Question

当我解决Singleton Vs Static类之间的差异时，我遇到了一个问题，我们可以在singleton类中继承一个接口，并且可以通过接口调用singleton进行多次实现。

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

谢谢，

Answer 1

虽然很难说出你究竟指的是什么，但你可能指的是一个模式Multiton pattern，你可以在其中管理一个命名实例的映射作为键值对。

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

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

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

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

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
    }
}

如何使用与singleton类的接口

3 个答案: