LINQ to XML in Depth (1) Modeling XML

Saturday, August 10, 2019

[LINQ via C# series]

[LINQ to XML in Depth series]

XML (eXtensible Markup Language) is widely used to represent, store, and transfer data. .NET Standard provides LINQ to XML APIs to query XML data source. LINQ to XML APIs are located in System.Xml.XDocument NuGet package for .NET Core, and System.Xml.Linq.dll assembly for .NET Framework. LINQ to XML can be viewed as specialized LINQ to Objects, where the queried objects represent XML structures.

Modeling XML

.NET Standard provides a set provides types to represent the XML structures, including XML document, namespace, element, attribute, comment, text, etc., so that XML can be loaded to memory as instances of those types, and then be queried with LINQ as objects.

Imperative paradigm vs. declarative paradigm

The XML DOM APIs are provided since .NET Framework 1.0. There a set of Xml* types in System.Xml namespace representing XML structures. The following list shows their inheritance hierarchy:

· XmlNamedNodeMap

o XmlAttributeCollection

· XmlNode

o XmlAttribute

o XmlDocument

o XmlDocumentFragment

o XmlEntity

o XmlLinkedNode

§ XmlCharacterData

§ XmlCDataSection

§ XmlComment

§ XmlSignificantWhitespace

§ XmlText

§ XmlWhitespace

§ XmlDeclaration

§ XmlDocumentType

§ XmlElement

§ XmlEntityReference

§ XmlProcessingInstruction

o XmlNotation

· XmlNodeList

· XmlQualifiedName

These DOM APIs for XML can be used to model and manipulate XML structures in imperative paradigm. Take the following XML fragment as example:

<item>

This is a tutorial of LINQ and functional programming. Hope it helps.

</description>

<guid isPermaLink="true">https://weblogs.asp.net/dixin/linq-via-csharp</guid>

<dixin:source>https://github.com/Dixin/CodeSnippets/tree/master/Dixin/Linq</dixin:source>

</item>

</channel>

</rss>

It is a small RSS feed sample with one single item. The following example calls XML DOM APIs to build such a XML tree, and serialize the XML tree to string:

internal static void CreateAndSerializeWithDom()

{

XmlNamespaceManager namespaceManager = new XmlNamespaceManager(new NameTable());

const string NamespacePrefix = "dixin";

namespaceManager.AddNamespace(NamespacePrefix, "https://weblogs.asp.net/dixin");

XmlDocument document = new XmlDocument(namespaceManager.NameTable);

XmlElement rss = document.CreateElement("rss");

rss.SetAttribute("version", "2.0");

XmlAttribute attribute = document.CreateAttribute(

"xmlns", NamespacePrefix, namespaceManager.LookupNamespace("xmlns"));

attribute.Value = namespaceManager.LookupNamespace(NamespacePrefix);

rss.SetAttributeNode(attribute);

document.AppendChild(rss);

XmlElement channel = document.CreateElement("channel");

rss.AppendChild(channel);

XmlElement item = document.CreateElement("item");

channel.AppendChild(item);

XmlElement title = document.CreateElement("title");

title.InnerText = "LINQ via C#";

item.AppendChild(title);

XmlElement link = document.CreateElement("link");

link.InnerText = "https://weblogs.asp.net/dixin/linq-via-csharp";

item.AppendChild(link);

XmlElement description = document.CreateElement("description");

description.InnerXml = "This is a tutorial of LINQ and functional programming. Hope it helps.";

item.AppendChild(description);

XmlElement pubDate = document.CreateElement("pubDate");

pubDate.InnerText = new DateTime(2009, 9, 7).ToString("r");

item.AppendChild(pubDate);

XmlElement guid = document.CreateElement("guid");

guid.InnerText = "https://weblogs.asp.net/dixin/linq-via-csharp";

guid.SetAttribute("isPermaLink", "true");

item.AppendChild(guid);

XmlElement category1 = document.CreateElement("category");

category1.InnerText = "C#";

item.AppendChild(category1);

XmlNode category2 = category1.CloneNode(false);

category2.InnerText = "LINQ";

item.AppendChild(category2);

XmlComment comment = document.CreateComment("Comment.");

item.AppendChild(comment);

XmlElement source = document.CreateElement(NamespacePrefix, "source", namespaceManager.LookupNamespace(NamespacePrefix));

source.InnerText = "https://github.com/Dixin/CodeSnippets/tree/master/Dixin/Linq";

item.AppendChild(source);

// Serialize XmlDocument to string.

// rssItem.ToString() outputs "System.Xml.XmlElement".

// rssItem.OuterXml outputs a single line of XML text.

StringBuilder xmlString = new StringBuilder();

XmlWriterSettings settings = new XmlWriterSettings

{

Indent = true,

IndentChars = " ",

OmitXmlDeclaration = true

};

using (XmlWriter writer = XmlWriter.Create(xmlString, settings))

{

document.Save(writer);

}

xmlString.WriteLine();

}

These APIs have a few disadvantages:

· Any XML structure has to be created with a XmlDocument instance.

· XML tree has to be built imperatively, node by node.

· Additional work is needed to manage namespaces and prefixes.

· Some operations, like serialization, is not straightforward.

Fortunately, LINQ to XML does not work with these Xml* types. It redesigns a bunch of X* types under System.Xml.Linq namespace, and enables LINQ queries for these objects. The following list shows the inheritance hierarchy of all the X* types, as well as each type’s conversion from/to other types, and their overloaded operators:

· XDeclaration

· XName: implicit convertible from string, ==, !=

· XNamespace: implicit convertible from string, + string, ==, !=

· XObject

o XAttribute: explicit convertible to string/bool/bool?/int/int?/uint/uint?/long/long?/ulong/ulong?/float/float?/double/double?/decimal/decimal?/DateTime/DateTime?/TimeSpan/TimeSpan?/Guid/Guid?

o XNode: DeepEquals

§ XComment

§ XContainer

§ XDocument

§ XElement: explicit convertible to string/bool/bool?/int/int?/uint/uint?/long/long?/ulong/ulong?/float/float?/double/double?/decimal/decimal?/DateTime/DateTime?/TimeSpan/TimeSpan?/Guid/Guid?

§ XDocumentType

§ XProcessingInstruction

§ XText

§ XCData

· XStreamingElement

As the names suggest, e.g., XNode represents a XML node, XDocument represents a XML document, XName represents XML element name or XML attribute name, etc. And apparently, An XML element/attribute name is essentially a string, so XName implements implicit conversion from string, which provides great convenience. The following example builds the same XML tree with the new LINQ to XML types:

internal static void CreateAndSerializeWithLinq()

{

XNamespace @namespace = "https://weblogs.asp.net/dixin";

XElement rss = new XElement(

"rss",

new XAttribute("version", "2.0"),

new XAttribute(XNamespace.Xmlns + "dixin", @namespace),

new XElement(

"channel",

new XElement(

"item", // Implicitly converted to XName.

new XElement("title", "LINQ via C#"),

new XElement("link", "https://weblogs.asp.net/dixin/linq-via-csharp"),

new XElement(

"description",

XElement.Parse("This is a tutorial of LINQ and functional programming. Hope it helps.")),

new XElement("pubDate", new DateTime(2009, 9, 7).ToString("r")),

new XElement(

"guid",

new XAttribute("isPermaLink", "true"), // "isPermaLink" is implicitly converted to XName.

"https://weblogs.asp.net/dixin/linq-via-csharp"),

new XElement("category", "C#"),

new XElement("category", "LINQ"),

new XComment("Comment."),

new XElement(

@namespace + "source",

"https://github.com/Dixin/CodeSnippets/tree/master/Dixin/Linq"))));

rss.ToString().WriteLine(); // Serialize XDocument to string.

}

The new APIs is shorter and more intuitive:

· XML structure can be created on the fly, XDocument is not involved in the entire example.

· XML tree can be built declaratively.

· Easier namespace management, with prefix automatically taken care of.

· To serialize an XML tree, simply call ToString.

Types, conversions and operators

Besides XDocument, XElement, XAttribute, and XComment in above example, some other XML structures can also can declaratively constructed too:

internal static void Construction()

{

XDeclaration declaration = new XDeclaration("1.0", null, "no");

declaration.WriteLine(); // <?xml version="1.0" standalone="no"?>

XDocumentType documentType = new XDocumentType("html", null, null, null);

documentType.WriteLine(); // <!DOCTYPE html>

XText text = new XText("text");

text.WriteLine(); // & lt;p>text

XCData cData = new XCData("cdata");

cData.WriteLine(); // <![CDATA[cdata]]>

XProcessingInstruction processingInstruction = new XProcessingInstruction(

"xml-stylesheet", @"type=""text/xsl"" href=""Style.xsl""");

processingInstruction.WriteLine(); //< ?xml-stylesheet type="text/xsl" href="Style.xsl"?>

}

XName is different. LINQ to XML provides 2 equivalent ways to instantiate XName:

· calling XName.Get

· implicitly converting from string (which is implemented with XName.Get as well).

The constructor is not exposed, because LINQ to XML caches all the constructed XName instances at runtime, so a XName instance is constructed only once for a specific name. LINQ to XML also implements the == and != operator by checking the reference equality:

internal static void Name()

{

XName attributeName1 = "isPermaLink"; // Implicitly convert string to XName.

XName attributeName2 = XName.Get("isPermaLink");

XName attributeName3 = "IsPermaLink";

object.ReferenceEquals(attributeName1, attributeName2).WriteLine(); // True

(attributeName1 == attributeName2).WriteLine(); // True

(attributeName1 != attributeName3).WriteLine(); // True

}

XNamespace has the same behaviour as XName. additionally, it implements the + operator to combine the namespace and local name:

internal static void Namespace()

{

XNamespace namespace1 = "http://www.w3.org/XML/1998/namespace"; // Implicitly convert string to XNamespace.

XNamespace namespace2 = XNamespace.Xml;

XNamespace namespace3 = XNamespace.Get("http://www.w3.org/2000/xmlns/");

(namespace1 == namespace2).WriteLine(); // True

(namespace1 != namespace3).WriteLine(); // True

XNamespace @namespace = "https://weblogs.asp.net/dixin";

XName name = @namespace + "localName"; // + operator.

name.WriteLine(); // {https://weblogs.asp.net/dixin}localName

XElement element = new XElement(name, new XAttribute(XNamespace.Xmlns + "dixin", @namespace)); // + operator.

element.WriteLine(); // <dixin:localName xmlns:dixin="https://weblogs.asp.net/dixin" />

}

XElement can be explicitly converted to .NET primitive types, e.g.:

internal static void Element()

{

XElement pubDateElement = XElement.Parse("<pubDate>Mon, 07 Sep 2009 00:00:00 GMT</pubDate>");

DateTime pubDate = (DateTime)pubDateElement;

pubDate.WriteLine(); // 9/7/2009 12:00:00 AM

}

The above conversion is implemented by calling DateTime.Parse with the string value returned by XElement.Value.

XAttribute can be converted to primitive types too:

internal static void Attribute()

{

XName name = "isPermaLink";

XAttribute isPermanentLinkAttribute = new XAttribute(name, "true");

bool isPermaLink = (bool)isPermanentLinkAttribute;

isPermanentLink.WriteLine() // True

}

Here the conversion is implemented by calling System.Xml.XmlConvert’s ToBoolean method with the string value returned by XElement.Value.

XComment, XDocument, XElement, XDocumentType, XProcessingInstruction, XText, and XCData types inherit XNode. XNode provides a DeepEquals method to compare any 2 nodes:

internal static void DeepEquals()

{

XElement element1 = XElement.Parse("<parent><child></child></parent>");

XElement element2 = new XElement("parent", new XElement("child")); // < parent><child /></parent>

object.ReferenceEquals(element1, element2).WriteLine(); // False

XNode.DeepEquals(element1, element2).WriteLine(); // True

XElement element3 = new XElement("parent", new XElement("child", string.Empty)); // < parent><child></child></parent>

object.ReferenceEquals(element1, element2).WriteLine(); // False

XNode.DeepEquals(element1, element3).WriteLine(); // False

}

Here element2’s child element is constructed with null content, so it is an empty element node <child /> (where XElement.IsEmpty returns true). element3’s child element is constructed with an empty string as content, so it is a non-empty element< child></child> ((where XElement.IsEmpty returns false). As a result, element1 has the same node structures and node values as element2, and they are different from element3.

Read and deserialize XML

In LINQ to XML, XML can be easily read or deserialized to XNode/XElement/XDocument instances in memory. with the following APIs:

· XmlReader (under System.Xml namespace)

· XNode.CreateReader, XNode.ReadFrom

· XDocument.Load, XDocument.Parse

· XElement.Load, XElement.Parse

The APIs accepting URI, for example:

internal static void Read()

{

using (XmlReader reader = XmlReader.Create("https://weblogs.asp.net/dixin/rss"))

{

reader.MoveToContent();

XNode node = XNode.ReadFrom(reader);

}

XElement element1 = XElement.Parse("<html><head></head><body></body></html>");

XElement element2 = XElement.Load("https://weblogs.asp.net/dixin/rss");

XDocument document1 = XDocument.Parse("<html><head></head><body></body></html>");

XDocument document2 = XDocument.Load("https://microsoft.com"); // Succeed.

XDocument document3 = XDocument.Load("https://asp.net"); // Fail.

// System.Xml.XmlException: The 'ul' start tag on line 68 position 116 does not match the end tag of 'div'. Line 154, position 109.

}

Reading an RSS feed to construct an XML tree usually work smoothly, since RSS is just XML. Reading a web page usually has bigger chance to fail, because in the real world, a HTML document may be not strictly structured.

The above example reads entire XML document and deserialize the string to XML tree in the memory. Regarding the specified XML can have arbitrary size, XmlReader and XNode.ReadFrom can also read XML fragment by fragment:

internal static IEnumerable<XElement> RssItems(string rssUri)

{

using (XmlReader reader = XmlReader.Create(rssUri))

{

reader.MoveToContent();

while (reader.Read())

{

if (reader.NodeType == XmlNodeType.Element && reader.Name.Equals("item", StringComparison.Ordinal))

{

yield return (XElement)XNode.ReadFrom(reader);

}

As discussed in the LINQ to Objects chapter, function with yield return statement is compiled to generator construction, and all the API calls in above function body is deferred, so each <item> in the RSS feed is read and deserialized on demand.

Serialize and write XML

The following APIs are provided to serialize XML to string, or write XML to somewhere (file system, memory, etc.):

· XmlWriter

· XObject.ToString

· XNode.ToString, XNode.WriteTo

· XContainer.CreateWriter

· XDocument.Save

· XElement.Save

· XStramingElement.Save, XStramingElement.ToString, XStreamingElement.WriteTo

For example:

internal static void Write()

{

XDocument document1 = XDocument.Load("https://weblogs.asp.net/dixin/rss");

using (FileStream stream = File.OpenWrite(Path.GetTempFileName()))

{

document1.Save(stream);

}

XElement element1 = new XElement("element", string.Empty);

XDocument document2 = new XDocument();

using (XmlWriter writer = document2.CreateWriter())

{

element1.WriteTo(writer);

}

document2.WriteLine(); //< element></element>

XElement element2 = new XElement("element", string.Empty);

using (XmlWriter writer = element2.CreateWriter())

{

writer.WriteStartElement("child");

writer.WriteAttributeString("attribute", "value");

writer.WriteString("text");

writer.WriteEndElement();

}

element2.ToString(SaveOptions.DisableFormatting).WriteLine();

// <element><child attribute="value">text</child></element>

}

XNode also provides a ToString overload to accept a SaveOptions flag:

internal static void XNodeToString()

{

XDocument document = XDocument.Parse(

"<root xmlns:prefix='namespace'><element xmlns:prefix='namespace' /></root>");

document.ToString(SaveOptions.None).WriteLine(); // Equivalent to document.ToString().

// <root xmlns:prefix="namespace">

// <element xmlns:prefix="namespace" />

// </root>

document.ToString(SaveOptions.DisableFormatting).WriteLine();

// <root xmlns:prefix="namespace"><element xmlns:prefix="namespace" /></root>

document.ToString(SaveOptions.OmitDuplicateNamespaces).WriteLine();

// <root xmlns:prefix="namespace">

// <element />

// </root>

}

To serialize XML with even more custom settings, the XmlWriter with XmlWriterSettings approach in the DOM API example can be used.

Deferred construction

The XStreamingElement is a special type. It is used to defer the build of element. For example:

internal static void StreamingElementWithChildElements()

{

IEnumerable<XElement> ChildElementsFactory() =>

Enumerable

.Range(0, 5).Do(value => value.WriteLine())

.Select(value => new XElement("child", value));

XElement immediateParent = new XElement("parent", ChildElementsFactory()); // 0 1 2 3 4.

immediateParent.ToString(SaveOptions.DisableFormatting).WriteLine();

// < parent><child>0</child><child>1</child><child>2</child><child>3</child><child>4</child></parent>

XStreamingElement deferredParent = new XStreamingElement("parent", ChildElementsFactory()); // Deferred.

deferredParent.ToString(SaveOptions.DisableFormatting).WriteLine();

// 0 1 2 3 4

// < parent><child>0</child><child>1</child><child>2</child><child>3</child><child>4</child></parent>

}

Here a factory function is defined to generate a sequence of child elements. It calls the Do query from Interactive Extension (Ix) to prints each value when that pulled from the sequence. Next, the XElement constructor is called, which immediately pulls all child elements from the sequence returned by the factory function, so that the parent element is immediately built with those child elements. Therefore, the Do query is executed right away, and prints the values of the generated child elements. In contrast, XStreamingElement constructor does not pull the child elements from the sequence, the values are not printed yet by Do. The pulling is deferred until the parent element needs to be built, for example, when XStreamingElement.Save/XStreamingElement.ToString/XStreamingElement.WriteTo is called.

This feature can also be demonstrated by modifying the child elements. For XElement, once constructed, the element is built immediately, and is not impacted by modifying the original child elements. In contrast, XStreamingElement can be impacted by the modification:

internal static void StreamingElementWithChildElementModification()

{

XElement source = new XElement("source", new XElement("child", "a"));

XElement child = source.Elements().Single();

XElement immediateParent = new XElement("parent", child);

XStreamingElement deferredParent = new XStreamingElement("parent", child); // Deferred.

child.Value = "b";

immediateParent.ToString(SaveOptions.DisableFormatting).WriteLine(); // < parent><child>a</child></parent>

deferredParent.ToString(SaveOptions.DisableFormatting).WriteLine(); // < parent><child>b</child></parent>

}

This is a really great work that demonstrates each and every possible LINQ expression operation on the complex looking XML markup with proper methodologies.Reading, writing, altering and removing xml elements is very clear and concise. Great article

Adeel Ahmed - Sunday, April 17, 2016 3:23:59 AM

Amazon.com/mytv - enter the 6 digit amazon mytv code you receive at screen at www.amazon.com/mytv to regiter your device. contact amazon support for hel

www.amazon.com/mytv - Monday, October 26, 2020 10:20:54 PM

This article is really fantastic and thanks for sharing the valuable post.

Lost Love Back By Vashikaran Baba Ji - Monday, June 28, 2021 5:31:24 AM

Great article with excellent idea! I have bookmarked your site since this site contains important data in it.

Black magic for girlfriend-boyfriend - Monday, June 28, 2021 6:27:31 AM

awesome post. I’m a normal visitor of your web site and appreciate you taking the time to maintain the nice site. I’ll be a frequent visitor for a long time.

Husband Wife Dispute Problem Solution - Monday, June 28, 2021 8:06:56 AM

This post is really astounding one! I was delighted to read this, very much useful. Many thanks

Online Islamic Wazifa for Love - Monday, June 28, 2021 8:31:25 AM

Thanks for sharing.I found a lot of interesting information here. A really good post, very thankful and hopeful that you will write many more

Get My Love Back In India - Monday, June 28, 2021 8:39:44 AM

Great Article it its really informative and innovative keep us posted with new updates. its was really valuable.

love problem solution - Monday, June 28, 2021 9:18:01 AM

Thanks for writing such a good article, I stumbled onto your blog and read a few post. I like your style of writing...

Online Love Solution - Monday, June 28, 2021 10:11:25 AM

Really nice style and perfectly written content material in this. Material on this page is very efficient I’ve ever had. We do not need anything else. Thank you so much for the information.

Career Problem Solution - Monday, June 28, 2021 10:40:52 AM

Great Post !! Very interesting topic will bookmark your site to check if you write more about in the future.

Astrology consultancy services in India - Monday, June 28, 2021 11:01:18 AM

Very interesting topic will bookmark your site to check if you Post more about in the future.

Astrology consultancy services in India - Monday, June 28, 2021 11:27:13 AM

https://ma-study.blogspot.com/

medicalphd - Monday, December 13, 2021 11:35:44 AM

Call of Duty Vanguard Ultimate Edition

Call of Duty game series or Call of Duty, which has long been one of the most popular, popular and also the best action and shooter style games narrated during the war. Also, in recent years, in some versions of this game, an attempt has been made to portray the modern war mode, thus bringing a different experience from the Call of Duty game series for those who are interested in this game and dear players. Now, with the release of the latest version of this game called Call of Duty: Vanguard, an attempt has been made to portray a story of World War II for gamers.
Prepare games from Jet Game site

https://jetgames.ir - Saturday, June 18, 2022 10:20:12 AM

I've been troubled for several days with this topic. Keonhacai But by chance looking at your post solved my problem! I will leave my blog, so when would you like to visit it?

Keonhacai - Friday, August 12, 2022 9:11:40 PM

This is one of the top content I have seen thanks for sharing this amazing work that demonstrates each and every possible. I really like this content and also like assessment experts for the great content that they give to the students.

gcse assignment service - Wednesday, November 9, 2022 10:05:34 PM

First of all, thank you for your post. casinosite Your posts are neatly organized with the information I want, so there are plenty of resources to reference. I bookmark this site and will find your posts frequently in the future. Thanks again ^^

casinosite - Saturday, January 7, 2023 7:53:30 PM

Custom Assignment is a leading provider of high-quality academic writing services to students across the globe. We have been in business for several years, and our team of experienced writers and editors have helped thousands of students achieve academic success.

custom assignment - Monday, March 20, 2023 3:32:31 AM

Hello ! I am the one who writes posts on these topics <a href="https://images.google.com.lb/url?sa=t&url=https%3A%2F%2Fwww.mtclean.blog/">baccaratsite</a> I would like to write an article based on your article. When can I ask for a review?

baccaratsite - Wednesday, November 22, 2023 2:17:58 AM

I was looking for another article by chance and found your article <a href="https://images.google.com.kw/url?sa=t&url=https%3A%2F%2Fwww.mtclean.blog/">slotsite</a> I am writing on this topic, so I think it will help a lot. I leave my blog address below. Please visit once.

slotsite - Wednesday, November 22, 2023 2:18:23 AM

I came to this site with the introduction of a friend around me and I was very impressed when I found your writing. I'll come back often after bookmarking! <a href="https://images.google.com.kh/url?sa=t&url=https%3A%2F%2Fwww.mtclean.blog/">baccaratcommunity</a>

baccaratcommunity - Wednesday, November 22, 2023 2:18:56 AM

It's the same topic , but I was quite surprised to see the opinions I didn't think of. My blog also has articles on these topics, so I look forward to your visit. <a href="https://images.google.com.jm/url?sa=t&url=https%3A%2F%2Fwww.mtclean.blog/">casinocommunity</a>

casinocommunity - Wednesday, November 22, 2023 2:19:33 AM

modeling XML using LINQ to XML in .NET provides a powerful way to manipulate XML data. You can create, read, update, and delete XML elements using LINQ to XML. Let's dive into how you can model XML using LINQ to XML.

connections nyt - Tuesday, January 2, 2024 6:43:48 AM

If you have no time Use Assignment Help Services for assistance. Writing Equity Law assignments is difficult, and mostly people find it exhausting.

Marketing Assignment Help - Tuesday, March 12, 2024 6:21:20 AM

You are really talented and smart in writing articles. Everything about you is very good to me.

sexy baccarat - Sunday, June 2, 2024 7:41:19 PM

Awesome, what article is this? I am enchanted by your article.

ลิงค์รับทรัพย์ dream gaming - Tuesday, June 4, 2024 9:02:06 PM

This is a very nice blog that I will definitely come back to more times this year! Thanks for the informative post.

ซื้อหวยผ่านคลิปโต - Wednesday, June 12, 2024 12:18:46 AM

You are my breathing in, I own few blogs and very sporadically run out from to post.

ฟิล์ม SELF-HEALING - Thursday, June 13, 2024 10:53:07 PM

today is my holiday And I happened to come across your article. It's really good. I'll come and read it again next time.

ดาวน์โหลด bet game tv - Sunday, June 16, 2024 8:52:55 PM

The blend of theoretical knowledge, practical examples, and detailed comparisons makes it an excellent learning tool.

1v1 lol - Wednesday, June 19, 2024 12:02:31 AM

Your answers on the official website will be kept totally

ติดต่อสอบหวยบี - Wednesday, June 19, 2024 9:02:32 AM

is an online retailer that offers a diverse collection of leather jackets for men and women. Their selection includes various styles, from classic to contemporary, crafted from premium materials like sheepskin and lambskin. The website features exclusive collections, seasonal sales, and ensures quality and comfort in every piece. Washington Jackets focuses on providing fashionable, high-quality outerwear that meets the needs of their customers.

Washington Jackets - Thursday, July 4, 2024 11:48:55 PM

Your article is completely new to me. It gives me the ability to extend my life.

ติดต่อ ag gaming - Thursday, August 29, 2024 5:26:15 PM

Regular income from subscriptions can help stabilize finances, especially for startups or companies with variable income sources.

Memebettoken news - Thursday, October 31, 2024 1:40:19 PM

Dixin's Blog

LINQ to XML in Depth (1) Modeling XML

[LINQ via C# series]

[LINQ to XML in Depth series]

Modeling XML

Imperative paradigm vs. declarative paradigm

Types, conversions and operators

Read and deserialize XML

Serialize and write XML

Deferred construction

34 Comments