DOC: Global Assembly Cache (GAC) API se no documentados en la documentación del Kit (SDK) de .NET Framework Software Development

Seleccione idioma Seleccione idioma
Id. de artículo: 317540 - Ver los productos a los que se aplica este artículo
Expandir todo | Contraer todo

En esta página

Resumen

Las interfaces de programación de aplicaciones (API) código nativo que permiten interactuar con la caché de ensamblados global (GAC) no están documentadas en la documentación del Kit de desarrollo de software (SDK) de .NET Framework.

Más información

Advertencia : no utilizar estas API en la aplicación para realizar enlaces de ensamblado o para comprobar la presencia de los ensamblados con otras tiempo de ejecución, desarrollo o las operaciones de tiempo de diseño. Sólo herramientas administrativas y programas de instalación deben utilizar estas API. Si utiliza la GAC, esto directamente expone la aplicación de fragilidad de enlace de ensamblado o puede hacer que su aplicación no funcione correctamente en versiones futuras de .NET Framework.

La GAC almacena los ensamblados que se comparten en todas las aplicaciones en un equipo. La ubicación de almacenamiento real y la estructura de la GAC no está documentada y está sujeta a cambios en futuras versiones de .NET Framework y el sistema operativo Microsoft Windows.

El único método compatible a ensamblados de acceso en la GAC es a través de las API que se documentan en este artículo.

La mayoría de las aplicaciones no es necesario utilizar estas API, ya que common language runtime realiza automáticamente el enlace de ensamblado. Sólo programas de instalación personalizados o herramientas de administración deben utilizar estas API. Microsoft Windows Installer ofrece compatibilidad nativa para instalar ensamblados en la GAC.

Para obtener más información sobre ensamblados y la GAC, vea el SDK de .NET Framework.

Utilizar la API GAC en las situaciones siguientes:
  • Al instalar un ensamblado en la GAC.
  • Cuando se quita un ensamblado de la GAC.
  • Cuando exporte un ensamblado de la GAC.
  • Al enumerar ensamblados que están disponibles en la GAC.
Nota : debe llamarse CoInitialize(Ex) que utiliza cualquiera de las funciones e interfaces que se describen en esta especificación.

IAssemblyCache interfaz

La interfaz IAssemblyCache es la interfaz de nivel superior que proporciona acceso a la GAC.

Para obtener una instancia de la API CreateAssemblyCache , llame al CreateAssemblyCache API, como sigue:
STDAPI CreateAssemblyCache(IAssemblyCache **ppAsmCache, DWORD dwReserved); 
los parámetros se definen como sigue:
  • ppAsmCache - puntero devolver IAssemblyCache
  • dwReservado

FUSION_INSTALL_REFERENCE estructura

La estructura FUSION_INSTALL_REFERENCE representa una referencia que se realiza cuando instala un ensamblado a una aplicación en la 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;
				
los campos de la estructura se definen como sigue:
  • cbSize - el tamaño de la estructura en bytes.
  • dwFlags - reservado, debe ser cero.
  • guidScheme - la entidad que agrega la referencia.
  • szIdentifier - cadena única que identifica la aplicación que instala al ensamblado.
  • szNonCannonicalData - cadena que sólo se entiende por la entidad que agrega la referencia. Sólo la GAC almacena esta cadena.
Los posibles valores para el campo guidScheme pueden ser una de las siguientes:
  • FUSION_REFCOUNT_MSI_GUID - el ensamblado hace referencia a una aplicación que ha instalado mediante Windows Installer. El campo szIdentifier se establece en MSI y szNonCannonicalData está establecida a Windows Installer . Esta combinación sólo se debe utilizar Windows Installer propio.
  • FUSION_REFCOUNT_UNINSTALL_SUBKEY_GUID - el ensamblado hace referencia a una aplicación que aparece en Agregar o quitar programas . El campo szIdentifier es el token que se utiliza para registrar la aplicación con Agregar o quitar programas .
  • FUSION_REFCOUNT_FILEPATH_GUID - el ensamblado hace referencia a una aplicación que está representada por un archivo en el sistema de archivos. El campo szIdentifier es la ruta de acceso este archivo.
  • FUSION_REFCOUNT_OPAQUE_STRING_GUID - el ensamblado hace referencia a una aplicación que sólo está representada por una cadena opaca. El szIdentifier es esta cadena opaca. La GAC no realiza existencia buscando referencias opacas cuando se quita este.

Estructura ASSEMBLY_INFO

La estructura ASSEMBLY_INFO representa información sobre un ensamblado en la caché de ensamblados.

Los campos de la estructura se definen como sigue:
  • cbAssemblyInfo - tamaño de la estructura en bytes. Permite adiciones a la estructura en versión futura de .NET Framework.
  • dwAssemblyFlags - indica uno o varios de los bits ASSEMBLYINFO_FLAG_ * .
  • uliAssemblySizeInKB - el tamaño de los archivos que componen el ensamblado en kilobytes (KB).
  • pszCurrentAssemblyPathBuf - un puntero a un búfer de cadena que contiene la actual ruta de acceso del directorio que contiene los archivos que componen el ensamblado. La ruta de acceso debe terminar con un cero.
  • cchBuf - tamaño del búfer que señala el campo pszCurrentAssemblyPathBug .
dwAssemblyFlags puede tener uno de los siguientes valores:
  • ASSEMBLYINFO_FLAG__INSTALLED - indica que el ensamblado está instalado realmente. Se establece siempre en la versión actual de .NET Framework.
  • ASSEMBLYINFO_FLAG__PAYLOADRESIDENT - no establecido en la actual versión de .NET Framework.

Método IAssemblyCache::UninstallAssembly

El método IAssemblyCache::UninstallAssembly quita una referencia a un ensamblado de la GAC. Si otras aplicaciones no otras referencias al ensamblado, se quitan los archivos que componen el ensamblado de la GAC.
    HRESULT UninstallAssembly(
        [in] DWORD dwFlags,
        [in] LPCWSTR pszAssemblyName, 
        [in] LPCFUSION_INSTALL_REFERENCE pRefData, 
        [out, optional] ULONG *pulDisposition
        );

				
Los parámetros se definen como siguiente:
  • dwFlags - sin indicadores definidos. Debe ser cero.
  • pszAssemblyName - el nombre del ensamblado. Un Unicode terminado en cero cadena.
  • pRefData - un puntero a una estructura FUSION_INSTALL_REFERENCE . Aunque no se recomienda, este parámetro puede ser null. El ensamblado está instalado sin una referencia de la aplicación, o desaparecen todas las referencias de aplicación existentes.
  • pulDisposition - puntero a un entero que indica la acción que realiza la función.
Nota : si pulDisposition no es null, pulDisposition contiene uno de los siguientes valores:
  • IASSEMBLYCACHE_UNINSTALL_DISPOSITION_UNINSTALLED - el ensamblado se quitaron los archivos de la GAC.
  • IASSEMBLYCACHE_UNINSTALL_DISPOSITION_STILL_IN_USE - una aplicación está utilizando el ensamblado. Este valor se devuelve en Microsoft Windows 95 y Microsoft Windows 98.
  • IASSEMBLYCACHE_UNINSTALL_DISPOSITION_ALREADY_UNINSTALLED - el ensamblado no existe en la GAC.
  • IASSEMBLYCACHE_UNINSTALL_DISPOSITION_DELETE_PENDING - no se utiliza
  • IASSEMBLYCACHE_UNINSTALL_DISPOSITION_HAS_INSTALL_REFERENCES - el ensamblado no se quitó de la GAC porque existe otra referencia de aplicación.
  • IASSEMBLYCACHE_UNINSTALL_DISPOSITION_REFERENCE_NOT_FOUND - la referencia que se especifica en pRefData no se encuentra en la GAC.
Los valores de devolución se definen como sigue:
  • se ha desinstalado S_OK - el ensamblado.
  • S_FALSE - la operación ha finalizado, pero el ensamblado no se ha quitado la GAC. El motivo se describe en pulDisposition .

Método IAssemblyCache::QueryAssemblyInfo

El método de IAssemblyCache::QueryAssemblyInfo recupera información sobre un ensamblado de la GAC.
    HRESULT QueryAssemblyInfo(
        [in] DWORD dwFlags,
        [in] LPCWSTR pszAssemblyName,
        [in, out] ASSEMBLY_INFO *pAsmInfo
        );
				
Los parámetros se definen como siguiente:
  • dwFlags - QUERYASMINFO_FLAG_VALIDATE O QUERYASMINFO_FLAG_GETSIZE :
    • * _VALIDATE -realiza la validación de los archivos en la GAC contra el manifiesto del ensamblado, incluida la comprobación de hash y comprobación de firma de nombre seguro.
    • * _GETSIZE -devuelve el tamaño de todos los archivos en el ensamblado (espacio de disco). Si no se especifica, no se modifica el campo ASSEMBLY_INFO::uliAssemblySizeInKB .
  • pszAssemblyName - nombre del ensamblado que se consulta.
  • pAsmInfo - puntero a la estructura ASSEMBLY_INFO devuelta.

Método IAssemblyCache::InstallAssembly

El método IAssemblyCache::InstallAssembly , agrega un nuevo ensamblado a la GAC. El ensamblado debe conservarse en el sistema de archivos y se copia en la GAC.
    HRESULT InstallAssembly( // If you use this, fusion will do the streaming & commit.
        [in] DWORD dwFlags,
        [in] LPCWSTR pszManifestFilePath, 
        [in] LPCFUSION_INSTALL_REFERENCE pRefData
        );
				
los parámetros se definen como sigue:
  • puede especificarse dwFlags - como máximo, uno de los bits de los valores IASSEMBLYCACHE_INSTALL_FLAG_ * :
    • * _REFRESH - si el ensamblado ya está instalado en la GAC y los números de versión de archivo del ensamblado se instala son la misma o posterior, los archivos se reemplazan.
    • * _FORCE_REFRESH -se sobrescriben los archivos de un ensamblado existente independientemente de su número de versión.
  • pszManifestFilePath - cadena apunta a la biblioteca dynamic-linked (DLL) que contiene el manifiesto del ensamblado. Otros archivos de ensamblado deben residir en el mismo directorio que la DLL que contiene el manifiesto del ensamblado.
  • pRefData - un puntero a un FUSION_INSTALL_REFERENCE que indica la aplicación en cuyo nombre se está instalando el ensamblado. Aunque no se recomienda, este parámetro puede ser null, pero esto deja el ensamblado sin ninguna referencia de aplicación.

IAssemblyName interfaz

La interfaz IAssemblyName representa un nombre de ensamblado. Un nombre de ensamblado incluye un conjunto predeterminado de pares de nombre y valor. El nombre del ensamblado se describe en detalle en el SDK de .NET Framework.
[
        local,
        object,
        uuid(CD193BC0-B4BC-11d2-9833-00C04FC31D2E),
        pointer_default(unique)
]
interface IAssemblyName: IUnknown
				
Se obtiene una instancia de IAssemblyName llamando a la API de CreateAssemblyNameObject :
STDAPI CreateAssemblyNameObject(LPASSEMBLYNAME *ppAssemblyNameObj, LPCWSTR szAssemblyName, DWORD dwFlags, LPVOID pvReserved);
los parámetros se definen como sigue:
  • ppAssemblyNameObj - puntero a una ubicación de memoria que recibe el puntero IAssemblyName que se crea.
  • szAssemblyName - una representación de cadena del nombre del ensamblado o de una referencia de ensamblado completo que viene determinada por dwFlags . La representación de cadena puede ser null.
  • dwFlags - cero o más de los bits que se definen en la enumeración CREATE_ASM_NAME_OBJ_FLAGS .
  • pvReserved - debe ser null.

CREATE_ASM_NAME_OBJ_FLAGS (enumeración)

La enumeración CREATE_ASM_NAME_OBJ_FLAGS contiene los valores siguientes:
  • CANOF_PARSE_DISPLAY_NAME - si se especifica este indicador, el parámetro de szAssemblyName es un nombre completo del ensamblado y se analiza para las propiedades individuales. Si no se especifica el indicador, szAssemblyName es la parte "Nombre" del nombre del ensamblado.
  • CANOF_SET_DEFAULT_VALUES - si este indicador es especificadas, ciertas propiedades, como la arquitectura de procesador, se establecen en sus valores predeterminados.
    typedef enum {
         CANOF_PARSE_DISPLAY_NAME = 0x1,
         CANOF_SET_DEFAULT_VALUES = 0x2
    } CREATE_ASM_NAME_OBJ_FLAGS;
				

ASM_NAME (enumeración)

El identificador de propiedad de enumeración ASM_NAME describe los nombres válidos de los pares de nombre y valor en el nombre de ensamblado. Consulte el .NET Framework SDK para obtener una descripción de estas propiedades.
    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;
				

Método IAssemblyName::SetProperty

El método IAssemblyName::SetProperty agrega un par de nombre y valor al nombre del ensamblado o, si ya existe un par de nombre y valor con el mismo nombre, modifica o elimina el valor de un par nombre-valor.
    HRESULT SetProperty(
        [in]    DWORD  PropertyId, 
        [in]    LPVOID pvProperty,
        [in]    DWORD  cbProperty);
				
Los parámetros se definen como siguiente:
  • PropertyId - el identificador que representa la parte de nombre el par nombre-valor que se va a agregar o modificarse. Identificadores de propiedad válido están definidos en la enumeración ASM_NAME .
  • pvProperty - un puntero a un búfer que contiene el valor de la propiedad.
  • cbProperty - la longitud del búfer pvProperty en bytes. Si cbProperty es cero, se quitará el nombre del ensamblado en el par de nombre y valor.

Método IAssemblyName::GetProperty

El método IAssemblyName::GetProperty recupera el valor de un par de nombre y valor en el nombre de ensamblado que especifica el nombre.
    HRESULT GetProperty(
        [in]         DWORD    PropertyId, 
        [out]        LPVOID   pvProperty,
        [in, out]    LPDWORD  pcbProperty);
				
Los parámetros se definen como siguiente:
  • PropertyId - el identificador que representa el nombre del par de nombre y valor cuyo valor es que se va a recuperar. Identificadores de propiedad especificado están definidos en la enumeración ASM_NAME .
  • pvProperty - un puntero a un búfer que va a contener el valor de la propiedad.
  • cbProperty - la longitud del búfer pvProperty , en bytes.

Método IAssemblyName::Finalize

El método IAssemblyName::Finalize inmoviliza un nombre de ensamblado. Llamadas adicionales al IAssemblyName::SetProperty están incorrectas después de que ha llamado a este método.
HRESULT Finalize();

Método IAssemblyName::GetDisplayName

El método IAssemblyName::GetDisplayName devuelve una representación de cadena del nombre del ensamblado.
    HRESULT  GetDisplayName(
        [out]       LPOLESTR  szDisplayName,
        [in, out]   LPDWORD   pccDisplayName,
        [in]        DWORD     dwDisplayFlags);
				
Los parámetros se definen como siguiente:
  • szDisplayName - un puntero a un búfer que va a contener el nombre para mostrar. Se devuelve el nombre para mostrar en Unicode.
  • pccDisplayName - el tamaño del búfer en caracteres (de entrada). Longitud del nombre devuelto de la presentación (en retorno).
  • dwDisplayFlags - uno o más de los bits definidos en la enumeración ASM_DISPLAY_FLAGS :
    • * _VERSION -incluye el número de versión como parte del nombre de presentación.
    • * _CULTURE -incluye la referencia cultural.
    • * _PUBLIC_KEY_TOKEN -incluye el token de clave pública.
    • * _PUBLIC_KEY -incluye la clave pública.
    • * _CUSTOM -incluye la parte del nombre del ensamblado personalizada.
    • * _PROCESSORARCHITECTURE -incluye la arquitectura del procesador.
    • * _LANGUAGEID -incluye el identificador de idioma.
    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;
				

Método IAssemblyName::GetName

El método IAssemblyName::GetName devuelve la parte del nombre el nombre del ensamblado.
    HRESULT GetName(
        [in, out] LPDWORD lpcwBuffer,
        [out] WCHAR *pwzName);
				
Los parámetros se definen como siguiente:
  • lpcwBuffer - tamaño del búfer pwszName (de entrada). Longitud del nombre (en retorno).
  • pwszName - puntero al búfer que va a contener la parte del nombre el nombre del ensamblado.

Método IAssemblyName::GetVersion

El método IAssemblyName::GetVersion devuelve la parte de la versión del nombre del ensamblado.
HRESULT GetVersion(
        [out] LPDWORD pdwVersionHi,
        [out] LPDWORD pdwVersionLow);
				
Los parámetros se definen como siguiente:
  • pdwVersionHi - puntero a un DWORD que contiene los 32 bits superiores del número de versión.
  • pdwVersionLow - puntero a un valor DWORD que contienen los 32 bits inferiores del número de versión.

Método IAssemblyName::IsEqual

El método IAssemblyName::IsEqual compara el nombre del ensamblado a nombres de ensamblado de otro.
    HRESULT IsEqual(
        [in] IAssemblyName *pName,
        [in] DWORD dwCmpFlags);
				
Los parámetros se definen como siguiente:
  • pName - el nombre de ensamblado para comparar.
  • dwCmpFlags - indica qué parte del nombre de ensamblado que va a utilizar en la comparación.
Los valores son uno o varios de los bits definidos en la enumeración 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;                       
				
los valores devueltos son:
  • S_OK: -los nombres coinciden de acuerdo con los criterios de comparación.
  • S_FALSE: -los nombres no coinciden.

Método IAssemblyName::Clone

El método IAssemblyName::Clone crea una copia de un nombre de ensamblado.
    HRESULT Clone(
        [out] IAssemblyName **pName);
				

IAssemblyEnum interfaz

La interfaz IAssemblyEnum enumera los ensamblados en la GAC.
 [
        local,
        object,
        uuid(21b8916c-f28e-11d2-a473-00c04f8ef448),
        pointer_default(unique)
]
interface IAssemblyEnum : IUnknown
				
Para obtener una instancia de la API CreateAssemblyEnum , llame al CreateAssemblyNameObject API, como sigue:
STDAPI CreateAssemblyEnum(IAssemblyEnum **pEnum, IUnknown *pUnkReserved, IAssemblyName *pName, DWORD dwFlags, LPVOID pvReserved);
los parámetros se definen como sigue:
  • pEnum - puntero a una ubicación de memoria que contiene el puntero IAssemblyEnum .
  • pUnkReserved - debe ser null.
  • pName - un nombre de ensamblado que se utiliza para filtrar la enumeración. Puede ser null para enumerar todos los ensamblados en la GAC.
  • dwFlags - exactamente uno de bits de la enumeración ASM_CACHE_FLAGS .
  • pvReserved - debe ser NULL.

ASM_CACHE_FLAGS (enumeración)

La enumeración ASM_CACHE_FLAGS contiene los valores siguientes:
  • ASM_CACHE_ZAP - enumera la caché de ensamblados precompilados utilizando Ngen.exe.
  • ASM_CACHE_GAC - enumera la GAC.
  • ASM_CACHE_DOWNLOAD - enumera los ensamblados que han descargado a petición o que hayan sido una copia sombra.
IAssemblyName::GetDisplayName
typedef enum
{
    ASM_CACHE_ZAP            = 0x1,
    ASM_CACHE_GAC            = 0x2,
    ASM_CACHE_DOWNLOAD       = 0x4
} ASM_CACHE_FLAGS;
				

Método IAssemblyEnum::GetNextAssembly

El método IAssemblyEnum::GetNextAssembly enumera los ensamblados en la GAC.
    HRESULT GetNextAssembly
    (
        [in]                  LPVOID                pvReserved,
        [out]                 IAssemblyName       **ppName,
        [in]                  DWORD                 dwFlags
    );
				
Los parámetros se definen como siguiente:
  • pvReserved - debe ser null.
  • ppName - puntero a una ubicación de memoria que va a recibir el puntero de interfaz para el nombre de ensamblado del ensamblado siguiente que se enumera.
  • dwFlags - debe ser cero.

Interfaz de la instancia de IInstallReferenceItem

La interfaz de la instancia de IInstallReferenceItem representa una referencia que se ha establecido en un ensamblado en la GAC. La interfaz de la instancia de IInstallReferenceEnum devuelve instancias de IInstallReferenceIteam .
[
        local,
        object,
        uuid(582dac66-e678-449f-aba6-6faaec8a9394),
        pointer_default(unique)
]
interface IInstallReferenceItem : IUnknown
				

Método IInstallReferenceItem::GetReference

El método IInstallReferenceItem::GetReference devuelve una estructura FUSION_INSTALL_REFERENCE .
    HRESULT GetReference
    (
    [out] LPFUSION_INSTALL_REFERENCE *ppRefData,
    [in]  DWORD dwFlags,
    [in]  LPVOID pvReserved
    );
				
Los parámetros se definen como siguiente:
  • ppRefData - un puntero a una estructura FUSION_INSTALL_REFERENCE . La memoria es asignada por el método GetReference y se libera cuando se libera la instancia de IInstallReferenceItem . Los llamadores no deben contener una referencia a este búfer una vez liberado el objeto de instancia de IInstallReferenceItem .
  • dwFlags - debe ser cero.
  • pvReserved - debe ser null.

Interfaz de la instancia de IInstallReferenceEnum

La interfaz de la instancia de IInstallReferenceEnum enumera todas las referencias se establecen en un ensamblado en la GAC.

Nota : se bloquean referencias que pertenecen al ensamblado para los cambios mientras se está enumerando esas referencias.
[
        local,
        object,
        uuid(56b1a988-7c0c-4aa2-8639-c3eb5a90226f),
        pointer_default(unique)
]
interface IInstallReferenceEnum : IUnknown
				
Para obtener una instancia de la API CreateInstallReferenceEnum , llame al CreateInstallReferenceEnum API, como sigue:
STDAPI CreateInstallReferenceEnum(IInstallReferenceEnum **ppRefEnum, IAssemblyName *pName, DWORD dwFlags, LPVOID pvReserved);
los parámetros se definen como sigue:
  • ppRefEnum - un puntero a una ubicación de memoria que recibe el puntero de la instancia de IInstallReferenceEnum .
  • pName - el nombre de ensamblado para el que se enumeran las referencias.
  • dwFlags - debe ser cero.
  • pvReserved - debe ser null.

Método IInstallReferenceEnum::GetNextInstallReferenceItem

IInstallReferenceEnum::GetNextInstallReferenceItem devuelve la siguiente información de referencia para un ensamblado.
    HRESULT GetNextInstallReferenceItem
            (
            [out] IInstallReferenceItem **ppRefItem,
            [in]  DWORD dwFlags,
            [in]  LPVOID pvReserved
            );
				
Los parámetros se definen como siguiente:
  • ppRefItem - puntero a una ubicación de memoria que recibe el puntero de la instancia de IInstallReferenceItem .
  • dwFlags - debe ser cero.
  • pvReserved - debe ser null.
Valores devueltos son como sigue:
  • S_OK: -se devuelve correctamente el elemento siguiente.
  • S_FALSE: -no hay más elementos.

GetCachePath API

GetCachePath API devuelve la ubicación de almacenamiento de la GAC.
STDAPI GetCachePath(ASM_CACHE_FLAGS dwCacheFlags, LPWSTR pwzCachePath, PDWORD pcchPath);
Los parámetros se definen como siguiente:
  • dwCacheFlags - exactamente uno de los bits definidos en la enumeración ASM_CACHE_FLAGS .
  • pwzCachePath - puntero a un búfer que recibe la ruta de acceso de la GAC como una cadena Unicode.
  • pcchPath - longitud del búfer pwszCachePath , en caracteres 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); ")
				

Propiedades

Id. de artículo: 317540 - Última revisión: viernes, 04 de abril de 2003 - Versión: 3.0
La información de este artículo se refiere a:
  • Microsoft .NET Framework Software Development Kit 1.0 Service Pack 2
  • Microsoft .NET Framework Software Development Kit 1.0 Service Pack 2
Palabras clave: 
kbmt kbbug kbdocerr kbpending KB317540 KbMtes
Traducción automática
IMPORTANTE: Este artículo ha sido traducido por un software de traducción automática de Microsoft (http://support.microsoft.com/gp/mtdetails) en lugar de un traductor humano. Microsoft le ofrece artículos traducidos por un traductor humano y artículos traducidos automáticamente para que tenga acceso en su propio idioma a todos los artículos de nuestra base de conocimientos (Knowledge Base). Sin embargo, los artículos traducidos automáticamente pueden contener errores en el vocabulario, la sintaxis o la gramática, como los que un extranjero podría cometer al hablar el idioma. Microsoft no se hace responsable de cualquier imprecisión, error o daño ocasionado por una mala traducción del contenido o como consecuencia de su utilización por nuestros clientes. Microsoft suele actualizar el software de traducción frecuentemente.
Haga clic aquí para ver el artículo original (en inglés): 317540
Renuncia a responsabilidad de los contenidos de la KB sobre productos a los que ya no se ofrece asistencia alguna
El presente artículo se escribió para productos para los que Microsoft ya no ofrece soporte técnico. Por tanto, el presente artículo se ofrece "tal cual" y no será actualizado.

Enviar comentarios

 

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