CHAPTER 15 TYPE REFLECTION, LATE BINDING, AND ATTRIBUTE-BASED PROGRAMMING
Putting Reflection, Late Binding, and Custom Attributes in
Perspective
Even though you have seen numerous examples of these techniques in action, you may still be
wondering when to make use of reflection, dynamic loading, late binding, and custom attributes in your
programs? To be sure, these topics can seem a bit on the academic side of programming (which may or
may not be a bad thing, depending on your point of view). To help map these topics to a real-world
situation, you need a solid example. Assume for the moment that you are on a programming team that is
building an application with the following requirement:
•
The product must be extendable by the use of additional third-party tools.
What exactly is meant by extendable? Well, consider the Visual Studio IDE. When this application
was developed, various “hooks” were inserted into the code base to allow other software vendors to
“snap” (or plug in) custom modules into the IDE. Obviously, the Visual Studio development team had no
way to set references to external .NET assemblies it had not developed yet (thus, no early binding), so
how exactly would an application provide the required hooks? Here is one possible way to solve this
problem:
•
First, an extendable application must provide some input vehicle to allow the user
to specify the module to plug in (such as a dialog box or command-line flag). This
requires dynamic loading.
•
Second, an extendable application must be able to determine whether the module
supports the correct functionality (such as a set of required interfaces) in order to
be plugged into the environment. This requires reflection.
•
Finally, an extendable application must obtain a reference to the required
infrastructure (such as a set of interface types) and invoke the members to trigger
the underlying functionality. This may require late binding.
Simply put, if the extendable application has been preprogrammed to query for specific interfaces,
it is able to determine at runtime whether the type can be activated. Once this verification test has been
passed, the type in question may support additional interfaces that provide a polymorphic fabric to their
functionality. This is the exact approach taken by the Visual Studio team, and despite what you might be
thinking, is not at all difficult!
Building an Extendable Application
In the sections that follow, I will take you through a complete example that illustrates the process of
building an extendable Windows Forms application that can be augmented by the functionality of
external assemblies. If you do not have some experience building GUIs with the Windows Forms API,
you might wish to load up the provided solution code and follow along.
591