LINQ Tutorial

We can create XML without using LINQ to XML by directly using the XmlDocument and the related classes.
When we create XML using this approach we are manipulating the XML document.It is also not very easy to understand the XML manipulation logic.We can not tell by just looking at the code the XML tree being created.

For example for creating the following XML tree

<Employees>
   <Employee>
     <EmpNumber>1</EmpNumber>
     <Name>Mike</Name>
    </Employee>
</Employees>

we use the following logic

XmlDocument doc = new XmlDocument();
XmlElement employees = doc.CreateElement("Employees");
XmlElement employee = doc.CreateElement("Employee");

XmlElement name = doc.CreateElement("Name");
name.InnerText = "Mike";
XmlElement empNumber = doc.CreateElement("empNumber");
empNumber.InnerText = "1";

employee.AppendChild(employee);

employees.AppendChild(empNumber);
employees.AppendChild(name);
doc.AppendChild(employees);

Though it creates the above XML tree correctly but just by looking at the above code we can not relate it to the XML tree.

By using LINQ to XML we can create the same XML tree in a single statement.Following LINQ to XML statement will create the same XML tree as above:

 XElement xmlDoc = new XElement("Employees", new XElement("Employee", new XElement("Name", "Mike"), new XElement("EmpNumber", "1")));

This is possible because of the functional construction provided by LINQ to XML.

To understand how we can create XML in a single statement its important to understand the XElement class.XElement defines several overloaded constructors which simplifies creation of XML trees.

Constructor	Use	Example
public XElement(XName name)	Creates XElement object having a specific name	XElement el = new XElement(“Employee”);
public XElement(XName name,object content)	Creates XElement object with a specific name and content	Using text content: mainElement = new XElement(“Employees”, “Employee Text”); using XElement: mainElement = new XElement(“Employees”,new XElement(“Employee”, “First Employee”));
public XElement(XName name,params object[] content)	Creates XElement object with a specific name and a group of content	new XElement(“Employees”, new XElement(“Employee1”), new XElement(“Employee2”), new XElement(“Employee3”), new XElement(“Employee4”));

If we look at the above code marked in bold then we can see that one of the overloaded constructors of XElement expects content as the second argument.We can pass either text content or another XElement object here.It is by passing objects of XElement that we are able to create XML tree using the functional construction.

 

 

 

Follow on:

The classes required for the LINQ to XML functionality are part of the System.Xml.Linq namespace.So if we want to implement LINQ to XML then we need to use the classes defined
in the System.Xml.Linq namespace.

Some of the important classes required to create an XML document are:

• XElement It represents an element in the XML.
• XDocument Represents XML document
• XAtrribute It represents an attribute of an element

Generating XML using XDocument

As XDocument class represents an XML document so we can create an object of this class if need to create XML document.This object represents an in-memory XML document on which we can perform queries.

XDocument xmlDoc = new XDocument(new XElement("root",
new XElement("element1", "content1"),
new XElement("element2", "content2")
)
);

XDocument defines several overloaded constructors.One of the constructors accepts an array of objects.We pass a object of XElement which defines the root and nested elements.The above XDocuments object represents the following XML.

<root>
<element1>content1</element1>
<element2>content2</element2>
</root>

We can use Console.WriteLine(xmlDoc) to write it to the console.

Generating XML using XElement

XElement is one of the important classes when we need to create XML using LINQ to XML.It provides constructors which we can use to create a hieracrchy of elements.

Creating a single root element having string content

XElement xmltree = new XElement("Root", "root");

Creating a root element containing a single child element

XElement xmlDoc = new XElement("Root", new XElement("Employee","employee1"));

Creating a root element having child elements which further have child elements

XElement xmlDoc = new XElement("Employees",  new XElement("employee", new XElement("name", "ashish")),  new XElement("employee", new XElement("name", "amit"))

The above code generates the following markup

<Employees>
<employee>
<name>ashish</name>
</employee>
<employee>
<name>amit</name>
</employee>
</Employees>

The constructor of XElement is overloaded.One of the constructors is defined as:

 XElement(XName name,params object[] content)

In the second parameter we can pass another XElement object.This allows us to create a hierarchy of nested elements.

Follow on:

LINQ to XML provides an efficient and better option for working with XML documents.We work with in-memory XML using LINQ queries.LINQ to XML provides us the familiar Linq programming model in our programming language we are comfortable with such C#.This is more convenient than using the XPath queries in many scenarios.

We can query as well as modify the XML  using LINQ to XML.

Using LINQ to XML

To start using LINQ to XML we use the Load() method of XElement class.Using this method populates the XElement instance with the XML document.

As XElement  class is defined in the System.Xml.Linq namespace so we need to import this namespace.

For example the following will load the XElement with the contents of the XML file  Students.xml.

XElement xelement = XElement.Load("..\\..\\Students.xml");

Students.xml file is defined as:

<?xml version="1.0" encoding="utf-8" ?>
<Students>
 <Student>
 <RollNo>1</RollNo>
 <Name>Mark</Name> 
 <Sex>Male</Sex>
 <Address>
 <Street>Street1</Street>
 <City>City1</City>
 <State>CA</State>
 <Zip>95220</Zip>
 <Country>USA</Country>
 </Address>
 </Student>
 <Student>
 <RollNo>2</RollNo>
 <Name>Robin</Name>
 <Sex>Female</Sex>
 <Address>
 <Street>Street1</Street>
 <City>City2</City>
 <State>CA</State>
 <Zip>95221</Zip>
 <Country>USA</Country>
 </Address>
 </Student>
 <Student>
 <RollNo>3</RollNo>
 <Name>Jenyy</Name>
 <Sex>Female</Sex>
 <Address>
 <Street>Street1</Street>
 <City>City2</City>
 <State>CA</State>
 <Zip>96121</Zip>
 <Country>USA</Country>
 </Address>
 </Student>
</Students>

To access all the elements contained by the root Student element we use the following

IEnumerable<XElement> students = xelement.Elements();

The above will populate students with all the elements defined in the XML file.

We can iterate through all the elements using a foreach loop as:

foreach (var student in students)
{
Console.WriteLine(student);
}

Fetching XML values using LINQ to XML

Accessing a specific element

We can also access a particular element in the XML by using the Element() method of the XElement object.To access the Address element we use the following

student.Element("Address")

Following will print all the  Address elements

foreach (var student in students)
{
Console.WriteLine(student.Element("Address"));
}

Selecting Elements having specific value

To filter elements having a specific value we use the Element() method of XElement instance and pass the element name.Finally we access the Value property to filter the elements.Following will return a student having RollNo 1.

var filteredRollNos = from student in students
where student.Element("RollNo").Value == "1"
select student;
foreach (var item in filteredRollNos)
{
Console.WriteLine(item);
}

Selecting attributes

If there are attributes defined in a element we can retrieve their values using the Attribute() method of the XElement class.

For example if we have student elements defined as:

<Student>
<RollNo>1</RollNo>
<Name>Mark</Name> 
<Sex>Male</Sex>
<Marks subject="English">85</Marks>
<Marks subject="Maths">70</Marks>
<Address>
<Street>Street1</Street>
<City>City1</City>
<State>CA</State>
<Zip>95220</Zip>
<Country>USA</Country>
</Address>
</Student>

then we can retrieve the name and marks of students as:

var studentMarks = from student in students
where student.Element("Marks").Attribute("subject").Value == "English"
select
new
{
Name= student.Element("Name").Value,
Marks= student.Element("Marks").Value
};

By using the student.Element(“Marks”).Attribute(“subject”)  ,we are able to fetch the Marks element having attribute value as “English”

Follow on:

When working with collections sometimes we need to perform certain operations only for some of the elements in a collection and skip the rest of the elements.Skip operator is used in such cases.

Skip operator in LINQ skips n number of elements in a collection of elements.It returns the remaining elements after skipping the n  elements in a collection

It is used as:

Collection.Skip(n)

where Collection is an object of type IEnumerable<T>

n can be any integer value

The following example will return all the elements except the first element which is 1.

List<int> numbers = new List<int> {1,2,3,4,5,6,7,8};
var result = numbers.Skip(1);

The Skip() operator is useful when used together with the OrderBy() operator.The elements in a collection can be ordered either ascendingly or descendingly and then the topmost or lowermost elements can be returned by using the Skip() operator.

In the following example we have a list of students.Each student has a name and marks which he has scored.
We can use the Skip() operator along with the OrderBy() operator to return the top 3 students based on his or her score.

List<Student> students = new List<Student> {
new Student{Name="Robin",Marks=88}
,new Student{ Name="John",Marks=56 }
,new Student{ Name="Tom",Marks= 66}
,new Student{ Name="Janet",Marks= 76}
,new Student{ Name="Punit",Marks= 77}
};
var studentSelected = students.OrderBy(x=>x.Marks).Skip(3);

SkipWhile

SkipWhile operator skips the elements in a collection until a certain condition returns true.Once the condition returns false the remaining elements are returned.
If we want to find the students scoring more than 60 marks we can use the SkipWhile operator as:

var studentSelected = students.OrderBy(x=>x.Marks).SkipWhile(x=> x.Marks < 60);

Skip and SkipWhile skips the elements depending on the ordinal or a condition.But once an element is returned by these operator the remaining elements are also returned.So for example if we remove the OrberBy operator then once a student is found having more than 60 marks then the remaining students are also returned irrespective of the marks scored.

var studentSelected = students.SkipWhile(x=> x.Marks < 60);

This will return all the elements since Robin is at the beginning of the list and he is having more than 60 marks.

Follow on:

Aggregate functions are applied to each element in a sequence and finally returns a single aggregated value.For example sum() function is applied to the first,second element to calculate their sum.This sum is then added to the third element to calculate the sum of first three elements.Finally the total sum of all the elements is calculated and returned.

Some of the aggregate operators are:

• Sum
• Count
• Average
• Min
• Max

Sum    Sum operator is applied to the values in a sequence and calculates a single value which is the sum of all the values in a collection.
In the following example we have a collection of students.Each element in the collection is represented by an object of Student class.

class Student
{
public String Name { get; set; }
public int TotalMarks { get; set; }
//other properties
}

The students are added in the collection:

List<Student> lstStudents = new List<Student>
{
new Student{Name="Marc",TotalMarks=774},
new Student{Name="John",TotalMarks=789},
new Student{Name="Amit",TotalMarks=888},
};

The sum of the scores of all the students can be calculated by using the sum function as:

lstStudents.Sum(x => x.TotalMarks);

We can write the above Sum() operator as:

int sum = lstStudents.Select(x => x.TotalMarks).Sum();

Note that we have passed the lambda expression to the Select() operator instead of Max().We can use the similar method overloads for each of the aggregate operators.

Max      Many times when working with numeric values we need to find the maximum value from a collection of values.Max operator can be used in such a scenario to find the maximum value from a collection of values.Continuing with the example of collection of students ,the student having maximum score can be found as:

int max = lstStudents.Max(x => x.TotalMarks);

Above Max() function can also be written as:

int max= lstStudents.Select(x=>x.TotalMarks).Max();

Min    Sometimes it is required to identify an element having a minimum value in a collection of elements.Min operator is used to find a minimum value from a collection of values.
In the following example we have a collection of days and temperatures.

Dictionary<int, int> tempratures = new Dictionary<int, int>();
tempratures.Add(1, 15);
tempratures.Add(2, 18);
tempratures.Add(3, 20);
tempratures.Add(4, 16);
tempratures.Add(5, 12);
tempratures.Add(6, 19);

tempratures.Add(7, 17);
tempratures.Add(8, 26);
tempratures.Add(9, 16);
tempratures.Add(10, 19);

The minimum temperature can be identified as:

int min=tempratures.Min(x => x.Value);

Average  To calculate the average of numeric values in a collection we can use the Avg operator.
Continuing with the previous example of days and tempratures ,average temprature can be calculated as:

double avg = tempratures.Average(x => x.Value);

Count   This returns the total number of elements in a collection.

Some of the main points about aggregate functions in LINQ are:

• Aggregate queries are executed immediately unlike other operators which are executed when the collection is iterated.
• Aggregate queries typically return a number instead of a collection.

 

Follow on: