是否可以创建一个Singleton工厂类来维护实例的字典？

Question

I have multiple classes that inherit from IPrint. I want to instantiate these classes using a factory but I want to maintain a single instance of each type. Is this possible?

Please find my sample code below.

 public interface IPrint
    {
        void DoPrint();
    }
    public class DigitalPrint : IPrint
    {
        public void DoPrint()
        {
            // logic
        }
    }
    public class InkPrint : IPrint
    {
        public void DoPrint()
        {
            // logic
        }
    }
    public class PrintFactory
    {
        private static IDictionary<IPrint, object> prints = new 
   Dictionary<IPrint, object>();
        private PrintFactory()
        {

        }
        public static IPrint GetPrint(PrintType type)
        {
            // return instance depending on type. Instantiate only once 
             //like singleton
            // How to write so that it returns a single instance depending 
            //on type
            return null;
        }
    }

    public enum PrintType
    {
        DigitalPrint,
        InkPrint
    }

Can someone give me some idea if this is possible?

Thanks.

Answer 1

You can create IPrint instances when initializing Dictionary<PrintType, IPrint> :

private static IDictionary<PrintType, IPrint> prints = 
  new Dictionary<PrintType, IPrint> {
      { PrintType.DigitalPrint, new DigitalPrint() },
      { PrintType.InkPrint, new InkPrint() }
  };

Getting print (thus print is a class, the same instance will be returned for each request):

public static IPrint GetPrint(PrintType type)
{
    IPrint print;
    if (!prints.TryGetValue(type, out print))
       return null;

    return print;
}

---

If you don't want to create IPrint instances until the client asks for them, you can use Dictionary<PrintType, Lazy<IPrint>> :

private static IDictionary<string, Lazy<IPrint>> prints =
    new Dictionary<string, Lazy<IPrint>> {
        { PrintType.DigitalPrint, new Lazy<IPrint>(() => new DigitalPrint()) },
        { PrintType.InkPrint, new Lazy<IPrint>(() => new InkPrint()) }
    };

Getting print (in this case only one instance of each IPrint type will be created, but not before someone tries to get the instance of that type):

public static IPrint GetPrint(PrintType type)
{
    Lazy<IPrint> factory;
    if (!prints.TryGetValue(type, out factory))
       return null;

    return factory.Value;
}

Though I would consider using dependency injection framework instead of implementing such functionality manually.

Further reading: Ninject or Autofac

Answer 2

Yes, it's possible.

This creates the IPrint 's before they're needed. You could make them lazily created, instead.

public class Program
{
    public static void Main(string[] args)
    {
        var factory = new PrintFactory();
        Console.WriteLine(PrintFactory.GetPrint(PrintType.DigitalPrint));
        Console.WriteLine(PrintFactory.GetPrint(PrintType.InkPrint));
    }
}

public interface IPrint
{
    void DoPrint();
}

public class DigitalPrint : IPrint
{
    public void DoPrint()
    {
        // logic
    }
}

public class InkPrint : IPrint
{
    public void DoPrint()
    {
        // logic
    }
}

public class PrintFactory
{
    // Make the dictionary from PrintType to IPrint instead of IPrint to object
    private static IDictionary<PrintType, IPrint> prints = new Dictionary<PrintType, IPrint>();

    // Initialize prints in a static constructor.
    static PrintFactory()
    {
        prints.Add(PrintType.DigitalPrint, new DigitalPrint());
        prints.Add(PrintType.InkPrint, new InkPrint());
    }

    public static IPrint GetPrint(PrintType type)
    {
        if (!prints.ContainsKey(type)) 
        {
            // TODO: Maybe throw an exception or log?
        }
        return prints[type];
    }
}

public enum PrintType
{
    DigitalPrint,
    InkPrint
}

Answer 3

I would get rid of the enum and make a generic method:

public static IPrint GetPrint<T>() where T : IPrint, new ()
{
    foreach (var key in prints.Keys) {
        if (key is T)
            return null;
    }
           return new T();
}