Est-il possible de partager une déclaration enum entre C # et C ++ non géré?

Question

Y at-il un moyen de partager une définition enum entre natif (non géré) C ++ et (géré) C #?

Je le ENUM suivant utilisé dans le code administrable:

enum MyEnum { myVal1, myVal2 };

Notre application utilise parfois un composant géré. Ce composant C # obtient les valeurs des éléments ENUM ints via une dll Interop géré C ++ (de la dll native). (Le dll Interop que des charges si le composant C # est nécessaire.) Le composant C # a dupliqué la définition enum:

public enum MyEnum { myVal1, myVal2 };

Y at-il un moyen d'éliminer la duplication sans tourner le C ++ natif dll dans un dll géré?

Answer 1

Vous pouvez utiliser un seul fichier .cs et le partager entre les deux projets. #include en C ++ sur un fichier .cs devrait y avoir aucun problème.

Ce serait un exemple de fichier .cs:

#if !__LINE__    
namespace MyNamespace
{
    public 
#endif

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

#if !__LINE__
}
#endif

Si vous voulez plusieurs énumérations dans un fichier, vous pouvez le faire (bien que vous devez définir temporairement du public à rien pour 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

Merci pour le partage!

J'ai joué un peu et trouvé un moyen d'avoir plusieurs ENUM et déclarations constantes sans avoir des tonnes de lignes supplémentaires:)

// 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

Rappelez-vous de nommer votre fichier * .cs

Answer 3

Vous pouvez exposer la bibliothèque C # COM puis importer la bibliothèque de type dans le code non géré - cette façon, vous serez en mesure d'utiliser le ENUM défini dans la bibliothèque C # dans la bibliothèque non géré

.

Answer 4

Unmanaged C ++ et C # vivent dans deux mondes différents, donc pas il n'y a pas moyen d'utiliser la même ENUM, sans changer le c ++ DLL dans un géré.

Et même alors, vous auriez probablement besoin de la duplication dans la DLL C ++ géré.

A C ++ ENUM est un peu comme une liste des constantes, alors qu'un C # ENUM hérite de la classe Enum, et fournit ainsi un tout à fait quelques "trucs". Donc, comme vous pouvez le voir, ils sont très différent.

Si elle n'a pas d'importance si la DLL C ++ natif est natif ou géré, je le transformer en une gestion et envelopper les appels natifs à l'intérieur d'une gestion C ++ couche.

De cette façon, vous pouvez avoir la duplication enum dans la DLL C ++, et vous pouvez vous débarrasser de tous les Interop en même temps: -)

Answer 5

J'ai eu le même problème dans le passé et résolu à l'aide de définitions de préprocesseur.

Dans votre code non géré, à l'intérieur d'un en-tête qui peut également être inclus par votre wrapper managé, placez vos objets de dénombrement en un #define.

Ensuite, dans votre énumération gérés et non gérés définitions, utilisez la même #define pour les deux usages.

Le mouvement des énumérations entre le monde géré et non géré semble un peu méchant (essentiellement un casting est nécessaire), mais à votre interlocuteur dans le monde non géré, il va regarder et se sentir bien.

Bonne chance,