Best Practices Using Windows Forms ComboBox Control

string progFilesPath = Environment.GetFolderPath(Environment.SpecialFolder.CommonStartMenu);
string[] names = System.IO.Directory.GetDirectories(progFilesPath, "*.*", System.IO.SearchOption.AllDirectories);

System.IO.DirectoryInfo[] dirs = new System.IO.DirectoryInfo[names.Length];

System.Drawing.Size comboSize = combo.ClientRectangle.Size;
comboSize.Width -= SystemInformation.VerticalScrollBarWidth;

for (int i = 0; i < names.Length; i++)
{

dirs[i] = new System.IO.DirectoryInfo(names[i]);
names[i] = CompactPath(names[i], comboSize, combo.Font);

}

combo.Tag = dirs;

if (names.Length > 0)
{
combo.Items.AddRange(names);
combo.SelectedIndex = 0;
}

First we are obtaining the array of full names of all directories belonging to common Start menu (recursively). These full names are then used to create DirectoryInfo objects which are stored in ComboBox's Tag property. After DirectoryInfo object is created, path is compacted and added to Items collection.

The result is a ComboBox which shows compacted paths to the user and, once user selects one path, DirectoryInfo can be recovered by taking object occupying position SelectedIndex from the array stored in the Tag property. Here is a utility read-only property which returns selected directory:

public System.IO.DirectoryInfo TagSelectedDirectory
{
get
{

System.IO.DirectoryInfo dir = null;
System.IO.DirectoryInfo[] dirs = combo.Tag as System.IO.DirectoryInfo[];

if (dirs != null)
dir = dirs[combo.SelectedIndex];

return dir;

}
}

It is always good practice to have a property like this, which saves you from typecasting and validation in many places in code.

When code listed above is applied, output may look as shown on the following picture. You can see that all paths are compacted if necessary, so that they perfectly fit the ComboBox drawing area. Note that all code required to perform this task is only about 60 lines in length, including workarounds for three bugs related to MeasureText function.

Solution #2 - Using DataSource and DisplayMember Properties

This is method of choice whenever applicable, and that is in all cases where objects used to populate ComboBox expose a property with public getter which provides user-friendly representation of the object.

Short example will be used to demonstrate this simplest of all techniques. We will load all installed fonts (FontFamily objects) and then use their Name property to populate drop list. Here is the code:

System.Drawing.Text.InstalledFontCollection fonts = new System.Drawing.Text.InstalledFontCollection();
combo.DataSource = fonts.Families;
combo.DisplayMember = "Name";

There is no shorter code than this. For that reason, always use DataSource and DisplayMember when desirable property is available.

Even strong-typed getter of the selected object is a single liner:

public System.IO.DirectoryInfo DataSourceSelectedDirectory
{
get
{
return combo.SelectedItem as System.IO.DirectoryInfo;
}
}

Solution #3 - Using DataSource Without Appropriate DisplayMember Value

This case is similar to one in which Tag property was used. Although it is always possible to populate ComboBox with plain string, that way requires additional code typing and typecasting. One way to cope with the problem of lacking a useful property is to use general class which has such a property.

For example, KeyValuePair generic class can be used in such way that keys are strings shown in the ComboBox and values are DirectoryInfo objects.

We will demonstrate this idea on the same example as in Solution #1, i.e. on directory paths. Here is the code which uses KeyValuePair class to populate DataSource and DisplayMember properties of the ComboBox:

private void populateCustomDataSource_Click(object sender, EventArgs e)
{

List<KeyValuePair<string, System.IO.DirectoryInfo>> dirs = new List<KeyValuePair<string, System.IO.DirectoryInfo>>();
string progFilesPath = Environment.GetFolderPath(Environment.SpecialFolder.CommonStartMenu);
string[] names = System.IO.Directory.GetDirectories(progFilesPath, "*.*", System.IO.SearchOption.AllDirectories);

System.Drawing.Size comboSize = combo.ClientRectangle.Size;
comboSize.Width -= SystemInformation.VerticalScrollBarWidth;

for (int i = 0; i < names.Length; i++)
{
System.IO.DirectoryInfo dir = new System.IO.DirectoryInfo(names[i]);
names[i] = CompactPath(names[i], comboSize, combo.Font);
dirs.Add(new KeyValuePair<string, System.IO.DirectoryInfo>(names[i], dir));

}

combo.DataSource = dirs;
combo.DisplayMember = "Key";

}

This code is not much shorter than the one that uses Tag property. But ComboBox populated in this way is simpler to use, which becomes obvious when strong-typed getter is looked at:

public System.IO.DirectoryInfo CustomDataSourceSelectedDirectory
{
get
{
return ((KeyValuePair<string, System.IO.DirectoryInfo>)combo.SelectedItem).Value;
}
}

Yet another single liner demonstrates that DataSource property is the best way to populate ComboBox with objects of any class.

Conclusion

This article has demonstrated that simplest, hence most desirable, method of populating ComboBox with objects is to use DataSource and DisplayMember properties.

When DisplayMember cannot be used directly, because there is no public property which could serve the purpose, one can decide either to store original objects in Tag property or to use custom class which wraps original class and exposes property suitable for DisplayMember use.

Another two methods are never suggested to be used. First highly undesirable method is to populate ComboBox with objects (either using Items or DataSource properties) without providing custom or built-in conversion to string, relying just on the ToString() method. Second undesirable solution is to populate ComboBox with strings and then use SelectedIndex to access external structures in order to decode meaning of the selected item.