This documentation is archived and is not being maintained.

ITemplate Interface

Defines the behavior for populating a templated ASP.NET server control with child controls. The child controls represent the inline templates defined on the page.

Namespace: System.Web.UI
Assembly: System.Web (in system.web.dll)

'Declaration
Public Interface ITemplate
'Usage
Dim instance As ITemplate

public interface ITemplate
public interface ITemplate
Not applicable.

This interface is used by custom server controls, but never implemented by them. ASP.NET always implements it.

The following code example demonstrates a simple templated server control that uses the ITemplate interface to create a templated property.

Imports System
Imports System.Web
Imports System.Web.UI

Namespace TemplateControlSamplesVB

    Public Class TemplateItem
        Inherits Control
        Implements INamingContainer

        Private _message As String = Nothing

        Public Sub New(Message As String)
            _message = message
        End Sub

        Public Property Message As String
           Get
              Return _message
           End Get
           Set
              _message = Value
           End Set
        End Property
    End Class
    <System.Security.Permissions.PermissionSetAttribute(System.Security.Permissions.SecurityAction.Demand, Name:="FullTrust"), _
    ParseChildren(true)> _
    Public Class Template1VB
        Inherits Control
        Implements INamingContainer

        Private _messageTemplate As ITemplate = Nothing
        Private _message As String = Nothing

        Public Property Message As String

           Get
              Return _message
           End Get
           Set
              _message = Value
           End Set
        End Property

        <TemplateContainer(GetType(TemplateItem))> _
        Public Property MessageTemplate As ITemplate

           Get
              Return _messageTemplate
           End Get
           Set
              _messageTemplate = Value
           End Set
        End Property

        Protected Overrides Sub CreateChildControls()

           ' If a template has been specified, use it to create children.
           ' Otherwise, create a single LiteralControl with the message value.

           If Not (MessageTemplate Is Nothing)
              Controls.Clear()
              Dim I As New TemplateItem(Me.Message)
              MessageTemplate.InstantiateIn(I)
              Controls.Add(I)
           Else
              Me.Controls.Add(New LiteralControl(Me.Message))
           End If
        End Sub

    End Class

End Namespace
   

package TemplateControlSamples;

import System.*;
import System.Web.*;
import System.Web.UI.*;   
   
public class TemplateItem extends Control implements INamingContainer
{
    private String _message = null;

    public TemplateItem(String message)
    {
        _message = message;
    } //TemplateItem
      
    /** @property 
     */
    public String get_Message()
    {
        return _message ;
    } //get_Message
    
    /** @property 
     */
    public void set_Message ( String value )
    {
        _message = value;
    } //set_Message
} //TemplateItem   
   
/** @attribute ParseChildren(true)
 */
public class Template1 extends Control implements INamingContainer
{
    private ITemplate _messageTemplate = null;
    private String _message = null;
      
    /** @property 
     */
    public String get_Message()
    {
        return _message ;
    } //get_Message

    /** @property 
     */
    public void set_Message ( String value )
    {
        _message = value;
    } //set_Message
      
    /** @attribute PersistenceMode(PersistenceMode.InnerProperty)
        @attribute TemplateContainer(TemplateItem.class)
     */      
      
    /** @property 
     */
    public ITemplate get_MessageTemplate()
    {
        return _messageTemplate ;
    }

    /** @property 
     */
    public void set_MessageTemplate ( ITemplate value )
    {
        _messageTemplate = value;
    }
      
    protected void CreateChildControls()
    {
        // If a template has been specified, use it to create children.
        // Otherwise, create a single LiteralControl with the message value.
        if ( get_MessageTemplate() != null  ) {
            get_Controls().Clear();
            TemplateItem i = new TemplateItem(this.get_Message());
            get_MessageTemplate().InstantiateIn(i);
            get_Controls().Add(i);
        }
        else {
            this.get_Controls().Add(new LiteralControl(this.get_Message()));
        }
    } //CreateChildControls
} //Template1

import System
import System.Web
import System.Web.UI

package TemplateControlSamplesJS{

    class TemplateItem extends Control implements INamingContainer{

        private var message : String = null

        function TemplateItem(message : String){
            this.message = message
        }

        function get Message() : String{
           return message
        }
        
        function set Message(value : String){
           message = value
        }
    }

    public ParseChildren(true)
    class Template1JS extends Control implements INamingContainer{

        private var messageTemplate : ITemplate = null
        private var message : String = null

        function get Message(): String{
           return message
        }
        
        function set Message(value : String){
           message = value
        }

        public TemplateContainer(TemplateItem)
        function get MessageTemplate() : ITemplate{
           return messageTemplate
        }
        
        function set MessageTemplate(value : ITemplate){
           messageTemplate = value
        }

        protected function CreateChildControls(){

           // if(a template has been specified, use it to create children.
           // Otherwise, create a single literalcontrol with message value

           if(MessageTemplate != null){
              Controls.Clear()
              var I : TemplateItem = new TemplateItem(this.Message)
              MessageTemplate.InstantiateIn(I)
              Controls.Add(I)
           }else
              this.Controls.Add(new LiteralControl(this.Message))
        }

    }

}

  • AspNetHostingPermission  for operating in a hosted environment. Demand value: LinkDemand; Permission value: Minimal.
  • AspNetHostingPermission  for operating in a hosted environment. Demand value: InheritanceDemand; Permission value: Minimal.

Windows 98, Windows Server 2000 SP4, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

The Microsoft .NET Framework 3.0 is supported on Windows Vista, Microsoft Windows XP SP2, and Windows Server 2003 SP1.

.NET Framework

Supported in: 3.0, 2.0, 1.1, 1.0
Show: