Consigli sul modello di fabbrica con implementazione DI

Sto cercando modi per migliorare il seguente codice:

public interface IExample{ void Do(); }

public interface IExampleA: IExample {}

public class ExampleA: IExampleA 
{ 
    IDependencyA _dependencyA;
    IDependencyB _dependencyB;

    public ExampleA(IDependencyA dependencyA, IDependencyB dependencyB)
    {
        _dependencyA = dependencyA;
        _dependencyB = dependencyB;
    }

    public void Do(); 
}

public interface IExampleB: IExample {}

public class ExampleB: IExampleB 
{ 
    IDependencyA _dependencyA;
    IDependencyB _dependencyB;
    IDependencyC _dependencyC;

    public ExampleB(IDependencyA dependencyA, IDependencyB dependencyB, IDependencyC dependencyC)
    {
        _dependencyA = dependencyA;
        _dependencyB = dependencyB;
        _dependencyC = dependencyC;
    }
    public void Do(); 
}


public interface IExampleFactory{
    IExample Make(TypesOfExamples thisIsAnEnum);
}

public class ExampleFactory: IExampleFactory {
    IExampleA _exampleA;
    IExampleB _exampleB;

    public ExampleFactory(IExampleA exampleA, IExampleB exampleB)
    {
        _exampleA = exampleA;
        _exampleB = exampleB;
    }

    public IExample Make(TypesOfExamples thisIsAnEnum)
    {
        switch(thisIsAnEnum)
        {
            case A: return _exampleA;
            case B: return _exampleB;
        }
    }        
}

In sostanza ciò che non mi piace è dover utilizzare IExampleA e IExampleB, sono lì solo per essere iniettati:

container.Bind<IExampleA>().To.<ExampleA>();
container.Bind<IExampleB>().To.<ExampleB>();
container.Bind<IExampleFactory>().To.<ExampleFactory>();
container.Bind<IDependencyA>().To.<DependencyA>();
container.Bind<IDependencyB>().To.<DependencyB>();
container.Bind<IDependencyC>().To.<DependencyC>();

E sarebbe usato in questo modo

public class ExampleUsage()
{    
    ExampleFactory _exampleFactory;

    public ExampleUsage(ExampleFactory exampleFactory)
    {
        _exampleFactory = exampleFactory;
    }

    public void useFactory(Test obj)
    {
        var implementation = _exampleFactory.Make(obj.ThisIsAnEnum);
        implementation.Do();
    }
}

Stavo cercando di far sì che la fabbrica implementasse classi concrete invece di restituire le interfacce, il problema con questo è che ogni classe concreta ha le sue dipendenze, e sarebbe un casino cercare di aggiungerle alla fabbrica (sono un sacco) Qualsiasi suggerimento sarebbe apprezzato, grazie!