switch - return enum c#

Enums-Todas las opciones de valor

Question

¿Hay una manera de agregar una opción "Todos los valores" a una enumeración sin tener que cambiar su valor cada vez que se agrega un nuevo valor a la enumeración?

[Flags] 
public enum SomeEnum
{
    SomeValue =  1,
    SomeValue2 = 1 << 1,
    SomeValue3 = 1 << 2,
    SomeValue4 = 1 << 3,
    All = ?
}

Actualizar:

Terminé heredando de long y usando la opción long.MaxValue for All.

Answer 1

Dado que debe definir el valor vacío en una enumeración de indicadores como None = 0 la forma más sencilla de definir el valor All es simplemente invirtiendo todos los bits en None .

[Flags]
enum MyEnum
{
   None = 0,
   A = 1
   B = 2,
   C = 4,
   ...
   All = ~None
}

Tenga en cuenta que ~0 lugar de ~None no funcionará para los tipos de respaldo sin firma, ya que es -1, que no es un valor válido para unsigned

Edición: la respuesta se modificó para utilizar una Ninguna invertida en lugar de una constante explícita como 0x7FFFFFFF o ~ 0, ya que esto también funciona para los no firmados

Answer 2

Debería ser así:

[Flags] 
public enum SomeEnum
{
    SomeValue =  1,
    SomeValue2 = 1 << 1,
    SomeValue3 = 1 << 2,
    SomeValue4 = 1 << 3,
    All = SomeValue | SomeValue2 | SomeValue3 | SomeValue4
}

Answer 3

Esto es posible si está de acuerdo con un campo de static readonly en un tipo separado, en lugar de como un campo de enumeración const :

[Flags] 
public enum SomeEnum
{
    None       = 0,
    SomeValue  = 1,
    SomeValue2 = 1 << 1,
    SomeValue3 = 1 << 2,
    SomeValue4 = 1 << 3,
}

public static class SomeEnumUtility {

    private static readonly SomeEnum[] _someEnumValues = (SomeEnum[])Enum.GetValues( typeof(SomeEnum) );
    public static readonly SomeEnum SomeEnum_All = GetSomeEnumAll();

    // Unfortunately C# does not support "enum generics" otherwise this could be a generic method for any Enum type
    private static SomeEnum GetSomeEnumAll() {

        SomeEnum value = SomeEnum.None; // or `(SomeEnum)0;` if None is undefined.
        foreach(SomeEnum option in _someEnumValues) {
            value |= option;
        }
        return value;
    }
}

Luego, puede obtener SomeEnumUtility.SomeEnum_All . Como es una static readonly el cálculo solo se realiza una vez, de forma segura para subprocesos.

Como escribí en el comentario de código, es desafortunado que C # no sea compatible con enum genéricos, de lo contrario podría hacer esto:

    private static TEnum GetEnumAllFlags<TEnum>() where TEnum : enum {

        TEnum[] allValues = Enum.GetValues<TEnum>();

        TEnum value = (TEnum)0;
        foreach(TEnum option in allValues) {
            value |= option;
        }
        return value;
    }

Oh bien :(

Answer 4

La idea es utilizar el comportamiento de la enumeración para calcular el último valor.

Agregar el último campo después de todos los valores de enumeración ''reales''.

El campo Agregar todo es igual a (Last << 1) - 3 .

[Flags]
public enum SomeEnum
{
    SomeValue =  1,
    SomeValue2 = 1 << 1,
    SomeValue3 = 1 << 2,
    SomeValue4 = 1 << 3,

    // Do not add values after this
    Last,
    All = (Last << 1) - 3,
}

Lo respondí en: Cómo usar Enum con opciones adicionales (Todos, Ninguno)

Puedes consultar mi blog en Enum Trick para obtener más información e ideas.

Answer 5

No, no se construye nada, lo que hará que dicha opción de All se actualice automáticamente cuando cambie Enum.

Es posible que desee tener un valor especial (valor de monitor) que signifique All (digamos -1), incluso si no es la suma a nivel de bits de todas las opciones.

Una alternativa es usar un valor que tenga todos los bits activados:

All = 0xFFFFFFFF

Answer 6

Puedes usar un pequeño truco

(SomeEnum)( (1 << ( Enum.GetValues( typeof(SomeEnum) ).Length ) ) -1 )

Si agregó un Nombre de Enumeración ''Ninguno'' con valor = 0 ( None = 0, ) entonces necesita poner un ''-1'' después de la Longitud.

Answer 7

Una enumeración se puede hacer de muchos tipos enteros de longitud diferente (short, int, long). Esto hace que la solución #FFFFFFFF inapropiada (como se señala en el comentario de @MarcGravell).

Se puede hacer una enumeración de tipos sin firmar (uint para la entidad). Esto hace que la solución -1 inapropiada.

Mi mejor apuesta es, libre de mantenimiento:

All = ~0