Passing dependency into Factory

Question

We are using factory to create an instance of Subscribers. Each subscriber can have its own dependency.

Each subscriber will use constructor injection.

Should I pass dependency into subscribers through Subscriber Factory? Every time adding new dependency in any subscriber will change Subscriber factory?

public interface IMessageSubscriber
{
    bool Process(string message)
}

public class MessageSubscriber1 : IMessageSubscriber
{
    public bool Process(string message)
    {
        //Some custom logic 
    }
}

public class MessageSubscriber2 : IMessageSubscriber
{
    public bool Process(string message)
    {
        //Some custom logic 
    }
}

public class MessageSubscriberFactory
{

    //SubscriberType is enum
    public IMessageSubscriber Get(SubscriberType type)
    {
            if(type == 1)
            {
                return new MessageSubscriber1();
            }
            else if(type == 2)
            {
                return new MessageSubscriber2();            
            }
    }
}

//Main class
public class Process
{
    public static void Main(string[] args)
    {
        MessageSubscriberFactory fac = new MessageSubscriberFactory();
        foreach SubscriberType
        {
            string  = "Message";
            IMessageSubscriber subscriber = fac.Get(type);
            subscriber.Process(message)
        }
    }
}

Answer 1

One approach would be to use named registrations with a DI/IOC container. This would involve using the container in a service locator fashion (which some people oppose), but I think it could make sense in this case. The example below is pretty crude, but it does give you an approach to handle subscribers with different dependencies without passing them into the factory. I used Unity here and you'd want to wrap the container reference rather than referencing directly, but this gets the point across.

public interface ILowerCaseWriter
{
    void Write(string message);
}
public class LowerCaseWriter : ILowerCaseWriter
{
    public void Write(string message)
    {
        Console.WriteLine(message.ToLower());
    }
}

public interface IUpperCaseWriter
{
    void Write(string message, int number);
}
public class UpperCaseWriter : IUpperCaseWriter
{
    public void Write(string message, int number)
    {
        Console.WriteLine("{0}:{1}", number, message.ToUpper());
    }
}

public interface ISubscriber
{
    void Write();
}
public class Subscriber1 : ISubscriber
{
    private ILowerCaseWriter _writer;
    public Subscriber1(ILowerCaseWriter writer)
    {
        _writer = writer;
    }
    public void Write()
    {
        _writer.Write("Using subscriber 1");
    }
}
public class Subscriber2 : ISubscriber
{
    private IUpperCaseWriter _writer;
    public Subscriber2(IUpperCaseWriter writer)
    {
        _writer = writer;
    }
    public void Write()
    {
        _writer.Write("Using subscriber 2", 2);
    }
}

public class SubscriberFactory
{
    private UnityContainer _container;
    public SubscriberFactory()
    {
        _container = new UnityContainer();
        _container.RegisterType<ILowerCaseWriter, LowerCaseWriter>();
        _container.RegisterType<IUpperCaseWriter, UpperCaseWriter>();
        _container.RegisterType<ISubscriber, Subscriber1>("Subscriber1");
        _container.RegisterType<ISubscriber, Subscriber2>("Subscriber2");
    }

    public ISubscriber GetSubscriber(int type)
    {
        switch (type)
        {
            case 1:
                return _container.Resolve<ISubscriber>("Subscriber1");
            case 2:
                return _container.Resolve<ISubscriber>("Subscriber2");
            default:
                throw new Exception();
        }
    }
}

class Program
{
    private static void Main(string[] args)
    {
        var factory = new SubscriberFactory();
        var subscriber = factory.GetSubscriber(1);
        subscriber.Write();
        Console.ReadLine();
    }
}