PostSharp। विलंबित निर्भरता लोड हो रहा है

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


तो, आप इस कोड में कितनी बार आए:

private IProductRepository _productRepository;
private IProductRepository ProductRepository
{
get
{
if (_productRepository == null )
{
_productRepository = new ProductRepository();
}
return _productRepository;
}
}

* This source code was highlighted with Source Code Highlighter .

जबकि संपत्ति IPropertyRepository का प्रकार है, इस संपत्ति का गेट्टर अभी भी ProductReptyitory के प्रकार से बंधा हुआ है। यदि आपको "नया ProductRepository (") "new RevisedProductRepository ()" या "New ProductRepository (2011)" "बदलने की आवश्यकता है, तो आपको बॉयलरप्लेट कोड के सभी स्थानों से गुजरना होगा और इसे अपडेट करना होगा। बेशक, हाथ तुरंत पता लगाने के लिए पहुंचेंगे-> बदलें, कॉपी-> पेस्ट ... हालांकि, यह स्थिति आप सभी से परिचित है, है ना? सबसे पहले, आप प्रतिस्थापन पर बहुत समय बिताएंगे, और दूसरी बात, आपकी टीम के लगभग हर सदस्य को इससे निपटना होगा (जब आपको नियमित प्रतिस्थापन करना होगा)। और, चूंकि सभी पहले से ही आईओसी कंटेनरों का सक्रिय रूप से उपयोग कर रहे हैं, आप सोच सकते हैं कि यह उदाहरण अतिरंजित है। हालांकि, मेरा विश्वास करो, ऐसे उदाहरण बहुत आम हैं! वैसे भी, IoC कंटेनर का उपयोग करने पर, हमें निम्नलिखित कोड मिलता है:

private IProductRepository _productRepository;
private IProductRepository ProductRepository
{
get
{
if (_productRepository == null )
{
_productRepository = ObjectFactory.GetInstance<IProductRepository>();
}
return _productRepository;
}
}

* This source code was highlighted with Source Code Highlighter .

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

[LoadDependency] private IProductRepository _productRepository;

[ Serializable ]
public sealed class LoadDependencyAttribute : LocationInterceptionAspect
{
public override void OnGetValue(LocationInterceptionArgs args)
{
args.ProceedGetValue(); // fetches the field and populates the args.Value
if (args.Value == null )
{
var locationType = args.Location.LocationType;
var instantiation = ObjectFactory.GetInstance(locationType);

if (instantiation != null )
{
args.SetNewValue(instantiation);
}
args.ProceedGetValue();
}
}
}

* This source code was highlighted with Source Code Highlighter .

अब हमारे पास निर्भरता का उपयोग करने के लिए एक घोषणात्मक दृष्टिकोण है। आप केवल "लोडडिपेंडेंसी" विशेषता के साथ किसी भी क्षेत्र को चिह्नित करते हैं, और यह पहली कॉल के दौरान IoC कंटेनर द्वारा आरंभीकृत किया जाएगा (पहली पंक्ति देखें)। इस प्रकार, आपने प्रत्येक संपत्ति के लिए लगातार बायलरप्लेट कोड लिखने से खुद को सुरक्षित रखा है जो आलसी-लोडिंग, नल चेक, थ्रेड-सेफ्टी, और अन्य बदलाव जो आपको करने होंगे, आप प्रत्येक संपत्ति को अलग से लिखते हैं। अब आपके सभी कार्य एक ही कक्षा में होंगे।
एक बहुत ही सरल और छोटे (केवल 19 लाइनों) पहलू का उपयोग करते हुए, हम परिणामस्वरूप कोड को 12 लाइनों से एक तक संपीड़ित करते हैं। हमने बहुत सारे निरर्थक दोहराए गए कोड ( DRY ) को हटा दिया और हार्ड इंटरफेस ( DIP ) के साथ कठिन निर्भरता को बदल दिया। हम आलसी-लोडिंग को अपनी कक्षा में रखते हैं, और हमारे ( एसआरपी ) में निर्भरता को हल करते हैं। इस प्रकार, निर्भरता की संख्या को कम करने के लिए न्यूनतम।
यह बहुत ही सरल उदाहरण वास्तव में मेरे दिन-प्रतिदिन के विकास में बहुत मदद करता है और इसे बहुत आसान बनाता है।
अब, मान लेते हैं कि संकलन के चरण में सभी निर्भरताएँ ज्ञात हैं। यह भी मान लें कि आवेदन चलने के दौरान निर्भरताएं नहीं बदलेंगी। इस मामले में, हमें अब सेवा लोकेटर की आवश्यकता नहीं है। हम संकलन समय पर निर्भरता को हल करने और कुछ क्षेत्र में प्रकार को सहेजने के लिए LocationInterceptionAspect से CompileTimeInitialize विधि को ओवरराइड कर सकते हैं। तब, जब अनुप्रयोग चल रहा है, तो आप इच्छित ऑब्जेक्ट बनाने के लिए Activator.CreateInstance का उपयोग कर सकते हैं।

[ Serializable ]
public sealed class LoadDependencyAttribute : LocationInterceptionAspect
{
private Type _type;

public override bool CompileTimeValidate(PostSharp.Reflection.LocationInfo locationInfo)
{
_type = DependencyMap.GetConcreteType(locationInfo.LocationType);
if (_type == null )
{
Message.Write(SeverityType.Error, "002" ,
"A concrete type was not found for {0}.{1}" ,
locationInfo.DeclaringType, locationInfo.Name);
return false ;
}
return true ;
}

public override void OnGetValue(LocationInterceptionArgs args)
{
args.ProceedGetValue();
if (args.Value == null )
{
form.LogListBox.Items.Add( "Instantiating UserService" );
args.SetNewValue(Activator.CreateInstance(_type));
args.ProceedGetValue();
}
}
}

* This source code was highlighted with Source Code Highlighter .

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

public override bool CompileTimeValidate(PostSharp.Reflection.LocationInfo locationInfo)
{
if (!locationInfo.LocationType.IsInterface)
{
Message.Write(SeverityType.Error, "001" ,
"LoadDependency can only be used on Interfaces in {0}.{1}" ,
locationInfo.DeclaringType, locationInfo.Name);
return false ;
}

_type = DependencyMap.GetConcreteType(locationInfo.LocationType);
if (_type == null )
{
Message.Write(SeverityType.Error, "002" ,
"A concrete type was not found for {0}.{1}" ,
locationInfo.DeclaringType, locationInfo.Name);
return false ;
}
return true ;
}

* This source code was highlighted with Source Code Highlighter .

संकलन त्रुटियों को प्राप्त करने के लिए, किसी भी प्रकार के फ़ील्ड के लिए "लोडडिपेंडेंसी" विशेषता सेट करें, लेकिन इंटरफ़ेस नहीं:



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

अन्य अनुवाद और लिंक:

• आधिकारिक वेबसाइट
• PostSharp। लॉगिंग और ऑडिट कार्य
• हम कैशिंग समस्या का समाधान करते हैं
• इंटेल ब्लॉग्स: पोस्टशार्प। भाग 1
• इंटेल ब्लॉग्स: पोस्टशार्प। विकल्प
• पहलू उन्मुख प्रोग्रामिंग बनाम निर्भरता इंजेक्शन