Come il runtime individua gli assemblyHow the Runtime Locates Assemblies

Per distribuire correttamente l'applicazione .NET Framework, è necessario comprendere in che modo Common Language Runtime individua e associa gli assembly che costituiscono l'applicazione.To successfully deploy your .NET Framework application, you must understand how the common language runtime locates and binds to the assemblies that make up your application. Per impostazione predefinita, il runtime tenta di eseguire l'associazione con la versione esatta di un assembly con cui è stata compilata l'applicazione.By default, the runtime attempts to bind with the exact version of an assembly that the application was built with. Questo comportamento predefinito può essere sottoposto a override dalle impostazioni del file di configurazione.This default behavior can be overridden by configuration file settings.

Quando si tenta di individuare un assembly e risolvere un riferimento ad assembly, Common Language Runtime esegue una serie di passaggi.The common language runtime performs a number of steps when attempting to locate an assembly and resolve an assembly reference. Ogni passaggio è descritto nelle sezioni seguenti.Each step is explained in the following sections. Il termine "individuazione tramite probe" viene usato quando si descrive la modalità di individuazione degli assembly mediante runtime e fa riferimento al set di euristiche usato per individuare l'assembly in base al nome e alle impostazioni cultura.The term probing is often used when describing how the runtime locates assemblies; it refers to the set of heuristics used to locate the assembly based on its name and culture.

Nota

Per visualizzare le informazioni di associazione nel file di log, usare il Visualizzatore log associazioni assembly (Fuslogvw.exe), incluso in Windows SDK.You can view binding information in the log file using the Assembly Binding Log Viewer (Fuslogvw.exe), which is included in the Windows SDK.

Avvio dell'associazioneInitiating the Bind

Il processo di individuazione e associazione di un assembly inizia quando il runtime tenta di risolvere un riferimento a un altro assembly.The process of locating and binding to an assembly begins when the runtime attempts to resolve a reference to another assembly. Questo riferimento può essere statico o dinamico.This reference can be either static or dynamic. I compilatore registra i riferimenti statici nei metadati del manifesto dell'assembly in fase di compilazione.The compiler records static references in the assembly manifest's metadata at build time. I riferimenti dinamici vengono costruiti nel momento in cui vengono chiamati i diversi metodi, ad esempio Assembly.Load.Dynamic references are constructed on the fly as a result of calling various methods, such as Assembly.Load.

Il modo migliore per fare riferimento a un assembly consiste nell'usare un riferimento completo che includa il nome dell'assembly, la versione, le impostazioni cultura il e token di chiave pubblica (se presente).The preferred way to reference an assembly is to use a full reference, including the assembly name, version, culture, and public key token (if one exists). Il runtime usa queste informazioni per individuare l'assembly, seguendo i passaggi descritti più avanti in questa sezione.The runtime uses this information to locate the assembly, following the steps described later in this section. Il runtime usa lo stesso processo di risoluzione a prescindere che il riferimento riguardi un assembly statico o dinamico.The runtime uses the same resolution process regardless of whether the reference is for a static or dynamic assembly.

Un riferimento dinamico a un assembly può essere eseguito anche fornendo il metodo di chiamata solo con informazioni parziali sull'assembly, ad esempio specificando solo il nome dell'assembly.You can also make a dynamic reference to an assembly by providing the calling method with only partial information about the assembly, such as specifying only the assembly name. In questo caso, l'assembly viene cercato solo nella directory dell'applicazione e non vengono eseguiti altri controlli.In this case, only the application directory is searched for the assembly, and no other checking occurs. È possibile creare un riferimento parziale usando uno dei diversi metodi per il caricamento degli assembly, ad esempio Assembly.Load o AppDomain.Load.You make a partial reference using any of the various methods for loading assemblies such as Assembly.Load or AppDomain.Load.

È infine possibile creare un riferimento dinamico usando un metodo come Assembly.Load e specificare solo informazioni parziali. In seguito verranno specificate informazioni complete sul riferimento usando l'elemento <qualifyAssembly> nel file di configurazione dell'applicazione.Finally, you can make a dynamic reference using a method such as Assembly.Load and provide only partial information; you then qualify the reference using the <qualifyAssembly> element in the application configuration file. Questo elemento consente di specificare le informazioni di riferimento complete (nome, versione, impostazioni cultura e, se applicabile, il token di chiave pubblica) nel file di configurazione dell'applicazione anziché nel codice.This element allows you to provide the full reference information (name, version, culture and, if applicable, the public key token) in your application configuration file instead of in your code. Questa tecnica si usa quando si vuole completare un riferimento a un assembly di fuori della directory dell'applicazione oppure se si vuole fare riferimento a un assembly nella Global Assembly Cache, ma si preferisce definirlo in modo completo nel file di configurazione anziché nel codice.You would use this technique if you wanted to fully qualify a reference to an assembly outside the application directory, or if you wanted to reference an assembly in the global assembly cache but you wanted the convenience of specifying the full reference in the configuration file instead of in your code.

Nota

Questo tipo di riferimento parziale non deve essere usato con gli assembly condivisi tra diverse applicazioni.This type of partial reference should not be used with assemblies that are shared among several applications. Poiché le impostazioni di configurazione vengono applicate per applicazione e non per assembly, per usare questo tipo di riferimento parziale in un assembly condiviso ogni applicazione che usa l'assembly condiviso dovrebbe disporre delle informazioni complete nel file di configurazione.Because configuration settings are applied per application and not per assembly, a shared assembly using this type of partial reference would require each application using the shared assembly to have the qualifying information in its configuration file.

Il runtime usa la procedura seguente per risolvere un riferimento ad assembly:The runtime uses the following steps to resolve an assembly reference:

  1. Determina la versione corretta dell'assembly esaminando i file di configurazione applicabili, tra cui il file di configurazione dell'applicazione, il file dei criteri editore e il file di configurazione del computer.Determines the correct assembly version by examining applicable configuration files, including the application configuration file, publisher policy file, and machine configuration file. Se il file di configurazione si trova in un computer remoto, il runtime deve prima individuare e scaricare il file di configurazione dell'applicazione.If the configuration file is located on a remote machine, the runtime must locate and download the application configuration file first.

  2. Controlla se il nome dell'assembly è stato associato in precedenza e, in questo caso, usa l'assembly caricato in precedenza.Checks whether the assembly name has been bound to before and, if so, uses the previously loaded assembly. Se una richiesta precedente di caricamento dell'assembly non è riuscita, la richiesta viene interrotta immediatamente senza effettuare alcun tentativo di caricamento dell'assembly.If a previous request to load the assembly failed, the request is failed immediately without attempting to load the assembly.

    Nota

    La memorizzazione nella cache di errori relativi all'associazione di assembly è stata introdotta in .NET Framework versione 2.0.The caching of assembly binding failures is new in the .NET Framework version 2.0.

  3. Controlla la Global Assembly Cache.Checks the global assembly cache. Se viene trovato nella Global Assembly Cache, il runtime usa questo assembly.If the assembly is found there, the runtime uses this assembly.

  4. Individua tramite probe l'assembly usando la procedura seguente:Probes for the assembly using the following steps:

    1. Se i criteri dell'editore e della configurazione non hanno effetto sul riferimento originale e se la richiesta di associazione è stata creata usando il metodo Assembly.LoadFrom, il runtime cerca suggerimenti per la posizione.If configuration and publisher policy do not affect the original reference and if the bind request was created using the Assembly.LoadFrom method, the runtime checks for location hints.

    2. Se viene trovata una codebase nei file di configurazione, il runtime controlla solo questo percorso.If a codebase is found in the configuration files, the runtime checks only this location. Se la probe non riesce, il runtime determina che la richiesta di associazione non è riuscita e non vengono eseguite altre individuazioni tramite probe.If this probe fails, the runtime determines that the binding request failed and no other probing occurs.

    3. Le probe per l'assembly che usa le euristiche descritte nella sezione relativa all'individuazione tramite probe.Probes for the assembly using the heuristics described in the probing section. Se l'assembly non è stato trovato dopo l'individuazione tramite probe, il runtime lo richiede a Windows Installer.If the assembly is not found after probing, the runtime requests the Windows Installer to provide the assembly. Questa operazione opera come una funzionalità di installazione su richiesta.This acts as an install-on-demand feature.

      Nota

      Per gli assembly senza nomi sicuri non vengono eseguiti controlli della versione né controlli nella Global Assembly Cache con il runtime.There is no version checking for assemblies without strong names, nor does the runtime check in the global assembly cache for assemblies without strong names.

Passaggio 1: Esame dei file di configurazioneStep 1: Examining the Configuration Files

Il comportamento dell'associazione di assembly può essere configurato a livelli diversi in base a tre file XML:Assembly binding behavior can be configured at different levels based on three XML files:

  • File di configurazione dell'applicazione.Application configuration file.

  • File dei criteri editore.Publisher policy file.

  • File di configurazione del computer.Machine configuration file.

Questi file seguono la stessa sintassi e forniscono informazioni quali i reindirizzamenti delle associazioni, la posizione del codice e le modalità di associazione per determinati assembly.These files follow the same syntax and provide information such as binding redirects, the location of code, and binding modes for particular assemblies. Ogni file di configurazione può contenere un elemento <assemblyBinding> che reindirizza il processo di associazione.Each configuration file can contain an <assemblyBinding> element that redirects the binding process. Negli elementi figlio dell'elemento <assemblyBinding> è incluso l'elemento <dependentAssembly>.The child elements of the <assemblyBinding> element include the <dependentAssembly> element. Negli elementi figlio dell'elemento <dependentAssembly> sono inclusi gli elementi <assemblyIdentity>, <bindingRedirect> e <codeBase>.The children of <dependentAssembly> element include the <assemblyIdentity> element, the <bindingRedirect> element, and the <codeBase> element.

Nota

Le informazioni di configurazione sono disponibili nei tre file di configurazione; non tutti gli elementi sono validi in tutti i file di configurazione.Configuration information can be found in the three configuration files; not all elements are valid in all configuration files. Ad esempio, le informazioni sulla modalità di associazione e sul percorso privato possono trovarsi solo nel file di configurazione dell'applicazione.For example, binding mode and private path information can only be in the application configuration file. Per un elenco completo delle informazioni contenute in ciascun file, vedere Configurazione delle app con file di configurazione.For a complete list of the information that is contained in each file, see Configuring Apps by Using Configuration Files.

File di configurazione dell'applicazioneApplication Configuration File

Common Language Runtime controlla innanzitutto il file di configurazione dell'applicazione per le informazioni che eseguono l'override delle informazioni sulla versione memorizzate nel manifesto dell'assembly chiamante.First, the common language runtime checks the application configuration file for information that overrides the version information stored in the calling assembly's manifest. Il file di configurazione dell'applicazione può essere distribuito con un'applicazione, ma non è necessario per la sua esecuzione.The application configuration file can be deployed with an application, but is not required for application execution. In genere il recupero di questo file è quasi istantaneo, ma in situazioni in cui la base dell'applicazione si trova in un computer remoto, ad esempio in uno scenario basato su Web di Internet Explorer, il file di configurazione deve essere scaricato.Usually the retrieval of this file is almost instantaneous, but in situations where the application base is on a remote computer, such as in an Internet Explorer Web-based scenario, the configuration file must be downloaded.

Per gli eseguibili del client, il file di configurazione dell'applicazione si trova nella stessa directory del file eseguibile dell'applicazione e ha lo stesso nome di base dell'eseguibile con estensione config.For client executables, the application configuration file resides in the same directory as the application's executable and has the same base name as the executable with a .config extension. Ad esempio, il file di configurazione per C:\Programmi\Myapp\Myapp.exe è C:\Programmi\Myapp\Myapp.exe.config. In un scenario basato sul browser nel file HTML deve essere usato l'elemento <link> per puntare in modo esplicito al file di configurazione.For example, the configuration file for C:\Program Files\Myapp\Myapp.exe is C:\Program Files\Myapp\Myapp.exe.config. In a browser-based scenario, the HTML file must use the <link> element to explicitly point to the configuration file.

Il codice seguente fornisce un esempio semplice di un file di configurazione dell'applicazione.The following code provides a simple example of an application configuration file. Questo esempio aggiunge TextWriterTraceListener a una raccolta Listeners per consentire la registrazione di informazioni di debug in un file.This example adds a TextWriterTraceListener to the Listeners collection to enable recording debug information to a file.

<configuration>  
   <system.diagnostics>  
      <trace useGlobalLock="false" autoflush="true" indentsize="0">  
         <listeners>  
            <add name="myListener" type="System.Diagnostics.TextWriterTraceListener, system version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" initializeData="c:\myListener.log" />  
         </listeners>  
      </trace>  
   </system.diagnostics>  
</configuration>  

File dei criteri editorePublisher Policy File

In secondo luogo, il runtime esamina il file dei criteri editore, se presente.Second, the runtime examines the publisher policy file, if one exists. I file dei criteri editore vengono distribuiti da un editore del componente, ad esempio una correzione o un aggiornamento, a un componente condiviso.Publisher policy files are distributed by a component publisher as a fix or update to a shared component. Questi file contengono le informazioni sulla compatibilità dell'editore del componente condiviso che indirizzano un riferimento ad assembly a una nuova versione.These files contain compatibility information issued by the publisher of the shared component that directs an assembly reference to a new version. A differenza dei file di configurazione del computer e dell'applicazione, i file dei criteri editore sono contenuti nei propri assembly che devono essere installati nella Global Assembly Cache.Unlike application and machine configuration files, publisher policy files are contained in their own assembly that must be installed in the global assembly cache.

Di seguito è riportato un esempio di un file di configurazione dei criteri editore:The following is an example of a Publisher Policy configuration file:

<configuration>  
    <runtime>  
        <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">  
  
            <dependentAssembly>  
                <assemblyIdentity name="asm6" publicKeyToken="c0305c36380ba429" />   
                <bindingRedirect oldVersion="3.0.0.0" newVersion="2.0.0.0"/>    
            </dependentAssembly>  
  
        </assemblyBinding>  
    </runtime>  
</configuration>  

Per creare un assembly, è possibile usare lo strumento Al.exe (Assembly Linker) con un comando analogo al seguente:To create an assembly, you can use the Al.exe (Assembly Linker) tool with a command such as the following:

Al.exe /link:asm6.exe.config /out:policy.3.0.asm6.dll /keyfile: compatkey.dat /v:3.0.0.0  

compatkey.dat è un file di chiave con nome sicuro.compatkey.dat is a strong-name key file. Questo comando crea un assembly con nome sicuro che è possibile inserire nella Global Assembly Cache.This command creates a strong-named assembly you can place in the global assembly cache.

Nota

I criteri dell'editore hanno effetto su tutte le applicazioni che usano un componente condiviso.Publisher policy affects all applications that use a shared component.

Il file di configurazione dei criteri editore esegue l'override delle informazioni sulla versione provenienti dall'applicazione (ovvero, dal manifesto dell'assembly o dal file di configurazione dell'applicazione).The publisher policy configuration file overrides version information that comes from the application (that is, from the assembly manifest or from the application configuration file). Se non è presente alcuna istruzione nel file di configurazione dell'applicazione per reindirizzare la versione specificata nel manifesto dell'assembly, il file dei criteri editore esegue l'override della versione specificata nel manifesto dell'assembly.If there is no statement in the application configuration file to redirect the version specified in the assembly manifest, the publisher policy file overrides the version specified in the assembly manifest. Tuttavia, se esiste un'istruzione di reindirizzamento nel file di configurazione dell'applicazione, i criteri editore eseguono l'override di questa versione e non di quella specificata nel manifesto.However, if there is a redirecting statement in the application configuration file, publisher policy overrides that version rather than the one specified in the manifest.

Un file dei criteri editore viene usato quando un componente condiviso viene aggiornato e la nuova versione del componente condiviso deve essere selezionata da tutte le applicazioni che usano il componente.A publisher policy file is used when a shared component is updated and the new version of the shared component should be picked up by all applications using that component. Le impostazioni nel file dei criteri editore eseguono l'override delle impostazioni nel file di configurazione dell'applicazione, a meno che quest'ultimo non attivi la modalità sicura.The settings in the publisher policy file override settings in the application configuration file, unless the application configuration file enforces safe mode.

Modalità sicuraSafe Mode

I file dei criteri editore vengono generalmente installati in maniera esplicita insieme a un Service Pack o a un aggiornamento di un programma.Publisher policy files are usually explicitly installed as part of a service pack or program update. Se si verifica un problema con il componente condiviso aggiornato, è possibile ignorare gli override nel file dei criteri editore usando la modalità sicura.If there is any problem with the upgraded shared component, you can ignore the overrides in the publisher policy file using safe mode. La modalità provvisoria è determinata dall'elemento <publisherPolicy apply="yes|no"/> , disponibile solo nel file di configurazione dell'applicazione.Safe mode is determined by the <publisherPolicy apply="yes|no"/> element, located only in the application configuration file. Specifica se le informazioni di configurazione dei criteri editore devono essere rimosse dal processo di associazione.It specifies whether the publisher policy configuration information should be removed from the binding process.

La modalità sicura può essere impostata per l'intera applicazione o per gli assembly selezionati.Safe mode can be set for the entire application or for selected assemblies. In altre parole è possibile disattivare i criteri per tutti gli assembly che costituiscono l'applicazione o attivarlo solo in alcuni assembly.That is, you can turn off the policy for all assemblies that make up the application, or turn it on for some assemblies but not others. Per applicare i criteri dell'editore solo agli assembly che costituiscono un'applicazione, impostare <publisherPolicy apply=no/> e specificare gli assembly da includere usando l'elemento <dependentAssembly>.To selectively apply publisher policy to assemblies that make up an application, set <publisherPolicy apply=no/> and specify which assemblies you want to be affected using the <dependentAssembly> element. Per applicare i criteri dell'editore a tutti gli assembly che costituiscono un'applicazione, impostare <publisherPolicy apply=no/> senza usare gli elementi relativi agli assembly dipendenti.To apply publisher policy to all assemblies that make up the application, set <publisherPolicy apply=no/> with no dependent assembly elements. Per altre informazioni sulla configurazione, vedere Configurazione delle app con file di configurazione.For more about configuration, see Configuring Apps by using Configuration Files.

File di configurazione del computerMachine Configuration File

In terzo luogo, il runtime esamina il file di configurazione del computer.Third, the runtime examines the machine configuration file. Questo file, denominato Machine.config, si trova nel computer locale nella sottodirectory Config della directory radice in cui è installato il runtime.This file, called Machine.config, resides on the local computer in the Config subdirectory of the root directory where the runtime is installed. Questo file può essere usato dagli amministratori per specificare le restrizioni relative all'associazione di assembly locali nel computer.This file can be used by administrators to specify assembly binding restrictions that are local to that computer. Le impostazioni nel file di configurazione del computer hanno la precedenza su tutte le altre impostazioni di configurazione. Tuttavia, ciò non implica che tutte le impostazioni di configurazione debbano essere inserite in questo file.The settings in the machine configuration file take precedence over all other configuration settings; however, this does not mean that all configuration settings should be put in this file. La versione determinata dal file dei criteri amministratore è finale e non può essere sottoposta a override.The version determined by the administrator policy file is final, and cannot be overridden. Gli override specificati nel file Machine.config file hanno effetto su tutte le applicazioni.Overrides specified in the Machine.config file affect all applications. Per altre informazioni sui file di configurazione, vedere Configurazione delle app con file di configurazione.For more information about configuration files, see Configuring Apps by using Configuration Files.

Passaggio 2: Controllo di assembly a cui è stato fatto riferimento in precedenzaStep 2: Checking for Previously Referenced Assemblies

Se l'assembly è stato richiesto anche nelle chiamate precedenti, Common Language Runtime usa l'assembly è già caricato.If the requested assembly has also been requested in previous calls, the common language runtime uses the assembly that is already loaded. Ciò può avere implicazioni per la denominazione di assembly che costituiscono un'applicazione.This can have ramifications when naming assemblies that make up an application. Per altre informazioni sulla denominazione degli assembly, vedere Nomi degli assembly.For more information about naming assemblies, see Assembly Names.

Se una richiesta precedente per l'assembly non è riuscita, le richieste successive verranno interrotte immediatamente senza effettuare alcun tentativo di caricamento dell'assembly.If a previous request for the assembly failed, subsequent requests for the assembly are failed immediately without attempting to load the assembly. A partire da .NET Framework versione 2.0, gli errori relativi all'associazione di assembly vengono memorizzati nella cache e le informazioni memorizzate nella cache vengono usate per determinare se tentare di caricare l'assembly.Starting with the .NET Framework version 2.0, assembly binding failures are cached, and the cached information is used to determine whether to attempt to load the assembly.

Nota

Per ripristinare il comportamento di .NET Framework versioni 1.0 e 1.1, che non memorizza nella cache gli errori di associazione, includere l'elemento <disableCachingBindingFailures> nel file di configurazione.To revert to the behavior of the .NET Framework versions 1.0 and 1.1, which did not cache binding failures, include the <disableCachingBindingFailures> Element in your configuration file.

Passaggio 3: Controllo della Global Assembly CacheStep 3: Checking the Global Assembly Cache

Per gli assembly con nome sicuro, il processo di associazione prosegue con la ricerca nella Global Assembly Cache.For strong-named assemblies, the binding process continues by looking in the global assembly cache. Gli assembly che possono essere usati da più applicazioni in un computer vengono archiviati nella Global Assembly Cache.The global assembly cache stores assemblies that can be used by several applications on a computer. Tutti gli assembly nella Global Assembly Cache devono avere nomi sicuri.All assemblies in the global assembly cache must have strong names.

Passaggio 4: Individuazione dell'assembly mediante codebase o probeStep 4: Locating the Assembly through Codebases or Probing

Dopo aver determinato la versione corretta dell'assembly usando le informazioni nel riferimento dell'assembly chiamante e nei file di configurazione e dopo aver archiviato tale versione nella Global Assembly Cache (solo per assembly con nome sicuro), Common Language Runtime tenta di trovare l'assembly.After the correct assembly version has been determined by using the information in the calling assembly's reference and in the configuration files, and after it has checked in the global assembly cache (only for strong-named assemblies), the common language runtime attempts to find the assembly. Il processo di individuazione di un assembly prevede i seguenti passaggi:The process of locating an assembly involves the following steps:

  1. Se nel file di configurazione dell'applicazione viene rilevato un elemento <codeBase>, il percorso specificato viene verificato dal runtime.If a <codeBase> element is found in the application configuration file, the runtime checks the specified location. Se viene rilevata una corrispondenza, viene usato l'assembly trovato e non vengono eseguite individuazioni tramite probe.If a match is found, that assembly is used and no probing occurs. Se l'assembly non viene trovato, la richiesta di associazione non riesce.If the assembly is not found there, the binding request fails.

  2. Il runtime esegue quindi l'individuazione tramite probe per l'assembly di riferimento usando le regole specificate più avanti in questa sezione.The runtime then probes for the referenced assembly using the rules specified later in this section.

Nota

Se sono presenti più versioni di un assembly in una directory e si vuole fare riferimento a una versione specifica, è necessario usare l'elemento <codeBase> invece dell'attributo privatePath dell'elemento <probing>.If you have multiple versions of an assembly in a directory and you want to reference a particular version of that assembly, you must use the <codeBase> element instead of the privatePath attribute of the <probing> element. Se si usa l'elemento <probing>, il runtime arresta l'individuazione tramite probe non appena viene trovato un assembly che corrisponde al nome semplice dell'assembly a cui viene fatto riferimento, indipendentemente dalla correttezza della corrispondenza.If you use the <probing> element, the runtime stops probing the first time it finds an assembly that matches the simple assembly name referenced, whether it is a correct match or not. Se la corrispondenza è corretta, viene usato questo assembly.If it is a correct match, that assembly is used. Se la corrispondenza non è corretta, l'individuazione tramite probe si arresta e l'associazione non riesce.If it is not a correct match, probing stops and binding fails.

Individuazione dell'assembly mediante codebaseLocating the Assembly through Codebases

È possibile specificare le informazioni relative alla codebase usando un elemento <codeBase> in un file di configurazione.Codebase information can be provided by using a <codeBase> element in a configuration file. Questa codebase viene sempre controllata prima che il runtime tenti l'individuazione tramite probe per l'assembly di riferimento.This codebase is always checked before the runtime attempts to probe for the referenced assembly. Se in un file dei criteri dell'editore contenente le informazioni per il reindirizzamento a una versione finale è incluso anche un elemento <codeBase>, verrà usato l'elemento <codeBase>.If a publisher policy file containing the final version redirect also contains a <codeBase> element, that <codeBase> element is the one that is used. Ad esempio, se il file di configurazione dell'applicazione specifica un elemento <codeBase> e anche un file dei criteri dell'editore tramite cui viene eseguito l'override delle informazioni dell'applicazione specifica un elemento <codeBase>, verrà usato l'elemento <codeBase> presente nel file dei criteri dell'editore.For example, if your application configuration file specifies a <codeBase> element, and a publisher policy file that is overriding the application information also specifies a <codeBase> element, the <codeBase> element in the publisher policy file is used.

Se nel percorso specificato dall'elemento <codeBase> non viene individuato alcun assembly, la richiesta di associazione non viene completata e non vengono eseguite altre operazioni.If no match is found at the location specified by the <codeBase> element, the bind request fails and no further steps are taken. Se il runtime determina che un assembly soddisfa i criteri dell'assembly chiamante, viene usato questo assembly.If the runtime determines that an assembly matches the calling assembly's criteria, it uses that assembly. Quando viene caricato il file indicato dall'elemento <codeBase> specificato, tramite il runtime viene controllato che il nome, la versione, le impostazioni cultura e la chiave pubblica corrispondano al riferimento dell'assembly chiamante.When the file specified by the given <codeBase> element is loaded, the runtime checks to make sure that the name, version, culture, and public key match the calling assembly's reference.

Nota

Gli assembly a cui viene fatto riferimento che sono esterni alla directory radice dell'applicazione devono avere nomi sicuri e devono essere installati nella Global Assembly Cache o specificati mediante l'elemento <codeBase>.Referenced assemblies outside the application's root directory must have strong names and must either be installed in the global assembly cache or specified using the <codeBase> element.

Individuazione dell'assembly mediante l'individuazione tramite probeLocating the Assembly through Probing

Se nel file di configurazione dell'applicazione non è stato specificato alcun elemento <codeBase>, il runtime esegue la ricerca dell'assembly usando quattro criteri:If there is no <codeBase> element in the application configuration file, the runtime probes for the assembly using four criteria:

  • La base dell'applicazione, ovvero il percorso radice in cui viene eseguita l'applicazione.Application base, which is the root location where the application is being executed.

  • Le impostazioni cultura, ovvero l'attributo delle impostazioni cultura dell'assembly di riferimento.Culture, which is the culture attribute of the assembly being referenced.

  • Il nome, ovvero il nome dell'assembly di riferimento.Name, which is the name of the referenced assembly.

  • L'attributo privatePath dell'elemento <probing>, ovvero l'elenco definito dall'utente delle sottodirectory del percorso radice.The privatePath attribute of the <probing> element, which is the user-defined list of subdirectories under the root location. Questo percorso può essere specificato nel file di configurazione dell'applicazione e nel codice gestito mediante la proprietà AppDomainSetup.PrivateBinPath di un dominio applicazione.This location can be specified in the application configuration file and in managed code using the AppDomainSetup.PrivateBinPath property for an application domain. Quando è specificato nel codice gestito, viene eseguita prima l'individuazione tramite probe del codice gestito privatePath, seguita dal percorso specificato nel file di configurazione dell'applicazione.When specified in managed code, the managed code privatePath is probed first, followed by the path specified in the application configuration file.

Individuazione tramite probe delle directory Application Base e CultureProbing the Application Base and Culture Directories

Il runtime avvia sempre l'individuazione tramite probe nella base dell'applicazione, che può essere un URL o la directory radice dell'applicazione in un computer.The runtime always begins probing in the application's base, which can be either a URL or the application's root directory on a computer. Se l'assembly di riferimento non viene trovato nella base dell'applicazione e non viene fornita alcuna informazione sulle impostazioni cultura, il runtime cerca il nome dell'assembly in tutte le sottodirectory.If the referenced assembly is not found in the application base and no culture information is provided, the runtime searches any subdirectories with the assembly name. Le directory di cui viene eseguita l'individuazione tramite probe includono:The directories probed include:

[application base]/[assembly name].dll[application base] / [assembly name].dll

[application base]/[assembly name]/[assembly name].dll[application base] / [assembly name] / [assembly name].dll

Se si specificano le informazioni sulle impostazioni cultura per l'assembly di riferimento, l'individuazione tramite probe viene eseguita solo sulle seguenti directory:If culture information is specified for the referenced assembly, only the following directories are probed:

[application base]/[culture]/[assembly name].dll[application base] / [culture] / [assembly name].dll

[application base]/[culture]/[assembly name]/[assembly name].dll[application base] / [culture] / [assembly name] / [assembly name].dll

Individuazione tramite probe con l'attributo privatePathProbing with the privatePath Attribute

Oltre alle sottodirectory relative alle impostazioni cultura e a quelle specificate per l'assembly a cui viene fatto riferimento, il runtime esegue la ricerca anche nelle directory specificate dall'attributo privatePath dell'elemento <probing>.In addition to the culture subdirectories and the subdirectories named for the referenced assembly, the runtime also probes directories specified using the privatePath attribute of the <probing> element. Le directory specificate usando l'attributo privatePath devono essere sottodirectory della directory radice dell'applicazione.The directories specified using the privatePath attribute must be subdirectories of the application's root directory. Le directory con individuazione tramite probe variano a seconda che le informazioni sulle impostazioni cultura siano incluse o meno nella richiesta dell'assembly di riferimento.The directories probed vary depending on whether culture information is included in the referenced assembly request.

Il runtime arresta l'individuazione tramite probe appena trova un assembly che corrisponde al nome semplice dell'assembly indicato, senza tenere conto della correttezza della corrispondenza.The runtime stops probing the first time it finds an assembly that matches the simple assembly name referenced, whether it is a correct match or not. Se la corrispondenza è corretta, viene usato questo assembly.If it is a correct match, that assembly is used. Se la corrispondenza non è corretta, l'individuazione tramite probe si arresta e l'associazione non riesce.If it is not a correct match, probing stops and binding fails.

Se le impostazioni cultura sono incluse, l'individuazione tramite probe viene eseguita sulle seguenti directory:If culture is included, the following directories are probed:

[application base]/[binpath]/[culture]/[assembly name].dll[application base] / [binpath] / [culture] / [assembly name].dll

[application base]/[binpath]/[culture]/[assembly name]/[assembly name].dll[application base] / [binpath] / [culture] / [assembly name] / [assembly name].dll

Se le informazioni sulle impostazioni cultura non sono incluse, l'individuazione tramite probe viene eseguita sulle seguenti directory:If culture information is not included, the following directories are probed:

[application base]/[binpath]/[assembly name].dll[application base] / [binpath] / [assembly name].dll

[application base]/[binpath]/[assembly name]/[assembly name].dll[application base] / [binpath] / [assembly name] / [assembly name].dll

Esempi di individuazione tramite probeProbing Examples

Date le seguenti informazioni:Given the following information:

  • Nome dell'assembly di riferimento: myAssemblyReferenced assembly name: myAssembly

  • Directory radice dell'applicazione: http://www.code.microsoft.comApplication root directory: http://www.code.microsoft.com

  • Elemento <probing> specificato nel file di configurazione: bin<probing> element in configuration file specifies: bin

  • Impostazioni cultura: deCulture: de

Il runtime esegue l'individuazione tramite probe dei seguenti URL:The runtime probes the following URLs:

http://www.code.microsoft.com/de/myAssembly.dll

http://www.code.microsoft.com/de/myAssembly/myAssembly.dll

http://www.code.microsoft.com/bin/de/myAssembly.dll

http://www.code.microsoft.com/bin/de/myAssembly/myAssembly.dll

Più assembly con lo stesso nomeMultiple Assemblies with the Same Name

L'esempio seguente mostra come configurare più assembly con lo stesso nome.The following example shows how to configure multiple assemblies with the same name.

<dependentAssembly>  
   <assemblyIdentity name="Server" publicKeyToken="c0305c36380ba429" />   
   <codeBase version="1.0.0.0" href="v1/Server.dll" />  
   <codeBase version="2.0.0.0" href="v2/Server.dll" />  
</dependentAssembly>  

Altri percorsi con individuazione tramite probeOther Locations Probed

Il percorso dell'assembly può essere determinato anche usando il contesto di associazione corrente.Assembly location can also be determined using the current binding context. Questa situazione si verifica spesso quando il metodo Assembly.LoadFrom viene usato in scenari di interoperabilità COM.This most often occurs when the Assembly.LoadFrom method is used and in COM interop scenarios. Se un assembly usa il metodo LoadFrom per fare riferimento a un altro assembly, il percorso dell'assembly chiamante viene considerato come un suggerimento su dove trovare l'assembly di riferimento.If an assembly uses the LoadFrom method to reference another assembly, the calling assembly's location is considered to be a hint about where to find the referenced assembly. Se viene trovata una corrispondenza, l'assembly viene caricato.If a match is found, that assembly is loaded. Se non viene trovata alcuna corrispondenza, il runtime continua con la semantica di ricerca, quindi esegue una query in Windows Installer per richiedere l'assembly.If no match is found, the runtime continues with its search semantics and then queries the Windows Installer to provide the assembly. Se non vengono forniti assembly corrispondenti alla richiesta di associazione, viene generata un'eccezione.If no assembly is provided that matches the binding request, an exception is thrown. Questa eccezione è TypeLoadException nel codice gestito, se è stato fatto riferimento a un tipo, oppure FileNotFoundException se l'assembly in fase di caricamento non è stato trovato.This exception is a TypeLoadException in managed code if a type was referenced, or a FileNotFoundException if an assembly being loaded was not found.

Se ad esempio Assembly1 fa riferimento ad Assembly2 e Assembly1 è stato scaricato da http://www.code.microsoft.com/utils, il percorso viene considerato come un suggerimento su dove trovare Assembly2.dll.For example, if Assembly1 references Assembly2 and Assembly1 was downloaded from http://www.code.microsoft.com/utils, that location is considered to be a hint about where to find Assembly2.dll. Il runtime quindi verifica la presenza dell'assembly in http://www.code.microsoft.com/utils/Assembly2.dll e http://www.code.microsoft.com/utils/Assembly2/Assembly2.dll.The runtime then probes for the assembly in http://www.code.microsoft.com/utils/Assembly2.dll and http://www.code.microsoft.com/utils/Assembly2/Assembly2.dll. Se Assembly2 non viene trovato nei percorsi indicati, il runtime esegue una query in Windows Installer.If Assembly2 is not found at either of those locations, the runtime queries the Windows Installer.

Vedere ancheSee also