introduzione al clr/msil alfredo paolillo e marco servetto

Introduzione alIntroduzione alCLR/MSILCLR/MSIL

Alfredo Paolillo e Marco ServettoAlfredo Paolillo e Marco Servetto

VocabolarioVocabolario

IL: IL: Intermediate Language, Standard Intermediate Language, Standard

ECMA del 1997ECMA del 1997 MSIL:MSIL:

Microsoft IL, Implementazione Microsoft IL, Implementazione Microsoft di ILMicrosoft di IL

IntroduzioneIntroduzione

Perché .NETPerché .NET Ambiente di esecuzioneAmbiente di esecuzione

Common Language RuntimeCommon Language Runtime

Perché .NETPerché .NET

Difficile effettuare sviluppo Difficile effettuare sviluppo omogeneoomogeneo

Molto tempo viene dedicato a far Molto tempo viene dedicato a far comunicare i vari “strati”comunicare i vari “strati”

Serve un salto qualitativo per Serve un salto qualitativo per semplificare lo scenariosemplificare lo scenario

CodiciCodici

EvoluzioneEvoluzione Codice nativoCodice nativo Codice interpretatoCodice interpretato Codice MSILCodice MSIL

Codice nativoCodice nativo

Codicenativo(.EXE)

Output

CompilatoreSorgenti

Codice interpretatoCodice interpretato

Interprete OutputSorgenti

Codice MSILCodice MSIL

Codicenativo

OutputCompilatoreJIT

CodiceMSIL

(Assembly).EXE/.DLL

Compilatore.NET

Sorgenti


Codicenativo

Output

Sorgenti

CompilatoreJIT

CodiceMSIL

(Assembly).EXE/.DLL

Compilatore.NET

Codice + metadati


Codicenativo

OutputCompilatoreJIT

CodiceMSIL

(Assembly).EXE/.DLL

Compilatore.NET

SorgentiAmbiente di esecuzione

.NET Runtime

Motori JITMotori JIT

Inizialmente previsti 4 motori:Inizialmente previsti 4 motori:

MotoreMotore DescrizioneDescrizione Dove si trovaDove si trova

JITJIT Attuale Attuale implementazioneimplementazione

OptiJitOptiJit Codice più ottimizzatoCodice più ottimizzato Non Non implementatoimplementato

FastJitFastJit Esecuzione JIT più veloceEsecuzione JIT più veloce .NET Compact .NET Compact FrameworkFramework

Native Native (Pre-(Pre-Jit)Jit)

Compilazione preventiva, Compilazione preventiva, assembly compilato salvato in assembly compilato salvato in GACGAC

NGEN.EXENGEN.EXE

JIT – Just in Time JIT – Just in Time CompilerCompiler

In teoria, come con Java, è possibile In teoria, come con Java, è possibile compilare MSIL ed eseguirlo compilare MSIL ed eseguirlo (interpretato) in qualsiasi ambiente che (interpretato) in qualsiasi ambiente che supporti l’esecuzionesupporti l’esecuzione

La compilazione di un’applicazione da un La compilazione di un’applicazione da un tipo di codice assembly quale MSIL verso tipo di codice assembly quale MSIL verso un codice eseguibile sulla macchina un codice eseguibile sulla macchina nativa dovrebbe appesantire le nativa dovrebbe appesantire le prestazioni dell’applicazioneprestazioni dell’applicazione

È quello che succede?È quello che succede?


Il codice non viene caricato tutto in Il codice non viene caricato tutto in memoriamemoria

il compilatore JIT compila solo il il compilatore JIT compila solo il codice necessario, quindi memorizza codice necessario, quindi memorizza nella cache il codice nativo nella cache il codice nativo compilato per riutilizzarlo compilato per riutilizzarlo

L’overhead è una lieve differenza L’overhead è una lieve differenza che, nella maggior parte dei casi, che, nella maggior parte dei casi, non verrà rilevatanon verrà rilevata


Quando viene caricata una classe, il Quando viene caricata una classe, il caricatore aggiunge uno stub a ogni caricatore aggiunge uno stub a ogni metodo della classe metodo della classe

La prima volta che viene chiamato il La prima volta che viene chiamato il metodo, il codice stub cede il controllo al metodo, il codice stub cede il controllo al compilatore JIT, che compila MSIL nel compilatore JIT, che compila MSIL nel codice nativo.codice nativo.

Lo stub viene quindi modificato per Lo stub viene quindi modificato per puntare al codice nativo appena creato, puntare al codice nativo appena creato, affinché le chiamate successive passino affinché le chiamate successive passino direttamente al codice nativo direttamente al codice nativo

Indipendenza dalla Indipendenza dalla piattaformapiattaforma .NET è un’implementazione di CLI.NET è un’implementazione di CLI

Common Language InfrastructureCommon Language Infrastructure CLI è uno standard ECMACLI è uno standard ECMA

ECMA-334, ECMA-335ECMA-334, ECMA-335 Esistono già altre implementazioni di Esistono già altre implementazioni di

CLI:CLI: SSCLI (Microsoft, per Windows, SSCLI (Microsoft, per Windows,

FreeBSD e Macintosh)FreeBSD e Macintosh) Mono (per Linux)Mono (per Linux) DotGNUDotGNU Intel OCL (Open CLI Library)Intel OCL (Open CLI Library) ……

Codice ILCodice IL

Tutto questo assomiglia a qualcosa di Tutto questo assomiglia a qualcosa di già visto?già visto?

Forse Java?Forse Java? Ci sono delle differenzeCi sono delle differenze Un compilatore Java crea bytecode, Un compilatore Java crea bytecode,

che in fase di esecuzione viene che in fase di esecuzione viene interpretato tramite JVM interpretato tramite JVM

.NET crea un codice nativo.NET crea un codice nativo

Codice ILCodice IL

Un vantaggio rilevante offerto Un vantaggio rilevante offerto da .NET Framework rispetto a Java e da .NET Framework rispetto a Java e JVM è la scelta del linguaggio di JVM è la scelta del linguaggio di programmazioneprogrammazione

JVM solo JavaJVM solo Java .NET Multilinguaggio (VB.net, C#, .NET Multilinguaggio (VB.net, C#,

J# etc…)J# etc…) Vediamo un esempio di ILVediamo un esempio di IL

AssemblyAssembly

Assembly

Codice IL

Metadati

Manifest

Modulo(file PE)

MetadatiMetadati

Concetto chiave in .NETConcetto chiave in .NET Informazioni sui tipi di un assemblyInformazioni sui tipi di un assembly Generati automaticamente dai compilatoriGenerati automaticamente dai compilatori Estendibili da terze partiEstendibili da terze parti Formato binario rappresentabile con XML:Formato binario rappresentabile con XML:

XML Schema (XSD)XML Schema (XSD) Serializzazione e deserializzazione Serializzazione e deserializzazione

oggetti a runtime in XMLoggetti a runtime in XML

MetadatiMetadati

Descrizione di un assemblyDescrizione di un assembly Identità: nome, versione, cultura [, pubblic key]Identità: nome, versione, cultura [, pubblic key] Tipi esportatiTipi esportati Assembly da cui dipendeAssembly da cui dipende

Descrizione dei tipiDescrizione dei tipi Nome, visibilità, classe base, interfacce Nome, visibilità, classe base, interfacce

implementateimplementate

Attributi customAttributi custom Definiti dall’utenteDefiniti dall’utente Definiti dal compilatoreDefiniti dal compilatore

Codice ILCodice IL

Proviamo adesso a scrivere e Proviamo adesso a scrivere e compilare dei semplici programmi in compilare dei semplici programmi in C# e proviamo ad analizzarliC# e proviamo ad analizzarli

Codice ILCodice IL Esempio 1Esempio 1namespace testUnonamespace testUno{{

public class esempioUnopublic class esempioUno{{

public esempioUno()public esempioUno(){{}}static void Main(string[] args)static void Main(string[] args){{

int primaVariabile = 0x1234;int primaVariabile = 0x1234;int secondaVariabile = 0xabcdef;int secondaVariabile = 0xabcdef;

}}}}

}}

Codice ILCodice IL

Il file eseguibile è costituito da due parti: Il file eseguibile è costituito da due parti: la prima è il codice MSIL, utilizzato per la prima è il codice MSIL, utilizzato per

generare il codice nativo generare il codice nativo la seconda è rappresentata dai metadati la seconda è rappresentata dai metadati

Con un tool in dotazione con l’SDK Con un tool in dotazione con l’SDK possiamo Diassemblare il file ottenuto dalla possiamo Diassemblare il file ottenuto dalla compilazionecompilazione

Otterremo il seguente outputOtterremo il seguente output Tralasceremo comunque alcuni dettagli Tralasceremo comunque alcuni dettagli

come il codice del costruttore di classecome il codice del costruttore di classe

Codice ILCodice IL.method private hidebysig static void Main(string[] args) cil .method private hidebysig static void Main(string[] args) cil

managedmanaged{{ .entrypoint.entrypoint // Code size 13 (0xd)// Code size 13 (0xd) .maxstack 1.maxstack 1 .locals init (int32 V_0, int32 V_1).locals init (int32 V_0, int32 V_1) IL_0000: ldc.i4 0x1234IL_0000: ldc.i4 0x1234 IL_0005: stloc.0IL_0005: stloc.0 IL_0006: ldc.i4 0xabcdefIL_0006: ldc.i4 0xabcdef IL_000b: stloc.1IL_000b: stloc.1 IL_000c: retIL_000c: ret} // end of method esempioUno::Main} // end of method esempioUno::Main

Codice IL – istruzioni Codice IL – istruzioni principaliprincipali

.entrypoint.entrypoint Specifies that this method is the entry point to the

application (only one such method is allowed). .maxstack.maxstack

int32 specifies the maximum number of elements on the evaluation stack during the execution of the method

.locals [init] Defines a set of local variables for this method.

ldc.i4:ldc.i4: Description Description Push num of type int32 onto the stack as

int32. stloc.0:stloc.0:

Description: Description: Pop value from stack into local variable 0. ret:ret:

Description: Description: return from method, possibly returning a value

Codice IL – Codice IL – MetainformazioniMetainformazioni

ScopeName : testUno.exeScopeName : testUno.exeMVID : {F01C8E38-E942-43D9-9D71-95D37789D357}MVID : {F01C8E38-E942-43D9-9D71-95D37789D357}======================================================================================================================Global functionsGlobal functions--------------------------------------------------------------------------------------------------------------

Global fieldsGlobal fields--------------------------------------------------------------------------------------------------------------

Global MemberRefsGlobal MemberRefs--------------------------------------------------------------------------------------------------------------

TypeDef #1TypeDef #1--------------------------------------------------------------------------------------------------------------

TypDefName: testUno.esempioUno (02000002)TypDefName: testUno.esempioUno (02000002)Flags : [Public] [AutoLayout] [Class] [AnsiClass] (00100001)Flags : [Public] [AutoLayout] [Class] [AnsiClass] (00100001)Extends : 01000001 [TypeRef] System.ObjectExtends : 01000001 [TypeRef] System.ObjectMethod #1 Method #1 --------------------------------------------------------------------------------------------------------------

MethodName: .ctor (06000001)MethodName: .ctor (06000001)Flags : [Public] [HideBySig] [ReuseSlot] [SpecialName] [RTSpecialName] [.ctor] (00001886)Flags : [Public] [HideBySig] [ReuseSlot] [SpecialName] [RTSpecialName] [.ctor] (00001886)RVA : 0x00002050RVA : 0x00002050ImplFlags : [IL] [Managed] (00000000)ImplFlags : [IL] [Managed] (00000000)CallCnvntn: [DEFAULT]CallCnvntn: [DEFAULT]hasThis hasThis ReturnType: VoidReturnType: VoidNo arguments.No arguments.

Method #2 [ENTRYPOINT]Method #2 [ENTRYPOINT]--------------------------------------------------------------------------------------------------------------

MethodName: Main (06000002)MethodName: Main (06000002)Flags : [Private] [Static] [HideBySig] [ReuseSlot] (00000091)Flags : [Private] [Static] [HideBySig] [ReuseSlot] (00000091)RVA : 0x00002064RVA : 0x00002064ImplFlags : [IL] [Managed] (00000000)ImplFlags : [IL] [Managed] (00000000)CallCnvntn: [DEFAULT]CallCnvntn: [DEFAULT]ReturnType: VoidReturnType: Void1 Arguments1 Arguments

Argument #1: SZArray StringArgument #1: SZArray String1 Parameters1 Parameters

(1) ParamToken : (08000001) Name : args flags: [none] (00000000)(1) ParamToken : (08000001) Name : args flags: [none] (00000000)


TypeRef #1 (01000001)TypeRef #1 (01000001)--------------------------------------------------------------------------------------------------------------Token: 0x01000001Token: 0x01000001ResolutionScope: 0x23000001ResolutionScope: 0x23000001TypeRefName: System.ObjectTypeRefName: System.Object

MemberRef #1MemberRef #1--------------------------------------------------------------------------------------------------------------

Member: (0a000002) .ctor: Member: (0a000002) .ctor: CallCnvntn: [DEFAULT]CallCnvntn: [DEFAULT]hasThis hasThis ReturnType: VoidReturnType: VoidNo arguments.No arguments.

TypeRef #2 (01000002)TypeRef #2 (01000002)--------------------------------------------------------------------------------------------------------------Token: 0x01000002Token: 0x01000002ResolutionScope: 0x23000001ResolutionScope: 0x23000001TypeRefName: System.Diagnostics.DebuggableAttributeTypeRefName: System.Diagnostics.DebuggableAttribute

MemberRef #1MemberRef #1--------------------------------------------------------------------------------------------------------------

Member: (0a000001) .ctor: Member: (0a000001) .ctor: CallCnvntn: [DEFAULT]CallCnvntn: [DEFAULT]hasThis hasThis ReturnType: VoidReturnType: Void2 Arguments2 Arguments

Argument #1: BooleanArgument #1: BooleanArgument #2: BooleanArgument #2: Boolean


Signature #1 (0x11000001)Signature #1 (0x11000001)--------------------------------------------------------------------------------------------------------------

CallCnvntn: [LOCALSIG]CallCnvntn: [LOCALSIG]2 Arguments2 Arguments

Argument #1: I4Argument #1: I4Argument #2: I4Argument #2: I4

AssemblyAssembly--------------------------------------------------------------------------------------------------------------

Token: 0x20000001Token: 0x20000001Name : testUnoName : testUnoPublic Key :Public Key :Hash Algorithm : 0x00008004Hash Algorithm : 0x00008004Major Version: 0x00000000Major Version: 0x00000000Minor Version: 0x00000000Minor Version: 0x00000000Build Number: 0x00000000Build Number: 0x00000000Revision Number: 0x00000000Revision Number: 0x00000000Locale: <null>Locale: <null>Flags : [SideBySideCompatible] (00000000)Flags : [SideBySideCompatible] (00000000)CustomAttribute #1 (0c000001)CustomAttribute #1 (0c000001)--------------------------------------------------------------------------------------------------------------

CustomAttribute Type: 0a000001CustomAttribute Type: 0a000001CustomAttributeName: System.Diagnostics.DebuggableAttribute :: instance void .ctor(bool,bool)CustomAttributeName: System.Diagnostics.DebuggableAttribute :: instance void .ctor(bool,bool)Length: 6Length: 6Value : 01 00 00 01 00 00 > <Value : 01 00 00 01 00 00 > <ctor args: ( <can not decode> )ctor args: ( <can not decode> )


AssemblyRef #1AssemblyRef #1--------------------------------------------------------------------------------------------------------------

Token: 0x23000001Token: 0x23000001Public Key or Token: b7 7a 5c 56 19 34 e0 89 Public Key or Token: b7 7a 5c 56 19 34 e0 89 Name: mscorlibName: mscorlibMajor Version: 0x00000001Major Version: 0x00000001Minor Version: 0x00000000Minor Version: 0x00000000Build Number: 0x00001388Build Number: 0x00001388Revision Number: 0x00000000Revision Number: 0x00000000Locale: <null>Locale: <null>HashValue Blob:HashValue Blob:Flags: [none] (00000000)Flags: [none] (00000000)

Codice ILCodice IL

I metadati vengono organizzati in I metadati vengono organizzati in tabelle, in cui fondamentalmente tabelle, in cui fondamentalmente viene descritto ciò che il codice viene descritto ciò che il codice definisce e a cui fa riferimento definisce e a cui fa riferimento

Prestiamo attenzione a questa parte di Prestiamo attenzione a questa parte di codice:codice:


Argument #1: I4Argument #1: I4Argument #2: I4Argument #2: I4

Codice C#Codice C# Proviamo adesso a compilare il seguente codiceProviamo adesso a compilare il seguente codiceFILE:esempioDueBFILE:esempioDueB

namespace testDuenamespace testDue{{

public class esempioDueBpublic class esempioDueB{{

static void Main(string[] args)static void Main(string[] args){{

esempioDueA variabile = new esempioDueA variabile = new esempioDueA();esempioDueA();

variabile.printString();variabile.printString();}}

}}}}

Codice C#Codice C#FILE: esempioDueAFILE: esempioDueA

using System;using System;namespace testDuenamespace testDue{{

public class esempioDueApublic class esempioDueA{{

public esempioDueA()public esempioDueA(){{}}public void printString()public void printString(){{

string s = "Hello!!!!";string s = "Hello!!!!";Console.Write(s);Console.Write(s);

}}}}

}}

Codice ILCodice IL

Disassembliamo:Disassembliamo:

A differenza di prima dovremo A differenza di prima dovremo analizzare due codicianalizzare due codici


managedmanaged{{ .entrypoint.entrypoint // Code size 13 (0xd)// Code size 13 (0xd) .maxstack 1.maxstack 1 .locals init (.locals init (class testDue.esempioDueA V_0class testDue.esempioDueA V_0)) IL_0000: IL_0000: newobj instance void newobj instance void

testDue.esempioDueA::.ctor()testDue.esempioDueA::.ctor() IL_0005: stloc.0IL_0005: stloc.0 IL_0006: ldloc.0IL_0006: ldloc.0 IL_0007: IL_0007: callvirt instance void callvirt instance void

testDue.esempioDueA::printString()testDue.esempioDueA::printString() IL_000c: retIL_000c: ret} // end of method esempioDueB::Main} // end of method esempioDueB::Main

Codice ILCodice IL.method public hidebysig instance void printString() cil .method public hidebysig instance void printString() cil

managedmanaged{{ // Code size 13 (0xd)// Code size 13 (0xd) .maxstack 1.maxstack 1 .locals init (.locals init (string V_0string V_0)) IL_0000: IL_0000: ldstr "Hello!!!!"ldstr "Hello!!!!" IL_0005: stloc.0IL_0005: stloc.0 IL_0006: ldloc.0IL_0006: ldloc.0 IL_0007: IL_0007: call void call void

[mscorlib]System.Console::Write(string)[mscorlib]System.Console::Write(string) IL_000c: retIL_000c: ret} // end of method esempioDueA::printString} // end of method esempioDueA::printString

Codice ILCodice ILPrincipali differenze rispetto al codice precedente:Principali differenze rispetto al codice precedente: Newobj:Newobj:

Assembli format: Assembli format: newobjctor Description: Description: allocate an uninitialized object or value

type and call ctor Call:Call:

Assembli format: call Assembli format: call methodmethod Description: Description: Call method described by method

Callvirt:Callvirt: Assembli format: Assembli format: callvirt method Description: Description: Call a method associated with obj

Codice ILCodice IL Andiamo nuovamente a riesaminare le meta-Andiamo nuovamente a riesaminare le meta-

informazioni:informazioni:Signature #2 (0x11000002) Signature #2 (0x11000002) (EsempioDueB)(EsempioDueB)--------------------------------------------------------------------------------------------------------------


Argument #1: Class Argument #1: Class testDue.esempioDueAtestDue.esempioDueA

Signature #1 (0x11000001) Signature #1 (0x11000001) (EsempioDueA)(EsempioDueA)--------------------------------------------------------------------------------------------------------------


Argument #1: StringArgument #1: String


Method #2 Method #2 (definizione del metodo invocato dalla call)(definizione del metodo invocato dalla call)--------------------------------------------------------------------------------------------------------------

MethodName: printString (06000002)MethodName: printString (06000002)Flags : [Public] [HideBySig] [ReuseSlot] Flags : [Public] [HideBySig] [ReuseSlot]

(00000086)(00000086)RVA : 0x00002064RVA : 0x00002064ImplFlags : [IL] [Managed] (00000000)ImplFlags : [IL] [Managed] (00000000)CallCnvntn: [DEFAULT]CallCnvntn: [DEFAULT]hasThis hasThis ReturnType: VoidReturnType: VoidNo arguments.No arguments.

....................................User Strings User Strings (costante)(costante)--------------------------------------------------------------------------------------------------------------70000001 : ( 9) L"Hello!!!!”70000001 : ( 9) L"Hello!!!!”

Codice C#Codice C# Passaggio di parametri:Passaggio di parametri:namespace testTrenamespace testTre{{

public class esempioTreApublic class esempioTreA{{

static void Main(string[] args)static void Main(string[] args){{

string s = ("HELLO!!!!!!!!!!!!!!!!!!!!!!!!!!");string s = ("HELLO!!!!!!!!!!!!!!!!!!!!!!!!!!");esempioTreB variabile = new esempioTreB variabile = new

esempioTreB();esempioTreB();variabile.printString(s);variabile.printString(s);

}}}}

}}

Esempio C#Esempio C#Using system;Using system;public class esempioTreBpublic class esempioTreB

{{public esempioTreB()public esempioTreB(){{}}public void printString(string s)public void printString(string s){{

Console.Write(s);Console.Write(s);}}

}}


managedmanaged{{ .entrypoint.entrypoint // Code size 20 (0x14)// Code size 20 (0x14) .maxstack 2.maxstack 2 .locals init .locals init (string V_0, class testTre.esempioTreB V_1)(string V_0, class testTre.esempioTreB V_1) IL_0000: ldstr "HELLO!!!!!!!!!!!!!!!!!!!!!!!!!!"IL_0000: ldstr "HELLO!!!!!!!!!!!!!!!!!!!!!!!!!!" IL_0005: stloc.0IL_0005: stloc.0 IL_0006: newobj instance void testTre.esempioTreB::.ctor()IL_0006: newobj instance void testTre.esempioTreB::.ctor() IL_000b: stloc.1IL_000b: stloc.1 IL_000c: ldloc.1IL_000c: ldloc.1 IL_000d: ldloc.0IL_000d: ldloc.0 IL_000e: callvirt instance void IL_000e: callvirt instance void

testTre.esempioTreB::testTre.esempioTreB::printString(string)printString(string) IL_0013: retIL_0013: ret} // end of method esempioTreA::Main} // end of method esempioTreA::Main

Codice ILCodice IL

.method public hidebysig instance void printString(string s) .method public hidebysig instance void printString(string s) cil managedcil managed

{{

// Code size 7 (0x7)// Code size 7 (0x7)

.maxstack 1.maxstack 1

IL_0000: IL_0000: ldarg.1ldarg.1

IL_0001: call void IL_0001: call void [mscorlib]System.Console::Write(string)[mscorlib]System.Console::Write(string)

IL_0006: retIL_0006: ret

} // end of method esempioTreB::printString} // end of method esempioTreB::printString

Codice ILCodice IL ldarg.1ldarg.1

Assembli format: ldarg.1Assembli format: ldarg.1 Description: Description: Load argument 1 onto stack

Esistono anche delle varianti, ad esempio: ldarg num

Assembli format: ldarg numAssembli format: ldarg num Description: Description: Load argument numbered num onto stack.


TypeDef #1TypeDef #1--------------------------------------------------------------------------------------------------------------

TypDefName: testTre.esempioTreB (02000002)TypDefName: testTre.esempioTreB (02000002)Flags : [Public] [AutoLayout] [Class] [AnsiClass] (00100001)Flags : [Public] [AutoLayout] [Class] [AnsiClass] (00100001)Extends : 01000001 [TypeRef] System.ObjectExtends : 01000001 [TypeRef] System.ObjectMethod #1 Method #1 --------------------------------------------------------------------------------------------------------------

MethodName: .ctor (06000001)MethodName: .ctor (06000001)Flags : [Public] [HideBySig] [ReuseSlot] [SpecialName] [RTSpecialName] [.ctor] (00001886)Flags : [Public] [HideBySig] [ReuseSlot] [SpecialName] [RTSpecialName] [.ctor] (00001886)RVA : 0x00002050RVA : 0x00002050ImplFlags : [IL] [Managed] (00000000)ImplFlags : [IL] [Managed] (00000000)CallCnvntn: [DEFAULT]CallCnvntn: [DEFAULT]hasThis hasThis ReturnType: VoidReturnType: VoidNo arguments.No arguments.

Method #2 Method #2 --------------------------------------------------------------------------------------------------------------

MethodName: printString (06000002)MethodName: printString (06000002)Flags : [Public] [HideBySig] [ReuseSlot] (00000086)Flags : [Public] [HideBySig] [ReuseSlot] (00000086)RVA : 0x00002064RVA : 0x00002064ImplFlags : [IL] [Managed] (00000000)ImplFlags : [IL] [Managed] (00000000)CallCnvntn: [DEFAULT]CallCnvntn: [DEFAULT]hasThis hasThis ReturnType: VoidReturnType: Void1 Arguments1 Arguments

Argument #1: StringArgument #1: String1 Parameters1 Parameters

(1) ParamToken : (08000001) Name : s flags: [none] (00000000)(1) ParamToken : (08000001) Name : s flags: [none] (00000000)


Signature #1 (0x11000001)Signature #1 (0x11000001)--------------------------------------------------------------------------------------------------------------


Argument #1: StringArgument #1: StringArgument #2: Class testTre.esempioTreBArgument #2: Class testTre.esempioTreB

Assenza di Signature #2Assenza di Signature #2La classe su cui viene invocato il metodo printString non ha La classe su cui viene invocato il metodo printString non ha

dichiarazioni localidichiarazioni locali

Garbage CollectorGarbage Collector

Gli oggetti vengono distrutti Gli oggetti vengono distrutti automaticamente quando non sono automaticamente quando non sono più referenziatipiù referenziati

Algoritmo Mark-and-Compact Algoritmo Mark-and-Compact

Garbage Collector - fase Garbage Collector - fase 1: Mark1: Mark

NextObjPtrNextObjPtr

Oggetti “vivi”Oggetti “vivi”

Oggetti non raggiungibiliOggetti non raggiungibili

Spazio liberoSpazio libero

Root setRoot set

Garbage Collector - fase Garbage Collector - fase 2: Compact2: Compact

NextObjPtrNextObjPtr

Oggetti “vivi”Oggetti “vivi”

Spazio liberoSpazio libero

Root setRoot set

Spazio recuperatoSpazio recuperato

GC e distruzione GC e distruzione deterministicadeterministica

In alcuni casi serve un comportamento di In alcuni casi serve un comportamento di finalizzazione deterministica:finalizzazione deterministica: Riferimenti a oggetti non gestitiRiferimenti a oggetti non gestiti Utilizzo di risorse che devono essere Utilizzo di risorse che devono essere

rilasciate appena termina il loro utilizzorilasciate appena termina il loro utilizzo Non si possono usare i finalizzatori, che Non si possono usare i finalizzatori, che

non sono richiamabili direttamentenon sono richiamabili direttamente Implementare l’interfaccia Implementare l’interfaccia IDisposableIDisposable

Common Type SystemCommon Type System

Tutto è un oggettoTutto è un oggetto Due categorie di tipi:Due categorie di tipi:

Tipi reference (riferimento)Tipi reference (riferimento) Allocati su heap gestitoAllocati su heap gestito

Tipi value (valore)Tipi value (valore) Allocati su stack o in oggetti gestiti (reference)Allocati su stack o in oggetti gestiti (reference)

Tutti i tipi value possono essere visti Tutti i tipi value possono essere visti come tipi referencecome tipi reference BoxingBoxing

Tipi value e reference in Tipi value e reference in memoriamemoria

StackStack HeapHeap

heightheight

widthwidth

Class CSizeClass CSize

v.heightv.height

v.widthv.width

rr

public struct Size { public int height; public int weight;}public class CSize { public int height; public int weight;}void Main() { Size v; // v istanza di Size v.height = 100; // ok CSize r; // r è un reference r.height = 100; // illegale, r non assegnato r = new CSize(); // r fa riferimento a un CSize r.height = 100; // ok, r inizializzata}

Equivalenza e identitàEquivalenza e identità Il confronto tra oggetti può essere:Il confronto tra oggetti può essere:

di equivalenzadi equivalenza Object.EqualsObject.Equals: oggetti con stesso tipo e uguale contenuto: oggetti con stesso tipo e uguale contenuto

di identitàdi identità Object.ReferenceEqualsObject.ReferenceEquals: stessa istanza o entrambi null: stessa istanza o entrambi null ====: dipende dal tipo (come ReferenceEquals o altro): dipende dal tipo (come ReferenceEquals o altro) Object.GetHashCodeObject.GetHashCode: rappresentazione univoca istanza: rappresentazione univoca istanza

StackStack HeapHeap

heightheight

widthwidth

Class Class CSizeCSize

r2r2

r1r1

r2=r1;r2=r1;

Equivalenza e identitàEquivalenza e identità““Teo”Teo”

1919

cc

aa

dd

bb

truetruetruetruecc

falsefalsetruetruebb

falsefalsefalsefalseaa

==d==d.Equals(d).Equals(d)

““Ugo”Ugo”

3838

““Ugo”Ugo”

3838

BoxingBoxing

I tipi value si possono sottoporre a I tipi value si possono sottoporre a “boxing” per supportare le “boxing” per supportare le funzionalità tipiche degli oggettifunzionalità tipiche degli oggetti Un tipo value “boxed” è un clone Un tipo value “boxed” è un clone

indipendenteindipendente Un tipo value “boxed” può tornareUn tipo value “boxed” può tornare

ad essere value (ad essere value (unboxingunboxing)) System.ObjectSystem.Object è il tipo universale è il tipo universale

BoxingBoxingint i = 123;int i = 123;object o = i;object o = i;int k = (int)o;int k = (int)o;

123123

i

ointint

123123

123123

k

int j = (int)o;int j = (int)o;

object o = i;object o = i;

int i = 123;int i = 123;

StackStack

HeapHeap

BoxinBoxingg

UnboxinUnboxingg

ConclusioniConclusioni

Evoluzione della macchina virtualeEvoluzione della macchina virtuale Si cerca di trovare il miglior Si cerca di trovare il miglior

compromesso tra sicurezza, flessibilità compromesso tra sicurezza, flessibilità e prestazionie prestazioni

Non tutto è documentatoNon tutto è documentato Scarsa documentazione per quanto Scarsa documentazione per quanto

riguarda i metadatiriguarda i metadati

Altre InformazioniAltre Informazioni

Dove posso ottenere maggiori Dove posso ottenere maggiori informazioniinformazioni www.microsoft.com/msdn/italy/studentiwww.microsoft.com/msdn/italy/studenti www.ugidotnet.orgwww.ugidotnet.org www.gotdotnet.comwww.gotdotnet.com www.ecma-international.orgwww.ecma-international.org

Developer resourcesDeveloper resources Microsoft Visual Studio.NETMicrosoft Visual Studio.NET Microsoft .NET Framework SDKMicrosoft .NET Framework SDK Microsoft Developer NetworkMicrosoft Developer Network

introduzione al clr/msil alfredo paolillo e marco servetto

Documents