Instantiate(Resources .Load("FemaleModel"))as GameObject;

例項化預製體，載入resources檔案中的femalemodel檔案轉換為gameobject

該物品名字的快捷鍵F2+滑鼠左鍵

1函式運用引數打到公用效果。

2靜態類公用設定public static 型別 屬性名

public lei類名（）

｛屬性名=this｝

使用：類名.屬性名.方法

ui的方法：

轉載：

一、單例模式優點

1. 單例模式核心在於對於某個單例類，在系統中同時只存在唯一一個例項，並且該例項容易被外界所訪問；
2. 意味著在記憶體中，只存在一個例項，減少了記憶體開銷；

二、單例模式特點

1. 只存在唯一一個例項；
2. 提供統一對外訪問介面，使得全域性可對該單例的唯一例項進行訪問；
3. 自行例項化（私有建構函式，不允許外界對其進行例項化）。

三、單例模式使用

1. 資源管理器，資源物件資料的載入和解除安裝（無狀態不需要例項化的物件）；
2. 單一客戶端連線伺服器等；
3. 生命週期在遊戲中永不消毀的物件。

四、單例模式注意點

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

五、單例模式常見模式

1. 懶漢模式(最常用)

   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. 餓漢模式

   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. 雙重鎖模式（解決執行緒安全問題）

   3.1 保證多執行緒中只存在唯一例項

4. • 程式碼如下：

     

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

     

5. 泛型單例模式

    

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

6. • 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. 所有建立時間都一致，證明該類提供單例提供類中的泛型替代，達到了單例模式的效果，提供了該類的唯一例項訪問