Deborah's Developer MindScape : Binding, WinForms

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!

Binding Control Properties to Business Object Properties

Deborah Kurata — Wed, 16 Sep 2009 23:32:40 GMT

As stated here, you use object binding in a WinForms application by following these steps:

1. Build the business objects for your application.

2. Define a business object data source in the Windows Application
project containing your user interface.

3. Bind properties of the controls on the form to business object
properties.

The first two steps were detailed here. This post covers the third step.

NOTE: You will not be able to follow along with the information in this post unless you perform steps 1 and 2 first from my prior post.

Binding to Existing Controls

Once you have at least one data source set up in your Data Sources window, you can bind it to your user interface. The technique you use to set up the binding is slightly different, depending on whether you are working with existing controls or creating new controls. This section describes the former, and the next section details the latter.

The process of binding existing controls on a form to a data source is
referred to as connect-the-dots binding. It is as easy as connecting point
A to point B.

To bind an existing control to a business object property displayed in
the Data Sources window:

1. Open the form you want to bind in the Forms Designer.

2. Open the Data Sources window. Position the Data Sources window so that you can easily see its contents and the Forms Designer at the same time.

3. Drag the desired property from the Data Sources window, and
drop it on the appropriate control on the form to bind them.

Repeat this process for every control on the form that needs to be
bound to the business object.

The first time you drop a property from an object data source to a form, Visual Studio adds a BindingSource component to the form’s component tray and names it based on the name of your business object class. This component manages the binding between the form controls and the
business object properties.

The default property of the control that you used as your drop target is bound to the BindingSource component for the property that was dragged from the Data Sources window. You can see this by using the Properties window to examine the control’s DataBindings property.

For example, add a TextBox to an empty form. Then drag the LastName property from the Customer object data source in the Data Sources window and drop it on the TextBox control. This binds the Text property of the TextBox control to the LastName property of the Customer class by way of the CustomerBindingSource. The result is shown below.

As shown in the Properties window, the Text property of the TextBox control is now bound to the LastName property by way of the CustomerBindingSource.

The binding information for the BindingSource component and for each bound control is retained in the form’s partial class. When you perform the binding, Visual Studio sets the appropriate control properties.

The code Visual Studio adds to the partial class for the BindingSource
component is as follows

In C#:

this.customerBindingSource.DataSource =
typeof(SampleBoCSharp.Customer);

In VB:

Me.CustomerBindingSource.DataSource = GetType(SampleBoVB.Customer)

This defines that the CustomerBindingSource is associated with the Customer class in the associated project.

Visual Studio adds code to the partial class for each bound control as
follows

In C#:

this.textBox1.DataBindings.Add(
new System.Windows.Forms.Binding("Text",
this.customerBindingSource, "LastName", true));

In VB:

Me.TextBox1.DataBindings.Add( _
New System.Windows.Forms.Binding("Text", _
Me.CustomerBindingSource, "LastName", True))

This code adds a binding entry for the TextBox control. The binding entry defines that the Text property of the TextBox is bound to the LastName property in the CustomerBindingSource. The last parameter defines that formatting is enabled to allow formatting of the value.

NOTE: Although you do not normally need to look at this generated code, there is one case where you may need to know about it. If you use the renaming feature, you will see that the Rename renames only direct references to the property or method, not any occurrences in quoted strings. So if you use
the rename feature and rename LastName to CustomerLastName, your binding no longer works, because it is still using LastName. You must locate any partial class code that references the property as a quoted string and manually change its name.

Before you can successfully run the application, you need to write some code. So far, you have defined that the BindingSource component binds to a business object. And you have defined which properties of the business object are to appear in which control of the form. However, you did not define which business object it binds to.

To define which instance of the business object to bind to, assign the DataSource property of the BindingSource component to a business object instance as follows:

In C#:

Customer cust = new Customer()
{LastName = "Baggins",
FirstName = "Bilbo"};
this.customerBindingSource.DataSource = cust;

In VB:

Dim cust= New Customer With _
{.LastName = "Baggins", _
.FirstName = "Bilbo"}
Me.CustomerBindingSource.DataSource = cust

This example binds the controls in the user interface to a new instance of the Product class. Place this binding code in the form. The specific location in the form depends on when you want the binding to occur. If you want the binding to occur when the form is loaded, add this code to the form’s Load event.

By setting that instance as the DataSource for the CustomerBindingSource, the runtime uses the properties associated with that instance to populate any controls on the form bound to the CustomerBindingSource. So by writing only two lines of code, when you run your application, your form appears populated with appropriate data.

If the user changes a value in a control on the form, the runtime assigns the revised value to the associated property.

NOTE: The business object property is assigned to the value from the control when the user leaves the control. By default, if the user modifies a value and then closes the form before leaving the control, the bound property is not changed. However, if you call the Validate method, the current control’s value is assigned to its associated property even if the user does not leave the control.

Binding to New Controls

Now for the really fun part. In addition to binding to existing controls you can use the features of the Data Sources window to add new controls to a form. Or you can use it to automatically create controls for all of the business object properties.

Adding New Controls Using the Data Sources Window

If you want to add a new control to a form, you can add the control from the Forms Designer toolbox, add the associated Label control, and then bind the new control using the techniques from the preceding section.

But the Data Sources window provides a shortcut for this process. If you drag a property from the Data Sources window and drop it on the Forms Designer, Visual Studio creates the control, binds it, and creates the associated Label control. All you need to do is drag and drop!

To add a new control to a form:

1. Open the form in the Forms Designer.

2. Open the Data Sources window. Position the Data Sources window so that you can easily see its contents and the Forms Designer at the same time.

If a Forms Designer window is active, the Data Sources window changes so that each object data source and each property under the object data source displays an icon to the left of the name. This icon indicates the type of control that Visual Studio creates if you drag the item to the Forms Designer.

3. Drag a property from the Data Sources window, and drop it on the
Forms Designer.

Visual Studio automatically creates the control associated with the dropped property and binds it. It even gives the control a valid name using the property name and the control type, such as FirstNameTextBox—no lame TextBox1 name. In addition, Visual Studio creates an appropriate Label control. Visual Studio is smart about generating the text for the Label control. It breaks the property name into separate words based on either alphabetic casing or underscores.

For example, if you drag the FirstName property from the Data Sources window and drop it in the CustomerWin form, Visual Studio creates a TextBox control for the First Name and an appropriate Label control.

But what if you don’t want the property to render as a TextBox control? You can change the type of control that is rendered using the Data Sources window.

To change the default control type associated with a property:

1. Ensure that a Forms Designer is active.

2. Open the Data Sources window.

3. Click a property in the Data Sources window. The property item changes to a drop-down control list.

4. Drop down the control list and select the desired control type as shown in the prior screen shot of the Data Sources Window.

Select Customize from the list to select a control type that is not on the list. You can select just about any type of control, including third-party and
custom controls.

NOTE: Before a third-party control can be added as a control type in the Data Sources window, it must first be added to the Forms Designer toolbox.

When you drag the control from the Data Sources window to the Forms Designer, Visual Studio renders the type of control you selected as the default control type for the property. The property retains its default control type in the Data Sources window.

Creating a Form from the Data Sources Window

But wait—there’s more! You can use the Data Sources window to create all the controls for a business object and bind them.

To create a new bound form:

1. Add a new Windows Form to your project.

2. Open the Data Sources window. Position the Data Sources window so that you can easily see its contents and the Forms Designer window at the same time.

3. In the Data Sources window, click the object data source you want
to bind to this form. The item changes to a drop-down control list.

4. Use the drop-down control list to define how Visual Studio renders controls on the form for this object data source.

The class object data source can be rendered as Details, DataGridView, or None, or you can select Customize from the control list to select a control type that is not on the list.

For a data entry form, set the control type for the object data source to Details. Visual Studio renders individual controls for each property in the object data source, along with associated Label controls. Select DataGridView to render the properties in the object data source as columns in a grid.

5. Drag the object data source node from the Data Sources window and drop it on the form.

NOTE: If you plan to use Panel or other container controls on the form, place the Panel controls or other containers on the form first, and then drag the object data source node and drop it on the desired container.

Bang! Visual Studio automatically creates the controls as you specified and binds them. If you selected Details rendering, Visual Studio creates a control based on the default control type for each object data source property in the Data Sources window. It sets each control’s Name property based on the name of the associated business object property and control type. Visual Studio also defines an appropriate Label control for each control it creates. If you selected DataGridView rendering, Visual Studio defines a grid with appropriate columns and column header text.

For example, if you set up the Customer object data source to render as Details and then drag the Customer node from the Data Sources window and drop it on a form, Visual Studio creates a TextBox control for every property, binds it, names it, and creates a Label control, as shown below.

Notice that this process created two components in the form’s component tray. The BindingSource is the component that manages the binding. The BindingNavigator added VCR-style controls to the top of the form. This type of user interface is not recommended for most business applications. (How often does a user want to sequentially navigate through every customer, for example?) You can delete the BindingNavigator component, and Visual Studio automatically deletes the VCR-style controls.

The labels created for the controls are generated based on the property names. Visual Studio is smart enough to add spaces between words based on underscores or alphabetic casing. This provides a great starting point for your user interface.

The controls are added in alphabetical order, which may not be the most logical order or placement for your users. You can move and size the controls as desired. After you have the controls in their desired order, use the Tab Order view to reset the tab order.

All you need then are those two lines of code in the form’s Load event to
define the instance of the business object that is bound to the controls:

In C#:

Customer cust = new Customer()
{LastName = "Baggins",
FirstName = "Bilbo"};
this.customerBindingSource.DataSource = cust;

In VB:

Dim cust= New Customer With _
{.LastName = "Baggins", _
.FirstName = "Bilbo"}
Me.CustomerBindingSource.DataSource = cust

When you run the application, the runtime automatically populates the
controls on the form.

The Data Sources window allows you to create all the controls on a form and bind them to a business object with one drag-and-drop operation and two lines of code. It has the flexibility to allow you to define the type of control to render for each property in the object data source.

Using these techniques can make quick work of building and maintaining
your user interface.

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

Enjoy!

Using Object Binding

Deborah Kurata — Tue, 08 Sep 2009 22:23:54 GMT

As stated here, you use object binding in a WinForms application by following these steps:

1. Build the business objects for your application.

2. Define a business object data source in the Windows Application
project containing your user interface.

3. Bind properties of the controls on the form to business object
properties.

Building the Business Objects

The idea with object binding is to bind your business objects to your user interface controls. So the first step is to create the business objects. This example builds a Customer class.

NOTE: Add a Class Library project to your solution and create the Customer class in the Class Library project. You could add the Customer class to your WinForms project, but it is not recommended.

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:

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

Configuring a Data Source

In Visual Studio, a data source defines the source of data, such as a business object or a database. To use a data source to bind your user interface, you need to configure the data source for the project containing your user interface, such as your Windows Application project.

For object binding, each data source represents a single business object class. This means that you configure a data source for each business object class that you want to bind. Luckily, this process is quick and easy.

When you use object binding, the data source is referred to as an object data source. This is technically accurate because at runtime, the binding binds to a specific business object. However, this can look a little confusing at design-time because each data source represents a single business object class. The Data Sources window displays each object data source with the class name and lists the public properties of the class. You then bind each property of the class to a control on the form.

To set up an object data source for your user interface:

1. Build your business object Class Library project.
Only compiled business object classes are recognized by the Data
Source Configuration Wizard and the Data Sources window.

2. Select the Windows Application project in Solution Explorer.
NOTE: Always ensure that the Windows Application project is selected in
Solution Explorer before you work with the Data Sources window.

3. Select Data | Show Data Sources from the main menu bar.
The Data Sources window is displayed.

4. Click the Add New Data Source link in the Data Sources window, or click the Add New Data Source button on the Data Sources window toolbar, or select Data | Add New Data Source from the main menu bar.

NOTE: The Add New Data Source link only appears when the Data Sources
window is empty.

This launches the Data Source Configuration Wizard. The first page, shown below, allows you to select the source of the data.

5. Select Object for object binding, and click Next.

The second page of the Data Source Configuration Wizard, shown below, provides the list of classes for your selection.

The tree view only lists the classes in the Windows Application
project and classes in any component referenced by the Windows
Application project. If you already have a reference to your business object Class Library component, the component appears in the Data Source
Configuration Wizard. Otherwise, you can add a reference using the Add Reference button.

6. Use the tree view to navigate to the class you wish to use for object binding.

7. Select the desired class, and click Finish.
The object data source for the selected class is added to the Data
Sources window, as shown below.

NOTE: The Data Sources window lists only public class properties.

Use the Data Source Configuration Wizard to define a data source for every business object class you plan to use for binding.

If you are curious about where the Data Sources window stores its information, it is in a set of XML files. Select the Windows Application project in Solution Explorer, and click the Show All Files button on the Solution Explorer toolbar. All the system files for the project are then accessible from Solution Explorer. Open the Properties node (My Project node in VB) under the Windows Application project, and open the DataSources node to see the XML files for the data sources in the Data Sources window.

Creating data sources is quick and easy. Add a data source to the Windows Application project for any business object class that you want to use for binding to your user interface.

Bind the User Interface Controls

There are many ways to bind the resulting object data source to your user interface. These are covered in a later post.

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

Enjoy!

Dates: Binding to Day Numbers

Deborah Kurata — Tue, 14 Jul 2009 21:07:07 GMT

My prior post demonstrated how to bind to a list of month names. Once the user picks the desired month, you may want to provide a list of valid dates to pick a date in that month. For example: 1-30 for September and 1-31 for July.

You can accomplish this using a switch statement (Select Case in VB), but that hard-codes the dates, does not handle leap year, and does not support localization.

Another option is to use the culture specific calendar as shown below.

The code is first shown in both VB and C#. It is then described in detail below.

In C#:

private List<int> GetListOfDays(int yearNumber , int monthNumber)
{
    Calendar currentCalendar = CultureInfo.CurrentCulture.Calendar;
    int numberOfDays =
              currentCalendar.GetDaysInMonth(yearNumber, monthNumber);
    return Enumerable.Range(1, numberOfDays).ToList();
}

In VB:

Private Function GetListOfDays(ByVal yearNumber As Integer, _
ByVal monthNumber As Integer) As List(Of Integer)
Dim currentCalendar As Calendar = CultureInfo.CurrentCulture.Calendar
Dim numberOfDays As Integer = _
currentCalendar.GetDaysInMonth(yearNumber, monthNumber)
Return Enumerable.Range(1, numberOfDays).ToList()
End Function

This function first defines the calendar based on the current culture. It then uses the calendar’s GetDaysInMonth method to get the appropriate number of days in the month.

It then uses the Range method of Enumerable to build a list of numbers from 1 to the number of days in the month and returns it as a list of integers.

This method is called as follows:

In C#:

comboBox1.DataSource = GetListOfDays(2009, 2);

In VB:

ComboBox1.DataSource = GetListOfDays(2009, 2)

Enjoy!

Dates: Binding to Month Names

Deborah Kurata — Tue, 14 Jul 2009 20:14:38 GMT

Visual Studio comes with DateTimePicker and MonthCalendar controls that provide a standard looking calendar for the user to pick a date. But there are times when these controls don’t provide the features you need.

For example, say you want to ask the user for the month and year that their credit card expires. Or you want to ask for a birth date and don’t want the user to have to scroll back to 1932. Or better yet, don’t need to know the year (not that I refuse to admit my birth year <G>.)

There is an easy way to achieve this.

The code is first shown in both VB and C#. It is then described in detail below.

In C#:

string[] MonthNames=
CultureInfo.CurrentCulture.DateTimeFormat.MonthNames;
comboBox1.DataSource = MonthNames;

In VB:

Dim MonthNames As String() = _
CultureInfo.CurrentCulture.DateTimeFormat.MonthNames
ComboBox1.DataSource = MonthNames

This code gets the month names based on the current culture. This ensures that you get the correct localized names. You can then bind the array to a ComboBox or ListBox.

NOTE: In both cases, be sure to set a reference and import System.Globalization.

When looking at the list from the US (and most countries), there is a problem. There appears to be room for 13 values in the list. This is for those countries that have 13 months, such as Ethiopia.

So for most countries, there is a blank entry at the bottom of the list when it is bound. There are numerous ways of removing the empty entry. Even though it might not be the most performant, I like lambda expressions, so here is one way to remove the empty entry.

In C#:

comboBox1.DataSource =
MonthNames.Where(m => !string.IsNullOrEmpty(m)).ToList();

In VB:

ComboBox1.DataSource = _
MonthNames.Where(Function(m) Not String.IsNullOrEmpty(m)).ToList()

Enjoy!

Enum: Binding to the Description Attribute

Deborah Kurata — Fri, 10 Jul 2009 23:31:04 GMT

The Enum keyword allows you to define a standard set of named constants for use in your application. Sometimes you may want to present this same list of values to your user.

You can display the set of Enum values in a ComboBox or ListBox using data binding. And even better, if you use the DescriptionAttribute in the Enum, you can display a more user-friendly set of values.

For example, a Customer business object may have a CustomerType defined with a specific set of options for corporations, individuals, schools, and charities. You want to use these values in your code, but also display them to the user in a ComboBox.

Enum Definition

The Enum can reside in the Customer class, or in its own class.

In C#:

public enum CustomerTypeOption
{
    NotDefined,
    Corp,
    IndividualorFamily,
    SchoolorUniversity,
    Charity
}

In VB:

Public Enum CustomerTypeOption
   NotDefined
   Corp
   IndividualorFamily
   SchoolorUniversity
   Charity
End Enum

CustomerType Property

A CustomerType property in the Customer class can use this enum type.

In C#:

public CustomerTypeOption CustomerType { get; set; }

In VB:

Private _CustomerType As CustomerTypeOption
Public Property CustomerType() As CustomerTypeOption
    Get
        Return _CustomerType
    End Get
    Set(ByVal value As CustomerTypeOption)
        _CustomerType = value
    End Set
End Property

The C# code uses the automatically implemented properties feature introduced with .NET 3.5. The VB code uses the full property definition.

Binding To an Enum

The Enum can also be used by the user interface. For example, you can bind a comboBox or listBox to a set of customer type options.

In C#:

Dictionary<string, int> CustomerTypeList =
                           new Dictionary<string, int>();

foreach (int enumValue in
             Enum.GetValues(typeof(Customer.CustomerTypeOption)))
{
    CustomerTypeList.Add(
         Enum.GetName(typeof(Customer.CustomerTypeOption),
                                      enumValue ), enumValue);
}

// Bind the customer type combo box
CustomerTypeComboBox.DisplayMember = "Key";
CustomerTypeComboBox.ValueMember = "Value";
CustomerTypeComboBox.DataSource = new BindingSource(CustomerTypeList,
null);

In VB:

Dim CustomerTypeList As New Dictionary(Of String, Integer)

For Each enumValue As Integer In _
            [Enum].GetValues(GetType(Customer.CustomerTypeOption))
    CustomerTypeList.Add( _
       [Enum].GetName(GetType(Customer.CustomerTypeOption), _
                                        enumValue), enumValue)
Next

' Bind the combo box
CustomerTypeComboBox.DisplayMember = "Key"
CustomerTypeComboBox.ValueMember = "Value"
CustomerTypeComboBox.DataSource = New BindingSource(CustomerTypeList, _
Nothing)

This code defines a Dictionary to contain the name of the enum and the integer value of the enum. The for/each loop iterates through the set of Enum values and adds the name and value to the dictionary.

The code then binds to the ComboBox, setting the DisplayMember to the “Key” of the dictionary and the ValueMember to the “Value” of the Dictionary.

The result looks like this:

While it does provide the appropriate options, it is not very user-friendly. It would be nicer if there were appropriate spaces and full words. For that, you can use the DescriptionAttribute on the Enum.

Using the DescriptionAttribute

NOTE: Be sure to import the System.ComponentModel and the System.Reflection namespaces.

In C#:

public enum CustomerTypeOption
{
[DescriptionAttribute("Not Specified")]
NotDefined,

[DescriptionAttribute("Corporation")]
Corp,

[DescriptionAttribute("Individual or Family")]
IndividualorFamily,

[DescriptionAttribute("School or University")]
SchoolorUniversity,

[DescriptionAttribute("Charity")]
Charity
}

In VB:

Public Enum CustomerType
<DescriptionAttribute("Corporate Customer")> _
CorpCustomer

<DescriptionAttribute("Individual or Family")> _
IndividualorFamily

<DescriptionAttribute("School or University")> _
SchoolorUniversity

<DescriptionAttribute("Charity")> _
Charity

<DescriptionAttribute("Kingdom")> _
Kingdom
End Enum

Binding to an Enum Description

Now you can bind to the description instead of to the Enum constant.

In C#:

Dictionary<string, int> CustomerTypeList =
new Dictionary<string, int>();

FieldInfo fi;
DescriptionAttribute da;
foreach (Customer.CustomerTypeOption enumValue in
           Enum.GetValues(typeof(Customer.CustomerTypeOption)))
{
    fi = typeof(Customer.CustomerTypeOption).
                    GetField((enumValue.ToString()));
    da = (DescriptionAttribute)Attribute.GetCustomAttribute(fi,
                    typeof(DescriptionAttribute));
    if (da != null)
    {
       CustomerTypeList.Add(da.Description, (int)enumValue);
    }
}

In VB:

Dim CustomerTypeList As New Dictionary(Of String, Integer)

Dim fi As FieldInfo
Dim da As DescriptionAttribute
For Each enumValue As Customer.CustomerTypeOption In _
            [Enum].GetValues(GetType(Customer.CustomerTypeOption))
    fi = GetType(Customer.CustomerTypeOption). _
                GetField(enumValue.ToString)
    da = DirectCast(Attribute.GetCustomAttribute(fi, _
                GetType(DescriptionAttribute)), DescriptionAttribute)
    If da IsNot Nothing Then
        CustomerTypeList.Add(da.Description, enumValue)
    End If
Next

' Bind the combo box
CustomerTypeComboBox.DisplayMember = "Key"
CustomerTypeComboBox.ValueMember = "Value"
CustomerTypeComboBox.DataSource = New BindingSource(CustomerTypeList, _
Nothing)

This code defines a Dictionary to contain the description of the enum and the integer value of the enum. The for/each loop iterates through the set of Enum values. It uses reflection to find the DescriptionAttribute. It then adds the description and value to the dictionary.

The code then binds to the ComboBox, setting the DisplayMember to the “Key” of the dictionary and the ValueMember to the “Value” of the Dictionary.

Now the combo box looks like this:

Much better!

Extension Methods

So the user interface looks nicer, but the code to get the DescriptionAttribute looks rather tedious. It would be much nicer if there was a GetDescription method on the Enum. But hey, with the extension method feature introduced in .NET 3.5, we can build one ourselves!

In C#:

public static string GetDescription(this Enum currentEnum)
{
string description = String.Empty;
DescriptionAttribute da ;

    FieldInfo fi = currentEnum.GetType().
                GetField(currentEnum.ToString());
    da = (DescriptionAttribute)Attribute.GetCustomAttribute(fi,
                typeof(DescriptionAttribute));
    if (da != null)
        description = da.Description;
    else
        description = currentEnum.ToString();

return description;
}

In VB:

<ExtensionAttribute()> _
Public Function GetDescription(ByVal currentEnum As [Enum]) As String
Dim description As String = String.Empty
Dim da As DescriptionAttribute

    Dim fi As FieldInfo = currentEnum.GetType. _
                GetField(currentEnum.ToString)
    da = DirectCast(Attribute.GetCustomAttribute(fi, _
                GetType(DescriptionAttribute)), DescriptionAttribute)
    If da IsNot Nothing Then
        description = da.Description
    Else
        description = currentEnum.ToString
    End If

Return description
End Function

The C# code can reside in any static class. The VB code must reside in a module, which provides the same features as a static class.

This code uses reflection to get the DescriptionAttribute for any Enum value. So it can be readily reused. The code returns the DescriptionAttribute if one is found, otherwise it returns the name.

Binding to an Enum Description - Redux

Now the binding code is much easier to work with.

In C#:

Dictionary<string, int> CustomerTypeList =
new Dictionary<string, int>();

foreach (Customer.CustomerTypeOption enumValue in
Enum.GetValues(typeof(Customer.CustomerTypeOption)))
{
CustomerTypeList.Add(enumValue.GetDescription(), (int)enumValue);
}

In VB:

Dim CustomerTypeList As New Dictionary(Of String, Integer)

For Each enumValue As Customer.CustomerTypeOption In _
[Enum].GetValues(GetType(Customer.CustomerTypeOption))
CustomerTypeList.Add(enumValue.GetDescription, enumValue)
Next

' Bind the combo box
CustomerTypeComboBox.DisplayMember = "Key"
CustomerTypeComboBox.ValueMember = "Value"
CustomerTypeComboBox.DataSource = New BindingSource(CustomerTypeList, _
Nothing)

Enjoy!