tipos - ¿Es posible compartir una declaración de enumeración entre C#y C++ no administrado?
variables c# (5)
¿Hay una manera de compartir una definición de enumeración entre C ++ nativo (no administrado) y C # (administrado)?
Tengo la siguiente enumeración utilizada en código completamente no administrado:
enum MyEnum { myVal1, myVal2 };
Nuestra aplicación a veces utiliza un componente gestionado. Ese componente de C # obtiene los valores de elemento de enumeración como ints a través de una dll de interoperabilidad de C ++ administrada (de la dll nativa). (La dll de interoperabilidad solo se carga si se necesita el componente C #). El componente C # ha duplicado la definición de enumeración:
public enum MyEnum { myVal1, myVal2 };
¿Hay alguna forma de eliminar la duplicación sin convertir la dll nativa de C ++ en una dll administrada?
¡Gracias por compartir!
Jugué un poco y encontré una forma de tener múltiples enumeración y constantes declaraciones sin tener un montón de líneas adicionales :)
// 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
Recuerde nombrar su archivo * .cs
C ++ no administrado y C # viven en dos mundos diferentes, por lo que no hay forma de usar la misma enumeración, sin cambiar la DLL de c ++ por una administrada.
E incluso entonces, probablemente necesitaría la duplicación en la DLL de C ++ administrada.
Una enumeración de C ++ es muy parecida a una lista de constantes, mientras que una enumeración de C # hereda la clase Enum, y por lo tanto proporciona bastantes "trucos". Como pueden ver, son muy diferentes.
Si no importa si la DLL nativa de C ++ es nativa o administrada, la convertiría en una administrada y envolvería las llamadas nativas dentro de una Capa de C ++ administrada.
De esa manera, puede tener la duplicación de enumeración dentro de la DLL de C ++, y también puede deshacerse de todas las interoperaciones al mismo tiempo :-)
He tenido el mismo problema en el pasado y lo resolví usando definiciones de preprocesador.
En su código no administrado, dentro de un encabezado que también puede incluir su envoltorio administrado, coloque sus elementos de enumeración en #define.
Luego, en sus definiciones de enumeración administradas y no administradas, use la misma # definición para ambos usos.
El movimiento de las enumeraciones entre el mundo administrado y no administrado parece un poco desagradable (básicamente se necesita un elenco), pero para su interlocutor en el mundo no administrado, se verá y se sentirá bien.
Buena suerte,
Puede exponer la biblioteca de C # a COM y luego importar la biblioteca de tipos al código no administrado, de esta manera podrá usar la enumeración definida en la biblioteca de C # en la biblioteca no administrada.
Puede usar un solo archivo .cs y compartirlo entre ambos proyectos. #include
en C ++ en un archivo .cs no debería ser un problema.
Este sería un ejemplo de archivo .cs:
#if !__LINE__
namespace MyNamespace
{
public
#endif
// shared enum for both C, C++ and C#
enum MyEnum { myVal1, myVal2 };
#if !__LINE__
}
#endif
Si desea múltiples enumeraciones en un archivo, puede hacer esto (aunque tiene que definir temporalmente el público como 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