c# - 如何在单例类中使用接口

Question

在分析 Singleton 与 Static 类之间的差异时，我遇到了一点，我们可以在单例类中继承一个接口，并且可以通过接口调用单例进行多种实现。

我想要一些带有很好示例的代码演示，如何通过单例而不是静态来实现面向对象。

谢谢，

Answer 1

虽然很难说出您到底指的是什么，但您可能指的是Multiton 模式，您可以在其中将命名实例的映射作为键值对进行管理。

这基本上是一个工厂，但每个实例只创建一次：

我对Wikipedia 示例进行了一些修改，以表明您甚至可以从单例类派生，只要您的具体实现是私有的并且在原始类中：

class FooMultiton
{
    private static readonly Dictionary<object, FooMultiton> _instances =
        new Dictionary<object, FooMultiton>();

    // this is the classic good old singleton trick (prevent direct instantiation)
    private FooMultiton()
    { }

    // you can also have private concrete implementations, 
    // invisible to the outside world
    private class ConcreteFooMultitonOne : FooMultiton
    { }

    public static FooMultiton GetInstance(object key)
    {
        lock (_instances) 
        {   
            FooMultiton instance;

            // if it doesn't exist, create it and store it
            if (!_instances.TryGetValue(key, out instance))
            {
                // at this point, you can create a derived class instance
                instance = new ConcreteFooMultitonOne();
                _instances.Add(key, instance);
            }

            // always return the same ("singleton") instance for this key
            return instance;
        }
    }
}

此外，一般来说，如果单例不是静态类，它可以实现您想要的任何接口。单例模式唯一阻止的是单例类的多个实例的实例化，但这并不意味着您不能用其他东西完全替换实现。

例如，如果您有一个不是静态类的单例：

interface ICanTalk
{
    string Talk();
}

class Singleton : ICanTalk
{
    private Singleton() { }

    private static readonly Singleton _instance = new Singleton();
    public static Singleton Instance
    { get { return _instance; } }

    public string Talk()
    { return "this is a singleton"; }
}

您还可以有许多不同的实现：

class OtherInstance : ICanTalk
{
    public string Talk()
    { return "this is something else"; }
}

然后你可以自由选择你想要的任何实现，但只得到一个Singleton类的实例：

ICanTalk item;

item = Singleton.Instance;
item = new OtherInstance();
item = new YetAnotherInstance();

Answer 2

根据nkr1pr

每个类都可以实现一个接口，而 Singleton 只是一个“普通”类，它确保除了它可能实现的其他业务逻辑之外，在任何时间点都只存在一个实例。这也意味着 Singleton 至少有 2 个职责，这不是好的 OO 设计，因为类应该只有 1 个职责并确保它们擅长该职责，但这是另一个讨论。

就像是：

public interface MyInterface 
{
}

和

public class MySingleton:MyInterface
{
  private static MyInterface instance = new MySingleton();

  private MySingleton() 
  {
  } 

  public static MyInterface getInstance()
  {
    return instance;
  }
}

Answer 3

我不确定你在问什么，但是单例类可以实现接口。单例类并不意味着静态类，创建单例实例的方法之一就是利用静态成员。

public class MyInterfaceImplementation : IMyInterface
{

    private static MyInterfaceImplementation instance;
    private static readonly object lockObj = new object();

    private MyInterfaceImplementation() { }  //private .ctor

    public static MyInterfaceImplementation Instance
    {
        get
        {
            if (instance == null)
            {
                lock (lockObj)
                {
                    instance = new MyInterfaceImplementation();
                }
            }
            return instance;
        }
    }

    public void MyInterfaceMethod()
    {
        //Implement here
    }
}