LINQ - reading data from xml file using linq in asp.net

hi,

i used the following query
var xml2 = from s3 in hell.Descendants("match") select (new{
          Label3 = s3.Element("team1").Value,
          Label4 = s3.Element("team2").Value,
              Label5=s3.Element("series").Value
        });
and bind it to repeater
Repeater2.DataSource = xml2;
        Repeater2.DataBind();
      
my output is

{ Label3 = Zimbabwe, Label4 = Bangladesh, Label5 = Bangladesh in Zimbabwe 2011 }{ Label3 = Canada, Label4 = Afghanistan, Label5 = Afghanistan in Canada 2011 }

i need without this curly braces and i want to directly assign the value to label in repeater.please suggest me an idea

HI

hi..

Using LINQ to XML (and how to build a custom RSS Feed Reader with it)

One of the big programming model improvements being made in .NET 3.5 is the work being done to make querying data a first class programming concept.  We call this overall querying programming model "LINQ", which stands for .NET Language Integrated Query.

LINQ supports a rich extensibility model that facilitates the creation of efficient domain-specific providers for data sources.  .NET 3.5 ships with built-in libraries that enable LINQ support against Objects, XML, and Databases.

What is LINQ to XML?

LINQ to XML is a built-in LINQ data provider that is implemented within the "System.Xml.Linq" namespace in .NET 3.5.

LINQ to XML provides a clean programming model that enables you to read, construct and write XML data.  You can use LINQ to XML to perform LINQ queries over XML that you retrieve from the file-system, from a remote HTTP URL or web-service, or from any in-memory XML content. 

LINQ to XML provides much richer (and easier) querying and data shaping support than the low-level XmlReader/XmlWriter API in .NET today.  It also ends up being much more efficient (and uses much less memory) than the DOM API that XmlDocument provides. 

Using LINQ to XML to query a local XML File

To get a sense of how LINQ to XML works, we can create a simple XML file on our local file-system like below that uses a custom schema we've defined to store RSS feeds:

I could then use the new XDocument class within the System.Xml.Linq namespace to open and query the XML document above.  Specifically, I want to filter the <Feed> elements in the XML file and return a sequence of the non-disabled RSS feeds (where a disabled feed is a <Feed> element with a "status" attribute whose value is "disabled").  I could accomplish this by writing the code below:

VB:

C#:

Notice in the code-snippets above how I'm loading the XML file using the XDocument.Load(path) static method - which returns back an XDocument object.  Because I'm running this code within ASP.NET, I'm using the Server.MapPath(path) helper method to resolve the correct path for my XML file relative to the page I'm running the code on.

Once I have an XDocument object for my XML file I can then write a LINQ query expression to retrieve the XML data I'm looking for.  In the code above I'm querying over each of the <Feed> elements within the XML file.  This is driven by this opening clause in the LINQ query expression:

from feed in feedXML.Decedents("Feed")

I'm then applying a filter that only returns back those "Feed" elements that either don't have a "status" attribute, or whose "status" attribute value is not set to "disabled":

Where (feed.Attribute("status") Is Nothing) OrElse (feed.Attribute("status").Value <> "disabled")

I am then using the select clause in our LINQ expression to indicate what data I want returned.  If I simply wrote "select feed", LINQ to XML would return back a sequence of XElement objects that represents each of the XML element nodes that match my filter.  In the code samples above, though, I am using the shaping/projection features of LINQ to instead define a new anonymous type on the fly, and I am defining two properties on it - Name and Feed - that I want populated using the <Name> and <Url> sub-elements under each <Feed> element:

Select Name = feed.Element("Name").Value, Url = feed.Element("Url").Value

As you can see above (and below), I can then work against this returned sequence of data just like I would any collection or array in .NET.  VS 2008 provides full intellisense and compilation checking support over this anonymous type sequence:

I can also data-bind the results against any UI control in ASP.NET, Windows Forms, or WPF.  For example, assuming I had a dropdownlist control defined in my page like so:

I could use the below LINQ to XML code to databind the results to it:

This will then produce a nice drop-downlist in our HTML page like so:

Hmm - What is this "anonymous type" thing?

In my code above I've taken advantage of a new language feature in VB and C# called "anonymous types".  Anonymous types enable developers to concisely define inline CLR types within code, without having to explictly define a formal class declaration of the type.  You can learn more about them in my previous New "Orcas" Language Feature: Anonymous Types blog post.

While anonymous types can be super useful when you want to locally iterate and work with data, we'll often want/need to define a standard class when passing the results of our LINQ query between multiple classes, across class library assemblies, and over web-services. 

To enable this, I could define a non-anonymous class called "FeedDefinition" to represent our Feed data like so:

Note above how I'm using the new "Automatic Properties" feature of C# to define the properties (and avoid having to define a field for them).

I could then write the below method to return back a generics based List<FeedDefinition> collection containing FeedDefinition objects:

Note above how the only change I've made to the LINQ to XML query we were using before is to change the "select" clause from "select new" (with no type-name) to "select new FeedDefinition".  With this change I'm now returning a sequence of FeedDefinition objects that I can pass from class to class, assembly to assembly, and across web-services.

Using LINQ to XML to Retrieve a Remote RSS XML Feed

The XDocument.Load(path) static method supports the ability open both XML files from the file-system, as well as remote XML feeds returned from an HTTP URL.  This enables you to use it to access remote RSS feeds, REST APIs, as well as any other XML feed published on the web.

For an example of this in action, let's take a look at the XML of my blog's RSS feed (http://weblogs.asp.net/scottgu/rss.aspx):

I could write the LINQ to XML code below to retrieve the above blog post data from my RSS feed, and work with the individual feed items as .NET objects:

Note above how I am converting the "Published" field in the RSS field - which is a string in the XML - to a .NET DateTime object.  Notice also how LINQ to XML includes a built-in XNamespace type that provides a type-safe way to declare and work with XML Namespaces (which I need to-do to retrieve the <slash:comments> element).

I could then take advantage of the composition features of LINQ to perform a further sub-query on the result, so that I filter over only those RSS posts that were published within the last 7 days using the code below:

As you can see above, you can feed the results of one LINQ query expression to be the input of another LINQ expression.   This enables you to write very clean, highly composable, code.

Using LINQ Sub-Queries within a LINQ to XML Query Expression

If you look at the raw XML of my RSS feed, you'll notice that the "tag" comments for each post are stored as repeated <category> elements directly below each <item> element:

When designing the object model for a "BlogEntry" class, I might want to represent these <category> values as a sub-collection of strings.  For example, using a "Tags" property that is a generic list of type string:

You might be wondering - how do we take a flat collection of <category> elements under <item> and transform them into a nested sub-collection of strings?  The nice thing about LINQ is that it makes this type of scenario easy by allowing us to use nested LINQ query expressions like so:

This "shaping" power of LINQ, and its ability to take flat data structures and make them hierarchical (and take hierarchical data structures and make them flat) is super powerful.  You can use this feature with any type of data source - regardless of whether it is XML, SQL, or plain old objects/arrays/collections.

Putting it all Together with a Simple RSS Feed Reader

The code snippets I've walked through above demonstrate how you can easily write LINQ to XML code to retrieve a list of RSS feeds from a local XML file, and how to remotely query an RSS feed to retrieve an individual feed's details and individual item post contents.  I could obviously then take the resulting feed contents and data-bind it to a ASP.NET GridView or ListView control to provide a nice view of the blog feed:

I've built a simple sample application that puts all of these snippets together to deliver a simple RSS Reader with LINQ to XML and the new <asp:ListView> control.  You can download it here.  Included in the download is both a VB and C# version of the application.

Summary

LINQ to XML provides a really powerful way to efficiently query, filter, and shape/transform XML data.  You can use it both against local XML content, as well as remote XML feeds.  You can use it to easily transform XML data into .NET objects and collections that you can further manipulate and transfer across your application.

LINQ to XML uses the same core LINQ query syntax and concepts that LINQ to SQL, LINQ to Objects, LINQ to SharePoint, LINQ to Amazon, LINQ to NHibernate, etc. use when querying data. You can learn more about the LINQ query syntax and the supporting language features being added to VB and C# to support it from these previous blog posts of mine:

• Automatic Properties, Object Initializer and Collection Initializers
• Extension Methods
• Lambda Expressions
• Query Syntax
• Anonymous Types

You might also find these blog posts of mine useful to learn more about LINQ to SQL:

Part 1: Introduction to LINQ to SQL

Part 2: Defining our Data Model Classes

Part 3: Querying our Database

Part 4: Updating our Database

HI



here is the good example

The ItemTemplate is straightforward enough: just add a LinkButton (or Button or ImageButton) with its CommandName property set to "Edit":

<ItemTemplate>
   <tr>
    <td>
     <asp:LinkButton ID="lnkEdit" runat="server" CommandName="Edit" Text="Edit" />
    </td>
    <td>
     <%# Eval("Name") %>
    </td>
    <td>
     <%# Eval("Telephone") %>
    </td>
   </tr>
</ItemTemplate>


refer this link
http://www.4guysfromrolla.com/articles/043008-1.aspx#postadlink

Using Linq you can select the element that you want

var custs = from c in XElement.Load("Customers.xml").Elements("Customers")
      select c ;

// Execute the query 

Using ForEach you can easily iterate the selected results

foreach (var customer in custs)
{
   Console.WriteLine(customer);
}

Linq to xml provides an easy query interface for XML files. In the following example I will demonstrate how to use linq to xml to read and write data from/to xml file, using the file for persistency maintaining a list of objects. linq to xml can be used for storing application settings, storing persistent objects or any other data needs to be saved. Follow the 3 steps to get the picture and see how easy it is:

1. Define the Data Entity
2. Create XML Data File
3. Load/Save the Data…

Lets check out the these three steps for using linq to xml

1. Define the Data Entity

In this example we’ll be dealing with patients, so lets define a Patient class with some attributes:

class Patient
{
    public string EMail { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

 

2. Create XML Data File

<?xml version="1.0" encoding="utf-8" ?>
<Patients>
  <Patient EMail="LeBron@James.com">
    <FirstName>LeBron</FirstName>
    <LastName>James</LastName>
  </Patient>
  <Patient EMail="Kobe@Bryant.com">
    <FirstName>Kobe</FirstName>
    <LastName>Bryant</LastName>
  </Patient>
  <Patient EMail="Allen@Iverson.com">
    <FirstName>Allen</FirstName>
    <LastName>Iverson</LastName>
  </Patient>
</Patients>

 

3. Load/Save the data

I Inherited the List<Patient> and add Load/Save methods to it:

class PatietList : List<Patient>
{
    public void Load(string xmlFile)
    {
        XDocument doc = XDocument.Load(xmlFile);     

        var query = from xElem in doc.Descendants("Patient")
                    select new Patient
                    {
                        EMail = xElem.Attribute("EMail").Value,
                        FirstName = xElem.Element("FirstName").Value,
                        LastName = xElem.Element("LastName").Value,
                    };     

        this.Clear();
        AddRange(query);
    }     

    public void Save(string xmlFile)
    {
        XElement xml = new XElement("Patients",
                        from p in this
                        select new XElement("Patient",
                            new XAttribute("EMail", p.EMail),
                            new XElement("FirstName", p.FirstName),
                            new XElement("LastName", p.LastName)));     

        xml.Save(xmlFile);     

    }     

}

See how easy this is? get familiar with the XDocument, XElement and XAttribute classes.

Another thing you could do is to move load/save knowledge into the Data object:

class Patient
{
    ...
    public Patient(XElement xElement)
    {
        EMail = xElement.Attribute("EMail").Value;
        FirstName = xElement.Element("FirstName").Value;
        LastName = xElement.Element("LastName").Value;
    }     

    public XElement XElement
    {
        get
        {
            return new XElement("Patient",
                    new XAttribute("EMail", EMail),
                    new XElement("FirstName", FirstName),
                    new XElement("LastName", LastName));
        }
    }
    ...
}

and than the load/save query looks like this:

public void Load(string xmlFile)
{
    ...
    var query = from xElem in doc.Descendants("Patient")
                select new Patient(xElem);
    ...     

public void Save(string xmlFile)
{
    ...
    XElement xml = new XElement("Patients",
                    from p in this
                    select p.XElement);

Refer this code for reading data from XML using LINQ

1) READING OF XML FILE

private static void ReadXML()
{
// Load the xml document from the specified path
XDocument xdoc = XDocument.Load(@"..\..\Employees.xml");

// Below LINQ query reads all the person under the Employees root tag
var query = from p in xdoc.Elements("Employees").Elements("person")
select p;

//Now loop through all the persons in resultset
foreach (var record in query)
{
string firstName = record.Element("firstname").Value;
string lastname = record.Element("lastname").Value;
string idrole = record.Element("idrole").Value;
}
}

refer this for more details
http://www.eggheadcafe.com/tutorials/aspnet/77270889-d046-4f46-a189-86f2c2bec296/processing-xml-using-linq.aspx

sir, then finally how to assign this foreach loop to repeater control.

Hi
You can directly assign value from xml file to repeater control like this way


XML file-> cdcatalog.xml

<?xml version="1.0" encoding="ISO-8859-1"?>

<catalog>
<cd>
  <title>Empire Burlesque</title>
  <artist>Bob Dylan</artist>
  <country>USA</country>
  <company>Columbia</company>
  <price>10.90</price>
  <year>1985</year>
</cd>
<cd>
  <title>Hide your heart</title>
  <artist>Bonnie Tyler</artist>
  <country>UK</country>
  <company>CBS Records</company>
  <price>9.90</price>
  <year>1988</year>
</cd>
<cd>
  <title>Greatest Hits</title>
  <artist>Dolly Parton</artist>
  <country>USA</country>
  <company>RCA</company>
  <price>9.90</price>
  <year>1982</year>
</cd>
<cd>
  <title>Still got the blues</title>
  <artist>Gary Moore</artist>
  <country>UK</country>
  <company>Virgin records</company>
  <price>10.20</price>
  <year>1990</year>
</cd>
<cd>
  <title>Eros</title>
  <artist>Eros Ramazzotti</artist>
  <country>EU</country>
  <company>BMG</company>
  <price>9.90</price>
  <year>1997</year>
</cd>
</catalog>


First, import the "System.Data" namespace. We need this namespace to work with DataSet objects. Include the following directive at the top of an .aspx page:
<%@ Import Namespace="System.Data" %>

Next, create a DataSet for the XML file and load the XML file into the DataSet when the page is first loaded:
<script runat="server">
sub Page_Load
if Not Page.IsPostBack then
  dim mycdcatalog=New DataSet
  mycdcatalog.ReadXml(MapPath("cdcatalog.xml"))
end if
end sub

Then we create a Repeater control in an .aspx page. The contents of the <HeaderTemplate> element are rendered first and only once within the output, then the contents of the <ItemTemplate> element are repeated for each "record" in the DataSet, and last, the contents of the <FooterTemplate> element are rendered once within the output:
<html>
<body>

<form runat="server">
<asp:Repeater id="cdcatalog" runat="server">

<HeaderTemplate>
...
</HeaderTemplate>

<ItemTemplate>
...
</ItemTemplate>

<FooterTemplate>
...
</FooterTemplate>

</asp:Repeater>
</form>

</body>
</html>

Then we add the script that creates the DataSet and binds the mycdcatalog DataSet to the Repeater control. We also fill the Repeater control with HTML tags and bind the data items to the cells in the<ItemTemplate> section with the <%#Container.DataItem("fieldname")%> method:
Example
<%@ Import Namespace="System.Data" %>

<script runat="server">
sub Page_Load
if Not Page.IsPostBack then
  dim mycdcatalog=New DataSet
  mycdcatalog.ReadXml(MapPath("cdcatalog.xml"))
  cdcatalog.DataSource=mycdcatalog
  cdcatalog.DataBind()
end if
end sub
</script>

<html>
<body>

<form runat="server">
<asp:Repeater id="cdcatalog" runat="server">

<HeaderTemplate>
<table border="1" width="100%">
<tr>
<th>Title</th>
<th>Artist</th>
<th>Country</th>
<th>Company</th>
<th>Price</th>
<th>Year</th>
</tr>
</HeaderTemplate>

<ItemTemplate>
<tr>
<td><%#Container.DataItem("title")%></td>
<td><%#Container.DataItem("artist")%></td>
<td><%#Container.DataItem("country")%></td>
<td><%#Container.DataItem("company")%></td>
<td><%#Container.DataItem("price")%></td>
<td><%#Container.DataItem("year")%></td>
</tr>
</ItemTemplate>

<FooterTemplate>
</table>
</FooterTemplate>

</asp:Repeater>
</form>

</body>
</html>


O/P

Title	Artist	Company	Price
Empire Burlesque	Bob Dylan	Columbia	10.90
Hide your heart	Bonnie Tyler	CBS Records	9.90
Greatest Hits	Dolly Parton	RCA	9.90
Still got the blues	Gary Moore	Virgin records	10.20
Eros	Eros Ramazzotti	BMG	9.90

sir,
it showing me the following error
'http:/synd.cricbuzz.com/score-gadget/gadget-scores-feed.xml' is not a valid virtual path.

You have to specify a virtual path like this:

<%@ Register Src="~/NEW TFC/footer.ascx" TagName="footer" TagPrefix="uc3" %>

This would tell the page to loook for a folder named "NEW TFC" in the root forlder of your application and then for a file named footer.ascx in it.

If you want to use files which are outside of the root folder of your application you have to use a custom virtual path provider. Here is a list of sample implementations of virtual path providers:

http://msdn.microsoft.com/en-us/library/system.web.hosting.virtualpathprovider.aspx http://www.thecodinghumanist.com/Content/VirtualPathProviderExample.aspx http://www.codeproject.com/KB/aspnet/Virtual_Path_Provider.aspx

what should i give in src="" field

How you are providing path? for example
if give path like this:

string xmlFilePath = Server.MapPath("http:/synd.cricbuzz.com/score-gadget/gadget-scores-feed.xml");

if (File.Exists(xmlFilePath))

{

}

You will get error like this way "'http:/synd.cricbuzz.com/score-gadget/gadget-scores-feed.xml' is not a valid virtual path. Its because You have specified the full path of xml file, then what is need of server.mappath there.

Use like this

string xmlFilePath = http:/synd.cricbuzz.com/score-gadget/gadget-scores-feed.xml;