Deborah's Developer MindScape : C#, LINQ

LINQ: Mean, Median, and Mode

Deborah Kurata — Fri, 07 May 2010 07:23:34 GMT

If you are doing any type of statistical analysis, you probably need to calculate mean, median and mode. There are lots of places on the Web you can find the calculations. This post is different than most in that it uses LINQ and Lambda expressions.

Mean is the statistical average of a set of numbers. This one is easy with LINQ because of the Average function.

In C#:

int[] numbers = { 4, 4, 4, 4, 3, 2, 2, 2, 1 };

double mean = numbers.Average();
Debug.WriteLine(("Mean: " + mean));

In VB:

Dim numbers() As Integer = {4, 4, 4, 4, 3, 2, 2, 2, 1}

Dim mean As Double = numbers.Average()
Debug.WriteLine("Mean: " & mean)

The result is:

Mean: 2.88888888888889

This code uses the Average extension method on the IEnumerable class to calculate the mean, or average, of the numbers.

Median is the middle number of a set of numbers. If there is an even number of entries, it is the average of the two middle numbers.

In C#:

int[] numbers = { 4, 4, 4, 4, 3, 2, 2, 2, 1 };

int numberCount = numbers.Count();
int halfIndex = numbers.Count()/2;
var sortedNumbers = numbers.OrderBy(n=>n);
double median;
if ((numberCount % 2) == 0)
{
    median = ((sortedNumbers.ElementAt(halfIndex) +
        sortedNumbers.ElementAt((halfIndex - 1)))/ 2);
} else {
    median = sortedNumbers.ElementAt(halfIndex);
}
Debug.WriteLine(("Median is: " + median));

In VB:

Dim numbers() As Integer = {4, 4, 4, 4, 3, 2, 2, 2, 1}

Dim numberCount As Integer = numbers.Count
Dim halfIndex As Integer = numbers.Count \ 2
Dim sortedNumbers = numbers.OrderBy(Function(n) n)
Dim median As Double
If (numberCount Mod 2 = 0) Then
    median = (sortedNumbers.ElementAt(halfIndex) +
       sortedNumbers.ElementAt(halfIndex - 1)) / 2
Else
    median = sortedNumbers.ElementAt(halfIndex)
End If
Debug.WriteLine("Median is: " & median)

The result is:

Median is: 3

This code first counts the numbers and divides the count by 2 to find the middle of the list. Note that the VB code uses the backslash (\) to perform an integer division where the C# code uses a forward slash (/) for the division.

It then sorts the numbers in order using the OrderBy extension method and a Lambda expression that simply orders by the numbers.

The last step is to get the element at the middle (if odd) or the average of the two middle elements (if even). The result is the median.

Mode is the number that occurs the largest number of times.

In C#:

int[] numbers = { 4, 4, 4, 4, 3, 2, 2, 2, 1 };

var mode = numbers.GroupBy(n=> n).
OrderByDescending(g=> g.Count()).
Select(g => g.Key).FirstOrDefault();
Debug.WriteLine(("Mode is: " + mode));

In VB:

Dim numbers() As Integer = {4, 4, 4, 4, 3, 2, 2, 2, 1}

Dim mode = numbers.GroupBy(Function(n) n).
OrderByDescending(Function(g) g.Count).
Select(Function(g) g.Key).FirstOrDefault
Debug.WriteLine("Mode is: " & mode)

The result is:

Mode is: 4

This code uses the GroupBy extension method on IEnumerable to group the numbers by number. It then orders them by the count and selects the first one. This provides the number that occurs the most times.

Use these techniques whenever you need to calculate the mean, median, or mode.

Enjoy!

Grouping and Summing with Lambda Expressions

Deborah Kurata — Tue, 04 May 2010 05:43:05 GMT

There are often cases where you need to group on multiple properties and potentially sum on others. This post details how to group and sum on multiple properties using lambda expressions.

This example uses an Invoice class, since that provides many opportunities for summing. First, here is a basic Invoice class.

In C#:

class Invoice
{
    public DateTime InvoiceDate { get; set; }
    public int InvoiceType { get; set; }
    public decimal InvoiceAmount { get; set; }
    public int NumberOfItems { get; set; }
}

In VB:

Public Class Invoice
    Public Property InvoiceDate As DateTime
    Public Property InvoiceType As Integer
    Public Property InvoiceAmount As Decimal
    Public Property NumberOfItems As Integer
End Class

Normally, you would populate the Invoice class from data in a database or other data store. But to keep this example simple, the values for the invoices are hard-coded.

In C#:

List<Invoice> invoiceList = new List<Invoice>();

invoiceList = new List<Invoice>
        {new Invoice()
              {
                InvoiceDate=new DateTime(2010,4,30),
                InvoiceType = 1,
                InvoiceAmount = 150,
                NumberOfItems = 8},
        new Invoice()
              {
                InvoiceDate=new DateTime(2010,4,29),
                InvoiceType = 2,
                InvoiceAmount = 215,
                NumberOfItems = 7},
        new Invoice()
              {
                InvoiceDate=new DateTime(2010,4,30),
                InvoiceType = 1,
                InvoiceAmount = 50,
                NumberOfItems = 2},
        new Invoice()
              {
                InvoiceDate=new DateTime(2010,4,29),
                InvoiceType = 2,
                InvoiceAmount = 550,
                NumberOfItems = 5}};

In VB:

Dim invoiceList As List(Of Invoice)

invoiceList = New List(Of Invoice) From
            {New Invoice With
                  {
                    .InvoiceDate = New DateTime(2010, 4, 30),
                    .InvoiceType = 1,
                    .InvoiceAmount = 150,
                    .NumberOfItems = 8},
            New Invoice With
                  {
                    .InvoiceDate = New DateTime(2010, 4, 29),
                    .InvoiceType = 2,
                    .InvoiceAmount = 215,
                    .NumberOfItems = 7},
            New Invoice With
                  {
                    .InvoiceDate = New DateTime(2010, 4, 30),
                    .InvoiceType = 1,
                    .InvoiceAmount = 50,
                    .NumberOfItems = 2},
            New Invoice With
                  {
                    .InvoiceDate = New DateTime(2010, 4, 29),
                    .InvoiceType = 2,
                    .InvoiceAmount = 550,
                    .NumberOfItems = 5}}

This code creates two invoices of type 1 that are dated 4/30/2010 and two invoices of type 2 that are dated 4/29/2010.

Now for the fun part. This example groups on both the InvoiceDate and the InvoiceType properties. The totals accumulate the invoice amount and the number of items. This allows the code to provide totals based both on the date and type.

In C#:

var query = invoiceList
            .GroupBy(g => new { g.InvoiceDate,
                                g.InvoiceType })
            .Select(group => new {
                       InvoiceDate = group.Key.InvoiceDate,
                       InvoiceType = group.Key.InvoiceType,
                       TotalAmount = group.Sum(a=>a.InvoiceAmount),
                       TotalCount = group.Sum(c=>c.NumberOfItems)});

In VB:

Dim query = invoiceList.
           GroupBy(Function(g) New With {Key g.InvoiceDate,
                                         Key g.InvoiceType}).
           Select(Function(group) New With {
              .InvoiceDate = group.Key.InvoiceDate,
              .InvoiceType = group.Key.InvoiceType,
              .TotalAmount = group.Sum(Function(a) a.InvoiceAmount),
              .TotalCount = group.Sum(Function(c) c.NumberOfItems)})

This code starts with a GroupBy clause with a Lambda expression. The Lambda expression (indicated with the => syntax in C# and the Function keyword in VB) uses the new keyword to create a new anonymous type with two properties: InvoiceDate and InvoiceType. This technique allows the code to group on both properties. More properties can be included here if you need to group on more than two properties.

Notice the Key modifier on the two properties in the Lambda expression for the VB example. This ensures that the anonymous type is immutable, providing read-only values. This is not necessary in the C# code because C# only supports immutable anonymous types.

The next part of the above code is a Select clause with another Lambda expression. The Lambda expression uses the new keyword to create an anonymous type with four properties: the invoice date and type from the grouping and the two totals. Each total uses a Sum clause with a Lambda expression defining the property to sum.

The group.Key syntax provides the key values from the grouping, which in this case are the properties from our first anonymous type.

The group.Sum syntax provides a sum on a particular property in the original list.

To view the results of the query, the code can display the items.

In C#:

foreach (var item in query)
{
    Console.WriteLine("Invoice Date: {0} ({1}) TotalAmount: {2} TotalCount: {3}",
                        item.InvoiceDate.ToShortDateString(),
                        item.InvoiceType,
                        item.TotalAmount,
                        item.TotalCount);
}

In VB:

For Each item In query
    Console.WriteLine("Invoice Date: {0} ({1}) TotalAmount: {2} TotalCount: {3}",
                        item.InvoiceDate.ToShortDateString(),
                        item.InvoiceType,
                        item.TotalAmount,
                        item.TotalCount)
Next

The result is as follows:

Invoice Date: 4/30/2010 (1) TotalAmount: 200 TotalCount: 10
Invoice Date: 4/29/2010 (2) TotalAmount: 765 TotalCount: 12

Use this technique any time you need to group or sum information in your business objects.

Enjoy!

Finding a set of Nodes in an XML String

Deborah Kurata — Thu, 25 Mar 2010 16:48:43 GMT

In this prior post, I demonstrated how to find a node in an XML string. In this post, I expand on that topic to find a set of nodes. You can then process those nodes as needed in your application. In this example, the set of nodes are displayed in a ComboBox.

If you are targeting the .NET Framework version 3.5 or later, you can use Linq to XML to retrieve a set of nodes. This example using Linq.

Here is the XML we will use in this example:

Starting with a simple example, let's find the set of all regions and display them in a combo box.

In C#:

// Build a list of region names
var regionElements = doc.Descendants("Region");
var regionEnumeration = regionElements.Select
(r => r.Attribute("name").Value);
List<string> regionList = regionEnumeration.ToList();
regionList.Sort();

// Bind to a ComboBox
comboBox1.DataSource = regionList;

// OR

List<string> regions = doc.Descendants("Region").Select
(r => r.Attribute("name").Value).ToList();
regions.Sort();
comboBox1.DataSource = regions;

In VB:

' Build a list of region names
Dim regionElements = doc...<Region>
Dim regionEnumeration = regionElements.Select(Function(r) r.@name)
Dim regionList As List(Of String) = regionEnumeration.ToList
regionList.Sort()

' Bind to a ComboBox
ComboBox1.DataSource = regionList

' OR

Dim regions As List(Of String) = doc...<Region>.Select _
(Function(r) r.@name).ToList
regions.Sort()
ComboBox1.DataSource = regions

The code first finds the set of region elements. The C# code uses the XElement methods and the VB code uses XML literals.

Only the name of the regions are needed, so the next statement selects the name attribute. Again, the C# code uses the XElement methods and the VB code uses XML literals.

NOTE: You can also use the XElement methods in VB as well.

The enumeration is then converted to a list so it can be sorted and assigned as a DataSource.

The second set of code combines the set of Linq to XML statements into one for a more condensed version of the code.

The result is as follows:

Use this technique any time you need to retrieve a set of nodes from an XML file.

Enjoy.

Binding to a ComboBox using a DataTable and Linq

Deborah Kurata — Sun, 28 Feb 2010 01:47:24 GMT

If you retrieve data into a DataTable, it is easy to bind it to a ComboBox. And before Linq, you would filter the DataTable using a DataView. But with Linq, you have some easy to use features for filtering the contents of your ComboBox.

First, here is the basic code for binding a ComboBox to a DataTable.

In C#:

private DataTable dt = Customers.Retrieve();

ComboBox1.DataSource = dt;
ComboBox1.DisplayMember = "FullName";
ComboBox1.ValueMember = "CustomerId";

In VB:

Private dt As DataTable = Customers.Retrieve

ComboBox1.DataSource = dt
ComboBox1.DisplayMember = "FullName"
ComboBox1.ValueMember = "CustomerId"

The Retrieve method on the Customers class retrieves a DataTable of customers. If you want to try this code, you can build a DataTable in code following the techniques covered here.

You can then set the DataSource to the DataTable, set the DisplayMember to the name of the field to display in the ComboBox, and set the ValueMember to the name of the field to use as the field value. This is most often the unique key.

The result looks like this:

With Linq you can add filtering criteria. So let's add a second ComboBox that lists only the customers with a last name that starts with "B".

NOTE: Be sure to set a reference to System.Data.DataSetExtensions.

In C#:

var query = dt.AsEnumerable().Where(c=>
c.Field<String>("LastName").StartsWith("B"));

ComboBox2.DataSource = query.AsDataView();
ComboBox2.DisplayMember = "FullName";
ComboBox2.ValueMember = "CustomerId";

In VB:

Dim query = dt.AsEnumerable.Where(Function(c) _
c.Field(Of String)("LastName").StartsWith("B"))

ComboBox2.DataSource = query.AsDataView
ComboBox2.DisplayMember = "FullName"
ComboBox2.ValueMember = "CustomerId"

This code uses a Lambda expression to filter the DataTable to only those rows where the LastName starts with "B".

The AsEnumerable extension method is necessary to allow Linq/Lambda expressions to work with a DataTable. Any field in the DataTable is accessed using c.Field<T> Or c.Field(Of T) where T is the type of the field. In this example, the field is a string.

The second ComboBox is then bound to the query using the AsDataView extension method. This allows the binding to bind the result as a DataView.

The result looks like this.

But wait, there is more. Because of the way that binding works. adding rows to the DataTable will add rows to the first ComboBox that is bound to the DataTable. AND if the new row starts with the letter "B", it will add it to the second ComboBox as well.

In this example, code in the Add button does this:

In C#:

private void Button1_Click(object sender, EventArgs e)
{
dt.Rows.Add(5, "Bond", "James", "Bond, James", DBNull.Value, DBNull.Value, DBNull.Value, DBNull.Value, DBNull.Value, DBNull.Value, 3);
}

In VB:

Private Sub Button1_Click2(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles Button1.Click
dt.Rows.Add(5, "Bond", "James", "Bond, James", DBNull.Value, DBNull.Value, DBNull.Value, DBNull.Value, DBNull.Value, DBNull.Value, 3)
End Sub

Click the button and the result is as follows:

No refreshing or re-executing binding code required. It just works!!

Use this technique any time you want to bind a ComboBox to a filtered set of data from a DataTable.

Enjoy!

Finding a Node in an XML String

Deborah Kurata — Sun, 31 Jan 2010 22:21:40 GMT

A common requirement with an XML file is to find a particular node. If you are targeting the .NET framework 3.5 or higher, you can find the node using Linq to XML or by using Lambda expressions.

As with many of my prior XML examples, the XML string is as follows:

The code to find the node for the Milwaukee region is as follows:

In C#:

// Be sure to set a reference to System.Core and System.Xml.Linq
XElement states = XElement.Load("testXML.xml");

// Using LINQ
XElement foundNode;
var query = from XElement r in states.Descendants("Region")
where r.Attribute("name").Value == "Milwaukee"
select r;
foundNode = query.FirstOrDefault();

// Using Lambda expressions
foundNode = states.Descendants("Region").
Where(r => r.Attribute("name").Value ==
"Milwaukee").FirstOrDefault();

In VB:

' Be sure to set a reference to System.Core and System.Xml.Linq
Dim states As XElement = XElement.Load("testXML.xml")

' Using LINQ
Dim foundNode As XElement
Dim query = From r As XElement In states...<Region> _
Where r.@<name> = "Milwaukee"
foundNode = query.FirstOrDefault()

' Using Lambda expression
foundNode = states...<Region>.Where(Function(r) r.@<name> = _
"Milwaukee").FirstOrDefault

This code first loads the XML file containing the XML. The next set of code can be done using LINQ or using Lambda expressions. Use either one, but not both. :-)

The C# code uses the XElement properties and methods. The VB code uses XML literals.

NOTE: The XElement properties and methods work in VB as well.

Enjoy!

NOTE: This post was created based on a prior post that included both finding a node and adding new nodes. This post separates the first step to provide a more straightforward example.

Populating a DataGridView from Xml Data

Deborah Kurata — Wed, 21 Oct 2009 04:49:09 GMT

If you are using XML in a WinForms application you may find the need to display the XML data in a DataGridView.

Let's take this XML:

<states>
    <state name="California">
        <abbreviation>CA</abbreviation>
        <year>1850</year>
        <governor>Schwarzenegger</governor>
    </state>
    <state name="Wisconsin">
        <abbreviation>WI</abbreviation>
        <year>1848</year>
        <governor>Doyle</governor>
    </state>
</states>

Displaying XML in a DataGridView sounds easy, but if you just set the DataGridView DataSource to the XML data, you will get something like this:

Notice how it has lots of yuck in it: attribute details, node properties, and so on for every node in the XML. So how do you get something more like this:

The trick is to use anonymous types.

The code is provided here in VB and C# and then described in detail below.

NOTE: Be sure to set a reference to System.Core and System.Xml.Linq

In C#:

XElement statesXml = XElement.Parse("<states>" +
    "<state name='California'>" +
        "<abbreviation>CA</abbreviation>" +
        "<year>1850</year>" +
        "<governor>Schwarzenegger</governor>" +
    "</state>" +
    "<state name='Wisconsin'>" +
        "<abbreviation>WI</abbreviation>" +
        "<year>1848</year>" +
        "<governor>Doyle</governor>" +
    "</state>" +
   "</states>");

var query = from st in statesXml.Descendants("state")
            select new
            {
                Name = st.Attribute("name").Value,
                Abbrev = st.Element("abbreviation").Value,
                Year = st.Element("year").Value,
                Governor = st.Element("governor").Value
            };
DataGridView1.DataSource = query.ToList();

In VB:

Dim statesXml As XElement = _
    <states>
        <state name="California">
            <abbreviation>CA</abbreviation>
            <year>1850</year>
            <governor>Schwarzenegger</governor>
        </state>
        <state name="Wisconsin">
            <abbreviation>WI</abbreviation>
            <year>1848</year>
            <governor>Doyle</governor>
        </state>
    </states>

Dim query = From st In statesXml...<state> _
            Select New With { _
                  .Name = st.@name, _
                  .Abbrev = st.<abbreviation>.Value, _
                  .Year = st.<year>.Value, _
                  .Governor = st.<governor>.Value}
DataGridView1.DataSource = query.ToList

The first part of this code builds the XML. The C# code uses the XElement.Parse function to build the XML; VB uses XML literals. This part of the code is not necessary if you are reading the XML from another source, such as a file.

The second part of the code leverages Linq to XML to process the set of state XML elements. For each element, it uses the Select New syntax to create an anonymous type. The syntax defines an unnamed (anonymous) type with properties Name, Abbrev, Year, and Governor.

[To view an overview of anonymous types, start here.]

The last line converts the results of the query to a generic list and assigns it to the DataSource property of the DataGridView. Visual Studio uses the anonymous type property names as the text for the column titles and populates the rows with each state element.

Use this technique any time you have XML that you want to display in a DataGridView.

Enjoy!

Lambda Expressions: Finding an Item in a Generic List

Deborah Kurata — Sun, 11 Oct 2009 19:52:53 GMT

In this prior post, I detailed how to build lists of things using a generic List<T>. Once you have a list, you may need to find items in the list. There are several ways to accomplish this, but using lambda expressions is the most concise.

[To begin with an overview of lambda expressions, start here.]

For example, here is how you find an item in a generic list using a for/each statement.

In C#:

Customer foundCustomer = null;
foreach (var c in custList)
{
    if (c.CustomerId == 4)
    {
        foundCustomer = c;
        break;
    }
}
Debug.WriteLine(foundCustomer);

In VB:

Dim foundCustomer As Customer = Nothing
For Each c As Customer In custList
    If c.CustomerId = 4 Then
        foundCustomer = c
        Exit For
    End If
Next
Debug.WriteLine(foundCustomer)

Notice the amount of code required to loop through each item in the list and find the one with a particular customer Id.

You may have heard about language integrated query (LINQ) and how you can use it to search a list.

In C#:

Customer foundCustomer = null;
var query = from c in custList
where c.CustomerId == 4
select c;
foundCustomer = query.FirstOrDefault();
Debug.WriteLine(foundCustomer);

In VB:

Dim foundCustomer As Customer = Nothing
Dim query = From c As Customer In custList _
Where c.CustomerId = 4 _
Select c
foundCustomer = query.FirstOrDefault()
Debug.WriteLine(foundCustomer)

So LINQ is cool, but the code does not seem much shorter.

Now let’s look at using lambda expressions to find the item in the list.

In C#:

Customer foundCustomer = null;
foundCustomer = custList.FirstOrDefault(c =>
c.CustomerId == 4);
Debug.WriteLine(foundCustomer);

The lambda expression syntax in C# looks like this:

c => c.CustomerId == 4

The code begins with the set of parameters to the lambda expression. The => is the “goes to” or lambda operator. The remainder of the code is the expression itself. In this case, checking for the item in the list where CustomerId is 4.

In VB:

Dim foundCustomer As Customer = Nothing
foundCustomer = custList.FirstOrDefault(Function(c)
c.CustomerId = 4)
Debug.WriteLine(foundCustomer)

The lambda expression syntax in VB looks like this:

Function(c) c.CustomerId = 4

The code begins with the word “Function” along with the set of parameters to the lambda expression. The remainder of the code is the expression itself. In this case, checking the item in the list where CustomerId is 4.

.NET 3.5 added a large list of extension methods on the Enumerable class. Any object that implements IEnumerable or IEnumerable<T> (basically any object you can do a for/each over) can use these methods. Many of these extension methods (such as the FirstOrDefault method shown in the above example) support lambda expressions.

The FirstOrDefault extension method of the Enumerable class returns the first item in the list or the default value for the object. If you pass it a lambda expression, it returns the first item in the list that matches the Boolean expression.

Enjoy!

Enumerable.Repeat

Deborah Kurata — Fri, 04 Sep 2009 20:57:27 GMT

The Enumerable class is new in .NET 3.5 and is part of the System.Linq namespace. It provides a set of static methods that allow you to query any object that implements IEnumerable, basically meaning any object that supports a for/each.

This post focuses on the Repeat method of the Enumerable class and some of the helpful things that this class can do for you.

NOTE: Be sure to set a reference to System.Core.

First, at the top of your code file, add this code.

In C#:

using System.Linq;

In VB:

Imports System.Linq

(Or for VB you can import a namespace using the project properties.)

You can then use the Enumerable.Repeat as shown in the following examples.

In C#:

// Initialize an array to -1 for each of 10 elements
int[] all1 = Enumerable.Repeat(-1, 10).ToArray();

// Initialize an array to "A" for each of 10 elements
string[] allA = Enumerable.Repeat("A", 10).ToArray();

// Convert a single value to an array
int value = 42;
int[] valueArray = Enumerable.Repeat(value, 1).ToArray();

// Generate 10 random numbers
Random rand = new Random();
int[] randomArray = Enumerable.Repeat(0, 10).Select(
i => rand.Next(0,10)).ToArray();

// Initialize a list with 5 Customer objects
List<Customer> custList = Enumerable.Repeat(
new Customer(), 10).ToList();

In VB:

' Initialize an array to -1 for each of 10 elements
Dim all1() As Integer = Enumerable.Repeat(-1, 10).ToArray()

' Initialize an array to "A" for each of 10 elements
Dim allA() As String = Enumerable.Repeat("A", 10).ToArray()

' Convert a single value to an array
Dim value As Integer = 42
Dim valueArray() As Integer = Enumerable.Repeat(value, 1).ToArray()

' Generate 10 random numbers
Dim rand As Random = New Random()
Dim randomArray() As Integer = Enumerable.Repeat(0, 10).Select( _
Function(i) rand.Next(0, 10)).ToArray()

' Initialize a list with 5 Customer objects
Dim custList As List(Of Customer) = Enumerable.Repeat( _
New Customer(), 10).ToList()

The first example initializes an array of 10 integers to –1.

The second example initializes an array of 10 strings to "A".

The third example takes a single value and creates an array from it. This is often necessary when a method requires an array instead of a single element.

The random number example provides another way to generate a random numbers. In this case, it generates 10 random numbers between 0 and 9. Note that this does not ensure uniqueness, so the number 2 for example could occur multiple times in the list.

The last example initializes a list of business objects to an empty set of objects. You could use object initializer syntax in this example to initialize all of the objects to some set of values, such as setting the State = "CA". This could be useful in setting up data for testing or prototyping.

Use the Repeat method any time you want to repeat values in an array or list.

Enjoy!

Adding Nodes to an XML String

Deborah Kurata — Thu, 20 Aug 2009 22:49:58 GMT

I have an XML string as follows:

I now want to add another area under Milwaukee called "Wauwatosa".

The code to accomplish this task is as follows.

In C#:

// Be sure to set a reference to System.Core and System.Xml.Linq
XElement states = XElement.Load("testXML.xml");

// New element under the Milwaukee region
XElement newElement = XElement.Parse(@"<Area name='Wauwatosa'/>");

// Find the desired parent element
// Using LINQ
XElement parentNode;
var parentQuery = from XElement r in states.Descendants("Region")
where r.Attribute("name").Value == "Milwaukee"
select r;
parentNode = parentQuery.FirstOrDefault();

// Using Lambda expression
parentNode = states.Descendants("Region").
Where(r => r.Attribute("name").Value ==
"Milwaukee").FirstOrDefault();

if (parentNode != null)
parentNode.Add(newElement);

states.Save("Revised.xml");

In VB:

' Be sure to set a reference to System.Core and System.Xml.Linq
Dim states As XElement = XElement.Load("testXML.xml")

' New element under the Milwaukee region
Dim newElement As XElement = <Area name="Wauwatosa"/>

' Find the desired parent element
' Using LINQ
Dim parentNode As XElement
Dim parentQuery = From r As XElement In states...<Region> _
Where r.@<name> = "Milwaukee"
parentNode = parentQuery.FirstOrDefault()

' Using Lambda expression
parentNode = states...<Region>.Where(Function(r) r.@<name> = _
"Milwaukee").FirstOrDefault

If (parentNode IsNot Nothing) Then
parentNode.Add(newElement)
End If

states.Save("Revised.xml")

This code first loads in the XML file containing the XML at the top of this post. The code then defines the new element for Wauwatosa using XML literals in VB and the XElement properties and methods in C#.

NOTE: The XElement Descendants property works in VB as well.

The next set of code can be done using LINQ or using Lambda expressions. Use either one, but not both. :-)

If the appropriate parent element was found, the new element is added to it. The Add method adds the element as a child element.

Finally, the code saves the revised XML:

Enjoy!

Processing Files Using Anonymous Types

Deborah Kurata — Wed, 19 Aug 2009 21:06:01 GMT

Another use of anonymous types is for processing directories or files. For example, your application needs to collect a set of files and then process them based on a subset of the file properties.

[To begin with an overview of anonymous types, start here.]

Here is an example.

In C#:

// Query the set of files
var fileTemplateQuery = from FileInfo f in
            new DirectoryInfo(@"C:\temp")
            .GetFiles("*.*", SearchOption.AllDirectories)
                 where f.Extension.ToLower() == ".xml" ||
                       f.Extension.ToLower() == ".txt"
                 select new
                 {
                    DateLastModified = f.LastWriteTime,
                    Extension = f.Extension,
                    Size = f.Length,
                    FileName = f.Name
                 };

foreach (var f in fileTemplateQuery.OrderBy(file =>
                                    file.DateLastModified))
    // Do whatever you need to with the files
    Debug.WriteLine(f.FileName);

In VB:

Dim fileTemplateQuery = From f As FileInfo In _
            My.Computer.FileSystem.GetDirectoryInfo("C:\temp") _
            .GetFiles("*.*", SearchOption.AllDirectories) _
                 Where f.Extension.ToLower = ".xml" OrElse _
                       f.Extension.ToLower = ".txt" _
                 Select New With _
                 { _
                    .DateLastModified = f.LastWriteTime, _
                    .Extension = f.Extension, _
                    .Size = f.Length, _
                    .FileName = f.Name _
                  }

For Each f In _
   fileTemplateQuery.OrderBy(Function(file) file.DateLastModified)
    ' Do whatever you need to with the files
    Debug.WriteLine(f.FileName)
Next

This code uses Linq to find a specific set of files. In this case, it finds all of the files in C:\temp and its subdirectories where the extension is .xml or .txt. It then uses an anonymous type to retain the set of desired file properties.

The for/each statement loops through the set of anonymous types in order by date and performs whatever operation is required to process the files.

Enjoy!

Anonymous Types: An Introduction

Deborah Kurata — Wed, 19 Aug 2009 19:31:01 GMT

The last several posts have provided examples of using anonymous types. This post backs up a little and provides an introduction if you are not already familiar with anonymous types.

If you are familiar with anonymous types and are looking for more examples, check out these links:

Anonymous types are new in C# 3.0 and VB 9.0 (Visual Studio 2008). An anonymous type allows you to encapsulate a set of properties (not methods) into a specific object without explicitly defining a type.

When you create a class, such as a Customer class, you are explicitly creating a Customer type with defined properties and methods. The resulting class defines a Customer type which is a named type with the name Customer.

There are times, however, where you need a temporary type. You could explicitly create this type using a class, but that seems like overkill if you only plan to use the type within one routine. This is where an anonymous type is very useful.

It is important to note that the properties of an anonymous type are read/write in VB, but read-only in C#.

You can create an anonymous type manually using the following syntax.

In C#:

var stats = new {Name = String.Empty, Max = 0,
Min = 0, Ave = 0};

In VB:

Dim stats = New With {.Name = String.Empty, .Max = 0, _
.Min = 0, .Ave = 0}

This code creates an anonymous type with Name, Max, Min, and Ave properties. This anonymous type defines some statistics. For example, a list of students each have a set of scores for a class. This anonymous type provides the student's name and score statistics.

However, using the syntax in this example is not the usual way to create anonymous types. Rather, the most common technique for creating anonymous types is within a Linq statement.

In C#:

In VB:

Dim scoreQuery = From s As Student In Students _
             Select New With {.Name = s.LastName, _
                              .Max = s.Scores.Max(), _
                              .Min = s.Scores.Min(), _
                              .Ave = s.Scores.Average()}
For Each s In scoreQuery
    Debug.Print("Student Name: {0}", s.Name)
    Debug.Print("Min: {0}, Max: {1}, Ave: {2}", s.Max, s.Min, s.Ave)
Next

NOTE: This code assumes you have a Student class with LastName and Scores properties (see below) and a populated List<Student> with several students and their scores.

The Linq statement in this example processes each student in the list of students. For each student, it creates an instance of the anonymous type with the student's name and the appropriate statistics.

The for/each loops through the resulting set of anonymous types and displays the results.

In my example, the results are as follows:

Student Name: Baggins
Min: 97, Max: 65, Ave: 87.2
Student Name: Cotton
Min: 100, Max: 90, Ave: 93.6
Student Name: Brandybuck
Min: 88, Max: 65, Ave: 79.6

Here is the minimum code for the Student class used in this example:

In C#:

public class Student
{
public string LastName { get; set; }
public List<int> Scores { get; set; }
}

In VB:

Public Class Student
    Private _LastName As String
    Public Property LastName() As String
        Get
            Return _LastName
        End Get
        Set(ByVal value As String)
            _LastName = value
        End Set
    End Property

    Private _Scores As List(Of Integer)
    Public Property Scores() As List(Of Integer)
        Get
            Return _Scores
        End Get
        Set(ByVal value As List(Of Integer))
            _Scores = value
        End Set
    End Property

End Class

Anyone else found interesting ways to use anonymous types? I'd enjoy hearing about it…

Enjoy!

Defining Lists of Anonymous Types

Deborah Kurata — Tue, 18 Aug 2009 06:44:00 GMT

Similar to my prior post here that details how to use anonymous types to display word counts, this post details how to track information on the physical lines that contain each word. Again, this specific task is more like a homework assignment than a business issue, but it does demonstrate how to work with lists of anonymous types.

[To begin with an overview of anonymous types, start here.]

First, the code needs an extension method. This extension method returns a generic List of a particular anonymous type.

In C#:

public static List<T> ListOfType<T>(this T type)
{
return new List<T>();
}

In VB:

NOTE: This code must reside in a module.

<Extension()> _
Public Function ListOfType(Of T)(ByVal type As T) As List(Of T)
Return New List(Of T)
End Function

Without this extension method, you would have no way to create a List<of anonymous type>. You can use this extension method any time you want to work with a list of your anonymous types.

The following code defines a list of all words in the sentence along with each physical line containing the word.

NOTE: Be sure to set a reference to System.Text.RegularExpressions.

In C#:

// Sample string
string sampleText = @"That that is, is.
That that is not, it not.
Is that it? It is.";

// Convert to lower case
sampleText = sampleText.ToLower();

// Split into lines
char[] lineSeparator =new char[1] {Convert.ToChar(10)};
string[] lineArray = sampleText.Split(lineSeparator,
StringSplitOptions.RemoveEmptyEntries);

// Define the anonymous type and List(of anonymous type)
var wordLines = new {Word = String.Empty, Line = 0};
var listOfWordLines = wordLines.ListOfType();

string lineText;
string[] lineWords;
string[] separators = new string[4] {" ", ".", ",", "?"};
for (int i = 0; i < lineArray.Count(); i++)
{
    lineText = Regex.Replace(lineArray[i], @"\s+", " ");
    lineWords = lineText.Split(separators,
                          StringSplitOptions.RemoveEmptyEntries);

    // Using an anonymous type
    int lineNumber = i + 1;
    var lineQuery = from string w in lineWords.Distinct()
                select new {Word = w, Line = lineNumber};
    listOfWordLines.AddRange(lineQuery);
}

var wordGroupQuery = from wordLine in listOfWordLines
                     group wordLine by wordLine.Word into g
                     orderby g.Key
                     select new { word = g.Key, wordGroup = g };

foreach (var g in wordGroupQuery)
{
    Debug.Write(g.word + ": ");
    foreach (var lineNumber in g.wordGroup)
        Debug.Write(lineNumber.Line + " ");
    Debug.WriteLine("");
}

In VB:

NOTE: For the VB code, be sure to also set a reference to System.Xml, System.Xml.Linq, and System.Core.

' Sample string
Dim sampleText As String = <string>That that is, is.
That that is not, it not.
Is that it? It is.</string>.Value

' Convert to lower case
sampleText = sampleText.ToLower

' Split into lines
Dim lineSeparator() As String = {Chr(10)}
Dim lineArray() As String = sampleText.Split(lineSeparator, _
StringSplitOptions.RemoveEmptyEntries)

' Define the anonymous type and List(of anonymous type)
Dim wordLines = New With {.Word = String.Empty, .Line = 0}
Dim listOfWordLines = wordLines.ListOfType()

Dim lineText As String
Dim lineWords() As String
Dim separators() As String = {" ", ".", ",", "?"}
For i As Integer = 0 To lineArray.Count - 1
    lineText = Regex.Replace(lineArray(i), "\s+", " ")
    lineWords = lineText.Split(separators, _
                                StringSplitOptions.RemoveEmptyEntries)

    ' Using an anonymous type
    Dim lineNumber As Integer = i + 1
    Dim lineQuery = From w As String In lineWords.Distinct _
                Select New With {.Word = w, .Line = lineNumber}
    listOfWordLines.AddRange(lineQuery)
Next

Dim wordGroupQuery = From wordLine In listOfWordLines _
          Group wordLine By currentWord = wordLine.Word Into Group _
          Select word = currentWord, wordGroup = Group _
          Order By Word

For Each g In wordGroupQuery
    Debug.Write(g.word & ": ")
    For Each lineNumber In g.wordGroup
        Debug.Write(lineNumber.Line & " ")
    Next
    Debug.WriteLine("")
Next

This code first builds a sample string. The C# code uses a verbatim string literal (@) to ensure that the string is interpreted verbatim. In VB, the code uses the XML literals feature new in .Net 3.5 to build a sample string.

The code converts the string to lower case so that the routine treats “The” and “the” as the same word. It then splits the string into its physical lines. The lineArray contains the text of each physical line in the string.

The next two lines of code define the anonymous type and the List of the anonymous type. You can define any desired properties of an anonymous type by adding them within the { }, separated by commas. In this example, two properties are defined: Word and Line. The Word property is the word from the string. The Line property is the number of the line containing the word. The ListOfType extension method creates a generic List of this type.

The code then loops through the lineArray. It first removes excess spaces from the line’s text, and any other white-space characters using a Regular Expression. It then splits the line of text into an array of words. If your string includes other punctuation marks, you will need to add them to the separators array.

The code uses LINQ to find the unique set of words. The Distinct method ensures that only unique words in the line are processed.

The select new syntax defines an anonymous type that is the same as the anonymous type defined earlier. This type defines the the set of words and line numbers for each line in the lineArray. The AddRange method of the List is used to append the words for each line into a single list.

At this point, the list of words and their physical line numbers is complete. The remaining code organizes the list for display. The code uses a Group By query to group the list by word. The final for/each loop then uses the groups to first display the word, then the list of line numbers that contain the word.

The result is:

is: 1 2 3
it: 2 3
not: 2
that: 1 2 3

Enjoy!

Counting Words in a String Using Anonymous Types

Deborah Kurata — Mon, 17 Aug 2009 18:10:53 GMT

This may be more of a homework assignment for a programming class than something you would do in your applications, but it is a good example of using anonymous types, which are new in .Net 3.5 in both VB and C#.

[To begin with an overview of anonymous types, start here.]

NOTE: Be sure to set a reference to System.Text.RegularExpressions.

In C#:

// Sample string
string sampleText = @"That that is, is.
That that is not, it not.
Is that it? It is.";

// Convert to lower case and convert double-spaces to a single space
sampleText = sampleText.ToLower();
sampleText = Regex.Replace(sampleText, @"\s+", " ");
string[] separators = new string[4] {" ", ".", ",", "?"};
string[] wordArray = sampleText.Split(separators,
StringSplitOptions.RemoveEmptyEntries);

// Sort the result
Array.Sort(wordArray);

// Using an anonymous type
var query = from string w in wordArray.Distinct()
            select new {Word = w,
        Count = wordArray.Count(wordToCount => wordToCount == w)};
foreach (var item in query)
    Debug.WriteLine(item.Word + ": " + item.Count);

In VB:

NOTE: For the VB code, be sure to also set a reference to System.Xml, System.Xml.Linq, and System.Core.

' Sample string
Dim sampleText As String = <string>That that is, is.
That that is not, it not.
Is that it? It is.</string>.Value

' Convert to lower case and convert double-spaces to a single space
sampleText = sampleText.ToLower
sampleText = Regex.Replace(sampleText, "\s+", " ")
Dim separators() As String = {" ", ".", ",", "?"}
Dim wordArray() As String = sampleText.Split(separators, _
StringSplitOptions.RemoveEmptyEntries)

' Sort the result
Array.Sort(wordArray)

' Using an anonymous type
Dim query = From w As String In wordArray.Distinct _
            Select New With {.Word = w, _
      .Count = wordArray.Count(Function(wordToCount) wordToCount = w)}
For Each item In query
    Debug.WriteLine(item.Word & ": " & item.Count)
Next

This code first builds a sample string. (Anyone recognize what movie this string came from?)

The C# code uses a verbatim string literal (@) to ensure that the string is interpreted verbatim. In VB, the code uses the XML literals feature new in .Net 3.5 to build a sample string.

The code converts the string to lower case so that the word count counts “The” and “the” as the same word. It then removes excess spaces, linefeeds, and other white-space characters.

It uses the string Split method to convert the string to an array of words and then sorts the words. If your string includes other punctuation marks, you will need to add them to the separators array.

The code uses LINQ to find the unique set of words and their counts. The District method is used to process only unique words from the list of words. This prevents duplicate words in the list.

The select new syntax defines an anonymous type to build a type comprised of the word itself and its count. You can define any desired properties of an anonymous type by adding them within the { }, separated by commas. In this example, two properties are defined: Word and Count. The Word property is the unique word. The Count property is the count of those words within the list. The Count property uses a Lambda expression to count the words.

Each item of the anonymous type is then displayed to the Debug window as follows:

is: 5
it: 3
not: 2
that: 5

This lists the word and the number of times it occurs in the string.

Enjoy!

P.S. (Edited 8/19/09) Though it does not demonstrate anonymous types, Eric Smith provided a *very* concise technique for counting words in a string using regular expressions and lambda expressions (see Comments below). I updated the code slightly to include the OrderBy and I provided the VB version of the code:

In C#:

foreach (var g in Regex.Matches(sampleText.ToLower(), @"\w+")
                    .Cast<Match>()
                    .GroupBy(m => m.Value)
                    .OrderBy(m => m.Key))
    Debug.WriteLine(g.Key + ": " + g.Count());

In VB:

For Each g In Regex.Matches(sampleText.ToLower(), "\w+") _
                .Cast(Of Match)() _
                .GroupBy(Function(m) m.Value) _
                .OrderBy(Function(m) m.Key)
    Debug.WriteLine(g.Key & ": " & g.Count())
Next

Using Linq with Microsoft Word and Excel

Deborah Kurata — Fri, 14 Aug 2009 20:14:16 GMT

Some of the collections in the Microsoft Office object models implement IEnumerable. The IEnumerable interface provides the ability to perform a for/each against the collection. With .NET 3.5, a Cast extension method of IEnumerable allows you to work with these collections using Linq.

Microsoft Word

For example, say you want to bind the set of open Word document names in a ComboBox.

First, set a reference to the desired version of the Microsoft Word Object Library from the COM tab of the Add Reference dialog. The resulting reference appears as Microsoft.Office.Interop.Word.

In C#:

// Add to the top of the code file
using Word = Microsoft.Office.Interop.Word;

// Add to a subroutine
Word.Application Wd;
Word.Document doc;
Word.Document doc2;
object missingValue = Missing.Value;

// Start Word and get Application object
Wd = new Word.Application();

// Define documents
doc = Wd.Documents.Add(ref missingValue,ref missingValue,
ref missingValue,ref missingValue );
doc2 = Wd.Documents.Add(ref missingValue, ref missingValue,
ref missingValue, ref missingValue);

// Use Linq to access the document names.
var query = from d in Wd.Documents.Cast<Word.Document>()
select d.Name;
comboBox1.DataSource = query.ToList();

// Or use Lambda expressions
var query2 = Wd.Documents.Cast<Word.Document>().Select(d=> d.Name);
comboBox1.DataSource = query2.ToList();

// Close
doc.Close(ref missingValue, ref missingValue, ref missingValue);
doc = null;
doc2.Close(ref missingValue, ref missingValue, ref missingValue);
doc2 = null;
Wd.Quit(ref missingValue, ref missingValue, ref missingValue);

// Clean up
// NOTE: When in release mode, this does the trick
GC.WaitForPendingFinalizers();
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect() ;

In VB:

' Add to the top of the code file
Imports Word = Microsoft.Office.Interop.Word

' Add to a subroutine
Dim Wd As Word.Application
Dim doc As Word.Document
Dim doc2 As Word.Document

' Start Word and get Application object
Wd = New Word.Application

' Define documents
doc = Wd.Documents.Add
doc2 = Wd.Documents.Add

' Use Linq to access the document names.
Dim query = From d In Wd.Documents.Cast(Of Word.Document)() _
Select d.Name
ComboBox1.DataSource = query.ToList

' Or use Lambda expressions
Dim query2 = Wd.Documents.Cast(Of Word.Document) _
.Select(Function(d) d.Name)
ComboBox1.DataSource = query2.ToList

' Close
doc.Close()
doc = Nothing
doc2.Close()
doc2 = Nothing
Wd.Quit()

' Clean up
' NOTE: When in release mode, this does the trick
GC.WaitForPendingFinalizers()
GC.Collect()
GC.WaitForPendingFinalizers()
GC.Collect()

In both of these examples, the code starts Word, creates two Word documents, uses either Linq or a Lambda expression to define a query and then binds the resulting set of document names to a Combo Box.

Notice the missingValue variable in the C# code that is not in the VB code. VB supports default parameters, but C# does not. So any time a parameter is defined for a Word method, C# must provide it. VB will use the default parameter values.

NOTE: A new feature in C# 4.0 (Visual Studio 2010) allows for default parameters in C# as well, dramatically simplifying the C# code that interacts with Word or Excel.

As another example, the following code retrieves all of the words from the defined Word document.

In C#:

var query = from w in doc.Words.Cast<Word.Range>()
select w.Text;
comboBox1.DataSource = query.ToList();

In VB:

Dim query = From w In doc.Words.Cast(Of Word.Range)() _
Select w.Text
ComboBox1.DataSource = query3.ToList

This code retrieves all of the words in the document defined by the doc variable. Instead of selecting the list of words, you could use any Linq feature such as finding only a specific set of words that match a criteria or counting the number of occurrences of a given word.

Microsoft Excel

This technique works with Excel as well. Say you want to bind the list of spreadsheets in an Excel workbook.

First, set a reference to the desired version of the Microsoft Excel Object Library from the COM tab of the Add Reference dialog. The resulting reference appears as Microsoft.Office.Interop.Excel.

In C#:

// Add to the top of the code file
using Excel = Microsoft.Office.Interop.Excel;

// Add to a subroutine
Excel.Application oXL;
Excel.Workbook oWB;
Excel.Worksheet oSheet;

// Start Excel and get Application object.
oXL = new Excel.Application();

// Get a new workbook.
oWB = oXL.Workbooks.Add(Missing.Value);

// Get the active sheet and change its name
oSheet = (Excel.Worksheet)oWB.ActiveSheet ;
oSheet.Name = "Test";

// Use Linq to access the spreadsheet names.
var query = from s in oXL.Worksheets.Cast<Excel.Worksheet>()
select s.Name;
comboBox1.DataSource = query.ToList();

// Or use Lambda expressions.
var query2 = oXL.Worksheets.Cast<Excel.Worksheet>()
.select(s => s.Name);
comboBox1.DataSource = query2.ToList();

// Close
oSheet = null;
oWB.Close(Missing.Value, Missing.Value, Missing.Value);
oWB = null;
oXL.Quit();

// Clean up
// NOTE: When in release mode, this does the trick
GC.WaitForPendingFinalizers();
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();

In VB:

' Add to the top of the code file
Imports Excel = Microsoft.Office.Interop.Excel

' Add to a subroutine
Dim oXL As Excel.Application
Dim oWB As Excel.Workbook
Dim oSheet As Excel.Worksheet

' Start Excel and get Application object.
oXL = New Excel.Application

' Get a new workbook.
oWB = oXL.Workbooks.Add

' Get the active sheet and change its name
oSheet = DirectCast(oWB.ActiveSheet, Excel.Worksheet)
oSheet.Name = "Test"

' Use Linq to access the spreadsheet names.
Dim query = From s In oXL.Worksheets.Cast(Of Excel.Worksheet)() _
Select s.Name
ComboBox1.DataSource = query.ToList

' Or use Lambda expressions
Dim query2 = oXL.Worksheets.Cast(Of Excel.Worksheet) _
.Select(Function(s) s.Name)
ComboBox1.DataSource = query2.ToList

' Close
oSheet = Nothing
oWB.Close()
oWB = Nothing
oXL.Quit()

' Clean up
' NOTE: When in release mode, this does the trick
GC.WaitForPendingFinalizers()
GC.Collect()
GC.WaitForPendingFinalizers()
GC.Collect()

In both examples, the code starts Excel, changes the name of the active sheet, uses either Linq or a Lambda expression to define a query and then binds the resulting set of sheet names to a Combo Box.

Enjoy!

EDITED 11/16/09: Added information on setting the appropriate reference.

Inferred Typing

Deborah Kurata — Tue, 28 Jul 2009 19:01:57 GMT

If you are using Visual Studio 2008 (.NET Framework 3.5) or newer, you can leverage inferred typing. Inferred typing allows the compiler to infer your data types instead of you having to explicitly define the type. Variables that use inferred typing are still strongly typed, they just depend on .NET for determining (or inferring) the type.

Inferred typing is sometimes referred to as “duck typing”. This is from the truth that if something looks like a duck and quacks like a duck, it must be a duck. For more general information on inferred typing (or type inference), see this.

The compiler infers your data type based on its context. Here are some examples.

In C#:

var i = 1;

var x = "Hello";

var arr = new int[] {1, 2, 3, 4};

var c = new Customer();

var y = null; // Generates an error

To use inferred typing in C#, use the var keyword as in the above examples. Note that var is not short for variant and does not imply that the variables are weakly typed. Rather, the var keyword defines that the compiler should infer the type based on the context.

In VB:

Dim i = 1

Dim x = "Hello"

Dim arr() = New Integer() {1, 2, 3, 4}

Dim c = new Customer()

Dim y = Nothing

To use inferred typing in VB, you need to set Option Infer On:

Double-Click on My Project under Solution Explorer.
Click the Compile tab.
Set Option Infer On.

If Option Infer is On, simply Dim the variable to take advantage of inferred typing. This does not imply that the variables are weakly typed or are of type Object. Rather, using Dim without a data type when Option Infer is On defines that the compiler should infer the type based on the context.

In the first example under either language, the inferred type of i is integer because it is assigned to 1. In the second example, x is inferred to be of type string. The arr variable is inferred to be of an integer array type.

The fourth example infers the type of c to be Customer and creates a new instance of the Customer class. This is less necessary as a shortcut in VB where you can also do this:

Dim c as New Customer

In the last example, VB infers the type of y to be Object. C# won’t attempt to infer the type and instead generates a compile error.

You can view the type that is inferred by hovering over the value in the Visual Studio text editor. In VB, hover over the variable. In C#, hover over the var keyword.

BUT – is this a good idea? Should you be leaving it up to the compiler to define your types?

The recommended best practice regarding inferred typing is as follows:

Do NOT use inferred typing for variables of intrinsic types (like in the above integer and string examples).
DO use inferred typing when creating a new instance, such as in the new Customer example.
DO use inferred typing when dealing with anonymous types (see this or this).
DO use inferred typing when working with LINQ and Lambda expressions.

Though a quick Bing of this topic shows that not all developers agree with these guidelines.

A common use of inferred typing is with LINQ and Lambda expressions because the data types of these expressions are often long and tedious.

For example:

In C#:

List<int> myList = new List<int>() { 1, 6, 8, 3, 2, 4, 15 };

var result = from item in myList
where item < 5
select item;

In VB:

Dim myArr() As Integer = {1, 6, 8, 3, 2, 4, 15}
Dim myList As List(Of Integer) = myArr.ToList

Dim result = From item In myList _
Where item < 5 _
Select item

NOTE: VB does not support List initializers but it does support array initializers. So to simplify the amount of code, an array initializer was used and then the array was converted to a List.

In both cases, the result variable type is System.Collections.Generic.IEnumerable<int>. Yuck!

Enjoy!

EDIT: 8/26/12

Two things to add to this:

1) VB does now support List initializers as of VB 10 (VS 2010).

2) In practice over the past few years, I have found that I also ignore the first recommendation for inferred typing. Why include the name of the type (string or int) when it is so obvious that you are assigning to a string or an integer?

Linq: Sorting a DataTable

Deborah Kurata — Thu, 23 Jul 2009 23:24:46 GMT

Last night, my husband (who is also a .NET developer) asked me about sorting a DataTable by user-defined columns. (Yes, we are a pretty exciting couple!)

Most developers that work with DataTables know how to sort the DataTable using a DataView.Sort. If you are interested in that technique, you can view the msdn documentation here. This post is about sorting using Linq.

NOTE: Be sure to set a reference to System.Data.DatasetExtensions.

If you know ahead of time which columns of the DataTable should be sorted, you can use LINQ to DataTables like this.

In C#:

var query = from c in dt.AsEnumerable()
            orderby c.Field<DateTime?>("LastPurchaseDate"),
                    c.Field<string>("LastName") descending
            select c;
DataView dv   = query.AsDataView();

In VB:

Dim query = From c In dt.AsEnumerable _
Order By c.Field(Of DateTime?)("LastPurchaseDate"), _
c.Field(Of String)("LastName") Descending
Dim dv As DataView = query.AsDataView

The dt variable represents the table you wish to sort. The AsEnumerable is an extension method on the DataTable that allows you to use Linq with it. The Order By clause takes any number of columns. You must specify the data type and then the column name or index. To sort descending, use the Descending keyword.

A nullable DateTime (represented by DateTime?) ensures that the code correctly handles any null values in the table.

In the above examples, the data is sorted first by LastPurchaseDate (ascending) and then by LastName (descending).

The resulting DataView can be bound to a grid or other control.

If you prefer Lambda expressions, you can do this same sort as follows:

In C#:

var query2 = dt.AsEnumerable()
           .OrderBy(c=> c.Field<DateTime?>("LastPurchaseDate"))
           .ThenByDescending(c=> c.Field<string>("LastName"));
DataView dv2   = query.AsDataView();

In VB:

Dim query2 = dt.AsEnumerable _
.OrderBy(Function(c) c.Field(Of DateTime?)("LastPurchaseDate")) _
.ThenByDescending(Function(c) c.Field(Of String)("LastName"))
Dim dv2 As DataView = query.AsDataView

This code performs the same sort as the prior examples.

But neither of these techniques work well if you want the user to select any number of columns to use for the sort. In that case, you need something a little more full-featured.

The first step to building a more generalized sort is to build your own comparer class.

In C#:

private class RowComparer : IComparer<DataRow>
{
public Dictionary<int, SortOrder> SortColumns { get; set; }

    public int Compare(System.Data.DataRow x, System.Data.DataRow y)
    {
        int returnValue = 0;
        foreach (int key in SortColumns.Keys)
        {
            int compareResult ;

            // Check for nulls
            if (x.ItemArray[key] == DBNull.Value
                       && y.ItemArray[key] == DBNull.Value)
                compareResult = 0;
            else if (x.ItemArray[key] == DBNull.Value)
                compareResult = -1;
            else if (y.ItemArray[key] == DBNull.Value)
                compareResult = 1;
            else
            {
                // Execute the compare based on the column type
                if (x.Table.Columns[key].DataType.Name ==
                                            typeof(Decimal).Name)
                    compareResult =
                         Decimal.Compare((decimal)x.ItemArray[key],
                                         (decimal)y.ItemArray[key]);

                else if (x.Table.Columns[key].DataType.Name ==
                                            typeof(DateTime).Name)
                    compareResult =
                         DateTime.Compare((DateTime)x.ItemArray[key],
                                          (DateTime)y.ItemArray[key]);
                else
                    // Compare anything else as a string
                    compareResult =
                         String.Compare(x.ItemArray[key].ToString(),
                                        y.ItemArray[key].ToString());
            }

            if (compareResult != 0)
            {
                returnValue =
                   SortColumns[key] == SortOrder.Ascending ?
                                  compareResult: -compareResult;
                break;
            }
        }
        return returnValue;
    }
}

In VB:

Public Class RowComparer
Implements IComparer(Of DataRow)

    Private _sortColumns As Dictionary(Of Integer, SortOrder)
    Public Property SortColumns() As Dictionary(Of Integer, SortOrder)
        Get
            Return _sortColumns
        End Get
        Set(ByVal value As Dictionary(Of Integer, SortOrder))
            _sortColumns = value
        End Set
    End Property

    Public Function Compare(ByVal x As System.Data.DataRow, _
         ByVal y As System.Data.DataRow) As Integer _
         Implements System.Collections.Generic.IComparer( _
                            Of System.Data.DataRow).Compare
        Dim returnValue As Integer = 0
        For Each key As Integer In SortColumns.Keys
            Dim compareResult As Integer

            ' Handle DBNull.
            Dim xValue As Object = _
              If(x.Item(key) Is DBNull.Value, Nothing, x.Item(key))
            Dim yValue As Object = _
              If(y.Item(key) Is DBNull.Value, Nothing, y.Item(key))

            ' Execute the appropriate compare based on the column type
            Select Case x.Table.Columns(key).DataType.Name
                Case GetType(Decimal).Name
                    compareResult = _
                        Decimal.Compare(CType(xValue, Decimal), _
                                       CType(yValue, Decimal))

                Case GetType(DateTime).Name
                    compareResult = _
                        DateTime.Compare(CType(xValue, DateTime), _
                                         CType(yValue, DateTime))

                Case Else
                    ' Compare anything else as a string
                    compareResult = _
                         String.Compare(x.Item(key).ToString, _
                                        y.Item(key).ToString)
            End Select

            If compareResult <> 0 Then
                returnValue = _
                  If(SortColumns(key) = SortOrder.Ascending, _
                          compareResult, -compareResult)
                Exit For
            End If
        Next
        Return returnValue

End Function
End Class

This class defines a comparer to use when sorting a DataRow. The sortColumns property is a Dictionary that stores the index of the column to use as the sort, and a SortOrder to define whether to sort ascending or descending. Presumably, the values for this Dictionary were obtained from the user.

The Compare method does all of the work. It compares any two DataRows to determine how each row should be sorted against any other row. The method processes each of the sortColumns.

First, it checks for a DBNull. The DBNull checking is different in the C# code and VB code. The C# code checks for a DBNull and manually sets the result of the compare. The VB code simply sets the value to Nothing if it is DBNull.

The code performs a compare based on the type of column. This is necessary because the user would expect decimals to sort as numbers, not as strings. You can add any other data types here as you require. Any data types not specifically handled will be handled as a string.

Note that a Select/Case statement was used in VB, but if/else if was used in C#. This is because C# requires its switch/case statements to switch based on constant values, not variables.

Regardless of the datatype, the result of the type-specific compare method is:

-1: If the value of x is less than the value of y.
1: if the value of x is great than the value of y.
0: if the value of x and y are equal.

If the resulting value is not 0, the loop can exit because the comparison is complete. If the resulting value is 0, meaning the columns are equal, the loop continues and the next column in the set of sort columns is checked.

You then use this class as follows.

In C#:

Dictionary<int, SortOrder> sortColumns =
new Dictionary<int, SortOrder>();
sortColumns.Add(2,SortOrder.Ascending);
sortColumns.Add(1, SortOrder.Descending);

RowComparer comp = new RowComparer();
comp.SortColumns = sortColumns;

var query3 = dt.AsEnumerable().OrderBy(q => q, comp);
DataView dv3 = query3.AsDataView();

In VB:

Dim sortColumns As New Dictionary(Of Integer, SortOrder)
sortColumns.Add(2, SortOrder.Ascending)
sortColumns.Add(1, SortOrder.Descending)

Dim comp As New RowComparer
comp.SortColumns = sortColumns

Dim query3 = dt.AsEnumerable.OrderBy(Function(q) q, comp)
Dim dv3 As DataView = query3.AsDataView

The first set of code sets up the Dictionary of sort columns. The sort columns are hard-coded in this example, but presumably they would come from the user.

The code then creates an instance of the new RowComparer class and passes in the set of columns.

NOTE: You could define a parameterized constructor and pass in the sorted columns instead of using a property, if desired.

The Lambda expression to perform the sort is then greatly simplified. It just passes in the desired comparer.

That’s it. You now have the ability to sort your DataTable using any user-defined set of columns.

Enjoy!

Zodiac Sign: ZodiacSigns Class

Deborah Kurata — Mon, 06 Jul 2009 21:53:16 GMT

This entry details the implementation of the ZodiacSigns class from this example in C#:

public class ZodiacSigns : List<ZodiacSign>
{

}

Constructor

The following is the constructor defined in the ZodiacSigns class:

public ZodiacSigns()
{
InitializeCollection();
}

This constructor ensures that the collection of zodiac signs is initialized when an instance of this class is created.

Methods

The following are the methods in the ZodiacSigns class:

public string FindSign(DateTime desiredDate)
{
    // Find the name of the Zodiak sign with the date within the ranges
    var query = from z in this
                from d in z.DateRanges
                where (desiredDate >= d.StartDate) &&
                        (desiredDate <= d.EndDate)
                select z.Name;
    string name = query.FirstOrDefault();
    return name;
}

The FindSign method uses LINQ to find the date within the defined ranges. It returns the name of the appropriate sign.

private void InitializeCollection()
{
    // This could potentially read all of these from a file.
    // NOTE: This data may not be accurate
    this.Add(new ZodiacSign("Rat",
        new List<DateRange> {
            new DateRange(new DateTime(1996, 2,19),
                new DateTime(1997, 2,6)),
            new DateRange(new DateTime(2008, 2,7),
                new DateTime(2009, 2,25))}));
    this.Add(new ZodiacSign("Ox",
        new List<DateRange> {
            new DateRange(new DateTime(1997, 2,7),
                new DateTime(1998, 2,27)),
            new DateRange(new DateTime(2009, 2,26),
                new DateTime(2010, 2,13))}));
    this.Add(new ZodiacSign("Tiger",
        new List<DateRange> {
            new DateRange(new DateTime(1998, 2,28),
                new DateTime(1999, 2,15)),
            new DateRange(new DateTime(2010, 2,14),
                new DateTime(2011, 2,2))}));
    this.Add(new ZodiacSign("Rabbit",
        new List<DateRange> {
            new DateRange(new DateTime(1999, 2,16),
                new DateTime(2000, 2,4)),
            new DateRange(new DateTime(2011, 2,3),
                new DateTime(2012, 1,22))}));
    this.Add(new ZodiacSign("Drago",
        new List<DateRange> {
            new DateRange(new DateTime(2000, 2,5),
                new DateTime(2001, 2,23)),
            new DateRange(new DateTime(2012, 1,23),
                new DateTime(2013, 2,9))}));
    this.Add(new ZodiacSign("Snake",
        new List<DateRange> {
            new DateRange(new DateTime(2001, 1,24),
                new DateTime(2002, 2,11)),
            new DateRange(new DateTime(2013, 2,10),
                new DateTime(2014, 1,30))}));
    this.Add(new ZodiacSign("Horse",
        new List<DateRange> {
            new DateRange(new DateTime(2002, 2,12),
                new DateTime(2003, 1,31)),
            new DateRange(new DateTime(2014, 1,31),
                new DateTime(2015, 2,18))}));
    this.Add(new ZodiacSign("Sheep",
        new List<DateRange> {
            new DateRange(new DateTime(2003, 2,1),
                new DateTime(2004, 2,21)),
            new DateRange(new DateTime(2015, 2,19),
                new DateTime(2016, 2,7))}));
    this.Add(new ZodiacSign("Monkey",
        new List<DateRange> {
            new DateRange(new DateTime(2004, 1, 22),
                new DateTime(2005, 2, 8)),
            new DateRange(new DateTime(2016, 2, 8),
                new DateTime(2017, 1, 27))}));
    this.Add(new ZodiacSign("Rooster",
        new List<DateRange> {
            new DateRange(new DateTime(2005, 2, 9),
                new DateTime(2006, 1, 28)),
            new DateRange(new DateTime(2017, 1, 28),
                new DateTime(2018, 2, 15))}));
    this.Add(new ZodiacSign("Dog",
        new List<DateRange> {
            new DateRange(new DateTime(2006, 1, 29),
                new DateTime(2007, 2, 17)),
            new DateRange(new DateTime(2018, 2, 16),
                new DateTime(2019, 2, 4))}));
    this.Add(new ZodiacSign("Pig",
        new List<DateRange> {
            new DateRange(new DateTime(2007, 2, 18),
                new DateTime(2008, 2, 6)),
            new DateRange(new DateTime(2019, 2, 5),
                new DateTime(2020, 2, 21))}));
}

The InitializeCollection method does exactly what it sounds like … creating the set of date ranges associated with each zodiac sign. This code takes advantage of the list initializers now available in C#.

Enjoy!

LINQ: Defining a List of Integers

Deborah Kurata — Fri, 03 Jul 2009 16:39:05 GMT

Defining a list of integers in your code involves lots of tedious typing.

In VB, you can’t do this:

'Dim numberList As new List(Of Integer) = {1, 2, 3, 4, 5, 6, 7, 8, 9}

So you have to either add numbers to the list manually, or create an array, which still involves lots of tedious typing:

Dim numberList() As Integer = {1, 2, 3, 4, 5, 6, 7, 8, 9}

With .NET 3.5, you can instead use the Range method of the Enumerable class that is part of the System.Linq namespace.

In VB:

Dim numberList2 As List(Of Integer) = Enumerable.Range(1, 9).ToList

In C#:

List<int> numberList2 = Enumerable.Range(1, 9).ToList();

The first parameter of the Range method defines the first integer of the sequence. The second parameter defines the number of items in the sequence. So Range(0,9) provides 9 integers from 0 through 8.

Enjoy!