É possível compartilhar uma declaração de enumeração entre C# e C ++ não gerenciado?

Question

Existe uma maneira de compartilhar uma definição de enum entre C ++ nativo (não gerenciado) e (gerenciado) C#?

Eu tenho o seguinte enum usado em código completamente não gerenciado:

enum MyEnum { myVal1, myVal2 };

Nosso aplicativo às vezes usa um componente gerenciado. Esse componente C# obtém os valores do item enum como INTs por meio de uma DLL de interop C ++ gerenciada (da DLL nativa). (A DLL de interop apenas carrega se o componente C# for necessário.) O componente C# duplicou a definição de enum:

public enum MyEnum { myVal1, myVal2 };

Existe uma maneira de eliminar a duplicação sem transformar a DLL C ++ nativa em uma DLL gerenciada?

Answer 1

Você pode usar um único arquivo .cs e compartilhá -lo entre os dois projetos. #include Em C ++ em um arquivo .cs não deve ter problema.

Este seria um exemplo de arquivo .cs:

#if !__LINE__    
namespace MyNamespace
{
    public 
#endif

// shared enum for both C, C++ and C#
enum MyEnum { myVal1, myVal2 };

#if !__LINE__
}
#endif

Se você deseja várias enumes em um arquivo, você pode fazer isso (embora precise definir temporariamente o público para não ser nada para C / C ++):

#if __LINE__
#define public
#else
namespace MyNamespace
{
#endif

    public enum MyEnum { MyEnumValue1, MyEnumValue2 };
    public enum MyEnum2 { MyEnum2Value1, MyEnum2Value2 };
    public enum MyEnum3 { MyEnum3Value1, MyEnum3Value2 };

#if __LINE__
#undef public
#else
}
#endif

Answer 2

Obrigado por compartilhar!

Eu brinquei um pouco e encontrei uma maneira de ter várias declarações constantes sem ter toneladas de linhas extras :)

// This is a valid C, C++ and C# file :)
#if __LINE__
#define public
#else
namespace MyCSharpNamespace{
#endif

    public enum MyConstant { MaxStr = 256 };
    public enum MyEnum1{ MyEnum1_A, MyEnum1_B };
    public enum MyEnum2{ MyEnum2_A, MyEnum2_B };

#if __LINE__
#undef public
#else
}
#endif

Lembre -se de nomear seu arquivo *.cs

Answer 3

Você pode expor a biblioteca C# para e importar a biblioteca de tipos para o código não gerenciado - dessa maneira você poderá usar a enumeração definida na biblioteca C# na biblioteca não gerenciada.

Answer 4

C ++ e C# não gerenciados vivem em dois mundos diferentes, então não há como usar a mesma enumeração, sem alterar a DLL C ++ em uma gerenciada.

E mesmo assim, você provavelmente precisaria da duplicação na DLL C ++ gerenciada.

Um enum C ++ é muito parecido com uma lista de constantes, enquanto um enum C# herda a classe Enum e, portanto, fornece alguns "truques". Então, como você pode ver, eles são muito diferente.

Se não importa se a DLL C ++ nativa é nativa ou gerenciada, eu a transformaria em uma gerenciada e embrulhava as chamadas nativas dentro de uma camada C ++ gerenciada.

Dessa forma, você pode ter a duplicação da enum dentro da DLL C ++, e também pode se livrar de toda a interoper ao mesmo tempo :-)

Answer 5

Eu tive o mesmo problema no passado e o resolvi usando definições de pré -processador.

No seu código não gerenciado, dentro de um cabeçalho que também pode ser incluído pelo seu invólucro gerenciado, coloque seus itens de enumeração em um #Define.

Então, em suas definições de enumeração gerenciada e não gerenciada, use o mesmo #Define para ambos os usos.

O movimento das enumerações entre o mundo gerenciado e não gerenciado parece um pouco desagradável (basicamente é necessário um elenco), mas para o seu chamador no mundo não gerenciado, parecerá bem.

Boa sorte,