.

NET Framework
The .NET Framework (pronounced dot net) is a software framework developed by Microsoft that
runs primarily on Microsoft Windows. It includes a large library and provides language
interoperability (each language can use code written in other languages) across several programming
languages. Programs written for the .NET Framework execute in a software environment (as contrasted
to hardware environment), known as the Common Language Runtime (CLR), an application virtual
machine that provides services such as security, memory management, and exception handling. The
class library and the CLR together constitute the .NET Framework.
The .NET Framework's Base Class Library provides user interface, data access, database
connectivity, cryptography, web application development, numeric algorithms, and network
communications. Programmers produce software by combining their own source code with the .NET
Framework and other libraries. The .NET Framework is intended to be used by most new applications
created for the Windows platform. Microsoft also produces an integrated development
environment largely for .NET software called Visual Studio.
Microsoft started development of the .NET Framework in the late 1990s, originally under the
name of Next Generation Windows Services (NGWS). By late 2000 the first beta versions of .NET 1.0
were released.
The .NET Framework family also includes two versions for mobile or embedded device use. A
reduced version of the framework, the .NET Compact Framework, is available on Windows CE platforms,
including Windows Mobile devices such as smartphones. Additionally, the .NET Micro Framework is
targeted at severely resource-constrained devices.
Generation
Version
number
Release
date
Development tool Distributed with
1.0 1.0.3705.0 2002-02-13 Visual Studio .NET N/A
1.1 1.1.4322.573 2003-04-24
Visual Studio .NET
2003
Windows Server 2003
2.0 2.0.50727.42 2005-11-07 Visual Studio 2005 Windows Server 2003 R2
3.0 3.0.4506.30 2006-11-06 Expression Blend
Windows Vista, Windows Server
2008
3.5 3.5.21022.8 2007-11-19 Visual Studio 2008
Windows 7, Windows Server 2008
R2
4.0 4.0.30319.1 2010-04-12 Visual Studio 2010 N/A
4.5 4.5.50709.17929 2012-08-15 Visual Studio 2012 Windows 8, Windows Server 2012


.Net Framework Features








Design features[edit]
Interoperability
Because computer systems commonly require interaction between newer and older applications,
the .NET Framework provides means to access functionality implemented in newer and older
programs that execute outside the .NET environment. Access to COM components is provided in
the System.Runtime.InteropServices and System.EnterpriseServices namespaces of the
framework; access to other functionality is achieved using the P/Invoke feature.
Common Language Runtime engine
The Common Language Runtime (CLR) serves as the execution engine of the .NET Framework.
All .NET programs execute under the supervision of the CLR, guaranteeing certain properties and
behaviors in the areas of memory management, security, and exception handling.
Language independence
The .NET Framework introduces a Common Type System, or CTS. The
CTS specification defines all possible datatypes and programming constructs supported by the
CLR and how they may or may not interact with each other conforming to the Common Language
Infrastructure (CLI) specification. Because of this feature, the .NET Framework supports the
exchange of types and object instances between libraries and applications written using any
conforming .NET language.
Base Class Library
The Base Class Library (BCL), part of the Framework Class Library (FCL), is a library of
functionality available to all languages using the .NET Framework. The BCL provides classes that
encapsulate a number of common functions, including file reading and writing, graphic
rendering, database interaction, XML document manipulation, and so on. It consists of classes,
interfaces of reusable types that integrates with CLR(Common Language Runtime).
Simplified deployment
The .NET Framework includes design features and tools which help manage the installation of
computer software to ensure it does not interfere with previously installed software, and it
conforms to security requirements.
Security
The design addresses some of the vulnerabilities, such as buffer overflows, which have been
exploited by malicious software. Additionally, .NET provides a common security model for all
applications.
Portability
While Microsoft has never implemented the full framework on any system except Microsoft
Windows, it has engineered the framework to be platform-agnostic,
[3]
and cross-platform
implementations are available for other operating systems (see Silverlight and the Alternative
implementations section below). Microsoft submitted the specifications for the Common
Language Infrastructure (which includes the core class libraries, Common Type System, and
the Common Intermediate Language),
[4][5][6]
the C# language,
[7]
and the C++/CLI language
[8]
to
both ECMA and the ISO, making them available as official standards. This makes it possible for
third parties to create compatible implementations of the framework and its languages on other
platforms.

Architecture[edit]


Visual overview of the Common Language Infrastructure (CLI)
Common Language Infrastructure (CLI)[edit]
Main article: Common Language Infrastructure
The purpose of the Common Language Infrastructure (CLI) is to provide a language-neutral platform for
application development and execution, including functions for exception handling, garbage collection,
security, and interoperability. By implementing the core aspects of the .NET Framework within the scope
of the CLI, this functionality will not be tied to a single language but will be available across the many
languages supported by the framework. Microsoft's implementation of the CLI is called the Common
Language Runtime, or CLR.
Main article: Assembly (CLI)
The CIL code is housed in CLI assemblies. As mandated by the specification, assemblies are stored in
the Portable Executable (PE) format, common on the Windows platform for all DLL and EXE files. The
assembly consists of one or more files, one of which must contain the manifest, which has
themetadata for the assembly. The complete name of an assembly (not to be confused with the filename
on disk) contains its simple text name, version number, culture, and public key token. Assemblies are
considered equivalent if they share the same complete name, excluding the revision of the version
number. A private key can also be used by the creator of the assembly for strong naming. The public key
token identifies which public key an assembly is signed with. Only the creator of the keypair (typically the
.NET developer signing the assembly) can sign assemblies that have the same strong name as a
previous version assembly, since he is in possession of the private key. Strong naming is required to add
assemblies to the Global Assembly Cache
Security[edit]
.NET has its own security mechanism with two general features: Code Access Security (CAS), and
validation and verification. Code Access Security is based on evidence that is associated with a specific
assembly. Typically the evidence is the source of the assembly (whether it is installed on the local
machine or has been downloaded from the intranet or Internet). Code Access Security uses evidence to
determine the permissions granted to the code. Other code can demand that calling code is granted a
specified permission. The demand causes the CLR to perform a call stack walk: every assembly of each
method in the call stack is checked for the required permission; if any assembly is not granted the
permission a security exception is thrown.
Class library[edit]
Namespaces in the BCL
[9]

System
System.Diagnostcs
System.Globalizaton
System.Resources
System.Text
System.Runtme.Serializaton
System.Data
See also: Base Class Library and Framework Class Library
The .NET Framework includes a set of standard class libraries. The class library is organized in a
hierarchy of namespaces. Most of the built-in APIs are part of
either System.* orMicrosoft.* namespaces. These class libraries implement a large number of
common functions, such as file reading and writing, graphic rendering, database interaction, and XML
document manipulation, among others. The .NET class libraries are available to all CLI compliant
languages. The .NET Framework class library is divided into two parts: the Base Class Library and the
Framework Class Library
The Base Class Library (BCL) includes a small subset of the entire class library and is the core set of
classes that serve as the basic API of the Common Language Runtime.
[9]
The classes
in mscorlib.dll and some of the classes in System.dll and System.core.dll are considered to
be a part of the BCL. The BCL classes are available in both .NET Framework as well as its alternative
implementations including .NET Compact Framework, Microsoft Silverlight and Mono.
The Framework Class Library (FCL) is a superset of the BCL classes and refers to the entire class library
that ships with .NET Framework. It includes an expanded set of libraries, including Windows
Forms, ADO.NET, ASP.NET, Language Integrated Query, Windows Presentation Foundation, Windows
Communication Foundation among others. The FCL is much larger in scope than standard libraries for
languages like C++, and comparable in scope to the standard libraries of Java.
Memory management[edit]
The .NET Framework CLR frees the developer from the burden of managing memory (allocating and
freeing up when done); it handles memory management itself by detecting when memory can be safely
freed. Instantiations of .NET types (objects) are allocated from the managed heap; a pool of memory
managed by the CLR. As long as there exists a reference to an object, which might be either a direct
reference to an object or via a graph of objects, the object is considered to be in use. When there is no
reference to an object, and it cannot be reached or used, it becomes garbage, eligible for collection. NET
Framework includes a garbage collector which runs periodically, on a separate thread from the
application's thread, that enumerates all the unusable objects and reclaims the memory allocated to them.
The .NET Garbage Collector (GC) is a non-deterministic, compacting, mark-and-sweep garbage collector.
The GC runs only when a certain amount of memory has been used or there is enough pressure for
memory on the system. Since it is not guaranteed when the conditions to reclaim memory are reached,
the GC runs are non-deterministic. Each .NET application has a set of roots, which are pointers to objects
on the managed heap (managed objects). These include references to static objects and objects defined
as local variables or method parameters currently in scope, as well as objects referred to by CPU
registers.
[10]
When the GC runs, it pauses the application, and for each object referred to in the root,
it recursively enumerates all the objects reachable from the root objects and marks them as reachable. It
uses CLI metadata and reflection to discover the objects encapsulated by an object, and then recursively
walk them. It then enumerates all the objects on the heap (which were initially allocated contiguously)
using reflection. All objects not marked as reachable are garbage.
[10]
This is the mark phase.
[11]
Since the
memory held by garbage is not of any consequence, it is considered free space. However, this leaves
chunks of free space between objects which were initially contiguous. The objects are
then compacted together to make used memory contiguous again.
[10][11]
Any reference to an object
invalidated by moving the object is updated by the GC to reflect the new location.
[11]
The application is
resumed after the garbage collection is over.
The GC used by .NET Framework is also generational.
[12]
Objects are assigned a generation; newly
created objects belong to Generation 0. The objects that survive a garbage collection are tagged
asGeneration 1, and the Generation 1 objects that survive another collection are Generation 2 objects.
The .NET Framework uses up to Generation 2 objects.
[12]
Higher generation objects are garbage
collected less frequently than lower generation objects. This helps increase the efficiency of garbage
collection, as older objects tend to have a longer lifetime than newer objects.
[12]
Thus, by eliminating older
(and thus more likely to survive a collection) objects from the scope of a collection run, fewer objects
need to be checked and compacted.
[12]

Standardization and licensing[edit]
In August 2000, Microsoft, Hewlett-Packard, and Intel worked to standardize CLI and
the C# programming language. By December 2001, both were ratified ECMA standards (ECMA
335 and ECMA 334).ISO followed in April 2003 - the current version of the ISO standards are ISO/IEC
23271:2012 and ISO/IEC 23270:2006.
[13][14]

While Microsoft and their partners hold patents
[citation needed]
for the CLI and C#, ECMA and ISO require that
all patents essential to implementation be made available under "reasonable and non-discriminatory
terms". In addition to meeting these terms, the companies have agreed to make the patents available
royalty-free.
[citation needed]

However, this does not apply for the part of the .NET Framework which is not covered by the ECMA/ISO
standard, which includes Windows Forms, ADO.NET, and ASP.NET. Patents that Microsoft holds in
these areas may deter non-Microsoft implementations of the full framework.
[15]

On 3 October 2007, Microsoft announced that much of the source code for the .NET Framework Base
Class Library (including ASP.NET, ADO.NET, and Windows Presentation Foundation) was to have been
made available with the final release of Visual Studio 2008 towards the end of 2007 under the shared
source Microsoft Reference License.
[1]
The source code for other libraries including Windows
Communication Foundation (WCF), Windows Workflow Foundation (WF), and Language Integrated
Query (LINQ) were to be added in future releases. Being released under the non-open source Microsoft
Reference License means this source code is made available for debugging purpose only, primarily to
support integrated debugging of the BCL in Visual Studio.
Alternative implementations[edit]
The Microsoft .NET Framework is the predominant implementation of .NET technologies. Other
implementations for parts of the framework exist. Although the runtime engine is described by an
ECMA/ISO specification, other implementations of it may be encumbered by patent issues; ISO
standards may include the disclaimer, "Attention is drawn to the possibility that some of the elements of
this document may be the subject of patent rights. ISO shall not be held responsible for identifying any or
all such patent rights."
[16]
It is more difficult to develop alternatives to the base class library (BCL), which is
not described by an open standard and may be subject to copyright restrictions. Additionally, parts of the
BCL have Windows-specific functionality and behavior, so implementation on non-Windows platforms can
be problematic.
Some alternative implementations of parts of the framework are listed here.
Microsoft's .NET Micro Framework is a .NET platform for extremely resource-constrained devices. It
includes a small version of the .NET CLR and supports development in C# (though some developers
were able to use VB.NET,
[17]
albeit with an amount of hacking, and with limited functionalities) and
debugging (in an emulator or on hardware), both using Microsoft Visual Studio. It also features a
subset of the .NET base class libraries (about 70 classes with about 420 methods), a GUI framework
loosely based on Windows Presentation Foundation, and additional libraries specific to embedded
applications.
Mono is an implementation of the CLI and the .NET Base Class Library (BCL), and provides
additional functionality. It is dual-licensed under free software and proprietary software licenses. It
includes support for ASP.NET, ADO.NET, and Windows Forms libraries for a wide range of
architectures and operating systems. It also includes C# and VB.NET compilers.
Portable.NET (part of DotGNU) provides an implementation of the Common Language Infrastructure
(CLI), portions of the .NET Base Class Library (BCL), and a C# compiler. It supports a variety of
CPUs and operating systems.
Microsoft's Shared Source Common Language Infrastructure is a non-free implementation of the CLR
component of the .NET Framework. However, the last version only runs on Microsoft Windows XP
SP2, and was not updated since 2006, therefore it does not contain all features of version 2.0 of the
.NET Framework.
CrossNet
[18]
is an implementation of the CLI and portions of the .NET Base Class Library (BCL). It
is free software using the open source MIT License.