Microsoft .NET is a framework for distributed, portable, scalable computing. This article discusses the features of the framework and the related terminologies, provides an insight to its architecture, and then discusses ASP.NET, ADO.NET, Web Services, Remoting, and the robust security model that this framework is designed on.

Features of the .NET Framework

The Microsoft .NET Framework has the following features:

·         Portability

·         Cross Language Integration

·         Interoperability

·         Common Runtime Engine

·         Base Class Library

·         Fast development

·         Simplified Deployment

·         Security

The Common Language Specification

It is a set of language-independent conventions intended to promote language interoperability for programs running inside the runtime environment. It defines types, methods, properties, fields, etc.

The Common Type System

The Common Type System (CTS) is a standard that defines a set of types and rules for creating new types and enables multi-language integration in the .NET environment. The common type system supports the following types:

·         Value Types

·         Reference Types

Value types are created in the stack, and reference types are created in the managed heap. The primitive types, structs, and enums are all examples of value types. Reference types are arrays, objects, etc. The conversion of a value type to a reference type is called boxing; un-boxing is the conversion of a reference type to a value type.

At runtime, the type checker ensures the validity of all objects within the runtime environment. It makes sure that only valid operations are performed on the code and throws exceptions on violations of the same.

.NET Framework Class Library

The .NET Framework Class Library (FCL) is a set of managed classes that provide a lot of services. The following are some of the language independent services provided by the FCL:

·         File Handling

·         Remoting

·         Sockets

·         Database access

·         XML

The Common Language Runtime

The CLR is a runtime engine that handles memory allocation, security, code verification, type verification, exception handling, and garbage collection. Managed code is one that runs in the context of the CLR and is hence managed by the common language runtime itself.

The source code in .NET is compiled to an intermediate language called the Microsoft Intermediate Language or the MSIL. This is then converted to the native code at runtime by the Just In Time Compiler (JIT).

CLR Services

The CLR provides a lot of services for applications that run in the .NET environment. These include:

·         Just In Time Compilation

·         Memory management and isolation of the application memory

·         Garbage Collection

·         Code Verification

·         Code Access Security

·         Verification of type safety

·         Exception handling

·         Conversion of the MSIL to the native code

·         Access to metadata

Assembly

An assembly is a group of resources and types, along with metadata about those resources and types, that is deployed as a single unit.

MSIL

The source code of the .NET languages is not converted into the native code. Rather, it is compiled into a machine-independent intermediate code known as Microsoft Intermediate Language or the MSIL.

The JIT compiler

The MSIL code and metadata are loaded into the memory with the help of Common Language Runtime (CLR). The JIT compiler then compiles the MSIL code to native code and executes it at runtime. The JIT does not convert the entire MSIL code to its native equivalent. Rather, it does so in demands, i.e., the portion of the current execution code is converted and loaded into the memory. Hence, it works the same way that Demand Paging works in Virtual Memory supporting Operating Systems. 

Garbage Collection

The Garbage Collector is responsible for cleaning up the unused objects in the runtime environment. Objects are generally created in the managed heap. Here the term 'managed' implies that it is cleaned implicitly by the Garbage Collector. The garbage collector works based on these principles:

·         Small objects are generally short-lived and frequently accessed.

·         Larger objects are longer-lived.

·         Heap compaction of the large objects to minimize heap fragmentation

Code Verification

This is a feature that enforces type safety and checks the code prior to its execution in the runtime environment. This disallows illegal operations inside the runtime environment and hence prevents an application running in the context of the runtime environment from crashing. Programs running in the runtime environment have restricted access to memory and devices of the system.

ASP.NET

ASP.NET is a language-neutral, interoperable server side technology that allows creation, execution, and deployment of scalable Web Applications and Services. The advantages of ASP.NET over traditional ASP are:

·         Language Neutrality

·         Code Separation with the help of code behind file

·         Better State Management

·         Enhanced XML support

·         Support for pre-compilation of the ASP.NET pages

ADO.NET

ADO.NET provides support for data access in Microsoft .NET and its features include:

·         Support for disconnected data access model

·         Integration with the .Net framework

·         XML support

This model can, however, only be used from the managed code environment. This implies that there is no COM interoperability allowed for ADO.NET.

Web Services

A web service is a platform–independent software component that contains a group of functions that are packaged together for use in a common framework throughout a network. Web services are based on the Simple Object Access Protocol or SOAP.

.NET Remoting

This is a concept that enables different applications residing on remote systems to communicate with one another. The .NET objects are exposed to remote processes, hence allowing inter-process communication between even remote systems. The remote objects are accessed through channels that physically transport the messages to and from the remote objects.

.NET Security

Microsoft .NET follows compact security architecture that is basically composed of but is not limited to:

·         Authentication

·         Authorization

·         Impersonation

The .NET Framework uses authentication to verify the credentials of the individual users. Authorization is used to determine the accessibility of a particular resource that a user is entitled to. Impersonation is the process by virtue of which a resource can be accessed under a different identity. The following are the types of security that the .NET Framework supports:

·         Code Access Security (CAS)

·         Evidence Based Security

·         Role Based Security

·         Declarative and Imperative Security

·         Cryptography

 

Conclusion

Microsoft .NET is a device and platform-independent distributed computing model based on open XML communication technology and helps integrate users, devices, and applications for the different environments. It promises to be the technology of choice for building robust, scalable, portable applications for a long time to come.

 

For Further Reading

http://www.midnightbeach.com/jon/pubs/2002/BorCon.London/dotNetArchitecture.html

http://www.gotdotnet.com/team/clr/about_clr.aspx

http://www.gotdotnet.com/team/clr/about_security.aspx

http://www.c-sharpcorner.com/Code/2002/Aug/GCinNet.asp

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpguide/html/cpconthecommontypesystem.asp

http://www.c-sharpcorner.com/Articles/CompilationOfCSharpProgram.asp