कुछ उपयोगी विशेषताओं के बारे में आप नहीं जानते होंगे

नमस्कार, मैं आपको कुछ दुर्लभ उपयोग के बारे में बताना चाहूंगा, लेकिन .NET दुनिया के बहुत उपयोगी गुण।

तो, चलिए इसके बारे में बात करते हैं:

• InternalsVisibleToAttribute
• TypeForwardedToAttribute
• CallerMemberNameAttribute
• MethodImplAttribute

InternalsVisibleToAttribute

इसकी आवश्यकता क्यों है? यह अद्भुत विशेषता कुछ मायनों में C ++ मित्र कीवर्ड के दूर के रिश्तेदार है। यह किसी भी विश्वसनीय विधानसभा को इस विधानसभा के आंतरिक प्रकार और आंतरिक प्रकार के सदस्यों तक पहुंचने की अनुमति देता है। यह एक पुरानी विशेषता है, इसे .NET 2.0 में वापस जोड़ा गया है।

यह कब काम आ सकता है? उदाहरण के लिए, आप इसका उपयोग आंतरिक प्रकारों के लिए इकाई परीक्षण लिखने के लिए कर सकते हैं। (आप डिफ़ॉल्ट रूप से सील किए गए आंतरिक के रूप में चिह्नित कक्षाएं बनाते हैं?)

उदाहरण: मान लीजिए कि आपके पास एक Domain.dll असेंबली है जिसमें आंतरिक प्रकार DefaultTimeScalingStrategy है। इसके अलावा, आपके पास Unit.Tests.dll इकाई परीक्षणों के साथ एक असेंबली है। मान लीजिए कि आप DefaultTimeScalingStrategy प्रकार के लिए इकाई परीक्षण जोड़ना चाहते हैं। फिर आपको निम्नलिखित विशेषता के साथ Domain.dll की असेंबली को चिह्नित करना होगा:

[assembly: InternalsVisibleTo("Domain.Tests")] 

नोट: यदि असेंबली Domain.Tests.dll का एक मजबूत नाम है, तो आपको न केवल असेंबली के नाम का उपयोग करना होगा, बल्कि इसकी सार्वजनिक कुंजी (टोकन भी नहीं) होगी।

TypeForwardedToAttribute

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

यह कब काम आ सकता है? मान लीजिए कि आप एक असेंबली (Crypto.dll v1.0.0.0) विकसित कर रहे हैं जो कि मांग में है। मेरा मानना ​​है कि कभी-कभी आप अतीत में किए गए अपने फैसलों पर पुनर्विचार करते हैं। उदाहरण के लिए, क्या आप एक प्रकार (BlumBlumShub) को एक अलग असेंबली (PRNG.dll) में स्थानांतरित करने की योजना बना रहे हैं।
आपके पास दो तरीके हैं:

1. बस असेंबली का नया संस्करण (Crypto.dll v1.1.0.0) जारी करें, जो अब नई विधानसभा (PRNG.dll) को संदर्भित करता है। लेकिन तब आपके उपयोगकर्ताओं को इस प्रकार (BlumBlumShub) का उपयोग करने वाले अपने अनुप्रयोगों के भाग को फिर से स्थापित करना होगा, क्योंकि यह स्थानांतरित हो गया था और CLR का कोई पता नहीं है कि अब इसे कहां देखना है।
2. असेंबली का नया संस्करण (Crypto.dll v1.1.0.0) जारी करें, जो अब नई असेंबली (PRNG.dll) को संदर्भित करता है, और टाइप के नए स्थान के बारे में TypeForwardedToAttribute विशेषता का उपयोग करके CLR को एक संकेत देता है।

उदाहरण: मान लीजिए कि आपके पास एक असेंबली (Crypto.dll) है, जिसमें से आप टाइप (BlumBlumShub) को दूसरी असेंबली (PRNG.dll) में स्थानांतरित करना चाहते हैं। फिर आपके लिए क्रिप्टो की विधानसभा को चिह्नित करना पर्याप्त होगा:

 [assembly: TypeForwardedTo(typeof(BlumBlumShub))] 

और, वास्तव में, प्रकार को स्थानांतरित करें।

टिप्पणी:

1. हमारे नायक में एक विरोधी है - TypeForwardedFromAttribute ।
2. विषय का उपयोग करने का वास्तविक उदाहरण .NET 4.0 है: एक्शन <,> टाइप इसका शिकार हो गया।
3. दिलचस्प है, TypeForwardedFromAttribute एक नियमित कस्टम विशेषता नहीं है, यह एक छद्म कस्टम विशेषता है। छद्म विशेषताओं के बारे में अधिक जानकारी यहाँ मिल सकती है ।
4. विषय के काम का अधिक विस्तृत उदाहरण यहां पाया जा सकता है ।

CallerMemberNameAttribute

इसकी आवश्यकता क्यों है? आओ आपको उस विधि का नाम मिलता है जिसे आपका कोड कहा जाता है।

यह कब काम आ सकता है? विशेषता दो मामलों में उपयोगी हो सकती है:

1. कोड अनुरेखण और डिबगिंग
2. INotifyPropertyChanged इंटरफ़ेस को कार्यान्वित करना

उदाहरण: निम्नलिखित सरल कोड का उपयोग करके, आप INOTifyPropertyChanged इंटरफ़ेस को लागू करते समय अपने आप को जादू के तार से बचा सकते हैं, जो कि रिफैक्टिंग के दौरान रक्त को बहुत खराब कर देता है।
जैसा कि पहले था:

  internal sealed class Star : INotifyPropertyChanged { private int _luminosity; public int Luminosity { get { return _luminosity; } set { if (value != _luminosity) { _luminosity = value; OnPropertyChanged("Luminosity"); } } } private void OnPropertyChanged(string propertyName) { var handler = PropertyChanged; if (handler != null) { handler(this, new PropertyChangedEventArgs(propertyName)); } } } 

जैसा कि अभी है:

 internal sealed class Star : INotifyPropertyChanged { private int _luminosity; public int Luminosity { get { return _luminosity; } set { if (value != _luminosity) { _luminosity = value; OnPropertyChanged(); } } } private void OnPropertyChanged([CallerMemberName]string propertyName = null) { var handler = PropertyChanged; if (handler != null) { handler(this, new PropertyChangedEventArgs(propertyName)); } } public event PropertyChangedEventHandler PropertyChanged; } 

OnPropertyChanged विधि की परिभाषा और आह्वान पर ध्यान दें ।

टिप्पणी:

1. विषय की एक खामी है: यह केवल .NET 4.5 में दिखाई दिया। ऐसा लगता है कि इसका उपयोग .NET 4.0 (विशिष्ट पैच स्थापित करते समय) में किया जा सकता है, लेकिन निश्चित रूप से पहले के संस्करणों में नहीं।
2. इस विशेषता के दो भाई भी हैं: CallerFilePathAttribute और CallerLineNumberAttribute । मुझे उम्मीद है कि उनके नाम अपने लिए बोलते हैं।

MethodImplAttribute

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

• AggressiveInlining
• ForwardRef
• InternalCall
• NoInlining
• NoOptimization
• PreserveSig
• सिंक्रनाइज़
• अप्रबंधित

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

 public void Foo() { // Do something } 

संकलक इस कोड की तरह कुछ उत्पन्न करेगा:

 public void Foo() { lock(this) { // Do something } } 

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

एक उदाहरण:

  public static class MathUtility { [MethodImplAttribute(MethodImplOptions.AggressiveInlining)] public static int GetFibonacciNumber(int n) { return (int)((Math.Pow((1 + Math.Sqrt(5))/2, n) - Math.Pow((1 - Math.Sqrt(5))/2, n))/Math.Sqrt(5)); } } 

नोट: MethodImplAttribute विशेषता, TypeForwardedToAttribute की तरह , एक छद्म विशेषता है। इसके अलावा, यह पता लगाने के लिए कि क्या यह विधि के लिए लागू किया गया था या नहीं, एक विशेष एपीआई है, अर्थात् GetMethodImplementationFlags MethodInfo वर्ग की विधि।

यही सब मैं बताना चाहता था।
यदि आपके कोई प्रश्न हैं, तो मुझे अपनी क्षमता और ज्ञान का सबसे अच्छा जवाब देने में खुशी होगी।