Chapter - 1
The Philosophy of .NET
1
School of CSE
Content
 The Building Block of the .NET Platform (CLR, CTS and CLS),




2
.NET Base Class Libraries, .NET Binaries (aka Assemblies).
The Role of the Common Intermediate Language, .NET Type
Metadata, Assembly Manifest, Compiling CIL to Platform –
Specific Instructions.
Understanding the Common Type System, Intrinsic CTS Data
Types, Understanding the Common Languages Specification.
Understanding the Common Language Runtime A tour of the
.NET Namespaces, Increasing Your Namespace Nomenclature,
Deploying the .NET Runtime.
Building C # Application using csc.exe and Visual Studio .NET
IDE
School of CSE
Understanding the previous state of affairs
 As a C/Win32 API Programmer
 It is complex
 C is a short/abrupt language
 Manual memory management, ugly pointer arithmetic, ugly
syntactic constructs
 Not a OO language
 As a C++/MFC Programmer
 Root is C
 C++ with MFC is still complex and error-prone
 As a VB 6 Programmer
 Not a complete OOP (“Object-aware”) – Why?
 Doesn‟t support inheritance
 No multithreading
 No parameterized Classes
 Low-level API calls are complex
3
School of CSE
Previous state of affairs…
 As a Java/J2EE Programmer
 Use of Java front-to-back during development cycle
 No language freedom!
 Pure Java is not suitable for graphic intensive problems
(E.g. 3D game)
 No cross-language integration
 As a COM Programmer
 Complex creation of COM types
 Active Template Library (ATL)
 Forced to contend with brittle/fragile registration entries
 Deployment issues
4
School of CSE
.NET Solution
 Full interoperability with existing Win32 Code
 Existing COM binaries can interoperate with .NET binaries
 Complete and total language integration
 Supports cross-language inheritance, exception handling, and debugging
 Common runtime engine shared by all .NET aware languages
 A base class library
 Good object model used by all .NET aware languages
 No more COM plumbing!
 No IClassFactory, IUnKnown, IDispatch, etc.
 Truly simplified deployment model
 No need to register a binary unit into the system registry
 Allows multiple versions of same *.dll
5
School of CSE
.NET Framework
VB
C++
C#
JScript
J#
Common Language Specification
Windows
Forms
ADO.NET and XML
Base Class Library
Common Language Runtime
Operating System
6
School of CSE
Visual Studio.NET
ASP.NET
Web Forms Web Services
CLR (Common Language Runtime)
 CLR sits on top of OS (same as JVM of Java)
 CLR loads modules containing executables and executes them
 Code may be managed or unmanaged
 Managed code consists of instructions in pseudo random code called




7
CIL (Common Intermediate Language). CIL instructions are JIT
compiled into native machine code at runtime
JIT compiled methods reside in cache until the application‟s life time
Advantages of managed code: type safety, memory management, and
code verification security
CLR can translate code from C#, J#, C, C++, VB, and Jscript into CIL.
CLR doesn‟t launch a new process for every application. It launches
one process and hosts individual applications in application domains
School of CSE
Building Blocks of .NET
 CLR (Common Language Runtime)
 To locate, load, and manage .NET types
 Automatic memory management, language integration, and
type safety
 CTS (Common Type System)
 Describes all possible data types and programming
constructs supported by the runtime
 CLS (Common Language Specification)
 A set of rules that defines a subset of types and
specifications
8
School of CSE
Base Class Libraries
 Encapsulates various primitives like: threads, file IO,
graphical rendering, and other interaction with HW devices
 It also provides: database manipulation, XML integration,
Web-enabled front-end.
Data Access
GUI
Threading
File IO
Base Class Libraries
XML/SOAP
Common Language Runtime
CTS
9
School of CSE
CLS
C#
 Almost same as Java
 No pointers required
 Automatic memory management (No „delete‟)
 Enumeration, class, structure, etc.
 Operator overloading allowed
 Interface-based programming techniques
 Assign characteristics to types (same as COM IDL)
 C# can produce code that can run only on .NET
environment (unlike COM server or Win32 API)
10
School of CSE
Understanding Assemblies
 Windows applications have dependencies on one





11
or more DLLs
These DLLs may contain COM classes registered
in System registry
When these components are updated,
applications may break – 'DLL hell'
Solution: .NET Assemblies
C# .NET compiler doesn't generate machine
code.
It is compiled into "assembly"
School of CSE
Assembly
Metadata
C# source code
12
School of CSE
+
C# .NET Compiler
=
IL
Assembly
Assembly
Metadata
C# source code
+
C# .NET Compiler
=
IL
Assembly
Metadata
Perl source code
+
Perl .NET Compiler
=
IL
Assembly
=
COBOLsource code
13
School of CSE
+
COBOL.NET Compiler
Metadata
IL
Assembly
IL & Metadata
 Intermediate Language (IL/CIL):
 Same as first pass of compiler. It can't be executed (it is not in
binary format)
 Metadata
 Describes the assembly contents
 No need for component registry
 Each assembly includes information about references to other
assemblies
 E.g. If you have a class called Car in a given assembly, the
type metadata describes Car's base class, which interfaces
are implemented by Car, description of members of Car.
14
School of CSE
Assembly…
 When CLR loads your application, it examines your program's
metadata to know which external assemblies are required for
execution
 Private assemblies
 Used by single application
 Is not shared
 Most preferred method
 Shared assemblies
 Intended for multiple applications
 Global Assembly Cache
 Manifest
 The metadata of assemblies: version, list of externally defined
assemblies, etc.
15
School of CSE
Single-File and Multifile Assemblies
 Single file assemblies
 single binary file
 CIL, metadata and associated manifest
 Multifile assemblies numerous . NET binaries
 Primary module must contain assembly manifest
 Other related modules contain module level manifest, CIL and type
metadata
Assembly is a logical grouping of one or more related modules
that are intended to be initially deployed and versioned as
single unit
16
School of CSE
Example of CIL


CIL sits above a specific compiler (C#, J#, etc.)
The associated compiler emits CIL instructions
using System;
namespace Calculator
{
public class CalcApp
{
public static void Main(string[] args)
{
Calc c = new Calc();
int ans = c.Add(10, 84);
Console.WriteLine(ans);
Console.ReadLine();
}
}
17
School of CSE
public class Calc
{
public int Add(int x, int y)
{ return x + y; }
}
}
 All .NET aware languages
emit same CIL instructions
Program in VB.NET
Imports System
Namespace ConsoleApplication7
Module CalcApp
Sub Main()
Dim ans As Integer
Dim c As New Calc
ans = c.Add(10, 84)
Console.WriteLine("10+84 is{0}.", ans)
Console.ReadLine()
End Sub
End Module
Class Calc
Public Function Add(ByVal x As Integer, ByVal y As Integer) As Integer
Return x + y
18
End Function
School of CSE
CIL of Add() Method
.method public hidebysig instance int32 Add(int32 x,
int32 y) cil managed
{
// Code size
8 (0x8)
.maxstack 2
.locals init ([0] int32 CS$00000003$00000000)
IL_0000: ldarg.1
IL_0001: ldarg.2
IL_0002: add
IL_0003: stloc.0
IL_0004: br.s
IL_0006
IL_0006: ldloc.0
IL_0007: ret
} // end of method Calc::Add
19
School of CSE
CIL Of VB Code Main method
.method public static void Main() cil managed
{
.entrypoint
.custom instance void
[mscorlib]System.STAThreadAttribute::.ctor() = ( 01
00 00 00 )
// Code size
40 (0x28)
.maxstack 3
.locals init (int32 V_0,
class ConsoleApplication7.Calc V_1)
IL_0000: newobj instance void
ConsoleApplication7.Calc::.ctor()
IL_0005: stloc.1
IL_0006: ldloc.1
IL_0007: ldc.i4.s 10
IL_0009: ldc.i4.s 84
20
School of CSE
IL_000b: callvirt instance int32
ConsoleApplication7.Calc::Add(int32,
int32)
IL_0010: stloc.0
IL_0011: ldstr
"10+84 is{0}."
IL_0016: ldloc.0
IL_0017: box
[mscorlib]System.Int32
IL_001c: call
void
[mscorlib]System.Console::WriteLine(string,
object)
IL_0021: call
string
[mscorlib]System.Console::ReadLine()
IL_0026: pop
IL_0027: ret
} // end of method CalcApp::Main
Manifest
External
Assembly
.assembly extern mscorlib
{
.publickeytoken = (B7 7A 5C 56 19 34 E0 89 )
.ver 1:0:5000:0
}
.assembly ConsoleApplication1
{
.hash algorithm 0x00008004
.ver 1:0:2058:39833
}
.module ConsoleApplication1.exe
// MVID: {51BE4F31-CBD0-4AE6-BC9D-F9A4976795FD}
.imagebase 0x00400000
.subsystem 0x00000003
.file alignment 4096
.corflags 0x00000001
// Image base: 0x070b0000
21
School of CSE
// .z\V.4..
CIL to Execution
Desktop
CIL
JIT
Server
Pocket PC
 Jitter compiles CIL instructions on the fly into
corresponding machine code and cache it. This is
useful for not recompiling, if the same method is
called again
22
School of CSE
Common Type System (CTS)
 CTS is a formal specification that describes how a





23
given type must be defined for CLR
CTS Class Type
CTS Structure Type
CTS Interface Type
CTS Enumeration type
CTS Delegate type
School of CSE
CTS Class Type
 Same as C++ class
 Can contain members: methods, properties,
events, etc.
 Support for abstract members that define a
polymorphic interface for derived classes
 Multiple inheritance is not allowed
24
School of CSE
CTS Class Characteristics
 "sealed"? – sealed classes can't function as
base classes
 Implement any interfaces? – An interface is a
collection of abstract members
 Abstract or Concrete? – Abstract classes (to
define common behaviors for derived) can't be
created directly but concrete classes can.
 Visibility? – visibility attribute to know whether
external assemblies can use it.
25
School of CSE
 CTS Structure types
 Same as C/C++
 Derived from a common base class System.ValueType
 CTS Interface Type
 Same as pure abstract class of C++
 A description of work that a derived class can perform
 Similar to a class, but can never be instantiated
 CTS Enumeration type
 To group name/value pairs under a specific name
 Default Storage: System.Int32 (could be changed)
 CTS Delegate type
 Same as C's function pointer (System.MulticastDelegate)
 Useful for event handling (ASP .NET)
26
School of CSE
Intrinsic CTS Data Types
.NET Base Type
C# Type
System.Byte
Byte
System.SByte
sbyte
System.Int16
short
System.Int32
int
System.Int64
long
System.UInt64
ulong
System.Single
float
System.Double
double
System.Object
object
System.String
string
System.Boolean
bool
School of CSE
27
Common Language Specification
(CLS)
 Set of guidelines that describe the minimal and
complete set of features a given .NET aware
compiler must support
 C# uses + for concatenation whereas VB .NET
uses &
 C# allows operator overloading but VB .NET does
not!
 The void functions may differ in syntax:
' VB .NET
Public Sub Foo()
'…….
End Sub
28
School of CSE
// C#
public void Foo()
{ ……. }
CLS Compliance
C# Type
CLS Compliance
byte
Yes
sbyte
No
short
Yes
int
Yes
long
Yes
ulong
No
float
Yes
double
Yes
object
Yes
string
Yes
char
Yes
bool
School of CSE
Yes
29
Example
public class Calc
{
// CLS compliant
public int Add(int x, int y)
{ return x + y; }
// Not CLS compliant
public ulong Add(ulong x, ulong y)
{ return x + y; }
}
 Once a method is CLS compliant, then all the .NET
aware languages can interact with that implementation
30
School of CSE
.NET
Source
Code
CLR
.NET Compiler
DLL or EXE
(CIL)
mscoree.dll
Class Loader
Base Class
Libraries
(mscorlib.dll)
Jitter
Platform
Specific code
mscoree.dll
MicroSoft Common
Object Runtime Execution Engine
31
School of CSE
Execute
.NET Execution Engine
.NET Namespace
 MFC, Java, VB 6.0 have predefined set of
classes; C# doesn't
 C# uses namespace concept
 Any language targeting the .NET runtime makes
use of the same namespaces and same types as
C#
 System is the root namespace
32
School of CSE
Example in C#
System Namespace
using System;
public Class MyApp
{
public static void Main()
{
Console class in System
Namespace
Console.WriteLine("Hello World");
}
}
33
School of CSE
Example in VB .NET
Imports System
Public Module MyApp
Sub Main()
Console.WriteLine("Hello World")
End Sub
End Module
34
School of CSE
Example in Managed C++
#using <mscorlib.dll>
using namespace System;
void Main()
{
Console::WriteLine("Hello World");
}
35
School of CSE
Sample .NET namespaces
System
primitive types, garbage
collection, etc
System.Collections
Container objects: ArrayList,
Queue, etc.
System.Data
System.Data.Common
System.Data.OleDb
System.Data.SqlClient
For Database manipulations
ADO .NET
System.IO
file IO, buffering, etc.
System.Drawing
System.Drawing.2D
GDI+ primitives, bitmaps, fonts,
icons, etc.
System.Threading
Threads
School of CSE
36