.NET Component Inspector

Have you ever wished you could explore the behavior of a component or some code without having to write any code? To watch events occur on any object and examine the history of events? To quickly try something and see how it affects the component? To look at the visual behavior of a component as you adjust not only its properties, but execute its methods? If so the .NET Component Inspector is the tool you have been seeking.

The Component Inspector allows you to:

  • open any .NET assembly (executable or library), any number of which can be opened at once;
  • trace events on any object by simple one click event registration either on all events for an object or selected events;
  • create any object from a class in the opened assemblies using drag/drop;
  • create Controls on the design surface, move, resize or embed them in other Controls;
  • search for types or object content.
  • use the same set of Control objects both in design mode and normal running mode and go back and forth between the two with a single click;
  • examine or alter any field or property in the created objects, regardless of visibility;
  • execute any method on the created objects, regardless of visibility;
  • quickly examine and manipulate objects in common collections (IList, IDictionary) without concern of the implementation details of the collections. For example, you can cut/copy/paste objects to/from lists;
  • directly execute an application, class, or Control without writing any code; and
  • explore the contents of assemblies and the Global Assembly Cache (GAC).

Compare the .NET Component Inspector with other tools/products.

Controls/Design Surface

Click image for full size

You can drag a control, specified in either the Controls or Assemblies/Types panel to either the Design Surface or the Objects panel. When you do this, not only does the Control appear, but the Control's object appears in the Objects panel. The Objects panel has a completely general structure that allows you to examine or modify any field or property (regardless of visibility), as shown below with the modification of the Anchor property.

You may also invoke a method (the return result of the method is recorded in the Objects tree so that you can examine it).

This structure is similar to that provided by the Visual Studio .NET debugger with some important differences:

  • Commonly used things like lists are presented in an easy to use fashion as simply a list of objects (see "Top-Level Object" in the Event Logging screenshot below).
  • You may modify the values of fields or properties and invoke methods within the tree.
  • The static type structure of superclasses is not presented, making it much easier to navigate.

Event Logging

This screenshot is an example of event logging, where all of the events for a TreeView are being logged. The TreeView is shown in execution (non-design) mode. You see the events that have occurred in the Event Log panel. On the BeforeExpand event, you can see that the stack trace associated with this event is shown, and on the Objects panel (on the left), the event object is shown, with the Node property opened up.

Another powerful feature is the event incarnation number. This shows which events are causally related. For example, the Click, MouseDown, BeforeExpand, and AfterExpand events are all related (as shown because they all have number 31).

Panes of the Inspector

  • Objects - A tree of all known objects. The tree shows all of the members of the object's class including fields, properties, and methods. The current values of the members is also shown. For example, if you call a given method, the return value of the method is shown.
  • Parameters - Provides the mechanism for detailed display and input of values for method parameters and fields/properties. Allows any type of value to be specified (including structures, colors, objects, etc).
  • Control Design Surface - Controls are created here and can be moved, resized or embedded in other controls. This can be either in design mode (served by the control's designer), or in actual runtime mode so you can see the behavior of the running control.
  • Assemblies/Types - Shows all of the open assemblies with their type information. This is similar to the type browser in VS.NET. You can select a class in this tree and drag it to the either Object Tree (or Control Design Surface if a Control) and it will create the object. If there are multiple constructors, you can select the constructor to use.
  • Controls - Shows only the Control classes of the presently open assemblies. This is done to allow you to quickly access controls. The Controls panel is organized by namespace, and beneath the Control classes the organization is the same as the Assemblies/Types panel.
  • GAC - The Global Accembly Cache (GAC) presented in the same manner as the Windows explorer. You can open assemblies from this panel, and they then appear on the Assemblies/Types panel.
  • Event Log - The Event Log panel contains a row for each occurrence of an event that is being logged. Each row contains the information about the event. A context menu allows you to display the event object or sending object in the Objects panel.
  • Events Being Logged - This panel provides a concise view of the events being logged. A context menu allows you to disable logging for a given event or events.
  • Detail Information - At the bottom, detailed information about the item selected in the upper panels is shown.