c# - tipo - para que sirve int en programacion

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 enum miembros. 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 no repetición.

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

Gracias como siempre.

Answer 1

Esto podría ayudar: Enumeraciones falsas en C #

Answer 2

Podrías definir los valores usando una enumeración pero luego hacer referencia a ellos a través de constantes en clases estáticas para que tus desarrolladores no se vean afectados por la gran enumeración. Podrías 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

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

Destruí las enumeraciones C # y uso 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 un "padre".

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.

Así obtengo:

un objeto singleton que:

• tiene miembros estáticos a los que se puede acceder fácilmente durante el tiempo de diseño.
• se puede usar durante el tiempo de ejecución para buscar ciertos miembros estáticos (en función de "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 es un truco bastante grande, pero estoy bastante contento con él.

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
}

Luego, haga algún tipo de CType cuando lo necesite.

Answer 5

Si las enumeraciones no tienen valores explícitos, proporciónales una y use indicadores para definir las "agrupaciones":

[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,
}

Luego puede usar Enum.GetValues y HasFlag para obtener los valores para un "agrupamiento" dado:

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