Méthode de localisation des assemblys par le runtimeHow the Runtime Locates Assemblies

Pour déployer correctement votre application .NET Framework, il est important de bien comprendre comment le common language runtime localise les assemblys qui composent votre application et comment il établit des liaisons à ces assemblys.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. Par défaut, le runtime essaie d'établir une liaison avec la version exacte d'un assembly avec lequel l'application a été générée.By default, the runtime attempts to bind with the exact version of an assembly that the application was built with. Ce comportement par défaut peut être substitué par les paramètres du fichier de configuration.This default behavior can be overridden by configuration file settings.

Le common language runtime effectue plusieurs étapes pour essayer de localiser un assembly et résoudre une référence d'assembly.The common language runtime performs a number of steps when attempting to locate an assembly and resolve an assembly reference. Chaque étape est expliquée dans les sections ci-dessous.Each step is explained in the following sections. Le terme « détection » est souvent utilisé pour décrire la manière dont le runtime localise les assemblys. Il fait référence au jeu de paramètres heuristiques utilisé pour localiser l'assembly en fonction de son nom et de sa culture.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.

Notes

Vous pouvez afficher les informations de liaison du fichier journal en utilisant la visionneuse du journal de liaison d’assembly (Fuslogvw.exe), fournie dans le SDK Windows.You can view binding information in the log file using the Assembly Binding Log Viewer (Fuslogvw.exe), which is included in the Windows SDK.

Initiation de la liaisonInitiating the Bind

Le processus de localisation et de liaison d'un assembly débute quand le runtime tente de résoudre une référence à un autre assembly.The process of locating and binding to an assembly begins when the runtime attempts to resolve a reference to another assembly. Cette référence peut être statique ou dynamique.This reference can be either static or dynamic. Le compilateur enregistre les références statiques dans les métadonnées du manifeste d'assembly au moment de la build.The compiler records static references in the assembly manifest's metadata at build time. Les références dynamiques sont créées instantanément après l’appel à différentes méthodes, telles que Assembly.Load.Dynamic references are constructed on the fly as a result of calling various methods, such as Assembly.Load.

La meilleure façon de référencer un assembly est d'utiliser une référence complète, comprenant le nom de l'assembly, sa version, sa culture et son jeton de clé publique (le cas échéant).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). Le runtime se sert de ces informations pour localiser l'assembly, en suivant les étapes décrites plus loin dans cette section.The runtime uses this information to locate the assembly, following the steps described later in this section. Il utilise le même processus de résolution pour les références d'assemblys statiques et dynamiques.The runtime uses the same resolution process regardless of whether the reference is for a static or dynamic assembly.

Vous pouvez aussi créer une référence dynamique à un assembly en fournissant à la méthode d'appel seulement une partie des informations relatives à l'assembly, par exemple en spécifiant le nom de l'assembly uniquement.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. Dans ce cas, l'assembly n'est recherché que dans le répertoire de l'application et aucune autre vérification n'est effectuée.In this case, only the application directory is searched for the assembly, and no other checking occurs. Il est possible de créer une référence partielle à l’aide d’une des méthodes de chargement des assemblys, telle que Assembly.Load ou AppDomain.Load.You make a partial reference using any of the various methods for loading assemblies such as Assembly.Load or AppDomain.Load.

Pour finir, vous pouvez créer une référence dynamique en utilisant une méthode comme Assembly.Load à laquelle vous fournissez seulement des informations partielles. Vous qualifiez ensuite la référence en définissant l’élément <qualifyAssembly> dans le fichier de configuration de l’application.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. Cet élément vous permet de fournir les informations de la référence complète (nom, version, culture et, le cas échéant, jeton de clé publique) dans le fichier de configuration de votre application plutôt que dans votre code.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. Utilisez cette technique si vous souhaitez créer une référence complète à un assembly en dehors du répertoire de l'application, ou si vous souhaitez référencer un assembly dans le Global Assembly Cache en gardant la possibilité de spécifier la référence complète dans le fichier de configuration plutôt que dans votre code.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.

Notes

Ce type de référence partielle ne doit pas être utilisé avec des assemblys partagés par plusieurs applications.This type of partial reference should not be used with assemblies that are shared among several applications. Les paramètres de configuration sont appliqués au niveau de l'application, et non de chaque assembly. Par conséquent, un assembly partagé utilisant ce type de référence partielle nécessite que chaque application liée à l'assembly partagé possède les informations de qualification dans son fichier de configuration.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.

Le runtime effectue les étapes suivantes pour résoudre une référence d'assembly :The runtime uses the following steps to resolve an assembly reference:

  1. Ildétermine la version correcte de l'assembly en examinant les fichiers de configuration applicables, y compris le fichier de configuration de l'application, le fichier de stratégie d'éditeur et le fichier de configuration de l'ordinateur.Determines the correct assembly version by examining applicable configuration files, including the application configuration file, publisher policy file, and machine configuration file. Si le fichier de configuration est situé sur un ordinateur distant, le runtime doit tout d'abord localiser et télécharger le fichier de configuration de l'application.If the configuration file is located on a remote machine, the runtime must locate and download the application configuration file first.

  2. Ilvérifie si le nom de l'assembly a déjà été lié et, si c'est le cas, il utilise l'assembly précédemment chargé.Checks whether the assembly name has been bound to before and, if so, uses the previously loaded assembly. Si une précédente demande de chargement de l'assembly avait échoué, la nouvelle demande échoue immédiatement sans qu'aucune tentative de chargement de l'assembly ne soit effectuée.If a previous request to load the assembly failed, the request is failed immediately without attempting to load the assembly.

    Notes

    La mise en cache des échecs de liaison d'assemblys a été introduite dans .NET Framework version 2.0.The caching of assembly binding failures is new in the .NET Framework version 2.0.

  3. Ilvérifie le Global Assembly Cache.Checks the global assembly cache. S'il y trouve l'assembly, il l'utilise.If the assembly is found there, the runtime uses this assembly.

  4. Ildétecte l'assembly en procédant comme suit :Probes for the assembly using the following steps:

    1. Si la configuration et la stratégie d'éditeur n'affectent pas la référence d'origine et que la demande de liaison a été faite avec la méthode Assembly.LoadFrom , le runtime vérifie la présence d'indications relatives à l'emplacement.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. Si une base de code est trouvée dans les fichiers de configuration, le runtime vérifie uniquement cet emplacement.If a codebase is found in the configuration files, the runtime checks only this location. Si cette détection ne donne aucun résultat, le runtime détermine que la demande de liaison a échoué et ne tente pas d'autre détection.If this probe fails, the runtime determines that the binding request failed and no other probing occurs.

    3. Il détecte l'assembly en se servant des paramètres heuristiques décrits dans la section sur la détection.Probes for the assembly using the heuristics described in the probing section. Si la détection ne permet pas de trouver l'assembly, le runtime demande à Windows Installer de lui fournir l'assemblyIf the assembly is not found after probing, the runtime requests the Windows Installer to provide the assembly. (sous la forme d'une fonctionnalité d'installation à la demande).This acts as an install-on-demand feature.

      Notes

      Pour les assemblys sans nom fort, le runtime n'effectue pas de vérification de version, ni de vérification dans le Global Assembly Cache.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.

Étape 1 : examen des fichiers de configurationStep 1: Examining the Configuration Files

Le comportement de la liaison d'assembly peut être configuré à différents niveaux à l'aide de ces trois fichiers XML :Assembly binding behavior can be configured at different levels based on three XML files:

  • le fichier de configuration de l'application ;Application configuration file.

  • le fichier de stratégie d'éditeur ;Publisher policy file.

  • le fichier de configuration de l'ordinateur.Machine configuration file.

Ces fichiers utilisent la même syntaxe. Ils fournissent plusieurs informations, notamment les redirections de liaisons, l'emplacement du code et les modes de liaison pour des assemblys particuliers.These files follow the same syntax and provide information such as binding redirects, the location of code, and binding modes for particular assemblies. Chaque fichier de configuration peut contenir un élément <assemblyBinding> qui redirige le processus de liaison.Each configuration file can contain an <assemblyBinding> element that redirects the binding process. Les éléments enfants de l’élément <assemblyBinding> incluent l’élément <dependentAssembly>.The child elements of the <assemblyBinding> element include the <dependentAssembly> element. Les éléments enfants de l’élément <dependentAssembly> incluent l’élément <assemblyIdentity>, l’élément <bindingRedirect> et l’élément <codeBase>.The children of <dependentAssembly> element include the <assemblyIdentity> element, the <bindingRedirect> element, and the <codeBase> element.

Notes

Les trois fichiers de configuration peuvent contenir des informations de configuration, mais ils n'acceptent pas forcément tous les éléments.Configuration information can be found in the three configuration files; not all elements are valid in all configuration files. Par exemple, les informations sur le mode de liaison et le chemin d'accès privé peuvent seulement se trouver dans le fichier de configuration de l'application.For example, binding mode and private path information can only be in the application configuration file. Pour obtenir la liste complète des informations contenues dans chaque fichier, consultez Configuration des applications à l'aide de fichiers de configuration.For a complete list of the information that is contained in each file, see Configuring Apps by Using Configuration Files.

Fichier de configuration de l'applicationApplication Configuration File

Le common language runtime vérifie tout d'abord le fichier de configuration de l'application à la recherche d'informations qui substituent les informations de version stockées dans le manifeste de l'assembly appelant.First, the common language runtime checks the application configuration file for information that overrides the version information stored in the calling assembly's manifest. Le fichier de configuration de l'application peut être déployé avec une application, mais il n'est pas nécessaire à l'exécution de celle-ci.The application configuration file can be deployed with an application, but is not required for application execution. En règle générale, la récupération de ce fichier est quasi instantanée mais, si la base de l'application se trouve sur un ordinateur distant (dans le cas d'une application web basée sur Internet Explorer, par exemple), le fichier de configuration doit être téléchargé.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.

Pour les fichiers exécutables client, le fichier de configuration de l'application réside dans le même répertoire que le fichier exécutable de l'application et possède le même nom que le fichier exécutable avec une extension .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. Par exemple, le fichier de configuration pour C:\Program Files\Myapp\Myapp.exe est C:\Program Files\Myapp\Myapp.exe.config. S’il s’agit d’une application basée sur un navigateur, le fichier HTML doit utiliser l’élément <link> pour pointer explicitement vers le fichier de configuration.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.

Le code suivant fournit un exemple simple de fichier de configuration de l'application.The following code provides a simple example of an application configuration file. Cet exemple ajoute un élément TextWriterTraceListener à la collection Listeners pour activer l'enregistrement des informations de débogage dans un fichier.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>

Fichier de stratégie d'éditeurPublisher Policy File

Le runtime examine ensuite le fichier de stratégie d'éditeur (si ce fichier existe).Second, the runtime examines the publisher policy file, if one exists. Les fichiers de stratégie d'éditeur sont distribués par un éditeur de composant, sous forme de correctif ou de mise à jour, à un composant partagé.Publisher policy files are distributed by a component publisher as a fix or update to a shared component. Ces fichiers contiennent des informations de compatibilité émises par l'éditeur du composant partagé qui dirige une référence d'assembly vers une nouvelle version.These files contain compatibility information issued by the publisher of the shared component that directs an assembly reference to a new version. Contrairement aux fichiers de configuration de l'application et de l'ordinateur, les fichiers de stratégie d'éditeur sont contenus dans leur propre assembly qui doit être installé dans le 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.

Voici un exemple de fichier de configuration de stratégie d'éditeur :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>

Pour créer un assembly, utilisez l’outil Al.exe (Assembly Linker) avec une commande telle que la suivante :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 est un fichier de clé de nom fort.compatkey.dat is a strong-name key file. Cette commande crée un assembly de nom fort que vous pouvez placer dans le Global Assembly Cache.This command creates a strong-named assembly you can place in the global assembly cache.

Notes

La stratégie d'éditeur est appliquée à toutes les applications qui utilisent un composant partagé.Publisher policy affects all applications that use a shared component.

Le fichier de configuration de la stratégie d'éditeur substitue les informations de version fournies par l'application (c'est-à-dire celles du manifeste de l'assembly ou du fichier de configuration de l'application).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). Si aucune instruction dans le fichier de configuration de l'application ne redirige la version qui est spécifiée dans le manifeste de l'assembly, le fichier de stratégie d'éditeur substitue cette version.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. En revanche, si une instruction de redirection est indiquée dans le fichier de configuration de l'application, le fichier de stratégie d'éditeur substitue cette version et non celle qui est spécifiée dans le manifeste.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 fichier de stratégie d'éditeur est utilisé quand un composant partagé est mis à jour et que la nouvelle version de ce composant doit être utilisée par toutes les applications partageant le composant.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. Les paramètres définis dans le fichier de stratégie d'éditeur substituent ceux du fichier de configuration de l'application, sauf si ce dernier applique le mode sans échec.The settings in the publisher policy file override settings in the application configuration file, unless the application configuration file enforces safe mode.

Mode sans échecSafe Mode

Les fichiers de stratégie d'éditeur sont généralement installés explicitement avec un Service Pack ou une mise à jour de programme.Publisher policy files are usually explicitly installed as part of a service pack or program update. En cas de problème avec le composant partagé mis à jour, vous pouvez ignorer les substitutions spécifiées dans le fichier de stratégie d'éditeur en utilisant le mode sans échec.If there is any problem with the upgraded shared component, you can ignore the overrides in the publisher policy file using safe mode. Le mode sans échec est déterminé par l’élément <publisherPolicy apply="yes|no"/> , situé uniquement dans le fichier de configuration d’application.Safe mode is determined by the <publisherPolicy apply="yes|no"/> element, located only in the application configuration file. Il spécifie si les informations de configuration du fichier de stratégie d'éditeur doivent être supprimées du processus de liaison.It specifies whether the publisher policy configuration information should be removed from the binding process.

Le mode sans échec peut être défini pour toute l'application ou pour des assemblys spécifiques.Safe mode can be set for the entire application or for selected assemblies. Autrement dit, vous pouvez désactiver la stratégie pour tous les assemblys qui composent votre application ou l'activer pour certains assemblys seulement.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. Pour appliquer sélectivement la stratégie d’éditeur aux assemblys qui composent une application, définissez l’élément <publisherPolicy apply=no/> et spécifiez les assemblys auxquels appliquer la stratégie à l’aide de l’élément <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. Pour appliquer la stratégie d’éditeur à tous les assemblys composant l’application, définissez l’élément <publisherPolicy apply=no/> sans aucun élément d’assembly dépendant.To apply publisher policy to all assemblies that make up the application, set <publisherPolicy apply=no/> with no dependent assembly elements. Pour plus d'informations sur la configuration, consultez Configuration des applications à l'aide de fichiers de configuration.For more about configuration, see Configuring Apps by using Configuration Files.

Fichier de configuration de l'ordinateurMachine Configuration File

Finalement, le runtime examine le fichier de configuration de l'ordinateur.Third, the runtime examines the machine configuration file. Ce fichier, intitulé Machine.config, réside sur l'ordinateur local dans le sous-répertoire Config du répertoire racine où le runtime est installé.This file, called Machine.config, resides on the local computer in the Config subdirectory of the root directory where the runtime is installed. Il peut être utilisé par les administrateurs pour spécifier des restrictions de liaison d'assemblys qui sont propres à cet ordinateur.This file can be used by administrators to specify assembly binding restrictions that are local to that computer. Les paramètres définis dans le fichier de configuration de l'ordinateur sont prioritaires par rapport aux autres paramètres de configuration. Cependant, cela ne signifie pas que tous les paramètres de configuration doivent être placés dans ce fichier.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 version déterminée par le fichier de stratégie d'administrateur est finale et ne peut pas être substituée.The version determined by the administrator policy file is final, and cannot be overridden. Les substitutions spécifiées dans le fichier Machine.config s'appliquent à toutes les applications.Overrides specified in the Machine.config file affect all applications. Pour plus d'informations sur les fichiers de configuration, consultez Configuration des applications à l'aide de fichiers de configuration.For more information about configuration files, see Configuring Apps by using Configuration Files.

Étape 2 : rechercher les assemblys précédemment référencésStep 2: Checking for Previously Referenced Assemblies

Si l'assembly demandé a aussi été demandé lors d'appels précédents, le common language runtime utilise l'assembly qui est déjà chargé.If the requested assembly has also been requested in previous calls, the common language runtime uses the assembly that is already loaded. Ceci peut avoir des implications au moment de l'attribution des noms des assemblys qui composent une application.This can have ramifications when naming assemblies that make up an application. Pour plus d'informations sur l'attribution des noms des assemblys, voir Noms d'assemblys.For more information about naming assemblies, see Assembly Names.

Si une précédente demande de chargement de l'assembly avait échoué, toute nouvelle demande échoue immédiatement sans qu'aucune tentative de chargement de l'assembly ne soit effectuée.If a previous request for the assembly failed, subsequent requests for the assembly are failed immediately without attempting to load the assembly. Depuis la version 2.0 du .NET Framework, les échecs de liaison d'assemblys sont mis en cache et les informations mises en cache sont utilisées pour déterminer s'il faut essayer de charger 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.

Notes

Pour rétablir le comportement des versions 1.0 et 1.1 du .NET Framework, où il n’y avait pas de mise en cache des échecs de liaison, ajoutez l’élément <disableCachingBindingFailures> dans votre fichier de configuration.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.

Étape 3 : vérifier le Global Assembly CacheStep 3: Checking the Global Assembly Cache

Pour les assemblys avec un nom fort, le processus de liaison examine ensuite le Global Assembly Cache.For strong-named assemblies, the binding process continues by looking in the global assembly cache. Le Global Assembly Cache stocke des assemblys qui peuvent être utilisés par plusieurs applications sur un ordinateur.The global assembly cache stores assemblies that can be used by several applications on a computer. Tous les assemblys figurant dans le Global Assembly Cache doivent avoir un nom fort.All assemblies in the global assembly cache must have strong names.

Étape 4 : localisation de l’assembly par le biais des bases de code ou de la détectionStep 4: Locating the Assembly through Codebases or Probing

Une fois que la version correcte de l'assembly a été déterminée d'après les informations contenues dans la référence de l'assembly appelant et dans les fichiers de configuration, et après la vérification du Global Assembly Cache (uniquement pour les assemblys avec un nom fort), le common language runtime tente de trouver 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. Le processus de localisation d'un assembly implique les étapes suivantes :The process of locating an assembly involves the following steps:

  1. Si un élément <codeBase> est trouvé dans le fichier de configuration de l’application, le runtime vérifie l’emplacement spécifié.If a <codeBase> element is found in the application configuration file, the runtime checks the specified location. Si une correspondance est trouvée, cet assembly est utilisé et aucune détection n'est effectuée.If a match is found, that assembly is used and no probing occurs. Si l'assembly ne se trouve pas dans cet emplacement, la demande de liaison échoue.If the assembly is not found there, the binding request fails.

  2. Le runtime tente ensuite de détecter l'assembly référencé en utilisant les règles spécifiées plus loin dans cette section.The runtime then probes for the referenced assembly using the rules specified later in this section.

Notes

Si vous disposez de plusieurs versions d’un assembly dans un répertoire et que vous souhaitez référencer une version particulière de cet assembly, utilisez l’élément <codeBase> à la place de l’attribut privatePath de l’élément <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. Si vous utilisez l’élément <probing>, le runtime interrompt la détection dès qu’il trouve le premier assembly correspondant au nom simple d’assembly référencé, que cette correspondance soit correcte ou non.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. Si la correspondance est correcte, cet assembly est utilisé.If it is a correct match, that assembly is used. Si elle ne l'est pas, la détection s'interrompt et la liaison échoue.If it is not a correct match, probing stops and binding fails.

Localisation de l'assembly par bases de codeLocating the Assembly through Codebases

Les informations de base de code peuvent être obtenues en utilisant un élément <codeBase> dans un fichier de configuration.Codebase information can be provided by using a <codeBase> element in a configuration file. Cette base de code est toujours vérifiée avant que le runtime ne tente de détecter l'assembly référencé.This codebase is always checked before the runtime attempts to probe for the referenced assembly. Si un fichier de stratégie d’éditeur contenant la redirection de la version finale contient aussi un élément <codeBase>, c’est cet élément <codeBase> qui est utilisé.If a publisher policy file containing the final version redirect also contains a <codeBase> element, that <codeBase> element is the one that is used. Par exemple, si votre fichier de configuration de l’application spécifie un élément <codeBase> et qu’un fichier de stratégie d’éditeur qui substitue les informations de l’application spécifie aussi un élément <codeBase>, l’élément <codeBase> du fichier de stratégie d’éditeur est utilisé.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.

Si aucune correspondance n’est trouvée dans l’emplacement défini par l’élément <codeBase>, la demande de liaison échoue et le processus s’arrête.If no match is found at the location specified by the <codeBase> element, the bind request fails and no further steps are taken. Si le runtime détermine qu'un assembly correspond au critère de l'assembly appelant, il utilise cet assembly.If the runtime determines that an assembly matches the calling assembly's criteria, it uses that assembly. Quand le fichier spécifié par l’élément <codeBase> donné est chargé, le runtime vérifie que le nom, la version, la culture et la clé publique correspondent bien à la référence de l’assembly appelant.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.

Notes

Les assemblys référencés à l’extérieur du répertoire racine de l’application doivent avoir un nom fort et doivent être installés dans le Global Assembly Cache ou spécifiés à l’aide de l’élément <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.

Localisation de l'assembly par détectionLocating the Assembly through Probing

Si aucun élément <codeBase> ne se trouve dans le fichier de configuration de l’application, le runtime tente de détecter l’assembly à l’aide des quatre critères suivants :If there is no <codeBase> element in the application configuration file, the runtime probes for the assembly using four criteria:

  • La base de l'application, qui est l'emplacement racine où l'application s'exécute.Application base, which is the root location where the application is being executed.

  • La culture, qui est l'attribut de culture de l'assembly référencé.Culture, which is the culture attribute of the assembly being referenced.

  • Le nom, qui est le nom de l'assembly référencé.Name, which is the name of the referenced assembly.

  • L’attribut privatePath de l’élément <probing>, qui est la liste définie par l’utilisateur des sous-répertoires sous l’emplacement racine.The privatePath attribute of the <probing> element, which is the user-defined list of subdirectories under the root location. Cet emplacement peut être spécifié dans le fichier de configuration de l'application et dans le code managé en utilisant la propriété AppDomainSetup.PrivateBinPath pour un domaine d'application.This location can be specified in the application configuration file and in managed code using the AppDomainSetup.PrivateBinPath property for an application domain. Quand il est spécifié dans le code managé, l'attribut privatePath du code managé est détecté en premier, suivi du chemin d'accès spécifié dans le fichier de configuration de l'application.When specified in managed code, the managed code privatePath is probed first, followed by the path specified in the application configuration file.

Détection de la base de l'application et des répertoires de cultureProbing the Application Base and Culture Directories

Le runtime commence toujours le processus de détection dans la base de l'application, qui peut être une URL ou le répertoire racine de l'application sur un ordinateur.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. Si l'assembly référencé n'est pas trouvé dans la base de l'application et qu'aucune information de culture n'est fournie, le runtime recherche des sous-répertoires avec le nom de l'assembly.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. Les répertoires détectés sont les suivants :The directories probed include:

  • [base de l'application] / [nom de l'assembly].dll[application base] / [assembly name].dll

  • [base de l'application] / [nom de l'assembly] / [nom de l'assembly].dll[application base] / [assembly name] / [assembly name].dll

Si les informations de culture sont spécifiées pour l'assembly référencé, seuls les répertoires suivants sont détectés :If culture information is specified for the referenced assembly, only the following directories are probed:

  • [base de l'application] / [culture] / [nom de l'assembly].dll[application base] / [culture] / [assembly name].dll

  • [base de l'application] / [culture] / [nom de l'assembly] / [nom de l'assembly].dll[application base] / [culture] / [assembly name] / [assembly name].dll

Détection avec l'attribut privatePathProbing with the privatePath Attribute

En plus des sous-répertoires de culture et des sous-répertoires nommés pour l’assembly référencé, le runtime détecte aussi les répertoires spécifiés en utilisant l’attribut privatePath de l’élément <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. Les répertoires spécifiés avec l'attribut privatePath doivent être des sous-répertoires du répertoire racine de l'application.The directories specified using the privatePath attribute must be subdirectories of the application's root directory. Les répertoires détectés varient en fonction de la présence d'informations de culture dans la demande de l'assembly référencé.The directories probed vary depending on whether culture information is included in the referenced assembly request.

Le runtime interrompt la détection dès qu'il trouve le premier assembly correspondant au nom simple d'assembly référencé, que cette correspondance soit correcte ou non.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. Si la correspondance est correcte, cet assembly est utilisé.If it is a correct match, that assembly is used. Si elle ne l'est pas, la détection s'interrompt et la liaison échoue.If it is not a correct match, probing stops and binding fails.

Si des informations de culture sont incluses, les répertoires suivants sont détectés :If culture is included, the following directories are probed:

  • [base de l'application] / [chemin bin] / [culture] / [nom de l'assembly].dll[application base] / [binpath] / [culture] / [assembly name].dll

  • [base de l'application] / [chemin bin] / [culture] / [nom de l'assembly] / [nom de l'assembly].dll[application base] / [binpath] / [culture] / [assembly name] / [assembly name].dll

Si des informations de culture ne sont pas incluses, les répertoires suivants sont détectés :If culture information is not included, the following directories are probed:

  • [base de l'application] / [chemin bin] / [nom de l'assembly].dll[application base] / [binpath] / [assembly name].dll

  • [base de l'application] / [chemin bin] / [nom de l'assembly] / [nom de l'assembly].dll[application base] / [binpath] / [assembly name] / [assembly name].dll

Exemples de détectionProbing Examples

Les exemples donnés sont basés sur les informations suivantes :Given the following information:

  • Nom de l'assembly référencé : myAssemblyReferenced assembly name: myAssembly

  • Répertoire racine de l’application : http://www.code.microsoft.comApplication root directory: http://www.code.microsoft.com

  • L’élément <probing> dans le fichier de configuration spécifie : bin<probing> element in configuration file specifies: bin

  • Culture : deCulture: de

Le runtime détecte les URL suivantes :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

Plusieurs assemblys ayant le même nomMultiple Assemblies with the Same Name

L'exemple suivant indique comment configurer plusieurs assemblys ayant le même nom.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>

Autres emplacements détectésOther Locations Probed

L'emplacement de l'assembly peut aussi être déterminé d'après le contexte de liaison actuel.Assembly location can also be determined using the current binding context. Cela se produit le plus souvent quand la méthode Assembly.LoadFrom est utilisée dans des scénarios COM Interop.This most often occurs when the Assembly.LoadFrom method is used and in COM interop scenarios. Si un assembly utilise la méthode LoadFrom pour référencer un autre assembly, l'emplacement de l'assembly appelant est considéré comme étant une indication de l'emplacement de l'assembly référencé.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. Si une correspondance est trouvée, cet assembly est chargé.If a match is found, that assembly is loaded. Si aucune correspondance n'est trouvée, le runtime continue ses recherches sémantiques, puis demande à Windows Installer de lui fournir l'assembly.If no match is found, the runtime continues with its search semantics and then queries the Windows Installer to provide the assembly. Si aucun assembly correspondant à la demande de liaison n'est fourni, une exception est levée.If no assembly is provided that matches the binding request, an exception is thrown. Il s'agit d'une exception TypeLoadException dans le code managé si un type a été référencé ou d'une exception FileNotFoundException si un assembly à charger n'a pas été trouvé.This exception is a TypeLoadException in managed code if a type was referenced, or a FileNotFoundException if an assembly being loaded was not found.

Par exemple, si Assembly1 référence Assembly2 et qu’Assembly1 a été chargé à partir de http://www.code.microsoft.com/utils, cet emplacement est considéré comme étant une indication de l’emplacement d’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. Le runtime sonde alors l’assembly dans http://www.code.microsoft.com/utils/Assembly2.dll et 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. Si Assembly2 n'est pas trouvé dans ces emplacements, le runtime demande à Windows Installer de lui fournir l'assembly.If Assembly2 is not found at either of those locations, the runtime queries the Windows Installer.

Voir aussiSee also