Export (0) Print
Expand All

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)

public interface 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.

using System;
using System.Web;
using System.Web.UI;

namespace TemplateControlSamples {

    public class TemplateItem : Control, INamingContainer {
        private String     _message         = null;

        public TemplateItem(String message) {
            _message = message;
        }

        public String Message {

           get {
              return _message;
           }
           set {
              _message = value;
           }
        }
    }

    [System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name="FullTrust")]
    [ParseChildren(true)]
    public class Template1 : Control, INamingContainer {

        private ITemplate  _messageTemplate = null;
        private String     _message         = null;

        public String Message {

           get {
              return _message;
           }
           set {
              _message = value;
           }
        }

        [
            PersistenceMode(PersistenceMode.InnerProperty),
            TemplateContainer(typeof(TemplateItem))
        ]
        public ITemplate MessageTemplate {
           get {
              return _messageTemplate;
           }
           set {
              _messageTemplate = value;
           }
        }

        protected override void CreateChildControls() {

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

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

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

    }

}

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

Community Additions

ADD
Show:
© 2014 Microsoft