👑 ✊🏾 👐🏻 टाइप आरंभीकरण के दौरान परिपत्र निर्भरता की समस्या 👩🏻‍🌾 🐝 ❇️

कुछ पाठकों को जिन्हें कभी लेख के शीर्षक में वर्णित समस्या का सामना करना पड़ा है, शायद देर तक काम पर रहे और डिबगर में कई घंटे बिताए। दूसरों के लिए, यह एक वाक्य और कठबोली शब्दों से ज्यादा कुछ नहीं हो सकता है। फिर भी, शब्दजाल से हटकर अवधारणाओं को प्रकट करें:

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

खैर, यह दिखाने के लिए एक छोटा सा उदाहरण कि क्या दांव पर है:

using System; class Test {         static void Main()    {        Console.WriteLine(First.Beta);    } } class First {     public static readonly int Alpha = 5;     public static readonly int Beta = Second.Gamma; } class Second {     public static readonly int Gamma = First.Alpha; }

इस कोड का परिणाम 0 होगा

बेशक, यदि आप विनिर्देश में नहीं देखते हैं, तो इस तरह की कोई अपेक्षाएं मान्यताओं से अधिक नहीं काम करेंगी। इसलिए, आइए विनिर्देश देखें (C # 4 संस्करण का खंड 10.5.5.1):

एक वर्ग का स्थिर क्षेत्र चर आरंभीकरण उन असाइनमेंट के अनुक्रम के अनुरूप होता है जो पाठ क्रम में निष्पादित होते हैं जिसमें वे कक्षा घोषणा में दिखाई देते हैं। यदि कोई स्थिर रचनाकार (.1210.12) वर्ग में मौजूद है, तो स्थैतिक क्षेत्र के आरंभकर्ताओं का निष्पादन उस स्थैतिक निर्माता को निष्पादित करने से तुरंत पहले होता है। अन्यथा, स्थैतिक क्षेत्र के शुरुआती को क्रियान्वयन-निर्भर समय पर उस वर्ग के स्थैतिक क्षेत्र के पहले उपयोग से पहले निष्पादित किया जाता है।

अनुवाद:

वर्ग के स्थिर क्षेत्रों का प्रारंभिक क्रम वर्ग के स्रोत कोड में उनके स्थान के क्रम से मेल खाता है। यदि क्लास में स्टैटिक कंस्ट्रक्टर होता है, तो स्टैटिक कंस्ट्रक्टर को कॉल करने से पहले क्लास के स्टैटिक फील्ड्स के लिए इनिशियलाइज़ेशन कोड का निष्पादन होता है। अन्यथा, यदि स्थिर कंस्ट्रक्टर मौजूद नहीं है, तो स्थैतिक फ़ील्ड्स का इनिशियलाइज़ेशन उस स्थान पर किया जाता है जो विशेष कार्यान्वयन पर निर्भर करता है: यह स्टैटिक फ़ील्ड के पहले उपयोग से पहले होता है।

भाषा विनिर्देश के अलावा, आप CLI विनिर्देश के एक अंश का हवाला दे सकते हैं, जो टाइप आरंभीकरण के बारे में अधिक विवरण प्रकट करता है, विशेष रूप से परिपत्र निर्भरता और बहु-थ्रेडेड ऑपरेशन के बारे में। हालाँकि, मैं ऐसा नहीं करूँगा, लेकिन सिर्फ कुछ अंशों को लिखूंगा:

टाइप आरंभीकरण के दौरान थ्रेड सुरक्षा की गारंटी
यदि CLI यह नोटिस करता है कि टाइप ए को आरंभ करने की आवश्यकता है और उसी थ्रेड में आरंभीकरण की प्रक्रिया में भी है, तो CLI काम करना जारी रखता है जैसे कि टाइप ए पहले से ही आरंभिक था।

तो आपकी राय में क्या होगा:

प्रारंभिक Test : आगे की कार्रवाई की आवश्यकता नहीं है।
स्टार्ट Main
First प्रारंभ करना प्रारंभ करें (क्योंकि हमें First आवश्यकता है। First.Beta )
First.Alpha सेट करें
Second आरंभ करना शुरू करें (क्योंकि हमें Second चाहिए। Second.Gamma )
दूसरा सेट करें। Second.Gamma को First.Alpha Second.Gamma पर First.Alpha (5)
प्रारंभिक प्रारंभ Second
पहले सेट करें। First.Beta से Second.Gamma (5)
आरंभिक समाप्ति First
"5" टाइप करें

और यहाँ वही है जो वास्तव में हो रहा है - .net फ्रेमवर्क 4.5 बीटा के साथ मेरे कंप्यूटर पर (मुझे पता है कि टाइप आरंभीकरण .NET .NET में बदल गया था। मुझे पता नहीं है कि .Net 4.5 में कोई परिवर्तन हुए हैं, लेकिन मैं नहीं करता। मैं तर्क दूंगा कि यह संभव नहीं है)

प्रारंभिक Test : आगे की कार्रवाई की आवश्यकता नहीं है।
स्टार्ट Main
First प्रारंभ करना प्रारंभ करें (क्योंकि हमें First आवश्यकता है। First.Beta )
Second आरंभ करना (हमें Second चाहिए। Second.Gamma )
दूसरा सेट करें। Second.Gamma को First.Alpha (0)
प्रारंभिक प्रारंभ Second
First.Alpha सेट करें
पहले सेट करें। First.Beta से Second.Gamma (0)
आरंभिक समाप्ति First
टाइप ०

चरण (5) बहुत दिलचस्प है। हम जानते हैं कि First First.Alpha प्राप्त करने के लिए हमें First को इनिशियलाइज़ करना First.Alpha । हालाँकि, यह थ्रेड पहले से ही इनिशियलाइज़ कर रहा है, इसलिए हम इनिशियलाइज़ेशन को छोड़ देते हैं, उम्मीद करते हैं कि सब कुछ क्रम में है। हालाँकि, इस बिंदु पर चर अभी तक आरंभ नहीं किया गया है। उफ़ ...

(एक सूक्ष्मता है जो वर्णित सभी समस्याओं से बचती है: कास्ट कीवर्ड का उपयोग करके)

वापस वास्तविक दुनिया में

मुझे आशा है कि मेरे उदाहरण ने आपके लिए स्पष्ट किया है कि जब परिपत्र प्रकार का उपयोग करते हुए परिपत्र निर्भरता का उपयोग किया जाता है तो यह आपके जीवन को बर्बाद कर देगा। ऐसी जगहों को पकड़ना और डिबग करना बहुत मुश्किल है। और वास्तव में यह एक क्लासिक गीज़ेनबैग है । हमारे उदाहरण में, यह समझना महत्वपूर्ण है कि अगर ऐसा होता है कि प्रोग्राम Second पहले शुरू करता है (उदाहरण के लिए, दूसरे चर का उपयोग करने के लिए), तो हमें एक पूरी तरह से अलग परिणाम मिलेगा। और, व्यवहार में, आप एक ऐसी स्थिति प्राप्त कर सकते हैं जहां सभी इकाई परीक्षणों के लॉन्च से इस तथ्य को जन्म दिया जाएगा कि वे सभी विफल हो जाएंगे। लेकिन अगर एक ही समय में आप उन्हें अलग से चलाते हैं, तो वे काम करेंगे (यह काफी संभव है, एक को छोड़कर)।

इस तरह की स्थितियों से बचने का एक तरीका यह है कि टाइप आरंभीकरण को पूरी तरह छोड़ दिया जाए। ज्यादातर मामलों में, यह वही है जो आपको चाहिए। हालांकि, हम आमतौर पर अच्छी तरह से ज्ञात चीजों का उपयोग करते हैं। जैसे Encoding.Utf8 । TimeZoneInfo.Utc , या TimeZoneInfo.Utc । ध्यान दें कि दोनों ही मामलों में ये स्थिर गुण हैं, लेकिन यह मुझे लगता है कि वे स्थैतिक क्षेत्रों का उपयोग करते हैं। पहली नज़र में, ऐसा लगता है कि public static readonly public static get-only का उपयोग करना public static readonly public static get-only गुण समान हैं, हालांकि, जैसा कि हम बाद में देखेंगे, गुणों का उपयोग करने से इसके फायदे मिलते हैं।

मेरी नोदा टाइम लाइब्रेरी में कुछ पल हमारे जैसे ही हैं। और सभी क्योंकि इस पुस्तकालय के कई प्रकार अपरिवर्तनीय हैं , अर्थात्। अपरिवर्तनीय। यह तब समझ में आता है जब आपको अपना UTC टाइम ज़ोन या ISO calendar system बनाने की आवश्यकता ISO calendar system । इसके अलावा, सार्वजनिक रूप से दिखाई देने वाले मूल्यों के अलावा, हमारे पास लाइब्रेरी के अंदर (मुख्य रूप से कैशिंग कार्यों के लिए) कई स्थिर चर हैं। यह सब पुस्तकालय को अधिक कठिन और कठिन बना देता है, लेकिन इस मामले में प्रदर्शन लाभ बहुत महत्वपूर्ण हैं।

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

प्रारंभिक परीक्षण टाइप करें

मुख्य प्रकारों में से एक जब प्रारंभिक प्रकारों को गारंटी के साथ संयोजन में प्रारंभ करने के क्रम की संवेदनशीलता है कि AppDomain भीतर का प्रकार केवल एक बार प्रारंभ किया जाएगा। जैसा कि मैंने पहले दिखाया था, यह संभव है कि एक आरंभीकरण आदेश के साथ यह एक त्रुटि का कारण होगा, और कुछ अन्य के साथ, कोई त्रुटि नहीं होगी।

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

यहाँ हमारी मोटी योजना है:

हम निर्भरताओं की एक खाली सूची के साथ शुरू करते हैं;
लक्ष्य विधानसभा के प्रत्येक प्रकार के लिए:
- नया AppDomain बनाएँ
- वहां विधानसभा डाउनलोड करें
- एक प्रकार को इनिशियलाइज़ करें (इनिशियलाइज़ेशन प्रोसेस शुरू करने के लिए उस पर एक्शन करें)
- प्रत्येक प्रकार के आरंभ की शुरुआत से स्टैक ट्रेस देखें और सभी निर्भरताओं को रिकॉर्ड करें।
सारांश सूची में परिपत्र निर्भरताएं देखें

कृपया ध्यान दें कि हमें ऐसी स्थिति कभी नहीं मिलेगी जहां हम एप्लिकेशन डोमेन के एक डाउनलोड में चक्रीय निर्भरता निर्धारित कर सकते हैं। ऐसा करने के लिए, सभी प्रकारों को बायपास करना और चक्रों की पहचान करना, परिणामों का विश्लेषण करना आवश्यक है।

यह वर्णन करता है कि कोड कैसे काम करता है यह कोड की तुलना में बहुत बड़ा होगा और वास्तव में इसे समझना बहुत आसान है, इसलिए मैं इसे लेख के अंत में डालूंगा।

यह समाधान कई कारणों से बहुत अच्छा नहीं है:

एक नया AppDomain बनाना और एक यूनिट टेस्टिंग प्रोग्राम से इसमें असेंबलिंग लोड करना उतना आसान नहीं हो सकता जितना कि हो सकता है। मेरा कोड NCrunch के साथ सही ढंग से काम नहीं करता है। और मुझे यकीन है कि अगर मैं इसे ठीक कर NCrunch , तो बाकी यूनिट टेस्टिंग सिस्टम अभी भी मेरे प्रोग्राम को तोड़ देंगे।
यह इस तथ्य पर आधारित है कि प्रत्येक प्रकार के इनिशलाइज़र में सिस्टम के काम करने के लिए आवश्यक कोड की एक पंक्ति होगी:
```
 private static readonly int TypeInitializationChecking = NodaTime.Utility.TypeInitializationChecker.RecordInitializationStart(); 
```
न केवल यह बुरा है कि आपको प्रत्येक प्रकार के कोड की एक पंक्ति जोड़ने की आवश्यकता है जो हमें रुचती है। यह ख़राब है क्योंकि इस लाइन को हर बार टाइप किया जाता है। यह ढेर से कम से कम 4 बाइट्स का चयन करेगा, जो कि प्रोग्राम मोड में नहीं चल रहा है तो बहुत बुरा है। बेशक, मैं इस कोड को संस्करण से हटाने के लिए प्रीप्रोसेसर निर्देशों का उपयोग कर सकता हूं, परीक्षण के लिए नहीं। लेकिन इससे कोड और भी गंदा लगेगा;
यह विधि केवल उन .Net संस्करणों के लिए चक्रीय निर्भरता पाता है जिन पर परीक्षण चलाए गए थे। यह देखते हुए कि .Net फ्रेमवर्क के विभिन्न संस्करणों में अंतर हैं, मुझे यकीन नहीं होगा कि परीक्षण 100% स्थितियों को कवर करेंगे। इसी तरह, यदि हम वर्तमान कल्चरइन्फो, या किसी अन्य प्रतीत होता है निरंतर, पर्यावरण चर को बदलते हैं, तो परीक्षण पूरी तरह से अलग तरीके से काम कर सकते हैं।
इस कार्यान्वयन में भी, मैं उन स्थितियों को नहीं देखता जहाँ कोड को मल्टीथ्रेड किया जाता है। ऐसी स्थितियों के लिए, मुझे, फिर से, यकीन नहीं है कि यह सही ढंग से काम करेगा।

और, इन सभी आरक्षणों पर विचार करना ... क्या यह उपयोग करने के लायक है? निश्चित रूप से हाँ। इस तकनीक ने मुझे कई कीड़े ढूंढने में मदद की जो तय हो गए थे।

चक्रीय निर्भरता को ठीक करें

अतीत में, मैंने कोड के साथ फ़ील्ड्स को स्थानांतरित करके टाइप इनिशियलाइज़ेशन ऑर्डर "फिक्स्ड" किया। चक्र अभी भी मौजूद थे, लेकिन मुझे पता चला कि उन्हें हानिरहित कैसे बनाया जाए। मैं कह सकता हूं कि यह दृष्टिकोण स्केलेबल नहीं है और जितना लगता है उससे कहीं अधिक प्रयास में खर्च होता है। कोड मुश्किल हो जाता है ... और अगर एक दिन आपको दो से अधिक निर्भरता का एक लूप मिलता है, तो यह दिमाग के लिए एक पहेली होगी कि इसे कैसे सुरक्षित बनाया जाए। फिलहाल मैं स्टैटिक वैरिएबल्स के विलंबित आरंभ को लागू करने के लिए एक बहुत ही सरल तकनीक का उपयोग कर रहा हूं।

इसलिए यह देखने के बजाय कि कौन सा static readonly field आपके लिए एक परिपत्र निर्भरता बनाता है, आप static readonly property उपयोग करते static readonly property , जो internal static readonly field को एक नेस्टेड, निजी स्थैतिक वर्ग में लौटाता है। हमारे पास अभी भी एकल कॉल की गारंटी के साथ थ्रेड-सुरक्षित इनिशियलाइज़ेशन है, हालाँकि, nested प्रकार को तब तक इनिशियलाइज़ नहीं किया जाएगा जब तक कि इसके लिए कोई आवश्यकता न हो।
इसलिए इसके बजाय:

  // Requires Bar to be initialized - if Bar also requires Foo to be // initialized, we have a problem... public static readonly Foo SimpleFoo = new Foo(Bar.Zero);

हम लिखेंगे:

 public static readonly Foo SimpleFoo { get { return Constants.SimpleFoo; } } private static class Constants {    private static readonly int TypeInitializationChecking = NodaTime.Utility.TypeInitializationChecker.RecordInitializationStart();     // This requires both Foo and Bar to be initialized, but that's okay    // so long as neither of them require Foo.Constants to be initialized.    // (The unit test would spot that.)    internal static readonly Foo SimpleFoo = new Foo(Bar.Zero); }

फिलहाल, मैं यह निर्धारित नहीं कर सकता कि आलसी आरंभीकरण को प्राप्त करने के लिए इन वर्गों में स्थिर निर्माणकर्ताओं को शामिल किया जाए या नहीं। यदि प्रकार Foo का एक इनिशलाइज़र Foo.Constants प्रकार का इनिशियलाइज़र कहता है, तो हम प्रारंभिक बिंदु पर लौट आएंगे। लेकिन नेस्टेड कक्षाओं में से प्रत्येक में स्थिर कंस्ट्रक्टर जोड़ना भयानक लगता है।

निष्कर्ष

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

हालांकि, जबकि यह दृष्टिकोण किसी प्रकार की हैकिंग की तरह दिखता है, यह अभी भी विकल्प से बेहतर है - त्रुटियों से भरा कोड। और ... मुझे यह कहते हुए शर्म आ रही है, लेकिन मुझे नहीं लगता कि Noda Time मुझे सभी चक्रीय निर्भरताएं मिलीं। यह अपने स्वयं के कोड पर प्रयास करने के लायक है - देखें कि आपको कहां छिपी हुई समस्याएं हो सकती हैं

आवेदन: परीक्षण कोड

TypeInitializationChecker

 internal sealed class TypeInitializationChecker : MarshalByRefObject { private static List<Dependency> dependencies = null; private static readonly MethodInfo EntryMethod = typeof(TypeInitializationChecker).GetMethod("FindDependencies"); internal static int RecordInitializationStart() { if (dependencies == null) { return 0; } Type previousType = null; foreach (var frame in new StackTrace().GetFrames()) { var method = frame.GetMethod(); if (method == EntryMethod) { break; } var declaringType = method.DeclaringType; if (method == declaringType.TypeInitializer) { if (previousType != null) { dependencies.Add(new Dependency(declaringType, previousType)); } previousType = declaringType; } } return 0; } /// <summary> /// Invoked from the unit tests, this finds the dependency chain for a single type /// by invoking its type initializer. /// </summary> public Dependency[] FindDependencies(string name) { dependencies = new List<Dependency>(); Type type = typeof(TypeInitializationChecker).Assembly.GetType(name, true); RuntimeHelpers.RunClassConstructor(type.TypeHandle); return dependencies.ToArray(); } /// <summary> /// A simple from/to tuple, which can be marshaled across AppDomains. /// </summary> internal sealed class Dependency : MarshalByRefObject { public string From { get; private set; } public string To { get; private set; } internal Dependency(Type from, Type to) { From = from.FullName; To = to.FullName; } } }

TypeInitializationTest

 [TestFixture] public class TypeInitializationTest { [Test] public void BuildInitializerLoops() { Assembly assembly = typeof(TypeInitializationChecker).Assembly; var dependencies = new List<TypeInitializationChecker.Dependency>(); // Test each type in a new AppDomain - we want to see what happens where each type is initialized first. // Note: Namespace prefix check is present to get this to survive in test runners which // inject extra types. (Seen with JetBrains.Profiler.Core.Instrumentation.DataOnStack.) foreach (var type in assembly.GetTypes().Where(t => t.FullName.StartsWith("NodaTime"))) { // Note: this won't be enough to load the assembly in all test runners. In particular, it fails in // NCrunch at the moment. AppDomainSetup setup = new AppDomainSetup { ApplicationBase = AppDomain.CurrentDomain.BaseDirectory }; AppDomain domain = AppDomain.CreateDomain("InitializationTest" + type.Name, AppDomain.CurrentDomain.Evidence, setup); var helper = (TypeInitializationChecker)domain.CreateInstanceAndUnwrap(assembly.FullName, typeof(TypeInitializationChecker).FullName); dependencies.AddRange(helper.FindDependencies(type.FullName)); } var lookup = dependencies.ToLookup(d => d.From, d => d.To); // This is less efficient than it might be, but I'm aiming for simplicity: starting at each type // which has a dependency, can we make a cycle? // See Tarjan's Algorithm in Wikipedia for ways this could be made more efficient. // http://en.wikipedia.org/wiki/Tarjan's_strongly_connected_components_algorithm foreach (var group in lookup) { Stack<string> path = new Stack<string>(); CheckForCycles(group.Key, path, lookup); } } private static void CheckForCycles(string next, Stack<string> path, ILookup<string, string> dependencyLookup) { if (path.Contains(next)) { Assert.Fail("Type initializer cycle: {0}-{1}", string.Join("-", path.Reverse().ToArray()), next); } path.Push(next); foreach (var candidate in dependencyLookup[next].Distinct()) { CheckForCycles(candidate, path, dependencyLookup); } path.Pop(); } }

टाइप आरंभीकरण के दौरान परिपत्र निर्भरता की समस्या