Contenedores, sitios y componentes

Artículo
02/19/2013

Un contenedor es un objeto de colección especializado que proporciona la contención lógica de uno o más componentes.Los contenedores administran la interacción de los componentes entre sí y con el entorno de la aplicación externa; para ello, proporcionan una implementación de la interfaz ISite a través de la cual pueden producirse las interacciones.El contenedor permite el seguimiento de los componentes sobre la base de que el primero en entrar es el primero en salir; además, permite hacer referencia a los componentes por medio de un índice.El contenedor proporciona también un medio para eliminar los componentes cuando ya no se necesitan.

El término contención hace referencia a una contención lógica, no visual ni física.El contenedor encapsula uno o más componentes y proporciona un empaquetador a través del cual pueden interactuar los clientes.Permite agregar y quitar componentes mediante la sintaxis siguiente:

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 contendor de componente puede ser una instancia de la clase Container o una implementación de la interfaz IContainer.Container es la implementación de referencia de esta interfaz.

Especificar un nombre de componente

También puede especificar un nombre para el componente dentro del contenedor.Este nombre debe ser único en el contenedor y se especifica mediante el método Add.

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");

Administrar recursos y extender contenedores

Los contenedores proporcionan un medio centralizado para administrar los recursos asociados a los componentes.Cuando se llama al método Dispose, el contenedor llama automáticamente al método Dispose de todos los componentes contenidos, con lo que se garantiza su inmediata liberación.

Los contenedores son extensibles.Puede crear una clase propia heredada de Container que incorpore funcionalidad personalizada.Por ejemplo, podría crear un contenedor que exigiera reglas para controlar qué componentes se pueden agregar al contenedor, como se muestra en el ejemplo siguiente:

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();
      }
   }
}

En el ejemplo anterior se crea una clase contenedora nueva con capacidad para exigir una regla relativa a los componentes que pueden ingresar en el contenedor.Si un componente no es de la clase especificada (en este ejemplo, Widget), se produce una excepción.

Cuando se agrega un componente a un contenedor, el contenedor crea un sitio para él.Ésta es una implementación de la interfaz ISite que se expone a través de la propiedad Site del componente.La comunicación de un componente con el contenedor que lo hospeda tiene lugar a través de la propiedad Site del componente.Esta propiedad representa el sitio lógico del componente y se hospeda en el contenedor.Un componente que no se contiene en un contenedor devuelve una referencia null en su propiedad Site.La propiedad Site permite obtener una referencia a la interfaz del contenedor por medio de la propiedad ISite.Container, o una referencia a la interfaz del componente hospedado por medio de la propiedad 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());

Ambas propiedades devuelven sólo la interfaz asociada a estos objetos, no una referencia a los propios objetos.Observe que el componente también tiene una propiedad Container que devuelve la misma interfaz que Container.Esta propiedad se proporciona a través del sitio y se puede considerar como un acceso directo.

Si se asigna un nombre al componente mediante el método Add, el nombre se puede recuperar a través de la propiedad Name.Si el contenedor tiene asociado un objeto de servicio, el componente puede obtener una referencia al objeto a través del método GetService.

Tener acceso a servicios

Puede tener acceso a una variedad de servicios a través del método GetService.Estos servicios proporcionan amplia compatibilidad para integrar sus componentes en el entorno de diseño.Para obtener más información, vea Cómo: Obtener acceso a servicios en tiempo de diseño y Arquitectura en tiempo de diseño.