Cenni preliminari su controlli utente e controlli personalizzati

Traduzione articoli Traduzione articoli
Identificativo articolo: 893667 - Visualizza i prodotti a cui si riferisce l?articolo.
Articolo ASP.NET Support Voice

Cenni preliminari su controlli utente e controlli personalizzati

per personalizzare questo articolo in base alle proprie esigenze, si desidera invitati a inviare le proprie idee sugli argomenti di interesse è e problemi che si desidera vedere risolti in futuro articoli della Knowledge Base e di Support Voice. È possibile inviare idee e commenti e suggerimenti tramite il modulo Ask For It. C'è anche un collegamento al modulo nella parte inferiore della colonna.
Espandi tutto | Chiudi tutto

In questa pagina

Introduzione

Ciao! Si tratta di Parag e è un supporto tecnico che collabora con il gruppo di supporto Microsoft ASP.NET per più di un anno a questo punto. Prima di partecipare a Microsoft, È occupato di progetti basati sul Web e applicazioni desktop utilizzando le tecnologie Microsoft. Fornendo supporto di qualità ai clienti, ho visto casi in cui si è verificato confusione intorno ai controlli personalizzati e semplicemente si desidera richiedere tempo per spiegare alcuni concetti intorno ai controlli personalizzati. Come non valido come appare, ritiene, una volta che viene visualizzato il blocco di esso, sarà più in una posizione migliore per apprezzare ASP.NET.

Cenni preliminari

Nell'articolo di mese questo tratterò i seguenti argomenti:
  • Che cosa sono i controlli utente?
  • Che cosa sono i controlli personalizzati?
  • Quali sono le differenze base tra i controlli utente e controlli personalizzati?
Verranno inoltre introdurre pochi degli argomenti avanzati che riguardano i controlli personalizzati, ad esempio Gestione dello stato e il rendering di controlli personalizzati.

Che cosa sono i controlli utente?

Controlli utente sono controlli personalizzati riutilizzabili e utilizzano le stesse tecniche vengono utilizzate dai controlli server Web e HTML. Offrono un modo semplice per suddividere e riutilizzare interfacce utente comune tra le applicazioni Web ASP.NET. Utilizzare lo stesso modello di programmazione Web Form in cui funziona una pagina Web Form. Per ulteriori informazioni sul modello di programmazione di Web Form, visitare i seguenti siti Web MSDN (informazioni in lingua inglese):
Introduzione alle pagine Web Form
http://msdn2.microsoft.com/en-us/library/65tcbxz3(vs.71).aspx

Modello di codice Web Form
http://msdn2.microsoft.com/en-us/library/015103yb(vs.71).aspx

Come creare un controllo utente

La sintassi che consente di creare un controllo utente è simile alla sintassi che consente di creare una pagina Web Form (aspx). L'unica differenza è che un controllo utente non includa il <html> <body>, e <form> elementi poiché una pagina Web Form contiene il controllo utente. Per creare un controllo utente, attenersi alla seguente procedura:
  1. Aprire un testo o l'editor HTML e creare un blocco di codice sul lato server esposizione di proprietà, metodi ed eventi.
    <script language="C#" runat="server">
       public void button1_Click(object sender, EventArgs e)
       {
          label1.Text = "Hello World!!!";
       }
    </script>
    
  2. Creare un'interfaccia utente per il controllo utente.
    <asp:Label id="label1" runat="server"/>
     <br><br>
    <asp:button id="button1" text="Hit" OnClick="button1_Click" runat="server" />
    

L'utilizzo di un controllo utente in una pagina Web Form

  1. Creare una nuova pagina Web Form (aspx) in Microsoft Visual Studio .NET 2002, Microsoft Visual Studio .NET 2003, Microsoft Visual Studio 2005 o qualsiasi editor di testo.
  2. Dichiarare la direttiva @ Register . Ad esempio, è possibile utilizzare il codice riportato di seguito.
    <%@ Register TagPrefix="UC" TagName="TestControl" Src="test.ascx" %>
    considera Nota che il controllo utente e la pagina Web Form sono nella stessa posizione.
  3. Per utilizzare il controllo utente nella pagina Web Form, è necessario utilizzare il codice riportato di seguito dopo la direttiva @ Register .
    <html>
        <body>
              <form runat="server">
                   <UC:TestControl id="Test1" runat="server"/>
              </form>
        </body>  
    </html>
    

Come creare a livello di programmazione di un'istanza di un controllo utente in file di una pagina Web form nascosto del codice

Nell'esempio precedente viene creata un'istanza un controllo utente in modo dichiarativo in una pagina Web Form utilizzando la direttiva @ Register . Tuttavia, è possibile creare in modo dinamico un'istanza di un controllo utente e aggiungere il, alla pagina. Di seguito sono i passaggi per eseguire l'operazione che:
  1. Creare una nuova pagina Web Form in Visual Studio.
  2. Passare a code-behind file generato per questa pagina Web Form.
  3. Nell'evento Page_Load della classe Page , scrittura la seguente code.
    // Load the control by calling LoadControl on the page class.
    Control c1 = LoadControl("test.ascx");
                
    // Add the loaded control in the page controls collection.	
    Page.Controls.Add(c1);
    
    Nota È possibile aggiungere dinamicamente un controllo utente in determinati eventi del ciclo di vita della pagina.

    Per ulteriori informazioni, visitare i seguenti siti Web:
    L'aggiunta di controlli a una pagina Web Form a livello di programmazione
    http://msdn2.microsoft.com/en-us/library/kyt0fzt1(vs.71).aspx

    Durata esecuzione controllo
    http://msdn2.microsoft.com/en-us/library/aa719775(vs.71).aspx

    I controlli Web dinamici, i postback e lo stato di visualizzazione da Scott Mitchell
    http://aspnet.4guysfromrolla.com/articles/092904-1.aspx

Come viene elaborato un controllo utente

Quando viene richiesta una pagina con un controllo utente, si verifica quanto segue:
  • Il parser della pagina analizza il file ascx specificato nell'attributo Src nella direttiva @ Register e genera una classe che deriva dalla classe System.Web.UI.UserControl .
  • Il parser quindi dinamicamente compila la classe in un assembly.
  • Se si utilizza Visual Studio, quindi solo in fase di progettazione, verrà creato un file per il controllo utente di code-behind e il file è precompilato dalla finestra di progettazione stessa.
  • Infine, la classe per il controllo utente, viene generato tramite il processo di generazione dinamica di codice e di compilazione, include il codice per il file code-behind (. ascx.cs), nonché il codice scritto all'interno di un file ascx.

Che cosa sono i controlli personalizzati?

Controlli personalizzati sono componenti di codice compilato che consentono di eseguono sul server, espongono il modello di oggetto e il rendering del testo tag, ad esempio HTML o XML, come un normale controllo Web Form o utente.

Come scegliere la classe base per il controllo personalizzato

Per scrivere un controllo personalizzato, è consigliabile direttamente o indirettamente derivare la nuova classe dalla classe System.Web.UI.Control o dalla classe System.Web.UI.WebControls.WebControl :
  • È necessario derivare da System.Web.UI.Control se si desidera il controllo per il rendering di elementi non visivi. Ad esempio, <meta> e <head> sono esempi di rendering non visivi.
  • Se si desidera il controllo per eseguire il rendering HTML che genera un'interfaccia visiva sul computer client, è necessario derivare da System.Web.UI.WebControls.WebControl .
Se si desidera modificare la funzionalità di controlli esistenti, ad esempio un pulsante o un'etichetta, è possibile derivare direttamente la nuova classe con queste classi esistenti e possibile modificare il comportamento predefinito.

In breve, la classe Control fornisce la funzionalità di base per il quale è possibile collocarla nella struttura di controllo per una classe di pagina . La classe di WebControl aggiunge la funzionalità della classe di controllo di base per la visualizzazione contenuto visivo sul computer client. Ad esempio, è possibile utilizzare la classe WebControl per controllare l'aspetto e gli stili tramite la proprietà come tipo di carattere, colore e altezza.

Come creare e utilizzare un semplice controllo personalizzato che si estende da System.Web.UI.Control utilizzando Visual Studio

  1. Avviare Visual Studio.
  2. Creare un progetto libreria di classi e assegnargli un nome, ad esempio, CustomServerControlsLib.
  3. Aggiungere un file di origine al progetto, ad esempio, SimpleServerControl.cs.
  4. Includere il riferimento dello spazio dei nomi System.Web nella sezione riferimenti.
  5. Controllare se gli spazi dei nomi riportato di seguito sono incluse nel file del SimpleServerControl.cs.
    System
    System.Collections
    System.ComponentModel
    System.Data
    System.Web
    System.Web.SessionState
    System.Web.UI
    System.Web.UI.WebControls
    
  6. Ereditare la classe SimpleServerControls con la classe base di controllo .
    public class SimpleServerControl : Control
  7. Eseguire l'override del metodo di rendering per scrivere l'output nel flusso di output.
    protected override void Render(HtmlTextWriter writer) 
    {
    	 writer.Write("Hello World from custom control");
    }
    
    Nota La classe HtmlTextWriter presenta la funzionalità di scrittura di HTML in un flusso di testo. Il metodo Write della classe HtmlTextWriter restituisce il testo specificato nel flusso di risposta HTTP, come il metodo Response.Write .
  8. Compilare il progetto libreria di classe. Verrà generato l'output DLL.
  9. Aprire la esistente o creare un nuovo progetto applicazione Web ASP.NET.
  10. Aggiungere una pagina Web Form in cui il controllo personalizzato è possibile utilizzare.
  11. Aggiungere un riferimento alla libreria di classi nella sezione riferimenti del progetto ASP.NET.
  12. Registrare il controllo personalizzato nella pagina Web Form.
    <%@ Register TagPrefix="CC " Namespace=" CustomServerControlsLib " Assembly="CustomServerControlsLib " %>
  13. Per creare un'istanza o utilizzare il controllo personalizzato nella pagina Web Form, aggiungere la seguente riga di codice nei tag <form>.
    <form id="Form1" method="post" runat="server">
        <CC:SimpleServerControl id="ctlSimpleControl" runat="server">
        </CC:SimpleServerControl >
    </form>
    
    Nota In questo codice, SimpleServerControl è il nome di classe di controllo all'interno della libreria di classi.
  14. Eseguire la pagina Web Form e verrà visualizzato l'output del controllo personalizzato.
Se non si utilizza Visual Studio, è necessario effettuare le seguenti operazioni:
  1. Aprire un editor di testo.
  2. Creare un file denominato SimpleServerControl.cs e scrivere il codice come specificato nei passaggi da 1 a 14.
  3. Nella variabile PATH, è necessario aggiungere il seguente percorso:
    c:\Windows (winnt)\Microsoft.Net\Framework\v1.1.4322
  4. Avviare un prompt dei comandi e passare al percorso in cui è presente SimpleServerControl.cs.
  5. Eseguire il comando riportato di seguito:
    csc /t:library/out: CustomServerControlsLib. SimpleServerControl.dll /r:System.dll /r:System.Web.dll SimpleServerControl.cs
    Per ulteriori informazioni sul compilatore C# (csc.exe), visitare il seguente sito Web MSDN:
    http://msdn2.microsoft.com/en-us/library/1700bbwd(vs.71).aspx
  6. Per eseguire il controllo personalizzato nella pagina Web Form, effettuare le seguenti operazioni:
    1. Creare una directory nella cartella wwwroot.
    2. Avviare Gestione Internet Information Services (IIS) e contrassegnare la nuova directory come directory principale virtuale.
    3. Creare una cartella bin nella directory nuova.
    4. Copiare la DLL del controllo personalizzato nella cartella bin.
    5. Inserire la pagina Web Form di esempio creato nella procedura precedente all'interno della nuova directory.
    6. Eseguire la pagina di esempio da Gestione IIS.
Ora che aver creato un semplice controllo personalizzato, esaminiamo come esporre le proprietà e applicare gli attributi in fase di progettazione su tale controllo personalizzato.

Come esporre proprietà del controllo personalizzato

Compilazione sull'esempio precedente e introdurre una o più proprietà che possono essere configurate durante l'utilizzo del controllo personalizzato nella pagina Web Form.

Nell'esempio seguente viene illustrato come definire una proprietà che verrà visualizzato un messaggio dal controllo di un determinato numero di volte specificato nella proprietà del controllo:
  1. Aprire SimpleServerControl.cs in un editor di testo.
  2. Aggiungere una proprietà nella classe SimpleServerControl . classe pubblica
    public class SimpleServerControl : Control
    {
       private int noOfTimes;
       public int NoOfTimes
       {
           get { return this.noOfTimes; }
           set { this.noOfTimes = value; }
       } 
       protected override void Render (HtmlTextWriter writer)
       {
         for (int i=0; i< NoOfTimes; i++)
         {
           write.Write("Hello World.."+"<BR>");
         } 
       }
    }
    
  3. Compilare il controllo personalizzato.
  4. Per utilizzare il controllo personalizzato nella pagina Web Form, aggiungere la nuova proprietà la dichiarazione del controllo.
    <CC:SimpleServerControl id="ctlSimpleControl" NoOfTimes="5" runat="server"></CC:SimpleServerControl>
  5. Esecuzione della pagina, verrà visualizzato il messaggio "Hello world" dal controllo personalizzato più volte come specificato nella proprietà del controllo.

Come applicare gli attributi in fase di progettazione al controllo personalizzato

Perché sono necessari gli attributi in fase di progettazione
Il controllo personalizzato creato nell'esempio precedente funziona come previsto. Tuttavia, se si desidera utilizzare tale controllo in Visual Studio, sarà necessario la proprietà NoOfTimes per essere evidenziato automaticamente nella finestra Proprietà quando viene selezionato il controllo personalizzato in fase di progettazione.

A tale scopo, è necessario fornite metadati a Visual Studio, che è possibile eseguire utilizzando una funzionalità in Visual Studio dette attributi. Gli attributi possono definire una classe, un metodo, una proprietà o un campo. Quando Visual Studio viene caricata la classe del controllo personalizzato, viene controllata per gli attributi definiti in classe, metodo, proprietà o livello di campo e modifica di conseguenza il comportamento del controllo personalizzato in fase di progettazione.

Per ulteriori informazioni sugli attributi, visitare il sito di MSDN:
http://msdn2.microsoft.com/en-us/library/Aa288059(VS.71).aspx
Generazione di un esempio che utilizza in genere utilizzato si attributi:
  1. Aprire SimpleServerControl.cs in un editor di testo.
  2. Introdurre alcuni attributi a livello di classe base, ad esempio, DefaultProperty , ToolboxData e TagPrefixAttrbute . Si verrà creato il nostro esempio su questi tre attributi.
            [
    	// Specify the default property for the control.		
    	DefaultProperty("DefaultProperty"),
    	
    	// Specify the tag that is written to the aspx page when the
            // control is dragged from the Toolbox to the Design view. 
    	// However this tag is optional since the designer automatically 
    	// generates the default tag if it is not specified.		
    	ToolboxData("<{0}:ControlWithAttributes runat=\"server\">" +
    		"</{0}:ControlWithAttributes>")
    	]
    	public class ControlWithAttributes : Control
    	{
    		private string _defaultProperty;
    		public string DefaultProperty
    		{
    			get { return "This is a default property value"; }
    			set { this._defaultProperty = value; }
    		}
    
    		protected override void Render(HtmlTextWriter writer)
    		{
    			writer.Write("Default Property --> <B>" + 
    			DefaultProperty + "</B>");
    		}
             }
    
  3. È presente un tag di ulteriori denominato TagPrefixAttrbute . È attributo a livello di assembly che fornisce un prefisso a un tag quando si trascina il controllo dalla casella degli strumenti alla finestra di progettazione. In caso contrario, la finestra di progettazione genera un prefisso, ad esempio "cc1" per impostazione predefinita. TagPrefixAttrbute non viene applicato direttamente alla classe del controllo. Per applicare TagPrefixAttrbute , aprire AssemblyInfo.cs, includere la seguente riga di codice e quindi rigenerare il progetto.
    [assembly:TagPrefix("ServerControlsLib ", "MyControl")]
    Nota se si desidera creare l'origine utilizzando la riga di comando, è necessario creare il file AssemblyInfo.cs, di inserire il file nella directory che contiene tutti i file di origine e di eseguire il seguente comando per generare il controllo:
    > csc /t:library/out: ServerControlsLib.dll /r:System.dll /r: *.cs System.Web.dll

Quali sono le differenze base tra i controlli utente e controlli personalizzati?

Ora che si dispone di una idea di base sui controlli utente e controlli personalizzati e come crearli, è opportuno esaminare rapido le differenze tra i due.
Riduci questa tabellaEspandi questa tabella
fattori controllo utente controllo personalizzato
DistribuzioneProgettati per scenari dell'applicazione singola

Distribuito nel modulo di origine (ascx) insieme con il codice sorgente dell'applicazione

Se lo stesso controllo deve essere utilizzato in più applicazioni, introduce la ridondanza e problemi di manutenzione
Progettato in modo che può essere utilizzato da più applicazioni

Distribuito nella directory bin dell'applicazione o nella global assembly cache

Distribuito facilmente e senza problemi associati alla ridondanza e la manutenzione
CreazioneCreazione è simile alla modalità di pagine Web Form creata, adatto per lo sviluppo rapido di applicazioni (RAD)Scrittura comporta grandi quantità di codice perché non è Nessun supporto finestra di progettazione
ContenutoUna quantità scelta migliore quando è necessario che contenuto statico all'interno di un layout fisso, ad esempio, quando è impostare intestazioni e piè di paginaPiù adatto quando un'applicazione richiede dinamico del contenuto da visualizzare; possono essere riutilizzati in un'applicazione, ad esempio, per il controllo della tabella con righe dinamiche associato ai dati
ProgettazioneScrittura non richiede molto progettazione dell'applicazione poiché vengono creati in fase di progettazione e spesso contengono dati staticiLa scrittura da zero richiede una conoscenza buona di ciclo di vita del controllo e l'ordine in cui gli eventi di esecuzione, che è in genere eseguita cura di nei controlli utente

Argomenti avanzati

Successivamente, diamo un'occhiata in alcune delle funzionalità avanzate che è possibile utilizzare durante lo sviluppo di controlli personalizzati.

Gestione dello stato

Le applicazioni Web vengono create su HTTP, ovvero senza informazioni sullo stato. Una pagina e relativi controlli figlio vengono creati a ogni richiesta e vengono eliminati di una volta tramite la richiesta. Per mantenere lo stato nella classica programmazione ASP, utilizzare gli oggetti di sessione e dell'applicazione. Ma a tal fine, è necessario eseguire grandi quantità di codice. Per evitare questo problema, ASP.NET fornisce un meccanismo noto come stato di visualizzazione per la gestione dello stato tra più richieste. Per ulteriori informazioni sulla gestione e visualizzazione stato, visitare i seguenti siti di MSDN:
Introduzione alla gestione dello stato di Web Form
http://msdn2.microsoft.com/en-us/library/75x4ha6s(vs.71).aspx

Lo stato di visualizzazione ASP.NET
http://msdn.microsoft.com/msdnmag/issues/03/02/cuttingedge/default.aspx

I valori utilizzando lo stato di visualizzazione di pagina di salvataggio di Web Form
http://msdn2.microsoft.com/en-us/library/4yfdwycw(vs.71).aspx
Esempio di utilizzo dello stato di visualizzazione in un controllo personalizzato
ViewStateExample.cs
using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;
using System.Text;

namespace ServerControlLib
{
	/// <summary>
	/// When a page framework reloads this control after postback, it   
        /// will restore the values which are in view state.
	/// This control can easily perform state management without 
        /// implementing our own logic for maintaining the state.
	/// </summary>
	public class ViewStateExample : WebControl
	{
		// Text to be displayed in Text box control.
		private string _text;
		
		/*
		 * This property needs to be populated before every 
                 * postback in order to 
		 * retain its value.
		*/ 
		public string Text
		{
			get { return (_text == null) ? "_text property is empty"  : _text; }
			set { _text = value; }
		}

		/*
		 * This property needs to be filled once and should be 
                 * available on the successive postbacks.
		*/ 
		public string TextInViewState
		{
			get
			{
				object o = ViewState["TextInViewState"];
				return (o == null) ? "View state is empty" : (string)o;
			}
			set { ViewState["TextInViewState"] = value; } 
		}

		/*
		 * Over-ridden method on WebControl base class which                   
                 * displays both of the property values 
		 * i.e. one stored in view state and other which is not 
                 * saved in view state.
		*/
		protected override void RenderContents(HtmlTextWriter writer)
		{
			writer.Write("Text Without View State = ");
			writer.Write(Text);
			writer.Write("<hr><br>");
			writer.Write("Text In View State = ");
			writer.Write(TextInViewState);
		}
	}
}
Esempio di utilizzo del controllo precedente in una pagina Web Form
ViewStateExampleDemo.aspx
<%@ Page Language="C#" %>
<%@ Register TagPrefix="CC" Namespace="ServerControlLib" Assembly = "ServerControlLib" %>

<html>
  <head>
    <script runat="server">
      void button1_Click(object sender, EventArgs e)
      {
          Control1.Text = textbox1.Text;
          Control1.TextInViewState = textbox2.Text;
      }
    </script>
  </head>
  <body>
    <form runat="server" ID="Form1">
      <br>
      Property Value Without View State: <asp:TextBox id="textbox1" 
        runat="server" />
      <br>
      Property Value with View State: <asp:TextBox id="textbox2" 
        runat="server" />

      <asp:Button text="Cause Postback" onClick="button1_Click" 
        id="button1" Runat="server" />

      Output from the ViewStateExample Control :
      <CC:ViewStateExample id="Control1" runat="server"/>
    </form>
  </body>
</html>

Rendering

In questa sezione verrà descritto brevemente i metodi che è necessario eseguire l'override quando si deriva un controllo personalizzato dalla classe Control o la classe WebControl .
Metodi di rendering della classe System.Web.UI.Control
Per informazioni sui metodi di rendering della classe System.Web.UI.Control , visitare i seguenti siti Web MSDN:
metodo Control.Render
http://msdn2.microsoft.com/en-us/library/system.web.ui.control.render(vs.71).aspx

metodo Control.RenderControl
http://msdn2.microsoft.com/en-us/library/system.web.ui.control.rendercontrol(vs.71).aspx

metodo Control.RenderChildren
http://msdn2.microsoft.com/en-us/library/system.web.ui.control.renderchildren(vs.71).aspx
Rendering di un controllo nella pagina
Ogni pagina dispone di una struttura di controllo che rappresenta un insieme di tutti i controlli figlio per la pagina. Per eseguire il rendering la struttura di controllo, viene creato un oggetto della classe HtmlTextWriter che contiene il codice HTML da sottoporre a rendering sul computer client. Tale oggetto viene passato al metodo RenderControl . Il metodo di RenderControl richiama a sua volta, il metodo Render . Quindi, il metodo Render chiama il metodo RenderChildren su ciascun controllo figlio, che effettua un ciclo ricorsivo fino a quando non viene raggiunta la fine dell'insieme. Questo processo migliore è illustrato nel codice di esempio riportato di seguito.
public void RenderControl(HtmlTextWriter writer) 
{
    // Render method on that control will only be called if its visible property is true.
    if (Visible)
    {
        Render(writer);
    }
}

protected virtual void Render(HtmlTextWriter writer) 
{
    RenderChildren(writer);
}
protected virtual void RenderChildren(HtmlTextWriter writer) 
{
    foreach (Control c in Controls) 
    {
        c.RenderControl(writer);
    }
} 
Metodi di rendering della classe System.Web.UI.WebControl
Per informazioni sui metodi di rendering della classe System.Web.UI.WebControl , visitare i seguenti siti Web MSDN:
metodo WebControl.RenderBeginTag
http://msdn2.microsoft.com/en-us/library/system.web.ui.webcontrols.webcontrol.renderbegintag(vs.71).aspx

metodo WebControl.RenderContents
http://msdn2.microsoft.com/en-us/library/system.web.ui.webcontrols.webcontrol.rendercontents(vs.71).aspx

metodo WebControl.RenderEndTag
http://msdn2.microsoft.com/en-us/library/system.web.ui.webcontrols.webcontrol.renderendtag(vs.71).aspx
Come viene eseguita il rendering della classe WebControl
Nell'esempio di codice riportato di seguito viene illustrato il metodo Render per il controllo personalizzato.
protected override void Render(HtmlTextWriter writer)
{
    RenderBeginTag(writer);
    RenderContents(writer);
    RenderEndTag(writer);
}
Non è necessario eseguire l'override del metodo Render per la classe WebControl . Se si desidera eseguire il rendering del contenuto all'interno della classe WebControl , è necessario eseguire l'override del metodo RenderContents . Tuttavia, se si desidera comunque eseguire l'override del metodo Render , è necessario eseguire l'override metodo RenderBeginTag , nonché il metodo RenderEndTag nell'ordine specifico visualizzato in esempio di codice precedente.

Conclusione

Questo è tutto per ora in controlli utente e controlli personalizzati in ASP.NET 1.0 e 1.1 di ASP.NET. Spero che questa colonna consente di comprendere le differenze di base tra loro e per i vari approcci che consentono di sviluppare tali.

Grazie per avere il tempo. Si prevede di scrivere più sugli argomenti avanzati per i controlli personalizzati, ad esempio la gestione dello stato, gli stili del controllo, i controlli compositi e supporto per i controlli personalizzati, in fase di progettazione nel prossimo futuro.

Per ulteriori informazioni sui controlli, visitare i seguenti siti Web MSDN:
Nozioni fondamentali sviluppo sui controlli server ASP.NET
http://msdn2.microsoft.com/en-us/library/aa310918(vs.71).aspx

Un'analisi completa dei controlli utente
http://msdn2.microsoft.com/en-us/library/ms972975.aspx

Controlli server ASP.NET generazione basato su modelli personalizzati
http://msdn2.microsoft.com/en-us/library/Aa478964.aspx

Eventi di controlli server ASP.NET
http://msdn2.microsoft.com/en-us/library/aa720049(vs.71).aspx

Controllo composito e controllo utente
http://msdn2.microsoft.com/en-us/library/aa719735(vs.71).aspx

Lo sviluppo di controlli server ASP.NET
http://msdn2.microsoft.com/en-us/library/aa719973(vs.71).aspx

Lo sviluppo di controlli personalizzati: concetti di chiave
http://msdn2.microsoft.com/en-us/library/aa720226(vs.71).aspx

Aggiunta del supporto in fase di progettazione controlli
http://msdn2.microsoft.com/en-us/library/Aa478960.aspx
Come sempre, liberamente inviare idee, gli argomenti desiderati in futuro indirizzati colonne o della Knowledge Base utilizzando il modulo Ask For It.

Proprietà

Identificativo articolo: 893667 - Ultima modifica: mercoledì 14 novembre 2007 - Revisione: 1.8
Le informazioni in questo articolo si applicano a:
  • Microsoft ASP.NET 1.1
  • Microsoft ASP.NET 1.0
Chiavi: 
kbmt kbhowto kbasp KB893667 KbMtit
Traduzione automatica articoli
Il presente articolo è stato tradotto tramite il software di traduzione automatica di Microsoft e non da una persona. Microsoft offre sia articoli tradotti da persone fisiche sia articoli tradotti automaticamente da un software, in modo da rendere disponibili tutti gli articoli presenti nella nostra Knowledge Base nella lingua madre dell?utente. Tuttavia, un articolo tradotto in modo automatico non è sempre perfetto. Potrebbe contenere errori di sintassi, di grammatica o di utilizzo dei vocaboli, più o meno allo stesso modo di come una persona straniera potrebbe commettere degli errori parlando una lingua che non è la sua. Microsoft non è responsabile di alcuna imprecisione, errore o danno cagionato da qualsiasi traduzione non corretta dei contenuti o dell?utilizzo degli stessi fatto dai propri clienti. Microsoft, inoltre, aggiorna frequentemente il software di traduzione automatica.
Clicca qui per visualizzare la versione originale in inglese dell?articolo: 893667
LE INFORMAZIONI CONTENUTE NELLA MICROSOFT KNOWLEDGE BASE SONO FORNITE SENZA GARANZIA DI ALCUN TIPO, IMPLICITA OD ESPLICITA, COMPRESA QUELLA RIGUARDO ALLA COMMERCIALIZZAZIONE E/O COMPATIBILITA' IN IMPIEGHI PARTICOLARI. L'UTENTE SI ASSUME L'INTERA RESPONSABILITA' PER L'UTILIZZO DI QUESTE INFORMAZIONI. IN NESSUN CASO MICROSOFT CORPORATION E I SUOI FORNITORI SI RENDONO RESPONSABILI PER DANNI DIRETTI, INDIRETTI O ACCIDENTALI CHE POSSANO PROVOCARE PERDITA DI DENARO O DI DATI, ANCHE SE MICROSOFT O I SUOI FORNITORI FOSSERO STATI AVVISATI. IL DOCUMENTO PUO' ESSERE COPIATO E DISTRIBUITO ALLE SEGUENTI CONDIZIONI: 1) IL TESTO DEVE ESSERE COPIATO INTEGRALMENTE E TUTTE LE PAGINE DEVONO ESSERE INCLUSE. 2) I PROGRAMMI SE PRESENTI, DEVONO ESSERE COPIATI SENZA MODIFICHE, 3) IL DOCUMENTO DEVE ESSERE DISTRIBUITO INTERAMENTE IN OGNI SUA PARTE. 4) IL DOCUMENTO NON PUO' ESSERE DISTRIBUITO A SCOPO DI LUCRO.

Invia suggerimenti

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com