Mastering Visual Studio .NET provides you, as an experienced programmer, with all the information needed to get the most out of the latest and greatest development tool from Microsoft®. It doesn't matter if you're an MFC, C++, STL, ATL, COM, Win32, Visual Basic, C#, HTML, XML, ASP.NET, database, web application, Web service, NT service, stand-alone client, or component programmer targeting Windows® or one of the Windows variants (i.e. Windows CE or the PocketPC) -- this is the book that will help you master the toolkit.

Written by experienced developers and trainers John Flanders, Ian Griffiths, and Chris Sells, Mastering Visual Studio .NET begins with fundamental information about maximizing the power of Visual Studio .NET as it comes out of the box, including the following topics:

projects and solutions

files and the various file editors

debugging

web projects

database projects

setup projects

To experience the full spectrum of functionality and extensibility, Mastering Visual Studio .NET provides you with the practical depth and detail needed to best put these features to work. The second section of the book is about extending VS.NET to suit your specific needs:

integrating controls and components with VS.NET

the VS.NET automation object model

macros and add-ins

custom wizards

the Visual Studio Integration Program (VSIP)

If you're serious about using the VS.NET toolkit, you'll want a book of this magnitude close by. Mastering Visual Studio .NET will take you beyond what you'll read in the standard documentation by offering hints and recommendations that the authors and the community at large have found to be useful after many years of experience.

"Mastering Visual Studio .NET" provides the experienced programmer with all the information needed to get the most out of the latest development tool from Microsoft. It doesn't matter if you're an MFC, C++, STL, ATL, COM, Win32, Visual Basic, C#, HTML, XML, ASP.NET, database, web application, Web service, NT service, stand-alone client, or component programmer targeting Windows or one of the Windows variants (Windows CE or the PocketPC) - this book will help you master the toolkit. Written by experienced developers and trainers, the book begins with fundamental information about maximizing the power of Visual Studio .NET as it comes out of the box, including the following topics: projects and solutions; files and the various file editors; debugging; web projects; database projects; and setup projects. To experience the full spectrum of functionality and extensibility, "Mastering Visual Studio .NET" provides you with the practical depth and detail needed to best put these features to work. The second section of the book is about extending VS.NET to suit your specific needs and covers: integrating controls and components with VS.NET; the VS.N

ET automation object model; macros and add-ins; custom wizards; and the Visual Studio Integration Program (VSIP).

Mastering Visual Studio .NET provides you, as an experienced programmer, with all the information needed to get the most out of the latest and greatest development tool from Microsoft®. Written by experienced developers and trainers John Flanders, Ian Griffiths, and Chris Sells, this book not only covers the fundamentals, but also shows how to customize and extend the toolkit to your specific needs.

Chris Sells in an independent consultant, speaker and author specializing in distributed applications in .NET and COM. He's written several books and is currently working on Windows Forms for C# and VB.NET Programmers and Mastering Visual Studio .NET. In his free time, Chris hosts various conferences, directs the Genghis source-available project, plays with Rotor and, in general, makes a pest of himself at Microsoft design reviews. More information about Chris, and his various projects, is available at http://www.sellsbrothers.com

Ian Griffiths is an independent consultant specializing in medical imaging applications and digital video. He also works as an instructor, teaching courses on .NET for DevelopMentor. Ian holds a degree in Computer Science from Cambridge University.

Although Jon spent the first few years of his professional life as an attorney, he quickly found chasing bits more interesting than chasing ambulances. After working with ASP and COM, he made the move to .NET. Jon is most at home spelunking, trying to figure out exactly how .NET (specifically ASP.NET and Visual Studio .NET) works. Deducing the details and disseminating that information to other developers is his passion.

CHAPTER 7 - Integrating Components with Visual Studio .NET

Visual Studio .NET presents a great deal of information about controls and other components you use in the development environment.When you drag a component from the toolbox into your project,VS.NET appears to know everything about it ?the events and properties it supports are displayed in the property panel,neatly categorized,with a short description available for each member.Some controls have their own unique interactive editing features.Many add extra items to Visual Studio .NET ?s menus.

You might suspect that this level of extensive and often highly specialized support is something that is available only for the built-in controls,but that is not the case.

Visual Studio .NET has a very open architecture for allowing components to customize the way in which they integrate with the environment.

Basic Integration
To build components that exploit Visual Studio .NET ?s integration facilities,you must understand the basic mechanisms involved.Component integration relies heavily on the .NET runtime ?s reflection mechanism ?the facility that allows type information to be examined at runtime.VS.NET uses reflection to discover what properties and events your component provides.

Strictly speaking,Visual Studio .NET doesn ?€™t use reflection directly.It uses the TypeDescriptor class and its friends in the System. ComponentModel namespace.These provide a virtualized view of type information,which allows a component ?s properties to be extended dynamically.The TypeDescriptor API is implemented using the reflection API however.One of the advantages of this reflection-based approach is that components get a great deal for free.All of their public properties and events will be detected automatically.So a component as simple as that shown in Example 7-1 can participate fully in visual editing in a Visual Studio .NET project.

If you compile the code in Example 7-1 into a class library,you can drag the compiled DLL from Windows Explorer onto a toolbox.(Alternatively,you can add it by right-clicking on the toolbox,selecting Customize Toolbox ?,choosing the .NET Framework Components tab,clicking the Browse ?button,and locating your component.This will have the same effect but is considerably more long-winded than the drag-and-drop approach.).

When you add a DLL to a toolbox,Visual Studio .NET searches it for classes that implement System.ComponentModel.IComponent and will add an entry to the toolbox for each such class that it finds.This includes all classes that derive from ComponentModel ? it implements IComponent .If the DLL just contains the class shown in Example 7-1,the toolbox will grow one extra entry,as shown in Figure 7-1.(The cog icon is the default graphic used when a component does not provide its own bitmap. We will see how to supply a custom bitmap later.)

You will now be able to drag this component onto Visual Studio .NET design windows just like any other component. Because it derives directly from Component (and not the Windows Forms or Web Forms Control classes),it will appear in the component tray of any form you add it to,rather than on the form itself.This makes perfect sense ?we didn?t write a visual component,so it would have no business appearing on the form itself.

Once you have added an instance of your component to the component tray,you can select it and edit its properties by displaying the Properties window,just as you can for any built-in component.Figure 7-2 shows the Properties window for this component.

Example 7-1.A very simple component
using System.ComponentModel;
public class MyComponent :Component
{
public string Title
{
get {return myTitle;}
set {myTitle =value;}
}
private string myTitle;
}
Figure 7-1.A newly added toolbox itemNotice that the one public property defined by our class ?Title ?has appeared in the Properties window,along with the standard pseudo properties that the designer always adds.(The (Name)entry simply determines the name of the designer-generated field that will hold a reference to the component. Note that if you add a property called Name ,this can lead to confusion,as VS.NET tends to want the Name property to be the same as the name of the field that holds the object.The Modifiers property determines that field ?s protection level.)If the component has any public events, and you are using it in a C#project,the lightning bolt button will appear at the top of the window,allowing us to browse the events instead of the properties. (For a Visual Basic .NET project,the events will instead be listed at the top of the source editor window.) Our property has appeared in the default Misc category, but we will see how to change that shortly.

If you are trying things out as you read this,be aware that Visual Studio .NET appears to cache information about components. This is reasonable, since most of the time components do not change while you are using them,but it is slightly inconvenient if you are developing a component ?s design-time features.If you modify your component (e.g., you add an event),you may need to do the following steps to make changes visible in the client project::

?Delete all instances of the component in the client project.
?Remove the reference to the component from the client project (in the project ?s References section in the Solution Explorer).
?Add the component back into the client project.
These first three steps are usually sufficient,but if they do not work, try performing these extra steps before adding the component back to the project:
?Delete the component from the toolbox.
?Recompile the component.
?Add the component back to the toolbox.

2004-04-26 Introduction to Visual Studio.NET rather than Mastering

Most of the information in this book would be learned by just using VS.NETfor a few days. Very little of this book is actually useful, there is achapter on writing wizards that was just about enough, but left youdangling with lots still missing.
I would just spend more time in thehelp system - its all there.