subconjunto o subgrupo Enum en C#

Question

Tengo una enumeración existente con numerosos elementos.

también tengo código existente que hace ciertas cosas con esta enumeración.

Ahora me gustaría una forma de ver solo un subconjunto de miembros enum. Lo que estoy buscando es una forma de dividir mi enumeración en grupos. Necesito preservar el valor (int) de cada miembro y necesito preservar la capacidad de ver todos los miembros enum si es necesario.

Lo único que se me ocurre es crear una nueva enumeración para cada subenume que solo contenga los elementos que quiero usando el mismo nombre y valor.

Esto funciona, pero viola el principio de todo sin repetición.

No espero que nadie tenga una mejor alternativa, pero pensé que podría preguntar en caso de que alguien tuviera un truco para mostrarme.

Gracias, como siempre.

Answer 1

Al final, tuve que reescribir gran parte del código, pero el siguiente "truco" se deriva:

Me destrocé C# enumeraciones y use miembros estáticos en una clase regular. Esta clase se convirtió en singleton y se ingresa al inicio de la aplicación.

Los constructores de mis miembros estáticos pueden hacer referencia a otro miembro estático como "principal".

A continuación, mi método init utiliza la reflexión para ir a través de cada miembro estático y los indexa en función de varias propiedades. Estos índices se almacenan en hashtables que también son miembros de singleton.

por lo tanto me sale:

un objeto único, que:

• tiene miembros estáticos que pueda accederse fácilmente durante el tiempo de diseño.
• se puede utilizar durante el tiempo de ejecución para buscar ciertos miembros estáticos (basado en "grupo" y otras propiedades).

Mi método init hace una buena cantidad de validación. Si se generan miembros estáticos no válidos (como duplicados), se obtiene un error en tiempo de ejecución al iniciar la aplicación.

Obviamente, una bastante grande truco, pero estoy muy contento con él.

Answer 2

Puede definir los valores usando una enumeración pero luego hacer referencia a ellos a través de constantes en clases estáticas para que los desarrolladores no se vean afectados por la enumeración grande. Usted podría tener:

enum MySuperEnumGroup 
{ 
    Group1Item1, 
    Group1Item2, 
    Group1Item3, 

    Group2Item1, 
    Group2Item2, 
    Group2Item3, 

    Group3Item1, 
    Group3Item2, 
    Group3Item3, 
} 

static class MySuperEnumGroup_Group1 
{ 
    public const MySuperEnumGroup Item1 = MySuperEnumGroup.Group1Item1; 
    public const MySuperEnumGroup Item2 = MySuperEnumGroup.Group1Item2; 
    public const MySuperEnumGroup Item3 = MySuperEnumGroup.Group1Item3; 
} 

static class MySuperEnumGroup_Group2 
{ 
    public const MySuperEnumGroup Item1 = MySuperEnumGroup.Group2Item1; 
    public const MySuperEnumGroup Item2 = MySuperEnumGroup.Group2Item2; 
    public const MySuperEnumGroup Item3 = MySuperEnumGroup.Group2Item3; 
} 

//etc. 

Answer 3

Esto podría ayudar: Fake Enums in C#

Answer 4

Me gustaría ir con esto (que funciona en VB.NET al menos)

enum MySuperEnumGroup 
{ 
    Group1Item1, 
    Group1Item2, 
    Group1Item3, 

    Group2Item1, 
    Group2Item2, 
    Group2Item3, 

    Group3Item1, 
    Group3Item2, 
    Group3Item3, 
} 

enum MySubEnumGroup 
{ 
Group2Item1 = MySuperEnumGroup.Group2Item1 
Group3Item1 = MySuperEnumGroup.Group3Item1 
Group3Item3 = MySuperEnumGroup.Group3Item3 
} 

Después, realice algún tipo de CType cuando es necesario.

Answer 5

Si las enumeraciones no tienen valores explícitos, les dan uno y usan banderas para definir los "grupos":

[Flags] 
enum MySuperEnumGroup 
{ 
    Group1 = 1 << 0, 
    Group2 = 1 << 1, 
    Group3 = 1 << 2, 

    Group1Item1 = 1 << 10 | Group1, 
    Group1Item2 = 1 << 11 | Group1, 
    Group1Item3 = 1 << 12 | Group1, 

    Group2Item1 = 1 << 13 | Group2, 
    Group2Item2 = 1 << 14 | Group2, 
    Group2Item3 = 1 << 15 | Group2, 

    Group3Item1 = 1 << 16 | Group3, 
    Group3Item2 = 1 << 17 | Group3, 
    Group3Item3 = 1 << 18 | Group3, 
} 

continuación, puede utilizar Enum.GetValues y HasFlag para obtener los valores para un grupo determinado" ":

var group1 = Enum.GetValues(typeof(MySuperEnumGroup)) 
       .Cast<MySuperEnumGroup>() 
       .Where(value => value.HasFlag(MySuperEnumGroup.Group1)) 
       .ToArray();