Linq (and all its flavors) will come out with .Net 3.5 and Visual Studio 2008. Along with the Xml support are classes such as XDocument, XElement, XAttribute, etc. What’s interesting about XElement in particular is that it allows us to load some Xml from many sources and query into it. Depending on your experience with XPath, an Xml Linq query may be easier to write AND read.

Let’s look at a sample Linq to Xml query. I’m going to use my blog’s RSS feed, http://feeds.feedburner.com/jeffreypalermo.

Let’s start simple. We’ll read in the Xml from the RSS feed and enumerate through all the posts (or "items" in the RSS world).

XElement rssFeed = XElement.Load(@"http://feeds.feedburner.com/jeffreypalermo");

var items = from item in rssFeed.Elements("channel").Elements("item")

 select item;

Console.WriteLine(items.Count());

foreach (object o in items)

{

 Console.WriteLine(o);

}

Note that we are merely reading in the feed into an XElement and then selecting all item nodes from the document.

That’s pretty interesting that we can filter to only the "item" nodes that quickly, but what if I want to find the posts with the author of "Jeffrey Palermo" (never mind that this is my feed, but imagine it was a composite feed).

XNamespace dc = "http://purl.org/dc/elements/1.1/";

XElement rssFeed = XElement.Load(@"http://feeds.feedburner.com/jeffreypalermo");

var items = from item in rssFeed.Elements("channel").Elements("item")

 where item.Element(dc + "creator").Value == "Jeffrey Palermo"

 select item;

Console.WriteLine(items.Count());

foreach (object o in items)

{

 Console.WriteLine(o);

}

I gave this example to illustrate how to use the XNamespace class to help filter in nodes that declare a namespace prefix such as "dc:creator" in an RSS feed. Note the "where" clause in my Linq query.

Let’s go further and filter down to just the posts that contain the term "altnetconf" (or choose another term to search for)

XNamespace dc = "http://purl.org/dc/elements/1.1/";

XElement rssFeed = XElement.Load(@"http://feeds.feedburner.com/jeffreypalermo");

var items = from item in rssFeed.Elements("channel").Elements("item")

 where item.Element(dc + "creator").Value == "Jeffrey Palermo"

 && item.Element("description").Value.Contains("altnetconf")

 select item;

Console.WriteLine(items.Count());

foreach (object o in items)

{

 Console.WriteLine(o);

}

Now we’ve seen how the where clause functions. Let’s shape the data now. I’ll drop the where clause for simplicity, and I want to grab my feed and put a title and abstract into a collection for use in my application. I’ll use an anonymous type to help me do that.

XElement rssFeed = XElement.Load(@"http://feeds.feedburner.com/jeffreypalermo");

var items = from item in rssFeed.Elements("channel").Elements("item")

 select new { Title = item.Element("title").Value, 

 Abstract = item.Element("description").Value.Substring(0, 100) }

;

Console.WriteLine(items.Count());

foreach (object o in items)

{

 Console.WriteLine(o);

}

Here, I have created an anonymous type with a Title and Abstract. Now that I have the information in object form, I can work with it. I would not want to work with Xml throughout my application, but only at the edges. I prefer to pull in the information and get it into my domain model as quickly as possible because objects are easier to work with that raw Xml.

I’m not finished yet because my type doesn’t have a name, so there is no way I can pass my IEnumberable<whateverthetypeis> to another part of my application. I need to hydrate one of my domain objects so I can work with my abstracts.

I’m going to use this class:

public class PostAbstract

{

 private string _title;

 private string _abstract;

 public string Title

 {

 get { return _title; }

 set { _title = value; }

 }

 public string Abstract

 {

 get { return _abstract; }

 set { _abstract = value; }

 }

}

I’ll have the results of my Xml query create a set of PostAbstracts, and then I can work with them.

XElement rssFeed = XElement.Load(@"http://feeds.feedburner.com/jeffreypalermo");

IEnumerable<PostAbstract> items = from item in rssFeed.Elements("channel").Elements("item")

 select new PostAbstract { Title = item.Element("title").Value, 

 Abstract = item.Element("description").Value.Substring(0, 100) }

;

Console.WriteLine(items.Count());

foreach (PostAbstract anAbstract in items)

{

 Console.WriteLine("{0} - {1}", anAbstract.Title, anAbstract.Abstract);

}

Note that I merely gave my type a name, PostAbstract. I used object initializers to set the properties, and now I have a set of objects I can work with to accomplish my purpose.

If you enjoyed this article, subscribe to my feed: http://feeds.feedburner.com/jeffreypalermo

David Diehl doesn’t have a blog, but he asked me to post his notes from the Domain-specific language session at AltNetConf.  Read below

What is a DSL?
“A thin veneer over top of an API” (Martin Fowler)

Two types of DSL
Internal — Domain language implemented as a fluent interface in a “standard” language (erg., Ruby, C#, Python)
External — Domain language that is parsed / compiled as its own language

The Key Attributes of DSLs (Fowler)
1. Should read like a language. This is a subjective criteria, but it should have a type of grammar.
2. Business users (domain users) should be able to make sense of it. In other words, it uses the “ubiquitous language” (Evans) of the domain.

Some Examples of DSLs
1. XAML is a DSL for designers
2. NHibernate is a DSL for O/R mapping and persistence

Possible Pitfalls When Using a DSL
1. The language can become too general very easily. The language must be very specific. Some would say NAnt has drifted too far from its original intent.
2. It can become hard to handle errors and debug a DSL. When this becomes difficult, it’s a warning sign that the language is becoming too generic.
3. If you are using an external DSL, you must test the layer between the DSL and the existing API thoroughly.

How to capture a DSL (Fowler). The two approaches
1. Build the DSL over top of an existing domain model and API
2. Capture the DSL with the requirements. Martin noted an experience where a developer had a laptop and was doing some DSL development right with the business expert.

What method should you choose?
No clear winner. It depends on what one you are most comfortable with.

Recommended Tools
1. ANTLr is the tool recommended at the moment for parsing and creating external DSLs.
2. Scott Guthrie recommended the use of debug visualizers to help with debugging and error handling.

I use Rhino Mocks, and I encourage you to do the same.  When unit testing, sometimes its necessary to interrogate an object that was passed to a dependency.

Consider the following test code:

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, “Courier New”, courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}

.csharpcode pre { margin: 0em; }

.csharpcode .rem { color: #008000; }

.csharpcode .kwrd { color: #0000ff; }

.csharpcode .str { color: #006080; }

.csharpcode .op { color: #0000c0; }

.csharpcode .preproc { color: #cc6633; }

.csharpcode .asp { background-color: #ffff00; }

.csharpcode .html { color: #800000; }

.csharpcode .attr { color: #ff0000; }

.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}

.csharpcode .lnum { color: #606060; }

   1:  [Test]

   2:  public void ShouldSaveObjectWithAllInformation()

   3:  {

   4:      string firstName = "Jeffrey";

   5:      string lastName = "Palermo";

   6:   

   7:      MockRepository mocks = new MockRepository();

   8:      IPersonRepository personRepository = (IPersonRepository) mocks.CreateMock(typeof (IPersonRepository));

   9:   

  10:      personRepository.SavePerson(null);

  11:      GenericConstraint personConstraint = new GenericConstraint();

  12:      LastCall.On(personRepository).Constraints(personConstraint);

  13:   

  14:      mocks.ReplayAll();

  15:   

  16:      PersonController controller = new PersonController(personRepository);

  17:      controller.PersonFirstName = "Jeffrey";

  18:      controller.PersonLastName = "Palermo";

  19:      controller.Save();

  20:   

  21:      mocks.VerifyAll();

  22:   

  23:      Person person = (Person) personConstraint.GetParameterObject();

  24:      Assert.That(person.FirstName, Is.EqualTo(firstName));

  25:      Assert.That(person.LastName, Is.EqualTo(lastName));

  26:  }

This is a case where we have a class that takes information, creates an object and sends it to a dependency. The dependency doesn’t need to return what was just passed to it, but in our unit test, we need to be able to assert that the object was created correctly before being passed to the dependency.  This is not an edge case.  I run into this scenario quite often.

What did I do to keep my test readable?  I created a Rhino Mocks constraint class that captures the argument passed to a dependency.  Later, I can write plain old asserts that verify the state of the object.   Here is the class:

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, “Courier New”, courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}

.csharpcode pre { margin: 0em; }

.csharpcode .rem { color: #008000; }

.csharpcode .kwrd { color: #0000ff; }

.csharpcode .str { color: #006080; }

.csharpcode .op { color: #0000c0; }

.csharpcode .preproc { color: #cc6633; }

.csharpcode .asp { background-color: #ffff00; }

.csharpcode .html { color: #800000; }

.csharpcode .attr { color: #ff0000; }

.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}

.csharpcode .lnum { color: #606060; }

   1:  public class GenericConstraint : AbstractConstraint

   2:  {

   3:      object _theObject;

   4:   

   5:      public override bool Eval(object obj)

   6:      {

   7:          _theObject = obj;

   8:          return true;

   9:      }

  10:   

  11:      public object GetParameterObject()

  12:      {

  13:          return _theObject;

  14:      }

  15:   

  16:      public override string Message

  17:      {

  18:          get { return ""; }

  19:      }

  20:  }

I prefer this over even the built-in constraints Rhino Mocks provides because I find the Assert syntax to be more familiar with more programmers than the in-line constraint syntax.  Notice on line 12 of the test listing that I’m assigning this constraint to the mocked call to IPersonRepository.  This allows me to come back later on line 23 and pull the object for interrogation.  Once I have a reference to the object that was passed to my dependency, I can write the appropriate asserts.

Feel free to use this constraint class or comment with how you’ve handled this situation.