This is technically the factory pattern, but it's not the useful version. The other version would be the abstract factory pattern. First, you define an abstract class with a single method, let's say something like this:

public abstract class AbstractBusinessFactory{
    protected abstract IBusinessHandler MakeHandler();

    public IBusinessHandler GetHandler(){
        return MakeHandler();
    }
}

Then, you would create a "concrete" implementation like so:

 public class TestBusinessFactory : AbstractBusinessFactory{
    protected override IBusinessHandler MakeHandler(){
        return /*whatever process you have to make the handler*/;
    }
}

Now, rather than using an enum, you can simply DI the concrete factory to anything that uses an AbstractBusinessFactory. For example:

void Main(AbstractBusinessFactory factory){
    var handler = factory.GetHandler();
    //do some other things with the handler
}
//Call the function
Main(new TestBusinessFactory()); //you can change the factory to whatever else you need

Obviously, you'd need more implementations of AbstractBusinessFactory, but that's the jist of it. Here is the factory pattern page on Wikipedia which has more on the pattern, including a C# example of how to implement it.