Di Unity, bagaimana cara menerapkan pola singleton dengan benar?

Saya telah melihat beberapa video dan tutorial untuk membuat objek singleton di Unity, terutama untuk a GameManager, yang tampaknya menggunakan pendekatan berbeda untuk membuat instance dan memvalidasi singleton.

Apakah ada pendekatan yang benar, atau lebih tepatnya, lebih disukai untuk ini?

Dua contoh utama yang saya temui adalah:

Pertama

public class GameManager
{
    private static GameManager _instance;

    public static GameManager Instance
    {
        get
        {
            if(_instance == null)
            {
                _instance = GameObject.FindObjectOfType<GameManager>();
            }

            return _instance;
        }
    }

    void Awake()
    {
        DontDestroyOnLoad(gameObject);
    }
}

Kedua

public class GameManager
{
    private static GameManager _instance;

    public static GameManager Instance
    {
        get
        {
            if(_instance == null)
            {
                instance = new GameObject("Game Manager");
                instance.AddComponent<GameManager>();
            }

            return _instance;
        }
    }

    void Awake()
    {
        _instance = this;
    }
}

Perbedaan utama yang bisa saya lihat antara keduanya adalah:

Pendekatan pertama akan mencoba untuk menavigasi tumpukan objek game untuk menemukan contoh GameManageryang walaupun ini hanya terjadi (atau seharusnya hanya terjadi) sekali tampaknya bisa sangat tidak dioptimalkan sebagai adegan tumbuh dalam ukuran selama pengembangan.

Juga, pendekatan pertama menandai objek yang tidak akan dihapus ketika aplikasi mengubah adegan, yang memastikan bahwa objek tetap ada di antara adegan. Pendekatan kedua tampaknya tidak mematuhi ini.

Pendekatan kedua tampak aneh karena dalam kasus di mana instance adalah null dalam pengambil, itu akan membuat GameObject baru dan menetapkan komponen GameManger untuk itu. Namun, ini tidak dapat berjalan tanpa terlebih dahulu komponen GameManager ini telah dilampirkan ke sebuah objek dalam adegan, jadi ini menyebabkan saya kebingungan.

Apakah ada pendekatan lain yang akan direkomendasikan, atau gabungan dari keduanya di atas? Ada banyak video dan tutorial mengenai lajang, tetapi semuanya sangat berbeda sehingga sulit untuk menarik perbandingan antara keduanya dan dengan demikian, kesimpulan yang mana yang merupakan pendekatan terbaik / disukai.

Tergantung, tetapi biasanya saya menggunakan metode ketiga. Masalah dengan metode yang Anda gunakan adalah bahwa jika objek dimasukkan untuk memulai, itu tidak akan menghapusnya dari pohon, dan mereka masih dapat dibuat dengan membuat terlalu banyak panggilan, yang dapat membuat hal-hal benar-benar membingungkan.

public class SomeClass : MonoBehaviour {
    private static SomeClass _instance;

    public static SomeClass Instance { get { return _instance; } }


    private void Awake()
    {
        if (_instance != null && _instance != this)
        {
            Destroy(this.gameObject);
        } else {
            _instance = this;
        }
    }
}

Masalah dengan kedua implementasi Anda adalah bahwa mereka tidak menghancurkan objek yang dibuat nanti. Itu bisa bekerja, tetapi orang bisa melemparkan kunci inggris ke dalam karya yang bisa mengakibatkan kesalahan debug yang sangat sulit di telepon. Pastikan untuk memeriksa Sedarlah jika sudah ada instance, dan jika demikian, hancurkan instance baru.

Berikut ringkasan singkatnya:

                 Create object   Removes scene   Global    Keep across
               if not in scene?   duplicates?    access?   Scene loads?

Method 1              No              No           Yes        Yes

Method 2              Yes             No           Yes        No

PearsonArtPhoto       No              Yes          Yes        No
Method 3

Jadi, jika yang Anda pedulikan adalah akses global, ketiganya mendapatkan apa yang Anda butuhkan. Penggunaan pola Singleton bisa sedikit ambigu tentang apakah kita ingin instantiasi malas, keunikan yang ditegakkan, atau akses global jadi pastikan untuk berpikir dengan hati-hati tentang mengapa Anda meraih singleton, dan memilih implementasi yang membuat fitur-fitur itu benar, alih-alih daripada menggunakan standar untuk ketiganya saat Anda hanya membutuhkannya.

(mis. jika game saya akan selalu memiliki GameManager, mungkin saya tidak peduli tentang instantiation yang malas - mungkin itu hanya akses global dengan jaminan keberadaan & keunikan yang saya pedulikan - dalam hal ini kelas statis membuat saya persis fitur-fitur itu dengan sangat ringkas, tanpa pertimbangan pemuatan adegan)

... tapi jelas tidak menggunakan Metode 1 seperti yang tertulis. Find dapat dilewati dengan lebih mudah dengan pendekatan Awake () Method2 / 3, dan jika kita menjaga manajer melintasi adegan maka kita sangat mungkin ingin membunuh duplikat, jika kita pernah memuat antara dua adegan dengan manajer yang sudah ada di dalamnya.

Implementasi terbaik dari Singletonpola umum untuk Unity yang saya tahu adalah (tentu saja) milik saya.

Ia dapat melakukan segalanya , dan melakukannya dengan rapi dan efisien :

Create object        Removes scene        Global access?               Keep across
if not in scene?     duplicates?                                       Scene loads?

     Yes                  Yes                  Yes                     Yes (optional)

Keuntungan lain:

• Ini aman dari benang .
• Itu menghindari bug yang terkait dengan memperoleh (menciptakan) instance tunggal ketika aplikasi berhenti dengan memastikan bahwa singleton tidak dapat dibuat setelahnya OnApplicationQuit(). (Dan ia melakukannya dengan satu bendera global, bukan masing-masing jenis tunggal yang memiliki bendera sendiri)
• Ini menggunakan Pembaruan Mono Unity 2017 (kira-kira setara dengan C # 6). (Tetapi dapat dengan mudah diadaptasi untuk versi kuno)
• Muncul dengan beberapa permen gratis!

Dan karena berbagi itu peduli , ini dia:

public abstract class Singleton<T> : Singleton where T : MonoBehaviour
{
    #region  Fields
    [CanBeNull]
    private static T _instance;

    [NotNull]
    // ReSharper disable once StaticMemberInGenericType
    private static readonly object Lock = new object();

    [SerializeField]
    private bool _persistent = true;
    #endregion

    #region  Properties
    [NotNull]
    public static T Instance
    {
        get
        {
            if (Quitting)
            {
                Debug.LogWarning($"[{nameof(Singleton)}<{typeof(T)}>] Instance will not be returned because the application is quitting.");
                // ReSharper disable once AssignNullToNotNullAttribute
                return null;
            }
            lock (Lock)
            {
                if (_instance != null)
                    return _instance;
                var instances = FindObjectsOfType<T>();
                var count = instances.Length;
                if (count > 0)
                {
                    if (count == 1)
                        return _instance = instances[0];
                    Debug.LogWarning($"[{nameof(Singleton)}<{typeof(T)}>] There should never be more than one {nameof(Singleton)} of type {typeof(T)} in the scene, but {count} were found. The first instance found will be used, and all others will be destroyed.");
                    for (var i = 1; i < instances.Length; i++)
                        Destroy(instances[i]);
                    return _instance = instances[0];
                }

                Debug.Log($"[{nameof(Singleton)}<{typeof(T)}>] An instance is needed in the scene and no existing instances were found, so a new instance will be created.");
                return _instance = new GameObject($"({nameof(Singleton)}){typeof(T)}")
                           .AddComponent<T>();
            }
        }
    }
    #endregion

    #region  Methods
    private void Awake()
    {
        if (_persistent)
            DontDestroyOnLoad(gameObject);
        OnAwake();
    }

    protected virtual void OnAwake() { }
    #endregion
}

public abstract class Singleton : MonoBehaviour
{
    #region  Properties
    public static bool Quitting { get; private set; }
    #endregion

    #region  Methods
    private void OnApplicationQuit()
    {
        Quitting = true;
    }
    #endregion
}
//Free candy!

Saya hanya ingin menambahkan bahwa mungkin berguna untuk menelepon DontDestroyOnLoadjika Anda ingin singleton Anda bertahan di seluruh adegan.

public class Singleton : MonoBehaviour
{ 
    private static Singleton _instance;

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

    private void Awake() 
    { 
        if (_instance != null && _instance != this) 
        { 
            Destroy(this.gameObject);
            return;
        }

        _instance = this;
        DontDestroyOnLoad(this.gameObject);
    } 
}

Pilihan lain mungkin untuk membagi kelas menjadi dua bagian: kelas statis reguler untuk komponen Singleton, dan MonoBehaviour yang bertindak sebagai pengontrol untuk instance singleton. Dengan cara ini Anda memiliki kontrol penuh atas konstruksi singleton, dan itu akan bertahan di seluruh adegan. Ini juga memungkinkan Anda menambahkan pengontrol ke objek apa pun yang mungkin memerlukan data tunggal, alih-alih harus menggali melalui adegan untuk menemukan komponen tertentu.

public class Singleton{
    private Singleton(){
        //Class initialization goes here.
    }

    public void someSingletonMethod(){
        //Some method that acts on the Singleton.
    }

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

public class SingletonController: MonoBehaviour{
   //Create a local reference so that the editor can read it.
   public Singleton instance;
   void Awake(){
       instance = Singleton.Instance;
   }
   //You can reference the singleton instance directly, but it might be better to just reflect its methods in the controller.
   public void someMethod(){
       instance.someSingletonMethod();
   }
} 

Berikut ini adalah implementasi saya dari kelas abstrak tunggal di bawah ini. Berikut adalah bagaimana hal itu sesuai dengan 4 kriteria

             Create object   Removes scene   Global    Keep across
           if not in scene?   duplicates?    access?   Scene loads?

             No (but why         Yes           Yes        Yes
             should it?)

Ini memiliki beberapa keunggulan lain dibandingkan dengan beberapa metode lain di sini:

• Itu tidak menggunakan FindObjectsOfTypeyang merupakan pembunuh kinerja
• Ini fleksibel karena tidak perlu membuat objek game baru yang kosong selama permainan. Anda cukup menambahkannya di editor (atau selama pertandingan) ke objek game pilihan Anda.

• Ini aman dari utas

  using System.Collections.Generic;
  using System.Linq;
  using UnityEngine;
  
  public abstract class Singleton<T> : MonoBehaviour where T : Singleton<T>
  {
      #region  Variables
      protected static bool Quitting { get; private set; }
  
      private static readonly object Lock = new object();
      private static Dictionary<System.Type, Singleton<T>> _instances;
  
      public static T Instance
      {
          get
          {
              if (Quitting)
              {
                  return null;
              }
              lock (Lock)
              {
                  if (_instances == null)
                      _instances = new Dictionary<System.Type, Singleton<T>>();
  
                  if (_instances.ContainsKey(typeof(T)))
                      return (T)_instances[typeof(T)];
                  else
                      return null;
              }
          }
      }
  
      #endregion
  
      #region  Methods
      private void OnEnable()
      {
          if (!Quitting)
          {
              bool iAmSingleton = false;
  
              lock (Lock)
              {
                  if (_instances == null)
                      _instances = new Dictionary<System.Type, Singleton<T>>();
  
                  if (_instances.ContainsKey(this.GetType()))
                      Destroy(this.gameObject);
                  else
                  {
                      iAmSingleton = true;
  
                      _instances.Add(this.GetType(), this);
  
                      DontDestroyOnLoad(gameObject);
                  }
              }
  
              if(iAmSingleton)
                  OnEnableCallback();
          }
      }
  
      private void OnApplicationQuit()
      {
          Quitting = true;
  
          OnApplicationQuitCallback();
      }
  
      protected abstract void OnApplicationQuitCallback();
  
      protected abstract void OnEnableCallback();
      #endregion
  }
  

Sebenarnya ada cara resmi palsu untuk menggunakan Singleton di Unity. Inilah penjelasannya, pada dasarnya buat kelas Singleton dan buat skrip Anda mewarisi dari kelas itu.

Saya akan menganggap implementasi saya juga untuk generasi mendatang.

void Awake()
    {
        if (instance == null)
            instance = this;
        else if (instance != this)
            Destroy(gameObject.GetComponent(instance.GetType()));
        DontDestroyOnLoad(gameObject);
    }

Bagi saya, baris Destroy(gameObject.GetComponent(instance.GetType()));ini sangat penting karena sekali saya meninggalkan skrip singleton pada gim lain. Menangkan adegan dan seluruh objek gim dihapus. Ini hanya akan Hancurkan komponen jika sudah ada.

Saya menulis kelas singleton yang memudahkan untuk membuat objek singleton. Ini adalah skrip MonoBehaviour, sehingga Anda dapat menggunakan Coroutine. Ini berdasarkan pada artikel Wiki Persatuan ini , dan saya akan menambahkan opsi untuk membuatnya dari Prefab nanti.

Jadi, Anda tidak perlu menulis kode Singleton. Cukup unduh Singleton.cs Base Class ini , tambahkan ke proyek Anda, dan buat singleton Anda memperluasnya:

public class MySingleton : Singleton<MySingleton> {
  protected MySingleton () {} // Protect the constructor!

  public string globalVar;

  void Awake () {
      Debug.Log("Awoke Singleton Instance: " + gameObject.GetInstanceID());
  }
}

Sekarang kelas MySingleton Anda adalah singleton, dan Anda dapat menyebutnya dengan Instance:

MySingleton.Instance.globalVar = "A";
Debug.Log ("globalVar: " + MySingleton.Instance.globalVar);

Berikut adalah tutorial lengkapnya: http://www.bivis.com.br/2016/05/04/unity-reusable-singleton-tutorial/