#Framework Net Architecture and .Net Framework basics

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 inter-operability 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.

Net Framework Base Class Library(BCL or FCL)

Common Language Runtime (CLR) CLS (Common Language Specification) Common Type System (CTS):

Operating system (OS)

Net Architecture and .Net Framework basics:

1. Common Language Runtime (CLR): The heart of the .Net Framework. It is also called the .Net runtime. It resides above the operating system and handles all .Net applications. It handles garbage collection, Code Access Security (CAS) etc.
2. Microsoft Intermediate Language (MSIL) Code: When we compile our .Net code then it is not directly converted to native/binary code; it is first converted into intermediate code known as MSIL code which is then interpreted by the CLR. MSIL is independent of hardware and the operating system. Cross language relationships are possible since MSIL is the same for all .Net languages. MSIL is further converted into native code.
3. Just in Time Compilers (JIT): It compiles IL code into native executable code (exe or dlls). Once code is converted to IL then it can be called again by JIT instead of recompiling that code.
4. Framework class library: The .Net Framework provides a huge class library called FCL for common tasks. It contains thousands of classes to access Windows APIs and common functions like string manipulations, Data structures, stream, IO, thread, security etc.
5. Common Language Specification (CLS): What makes a language to be .Net compliant? Answer is CLS. Microsoft has defined some specifications that each .Net language has to follow. For e.g.: no pointer, no multiple inheritances etc.
    
6. Common Type System (CTS): CTS defines some basic data types that IL can understand. Each .Net compliant language should map its data types to these standard data types. This makes it possible for two .Net compliant languages to communicate by ing/receiving parameters to and from each other. For example CTS defines Int32 for C# int and VB integer data types.
    
7. The .Net Framework: Is a combination of CLR, FCL, ADO.Net and XML classes, Web/Window applications and Web services.

8. 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.
   
   
   9.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. Pre JIT
   2. Econo JIT
   3. Normal JIT
   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.
   
   

   10 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).
   
   
   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.
   
   

   11.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.