DOC : Global Assembly Cache (GAC) API sont pas documentés dans la documentation .NET Framework Software Development Kit (SDK)

Traductions disponibles Traductions disponibles
Numéro d'article: 317540 - Voir les produits auxquels s'applique cet article
Agrandir tout | Réduire tout

Sommaire

Résumé

Les code natif interfaces de programmation (API) qui vous permettent d'interagir avec le Global Assembly Cache (GAC) ne sont pas expliquées dans la documentation Kit de développement SDK .NET Framework.

Plus d'informations

attention : ne pas utiliser ces API dans votre application pour effectuer des liaisons d'assembly ou pour tester la présence d'assemblys ou autres temps d'exécution, développement ou opérations DTC. Uniquement les outils d'administration et les programmes d'installation doivent utiliser ces API. Si vous utilisez le cas, cela directement expose votre application assembly liaison fragility ou peut-être entraîner votre application fonctionnement incorrectement sur les versions futures de .NET Framework.

Le cache d'assembly global stocke les assemblys qui sont partagés par toutes les applications sur un ordinateur. Le d'emplacement de stockage réel et de structure du cache d'assembly global n'est pas documentée et sont susceptibles d'être modifiées dans les versions futures de .NET Framework et le système d'exploitation Microsoft Windows.

La seule méthode prise en charge aux accès des assemblys dans le GAC consiste via les API qui sont documentées dans cet article.

La plupart des applications est inutile d'utiliser ces API, car l'assembly de liaison est effectuée automatiquement par le common language runtime. Uniquement des programmes d'installation personnalisée ou des outils de gestion doivent utiliser ces API. Microsoft Windows Installer prend en charge native Installation des assemblys dans le cas.

Pour plus d'informations sur les assemblys et le cas, consultez le Kit de développement logiciel (SDK) .NET Framework.

Utiliser l'API de cache d'assembly global dans les scénarios suivants :
  • Lorsque vous installez un assembly pour le cache d'assembly global.
  • Lorsque vous supprimez un assembly dans le cas.
  • Lorsque vous exporter un assembly dans le cas.
  • Lorsque vous énumérer les assemblys qui sont disponibles dans le GAC.
Remarque : CoInitialize(Ex) doit être appelée avant que vous utiliser toutes les fonctions et les interfaces qui sont décrites dans cette spécification.

Interface IAssemblyCache

L'interface IAssemblyCache est l'interface de niveau supérieur qui permet d'accéder au cache d'assembly global.

Pour obtenir une instance de CreateAssemblyCache API, appelez CreateAssemblyCache API, comme suit :
STDAPI CreateAssemblyCache(IAssemblyCache **ppAsmCache, DWORD dwReserved); 
les paramètres sont définis comme suit :
  • ppAsmCache - pointeur pour renvoyer IAssemblyCache
  • dwReserved

Structure FUSION_INSTALL_REFERENCE

La structure FUSION_INSTALL_REFERENCE représente une référence qui est effectuée lorsqu'une application a installé un assembly dans le GAC.
    typedef struct _FUSION_INSTALL_REFERENCE_
    {
        DWORD  cbSize;
        DWORD  dwFlags;
        GUID   guidScheme;     // Contains one of the pre-defined GUIDs.
        LPCWSTR szIdentifier;  // Unique identifier for the application that installs this  assembly.
        LPCWSTR szNonCannonicalData;  // Data is description; relevant to the GUID above. 
    } FUSION_INSTALL_REFERENCE, *LPFUSION_INSTALL_REFERENCE;
				
FUSION_INSTALL_REFERENCE}, * LPFUSION_INSTALL_REFERENCE ; les champs de la structure sont définis comme suit :
  • cbSize - la taille de la structure en octets.
  • dwFlags - réservé, doit être de zéro.
  • guidScheme - l'entité qui ajoute la référence.
  • szIdentifier - une chaîne unique qui identifie l'application installée l'assembly.
  • szNonCannonicalData - une chaîne qui est compris uniquement par l'entité qui ajoute la référence. Le cache d'assembly global stocke uniquement cette chaîne.
Valeurs possibles du champ guidScheme peuvent être une des options suivantes :
  • FUSION_REFCOUNT_MSI_GUID - l'assembly est référencée par une application qui a été installée à l'aide de Windows Installer. Le champ szIdentifier est défini pour MSI et szNonCannonicalData est défini sur Windows Installer . Ce schéma doit uniquement être utilisé par Windows Installer proprement dit.
  • FUSION_REFCOUNT_UNINSTALL_SUBKEY_GUID - l'assembly est référencée par une application qui s'affiche dans Ajout/Suppression de programmes . Le champ szIdentifier est le jeton qui sert à inscrire l'application dans Ajout/Suppression de programmes .
  • FUSION_REFCOUNT_FILEPATH_GUID - l'assembly est référencée par une application qui est représentée par un fichier dans le système de fichiers. Le champ szIdentifier est le chemin d'accès à ce fichier.
  • FUSION_REFCOUNT_OPAQUE_STRING_GUID - l'assembly est référencée par une application qui est uniquement représentée par une chaîne opaque. Le szIdentifier est cette chaîne opaque. Le cache d'assembly global n'effectue pas existence la vérification des références opaques lorsque vous supprimez ce.

Structure ASSEMBLY_INFO

La structure ASSEMBLY_INFO représente des informations sur un assembly dans le cache d'assembly.

Les champs de la structure sont définis comme suit :
  • cbAssemblyInfo - taille de la structure d'octets. Autorise les ajouts à la structure dans future version de .NET Framework.
  • dwAssemblyFlags - indique un ou plusieurs des bits ASSEMBLYINFO_FLAG_ * .
  • uliAssemblySizeInKB - la taille des fichiers qui constituent l'assembly en kilo-octets (Ko).
  • pszCurrentAssemblyPathBuf - un pointeur vers un tampon de chaîne contenant le chemin du répertoire en cours contient les fichiers qui constituent l'assembly. Le chemin d'accès doit se terminer par un zéro.
  • cchBuf - taille de champ pszCurrentAssemblyPathBug pointe vers le tampon.
dwAssemblyFlags peut avoir un des valeurs suivantes :
  • ASSEMBLYINFO_FLAG__INSTALLED - indique que l'assembly est effectivement installé. Définissez toujours dans la version actuelle du .NET Framework.
  • ASSEMBLYINFO_FLAG__PAYLOADRESIDENT - jamais défini dans la version actuelle du .NET Framework.

IAssemblyCache::UninstallAssembly, méthode

La méthode IAssemblyCache::UninstallAssembly supprime une référence à un assembly dans le cas. Si d'autres applications ne contenir aucune autre référence à l'assembly, les fichiers qui constituent l'assembly sont supprimés dans le cas.
    HRESULT UninstallAssembly(
        [in] DWORD dwFlags,
        [in] LPCWSTR pszAssemblyName, 
        [in] LPCFUSION_INSTALL_REFERENCE pRefData, 
        [out, optional] ULONG *pulDisposition
        );

				
Les paramètres sont définis comme suit :
  • dwFlags - non indicateurs définis. Doit être égale à zéro.
  • pszAssemblyName - le nom de l'assembly. Un Unicode nulle terminé chaîne.
  • pRefData - un pointeur vers une structure FUSION_INSTALL_REFERENCE . Bien que cela ne soit pas recommandé, ce paramètre peut être null. L'assembly est installé sans une référence de l'application, ou toutes les références d'application existantes ont disparu.
  • pulDisposition - pointeur à l'entier qui indique l'action effectuée par la fonction.
Remarque : si pulDisposition n'est pas null, pulDisposition contient l'une des valeurs suivantes :
  • IASSEMBLYCACHE_UNINSTALL_DISPOSITION_UNINSTALLED - assembly de fichiers ont été supprimés dans le cas.
  • IASSEMBLYCACHE_UNINSTALL_DISPOSITION_STILL_IN_USE - application utilise l'assembly. Cette valeur est renvoyée sous Microsoft Windows 95 et Microsoft Windows 98.
  • IASSEMBLYCACHE_UNINSTALL_DISPOSITION_ALREADY_UNINSTALLED - l'assembly n'existe pas dans le GAC.
  • IASSEMBLYCACHE_UNINSTALL_DISPOSITION_DELETE_PENDING - non utilisé.
  • IASSEMBLYCACHE_UNINSTALL_DISPOSITION_HAS_INSTALL_REFERENCES - l'assembly n'a pas été retiré du GAC car une autre application référence existe.
  • IASSEMBLYCACHE_UNINSTALL_DISPOSITION_REFERENCE_NOT_FOUND - la référence qui est spécifié dans pRefData est introuvable dans le GAC.
Les valeurs de retour sont définis comme suit :
  • S_OK - l'assembly a été désinstallé.
  • S_FALSE - l'opération a réussi, mais l'assembly n'a pas supprimé du cache d'assembly global. La raison est décrite dans pulDisposition .

IAssemblyCache::QueryAssemblyInfo, méthode

La méthode IAssemblyCache::QueryAssemblyInfo récupère les informations sur un assembly dans le cas.
    HRESULT QueryAssemblyInfo(
        [in] DWORD dwFlags,
        [in] LPCWSTR pszAssemblyName,
        [in, out] ASSEMBLY_INFO *pAsmInfo
        );
				
Les paramètres sont définis comme suit :
  • dwFlags - une des QUERYASMINFO_FLAG_VALIDATE ou QUERYASMINFO_FLAG_GETSIZE :
    • * _VALIDATE -effectue la validation des fichiers dans le GAC contre le manifeste d'assembly, y compris vérification du hachage et vérification de signature de nom fort.
    • * _GETSIZE -renvoie la taille de tous les fichiers dans l'assembly encombrement de disque. Si ce n'est pas spécifié, le champ ASSEMBLY_INFO::uliAssemblySizeInKB n'est pas modifié.
  • pszAssemblyName - nom de l'assembly qui est interrogée.
  • pAsmInfo - pointeur sur la structure ASSEMBLY_INFO renvoyée.

IAssemblyCache::InstallAssembly, méthode

La méthode IAssemblyCache::InstallAssembly ajoute un nouvel assembly pour le cache d'assembly global. L'assembly doit être conservé dans le système de fichiers et est copié dans le cas.
    HRESULT InstallAssembly( // If you use this, fusion will do the streaming & commit.
        [in] DWORD dwFlags,
        [in] LPCWSTR pszManifestFilePath, 
        [in] LPCFUSION_INSTALL_REFERENCE pRefData
        );
				
les paramètres sont définis comme suit :
  • dwFlags - au plus, parmi les bits des valeurs IASSEMBLYCACHE_INSTALL_FLAG_ * peut être spécifié :
    • * _REFRESH - si l'assembly est déjà installé dans le GAC et les numéros de version fichier de l'assembly en cours d'installation sont identiques ou version ultérieure, les fichiers sont remplacés.
    • * _FORCE_REFRESH -les fichiers d'un assembly existant sont remplacés, quel que soit leur numéro de version.
  • pszManifestFilePath - chaîne pointant vers la bibliothèque dynamic-linked (DLL) qui contient le manifeste de l'assembly. Autres fichiers assembly doivent résider dans le même répertoire que la DLL qui contient le manifeste de l'assembly.
  • pRefData - un pointeur vers un FUSION_INSTALL_REFERENCE qui indique l'application sur dont part l'assembly est installé. Bien que cela ne soit pas recommandé, ce paramètre peut être null, mais cela laisse l'assembly sans toute référence d'application.

Interface IAssemblyName

L'interface IAssemblyName représente un nom d'assembly. Un nom de l'assembly inclut un ensemble prédéfini de paires nom-valeur. Le nom de l'assembly est décrit dans en détail dans le Kit de développement logiciel (SDK) .NET Framework.
[
        local,
        object,
        uuid(CD193BC0-B4BC-11d2-9833-00C04FC31D2E),
        pointer_default(unique)
]
interface IAssemblyName: IUnknown
				
Une occurrence de IAssemblyName est obtenue en appelant l' API CreateAssemblyNameObject :
STDAPI CreateAssemblyNameObject(LPASSEMBLYNAME *ppAssemblyNameObj, LPCWSTR szAssemblyName, DWORD dwFlags, LPVOID pvReserved);
les paramètres sont définis comme suit :
  • ppAssemblyNameObj - pointeur sur un emplacement mémoire qui reçoit le pointeur IAssemblyName qui est créé.
  • szAssemblyName - représentation de chaîne de nom d'assembly ou une référence d'assembly complet est déterminée par dwFlags . La représentation de chaîne peut être nulle.
  • dwFlags - zéro ou plus des bits qui sont définies dans l'énumération CREATE_ASM_NAME_OBJ_FLAGS .
  • pvReserved - doit être null.

CREATE_ASM_NAME_OBJ_FLAGS, énumération

L'énumération CREATE_ASM_NAME_OBJ_FLAGS contient les valeurs suivantes :
  • CANOF_PARSE_DISPLAY_NAME - si cet indicateur est spécifié, le paramètre de szAssemblyName est un nom d'assembly complet et est analysé pour les propriétés individuelles. Si l'indicateur n'est pas spécifié, szAssemblyName est la partie « nom » du nom d'assembly.
  • CANOF_SET_DEFAULT_VALUES - si cet indicateur est propriétés spécifiées, certains, comme architecture de processeur, sont définies sur leurs valeurs par défaut.
    typedef enum {
         CANOF_PARSE_DISPLAY_NAME = 0x1,
         CANOF_SET_DEFAULT_VALUES = 0x2
    } CREATE_ASM_NAME_OBJ_FLAGS;
				

ASM_NAME, énumération

L'ID de propriété d'énumération ASM_NAME décrit les noms valides des paires nom-valeur dans un nom d'assembly. Consultez le kit SDK Framework .NET pour une description de ces propriétés.
    typedef enum
    {
        ASM_NAME_PUBLIC_KEY = 0,
        ASM_NAME_PUBLIC_KEY_TOKEN,
        ASM_NAME_HASH_VALUE,
        ASM_NAME_NAME,
        ASM_NAME_MAJOR_VERSION,
        ASM_NAME_MINOR_VERSION,
        ASM_NAME_BUILD_NUMBER,
        ASM_NAME_REVISION_NUMBER,
        ASM_NAME_CULTURE,
        ASM_NAME_PROCESSOR_ID_ARRAY,
        ASM_NAME_OSINFO_ARRAY,
        ASM_NAME_HASH_ALGID,
        ASM_NAME_ALIAS,
        ASM_NAME_CODEBASE_URL,
        ASM_NAME_CODEBASE_LASTMOD,
        ASM_NAME_NULL_PUBLIC_KEY,
        ASM_NAME_NULL_PUBLIC_KEY_TOKEN,
        ASM_NAME_CUSTOM,
        ASM_NAME_NULL_CUSTOM,                
        ASM_NAME_MVID,
        ASM_NAME_MAX_PARAMS
    } ASM_NAME;
				

IAssemblyName::SetProperty, méthode

La méthode IAssemblyName::SetProperty ajoute une paire nom-valeur de l'assembly, ou, si une paire nom-valeur portant le même nom existe déjà, modifie ou supprime la valeur d'une paire nom-valeur.
    HRESULT SetProperty(
        [in]    DWORD  PropertyId, 
        [in]    LPVOID pvProperty,
        [in]    DWORD  cbProperty);
				
Les paramètres sont définis comme suit :
  • PropertyId - ID qui représente la partie nom de la paire nom-valeur qui est à ajouter ou à modifier. ID de propriété valide est définies dans l'énumération ASM_NAME .
  • pvProperty - un pointeur vers un tampon qui contient la valeur de la propriété.
  • cbProperty - la longueur du tampon pvProperty en octets. Si cbProperty est égale à zéro, la paire nom-valeur est supprimée à partir du nom d'assembly.

IAssemblyName::GetProperty, méthode

La méthode IAssemblyName::GetProperty extrait la valeur d'une paire nom-valeur dans le nom d'assembly qui spécifie le nom.
    HRESULT GetProperty(
        [in]         DWORD    PropertyId, 
        [out]        LPVOID   pvProperty,
        [in, out]    LPDWORD  pcbProperty);
				
Les paramètres sont définis comme suit :
  • PropertyId - ID qui représente le nom de la paire nom-valeur dont la valeur doit être récupéré. ID de propriété spécifié est définies dans l'énumération ASM_NAME .
  • pvProperty - un pointeur vers un tampon qui doit contenir la valeur de la propriété.
  • cbProperty - la longueur du tampon pvProperty , en octets.

IAssemblyName::Finalize, méthode

La méthode IAssemblyName::Finalize fige un nom d'assembly. Appels supplémentaires de IAssemblyName::SetProperty sont échoue après que cette méthode a été appelée.
HRESULT Finalize();

IAssemblyName::GetDisplayName, méthode

La méthode IAssemblyName::GetDisplayName renvoie une représentation de chaîne de nom d'assembly.
    HRESULT  GetDisplayName(
        [out]       LPOLESTR  szDisplayName,
        [in, out]   LPDWORD   pccDisplayName,
        [in]        DWORD     dwDisplayFlags);
				
Les paramètres sont définis comme suit :
  • szDisplayName - un pointeur vers un tampon qui doit contenir le nom complet. Le nom complet est renvoyé au format Unicode.
  • pccDisplayName - la taille du tampon en caractères (sur ENTRÉE). Longueur du nom complet renvoyé (sur retour).
  • dwDisplayFlags - un ou plusieurs des bits définies dans l'énumération ASM_DISPLAY_FLAGS :
    • * _VERSION -comprenne le numéro de version du nom complet.
    • * _CULTURE -inclut la culture.
    • * _PUBLIC_KEY_TOKEN -inclut le jeton de clé publique.
    • * _PUBLIC_KEY -inclut la clé publique.
    • * _CUSTOM -inclut la partie personnalisée du nom d'assembly.
    • * _PROCESSORARCHITECTURE -comprend l'architecture de processeur.
    • * _LANGUAGEID -comprend l'ID de langue.
    typedef enum
    {
        ASM_DISPLAYF_VERSION    = 0x1,
        ASM_DISPLAYF_CULTURE    = 0x2,
        ASM_DISPLAYF_PUBLIC_KEY_TOKEN = 0x4,
        ASM_DISPLAYF_PUBLIC_KEY = 0x8,
        ASM_DISPLAYF_CUSTOM     = 0x10,
        ASM_DISPLAYF_PROCESSORARCHITECTURE = 0x20,
        ASM_DISPLAYF_LANGUAGEID     = 0x40

    } ASM_DISPLAY_FLAGS;
				

IAssemblyName::GetName, méthode

La méthode IAssemblyName::GetName renvoie la partie nom du nom de l'assembly.
    HRESULT GetName(
        [in, out] LPDWORD lpcwBuffer,
        [out] WCHAR *pwzName);
				
Les paramètres sont définis comme suit :
  • lpcwBuffer - taille de la mémoire tampon pwszName (sur ENTRÉE). Longueur du nom (sur retour).
  • pwszName - pointeur dans le tampon qui doit contenir la partie nom du nom assembly.

IAssemblyName::GetVersion, méthode

La méthode IAssemblyName::GetVersion renvoie la partie de version du nom de l'assembly.
HRESULT GetVersion(
        [out] LPDWORD pdwVersionHi,
        [out] LPDWORD pdwVersionLow);
				
Les paramètres sont définis comme suit :
  • pdwVersionHi - pointeur sur une valeur DWORD qui contient les 32 bits du numéro de version supérieurs.
  • pdwVersionLow - pointeur sur une valeur DWORD qui contiennent les 32 bits du numéro de version inférieurs.

IAssemblyName::IsEqual, méthode

La méthode IAssemblyName::IsEqual compare le nom d'assembly à noms d'un autre assembly.
    HRESULT IsEqual(
        [in] IAssemblyName *pName,
        [in] DWORD dwCmpFlags);
				
Les paramètres sont définis comme suit :
  • pName - le nom d'assembly à comparer à.
  • dwCmpFlags - indique quelle partie du nom assembly à utiliser dans la comparaison.
Les valeurs sont une ou plusieurs des bits définies dans l'énumération ASM_CMP_FLAGS :
    typedef enum
    {
        ASM_CMPF_NAME            = 0x1,
        ASM_CMPF_MAJOR_VERSION   = 0x2,
        ASM_CMPF_MINOR_VERSION   = 0x4,
        ASM_CMPF_BUILD_NUMBER    = 0x8,
        ASM_CMPF_REVISION_NUMBER = 0x10,
        ASM_CMPF_PUBLIC_KEY_TOKEN = 0x20,
        ASM_CMPF_CULTURE         = 0x40,
        ASM_CMPF_CUSTOM          = 0x80,
        ASM_CMPF_ALL = ASM_CMPF_NAME | ASM_CMPF_MAJOR_VERSION | ASM_CMPF_MINOR_VERSION |
                       ASM_CMPF_REVISION_NUMBER | ASM_CMPF_BUILD_NUMBER |
                       ASM_CMPF_PUBLIC_KEY_TOKEN | ASM_CMPF_CULTURE | ASM_CMPF_CUSTOM,
        // For strongly named assemblies, ASM_CMPF_DEFAULT==ASM_CMPF_ALL.
        // For simply named assemblies, this is also true. However, when
        // performing IAssemblyName::IsEqual, the build number/revision 
        // number will be removed from the comparison.
        ASM_CMPF_DEFAULT = 0x100
    } ASM_CMP_FLAGS;                       
				
ASM_CMPF_DEFAULT = 0 x 100} ASM_CMP_FLAGS ; les valeurs de retour sont les suivantes :
  • S_OK : -les noms correspondent selon les critères de comparaison.
  • S_FALSE : -les noms ne correspondent pas.

IAssemblyName::Clone, méthode

La méthode IAssemblyName::Clone crée une copie d'un nom d'assembly.
    HRESULT Clone(
        [out] IAssemblyName **pName);
				

Interface IAssemblyEnum

L'interface IAssemblyEnum énumère les assemblys dans le GAC.
 [
        local,
        object,
        uuid(21b8916c-f28e-11d2-a473-00c04f8ef448),
        pointer_default(unique)
]
interface IAssemblyEnum : IUnknown
				
Pour obtenir une instance de CreateAssemblyEnum API, appelez CreateAssemblyNameObject API, comme suit :
STDAPI CreateAssemblyEnum(IAssemblyEnum **pEnum, IUnknown *pUnkReserved, IAssemblyName *pName, DWORD dwFlags, LPVOID pvReserved);
les paramètres sont définis comme suit :
  • pEnum - pointeur sur un emplacement mémoire qui contient le pointeur IAssemblyEnum .
  • pUnkReserved - doit être null.
  • pName - nom d'assembly utilisé pour filtrer l'énumération. Peut être null pour énumérer tous les assemblys dans le GAC.
  • dwFlags - exactement un bit à partir de l'énumération ASM_CACHE_FLAGS .
  • pvReserved - doit être nulle.

ASM_CACHE_FLAGS, énumération

L'énumération ASM_CACHE_FLAGS contient les valeurs suivantes :
  • ASM_CACHE_ZAP - énumère le cache des assemblys précompilés à l'aide de ngen.exe.
  • ASM_CACHE_GAC - énumère le cache d'assembly global.
  • ASM_CACHE_DOWNLOAD - énumère les assemblys qui ont été téléchargée à la demande ou qui ont été-cliché.
IAssemblyName::GetDisplayName
typedef enum
{
    ASM_CACHE_ZAP            = 0x1,
    ASM_CACHE_GAC            = 0x2,
    ASM_CACHE_DOWNLOAD       = 0x4
} ASM_CACHE_FLAGS;
				

IAssemblyEnum::GetNextAssembly, méthode

La méthode IAssemblyEnum::GetNextAssembly énumère les assemblys dans le GAC.
    HRESULT GetNextAssembly
    (
        [in]                  LPVOID                pvReserved,
        [out]                 IAssemblyName       **ppName,
        [in]                  DWORD                 dwFlags
    );
				
Les paramètres sont définis comme suit :
  • pvReserved - doit être null.
  • ppName - pointeur dans un emplacement mémoire qui doit recevoir le pointeur d'interface sur le nom d'assembly de l'assembly suivant qui est énuméré.
  • dwFlags - doit être de zéro.

Interface IInstallReferenceItem

L'interface IInstallReferenceItem représente une référence qui a été définie sur un assembly dans le GAC. Instances de IInstallReferenceIteam sont renvoyés par l'interface IInstallReferenceEnum .
[
        local,
        object,
        uuid(582dac66-e678-449f-aba6-6faaec8a9394),
        pointer_default(unique)
]
interface IInstallReferenceItem : IUnknown
				

IInstallReferenceItem::GetReference, méthode

La méthode IInstallReferenceItem::GetReference renvoie une structure FUSION_INSTALL_REFERENCE .
    HRESULT GetReference
    (
    [out] LPFUSION_INSTALL_REFERENCE *ppRefData,
    [in]  DWORD dwFlags,
    [in]  LPVOID pvReserved
    );
				
Les paramètres sont définis comme suit :
  • ppRefData - un pointeur vers une structure FUSION_INSTALL_REFERENCE . La mémoire est affectée par la méthode GetReference et est libérée lorsque IInstallReferenceItem est lancé. Appelants ne doivent pas conservent une référence à cette mémoire tampon après publication de l'objet IInstallReferenceItem .
  • dwFlags - doit être de zéro.
  • pvReserved - doit être null.

Interface IInstallReferenceEnum

L'interface IInstallReferenceEnum énumère toutes les références qui sont définies sur un assembly dans le GAC.

Remarque : les références qui appartiennent à l'assembly sont verrouillés pour modifications lors de ces références sont en cours énumérés.
[
        local,
        object,
        uuid(56b1a988-7c0c-4aa2-8639-c3eb5a90226f),
        pointer_default(unique)
]
interface IInstallReferenceEnum : IUnknown
				
Pour obtenir une instance de CreateInstallReferenceEnum API, appelez CreateInstallReferenceEnum API, comme suit :
STDAPI CreateInstallReferenceEnum(IInstallReferenceEnum **ppRefEnum, IAssemblyName *pName, DWORD dwFlags, LPVOID pvReserved);
les paramètres sont définis comme suit :
  • ppRefEnum - un pointeur vers un emplacement mémoire qui reçoit le pointeur IInstallReferenceEnum .
  • pName - le nom d'assembly pour lequel les références sont énumérés.
  • dwFlags - doit être de zéro.
  • pvReserved - doit être null.

IInstallReferenceEnum::GetNextInstallReferenceItem, méthode

IInstallReferenceEnum::GetNextInstallReferenceItem renvoie les informations référence suivante d'un assemblage.
    HRESULT GetNextInstallReferenceItem
            (
            [out] IInstallReferenceItem **ppRefItem,
            [in]  DWORD dwFlags,
            [in]  LPVOID pvReserved
            );
				
Les paramètres sont définis comme suit :
  • ppRefItem - pointeur sur un emplacement mémoire qui reçoit le pointeur IInstallReferenceItem .
  • dwFlags - doit être de zéro.
  • pvReserved - doit être null.
Valeurs de retour sont les suivantes :
  • S_OK : -l'élément suivant est renvoyée avec succès.
  • S_FALSE : -non davantage d'articles.

GetCachePath API

GetCachePath API renvoie l'emplacement de stockage du cache d'assembly global.
STDAPI GetCachePath(ASM_CACHE_FLAGS dwCacheFlags, LPWSTR pwzCachePath, PDWORD pcchPath);
Les paramètres sont définis comme suit :
  • dwCacheFlags - exactement une des bits définies dans l'énumération ASM_CACHE_FLAGS .
  • pwzCachePath - pointeur vers un tampon qui doit recevoir le chemin d'accès du cas sous la forme d'une chaîne Unicode.
  • pcchPath - longueur du tampon pwszCachePath , en caractères Unicode.
// ==++==
// 
//   Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// ==--==
//+---------------------------------------------------------------------------
// 
//  Microsoft Windows
//  File:       fusion.idl
// 
//  Contents:   Fusion Interfaces
// 
//  Classes:
// 
//  Functions:
// 
// 
//----------------------------------------------------------------------------
cpp_quote("//=--------------------------------------------------------------------------=")
cpp_quote("// fusion.h")
cpp_quote("//=--------------------------------------------------------------------------=")
cpp_quote("// Copyright (c) Microsoft Corporation.  All rights reserved.")
cpp_quote("//")
cpp_quote("// THIS CODE AND INFORMATION IS PROVIDED \"AS IS\" WITHOUT WARRANTY OF")
cpp_quote("// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO")
cpp_quote("// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A")
cpp_quote("// PARTICULAR PURPOSE.")
cpp_quote("//=--------------------------------------------------------------------------=")
cpp_quote("")
cpp_quote("#ifdef _MSC_VER")
cpp_quote("#pragma comment(lib,\"uuid.lib\")")
cpp_quote("#endif")
cpp_quote("")
cpp_quote("//---------------------------------------------------------------------------=")
cpp_quote("// Fusion Interfaces.")
cpp_quote("")

import "objidl.idl";

cpp_quote("#ifdef _MSC_VER")
cpp_quote("#pragma once")
cpp_quote("#endif")

interface IAssemblyCache;
interface IAssemblyCacheItem;
interface IAssemblyName;
interface IAssemblyEnum;


typedef enum
{
    ASM_CACHE_ZAP            = 0x1,
    ASM_CACHE_GAC            = 0x2,
    ASM_CACHE_DOWNLOAD       = 0x4
} ASM_CACHE_FLAGS;

/////////////////////////////////////////////////////////////////////////////// 
// 
// IAssemblyCache
// 
/////////////////////////////////////////////////////////////////////////////// 

[
        local,
        object,
        uuid(e707dcde-d1cd-11d2-bab9-00c04f8eceae),
        pointer_default(unique)
]
interface IAssemblyCache : IUnknown
{
    cpp_quote("// {8cedc215-ac4b-488b-93c0-a50a49cb2fb8}")
    cpp_quote("DEFINE_GUID(FUSION_REFCOUNT_UNINSTALL_SUBKEY_GUID, 0x8cedc215, 0xac4b, 0x488b, 0x93, 0xc0, _
0xa5, 0x0a, 0x49, 0xcb, 0x2f, 0xb8);")
    cpp_quote("")
    cpp_quote("// {b02f9d65-fb77-4f7a-afa5-b391309f11c9}")
    cpp_quote("DEFINE_GUID(FUSION_REFCOUNT_FILEPATH_GUID, 0xb02f9d65, 0xfb77, 0x4f7a, 0xaf, 0xa5, 0xb3, 0x91, _
0x30, 0x9f, 0x11, 0xc9);")
    cpp_quote("")
    cpp_quote("// {2ec93463-b0c3-45e1-8364-327e96aea856}")
    cpp_quote("DEFINE_GUID(FUSION_REFCOUNT_OPAQUE_STRING_GUID, 0x2ec93463, 0xb0c3, 0x45e1, 0x83, 0x64, 0x32, _
0x7e, 0x96, 0xae, 0xa8, 0x56);")

    cpp_quote(" // {25df0fc1-7f97-4070-add7-4b13bbfd7cb8} // this GUID cannot be used for installing into GAC.")
    cpp_quote("DEFINE_GUID(FUSION_REFCOUNT_MSI_GUID,  0x25df0fc1, 0x7f97, 0x4070, 0xad, 0xd7, 0x4b, 0x13, 0xbb, 0xfd, _
0x7c, 0xb8); ")


    typedef struct _FUSION_INSTALL_REFERENCE_
    {
        DWORD  cbSize;
        DWORD  dwFlags;
        GUID   guidScheme; // contains one of the pre-defined guids.
        LPCWSTR szIdentifier;  // unique identifier for app installing this  assembly.
        LPCWSTR szNonCannonicalData;  // data is description; relevent to the guid above 
    } FUSION_INSTALL_REFERENCE, *LPFUSION_INSTALL_REFERENCE;

    typedef const FUSION_INSTALL_REFERENCE  *LPCFUSION_INSTALL_REFERENCE;


    typedef struct _ASSEMBLY_INFO
    {
        ULONG cbAssemblyInfo; // size of this structure for future expansion
        DWORD dwAssemblyFlags;
        ULARGE_INTEGER uliAssemblySizeInKB;
        LPWSTR pszCurrentAssemblyPathBuf;
        ULONG   cchBuf; // size of path buf.
    } ASSEMBLY_INFO;

    cpp_quote("#define IASSEMBLYCACHE_INSTALL_FLAG_REFRESH       (0x00000001)")
    cpp_quote("#define IASSEMBLYCACHE_INSTALL_FLAG_FORCE_REFRESH (0x00000002)")

    cpp_quote("#define IASSEMBLYCACHE_UNINSTALL_DISPOSITION_UNINSTALLED (1)")
    cpp_quote("#define IASSEMBLYCACHE_UNINSTALL_DISPOSITION_STILL_IN_USE (2)")
    cpp_quote("#define IASSEMBLYCACHE_UNINSTALL_DISPOSITION_ALREADY_UNINSTALLED (3)")
    cpp_quote("#define IASSEMBLYCACHE_UNINSTALL_DISPOSITION_DELETE_PENDING (4)")
    cpp_quote("#define IASSEMBLYCACHE_UNINSTALL_DISPOSITION_HAS_INSTALL_REFERENCES (5)")
    cpp_quote("#define IASSEMBLYCACHE_UNINSTALL_DISPOSITION_REFERENCE_NOT_FOUND (6)")

    cpp_quote("#define QUERYASMINFO_FLAG_VALIDATE        (0x00000001)")
    cpp_quote("#define QUERYASMINFO_FLAG_GETSIZE         (0x00000002)")

    // these flags are for dwAssemblyFlags field in struct _ASSEMBLY_INFO  
    cpp_quote("#define ASSEMBLYINFO_FLAG_INSTALLED       (0x00000001)")
    cpp_quote("#define ASSEMBLYINFO_FLAG_PAYLOADRESIDENT (0x00000002)")

    HRESULT UninstallAssembly(
        [in] DWORD dwFlags,
        [in] LPCWSTR pszAssemblyName, 
        [in] LPCFUSION_INSTALL_REFERENCE pRefData, 
        [out, optional] ULONG *pulDisposition
        );
 
    HRESULT QueryAssemblyInfo(
        [in] DWORD dwFlags,
        [in] LPCWSTR pszAssemblyName,
        [in, out] ASSEMBLY_INFO *pAsmInfo
        );
 
    HRESULT CreateAssemblyCacheItem( 
        [in] DWORD dwFlags,
        [in] PVOID pvReserved,
        [out] IAssemblyCacheItem **ppAsmItem,
        [in, optional] LPCWSTR pszAssemblyName  // uncanonicalized, comma separated name=value pairs.
        );
        
    HRESULT CreateAssemblyScavenger
    (
        [out]   IUnknown **ppUnkReserved
    );

    HRESULT InstallAssembly( // if you use this, fusion will do the streaming & commit.
        [in] DWORD dwFlags,
        [in] LPCWSTR pszManifestFilePath, 
        [in] LPCFUSION_INSTALL_REFERENCE pRefData
        );

}


/////////////////////////////////////////////////////////////////////////////// 
// 
// IAssemblyCacheItem
// 
/////////////////////////////////////////////////////////////////////////////// 

[
        local,
        object,
        uuid(9e3aaeb4-d1cd-11d2-bab9-00c04f8eceae),
        pointer_default(unique)
]
interface IAssemblyCacheItem : IUnknown
{
    cpp_quote("#define STREAM_FORMAT_COMPLIB_MODULE    0")
    cpp_quote("#define STREAM_FORMAT_COMPLIB_MANIFEST  1")
    cpp_quote("#define STREAM_FORMAT_WIN32_MODULE      2")
    cpp_quote("#define STREAM_FORMAT_WIN32_MANIFEST    4")
    
    cpp_quote("#define IASSEMBLYCACHEITEM_COMMIT_FLAG_REFRESH       (0x00000001)")
    cpp_quote("#define IASSEMBLYCACHEITEM_COMMIT_FLAG_FORCE_REFRESH (0x00000002)")
    
    cpp_quote("#define IASSEMBLYCACHEITEM_COMMIT_DISPOSITION_INSTALLED (1)") // first time install
    cpp_quote("#define IASSEMBLYCACHEITEM_COMMIT_DISPOSITION_REFRESHED (2)") // overwrite, if existing
    cpp_quote("#define IASSEMBLYCACHEITEM_COMMIT_DISPOSITION_ALREADY_INSTALLED (3)") // existing, 
    

    HRESULT CreateStream(
        [in] DWORD dwFlags,                         // For general API flags
        [in] LPCWSTR pszStreamName,                 // Name of the stream to be passed in
        [in] DWORD dwFormat,                        // format of the file to be streamed in.
        [in] DWORD dwFormatFlags,                   // format-specific flags
        [out] IStream **ppIStream,
        [in, optional] ULARGE_INTEGER *puliMaxSize  // Max size of the Stream.
        );
 
    HRESULT Commit
    (
        [in] DWORD dwFlags, // For general API flags like IASSEMBLYCACHEITEM _COMMIT_FLAG_REFRESH 
        [out, optional] ULONG *pulDisposition
    ); 
 
    HRESULT AbortItem(); // If you have created IAssemblyCacheItem and don't plan to use it, its good idea to call 
    AbortItem before releasing it.

}



/////////////////////////////////////////////////////////////////////////////// 
// 
// IAssemblyName
// 
/////////////////////////////////////////////////////////////////////////////// 

[
        local,
        object,
        uuid(CD193BC0-B4BC-11d2-9833-00C04FC31D2E),
        pointer_default(unique)
]
interface IAssemblyName: IUnknown
{
    typedef [unique] IAssemblyName *LPASSEMBLYNAME;
    
    typedef enum {
         CANOF_PARSE_DISPLAY_NAME = 0x1,
         CANOF_SET_DEFAULT_VALUES = 0x2
    } CREATE_ASM_NAME_OBJ_FLAGS;
    
    typedef enum
    {
        ASM_NAME_PUBLIC_KEY = 0,
        ASM_NAME_PUBLIC_KEY_TOKEN,
        ASM_NAME_HASH_VALUE,
        ASM_NAME_NAME,
        ASM_NAME_MAJOR_VERSION,
        ASM_NAME_MINOR_VERSION,
        ASM_NAME_BUILD_NUMBER,
        ASM_NAME_REVISION_NUMBER,
        ASM_NAME_CULTURE,
        ASM_NAME_PROCESSOR_ID_ARRAY,
        ASM_NAME_OSINFO_ARRAY,
        ASM_NAME_HASH_ALGID,
        ASM_NAME_ALIAS,
        ASM_NAME_CODEBASE_URL,
        ASM_NAME_CODEBASE_LASTMOD,
        ASM_NAME_NULL_PUBLIC_KEY,
        ASM_NAME_NULL_PUBLIC_KEY_TOKEN,
        ASM_NAME_CUSTOM,
        ASM_NAME_NULL_CUSTOM,                
        ASM_NAME_MVID,
        ASM_NAME_MAX_PARAMS
    } ASM_NAME;
    
    typedef enum
    {
        ASM_DISPLAYF_VERSION    = 0x1,
        ASM_DISPLAYF_CULTURE    = 0x2,
        ASM_DISPLAYF_PUBLIC_KEY_TOKEN = 0x4,
        ASM_DISPLAYF_PUBLIC_KEY = 0x8,
        ASM_DISPLAYF_CUSTOM     = 0x10,
        ASM_DISPLAYF_PROCESSORARCHITECTURE = 0x20,
        ASM_DISPLAYF_LANGUAGEID     = 0x40

    } ASM_DISPLAY_FLAGS;
    
    typedef enum
    {
        ASM_CMPF_NAME            = 0x1,
        ASM_CMPF_MAJOR_VERSION   = 0x2,
        ASM_CMPF_MINOR_VERSION   = 0x4,
        ASM_CMPF_BUILD_NUMBER    = 0x8,
        ASM_CMPF_REVISION_NUMBER = 0x10,
        ASM_CMPF_PUBLIC_KEY_TOKEN = 0x20,
        ASM_CMPF_CULTURE         = 0x40,
        ASM_CMPF_CUSTOM          = 0x80,
        ASM_CMPF_ALL = ASM_CMPF_NAME | ASM_CMPF_MAJOR_VERSION | ASM_CMPF_MINOR_VERSION |
                       ASM_CMPF_REVISION_NUMBER | ASM_CMPF_BUILD_NUMBER |
                       ASM_CMPF_PUBLIC_KEY_TOKEN | ASM_CMPF_CULTURE | ASM_CMPF_CUSTOM,
        // For strongly named assemblies, ASM_CMPF_DEFAULT==ASM_CMPF_ALL.
        // For simply named assemblies, this is also true, however, when
        // performing IAssemblyName::IsEqual, the build number/revision 
        // number will be removed from the comparision.
        ASM_CMPF_DEFAULT = 0x100
    } ASM_CMP_FLAGS;                       

    HRESULT SetProperty(
        [in]    DWORD  PropertyId, 
        [in]    LPVOID pvProperty,
        [in]    DWORD  cbProperty);

    HRESULT GetProperty(
        [in]         DWORD    PropertyId, 
        [out]        LPVOID   pvProperty,
        [in, out]    LPDWORD  pcbProperty);

    HRESULT Finalize();

    HRESULT  GetDisplayName(
        [out]       LPOLESTR  szDisplayName,
        [in, out]   LPDWORD   pccDisplayName,
        [in]        DWORD     dwDisplayFlags);

    HRESULT BindToObject(
        [in]      REFIID               refIID,
        [in]      IUnknown            *pUnkSink, 
        [in]      IUnknown            *pUnkContext,
        [in]      LPCOLESTR            szCodeBase,
        [in]      LONGLONG             llFlags,
        [in]      LPVOID               pvReserved,
        [in]      DWORD                cbReserved,
        [out]     LPVOID               *ppv);


    HRESULT GetName(
        [in, out] LPDWORD lpcwBuffer,
        [out] WCHAR *pwzName);
        
    HRESULT GetVersion(
        [out] LPDWORD pdwVersionHi,
        [out] LPDWORD pdwVersionLow);

    HRESULT IsEqual(
        [in] IAssemblyName *pName,
        [in] DWORD dwCmpFlags);
        
    HRESULT Clone(
        [out] IAssemblyName **pName);
        

}

/////////////////////////////////////////////////////////////////////////////// 
// 
// IAssemblyEnum
// 
/////////////////////////////////////////////////////////////////////////////// 
[
        local,
        object,
        uuid(21b8916c-f28e-11d2-a473-00c04f8ef448),
        pointer_default(unique)
]
interface IAssemblyEnum : IUnknown
{

    HRESULT GetNextAssembly
    (
        [in]                  LPVOID                pvReserved,
        [out]                 IAssemblyName       **ppName,
        [in]                  DWORD                 dwFlags
    );

    HRESULT Reset(void);

    HRESULT Clone 
    (
        [out] IAssemblyEnum **ppEnum
    );
    
}


/////////////////////////////////////////////////////////////////////////////// 
// 
// IInstallReferenceItem
// 
/////////////////////////////////////////////////////////////////////////////// 

[
        local,
        object,
        uuid(582dac66-e678-449f-aba6-6faaec8a9394),
        pointer_default(unique)
]
interface IInstallReferenceItem : IUnknown
{
    HRESULT GetReference
    (
    [out] LPFUSION_INSTALL_REFERENCE *ppRefData,
    [in]  DWORD dwFlags,
    [in]  LPVOID pvReserved
    );
}

/////////////////////////////////////////////////////////////////////////////// 
// 
// IInstallReferenceEnum
// 
/////////////////////////////////////////////////////////////////////////////// 

[
        local,
        object,
        uuid(56b1a988-7c0c-4aa2-8639-c3eb5a90226f),
        pointer_default(unique)
]
interface IInstallReferenceEnum : IUnknown
{
    HRESULT GetNextInstallReferenceItem
            (
            [out] IInstallReferenceItem **ppRefItem,
            [in]  DWORD dwFlags,
            [in]  LPVOID pvReserved
            );
}

#pragma midl_echo("STDAPI CreateInstallReferenceEnum(IInstallReferenceEnum **ppRefEnum, IAssemblyName *pName, DWORD dwFlags, _
LPVOID pvReserved);      ")
#pragma midl_echo("STDAPI CreateAssemblyEnum(IAssemblyEnum **pEnum, IUnknown *pUnkReserved, IAssemblyName *pName, DWORD dwFlags, _
LPVOID pvReserved);      ") 
#pragma midl_echo("STDAPI CreateAssemblyNameObject(LPASSEMBLYNAME *ppAssemblyNameObj, LPCWSTR szAssemblyName, DWORD dwFlags, _
LPVOID pvReserved);             ")
#pragma midl_echo("STDAPI CreateAssemblyCache(IAssemblyCache **ppAsmCache, DWORD dwReserved); ")
#pragma midl_echo("STDAPI GetCachePath(ASM_CACHE_FLAGS dwCacheFlags, LPWSTR pwzCachePath, PDWORD pcchPath); ")
				

Propriétés

Numéro d'article: 317540 - Dernière mise à jour: vendredi 4 avril 2003 - Version: 3.0
Les informations contenues dans cet article s'appliquent au(x) produit(s) suivant(s):
  • Microsoft .NET Framework Software Development Kit 1.0 Service Pack 2
  • Microsoft .NET Framework Software Development Kit 1.0 Service Pack 2
Mots-clés : 
kbmt kbbug kbdocerr kbpending KB317540 KbMtfr
Traduction automatique
IMPORTANT : Cet article est issu du système de traduction automatique mis au point par Microsoft (http://support.microsoft.com/gp/mtdetails). Un certain nombre d?articles obtenus par traduction automatique sont en effet mis à votre disposition en complément des articles traduits en langue française par des traducteurs professionnels. Cela vous permet d?avoir accès, dans votre propre langue, à l?ensemble des articles de la base de connaissances rédigés originellement en langue anglaise. Les articles traduits automatiquement ne sont pas toujours parfaits et peuvent comporter des erreurs de vocabulaire, de syntaxe ou de grammaire (probablement semblables aux erreurs que ferait une personne étrangère s?exprimant dans votre langue !). Néanmoins, mis à part ces imperfections, ces articles devraient suffire à vous orienter et à vous aider à résoudre votre problème. Microsoft s?efforce aussi continuellement de faire évoluer son système de traduction automatique.
La version anglaise de cet article est la suivante: 317540
L'INFORMATION CONTENUE DANS CE DOCUMENT EST FOURNIE PAR MICROSOFT SANS GARANTIE D'AUCUNE SORTE, EXPLICITE OU IMPLICITE. L'UTILISATEUR ASSUME LE RISQUE DE L'UTILISATION DU CONTENU DE CE DOCUMENT. CE DOCUMENT NE PEUT ETRE REVENDU OU CEDE EN ECHANGE D'UN QUELCONQUE PROFIT.
Exclusion de responsabilité concernant les contenus obsolètes dans la Base de connaissances
Cet article concerne des produits pour lesquels Microsoft n'offre plus de support. Il est par conséquent fourni « en l'état » et ne sera plus mis à jour.

Envoyer des commentaires

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com