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
Codice MSILCodice MSIL
Codicenativo
Output
Sorgenti
CompilatoreJIT
CodiceMSIL
(Assembly).EXE/.DLL
Compilatore.NET
Codice + metadati
Codice MSILCodice MSIL
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?
JIT – Just in Time JIT – Just in Time CompilerCompiler
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
JIT – Just in Time JIT – Just in Time CompilerCompiler
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)
Codice IL – Codice IL – MetainformazioniMetainformazioni
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
Codice IL – Codice IL – MetainformazioniMetainformazioni
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> )
Codice IL – Codice IL – MetainformazioniMetainformazioni
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:
CallCnvntn: [LOCALSIG]CallCnvntn: [LOCALSIG]2 Arguments2 Arguments
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
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 (.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)--------------------------------------------------------------------------------------------------------------
CallCnvntn: [LOCALSIG]CallCnvntn: [LOCALSIG]1 Arguments1 Arguments
Argument #1: Class Argument #1: Class testDue.esempioDueAtestDue.esempioDueA
Signature #1 (0x11000001) Signature #1 (0x11000001) (EsempioDueA)(EsempioDueA)--------------------------------------------------------------------------------------------------------------
CallCnvntn: [LOCALSIG]CallCnvntn: [LOCALSIG]1 Arguments1 Arguments
Argument #1: StringArgument #1: String
Codice IL – Codice IL – MetainformazioniMetainformazioni
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);}}
}}
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 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.
Codice IL – Codice IL – MetainformazioniMetainformazioni
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)
Codice IL – Codice IL – MetainformazioniMetainformazioni
Signature #1 (0x11000001)Signature #1 (0x11000001)--------------------------------------------------------------------------------------------------------------
CallCnvntn: [LOCALSIG]CallCnvntn: [LOCALSIG]2 Arguments2 Arguments
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