Overview of the .NET Framework The .

NET Framework is a new computing platform that simplifies application development in the highly distributed environment of the Internet. Services NET Framework provides the following services:

Tools for developing software applications, run-time environments for software application to execute, server infrastructure, value added intelligent software which helps developers to do less coding and work efficiently,

The .Net Framework will enable developers to develop applications for various devices and platforms like windows application web applications windows services and web services . Objectives The .NET Framework is designed to fulfill the following objectives:

A consistent object-oriented programming environment, where object code can be stored and executed locally, executed locally but Internet-distributed, or executed remotely. A code-execution environment that minimizes software deployment and versioning conflicts. A code-execution environment that guarantees safe execution of code, including code created by an unknown or semi-trusted third party. A code-execution environment that eliminates the performance problems of scripted or interpreted environments. Developers can experience consistency across widely varying types of applications, such as Windows-based applications and Web-based applications. Build all communication on industry standards to ensure that code based on the .NET Framework can integrate with any other code.

Understanding the .NET Framework Architecture The .NET Framework has two components: the .NET Framework class library and the common language runtime. The .NET Framework class library facilitates types (CTS) that are common to all .NET languages. The common language runtime consists of (class loader) that load the IL code of a program into the runtime, which compiles the IL code into native code, and executes and manage the code to enforce security and type safety, and provide thread support.

.NET Framework Architecture has languages at the top such as VB .NET C#, VJ#, VC++ .NET; developers can develop (using any of above languages) applications such as Windows Forms, Web Form, Windows Services and XML Web Services. Bottom two layers consist of .NET Framework class library and Common Language Runtime. This we are going to understand using this article. Understanding the Roll of .NET Framework The .NET Framework has two main components: the common language runtime (CLR) and the .NET Framework class library. The common language runtime is the foundation of the .NET Framework. CLR act as an agent that manages code at execution time, providing core services such as memory management, thread management, and remoting, while also enforcing strict type safety and facilitates with code accuracy that ensure security and robustness. The concept of code management is a fundamental principle of the CLR. Code that targets the CLR is known as managed code, while code that does not target the CLR is known as unmanaged code. The class library, is a integral component of the .NET Framework, consists of object-oriented collection of reusable classes (types) that we can use to develop applications ranging from traditional command-line or any graphical user interface (GUI) applications such as Windows Forms, ASP. NET Web Forms and Windows Services the newly invented XML Web services. The European Computer Manufacturers Association (ECMA) standard has defines the Common Language Specification (CLS); this enforces that software development languages should be interoperable between them. The code written in a CLS should be compliant with the code written in another CLS-compliant language. Because the code supported by CLS-compliant language should be compiled into an intermediate language (IL) code. The CLR engine executes the IL code. This ensures interoperability between CLS-compliant languages. Microsoft .NET Framework supports Languages like Microsoft Visual Basic .NET, Microsoft Visual C#, Microsoft Visual C++ .NET, and Microsoft Visual J# .NET. The language compilers generate an Intermediate Language code, called Microsoft Intermediate Language (MSIL), which makes programs written in the .NET languages

interoperable across languages. The ECMA standard, Common Language Infrastructure (CLI), defines the specifications for the infrastructure that the IL code needs for execution. The CLI provides a common type system (CTS) and services such as type safety, managed code execution and side by side execution.

Figure 1. ECMA Standards under Microsoft .NET Framework. The .NET Framework provides the infrastructure and services. The CLI specifications. These include:

Common language runtime o The CLR includes the CLI, o The CLR also provides the execution environment for .NET Applications. Common type system. o Provides the data types, values, object types. This helps developers to develop applications in different languages.Where .NET languages share CTS mean all the types used in applications shares the same types defined under CLI. Type safety o .NET Framework performs operations on the values or objects for which .NET Framework requires each value or object has a type and which reference to the value or object type. Managed code execution. o .NET Framework manages the state of the object while executing the .NET Applications. o .NET Framework automatically allocates memory and provides garbage collation mechanism to de-allocate memory.

Side-by-side execution o .NET Framework allows different version of the same application to run on the same machine by using assemblies of different versions. Assemblies consist of IL Code and Metadata. Where metadata determines the application dependencies. By this .NET Framework Runtime executes multiple version of assembly and solves the major problem of legacy development environment. That is the "DLL HELL".

.NET Assembly

Figure 2 Side-by-side Execution. Understanding .NET Framework CLR The common language runtime facilitates the followings:

Run-time environment o CLR Compiles application into the runtime, compile the IL code into native code, execute the code. Run-time services. o Memory management, o Type safety, o Enforces Security, o Exception Management. Thread support Debugging support

Understanding Architecture of .NET Framework CLR

Class loader, which loads classes into CLR. MSIL to native code compiles, this converts MSIL code into native code. Code manager, this manages the code during execution. Memory allocation and Garbage collector, this performs automatic memory management. Security engine, this enforces security restrictions as code level security folder level and machine level security using tools provided by Microsoft .NET and using .NET Framework setting under control panel. Type checker, which enforces strict type checking. Thread support, which provides multithreading support to applications. Exception manager, which provides a mechanism to handle the run-time exceptions handling. Debug engine, which allows developer to debug different types of applications. COM marshaler, which allows .NET applications to exchange data with COM applications. Base class library support, which provides the classes (types) that the applications need at run time.

Features of the Common Language Runtime The CLR has the following Fractures

Manages memory, o Allocation of Memory o De-Allocation of Memory (garbage collation) Thread execution support, Code execution,

Code safety verification, Compilation. o MSIL to Native Code. Code Security based on Trust (granted permission to execute code. Code level, Folder level, Machine level) These features are intrinsic to the managed code that runs on the common language runtime.

Understanding CLR To execute the program and gain all the benefits of managed execution environment we write code in a language which is supported by CLS that is .NET Framework. The language compiler compiles the source code into the MSIL code which consists of CPU- independent code and instructions which is platform independent. MSIL consists of the followings:

Instructions that enables to perform arithmetic and logical operations Access memory directly. Control the flow of execution, Handles exceptions,

MSIL code can be compiling into CPU specific instructions before executing, for which the CLR requires information about the code which is nothing but metadata. Metadata describes the code and defines the types that the code contains as well referenced to other types which the code uses at run time. An assembly consists of portable executable file. At the time of executing PE file the class loader loads the MSIL code and the metadata form the portable executable file into the run time memory. Before the execution of PE file it passes the code to the native code compiler for compilation, IL to native code compilation is done by JIT compiler. For different CPU architecture and compilers for the IL code in to the native instructions. Futures of CLR

Managed multithreading support and monitor the threads. Application domain contains one or more threads to execute. Manages interoperability with unmanaged code, and COM marshaling A structured exception handling mechanism, The infrastructure and managed execution process, memory management and garbage collection.

Architecture of CLR

Base class library support supports al the base classes used for .net languages to support basic functionality. COM Marshaler supports Marshaling of data between COM objects. Exception management supports handling Errors at runtime using try catch finally blocks. Security engine enforces security rules at runtime. Type checker checks for Type safe checks at runtime. Debug engine supports debugging at runtime. Code manger manages the Managed code at runtime. IL to native compiler compiles the MSIL code to the Native code which is machine independent. Garbage collector supports the Memory management and supports Clearing unused memory at runtime. Class loader lodes the classes at runtime .

Understanding JIT compiler JIT compiler compiles is the integral part of CLR. the MSIL code to Native code and executes the batch of code Just in time which will be cached and next time when the code gets executed from cache in stud of compiling again.

JIT Execution process CLR class loader lodes MSIL code and metadata are loaded into memory; the code manager calls the entry point method which is WinMain or DLLMain method. The JIT compiler compiles the method to before its execution of the entry point method. The code manager places the objects in memory and controls the execution of the code. The garbage collector performs periodic checks on the managed heap to identify the objects which is not in use for the application. At the time of program execution the type checker ensures that all objects and values, and the references of objects and values has its valid type. The type checker also makes sure that only valid operations are performed on the code other wise the exception will be thrown. The code is controlled by CLR at run time. CLR enforces security in following manner.

To control and access the system recourses like hard disk. To control and access the network connections. To control and access the other hard ware resources.

Managed code Execution Managed code execution is known as the process executed by the CLR which is as follows:

CLR loads the MSIL & refers metadata, CLR executes the Native code, CLR provides automatic memory management. Managed execution also performs JIT compilations, Ensuring type safety, Enforcing security, Handling exceptions.

Managed Execution Process

Managed code is self-explanatory code which gives information to CLR for multiple runtime services in .NET Framework. This information is stored in MSIL code in the form of metadata inside the PE file. Mata data information will describe the types that the code contains. Managed data is allocated and released from memory automatically by garbage collection. Managed data can be accessible form managed code but managed code can be accessible from managed and unmanaged data.

Memory Management Automatic memory management means no need to write code to allocate memory when objects are created or to release memory when objects are not required the application. The process of automatic memory management involves the following tasks: Allocating memory

When a process is initialized, the runtime reserves a contiguous address space without allocating any storage space for it. This reserved address space is called a managed heap. The managed heap keeps a pointer at the location where the next object will be located. When an application uses the new operator to create an object, the new operator checks whether the memory required by the object is available on the heap. When the next object is created, the garbage collector allocates memory to the object on the managed heap. Allocating memory to the objects in a managed heap takes less time than allocating unmanaged memory. In unmanaged memory, the pointers to memory are maintained in linked-list data structures. Therefore, allocating memory requires navigating through the linked list, finding a large memory block to accommodate that. You can access objects in managed memory faster than objects in unmanaged memory because in managed memory allocation, objects are created contiguously in the managed address space.

Releasing Memory

The garbage collector periodically releases memory from the objects that are no longer required by the application. Every application has a set of roots. Roots point to the storage location on the managed heap. Each root either refers to an object on the managed heap or is set to null. An application's roots consist of global and static object pointers, local variables, and reference object parameters on a thread stack. The JIT compiler and the run-time maintain the list of the application roots. The garbage collector uses this list to create a graph of objects on the managed heap that are reachable from the root list.

When the garbage collector starts running, it considers all the objects on the managed heap as garbage. The garbage collector navigates through the application root list, it identifies the objects that have corresponding references in the application root list and marks them as reachable. The garbage collector also considers such objects as reachable objects. The garbage collector considers all unreachable objects on the managed heap as garbage. The garbage collector performs a collection process to free the memory occupied by the garbage objects. The garbage collector performs the memory copy function to compress the objects in the managed heap. The garbage collector updates the pointers in the application root list so that the application roots correctly point to the objects to which they were pointing earlier. The garbage collector uses a highly optimized mechanism to perform garbage collection. It divides the objects on the managed heap into three generations: 0, 1, and 2. Generation 0 contains recently created objects. The garbage collector first collects the unreachable objects in generation 0. Next, the garbage collector compacts memory and promotes the reachable objects to generation 1. The objects that survive the collection process are promoted to higher generations. The garbage collector searches for unreachable objects in generations 1 and 2 only when the memory released by the collection process of generation 0 objects is insufficient to create the new object. The garbage collector manages memory for all managed objects created by the application. The garbage collection can explicitly release these system resources by providing the cleanup code in the Dispose method of the object. We need to explicitly call the Dispose method after you finish working with the object.

Implementing Finalizers

The finalization process allows an object to perform cleanup tasks automatically before garbage collection starts. The Finalize method ensures that even if the client does not call the Dispose method explicitly, the resources used by the object are released from memory when the object is garbage collected. After the garbage collector identifies the object as garbage during garbage collection, it calls the Finalize method on the object before releasing memory. Finalizers are the methods that contain the cleanup code that is executed before the object is garbage collected. The process of executing cleanup code is called finalization. The Dispose and Finalize methods are called finalizers.

The Dispose method of an object should release all its resources in addition to the resources owned by its parent object by calling the Dispose method of the ?parent object. We can execute the Dispose method in two ways. o The user of the class can call the Dispose method on the object that is being disposed, or o The Finalize method can call the Dispose method during the finalization process.

.NET Framework Tools Assembly Linker Al.exe Tool

tool can create an assembly or resource file with the manifest in a separate file out of modules. Syntax: al [source] [options] This tool allows us to create multi-file assembly outside .NET. A multi-file assembly is useful to combine modules developed under different .NET languages into a single application.

IL Assembler Ilasm.exe Tool

When we compile managed code, the code is converted into MSIL code; this is CPU independent language which is converted to native code. We can use Ilasm tool to generate a portable executable (PE) file from the MSIL code. The resulting executable file is performance optimized, where the Ilasm tool does not create intermediate object file Syntex: Ilasm [source] filename [options] We can specify multiple source files to produce a single PE file.

IL Disassembler Ildasm.exe Tool

Ildasm tool is used to view PE file contains that is nothing but the MSIL code as a parameter and creates the text file that consists of managed code.

Code Access Security Policy Tool Caspol.exe Tool

Caspool is nothing but Code Access Security Policy tool, which allows us to grant and modify permissions granted to code groups at the user-policy, machine-policy, and enterprise-policy levels. Etc... Syntex: caspol [options]

.NET Framework Configuration Tool Mscorcfg.msc

With this tool we can manage and configure assemblies in to the global assembly cache. And also manage the code access security along with remoting services. This tool also creates code group policies at user level- policies, machine level-policies, and enterprise level policies to assign and remove the permissions on assemblies within .NET Framework.

What is the .NET Framework? The .NET Framework is a new and revolutionary platform created by Microsoft for developing applications. It is a platform for application developers. It is a Framework that supports Multiple Language and Cross language integration. IT has IDE (Integrated Development Environment). Framework is a set of utilities or can say building blocks of your application system. .NET Framework provides GUI in a GUI manner. .NET is a platform independent but with help of Mono Compilation System (MCS). MCS is a middle level interface. .NET Framework provides interoperability between languages i.e. Common Type System (CTS) . .NET Framework also includes the .NET Common Language Runtime (CLR), which is responsible for maintaining the execution of all applications developed using the .NET library. The .NET Framework consists primarily of a gigantic library of code.

Definition: A programming infrastructure created by Microsoft for building, deploying, and running applications and services that use .NET technologies, such as desktop applications and Web services .
Cross Language integration You can use a utility of a language in another language (It uses Class Language Integration). .NET Framework includes no restriction on the type of applications that are possible. The .NET Framework allows the creation of Windows applications, Web applications, Web services, and lot more. The .NET Framework has been designed so that it can be used from any language, including C#, C++, Visual Basic, JScript, and even older languages such as COBOL. Difference between Visual Studio and Visual Studio .NET Visual Studio It is object based Internet based application - Web Application - Web services - Internet enable application - Third party API Visual Studio It is object oriented All developing facilities in internet based application

- Peer to peer Application Poor error handling Exception/Error Memory Management System Level Task DLL HELL

Advance error handler and debugger Memory Management Application Domain with help of GC (Garbage Collector) VS .NET has solved DLL HELL Problem

Simple explanation of definition used in the above comparision: Web Application All websites are example of web application. They use a web server. Internet Enabled Application They are desktop Peer to Peer Communication through computers through some system. Web Services It doesn't use web-based server. Internet payment systems are example of web services. DLL Hell application. Yahoo messenger is an example of desktop application.

"DLL Hell" refers to the set of problems caused when multiple applications attempt to share a common component like a dynamic link library (DLL) or a Component Object Model (COM) class.
The reason for this issue was that the version information about the different components of an application was not recorded by the system. (Windows Registry cannot support the multiple versions of same COM component this is called the dll hell problem.) .Net Framework provides operating systems with a Global Assembly Cache (GAC). This Cache is a repository for all the .Net components that are shared globally on a particular machine. When a .Net component is installed onto the machine, the Global Assembly Cache looks at its version, its public key, and its language information and creates a strong name for the component. The component is then registered in the repository and indexed by its strong name, so there is no confusion between different versions of the same component, or DLL. Architecture of .NET Framework

Architecture of CLR

CLS (Common Language Specification) It is a subset of CTS. All instruction is in CLS i.e. instruction of CTS is written in CLS. Code Manager Code manager invokes class loader for execution. .NET supports two kind of coding 1) Managed Code 2) Unmanaged Code

Managed Code The resource, which is with in your application domain is, managed code. The resources that are within domain are faster. The code, which is developed in .NET framework, is known as managed code. This code is directly executed by CLR with help of managed code execution. Any language that is written in .NET Framework is managed code. Managed code uses CLR which in turns looks after your applications by managing memory, handling security, allowing cross - language debugging, and so on.

Unmanaged Code The code, which is developed outside .NET, Framework is known as unmanaged code. Applications that do not run under the control of the CLR are said to be unmanaged, and certain languages such as C++ can be used to write such applications, which, for example, access low - level functions of the operating system. Background compatibility with code of VB, ASP and COM are examples of unmanaged code. Unmanaged code can be unmanaged source code and unmanaged compile code. Unmanaged code is executed with help of wrapper classes. Wrapper classes are of two types: CCW (COM callable wrapper) and RCW (Runtime Callable Wrapper). Wrapper is used to cover difference with the help of CCW and RCW. COM callable wrapper unmanaged code

Runtime Callable Wrapper unmanaged code

Native Code The code to be executed must be converted into a language that the target operating system understands, known as native code. This conversion is called compiling code, an act that is performed by a compiler. Under the .NET Framework, however, this is a two - stage process. With help of MSIL and JIT. MSIL (Microsoft Intermediate Language) It is language independent code. When you compile code that uses the .NET Framework library, you don't immediately create operating system - specific native code.

Instead, you compile your code into Microsoft Intermediate Language (MSIL) code. The MSIL code is not specific to any operating system or to any language. JIT (Just-in-Time) Just - in - Time (JIT) compiler, which compiles MSIL into native code that is specific to the OS and machine architecture being targeted. Only at this point can the OS execute the application. The just - in - time part of the name reflects the fact that MSIL code is only compiled as, and when, it is needed. In the past, it was often necessary to compile your code into several applications, each of which targeted a specific operating system and CPU architecture. Often, this was a form of optimization. This is now unnecessary, because JIT compilers (as their name suggests) use MSIL code, which is independent of the machine, operating system, and CPU. Several JIT compilers exist, each targeting a different architecture, and the appropriate one will be used to create the native code required. The beauty of all this is that it requires a lot less work on your part - in fact, you can forget about system dependent details and concentrate on the more interesting functionality of your code. JIT are of three types: 1. 2. 3. Pre JIT It converts all the code in executable code and it is slow Econo JIT It will convert the called executable code only. But it will convert code every time when a code is called again. Normal JIT It will only convert the called code and will store in cache so that it will not require converting code again. Normal JIT is fast. Assemblies When you compile an application, the MSIL code created is stored in an assembly. Assemblies include both executable application files that you can run directly from Windows without the need for any other programs (these have a .exe file extension), and libraries (which have a .dll extension) for use by other applications. In addition to containing MSIL, assemblies also include meta information (that is, information about the information contained in the assembly, also known as metadata) and optional resources (additional data used by the MSIL, such as sound files and pictures). Pre JIT Econo JIT Normal JIT

The meta information enables assemblies to be fully self - descriptive. You need no other information to use an assembly, meaning you avoid situations such as failing to add required data to the system registry and so on, which was often a problem when developing with other platforms. This means that deploying applications is often as simple as copying the files into a directory on a remote computer. Because no additional information is required on the target systems, you can just run an executable file from this directory and (assuming the .NET CLR is installed) you're good to go. Of course, you won't necessarily want to include everything required to run an application in one place. You might write some code that performs tasks required by multiple applications. In situations like that, it is often useful to place the reusable code in a place accessible to all applications. In the .NET Framework, this is the Global Assembly Cache (GAC). Placing code in the GAC is simple - you just place the assembly containing the code in the directory containing this cache. Garbage Collection (GC) One of the most important features of managed code is the concept of garbage collection. This is the .NET method of making sure that the memory used by an application is freed up completely when the application is no longer in use. Prior to .NET this was mostly the responsibility of programmers, and a few simple errors in code could result in large blocks of memory mysteriously disappearing as a result of being allocated to the wrong place in memory. That usually meant a progressive slowdown of your computer followed by a system crash. .NET garbage collection works by inspecting the memory of your computer every so often and removing anything from it that is no longer needed. There is no set time frame for this; it might happen thousands of times a second, once every few seconds, or whenever, but you can rest assured that it will happen. Will try to explain the processing in terms of C# code which is written using .NET Framework.

Step 1- Application code is written using a .NET - compatible language C#.

Step 2 - Code is compiled into MSIL, which is stored in an assembly (see Figure 1 - 2).

Step 3 - When this code is executed (either in its own right if it is an executable or when it is used from other code), it must first be compiled into native code using a JIT compiler.

Step 4 - The native code is executed in the context of the managed CLR, along with any other running applications or processes.

Note: One additional point concerning this process. The C# code that compiles into MSIL in step 2 needn't be contained in a single file. It's possible to split application code across multiple source code files, which are then compiled together into a single assembly. This extremely useful process is known as linking.
This is because it is far easier to work with several smaller files than one enormous one. You can separate out logically related code into an individual file so that it can be worked on independently and then practically forgotten about when completed. This also makes it easy to locate specific pieces of code when you need them and enables teams of developers to divide up the programming burden into manageable chunks, whereby individuals can check out pieces of code to work on without risking damage to otherwise satisfactory sections or sections other people are working on. Conclusion I hope that this article would have helped you in understanding .NET Framework and have built a simple and clear understanding of .NET.

Have taken some definition and lines from some references for technically explanation and understanding. Your feedback and constructive contributions are welcome. Please feel free to contact me for feedback or comments you may have about this article.

Differences between .Net Framework 2.0 and 3.5

Microsoft is always been stepping ahead of its competitors by bringing great new features and products in the market. Specially for developers Microsoft based technologies are like a dream come true. Considering from development point of view the latest product in Microsoft Box is Visual Studio 2008. The new development environment comes with tons of new features and design differences. .Net Framework 3.5 is ready to make futuristic websites with its extremely easy to use interface, rich accessibility features and new design that allows to reduce the time and efforts in website development.

One thing that was lagging in .net framework 2.0 was multi targeting. As in .Net framework 2.0 or framework 1.1 there was a separation in terms of development. Like one builds a site in framework 1.1 would have to use Visual Studio 2003, and for development in framework 2.0 we need to work in Visual Studio 2005. What Visual Studio 2008 has offered a great new experience to target multiple frameworks in one place. Major advancements have arrived in new framework. Ajax extensions comes built in in .net framework 3.5. Support to place web parts in update panel is also supported.This new built in support has allowed us to create more rich and cross platform Ajax application easier. Apart from this, the extensive set of Ajax

templates are also provided in the new framework support. ASP.net 3.5 enhancements for Ajax are totally rewritten for performance and new control types. The existing role management, authentication and authorization are now available as a service. Now we can merge two or more assemblies into one .net assembly with the new .net merge tool. The new controls introduced in Asp.net are LinqDataSource, ListView and DataPager. Talking of framework 3.5, if is a sequel to framework 3.0, and is the latest in frameworks. Its service pack 1 has been released but it is still not comes in windows server 2008. Microsoft has also release a beta version of Framework 4 and Visual Studio 2010 which is available for download. One of the major advancement in Framework 3 and 3.5 is LINQ, though we can use LINQ in Framework 2 as well after installing a separate executable, which is now fully supported automatically. Linq allows us to use and interact with data as an object. Now no matter what type of data we have we can play with them using Linq easily. In Figure below we can have an understanding of the architecture of Linq.

There is rich support for JavaScript coding, debugging, profiling and management in new framework. There is added extended support for JSON, there is design time code validation and checks, also, new design time editor support is provided. If we have a cross chart of major advancements in framework,

New in .NET framework 2.0

It brings a lot of evolution in class of the framework and refactor control including the support of Generics Anonymous methods Partial class Nullable type The new API gives a fine grain control on the behavior of the runtime with regards to multithreading, memory allocation, assembly loading and more Full 64-bit support for both the x64 and the IA64 hardware platforms New personalization features for ASP.NET, such as support for themes, skins and webparts. .NET Micro Framework

New in .NET framework 3.0

Also called WinFX,includes a new set of managed code APIs that are an integral part of Windows Vista and Windows Server 2008 operating systems and provides Windows Communication Foundation (WCF), formerly called Indigo; a service-oriented messaging system which allows programs to interoperate locally or remotely similar to web services. Windows Presentation Foundation (WPF), formerly called Avalon; a new user interface subsystem and API based on XML and vector graphics, which uses 3D computer graphics hardware and Direct3D technologies. Windows Workflow Foundation (WF) allows for building of task automation and integrated transactions using workflows. Windows CardSpace, formerly called InfoCard; a software component which securely stores a person's digital identities and provides a unified interface for choosing the identity for a particular transaction, such as logging in to a website

New in .NET framework 3.5

It implement Linq evolution in language. So we have the following evolution in class: Linq for SQL, XML, Dataset, Object Addin system p2p base class Active directory ASP.NET Ajax Anonymous types with static type inference Paging support for ADO.NET ADO.NET synchronization API to synchronize local caches and server side datastores Asynchronous network I/O API Support for HTTP pipelining and syndication feeds. New System.CodeDom namespace. If we take a look into .net Framework 3.0, we clearly see four major break troughs

Windows Card Space

sWindows card space is a specialized library for identity and authentication. Three main component are Info Card, Digital Identity and Identity Provider. IT provides enhanced security techniques which helps developers to develop more secure and durable websites.

Windows Presentation Foundation

Windows Presentation Foundation or code name Avalon is built for rich media graphics, it is a replacement for windows GDI graphics library. It is a one stop shop for Forms, media, documents and 3d graphics. It is based on XAML (eXtensible markup language) which provides a bridge between developer and graphics designer. Silver Light also uses XAML for displaying its content.

Windows Communication Foundation

Windows Communication foundation or code name Indigo is SOA (Service oriented applications) and built on rich service oriented architecture. The remoting architecture is changed a lot in WCF. WSE 3 introduced with enhance upgrades to Web services. Support of distributed transactions and Message queing are totally rewritten.

Windows Workflow Foundation

It is a workflow foundation for windows based application. It provides both sequential workflows as well as State based workflows. We get a more process oriented view of Software development. Workflows help define the process of an application in a more elite manner.

More notable of point is that .Net 3.5 is not visible in IIS as a separate version, we can just see .Net 2.0 even if there is .Net framework 3.5 installed. Even in windows .Net framework folder, the .Net Framework 3.5 core files reside in .Net framework 2.0 folder and only WPF and WCF libraries are in Framework 3.5 folder. This means that Framework 3 or 3.5 is a wrapper upgrade to Framework 2.0, with support for cross platform and cross framework integration and development.

All in all, .Net framework 3.0 and above is lot more enhanced and still getting better for Rich Internet Applications and Service oriented applications. It is keep getting better and better. As Microsoft's passion is our satisfaction.

Windows Communication Foundation is...

a part of the .NET Framework that provides a unified programming model for rapidly building service-oriented applications that communicate across the web and the enterprise