As part of a project I worked on at Mindseye, I wrote a couple utilities using C# that used reflection to query a given type for the existence of a method and if the method existed, to then invoke the method. In short, the utility allowed me to do this (pseudo-code):

AbstractType type = AbstractTypeFactory.Find("com.company.SomeClass");
string result = type.InvokeMethod("delete");

The AbstractTypeFactory type has a single static method ‘Find()’ that looks for the given type by name. If successful, it returns an instance of AbstractType, which you can use to invoke a given method on the type you looked up using the InvokeMethod() method. The InvokeMethod() method checks to see if the given method is a static or instance method, creates an instance if necessary, and then calls the method.

These utilities worked fine until I need to call the Find() method against a type that wasn’t in the same assembly as the assembly that my utility was in. Inside the AbStractTypeFactory (which is a pseudo-name by the way), I used the .NET Type class:

// Gets the Type with the specified name, performing a case-sensitive search.
Type type = Type.GetType("com.company.SomeClass");

I didn’t have time to look into why the GetType() method wouldn’t find types outside of the currently assembly… until today when I really needed to be use the utilities against a different assembly. It turns out that it’s relatively simple to do. Instead of using the type name (ie: “com.company.SomeClass”), you can use the AssemblyQualifiedName, which looks likes this:

com.company.SomeClass, assemblyname, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null

where assemblyname is the name of the DLL that com.company.SomeClass exists in. It’s relatively easy to retrieve the AssemblyQualifiedName using the AssemblyQualifiedName property of the Type type. For example, the .NET documentation gives this example:

Type objType = typeof(System.Array);
Console.WriteLine ("Qualified assembly name: {0}.", objType.AssemblyQualifiedName.ToString());

There are alot of good reasons why Microsoft designed the GetType() method the way they did, the majority of them related to how the runtime locates assemblies, which you should read about when you have a alot of time.

Couple days ago I was writing an ASP.NET webform and I wanted to programmatically inspect the items in the drop down. The drop down list in the ASP.NET page looks something like this:

<asp:dropdownlist id="mydropdown" class="dropbox" runat="server">
  <asp:listitem text=" -- select -- " value="" />
  <asp:listitem text="Text 1" value="1" />
  <asp:listitem text="Text 2" value="2" />
  <asp:listitem text="Text 3" value="3" />
</asp:dropdownlist>

and then in the code behind (like I mentioned before) you can do a bunch of useful things. First, if I wanted to set the default selected item in the form, I’d write this:

public void Page_Load(Object sender, EventArgs e) {
  // initialize form
  if (!IsPostBack) {
   mydropdown.SelectedValue = "1";
  }
}

That’s relatively trivial, it gets more interesting when you consider that you can access the DropDownList items programatically:

foreach (ListItem l in mydropdown.Items) {
  if (l.Value == 1) {
   l.Selected = true;
  }
}

In the above example I use the foreach statement to iterate through the collection of ListItems in the Items property. If the Value property of the ListItem is 1, then I set that to be selected. You can also access the Text property of the List Item.

The C# foreach construct jogged my memory about Java 1.5 (Tiger) which is supposed to have enhanced ‘for’ loops (also read this); for example this:

for (Iterator i = c.iterator(); i.hasNext(); ) {
  // do stuff with 'i'
}

becomes this:

for (Object o : c) {
  // do stuff w/ 'o'
}

When is 1.5 gonna arrive?

[Update: The link to the TextBox class from the ASP.NET TextBox Web Server Control points to the Windows Forms TextBox, not the Web Controls TextBox. Balls!]

If you’re running into trouble when using the TextBox class in ASP.NET, the MultiLine property and the Microsoft .NET Framework SDK Documentation, it’s probably because the documentation is wrong. The documentation that ships with v1.1 says that you can use the ‘Multiline’ property of the TextBox class (which is actually a property of the TextBoxBase class) to toggle the TextMode property like this:

private void CreateMyMultilineTextBox() {
  // Create an instance of a TextBox control.
  TextBox textBox1 = new TextBox();

  // Set the Multiline property to true.
  textBox1.Multiline = true;
  ....
}

If you do what the documentation says, you’ll get a compiler error that says this:

error CS0117: 'System.Web.UI.WebControls.TextBox' does not contain a definition for 'Multiline'

So instead, use the the TextBoxMode enumeration and the TextMode property:

private void CreateMyMultilineTextBox() {
  // Create an instance of a TextBox control
  TextBox textBox1 = new TextBox();

  // use the TextMode property and the TextBoxMode enumeration
  textBox1.TextMode = TextBoxMode.MultiLine;
  ....
}

All of this is documented correctly online.