Unit I- Introduction to .NET Framework.pdf

Introduction to .NET Framework

1. Introduction to .NET Framework

.NET is software framework which is developed by Microsoft. In other way .Net is a virtual
machine which compiles and executes programs written in different languages such as Visual
Basic, CPP, C# etc. There are different versions of .NET. Very first version of .NET was released
in 2001 that was 1.0. In a .NET we can develop different types of applications like Web based
applications, Form based applications and Web services. These applications can build for
Windows, for Mobile, for Web etc. and .Net also support to industry standards.


NET Framework maintains more than 60 programming languages in which 11 programming
languages are proposed and developed by Microsoft, these languages are C#.Net, VB.Net,
C++.Net, J#.Net,F#.Net, C OMEGA, IRON Ruby and Python, JScript.Net, Windows powershell
and ASML (Abstract State Machine Language). Whereas remaining programming languages are
not designed and developed by Microsoft but it is supported by NET Framework.

.NET framework supports to the important feature that is Object Oriented Programming.
It provides the code execution environment which makes code execution safe and also minimize
the software deployment and version problems.

Features of .NET

Due to following features .NET is a wonderful platform for developing modern applications.

• Variety of Functionality
.NET framework offers a affluent set of functionality out of the box. It includes hundreds of classes
that provide variety of functionality ready to use in your applications. There is no need find low
level details.

• Effortless Expansion of web applications
Dynamic and data driven web applications development is possible due to ASP.NET technology
available on .NET platform. ASP.NET offers an complex user interface event driven programming
model (similar to Visual Basic 6 that simplify development of web pages mostly called as web
forms).

• Support Object Oriented Programming Feature
.NET provides a completely object oriented environment and we are very well familiar with Object
Oriented programming features. As Object is consider as mother of all so languages like Visual
Basic.NET now support many of the Object Oriented features that were absent traditionally.

• Embrace Multiple Languages
.NET supports multiple languages like C++, C#, Jscript.NET etc . This means that if you very
well are familiar with C++ languages then you have to just mould them to suit .NET environment.
Currently four languages are available such as Visual Basic.NET, C# (pronounced as C-sharp),
Jscript.NET and Managed C++ (a dialect of Visual C++).

2. .
• Handles Multi-Devices
.NET provides capable platform for programming with multiple devices such as PDAs, mobiles
and handheld PCs. As Modern life style is increasingly embracing mobile and wireless devices so
programming with such devices is great support.

• Automatic memory management
In .NET developers don’t have to worry about memory management. It is tedious task because
while developing applications developers had to develop an eye on system resources like memory.
Memory leaks were major reason in failure of applications. But NET handles memory on its own.
The garbage collector takes care of freeing unused objects at appropriate intervals.

• No more DLL Hell
In .COM world “DLL hell” is very famous term. Also DLL clash are a frequent fact in COM
world. The main reason behind this was “one version of component across machine”. Also, COM
components require registration in the system registry. .NET ends this DLL hell by allowing
applications to use their own copy of dependent DLLs. Also, .NET components do not require any
kind of registration in system registry.

• Strongly Support to XML
Mostly all are well-known with XML. XML has powerful industry support that almost all the
dealers have freed some kind of upgrades or patches to their existing software to make it “XML
compatible”. .NET Strongly Support to XML and it is the only platform that has built with XML
right into the core framework. .NET provides XML web services that are based on standards like
HTTP, XML and SOAP.

• Effortlessness of deployment
Windows applications Deployment particularly COM components were always been a tedious job.
Since .NET does not require any registration as such, much of the deployment is simplified.

• Security Mechanisms
Windows platform was always criticized for poor security mechanisms. Microsoft has taken great
efforts to make .NET platform safe and secure for enterprise applications. Features such as type
safety, code access security and role based authentication make overall application more robust
and secure





.NET Framework Design Goals

3. Following are the main design goals of Microsoft .NET framework:
1. Component Infrastructure
2. Language Integration
3. Internet Interoperation
4. Simple Development
5. Simple Deployment
6. Reliability
7. Security
Component Infrastructure: Previously COM technology does not integrate binary libraries
without referring to or alter their source code. Although COM permits you to integrate binary
components developed using any language, it requires to follow COM identity and rule. And
you may have to rewrite similar code but .NET removes them. In .NET all classes are ready to
be reused at binary level. You don’t have to write extra code.
Language Integration: .NET supports not only language independence but also language
integration. It mean that you can inherit classes, take benefit of polymorphism also. .NET
make this possible with the specification called Common Type System(CTS). .NET base
classes provide base system types eg. Integer, string etc. Because every language compiler
must get minimum set of rules specified by CLS.
Internet Interoperation: The .NET frame work uses open, simple and lightweight protocol
i.e. SOAP protocol for distributed computing which is based on widely accepted XML and
HTTP standards.
Simple development: Suppose you have to develop software for the particular platform such
as Windows platforms. Each time you set out to develop something in a different compiler,
you had to learn a new API or a class library, because there is no consistency or commonality
among these different libraries or interfaces.
NET solution provides a set of framework classes and so that every language can used it.
Therefore no need to learn new API. So development becomes simple.
Simple Deployment (use): .NET uses shared DLL with which it was built. Shared DLL have
unique hash value, public key, local and version number therefore its physical file name is no
longer important. .NET don’t need component related register setting. In .NET you can simply
copy your file from one directory to another directory.
Reliability: .NET requires type safety. Every class in .NET is derived from the mother of all
classes, objects, which support runtime type-identification features etc. .NET supports
exceptions in the CLR which provides error handling mechanism.

4. Security: .NET Provides number of security features. . Net protects access to specific part of
the executable code. . For example, to take advantage of declarative security checks, you can
prefix your method implementations with security attributes without having to write any code.
To take advantage of imperative security checks, you write the code in your method to
explicitly cause a security check. There are many other security facilities that .NET provides
in an attempt to make it harder to penetrate your applications and system.















.NET FRAMEWORK:
.NET Framework is ready to use collection of classes and, interfaces and libraries for
developing particular type of application. Frameworks are collection of reusable classes that
present software design and code that can be recycled for various applications.

5. As shown in given diagram. NET framework sits on the top of operating system. .NET is
essentially a system application that runs on windows.



Fig: .NET Framework
The most important component of Framework is CLR. It is the execution engine that
handles running applications. CLR activates objects, perform different services such as security
checks on them, put them out in the memory, executes them and garbage collect them.
CLR is similar to JVM(Java Virtual Machine), JVM support to Java language and the CLR
support to all languages. JVM runs on multiple platforms whereas .NET code runs only on
Windows platforms.
On the top of CLR there is set of framework base classes, these set of classes is similar to
the classes in Java. These classes supports elementary input output functionality, string
manipulation, security management , network communication, thread management, text
management , reflection and collection functionality and other functionality.
At the top of base classes there is a set of classes that support data management and XML
manipulation. Data classes support data management which includes SQL, ADO.NET classes.
.NET framework support classes that manipulate XML data, perform XML searching etc.
There are classes in three different technologies such as web services, web form and
windows form. Web services include a number of classes that supports to distributed components.
These components supports plug and play across cyberspace because it uses HTTP and SOPE.

6. Web Forms includes number of classes that allow you to develop web graphical User
Interface (GUI) applications.
Windows Forms supports set of classes that allow you to develop native windows GUI
applications.
.NET applications are written in the C#, F#, or Visual Basic programming language. Code
is compiled into a language-agnostic Common Intermediate Language (CIL). Compiled code is
stored in assemblies—files with a .dll or .exe file extension. When an app runs, the CLR takes the
assembly and uses a just-in-time compiler (JIT) to turn it into machine code that can execute on
the specific architecture of the computer it is running on as shown in following figure.

Fig: .Visual overview of CIL & CLR.


The following are key component of .NET Framework:
1. The Common Type System (CTS)
2. The Common Language Specification (CLS)
3. The Common Language Runtime (CLR)

The Common Type System (CTS)
The common type system is a formal definition of how all type in the .net framework are
connected, declared, used and managed. .NET treats all language as equal therefore class

7. written in c# should same to class in vb.net etc. So to make language integration , Microsoft
specifies CTS.
CTS specify how type’s classes are reference and how applications and class libraries are
packaged for execution on CLR. It defines class declaration, inheritance, referencing and
type management as .NET Framework.
CTS supply the following ground works for the .NET framework:
● CTS provide the first class, pure object oriented model supported by all
programming languages.
● CTS establish the foundation and reference framework for cross language
integration, interoperation, type safety, security and high performance code
execution.
● CTS defines rule that languages must follow, which ensures that objects written in
different languages can interact with each other.
Microsoft .NET support rich set of types but the important types are value type,
reference type, classes, interfaces and delegates.
Value types: It represents the value allocated on stack. They can not be null must contain some
value. Values are passed by value to the function it means that original value would not
change. Value types includes primitives, structure and enumeration.
Reference Type: It includes object, interfaces and pointer. It contains reference to the object and
it can be null.
Classes: CLR provides full support of OO concepts and class features such as methods, fields,
static members, visibility , nested type etc.
Interfaces: It is exactly the same concept as C++ abstract base classes. An interface may contain
method , properties, events ,indexer. In .NET a class can derived from multiple interfaces.
Delegates: Microsoft .NET support type safe version of function pointer called delegates.

Common Language Specification (CLS)
.NET is generally call “many language for one platform”. We can construct classes and
components that can be used by any language and its respective IDEs and development
tools, without the need for complex COM and ActiveX interfaces and registration details.
To achieve this, CLS requires that classes and component providers should expose only
the features that are common to all .NET languages.
CLS is a subset of CTS (Common Type System). Main goal of .NET is that program written
in any language should interoperate with one another taking advantage of inheritance,
polymorphism etc. However languages are not equal, they all have their own features but
Microsoft publish CLS to put all language on same sheet. CLS specifies series of rules that
are require for language integration and interoperation. Due to this classes of one language
can inherit in other language, objects of one language can pass to other language. So that
maximum code can be reuse. There are so many software development features such as
general, naming, types, types members, method, properties, event, pointers, arrays,

8. interfaces etc, these features must meet CLS compliance rules and indicates whether the
features applies to both developers and compiler or only to compiler.

Common Language Runtime (CLR)
Visual Basic.NET applications, class libraries and components live in two realities. One is
design time reality and other is runtime reality.
The design time reality is one where you design applications, write source code, create
classes and objects, debug and compile your code. Run time reality is an external
environment and this environment is a Common Language Runtime mostly known as CLR.
The code that targets the CLR is called managed code. It means that code execution in
runtime environment is managed by CLR.
The CLR is a hosted execution environment before it can bootstrap on target platform, the
CLR’s host must be supported on that platform.
CLR activates objects, perform security check on them, put them in memory executes
them and garbage collect them.
There are many components in CLR as shown below:

Fig: Major CLR components: the virtual execution system
As shown in figure at the top there is .NET PE (Portable Executable) files layer and
executes within CLR’s Virtual Execution System which host the major component of
runtime. .NET PE files will have to go through class loader, verifier, JIT compiler and
other execution support components before it executes.
Class loader loads the .NET classes in memory and prepare them for execution. Verifier is
a component that executes at runtime to verify that code is type safe. JIT compiler converts
the IL code to native (object) code so that it can execute on target operating system. Code
manager uses managed data to control the execution of code, also include exception
handling, security check, garbage collection and management services.
For example: Code for “Hello World” in VB.NET

9. Imports System
Public Module modmain
Sub Main()
Console.WriteLine(“Hello World”)
End Sub
End Module
To compile this code use
vbc /t:exe /out:hello.exe hello.vb
Microsoft provide command line compiler, vbc, for VB.NET. the /t option specify the type
of PE file to be created. In this case we have specified an EXE, hello.exe will be the output of this
command.

Intermediate Language (IL)/ MSIL:
When you compile your visual basic .NET source code, it is converted into intermediate
language (IL) so that CLR and other .NET development environment can understand it. MSIL is
a CPU-independent set of instructions that can be efficiently converted to native code. All .NET
languages compile code into IL, which is known as Microsoft Intermediate Language MSIL or IL.
MSIL includes instructions for loading, storing, initializing, and calling methods on
objects, as well as instructions for arithmetic and logical operations, control flow, direct memory
access, exception handling, and other operations. Once MSIL code is generated it packaged with
its metadata in an assembly. Before code can be executed, MSIL must be converted to CPU-
specific code by a just in time (JIT) compiler.
There are many advantages of IL such as compilation process is much quicker because you
don’t have to compile to machine code just to run debug builds. Development environment of
other .NET languages can use components and class libraries from other languages because at IL
level all code is same.
There are some drawbacks of IL such as IL is not compile to machine code so it can more
easily be reverse engineered. As IL is further compile to machine code, a small algorithm will
require a direct unwrapped access to system resources and hardware.

Assemblies:
Assembly is a physical container for at least one built executable or class file, module
component or icon. An assembly is a compiled code library used for deployment, versioning and
security. Assembly consists of one or more code modules.

10. Microsoft .Net Assembly is a logical unit of code, that contains code which the Common
Language Runtime (CLR) executes. It is the smallest unit of deployment of a .net application and
it can be a .dll or an exe .

An assembly is a grouping of files deployed as a single file. An assembly almost always
consists of at least two files: the executable and the manifest. The manifest is a list of all the files
that exist inside the assembly.
Assembly can be library or executable file. If the assembly is a library then the class or classes are
refereed by fully qualified namespace. If the assembly is an executable file, an application which
is referred by the name of physical file, needs an entry point to allow OS to initiate its execution.
For example if we create an application called “welcome” then welcome.exe is an assembly.
We can separate assembly in four types,
Console executable: This assembly is standard and GUI less console window file. Console
assembly have .exe extension and it OS entry is through Main.
Windows executable: This assembly is standard .NET windows file and has .exe extension and it
OS entry is through WinMain.
Class library: This is standard .NET class library. These assembly have .DDL extension and OS
entry into the library is via DLLMain.
Class module: This is standard class module, which contains compiled class. It has .netmodule
extension.
Assembly cab be of different nature such as static, dynamic, private or shared.
Static assembly: This is a file created when you compile and build class library.
Dynamic assembly: This is memory occupant module , which allow you to access runtime type
information.
Private assembly: It is access only by specific application.
Shared assembly: Any application can use it and dynamic assembly can also be shared one.


Garbage Collection (Automatic memory management):
CLR support automatic memory management for all. NET objects. The garbage collector (GC) is
used when your objects are no longer being referenced and performed garbage collection to recover
the unused memory.
Automatic memory management only frees resources held by outdated objects. The
finalization of objects in GC world of automatic memory management is non-deterministic. It
means you cannot predict exactly when an object will remove from memory. Garbage collection
can be block then CLR controls GC.
CLR allows you some management over GC. The collection of GC classes and methods are
at your request. But you cannot force the collection or make the cleanup deterministic. GC is very
fast, so quickly it disposes an object and frees its resources.

11. Namespaces:
Namespaces allow classes, structures and other items to be grouped and organized and remove the
possibility of class-naming conflicts. As programming languages have progressed, the frameworks
around them have greatly increased in size. The .NET framework provides a huge number of base
classes, data types, algorithms, etc. If every one of these items had to be declared with a unique
name, the naming task would be equally large and would leave very few good names available for
the .NET developer.
To ensure that naming conflicts do not occur, either within the .NET framework or in your own
programs, namespaces are used. A namespace simply provides a named group of classes,
structures, enumerations, delegates, interfaces and other namespaces. Within the namespace, all
declared items must be uniquely named. However, the same name may be duplicated in different
namespaces. This means that if you decide to create a mathematics library you will be able to call
it 'Math' even though Microsoft have also provided a Math library.
The VB.Net "Imports" keyword is used to add a reference of a namespace manually.

Example
1. Imports System
Note: Imports allow access to classes in the referenced Namespace only not in its internal or child
Namespaces. If we want to access internal Namespace we might need to write:
1. Imports System.Collections
We can't build a VB.NET application without using classes from the .NET System namespace.
When we want to use a Windows form, for example, you must use the
System.Windows.Forms.Form class. A button in a Windows form comes from the
System.Windows. Forms.Button class, and so on. There are many such classes, organized into
various namespaces like System.Windows.Forms.
Here's an overview of some namespaces other than System and System.Collections:
System.Data-Includes classes that make up ADO.NET. ADO.NET lets you build data-handling
components that manage data from multiple distributed data sources.
System.Data.OleDb-Includes classes that support the OLE DB .NET data provider.
System.Data.SqlClient-Includes classes that support the SQL Server .NET data provider.
System.Diagnostics-Includes classes that allow you to debug your application and to step through
your code. Also includes code to start system processes, read and write to event logs, and monitor
system performance.
System.Drawing-Provides access to the GDI+ graphics packages that give you access to drawing
methods.
System.Drawing.Drawing2D-Includes classes that support advanced two dimensional and vector
graphics.
System.Drawing.Imaging-Includes classes that support advanced GDI+imaging.
System.Drawing.Printing-Includes classes that allow you to customize and perform printing.

12. System.Drawing.Text-Includes classes that support advanced GDI+typography operations. The
classes in this namespace allow users to create and use collections of fonts.
System.Globalization-Includes classes that specify culture-related information, including the
language, the country/region, calendars, the format patterns for dates, currency and numbers, the
sort order for strings, and so on.
System.IO-Includes types that support synchronous and asynchronous reading from and writing
to both data streams and files.
System.Net-Provides an interface to many of the protocols used on the Internet.
System.Net.Sockets-Includes classes that support the Windows Sockets interface. If you've
worked with the Winsock API, you should be able to develop applications using the Socket class.
System.Reflection-Includes classes and interfaces that return information about types, methods,
and fields, and also have the ability to dynamically create and invoke types.
System.Security-Includes classes that support the structure of the common language runtime
security system.
System.Threading-Includes classes and interfaces that enable multithreaded programming.
System.Web-Includes classes and interfaces that support browser/server communication.
Included in this namespace are the HTTPRequest class that provides information about HTTP
requests, the HTTPResponse class that manages HTTP output to the client, and the
HTTPServerUtility class that provides access to server-side utilities and processes. You can also
use cookies, support file transfer, and more with these classes.
System.Web.Security-Includes classes that are used to implement ASP.NET security in Web
server applications.
System.Web.Services-Includes classes that let you build and use Web services, programmable
entities on Web Server that code can communicate with using standard Internet protocols.
System.Windows.Forms-Includes classes for creating Windows-based forms that make use of
the user interface controls and other features available in the Windows operating system.
System.Xml-Includes classes that support processing of XML.

Namespaces are basically used to avoid naming collisions, when we have multiple classes with
the same name, and it is also helpful for organizing classes libraries in a hierarchal structure.
Namespaces allow us to organize Classes so that they can be easily accessed in other applications.
Namespaces also enable reusability.

The End to DLL Hell:
Dll Hell refers to a set of problems caused when multiple applications attempt to share a common
component like a dynamic link library (DLL).

13. For example before some time, if we install an application then dll of that application get stored in
the registry, then if we install other application that has same name .dll that means previously
installed .dll get overwrite by the same name new .dll. Ok for newly installed application but
previously installed application cant get execute further. This is big problem in context of version
of same application. This is Dell-Hell problem.
This problem of dynamic link library (.dll) is resolved through Versioning. Versioning is the
technique to provide version to the .dll to prevent them from replacement. In .NET as long as you
keep the old component around, the application can still reference it. Newer version of the
component can be install to the machine as needed by the newer application. Therefore you don’t
need to register the DLL and components.
To add version in assembly just write in Program :



Managed Execution:
.NET just-in-time compiler has been engineered to preserve both memory and resources while
giving maximum throughput. Whenever code needs to be compiled immediately, the function
JIT compilation is done.

14. Managed execution is not a single process but it is stack of many operations. The following list is
a reduced stack that represents beginning to end of .NET application:
1. Code is generated by developer.
2. Code is compiled to MIL.
3. Code is described with metadata and gathered into an assembly.
4. Code check prior to execution (To make sure nothing malicious has been included).
5. Code is JIT compiled (convert MSIL code to CPU specific code).
6. Code is executed.
7. Code execution is managed (GC management)
8. Code is terminated and resources are freed.
Managed execution also describe what the CLR does once it has loaded and executed an
application. Three sophisticated operations on CLR that influence application design and
construction are side by side execution, garbage collection and isolation of application.