c# - C#での優れたスレッドセーフなシングルトンの汎用テンプレートパターンは何ですか?

Question

次の C# シングルトンパターンがありますが、それを改善する方法はありますか?

    public class Singleton<T> where T : class, new()
    {

        private static object _syncobj = new object();
        private static volatile T _instance = null;
        public static T Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (_syncobj)
                    {
                        if (_instance == null)
                        {
                            _instance = new T();
                        }
                    }
                }
                return _instance;
            }
        }

        public Singleton()
        { }

    }

好ましい使用例:

class Foo : Singleton<Foo> 
{
}

関連：

.NET の明らかなシングルトン実装?

score 18 · Accepted Answer

Jon Skeet in Implementing the Singleton Pattern in C#によると、投稿したコードは実際には悪いコードと見なされます。これは、ECMA CLI 標準に対してチェックすると壊れているように見えるためです。

また、注意してください。オブジェクトを新しいタイプの T でインスタンス化するたびに、別のインスタンスになります。元のシングルトンには反映されません。

score 10 · Accepted Answer

このコードはコンパイルされません。T に「クラス」制約が必要です。

また、このコードはターゲットクラスに public コンストラクターを必要としますが、これはシングルトンには適していません。これは、Instance プロパティ (またはフィールド) を介してのみ (単一の) インスタンスを取得することをコンパイル時に制御できないためです。Instance 以外に他の静的メンバーがない場合は、これだけで問題ありません。

class Foo
{
  public static readonly Instance = new Foo();
  private Foo() {}
  static Foo() {}
}

これはスレッドセーフ (CLR によって保証されます) であり、レイジーです (型への最初のアクセスでインスタンスが作成されます)。BeforeFieldInit の詳細と、ここで静的コンストラクターが必要な理由については、https: //csharpindepth.com/articles/BeforeFieldInit を参照してください。

型に他の public static メンバーを持ちたいが、インスタンスへのアクセス時にのみオブジェクトを作成する場合は、https://csharpindepth.com/articles/Singletonのように、ネストされた型を作成できます。

score 9 · Accepted Answer

ジュディス・ビショップの厚意によるhttp://patterns.cs.up.ac.za/

このシングルトンパターンの実装により、遅延初期化が保証されます。

//  Singleton PatternJudith Bishop Nov 2007
//  Generic version

public class Singleton<T> where T : class, new()
{
    Singleton() { }

    class SingletonCreator
    {
        static SingletonCreator() { }
        // Private object instantiated with private constructor
        internal static readonly T instance = new T();
    }

    public static T UniqueInstance
    {
        get { return SingletonCreator.instance; }
    }
}

score 6 · Accepted Answer

これが.NET 4を使用する私のポイントです

public class Singleton<T> where T : class, new()
    {
        Singleton (){}

        private static readonly Lazy<T> instance = new Lazy<T>(()=> new T());

        public static T Instance { get { return instance.Value; } } 
    }

score 3 · Accepted Answer

2行のコードを節約できるように、「基本クラスを焼き付け」たいとは思いません。シングルトンを実装するために基本クラスは必要ありません。

シングルトンが必要なときはいつでも、これを行うだけです：

class MyConcreteClass
{
  #region Singleton Implementation

    public static readonly Instance = new MyConcreteClass();

    private MyConcreteClass(){}

  #endregion

    /// ...
}

score 3 · Accepted Answer

この回答の詳細については、別のスレッド : How to implement a singleton in C#?

ただし、スレッドはジェネリックを使用しません。

score 2 · Accepted Answer

:/ Judith Bishop による一般的な「シングルトン」パターンには、少し欠陥があるように見えます。この「パターン」で使用するには、コンストラクターが公開されている必要があるため、型 T の複数のインスタンスを作成することは常に可能です。私の意見では、シングルトンとはまったく関係がありません。常に同じオブジェクトを返す一種のファクトリですが、シングルトンにはなりません...クラスのインスタンスが複数存在できる限り、シングルトンにすることはできません。このパターンが最高評価の理由は何ですか?

public sealed class Singleton
{
  private static readonly Singleton _instance = new Singleton();

  private Singleton()
  {
  }

  public static Singleton Instance
  {
    get
    {
      return _instance;
    }
  }
}

静的初期化子はスレッドセーフと見なされます..わかりませんが、コードを3行以内でラップする場合、シングルトンのイディオムをまったく使用しないでください...シングルトンから継承しても作成されませんどんな意味でも。

score 2 · Accepted Answer

public sealed class Singleton
{
   private static readonly Singleton instance = new Singleton();

   private Singleton(){}

   public static Singleton Instance
   {
      get 
      {
         return instance; 
      }
   }
}

.NET では、初期化順序に関してあいまいさはありません。しかし、これはスレッド化の問題を引き起こします。

score 1 · Accepted Answer

私はより良いシングルトンパターンを探していて、これが好きでした。したがって、VB.NETに移植すると、他の人にも役立ちます。

Public MustInherit Class Singleton(Of T As {Class, New})
    Public Sub New()
    End Sub

    Private Class SingletonCreator
        Shared Sub New()
        End Sub
        Friend Shared ReadOnly Instance As New T
    End Class

    Public Shared ReadOnly Property Instance() As T
        Get
            Return SingletonCreator.Instance
        End Get
    End Property
End Class

score 1 · Accepted Answer

要求に応じて、元の回答から別の質問へのクロス投稿。

私のバージョンはリフレクションを使用し、派生クラスの非公開コンストラクターで動作し、(明らかに) 遅延インスタンス化によるスレッドセーフです (以下にリンクされている記事によると):

public class SingletonBase<T> where T : class
{
    static SingletonBase()
    {
    }

    public static readonly T Instance = 
        typeof(T).InvokeMember(typeof(T).Name, 
                                BindingFlags.CreateInstance | 
                                BindingFlags.Instance |
                                BindingFlags.Public |
                                BindingFlags.NonPublic, 
                                null, null, null) as T;
}

私はこれを数年前に拾いました。どれだけ私のものかはわかりませんが、コードをグーグルで検索すると、私ではない場合、テクニックの元のソースが見つかる可能性があります。

これは、私が投稿したのではなく、私が見つけることができるコードの最も古いソースです。

score 1 · Accepted Answer

ここでMicrosoft が提供する Double-Check Locking [Lea99] イディオムは、提供されたコードと驚くほど似ています。

マルチスレッドプログラムでは、異なるスレッドがクラスを同時にインスタンス化しようとする可能性があります。このため、if ステートメントに依存してインスタンスが null かどうかをチェックする Singleton 実装は、スレッドセーフではありません。そのようなコードを書かないでください！

スレッドセーフなシングルトンを作成する簡単で効果的な方法は、ネストされたクラスを使用してインスタンス化することです。以下は、遅延インスタンス化シングルトンの例です。

public sealed class Singleton
{ 
   private Singleton() { }

   public static Singleton Instance
   {
      get
      {
         return SingletonCreator.instance;
      }
   }

   private class SingletonCreator
   {
      static SingletonCreator() { }
      internal static readonly Singleton instance = new Singleton();
   }
}

使用法：

Singleton s1 = Singleton.Instance;
Singleton s2 = Singleton.Instance;
if (s1.Equals(s2))
{
    Console.WriteLine("Thread-Safe Singleton objects are the same");
}

一般的な解決策:

public class Singleton<T>
    where T : class, new()
{
    private Singleton() { }

    public static T Instance 
    { 
        get 
        { 
            return SingletonCreator.instance; 
        } 
    } 

    private class SingletonCreator 
    {
        static SingletonCreator() { }

        internal static readonly T instance = new T();
    }
}

使用法：

class TestClass { }

Singleton s1 = Singleton<TestClass>.Instance;
Singleton s2 = Singleton<TestClass>.Instance;
if (s1.Equals(s2))
{
    Console.WriteLine("Thread-Safe Generic Singleton objects are the same");
}

最後に、多少関連する有用な提案があります。lock キーワードの使用によって引き起こされる可能性があるデッドロックを回避するために、次の属性を追加して public static メソッドのみのコードを保護することを検討してください。

using System.Runtime.CompilerServices;
[MethodImpl (MethodImplOptions.Synchronized)]
public static void MySynchronizedMethod()
{
}

参考文献:

C# クックブック (O'Reilly)、Jay Hilyard、Stephen Teilhet
C# 3.0 デザインパターン (O'Reilly)、Judith Bishop
CSharp-Online.Net - シングルトン設計パターン: スレッドセーフなシングルトン

score 1 · Accepted Answer

シングルトンデザインパターンをスレッドセーフで怠惰な方法 (thx から wcell) で実装するこの汎用シングルトンクラスを試してください。

public abstract class Singleton<T> where T : class
{
    /// <summary>
    /// Returns the singleton instance.
    /// </summary>
    public static T Instance
    {
        get
        {
            return SingletonAllocator.instance;
        }
    }

    internal static class SingletonAllocator
    {
        internal static T instance;

        static SingletonAllocator()
        {
            CreateInstance(typeof(T));
        }

        public static T CreateInstance(Type type)
        {
            ConstructorInfo[] ctorsPublic = type.GetConstructors(
                BindingFlags.Instance | BindingFlags.Public);

            if (ctorsPublic.Length > 0)
                throw new Exception(
                    type.FullName + " has one or more public constructors so the property cannot be enforced.");

            ConstructorInfo ctorNonPublic = type.GetConstructor(
                BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[0], new ParameterModifier[0]);

            if (ctorNonPublic == null)
            {
                throw new Exception(
                    type.FullName + " doesn't have a private/protected constructor so the property cannot be enforced.");
            }

            try
            {
                return instance = (T)ctorNonPublic.Invoke(new object[0]);
            }
            catch (Exception e)
            {
                throw new Exception(
                    "The Singleton couldnt be constructed, check if " + type.FullName + " has a default constructor", e);
            }
        }
    }
}

score 0 · Accepted Answer

ウィキペディアのように：

シングルトンパターンは、クラスのインスタンス化を 1 つのオブジェクトに制限する設計パターンです。

ジェネリックを使用してそれを行う保証された方法はないと信じています。シングルトン自体のインスタンス化を制限している場合、メインクラスのインスタンス化を制限する方法は不可能だと思います。この単純なパターンを実装するそれほど難しいことではありません。静的コンストラクターとプライベートセットを使用して、次のようにします。

public class MyClass
{
        private MyClass()
        {

        }

        static MyClass()
        {
            Instance = new MyClass();
        }

        public static MyClass Instance { get; private set; }
}

また：

public class MyClass
    {
            private MyClass()
            {

            }

            static MyClass()
            {
                Instance = new MyClass();
            }

            private static MyClass instance;



            public static MyClass Instance
            {
                get
                {
                    return instance;
                }
                private set
                {
                    instance = value;
                }
            }
    }

score 0 · Accepted Answer

少し前に、リフレクションを使用してプライベート (またはパブリック) の既定のコンストラクターにアクセスするものを見ました。

public static class Singleton<T>
{
    private static object lockVar = new object();
    private static bool made;
    private static T _singleton = default(T);

    /// <summary>
    /// Get The Singleton
    /// </summary>
    public static T Get
    {
        get
        {
            if (!made)
            {
                lock (lockVar)
                {
                    if (!made)
                    {
                        ConstructorInfo cInfo = typeof(T).GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[0], null);
                        if (cInfo != null)
                            _singleton = (T)cInfo.Invoke(new object[0]);
                        else
                            throw new ArgumentException("Type Does Not Have A Default Constructor.");
                        made = true;
                    }
                }
            }

            return _singleton;
        }
    }
}

score 0 · Accepted Answer

public static class LazyGlobal<T> where T : new()
{
    public static T Instance
    {
        get { return TType.Instance; }
    }

    private static class TType
    {
        public static readonly T Instance = new T();
    }
}

// user code:
{
    LazyGlobal<Foo>.Instance.Bar();
}

または：

public delegate T Func<T>();

public static class CustomGlobalActivator<T>
{
    public static Func<T> CreateInstance { get; set; }
}

public static class LazyGlobal<T>
{
    public static T Instance
    {
        get { return TType.Instance; }
    }

    private static class TType
    {
        public static readonly T Instance = CustomGlobalActivator<T>.CreateInstance();
    }
}

{
    // setup code:
    // CustomGlobalActivator<Foo>.CreateInstance = () => new Foo(instanceOf_SL_or_IoC.DoSomeMagicReturning<FooDependencies>());
    CustomGlobalActivator<Foo>.CreateInstance = () => instanceOf_SL_or_IoC.PleaseResolve<Foo>();
    // ...
    // user code:
    LazyGlobal<Foo>.Instance.Bar();
}

score 0 · Accepted Answer

インスタンスデータのオンデマンド作成を保証するための私の貢献:


/// <summary>Abstract base class for thread-safe singleton objects</summary>
/// <typeparam name="T">Instance type</typeparam>
public abstract class SingletonOnDemand<T> {
    private static object __SYNC = new object();
    private static volatile bool _IsInstanceCreated = false;
    private static T _Instance = default(T);


    /// <summary>Instance data</summary>
    public static T Instance {
        get {
            if (!_IsInstanceCreated)
                lock (__SYNC)
                    if (!_IsInstanceCreated)
                        _Instance = Activator.CreateInstance<T>();
            return _Instance;
        }
    }
}

score 0 · Accepted Answer

pff... 再び... :)
インスタンスデータのオンデマンド作成を保証するための私の貢献:


/// <summary>Abstract base class for thread-safe singleton objects</summary>
/// <typeparam name="T">Instance type</typeparam>
public abstract class SingletonOnDemand<T> {
  private static object __SYNC = new object();
  private static volatile bool _IsInstanceCreated = false;
  private static T _Instance = default(T);

  /// <summary>Instance data</summary>
  public static T Instance {
    get {
      if (!_IsInstanceCreated)
        lock (__SYNC)
          if (!_IsInstanceCreated) {
            _Instance = Activator.CreateInstance<T>();
            _IsInstanceCreated = true;
          }
          return _Instance;
    }
  }
}

score 0 · Accepted Answer

私はあなたの元の答えがとても気に入りました - (blowdart によって投稿されたリンクによると) 唯一欠けているのは、_instance 変数を volatile にして、実際にロックに設定されていることを確認することです。シングルトンを使用する必要がある場合は実際にblowdartsソリューションを使用しますが、後でインスタンス化する必要はありません.

score 0 · Accepted Answer

これをグループに提出します。スレッドセーフで汎用的で、パターンに従っているようです。そこから継承できます。これは他の人が言ったことからまとめられています。

public class Singleton<T> where T : class
{
    class SingletonCreator
    {
        static SingletonCreator() { }

        internal static readonly T Instance =
            typeof(T).InvokeMember(typeof(T).Name,
                                    BindingFlags.CreateInstance |
                                    BindingFlags.Instance |
                                    BindingFlags.Public |
                                    BindingFlags.NonPublic,
                                    null, null, null) as T;
    }

    public static T Instance
    {
        get { return SingletonCreator.Instance; }
    }
}

意図した実装:

public class Foo: Singleton<Foo>
{
     private Foo() { }
}

それで：

Foo.Instance.SomeMethod();

score -8 · Accepted Answer

C# には既に優れたシングルトンパターンが組み込まれています。

static class Foo

それよりも興味深いものが必要な場合は、新しいシングルトンが十分に異なるため、一般的なパターンが役に立たなくなる可能性があります。

編集：「もっと興味深いもの」には、継承が含まれています。シングルトンから継承できる場合、それはもはやシングルトンではありません。

c# - C#での優れたスレッドセーフなシングルトンの汎用テンプレート パターンは何ですか?

22 に答える 22

Related

Reference

c# - C#での優れたスレッドセーフなシングルトンの汎用テンプレートパターンは何ですか?