Esclarecimento sobre como declarar corretamente interoperabilidade de interfaces

Question

Esta é apenas uma questão de como escrever o meu código para uma importação COM.

O meu entendimento da implementação das interfaces de interoperabilidade é que os principais critérios é que:

1. Todas as assinaturas de método deve corresponder de forma compatível
2. Os métodos devem aparecer exatamente na mesma ordem na interface .NET como eles fazem na interface não gerenciado
3. Quando os herda interface não gerenciada de outra interface não gerenciado, a implementação gerenciada deve primeiro declarar os membros de interface de nível de base, começando com o mais básico interface.

A minha pergunta é; o que eu faço, no que diz respeito à ordem em que os membros aparecem, se a interface Estou importando é herdada de outra interface e substituições / oculta um ou mais dos membros na interface de base? Onde é que a declaração de membro interface de ir? Em primeiro lugar, onde a interface base declarou isso? Ou removido de sua posição original e colocado onde a interface derivada declara ele?

[uuid(31d1c294-1dd2-11b2-be3a-c79230dca297)]
interface BaseComInterface
{
    void method1();
    void method2();
    void method3();
}

[uuid(fab51c92-95c3-4468-b317-7de4d7588254)]
interface DerivedComInterface : BaseComInterface
{
    void method1();
    void method4();
    void method5();
}

Agora, para o código C #:

[Guid("fab51c92-95c3-4468-b317-7de4d7588254"), ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IDerivedComInterface
{
    void method1(); // do I remove this one?
    void method2();
    void method3();
    void method1(); // or this one?
    void method4();
    void method5();
}

Answer 1

Você tem um exemplo de alguém realmente fazendo isso? Embora seja perfeitamente legal no COM ter o mesmo nome para um método em uma interface e na outra interface derivada dela, ele faz o trabalho com os todos os ambientes de desenvolvimento de interface difícil ou impossível em praticamente derivados. Isso inclui a implementação, bem como chamar qualquer COM objetos com base na interface.

Não existe tal coisa como substituir ou se escondendo em uma interface COM. A interface COM é apenas um contrato para como interface binária de um objeto será colocado para fora na memória, os nomes dos métodos na definição de interface são sem sentido a não ser para ferramentas. No seu caso o BaseComInterface promete uma 'vtable' com seis métodos os três primeiro jogo das assinaturas dos métodos IUnknown e os próximos três match as assinaturas dos três métodos que você deu, tudo em ordem correta. Nas outras promessas DerivedComInterface mão de um 'vtable' que inclui nove métodos, novamente as três primeiras assinaturas combinar os métodos IUnknown, o próximo três match as assinaturas dos métodos BaseComInterface e os últimos três jogo, os três métodos únicos para DerivedComInterface. Os nomes destes métodos são imateriais, exceto aos seus IDE, ferramentas e compilador que precisam os nomes para encontrar os ponteiros 'vtable'.

Então, basicamente, em C #, bem como C, C ++ e algumas outras línguas, a fim de implementar DerivedComInterface um dos nomes de métodos que precisam ser decorada para distingui-lo do slot de 'vtable' do outro.

Para responder à sua pergunta - você deve remover nenhum método dado que ambos são obrigados a estar lá para cumprir o contrato COM:

[Guid("fab51c92-95c3-4468-b317-7de4d7588254"), ComImport,  InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IDerivedComInterface
{
    void method1(); 
    void method2();
    void method3();
    void method1_2(); //Decorated to distinguish from base interface method.
    void method4();
    void method5();
}

Isto ignora o que aconteceria se essas interfaces derivada de IDispatch em vez de IUnknown, uma bagunça Eu não gostaria de entrar. Além disso, lembre-se que se o seu IDL realmente define os métodos como retornando vazio que você deve decorar seus métodos C # com o atributo PreserveSig.

Answer 2

Eu sugiro que você use explícitas implementações membro interface ao conflito evitar.