Know about ASP.NET

ASP.NET is an open-source server-side web request framework designed for web progress to manufacture active web pages. It was developed by Microsoft to allow programmers to construct dynamic web sites, web applications and web services. It was first at large in January 2002 with 

version 1.0 of the .NET Framework, and is the descendant to Microsoft's Active Server Pages (ASP) technology. ASP.NET is built on the Common Language Runtime (CLR), allow programmers to put pen to paper ASP.NET code by means of every supported .NET language. The ASP.NET SOAP addition framework allows ASP.NET components to process SOAP messages. ASP.NET's successor is ASP.NET Core. It is a re-implementation of ASP.NET as a modular web framework, together with other frameworks like Entity Framework. The latest framework uses the new open-source .NET Compiler Platform (codename "Roslyn") and is cross platform. ASP.NET MVC, ASP.NET Web API, and ASP.NET Web Pages (a platform using only Razor pages) have complex into a unified MVC 6.

Behind four years of development, and a series of beta releases in 2000 and 2001, ASP.NET 1.0 was released on January 5, 2002 as division of version 1.0 of the .NET Framework. Even prior to the free, dozens of books had been written about ASP.NET, and Microsoft promoted it a lot as part of its platform for Web services. Scott Guthrie became the produce unit manager for ASP.NET and development constant apace, with version 1.1 being released on April 24, 2003 as a part of Windows Server 2003. ASP.NET is anxiously based on HTML. This free focused on improving ASP.NET's maintain for mobile devices. ASP.NET Web pages, recognized formally as Web Forms, are the main building blocks for application development in ASP.NET. There are two essential methodologies for Web Forms, a web application arrangement and a web site format. Web applications need to be compiled before deployment, while web sites structures permit the user to copy the files straight to the server without previous collection. Web forms are controlled in files with a ".aspx" extension;

 

 these files classically contain static (X)HTML markup or constituent markup. The constituent markup can include server-side Web Controls and User Controls that have been definite in the framework or the web page. For example, a textbox component can be defined on a page as <asp:textbox id='myid' runat='server'>, which is rendered into a html contribution box. Moreover, dynamic code, which runs on the server, can be placed in a page within a block <% -- dynamic code -- %>, which is alike to other Web development technologies such as PHP, JSP, and ASP. With ASP.NET Framework 2.0, Microsoft introduced a latest code-behind model that lets inert text stay on the .aspx page, while active code remains in an .aspx.vb or .aspx.cs or .aspx.fs file (depending on the programming language used). Microsoft recommends commerce with active program code by using the code-behind mock-up, which seats this code in a divide file or in a particularly designated script tag. Code-behind files classically have names like MyPage.aspx.cs or MyPage.aspx.vb while the page file is MyPage.aspx (same filename as the page file (ASPX), but with the final extension denoting the page language). This carry out is automatic in Visual Studio and other IDEs on the other hand the user can modify the code-behind page. Also, in the web application format, the pagename.aspx.cs is a incomplete class that is linked to the pagename.designer.cs file. The designer file is a file that is auto generated from the aspx page that allows the programmer to position workings in the aspx page from the cs page without having to announce them physically as in versions prior to ASP.Net version 2. When using this style of programming, the developer writes code to counter to dissimilar events, like the page being loaded, or a manage being clicked, rather than a technical walkthrough of the document. ASP.NET's code-behind model marks a going away from Classic ASP in that it encourages developers to construct applications with division of arrangement and satisfied in mind. In theory, this would allow a Web designer, for example, to focus on the design markup with less potential for disturbing the programming code that drives it. This is similar to the separation of the controller from the view in model–view–organizer (MVC) frameworks. .NET uses a "visited composites" depiction method. During collection, the template (.aspx) file is compiled into initialization code that builds a control tree (the composite) in lieu of the unique template. Literal text 

goes into instance of the Literal organize class, and server controls are represented by instances of a explicit control class. The initialization code is collective with user-written code (usually by the assembly of numerous partial classes) and consequences in a class definite for the page. The page doubles as the root of the manage tree. Genuine requirements for the page are processed through a number of steps. First, during the initialization steps, an example of the page class is shaped and the initialization code is executed. This produces the initial manage tree, which is now classically manipulated by the systems of the page in the next steps. As every node in the tree is a manage represented as an example of a class, the code may modify the tree arrangement as well as control the properties/methods of the person nodes. Finally, through the depiction step a visitor is used to visit each node in the tree, asking every node to turn into it using the methods of the visitor. The resulting HTML production is sent to the consumer. After the request has been processed, the example of the page class is surplus and with it the entire control tree. This is a basis of confusion amongst novice ASP.NET programmers who rely on the class instance members that are mislaid with every page demand/response cycle. ASP.NET applications are hosted by a Web server and are accessed by means of the stateless  HTTP protocol. As such, if an application uses stateful interaction, it has to apply state organization on it’s possess. ASP.NET provides a variety of functions for state management. Theoretically, Microsoft treats "state" as GUI state. Problems may arise if an application must track "data state"; for instance, a finite-state engine that may be in a fleeting state between requirements (lazy evaluation) or takes a long time to initialize. State organization in ASP.NET pages with confirmation can make Web scraping hard or unfeasible. Application state is held by a compilation of shared user-defined variables. These are set and initialized when the Application_OnStart happening fires on the loading of the first example of the application and are available until the last example exits. Application state variables are accessed using the Applications collection, which provides a wrapper for the application situation. Application condition variables are identified by name. 

Application is state organization. Server-side assembly state is detained by a collection of user-defined assembly variables that are persistent throughout a user meeting. These variables, accessed using the Session compilation, are exclusive to each session occurrence. The variables can be set to be robotically destroyed after a distinct time of idleness even if the session does not finish. Client-side user session is maintained by neither a cookie nor by encoding the session ID in the URL itself.  ASP.NET supports three modes of persistence for server-side session variables:  The session variables are maintained inside the ASP.NET method. This is the best way; though, in this mode the variables are shattered when the ASP.NET method is recycled or shut down. ASP.NET runs a divide Windows service that maintains the situation variables. Because state organization happens exterior the ASP.NET process, and because the ASP.NET engine accesses data using .NET Remoting, ASPState is slower than In-System. This mode permits an ASP.NET application to be load-balanced and scaled crosswise manifold servers. Because the state organization service runs separately of ASP.NET, the session variables can keep it up across ASP.NET method shutdowns. Though, since session state server runs as one instance, it is still one point of crash for session state. The session-state service cannot be load-balanced, and there are limitations on types that can be stored in a session variable.

State variables are stored in a database, allowing assembly variables to be persisted crosswise ASP.NET method shutdowns. The major benefit of this mode is that it allows the application to balance load on a server cluster, sharing sessions between servers. This is the slowest system of session state management in ASP.NET. ASP.NET session state enables you to accumulate and get back values for a user as the user navigates ASP.NET pages in a Web application. HTTP is a stateless procedure. This means that a Web server treats every HTTP request for a page as a free request. The server retains no information of variable values that were used throughout earlier requests. ASP.NET session state identifies requests from the similar browser during a partial time window as a session, and provides a way to continue variable values for the period of that session. By default, ASP.NET session state is enabled for all ASP.NET applications. Application state, which provisions variables that can be accessed by everyone users of an ASP.NET application. Profile properties, which persists user values in a data amass with no dying them. ASP.NET caching, which stores values in memory that is obtainable to all ASP.NET applications. View state refers to the page-level state organization mechanism, utilized by the HTML pages emitted by ASP.NET applications to uphold the state of the 

 

Web form reins and widgets. The state of the reins is encoded and sent to the server at each form obedience in a concealed field known as __VIEWSTATE. The server sends reverse the variable so that, when the page is re-rendered, the controls cause to be at their last state. At the server side, the application may alter the view state, if the dispensation requires alter of state of any manage. The states of person controls are decoded at the server, and are obtainable for use in ASP.NET pages using the View State collection. The major use for this is to protect form information crosswise postbacks. View state is curved on by defaulting and usually serializes the data in each manage on the page in spite of whether it is in fact used during a postback. This behavior can be customized, though, as View state can be disabled on a per-control, per-page, or server-wide basis. Developers require being cautious of storing sensitive or confidential information in the View state of a page or control, as the base64 string containing the view state data can with no trouble be de-serialized. By defaulting, View state does not encrypt the __VIEWSTATE value. Encryption can be enabled on a server-wide (and server-specific) foundation, allowing for a sure level of security to be maintained. ASP.NET offers a "Cache" object that is common crosswise the application and can also be used to store different objects. The "Cache" object holds the data merely for a specific amount of time and is mechanically cleaned after the session time-limit elapses. Other resources of state organization that are supported by ASP.NET are cookies, caching, and using the query string.