Conteneurs, sites et composants

Article
05/17/2015

Un conteneur est un objet collection d'un type particulier qui sert de réceptacle logique à un ou plusieurs composants. Les conteneurs gèrent les interactions des composants entre eux et avec l'environnement applicatif extérieur par le biais de l'implémentation de l'interface ISite. Ils permettent de suivre les composants selon la règle du « premier entré premier sorti » et de se référer aux composants par le biais d'un index. Ils offrent aussi un moyen de supprimer simultanément plusieurs composants dont vous n'avez plus besoin.

Dans un conteneur, les composants sont regroupés logiquement et non visuellement ou physiquement. Le conteneur encapsule un ou plusieurs composants et offre un wrapper à travers lequel les clients peuvent interagir. Il vous permet d'ajouter et de supprimer des composants au moyen de la syntaxe suivante :

Imports System.ComponentModel
Dim myComponent As New Component()
Dim myContainer As New Container()
myContainer.Add(myComponent)
myContainer.Remove(myComponent)

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

Un conteneur composant peut être soit une instance de la classe Container, soit une implémentation de l'interface IContainer. Container est l'implémentation de référence de cette interface.

Spécification d'un nom de composant

Vous pouvez également spécifier un nom pour votre composant à l'intérieur du conteneur. Ce nom, que vous spécifiez au moyen de la méthode Add, doit être unique à l'intérieur du conteneur.

Dim myComponent As New Component()
Dim myContainer As New Container()
MyContainer.Add(myComponent, "ThisComponent")

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

Gestion des ressources et extension des conteneurs

Les conteneurs permettent de centraliser la gestion des ressources associées à vos composants. Lorsque la méthode Dispose est appelée, le conteneur appelle automatiquement la méthode Dispose des composants qu'il englobe et garantit ainsi que leurs ressources seront rapidement libérées.

Les conteneurs sont extensibles. Vous pouvez créer votre propre classe héritant de Container qui comprend des fonctionnalités personnalisées. Par exemple, vous pouvez créer un conteneur qui applique des règles déterminant quels composants peuvent lui être ajoutés, comme le montre l'exemple suivant :

Public Class MyContainer
   Inherits Container
   Public Overloads Overrides Sub Add(ByVal component As IComponent)
      ' Checks to see if the component is allowed to join this container.
      If TypeOf component Is Widget Then
         ' Calls the Add method of the base class, and adds the component.
         MyBase.Add(component)
      Else
         ' If the component is not allowed, an exception is thrown.
         Throw New NonWidgetException()
      End If
   End Sub
End Class

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)
      {
         base.Add(component);
      }
      else
      {
         throw new NonWidgetException();
      }
   }
}

Dans l'exemple précédent, une classe de conteneur est créée ; cette classe applique une règle déterminant quels composants peuvent être ajoutés au conteneur. Si un composant n'appartient pas à la classe spécifiée (en l'occurrence, Widget), une exception est levée.

Lorsqu'un composant lui est ajouté, un conteneur crée pour lui un site. Il s'agit d'une implémentation de l'interface ISite qui est exposée par le biais de la propriété Site du composant. Le composant communique avec son conteneur via la propriété Site. Cette propriété, qui représente le site logique du composant, est hébergée par le conteneur. Un composant qui n'est pas rattaché à un conteneur retourne une référence null pour sa propriété Site. La propriété Site vous permet d'obtenir une référence à l'interface du conteneur par le biais de la propriété ISite.Container ou bien à celle du composant qu'il contient par le biais de la propriété Component.

Dim myComponent As New Component
Dim myContainer As New Container
myContainer.Add(myComponent)
Dim myIComponent as IComponent
Dim myIContainer as IContainer
myIComponent = myComponent.Site.Component
myIContainer = myComponent.Site.Container
' These two messages display True.
MessageBox.Show("Are the components equal? " & _
   myComponent.Equals(myIComponent).ToString)
MessageBox.Show("Are the containers equal? " & _
   myContainer.Equals(myIContainer).ToString)

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

L'une et l'autre propriétés retournent uniquement l'interface associée à ces objets et non une référence aux objets eux-mêmes. Notez que le composant a également une propriété Container qui retourne la même interface que Container. Cette propriété est fournie via le site et peut être considérée comme un raccourci.

Si vous assignez un nom à votre composant par le biais de la méthode Add, il peut être récupéré via la propriété Name. Si le conteneur est associé à un objet de service, le composant peut obtenir une référence à cet objet via la méthode GetService.

Accès aux services

Vous pouvez accéder à divers services à travers la méthode GetService. Ces services fournissent la prise en charge complète pour intégrer vos composants dans l'environnement de design. Pour plus d'informations, consultez Comment : accéder aux services au moment du design et Architecture de design.