如何在c#中创建一个完美的单例类？

我想用Singleton类存储一些数据。据我所知，singleton类只能实例化一次。但这对我不起作用。有人能纠正我的代码吗：

public class MvcApplication : System.Web.HttpApplication
    {
        Singleton clientsessionidinstance = Singleton.GetInstance();
        public static void RegisterGlobalFilters(GlobalFilterCollection filters)
        {
            filters.Add(new HandleErrorAttribute());
        }


        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
            routes.MapRoute(
                "Default", // Route name
                "{controller}/{action}/{id}", // URL with parameters
                new { controller = "Home", action = "Index", id = UrlParameter.Optional },
                new string[] { "MVCPrj.Controllers" }
            );
        }

        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();

            RegisterGlobalFilters(GlobalFilters.Filters);
            RegisterRoutes(RouteTable.Routes);

            LOGICcLASSES.Logic.Auth ca = new LOGICcLASSES.Logic.Auth();
            clientsessionidinstance = Singleton.GetInstance();
            clientsessionidinstance.ClientSessionID = ca.Login(new LOGICcLASSES.Entities.ClientAuthentication()
            {
                IP = HttpContext.Current.Request.ServerVariables["REMOTE_ADDR"],
                UserName = ConfigurationManager.AppSettings["ClientUserName"],
                Password = ConfigurationManager.AppSettings["ClientPassword"]
            });
        }

        protected void Application_AcquireRequestState(object sender, EventArgs e)
        {
            if (System.Web.HttpContext.Current.Session != null)
            {
                if (!string.IsNullOrEmpty(clientsessionidinstance.ClientSessionID))
                {
                    CurrentUserSession.Store<string>("ClientSessionID", clientsessionidinstance.ClientSessionID);
                }
            }
        }
    }  

编辑

阅读后，此代码对我有效

---

仅当成员实例为null时，才需要创建新实例。您似乎一直都在这样做。

如果您使用.NET4，“完美的单例”通常最好使用

---

另请参见C#中许多不同单例模式的描述及其各种优缺点。

实际上，如果新的CTOR为默认值（无参数），则可以将其放入变量定义中：

---

请参见

我一直使用这个通用基类作为我的单例：

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

公共类SingletonBase，其中T:class
{
静态单碱基（）
{
}
公共静态只读T实例=
typeof（T）.InvokeMember（typeof（T）.Name，
BindingFlags.CreateInstance|
BindingFlags.Instance|
BindingFlags.Public|
BindingFlags.NonPublic，
null，null，null）作为T；
}

这是我见过的最好的单身汉

它很简单，但线程安全，无需使用锁

---

您还可以将“实例””作为带有“\u Instance”字段的属性。

我使用这样的单例，我没有问题：

public sealed class Settings
{
    private static readonly Lazy<Settings> lazy =
    new Lazy<Settings>(() => new Settings());

    public static Settings Instance { get { return lazy.Value; } }

    private Settings()
    {
        _fileName = "Settings.ini";
    }
....
}

公共密封类设置
{
私有静态只读惰性=
新设置（（）=>新设置（））；
公共静态设置实例{get{return lazy.Value；}}
私人设置（）
{
_fileName=“Settings.ini”；
}
....
}

单身人士

using System;

public class Singleton
{
   private static Singleton instance;

   private Singleton() {}

   public static Singleton Instance
   {
      get 
      {
         if (instance == null)
         {
            instance = new Singleton();
         }
         return instance;
      }
   }
}

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

   private Singleton(){}

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

    using System;

public sealed class Singleton
{
   private static volatile Singleton instance;
   private static object syncRoot = new Object();

   private Singleton() {}

   public static Singleton Instance
   {
      get 
      {
         if (instance == null) 
         {
            lock (syncRoot) 
            {
               if (instance == null) 
                  instance = new Singleton();
            }
         }

         return instance;
      }
   }
}

静态初始化

using System;

public class Singleton
{
   private static Singleton instance;

   private Singleton() {}

   public static Singleton Instance
   {
      get 
      {
         if (instance == null)
         {
            instance = new Singleton();
         }
         return instance;
      }
   }
}

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

   private Singleton(){}

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

    using System;

public sealed class Singleton
{
   private static volatile Singleton instance;
   private static object syncRoot = new Object();

   private Singleton() {}

   public static Singleton Instance
   {
      get 
      {
         if (instance == null) 
         {
            lock (syncRoot) 
            {
               if (instance == null) 
                  instance = new Singleton();
            }
         }

         return instance;
      }
   }
}

多线程单例

using System;

public class Singleton
{
   private static Singleton instance;

   private Singleton() {}

   public static Singleton Instance
   {
      get 
      {
         if (instance == null)
         {
            instance = new Singleton();
         }
         return instance;
      }
   }
}

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

   private Singleton(){}

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

    using System;

public sealed class Singleton
{
   private static volatile Singleton instance;
   private static object syncRoot = new Object();

   private Singleton() {}

   public static Singleton Instance
   {
      get 
      {
         if (instance == null) 
         {
            lock (syncRoot) 
            {
               if (instance == null) 
                  instance = new Singleton();
            }
         }

         return instance;
      }
   }
}

---

来源：

不要重新发明轮子：完美单身是一种矛盾修饰法。创建一个工厂。不要创建试图理解其自身生存期的类。

lock（typeof（Singleton））{var mine=Singleton.GetInstance（）；}

@thesan无公共构造函数。不必是基类。只需向返回Singleton.Instance的MyClass添加一个公共静态属性，这应该会使初始化变得懒惰@erikH是的，这也可以，但MyClass的一部分：SingletonBase（MyClass）是它记录了期望值。