相关疑难解决方法(0)

从Head First设计模式书中,具有双重检查锁定的单例模式已实现如下:

public class Singleton {
    private volatile static Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

我不明白为什么volatile被使用.volatile使用不会 破坏使用双重检查锁定的目的,即性能？

这是我的单例模式的自定义类.在这段代码中,我使用双重检查锁定如下.当我在某些源上阅读很多帖子时,他们说双重检查很有用,因为它可以防止两个并发线程同时运行产生两个不同的对象.

public class DoubleCheckLocking {

    public static class SearchBox {
        private static volatile SearchBox searchBox;

        // private constructor
        private SearchBox() {}

        // static method to get instance
        public static SearchBox getInstance() {
            if (searchBox == null) { // first time lock
                synchronized (SearchBox.class) {
                    if (searchBox == null) {  // second time lock
                        searchBox = new SearchBox();
                    }
                }
            }
            return searchBox;
        }
}

我仍然不太了解上面的代码.如果两个线程在实例为空时一起运行相同的代码行,会出现什么问题？

if (searchBox == null) {
                synchronized (SearchBox.class) {
                    if (searchBox == null) {
                        searchBox = …

private volatile static Singleton uniqueInstance

在单独使用双锁方法进行同步时,为什么单个实例声明为volatile？我可以在不将其声明为volatile的情况下实现相同的功能吗？

我的问题是在重构一个只包含要声明为static类的静态方法的类之后,并在启动应用程序时遇到奇怪的问题.

我没有进行任何彻底的调查,但似乎从静态构造函数中进行的某些调用由于某种原因没有完成.

那么,我想知道在C#中使用静态构造函数时有哪些陷阱？更具体地说,是否有任何事情应该不惜一切代价避免,而不是在静态构造函数中使用？

如果创建一个只读静态成员,如下所示:

public sealed class MyClass
{
    public readonly static MyClass Instance = new MyClass();
}

我们知道如果某个线程第一次访问MyClass,静态构造函数将初始化MyClass.Instance字段.但是,如果多个线程同时访问MyClass(即静态字段线程安全的初始化),是否会创建单个实例(在本例中为MyClass)？

ASP.NET MVC 4,EF5,Code First,SQL Server 2012 Express

在模型中强制使用唯一值的最佳做法是什么？我有一个具有'url'属性的place类,对于每个地方都应该是唯一的.

public class Place
{
      [ScaffoldColumn(false)]
      public virtual int PlaceID { get; set; }

      [DisplayName("Date Added")]
      public virtual DateTime DateAdded { get; set; }

      [Required(ErrorMessage = "Place Name is required")]
      [StringLength(100)]
      public virtual string Name { get; set; }

      public virtual string URL { get; set; }
};

为什么不能只放置一个[Unique]数据注释？

我已经看过1或2次讨论,但没有谈到最佳实践.使用Code First可以以某种方式告诉数据库在数据库中的字段上设置唯一约束吗？

什么是最简单的方法 - 什么是最佳实践？

我正在使用一个多线程的c#应用程序,它正在使用WCF Web服务.与webservice的连接将具有我们可以定义的特定超时,然后它将关闭.我希望使用singleton类存储与Web服务的连接.我试图得到如下实例:

CLazySingleton ins = CLazySingleton.Instance;
string connection = CLazySingleton.abc;

下面是单例类的代码:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace LazySingleton
{
    public class CLazySingleton
    {
        private static readonly Lazy<CLazySingleton> _instance
            = new Lazy<CLazySingleton>(() => new CLazySingleton());
        private static readonly object ThreadLock = new object();
        public static string abc;  
        //I will use the service connection object in place of 'abc' in the application
        //assume that 'abc' is storing the connection object    

        private CLazySingleton()
        { }

        public static CLazySingleton Instance
        { …

我认为静态对象是跨多个线程共享的.但是,我在我的一个网站上遇到了一个高CPU问题,所以我采取了一个windbg转储并且非常惊讶,我看到了:

我们可以看到有一个名为ConnectionMultiplexer的类的10个实例.但我的代码将ConnectionMultiplexer创建为静态对象.这应该意味着只为所有线程创建一个实例.那么windbg怎么会出现多个实例呢？

这是我创建redis连接的代码

public static class CacheConnection
    {
        private static StackExchangeRedisCacheClient _newconnectionDb;

        public static StackExchangeRedisCacheClient NewConnectionDb
            => _newconnectionDb ?? (_newconnectionDb = NewRedisConnection());

        private static IDatabase _connectionDb;

        public static IDatabase ConnectionDb => _connectionDb ?? (_connectionDb = RedisConnection());

        private static StackExchangeRedisCacheClient NewRedisConnection()
        {
            var serializer = new NewtonsoftSerializer();
            return new StackExchangeRedisCacheClient(Connection, serializer);
        }

        private static IDatabase RedisConnection()
        {
            var cacheDatabase = Connection.GetDatabase();
            return cacheDatabase;
        }

        public static ConnectionMultiplexer Connection => LazyConnection.Value;

        private static readonly Lazy<ConnectionMultiplexer> LazyConnection = new Lazy<ConnectionMultiplexer>(() => ConnectionMultiplexer.Connect(
            System.Configuration.ConfigurationManager.AppSettings["CacheConnectionString"]), …