Conversão de tipo importado

Artigo
08/01/2011

Este tópico descreve como o processo de importação converte os seguintes tipos:

Interfaces
Classes
Estruturas
Enumerações
Constantes
Typedefs

Em geral, o Tlbimp. exe importa tipos com o mesmo nome que tinham na biblioteca de tipos original. Nomes dentro de uma biblioteca de tipos devem ser exclusivos, eliminando assim a nomes de conflitos durante o processo de conversão. Todos os nomes de biblioteca de tipos válidos são nomes de assembly válido.

Os tipos importados limitam-se pelo namespace ao qual pertencem, qual é a mesma biblioteca de tipos do original. Tipos individualmente são identificados por seu namespace completo e digite os nomes.

Explicitamente, você pode controlar o nome gerenciado de um tipo importado usando o atributo type library na biblioteca de tipos. Esse identificador de atributo definido pelo usuário é 0F21F359-AB84-41e8-9A78-36D110E6D2F9. A biblioteca de tipos a seguir mostra a adição do atributo definido pelo usuário.

Representação de biblioteca de tipo

[  uuid(…),
    version(1.0)
]
library AcmeLib {
    interface Widget {};
    [custom(0F21F359-AB84-41e8-9A78-36D110E6D2F9, 
     "Acme.WidgetLib.Slingshot")]
    coclass Slingshot {};
};

Embora o Tlbimp. exe importa a biblioteca de tipos no namespace AcmeLib, a classe Slingshot torna-se Acme.WidgetLib.Slingshot.

Interfaces

Quando o processo de importação converte uma interface, ele desmonta todas as IUnknown e IDispatch métodos. A conversão se aplica a GuidAttribute para a interface para reter o identificador de interface (IID) atribuído na biblioteca de tipos e o InterfaceTypeAttribute , a menos que a interface é dupla (uma interface derivando de IDispatch).

Representação de biblioteca de tipo

[uuid(…), ]
interface IWidget : IUnknown {
    HRESULT New()
    HRESULT Start()
};
[uuid(…), ]
interface IGadget : IWidget {
    HRESULT Baz()
};

Durante a conversão, o processo de importação adiciona os métodos da interface base à interface derivada. No exemplo a seguir, New e Start são adicionados para o IGadget interface:

<Guid(…), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)> _
Interface IWidget
    Sub [New]()
    Sub Start()
End Interface

<Guid(…), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)> _
Interface IGadget
    Inherits IWidget
    Shadows Sub [New]()
    Shadows Sub Start()
    Sub Baz()
End Interface

[Guid(…), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
interface IWidget {
    void New();
    void Start();
};
[Guid(…), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
interface IGadget : IWidget {
    new void New();
    new void Start();
    void Baz();
};

Classes

O processo de importação cria uma classe gerenciada para representar o coclass cada COM, dando a classe gerenciada o mesmo nome que o coclass original acrescidos de classe. Por exemplo, o NewNewer coclass torna-se NewNewerClass. A conversão adiciona o GuidAttribute à classe para capturar o identificador de classe (CLSID) do coclass.

Além da classe gerenciada, o processo de importação adiciona uma interface com o mesmo nome como o coclass e se aplica a CoClassAttribute para identificar o CLSID do coclass original. Essa interface tem o mesmo IID como interface padrão para o coclass. Com essa interface, os clientes sempre podem registrar como coletores de eventos.

Ao contrário uma coclass de COM uma classe gerenciada pode conter membros de classe. Acompanhando o.Abordagem do NET Framework, a conversão adiciona cada classe de membros associados a cada interface implementada pelo coclass. Os usuários da classe gerenciada podem invocar métodos e propriedades do tipo gerenciado sem a projeção primeiro para uma interface específica. O processo de importação também adiciona um construtor padrão para cada coclass convertido. Um construtor torna possível criar a classe do código gerenciado. (Classes sem um construtor não podem ser criados). O construtor padrão não tem argumentos; sua implementação chama o construtor de classe base. Se a noncreatable atributo do tipo biblioteca é aplicado para o coclass, o processo de importação não cria um construtor padrão da classe.

Como os nomes de membros de interface não são sempre exclusivos, nome e o colisões de DISPID entre os membros podem ocorrer. Tlbimp. exe resolve conflitos de nome por prefixando o nome da interface e um sublinhado ao nome de cada membro de colisão da classe. Onde os nomes dos membros entrarem em conflito, a primeira interface listada na instrução coclass permanece inalterada.

Quando DispId colisões, o processo de importação atribui DispIds para membros de interface de padrão do coclass e nenhum para os membros da classe conflitantes. No entanto, o processo de importação sempre atribui DispIds membros da interface.

Representação de biblioteca de tipo

[uuid(…)]
interface INew : IDispatch {
    [id(0x100)] HRESULT DoFirst();
    [id(0x101)] HRESULT DoSecond();
}
[uuid(…)]
interface INewer : IDispatch {
    [id(0x100)] HRESULT DoNow();
    [id(0x101)] HRESULT DoSecond();
}
[uuid(…)]
coclass NewNewer  {
    [default] interface INew;
    interface INewer;
}

Os tipos convertidos aparecem como segue:

<Guid(…)> Public Interface INew
    …
End Interface

<Guid(…)> Public Interface INewer
    …
End Interface

<Guid(…)> Public Interface NewNewer
Inherits INew
    …
End Interface

<Guid(…)> Public Class NewNewerClass
Implements INew   
Implements INewer
Implements NewNewer
' Method implementation
     <DispId(100)> _
      …
End Class

[Guid(…)]
public interface INew {…}

[Guid(…)]
public interface INewer {…}

[Guid(…)]
public interface NewNewer : INew {…}

[Guid(…)]
public class NewNewer : INew, INewer, NewNewer{
// Method implementation.
     [DispId(100)]…
}

Estruturas

Estruturas definidas dentro de uma biblioteca de tipo são importadas como metadados. Se um campo de uma struct é um tipo de referência, Tlbimp. exe importa o tipo como um IntPtr e aplica a ComConversionLossAttribute. O atributo indica que informações eram perdidas durante o processo de importação.

Enumerações

Importador da biblioteca (Tlbimp. exe) importa enumerações não gerenciadas como gerenciado Enum tipos.

Constantes

Constantes não serão importados da biblioteca de tipo nesta versão.

Typedefs

Definições de tipo (typedefs) dentro de uma biblioteca de tipo não são importadas. Em vez disso, os campos e os parâmetros são importados como os tipos subjacentes. Por exemplo, um parâmetro do tipo BUTTON_COLOR é importado como um inteiro de tipo, como o BUTTON_COLOR é um alias para um número inteiro.

Quando importados, campos e parâmetros de transportam informações associa seu tipo original na ComAliasNameAttribute. O processo de conversão se aplica ComAliasNameAttribute para associar um campo, parâmetro ou valor de retorno com o nome da biblioteca de tipos e o tipo de biblioteca que foi usado como um alias.

A representação de biblioteca de tipo seguinte mostra que o cl parâmetro é digitado como um BUTTON_COLOR, que é um alias para um inteiro.

Representação de biblioteca de tipo

library MyLib {
    typedef [public] int BUTTON_COLOR;

    interface ISee {
        HResult SetColor([in] BUTTON_COLOR cl);
        HResult GetColor([out, retval] BUTTON_COLOR *cl);
    };
   
    coclass See {
        [default] interface ISee
    };
};

Os tipos convertidos aparecem como segue:

public interface ISee {
    void SetColor([ComAliasName("MyLib.BUTTON_COLOR")]] int cl);
    [return: ComAliasName("MyLib.BUTTON_COLOR")] int GetColor();
};

public class See {
    public void SetColor([ComAliasName("MyLib.BUTTON_COLOR")]] int cl);
    [return: ComAliasName("MyLib.BUTTON_COLOR")] int GetColor();
};

Observe que o tipo real BUTTON_COLOR não está definido em metadados resultante. Em vez disso, os parâmetros são digitados como BUTTON_COLOR na biblioteca de tipos são digitados como o tipo subjacente, inte são atribuídos com o ComAliasNameAttribute. O processo de conversão também se aplica o atributo argumentos de métodos de classe.