Deborah's Developer MindScape : VB, Generics

Building a List of of Items with Child Items

Deborah Kurata — Sun, 31 Oct 2010 00:46:52 GMT

In this prior post, I demonstrated how to build a generic list of items. The example built a list of individual customers. This post demonstrates how to build a generic list of items where one of those items is another generic list.

In this example, the customer is no longer a single person, but rather a company with a set of contact persons.

Here is a first draft of a Contact class and a Customer class that contains a list of contacts.

In C#:

public class Contact
{
    public int ContactId { get; set; }
    public int CustomerId { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string EmailAddress { get; set; }
}

public class Customer
{
    public int CustomerId { get; set; }
    public string CompanyName { get; set; }
    public List<Contact> ContactList { get; set; }
}

In VB:

Public Class Contact
    Public Property ContactId As Integer
    Public Property CustomerId As Integer
    Public Property FirstName As String
    Public Property LastName As String
    Public Property EmailAddress As String
End Class

Public Class Customer
    Public Property CustomerId As Integer
    Public Property CompanyName() As String
    Public Property ContactList As List(Of Contact)
End Class

Both of these classes use auto-properties, which is the one-line technique for defining property procedures. (See this post for more information on auto-properties.)

And here is a single line of code to populate the list of Customers.

In C#:

List<Customer> custList = new List<Customer> {
new Customer() {
   CustomerId = 1,
   CompanyName = "ME Industries",
   ContactList = new List<Contact>() {
      new Contact() {
       ContactId = 1,
       CustomerId = 1,
       FirstName = "Bilbo",
       LastName = "Baggins",
       EmailAddress = "bb@hob.me"},
     new Contact() {
       ContactId = 2,
       CustomerId = 1,
       FirstName = "Frodo",
       LastName = "Baggins",
       EmailAddress = "fb@hob.me"}}},
new Customer() {
    CustomerId = 2,
    CompanyName = "Farmers Trust",
    ContactList = new List<Contact>() {
      new Contact() {
         ContactId = 3,
         CustomerId = 2,
         FirstName = "Samwise",
         LastName = "Gamgee",
         EmailAddress = "sg@hob.me"},
      new Contact() {
         ContactId = 4,
         CustomerId = 2,
         FirstName = "Rosie",
         LastName = "Cotton",
         EmailAddress = "rc@hob.me"}}}};

In VB:

Dim custList As New List(Of Customer) From {
   New Customer() With {
      .CustomerId = 1,
      .CompanyName = "ME Industries",
      .ContactList = New List(Of Contact) From {
        New Contact() With {
          .ContactId = 1,
          .CustomerId = 1,
          .FirstName = "Bilbo",
          .LastName = "Baggins",
          .EmailAddress = "bb@hob.me"},
        New Contact() With {
          .ContactId = 2,
          .CustomerId = 1,
          .FirstName = "Frodo",
          .LastName = "Baggins",
          .EmailAddress = "fb@hob.me"}}},
    New Customer() With {
      .CustomerId = 2,
      .CompanyName = "Farmers Trust",
      .ContactList = New List(Of Contact) From {
        New Contact() With {
            .ContactId = 3,
            .CustomerId = 2,
            .FirstName = "Samwise",
            .LastName = "Gamgee",
            .EmailAddress = "sg@hob.me"},
        New Contact() With {
            .ContactId = 4,
            .CustomerId = 2,
            .FirstName = "Rosie",
            .LastName = "Cotton",
            .EmailAddress = "rc@hob.me"}}}}

Wow! That is one long line of code! Notice how close the VB and C# syntax is for this line.

This code creates two new customers defined with the two "new Customer()" statements. For each customer it creates two contacts. This code uses a technique called collection initializers. (For more information on collection initializers, see this post.)

Any time you have a related set of "child" data, you can associate that data with the "parent" by defining a List<child>. Initializing it in one line of code is completely optional. :-)

Enjoy!

Collection Initializers

Deborah Kurata — Thu, 29 Apr 2010 22:08:07 GMT

One of the new features in VB 10.0 is collection initializers. Collection initializers allow you to initialize an array or list in a single line of code.

(C# has had collection initializers since C# 3.0. The examples here show both C# and VB for completeness.)

This example uses the customer class defined here and builds a list of customers using collection initializers.

In VB:

Dim custList As New List(Of Customer) From
            {New Customer() With
                  {.CustomerId = 1,
                    .FirstName = "Bilbo",
                    .LastName = "Baggins",
                    .EmailAddress = "bb@hob.me"},
            New Customer() With
                  {.CustomerId = 2,
                    .FirstName = "Frodo",
                    .LastName = "Baggins",
                    .EmailAddress = "fb@hob.me"},
            New Customer() With
                  {.CustomerId = 3,
                    .FirstName = "Samwise",
                    .LastName = "Gamgee",
                    .EmailAddress = "sg@hob.me"},
            New Customer() With
                  {.CustomerId = 4,
                    .FirstName = "Rosie",
                    .LastName = "Cotton",
                    .EmailAddress = "rc@hob.me"}}

In C#:

List<Customer> custList = new List<Customer>
        {new Customer()
              { CustomerId = 1,
                FirstName="Bilbo",
                LastName = "Baggins",
                EmailAddress = "bb@hob.me"},
        new Customer()
              { CustomerId = 2,
                FirstName="Frodo",
                LastName = "Baggins",
                EmailAddress = "fb@hob.me"},
        new Customer()
              { CustomerId = 3,
                FirstName="Samwise",
                LastName = "Gamgee",
                EmailAddress = "sg@hob.me"},
        new Customer()
              { CustomerId = 4,
                FirstName="Rosie",
                LastName = "Cotton",
                EmailAddress = "rc@hob.me"}};

Notice how these two code snippets are very similar. VB even has the same curly braces!

The key differences are that VB requires the From keyword when initializing the list, the With keyword when initializing each customer in the list, and the "." in front of the property names.

Compare this VB example to the one shown for VB 9 (VS 2008) here.

Use this technique whenever you need to initialize a list or array of objects.

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!

Lambda Expressions: An Introduction

Deborah Kurata — Sun, 11 Oct 2009 19:11:17 GMT

My presentation at our local Code Camp was fun. I covered a lot of material and had a GREAT audience. Several people have asked for the slide information in my blog. So this is the start of several posts on lambda expressions.

In addition, I wrote an article on lambda expressions that should appear in the Jan/Feb 2010 issue of Code Magazine. I’ll post the link as soon as its published. (See Edit below.)

You can find sample code that demonstrates many different lambda expressions here.

Lambda expressions are unnamed, inline functions. They are new in Visual Basic 9 and C# 3.0 (VS 2008). You can use a lambda expression anywhere a delegate is required. For more information on delegates, see this post.

Here are an additional set of posts that cover the slides and information from my talk:

I will be adding more as time permits.

Enjoy!

EDIT: 1/4/2010

The Code Magazine article was published in the Jan/Feb 2010 issue and is here.

Added a link to sample code above.

Nullable Data Types

Deborah Kurata — Wed, 02 Sep 2009 21:12:05 GMT

A data type is said to be nullable if it can be assigned a value or a null reference. Reference types, such as strings and class types, are nullable; they can be set to a null reference, and the result is a null value. Value types, such as integers, Booleans, and dates, are not nullable. If you set a value type to a null reference, the result is a default value, such as 0 or false.

Try this:

In C#:

int i = null;
Boolean b = null;
DateTime d = null;
Debug.WriteLine(i + ", " + b + ", " + d.ToShortDateString());

In VB:

Dim i As Integer = Nothing
Dim b As Boolean = Nothing
Dim d As DateTime = Nothing
Debug.WriteLine(i & ", " & b & ", " & d.ToShortDateString)

The C# code will generate compile-time errors saying you cannot convert null to the defined type because it is a non-nullable value type.

VB, however, will display this:

0, False, 1/1/0001

Instead of retaining a null value, VB sets the variable to the default value.

A value type can express only the values appropriate to its type; there is no easy way for a value type to understand that it is null.

There may be cases, however, when you need your code to really handle a null as a null and not as a default value. It would be odd, for example, to handle a null date by hard-coding a check for the 1/1/0001 date.

The .NET Framework 2.0 introduced a Nullable class and an associated Nullable structure. The Nullable structure includes the value type itself and a field identifying whether the value is null. A variable of a Nullable type can represent all the values of the underlying type, plus an additional null value. The Nullable structure supports only value types because reference types are nullable by design.

To make a value type property nullable, you need to declare it using the Nullable structure. However, you still want your property to be strongly typed as an integer, date, Boolean, or the appropriate underlying type. The ability to use a class or structure for only a specific type of data is the purpose of generics.

Generics allow you to tailor a class, structure, method, or interface to a specific data type. So you can create a class, structure, method, or interface with generalized code. When you use it, you define that it can work only on a particular data type. This gives you greater code reusability and type safety.

The .NET Framework built-in Nullable structure is generic. When you use the structure, you define the particular data type to use. As a specific example, an InventoryDate property that allows the date to be a date or a null value uses the generic Nullable structure as follows:

In C#:

public Nullable<DateTime> InventoryDate { get; set; }

In VB:

Private _InventoryDate As Nullable(Of DateTime)
Public Property InventoryDate() As Nullable(Of DateTime)
    Get
        Return _InventoryDate
    End Get
    Set(ByVal value As Nullable(Of DateTime))
        _InventoryDate = value
    End Set
End Property

Notice the syntax of the Nullable structure. Since it is a generic structure, it has the standard <T> [C#] or (Of T) [VB] syntax, where T is the specific data type you want it to accept. In this case, the Nullable structure supports dates, so the <DateTime> or (Of DateTime) syntax is used. This ensures that the Nullable structure contains only a date or a null value.

More commonly, however, the nullable structure is defined using the question mark (?) short-hand syntax:

In C#:

public DateTime? InventoryDate { get; set; }

In VB:

Private _InventoryDate As DateTime?
Public Property InventoryDate() As DateTime?
    Get
        Return _InventoryDate
    End Get
    Set(ByVal value As DateTime?)
        _InventoryDate = value
    End Set
End Property

Both examples work the same way, but many developers prefer the shorter, question mark syntax.

You can then use this property in your application as needed. For
example:

In C#:

Product prod = new Product();
if (prod.InventoryDate.HasValue)
{
    if (prod.InventoryDate.Value < DateTime.Now.Date.AddDays(-10))
    {
        MessageBox.Show("Need to do an inventory");
    }
}
else
{
    MessageBox.Show("Need to do an inventory - never been done");
}

In VB:

Dim prod As New Product
If prod.InventoryDate.HasValue Then
    If prod.InventoryDate.Value < Now.Date.AddDays(-10) Then
        MessageBox.Show("Need to do an inventory")
    End If
Else
    MessageBox.Show("Need to do an inventory - never been done")
End If

The HasValue property of the Nullable class defines whether the value type has a value—in other words, whether it is null. If it does have a value, you can retrieve the value using the Value property of the Nullable class.

The Nullable structure is exceptionally useful when you’re working with databases, because empty fields in a database are often null. Assuming that you have an InventoryDate fi eld in a table, you could write code as follows:

In C#:

prod.InventoryDate =
    dt.Rows[0]["InventoryDate"] == DBNull.Value ?
               null :
               (DateTime?)dt.Rows[0]["InventoryDate"];

In VB:

prod.InventoryDate = _
   If(dt.Rows(0).Item("InventoryDate") Is DBNull.Value, _
               Nothing, _
               CType(dt.Rows(0)("InventoryDate"), DateTime))

The ternary operator is required here because you cannot convert a DBNull
to a date, so you need to ensure that it is not a null.

Use the Nullable structure any time you need to support nulls in a
value type, such as an integer, Boolean, or date.

(Based on an except from "Doing Objects in Visual Basic 2005".)

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!

Generics: Building a List of Customers

Deborah Kurata — Fri, 03 Jul 2009 15:23:19 GMT

Often times applications require lists of things: lists of customers, lists of experiments, lists of accounts and so on. The generic lists provided in .NET 2.0 made working with these lists easy. And the list initializers in C# and the object initializers in VB make lists easier still.

As an example, here is a first draft of a simple Customer class.

In C#:

public class Customer
{
    public int CustomerId { get; set; }
    public string LastName { get; set; }
    public string FirstName { get; set; }
    public string EmailAddress { get; set; }
}

The above code takes advantage of automatically implemented properties. VB does not yet have this feature, but it is expected with VB 10.

In VB 9 (VS 2008):

Public Class Customer

    Private _CustomerId As Integer
    Public Property CustomerId() As Integer
        Get
            Return _CustomerId
        End Get
        Set(ByVal value As Integer)
            _CustomerId = value
        End Set
    End Property

    Private _FirstName As String
    Public Property FirstName() As String
        Get
            Return _FirstName
        End Get
        Set(ByVal value As String)
            _FirstName = value
        End Set
    End Property

    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 _EmailAddress As String
    Public Property EmailAddress () As String
        Get
            Return _EmailAddress
        End Get
        Set(ByVal value As String)
            _EmailAddress = value
        End Set
    End Property
End Class

Most often, you would read the customers from a database and build the list. But there are times where you may want to build the list manually. For example, for prototyping or testing.

In C#:

With C#, you can build a list of customers in one line of code:

List<Customer> custList = new List<Customer>
                    {new Customer()
                          { CustomerId = 1,
                            FirstName="Bilbo",
                            LastName = "Baggins",
                            EmailAddress = "bb@hob.me"},
                    new Customer()
                          { CustomerId = 2,
                            FirstName="Frodo",
                            LastName = "Baggins",
                            EmailAddress = "fb@hob.me"},
                    new Customer()
                          { CustomerId = 3,
                            FirstName="Samwise",
                            LastName = "Gamgee",
                            EmailAddress = "sg@hob.me"},
                    new Customer()
                          { CustomerId = 4,
                            FirstName="Rosie",
                            LastName = "Cotton",
                            EmailAddress = "rc@hob.me"}};

The above example takes advantage of the list initializers feature of C#. VB does not yet have this feature, but it is expected in VB10.

In VB 9 (VS 2008):

The code to do this in VB takes advantage of object initializers:

Dim custList As New List(Of Customer)
custList.Add(New Customer With {.CustomerId = 1, _
                                .LastName = "Baggins", _
                                .FirstName = "Bilbo", _
                                .EmailAddress="bb@hob.me"})
custList.Add(New Customer With {.CustomerId = 2, _
                                .LastName = "Baggins", _
                                .FirstName = "Frodo", _
                                .EmailAddress = "fb@hob.me"})
custList.Add(New Customer With {.CustomerId = 3, _
                                .LastName = "Gamgee", _
                                .FirstName = "Samwise", _
                                .EmailAddress = "sg@hob.me"})
custList.Add(New Customer With {.CustomerId = 4, _
                                .LastName = "Cotton", _
                                .FirstName = "Rosie", _
                                .EmailAddress = "rc@hob.me"})

Notice the With statement in this VB code.

Enjoy!

EDIT 4/29/10: This syntax is much easier now in VB 10 (VS 2010). See this link for more information on auto-implemented properties in VB 10. See this link for more information on collection initializers in VB 10.