ASP.

NET is a web application framework developed and marketed by Microsoft to

allow programmers to build dynamic web sites, web applications and web services. It was first
released in January 2002 with version 1.0 of the .NET Framework, and is the successor to
Microsoft's Active Server Pages (ASP) technology. ASP.NET is built on the Common Language
Runtime (CLR), allowing programmers to write ASP.NET code using any supported .NET
language. The ASP.NET SOAP extension framework allows ASP.NET components to process
SOAP messages.

History

After the release of Internet Information Services 4.0 in 1997, Microsoft began
researching possibilities for a new web application model that would solve common complaints
about ASP, especially with regard to separation of presentation and content and being able to
write "clean" code.[1] Mark Anders, a manager on the IIS team, and Scott Guthrie, who had
joined Microsoft in 1997 after graduating from Duke University, were tasked with determining
what that model would look like. The initial design was developed over the course of two
months by Anders and Guthrie, and Guthrie coded the initial prototypes during the Christmas
holidays in 1997.[2]

The initial prototype was called "XSP"; Guthrie explained in a 2007 interview that,
"People would always ask what the X stood for. At the time it really didn't stand for anything.
XML started with that; XSLT started with that. Everything cool seemed to start with an X, so
that's what we originally named it."[1] The initial prototype of XSP was done using Java,[3] but it
was soon decided to build the new platform on top of the Common Language Runtime (CLR), as
it offered an object-oriented programming environment, garbage collection and other features
that were seen as desirable features that Microsoft's Component Object Model platform didn't
support. Guthrie described this decision as a "huge risk", as the success of their new web
development platform would be tied to the success of the CLR, which, like XSP, was still in the
early stages of development, so much so that the XSP team was the first team at Microsoft to
target the CLR.

With the move to the Common Language Runtime, XSP was re-implemented in C#
(known internally as "Project Cool" but kept secret from the public), and the name changed to
ASP+, as by this point the new platform was seen as being the successor to Active Server Pages,
and the intention was to provide an easy migration path for ASP developers.[4]

Mark Anders first demonstrated ASP+ at the ASP Connections conference in Phoenix,
Arizona on May 2, 2000. Demonstrations to the wide public and initial beta release of ASP+
(and the rest of the .NET Framework) came at the 2000 Professional Developers Conference on
July 11, 2000 in Orlando, Florida. During Bill Gates' keynote presentation, Fujitsu demonstrated
ASP+ being used in conjunction with COBOL,[5] and support for a variety of other languages
was announced, including Microsoft's new Visual Basic .NET and C# languages, as well as
Python and Perl support by way of interoperability tools created by ActiveState.[6]

Once the ".NET" branding was decided on in the second half of 2000, it was decided to
rename ASP+ to ASP.NET. Mark Anders explained on an appearance on The MSDN Show that
year that, "The .NET initiative is really about a number of factors, it's about delivering software
as a service, it's about XML and web services and really enhancing the Internet in terms of what
it can do ... we really wanted to bring its name more in line with the rest of the platform pieces
that make up the .NET framework."[4]
 After 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 part of version 1.0 of the .NET Framework.
Even prior to the release, dozens of books had been written about ASP.NET,[7] and Microsoft
promoted it heavily as part of their platform for web services. Guthrie became the product unit
manager for ASP.NET, and development continued apace, with version 1.1 being released on
April 24, 2003 as a part of Windows Server 2003. This release focused on improving ASP.NET's
support for mobile devices.

Characteristics

Pages

.NET pages, known officially as "web forms", are the main building block for application
development.[8] Web forms are contained in files with an ".aspx" extension; these files typically
contain static (X)HTML markup, as well as markup defining server-side Web Controls and User
Controls where the developers place all the required static and dynamic content for the web page.
Additionally, dynamic code which runs on the server can be placed in a page within a block <%
-- dynamic code -- %> which is similar to other web development technologies such as PHP,
JSP, and ASP, but this practice is generally discouraged except for the purposes of data binding
since it requires more calls when rendering the page.[citation needed]

Note that this sample uses code "inline", as opposed to code-behind.

<%@ Page Language="C#" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<script runat="server">

protected void Page_Load(object sender, EventArgs e)

{
Label1.Text = DateTime.Now.ToLongTimeString();
}

</script>

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title>Sample page</title>
</head>
<body>
<form id="form1" runat="server">
<div>
The current time is: <asp:Label runat="server" id="Label1" />
</div>
</form>

</body>
</html>

Code-behind model

Microsoft recommends dealing with dynamic program code by using the code-behind model,
which places this code in a separate file or in a specially designated script tag. Code-behind files
typically 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 practice is automatic in Microsoft Visual Studio and other IDEs. When
using this style of programming, the developer writes code to respond to different events, like the
page being loaded, or a control being clicked, rather than a procedural walk through the
document.

ASP.NET's code-behind model marks a departure from Classic ASP in that it encourages
developers to build applications with separation of presentation and content 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-controller frameworks.

Example

<%@ Page Language="C#" CodeFile="SampleCodeBehind.aspx.cs"

Inherits="Website.SampleCodeBehind"
AutoEventWireup="true" %>

The above tag is placed at the beginning of the ASPX file. The CodeFile property of the @ Page
directive specifies the file (.cs or .vb) acting as the code-behind while the Inherits property
specifies the Class the Page derives from. In this example, the @ Page directive is included in
SampleCodeBehind.aspx, then SampleCodeBehind.aspx.cs acts as the code-behind for this page:

using System;
namespace Website
{
public partial class SampleCodeBehind : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
Response.Write("Hello, world");
}
}
}

In this case, the Page_Load() method is called every time the ASPX page is requested. The
programmer can implement event handlers at several stages of the page execution process to
perform processing.

User controls

User controls are encapsulations of sections of pages which are registered and used as controls in
ASP.NET. User controls are created as ASCX markup files. These files usually contain static
(X)HTML markup, as well as markup defining server-side web controls where the developers
place all the required static and dynamic content. A user control is compiled when its containing
page is requested and is stored in memory for subsequent requests. User controls have their own
events which are handled during the life of ASP.NET requests. An event bubbling mechanism
provides the ability to pass an event fired by a user control up to its containing page. Unlike an
ASP.NET page, a user control cannot be requested independently; one of its containing pages is
requested instead.
Custom controls

Programmers can also build custom controls for ASP.NET applications. Unlike user
controls, these controls don't have an ASCX markup file, having all their code compiled into a
DLL file. Such custom controls can be used across multiple web applications and Visual Studio
projects (which is not allowed with user controls). By using a Register directive, the control is
loaded from the DLL.

Rendering technique

ASP.NET uses a visited composites rendering technique. During compilation, the

template (.aspx) file is compiled into initialization code which builds a control tree (the
composite) representing the original template. Literal text goes into instances of the Literal
control class, and server controls are represented by instances of a specific control class. The
initialization code is combined with user-written code (usually by the assembly of multiple
partial classes) and results in a class specific for the page. The page doubles as the root of the
control tree.

Actual requests for the page are processed through a number of steps. First, during the
initialization steps, an instance of the page class is created and the initialization code is executed.
This produces the initial control tree which is now typically manipulated by the methods of the
page in the following steps. As each node in the tree is a control represented as an instance of a
class, the code may change the tree structure as well as manipulate the properties/methods of the
individual nodes. Finally, during the rendering step a visitor is used to visit every node in the
tree, asking each node to render itself using the methods of the visitor. The resulting HTML
output is sent to the client.

After the request has been processed, the instance of the page class is discarded and with
it the entire control tree. This is a source of confusion among novice ASP.NET programmers
who rely on class instance members that are lost with every page request/response cycle.

State management

ASP.NET applications are hosted by a web server and are accessed using the stateless
HTTP protocol. As such, if an application uses stateful interaction, it has to implement state
management on its own. ASP.NET provides various functions for state management.
Conceptually, Microsoft treats "state" as GUI state. Problems may arise if an application needs to
keep track of "data state"; for example, a finite state machine which may be in a transient state
between requests (lazy evaluation) or which takes a long time to initialize. State management in
ASP.NET pages with authentication can make Web scraping difficult or impossible.

Application state

Application state is held by a collection of shared user-defined variables. These are set
and initialized when the Application_OnStart event fires on the loading of the first instance of
the application and are available until the last instance exits. Application state variables are
accessed using the Applications collection, which provides a wrapper for the application state
variables. Application state variables are identified by name.[9]
Session state

Server-side session state is held by a collection of user-defined session variables that are
persistent during a user session. These variables, accessed using the Session collection, are
unique to each session instance. The variables can be set to be automatically destroyed after a
defined time of inactivity even if the session does not end. Client-side user session is maintained
by either a cookie or by encoding the session ID in the URL itself.[9]

ASP.NET supports three modes of persistence for server-side session variables:[9]

In-Process Mode
The session variables are maintained within the ASP.NET process. This is the fastest
way; however, in this mode the variables are destroyed when the ASP.NET process is
recycled or shut down.
ASPState Mode
ASP.NET runs a separate Windows service that maintains the state variables. Because
state management happens outside the ASP.NET process, and because the ASP.NET
engine accesses data using .NET Remoting, ASPState is slower than In-Process. This
mode allows an ASP.NET application to be load-balanced and scaled across multiple
servers. Because the state management service runs independently of ASP.NET, the
session variables can persist across ASP.NET process shutdowns. However, since session
state server runs as a single instance, it is still a single point of failure for session state.
The session-state service cannot be load-balanced, and there are restrictions on types that
can be stored in a session variable.
SqlServer Mode
State variables are stored in a database, allowing session variables to be persisted across
ASP.NET process shutdowns. The main advantage of this mode is that it allows the
application to balance load on a server cluster, sharing sessions between servers. This is
the slowest method of session state management in ASP.NET.

View state

View state refers to the page-level state management mechanism, utilized by the HTML pages
emitted by ASP.NET applications to maintain the state of the web form controls and widgets.
The state of the controls is encoded and sent to the server at every form submission in a hidden
field known as __VIEWSTATE. The server sends back the variable so that when the page is re-
rendered, the controls render at their last state. At the server side, the application may change the
viewstate, if the processing requires a change of state of any control. The states of individual
controls are decoded at the server, and are available for use in ASP.NET pages using the
ViewState collection.[10] [11]

The main use for this is to preserve form information across postbacks. View state is turned on
by default and normally serializes the data in every control on the page regardless of whether it is
actually used during a postback. This behavior can (and should) be modified, however, as View
state can be disabled on a per-control, per-page, or server-wide basis.

Developers need to be wary of storing sensitive or private information in the View state of a
page or control, as the base64 string containing the view state data can easily be de-serialized. By
default, View state does not encrypt the __VIEWSTATE value. Encryption can be enabled on a
server-wide (and server-specific) basis, allowing for a certain level of security to be maintained.
[12]
Server-side caching

ASP.NET offers a "Cache" object that is shared across the application and can also be used to
store various objects. The "Cache" object holds the data only for a specified amount of time and
is automatically cleaned after the session time-limit elapses.

Other

Other means of state management that are supported by ASP.NET are cookies, caching, and
using the query string.

Template engine

When first released, ASP.NET lacked a template engine. Because the .NET framework is object-
oriented and allows for inheritance, many developers would define a new base class that inherits
from "System.Web.UI.Page", write methods there that render HTML, and then make the pages
in their application inherit from this new class. While this allows for common elements to be
reused across a site, it adds complexity and mixes source code with markup. Furthermore, this
method can only be visually tested by running the application - not while designing it. Other
developers have used include files and other tricks to avoid having to implement the same
navigation and other elements in every page.

ASP.NET 2.0 introduced the concept of "master pages", which allow for template-based page
development. A web application can have one or more master pages, which, beginning with
ASP.NET 2.0, can be nested.[13] Master templates have place-holder controls, called
ContentPlaceHolders to denote where the dynamic content goes, as well as HTML and
JavaScript shared across child pages.

Child pages use those ContentPlaceHolder controls, which must be mapped to the place-holder
of the master page that the content page is populating. The rest of the page is defined by the
shared parts of the master page, much like a mail merge in a word processor. All markup and
server controls in the content page must be placed within the ContentPlaceHolder control.

When a request is made for a content page, ASP.NET merges the output of the content page with
the output of the master page, and sends the output to the user.

The master page remains fully accessible to the content page. This means that the content page
may still manipulate headers, change title, configure caching etc. If the master page exposes
public properties or methods (e.g. for setting copyright notices) the content page can use these as
well.

PERFORMANCE

ASP.NET aims for performance benefits over other script-based technologies (including Classic
ASP) by compiling the server-side code to one or more DLL files on the web server.[15] This
compilation happens automatically the first time a page is requested (which means the developer
need not perform a separate compilation step for pages). This feature provides the ease of
development offered by scripting languages with the performance benefits of a compiled binary.
However, the compilation might cause a noticeable but short delay to the web user when the
newly-edited page is first requested from the web server, but won't again unless the page
requested is updated further.
The ASPX and other resource files are placed in a virtual host on an Internet Information
Services server (or other compatible ASP.NET servers; see Other implementations, below). The
first time a client requests a page, the .NET framework parses and compiles the file(s) into a
.NET assembly and sends the response; subsequent requests are served from the DLL files. By
default ASP.NET will compile the entire site in batches of 1000 files upon first request. If the
compilation delay is causing problems, the batch size or the compilation strategy may be
tweaked.

Developers can also choose to pre-compile their "codebehind" files before deployment, using
MS Visual Studio, eliminating the need for just-in-time compilation in a production
environment. This also eliminates the need of having the source code on the web server.

EXTENSION

Microsoft has released some extension frameworks that plug into ASP.NET and extend its
functionality. Some of them are:

ASP.NET AJAX
An extension with both client-side as well as server-side components for writing
ASP.NET pages that incorporate AJAX functionality.
ASP.NET MVC Framework
An extension to author ASP.NET pages using the MVC architecture.

ASP.NET compared with ASP classic

ASP.NET simplifies developers' transition from Windows application development to web

development by offering the ability to build pages composed of controls similar to a Windows
user interface. A web control, such as a button or label, functions in very much the same way as
its Windows counterpart: code can assign its properties and respond to its events. Controls know
how to render themselves: whereas Windows controls draw themselves to the screen, web
controls produce segments of HTML and JavaScript which form parts of the resulting page sent
to the end-user's browser.

ASP.NET encourages the programmer to develop applications using an event-driven GUI model,
rather than in conventional web-scripting environments like ASP and PHP. The framework
combines existing technologies such as JavaScript with internal components like "ViewState" to
bring persistent (inter-request) state to the inherently stateless web environment.

Other differences compared to ASP classic are:

• Compiled code means applications run faster with more design-time errors trapped at the
development stage.
• Significantly improved run-time error handling, making use of exception handling using
try-catch blocks.
• Similar metaphors to Microsoft Windows applications such as controls and events.
• An extensive set of controls and class libraries allows the rapid building of applications,
plus user-defined controls allow commonly-used web template, such as menus. Layout of
these controls on a page is easier because most of it can be done visually in most editors.
• ASP.NET uses the multi-language capabilities of the .NET Common Language Runtime,
allowing web pages to be coded in VB.NET, C#, J#, Delphi.NET, Chrome etc.
• Ability to cache the whole page or just parts of it to improve performance.
 • Ability to use the code-behind development model to separate business logic from
presentation.
• Ability to use true object-oriented design for programming both page and controls
• If an ASP.NET application leaks memory, the ASP.NET runtime unloads the
AppDomain hosting the erring application and reloads the application in a new
AppDomain.
• Session state in ASP.NET can be saved in a Microsoft SQL Server database or in a
separate process running on the same machine as the web server or on a different
machine. That way session values are not lost when the web server is reset or the
ASP.NET worker process is recycled.
• Versions of ASP.NET prior to 2.0 were criticized for their lack of standards compliance.
The generated HTML and JavaScript sent to the client browser would not always validate
against W3C/ECMA standards. In addition, the framework's browser detection feature
sometimes incorrectly identified web browsers other than Microsoft's own Internet
Explorer as "downlevel" and returned HTML/JavaScript to these clients with some of the
features removed, or sometimes crippled or broken. However, in version 2.0, all controls
generate valid HTML 4.0, XHTML 1.0 (the default) or XHTML 1.1 output, depending
on the site configuration. Detection of standards-compliant web browsers is more robust
and support for Cascading Style Sheets is more extensive.
• Web Server Controls: these are controls introduced by ASP.NET for providing the UI for
the web form. These controls are state managed controls and are WYSIWYG controls.

Frameworks

It is not essential to use the standard webforms development model when developing with
ASP.NET. Noteworthy frameworks designed for the platform include:

• Base One Foundation Component Library (BFC) is a RAD framework for building .NET
database and distributed computing applications.
• DotNetNuke is an open-source solution which comprises both a web application
framework and a content management system which allows for advanced extensibility
through modules, skins, and providers.
• Castle Monorail, an open-source MVC framework with an execution model similar to
Ruby on Rails. The framework is commonly used with Castle ActiveRecord, an ORM
layer built on NHibernate.
• Spring.NET, a port of the Spring framework for Java.
• Skaffold.NET, A simple framework for .NET applications, used in enterprise
applications.

The Microsoft .NET Framework is a software framework that can be installed on

computers running Microsoft Windows operating systems. It includes a large library of
coded solutions to common programming problems and a common language infrastructure
that manages the execution of programs written specifically for the framework. The .NET
Framework supports multiple programming languages in a manner that allows language
interoperability, whereby each language can utilize code written in other languages; in
particular, the .NET library is available to all the programming languages that .NET
encompasses.

The framework's Base Class Library provides a large range of features including user
interface, data access, database connectivity, cryptography, web application development,
 numeric algorithms, and network communications. The class library is used by programmers,
who combine it with their own code to produce applications.

Programs written for the .NET Framework execute in a software environment that manages
the program's runtime requirements. Also part of the .NET Framework, this runtime
environment is known as the Common Language Runtime (CLR). The CLR provides the
appearance of an application virtual machine so that programmers need not consider the
capabilities of the specific CPU that will execute the program. The CLR also provides other
important services such as security, memory management, and exception handling. The class
library and the CLR together constitute the .NET Framework.

The .NET Framework is a Microsoft offering and is intended to be used by most new
applications created for the Windows platform. In order to be able to develop and not just run
applications for the Microsoft .NET Framework 4.0

Framework may refer to:

• Software framework, a reusable set of libraries or classes for a software system (or
subsystem).
o Application framework, a software framework used to implement the standard
structure of an application for a specific operating system
o Web application framework, a software framework for development of dynamic
websites, web applications and web services
• Framework (office suite), a DOS office application suite launched in 1984 to run on the
original IBM PC under the MS-DOS operating system
• Process framework such as ITIL or Enhanced Telecom Operations Map
• Conceptual framework, a set of theories widely accepted enough to serve as the guiding
principles of research within a particular discipline.
• Legal framework, a form of legal doctrine