Unit-1 8hrs

Introduction to C# and .NET platform and Building C# applications

Introduction to C# and .NET platform: .NET solution, Building blocks of the .NET platform, Role
of .NET base class libraries, .NET aware programming languages, Role of CIL, Role of Type
Metadata, Role of Assembly Manifest, Tour of .NET namespaces.
Building C# applications: Role of command line compiler(csc.exe), Building a C# application using
csc.exe, command line debugger(cordbg.exe), Introduction to visual studio .NET IDE and its
debugging, C# pre-processor directives.
The .NET Solution Microsoft recognized these factors and they introduced the .NET considering all
these factors. All unwanted complexities are eliminated and a pure object oriented programming
model was introduced. .NET framework comes with a single class library. Whether programmer write
the code in C# or VB.NET or J#, it doesn’t matter, one just use the .NET class library. There is no
class’s specific to any language. One can write code in C# or VB.NET with the same number of lines of
code, same performance and same efficiency, because everyone uses same .NET class library.
Introduction to .NET Framework

The .NET Framework is a software development platform that was introduced by Microsoft in the
late 1990 under the NGWS. On 13 February 2002, Microsoft launched the first version of the .NET
Framework, referred to as the .NET Framework 1.0.

In this section, we will understand the .NET Framework, characteristics, components, and
its versions.

What is .NET Framework

It is a virtual machine that provide a common platform to run an application that was built using the
different language such as C#, VB.NET, Visual Basic, etc. It is also used to create a form based,
console-based, mobile and web-based application or services that are available in Microsoft
environment. Furthermore, the .NET framework is a pure object oriented, that similar to the Java
language. But it is not a platform independent as the Java. So, its application runs only to the windows
platform.

The main objective of this framework is to develop an application that can run on
the windows platform. The current version of the .Net framework is 4.8.

Note: The .NET Framework is not only a language, but it is also a software and language
neutral platform.
Components of .NET Framework

There are following components of .NET Framework:

1. CLR (Common Language Runtime)

2. CTS (Common Type System)
3. BCL (Base Class Library)
4. CLS (Common Language Specification)
5. FCL (Framework Class Library)
6. .NET Assemblies
7. XML Web Services
8. Window Services

CLR (common language runtime)

It is an important part of a .NET framework that works like a virtual component of the .NET
Framework to executes the different languages program like c#, Visual Basic, etc. A CLR also helps
to convert a source code into the byte code, and this byte code is known as CIL (Common
Intermediate Language) or MSIL (Microsoft Intermediate Language). After converting into a byte
code, a CLR uses a JIT compiler at run time that helps to convert a CIL or MSIL code into the
machine or native code.

It is a program execution engine that loads and executes the program. It converts the program
into native code. It acts as an interface between the framework and operating system
 • Suppose we have written a C# program and save it in a file.
• Language specific compiler compiles the source code into the MSIL(Microsoft Intermediate
Language) which is also know as the CIL(Common Intermediate
Language) or IL(Intermediate Language) along with its metadata.
• Metadata includes the all the types, actual implementation of each function of the program.
MSIL is machine independent code.
• Now CLR comes into existence. CLR provides the services and runtime environment to the
MSIL code. Internally CLR includes the JIT(Just-In-Time) compiler which converts the
MSIL code to machine code which further executed by CPU.

• Common Language Specification (CLS) : It is responsible for converting the different .NET
programming language syntactical rules and regulations into CLR understandable format.
Basically, it provides the Language Interoperability.
• Common Type System (CTS) :Every programming language has its own data type system, so
CTS is responsible for understanding all the data type of system.
• Garbage Collection (GC): It is used to provide the Automatic Memory Management feature.
• Just In – Time Compiler (JIT) : It is responsible for converting the CIL(Common
Intermediate Language) into machine code or native code using the Common Language
Runtime environment.

CTS (Common Type System)

It specifies a standard that represent what type of data and value can be defined and managed in
computer memory at runtime. A CTS ensures that programming data defined in various languages
should be interact with each other to share information. For example, in C# we define data type as int,
while in VB.NET we define integer as a data type.
The language interoperability, and .NET Class Framework, are not possible without all the language
sharing the same data types. What this means is that an “int” should mean the same in VB, VC++, C#
and all other .NET compliant languages. Same idea follows for all the other data types. This is
achieved through introduction of Common Type System (CTS).

Common type system (CTS) is an important part of the runtimes support for cross language
integration. The common type system performs the following functions:

• Establishes a framework that enables cross-language integration, type safety, and high performance
code execution.

• Provides an object-oriented model that supports the complete implementation of many programming
languages.

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.
Furthermore, BCL divides into two parts:

1. User defined class library

o Assemblies - It is the collection of small parts of deployment an application's part. It
contains either the DLL (Dynamic Link Library) or exe (Executable) file.
1. In LL, it uses code reusability, whereas in exe it contains only output file/ or
application.
2. DLL file can't be open, whereas exe file can be open.
3. DLL file can't be run individually, whereas in exe, it can run individually.
4. In DLL file, there is no main method, whereas exe file has main method.
2. Predefined class library
o Namespace - It is the collection of predefined class and method that present in .Net.
In other languages such as, C we used header files, in java we used package similarly
we used "using system" in .NET, where using is a keyword and system is a
namespace.

Cts and cls

o CTS and CLS are parts of .NET CLR and are responsible for type safety within the
code. Both allow cross-language communication and type safety. In this article, I
would like to expose the relationship between these two.
o CLS
o CLS stands for Common Language Specification and it is a subset of CTS. It defines
a set of rules and restrictions that every language must follow which runs under the
.NET framework. The languages which follow these set of rules are said to be CLS
Compliant. In simple words, CLS enables cross-language integration or
Interoperability.
o For Example
o if we talk about C# and VB.NET then, in C# every statement must have to end with a
semicolon. it is also called a statement Terminator, but in VB.NET each statement
should not end with a semicolon(;).
o Explanation of the above Example
 o So these syntax rules which you have to follow from language to language differ but
CLR can understand all the language Syntax because in .NET each language is
converted into MSIL code after compilation and the MSIL code is language
specification of CLR.
o CTS
o Common Type System (CTS) describes the datatypes that can be used by managed
code. CTS defines how these types are declared, used and managed in the runtime. It
facilitates cross-language integration, type safety, and high-performance code
execution. The rules defined in CTS can be used to define your own classes and
values.
o OR we can also understand like,
o CTS deals with the data type. So here we have several languages and each and every
language has its own data type and one language data type cannot be understandable
by other languages but .NET Framework language can understand all the data types.
o C# has an int data type and VB.NET has Integer data type. Hence a variable declared
as an int in C# and Integer in VB.NET, finally after compilation, uses the same
structure Int32 from CTS.
o All the structures and classes available in CTS are common for all .NET Languages
and the purpose of these is to support language independence in .NET. Hence it is
called CTS.

CLS (Common language Specification)

It is a subset of common type system (CTS) that defines a set of rules and regulations which should be
followed by every language that comes under the .net framework. In other words, a CLS language
should be cross-language integration or interoperability. For example, in C# and VB.NET language,
the C# language terminate each statement with semicolon, whereas in VB.NET it is not end with
semicolon, and when these statements execute in .NET Framework, it provides a common platform to
interact and share information with each other.

Microsoft .NET Assemblies

A .NET assembly is the main building block of the .NET Framework. It is a small unit of code that
contains a logical compiled code in the Common Language infrastructure (CLI), which is used for
deployment, security and versioning. It defines in two parts (process) DLL and library (exe)
assemblies. When the .NET program is compiled, it generates a metadata with Microsoft Intermediate
Language, which is stored in a file called Assembly.

FCL (Framework Class Library)

It provides the various system functionality in the .NET Framework, that includes classes, interfaces
and data types, etc. to create multiple functions and different types of application such as desktop,
web, mobile application, etc. In other words, it can be defined as, it provides a base on which various
applications, controls and components are built in .NET Framework.
Key Components of FCL

1. Object type
2. Implementation of data structure
3. Base data types
4. Garbage collection
5. Security and database connectivity
6. Creating common platform for window and web-based application

In the common language runtime (CLR), the garbage collector (GC) serves as an automatic
memory manager. The garbage collector manages the allocation and release of memory for an
application. Therefore, developers working with managed code don't have to write code to
perform memory management tasks. Automatic memory management can eliminate common
problems such as forgetting to free an object and causing a memory leak or attempting to
access freed memory for an object that's already been freed.

Benefits

• The garbage collector provides the following benefits:

• Frees developers from having to manually release memory.
• Allocates objects on the managed heap efficiently.

Reclaims objects that are no longer being used, clears their memory, and keeps the memory
available for future allocations. Managed objects automatically get clean content to start with,
so their constructors don't have to initialize every data field.

Provides memory safety by making sure that an object can't use for itself the memory
allocated for another object.
Characteristics of .NET Framework

1. CLR (Common Language Runtime)

2. Namespace - Predefined class and function
3. Metadata and Assemblies
4. Application domains
5. It helps to configure and deploy the .net application
6. It provides form and web-based services
7. NET and ASP.NET AJAX
8. LINQ
9. Security and Portability
10. Interoperability
11. It provides multiple environments for developing an application

Versions of .NET Framework

1. On 13 February 2002, Microsoft launched first version of .Net framework 1.0.

2. The second version 2.0 of .net framework was launched on 22 January 2006.
3. Third version 3.0 of .Net framework was released on 21 November 2006.
4. A .Net framework version 3.5 was released on 19 November 2007.
5. Version 4.0 of .Net framework was released on 29 September 2008
6. Version 4.5 of .Net framework was released on 15 August 2012.
7. .Net framework 4.5.1 version was announced on 17 October 2013
8. On 5 May 2014, a 4.5.2 version of .Net framework was released.
9. .Net framework 4.6 version was announced on 12 November 2014
10. .Net framework 4.6.1 version was released on 30 October 2015
11. .Net framework 4.6.2 version was announced on March 30, 2016
12. .Net framework 4.7 version was announced on April 5, 2017
13. .Net framework 4.7.1 version was announced on October 17, 2017
14. Version 4.7.2 of .Net framework was released on 30 April 2018.
15. And currently we are using .Net framework version 4.8 that was released on 18 April 2019
Describe the .Net base class library.

- It is a library of classes, interfaces, and value types.

- This library system functionality and is the foundation of .NET Framework applications,
components, and controls are built.

- The .NET base class library exists in order to encapsulate a huge number of common functions and
makes them easily accessible to the developer.

- It provides the functionality like ADO.NET, XML, Threading, IO, Security, Diagnostics, Resources,
Globalization, collections etc.

- It serves as the main point of interaction between developer and runtime.

- The .Net base class library provides namespaces which are frequently used, some of them are as
follows:

Namespaces Description

System It contains fundamental classes and base classes that define commonly-
used value and reference data types, events and event handlers, interfaces,
attributes and processing exceptions.

System.Activities It contains all the classes necessary to create and work with activities in
Windows Workflow Foundation.

System.Collections It contains types that define various standard, specialized and generic
collection objects.

System.Configuration It contains types that define various standard, specialized and generic
collection objects.

System.Data It contains classes for accessing and managing data from diverse sources.

System.Deployment It contains types that define support deployment of ClickOnce application.

System.EnterpriseServices It contains types that define the com+services architechture, which

provides an infrastructure for enterprise application.

System.Globalization It contains classes that define culture-related information, including

language, country/region, calenders in use, currency.

System.IO It contains types that support input and output, including the ability to read
and write data to streams either synchronously or asynchronously.

System.Linq It contains types that support queries which is used Language-Integrated

Query (LINQ). It includes types that represent queries as objects in
expression trees.
System.Management It contains a type that provides access to management information and
management events about the system, devices and applications
instrumented to the Windows Management Instrumentation (WMI)
infrastructure.

System.Net It contains classes that provide a simple programming interface for a

number of network protocols.

System.Printing It contains types that support printing. It provides access to the properties
of print system objects.

System.Runtime It contains types that support an application's interaction with the common
language runtime.

System.Security It contains classes that represent the .Net framework security system and
permissions.

System.Windows It contains types used in Windows Presentation Foundation (WPF)

application, including animation clients, user interface controls, data
binding.

Namespaces

Namespaces are used to organize the classes. It helps to control the scope of methods and classes in
larger .Net programming projects. In simpler words you can say that it provides a way to keep one
set of names(like class names) different from other sets of names. The biggest advantage of using
namespace is that the class names which are declared in one namespace will not clash with the same
class names declared in another namespace. It is also referred as named group of classes having
common features. The members of a namespace can be namespaces, interfaces, structures,
and delegates.

Defining a Namespace
To define a namespace in C#, we will use the namespace keyword followed by the name of the
namespace and curly braces containing the body of the namespace as follows:
Syntax:
namespace name_of_namespace {

// Namespace (Nested Namespaces)

// Classes
// Interfaces
// Structures
// Delegates

}
example
using System;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello Namespace!");
}
}
}
Example:
// defining the namespace name1
namespace name1
{
// C1 is the class in the namespace name1
class C1
{
// class code
}
}
example of namespace in C# where one namespace program accesses another namespace
program

using System;
namespace First {
public class Hello
{
public void sayHello()
{
Console.WriteLine("Hello First Namespace");
}
}
}
namespace Second
{
public class Hello
{
public void sayHello() { Console.WriteLine("Hello Second Namespace"); }
}
}
public class TestNamespace
{
public static void Main()
{
First.Hello h1 = new First.Hello();
Second.Hello h2 = new Second.Hello();
h1.sayHello();
h2.sayHello();
}
}
Output:

Hello First Namespace

Hello Second Namespace
.NET Framework supports more than 60 programming languages of which 11 programming
languages are designed and developed by Microsoft. The remaining Non-Microsoft Languages are
supported by .NET Framework but not designed and developed by Microsoft.
There are three significant phases of the development of .NET technology.
• OLE Technology
• COM Technology
• .NET Technology

OLE Technology: OLE (Object Linking and Embedding) is one of the technologies of Microsoft’s
component document. Basically, its main purpose is to link elements from different applications
with each other.
COM Technology: The technology of the Microsoft Windows family of the operating system,
Microsoft COM (Common Object Model) enables various software components to communicate.
COM is mostly used by developers for various purposes like creating reusable software
components, linking components together to build applications, and also taking advantage of
Windows services. The objects of COM can be created with a wide range of programming
languages.
.NET Technology: .NET technology of collection or set of technologies to develop windows and
web applications. The technology of .Net is developed by Microsoft and was launched in Feb. 2002,
by basic definition, Microsoft’s new Internet Strategy. It was originally called NGWS (Next
Generation Web Services). It is considered to be one of the most powerful, popular, and very useful
Internet Technology available today.
11 Programming Languages which are designed and developed by Microsoft are:
• C#.NET
• VB.NET
• C++.NET
• J#.NET
• F#.NET
• JSCRIPT.NET
• WINDOWS POWERSHELL
• IRON RUBY
• IRON PYTHON
• C OMEGA
• ASML(Abstract State Machine Language)

Important Points:
• Visual Studio is the development tool that is used to design and develop .NET
applications. For using Visual Studio, the user has to first install the .NET framework
on the system.
• In the older version of Windows OS like XP SP1, SP2, or SP3, the .NET framework
was integrated with the installation media.
• Windows 8, 8.1, or 10 do not provide a pre-installed version 3.5 or later of .NET
Framework. Therefore, a version higher than 3.5 must be installed either from a
Windows installation media or from the Internet on demand. Windows update will give
recommendations to install the .NET framework.

Advantages of .NET Framework:

1. Multi-language support: The .NET Framework supports a variety of programming
languages, including C#, F#, and Visual Basic, which allows developers to choose the
language that best fits their needs and expertise.
2. Cross-platform compatibility: The .NET Framework can run on multiple operating
systems, including Windows, Linux, and macOS, which provides flexibility in
developing and deploying applications.
3. Large community: The .NET Framework has a large and active community of
developers who have created a wide range of resources, including libraries, tools, and
documentation.
4. Security: The .NET Framework includes a variety of security features, such as code
access security and digital signatures, which can help protect applications from
malicious attacks.
5. Productivity: The .NET Framework includes a large set of pre-built libraries and tools
that can help developers save time and improve productivity.
 Disadvantages of .NET Framework:
1. Windows dependency: Although the .NET Framework can run on multiple operating
systems, it was originally designed for use on Windows operating systems, which
means that it may not be the best choice for cross-platform applications.
2. Large footprint: The .NET Framework has a large installation footprint, which can
make it difficult to deploy applications on systems with limited storage or bandwidth.
3. Licensing: Some versions of the .NET Framework require a license, which can add to
the cost of developing and deploying applications.
4. Performance: While the .NET Framework provides good performance for most
applications, it may not be the best choice for high-performance applications that
require low-level access to hardware or complex algorithms.
5. Learning curve: Although the .NET Framework is designed to be easy to use, it still
has a learning curve, especially for developers who are new to the platform or to object-
oriented programming in general.

CIL or MSIL | Microsoft Intermediate Language or Common Intermediate Language

The Microsoft Intermediate Language (MSIL), also known as the Common Intermediate Language
(CIL) is a set of instructions that are platform independent and are generated by the language-specific
compiler from the source code. The MSIL is platform independent and consequently, it can be
executed on any of the Common Language Infrastructure supported environments such as the
Windows .NET runtime.
The MSIL is converted into a particular computer environment specific machine code by the JIT
compiler. This is done before the MSIL can be executed. Also, the MSIL is converted into the
machine code on a requirement basis i.e. the JIT compiler compiles the MSIL as required rather than
the whole of it.
Execution process in Common Language Runtime (CLR): The execution process that includes the
creation of the MSIL and the conversion of the MSIL into machine code by the JIT compiler is given
as follows:
 • The source code is converted into the MSIL by a language-specific compiler in the
compile time of the CLR. Also, along with the MSIL, metadata is also produced in the
compilation. The metadata contains information such as the definition and signature of
the types in the code, runtime information, etc.
• A Common Language Infrastructure (CLI) assembly is created by assembling the MSIL.
This assembly is basically a compiled code library that is used for security, deployment,
versioning, etc. and it is of two types i.e. process assembly (EXE) and library assembly
(DLL).
• The JIT compiler then converts the Microsoft Intermediate Language(MSIL) into the
machine code that is specific to the computer environment that the JIT compiler runs on.
The MSIL is converted into the machine code on a requirement basis i.e. the JIT compiler
compiles the MSIL as required rather than the whole of it.
• The machine code obtained using the JIT compiler is then executed by the processor of
the computer.
Example: The MSIL is generated by the language specific compiler from the source code given
below. To understand the MSIL in detail, simple C# source code with the class Demo that prints hello
world is given as follows:
using System;
public class Demo {
public static void Main()
{
Console.WriteLine("hello world");
}
}

In the above MSIL, there are opcodes that are one or two bytes long. The base class declarations from
which all other classes are inherited are contained in the mscorlib.dll. In the method Main(), the
instruction ldstr loads the string “hello world” on the stack. Then the
static System.Console.Writeline function is called and the string is popped from the stack. Finally, the
ret instruction signals the end of the function call.
Then the .ctor() statement implies a default constructor without parameters for the class Demo. This
constructor is automatically created by the compiler for the non-static class Demo. The call instruction
passes the base object constructor and the ret instruction signals the end of the function call.

What is Assembly manifest?

- Assembly Manifest describes the relationship and dependencies of the components in the assembly.

- The versioning information, scope information and the security permissions are required by the
assembly.

- An Assembly data like version, scope, security information (strong name),etc is stored in manifest.

- The assembly manifest also contains a reference to the resource and classes.

- The assembly manifest of an assembly is stored in either an .exe or a .dll with Microsoft
intermediate language (MSIL) code.

- This file contains metadata about .NET assemblies.

- It contains a collection of data that describes how the elements in the assembly relate to each other.

Where is it stored?

- It can be stored in Portable Executable(PE) file (.exe or .dll) with Microsoft Intermediate
Language(MSIL) code.

- You can add or change some information in the Assembly Manifest by using assembly attributes in
your code.

- You can view the manifest information for any managed DLL using ILDasm.
It performs following functions:

- It enumerates the files that make up the assembly.

- It provides a level of indirection between consumers of the assembly and the assemblies
implementation details.

- It renders the assembly self-describing.

- It enumerates other assemblies on which the assembly depends.

Namespaces are used to organize the classes. It helps to control the scope of methods and classes in
larger .Net programming projects. In simpler words you can say that it provides a way to keep one
set of names(like class names) different from other sets of names. The biggest advantage of using
namespace is that the class names which are declared in one namespace will not clash with the same
class names declared in another namespace. It is also referred as named group of classes having
common features. The members of a namespace can be namespaces, interfaces, structures,
and delegates.
Defining a Namespace
To define a namespace in C#, we will use the namespace keyword followed by the name of the
namespace and curly braces containing the body of the namespace as follows:
Syntax:
namespace name_of_namespace {

// Namespace (Nested Namespaces)

// Classes
// Interfaces
// Structures
// Delegates
}
Example:
// defining the namespace name1
namespace name1
{
// C1 is the class in the namespace name1
class C1
{
// class code
}
}
Accessing the Members of Namespace
The members of a namespace are accessed by using dot(.) operator. A class in C# is fully known by
its respective namespace.
Syntax:
[namespace_name].[member_name]
Note:
• Two classes with the same name can be created inside 2 different namespaces in a
single program.
• Inside a namespace, no two classes can have the same name.
• In C#, the full name of the class starts from its namespace name followed
by dot(.) operator and the class name, which is termed as the fully qualified name of the
class.
Example:
In the above example:
• In System.Console.WriteLine()” “System” is a namespace in which we have a class
named “Console” whose method is “WriteLine()“.
• It is not necessary to keep each class in C# within Namespace but we do it to organize
our code well.
• Here “.” is the delimiter used to separate the class name from the namespace and
function name from the classname.
The using keyword
It is not actually practical to call the function or class(or you can say members of a namespace)
every time by using its fully qualified name. In the above
example, System.Console.WriteLine(“Hello Geeks!”); and first.Geeks_1.display(); are the fully
qualified name. So C# provides a keyword “using” which help the user to avoid writing fully
qualified names again and again. The user just has to mention the namespace name at the starting of
the program and then he can easily avoid the use of fully qualified names.
Syntax:
using [namespace_name][.][sub-namespace_name];
In the above syntax, dot(.) is used to include subnamespace names in the program.
Example:
// predefined namespace name
using System;
// user-defined namespace name
using name1
// namespace having subnamespace
using System.Collections.Generic;
Program:
// C# program to illustrate the use of namespaces
// namespace declaration
namespace first {
// name_1 namespace members
// i.e. class
class Geeks_1
{
// function of class Geeks_1
public static void display()
{
 // Here System is the namespaces under which Console class is defined
// You can avoid writing System with the help of "using" keyword
System.Console.WriteLine("Hello Geeks!");
}
}
/* Removing comment will give the error because no two classes can have the same name under a
single namespaces
class Geeks_1
{
} */
} // ending of first namespace
// Class declaration
class Geeks_2
{
// Main Method
public static void Main(String []args)
{
// calling the display method of class Geeks_1 by using two dot operator as one is use to access
the class of first namespace and another is use to access the
static method of class Geeks_1
first.Geeks_1.display();
}
}
Output:
Hello Geeks!

Nested Namespaces
You can also define a namespace into another namespace which is termed as the nested namespace.
To access the members of nested namespace user has to use the dot(.) operator.
For example, Generic is the nested namespace in the collections namespace
as System.Collections.Generic
Syntax:
namespace name_of_namespace_1
{
// Member declarations & definitions
namespace name_of_namespace_2
{
 // Member declarations & definitions
.
.
}
}

Main Differences between C# vs .NET

We’ve compiled a comparison chart to visualize differences and similarities between C# and
.NET.

C# .NET

• A programming language • A developer platform

• Open-source • Open-source
• Created by Microsoft • Created by Microsoft
• Supports coding in C# and multiple other
• Part of the .NET ecosystem languages
• Easy to learn • Hard to learn
• Used to develop desktop apps, web • Used for frontend and backend development,
apps, services, APIs, games, cloud cloud, mobile, desktop, web application
apps, mobile apps development, as well as IoT, ML, gaming apps

We can also name various tech differences; for example, local variables are automatically
initialized in .NET but not in C#; a specific base class constructor is used in the .NET
framework but lacks in C#; and many other different things.

Review questions;
1. Explain the following in detail
• CTS (Common Type System)
• BCL (Base Class Library)
• CLS (Common Language Specification)
• FCL (Framework Class Library)

2. Explain the architecture of CLR in detail.

3. Explain dot net namespaces with suitable example.