ภาพรวมของการควบคุมผู้ใช้เปรียบเทียบกับคอนโทรลแบบกำหนดเอง

การแปลบทความ การแปลบทความ
หมายเลขบทความ (Article ID): 893667 - ผลิตภัณฑ์ที่เกี่ยวข้องในบทความนี้
คอลัมน์เสียงสนับสนุน asp.net

ภาพรวมของการควบคุมผู้ใช้เปรียบเทียบกับคอนโทรลแบบกำหนดเอง

เมื่อต้องการกำหนดคอลัมน์นี้กับความต้องการของคุณ เราต้องการเชิญให้คุณส่งของแนวคิดเกี่ยวกับหัวข้อที่สนใจการตัดสินค้าจากคลังที่คุณต้องการดูและคุณ ระบุในอนาคตบทความในฐานความรู้และคอลัมน์ของบริการเสียง คุณสามารถส่งแนวคิดและของคุณโดยใช้ผลป้อนกลับถามอย่างได้แบบฟอร์ม มีอยู่ด้วยการเชื่อมโยงไปยังแบบฟอร์มที่ด้านล่างของคอลัมน์นี้
ขยายทั้งหมด | ยุบทั้งหมด

เนื้อหาบนหน้านี้

บทนำ

สูง นี่คือ Parag และฉันวิศวกรฝ่ายสนับสนุนการทำงานกับกลุ่มการสนับสนุนของ Microsoft ASP.NET สำหรับหลายปีในขณะนี้ ก่อนที่จะเข้าร่วม Microsoft ฉันจะทำงานบนโครงการที่ใช้เว็บและแอปพลิเคชันเดสก์ท็อปที่ใช้เทคโนโลยีของ Microsoft ในขณะที่ให้บริการสนับสนุนของคุณภาพให้แก่ลูกค้า ฉันจะได้เห็นกรณีที่มีบาง confusion ล้อมรอบคอนโทรลแบบกำหนดเอง และฉันเพียงแค่ต้องการใช้เวลาบางอย่างเพื่ออธิบายแนวคิดบางล้อมรอบคอนโทรลแบบกำหนดเอง เป็นไม่ถูกต้อง ตามที่ปรากฏ เชื่อฉัน หลังจากที่คุณได้รับแฮงค์ของคุณ คุณจะอยู่ในตำแหน่งที่ดีกว่าการขึ้น ASP.NET

ภาพรวม

ในคอลัมน์ของเดือนนี้ ฉันจะกล่าวถึงหัวข้อต่อไปนี้:
  • ตัวควบคุมผู้ใช้คืออะไร
  • คอนโทรลแบบกำหนดเองคืออะไร
  • ความแตกต่างพื้นฐานระหว่างผู้ใช้ควบคุมและคอนโทรลแบบกำหนดเองคืออะไร
ฉันจะแนะนำบางหัวข้อขั้นสูงที่เกี่ยวกับคอนโทรลแบบกำหนดเอง เช่นการจัดการสถานะและการแสดงผลของตัวควบคุมแบบกำหนดเอง เช่นกัน

ตัวควบคุมผู้ใช้คืออะไร

ผู้ใช้ควบคุมตัวควบคุมแบบกำหนดเอง reusable และพวกเขาใช้เทคนิคเดียวกันที่จ้างงาน โดยการควบคุมเซิร์ฟเวอร์ HTML และเว็บ พวกเขานำเสนอเป็นวิธีง่าย ๆ ในการแบ่งพาร์ติชัน และนำมาใช้อินเทอร์เฟซผู้ใช้ทั่วไปบนเว็บ ASP.NET แอพลิเค ผู้ใช้เดียวกันกับฟอร์มของเว็บโปรแกรมรุ่นที่ฟอร์มเว็บเพจที่ทำงาน สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับฟอร์มเว็บการเขียนโปรแกรมรุ่น แวะไปที่เว็บไซต์ของ Microsoft สำหรับนักพัฒนาเครือข่าย (MSDN) ต่อไปนี้:
บทนำสู่การฟอร์มของเว็บเพจ
.aspx http://msdn2.microsoft.com/en-us/library/65tcbxz3 (vs.71)

รูปแบบรหัสฟอร์มของเว็บ
.aspx http://msdn2.microsoft.com/en-us/library/015103yb (vs.71)

วิธีการสร้างตัวควบคุมผู้ใช้

ไวยากรณ์คุณใช้เพื่อสร้างตัวควบคุมผู้ใช้จะคล้ายกับไวยากรณ์คุณใช้เพื่อสร้างฟอร์มของเว็บเพจ (.aspx) ความแตกต่างเพียงอย่างเดียวคือการ ให้ตัวควบคุมผู้ใช้ไม่ได้รวมการ<html>,<body> และ<form>องค์ประกอบเนื่องจากเพจในเว็บฟอร์มเป็นโฮสต์การควบคุมผู้ใช้เมื่อต้องการสร้างตัวควบคุมผู้ใช้ ดำเนินการดังต่อไปนี้:</body></html>
  1. เปิดข้อความหรือตัวแก้ไข HTML และสร้างกลุ่มรหัสฝั่งเซิร์ฟเวอร์ exposing ทั้งหมดคุณสมบัติ วิธี และเหตุการณ์
    <script language="C#" runat="server">
       public void button1_Click(object sender, EventArgs e)
       {
          label1.Text = "Hello World!!!";
       }
    </script>
    
  2. สร้างอินเทอร์เฟซสำหรับผู้ใช้สำหรับการควบคุมผู้ใช้
    <asp:Label id="label1" runat="server"/>
     <br><br>
    <asp:button id="button1" text="Hit" OnClick="button1_Click" runat="server" />
    

วิธีการใช้ตัวควบคุมผู้ใช้ในฟอร์มของเว็บเพจ

  1. สร้างหน้าเว็บฟอร์มใหม่ (.aspx) ใน Microsoft Visual Studio .NET 2002, Microsoft Visual Studio .NET 2003, Microsoft Visual Studio 2005 หรือตัวแก้ไขข้อความใด ๆ
  2. ประกาศได้ลงทะเบียน @directive ตัวอย่างเช่น ใช้รหัสดังต่อไปนี้
    <%@ Register TagPrefix="UC" TagName="TestControl" Src="test.ascx" %>
    หมายเหตุ:สมมติว่า ตัวควบคุมผู้ใช้และหน้าเว็บฟอร์มอยู่ในตำแหน่งที่ตั้งเดียวกัน
  3. เมื่อต้องการใช้การควบคุมผู้ใช้ในฟอร์มของเว็บเพจ ใช้โค้ดต่อไปนี้หลังจากลงทะเบียน @directive
    <html>
        <body>
              <form runat="server">
                   <UC:TestControl id="Test1" runat="server"/>
              </form>
        </body>  
    </html>
    

วิธีการสร้างอินสแตนซ์ของตัวควบคุมผู้ใช้โดยทางโปรแกรมในรหัสหลังแฟ้มเพฟอร์มเว็บ

ตัวอย่างก่อนหน้า instantiated ตัวควบคุมผู้ใช้ในการได้โดยใช้ฟอร์มเว็บเพจที่ declarativelyลงทะเบียน @directive อย่างไรก็ตาม คุณสามารถเริ่มต้นตัวควบคุมผู้ใช้แบบไดนามิก และเพิ่มลงในเพจ ต่อไปนี้เป็นขั้นตอนสำหรับการทำงานที่:
  1. สร้างฟอร์มของเว็บเพจใหม่ใน Visual Studio
  2. นำทางไปยังรหัสหลังแฟ้มที่สร้างขึ้นสำหรับเพจนี้ฟอร์มเว็บ
  3. ในการPage_Loadเหตุการณ์ของการหน้าคลาส เขียนรหัสต่อไปนี้
    // 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);
    
    หมายเหตุ:คุณสามารถเพิ่มตัวควบคุมผู้ใช้แบบไดนามิกที่เหตุการณ์บางอย่างของวงจรชีวิตของหน้า

    สำหรับข้อมูลเพิ่มเติม โปรดไปที่เว็บไซต์ต่อไปนี้:
    เพิ่มตัวควบคุมฟอร์มของเว็บเพโดยทางโปรแกรม
    .aspx http://msdn2.microsoft.com/en-us/library/kyt0fzt1 (vs.71)

    ควบคุมการดำเนินการ lifecycle
    .aspx http://msdn2.microsoft.com/en-us/library/aa719775 (vs.71)

    ตัวควบคุมของเว็บแบบไดนามิก postbacks และดู สถานะ โดย Scott Mitchell
    http://aspnet.4guysfromrolla.com/articles/092904-1.aspx

วิธีการประมวลผลตัวควบคุมผู้ใช้

เมื่อหน้ากับตัวควบคุมผู้ใช้มีร้อง ต่อไปนี้เกิดขึ้น:
  • The page parser parses the .ascx file specified in theSrcคุณลักษณะในการ@ Registerdirective and generates a class that derives from theSystem.Web.UI.UserControlคลาสที่
  • The parser then dynamically compiles the class into an assembly.
  • If you are using Visual Studio, then at design time only, Visual Studio creates a code behind file for the user control, and the file is precompiled by the designer itself.
  • Finally, the class for the user control, which is generated through the process of dynamic code generation and compilation, includes the code for the code behind file (.ascx.cs) as well as the code written inside the .ascx file.

What are custom controls?

Custom controls are compiled code components that execute on the server, expose the object model, and render markup text, such as HTML or XML, as a normal Web Form or user control does.

How to choose the base class for your custom control

To write a custom control, you should directly or indirectly derive the new class from theSystem.Web.UI.Controlclass or from theSystem.Web.UI.WebControls.WebControlคลาส:
  • You should derive fromSystem.Web.UI.Controlif you want the control to render nonvisual elements. For example, <meta> and<head>are examples of nonvisual rendering.</head>
  • You should derive fromSystem.Web.UI.WebControls.WebControlif you want the control to render HTML that generates a visual interface on the client computer.
If you want to change the functionality of existing controls, such as a button or label, you can directly derive the new class with these existing classes and can change their default behavior.

In brief, theตัวควบคุมclass provides the basic functionality by which you can place it in the control tree for aหน้าคลาสที่ กระบวนการWebControlclass adds the functionality to the baseตัวควบคุมclass for displaying visual content on the client computer. For example, you can use theWebControlclass to control the look and styles through properties like font, color, and height.

How to create and use a simple custom control that extends from System.Web.UI.Control using Visual Studio

  1. เริ่ม Visual Studio
  2. Create a class library project, and give it a name, for example, CustomServerControlsLib.
  3. Add a source file to the project, for example, SimpleServerControl.cs.
  4. Include the reference of theSystem.Webnamespace in the references section.
  5. Check whether the following namespaces are included in the SimpleServerControl.cs file.
    System
    System.Collections
    System.ComponentModel
    System.Data
    System.Web
    System.Web.SessionState
    System.Web.UI
    System.Web.UI.WebControls
    
  6. Inherit theSimpleServerControlsclass with theตัวควบคุมbase class.
    public class SimpleServerControl : Control
  7. Override theRendermethod to write the output to the output stream.
    protected override void Render(HtmlTextWriter writer) 
    {
    	 writer.Write("Hello World from custom control");
    }
    
    หมายเหตุ:กระบวนการHtmlTextWriterclass has the functionality of writing HTML to a text stream. กระบวนการการเขียนวิธีการนี้HtmlTextWriterclass outputs the specified text to the HTTP response stream and is the same as theResponse.Writeวิธีการ
  8. Compile the class library project. It will generate the DLL output.
  9. Open an existing or create a new ASP.NET Web application project.
  10. Add a Web Forms page where the custom control can be used.
  11. Add a reference to the class library in the references section of the ASP.NET project.
  12. Register the custom control on the Web Forms page.
    <%@ Register TagPrefix="CC " Namespace=" CustomServerControlsLib " Assembly="CustomServerControlsLib " %>
  13. To instantiate or use the custom control on the Web Forms page, add the following line of code in the<form>แท็ก
    <form id="Form1" method="post" runat="server">
        <CC:SimpleServerControl id="ctlSimpleControl" runat="server">
        </CC:SimpleServerControl >
    </form>
    
    หมายเหตุ:In this code,SimpleServerControlis the control class name inside the class library.
  14. Run the Web Forms page, and you will see the output from the custom control.
If you are not using Visual Studio, you need to perform the following steps:
  1. Open any text editor.
  2. Create a file named SimpleServerControl.cs, and write the code as given in steps 1 through 14.
  3. In the PATH variable, add the following path:
    c:\windows (winnt)\Microsoft.Net\Framework\v1.1.4322
  4. Start a command prompt, and go to the location where SimpleServerControl.cs is present.
  5. เรียกใช้คำสั่งต่อไปนี้:
    csc /t:library/ออก: CustomServerControlsLib /r:System.Web.dll /r:System.dll SimpleServerControl.dll SimpleServerControl.cs
    สำหรับข้อมูลเพิ่มเติมเกี่ยวกับ c# คอมไพเลอร์ (csc.exe), ไปที่ MSDN เว็บไซต์ต่อไปนี้:
    .aspx http://msdn2.microsoft.com/en-us/library/1700bbwd (vs.71)
  6. เมื่อต้องการเรียกใช้ตัวควบคุมแบบกำหนดเองในฟอร์มของเว็บเพจ ทำต่อไปนี้:
    1. สร้างไดเรกทอรีภายใต้โฟลเดอร์ wwwroot
    2. เริ่มการทำงานของโปรแกรมจัดการบริการข้อมูลทางอินเทอร์เน็ตของ Microsoft (IIS) และทำเครื่องหมายในไดเรกทอรีใหม่เป็นไดเรกทอรีรากเสมือน
    3. สร้างช่องเก็บโฟลเดอร์ภายใต้ไดเรกทอรีใหม่
    4. การคัดลอกตัวควบคุม DLL ที่กำหนดเองลงในโฟลเดอร์ช่องเก็บ
    5. ทำหน้าเว็บฟอร์มตัวอย่างที่คุณสร้างในขั้นตอนก่อนหน้าภายในไดเรกทอรีใหม่
    6. เรียกใช้ตัวอย่างหน้าจากโปรแกรมจัดการ IIS
หลังจากที่คุณได้สร้างตัวควบคุมแบบกำหนดเองอย่างง่าย ลองดูที่วิธีการแสดงคุณสมบัติ และใช้คุณลักษณะขณะออกแบบบนตัวควบคุมที่กำหนดเอง

วิธีการที่แสดงคุณสมบัติของตัวควบคุมแบบกำหนดเอง

ฉันจะสร้างในตัวอย่างก่อนหน้านี้ และแนะนำอย่าง น้อยหนึ่งคุณสมบัติที่คุณสามารถกำหนดค่าในขณะที่ใช้คอนโทรลแบบกำหนดเองในฟอร์มของเว็บเพจ

ตัวอย่างต่อไปนี้แสดงวิธีการกำหนดลักษณะที่จะแสดงข้อความจากตัวควบคุมจำนวนของเวลา ตามที่ระบุในคุณสมบัติของตัวควบคุม:
  1. เปิด SimpleServerControl.cs ในตัวแก้ไขข้อความ
  2. เพิ่มคุณสมบัติในนั้นSimpleServerControlคลาสที่
    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. การคอมไพล์คอนโทรลแบบกำหนดเอง
  4. เมื่อต้องการใช้คอนโทรลแบบกำหนดเองในฟอร์มของเว็บเพจ เพิ่มคุณสมบัติใหม่เพื่อการรายงานการควบคุม
    <CC:SimpleServerControl id="ctlSimpleControl" NoOfTimes="5" runat="server"></CC:SimpleServerControl>
  5. ใช้เพจนี้จะเป็นแสดงข้อความ "Hello โลก" จากตัวควบคุมแบบกำหนดเองเป็นหลายครั้งเป็นระบุในคุณสมบัติของตัวควบคุม

วิธีการใช้คุณลักษณะขณะออกแบบบนตัวควบคุมแบบกำหนดเอง

เหตุใดจึงต้องแอตทริบิวต์ขณะออกแบบ
คอนโทรลแบบกำหนดเองที่คุณอยู่แล้วภายในตัวอย่างก่อนหน้านี้ทำงานอย่างที่คาดไว้ อย่างไรก็ตาม ถ้าคุณต้องการใช้ตัวควบคุมนั้นใน Visual Studio คุณอาจต้องการNoOfTimesคุณสมบัติการถูกเน้นในหน้าต่างคุณสมบัติโดยอัตโนมัติทุกครั้งที่มีเลือกตัวควบคุมแบบกำหนดเองในเวลาการออกแบบ

เพื่อทำค่านี้อาจเกิดขึ้น คุณจำเป็นต้องให้ข้อมูลเมต้าดาต้า Visual Studio ซึ่งคุณสามารถทำได้ โดยการใช้คุณลักษณะใน Visual Studio เรียกแอตทริบิวต์ แอตทริบิวต์ที่สามารถกำหนดคลาสที่ วิธี คุณสมบัติ หรือเขตข้อมูล เมื่อ Visual Studio โหลดคลาของตัวควบคุมแบบกำหนดเอง จะตรวจสอบแอตทริบิวต์ใด ๆ ที่กำหนดไว้ในคลา วิธี คุณสมบัติ หรือฟิลด์ระดับ และเปลี่ยนแปลงลักษณะการทำงานของตัวควบคุมแบบกำหนดเองในเวลาการออกแบบตามลำดับ

การค้นหาข้อมูลเพิ่มเติมเกี่ยวกับคุณลักษณะ ไปที่ MSDN เว็บไซต์ต่อไปนี้:
.aspx http://msdn2.microsoft.com/en-us/library/Aa288059 (VS.71)
มาลองสร้างตัวอย่างที่ใช้กันทั่วไปใช้แอตทริบิวต์:
  1. เปิด SimpleServerControl.cs ในตัวแก้ไขข้อความ
  2. แนะนำแอตทริบิวต์พื้นฐานบางอย่างในระดับของระดับชั้น ตัวอย่างเช่นDefaultProperty,ToolboxDataและTagPrefixAttrbute. เราจะสร้างตัวอย่างของเราในแอตทริบิวต์เหล่านี้ที่สาม
            [
    	// 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. ไม่มีแท็กมากกว่าหนึ่งที่เรียกว่าTagPrefixAttrbute. แอตทริบิวต์ระดับแอสเซมบลีที่ให้หมายเลขนำหน้าไปยังแท็กเมื่อคุณลากตัวควบคุมจากกล่องเครื่องมือในโปรแกรมออกแบบ ได้ มิฉะนั้น ผู้ออกแบบสร้างหมายเลขนำหน้าเช่น "cc1" โดยค่าเริ่มต้นTagPrefixAttrbuteไม่ตรงใช้กับคลาควบคุม เมื่อต้องการใช้TagPrefixAttrbuteเปิด AssemblyInfo.cs บรรทัดต่อไปนี้ของรหัสรวม และจากนั้น สร้างโครงการ
    [assembly:TagPrefix("ServerControlsLib ", "MyControl")]
    หมายเหตุ:ถ้าคุณต้องการสร้างแหล่งที่มาโดยใช้บรรทัดคำสั่ง คุณต้องการสร้างแฟ้ม AssemblyInfo.cs วางแฟ้มในไดเรกทอรีที่ประกอบด้วยแฟ้มต้นฉบับทั้งหมด และเรียกใช้คำสั่งต่อไปนี้เพื่อสร้างตัวควบคุม:
    > csc /t:library/ออก: ServerControlsLib.dll /r:System.dll /r: System.Web.dll *.cs

ความแตกต่างพื้นฐานระหว่างผู้ใช้ควบคุมและคอนโทรลแบบกำหนดเองคืออะไร

หลังจากที่คุณมีความคิดพื้นฐานของการควบคุมผู้ใช้และการควบคุมแบบกำหนดเองคืออะไรและวิธีการสร้างนั้น ลองมาดูแบบด่วนที่แตกต่างระหว่างทั้งสอง
ยุบตารางนี้ขยายตารางนี้
ปัจจัยการควบคุมผู้ใช้คอนโทรลแบบกำหนดเอง
การปรับใช้ออกแบบมาสำหรับสถานการณ์แอพลิเคชันเดียว

การจัดวางในแบบฟอร์ม (.ascx) แหล่งที่มาพร้อมกับรหัสแหล่งที่มาของแอพลิเคชัน

ถ้าตัวควบคุมเดียวกันที่จำเป็นต้องใช้ในโปรแกรมประยุกต์มากกว่าหนึ่ง จะแนะนำปัญหาในการบำรุงรักษาและการสำรอง
การออกแบบมาเพื่อให้สามารถถูกใช้ โดยโปรแกรมประยุกต์มากกว่าหนึ่ง

การจัดวาง ในไดเรกทอรีของช่องเก็บของแอพลิเคชัน หรือ ในแคชแอสเซมบลีส่วนกลาง

Distributed easily and without problems associated with redundancy and maintenance
CreationCreation is similar to the way Web Forms pages are created; well-suited for rapid application development (RAD)Writing involves lots of code because there is no designer support
เนื้อหาA much better choice when you need static content within a fixed layout, for example, when you make headers and footersMore suited for when an application requires dynamic content to be displayed; can be reused across an application, for example, for a data bound table control with dynamic rows
ออกแบบWriting doesn't require much application designing because they are authored at design time and mostly contain static dataWriting from scratch requires a good understanding of the control's life cycle and the order in which events execute, which is normally taken care of in user controls

Advanced topics

Next, let's take a look at a few of the advanced features that you may use while developing custom controls.

State management

Web applications are built on HTTP, which is stateless. A page and its child controls are created on every request and are disposed of after the request is over. To maintain state in classic ASP programming, you use session and application objects. But for that, you need to do lots of coding. To avoid this, ASP.NET provides a mechanism known as view state for maintaining state across several requests. To learn more about state management and view state, visit the following MSDN Web sites:
Introduction to Web Forms state management
http://msdn2.microsoft.com/en-us/library/75x4ha6s(vs.71).aspx

The ASP.NET view state
http://msdn.microsoft.com/msdnmag/issues/03/02/cuttingedge/default.aspx

Saving Web Forms page values using view state
http://msdn2.microsoft.com/en-us/library/4yfdwycw(vs.71).aspx
Example using view state in a custom control
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);
		}
	}
}
Example using the previous control on a Web Forms page
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 this section, I'll briefly describe what methods you should override when you derive a custom control from either theตัวควบคุมคลาหรือWebControlคลาสที่
Rendering methods of the System.Web.UI.Control class
For information about the rendering methods of theSystem.Web.UI.Controlclass, visit the following MSDN Web sites:
Control.Renderวิธีการ
http://msdn2.microsoft.com/en-us/library/system.web.ui.control.render(vs.71).aspx

Control.RenderControlวิธีการ
http://msdn2.microsoft.com/en-us/library/system.web.ui.control.rendercontrol(vs.71).aspx

Control.RenderChildrenวิธีการ
http://msdn2.microsoft.com/en-us/library/system.web.ui.control.renderchildren(vs.71).aspx
How a control is rendered on the page
Every page has a control tree that represents a collection of all the child controls for that page. To render the control tree, an object of theHtmlTextWriterclass is created that contains the HTML to be rendered on the client computer. That object is passed to theRenderControlวิธีการ In turn, theRenderControlmethod invokes therenderวิธีการ Then, therenderการเรียกวิธีการRenderChildrenmethod on each child control, making a recursive loop until the end of the collection is reached. This process is best explained by the following example code.
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);
    }
} 
Rendering methods of the System.Web.UI.WebControl class
For information about the rendering methods of theSystem.Web.UI.WebControlclass, visit the following MSDN Web sites:
WebControl.RenderBeginTagวิธีการ
http://msdn2.microsoft.com/en-us/library/system.web.ui.webcontrols.webcontrol.renderbegintag(vs.71).aspx

WebControl.RenderContentsวิธีการ
http://msdn2.microsoft.com/en-us/library/system.web.ui.webcontrols.webcontrol.rendercontents(vs.71).aspx

WebControl.RenderEndTagวิธีการ
http://msdn2.microsoft.com/en-us/library/system.web.ui.webcontrols.webcontrol.renderendtag(vs.71).aspx
How the rendering of the WebControl class takes place
The following code example shows therendermethod for the custom control.
protected override void Render(HtmlTextWriter writer)
{
    RenderBeginTag(writer);
    RenderContents(writer);
    RenderEndTag(writer);
}
You don't need to override therenderวิธีการนี้WebControlคลาสที่ ถ้าคุณต้องการแสดงเนื้อหาภายในนั้นWebControlคลา ที่คุณต้องการแทนRenderContentsวิธีการ อย่างไรก็ตาม ถ้าคุณมี ต้องการแทนrenderวิธี คุณต้องแทนRenderBeginTagวิธีการเช่นเดียว กับRenderEndTagวิธีการในใบสั่งเฉพาะที่แสดงในตัวอย่างรหัสก่อนหน้านี้

บทสรุป

นั่นคือข้อมูลทั้งหมดในขณะนี้ในการควบคุมผู้ใช้และการควบคุมแบบกำหนดเองใน ASP.NET 1.0 และ ASP.NET 1.1 ฉัน hope ว่า คอลัมน์นี้ช่วยคุณในการทำความเข้าใจความแตกต่างพื้นฐานระหว่างเหล่านั้นและ approaches ต่าง ๆ ที่คุณสามารถใช้การพัฒนาเหล่านั้น

ขอบคุณสำหรับเวลาของคุณ เราคาดว่าจะเขียนเพิ่มเติมเกี่ยวกับหัวข้อขั้นสูงสำหรับตัวควบคุมแบบกำหนดเอง เช่นการจัดการสถานะ ตัวควบคุมลักษณะ ตัวควบคุมแบบร่วม และสนับสนุนขณะออกแบบสำหรับตัวควบคุมแบบกำหนดเอง ในอนาคต near

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการควบคุม แวะไปที่ MSDN เว็บไซต์ต่อไปนี้:
หลักการพัฒนาการควบคุมการเซิร์ฟเวอร์ asp.net
.aspx http://msdn2.microsoft.com/en-us/library/aa310918 (vs.71)

examination ที่หลากหลายของตัวควบคุมผู้ใช้
http://msdn2.microsoft.com/en-us/library/ms972975.aspx

อาคาร templated ASP.NET เซิร์ฟเวอร์คอนโทรลแบบกำหนดเอง
http://msdn2.microsoft.com/en-us/library/Aa478964.aspx

เหตุการณ์ต่าง ๆ ในตัวควบคุมเซิร์ฟเวอร์ของ ASP.NET
.aspx http://msdn2.microsoft.com/en-us/library/aa720049 (vs.71)

ตัวควบคุมคอมโพสิตเปรียบเทียบกับตัวควบคุมผู้ใช้
.aspx http://msdn2.microsoft.com/en-us/library/aa719735 (vs.71)

การพัฒนาตัวควบคุมเซิร์ฟเวอร์ของ ASP.NET
.aspx http://msdn2.microsoft.com/en-us/library/aa719973 (vs.71)

การพัฒนาคอนโทรลแบบกำหนดเอง: คีย์แนวคิด
.aspx http://msdn2.microsoft.com/en-us/library/aa720226 (vs.71)

การเพิ่มการสนับสนุนขณะออกแบบเพื่อควบคุม ASP.NET
http://msdn2.microsoft.com/en-us/library/Aa478960.aspx
ตามที่ได้รับการเสมอ feel ว่างส่งแนวคิดในหัวข้อที่คุณต้องจัดการในอนาคตคอลัมน์ หรืออยู่ ในฐานความรู้ใช้นั้นถามอย่างได้แบบฟอร์ม

คุณสมบัติ

หมายเลขบทความ (Article ID): 893667 - รีวิวครั้งสุดท้าย: 15 มกราคม 2554 - Revision: 4.0
ใช้กับ
  • Microsoft ASP.NET 1.1
  • Microsoft ASP.NET 1.0
Keywords: 
kbhowto kbasp kbmt KB893667 KbMtth
แปลโดยคอมพิวเตอร์
ข้อมูลสำคัญ: บทความนี้แปลโดยซอฟต์แวร์การแปลด้วยคอมพิวเตอร์ของ Microsoft แทนที่จะเป็นนักแปลที่เป็นบุคคล Microsoft มีบทความที่แปลโดยนักแปลและบทความที่แปลด้วยคอมพิวเตอร์ เพื่อให้คุณสามารถเข้าถึงบทความทั้งหมดในฐานความรู้ของเรา ในภาษาของคุณเอง อย่างไรก็ตาม บทความที่แปลด้วยคอมพิวเตอร์นั้นอาจมีข้อบกพร่อง โดยอาจมีข้อผิดพลาดในคำศัพท์ รูปแบบการใช้ภาษาและไวยากรณ์ เช่นเดียวกับกรณีที่ชาวต่างชาติพูดผิดเมื่อพูดภาษาของคุณ Microsoft ไม่มีส่วนรับผิดชอบต่อความคลาดเคลื่อน ความผิดพลาดหรือความเสียหายที่เกิดจากการแปลเนื้อหาผิดพลาด หรือการใช้บทแปลของลูกค้า และ Microsoft มีการปรับปรุงซอฟต์แวร์การแปลด้วยคอมพิวเตอร์อยู่เป็นประจำ
ต่อไปนี้เป็นฉบับภาษาอังกฤษของบทความนี้:893667

ให้ข้อเสนอแนะ

 

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