Unity中C#單例模式使用總結

本文轉載自查看原文 2016-01-14 14:35 13554 【內功修煉】設計模式

一、單例模式優點

單例模式核心在於對於某個單例類，在系統中同時只存在唯一一個實例，並且該實例容易被外界所訪問；
意味着在內存中，只存在一個實例，減少了內存開銷；

二、單例模式特點

只存在唯一一個實例；
提供統一對外訪問接口，使得全局可對該單例的唯一實例進行訪問；
自行實例化（私有構造函數，不允許外界對其進行實例化）。

三、單例模式使用

資源管理器，資源對象數據的加載和卸載（無狀態不需要實例化的對象）；
單一客戶端連接服務器等；
生命周期在游戲中永不消毀的對象。

四、單例模式注意點

注意線程安全問題，在多線程、高並發的情況下，可能同時產生多個實例,違背了單例模式。
Unity中如果過度使用單例模式，將會導致代碼耦合度非常高，腳本與腳本之間的耦合，代碼的后續拓展變得非常麻煩。一個過分依賴單例模式的開發者不能成為一個好的開發者，也不會去接觸到更多優秀的設計模式。個人推薦ECS 實體 - 組件式編程。
Unity中暫時不需要考慮多線程問題，Unity就只有一個主線程和開啟多個輔助協程，不會出現多線程並發問題。
控制游戲對象的生成和銷毀並不建議使用單例模式，可通過主游戲邏輯InGame進行事件下發，自行管理Update，使用工廠來進行對象的創建和銷毀。

五、單例模式常見模式

懶漢模式(最常用)

1.1 提供私有構造函數;

1.2 自行實例化;

1.3 提供唯一實例，並且對外提供全局靜態訪問接口對該實例進行訪問；

代碼如下：

/// <summary>
/// 普通模式
/// </summary>
public class Singleton
{
    private static Singleton _instance = null;

    private Singleton()
    {
    }

    public static Singleton GetInstance()
    {
        if (_instance == null)
        {
            _instance = new Singleton();
        }
        return _instance;
    }
}

餓漢模式

2.1 本類內部預先自行實例化出唯一實例；

2.2 對外提供唯一訪問接口（靜態方法），對預先實例化的唯一實例進行訪問；

2.3 私有構造函數；

代碼如下：

     /// <summary>
    /// 餓漢單例模式
    /// </summary>
    public class Singleton
    {
        // 自行預先實例化,內部定義自己唯一實例，只供內部使用 //
        private readonly static  Singleton Instance = new Singleton();

        private Singleton() 
        {
            // Do Something
        }

        // 提供外部訪問的靜態方法，來對內部唯一實例進行訪問 //
        public static Singleton GetInstance()
        {
            return Instance;
        }
    }

雙重鎖模式（解決線程安全問題）

3.1 保證多線程中只存在唯一實例

代碼如下：

/// <summary>
/// 雙重鎖單例模式
/// </summary>
public class Singleton
{
    private static Singleton _instance = null;
    private static readonly object _syslock = new object();  
    private Singleton()
    {
    }

    public static Singleton GetInstance()
    {
        // 最開始判斷不存在的時候，該類從來未被實例化過 //
        if (_instance == null)
        {
            // 鎖定狀態，繼續搜索是否存在該類的實例 //
            lock (_syslock)
            {
                // 如果不存在，在鎖定狀態下實例化出一個實例 //
                if (_instance == null)
                {
                    _instance = new Singleton();
                    return _instance;
                }
                else  // 鎖定狀態下，存在該類實例，直接返回 //
                {
                    return _instance;
                }
            }
        }
        // 該實例本身就已經存在了，直接返回 //
        return _instance;
    }
}

泛型單例模式

4.1 在一個案例中,我們可能需要使用到不止一個單例模式類,甚至更多。那么此時,使用泛型單例模式模板來實現單例模式,我們可以有兩種不同的方法來實現它:

4.2首先我們來看下泛型模板，我們對泛型類進行約束，T只能是一個Class，並且有一個公共無參構造函數，代碼如下：

using System;
using UnityEngine;

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

    private static T _instance;
    // 用於lock塊的對象
    private static readonly object _synclock = new object();

    public static T Instance
    {
        get
        {
            if (_instance == null)
            {
                lock (_synclock)
                {
                    if (_instance == null)
                    {
                        // 若T class具有私有構造函數,那么則無法使用SingletonProvider<T>來實例化new T();
                        _instance = new T();
                        //測試用，如果T類型創建了實例，則輸出它的類型名稱
                        Debug.Log("{0}：創建了單例對象" + typeof(T).Name);
                    }
                }
            }
            return _instance;
        }
        set { _instance = value; }
    }
}

4.2.1 然后我們定義了一個網絡連接類 NetIO,使用單例提供類中的泛型T替代為具體的網絡連接類進行使用：
4.2.2 使用具體類替代泛型，用泛型單例提供類對該具體類達到提供唯一實例的單例實現效果：

4.2.3 具體類中定義了字段NetIoCreateTime來存儲該類實例化的時間，進行下一步分析該類實例是否是唯一實例，具體類代碼如下：

public class NetIO 
{

    public static NetIO GetInstance()
    {
        return SingletonProvider<NetIO>.Instance;
    }

    public NetIO()
    {
        this.NetIoCreateTime = DateTime.Now;
    }

    public DateTime NetIoCreateTime
    {
        get { return _ct; }
        set { _ct = value; }
    }

    private DateTime _ct;
}

4.2.4 在Unity中Update參數中調用該類，對該類創建時間進行輸出

public void Update()
    {
        Debug.Log(NetIO.GetInstance().NetIoCreateTime);
    }

4.2.5 測試結果如下：
4.2.6 所有創建時間都一致，證明該類提供單例提供類中的泛型替代，達到了單例模式的效果，提供了該類的唯一實例訪問

4.3 在一個案例中,我們可能需要使用到不止一個單例模式類,甚至更多。那么此時,使用泛型單例模式模板來實現單例模式,我們可以有兩種不同的方法來實現它:

4.3.1 首先我們來看下泛型模板，我們對泛型類進行約束，T只能是一個Class，並且有一個公共無參構造函數，代碼如下：

using System;
using UnityEngine;

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

    private static T _instance;
    // 用於lock塊的對象
    private static readonly object _synclock = new object();

    public static T Instance
    {
        get
        {
            if (_instance == null)
            {
                lock (_synclock)
                {
                    if (_instance == null)
                    {
                        // 若T class具有私有構造函數,那么則無法使用SingletonProvider<T>來實例化new T();
                        _instance = new T();
                        //測試用，如果T類型創建了實例，則輸出它的類型名稱
                        Debug.Log("{0}：創建了單例對象" + typeof(T).Name);
                    }
                }
            }
            return _instance;
        }
        set { _instance = value; }
    }
}

4.3.2 然后我們定義了一個網絡連接類 NetIO,使用單例提供類中的泛型T替代為具體的網絡連接類進行使用：
1. 使用具體類替代泛型，用泛型單例提供類對該具體類達到提供唯一實例的單例實現效果：
2. 具體類中定義了字段NetIoCreateTime來存儲該類實例化的時間，進行下一步分析該類實例是否是唯一實例，具體類代碼如下：
```
public class NetIO 
{

    public static NetIO GetInstance()
    {
        return SingletonProvider<NetIO>.Instance;
    }

    public NetIO()
    {
        this.NetIoCreateTime = DateTime.Now;
    }

    public DateTime NetIoCreateTime
    {
        get { return _ct; }
        set { _ct = value; }
    }

    private DateTime _ct;
}
```
3. 在Unity中Update參數中調用該類，對該類創建時間進行輸出
```
public void Update()
    {
        Debug.Log(NetIO.GetInstance().NetIoCreateTime);
    }
```
4. 測試結果如下：
5. 所有創建時間都一致，證明該類提供單例提供類中的泛型替代，達到了單例模式的效果，提供了該類的唯一實例訪問

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 C#單例模式單例模式--C# C#設計模式(1)——單例模式 C#設計模式-單例模式 C# 設計模式-單例模式 c#設計模式之單例模式 C#開發模式——單例模式 C#設計模式--單例模式 C++中的單例模式 C# 單例模式的多種簡單實現