डायनामिकएक्सएमएल: एक्सएमएल डेटा के साथ काम करने के लिए एक "गतिशील" शेल

मैंने पहले ही एक बार लिखा था कि स्थिर टाइपिंग के मेरे प्यार के बावजूद, कुछ परिदृश्यों में डायनामिक टाइपिंग के फायदे इससे जुड़े नुकसान से अधिक हो सकते हैं। पिछली बार हमने डायनामिक LINQ के बारे में बात की थी, और इस बार हम नए C # 4.0 फीचर का उपयोग करने के बारे में बात करेंगे, जिसे XML के रूप में ऐसे कमजोर टाइप डेटा के साथ काम करने के लिए डायनामिक कहा गया है।

नोट
इस आलेख में चर्चा की गई डायनेमिकएक्सएमएल लाइब्रेरी के लिए स्रोत कोड जीथब पर उपलब्ध है

परिचय

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


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

XML डेटा पढ़ने का एक सरल उदाहरण

तो, मान लेते हैं कि हमारे पास एक पंक्ति है जिसमें निम्नलिखित डेटा (***) हैं:

< books >
< book >
< title > Mortal Engines </ title >
< author name ="" Philip Reeve "" />
</ book >
< book >
< title > The Talisman </ title >
< author name ="" Stephen King "" />
< author name ="" Peter Straub "" />
</ book >
</ books >

* This source code was highlighted with Source Code Highlighter .

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

अगर हम यह मान लें कि उपरोक्त लाइन पुस्तकों नामक एक चर में समाहित है, तो आप कुछ सरल शब्दों को प्राप्त करने के लिए एक बहुत ही सरल कोड का उपयोग कर सकते हैं:

var element = XElement .Parse(books);
string firstBooksTitle =
element.Element( "book" ).Element( "title" ).Value;
Assert.That(firstBooksTitle, Is.EqualTo( "Mortal Engines" ));

string firstBooksAuthor =
element.Element( "book" ).Element( "author" ). Attribute ( "name" ).Value;
Assert.That(firstBooksAuthor, Is.EqualTo( "Philip Reeve" ));

string secondBooksTitle =
element.Elements().ElementAt(1).Element( "title" ).Value;
Assert.That(secondBooksTitle, Is.EqualTo( "The Talisman" ));

* This source code was highlighted with Source Code Highlighter .

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

// Dynamic Wrapper XElement
dynamic dynamicElement = // ...

//
string firstBooksTitle = dynamicElement.book.title;
Assert.That(firstBooksTitle, Is.EqualTo( "Mortal Engines" ));

// , ,
string firstBooksAuthor = dynamicElement.book.author[ "name" ];
Assert.That(firstBooksAuthor, Is.EqualTo( "Philip Reeve" ));

// , ,
string secondBooksTitle = dynamicElement.book[1].title;
Assert.That(secondBooksTitle, Is.EqualTo( "The Talisman" ));

* This source code was highlighted with Source Code Highlighter .

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

XML डेटा पढ़ने के लिए "डायनेमिक" आवरण बनाना

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

इस प्रकार, हमें बस इतना करने की आवश्यकता है कि डायनेमिकऑब्जेक्ट से एक इनहेरिटेरेटर बनाया जाए , जो एक एक्साइमेंट ऑब्जेक्ट को एक कंस्ट्रक्टर पैरामीटर के रूप में ले और कई सहायक विधियों को ओवरराइड करे:

/// <summary>
/// " " XElement
/// </summary>
public class DynamicXElementReader : DynamicObject
{
private readonly XElement element;

private DynamicXElementReader( XElement element)
{
this .element = element;
}

public static dynamic CreateInstance( XElement element)
{
Contract.Requires(element != null );
Contract.Ensures(Contract.Result< object >() != null );

return new DynamicXElementReader(element);
}
}

* This source code was highlighted with Source Code Highlighter .

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

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

public class DynamicXElementReader : DynamicObject
{
/// <summary>
/// true, .
/// </summary>
/// <remarks>
/// Pure
/// </remarks>
[Pure]
public bool HasParent()
{
return element.Parent != null ;
}

public dynamic this [XName name]
{
get
{
Contract.Requires(name != null );

XAttribute attribute = element. Attribute (name);

if (attribute == null )
throw new InvalidOperationException(
"Attribute not found. Name: " + name.LocalName);

return attribute.AsDynamic();
}
}

public dynamic this [ int idx]
{
get
{

Contract.Requires(idx >= 0, "Index should be greater or equals to 0" );
Contract.Requires(idx == 0 || HasParent(),
"For non-zero index we should have parent element" );

//
if (idx == 0)
return this ;

// "" .
// ,
var parent = element.Parent;
Contract.Assume(parent != null );

XElement subElement = parent.Elements().ElementAt(idx);

// subElement null, ElementAt
// , .
// ,
// Contract.Assume
Contract.Assume(subElement != null );

return CreateInstance(subElement);
}
}

public XElement XElement { get { return element; } }

}

* This source code was highlighted with Source Code Highlighter .

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

अब दो मुख्य कार्यान्वयन के लिए चलते हैं (इस वर्ग के लिए) डायनामिकऑब्जेक्ट क्लास के वर्चुअल तरीके: ट्राइगेटमम्बर विधि - जो डायनेमिकऑब्जेक्ट के एक संपत्ति या क्षेत्र तक पहुँचने के लिए ज़िम्मेदार है। प्रकार, साथ ही ट्राइकोवर्थ विधि - जिसे कहा जाता है जब टाइप को डायनामिक टाइप किए गए ऑब्जेक्ट से सांख्यिकीय रूप से परिवर्तित किया जाता है। टाइप, स्ट्रिंग मान = डायनामिकऑब्जेक्ट ।

public class DynamicXElementReader : DynamicObject
{
// not used
private XElement element;
public static dynamic CreateInstance( XElement ) { return null ;}

/// <summary>
/// :
/// SomeType variable = dynamicElement;
/// </summary>
public override sealed bool TryConvert(ConvertBinder binder, out object result)
{
// XElement
// xml-
if (binder.ReturnType == typeof ( XElement ))
{
result = element;
return true ;
}

//
//
string underlyingValue = element.Value;
result = Convert .ChangeType(underlyingValue, binder.ReturnType,
CultureInfo.InvariantCulture);

return true ;
}

/// <summary>
///
/// </summary>
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
string binderName = binder.Name;
Contract.Assume(binderName != null );

// ,
//
XElement subelement = element.Element(binderName);
if (subelement != null )
{
result = CreateInstance(subelement);
return true ;
}

// ,
//
return base .TryGetMember(binder, out result);
}

}

* This source code was highlighted with Source Code Highlighter .

जैसा कि ऊपर उल्लेख किया गया है, TryConvert विधि को तब कहा जाता है जब किसी भी प्रकार को xml तत्व या उसके किसी उपशीर्ष को निर्दिष्ट प्रकार में बदलने का प्रयास किया जाता है। चूँकि हम आसानी से वर्तमान xml तत्व का मान प्राप्त कर सकते हैं, इस पद्धति को लागू करने के लिए सभी को Convert वर्ग के ChangeType को कॉल करना है; एकमात्र अपवाद XElement प्रकार है, जिसे अलग से संसाधित किया जाता है और आपको सीधे अंतर्निहित XElement प्राप्त करने की अनुमति मिलती है।

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

यह सब आपको निम्नानुसार शेल का उपयोग करने की अनुमति देता है:

// bookXElement
string firstBooksElement = dynamicElement.book;
Console .WriteLine( "First books element: {0}" , firstBooksElement);

//
string firstBooksTitle = dynamicElement.book.title;
Console .WriteLine( "First books title: {0}" , firstBooksTitle);

// int
int firstBooksPageCount = dynamicElement.book.pages;
Console .WriteLine( "First books page count: {0}" , firstBooksPageCount);

* This source code was highlighted with Source Code Highlighter .

इस कोड को निष्पादित करने का परिणाम:

First books element: < book >
< title > Mortal Engines </ title >
< author name ="Philip Reeve" />
< pages > 347 </ pages >
</ book >

First books title: Mortal Engines
First books page count: 347
First books author: Philip Reeve
Second books title: The Talisman

* This source code was highlighted with Source Code Highlighter .

XML डेटा बनाने / संशोधित करने के लिए "गतिशील" शेल बनाना

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

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

XML डेटा बनाने / संशोधित करने के उद्देश्य से डायनेमिक शेल में मुख्य अंतर दो इंडेक्सर्स के लिए सेटर्स की उपस्थिति है: एक विशेषता मान को बदलने के लिए, और दूसरा अतिरिक्त तत्वों को जोड़ने के लिए। दूसरा अंतर दो अतिरिक्त गैर-गतिशील तरीकों की उपस्थिति है: SetValue और SetAttributeValue , जिनका उपयोग वर्तमान तत्व और उसके गुणों के मूल्य को बदलने के लिए किया जाता है।

public class DynamicXElementWriter : DynamicObject
{
// ,

/// <summary>
///
/// </summary>
public void SetValue( object value )
{
Contract.Requires( value != null );

element.SetValue( value );
}

/// <summary>
///
/// </summary>
public void SetAttributeValue(XName name, object value )
{
Contract.Requires(name != null );
Contract.Requires( value != null );

element.SetAttributeValue(name, value );
}

/// <summary>
///
/// </summary>
public dynamic this [XName name]
{
get
{
//
}

set
{
//
// XElement.SetAttributeValue,
element.SetAttributeValue(name, value );
}

}

/// <summary>
/// ""
/// </summary>
public dynamic this [ int idx]
{
get
{
//
Contract.Requires(idx >= 0, "Index should be greater or equals to 0" );
Contract.Requires(idx == 0 || HasParent(),
"For non-zero index we should have parent element" );

//
if (idx == 0)
return this ;

// "" .
// ,
var parent = element.Parent;
Contract.Assume(parent != null );

// "" ,
//
XElement subElement = parent.Elements(element.Name).ElementAtOrDefault(idx);
if (subElement == null )
{
XElement sibling = parent.Elements(element.Name).First();
subElement = new XElement (sibling.Name);
parent.Add(subElement);
}

return CreateInstance(subElement);
}

set
{
Contract.Requires(idx >= 0, "Index should be greater or equals to 0" );
Contract.Requires(idx == 0 || HasParent(),
"For non-zero index we should have parent element" );

//
// ,
//
dynamic d = this [idx];
d.SetValue( value );
return ;
}

}
}

* This source code was highlighted with Source Code Highlighter .

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

एक अन्य महत्वपूर्ण अंतर ट्राइगेट मेम्बर विधि का कार्यान्वयन है, साथ ही एक अतिरिक्त ट्राइसेमेम्बर विधि की उपस्थिति है, जिसे तब कहा जाएगा जब तत्व का xml मान सेट किया गया है: dynamElement.SubElement = value ।

/// <summary>
///
/// </summary>
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
string binderName = binder.Name;
Contract.Assume(binderName != null );

//
XElement subelement = element.Element(binderName);

// ,
//
if (subelement == null )
{
subelement = new XElement (binderName);
element.Add(subelement);
}

result = CreateInstance(subelement);
return true ;
}

/// <summary>
///
/// </summary>
public override bool TrySetMember(SetMemberBinder binder, object value )
{
Contract.Assume(binder != null );
Contract.Assume(! string .IsNullOrEmpty(binder.Name));
Contract.Assume( value != null );

string binderName = binder.Name;

// ,
// , ;
// XElement.SetElementValue,
//
if (binderName == element.Name)
element.SetValue( value );
else
element.SetElementValue(binderName, value );
return true ;
}

* This source code was highlighted with Source Code Highlighter .

TryGetValue विधि के कार्यान्वयन के बीच मुख्य अंतर यह है कि मूल xml पेड़ में नहीं होने वाले एक उप तत्व को एक्सेस करते समय, अपवाद फेंकने के बजाय निर्दिष्ट नाम के साथ एक तत्व जोड़ा जाएगा। TrySetMember पद्धति का कार्यान्वयन भी इस तथ्य के कारण बहुत जटिल नहीं है कि XElement.SetElementValue विधि हमारे लिए सभी गंदे काम करती है, जो यदि आवश्यक हो तो वांछित नाम के साथ एक तत्व जोड़ देगा।

निष्कर्ष

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

एक बार फिर, डायनेमिकएक्सएमएल लाइब्रेरी का सोर्स कोड यहां उपलब्ध है ।

- (*) सबसे दिलचस्प बात यह है कि DLR - डायनेमिक लैंग्वेज रनटाइम का रनटाइम से कोई लेना-देना नहीं है, लेकिन सिर्फ एक "रेगुलर" लाइब्रेरी है जो अभिव्यक्ति के पेड़ों को चालाकी से काटती है।

(**) इस संभावना को दिखाने वाले कई उदाहरण हैं, उदाहरण के लिए, यहाँ और यहाँ ।

(***) यह थोड़ा संशोधित उदाहरण है कि जॉन स्कीट ने अपनी पुस्तक "सी # इन डेप्थ", 2 डी संस्करण में एक उदाहरण में उपयोग किया है।