La versatilità con la quale i web control ogni giorno ci consentono di affrontare le più disparate esigenze è da attribuire in gran parte alla possibilità offerta allo sviluppatore di definire il layout grafico da utilizzare per presentare dati e informazioni all'utente.
In questo script vedremo come realizzare un custom web control che consenta la personalizzazione del proprio layout grafico.
Per prima cosa scegliamo la classe base, scelta che va ponderata considerando le funzionalità di cui avremo bisogno e che già sono state implementate ad esempio da un altro controllo già esistente.
Nel nostro caso è sufficiente utilizzare come classe base il tipo WebControl, ricordandoci inoltre di implementare l'interfaccia INamingContainer, consentendoci così di utilizzare durante definizione dei Template l'espressione:

<%# Container %>

Il nostro controllo, chiamato GameView, è dotato di quattro proprietà, due delle quali, Name e Developer di tipo string, sono utilizzare per definire rispettivamente il nome del gioco e il gruppo che lo ha sviluppato.
Le proprietà rimanenti, chiamate Template e TemplateContainer, la prima di tipo ITemplate e la seconda di tipo Control, sono usate rispettivamente per definire la template e il suo contenitore.
La creazione vera e propria del template avrà luogo nel metodo CreateChildControls, del quale eseguiamo l'override:

protected override void CreateChildControls()
{
  //svuoto la collezione dei controlli
  Controls.Clear();

  //istanzio un placeholder che userò come contenitore per il template 
  _templateContainer = new PlaceHolder();

  ITemplate _template = Template;

  //se non è stato impostato nessun template uso quello di default
  if (_template == null)
  {
    _template = new InnerTemplate();
  }

  //creo il template aggiungendolo al suo contenitore
  _template.InstantiateIn(_templateContainer);

  //aggiungo il contenitore ed il template alla collezione dei controlli
  Controls.Add(_templateContainer);
}

Infine eseguiamo l'override del metodo DataBind, nel quale richiameremo il metodo CreateChildControls.

public override void DataBind()
{
  CreateChildControls();
  ChildControlsCreated = true;
  _requireDataBind = false;
  base.DataBind();
}

Da notare gli attributi che decorano la proprietà Template:

[Browsable(false)]
[PersistenceMode(PersistenceMode.InnerProperty)]
[DefaultValue(typeof(ITemplate), "")]
[Description("Control template")]
[TemplateContainer(typeof(GameView))]
public virtual ITemplate Template
{
  get
  {
    return _template;
  }
  set
  {
     _template = value;
  }
}

Mediante PersisetenceMode e TemplateContainer indichiamo rispettivamente come persistere nel markup la proprietà Template, ed il tipo che contiene il Template. In particolare, quest'ultimo attributo consente l'utilizzo nella definizione del Template dell'espressione:

<%# Container.Name %>

Di seguito un esempio che illustra come definire nel markup il Template:

<My:GameView runat="server" ID="MyGameView" Name="Halo 3" Developer="Bungie / Microsoft">
  <Template>
    <fieldset>
      <legend>Nome del gioco</legend>
      <%# Container.Name %>
    </fieldset>
    <fieldset>
      <legend>Sviluppato da</legend>
      <%# Container.Developer %>
    </fieldset>
    </Template>
</My:GameView>

Ricapitolando, per creare un custom web control che supporti l'utilizzo di template, i passi da seguire sono i seguenti:
- scegliere la classe base, e se quest'ultima già non implementa l'iterfaccia INamingContainer provvedere a implementarla;
- implementare l'interfaccia ITemplate, e, anche se opzionale, decorare l'unica proprietà definita dall'interfaccia con l'attributo TemplateContainer: questo congiuntamente all'implementazione dell'interfaccia INamingcontainer ci consentirà di utilizzare nel markup l'espressione di binding sopra riportata;
- esporre una proprietà di tipo Control il quale funzionerà da contenitore per il Template;
- eseguire l'override del metodo CreateChildControls per istanziare il Template.