Carly Fiorina
Former CEO, HP
Carleton S. (Carly) Fiorina was president and chief executive officer of Hewlett-Packard Company from 1999 to 2005. She served as chairman of the board from 2000 to 2005.
Prior to joining HP, Fiorina spent nearly 20 years at AT&T and Lucent Technologies, where she held a number of senior leadership positions and directed Lucent's initial public offering and subsequent spin-off from AT&T.
Fiorina was named an honorary fellow of the London Business School in July 2001. In 2002, she was honored with the Appeal of Conscience Award, and in 2003 she received the Concern Worldwide "Seeds of Hope" Award in recognition of her worldwide efforts to make global citizenship a priority for business.
The Private Sector Council honored Fiorina with its 2004 Leadership Award for her contributions to improving the business of government. Also in 2004, the White House appointed her to the U.S. Space Commission.
Fiorina has a bachelor's degree in medieval history and philosophy from Stanford University. She holds a master's degree in business administration from the Robert H. Smith School of Business at the University of Maryland at College Park, Md., and a master of science degree from MIT's Sloan School.
Vinod Khosla
Khosla Ventures
Vinod grew up dreaming of being an entrepreneur. He was raised in an Indian Army household with no business or technology connections. When, at age 16, he first heard about Intel, he dreamt of starting his own technology company.
Upon graduating with a Bachelors in Electrical Engineering from the Indian Institute of Technology, Delhi, he tried to start a soy milk company to service the many people in India who did not have refrigerators. He then came to the US and got his Masters in Biomedical Engineering at Carnegie-Mellon University. His startup dreams attracted him to Silicon Valley where he got an MBA at Stanford University in 1980.
In 1982, Khosla started Sun Microsystems to build workstations for software developers. At Sun he pioneered "open systems" and RISC processors. Sun was funded by long time friend and board member John Doerr of Kleiner Perkins Caufield & Byers.
In 1986 he switched sides and joined Kleiner Perkins where he was a general partner. There, he worked with Nexgen/AMD, Juniper, Excite, and many other ventures.
In 2004, Khosla formed Khosla Ventures. Khosla Ventures offers venture assistance, strategic advice and capital to entrepreneurs. The firm helps entrepreneurs extend the potential of their ideas in both traditional venture areas like the Internet, computing, mobile, and silicon technology arenas but also supports breakthrough scientific work in clean technology areas such as bio-refineries for energy and bioplastics, solar, battery and other environmentally friendly technologies.
Marissa Mayer
Google
Marissa leads the product management efforts on Google's search products- web search, images, groups, news, Froogle, the Google Toolbar, Google Desktop, Google Labs, and more. She joined Google in 1999 as Google's first female engineer and led the user interface and webserver teams at that time. Her efforts have included designing and developing Google's search interface, internationalizing the site to more than 100 languages, defining Google News, Gmail, and Orkut, and launching more than 100 features and products on Google.com. Several patents have been filed on her work in artificial intelligence and interface design. In her spare time, Marissa also organizes Google Movies- outings a few times a year to see the latest blockbusters- for 6,000+ people (employees plus family members and friends).
Concurrently with her full-time work at Google, Marissa has taught introductory computer programming classes at Stanford to over 3,000 students. Stanford has recognized her with the Centennial Teaching Award and the Forsythe Award for her outstanding contribution to undergraduate education.
Prior to joining Google, Marissa worked at the UBS research lab (Ubilab) in Zurich, Switzerland and at SRI International in Menlo Park, California.
Graduating with honors, Marissa received her BS in Symbolic Systems and her MS in Computer Science from Stanford University. For both degrees, she specialized in artificial intelligence.
New Opportunities in Search Engine Technology
Anna Patterson is President and Founder of search engine Cuil. Her focus is on scaling architecture, tackling one of the major problems in search-the exponential growth of the Internet. Anna was the architect of Google?s large search index, TeraGoogle, that launched in early 2006. While at Google, Anna was the technical lead of one of the two Web ranking groups at Google, in charge of GoogleBase, and the manager for the core piece of Google's ad-matching technology. She joined Google in 2004 after designing, writing and selling Recall-the largest search engine in existence at the time at 12 billion pages. Anna has a PhD in Computer Science from the University of Illinois at Urbana-Champaign, and was a Research Scientist at Stanford University.
Alec Ross serves as Senior Advisor for Innovation in the Office of Secretary of State Hillary Clinton. In this role, Alec is tasked with maximizing the potential of technology in service of America?s diplomatic and development goals.
Prior to his service at the State Department, Ross worked on the Obama-Biden Presidential Transition Team and served as Convener for Obama for America's Technology, Media & Telecommunications Policy Committee.
This lesson was selected from a broader, comprehensive course, Public Speaking. This course and others are available from Thinkwell, Inc. The full course can be found at http://www.thinkwell.com/student/product/publicspeaking. The full course covers getting started, preparing a speech, presenting the speech, audience considerations, types of speeches, small group communication, and more. The course features three renowned professors: Jess K. Alberts of Arizona State University, Brenda J, Allen of the University of Colorado at Denver, and Dan West of Ohio State University.
Jess K. Alberts is a professor of communication at the Hugh Downs School of Human Communication at Arizona State University, where she was Director from 1995 until 2004. She currently serves as Director of the Conflict Transformation Project and is an associate with Project for Wellness and Work-life. Her research appears regularly in academic journals, and she recently co-authored Human Communication in Society. Undergraduates at Arizona State honored her classroom teaching skills with a "Last Lecture Award," and she has twice been a finalist for Professor of the Year at ASU. A nationally known speaker on interpersonal communication, Prof. Alberts has given numerous presentations across the country on humor, conflict, and developing and maintaining a passionate life.
Brenda J. Allen is departmental chair and a professor of communication at the University of Colorado at Denver and Health Sciences Center, where she teaches organizational communication. She has published numerous articles and book chapters on organizational communication and diversity and she serves on the editorial boards of several communication journals. In 2004, she authored the book Difference Matters: Communicating Social Identity. While at the University of Colorado at Denver and Health Sciences Center, she has been recognized with the First Annual Award for Outstanding Achievement for Commitment to Diversity and she received the Francine Meritt Award for Outstanding Contributions to the Lives of Women in Communication from the Womens Caucus of the National Communication Association. Prof. Allen is frequently invited to speak at community and professional events.
Dan West is the John A. Cassese Director of Forensics at Ohio University. Previously, he was a distinguished lecturer at Rice University, where he also acted as Director of Forensics. Under his direction, the team consistently placed in the top ten at national debate tournaments. While at Rice, Prof. West won the Outstanding Faculty Associate for Brown College (1999) and the award for Outstanding Teaching in the Humanities and Social Sciences (four times). He is well known for using his engaging speaking style in a variety of settings; his annual presentation of the Rice University Alcohol Policy to the freshman class was always a hit.
Www.kwikvid.com Social Media networking sites are more popular than ever today. In the UK, there are bigger budgets in online advertising than TV or Radio. Your clients and prospects communicate, socialise and network increasingly online. Marketing in forums, social networking and social bookmarking websites can be more difficult than it seems. This social media marketing tutorial from Kent video marketing agency Kersh Media KWIKVID, will give you the skills and confidence to get your company up and running with social media marketing. Traditional marketing and advertising rules apply less and less in the online social media space. This online guide to social media marketing will help you make the most of networks such as Facebook, Linkedin, Youtube, Stumbleupon, Twitter, Flickr, Bebo and many others. Social media sites are among the most popular places to visit online. From social networks like Facebook, to social bookmarking sites like Delicious, to social news sites like Digg, there are many ways a marketer can learn to participate in meaningful ways. We offer Social Media Marketing Training Packages to show you how to use Facebook to market your business. Using Facebook for Marketing is one of the fastest growing forms of marketing. In this tutorial we cover topics including Facebook advertising Kent, how to use Facebook to market your business, Facebook page for Business, Twitter marketing and marketing through Facebook. Our Social Media Marketing tutorial will show you how to use Facebook to market your business and generate new sales leads and enquiries. Using Facebook for business is an effective Social Media Marketing tool which allows you to engage and interact with your audiences in a social yet professional way. Marketing through Facebook means you can upload videos, photos and content and regularly keep your audiences up-to-date with the latest news from your business. Our Social Media Marketing tutorial will show you how to create a Facebook page for business. Social Media marketing is delivering impressive results and we can show you how to make the most of Facebook marketing for your business. If you would like some more information about our Social Media Marketing and Video Marketing Training Packages please contact us today
Web pages rarely be stand alone. Web applications almost always need to track users who visits multiple pages, whether to provide personalization, store information about a user or to track usage for reporting purposes.
Purpose
State management is the process by which you maintain state and page information over multiple requests for the same or different pages.
Types of State Management
There are 2 types State Management:
1. Client � Side State Management
This stores information on the client's computer by embedding the information into a Web page, a uniform resource locator(url), or a cookie. The techniques available to store the state information at the client end are listed down below:
a. View State � Asp.Net uses View State to track the values in the Controls. You can add custom values to the view state. It is used by the Asp.net page framework to automatically save the values of the page and of each control just prior to rendering to the page. When the page is posted, one of the first tasks performed by page processing is to restore view state.
b. Control State � If you create a custom control that requires view state to work properly, you should use control state to ensure other developers don�t break your control by disabling view state.
c. Hidden fields � Like view state, hidden fields store data in an HTML form without displaying it in the user's browser. The data is available only when the form is processed.
d. Cookies � Cookies store a value in the user's browser that the browser sends with every page request to the same server. Cookies are the best way to store state data that must be available for multiple Web pages on a web site.
e. Query Strings - Query strings store values in the URL that are visible to the user. Use query strings when you want a user to be able to e-mail or instant message state data with a URL.
2. Server � Side State Management
a. Application State - Application State information is available to all pages, regardless of which user requests a page.
b. Session State � Session State information is available to all pages opened by a user during a single visit.
Both application state and session state information is lost when the application restarts. To persist user data between application restarts, you can store it using profile properties.
Implementation Procedure
Client � Side State Management:
View State:
The ViewState property provides a dictionary object for retaining values between multiple requests for the same page. When an ASP.NET page is processed, the current state of the page and controls is hashed into a string and saved in the page as a hidden field. If the data is too long for a single field, then ASP.NET performs view state chunking (new in ASP.NET 2.0) to split it across multiple hidden fields. The following code sample demonstrates how view state adds data as a hidden form within a Web page�s HTML:
Encrypting of the View State: You can enable view state encryption to make it more difficult for attackers and malicious users to directly read view state information. Though this adds processing overhead to the Web server, it supports in storing confidential information in view state. To configure view state encryption for an application does the following:
Alternatively, you can enable view state encryption for a specific page by setting the value in the page directive, as the following sample demonstrates:
<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" ViewStateEncryptionMode="Always"%>
View State is enabled by default, but if you can disable it by setting the EnableViewState property for each web control to false. This reduces the server processing time and decreases page size.
Reading and Writing Custom View State Data:
If you have a value that you�d like to keep track of while the user is visiting a single ASP.NET Web page, adding a custom value to ViewState is the most efficient and secure way to do that. However, ViewState is lost if the user visits a different Web page, so it is useful only for temporarily storing values.
Example: Determine the time of last visit to the page
// Check if View State object exists, and display it if it does
If (ViewState ["lastVisit"]!= null)
Label1.Text = (string)ViewState["lastVisit"]; else
Label1.Text = "lastVisit ViewState not defined.";
// Define the ViewState object for the next page view ViewState.Add("lastVisit", DateTime.Now.ToString());
Control State: If you create a custom control that requires ViewState, you can use the ControlState property to store state information for your control. ControlState allows you to persist property information that is specific to a control and cannot be turned off like the ViewState property. To use control state in a custom control, your control must override the OnInit method and call the Register-RequiresControlState method during initialization and then override the SaveControl-State and LoadControlState methods.
Hidden fields: ViewState stores information in the Web page using hidden fields. Hidden fields are sent back to the server when the user submits a form; however, the information is never displayed by the Web browser (unless the user chooses to view the page source). ASP.NET allows you to create your own custom hidden fields and store values that are submitted with other form data. A HiddenField control stores a single variable in its Value property and must be explicitly added to the page. You can use hidden fields only to store information for a single page, so it is not useful for storing session data. If you use hidden fields, you must submit your pages to the server using Hypertext Transfer Protocol (HTTP) POST (which happens if the user presses a button) rather than requesting the page using HTTP GET (which happens if the user clicks a link). Unlike view state data, hidden fields have no built-in compression, encryption, hashing, or chunking, so users can view or modify data stored in hidden fields.
Cookies: Web applications can store small pieces of data in the client�s Web browser by using cookies. A cookie is a small amount of data that is stored either in a text file on the client file system (if the cookie is persistent) or in memory in the client browser session (if the cookie is temporary). The most common use of cookies is to identify a single user as he or she visits multiple Web pages.
Reading and Writing Cookies:
A Web application creates a cookie by sending it to the client as a header in an HTTP response. The Web browser then submits the same cookie to the server with every new request.
Create a cookie -> add a value to the Response.Cookies HttpCookieCollection.
Read a cookie -> read values in Request.Cookies.
Example:
// Check if cookie exists, and display it if it does
if (Request.Cookies["lastVisit"] != null) // Encode the cookie in case the cookie contains client-side script Label1.Text = Server.HtmlEncode(Request.Cookies["lastVisit"].Value);
else Label1.Text = "No value defined";
// Define the cookie for the next visit Response.Cookies["lastVisit"].Value = DateTime.Now.ToString();Response.Cookies["lastVisit"].Expires = DateTime.Now.AddDays(1);
If you do not define the Expires property, the browser stores it in memory and the cookie is lost if the user closes his or her browser.
To delete a cookie, overwrite the cookie and set an expiration date in the past. You can�t directly delete cookies because they are stored on the client�s computer.
Controlling the Cookie Scope: By default, browsers won�t send a cookie to a Web site with a different hostname. You can control a cookie�s scope to either limit the scope to a specific folder on the Web server or expand the scope to any server in a domain. To limit the scope of a cookie to a folder, set the Path property, as the following example demonstrates:
Example:
Response.Cookies["lastVisit"].Path = "/Application1";
Through this the scope is limited to the �/Application1� folder that is the browser submits the cookie to any page with in this folder and not to pages in other folders even if the folder is in the same server. We can expand the scope to a particular domain using the following statement:
Example:
Response.Cookies[�lastVisit�].Domain = �Contoso�;
Storing Multiple Values in a Cookie:
Though it depends on the browser, you typically can�t store more than 20 cookies per site, and each cookie can be a maximum of 4 KB in length. To work around the 20-cookie limit, you can store multiple values in a cookie, as the following code demonstrates:
Example:
Response.Cookies["info"]["visit"].Value = DateTime.Now.ToString();
Response.Cookies["info"]["firstName"].Value = "Tony";
Response.Cookies["info"]["border"].Value = "blue";
Response.Cookies["info"].Expires = DateTime.Now.AddDays(1);
Running the code in this example sends a cookie with the following value to the Web browser:
(visit=4/5/2006 2:35:18 PM) (firstName=Tony) (border=blue)
Query Strings: Query strings are commonly used to store variables that identify specific pages, such as search terms or page numbers. A query string is information that is appended to the end of a page URL. A typical query string might look like the following real-world example:
http://support.microsoft.com/Default.aspx?kbid=315233
In this example, the URL identifies the Default.aspx page. The query string (which starts with a question mark [?]) contains a single parameter named �kbid,� and a value for that parameter, �315233.� Query strings can also have multiple parameters, such as the following real-world URL, which specifies a language and query when searching the Microsoft.com Web site:
http://search.microsoft.com/results.aspx?mkt=en-US&setlang=en-US&q=hello+world
Value Name | ASP.NET Object | Value
mkt | Request.QueryString[�mkt�] | en-US
setlang | Request.QueryString[�setlang�] | en-US
q | Request.QueryString[�q�] | hello world
Limitations for Query Strings:
1. Some Browsers and client devices impose a 2083 � character limit on the length of the URL.
2. You must submit the page using an HTTP GET command in order for query string values to be available during page processing. Therefore, you shouldn�t add query strings to button targets in forms.
3. You must manually add query string values to every hyperlink that the user might click.
Example:
Label1.Text = "User: " + Server.HtmlEncode(Request.QueryString["user"]) +
", Prefs: " + Server.HtmlEncode(Request.QueryString["prefs"]) +
", Page: " + Server.HtmlEncode(Request.QueryString["page"]);
Server - Side State Management:
Application State: ASP.NET allows you to save values using application state, a global storage mechanism that is accessible from all pages in the Web application. Application state is stored in the Application key/value dictionary. Once you add your application-specific information to application state, the server manages it, and it is never exposed to the client. Application state is a great place to store information that is not user-specific. By storing it in the application state, all pages can access data from a single location in memory, rather than keeping separate copies of the data. Data stored in the Application object is not permanent and is lost any time the application is restarted.
ASP.NET provides three events that enable you to initialize Application variables (free resources when the application shuts down) and respond to Application errors:
a. Application_Start: Raised when the application starts. This is the perfect place to initialize Application variables.
b. Application_End: Raised when an application shuts down. Use this to free application resources and perform logging.
c. Application_Error: Raised when an unhandled error occurs. Use this to perform error logging.
Session State: ASP.NET allows you to save values using session state, a storage mechanism that is accessible from all pages requested by a single Web browser session. Therefore, you can use session state to store user-specific information. Session state is similar to application state, except that it is scoped to the current browser session. If different users are using your application, each user session has a different session state. In addition, if a user leaves your application and then returns later after the session timeout period, session state information is lost and a new session is created for the user. Session state is stored in the Session key/value dictionary.
You can use session state to accomplish the following tasks:
i. Uniquely identify browser or client-device requests and map them to individual session instances on the server. This allows you to track which pages a user saw on your site during a specific visit.
ii. Store session-specific data on the server for use across multiple browser or client-device requests during the same session. This is perfect for storing shopping cart information.
iii. Raise appropriate session management events. In addition, you can write application code leveraging these events.
ASP.NET session state supports several different storage options for session data:
a. InProc Stores session state in memory on the Web server. This is the default, and it offers much better performance than using the ASP.NET state service or storing state information in a database server. InProc is fine for simple applications, but robust applications that use multiple Web servers or must persist session data between application restarts should use State Server or SQLServer.
b. StateServer Stores session state in a service called the ASP.NET State Service. This ensures that session state is preserved if the Web application is restarted and also makes session state available to multiple Web servers in a Web farm. ASP.NET State Service is included with any computer set up to run ASP.NET Web applications; however, the service is set up to start manually by default. Therefore, when configuring the ASP.NET State Service, you must set the startup type to Automatic.
c. SQLServer Stores session state in a SQL Server database. This ensures that session state is preserved if the Web application is restarted and also makes session state available to multiple Web servers in a Web farm. On the same hardware, the ASP.NET State Service outperforms SQLServer. However, a SQL Server database offers more robust data integrity and reporting capabilities.
d. Custom Enables you to specify a custom storage provider. You also need to implement the custom storage provider.
e. Off Disables session state. You should disable session state if you are not using it to improve performance.
Advantages
Advantages of Client � Side State Management:
1. Better Scalability: With server-side state management, each client that connects to the Web server consumes memory on the Web server. If a Web site has hundreds or thousands of simultaneous users, the memory consumed by storing state management information can become a limiting factor. Pushing this burden to the clients removes that potential bottleneck.
2. Supports multiple Web servers: With client-side state management, you can distribute incoming requests across multiple Web servers with no changes to your application because the client provides all the information the Web server needs to process the request. With server-side state management, if a client switches servers in the middle of the session, the new server does not necessarily have access to the client�s state information. You can use multiple servers with server-side state management, but you need either intelligent load-balancing (to always forward requests from a client to the same server) or centralized state management (where state is stored in a central database that all Web servers access).
Advantages of Server � Side State Management:
1. Better security: Client-side state management information can be captured (either in transit or while it is stored on the client) or maliciously modified. Therefore, you should never use client-side state management to store confidential information, such as a password, authorization level, or authentication status.
2. Reduced bandwidth: If you store large amounts of state management information, sending that information back and forth to the client can increase bandwidth utilization and page load times, potentially increasing your costs and reducing scalability. The increased bandwidth usage affects mobile clients most of all, because they often have very slow connections. Instead, you should store large amounts of state management data (say, more than 1 KB) on the server.
When an ASP.NET page runs, the page goes through a life cycle in which it performs a series of processing steps. These include initialization, instantiating controls, restoring and maintaining state, running event handler code, and rendering. It is important for you to understand the page life cycle so that you can write code at the appropriate life-cycle stage for the effect you intend.
If you develop custom controls, you must be familiar with the page life cycle in order to correctly initialize controls, populate control properties with view-state data, and run control behavior code. The life cycle of a control is based on the page life cycle, and the page raises many of the events that you need to handle in a custom control
In general terms, the page goes through the stages outlined in the following table. In addition to the page life-cycle stages, there are application stages that occur before and after a request but are not specific to a page. For more information, see Introduction to the ASP.NET Application Life Cycle and ASP.NET Application Life Cycle Overview for IIS 7.0.
Some parts of the life cycle occur only when a page is processed as a postback. For postbacks, the page life cycle is the same during a partial-page postback (as when you use an UpdatePanel control) as it is during a full-page postback.
n general terms, the page goes through the stages outlined in the following table. In addition to the page life-cycle stages, there are application stages that occur before and after a request but are not specific to a page. For more information, see Introduction to the ASP.NET Application Life Cycle and ASP.NET Application Life Cycle Overview for IIS 7.0.
Some parts of the life cycle occur only when a page is processed as a postback. For postbacks, the page life cycle is the same during a partial-page postback (as when you use an UpdatePanel control) as it is during a full-page postback.
Stage Description
Page request The page request occurs before the page life cycle begins. When the page is requested by a user, ASP.NET determines whether the page needs to be parsed and compiled (therefore beginning the life of a page), or whether a cached version of the page can be sent in response without running the page.
Start In the start stage, page properties such as Request and Response are set. At this stage, the page also determines whether the request is a postback or a new request and sets the IsPostBack property. The page also sets the UICulture property.
Initialization During page initialization, controls on the page are available and each control's UniqueID property is set. A master page and themes are also applied to the page if applicable. If the current request is a postback, the postback data has not yet been loaded and control property values have not been restored to the values from view state.
Load During load, if the current request is a postback, control properties are loaded with information recovered from view state and control state.
Postback event handling If the request is a postback, control event handlers are called. After that, the Validate method of all validator controls is called, which sets the IsValid property of individual validator controls and of the page. (There is an exception to this sequence: the handler for the event that caused validation is called after validation.)
Rendering Before rendering, view state is saved for the page and all controls. During the rendering stage, the page calls the Render method for each control, providing a text writer that writes its output to the OutputStream object of the page's Response property.
Unload The Unload event is raised after the page has been fully rendered, sent to the client, and is ready to be discarded. At this point, page properties such as Response and Request are unloaded and cleanup is performed.
Life-Cycle Events
________________________________________
Within each stage of the life cycle of a page, the page raises events that you can handle to run your own code. For control events, you bind the event handler to the event, either declaratively using attributes such as onclick, or in code.
Pages also support automatic event wire-up, meaning that ASP.NET looks for methods with particular names and automatically runs those methods when certain events are raised. If the AutoEventWireup attribute of the @ Page directive is set to true, page events are automatically bound to methods that use the naming convention of Page_event, such as Page_Load and Page_Init. For more information on automatic event wire-up, see ASP.NET Web Server Control Event Model.
The following table lists the page life-cycle events that you will use most frequently. There are more events than those listed; however, they are not used for most page-processing scenarios. Instead, they are primarily used by server controls on the ASP.NET Web page to initialize and render themselves. If you want to write custom ASP.NET server controls, you need to understand more about these events. For information about creating custom controls, see Developing Custom ASP.NET Server Controls.
Page Event Typical Use
PreInit
Raised after the start stage is complete and before the initialization stage begins.
Use this event for the following:
� Check the IsPostBack property to determine whether this is the first time the page is being processed. The IsCallback and IsCrossPagePostBack properties have also been set at this time.
� Create or re-create dynamic controls.
� Set a master page dynamically.
� Set the Theme property dynamically.
� Read or set profile property values.
Note
If the request is a postback, the values of the controls have not yet been restored from view state. If you set a control property at this stage, its value might be overwritten in the next event.
Init
Raised after all controls have been initialized and any skin settings have been applied. The Init event of individual controls occurs before the Init event of the page.
Use this event to read or initialize control properties.
InitComplete
Raised at the end of the page's initialization stage. Only one operation takes place between the Init and InitComplete events: tracking of view state changes is turned on. View state tracking enables controls to persist any values that are programmatically added to the ViewState collection. Until view state tracking is turned on, any values added to view state are lost across postbacks. Controls typically turn on view state tracking immediately after they raise their Init event.
Use this event to make changes to view state that you want to make sure are persisted after the next postback.
PreLoad
Raised after the page loads view state for itself and all controls, and after it processes postback data that is included with the Request instance.
Load
The Page object calls the OnLoad method on the Page object, and then recursively does the same for each child control until the page and all controls are loaded. The Load event of individual controls occurs after the Load event of the page.
Use the OnLoad event method to set properties in controls and to establish database connections.
Control events Use these events to handle specific control events, such as a Button control's Click event or a TextBox control's TextChanged event.
Note
In a postback request, if the page contains validator controls, check the IsValid property of the Page and of individual validation controls before performing any processing.
LoadComplete
Raised at the end of the event-handling stage.
Use this event for tasks that require that all other controls on the page be loaded.
PreRender
Raised after the Page object has created all controls that are required in order to render the page, including child controls of composite controls. (To do this, the Page object calls EnsureChildControls for each control and for the page.)
The Page object raises the PreRender event on the Page object, and then recursively does the same for each child control. The PreRender event of individual controls occurs after the PreRender event of the page.
Use the event to make final changes to the contents of the page or its controls before the rendering stage begins.
PreRenderComplete
Raised after each data bound control whose DataSourceID property is set calls its DataBind method. For more information, see Data Binding Events for Data-Bound Controls later in this topic.
SaveStateComplete
Raised after view state and control state have been saved for the page and for all controls. Any changes to the page or controls at this point affect rendering, but the changes will not be retrieved on the next postback.
Render
This is not an event; instead, at this stage of processing, the Page object calls this method on each control. All ASP.NET Web server controls have a Render method that writes out the control's markup to send to the browser.
If you create a custom control, you typically override this method to output the control's markup. However, if your custom control incorporates only standard ASP.NET Web server controls and no custom markup, you do not need to override the Render method. For more information, see Developing Custom ASP.NET Server Controls.
A user control (an .ascx file) automatically incorporates rendering, so you do not need to explicitly render the control in code.
Unload
Raised for each control and then for the page.
In controls, use this event to do final cleanup for specific controls, such as closing control-specific database connections.
For the page itself, use this event to do final cleanup work, such as closing open files and database connections, or finishing up logging or other request-specific tasks.
Note
During the unload stage, the page and its controls have been rendered, so you cannot make further changes to the response stream. If you attempt to call a method such as the Response.Write method, the page will throw an exception.
Additional Page Life Cycle Considerations
Individual ASP.NET server controls have their own life cycle that is similar to the page life cycle. For example, a control's Init and Load events occur during the corresponding page events.
Although both Init and Load recursively occur on each control, they happen in reverse order. The Init event (and also the Unload event) for each child control occur before the corresponding event is raised for its container (bottom-up). However the Load event for a container occurs before the Load events for its child controls (top-down). Master pages behave like child controls on a page: the master page Init event occurs before the page Init and Load events, and the master page Load event occurs after the page Init and Load events.
When you create a class that inherits from the Page class, in addition to handling events raised by the page, you can override methods from the page's base class. For example, you can override the page's InitializeCulture method to dynamically set culture information. Note that when an event handler is created using the Page_event syntax, the base implementation is implicitly called and therefore you do not need to call it in your method. For example, the base page class's OnLoad method is always called, whether you create a Page_Load method or not. However, if you override the page OnLoad method with the override keyword (Overrides in Visual Basic), you must explicitly call the base method. For example, if you override the OnLoad method on the page, you must call base.Load (MyBase.Load in Visual Basic) in order for the base implementation to be run.
The following illustration shows some of the most important methods of the Page class that you can override in order to add code that executes at specific points in the page life cycle. (For a complete list of page methods and events, see the Page class.) The illustration also shows how these methods relate to page events and to control events. The sequence of methods and events in the illustration is from t
Mark Suster is a serial entrepreneur who grew up in Northern California.
After graduating from UCSD (economics) and University of Chicago (MBA), he joined Andersen Consulting (now Accenture) in Los Angeles to build computer systems for large corporations. There, he focused mostly on computer networking but had stints with programming, database design, system modeling, and testing.
In 1994 he transferred within Accenture to their technology center of excellence in Sophia Antipolis, France, where he traveled extensively throughout Europe.
Suster started his first company in 1999 while headquartered in London - a SaaS platform for large-scale engineering and construction projects including the London Underground, Thames Water, BNP Paribas, and all of the top German construction firms. The company grew to have offices in seven countries before it was sold in 2005..
He then launched his second company, Koral, in San Mateo, California, which l...
While many legendary Silicon Valley companies were founded by teams of two, partnerships aren't without their problems, states venture capitalist Mark Suster. Disagreements arise based on personal life changes, business strategies, and roles within the company. Suster prefers to avoid playing the role of co-founder "marriage counselor" by working with a strong, individual entrepreneur.
Co-founder
While many legendary Silicon Valley companies were founded by teams of two, partnerships aren't without their problems, states venture capitalist Mark Suster. Disagreements arise based on personal life changes, business strategies, and roles within the company. Suster prefers to avoid playing the role of co-founder "marriage counselor" by working with a strong, individual entrepreneur.
Courtesy : Stanford
