Contenitori, siti e componenti

Articolo
08/11/2011

Un contenitore è un oggetto insieme specializzato che consente di contenere in modo logico uno o più componenti. I contenitori gestiscono l'interazione tra i componenti e con l'ambiente delle applicazioni esterne, fornendo un'implementazione dell'interfaccia ISite tramite la quale avvengono le interazioni. Il contenitore consente di tenere traccia dei componenti basandosi su un criterio FIFO (First-In/First-Out) e di fare riferimento ai componenti in base a un indice. Inoltre, il contenitore fornisce un sistema di eliminazione comune dei componenti non più necessari.

Il contenimento è di tipo logico, non visivo o fisico. Il contenitore consente di incapsulare uno o più componenti e fornisce un wrapper attraverso il quale i client possono interagire. Il contenitore consente di aggiungere e rimuovere i componenti utilizzando la seguente sintassi:

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 contenitore di componenti sarà un'istanza della classe Container oppure un'implementazione dell'interfaccia IContainer. Container è l'implementazione di riferimento dell'interfaccia.

Specifica del nome di un componente

È inoltre possibile specificare un nome per il componente all'interno del contenitore. All'interno del contenitore il nome deve essere univoco e viene specificato con il metodo 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");

Gestione delle risorse ed estensione dei contenitori

I contenitori forniscono un metodo centralizzato di gestione delle risorse associate ai componenti. Dopo che è stato chiamato il metodo Dispose, il contenitore chiama automaticamente il metodo Dispose di tutti i componenti contenuti, assicurando in tal modo l'immediato rilascio delle risorse.

I contenitori sono estensibili. È possibile creare una classe personalizzata mediante la quale sia possibile ereditare dall'oggetto Container, che contiene funzionalità personalizzate. È ad esempio possibile creare un contenitore che attivi le regole per la determinazione dei componenti aggiungibili, come illustrato nell'esempio seguente:

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

class MyContainer extends Container
{
   public void Add(IComponent component) throws NonWidgetException
   {
      // Checks to see if the component is allowed to join this container.
      if (component instanceof Widget) 
      {
         super.Add(component);
      }
      else
      {
         throw new NonWidgetException() ;
      }
   }
}

Nell'esempio precedente viene creata una nuova classe del contenitore, in grado di attivare una regola per la determinazione dei componenti che possono essere aggiunti al contenitore. Se un componente non appartiene alla classe specificata, in questo caso Widget, verrà generata un'eccezione.

Quando si aggiunge un componente a un contenitore, il contenitore crea un site. Si tratta di un'implementazione dell'interfaccia ISite, che viene esposta attraverso la proprietà Site del componente. La comunicazione di un componente con il contenitore che lo contiene avviene tramite la proprietà Site del componente. Questa proprietà rappresenta il sito logico del componente ed è contenuta nel contenitore. Un componente non contenuto in un contenitore restituisce un riferimento null per la proprietà Site. La proprietà Site consente di ottenere un riferimento all'interfaccia del contenitore tramite la proprietà ISite.Container oppure un riferimento all'interfaccia del componente contenuto tramite la proprietà 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());

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

Entrambe le proprietà restituiscono solo l'interfaccia associata a questi oggetti, non un riferimento agli oggetti. Si noti che il componente dispone inoltre di una proprietà Container che restituisce la stessa interfaccia come Container. La proprietà viene fornita tramite il site e può essere considerata come una sorta di collegamento.

Se si assegna un nome al componente utilizzando il metodo Add, sarà possibile recuperare il nome tramite la proprietà Name. Se al contenitore è stato associato un oggetto servizio, dal componente sarà possibile ottenere un riferimento all'oggetto attraverso il metodo GetService.

Accesso ai servizi

È possibile accedere a vari servizi tramite il metodo GetService. Questi servizi forniscono un ampio supporto per l'integrazione dei componenti nell'ambiente di progettazione. Per ulteriori informazioni, vedere Procedura: accedere ai servizi per la fase di progettazione e Architettura della fase di progettazione.