LINQ to XML API का उपयोग करके XML का निर्माण करना

हाल तक तक, मैं वास्तव में XML फ़ाइलों के साथ काम करना पसंद नहीं करता था, मैंने जहाँ भी संभव हो, इससे बचने की कोशिश की, बस उन्हें मानक फ़ाइल कॉन्फ़िगरेशन फ़ाइलों के साथ प्रतिस्थापित किया। लेकिन जहां डेटा एक्सचेंज का इस्तेमाल करना जरूरी था, वहां एक्सएमएल से कोई बच नहीं पाया। मुझे थोड़ी सी जानकारी को परिवर्तित करने या पढ़ने के लिए बड़ी मात्रा में कोड बनाना पड़ा। हां, वह XML दस्तावेज़ ऑब्जेक्ट मॉडल (DOM) API है।

XML DOM API उदाहरण

आपको निम्न संदेश प्राप्त करना होगा:

< Groups >

< Group Id ="523063B0-47C0-4ABE-8D38-4A449137A00B" DepartmentId ="D939743F-BFF7-41E4-9A1B-1193EEFF0486" >

< Name > 555A </ Name >

< Course > 5 </ Course >

</ Group >

</ Groups >

ऐसा करने के लिए, आपको एक बहुत ही सरल, लेकिन स्वैच्छिक कोड लिखना होगा:

private sealed class Nodes

{

public const string Root = "Groups" ;



// Attributes.

public const string Group = "Group" ;

public const string Id = "Id" ;

public const string DepartmentId = "DepartmentId" ;



// Elements.

public const string Name = "Name" ;

public const string Course = "Course" ;

}



// Create XML document.

XmlDocument document = new XmlDocument ();



// Create root element.

XmlElement rootElement = document.CreateElement( Nodes .Root);



// Create Group element.

XmlElement groupElement = document.CreateElement( Nodes .Group);



// Create attributes.

XmlAttribute idAttribute = document.CreateAttribute( Nodes .Id);

idAttribute.InnerText = "523063B0-47C0-4ABE-8D38-4A449137A00B" ;

groupElement.Attributes.Append(idAttribute);



XmlAttribute departmentIdAttribute = document.CreateAttribute( Nodes .DepartmentId);

departmentIdAttribute.InnerText = "D939743F-BFF7-41E4-9A1B-1193EEFF0486" ;

groupElement.Attributes.Append(departmentIdAttribute);



// Create elements.

XmlElement nameElement = document.CreateElement( Nodes .Name);

nameElement.InnerText = "555A" ;

groupElement.AppendChild(nameElement);



XmlElement courseElement = document.CreateElement( Nodes .Course);

courseElement.InnerText = "5" ;

groupElement.AppendChild(courseElement);



rootElement.AppendChild(groupElement);

document.AppendChild(rootElement);

मेरे साथ सहमत हूं कि इस तरह के कोड को लिखना, डिसाइड करना और बनाए रखना बहुत सुखद नहीं है।



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



सौभाग्य से, माइक्रोसॉफ्ट ने हमें न केवल XML प्रश्नों के लिए एकीकृत LINQ निष्पादित करने की क्षमता प्रदान की, बल्कि XML DOM API को फिर से डिज़ाइन किया।

मैं आज आपको इसके बारे में और बताना चाहता हूं। ऐसा करने के लिए, आपको निम्नलिखित नामस्थान कनेक्ट करने की आवश्यकता है:

using System.Collections.Generic;

using System.Linq;

using System.Xml.Linq;

जैसा कि मैंने कहा, मानक DOM मॉडल की कमियों में से एक परिणामी XML फ़ाइल की संरचना को पढ़ना मुश्किल था। LINQ to XML API इस समस्या को हल करता है एक नई तकनीक जिसे कार्यात्मक निर्माण कहा जाता है। कार्यात्मक डिजाइन आपको एक्सएमएल वस्तुओं का निर्माण करने और उनके मूल्यों को शुरू करने की अनुमति देता है - एक साथ, एक ही बयान में, कई अतिभारित निर्माणकर्ताओं के कारण।



आइए देखें कि XML फ़ाइल का निर्माण जो हम पहले से जानते हैं, वह LINQ से XML API का उपयोग करने जैसा लगेगा:

XElement document = new XElement ( Nodes .Root,

new XElement ( Nodes .Group,

new XAttribute ( Nodes .Id, "523063B0-47C0-4ABE-8D38-4A449137A00B" ),

new XAttribute ( Nodes .DepartmentId, "D939743F-BFF7-41E4-9A1B-1193EEFF0486" ),

new XElement ( Nodes .Name, "555A" ),

new XElement ( Nodes .Course, 5)));

वैसे कैसे? आपके लिए कौन सा कोड पढ़ना आसान है? उत्तर स्पष्ट है।

ऑब्जेक्ट मॉडल

XObject , XNode , और XContainer कक्षाएं सार हैं, इसलिए हम उन्हें नहीं बना सकते।

XAttribute वर्ग - XNode से विरासत में नहीं मिला, अर्थात एक नोड नहीं है, यह एक साधारण संग्रह आइटम है जो एक कुंजी-मूल्य जोड़ी का प्रतिनिधित्व करता है।

XDocument और XElement क्लासेस एकमात्र हैं जिनमें XNode से विरासत में प्राप्त नोड्स हो सकते हैं।

XDocument

LINQ to XML API में, XML ट्री या उसका टुकड़ा बनाने के लिए XDocument बनाना आवश्यक नहीं है।

XDocument document = new XDocument ();

Console .WriteLine(document.ToString());

हमें एक खाली परिणाम मिलता है।



XDocument में कुछ भी उपयोगी नहीं है, दस्तावेज़ में केवल एक विज्ञापन ( XDeclaration ), प्रकार निर्माण ( XDocumentType ) या प्रसंस्करण निर्देश ( XProcessingInstruction ) जोड़ने की क्षमता है।



इसमें सभी प्रकार के अधिभार विकल्पों के साथ दस्तावेजों की सामग्री को पढ़ने के लिए स्थिर तरीके हैं:

public static XDocument Load( Stream stream);

public static XDocument Load( string uri);

public static XDocument Load( TextReader textReader);

public static XDocument Load( XmlReader reader);

public static XDocument Load( Stream stream, LoadOptions options);

public static XDocument Load( string uri, LoadOptions options);

public static XDocument Load( TextReader textReader, LoadOptions options);

public static XDocument Load( XmlReader reader, LoadOptions options);

और दस्तावेज़ को बचाने के लिए भी:

public void Save( Stream stream);

public void Save( string fileName);

public void Save( TextWriter textWriter);

public void Save( XmlWriter writer);

public void Save( Stream stream, SaveOptions options);

public void Save( string fileName, SaveOptions options);

public void Save( TextWriter textWriter, SaveOptions options);

तत्व ( XElement ) में समान विधियां हैं।



मैं XDocument का उपयोग केवल तभी करता हूं जब मुझे एक दस्तावेज़ के लिए एक विज्ञापन सेट करने की आवश्यकता होती है जिसमें एक संस्करण संख्या और एक एन्कोडिंग होता है।

XDeclaration

XDeclaration ऑब्जेक्ट्स, आपने अनुमान लगाया है, इसमें घोषणाएँ शामिल हैं और दस्तावेज़ में जोड़े जाते हैं, हालांकि कंपाइलर आपको किसी तत्व ( XElement ) में घोषणाएँ जोड़ने की अनुमति देता है, लेकिन यह कोई दृश्य परिणाम नहीं देगा।

XDocument document = new XDocument (

new XDeclaration ( "1.0" , "UTF-8" , "yes" ));

Console .WriteLine(document.ToString());

यह कोड भी किसी भी लाइन को प्रदर्शित नहीं करेगा, हालांकि यदि आप डिबगर को देखते हैं, तो घोषणा अभी भी जोड़ी गई है:







यदि आप XDocument वर्ग के सहेजें () विधि का उपयोग करते हैं तो घोषणा दिखाई देगी।

XElement

सबसे अधिक इस्तेमाल की जाने वाली एपीआई वस्तु।

इसके कई डिज़ाइनर हैं, उनमें से दो पर विचार करें:

public XElement ( XName name, object content);

public XElement ( XName name, params object [] content);

पहला कंस्ट्रक्टर सबसे सरल मामला है जब किसी तत्व की कोई संतान नहीं होती है और हम केवल उसका मूल्य निर्धारित करते हैं, दूसरा कंस्ट्रक्टर - बच्चों के साथ, जैसे तत्व, गुण, प्रसंस्करण निर्देश, टिप्पणियां ( XComment ), आदि।



सरलतम तत्व बनाएं:

XElement element = new XElement ( "Element" , 777);

Console .WriteLine(element.ToString());

Console .WriteLine(( int )element);

परिणाम:

< Element > 777 </ Element >

777

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

आप पूछते हैं, निर्माता को एक्सनेम की आवश्यकता है, और मैं इसे एक स्ट्रिंग पास करता हूं? और मैं आपको उत्तर दूंगा: स्ट्रिंग को स्पष्ट रूप से एक्सनाम ऑब्जेक्ट पर डाल दिया गया है। वास्तव में, XName एक स्ट्रिंग है, केवल एक नेमस्पेस ( XNamespace ) निर्दिष्ट करने की क्षमता के साथ।



मैं वस्तुओं से XML बनाने का अधिक विस्तृत उदाहरण दूंगा:

public sealed class Teacher

{

public Guid Id;

public string FirstName;

public string LastName;

}



IEnumerable < Teacher > teachers = new []

{

new Teacher () { Id = Guid .NewGuid(), FirstName = "" , LastName = "" },

new Teacher () { Id = Guid .NewGuid(), FirstName = "" , LastName = "" }

};



XElement elements = new XElement ( "Teachers" ,

teachers.Select(t => new XElement ( "Teacher" ,

new XAttribute ( "Id" , t.Id),

new XElement ( "FirstName" , t.FirstName),

new XElement ( "LastName" , t.LastName))));



Console .WriteLine(elements.ToString());

परिणामस्वरूप, हमारे पास:

< Teachers >

< Teacher Id ="80321d66-ee4b-4b55-ace8-3892b682d483" >

< FirstName > </ FirstName >

< LastName > </ LastName >

</ Teacher >

< Teacher Id ="33f58b19-1bbb-468f-acee-961edb63ce0b" >

< FirstName > </ FirstName >

< LastName > </ LastName >

</ Teacher >

</ Teachers >

XAttribute

जैसा कि मैंने पहले कहा था, तत्व विशेषताओं के संग्रह के लिए एक कुंजी-मूल्य जोड़ी है। किसी तत्व को विशेषताएँ बनाना और जोड़ना एक बहुत ही सरल कार्य है:

XAttribute attribute = new XAttribute ( "Id" , Guid .NewGuid());

XElement element = new XElement ( "Teachers" );

element.Add(attribute);

Console .WriteLine(element.ToString());

या तो:

XElement element = new XElement ( "Teachers" ,

new XAttribute ( "Id" , Guid .NewGuid()));

Console .WriteLine(element.ToString());

परिणाम समान है:

< Teachers Id ="713c6cbf-f698-42fd-b5fc-74415b93d824" />

XComment

टिप्पणी बनाने और जोड़ने से भी कोई कठिनाई नहीं होती है:

XElement teacherElement = new XElement ( "Teacher" ,

new XComment ( "Teacher element" ));

Console .WriteLine(teacherElement.ToString());

परिणाम:

< Teacher >

<!--Teacher element-->

</ Teacher >

निष्कर्ष

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



अगले लेख में, मैं एक XML दस्तावेज़ की सामग्री के माध्यम से एक मार्ग पर विचार करने की योजना बना रहा हूं।