There are two ways to debug your design-time code:

• Place MessageBox..::.Show calls at strategic points in your code.

• Attach another instance of Visual Studio to debug the design environment of the first instance.

For more information, see How to: Access Design-Time Services.

You should reference the System.Design assembly. Designer-related types are located in the System.Design assembly. This includes types in the System.Windows.Forms.Design and System.ComponentModel.Design namespaces.

Also, be sure to import the namespaces you need using the Imports or using keywords. For more information, see How to: Access Design-Time Support in Windows Forms.

You can receive this error when you are creating your component or control on the design surface from the Toolbox. The following table shows the two likely causes for this error.

You can receive this error when you are creating your component or control on the design surface from the Toolbox. The most likely cause is that you are trying to use a component or control that was built to a 64-bit assembly. The Visual Studio design environment does not support 64-bit components.

If you use multithreading in your Windows Forms applications, you must be careful to make calls to your controls in a thread-safe way. This exception is raised by the debugger and does not appear at run time, but you are strongly advised to fix this problem when you see it. For more information, see How to: Make Thread-Safe Calls to Windows Forms Controls.

The file with your component or control can contain multiple class definitions, but the first class in the file must be one that you can design. The first class in the file must implement the IComponent interface, or it must derive from the Component class or a class that derives Component.

If your custom designer creates any Adorner objects, you must delete them from the design surface when your designer goes out of scope. Call BehaviorServiceAdornerCollection..::.Remove in your designer's Dispose method, to clear Glyph objects and related Adorner and Behavior objects. For more information, see How to: Extend the Appearance and Behavior of Controls in Design Mode.

The default control designer creates a glyph that covers the entire control on the design surface. This is named the body glyph. If your custom control designer creates a glyph with the same bounds as the body glyph, it will obscure the underlying Behavior implementation associated with the body glyph. This prevents default features such as smart tags and resize glyphs from appearing.

You cannot pass messages among Behavior objects, so you cannot handle a mouse message and forward it to any underlying Behavior objects. When you implement a glyph that covers the entire control, you are responsible for the entire appearance and behavior of your custom design experience.

If your custom designer attaches event handlers to designer events such as ComponentRemoved ActiveDesignerChanged, and SelectionChanged, you must detach your event handlers in your designer's Dispose method.

Failing to do this can result in unintended behavior at design time. The following list shows some of the symptoms that can occur:

• Error message box: "An error occurred while processing this command."

• Error message box: "Object reference not set to an instance of an object."

• Event handlers called inappropriately when components are deleted or designers are closed.

If you want your custom component or control's collection property to be serialized, apply the DesignerSerializationVisibilityAttribute and set it to Content. For more information, see How to: Serialize Collections of Standard Types with the DesignerSerializationVisibilityAttribute.

If you attempt to acquire a reference to the UndoEngine service while a form is loading, the GetService method returns null.

The UndoEngine service is not created and enabled until the form has completed its load phase. After the form is loaded, subsequent calls to GetService will return an UndoEngine reference.

In general, you should seldom require a reference to the UndoEngine directly. Those cases in which you do need it are usually caused by a user action and occur after the designer is loaded.

The design environment does not recognize changes to your component or control if you set properties directly. For events like ComponentChanged to be raised, you must set the value of your component's properties with the PropertyDescriptor..::.SetValue method. This notifies the design environment of the property change, enabling the design surface and PropertyGrid controls to update correctly. For more information, see How to: Extend the Appearance and Behavior of Controls in Design Mode.

You attach your custom designer to the control it designs by applying the DesignerAttribute to the control.

You must precisely specify the DesignerAttribute parameters, otherwise the design environment will not load your custom designer.

When you make changes to the design-time aspects of a component, you must rebuild the component's project. In addition, if there is another Windows Forms project that is currently open and uses this component, you will probably need to refresh the project to see the changes. Typically, you must close and reopen the design window containing the component.

The Windows Forms Designer generates the following code for Windows Forms Application projects in C#.

private System.ComponentModel.IContainer components = null;

Depending on which FxCop rules are in effect, FxCop may produce the "DoNotInitializeUnnecessarily" warning. This is because null is the Common Language Runtime (CLR) default for reference properties.

If the designer did not initialize the components field to null, the C# compiler would produce the following warning:

"Form1.components is never assigned to, and will always have its default value null."

You can suppress the FxCop warning with SuppressMessageAttribute, but this can cause maintenance issues if the class name is changed. Therefore, it is recommended that you ignore the FxCop warning.

By default, the Windows Forms Designer emits designer serialization code into a dedicated file that is separate from your component's main file. For example, in a Windows Forms Application project, the definition for the Form1 class is split into two files, as shown in the following table.

In general, you do not need to modify the code emitted by the Windows Forms Designer. Edit the main class file instead.

The Windows Forms Designer uses the partial keyword to divide the implementation of Form1 into two separate files. This prevents the designer-emitted code from being interspersed with your code. For more information about the partial keyword, see Partial Classes and Methods (C# Programming Guide) and Partial (Visual Basic).

The Windows Forms Designer does not support dividing a designable type's definition into more than two partial implementations. This restriction includes creating a new class file that contains a third partial definition of the type, as well as adding a third partial class definition of the type in either the main file or the designer file. Members defined this way will not be visible in the Windows Forms Designer.

When types are invalidated in the designer, the ComponentSerializationService performs a partial reload to refresh the designer with the updated types. Versions of Visual Studio preceding Visual Studio 2005 completely reloaded the designer. The partial reload behavior in Visual Studio 2005 is faster than a complete reload, and it also preserves the undo stack.

Components and corresponding serializers authored before Visual Studio 2005 may not be able to accommodate a partial reload. Components and controls may cause unexpected behavior because they were authored to deserialize only during a full reload. Symptoms include stack overflows, hangs, or blank regions in the Windows Forms Designer when legacy controls are present.

You can revert to the full reload behavior by adding the following setting to the devenv.exe.config file. If you installed Visual Studio 2005 to the default location, this file is in the C:\Program Files\Microsoft Visual Studio 8\Common7\IDE folder.

<appSettings>
   <add key="EnableOptimizedDesignerReloading" value="false" />
</appSettings>

If you are hosting a designer outside Visual Studio, your smart tags may raise a NullReferenceException. To resolve this issue, provide an IUIService reference in your designer and implement the Styles property. In the IDictionary exposed by Styles, assign a new Font as the element specified by the "DialogFont" key, as shown in the following code fragment.

Styles["DialogFont"] = new Font(...);

In Visual Studio, when you use ToolboxBitmapAttribute to associate an icon with your custom component, the bitmap does not appear in the Toolbox for autogenerated components. To see the bitmap, reload the control by using the Choose Toolbox Items dialog box.

Tasks

Concepts

Other Resources