election survey comapny in delhi|election survey company|election survey company in rajasthan|election survey company in haryana|political survey company delhi|election survey company in mp|election survey comapny in haryana http://www.horizonss.co.in/politicalsurvey/

1. We Believe in The Power of Single Idea

2. • .Net Framework is a software development platform
developed by Microsoft for building and running
Windows applications. The .Net framework consists
of developer tools, programming languages, and
libraries to build desktop and web applications. It is
also used to build websites, web services, and
games.
Introduction to .NET Framework

3. • The .Net framework was meant to create
applications, which would run on the Windows
Platform. The first version of the .Net framework was
released in the year 2002. The version was called
.Net framework 1.0. The Microsoft .Net framework
has come a long way since then, and the current
version is .Net Framework .NET Framework 4.8 .
Introduction to .NET Framework

4. • .NET Framework supports more than 60
programming languages in which 11 programming
languages are designed and developed by Microsoft.
The remaining Non-Microsoft Languages which are
supported by .NET Framework but not designed and
developed by Microsoft.
Introduction to .NET Framework

5. Introduction to .NET Framework
• Components of .NET Framework
• There are following components of .NET Framework:
• CLR (Common Language Runtime)
• CTS (Common Type System)
• CLS (Common Language Specification)
• BCL (Base Class Library)
• FCL (Framework Class Library)
• .NET Assemblies
• XML Web Services
• Window Services

6. CLR

7. IL Or MSIL
• MSIL stands for Microsoft Intermediate Language. We
can call it as Intermediate Language (IL) or Common
Intermediate Language (CIL). During the compile time ,
the compiler convert the source code into Microsoft
Intermediate Language (MSIL) .Microsoft Intermediate
Language (MSIL) is a CPU-independent set of
instructions that can be efficiently converted to the
native code. During the runtime the Common
Language Runtime (CLR)'s Just In Time (JIT) compiler
converts the Microsoft Intermediate Language (MSIL)
code into native code to the Operating System.

8. IL Or MSIL

9. CLR

10. • First, the developer has to write the code using any dot net
supported programming languages such as C#, VB, J#, etc. Then
the respective language compiler will compile the program into
something called Intermediate language (IL) code. For example,
if the programming language is C#, then the compiler is csc and
if the programming language is VB, then the compiler will be
vbc. This Intermediate Language (IL) code is half compiled code
i.e. partially compiled code and cannot be executed directly by
the operating system. So, when you want to execute this IL code
on your machine, the dot net framework provides something
called CLR or Common Language Runtime which takes the
responsibility to execute your IL Code.
CLR

11. • The CLR takes the IL (Intermediate Language) code and
gives it to something called JIT (Just-in-Time) Compiler. The
JIT compiler takes the IL code and reads each and every line
of the IL code and converts it to machine-specific
instructions (i.e. into binary format) which can be executed
by the underlying operating system.
CLR

12. IL Or MSIL

13. • The Common Language Runtime in the .NET Framework is the
Virtual Machine component that handles program execution for
various languages such as C#, F#, Visual Basic .NET, etc. The
managed execution environment is provided by giving various
services such as memory management, security handling,
exception handling, garbage collection, thread management,
etc.
The Common Language Runtime implements the VES (Virtual
Execution System) which is a run time system that provides a
managed code execution environment. The VES is defined in
Microsoft’s implementation of the CLI (Common Language
Infrastructure)..
Architecture of Common
Language Runtime (CLR)

14. Architecture of Common
Language Runtime (CLR)

15. • There are multiple components in the architecture of Common
Language Runtime. Details about these are given as follows:
• Base Class Library Support: The Common Language Runtime
provides support for the base class library. The BCL contains
multiple libraries that provide various features such as
Collections, I/O, XML, DataType definitions, etc. for the multiple
.NET programming languages.
• Thread Support: The CLR provides thread support for managing
the parallel execution of multiple threads. The System.Threading
class is used as the base class for this.
• operability support.
Architecture of Common
Language Runtime (CLR)

16. • Type Checker: Type safety is provided by the type checker
by using the Common Type System (CTS) and the Common
Language Specification (CLS) that are provided in the CLR to
verify the types that are used in an application.
• Exception Manager: The exception manager in the CLR
handles the exceptions regardless of the .NET Language
that created them. For a particular application, the catch
block of the exceptions are executed in case they occur and
if there is no catch block then the application is terminated
Architecture of Common
Language Runtime (CLR)

17. • Security Engine: The security engine in the CLR handles the
security permissions at various levels such as the code
level, folder level, and machine level. This is done using the
various tools that are provided in the .NET framework.
Debug Engine: An application can be debugged during the
run-time using the debug engine. There are various
ICorDebug interfaces that are used to track the managed
code of the application that is being debugged.
Architecture of Common
Language Runtime (CLR)

18. • JIT Compiler: The JIT compiler in the CLR converts the
Microsoft Intermediate Language (MSIL) into the machine
code that is specific to the computer environment that the
JIT compiler runs on. The compiled MSIL is stored so that it
is available for subsequent calls if required
Architecture of Common
Language Runtime (CLR)

19. • . Code Manager: The code manager in CLR manages the
code developed in the .NET framework i.e. the managed
code. The managed code is converted to intermediate
language by a language-specific compiler and then the
intermediate language is converted into the machine code
by the Just-In-Time (JIT) compiler.
Architecture of Common
Language Runtime (CLR)

20. • Garbage Collector: Automatic memory management is
made possible using the garbage collector in CLR. The
garbage collector automatically releases the memory space
after it is no longer required so that it can be reallocated.
CLR Loader: Various modules, resources, assemblies, etc.
are loaded by the CLR loader. Also, this loader loads the
modules on demand if they are actually required so that
the program initialization time is faster and the resources
consumed are lesser.
Architecture of Common
Language Runtime (CLR)

21. IL Or MSIL
Role of MSIL in a .NET environment
1. Platform Independence:-
Platform independence means that the same file containing byte code
instruction can be placed on any platform; at runtime, the final stage of
compilation can then be easily accomplished so that the code can run on that
particular platform. In other words, MSIL defines a set of portable instructions
that are independent of any specific CPU.
2. Performance Improvement:-
Instead of compiling the entire application at once, the JIT compiler simply
compiles each portion of code as it is called just in time. When code has been
compiled once, the resultant native executable is stored until the application
exists so that it does not need to be recompiled the next time that portion of the
code is run. This process is more efficient than compiling the entire application
code at the start. This shows that the execution of the MSIL code will be almost
as fast as executing native machine code.

22. IL Or MSIL
3. Language Interoperability:-
The use of MSIL facilitates language interoperability. One can compile to MSIL
from one language, and this compiled code should then be interoperable with
code that has been compiled to MSIL from another language. In other words,
MSIL architecture enables the framework to be language neutral. To a large
degree, language choice is no longer dictated by the preference of the developer
or the team. One can even mix languages in a single application. A class and an
exception are thrown in a C#method that can be caught in a VB method.
4. Reducing maintenance headaches:-
MSIL code can be analyzed by the CLR to determine compliance with
requirements such as type safety. Things like buffer overflows and unsafe casts
can be caught at compile-time, greatly reducing maintenance headaches.

23. IL Or MSIL

24. CTS
Common Type System (CTS) describes a set of
types that can be used in different .Net
languages in common . That is , the Common
Type System (CTS) ensure that objects written
in different .Net languages can interact with
each other. For Communicating between
programs written in any .NET complaint
language, the types have to be compatible on
the basic level .

25. s
CTS

26. CTS
• The Common Type System (CTS) standardizes the data
types of all programming languages using .NET under the
umbrella of .NET to a common data type for easy and
smooth communication among these .NET languages.
• How CTS converts the data type to a common data type
• To implement or see how CTS is converting the data type to
a common data type, for example, when we declare an int
type data type in C# and VB.Net then they are converted to
int32. In other words, now both will have a common data
type that provides flexible communication between these
two languages.

27. CTS

28. CLS
• Common Language Specification
• Design a component that is language independent.
• The .Net framework is language independent. This
means the developer writes a program in many
languages such as C#,VB.net.
• Microsoft has defined CLS which is nothing but
guidelines for languages follow so that it can
communicate with other .Net languages. CLS defines a
set of rules and restrictions that every language must
follow which runs under the .net framework. CLS
enables cross-language integration or Interoperability.

29. CLS

30. CLS
• CLS is a subset of the Common type System.
The code that follows the CLS rules is
compatible with all other languages present in
the .net framework.

31. BCL (Base Class Library)
The base class library has a rich collection of
libraries features and functions that help to
implement many programming languages in
the .NET Framework, such as C #, F #, Visual C
++, and more

32. BCL (Base Class Library)

33. BCL (Base Class Library)

34. .NET Framework Class Library (FCL)
• NET Framework Class Library is the collection
of classes, namespaces, interfaces and value
types that are used for .NET applications.
• t contains thousands of classes that supports
the following functions.
• Base and user-defined data types
• Support for exceptions handling

35. .NET Framework Class Library (FCL)
• input/output and stream operations
• Communications with the underlying system
• Access to data
• Ability to create Windows-based GUI
applications
• Ability to create web-client and server
applications
• Support for creating web services

36. BCL (Base Class Library)

37. Thank you!
Visit Us
3rd Floor, Mk Plaza Amrapali West Marg, Vaishali Nagar
Jaipur-302021 Rajasthan
503,Shri Kriti CGHS,Plot No.64,Sec.55
Gurgaon -122002,Haryana
Call :+91-9057710001,2,6
Email: training@horizonss.co.in
http://www.mcainternship.online/