Overzicht van besturingselementen en aangepaste besturingselementen

Vertaalde artikelen Vertaalde artikelen
Artikel ID: 893667 - Bekijk de producten waarop dit artikel van toepassing is.
ASP.De kolom NET ondersteuning Voice

Overzicht van besturingselementen en aangepaste besturingselementen

Deze kolom aan uw behoeften aanpassen, willen we nodigen u uit om uw ideeën over onderwerpen die interessant zijn voor problemen die u wilt zien en behandeld in toekomstige Knowledge Base-artikelen en ondersteuning Voice kolommen. U kunt uw ideeën en feedback via indienen deVoor deze vraagformulier. Er is een koppeling naar het formulier onderaan deze kolom.
Alles uitklappen | Alles samenvouwen

Op deze pagina

Inleiding

Hallo! Dit Parag is en ik ben een ondersteuningstechnicus die werken met Microsoft ASP.NET-ondersteuning voor meer dan een jaar nu. Ik gewerkt voordat u het lidmaatschap van Microsoft op het Web gebaseerde projecten en toepassingen met Microsoft-technologieën. Terwijl de kwaliteit ondersteuning bieden aan klanten, hebben ik gevallen waar er enige verwarring rond aangepaste besturingselementen en ik wil alleen duren leggen sommige concepten om aangepaste besturingselementen gezien. Als slecht eruitziet, Geloof me, nadat u het vastlopen van het ophalen, worden in een betere positie ASP waarderen.NET.

Overzicht

In deze maand kolom wordt de volgende onderwerpen besproken:
  • Wat zijn besturingselementen?
  • Wat zijn aangepaste besturingselementen?
  • Wat zijn de belangrijkste verschillen tussen besturingselementen en aangepaste besturingselementen?
Ik moet ook enkele geavanceerde onderwerpen die betrekking hebben op aangepaste besturingselementen zoals statusbeheer en de weergave van aangepaste besturingselementen introduceren.

Wat zijn besturingselementen?

Besturingselementen zijn herbruikbare aangepaste besturingselementen en gebruik van dezelfde technieken door serverbesturingselementen voor HTML en webpagina. Partitie en hergebruik gemeenschappelijke gebruikersinterfaces via ASP een eenvoudige manier bieden.NET-webtoepassingen. Ze gebruiken hetzelfde webformulieren programmeermodel waarvoor een webformulieren pagina werkt. Bezoek de volgende websites van Microsoft Developer Network (MSDN) voor meer informatie over webformulieren programmeermodel:
Inleiding tot webformulieren 's
http://msdn2.Microsoft.com/en-us/library/65tcbxz3 (vs.71) .aspx

Web formulieren codemodel
http://msdn2.Microsoft.com/en-us/library/015103yb (vs.71) .aspx

Een besturingselement maken

De syntaxis die gebruik maken van een besturingselement is vergelijkbaar met de syntaxis met webformulieren-pagina (.aspx) te maken. Het enige verschil is dat een besturingselement bevat de<html>,<body>, en<form>Aangezien een pagina webformulieren de gebruiker controle host-elementen. Maken van een besturingselement als volgt:</form></body></html>
  1. Tekst of HTML-editor openen en maken van een server-side codeblok bloot alle eigenschappen, methoden en gebeurtenissen.
    <script language="C#" runat="server">
       public void button1_Click(object sender, EventArgs e)
       {
          label1.Text = "Hello World!!!";
       }
    </script>
    
  2. Maak een interface voor het besturingselement.
    <asp:Label id="label1" runat="server"/>
     <br><br>
    <asp:button id="button1" text="Hit" OnClick="button1_Click" runat="server" />
    

Het gebruik van een besturingselement in een Web pagina

  1. Maak een nieuwe pagina voor webformulieren (.aspx) in Microsoft Visual Studio.NET 2002, Microsoft Visual Studio.NET 2003, Microsoft Visual Studio 2005 of een teksteditor.
  2. Declareer de@ RegistrerenRichtlijn. Gebruik bijvoorbeeld de volgende code.
    <%@ Register TagPrefix="UC" TagName="TestControl" Src="test.ascx" %>
    OpmerkingStel het besturingselement en de pagina webformulieren op dezelfde locatie zijn.
  3. Gebruik de volgende code na gebruik van het besturingselement in de webformulieren pagina de@ RegistrerenRichtlijn.
    <html>
        <body>
              <form runat="server">
                   <UC:TestControl id="Test1" runat="server"/>
              </form>
        </body>  
    </html>
    

Een exemplaar van het gebruikersbesturingselement van een programmatisch de programmacode van een pagina webformulieren maken

Het vorige voorbeeld geïnstantieerd een besturingselement declaratief in webformulieren pagina met de@ RegistrerenRichtlijn. U kunt echter een besturingselement dynamisch instantiëren en toevoegen aan de pagina. Hier zijn de stappen om dat te doen:
  1. Maak een nieuwe pagina webformulieren in Visual Studio.
  2. Ga naar de code achter het bestand gegenereerd voor deze pagina webformulieren.
  3. In dePage_Loadgebeurtenis van dePaginaklasse, de volgende code schrijven.
    // 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);
    
    OpmerkingU kunt een besturingselement dynamisch toevoegen bij bepaalde gebeurtenissen van de levenscyclus van de pagina.

    Voor meer informatie de volgende websites:
    Programmatisch besturingselementen toevoegen aan een pagina met webformulieren
    http://msdn2.Microsoft.com/en-us/library/kyt0fzt1 (vs.71) .aspx

    Besturingselement uitvoering lifecycle
    http://msdn2.Microsoft.com/en-us/library/aa719775 (vs.71) .aspx

    Dynamische Web-controls en terugsturen weergavestatus door Scott Mitchell
    http://ASPNET.4guysfromrolla.com/articles/092904-1.aspx

Hoe een besturingselement wordt verwerkt

Wanneer een pagina met een besturingselement wordt aangevraagd, gebeurt het volgende:
  • De parser pagina parseert het bestand .ascx is opgegeven in deSrckenmerk de@ Registrerenrichtlijn en genereert een klasse die is afgeleid van deSystem.Web.UI.UserControlklasse.
  • De parser vervolgens dynamisch gecompileerd de klasse in assembly.
  • Als u Visual Studio in de ontwerpfase alleen Visual Studio maakt vervolgens een code achter het bestand voor het besturingselement en het bestand vooraf gecompileerd door de ontwerper zelf.
  • Ten slotte bevat de klasse voor het besturingselement, die wordt gegenereerd door het proces van dynamische code genereren en de samenstelling, de code voor de code achter het bestand (. ascx.cs) als de code in het bestand .ascx geschreven.

Wat zijn aangepaste besturingselementen?

Aangepaste besturingselementen zijn onderdelen van gecompileerde code uitvoeren op de server, het objectmodel blootstellen en renderen markeringstekst, zoals HTML of XML, als een normaal besturingselement formulier of gebruiker.

De basisklasse voor een aangepast besturingselement kiezen

Schrijven van een aangepast besturingselement u moet direct of indirect afgeleid van de nieuwe klasse deSystem.Web.UI.Controlklasse of deSystem.Web.UI.WebControls.WebControlklasse:
  • U moet afleiden uitSystem.Web.UI.ControlAls u het besturingselement nonvisual elementen weer. Bijvoorbeeld, <meta> en<head>zijn voorbeelden van nonvisual renderen.</head>
  • U moet afleiden uitSystem.Web.UI.WebControls.WebControlAls u het besturingselement weer te geven HTML een visuele interface op de clientcomputer genereert.
Als u wilt wijzigen van de functionaliteit van bestaande besturingselementen, zoals een knop of label, de nieuwe klasse met deze bestaande klassen rechtstreeks kunt afleiden en hun standaardgedrag kunt wijzigen.

In het kort deBesturingselementklasse biedt de basisfunctionaliteit waarmee u kunt plaatsen in de consolestructuur voor eenPaginaklasse. DeWebControlklasse de functionaliteit wordt toegevoegd aan de baseBesturingselementklasse voor het weergeven van visuele inhoud op de clientcomputer. U kunt bijvoorbeeld deWebControlklasse bepalen het uiterlijk en eigenschappen zoals lettertype, kleur en hoogte.

Het maken en gebruiken van een eenvoudig aangepast besturingselement die zich uitstrekt van System.Web.UI.Control met Visual Studio

  1. Start Visual Studio.
  2. Class library-project maken en een naam, bijvoorbeeld CustomServerControlsLib.
  3. Een bronbestand toevoegen aan het project, bijvoorbeeld SimpleServerControl.cs.
  4. De verwijzing van deSystem.Webde naamruimte in de verwijzingssectie.
  5. Controleer of de volgende naamruimten zijn opgenomen in het bestand SimpleServerControl.cs.
    System
    System.Collections
    System.ComponentModel
    System.Data
    System.Web
    System.Web.SessionState
    System.Web.UI
    System.Web.UI.WebControls
    
  6. Nemen deSimpleServerControlsklasse met deBesturingselementde basisklasse.
    public class SimpleServerControl : Control
  7. Overschrijven deRenderenmethode voor de uitvoer naar de uitvoerstroom schrijven.
    protected override void Render(HtmlTextWriter writer) 
    {
    	 writer.Write("Hello World from custom control");
    }
    
    OpmerkingDeHtmlTextWriterklasse heeft de functionaliteit van HTML schrijven naar een tekststream met. DeSchrijvenmethode van deHtmlTextWriterklasse uit de opgegeven tekst aan de antwoordstroom HTTP en is hetzelfde als deResponse.Writemethode.
  8. Compileer het project class library. De DLL-uitvoer wordt gegenereerd.
  9. Open een bestaande of nieuwe ASP maken.NET Web application-project.
  10. Waar het aangepaste besturingselement kan worden gebruikt webformulieren pagina toevoegen.
  11. Een verwijzing naar de klassenbibliotheek toevoegen in de verwijzingssectie van het ASP.NET-project.
  12. Aangepast besturingselement op de pagina webformulieren registreren.
    <%@ Register TagPrefix="CC " Namespace=" CustomServerControlsLib " Assembly="CustomServerControlsLib " %>
  13. Instantiëren of aangepast besturingselement op de pagina webformulieren gebruiken, voeg de volgende regel code in de<form>tags.</form>
    <form id="Form1" method="post" runat="server">
        <CC:SimpleServerControl id="ctlSimpleControl" runat="server">
        </CC:SimpleServerControl >
    </form>
    
    OpmerkingIn deze codeSimpleServerControlis de naam van de klasse control in de class library.
  14. De pagina webformulieren uitgevoerd en ziet u de uitvoer van het aangepaste besturingselement.
Als u Visual Studio niet gebruikt, moet u de volgende stappen uitvoeren:
  1. Elke teksteditor openen.
  2. Maak een bestand met de naam SimpleServerControl.cs en de code in stap 1 tot en met 14 schrijven.
  3. In de variabele pad toevoegen het volgende pad:
    c:\Windows (winnt)\Microsoft.Net\Framework\v1.1.4322
  4. Start een opdrachtprompt en Ga naar de locatie waar de SimpleServerControl.cs aanwezig is.
  5. Voer de volgende opdracht:
    /t:library csc/out: CustomServerControlsLib. SimpleServerControl.dll /r:System.dll /r:System.Web.dll SimpleServerControl.cs
    De volgende MSDN-website voor meer informatie over de C#-compiler (csc.exe):
    http://msdn2.Microsoft.com/en-us/library/1700bbwd (vs.71) .aspx
  6. Uitvoeren van het aangepaste besturingselement op de pagina webformulieren als volgt:
    1. Maak een map onder de map wwwroot.
    2. Start Microsoft Internet Information Services (IIS) Manager en de nieuwe map als de virtuele hoofdmap te markeren.
    3. Een Bin-map onder de nieuwe map maken.
    4. Het aangepaste besturingselement dll-bestand kopiëren naar de map Bin.
    5. Plaats de voorbeeldpagina webformulieren die u in de vorige stappen in de nieuwe map gemaakt.
    6. De voorbeeldpagina uitvoeren vanuit IIS-beheer.
Nu dat u een eenvoudig aangepast besturingselement hebt gemaakt, gaan we kijken hoe blootstellen eigenschappen en kenmerken ontwerpfase toepassen op het aangepaste besturingselement.

Hoe eigenschappen op het aangepaste besturingselement weer te geven

Ik bouwen op het vorige voorbeeld en een of meer eigenschappen die kunnen worden geconfigureerd tijdens het gebruik van het aangepaste besturingselement op de pagina webformulieren introduceren.

In het volgende voorbeeld ziet u hoe een eigenschap in het besturingselement verschijnt definiëren een bepaald aantal keren opgegeven in de eigenschap van het besturingselement:
  1. SimpleServerControl.cs in een teksteditor openen.
  2. Toevoegen van een eigenschap in deSimpleServerControlklasse.
    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. Compileer het aangepaste besturingselement.
  4. Gebruik van het aangepaste besturingselement op de pagina webformulieren toevoegen nieuwe eigenschap aan de declaratie van het besturingselement.
    <CC:SimpleServerControl id="ctlSimpleControl" NoOfTimes="5" runat="server"></CC:SimpleServerControl>
  5. De pagina waarop weergegeven het bericht 'Hello world' uit het aangepaste besturingselement zo vaak als eigenschap van het besturingselement.

Design-time kenmerken toepassen op het aangepaste besturingselement

Waarom ontwerpmodus kenmerken nodig zijn
Het aangepaste besturingselement in het vorige voorbeeld gemaakt werkt zoals verwacht. Echter, als u dat besturingselement in Visual Studio gebruiken wilt, kunt u deNoOfTimeseigenschap automatisch gemarkeerd in het venster Eigenschappen wanneer het aangepaste besturingselement wordt geselecteerd in de ontwerpfase.

Dit moet u Visual Studio, u doen kunt met een functie van Visual Studio kenmerken genoemd bieden informatie over metagegevens. Kenmerken kunnen een klasse, een methode, een eigenschap of een veld definiëren. Wanneer Visual Studio class van het aangepaste besturingselement is geladen, controleert kenmerken gedefinieerd op de klasse, methode, eigenschap of veldniveau en verandert het gedrag van het aangepaste besturingselement tijdens het ontwerpen.

Ga naar de volgende MSDN-website voor meer informatie over kenmerken:
http://msdn2.Microsoft.com/en-us/library/Aa288059 (VS.71) .aspx
We maken een monster dat veelgebruikte toepassingen kenmerken:
  1. SimpleServerControl.cs in een teksteditor openen.
  2. Sommige elementaire kenmerken op het klasseniveau van de bijvoorbeeld introducerenDefaultProperty,ToolboxData, enTagPrefixAttrbute. Wij zullen ons voorbeeld bouwen op deze drie kenmerken.
            [
    	// 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. Er is één meer code genoemdTagPrefixAttrbute. Dit is een kenmerk assembly niveau waarmee een voorvoegsel om een tag wanneer u het besturingselement vanuit de werkset naar de designer slepen. Anders genereert de ontwerper een voorvoegsel, zoals "cc1" standaard.TagPrefixAttrbuteniet direct toegepast op de klasse control. ToepassenTagPrefixAttrbute, AssemblyInfo.cs opent, bevatten de volgende regel code en het project opnieuw compileren.
    [assembly:TagPrefix("ServerControlsLib ", "MyControl")]
    OpmerkingAls u maken van de bron die via de opdrachtregel wilt, moet u het bestand AssemblyInfo.cs maken, plaats het bestand in de map alle bronbestanden bevat en voer de volgende opdracht het besturingselement maken
    > /t:library csc/out: ServerControlsLib.dll /r:System.dll/r: bestanden System.Web.dll *.cs

Wat zijn de belangrijkste verschillen tussen besturingselementen en aangepaste besturingselementen?

Nu dat u eenvoudige rekenfuncties van besturingselementen en aangepaste besturingselementen en hoe ze te maken, we een kort overzicht van de verschillen tussen de twee.
Deze tabel samenvouwenDeze tabel uitklappen
FactorenBesturingselement van gebruikerAangepast besturingselement
ImplementatieOntworpen voor één toepassing scenario 's

Samen met de broncode van de toepassing in het bronformulier (.ascx) geïmplementeerd

Als hetzelfde besturingselement worden gebruikt in meer dan één toepassing moet, introduceert het redundantie en onderhoudsproblemen
Zo ontworpen dat kan worden gebruikt door meer dan één toepassing

In de directory Bin van de toepassing of in de globale assembly-cache geïmplementeerd

Gedistribueerde eenvoudig en zonder problemen met redundantie en onderhoud
MakenWordt gemaakt op dezelfde manier formulieren voor webpagina's worden gemaakt; Artikelnaam rapid application development (RAD)Schrijven omvat veel code omdat er geen professionele ondersteuning
InhoudEen veel betere keuze wanneer u statische inhoud binnen een vaste indeling, bijvoorbeeld wanneer u kopteksten en voettekstenMeer geschikt voor wanneer een toepassing dynamische inhoud vereist weergegeven; opnieuw kan worden gebruikt binnen een toepassing, bijvoorbeeld voor een tabelbesturingselement met dynamische rijen gegevensgebonden
OntwerpSchrijven hoeft niet veel toepassingen ontwerpen omdat ze zijn geschreven in de ontwerpfase en voornamelijk statische gegevens bevattenSchrijven helemaal vereist een goed inzicht in de levenscyclus van het besturingselement en de volgorde waarin gebeurtenissen worden uitgevoerd, is meestal afgehandeld in besturingselementen

Geavanceerde onderwerpen

Daarna laten we eens enkele van de geavanceerde functies die u tijdens het ontwikkelen van aangepaste besturingselementen kan gebruiken.

Statusbeheer

Webtoepassingen zijn gebaseerd op HTTP stateless is. Een pagina en de onderliggende besturingselementen worden gemaakt op elke aanvraag en worden verwijderd na het verzoek. Klassieke ASP programmering staat behouden, u sessie- en objecten. Maar dat u wilt doen veel code. Voorkomen, ASP.NET biedt een mechanisme status voor het statusbeheer voor verschillende aanvragen genoemd. Ga naar de volgende MSDN-websites voor meer informatie over beheer- en staat staat:
Introduction to Web Forms state management
http://msdn2.Microsoft.com/en-us/library/75x4ha6s (vs.71) .aspx

ASP.NET view staat
http://msdn.Microsoft.com/msdnmag/Issues/03/02/cuttingedge/default.aspx

Pagina status waarden webformulieren opslaan
http://msdn2.Microsoft.com/en-us/library/4yfdwycw (vs.71) .aspx
Voorbeeld met de status in een aangepast besturingselement
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);
		}
	}
}
Voorbeeld met het vorige besturingselement op een pagina webformulieren
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 deze sectie ik kort beschreven welke methoden moeten worden overschreven wanneer u een aangepast besturingselement afleiden uit deBesturingselementklasse of deWebControlklasse.
Methoden van de klasse System.Web.UI.Control weergeven
Voor informatie over de weergave van deSystem.Web.UI.Controlklasse, Ga naar de volgende MSDN-websites:
Control.Rendermethode
http://msdn2.Microsoft.com/en-us/library/System.Web.UI.Control.Render (vs.71) .aspx

Control.RenderControlmethode
http://msdn2.Microsoft.com/en-us/library/System.Web.UI.Control.rendercontrol (vs.71) .aspx

Control.RenderChildrenmethode
http://msdn2.Microsoft.com/en-us/library/System.Web.UI.Control.RenderChildren (vs.71) .aspx
Hoe een besturingselement wordt weergegeven op de pagina
Elke pagina heeft een collectie van alle onderliggende besturingselementen voor die pagina besturingselementstructuur. Genereren van de consolestructuur een object van hetHtmlTextWriterklasse gemaakt met de HTML kunnen worden weergegeven op de clientcomputer. Object wordt doorgegeven aan deRenderControlmethode. Op zijn beurt deRenderControlmethode roept deRenderenmethode. Vervolgens deRenderenmethodeaanroepen deRenderChildrende methode op elk onderliggend besturingselement recursieve lus maken tot het einde van de collectie is bereikt. Dit proces wordt best door de volgende voorbeeldcode toegelicht.
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);
    }
} 
Methoden van de klasse System.Web.UI.WebControl weergeven
Voor informatie over de weergave van deSystem.Web.UI.WebControlklasse, Ga naar de volgende MSDN-websites:
WebControl.RenderBeginTagmethode
http://msdn2.Microsoft.com/en-us/library/System.Web.UI.WebControls.WebControl.renderbegintag (vs.71) .aspx

WebControl.RenderContentsmethode
http://msdn2.Microsoft.com/en-us/library/System.Web.UI.WebControls.WebControl.rendercontents (vs.71) .aspx

WebControl.RenderEndTagmethode
http://msdn2.Microsoft.com/en-us/library/System.Web.UI.WebControls.WebControl.renderendtag (vs.71) .aspx
Hoe de weergave van de klasse WebControl plaatsvindt
De volgende code in het volgende voorbeeld toont deRenderenmethode voor het aangepaste besturingselement.
protected override void Render(HtmlTextWriter writer)
{
    RenderBeginTag(writer);
    RenderContents(writer);
    RenderEndTag(writer);
}
U hoeft niet te overschrijven deRenderenmethode voor deWebControlklasse. Als u wilt renderen, inhoud binnen deWebControlklasse, moet u overschrijven deRenderContentsmethode. Als u wilt echter negeren deRenderenmethode, moet u overschrijven deRenderBeginTagmethode alsmede deRenderEndTagmethode in de specifieke volgorde die wordt weergegeven in het vorige voorbeeld.

Conclusie

Dat is alles nu op de gebruikersbesturingselementen en aangepaste besturingselementen in ASP.NET 1.0 en ASP.NET 1.1. Ik hoop dat deze kolom kunt u elementaire verschillen tussen hen en de verschillende benaderingen die u ondernemen kunt om ze te ontwikkelen.

Bedankt voor uw tijd. We verwachten meer geavanceerde onderwerpen voor aangepaste besturingselementen, zoals state management, stijlen besturingselement samengestelde besturingselementen en design-time ondersteuning voor aangepaste besturingselementen in de nabije toekomst te schrijven.

Ga naar de volgende MSDN-websites voor meer informatie over besturingselementen:
ASP.NETTO server control ontwikkeling basisbeginselen
http://msdn2.Microsoft.com/en-us/library/aa310918 (vs.71) .aspx

Een uitgebreid onderzoek van besturingselementen
http://msdn2.Microsoft.com/en-us/library/ms972975.aspx

Aangepaste ASP sjablonen maken.NETTO-serverbesturingselementen
http://msdn2.Microsoft.com/en-us/library/Aa478964.aspx

Gebeurtenissen in ASP.NETTO-serverbesturingselementen
http://msdn2.Microsoft.com/en-us/library/aa720049 (vs.71) .aspx

Samengesteld besturingselement versus besturingselement
http://msdn2.Microsoft.com/en-us/library/aa719735 (vs.71) .aspx

Ontwikkelen van ASP.NETTO-serverbesturingselementen
http://msdn2.Microsoft.com/en-us/library/aa719973 (vs.71) .aspx

Aangepaste besturingselementen ontwikkelen: de belangrijkste concepten
http://msdn2.Microsoft.com/en-us/library/aa720226 (vs.71) .aspx

Design-time ondersteuning toevoegen aan ASP.NETTO besturingselementen
http://msdn2.Microsoft.com/en-us/library/Aa478960.aspx
Zoals altijd, gerust ideeën over onderwerpen die u wilt verzenden in toekomstige kolommen behandeld of in de Knowledge Base met deVoor deze vraagformulier.

Eigenschappen

Artikel ID: 893667 - Laatste beoordeling: donderdag 17 maart 2011 - Wijziging: 2.0
De informatie in dit artikel is van toepassing op:
  • Microsoft ASP.NET 1.1
  • Microsoft ASP.NET 1.0
Trefwoorden: 
kbhowto kbasp kbmt KB893667 KbMtnl
Automatisch vertaald artikel
BELANGRIJK: Dit artikel is vertaald door de vertaalmachine software van Microsoft in plaats van door een professionele vertaler. Microsoft biedt u professioneel vertaalde artikelen en artikelen vertaald door de vertaalmachine, zodat u toegang heeft tot al onze knowledge base artikelen in uw eigen taal. Artikelen vertaald door de vertaalmachine zijn niet altijd perfect vertaald. Deze artikelen kunnen fouten bevatten in de vocabulaire, zinsopbouw en grammatica en kunnen lijken op hoe een anderstalige de taal spreekt en schrijft. Microsoft is niet verantwoordelijk voor onnauwkeurigheden, fouten en schade ontstaan door een incorrecte vertaling van de content of het gebruik ervan door onze klanten. Microsoft past continue de kwaliteit van de vertaalmachine software aan door deze te updaten.
De Engelstalige versie van dit artikel is de volgende:893667

Geef ons feedback

 

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