Dot Net Perls

Problem

Use LINQ to query a sitemap-like data structure. We are using ASP.NET and our website needs a navigation system. Often, using the Web.sitemap in its default form is sufficient, be here we need a more flexible solution that allows us to generate Google XML sitemaps, allow more per-user customization, or create page series.

C# Solution

The solution will be in the code-behind and C# classes. First, the data source format is not important. It can be in a database, an XML file, or just custom object arrays in code. The data source contains a series of nodes, one for each page in the site, and each node can have any number of properties.

How can we store the data?

These objects can be constructed from any data source. Due to the limited scope of the project and the fact that my application has limitations due to the server's security mechanism, I will store the SitePage object array in a C# file. What follows are the sitemap properties and some sample code.

/// <summary>
/// A single object that corresponds to a page.
/// </summary>
public class SitePage
{
    /// <summary>
    /// The visibility level of the page in the sitemap.
    /// Note the condenced syntax.
    /// </summary>
    public VisibilityType Visibility { get; set; }

    /// <summary>
    /// The page's title.
    /// </summary>
    private string Title { get; set; }

    // Several properties and fields omitted.
}

How can we initialize it?

We initialize all the nodes directly in a class in the App_Code folder. Another object must contain arrays or Lists of SitePage. VisibilityType is a simple enum containing different values. You can use a special collection initialization syntax that improves readability.

/// <summary>
/// Initialize all the SitePage objects in the array in this constructor.
/// </summary>
public SiteStructure()
{
    _site.Pages = new SitePage[]
    {
        new SitePage
        {
            Visibility = VisibilityType.Root, // Show on top-level pages.
            Url = "Default.aspx", // The home page URL.
            Title = "Blank", // The page title (should be something else).
            Category = PageCategory.None // No specific category.
        },
        new SitePage 
        {
            Visibility = VisibilityType.Regular,
            Url = "Content/Anagram-Web-Database.aspx",
            Title = "An Anagram Database Web Application",
            Category = PageCategory.WebApplications
        },
        new SitePage
        {
            Visibility = VisibilityType.Archive,
            Url = "Content/Find-First-Set-Cpp.aspx",
            Title = "Find First Set: Choices in C++ and VC++",
            Category = PageCategory.Performance
        }
    };
}

How can we use LINQ to query it?

We must use the standard query syntax in C#. Here we use LINQ to query the data array and use it in the site. Let's look at a simple special-case first. On the Archives page on this site, I want to list all pages in Visibility of VisibilityType.Archive. Here is some example code.

/// <summary>
/// Build up a string containing all the HTML links to archive pages.
/// </summary>
/// <param name="pageUrlIn">Our site root (virtual) URL.</param>
/// <returns>The HTML string generated.</returns>
public string GetArchiveString(string pageUrlIn)
{
    StringBuilder builder = new StringBuilder();

    // Select archive pages from the sitemap structure in memory.
    // Alphabetize them. We use the var keyword for simpler syntax.
    var pageList = from page in _site.Pages
                   where page.Visibility == VisibilityType.Archive
                   orderby page.Title
                   select page;

    // Build up a StringBuilder containing HTML markup for the output.
    foreach (SitePage page in pageList)
    {
        builder.Append("<a href=\").Append(page.Url).Append("\">").Append(
            page.Title).Append("</a>");
    }
    return builder.ToString();
}

• We use a StringBuilder
  Because we don't know how many pages we will need to output or the resulting string size, we can use StringBuilder as an optimization (it will prevent a performance disaster).
• LINQ query
  The var line is an example of a LINQ query.
  First, the LINQ query takes each page from the Pages List in this class, and sees if the page has a VisibilityType of Archive.
  It then alphabetizes based on the Title property.
  Finally, it selects each page and returns them all.
• foreach loop
  When using LINQ, the foreach loop is very important and highly recommended. Just use the foreach loop on everything for now. We cast each item in "var pageList" to a SitePage object, which is the object type of each page in the sitemap collection.
• Append to StringBuilder
  We append to the StringBuilder lines of HTML markup containing results from our query, for display in the HTML. (We use special StringBuilder syntax for clarity.)

Singletons are ideal here

For global, single-instance data like this, use a singleton pattern. The singleton pattern saves memory and enhances performance and will allow for cleaner code. I use a master page for the site. On the master page file, you can simply do a Response.Write of a function call to your custom sitemap object. (Note that it is far better to use HtmlTextWriter.)

We could use the groupby operator

For a hierarchal, tree-like sidebar, you can use the groupby operator to group the categories, alphabetize them, and then alphabetize their pages. groupby allows you to generate IGrouping enumerables, which are fairly simple to use in foreach loops.

Conclusion

Everything above could be done in SQL, but it is all on in-memory object arrays here. LINQ doesn't involve any confusing casts or complicated database connections. LINQ queries provide easier sorting and categorization, and are stateless and extremely flexible. Make custom sitemaps and run queries on them using LINQ.

Ads by The Lounge