Este artigo foi traduzido por máquina. Para visualizar o arquivo em inglês, marque a caixa de seleção Inglês. Você também pode exibir o texto Em inglês em uma janela pop-up, movendo o ponteiro do mouse sobre o texto.
Tradução
Inglês

ITemplate Interface

Define o comportamento para preencher um modelo Controlarar de servidor ASP.NET com Controlarars filho. Os controles filho representam o Em Linha modelos definidos na página.

Namespace:  System.Web.UI
Assembly:  System.Web (em System.Web. dll)

[AspNetHostingPermissionAttribute(SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
[AspNetHostingPermissionAttribute(SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
public interface ITemplate

Essa interface é usada pelos controles de servidor Personalizars, mas nunca implementada por eles.O ASP.NET sempre implementa-lo.

TopicLocation
Como: Criar Templated controles de usuário ASP.NETdv_aspnetcon
Como: Criar Templated ASP.NET usuário ControlsBuilding ASP .NET Web Applications in Visual Studio
Como: Criar Modelos Dynamically in DataList Servidor Web Controlesdv_aspnetcon
Como: Criar modelos dinamicamente em controles DataList do servidor WebBuilding ASP .NET Web Applications in Visual Studio
Como: Criar Templated ASP.NET usuário ControlsBuilding ASP .NET Web Applications in Visual Studio
Como: Criar modelos dinamicamente em controles DataList do servidor WebBuilding ASP .NET Web Applications in Visual Studio

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

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

 TemplateControlSamples {

      TemplateItem : Control, INamingContainer {
         String     _message         = ;

         TemplateItem(String message) {
            _message = message;
        }

         String Message {

            {
               _message;
           }
            {
              _message = value;
           }
        }
    }

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

         ITemplate  _messageTemplate = ;
         String     _message         = ;

         String Message {

            {
               _message;
           }
            {
              _message = value;
           }
        }

        [
            PersistenceMode(PersistenceMode.InnerProperty),
            TemplateContainer((TemplateItem))
        ]
         ITemplate MessageTemplate {
            {
               _messageTemplate;
           }
            {
              _messageTemplate = value;
           }
        }

           CreateChildControls() {

           
           

            (MessageTemplate != ) {
              Controls.Clear();
              TemplateItem i =  TemplateItem(.Message);
              MessageTemplate.InstantiateIn(i);
              Controls.Add(i);
           }
            {
              .Controls.Add( LiteralControl(.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))
        }

    }

}


Contribuições da comunidade

ADICIONAR
Mostrar: