processo di esecuzione gestitaManaged Execution Process

Il processo di esecuzione gestita include i passaggi seguenti, descritti in modo dettagliato più avanti in questo argomento:The managed execution process includes the following steps, which are discussed in detail later in this topic:

  1. Scelta di un compilatore.Choosing a compiler.

    Per sfruttare i vantaggi offerti da Common Language Runtime, è necessario usare uno o più compilatori di linguaggio destinati al runtime.To obtain the benefits provided by the common language runtime, you must use one or more language compilers that target the runtime.

  2. Compilazione del codice in MSIL.Compiling your code to MSIL.

    La compilazione converte il codice sorgente in codice MSIL (Microsoft Intermediate Language) e genera i metadati necessari.Compiling translates your source code into Microsoft intermediate language (MSIL) and generates the required metadata.

  3. Compilazione di MSIL in codice nativo.Compiling MSIL to native code.

    In fase di esecuzione, un compilatore JIT converte il codice MSIL in codice nativo.At execution time, a just-in-time (JIT) compiler translates the MSIL into native code. Durante questa compilazione, il codice deve superare un processo di verifica che esamina il codice MSIL e i metadati per determinare se può essere considerato indipendente dai tipi.During this compilation, code must pass a verification process that examines the MSIL and metadata to find out whether the code can be determined to be type safe.

  4. Esecuzione del codice.Running code.

    Common Language Runtime fornisce l'infrastruttura che permette l'esecuzione e i servizi che possono essere usati durante l'esecuzione.The common language runtime provides the infrastructure that enables execution to take place and services that can be used during execution.

Scelta di un compilatoreChoosing a Compiler

Per sfruttare i vantaggi offerti da Common Language Runtime (CLR), è necessario usare uno o più compilatori di linguaggio destinati al runtime, come Visual Basic, C#, Visual C++, F# o uno dei molti compilatori di terze parti come Eiffel, Perl o COBOL.To obtain the benefits provided by the common language runtime (CLR), you must use one or more language compilers that target the runtime, such as Visual Basic, C#, Visual C++, F#, or one of many third-party compilers such as an Eiffel, Perl, or COBOL compiler.

Poiché si tratta di un ambiente di esecuzione multilinguaggio, il runtime supporta un'ampia gamma di tipi di dati e funzionalità per i linguaggi.Because it is a multilanguage execution environment, the runtime supports a wide variety of data types and language features. Il compilatore di linguaggio usato determina le funzionalità di runtime disponibili, che verranno usate per progettare il codice.The language compiler you use determines which runtime features are available, and you design your code using those features. È il compilatore, non Common Language Runtime, a determinare la sintassi che deve essere utilizzata dal codice.Your compiler, not the runtime, establishes the syntax your code must use. Per essere completamente utilizzabile dai componenti scritti in altri linguaggi, il componente deve avere tipi esportati che espongono solo le funzionalità per i linguaggi incluse in Language Independence and Language-Independent Components (CLS).If your component must be completely usable by components written in other languages, your component's exported types must expose only language features that are included in the Language Independence and Language-Independent Components (CLS). È possibile usare l'attributo CLSCompliantAttribute per garantire che il codice sia conforme a CLS.You can use the CLSCompliantAttribute attribute to ensure that your code is CLS-compliant. Per altre informazioni, vedere Language Independence and Language-Independent Components.For more information, see Language Independence and Language-Independent Components.

Torna all'inizioBack to top

Compilazione in MSILCompiling to MSIL

Quando si esegue la compilazione in codice gestito, il compilatore converte il codice sorgente in codice MSIL (Microsoft Intermediate Language), che è un set di istruzioni indipendente dalla CPU che può essere convertito in modo efficiente in codice nativo.When compiling to managed code, the compiler translates your source code into Microsoft intermediate language (MSIL), which is a CPU-independent set of instructions that can be efficiently converted to native code. Il codice MSIL include istruzioni per il caricamento, l'archiviazione, l'inizializzazione e la chiamata di metodi su oggetti, nonché per operazioni aritmetiche e logiche, flusso di controllo, accesso diretto alla memoria, gestione delle eccezioni e altre ancora.MSIL includes instructions for loading, storing, initializing, and calling methods on objects, as well as instructions for arithmetic and logical operations, control flow, direct memory access, exception handling, and other operations. Prima che sia possibile eseguire il codice, il codice MSIL deve essere convertito in codice specifico della CPU, in genere da un compilatore JIT (Just-In-Time).Before code can be run, MSIL must be converted to CPU-specific code, usually by a just-in-time (JIT) compiler. Poiché Common Language Runtime fornisce uno o più compilatori JIT per ogni architettura di computer supportata, lo stesso set di codice MSIL può essere compilato tramite JIT ed eseguito su qualsiasi architettura supportata.Because the common language runtime supplies one or more JIT compilers for each computer architecture it supports, the same set of MSIL can be JIT-compiled and run on any supported architecture.

Quando un compilatore produce codice MSIL, genera anche i metadati.When a compiler produces MSIL, it also produces metadata. I metadati descrivono i tipi nel codice, con la definizione di ogni tipo, le firme dei membri di ogni tipo, i membri cui fa riferimento il codice e altri dati usati dal runtime in fase di esecuzione.Metadata describes the types in your code, including the definition of each type, the signatures of each type's members, the members that your code references, and other data that the runtime uses at execution time. Il codice MSIL e i metadati sono contenuti in un file eseguibile portabile (PE) che si basa (estendendolo) sul formato Microsoft PE e COFF (Common Object File Format) pubblicato, usato tradizionalmente per il contenuto eseguibile.The MSIL and metadata are contained in a portable executable (PE) file that is based on and that extends the published Microsoft PE and common object file format (COFF) used historically for executable content. Questo formato di file, che adatta il codice MSIL o il codice nativo e i metadati, permette al sistema operativo di riconoscere le immagini Common Language Runtime.This file format, which accommodates MSIL or native code as well as metadata, enables the operating system to recognize common language runtime images. La presenza di metadati nel file insieme a codice MSIL permette al codice di descrivere se stesso, per cui non sono necessari un linguaggio di definizione dell'interfaccia né librerie dei tipi.The presence of metadata in the file together with MSIL enables your code to describe itself, which means that there is no need for type libraries or Interface Definition Language (IDL). Il runtime individua ed estrae dal file i metadati al momento necessario durante l'esecuzione.The runtime locates and extracts the metadata from the file as needed during execution.

Torna all'inizioBack to top

Compilazione del codice MSIL in codice nativoCompiling MSIL to Native Code

Prima di poter essere eseguito, il codice MSIL (Microsoft Intermediate Language) deve essere compilato con Common Language Runtime in codice nativo per l'architettura di computer di destinazione.Before you can run Microsoft intermediate language (MSIL), it must be compiled against the common language runtime to native code for the target machine architecture. .NET Framework offre due strumenti per eseguire questa conversione:The .NET Framework provides two ways to perform this conversion:

Compilazione tramite il compilatore JITCompilation by the JIT Compiler

La compilazione JIT converte il codice MSIL in codice nativo su richiesta in fase di esecuzione dell'applicazione, durante il caricamento e l'esecuzione del contenuto di un assembly.JIT compilation converts MSIL to native code on demand at application run time, when the contents of an assembly are loaded and executed. Poiché Common Language Runtime fornisce un compilatore JIT per ogni architettura CPU supportata, gli sviluppatori possono compilare un set di assembly MSIL da compilare tramite JIT ed eseguire su più computer con diverse architetture di computer.Because the common language runtime supplies a JIT compiler for each supported CPU architecture, developers can build a set of MSIL assemblies that can be JIT-compiled and run on different computers with different machine architectures. Tuttavia, se il codice gestito chiama API native specifiche della piattaforma o una libreria di classi specifica della piattaforma, viene eseguito solo su tale sistema operativo.However, if your managed code calls platform-specific native APIs or a platform-specific class library, it will run only on that operating system.

La compilazione JIT tiene conto della possibilità che parte del codice non venga mai chiamata durante l'esecuzione.JIT compilation takes into account the possibility that some code might never be called during execution. Invece di usare tempo e memoria per convertire tutto il codice MSIL in un file PE in codice nativo, la compilazione converte solo quello necessario durante l'esecuzione e archivia il codice nativo risultante in memoria, perché sia accessibile per le chiamate successive nel contesto del processo.Instead of using time and memory to convert all the MSIL in a PE file to native code, it converts the MSIL as needed during execution and stores the resulting native code in memory so that it is accessible for subsequent calls in the context of that process. Il caricatore crea e collega uno stub a ogni metodo in un tipo durante il caricamento e l'inizializzazione del tipo.The loader creates and attaches a stub to each method in a type when the type is loaded and initialized. Quando un metodo viene chiamato per la prima volta, lo stub passa il controllo al compilatore JIT, che converte in codice nativo il codice MSIL per il metodo e modifica lo stub in modo da puntare direttamente al codice nativo generato.When a method is called for the first time, the stub passes control to the JIT compiler, which converts the MSIL for that method into native code and modifies the stub to point directly to the generated native code. Di conseguenza, le successive chiamate del metodo compilato tramite JIT passano direttamente al codice nativo.Therefore, subsequent calls to the JIT-compiled method go directly to the native code.

Generazione di codice in fase di installazione mediante NGen.exeInstall-Time Code Generation Using NGen.exe

Poiché il compilatore JIT converte il codice MSIL di un assembly in codice nativo quando vengono chiamati singoli metodi definiti nell'assembly, influisce negativamente sulle prestazioni in fase di esecuzione.Because the JIT compiler converts an assembly's MSIL to native code when individual methods defined in that assembly are called, it affects performance adversely at run time. Nella maggior parte dei casi, queste prestazioni inferiori sono comunque accettabili.In most cases, that diminished performance is acceptable. Un aspetto ancora più importante è che il codice generato dal compilatore JIT è associato al processo che ha attivato la compilazioneMore importantly, the code generated by the JIT compiler is bound to the process that triggered the compilation. e non può essere condiviso tra più processi.It cannot be shared across multiple processes. Per permettere la condivisione del codice generato tra più chiamate di un'applicazione o tra più processi che condividono un set di assembly, Common Language Runtime supporta una modalità di compilazione anticipata.To allow the generated code to be shared across multiple invocations of an application or across multiple processes that share a set of assemblies, the common language runtime supports an ahead-of-time compilation mode. Questa modalità di compilazione usa il generatore di immagini native (Ngen.exe) per convertire assembly MSIL in codice nativo in modo molto simile al compilatore JIT.This ahead-of-time compilation mode uses the Ngen.exe (Native Image Generator) to convert MSIL assemblies to native code much like the JIT compiler does. Tuttavia, il funzionamento di Ngen.exe differisce da quello del compilatore JIT per tre aspetti:However, the operation of Ngen.exe differs from that of the JIT compiler in three ways:

  • Esegue la conversione da codice MSIL a codice nativo prima di eseguire l'applicazione invece che durante l'esecuzione dell'applicazione.It performs the conversion from MSIL to native code before running the application instead of while the application is running.

  • Compila un intero assembly per volta, invece di un metodo per volta.It compiles an entire assembly at a time, instead of one method at a time.

  • Mantiene il codice generato nella cache delle immagini native come file su disco.It persists the generated code in the Native Image Cache as a file on disk.

Verifica del codiceCode Verification

Come parte della compilazione in codice nativo, il codice MSIL deve superare un processo di verifica, a meno che un amministratore non abbia definito criteri di sicurezza che permettono di evitare la verifica del codice.As part of its compilation to native code, the MSIL code must pass a verification process unless an administrator has established a security policy that allows the code to bypass verification. La verifica esamina il codice MSIL e i metadati per determinare se il codice è indipendente dai tipi, che significa che accede solo alle posizioni di memoria cui è autorizzato ad accedere.Verification examines MSIL and metadata to find out whether the code is type safe, which means that it accesses only the memory locations it is authorized to access. L'indipendenza dai tipi isola gli oggetti gli uni dagli altri e aiuta a proteggerli da danni accidentali o intenzionali.Type safety helps isolate objects from each other and helps protect them from inadvertent or malicious corruption. Inoltre, garantisce l'applicazione affidabile delle restrizioni di sicurezza.It also provides assurance that security restrictions on code can be reliably enforced.

Il runtime si basa sul fatto che le affermazioni seguenti siano vere per il codice verificabile come indipendente dai tipi:The runtime relies on the fact that the following statements are true for code that is verifiably type safe:

  • Un riferimento a un tipo è strettamente compatibile con il tipo a cui viene fatto riferimento.A reference to a type is strictly compatible with the type being referenced.

  • Vengono richiamate in un oggetto solo le operazioni definite in modo appropriato.Only appropriately defined operations are invoked on an object.

  • Le identità sono quello che sostengono di essere.Identities are what they claim to be.

Durante il processo di verifica, il codice MSIL viene esaminato nel tentativo di confermare che possa accedere alle posizioni di memoria e chiamare metodi solo attraverso i tipi definiti in modo appropriato.During the verification process, MSIL code is examined in an attempt to confirm that the code can access memory locations and call methods only through properly defined types. Ad esempio, il codice non può permettere l'accesso ai campi di un oggetto in un modo che consenta l'overrun delle posizioni di memoria.For example, code cannot allow an object's fields to be accessed in a manner that allows memory locations to be overrun. La verifica esamina inoltre il codice per determinare se il codice MSIL sia stato generato correttamente, perché quello generato in modo non corretto può causare una violazione delle regole di indipendenza dai tipi.Additionally, verification inspects code to determine whether the MSIL has been correctly generated, because incorrect MSIL can lead to a violation of the type safety rules. Il processo di verifica passa un set di codice indipendente dai tipi ben definito e passa solo il codice indipendente dai tipi.The verification process passes a well-defined set of type-safe code, and it passes only code that is type safe. Tuttavia, parte del codice indipendente dai tipi potrebbe non superare la verifica a causa di alcune limitazioni del processo di verifica e alcuni linguaggi, in base alla progettazione, non producono codice verificabile come indipendente dai tipi.However, some type-safe code might not pass verification because of some limitations of the verification process, and some languages, by design, do not produce verifiably type-safe code. Se i criteri di sicurezza richiedono codice indipendente dai tipi ma il codice non supera la verifica, al momento dell'esecuzione verrà generata un'eccezione.If type-safe code is required by the security policy but the code does not pass verification, an exception is thrown when the code is run.

Torna all'inizioBack to top

Esecuzione del codiceRunning Code

Common Language Runtime fornisce l'infrastruttura che permette l'esecuzione gestita e i servizi che possono essere usati durante l'esecuzione.The common language runtime provides the infrastructure that enables managed execution to take place and services that can be used during execution. Prima che un metodo possa essere eseguito, deve essere compilato in codice specifico del processore.Before a method can be run, it must be compiled to processor-specific code. Ogni metodo per cui è stato generato codice MSIL viene compilato tramite JIT quando viene chiamato per la prima volta, quindi viene eseguito.Each method for which MSIL has been generated is JIT-compiled when it is called for the first time, and then run. Alla successiva esecuzione del metodo, viene eseguito il codice nativo esistente compilato tramite JIT.The next time the method is run, the existing JIT-compiled native code is run. Il processo di compilazione JIT e di esecuzione del codice viene ripetuto fino al completamento dell'esecuzione.The process of JIT-compiling and then running the code is repeated until execution is complete.

Durante l'esecuzione, il codice gestito riceve servizi come Garbage Collection, sicurezza, interoperabilità con codice non gestito, supporto per il debug tra linguaggi e supporto migliorato per distribuzione e controllo delle versioni.During execution, managed code receives services such as garbage collection, security, interoperability with unmanaged code, cross-language debugging support, and enhanced deployment and versioning support.

In Microsoft Windows Vista, il caricatore del sistema operativo controlla i moduli gestiti esaminando un po' nell'intestazione COFF.In Microsoft Windows Vista, the operating system loader checks for managed modules by examining a bit in the COFF header. Il bit impostato denota un modulo gestito.The bit being set denotes a managed module. Se il caricatore rileva moduli gestiti, carica mscoree.dll e _CorValidateImage e _CorImageUnloading notificano al caricatore l'avvenuto caricamento o scaricamento delle immagini dei moduli gestiti.If the loader detects managed modules, it loads mscoree.dll, and _CorValidateImage and _CorImageUnloading notify the loader when the managed module images are loaded and unloaded. _CorValidateImage esegue le azioni seguenti:_CorValidateImage performs the following actions:

  1. Assicura che il codice sia codice gestito valido.Ensures that the code is valid managed code.

  2. Modifica il punto di ingresso nell'immagine in un punto di ingresso nel runtime.Changes the entry point in the image to an entry point in the runtime.

In Windows a 64 bit _CorValidateImage modifica l'immagine presente in memoria trasformandola dal formato PE32 al formato PE32+.On 64-bit Windows, _CorValidateImage modifies the image that is in memory by transforming it from PE32 to PE32+ format.

Torna all'inizioBack to top

Vedere ancheSee also