परिचय

प्रोग्रामिंग की एक बड़ी संख्या पैटर्न और एंटीपैटर्न हैं। अक्सर पैटर्न का उपयोग हमें अनुभव और स्वयं के वास्तविक ज्ञान को निर्देशित करता है। इस लेख में मैं आपके साथ सिंगलटन पैटर्न के आवेदन पर चर्चा करना चाहता हूं , अर्थात् नेट में इसका कार्यान्वयन एकता के अनुसार लागू किया गया।

एकाकी वस्तु

मैं ध्यान देता हूं कि मैं एक टीम में कोड लिख रहा हूं, इसलिए मैं टीम को उतारने और यूनिटी में कुछ पैटर्न लागू करने की कुछ कठिनाइयों के बारे में सोचने की आवश्यकता को खत्म करने के लिए कोड के अंदर जितना संभव हो उतना काम लेता हूं।

इस प्रश्न ^{2 के} संबंध में नेट ¹ पर साहित्य का अध्ययन ^, और कई परियोजनाओं पर काम के परिणामस्वरूप, निम्न वर्ग का जन्म हुआ:

using UnityEngine;

/// <summary>
///    .
/// </summary>
/// <typeparam name="T">,    </typeparam>
/// <remarks>
///        OnDestroy  OnApplicationQuit
///      IsAlive.     
/// ,        .
/// 
/// 
///      Awake, OnDestroy, 
/// OnApplicationQuit    
/// base.Awake()  .
/// 
///    Initialization -      
///  .
/// 
///     unity,    
///   .    ,    
///       .
/// 
///  :
///     -  "CLR via C#"
///     - Chris Dickinson "Unity 2017 Game optimization"
///</remarks>

public class Singleton<T> : MonoBehaviour where T : Singleton<T>
{

    private static T instance = null;

    private bool alive = true;

    public static T Instance
    {
        get
        {
            if (instance != null)
            {
                return instance;
            }
            else
            {
                //Find T
                T[] managers = GameObject.FindObjectsOfType<T>();
                if (managers != null)
                {
                    if (managers.Length == 1)
                    {
                        instance = managers[0];
                        DontDestroyOnLoad(instance);
                        return instance;
                    }
                    else
                    {
                        if (managers.Length > 1)
                        {
                            Debug.LogError($"Have more that one {typeof(T).Name} in scene. " +
                                            "But this is Singleton! Check project.");
                            for (int i = 0; i < managers.Length; ++i)
                            {
                                T manager = managers[i];
                                Destroy(manager.gameObject);
                            }
                        }
                    }
                }
                //create 
                GameObject go = new GameObject(typeof(T).Name, typeof(T));
                instance = go.GetComponent<T>();
        instance.Initialization();
                DontDestroyOnLoad(instance.gameObject);
                return instance;
            }
        }

        //Can be initialized externally
        set
        {
            instance = value as T;
        }
    }

    /// <summary>
    /// Check flag if need work from OnDestroy or OnApplicationExit
    /// </summary>
    public static bool IsAlive
    {
        get
        {
            if (instance == null)
                return false;
            return instance.alive;
        }
    }

    protected void Awake()
    {
        if (instance == null)
        {
            DontDestroyOnLoad(gameObject);
            instance = this as T;
            Initialization();
        }
        else
        {
            Debug.LogError($"Have more that one {typeof(T).Name} in scene. " +
                            "But this is Singleton! Check project.");
            DestroyImmediate(this);
        }
    }

    protected void OnDestroy() { alive = false; }

    protected void OnApplicationQuit() { alive = false; }

    protected virtual void Initialization() { }
}

मैं कई पहलुओं पर ध्यान केंद्रित करूंगा।

वस्तु निर्माण

जब एक परियोजना का विस्तार, और यहां तक ​​कि एक टीम> 3 लोगों के रूप में काम करते हुए, एक स्थिति अक्सर उत्पन्न होती है जब ऑब्जेक्ट बनाने का क्रम अस्पष्ट हो जाता है। सख्ती से ³ बोलना , जागने के लिए कॉल का क्रम () निश्चित रूप से यादृच्छिक है, यह पूरी तरह से सच नहीं है, और प्रक्रिया प्रभावित हो सकती है, लेकिन प्रलेखन पवित्र है), यही कारण है कि इंस्टेंस {get;} संपत्ति को लागू करने से इस कष्टप्रद दोष को खत्म करना आवश्यक है । नतीजतन, हम अन्य वर्गों के सजग () से सिंगलटन तक पूरी पहुंच प्राप्त करते हैं।

, Lazy, Awake() .

4-⁴, , Instance{get;}.

Unity — Awake(). , , Initialization(). (KISS).

, DI SD. . .

, , OnDestroy(), OnApplicationQuit() ⁵:

Did you spawn new GameObjects from OnDestroy?

, , , . , IsAlive(), , . , ...

तेजी से, मैं इस निष्कर्ष पर पहुंचता हूं कि एकता प्रतिमान का उपयोग करके सिंगलटन के बिना मेरी परियोजनाओं को लागू करना संभव है। अक्सर, इस पैटर्न को लागू करने से आपका कोड अत्यधिक जुड़ा और बेहद नाजुक हो जाता है।

धन्यवाद।

सूत्रों का कहना है

- रिक्टर जे। "CR थ्रू सी # #। Microsoft.NET # फ्रेमवर्क 4.5 इन C #", 2013 पर प्रोग्रामिंग

- https://www.codingame.com/playgrounds/1979/different-ways-to-implement-singleton-in--net-and-make-people-hate-you-along-the-way

- https://docs.unity3d.com/en/current/ScriptReference/MonoBehaviour.Awen.html

- https://ru.wikipedia.org/wiki/Design_Patterns

- डिकिंसन क्रिस "यूनिटी 2017 गेम ऑप्टिमाइज़ेशन, दूसरा संस्करण", 2017