LINQ - Tutorial - LINQ to XML

Create a new Windows Forms Application project in Visual Studio.

Add to the main form all necessary controls:

Use a SplitContainer control to make the user interface more flexible.
Set the Text property of the addressToolStripTextBox control to any valid RSS address (e.g. http://www.mini.pw.edu.pl/~mossakow/feeds/en.xml). The getToolStripButton button placed on the ToolStrip will try to fetch RSS feeds from the address written in the addressToolStripTextBox.
Labels placed above the ListView control (in the tableLayoutPanel2 control - this control is used only by the Designed, so the default name is kept) will display properties of the channel. The last label should be a clickable link, so the LinkLabel control is used.
The itemsListView control will display all feeds read from the channel. Only a title and a publish date will be display here, so add these 2 columns using the Columns property.
Labels placed below the ListView control will display properties of an item selected on the list. Again, the last label will be a link, so the LinkLabel control is used.
The description fields of an RSS item can contain HTML tags, so the WebBrowser control is used to display it. This control (named descriptionWebBrowser) will automatically render the text written in the description field as an HTML page.

Add an event handler for the click event of the getToolStripButton control:

private XDocument xml;

private void getToolStripButton_Click(object sender, EventArgs e)
{
    string address = addressToolStripTextBox.Text.Trim();
    if (address.Length == 0)
    {
        MessageBox.Show("No address");
    }
    else
    {
        xml = null;
        try
        {
            xml = XDocument.Load(address);
        }
        catch (Exception ex)
        {
            MessageBox.Show("Exception loading feeds: " + ex.ToString());
        }
    }

    ShowFeeds();
}

The XDocument.Load method will download the RSS data from the Internet and will recognize if it is a valid XML data. The XDocument class represents a whole XML document in the LINQ to XML.
The ShowFeeds method must be implemented:
private void ShowChannelProperties()
{
    if (xml == null)
    {
        channelDescriptionLabel.Text = "";
        channelLinkLabel.Text = "";
        channelPublishedLabel.Text = "";
        channelTitleLabel.Text = "";
    }
    else
    {
        XElement channel = xml.Element("rss").Element("channel");
        channelDescriptionLabel.Text = GetSaveValue(channel, "description");
        channelLinkLabel.Text = GetSaveValue(channel, "link");
        channelPublishedLabel.Text = GetSaveValue(channel, "pubDate");
        channelTitleLabel.Text = GetSaveValue(channel, "title");
    }
}

private void ShowItemsList()
{
    itemsListView.Items.Clear();
    if (xml != null)
    {
        IEnumerable<XElement> items = xml.Element("rss").Element("channel").Elements("item");
        foreach (XElement item in items)
        {
            ListViewItem lvi = new ListViewItem(new string[] {
                GetSaveValue(item, "title"),
                GetSaveValue(item, "pubDate") });
            lvi.Tag = item;
            itemsListView.Items.Add(lvi);
        }
    }
}

private void ShowFeeds()
{
    try
    {
        ShowChannelProperties();
        ShowItemsList();
    }
    catch (Exception ex)
    {
        MessageBox.Show("Exception parsing feeds: " + ex.ToString());
    }
}
The XElement class is a heart of the LINQ to XML. It represents a node (element) in the XML data structure with all its subnodes. Its subnodes can be reached using the Element (for single subnode) or Elements (for multiple subnodes) methods. The XElement.Value property gives a value written in the node.
The GetSaveValue method is a simple helpful method which helps in cases where an expected field was no provided by an author of the feed:
private string GetSaveValue(XElement element, string subKey)
{
    if (element == null)
    {
        return "";
    }
    else
    {
        XElement sub = element.Element(subKey);
        if (sub == null)
        {
            return "";
        }
        else
        {
            return sub.Value ?? "";
        }
    }
}

In response for the changing selection on the list of items, show properties of the selected item and its description:

private void ShowItemProperties(XElement item)
{
    if (item == null)
    {
        feedAuthorLabel.Text = "";
        feedLinkLabel.Text = "";
        feedPublishedLabel.Text = "";
        feedTitleLabel.Text = "";
    }
    else
    {
        feedAuthorLabel.Text = GetSaveValue(item, "author");
        feedLinkLabel.Text = GetSaveValue(item, "link");
        feedPublishedLabel.Text = GetSaveValue(item, "pubDate");
        feedTitleLabel.Text = GetSaveValue(item, "title");
    }
}

private void ShowItemDescription(XElement item)
{
    if (item == null)
    {
        descriptionWebBrowser.DocumentText = "";
    }
    else
    {
        descriptionWebBrowser.DocumentText = item.Element("description").Value;
    }
}

private void ShowItem(XElement item)
{
    try
    {
        ShowItemProperties(item);
        ShowItemDescription(item);
    }
    catch (Exception ex)
    {
        MessageBox.Show("Exception parsing feeds: " + ex.ToString());
    }
}

private void itemsListView_SelectedIndexChanged(object sender, EventArgs e)
{
    if (itemsListView.SelectedIndices.Count == 1)
    {
        ListViewItem lvi = itemsListView.SelectedItems[0];
        XElement item = lvi.Tag as XElement;
        ShowItem(item);
    }
}

Note a way of rendering HTML description - it is enough to set the DocumentText property of the WebBrowser control.

To make the LinkLabel control opening a browser with a target address, custom code must be provided (the LinkLable control provides appearance, but not functionality):

private void linkLabel_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
string url = (sender as LinkLabel).Text;
Process.Start(url);
}

A new system process with the target URL passed as its name is created, so the behaviour depends on the system settings. In most cases, it will open a new window in the default web browser.

Run and test the application.
Note that we have a built-in web browser.

There is one thing in out application that should be improved. When there is a problem with connection to the source of feeds, or just the connection is slow and the content is big, our application freezes. The reason is downloading data from the Internet in the main thread. It should never be done in this way - always use asynchronous methods for loading data from the Internet or use a background thread. There is no asynchronous equivalent of the XDocument.Load method, so we have to create a background thread. To force the user to wait, we will display a modal form with nice 'waiting' animation.
Add a new form (named WaitingForm) to the project. Add controls to the form:

Use some nice, animated image in the pictureBox1 control, e.g. this one.
Set some of the WaitingForm's properties: FormBorderStyle, StartPosition, and ShowInTaskbar
The form will be displayed as a modal window and the following DialogResult values will be used:
- OK - when the XML was successfully loaded,
- Cancel - when the used cancelled loading,
- Abort - when an exception occured during loading.
Set the DialogResult property of the cancelButton control to Cancel.
Add 3 properties to the WaitingForm:
public XDocument Xml { get; private set; }
public string Address { private get;set; }
public Exception Exception { get; private set; }
Add code for the backgroundWorker control which will download the XML data:
protected override void OnLoad(EventArgs e)
{
    base.OnLoad(e);

    backgroundWorker.RunWorkerAsync();
}

private void backgroundWorker_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
{
    try
    {
        Xml = XDocument.Load(Address);
    }
    catch (Exception ex)
    {
        Exception = ex;
    }
}

private void backgroundWorker_RunWorkerCompleted(object sender, System.ComponentModel.RunWorkerCompletedEventArgs e)
{
    DialogResult = (Exception == null) ? DialogResult.OK : DialogResult.Abort;
}

private void cancelButton_Click(object sender, EventArgs e)
{
    backgroundWorker.CancelAsync();
}
In the MainForm, modify the getToolStripButton_Click method to use the new WaitingForm:
private void getToolStripButton_Click(object sender, EventArgs e)
{
    string address = addressToolStripTextBox.Text.Trim();
    if (address.Length == 0)
    {
        MessageBox.Show("No address");
    }
    else
    {
        xml = null;
        WaitingForm waitingForm = new WaitingForm();
        waitingForm.Address = address;
        switch (waitingForm.ShowDialog())
        {
            case DialogResult.OK:
                // successfully finished, get the Xml
                xml = waitingForm.Xml;
                break;
            case DialogResult.Cancel:
                // cancelled by the user, nothing to do
                break;
            case DialogResult.Abort:
                // aborted by an exception, show it
                MessageBox.Show("Exception loading feeds: " + waitingForm.Exception.ToString());
                break;
        }
    }

    ShowFeeds();
}

Run and enjoy the great RSS Reader:

All collections of XML data can be used by LINQ expressions. As an example lets define a task: find the most frequent word from descriptions of all items from the channel.

Add a new button to the ToolStrip control and write the following code:
private void mostFrequentWordToolStripButton_Click(object sender, EventArgs e)
{
    if (xml != null)
    {
        Regex tagMatch = new Regex("<[^>]+>", RegexOptions.Compiled);
        char[] delimiterChars = { ' ', ',', '.', ':', '\t', '\n', '\r', '\\', '/' };

        var mostFrequent =
            (from item in xml.Element("rss").Element("channel").Elements("item")
             let description = item.Element("description").Value
             let withoutTags = tagMatch.Replace(description, " ")
             from word in withoutTags.Split(delimiterChars, StringSplitOptions.RemoveEmptyEntries)
             group word by word into groups
             orderby groups.Count() descending
             select new { Word = groups.Key, Count = groups.Count() })
            .First();

        MessageBox.Show(string.Format("{0}: {1}", mostFrequent.Word, mostFrequent.Count));
    }
}