User and Custom Control

Question

Hi, Sir i am little confuse what is the difference between user control and custom control where we use user or custom control ?

Satyapriya Nayak · Answer

Hi Shubham, User controls are similar to those of asp include files easy to create, can not be placed into the toolbox and dragged dropped from it. A User controls can share single application files. Normally designed to provided functionality that is reusable for the particular application. Custom controls are compiled code(Dlls) easier to use,difficult to create and can be place in toolbox. You can drag and drop controls, Attributes of this control are visually set at design time. A custom control can be used in multiple application as shared DLLS. Any one can copy DLL of custom control in bin directory and add reference and use them. Normally custom controls are designed to provide custom functionality independent of consuming application. What are user controls? loadTOCNode(2, 'moreinformation'); User controls are custom, reusable controls, and they use the same techniques that are employed by HTML and Web server controls. They offer an easy way to partition and reuse common user interfaces across ASP.NET Web applications. They use the same Web Forms programming model on which a Web Forms page works. For more details about the Web Forms programming model, visit the following Microsoft Developer Network (MSDN) Web sites: Introduction to Web Forms pages http://msdn2.microsoft.com/en-us/library/65tcbxz3(vs.71).aspx (http://msdn2.microsoft.com/en-us/library/65tcbxz3(vs.71).aspx) Web Forms code model http://msdn2.microsoft.com/en-us/library/015103yb(vs.71).aspx (http://msdn2.microsoft.com/en-us/library/015103yb(vs.71).aspx) How to create a user control loadTOCNode(3, 'moreinformation'); The syntax you use to create a user control is similar to the syntax you use to create a Web Forms page (.aspx). The only difference is that a user control does not include the , , and elements since a Web Forms page hosts the user control. To create a user control, follow these steps: Open a text or HTML editor, and create a server-side code block exposing all the properties, methods, and events. public void button1_Click(object sender, EventArgs e) { label1.Text = "Hello World!!!"; } Create a user interface for the user control. How to use a user control in a Web Forms page loadTOCNode(3, 'moreinformation'); Create a new Web Forms page (.aspx) in Microsoft Visual Studio .NET 2002, Microsoft Visual Studio .NET 2003, Microsoft Visual Studio 2005, or any text editor. Declare the @ Register directive. For example, use the following code. Note Assume that the user control and the Web Forms page are in the same location. To use the user control in the Web Forms page, use the following code after the @ Register directive. How to create an instance of a user control programmatically in the code behind file of a Web Forms page loadTOCNode(3, 'moreinformation'); The previous example instantiated a user control declaratively in a Web Forms page using the @ Register directive. However, you can instantiate a user control dynamically and add it to the page. Here are the steps for doing that: Create a new Web Forms page in Visual Studio. Navigate to the code behind file generated for this Web Forms page. In the Page_Load event of the Page class, write the following 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); Note You can add a user control dynamically at certain events of the page life cycle. For more information, visit the following Web sites: Adding controls to a Web Forms page programmatically http://msdn2.microsoft.com/en-us/library/kyt0fzt1(vs.71).aspx (http://msdn2.microsoft.com/en-us/library/kyt0fzt1(vs.71).aspx) Control execution lifecycle http://msdn2.microsoft.com/en-us/library/aa719775(vs.71).aspx (http://msdn2.microsoft.com/en-us/library/aa719775(vs.71).aspx) Dynamic Web controls, postbacks, and view state, by Scott Mitchell http://aspnet.4guysfromrolla.com/articles/092904-1.aspx (http://aspnet.4guysfromrolla.com/articles/092904-1.aspx) How a user control is processed loadTOCNode(3, 'moreinformation'); When a page with a user control is requested, the following occurs: The page parser parses the .ascx file specified in the Src attribute in the @ Register directive and generates a class that derives from the System.Web.UI.UserControl class. 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. Back to the top What are custom controls? loadTOCNode(2, 'moreinformation'); 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 loadTOCNode(3, 'moreinformation'); To write a custom control, you should directly or indirectly derive the new class from the System.Web.UI.Control class or from the System.Web.UI.WebControls.WebControl class: You should derive from System.Web.UI.Control if you want the control to render nonvisual elements. For example, and are examples of nonvisual rendering. You should derive from System.Web.UI.WebControls.WebControl if 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 Control class provides the basic functionality by which you can place it in the control tree for a Page class. The WebControl class adds the functionality to the base Control class for displaying visual content on the client computer. For example, you can use the WebControl class 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 loadTOCNode(3, 'moreinformation'); Start Visual Studio. Create a class library project, and give it a name, for example, CustomServerControlsLib. Add a source file to the project, for example, SimpleServerControl.cs. Include the reference of the System.Web namespace in the references section. 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 Inherit the SimpleServerControls class with the Control base class. public class SimpleServerControl : Control Override the Render method to write the output to the output stream. protected override void Render(HtmlTextWriter writer) { writer.Write("Hello World from custom control"); } Note The HtmlTextWriter class has the functionality of writing HTML to a text stream. The Write method of the HtmlTextWriter class outputs the specified text to the HTTP response stream and is the same as the Response.Write method. Compile the class library project. It will generate the DLL output. Open an existing or create a new ASP.NET Web application project. Add a Web Forms page where the custom control can be used. Add a reference to the class library in the references section of the ASP.NET project. Register the custom control on the Web Forms page. To instantiate or use the custom control on the Web Forms page, add the following line of code in the tags. Note In this code, SimpleServerControl is the control class name inside the class library. 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: Open any text editor. Create a file named SimpleServerControl.cs, and write the code as given in steps 1 through 14. In the PATH variable, add the following path: c:\windows (winnt)\Microsoft.Net\Framework\v1.1.4322 Start a command prompt, and go to the location where SimpleServerControl.cs is present. Run the following command: csc /t:library /out: CustomServerControlsLib. SimpleServerControl.dll /r:System.dll /r:System.Web.dll SimpleServerControl.cs For more information about the C# compiler (csc.exe), visit the following MSDN Web site: http://msdn2.microsoft.com/en-us/library/1700bbwd(vs.71).aspx (http://msdn2.microsoft.com/en-us/library/1700bbwd(vs.71).aspx) To run the custom control on the Web Forms page, do the following: Create a directory under the wwwroot folder. Start Microsoft Internet Information Services (IIS) Manager, and mark the new directory as the virtual root directory. Create a Bin folder under the new directory. Copy the custom control DLL into the Bin folder. Place the sample Web Forms page that you created in the previous steps inside the new directory. Run the sample page from IIS Manager. Now that you have built a simple custom control, let's look at how to expose properties and apply design-time attributes on that custom control. How to expose properties on the custom control loadTOCNode(3, 'moreinformation'); I will build on the previous example and introduce one or more properties that can be configured while using the custom control on the Web Forms page. The following example shows how to define a property that will display a message from the control a certain number of times, as specified in the property of the control: Open SimpleServerControl.cs in a text editor. Add a property in the SimpleServerControl class. 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 { write.Write("Hello World.."+" "); } } } Compile the custom control. To use the custom control on the Web Forms page, add the new property to the control declaration. Running the page will display the message "Hello world" from the custom control as many times as specified in the property of the control. How to apply design-time attributes on the custom control loadTOCNode(3, 'moreinformation'); Why design-time attributes are needed loadTOCNode(4, 'moreinformation'); The custom control that you built in the previous example works as expected. However, if you want to use that control in Visual Studio, you may want the NoOfTimes property to be automatically highlighted in the Properties window whenever the custom control is selected at design time. To make this happen, you need to provide the metadata information to Visual Studio, which you can do by using a feature in Visual Studio called attributes. Attributes can define a class, a method, a property, or a field. When Visual Studio loads the custom control's class, it checks for any attributes defined at the class, method, property, or field level and changes the behavior of the custom control at design time accordingly. To find more information about attributes, visit the following MSDN Web site: http://msdn2.microsoft.com/en-us/library/Aa288059(VS.71).aspx (http://msdn2.microsoft.com/en-us/library/Aa288059(VS.71).aspx) Let's build a sample that uses commonly used attributes: Open SimpleServerControl.cs in a text editor. Introduce some basic attributes at the class level, for example, DefaultProperty , ToolboxData , and TagPrefixAttrbute . We'll build our sample on these three attributes. [ // 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(" " + " ") ] 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 --> " + DefaultProperty + " "); } } There is one more tag called TagPrefixAttrbute . It is an assembly-level attribute that provides a prefix to a tag when you drag the control from the Toolbox to the designer. Otherwise, the designer generates a prefix such as "cc1" by default. TagPrefixAttrbute is not directly applied to the control class. To apply TagPrefixAttrbute , open AssemblyInfo.cs, include the following line of code, and then rebuild the project. [assembly:TagPrefix("ServerControlsLib ", "MyControl")] Note If you want to build the source using the command line, you need to create the AssemblyInfo.cs file, place the file in the directory that contains all the source files, and run the following command to build the control: > csc /t:library /out: ServerControlsLib.dll /r:System.dll /r :System.Web.dll *.cs Back to the top What are the basic differences between user controls and custom controls? loadTOCNode(2, 'moreinformation'); Now that you have a basic idea of what user controls and custom controls are and how to create them, let's take a quick look at the differences between the two. Collapse this table Expand this table Factors User control Custom control Deployment Designed for single-application scenarios Deployed in the source form (.ascx) along with the source code of the application If the same control needs to be used in more than one application, it introduces redundancy and maintenance problems Designed so that it can be used by more than one application Deployed either in the application's Bin directory or in the global assembly cache Distributed easily and without problems associated with redundancy and maintenance Creation Creation 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 Content A much better choice when you need static content within a fixed layout, for example, when you make headers and footers More 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 Design Writing doesn't require much application designing because they are authored at design time and mostly contain static data Writing 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 Please refer the below link http://support.microsoft.com/kb/893667 Thanks

Senthilkumar · Answer

Hi, he main difference between the two controls lies in ease of creation vs. ease of use at design time. Web user control : 1. Web user controls are easy to make, but they can be less convenient to use. 2. Web user controls are compiled dynamically at run time they cannot be added to the Toolbox 3. the only way to share the user control between applications is to put a separate copy in each application, which takes more maintenance if you make changes to the control 4. If your control has a lot of static layout, a user control might make sense web custom control : 1. Web custom controls are compiled code, which makes them easier to use but more difficult to create. 2. Once you have created the control, however, you can add it to the Toolbox and display it in a visual designer with full Properties window support and all the other design-time features of ASP.NET server controls. In addition, you can install a single copy of the Web custom control in the global assembly cache and share it between applications, which makes maintenance easier. Where to use user control: The user controls needs to added for the every application and has to be registered in the page for use. In the common portion of page has to be created as web user control and it has to be registered. For example, in the web page you may have the header, footer, menus, etc.. This part has to be adapted in the every web page for enforce the commonality and same things can't be done for every page. These parts has to be created as user control. Where to use custom control: Custom controls are created by inheriting its parent control and has to be binded as assembly. It can be either added into the application or GAC. The added custom control needs to be added into the controls. If you have textbox which should accept only numeric or set the background color then you create the custom control. For more info: http://support.microsoft.com/kb/893667 http://steveorr.net/faq/UserCustom.aspx

User and Custom Control

Answers (2)