DOC: O global assembly cache (GAC) API são não documentadas na documentação .NET Framework Software Development Kit (SDK)

Traduções de Artigos Traduções de Artigos
Artigo: 317540 - Ver produtos para os quais este artigo se aplica.
Expandir tudo | Reduzir tudo

Nesta página

Sumário

As código nativo interfaces programação da aplicação (API) que permitem a interacção com cache de assemblagem global (GAC) não estão documentadas na documentação do .NET Framework Software Development Kit (SDK).

Mais Informação

atenção : não utilizar estas APIs da aplicação para executar as associações de assemblagem ou para testar a existência de assemblagens ou outro tempo de execução, desenvolvimento ou operações de tempo de estruturação. Apenas ferramentas administrativas e programas de configuração tem de utilizar estas APIs. Se utilizar a GAC, isto directamente expõe a aplicação fragilidade da vinculação de assemblagem ou pode fazer com que a aplicação funcionem incorrectamente em futuras versões do .NET Framework.

GAC armazena assemblagens partilhadas por todas as aplicações num computador. A localização de armazenamento real and estrutura da GAC não documentado e é sujeitas a alterações em futuras versões do .NET Framework e o sistema operativo Microsoft Windows.

O único método suportado para assemblagens de acesso na GAC consiste através de API documentadas deste artigo.

A maior parte das aplicações não são necessário utilizar estas APIs porque a assemblagem do enlace é executada automaticamente pelo common language runtime. Apenas programas de configuração personalizada ou ferramentas de gestão tem de utilizar estas APIs. Microsoft Windows Installer tem suporte nativo para instalar assemblagens GAC.

Para mais informações sobre assemblagens e GAC, consulte o .NET Framework SDK.

Utilize a API GAC nos seguintes cenários:
  • Quando instalar uma assemblagem de GAC.
  • Quando remove uma assemblagem de GAC.
  • Quando exportar uma assemblagem de GAC.
  • Quando enumerar as assemblagens que estão disponíveis na GAC.
Nota : CoInitialize(Ex) tem de ser chamado antes de utilizar qualquer um dos funções e interfaces que são descritas esta especificação.

Interface IAssemblyCache

A interface IAssemblyCache é a interface de nível superior que fornece acesso a GAC.

Para obter uma instância de CreateAssemblyCache API, chamada CreateAssemblyCache API, da seguinte forma:
STDAPI CreateAssemblyCache(IAssemblyCache **ppAsmCache, DWORD dwReserved); 
os parâmetros são definidos da seguinte forma:
  • ppAsmCache - apontador para regressar IAssemblyCache
  • dwReserved

Estrutura FUSION_INSTALL_REFERENCE

A estrutura FUSION_INSTALL_REFERENCE representa uma referência que é efectuada quando uma aplicação tiver instalado uma assemblagem na 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;
				
os campos da estrutura são definidos da seguinte forma:
  • cbSize - O tamanho da estrutura em bytes.
  • dwFlags - reservado, tem de ser zero.
  • guidScheme - A entidade que adiciona a referência.
  • szIdentifier - uma cadeia exclusiva que identifica a aplicação que instalou a assemblagem.
  • szNonCannonicalData - uma cadeia só é compreendida pela entidade que adiciona a referência. GAC apenas armazena esta cadeia.
Valores possíveis para o campo guidScheme podem ser um dos seguintes procedimentos:
  • FUSION_REFCOUNT_MSI_GUID - A assemblagem é referenciado por uma aplicação que foi instalada utilizando o Windows Installer. O campo szIdentifier é definido como MSI e szNonCannonicalData está definida para o Windows Installer . Este esquema tem apenas de ser utilizado pelo Windows Installer propriamente dito.
  • FUSION_REFCOUNT_UNINSTALL_SUBKEY_GUID - A assemblagem é referenciado por uma aplicação que aparece em Adicionar/remover programas . O campo szIdentifier é o token é utilizado para registar a aplicação Adicionar/remover programas .
  • FUSION_REFCOUNT_FILEPATH_GUID - A assemblagem é referenciado por uma aplicação que é representada por um ficheiro no sistema de ficheiros. O campo szIdentifier é o caminho para este ficheiro.
  • FUSION_REFCOUNT_OPAQUE_STRING_GUID - A assemblagem é referenciado por uma aplicação que só é representada por uma cadeia opaca. szIdentifier é esta cadeia opaca. GAC não efectua existência procurar referências opacas quando remove esta.

Estrutura ASSEMBLY_INFO

A estrutura ASSEMBLY_INFO representa as informações sobre uma assemblagem na cache de assemblagem.

Os campos da estrutura são definidos da seguinte forma:
  • cbAssemblyInfo - tamanho da estrutura em bytes. Permite adições a estrutura na versão futura do .NET Framework.
  • dwAssemblyFlags - indica um ou mais bits ASSEMBLYINFO_FLAG_ * .
  • uliAssemblySizeInKB - O tamanho dos ficheiros que constituem a assemblagem em kilobytes (KB).
  • pszCurrentAssemblyPathBuf - um ponteiro para a memória intermédia de cadeia que contém o actual caminho do directório que contém os ficheiros que constituem a assemblagem. O caminho tem de terminar com um zero.
  • cchBuf - tamanho da memória intermédia que o campo pszCurrentAssemblyPathBug aponta para.
dwAssemblyFlags pode ter um dos seguintes valores:
  • ASSEMBLYINFO_FLAG__INSTALLED - indica que a assemblagem é efectivamente instalada. Sempre definido na versão actual do .NET Framework.
  • ASSEMBLYINFO_FLAG__PAYLOADRESIDENT - nunca definido na versão actual do .NET Framework.

Método IAssemblyCache::UninstallAssembly

O método IAssemblyCache::UninstallAssembly remove uma referência a uma assemblagem de GAC. Se outras aplicações contêm não outras referências à assemblagem, são removidos os ficheiros que constituem a assemblagem do GAC.
    HRESULT UninstallAssembly(
        [in] DWORD dwFlags,
        [in] LPCWSTR pszAssemblyName, 
        [in] LPCFUSION_INSTALL_REFERENCE pRefData, 
        [out, optional] ULONG *pulDisposition
        );

				
Os parâmetros são definidos como:
  • dwFlags - sem sinalizadores definidos. Tem de ser zero.
  • pszAssemblyName - O nome da assemblagem. Unicode terminada em zero cadeia.
  • pRefData - um ponteiro para uma estrutura FUSION_INSTALL_REFERENCE . Embora não seja recomendado, este parâmetro pode ser nulo. A assemblagem está instalada sem uma referência de aplicação ou todas as referências de aplicações existente tiverem desaparecidas.
  • pulDisposition - ponteiro para um número inteiro que indica a acção que é efectuada pela função.
Nota : Se pulDisposition não for nulo, pulDisposition contém um dos seguintes valores:
  • IASSEMBLYCACHE_UNINSTALL_DISPOSITION_UNINSTALLED - A assemblagem ficheiros foram removidos da GAC.
  • IASSEMBLYCACHE_UNINSTALL_DISPOSITION_STILL_IN_USE - aplicação está a utilizar a assemblagem. Este valor é devolvido no Microsoft Windows 95 e Microsoft Windows 98.
  • Não existe IASSEMBLYCACHE_UNINSTALL_DISPOSITION_ALREADY_UNINSTALLED - A assemblagem na GAC.
  • IASSEMBLYCACHE_UNINSTALL_DISPOSITION_DELETE_PENDING - não utilizada.
  • não ter sido removido IASSEMBLYCACHE_UNINSTALL_DISPOSITION_HAS_INSTALL_REFERENCES - A assemblagem de GAC porque existe outra referência de aplicação.
  • IASSEMBLYCACHE_UNINSTALL_DISPOSITION_REFERENCE_NOT_FOUND - A referência que é especificada em pRefData não se encontra na GAC.
Os valores de retorno são definidos como:
  • S_OK - A assemblagem foi desinstalado.
  • S_FALSE - A operação teve êxito mas a assemblagem não foi removida da GAC. O motivo é descrito no pulDisposition .

Método IAssemblyCache::QueryAssemblyInfo

O método IAssemblyCache::QueryAssemblyInfo obtém informações sobre uma assemblagem de GAC.
    HRESULT QueryAssemblyInfo(
        [in] DWORD dwFlags,
        [in] LPCWSTR pszAssemblyName,
        [in, out] ASSEMBLY_INFO *pAsmInfo
        );
				
Os parâmetros são definidos como:
  • dwFlags - um dos QUERYASMINFO_FLAG_VALIDATE ou QUERYASMINFO_FLAG_GETSIZE :
    • * _VALIDATE -executa a validação dos ficheiros na GAC contra o manifesto da assemblagem, incluindo a verificação do hash e verificação de assinatura de nome seguro.
    • * _GETSIZE -devolve o tamanho de todos os ficheiros na assemblagem (requisitos de espaço do disco). Se não for especificado, o campo ASSEMBLY_INFO::uliAssemblySizeInKB não será modificado.
  • pszAssemblyName - nome da assemblagem que está a ser consultada.
  • pAsmInfo - ponteiro para a estrutura ASSEMBLY_INFO devolvida.

Método IAssemblyCache::InstallAssembly

O método IAssemblyCache::InstallAssembly adiciona uma nova assemblagem para a GAC. A assemblagem tem de ser persistente no sistema de ficheiros e é copiada para a GAC.
    HRESULT InstallAssembly( // If you use this, fusion will do the streaming & commit.
        [in] DWORD dwFlags,
        [in] LPCWSTR pszManifestFilePath, 
        [in] LPCFUSION_INSTALL_REFERENCE pRefData
        );
				
os parâmetros estão definidos como se segue:
  • dwFlags - no máximo, um dos bits dos valores IASSEMBLYCACHE_INSTALL_FLAG_ * podem ser especificados:
    • * _REFRESH - se a assemblagem já está instalada na GAC e os números de versão de ficheiro da assemblagem que está a ser instalado são a mesma ou posterior, os ficheiros são substituídos.
    • * _FORCE_REFRESH -os ficheiros de uma assemblagem existente são substituídos independentemente do respectivo número de versão.
  • pszManifestFilePath - uma cadeia que aponta para a biblioteca ligado dinâmica (DLL) que contém o manifesto da assemblagem. Outros ficheiros de assemblagem tem de residir no mesmo directório como DLL que contém o manifesto da assemblagem.
  • pRefData - um ponteiro para FUSION_INSTALL_REFERENCE que indica a aplicação cujo nome a assemblagem está a ser instalada. Embora não seja recomendado, este parâmetro pode ser nulo, mas este deixa a assemblagem sem qualquer referência de aplicação.

Interface IAssemblyName

A interface IAssemblyName representa um nome de assemblagem. Um nome de assemblagem inclui um conjunto predeterminado de pares nome / valor. O nome da assemblagem é descrito em detalhe no .NET Framework SDK.
[
        local,
        object,
        uuid(CD193BC0-B4BC-11d2-9833-00C04FC31D2E),
        pointer_default(unique)
]
interface IAssemblyName: IUnknown
				
Uma instância de IAssemblyName é obtida através de accione a API CreateAssemblyNameObject :
STDAPI CreateAssemblyNameObject(LPASSEMBLYNAME *ppAssemblyNameObj, LPCWSTR szAssemblyName, DWORD dwFlags, LPVOID pvReserved);
os parâmetros são definidos da seguinte forma:
  • ppAssemblyNameObj - ponteiro numa localização de memória que recebe o ponteiro de IAssemblyName é criado.
  • szAssemblyName - uma representação em cadeia do nome da assemblagem ou de uma referência de assemblagem total é determinada pelo dwFlags . A representação em cadeia pode ser nulo.
  • dwFlags - zero ou mais bits que são definidos na enumeração CREATE_ASM_NAME_OBJ_FLAGS .
  • pvReserved - tem de ser nulo.

Enumeração CREATE_ASM_NAME_OBJ_FLAGS

A enumeração CREATE_ASM_NAME_OBJ_FLAGS contém os seguintes valores:
  • CANOF_PARSE_DISPLAY_NAME - se este sinalizador for especificado, o parâmetro szAssemblyName é um nome de assemblagem completo e é analisado às propriedades individuais. Se o sinalizador não for especificado, szAssemblyName é a parte "Nome" do nome da assemblagem.
  • CANOF_SET_DEFAULT_VALUES - se este sinalizador é propriedades especificadas, determinadas, tais como arquitectura de processador, são definidas para os respectivos valores predefinidos.
    typedef enum {
         CANOF_PARSE_DISPLAY_NAME = 0x1,
         CANOF_SET_DEFAULT_VALUES = 0x2
    } CREATE_ASM_NAME_OBJ_FLAGS;
				

Enumeração ASM_NAME

O ID de propriedade de enumeração ASM_NAME descreve os nomes dos pares nome / valor num nome de assemblagem válidos. Consulte .NET Framework SDK para obter uma descrição destas propriedades.
    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

O método IAssemblyName::SetProperty adiciona um par nome-valor do nome da assemblagem ou, se já existir um par nome-valor com o mesmo nome, modifica ou elimina o valor de um par nome / valor.
    HRESULT SetProperty(
        [in]    DWORD  PropertyId, 
        [in]    LPVOID pvProperty,
        [in]    DWORD  cbProperty);
				
Os parâmetros são definidos como:
  • PropertyId - O ID que representa a parte do nome do par nome-valor que está a ser adicionado ou a ser modificada. ID de propriedade válido são definidos na enumeração ASM_NAME .
  • pvProperty - um ponteiro para uma memória intermédia que contém o valor da propriedade.
  • cbProperty - O comprimento da memória intermédia pvProperty em bytes. Se cbProperty for zero, o par nome-valor é removido do nome da assemblagem.

Método IAssemblyName::GetProperty

O método IAssemblyName::GetProperty obtém o valor de um par nome / valor no nome da assemblagem Especifica o nome.
    HRESULT GetProperty(
        [in]         DWORD    PropertyId, 
        [out]        LPVOID   pvProperty,
        [in, out]    LPDWORD  pcbProperty);
				
Os parâmetros são definidos como:
  • PropertyId - O ID que representa o nome do par nome-valor cujo valor deve ser obtida. ID de propriedade especificado são definidos na enumeração ASM_NAME .
  • pvProperty - um ponteiro para uma memória intermédia que deve conter o valor da propriedade.
  • cbProperty - O comprimento do buffer pvProperty , em bytes.

Método IAssemblyName::Finalize

O método IAssemblyName::Finalize fixa um nome de assemblagem. Chamadas adicionais para IAssemblyName::SetProperty ficam sem êxito depois deste método foi chamado.
HRESULT Finalize();

Método IAssemblyName::GetDisplayName

O método IAssemblyName::GetDisplayName devolve uma representação de cadeia do nome da assemblagem.
    HRESULT  GetDisplayName(
        [out]       LPOLESTR  szDisplayName,
        [in, out]   LPDWORD   pccDisplayName,
        [in]        DWORD     dwDisplayFlags);
				
Os parâmetros são definidos como:
  • szDisplayName - um ponteiro para uma memória intermédia conter o nome a apresentar. O nome a apresentar é devolvido em Unicode.
  • pccDisplayName - O tamanho da memória intermédia de caracteres (na entrada). O comprimento do nome de visualização devolvidos (devolução).
  • dwDisplayFlags - uma ou mais bits definidos na enumeração ASM_DISPLAY_FLAGS :
    • * _VERSION -inclui o número da versão como parte do nome da apresentação.
    • * _CULTURE -inclui o idioma.
    • * _PUBLIC_KEY_TOKEN -inclui o token de chave pública.
    • * _PUBLIC_KEY -inclui a chave pública.
    • * _CUSTOM -inclui a parte do nome assemblagem personalizada.
    • * _PROCESSORARCHITECTURE -inclui a arquitectura de processador.
    • * _LANGUAGEID -inclui o ID 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

O método IAssemblyName::GetName devolve a parte de nome do nome da assemblagem.
    HRESULT GetName(
        [in, out] LPDWORD lpcwBuffer,
        [out] WCHAR *pwzName);
				
Os parâmetros são definidos como:
  • lpcwBuffer - tamanho da memória intermédia pwszName (na entrada). Comprimento do nome (na devolução).
  • pwszName - ponteiro para a memória intermédia que vai conter a parte do nome do nome da assemblagem.

Método IAssemblyName::GetVersion

O método IAssemblyName::GetVersion devolve a parte de versão do nome da assemblagem.
HRESULT GetVersion(
        [out] LPDWORD pdwVersionHi,
        [out] LPDWORD pdwVersionLow);
				
Os parâmetros são definidos como:
  • pdwVersionHi - ponteiro para uma DWORD que contém os 32 bits do número de versão superiores.
  • pdwVersionLow - ponteiro para uma DWORD que contêm os 32 bits do número de versão inferiores.

Método IAssemblyName::IsEqual

O método IAssemblyName::IsEqual compara o nome de assemblagem para outro nomes de assemblagem.
    HRESULT IsEqual(
        [in] IAssemblyName *pName,
        [in] DWORD dwCmpFlags);
				
Os parâmetros são definidos como:
  • nomef - O nome da assemblagem para comparar.
  • dwCmpFlags - indica que parte do nome de assemblagem para utilizar na comparação.
Os valores são um ou mais bits definidos na enumeração 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;                       
				
os valores devolvidos são os seguintes:
  • S_OK: -correspondência com os nomes de acordo com os critérios de comparação.
  • S_FALSE: -os nomes não são iguais.

Método IAssemblyName::Clone

O método IAssemblyName::Clone cria uma cópia de um nome de assemblagem.
    HRESULT Clone(
        [out] IAssemblyName **pName);
				

Interface IAssemblyEnum

A interface IAssemblyEnum enumera as assemblagens na GAC.
 [
        local,
        object,
        uuid(21b8916c-f28e-11d2-a473-00c04f8ef448),
        pointer_default(unique)
]
interface IAssemblyEnum : IUnknown
				
Para obter uma instância de CreateAssemblyEnum API, chamada CreateAssemblyNameObject API, da seguinte forma:
STDAPI CreateAssemblyEnum(IAssemblyEnum **pEnum, IUnknown *pUnkReserved, IAssemblyName *pName, DWORD dwFlags, LPVOID pvReserved);
os parâmetros são definidos da seguinte forma:
  • pEnum - ponteiro para uma localização de memória que contém o ponteiro IAssemblyEnum .
  • pUnkReserved - tem de ser nulo.
  • nomef - um nome de assemblagem que é utilizado para filtrar a enumeração. Pode ser nulo para enumerar todas as assemblagens na GAC.
  • dwFlags - exactamente um bit da enumeração ASM_CACHE_FLAGS .
  • pvReserved - tem de ser NULL.

Enumeração ASM_CACHE_FLAGS

A enumeração ASM_CACHE_FLAGS contém os seguintes valores:
  • ASM_CACHE_ZAP - Enumera a cache de assemblagens pré-compiladas utilizando Ngen.exe.
  • ASM_CACHE_GAC - enumera GAC.
  • ASM_CACHE_DOWNLOAD - enumera as assemblagens que tenham sido transferida marcação ou que foram copiados de sombra.
IAssemblyName::GetDisplayName
typedef enum
{
    ASM_CACHE_ZAP            = 0x1,
    ASM_CACHE_GAC            = 0x2,
    ASM_CACHE_DOWNLOAD       = 0x4
} ASM_CACHE_FLAGS;
				

Método IAssemblyEnum::GetNextAssembly

O método IAssemblyEnum::GetNextAssembly enumera as assemblagens na GAC.
    HRESULT GetNextAssembly
    (
        [in]                  LPVOID                pvReserved,
        [out]                 IAssemblyName       **ppName,
        [in]                  DWORD                 dwFlags
    );
				
Os parâmetros são definidos como:
  • pvReserved - tem de ser nulo.
  • ppName - ponteiro numa localização de memória que irá receber o ponteiro de interface para o nome de assemblagem da assemblagem seguinte que é enumerada.
  • dwFlags - tem de ser zero.

Interface IInstallReferenceItem

A interface IInstallReferenceItem representa uma referência que foi definida uma assemblagem na GAC. Instâncias do IInstallReferenceIteam são devolvidas pela interface IInstallReferenceEnum .
[
        local,
        object,
        uuid(582dac66-e678-449f-aba6-6faaec8a9394),
        pointer_default(unique)
]
interface IInstallReferenceItem : IUnknown
				

Método IInstallReferenceItem::GetReference

O método IInstallReferenceItem::GetReference devolve uma estrutura FUSION_INSTALL_REFERENCE .
    HRESULT GetReference
    (
    [out] LPFUSION_INSTALL_REFERENCE *ppRefData,
    [in]  DWORD dwFlags,
    [in]  LPVOID pvReserved
    );
				
Os parâmetros são definidos como:
  • ppRefData - um ponteiro para uma estrutura FUSION_INSTALL_REFERENCE . A memória atribuída pelo método GetReference e é libertada quando IInstallReferenceItem é lançada. Os autores das chamadas não devem reter uma referência a esta memória intermédia depois do objecto IInstallReferenceItem é libertado.
  • dwFlags - tem de ser zero.
  • pvReserved - tem de ser nulo.

Interface IInstallReferenceEnum

A interface IInstallReferenceEnum enumera todas as referências são definidas numa assemblagem na GAC.

Nota : referências que pertencem a assemblagem estão bloqueadas para alterações enquanto estão a ser enumeradas essas referências.
[
        local,
        object,
        uuid(56b1a988-7c0c-4aa2-8639-c3eb5a90226f),
        pointer_default(unique)
]
interface IInstallReferenceEnum : IUnknown
				
Para obter uma instância de CreateInstallReferenceEnum API, chamada CreateInstallReferenceEnum API, da seguinte forma:
STDAPI CreateInstallReferenceEnum(IInstallReferenceEnum **ppRefEnum, IAssemblyName *pName, DWORD dwFlags, LPVOID pvReserved);
os parâmetros são definidos da seguinte forma:
  • ppRefEnum - um ponteiro para uma localização de memória que recebe o ponteiro IInstallReferenceEnum .
  • nomef - O nome da assemblagem para o qual as referências são enumeradas.
  • dwFlags - tem de ser zero.
  • pvReserved - tem de ser nulo.

Método IInstallReferenceEnum::GetNextInstallReferenceItem

IInstallReferenceEnum::GetNextInstallReferenceItem devolve as seguinte informações de referência para uma assemblagem.
    HRESULT GetNextInstallReferenceItem
            (
            [out] IInstallReferenceItem **ppRefItem,
            [in]  DWORD dwFlags,
            [in]  LPVOID pvReserved
            );
				
Os parâmetros são definidos como:
  • ppRefItem - ponteiro para uma localização de memória recebe o ponteiro IInstallReferenceItem .
  • dwFlags - tem de ser zero.
  • pvReserved - tem de ser nulo.
Valores de retorno são:
  • S_OK: -O item seguinte é devolvido com êxito.
  • S_FALSE: -não existem mais itens.

GetCachePath API

GetCachePath API devolve a localização de armazenamento da GAC.
STDAPI GetCachePath(ASM_CACHE_FLAGS dwCacheFlags, LPWSTR pwzCachePath, PDWORD pcchPath);
Os parâmetros são definidos como:
  • dwCacheFlags - exactamente um dos bits definidos na enumeração ASM_CACHE_FLAGS .
  • pwzCachePath - ponteiro para uma memória intermédia que irá receber o caminho da GAC como uma cadeia Unicode.
  • pcchPath - tamanho do buffer pwszCachePath , em 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); ")
				

Propriedades

Artigo: 317540 - Última revisão: 4 de abril de 2003 - Revisão: 3.0
A informação contida neste artigo aplica-se a:
  • Microsoft .NET Framework Software Development Kit 1.0 Service Pack 2
  • Microsoft .NET Framework Software Development Kit 1.0 Service Pack 2
Palavras-chave: 
kbmt kbbug kbdocerr kbpending KB317540 KbMtpt
Tradução automática
IMPORTANTE: Este artigo foi traduzido por um sistema de tradução automática (também designado por Machine translation ou MT), não tendo sido portanto revisto ou traduzido por humanos. A Microsoft tem artigos traduzidos por aplicações (MT) e artigos traduzidos por tradutores profissionais. O objectivo é simples: oferecer em Português a totalidade dos artigos existentes na base de dados do suporte. Sabemos no entanto que a tradução automática não é sempre perfeita. Esta pode conter erros de vocabulário, sintaxe ou gramática? erros semelhantes aos que um estrangeiro realiza ao falar em Português. A Microsoft não é responsável por incoerências, erros ou estragos realizados na sequência da utilização dos artigos MT por parte dos nossos clientes. A Microsoft realiza actualizações frequentes ao software de tradução automática (MT). Obrigado.
Clique aqui para ver a versão em Inglês deste artigo: 317540
Exclusão de Responsabilidade para Conteúdo sem Suporte na KB
Este artigo foi escrito sobre produtos para os quais a Microsoft já não fornece suporte. Por conseguinte, este artigo é oferecido "tal como está" e deixará de ser actualizado.

Submeter comentários

 

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