Keeping up with C# 3.0 isn’t too difficult, as Granville Barnett demonstrates by exploring LINQ to SQL, LINQ to XML and the strange sounding lambda expression

By Granville Barnett

Published: 1 April 2007

In the February edition of VSJ we looked at some of the core fundamentals of .NET 3.5 and C# 3.0, in particular we looked at LINQ to SQL using ad-hoc queries. In this article we will build on what we learnt and look at LINQ to SQL using stored procedures, and LINQ to XML; we will also demystify lambda expressions through a series of practical examples.

Note: All the code samples in this article are based on the January CTP of Visual Studio Orcas.

LINQ to SQL

For all the examples in this article we will use the same database schema as the February article Next Generation Data Access with LINQ.

Configuring our data access layer for stored procedures

[StoredProcedure(Name="GetAuthors")]
public StoredProcedureResult<
	GetAuthorsResult> GetAuthors() {
	return this.ExecuteStoredProcedure
		<GetAuthorsResult>(
		((MethodInfo)(
		MethodInfo.GetCurrentMethod(
	))));
}

public partial class GetAuthorsResult {
	private int _AuthorId;
	private string _AuthorName;
	public GetAuthorsResult() {
	}

	[Column(Name="AuthorId", Storage="_AuthorId",
		DBType="Int")]
	public int AuthorId {
		get {
			return this._AuthorId;
		}
		set {
			if ((this._AuthorId != value)) {
				this._AuthorId = value;
			}
		}
	}

	[Column(Name="AuthorName", Storage="_AuthorName",
		DBType="NVarChar(50)")]
	public string AuthorName {
		get {
			return this._AuthorName;
		}
		set {
			if ((this._AuthorName != value)) {
				this._AuthorName = value;
			}
		}
	}
}

Note: Remember this is still a very early CTP of LINQ, so it’s likely that the final code generation tool will take into account the similarities between already defined entities and stored procedures.

Running a few queries

BookShop db = new BookShop(_conn);
foreach (var author in
	db.GetAuthors()) {
	Console.WriteLine(
		author.AuthorName);
}

var query = from a in db.GetAuthors()
	orderby a.AuthorName
	select new { a.AuthorName };
foreach (var book in query) {
	Console.WriteLine(book.AuthorName);
}

Notice that stored procedures can be debugged in the usual way – see Figure 1.

Figure 1: Debugging

When extracting the stored procedures from your database, all stored procedures that take any arguments will be taken into account when SqlMetal generates the methods associated with those stored procedures. In our scenario we have a stored procedure called GetAuthorByBookId, which takes a single parameter of type int – this leads to the generation of a method of the same name, which also takes a parameter of type int. If you have a stored procedure that takes n arguments then you will also have generated a method with the same n arguments. For example:

//...
myDataContext.GetAuthorByBookId(8);
//...

LINQ to XML

XElement book = new XElement("book",
	new XAttribute("publisher", "MS Press"),
	new XElement("title", "CLR Via C#"),
	new XElement("authors",
	new XElement("author", "Jeffrey Richter")
	));
Console.WriteLine(book);

Figure 2: The XML document

One of the things about which I was sceptical at first was the whacky indentation used when defining an XML document using some of the new types like XElement and XAttribute. This indentation is not compulsory, however it is remarkably clear to read when reviewing your code, so I would encourage you to preserve this indentation, if only for code clarity.

Querying XML data

XElement doc =
	XElement.Load("Books.xml");
IEnumerable<XElement> query =
	doc.Descendants("book");
foreach (XElement book in query) {
	Console.WriteLine(book);
}

XElement doc =
	XElement.Load("Books.xml");
IEnumerable<XElement> query =
	doc.Descendants("book").
	Where(x => (string)x.
	Attribute("publisher") ==
	"MS Press");
foreach (XElement book in query) {
	Console.WriteLine(book);
}

Figure 3: Output of the XML query

Adding data to the XML document

XElement doc =
	XElement.Load("Books.xml");
XElement myBook = new XElement("book",
	new XAttribute("publisher",
	"Addison-Wesley"),
	new XElement("title",
	"Exceptional C++ Style"),
	new XElement("authors",
	new XElement("author",
	"Herb Sutter")
	));
doc.Add(myBook);
doc.Save("Books.xml");

Updating data

XElement books =
	XElement.Load(@"Books.xml");
books.Element("book").Attribute(
	"publisher").Value = "MS Press";
books.Save(@"Books.xml");

Deleting data

XElement doc = 
	XElement.Load("Books.xml");
doc.Descendants("book").Where(x =>
	(string)x.Attribute("publisher")
	== "MS Press").Remove();
doc.Save("Books.xml");

Don’t be alarmed by the lambda expression argument to the Where extension method for now – we will cover lambda expressions later on in this article.

LINQ to SQL and LINQ to XML

BookShop db = new BookShop(_conn);
XElement titles =
	new XElement("titles",
	from b in db.GetBooks()
	select new XElement("title",
	b.Title));
Console.WriteLine(titles);

Figure 4: Resulting document

Here, instead of creating a new anonymous type like we may do when selecting specific properties of an entity, we create the appropriate XML types – constructing a perfect XML document while using a very small amount of code. I still get excited when I use this particular feature of LINQ to SQL, look at how much code we are writing – the simplicity of it is just great!

One of the concepts introduced in our last code snippet was the ability to actually nest a query within the definition of an XElement type. Our next example builds on this concept and introduces a second nested query so that we can loop through all the authors associated with any particular book:

XElement books = new XElement("books",
	from b in db.GetBooks()
	select new XElement("book",
	new XAttribute("publisher",
	b.PublisherName),
	new XElement("title", b.Title),
	new XElement("authors",
	from a in db.GetAuthorByBookId(
	b.BookId)
	select new XElement("author",
	a.AuthorName))));
Console.WriteLine(books);

Figure 5: Result of running a nested query

Lambda Expressions

Func<int, int> square = x => x * x;
Console.WriteLine(square(3));

Let’s now apply what we have just learned to filtering an in-memory collection. Just as before, our lambda expression will take a single argument, but this time return a Boolean value determined by whether or not the argument satisfied the expression:

List<string> people =
	new List<string>()
	{ "Granville", "Rachel",
	"John", "Ross",
	"Monica" };
IEnumerable<string> expr =
	people.Where(x =>
	x.Length > 4);
foreach (string person
	in expr) {
	Console.WriteLine(person);
}

For our final example we will use a lambda expression to select only the AuthorName property of the Author entity instead of creating an anonymous type. First we show how we would do this returning an anonymous type:

BookShop db = new BookShop(_conn);
var authors = from a in db.Authors
	select new { a.AuthorName };
foreach (var author in authors) {
	Console.WriteLine(
		author.AuthorName);
}

BookShop db = new BookShop(_conn);
IEnumerable<string> authors =
	db.Authors.Select(
	x => x.AuthorName);
foreach (string author in authors) {
	Console.WriteLine(author);
}

Summary

Granville Barnett’s interest in programming has spanned many languages – currently he is more than happy developing in C# (and the .NET framework in general), and C++. Granville’s blog is at gbarnett.org.

Return to XML & Web Services Zone