Basic Controls - Button Controls | Properties - ASP .NET

ASP.NET - Basic Controls:

Button Controls:

The Button control is a commonly used rectangular button. Button controls look like they can be pressed, and have a text label, an icon, or both on their face. You can optionally specify graphic skins for each of several Button states.

You can create a normal Button control or a toggle Button control. A normal Button control stays in its pressed state for as long as the mouse button is down after you select it. A toggle Button controls stays in the pressed state until you select it a second time.

Properties:

CausesValidation :Specifies if a page is validated when a button is clicked 1.0 CommandArgument Specifies additional information about the command to perform 1.0 CommandName Specifies the command associated with the Command event 1.0

  
OnClientClick :  Specifies the name of the function to be executed when a button is clicked 2.0

PostBackUrl :Specifies the URL of the page to post to from the current page when a button is clicked 2.0  

runat : Specifies that the control is a server control.  Must be set to "server" 1.0

Text  : Specifies the text on a button 1.0

UseSubmitBehavior :Specifies whether or not a button uses the browser's submit mechanism or the ASP.NET postback mechanism 2.0

ValidationGroup :Specifies the group of controls a button causes validation, when it posts back to the server

Read More

ASP.Net Application Life Cycle | Page Life Cycle Events | Example - Elearnsite Tutorial

ASP.Net Application Life Cycle:

The application life cycle has the following stages:

·         User makes a request for accessing application resource, a page. Browser sends this request to the web server.

·         A unified pipeline receives the first request and the following events take place:

o    An object of the ApplicationManager class is created.

o    An object of the HostingEnvironment class is created to provide information regarding the resources.

o    Top level items in the application are compiled.

·         Response objects are created . the application objects: HttpContext, HttpRequest and HttpResponse are created and initialized.

·         An instance of the HttpApplication object is created and assigned to the request. The request is processed by the HttpApplication class. Different events are raised by this class for processing the request.

The ASP.NET Page Life Cycle:

Understanding the Page Life Cycle in ASP.NET is essential knowledge for developing ASP.NET apps, without a firm understanding of the Page Life Cycle developing apps will be an uphill battle.
When a web page is sent to the Web Server for processing, it goes through a sequence of steps before it finally gets displayed in the Web Browser. This article discusses these series of steps and events that occur in a page life cycle in ASP.NET.

From The Web Browser to IIS

When a POST request is initiated from the client side, the Web Server traps the request and it is usually routed to an .aspx web page. The request is actually routed to the HTTP Pipeline, a chain of managed objects.
After the HTTP Page handler class is identified, the ProcessRequest () method is called which eventually fires the different page events in the life cycle of a web page. The sequence of events that takes place in the life cycle of a web page in ASP.NET is:

1. Page_Init
2. LoadViewState
3. LoadPostData
4. Page_Load
5. RaisePostDataChangedEvent
6. RaisePostBackEvent
7. Page_PreRender
8. SaveViewState
9. Page_Render
10. Page_UnLoad

All these events are associated with their respective handlers and you can even override them to customize their default behaviour. The following section discusses each of these events in detail.

The Page Life Cycle Events Explained :

Once the request for the web page arrives at the web server, the ASP.NET runtime determines whether the page needs to be parsed or whether a cached version of the page needs to be rendered to the requestor. Then the Request and the Response objects for the page are set and the page life cycle starts.
The Page_Init event is the first event to be triggered in the page life cycle. It is responsible for the initialization activities that are essential to create a page instance. In this phase of the page life cycle, all the server controls of the web page are initialized to their default values. However, it should be noted that the View State for a page is not available at this stage of the page life cycle and a server control of the page cannot access other server controls of the page at this phase.
You can use the Page_Init event to create or re-create the controls that need to be created or re-created dynamically. The following example illustrates how you can override the OnInit() method.

protected override void OnInit(EventArgs e)

 {

if (Page != null)

{

Page.Trace.Write ("The OnInit method has been called");

base.OnInit(e);

Page.RegisterRequiresPostBack(this);

}

}

ASP.Net Page Life Cycle Events:

When the Page is requested for the first time

The Life Cycle of a page when requested for the first time:

Initializing: During this phase, the server creates an instance of the server control

Loading: During this phase, the instance of the control is loaded onto the page object in which it is defined.

PreRendering: During this phase, the control is updated with the changes made to it. This prepares the control for rendering.

Saving: During this phase, the state information of the control is saved. For example, if a value is set for the control during the Load event, it is embedded in the HTML tag that will be returned to the browser.

Rendering: During this phase, the server creates the corresponding HTML tag for the control.

Disposing: During this phase, all cleanup tasks, such as closing files and database connections opened by the control are performed.

Unloading: During this phase, all cleanup tasks, such as destroying the instances of server control are performed. This is the final event in the life cycle of a server control

Life cycle when the page processed during a postback event

The processing sequence in which a page is processed during a postback event is:

Initializing: During this phase, the server creates an instance of the server control

Loading view state: During this phase, the view state of the control posted by the client is reloaded into the new instance of the control.

Loading: During this phase, the instance of the control is loaded onto the page object in which it is defined.

Loading the postback data: During this phase, the server searches any data corresponding to the control that is loaded in the data posted by the client.

PreRendering: During this phase, the control is updated with the changes made to it. This prepares the control for rendering.

Saving state: During this phase, the change in the state of control between the current request and the previous request of the page is saved. For each change, the corresponding event is raised. For example, if the text of a textbox is changed, the new text is saved and a text_change event is raised.

Rendering: During this phase, the server creates the corresponding HTML tag 
for the control.

Disposing: During this phase, all cleanup tasks, such as closing files and database connections opened by the control are performed.

Unloading: During this phase, all cleanup tasks, such as destroying the instances of server control are performed. This is the final event in the life cycle of a server control

The events associated with the relevant page cycle phases are:

• Page Initialization: Page_Init
• View State Loading:LoadViewState
• Postback data processing: LoadPostData
• Page Loading: Page_Load
• PostBack Change Notification: RaisePostDataChangedEvent
• PostBack Event Handling: RaisePostBackEvent
• Page Pre Rendering Phase: Page_PreRender
• View State Saving: SaveViewState
• Page Rendering: Page_Render
• Page Unloading: Page_UnLoad

Asp.net basic examples:

1. <%@ Page Language="C#" AutoEventWireup="true" %>  
2.   
3. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">  
4. <script runat="server">  
5.     protected void Button1_Click(object sender, System.EventArgs e)  
6.     {  
7.         BulletedList1.Style.Add("Padding", "10px 25px 10px 55px");  
8.         BulletedList1.Style.Add("font-family", "Courier New");  
9.         BulletedList1.Style.Add("font-size", "x-large");  
10.         BulletedList1.Style.Add("font-style", "italic");  
11.         BulletedList1.Style.Add("text-decoration", "underline");  
12.         BulletedList1.Style.Add("border", "2px dotted darkred");  
13.         BulletedList1.Style.Add("background-color", "pink");  
14.         BulletedList1.Style.Add("color", "deeppink");  
15.     }  
16. </script>  
17.   
18. <html xmlns="http://www.w3.org/1999/xhtml">  
19. <head id="Head1" runat="server">  
20.     <title>How to create and apply CSS style programmatically in asp.net control</title>  
21. </head>  
22. <body>  
23.     <form id="form1" runat="server">  
24.     <div>  
25.         <h2 style="color:MidnightBlue; font-style:italic;">  
26.             How to create and apply CSS style  
27.             <br /> programmatically in asp.net control  
28.         </h2>  
29.         <hr width="450" align="left" color="SkyBlue"/>  
30.         <asp:BulletedList  
31.              ID="BulletedList1"  
32.              runat="server"  
33.              Width="500"  
34.              BackColor="Crimson"  
35.              ForeColor="Snow"  
36.              >  
37.              <asp:ListItem>Crimson</asp:ListItem>  
38.              <asp:ListItem>MidnightBlue</asp:ListItem>  
39.              <asp:ListItem>CornFlower</asp:ListItem>  
40.              <asp:ListItem>DarkSalmon</asp:ListItem>  
41.              <asp:ListItem>IndianRed</asp:ListItem>  
42.              <asp:ListItem>OliveDrab</asp:ListItem>  
43.         </asp:BulletedList>  
44.         <asp:Button   
45.             ID="Button1"  
46.             runat="server"  
47.             OnClick="Button1_Click"  
48.             Text="Create And Apply CSS Style In BulletedList"  
49.             Height="45"  
50.             Font-Bold="true"  
51.             ForeColor="DarkBlue"  
52.             />  
53.     </div>  
54.     </form>  
55. </body>  
56. </html>  

 

Read More

Asp .Net Tutorial - Introduction | Application Life Cycle | Advantages - Disadvantages | Architecture | ASP.NET Applications and Configuration.

ASP.NET is more than the next version of Active Server Pages (ASP); it provides a unified Web development model that includes the services necessary for developers to build enterprise-class Web applications. While ASP.NET is largely syntax compatible with ASP, it also provides a new programming model and infrastructure for more scalable and stable applications that help provide greater protection. You can feel free to augment your existing ASP applications by incrementally adding ASP.NET functionality to them.

Advantages:

1.  Separation of Code from HTML
   To make a clean sweep, with ASP.NET you have the ability to completely separate layout and business logic. This makes it much easier for teams of programmers and designers to collaborate efficiently. This makes it much easier for teams of programmers and designers to collaborate efficiently.
2. Support for compiled languages
   developer can use VB.NET and access features such as strong typing and object-oriented programming. Using compiled languages also means that ASP.NET pages do not suffer the performance penalties associated with interpreted code. ASP.NET pages are precompiled to byte-code and Just In Time (JIT) compiled when first requested. Subsequent requests are directed to the fully compiled code, which is cached until the source changes.
3. Use services provided by the .NET Framework
   The .NET Framework provides class libraries that can be used by your application. Some of the key classes help you with input/output, access to operating system services, data access, or even debugging. We will go into more detail on some of them in this module.
4. Graphical Development Environment
   Visual Studio .NET provides a very rich development environment for Web
   developers. You can drag and drop controls and set properties the way you do in Visual Basic 6. And you have full IntelliSense support, not only for your code, but also for HTML and XML.
5. State management
   To refer to the problems mentioned before, ASP.NET provides solutions for session and application state management. State information can, for example, be kept in memory or stored in a database. It can be shared across Web farms, and state information can be recovered, even if the server fails or the connection breaks down.
6. Update files while the server is running!
   Components of your application can be updated while the server is online and clients are connected. The Framework will use the new files as soon as they are copied to the application. Removed or old files that are still in use are kept in memory until the clients have finished.
7. XML-Based Configuration Files
   Configuration settings in ASP.NET are stored in XML files that you can easily read and edit. You can also easily copy these to another server, along with the other files that comprise your application.

ASP.Net Application Life Cycle:

The application life cycle has the following stages:

User makes a request for accessing application resource, a page. Browser sends this request to the web server.

A unified pipeline receives the first request and the following events take place:

o    An object of the ApplicationManager class is created.

o    An object of the HostingEnvironment class is created to provide information regarding the resources.

o    Top level items in the application are compiled.

Response objects are created . the application objects: HttpContext, HttpRequest and HttpResponse are created and initialized.

An instance of the HttpApplication object is created and assigned to the request. The request is processed by the HttpApplication class. Different events are raised by this class for processing the request.

Architecture :

            ASP.NET uses ISAPI to run on the Internet Information Server (IIS) in Windows 2000 Server. Not only does IIS host ASP.NET but the ISAPI filter mechanism also allows both ASP and ASP.NET to coexist on the same IIS server. (IIS can direct a *.asp page to ASP and a *.aspx page to ASP.NET.)
The configuration of ASP.NET is managed by information stored in XML-format in a configuration file (Web.Config).
The cache allows for improved performance of ASP.NET, as the most commonly requested pages would be served from the ASP.NET cache.
State management services for ASP.NET are provided by the ASP.NET state service.
The .NET Framework provides the Common Language Runtime (CLR), which compiles and manages the execution of ASP.NET code, and the class libraries, which offer prebuilt programmatic functionality for Web Forms, XML support, and exception handling.
ADO.NET provides ASP.NET with connections to databases.

4)Page Structure:

            Here is quick introduction of syntax used in ASP.NET

Directives

You can use directives to specify optional settings used by the page compiler when processing ASP.NET files. For each directive you can set different attributes. One example is the language directive at the beginning of a page defining the default programming language.

Code Declaration Blocks

Code declaration blocks are lines of code enclosed in <script> tags. They contain the runat=server attribute, which tells ASP.NET that these controls can be accessed on the server and on the client. Optionally you can specify the language for the block. The code block itself consists of the definition of member variables and methods.

Code Render Blocks

Render blocks contain inline code or inline expressions enclosed by the character sequences shown here. The language used inside those blocks could be specified through a directive like the one shown before.

HTML Control Syntax

You can declare several standard HTML elements as HTML server controls. Use the element as you are familiar with in HTML and add the attribute runat=server. This causes the HTML element to be treated as a server control. It is now programmatically accessible by using a unique ID. HTML server controls must reside within a <form> section that also has the attribute runat=server.

Custom Control Syntax

There are two different kinds of custom controls. On the one hand there are the controls that ship with .NET, and on the other hand you can create your own custom controls. Using custom server controls is the best way to encapsulate common programmatic functionality.

Just specify elements as you did with HTML elements, but add a tag prefix, which is an alias for the fully qualified namespace of the control. Again you must include the runat=server attribute. If you want to get programmatic access to the control, just add an Id attribute.

You can include properties for each server control to characterize its behavior. For example, you can set the maximum length of a TextBox. Those properties might have sub properties; you know this principle from HTML. Now you have the ability to specify, for example, the size and type of the font you use (font-size and font-type).

The last attribute is dedicated to event binding. This can be used to bind the control to a specific event. If you implement your own method MyClick, this method will be executed when the corresponding button is clicked if you use the server control event binding shown in the slide.

Data Binding Expression

You can create bindings between server controls and data sources. The data binding expression is enclosed by the character sequences <%# and %>. The data-binding model provided by ASP.NET is hierarchical. That means you can create bindings between server control properties and superior data sources.

Server-side Object Tags

If you need to create an instance of an object on the server, use server-side object tags. When the page is compiled, an instance of the specified object is created. To specify the object use the identifier attribute. You can declare (and instantiate) .NET objects using class as the identifier, and COM objects using either progid or classid.

Server-side Include Directives

With server-side include directives you can include raw contents of a file anywhere in your ASP.NET file. Specify the type of the path to filename with the pathtype attribute. Use either File, when specifying a relative path, or Virtual, when using a full virtual path.

Server-side Comments

To prevent server code from executing, use these character sequences to comment it out. You can comment out full blocks - not just single lines.

ASP.NET Applications and Configuration:

The behavior of an ASP.Net application is affected by different settings in the configuration files:

·         machine.config

·         web.config

The machine.config file contains default and the machine-specific value for all supported settings. The machine settings are controlled by the system administrator and applications are generally not given access to this file.
An application however, can override the default values by creating web.config files in its roots folder. The web.config file is a subset of the machine.config file.
If the application contains child directories, it can define a web.config file for each folder. Scope of each configuration file is determined in a hierarchical top-down manner.
Any web.config file can locally extend, restrict or override any settings defined on the upper level.
Visual Studio generates a default web.config file for each project. An application can run without a web.config file, however, you cannot debug an application without a web.config file.

Read More