C# 如何拥有一个单例类并在整个应用程序c中使用它#

我有一个反序列化JSON文件的类。 JSON是styleconfig.JSON

    {  
        "Style1": {  
            "Font":       "Arial",   
            "width":      "25px",   
            "className":    "Grid-side"
        }  ,
"Style2": {  
            "Font":       "Arial",   
            "width":      "25px",   
            "className":    "Grid-side"
        }  
    }  

我有一个a班：

 var jss = new JavaScriptSerializer();
string json = new StreamReader(context.Request.InputStream).ReadToEnd();
Dictionary<string, string> sData = jss.Deserialize<Dictionary<string, string>>(json);

var jss=new JavaScriptSerializer（）；
字符串json=newstreamreader（context.Request.InputStream.ReadToEnd（）；
字典sData=jss.Deserialize（json）；

所以我需要在我的应用程序中每次调用这个classA 例如 有两个页面…Page1和page2这两个样式变量都在json上 所以每次我需要调用classA进行反序列化

第1页调用classA进行反序列化

第2页调用classA进行反序列化

所以这可能会影响性能

因此，我的要求是在登录到应用程序并进行 整个应用程序中的反序列化JSON对象。 我需要一些帮助，你应该用它。下面是一个例子：

static class ClassA 
{
    private static Lazy<Dictionary<string, string>> _json = new Lazy<Dictionary<string, string>>(ReadJson);

    private static Dictionary<string, string> ReadJson()
    {
        var jss = new JavaScriptSerializer();
        var json = new StreamReader(context.Request.InputStream).ReadToEnd();
        return jss.Deserialize<Dictionary<string, string>>(json);
    }

    public Dictionary<string, string> Json => _json.Value;

}

静态类ClassA
{
private static Lazy _json=new Lazy（ReadJson）；
私有静态字典ReadJson（）
{
var jss=新的JavaScriptSerializer（）；
var json=newstreamreader（context.Request.InputStream.ReadToEnd（）；
返回jss.Deserialize（json）；
}
公共字典Json=>_Json.Value；
}

---

现在，当您第一次阅读

ClassA.Json

时，文件将被解析和读取。后续调用将只返回缓存的值。

您可以使用静态类执行此操作，并使用Lazy命令确保只加载一次：

public static class A
{
    private static Lazy<Dictionary<string, string>> _data = new Lazy<Dictionary<string, string>>(() => GetData());

    public static Dictionary<string, string> Data => _data.Value;

    private static Dictionary<string, string> GetData()
    {
        var jss = new JavaScriptSerializer();
        string json = new StreamReader(context.Request.InputStream).ReadToEnd();
        return jss.Deserialize<Dictionary<string, string>>(json);
    }
}

公共静态A类
{
私有静态惰性数据=新惰性（（）=>GetData（））；
公共静态字典数据=>\u Data.Value；
私有静态字典GetData（）
{
var jss=新的JavaScriptSerializer（）；
字符串json=newstreamreader（context.Request.InputStream.ReadToEnd（）；
返回jss.Deserialize（json）；
}
}

如果我正确理解了您的问题，除了其他注释中已经解释的惰性字段外，您是否尝试过简单属性

公共类ClassA
{
//只是一个单件模型
静态ClassA _SingleInstance=null；
公共静态类A单实例
{
得到
{
if（_SingleInstance==null）
_SingleInstance=newClassA（）；
返回单实例；
}
}
字典_Data=null；
公共词典数据
{
得到
{
如果（_Data==null）
LoadData（）；
返回数据；
}
}
私有ClassA（）
{
//你的构造器
}
//正如torvin所指出的，为了避免多线程竞争，必须加载
//同步
私有void LoadData（）
{
锁（加载互斥）
{
如果（_Data==null）
{
var jss=新的JavaScriptSerializer（）；
字符串json=newstreamreader（context.Request.InputStream.ReadToEnd（）；
_Data=jss.Deserialize（json）；
}
}
}
私有静态只读对象LoadMutex=新对象（）；
}

然后从第1页和第2页，你称之为：

Dictionary myConfigData=ClassA.SingleInstance.Data；

使用“simple property”与使用

Lazy

相比的缺点是它不是线程安全的，它可以调用

LoadData

两次，这可能是不受欢迎的。你完全正确，它应该使用一些互斥同步。我编辑了我的答案否，你应该使用专门为这个用例设计的

Lazy

。在这个例子中，我有一个ReadJson（）方法，带有参数，例如ReadJson（int a）。所以我无法使用上面的内容。谢谢你的回复，真的很有帮助@托文