1.philosophy of .net

C# Programming and .NET Concepts

ByS. [email protected]

S. Nandagopalan, B I T 2

Books for Reference

• C# and the .NET Platform (2 Ed) By Andrew Troelsen Dreamtech Publications

• Microsoft Visual C# .NET By Mickey Williams Microsoft Press


Chapter - 1

The Philosophy of .NET


Objectives

• Understanding the previous state of affairs

• The .NET Solution• Building blocks of .NET Platform

CLR, CTS, and CLS

• .NET Base Class Libraries


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


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


.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


.NET Framework

Operating SystemOperating System

Common Language RuntimeCommon Language Runtime

Base Class LibraryBase Class Library

ADO.NET and XMLADO.NET and XML

ASP.NETASP.NETWeb Forms Web ServicesWeb Forms Web Services

WindowsWindowsFormsForms

Common Language SpecificationCommon Language Specification

VBVB C++C++ C#C# JScriptJScript J#J#V

isua

l Stu

dio

.NE

TV

isua

l Stu

dio

.NE

T


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


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


Common Language Runtime

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.

CTS CLS

Base Class Libraries

Threading

Data Access

File IO XML/SOAP

GUI


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)


Understanding Assemblies

• Windows applications have dependencies on one 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"


Assembly

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

C# source code C# .NET CompilerAssembly

Metadata

IL+ =


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.


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();

}}

public class Calc{

public int Add(int x, int y)

{ return x + y; }}

}

All .NET aware languages emit same CIL

instructions


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


Manifest.assembly extern mscorlib{ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .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

External Assembly


CIL to Execution

• 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

CIL JIT

Desktop

Pocket PC

Server


Common Type System (CTS)

• CTS is a formal specification that describes how a given type must be defined for CLR

• CTS Class Type• CTS Structure Type• CTS Interface Type• CTS Enumeration type• CTS Delegate type


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


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.

• CTS Structure types Same as C/C++

• Derived from a common base class System.ValueType

• CTS Enumeration type To group name/value pairs under a specific name Default Storage: System.Int32 (could be changed)

• 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 Delegate type Same as C's function pointer (System.MulticastDelegate)

Useful for event handling (ASP .NET)


Intrinsic CTS Data Types

.NET Base Type C# TypeSystem.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


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 // C#

Public Sub Foo() public void Foo()'……. { ……. }

End Sub


CLS ComplianceC# Type CLS Compliancebyte Yes

sbyte No

short Yes

int Yes

long Yes

ulong No

float Yes

double Yes

object Yes

string Yes

char Yes

bool Yes


Examplepublic class Calc{

// CLS compliantpublic int Add(int x, int y)

{ return x + y; }

// Not CLS compliantpublic 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

CLR .NET Source

Code

Base ClassLibraries

(mscorlib.dll)

.NET Execution Engine

Class Loader

Jitter

Platform Specific code

Execute

.NET Compiler

DLL or EXE(CIL)

mscoree.dll

mscoree.dllMicroSoft Common

Object Runtime 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


Example in C#

using System;public Class MyApp{

public static void Main(){

Console.WriteLine("Hello World"); }

}

System Namespace

Console class in System Namespace


Example in VB .NET

Imports SystemPublic Module MyApp

Sub Main()Console.WriteLine("Hello World")

End SubEnd Module


Example in Managed C++

#using <mscorlib.dll>using namespace System;void Main(){

Console::WriteLine("Hello World");

}


Sample .NET namespacesSystem primitive types, garbage

collection, etc

System.Collections Container objects: ArrayList, Queue, etc.

System.DataSystem.Data.CommonSystem.Data.OleDbSystem.Data.SqlClient

For Database manipulations ADO .NET

System.IO file IO, buffering, etc.

System.DrawingSystem.Drawing.2D

GDI+ primitives, bitmaps, fonts, icons, etc.

System.Threading Threads


Demo

• Console Application• Windows Application• Graphics


End of Chapter 1Chapter 1

1.philosophy of .net

Documents

net environment

philosophy of net

oo language

language freedom

clrcommon language runtime

cls net base class libraries

crosslanguage integration

net aware languages