làm thế nào để sử dụng giao diện với lớp singleton

Question

Khi tôi đi qua sự khác biệt giữa Singleton Vs lớp tĩnh, tôi đi qua một điểm mà chúng ta có thể kế thừa một giao diện trong lớp singleton và có thể gọi singleton thông qua giao diện để thực hiện nhiều.

Tôi muốn một số minh họa mã với ví dụ tốt, cách định hướng đối tượng có thể đạt được thông qua singleton và không thông qua tĩnh.

Cảm ơn,

Answer 1

Mặc dù thật khó để nói chính xác những gì bạn đang đề cập đến, một mẫu bạn có thể được đề cập đến là Multiton pattern, nơi bạn quản lý bản đồ các trường hợp được đặt tên dưới dạng cặp khóa-giá trị.

Đó là cơ bản là một nhà máy, nhưng mỗi trường hợp chỉ được tạo ra khi:

Tôi đã sửa đổi các Wikipedia example một chút để thấy rằng bạn thậm chí có thể xuất phát từ một lớp singleton, miễn là triển khai cụ thể của bạn là tư nhân và trong lớp gốc:

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

Ngoài ra, nói chung, nếu singleton không phải là lớp tĩnh, nó có thể triển khai bất kỳ giao diện nào bạn muốn. Điều duy nhất mà một mô hình đơn lẻ ngăn cản là sự khởi tạo của nhiều trường hợp của một lớp singleton, nhưng điều đó không có nghĩa là bạn không thể thay thế hoàn toàn việc triển khai thực hiện bằng một thứ khác.

Ví dụ, nếu bạn có một singleton mà không phải là một lớp tĩnh:

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

Bạn cũng có thể có một số triển khai khác nhau:

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

Sau đó, bạn có thể tự do lựa chọn bất kỳ triển khai bạn muốn, nhưng chỉ nhận được một phiên bản duy nhất của lớp học Singleton:

ICanTalk item; 

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

Answer 2

Theo nkr1pr

Mỗi lớp có thể thực hiện một giao diện, và một Singleton chỉ là một lớp "bình thường" mà làm cho chắc chắn rằng chỉ có một thể hiện của nó tồn tại ở bất kỳ điểm nào trong thời gian ngoài từ logic kinh doanh khác mà nó có thể thực hiện. Điều này cũng có nghĩa là Singleton có ít nhất 2 trách nhiệm và đây không phải là thiết kế OO tốt vì các lớp học chỉ nên có 1 trách nhiệm và đảm bảo chúng có trách nhiệm tốt, nhưng đó là một cuộc thảo luận khác.

Cái gì như:

public interface MyInterface 
{ 
} 

Và

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

    private MySingleton() 
    { 
    } 

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

Answer 3

Tôi không chắc chắn những gì bạn đang yêu cầu, nhưng các lớp singleton có thể thực hiện các giao diện. lớp singleton không có nghĩa là lớp tĩnh, một trong những phương pháp để tạo ra một cá thể singleton là để sử dụng các thành viên tĩnh.

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