Simplify Interface Implementation with Visual Studio

Interface types are a key aspect of many .NET projects. Even if you don’t directly build a custom interface, it is very common to implement standard interfaces to ensure your classes and structures integrate within the fabric of the base class libraries.

I’d guess most of you are aware that interfaces by themselves are nothing more than a named set of abstract members (methods, properties and/or events). By defining an interface, you have created a “contract” which provides a polymorphic interface to the caller. Essentially when callers see that you support an interface type, they can rest assured that the object supports a canned set of members.

Given that implementing an interface is an all or nothing proposition, one slightly annoying aspect of working with these types is that the supporting class (or structure) must content with *all* of the members. Thus, if the interface in question contains 10 members, you must ensure each member has the correct arguments, return values, and member names.

Visual Studio has a few tricks which can simply the task of dealing with interfaces. Some of you have (hopefully) been using these features for quite some time, however when I teach .NET courses, I am surprised how many developers are unaware of these features of the IDE. So, in this (real) quick blog post, I’d like to point out two useful shortcuts.

Visually Define and Implement Interfaces

When you add a new *.cd (aka, class designer) file to your project, you can drag over an Interface type from your Toolbox, and populate the members using the related Class Details window:

Fair enough, however what if you wish to support this interface on a new type? Although a tad unintuitive, your journey begins by selecting the Inheritance icon from the Toolbox (there is no ‘implements’ icon, although this is the better term when dealing with interfaces). Assume you have added a new Class to your designer named MyClass. Click the Inheritance icons, then click on the class which will be implementing the interface. After this point, click on the interface you want to support. At this point, your designer will look something like so:

If you were to look at the code behind MyClass, you’ll see that each member of the interface has been accounted for. At this point, you can gut the stub code and provide real functionality:

public class MyClass : ISomeInterface
{
  #region ISomeInterface Members

  public void MethodA()
  {
    throw new NotImplementedException();
  }

  public int MethodB(string arg1, int arg2)
  {
    throw new NotImplementedException();
  }

  #endregion
}

Implement Interfaces using the Integrated Smart Tag

Let’s say you are pounding away some code, and need to support a set of interfaces on a new type. While you could flip to the designer, you can stay fixed within your code window and still get the much appreciated code gen of the visual designer. As soon as you type in an interface name on a class / structures opening definition, you will be able to activate an interface ‘Smart Tag’. To do so, hover your mouse over the interface itself:

Here, you can choose to implement the interface implicitly (e.g., as a set of normal public members) or explicitly (e.g., hidden from the type instance and only accessible via a casting operation). Once you select an option, you’ll find that Visual Studio will provide stub code for each member of the interface, and any base interfaces which it extends.

That’s it folks. Told you it would be a short post. Just wanted to throw this out there, as my last class had numerous people who had no clue Visual Studio had these helpful tricks. Take care.