Was this page helpful?
Your feedback about this content is important. Let us know what you think.
Additional feedback?
1500 characters remaining
Export (0) Print
Expand All

Containers, Sites, and Components

A container is a specialized collection object that provides logical containment for one or more components. Containers manage the interaction of the components with each other, as well as with the external application environment, by providing an implementation of the ISite interface through which interactions can take place. The container allows tracking of your components on a first-in, first-out basis, and allows you to refer to your components by an index. The container also provides for a means of common disposal of your components when you no longer have need for them.

Containment refers to logical containment, not visual or physical containment. The container encapsulates one or more components and provides a wrapper through which clients may interact. The container allows you to add and remove components via the following syntax:

using System.ComponentModel;
Component myComponent = new Component();
Container myContainer = new Container();

A component container will either be an instance of the Container class, or an implementation of the IContainer interface. Container is the reference implementation of this interface.

You can also specify a name for your component within the container. This name must be unique within the container, and is specified using the Add method.

Component myComponent = new Component();
Container myContainer = new Container();
myContainer.Add(myComponent, "ThisComponent");

Containers provide a central means of managing the resources associated with your components. When the Dispose method is called, the container automatically calls the Dispose method of all the contained components, thereby ensuring that resources are released promptly.

Containers are extensible. You can create your own class that inherits from Container that incorporates custom functionality. For example, you might create a container that enforced rules that govern which components may be added to the container, as is shown in the following example:

class MyContainer : Container
   public override void Add(IComponent component)
      // Checks to see if the component is allowed to join this container.
      if (component is Widget)
         throw new NonWidgetException();

The previous example creates a new container class that is able to enforce a rule about which components are able to join the container. If a component is not of the specified class (in this case, Widget), then an exception is thrown.

When a component is added to a container, the container creates a site for it. This is an implementation of the ISite interface that is exposed through the component's Site property. Communication by a component with its host container is accomplished via the component's Site property. This property represents the logical site of the component, and is hosted by the container. A component that is not contained in a container returns a null reference for its Site property. The Site property allows you to obtain a reference to the container interface through the ISite.Container property, or a reference to the component interface being hosted through the Component property.

Component myComponent = new Component();
Container myContainer = new Container();
IComponent myIComponent;
IContainer myIContainer;
myIComponent = myComponent.Site.Component;
myIContainer = myComponent.Site.Container;
MessageBox.Show("Are the components equal? " + 
MessageBox.Show("Are the containers equal? " + 

Both of these properties return only the interface associated with these objects, not a reference to the objects themselves. Note that the component also has a Container property that returns the same interface as Container. This property is provided by through the site and can be thought of as a shortcut.

If you assign a name to your component using the Add method, the name can be retrieved via the Name property. If the container has a service object associated with it, a reference to that object can be obtained by the component via the GetService method.

You can access a variety of services through the GetService method. These services provide extensive support for integrating your components into the design environment. For more information, see How to: Access Design-Time Services and Design-Time Architecture.

© 2015 Microsoft