Přehled uživatelských ovládacích prvků a vlastní ovládací prvky

Překlady článku Překlady článku
ID článku: 893667 - Produkty, které se vztahují k tomuto článku.
PROSTŘEDÍ ASP.Sloupec NET podporu hlasu

Přehled uživatelských ovládacích prvků a vlastní ovládací prvky

Chcete-li upravit tento sloupec vašim potřebám, chceme vás pozvat předložit své nápady o tématech, které zajímají je a problémy, které chcete zobrazit určeno v budoucnu článků znalostní báze a podpora hlasové sloupce. Můžete odeslat své myšlenky a pomocí zpětné vazby Požádat o to formulář. Je také odkaz na formulář v dolní části tohoto sloupce.
Rozbalit všechny záložky | Minimalizovat všechny záložky

Na této stránce

Úvod

Hi! Toto je Parag a jsem pracovník podpory práce s Microsoft ASP.ČISTÉ podpory skupiny nyní více než jeden rok. Před k připojení k Microsoft I pracovali webové projekty a aplikace pomocí technologie společnosti Microsoft. Při poskytování podpory jakosti zákazníkům, I prohlédnutých případech, kdy došlo některé nejasnosti kolem vlastní ovládací prvky a který by stejně jako na trvat delší dobu vysvětlit některé pojmy kolem vlastní ovládací prvky. Jako chybný tak, jak vypadá, že me, jakmile se zablokuje ji, bude lepší pozici, aby vyhodnotila ASP.NET.

Přehled

Ve sloupci tento měsíc se podíváme na následující témata:
  • Co jsou ovládací prvky uživatele?
  • Co jsou vlastní ovládací prvky?
  • Jaké jsou základní rozdíly mezi ovládací prvky a vlastní ovládací prvky?
Představím také několik Pokročilá témata, které se týkají vlastní ovládací prvky, jako jsou například státní správy a vykreslování vlastní ovládací prvky.

Co jsou ovládací prvky uživatele?

Uživatelské ovládací prvky jsou prvky vlastní, opakovaně použitelných a používají stejné postupy, které jsou zaměstnáni v HTML a webové serverové ovládací prvky. Nabízejí snadno znovu použít běžné uživatelské rozhraní v prostředí ASP a oddíly.NET webových aplikací. Používají stejný model programování webových formulářů lze použít stránky webových formulářů. Další podrobnosti o model programování webových formulářů naleznete na následujících webech společnosti Microsoft Developer Network (MSDN):
Úvod ke stránkám webových formulářů
http://msdn2.microsoft.com/en-us/library/65tcbxz3 (vs.71) .aspx

Modelu kódu webových formulářů
http://msdn2.microsoft.com/en-us/library/015103yb (vs.71) .aspx

Jak vytvořit ovládací prvek uživatele

Uživatelský ovládací prvek vytvoříte pomocí syntaxe je podobná syntaxi můžete použít k vytvoření stránky webových formulářů (ASPX). Jediným rozdílem je, že neobsahuje prvek uživatele<html>,<body>, a<form>prvky, protože stránky webových formulářů hostitelem uživatelský ovládací prvek. Chcete-li vytvořit ovládací prvek uživatele, postupujte takto:</form></body></html>
  1. Otevřete text nebo HTML editor a vytvořit blok kódu na straně serveru, vystavuje vlastnosti, metody a události.
    <script language="C#" runat="server">
       public void button1_Click(object sender, EventArgs e)
       {
          label1.Text = "Hello World!!!";
       }
    </script>
    
  2. Vytvořte uživatelské rozhraní pro uživatelský ovládací prvek.
    <asp:Label id="label1" runat="server"/>
     <br><br>
    <asp:button id="button1" text="Hit" OnClick="button1_Click" runat="server" />
    

Použití nástroje Řízení uživatelských formulářů webové stránky

  1. Vytvoření nové stránky webových formulářů (ASPX) v aplikaci Microsoft Visual Studio.NET 2002, Microsoft Visual Studio.NET 2003, Microsoft Visual Studio 2005 nebo libovolného textového editoru.
  2. Prohlásit, @ Register směrnice. Použijte například následující kód.
    <%@ Register TagPrefix="UC" TagName="TestControl" Src="test.ascx" %>
    Poznámka: Předpokládají, že uživatelský ovládací prvek a stránky webových formulářů jsou na stejném místě.
  3. Chcete-li použít uživatelský ovládací prvek na stránce webových formulářů, použijte následující kód po @ Register směrnice.
    <html>
        <body>
              <form runat="server">
                   <UC:TestControl id="Test1" runat="server"/>
              </form>
        </body>  
    </html>
    

Jak vytvořit instanci ovládacího prvku uživateli programově v kódu za soubor stránky webových formulářů

V předchozím příkladu je vytvořena instance řízení uživatelských deklarativně do formulářů webové stránky pomocí @ Register směrnice. Můžete však vytvořit instanci ovládacího prvku uživateli dynamicky a přidat na stránku. Zde jsou kroky pro to, že:
  1. Vytvoření nové stránky webových formulářů v aplikaci Visual Studio.
  2. Vyhledejte kód soubor byl vytvořen pro tuto stránku webových formulářů.
  3. V Page_Load události Stránka třídy, následující kód.
    // 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);
    
    Poznámka: Ovládací prvek uživatele můžete přidat dynamicky při určitých událostech stránky životního cyklu.

    Další informace naleznete na následujících webech:
    Přidání ovládacích prvků formulářů webové stránky pomocí programu
    http://msdn2.microsoft.com/en-us/library/kyt0fzt1 (vs.71) .aspx

    Řízení provádění cyklu
    http://msdn2.microsoft.com/en-us/library/aa719775 (vs.71) .aspx

    Dynamické webové ovládací prvky, postbacks a stavu zobrazení o Scott Meisnerová
    http://ASPNET.4guysfromrolla.com/articles/092904-1.aspx

Zpracování uživatele ovládacího prvku

Když je požadované stránky s uživateli řízení, nastane následující:
  • Analyzátor stránky analyzuje ASCX soubor zadaný v Src atribut v @ Register směrnice a generuje třídy, který je odvozen od System.web.UI.UserControl Třída.
  • Analyzátor pak dynamicky zkompiluje třídy do sestavení.
  • Používáte-li aplikaci Visual Studio, v době návrhu aplikace Visual Studio vytvoří kód za uživatelský ovládací prvek soubor a soubor je předkompilována Návrhář sám.
  • Nakonec třídy uživatele ovládacího prvku, generovaného prostřednictvím procesu generování kódu pro dynamické a kompilace obsahuje kód pro kód souboru (. ascx.cs) jakož i kód zapsán do souboru ASCX.

Co jsou vlastní ovládací prvky?

Vlastní ovládací prvky jsou součástí zkompilovaný kód spustit na serveru, vystavit objektový model a vykreslit text poznámky, například HTML nebo XML, které stejně jako normální ovládacího prvku webového formuláře nebo uživatele.

Jak zvolit základní třída pro vaše vlastní ovládací prvek

Chcete-li vlastní ovládací prvek, který by přímo nebo nepřímo odvodit nové třídy z System.web.UI.Control třídy nebo z System.web.UI.WebControls.WebControl Třída:
  • By měla být odvozena od System.web.UI.Control Pokud chcete vykreslit bez viditelného rozhraní prvků. Například <meta> a<head>Příklady bez viditelného rozhraní vykreslování.</head>
  • By měla být odvozena od System.web.UI.WebControls.WebControl Pokud chcete vykreslit HTML, který generuje grafické rozhraní v klientském počítači.
Chcete-li změnit funkce existující ovládací prvky, jako je tlačítko nebo popisek, můžete přímo odvodit nové třídy s těchto existujících tříd a jejich výchozí chování můžete změnit.

Stručně řečeno Ovládací prvek Třída poskytuje základní funkce, kterým můžete umístit ji do stromu ovládacích prvků pro Stránka Třída. Na WebControl Třída přidá do základní funkce Ovládací prvek Třída pro zobrazování vizuálního obsahu v klientském počítači. Například můžete použít WebControl třídy, které řídí vzhled a styly prostřednictvím vlastnosti jako písmo, barvu a výšku.

Jak vytvořit a používat jednoduché vlastní ovládací prvek, který sahá od System.Web.UI.Control používání aplikace Visual Studio

  1. Spusťte aplikaci Visual Studio.
  2. Vytvoření projektu knihovny třídy a zadejte jeho název, například CustomServerControlsLib.
  3. Přidáte zdrojový soubor projektu, například SimpleServerControl.cs.
  4. Zahrnout odkaz System.web obor názvů v části odkazy.
  5. Zkontrolujte, zda následující obory názvů jsou zahrnuty v souboru SimpleServerControl.cs.
    System
    System.Collections
    System.ComponentModel
    System.Data
    System.Web
    System.Web.SessionState
    System.Web.UI
    System.Web.UI.WebControls
    
  6. Dědí SimpleServerControls Třída s Ovládací prvek Základní třída.
    public class SimpleServerControl : Control
  7. Přepsat Vykreslení způsob zápisu výstupu do výstupního datového proudu.
    protected override void Render(HtmlTextWriter writer) 
    {
    	 writer.Write("Hello World from custom control");
    }
    
    Poznámka: Na HtmlTextWriter Třída má funkce zápisu do proudu text HTML. Na Zápis Metoda HtmlTextWriter Třída výstup zadaný text na datový proud odpovědí HTTP a je stejná jako Response.Write Metoda.
  8. Kompilace projektu knihovny tříd. Vygeneruje výstup knihovny DLL.
  9. Otevřete existující nebo vytvořit nové prostředí ASP.NET webové aplikace project.
  10. Přidáte stránku webových formulářů, kde lze použít vlastní ovládací prvek.
  11. Přidáte odkaz na knihovnu tříd v ASP v části odkazy.NET projekt.
  12. Registrovat vlastní ovládací prvek na stránce webové formuláře.
    <%@ Register TagPrefix="CC " Namespace=" CustomServerControlsLib " Assembly="CustomServerControlsLib " %>
  13. Chcete-li vytvořit instanci nebo použít vlastní ovládací prvky na stránce webové formuláře, přidejte následující řádek kódu<form>tagy.<b00></b00></form>
    <form id="Form1" method="post" runat="server">
        <CC:SimpleServerControl id="ctlSimpleControl" runat="server">
        </CC:SimpleServerControl >
    </form>
    
    Poznámka: V tomto kódu SimpleServerControl je název ovládacího prvku třídy uvnitř knihovny tříd.
  14. Stránka webové formuláře spustit a zobrazí výstup z vlastní ovládací prvek.
Pokud nepoužíváte aplikaci Visual Studio, musíte provést následující kroky:
  1. Otevření libovolného textového editoru.
  2. Vytvořte soubor s názvem SimpleServerControl.cs a kód uvedený v krocích 1 až 14.
  3. V proměnné PATH přidáte následující cestu:
    c:\Windows (winnt)\Microsoft.Net\Framework\v1.1.4322
  4. Spusťte příkazový řádek a přejděte do umístění, kde je k dispozici SimpleServerControl.cs.
  5. Spusťte následující příkaz:
    CSC /t:library/out: CustomServerControlsLib. SimpleServerControl.dll /r:System.dll /r:System.Web.dll SimpleServerControl.cs
    Další informace o kompilátoru jazyka C# (csc.exe) naleznete na webu MSDN:
    http://msdn2.microsoft.com/en-us/library/1700bbwd (vs.71) .aspx
  6. Chcete-li spustit vlastní ovládací prvek na stránce webové formuláře, postupujte takto:
    1. Vytvoření adresáře ve složce wwwroot.
    2. Spusťte Správce služby IIS (Internetová informační služba) a označit jako virtuální kořenový adresář nového adresáře.
    3. Vytvořte složku přihrádky podle nového adresáře.
    4. Vlastní knihovna DLL ovládacího prvku zkopírujte do složky Bin.
    5. Umístěte ukázkovou stránku webové formuláře, který jste vytvořili v předchozích krocích do nového adresáře.
    6. Spusťte ukázkovou stránku ze Správce služby IIS.
Nyní, když jste vytvořili jednoduchou vlastní ovládací prvek, podívejme jak zobrazit vlastnosti a návrhu atributy aplikovat na vlastní ovládací prvek.

Jak zobrazit vlastnosti na vlastní ovládací prvek

Bude stavět na předchozím příkladu a zavést jednu nebo více vlastností, které lze konfigurovat pomocí vlastní ovládací prvek na stránce webové formuláře.

Následující příklad ukazuje, jak definovat vlastnost, která se zobrazí zpráva z ovládacího prvku počet časy, jak je uvedeno ve vlastnosti ovládacího prvku:
  1. V textovém editoru otevřete SimpleServerControl.cs.
  2. Přidat vlastnost v SimpleServerControl Třída.
    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. Kompilovat vlastní ovládací prvek.
  4. Chcete-li použít vlastní ovládací prvky na stránce webových formulářů, přidáte nové vlastnosti ovládacího prvku prohlášení.
    <CC:SimpleServerControl id="ctlSimpleControl" NoOfTimes="5" runat="server"></CC:SimpleServerControl>
  5. Spuštění stránky se zobrazí zpráva "Hello world" z vlastní ovládací prvek jako mnohokrát jako určený ve vlastnosti ovládacího prvku.

Jak použít atributy návrhu na vlastní ovládací prvek

Proč jsou zapotřebí návrhu atributy
Vlastní ovládací prvek, který jste vytvořili v předchozím příkladu pracuje podle očekávání. Ale pokud chcete použít ovládací prvek v aplikaci Visual Studio, můžete NoOfTimes Vlastnost automaticky zvýrazněn v okně Vlastnosti při každém vlastní ovládací prvek v době návrhu.

Docílíte, musíte poskytnout informace metadat aplikace Visual Studio, což lze provést pomocí funkce v aplikaci Visual Studio, nazývaných atributy. Atributy můžete definovat třídu, metodu, vlastnost nebo pole. Visual Studio načte vlastní ovládací prvek třídy, kontroluje všechny atributy definované na úrovni třídu, metodu, vlastnost nebo pole a odpovídajícím způsobem změní chování vlastní ovládací prvek v době návrhu.

Chcete-li najít další informace o atributech, naleznete na následujícím webu MSDN:
http://msdn2.microsoft.com/en-us/library/Aa288059 (VS.71) .aspx
Řekněme sestavení vzorku, který používá běžně používané atributy:
  1. V textovém editoru otevřete SimpleServerControl.cs.
  2. Například zavést některé základní atributy na úrovni třídy DefaultProperty, ToolboxData, a TagPrefixAttrbute. Naše vzorku jsme budete stavět na tyto tři atributy.
            [
    	// 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. Existuje jeden další značka nazývá TagPrefixAttrbute. Atribut sestavení úrovně, který poskytuje Předpona Značka přetažením ovládacího prvku z panelu nástrojů Návrhář je. Návrhář jinak ve výchozím nastavení generuje předponu, jako je například "cc1". TagPrefixAttrbute nebude použito přímo do ovládacího prvku třídy. Použít TagPrefixAttrbute, otevřete AssemblyInfo.cs, zadejte následující řádek kódu a potom sestavte projekt znovu.
    [assembly:TagPrefix("ServerControlsLib ", "MyControl")]
    Poznámka: Chcete-li vytvořit zdroj pomocí příkazového řádku, musíte vytvořit soubor AssemblyInfo.cs, umístěte soubor do adresáře, který obsahuje všechny zdrojové soubory a spusťte následující příkaz příkaz k vytvoření ovládacího prvku:
    > csc /t:library/out: ServerControlsLib.dll /r:System.dll /r: System.Web.dll *.cs

Jaké jsou základní rozdíly mezi ovládací prvky a vlastní ovládací prvky?

Nyní, když máte Základní myšlenkou, co jsou ovládací prvky a vlastní ovládací prvky a jak je vytvořit, podívejme rychlý na rozdíly mezi nimi.
Zmenšit tuto tabulkuRozšířit tuto tabulku
FaktoryUživatelský ovládací prvekVlastní ovládací prvek
NasazeníNavržené pro scénáře k jediné aplikaci

Nasazení ve formě zdroje (ASCX) spolu s zdrojový kód aplikace

Pokud tentýž ovládací musí být používán více než jednu žádost, zavádí redundance a problémy s údržbou
Navržen tak, že jej můžete používat více než jednu žádost

Nasazena v adresáři Bin aplikace nebo v globální mezipaměť sestavení (GAC)

Distributed snadno a bez problémů spojených s redundance a údržba
VytvořeníVytvoření je podobná způsobu vytváření stránky webových formulářů; nebudou vhodné pro rapid application development (RAD)Zápis zahrnuje velké množství kódu, protože neexistuje žádná podpora pro návrháře
ObsahMnohem lepší volbou potřebujete statický obsah v pevné rozložení, například pokud provedete záhlaví a zápatíDalší vhodný pro aplikace vyžaduje dynamický obsah zobrazený; lze znovu použít v aplikaci, například pro datové vázaný ovládací prvek tabulky s dynamickou řádky
NávrhZápis nevyžaduje mnoho aplikací navrhování proto, že jsou vytvořeny v době návrhu a většinou obsahují statická dataZápis od začátku vyžaduje dobrou znalost ovládacího prvku životního cyklu a pořadí, ve kterém spouštění událostí, což je obvykle stará uživatelské ovládací prvky

Pokročilá témata

Dále podívejme na několik rozšířené funkce, které můžete použít při vývoji vlastních ovládacích prvků.

Správa stavu

Webové aplikace jsou založeny na protokolu HTTP, což je bez státní příslušnosti. Stránka a jeho podřízené ovládací prvky jsou vytvořeny na každý požadavek a jsou odstraněny po žádosti. Udržení stavu v klasickém prostředí ASP programování, použijte objekty relace a aplikace. Ale, musíte provést mnoho kódování. K tomu zabránit, ASP.NET poskytuje mechanismus známý jako zobrazení stavu pro udržení stavu přes několik žádostí. Další informace o stavu řízení a zobrazení stavu naleznete na následujících webech MSDN:
Úvod do správy stavu webových formulářů
http://msdn2.microsoft.com/en-us/library/75x4ha6s (vs.71) .aspx

ASP.Stát NET view
http://msdn.microsoft.com/msdnmag/issues/03/02/cuttingedge/default.aspx

Ukládání webových formulářů stránky hodnoty pomocí zobrazení stavu
http://msdn2.microsoft.com/en-us/library/4yfdwycw (vs.71) .aspx
Příklad použití zobrazení stavu vlastní ovládací prvek
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);
		}
	}
}
Příklad použití předchozího ovládacího prvku na stránce webové formuláře
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>

Vykreslování

V této části I budete Krátce popište jaké metody by měla mít přednost při odvození vlastní ovládací prvek buď Ovládací prvek třídy nebo WebControl Třída.
Vykreslení metody třídy System.Web.UI.Control
Informace o metodách vykreslování System.web.UI.Control třídy, naleznete na následujících webech MSDN:
Control.Render Metoda
http://msdn2.microsoft.com/en-us/library/System.web.UI.Control.Render (vs.71) .aspx

Control.RenderControl Metoda
http://msdn2.microsoft.com/en-us/library/System.web.UI.Control.rendercontrol (vs.71) .aspx

Control.RenderChildren Metoda
http://msdn2.microsoft.com/en-us/library/System.web.UI.Control.renderchildren (vs.71) .aspx
Způsob vykreslení ovládacího prvku na stránce
Každá stránka má Strom ovládacích prvků, která představuje kolekci prvků všechny podřízené stránky. Strom ovládacích prvků, objekt pro vykreslení HtmlTextWriter je vytvořena třída obsahující HTML vykreslený v klientském počítači. Tento objekt je předán RenderControl Metoda. Naopak RenderControl metoda vyvolá Vykreslení Metoda. Potom, Vykreslení volání metody RenderChildren Metoda na každý podřízený ovládací prvek, provádět rekurzivní smyčky, dokud není dosaženo konce kolekce. Tento proces je nejlépe vysvětlit následující příklad kódu.
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);
    }
} 
Vykreslení metody třídy System.Web.UI.WebControl
Informace o metodách vykreslování System.web.UI.WebControl třídy, naleznete na následujících webech MSDN:
WebControl.RenderBeginTag Metoda
http://msdn2.microsoft.com/en-us/library/System.web.UI.webcontrols.webcontrol.renderbegintag (vs.71) .aspx

WebControl.RenderContents Metoda
http://msdn2.microsoft.com/en-us/library/System.web.UI.webcontrols.webcontrol.rendercontents (vs.71) .aspx

WebControl.RenderEndTag Metoda
http://msdn2.microsoft.com/en-us/library/System.web.UI.webcontrols.webcontrol.renderendtag (vs.71) .aspx
Jak probíhá vykreslování třídy WebControl
Následující kód ukazuje příklad Vykreslení Metoda pro vlastní ovládací prvek.
protected override void Render(HtmlTextWriter writer)
{
    RenderBeginTag(writer);
    RenderContents(writer);
    RenderEndTag(writer);
}
Není třeba přepsat Vykreslení Metoda WebControl Třída. Pokud chcete vykreslit obsah WebControl třídy, je třeba přepsat RenderContents Metoda. Ale pokud stále chcete přepsat Vykreslení metodu, musíte změnit RenderBeginTag Metoda jakož i RenderEndTag Metoda ve specifickém pořadí, které je uvedeno v předchozím příkladu kódu.

Závěr

To je vše, nyní na ovládací prvky a vlastní ovládací prvky v prostředí ASP.NET 1.0 a ASP.NET 1.1. Doufám, že tento sloupec pomáhá pochopit základní rozdíly mezi nimi a různých přístupů, které můžete využít k jejich vývoji.

Děkujeme vám za váš čas. Zápis naleznete v tématu Pokročilá témata pro vlastní ovládací prvky, jako jsou například státní správy, styly řízení, složený ovládací prvky a podporu vlastních ovládacích prvků návrhu v blízké budoucnosti očekávat.

Další informace o ovládacích prvcích naleznete na následujících webech MSDN:
PROSTŘEDÍ ASP.Základy vývoje řízení serveru NET
http://msdn2.microsoft.com/en-us/library/aa310918 (vs.71) .aspx

Rozsáhlé zkoumání uživatelské ovládací prvky
http://msdn2.microsoft.com/en-us/library/ms972975.aspx

Vytváření šablon ASP vlastní.NET serverové ovládací prvky
http://msdn2.microsoft.com/en-us/library/Aa478964.aspx

Události v prostředí ASP.NET serverové ovládací prvky
http://msdn2.microsoft.com/en-us/library/aa720049 (vs.71) .aspx

Složený ovládací prvek vs. uživatelský ovládací prvek
http://msdn2.microsoft.com/en-us/library/aa719735 (vs.71) .aspx

Vývoj ASP.NET serverové ovládací prvky
http://msdn2.microsoft.com/en-us/library/aa719973 (vs.71) .aspx

Vývoj vlastních ovládacích prvků: klíčové koncepty
http://msdn2.microsoft.com/en-us/library/aa720226 (vs.71) .aspx

Přidání podpory návrhu prostředí ASP.SÍŤOVÉ prvky
http://msdn2.microsoft.com/en-us/library/Aa478960.aspx
Jako vždy, určena atmosféru zdarma podat nápady na témata, které chcete v budoucnu sloupce nebo pomocí znalostní báze Knowledge Base Požádat o to formulář.

Vlastnosti

ID článku: 893667 - Poslední aktualizace: 22. května 2011 - Revize: 3.0
Informace v tomto článku jsou určeny pro produkt:
  • Microsoft ASP.NET 1.1
  • Microsoft ASP.NET 1.0
Klíčová slova: 
kbhowto kbasp kbmt KB893667 KbMtcs
Strojově přeložený článek
Důležité: Tento článek byl přeložen pomocí software společnosti Microsoft na strojový překlad, ne profesionálním překladatelem. Společnost Microsoft nabízí jak články přeložené překladatelem, tak články přeložené pomocí software na strojový překlad, takže všechny články ve Znalostní databázi (Knowledge Base) jsou dostupné v češtině. Překlad pomocí software na strojový překlad ale není bohužel vždy dokonalý. Obsahuje chyby ve skloňování slov, skladbě vět, nebo gramatice, podobně jako když cizinci dělají chyby při mluvení v češtině. Společnost Microsoft není právně zodpovědná za nepřesnosti, chyby nebo škody vzniklé chybami v překladu, nebo při použití nepřesně přeložených instrukcí v článku zákazníkem. Společnost Microsoft aktualizuje software na strojový překlad, aby byl počet chyb omezen na minimum.
Projděte si také anglickou verzi článku:893667

Dejte nám zpětnou vazbu

 

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