👇 🤲🏼 😋 C # गुण: सभी पहलुओं के बारे में 👨🏼‍🔬 👶🏾 🤲🏼

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

सामग्री

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

परिचय

हमेशा की तरह, परिभाषाओं और विशिष्टताओं के साथ शुरू करें। यह सभी स्तरों पर विशेषताओं को समझने और महसूस करने में मदद करेगा, जो बदले में, उनके लिए सही एप्लिकेशन खोजने के लिए बहुत उपयोगी है।

मेटाडेटा को परिभाषित करके प्रारंभ करें। मेटाडेटा वह डेटा है जो सीटीएस द्वारा परिभाषित प्रकारों का वर्णन और संदर्भित करता है। मेटाडेटा को एक तरह से संग्रहीत किया जाता है जो किसी विशेष प्रोग्रामिंग भाषा से स्वतंत्र होता है। इस प्रकार, मेटाडेटा उपकरणों के बीच उपयोग के लिए एक कार्यक्रम के बारे में जानकारी के आदान-प्रदान के लिए एक सामान्य तंत्र प्रदान करता है जिसके लिए इसकी आवश्यकता होती है (कंपाइलर और डीबगर्स, साथ ही साथ कार्यक्रम), साथ ही वीईएस के बीच भी। मेटाडेटा को विधानसभा के घोषणापत्र में शामिल किया गया है। उन्हें IL कोड के साथ PE फ़ाइल में या एक अलग PE फ़ाइल में संग्रहीत किया जा सकता है, जहां केवल एक असेंबली मैनिफ़ेस्ट होगा।
एक विशेषता एक प्रकार या उसके सदस्यों (या अन्य भाषा निर्माण) की एक विशेषता है जिसमें वर्णनात्मक जानकारी होती है। यद्यपि सबसे आम विशेषताएँ पूर्वनिर्धारित हैं और मेटाडेटा में एक विशिष्ट प्रारूप है, कस्टम विशेषताओं को मेटाडेटा में भी जोड़ा जा सकता है। विशेषताएँ सराहनीय हैं, अर्थात् तत्व पर उनकी घोषणा का क्रम महत्वहीन है

एक वाक्यात्मक दृष्टिकोण से (मेटाडेटा में), निम्नलिखित विशेषताएं हैं

IL में विशेष सिंटैक्स का उपयोग करना। उदाहरण के लिए, कीवर्ड विशेषता हैं। और उनके लिए आईएल में एक विशेष वाक्यविन्यास है। उनमें से बहुत सारे हैं, सब कुछ सूचीबद्ध करने का कोई मतलब नहीं है
सामान्यीकृत सिंटैक्स का उपयोग करना। इनमें उपयोगकर्ता और लाइब्रेरी विशेषताएँ शामिल हैं।
सुरक्षा विशेषताएँ। इनमें वे विशेषताएँ शामिल हैं जो SecurityAttribute (सीधे या परोक्ष रूप से) से प्राप्त होती हैं। उन्हें एक विशेष तरीके से संसाधित किया जाता है। आईएल में उनके लिए एक विशेष वाक्यविन्यास है, जो आपको सीधे इन विशेषताओं का वर्णन करने वाले एक्सएमएल बनाने की अनुमति देता है

उदाहरण

C # कोड जिसमें उपरोक्त सभी प्रकार की विशेषताएँ हैं

[StructLayout(LayoutKind.Explicit)] [Serializable] [Obsolete] [SecurityPermission(SecurityAction.Assert)] public class Sample { }

परिणामी आईएल

 .class public EXPLICIT ansi SERIALIZABLE beforefieldinit AttributeSamples.Sample extends [System.Runtime]System.Object { .custom instance void [System.Runtime]System.ObsoleteAttribute::.ctor() = (01 00 00 00 ) .permissionset assert = { class 'System.Security.Permissions.SecurityPermissionAttribute, System.Runtime.Extensions, Version=4.2.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a' = {}} .method public hidebysig specialname rtspecialname instance void .ctor() cil managed {/*constructor body*/} }

जैसा कि आप देख सकते हैं, StructLayoutAttribute में एक विशेष सिंटैक्स है, क्योंकि IL में इसे "स्पष्ट" के रूप में दर्शाया गया है। अप्रत्यक्ष योगदान एक सामान्य वाक्यविन्यास का उपयोग करता है - IL में ".custom" से शुरू होता है। SecurityPermissionAttribute एक सुरक्षा विशेषता के रूप में एक ".permissionset मुखर" में बदल गया है।

उपयोगकर्ता विशेषताएँ मेटाडेटा में उपयोगकर्ता जानकारी जोड़ते हैं। इस तंत्र का उपयोग एप्लिकेशन-विशिष्ट जानकारी को संकलन समय पर संग्रहीत करने के लिए किया जा सकता है और इसे रन टाइम पर या किसी अन्य उपकरण द्वारा पढ़ने और विश्लेषण के लिए उपयोग किया जा सकता है। यद्यपि किसी भी उपयोगकर्ता-परिभाषित प्रकार को एक विशेषता के रूप में उपयोग किया जा सकता है, सीएलएस अनुरूपता के लिए आवश्यक है कि विशेषताएँ System.Attribute से इनहेरिट करें। सीएलआई कुछ विशेषताओं को पूर्वनिर्धारित करता है और रनटाइम व्यवहार को नियंत्रित करने के लिए उनका उपयोग करता है। कुछ भाषाएं सीटीएस में सीधे प्रतिनिधित्व नहीं की गई भाषा सुविधाओं का प्रतिनिधित्व करने के लिए विशेषताओं को परिभाषित करती हैं।

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

अब सीमाओं के बारे में थोड़ा

अगर किसी कारण से नाम और NameAtribute नाम के साथ एक ही असेंबली में 2 विशेषताएँ हैं, तो उनमें से पहला नाम रखना असंभव हो जाता है। उपयोग करते समय [नाम] (जो कि प्रत्यय के बिना है), संकलक का कहना है कि यह अनिश्चितता को देखता है। [NameAttribute] का उपयोग करते समय हम NameAttribute को रखेंगे, जो तार्किक है। नामकरण करते समय कल्पना की कमी के साथ ऐसी रहस्यमय स्थिति के लिए एक विशेष वाक्यविन्यास है। पहला संस्करण बिना प्रत्यय के रखने के लिए, आप विशेषता नाम [@ नाम] से पहले कुत्ते का चिह्न निर्दिष्ट कर सकते हैं (जैसे, [नाम] एक मजाक है, यह आवश्यक नहीं है)।

कस्टम विशेषताओं को कुछ भी लेकिन कस्टम विशेषताओं में जोड़ा जा सकता है। यह मेटाडेटा को संदर्भित करता है, अर्थात यदि हम विशेषता वर्ग के ऊपर C # में एक विशेषता रखते हैं, तो मेटाडेटा में यह कक्षा को संदर्भित करेगा। लेकिन आप "सार्वजनिक" में एक विशेषता नहीं जोड़ सकते। लेकिन आप असेंबली, मॉड्यूल, क्लासेस, वैल्यू टाइप, एनम, कंस्ट्रक्टर, मेथड, प्रॉपर्टी, फील्ड, इवेंट, इंटरफेस, पैरामीटर, डेलीगेट्स, रिटर्न वैल्यू, या सामान्यीकृत पैरामीटर के साथ कर सकते हैं। नीचे दिए गए उदाहरण से पता चलता है कि आप किसी विशेष निर्माण पर एक विशेषता कैसे डाल सकते हैं, यह स्पष्ट नहीं है।

घोषणा घोषणा सिंटेक्स

 using System; using System.Runtime.InteropServices; using System.Security.Permissions; using AttributeSamples; [assembly:All] [module:All] namespace AttributeSamples { [AttributeUsage(AttributeTargets.All)] public class AllAttribute : Attribute { } [All] //   public class Usage { [All] //   [return:All] //     public int GiveMeInt<[All]T>([All]int param) { return 5 + param; } [All] //   [field:All] //        public event Action Event; [All] //   [field: All] //       public int Action { get; set; } } }

विशेषताओं में 2 प्रकार के पैरामीटर हैं - नाम और स्थिति। स्थितीय मापदंडों में कंस्ट्रक्टर पैरामीटर शामिल हैं। नामित करने के लिए - एक सुलभ सेटर के साथ सार्वजनिक गुण। इसके अलावा, ये सिर्फ औपचारिक नाम नहीं हैं, इसके नाम के बाद कोष्ठक में विशेषता की घोषणा करते समय सभी मापदंडों को इंगित किया जा सकता है। नाम वाले वैकल्पिक हैं।

पैरामीटर्स के प्रकार

 [AttributeUsage(AttributeTargets.All, AllowMultiple = true)] public class AttrParamsAttribute : Attribute { public AttrParamsAttribute(int positional) //  { } public int Named { get; set; } //  } [AttrParams(1)] [AttrParams(1, Named = 2)] public class AttrParams { }

विशेषता के लिए मान्य पैरामीटर (दोनों प्रकार के) निम्न प्रकारों में से एक होने चाहिए:

बूल, बाइट, चार, डबल, फ्लोट, इंट, लॉन्ग, शॉर्ट, स्ट्रिंग और आगे आदिम, दशमलव को छोड़कर
वस्तु
System.Type
enum
उपरोक्त प्रकारों में से किसी एक का एक आयामी सरणी

यह मोटे तौर पर इस तथ्य के कारण है कि यह एक संकलन-समय स्थिर होना चाहिए, और ऊपर दिए गए प्रकार इस निरंतरता को स्वीकार कर सकते हैं (किसी वस्तु को स्वीकार करके हम int पास कर सकते हैं)। लेकिन किसी कारण से, तर्क प्रकार प्रकार का नहीं हो सकता है, हालांकि यह तार्किक दृष्टिकोण से संभव है।

उपयोगकर्ता विशेषताओं के दो प्रकार हैं: वास्तविक कस्टम विशेषताएँ और छद्म कस्टम ।
कोड में, वे समान दिखते हैं (उन्हें वर्ग कोष्ठक में भाषा संरचना के ऊपर दर्शाया गया है), लेकिन उन्हें अलग तरीके से संसाधित किया जाता है:

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

छद्म उपयोगकर्ता विशेषताएँ दृश्य प्रतिबिंब नहीं हैं

 [Serializable] [StructLayout(LayoutKind.Explicit)] public class CustomPseudoCustom { } class Program { static void Main() { var onlyCustom = typeof(CustomPseudoCustom).GetCustomAttributes(); // SerializableAttribute } }

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

रनटाइम-सक्षम विशेषताएँ

यह खंड पूरी तरह से जानकारीपूर्ण है, अगर रनटाइम का उपयोग करने में कोई दिलचस्पी नहीं है, तो आप अगले अनुभाग तक स्क्रॉल कर सकते हैं।

नीचे दी गई तालिका छद्म उपयोगकर्ता विशेषताओं और विशेष उपयोगकर्ता विशेषताओं (सीएलआई या संकलक उन्हें एक विशेष तरीके से संभालती है) को सूचीबद्ध करती है।

छद्म-उपयोगकर्ता विशेषताएँ (वे प्रतिबिंब के माध्यम से प्राप्त नहीं की जा सकती हैं)।
सीएलआई गुण:

गुण	विवरण
AssemblyAlgorithmIDAttribute	उपयोग किए गए हैश एल्गोरिथ्म के पहचानकर्ता को लिखता है। विधानसभा सेट करता है। हाशलाग्ड क्षेत्र
AssemblyFlagsAttribute	संबंधित विधानसभा के लिए झंडे लिखते हैं। विधानसभा सेट करता है। फ़्लैग्स फ़ील्ड
DllImportAttribute	एक अप्रबंधित पुस्तकालय में लागू कोड के बारे में जानकारी प्रदान करता है। विधि सेट करता है। Lags.PinvokeImpl इसी विधि का बिट; ImplMap के लिए एक नई प्रविष्टि जोड़ता है (MappingFlags, MemberForwarded, ImportName और ImportScope के मूल्यों को सेट करके)
StructLayoutAttribute	आपको संदर्भ या महत्वपूर्ण प्रकार के फ़ील्ड रखने के लिए विधि को स्पष्ट रूप से सेट करने की अनुमति देता है। प्रकार के लिए TypeDef.Flags.LayoutMask फ़ील्ड सेट करता है। यह TypeDef.lags.StringFormatMask, ClassLayout.PackingSize और ClassLayout.ClassSize फ़ील्ड भी सेट कर सकता है
FieldOffsetAttribute	एक संदर्भ या महत्वपूर्ण प्रकार में खेतों की बाइट ऑफसेट को परिभाषित करता है। इसी विधि के लिए FieldLayout.OffSet का मान सेट करता है।
InAttribute	इंगित करता है कि पैरामीटर को [में] तर्क के रूप में पारित किया गया है। Param.Flags.In बिट को संबंधित पैरामीटर के लिए सेट करता है।
OutAttribute	इंगित करता है कि पैरामीटर को [आउट] तर्क के रूप में पारित किया गया है। Param.Flags.Out बिट के लिए इसी पैरामीटर सेट करता है।
MarshalAsAttribute	परिभाषित करता है कि प्रबंधित और अनवांटेड कोड के बीच डेटा को कैसे मार्श किया जाता है। फ़ील्ड के लिए सेट करता है। फ़ील्ड के लिए। (Param.Flags.HasFieldMarshal बिट पैरामीटर के लिए); फ़ील्डमार्शल तालिका में प्रवेश को जोड़ता है (अभिभावक और मूल निवासी के मूल्यों को निर्धारित करके)
MethodImplAttribute	एक विधि के लिए कार्यान्वयन विवरण को परिभाषित करता है। इसी विधि के लिए Method.ImplFlags का मान सेट करता है

सीएलएस विशेषताएँ - भाषाओं को उनका समर्थन करना चाहिए:

गुण	विवरण
AttributeUsageAttribute	यह इंगित करने के लिए उपयोग किया जाता है कि किसी विशेषता का उपयोग कैसे किया जा सकता है।
ObsoleteAttribute	इंगित करता है कि आइटम का उपयोग नहीं किया जाना चाहिए।
CLSCompliantAttribute	इंगित करता है कि क्या कोई आइटम सीएलएस के रूप में घोषित किया गया है।

विविध रोचक

गुण	विवरण
ThreadStaticAttribute	स्ट्रीम से संबंधित प्रकार के फ़ील्ड प्रदान करता है
ConditionalAttribute	एक संकलित स्थिति (निर्दिष्ट / परिभाषित) के आधार पर विधि के रूप में चिह्नित करता है। यदि शर्त पूरी नहीं होती है, तो विधि को नहीं बुलाया जाएगा (और आईएल में संकलित नहीं किया जाएगा)। केवल शून्य विधि को टैग किया जा सकता है। अन्यथा, एक संकलन त्रुटि उत्पन्न होगी।
DecimalConstantAttribute	मेटाडेटा में स्टोर दशमलव निरंतर मान
DefaultMemberAttribute	InvokeMember विधि के साथ डिफ़ॉल्ट रूप से उपयोग करने के लिए वर्ग के सदस्य को परिभाषित करता है।
CompilationRelaxationsAttribute	इंगित करता है कि क्या अनुदेशों की जाँच के अपवाद सख्त या शिथिल हैं। वर्तमान में, आप केवल NoStringInterning पैरामीटर पास कर सकते हैं, जो असेंबली को स्ट्रिंग शाब्दिक इंटर्निंग की आवश्यकता नहीं के रूप में चिह्नित करता है। लेकिन इस तंत्र का अभी भी उपयोग किया जा सकता है।
FlagsAttribute	यह दर्शाता है कि ईनम को झंडे के रूप में माना जाना चाहिए
IndexerNameAttribute	उस नाम को निर्दिष्ट करता है जिसके द्वारा अनुक्रमणिका को प्रोग्रामिंग भाषाओं में जाना जाएगा जो सीधे इस सुविधा का समर्थन नहीं करते हैं।
ParamArrayAttribute	इंगित करता है कि विधि मापदंडों के एक चर संख्या को स्वीकार करती है।

उपयोगी गुण

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

DebuggerDisplayAttribute इंगित करता है कि डिबगर चर विंडो में प्रकार या उसके सदस्य को कैसे प्रदर्शित किया जाता है (और न केवल)।

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

DebuggerBrowsableAttribute परिभाषित करता है कि डीबगर चर विंडो में किसी फ़ील्ड या गुण को कैसे प्रदर्शित किया जाता है। एक DebuggerBrowsableState को स्वीकार करता है, जिसमें 3 विकल्प हैं:

कभी नहीं - डिबगिंग के दौरान फ़ील्ड बिल्कुल भी प्रदर्शित नहीं होती है। वस्तुओं के पदानुक्रम का विस्तार करते समय, इस फ़ील्ड को प्रदर्शित नहीं किया जाएगा
ढह गया - क्षेत्र अनसुलझा है, लेकिन इसका विस्तार किया जा सकता है। यह डिफ़ॉल्ट व्यवहार है।
रूटहेड्ड - फ़ील्ड को स्वयं नहीं दिखाया गया है, लेकिन इसमें जिन वस्तुओं को दिखाया गया है (सरणियों और संग्रह के लिए)

DebuggerTypeProxy - यदि ऑब्जेक्ट दिन में सैकड़ों बार डिबगर में देखा जाता है, तो आप भ्रमित हो सकते हैं और 3 मिनट बिता सकते हैं एक प्रॉक्सी ऑब्जेक्ट बना सकते हैं जो मूल ऑब्जेक्ट को प्रदर्शित करता है जैसा कि इसे करना चाहिए। आमतौर पर, प्रदर्शित करने के लिए प्रॉक्सी ऑब्जेक्ट आंतरिक वर्ग है। दरअसल, इसे लक्ष्य वस्तु के बजाय प्रदर्शित किया जाएगा।

अन्य उपयोगी विशेषताएँ

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

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

इस तरह से:

संदर्भ प्रकार - हीप पर स्थित, थ्रेडस्टैटिकहैंडलटेबल, जो थ्रेडलोकब्लॉक वर्ग द्वारा समर्थित है, उनसे लिंक रखता है।
संरचनाएं - एक प्रबंधित ढेर के साथ-साथ संदर्भ प्रकारों में पैक और संग्रहीत
आदिम महत्वपूर्ण प्रकार अप्रबंधित मेमोरी के क्षेत्रों में संग्रहीत होते हैं जो थ्रेडलोकलमॉड्यूल का हिस्सा है

खैर, जब से हम इस बारे में बात कर रहे हैं, यह अतुल्यकालिक तरीकों के बारे में ध्यान देने योग्य है। जैसा कि एक चौकस पाठक देख सकता है, यदि हम अतुल्यकालिक का उपयोग करते हैं, तो निरंतरता को आवश्यक रूप से एक ही धागे में निष्पादित नहीं किया जाएगा (हम निष्पादन के संदर्भ को प्रभावित कर सकते हैं, लेकिन धागा नहीं)। तदनुसार, हमें एक बकवास मिलता है यदि हम थ्रेडलोक का उपयोग करते हैं। इस स्थिति में, यह AsyncLocal का उपयोग करने के लिए अनुशंसित है। लेकिन लेख इस बारे में नहीं है, इसलिए हम आगे बढ़ गए।

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

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

DisablePStreetReflection - प्रतिबिंब के लिए असेंबली के सभी निजी सदस्यों को अप्राप्य बनाता है। विशेषता को विधानसभा पर रखा गया है।

अपनी विशेषता को परिभाषित करना

सिर्फ इसलिए नहीं कि यह खंड अंतिम है। आखिरकार, यह समझने का सबसे अच्छा तरीका कि किन मामलों में विशेषता का उपयोग करना फायदेमंद होगा, पहले से ही उपयोग किए गए लोगों को देखना है। एक औपचारिक नियम कहना मुश्किल है जब आपको अपनी विशेषता के बारे में सोचना चाहिए। अक्सर उन्हें एक प्रकार / इसके सदस्य या किसी अन्य भाषा के निर्माण के बारे में अतिरिक्त जानकारी के रूप में उपयोग किया जाता है जो पूरी तरह से अलग-अलग संस्थाओं के लिए आम है। एक उदाहरण के रूप में, क्रमांकन / ORM / स्वरूपण आदि के लिए उपयोग की जाने वाली सभी विशेषताएँ। इन तंत्रों के पूरी तरह से अलग-अलग प्रकारों के व्यापक अनुप्रयोग के कारण, अक्सर संबंधित तंत्र के डेवलपर्स के लिए नहीं जाना जाता है, विशेषताओं का उपयोग उपयोगकर्ता को इस तंत्र के लिए घोषणात्मक जानकारी प्रदान करने में सक्षम करने का एक शानदार तरीका है।

अपनी विशेषताओं का उपयोग करके 2 भागों में विभाजित किया जा सकता है:

एक विशेषता बनाना और उसका उपयोग करना
एक विशेषता प्राप्त करना और उसे संसाधित करना

एक विशेषता बनाना और उसका उपयोग करना

अपनी विशेषता बनाने के लिए, यह System.Attribute से वारिस करने के लिए पर्याप्त है। इस मामले में, नामित नाम शैली का पालन करना उचित है - विशेषता पर वर्ग का नाम समाप्त करें। हालांकि, इस प्रत्यय को छोड़ देने पर कोई त्रुटि नहीं होगी। जैसा कि पहले उल्लेख किया गया है, विशेषताओं में 2 प्रकार के पैरामीटर हो सकते हैं - स्थिति और नाम। उनके आवेदन का तर्क वर्ग के निर्माता के गुणों और मापदंडों के साथ समान है - ऑब्जेक्ट बनाने के लिए आवश्यक मान जिसके लिए कोई उचित "डिफ़ॉल्ट" स्थिति में नहीं रखा गया है (यानी, कंस्ट्रक्टर)। क्या यथोचित रूप से डिफ़ॉल्ट हो सकता है, जो अक्सर उपयोग किया जाएगा, एक नामित व्यक्ति (यानी एक संपत्ति) में बेहतर रूप से प्रतिष्ठित है।

एक विशेषता बनाने में कोई छोटा महत्व नहीं है इसके अनुप्रयोग के स्थानों की सीमा है। इसके लिए AttributeUsageAttribute का उपयोग किया जाता है। आवश्यक पैरामीटर (स्थिति) विशेषता गुण है, जो निर्धारित करता है कि विशेषता का उपयोग कहां किया जाता है (विधि, विधानसभा, आदि)। वैकल्पिक (नामित) पैरामीटर हैं:

AllowMultiple - इंगित करता है कि क्या इसके आवेदन के स्थान पर एक से अधिक विशेषताओं को रखना संभव है या नहीं। डिफ़ॉल्ट रूप से गलत
निहित - यह निर्धारित करता है कि क्या यह विशेषता वंशजों (बेस क्लास पर प्लेसमेंट के मामले में) और ओवरराइड विधियों (विधि पर प्लेसमेंट के मामले में) से संबंधित होगी। डिफ़ॉल्ट सत्य है।

उसके बाद, आप पेलोड के साथ विशेषताओं को लोड कर सकते हैं। एक विशेषता घोषणात्मक जानकारी है, जिसका अर्थ है कि इसमें जो कुछ भी परिभाषित किया गया है वह उस निर्माण का वर्णन करना चाहिए जिससे वह संबंधित है। विशेषता में कोई गहरा तर्क नहीं होना चाहिए। आपके द्वारा परिभाषित विशेषताओं के प्रसंस्करण के लिए, विशेष सेवाओं को जिम्मेदार होना चाहिए जो उन्हें संसाधित करेंगे। लेकिन तथ्य यह है कि विशेषता में तर्क नहीं होना चाहिए इसका मतलब यह नहीं है कि इसमें विधियां नहीं होनी चाहिए।

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

एक विशेषता को पुनः प्राप्त करना और संसाधित करना

प्राप्त विशेषताओं का प्रसंस्करण विशिष्ट मामले पर निर्भर करता है और पूरी तरह से अलग-अलग तरीकों से किया जा सकता है। इसके लिए उपयोगी कार्य और चाल देना मुश्किल है।

प्रतिबिंब के उपयोग से रन टाइम पर गुण प्राप्त किए जाते हैं। एक विशिष्ट तत्व से एक विशेषता प्राप्त करने के विभिन्न तरीके हैं।

लेकिन सब कुछ ICustomAttributeProvider इंटरफ़ेस से उत्पन्न होता है । यह इस तरह के असेंबली, मेंबरइन्फो, मॉड्यूल, पैरामीटरइन्फो द्वारा कार्यान्वित किया जाता है। बदले में, सदस्यइन्फो के उत्तराधिकारी टाइप, EventInfo, FieldInfo, MethodBase, PropertyInfo हैं।

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

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

विधि का नाम	विवरण
GetCustomAttributes <LogAttribute> (बूल विरासत)	निर्दिष्ट प्रकार की विशेषताओं की गणना करता है। यदि विशेषता एक है, तो 1 तत्व का एन्यूमरेशन वापस किया जाएगा
GetCustomAttribute <LogAttribute> (बूल विरासत)	निर्दिष्ट प्रकार का एकल गुण देता है। यदि कई हैं, तो एक System.Reflection.AmbiguousMatchException को फेंक दें : एक ही प्रकार के कई कस्टम गुण अपवाद पाए गए
GetCustomAttributes ()	सभी प्रकार की विशेषताओं की गणना करता है
GetCustomAttributesData ()	एक प्रतिपूर्ति CustomAttributeData, जिसमें ऐसे गुण हैं जो आपको एक निर्माता, पैरामीटर (नाम और स्थिति), निर्माता तर्क देने की अनुमति देते हैं
अलग	यदि गुण तत्व पर घोषित किया गया है, तो सही है, यदि नहीं तो गलत है

स्पष्टता के लिए, मैं उल्लेख किए गए सभी कार्यों के काम का एक छोटा डेमो देखने का प्रस्ताव करता हूं।

उपरोक्त विधियों का मान लौटाएँ

 [AttributeUsage(AttributeTargets.All, AllowMultiple = true)] public class LogAttribute : Attribute { public string LogName { get; set; } } [AttributeUsage(AttributeTargets.All, AllowMultiple = true, Inherited = false)] public class SerializeAttribute : Attribute { public string SerializeName { get; set; } } [Log(LogName = "LogBase1")] [Log(LogName = "LogBase2")] [Serialize(SerializeName = "SerializeBase1")] [Serialize(SerializeName = "SerializeBase2")] public class RandomDomainEntityBase { [Log(LogName = "LogMethod1")] [Log(LogName = "LogMethod2")] [Serialize(SerializeName = "SerializeMethod1")] [Serialize(SerializeName = "SerializeMethod2")] public virtual void VirtualMethod() { throw new NotImplementedException(); } } [Log(LogName = "LogDerived1")] [Log(LogName = "LogDerived2")] [Serialize(SerializeName = "SerializeDerived1")] [Serialize(SerializeName = "SerializeDerived2")] public class RandomDomainEntityDerived : RandomDomainEntityBase { [Log(LogName = "LogOverride1")] [Log(LogName = "LogOverride2")] [Serialize(SerializeName = "SerializeOverride1")] [Serialize(SerializeName = "SerializeOverride2")] public override void VirtualMethod() { throw new NotImplementedException(); } } class Program { static void Main() { Type derivedType = typeof(RandomDomainEntityDerived); MemberInfo overrideMethod = derivedType.GetMethod("VirtualMethod"); // overrideMethod.GetCustomAttribute(typeof(LogAttribute)); //System.Reflection.AmbiguousMatchException: Multiple custom attributes of the same type found. // overrideMethod.GetCustomAttribute<LogAttribute>(false); // System.Reflection.AmbiguousMatchException: Multiple custom attributes of the same type found. // Attribute.GetCustomAttribute(derivedType, typeof(SerializeAttribute)); // System.Reflection.AmbiguousMatchException: Multiple custom attributes of the same type found. IEnumerable<Attribute> allCustom = overrideMethod.GetCustomAttributes(); //LogOverride1 LogOverride2 SerializeOverride1 SerializeOverride2 LogMethod1 LogMethod2 IList<CustomAttributeData> allCustomInfo = overrideMethod.GetCustomAttributesData(); //  ,     IEnumerable<LogAttribute> typedCustom1 = overrideMethod.GetCustomAttributes<LogAttribute>(inherit:false); //LogOverride1 LogOverride2 IEnumerable<LogAttribute> typedInheritedCustom1 = overrideMethod.GetCustomAttributes<LogAttribute>(inherit:true); //LogOverride1 LogOverride2 LogMethod1 LogMethod2 IEnumerable<SerializeAttribute> typedCustom2 = overrideMethod.GetCustomAttributes<SerializeAttribute>(inherit:false); //SerializeOverride1 SerializeOverride2 IEnumerable<SerializeAttribute> typedInheritedCustom2 = overrideMethod.GetCustomAttributes<SerializeAttribute>(inherit:true); //SerializeOverride1 SerializeOverride2 Attribute[] customFromStaticClass = Attribute.GetCustomAttributes(overrideMethod, typeof(SerializeAttribute), inherit:true); //SerializeOverride1 SerializeOverride2 IEnumerable<Attribute> classCustom = derivedType.GetCustomAttributes(); //LogDerived1 LogDerived2 SerializeDerived1 SerializeDerived2 LogBase1 LogBase2 IList<CustomAttributeData> classCustomInfo = derivedType.GetCustomAttributesData(); //  ,     IEnumerable<LogAttribute> typedClassCustom1 = derivedType.GetCustomAttributes<LogAttribute>(false); //LogDerived1 LogDerived2 IEnumerable<LogAttribute> typedInheritedClassCustom1 = derivedType.GetCustomAttributes<LogAttribute>(true); //LogDerived1 LogDerived2 LogBase1 LogBase2 IEnumerable<SerializeAttribute> typedClassCustom2 = derivedType.GetCustomAttributes<SerializeAttribute>(false); //SerializeDerived1 SerializeDerived2 IEnumerable<SerializeAttribute> typedInheritedClassCustom2 = derivedType.GetCustomAttributes<SerializeAttribute>(true); //SerializeDerived1 SerializeDerived2 } }

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

कोड

 public class TypeCreator { private const string TypeSignature = "DynamicType"; private const string ModuleName = "DynamicModule"; private const string AssemblyName = "DynamicModule"; private readonly TypeBuilder _typeBuilder = GetTypeBuilder(); public object CreateTypeInstance() { _typeBuilder.DefineNestedType("ClassName"); CreatePropertyWithAttribute<SerializeAttribute>("PropWithAttr", typeof(int), new Type[0], new object[0]); Type newType = _typeBuilder.CreateType(); return Activator.CreateInstance(newType); } private void CreatePropertyWithAttribute<T>(string propertyName, Type propertyType, Type[] ctorTypes, object[] ctorArgs) where T : Attribute { var attributeCtor = typeof(T).GetConstructor(ctorTypes); CustomAttributeBuilder caBuilder = new CustomAttributeBuilder(attributeCtor, ctorArgs); PropertyBuilder newProperty = CreateProperty(propertyName, propertyType); newProperty.SetCustomAttribute(caBuilder); } private PropertyBuilder CreateProperty(string propertyName, Type propertyType) { FieldBuilder fieldBuilder = _typeBuilder.DefineField(propertyName, propertyType, FieldAttributes.Private); PropertyBuilder propertyBuilder = _typeBuilder.DefineProperty(propertyName, PropertyAttributes.HasDefault, propertyType, null); MethodAttributes getSetAttr = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig; MethodBuilder getter = GenerateGetter(); MethodBuilder setter = GenerateSetter(); propertyBuilder.SetGetMethod(getter); propertyBuilder.SetSetMethod(setter); return propertyBuilder; MethodBuilder GenerateGetter() { MethodBuilder getMethodBuilder = _typeBuilder.DefineMethod($"get_{propertyName}", getSetAttr, propertyType, Type.EmptyTypes); ILGenerator getterIl = getMethodBuilder.GetILGenerator(); getterIl.Emit(OpCodes.Ldarg_0); getterIl.Emit(OpCodes.Ldfld, fieldBuilder); getterIl.Emit(OpCodes.Ret); return getMethodBuilder; } MethodBuilder GenerateSetter() { MethodBuilder setMethodBuilder = _typeBuilder.DefineMethod($"set_{propertyName}", getSetAttr, null,new [] { propertyType }); ILGenerator setterIl = setMethodBuilder.GetILGenerator(); setterIl.Emit(OpCodes.Ldarg_0); setterIl.Emit(OpCodes.Ldarg_1); setterIl.Emit(OpCodes.Stfld, fieldBuilder); setterIl.Emit(OpCodes.Ret); return setMethodBuilder; } } private static TypeBuilder GetTypeBuilder() { var assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName(AssemblyName), AssemblyBuilderAccess.Run); ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(ModuleName); TypeBuilder typeBuilder = moduleBuilder.DefineType(TypeSignature, TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.AutoClass | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit | TypeAttributes.AutoLayout,null); return typeBuilder; } } public class Program { public static void Main() { object instance = new TypeCreator().CreateTypeInstance(); IEnumerable<Attribute> attrs = instance.GetType().GetProperty("PropWithAttr").GetCustomAttributes(); // Serializable } }

C # गुण: सभी पहलुओं के बारे में