¿Le resultó útil esta página?
Sus comentarios sobre este contenido son muy importantes. Háganos saber su opinión.
¿Tiene comentarios adicionales?
Caracteres restantes: 1500
Exportar (0) Imprimir
Expandir todo

FlagsAttribute (Clase)

Actualización: noviembre 2007

Indica que una enumeración puede considerarse como un campo de bits, es decir, un conjunto de indicadores.

Espacio de nombres:  System
Ensamblado:  mscorlib (en mscorlib.dll)

[SerializableAttribute]
[AttributeUsageAttribute(AttributeTargets.Enum, Inherited = false)]
[ComVisibleAttribute(true)]
public class FlagsAttribute : Attribute
/** @attribute SerializableAttribute */ 
/** @attribute AttributeUsageAttribute(AttributeTargets.Enum, Inherited = false) */
/** @attribute ComVisibleAttribute(true) */
public class FlagsAttribute extends Attribute
public class FlagsAttribute extends Attribute

Normalmente, los campos de bits se utilizan para listas de elementos que pueden aparecer combinados, mientras que las constantes enumeradas se utilizan, por lo general, para listas de elementos que se excluyen mutuamente. Por lo tanto, a diferencia de las constantes enumeradas, los campos de bits están diseñados para combinarse mediante operaciones OR bit a bit con objeto de generar valores sin nombre. El uso de los campos de bits frente a las constantes enumeradas varía en función del lenguaje.

Atributos de FlagsAttribute

AttributeUsageAttribute se aplica a esta clase y su propiedad Inherited especifica false. Este atributo sólo puede aplicarse a las enumeraciones.

Instrucciones para FlagsAttribute y Enum

  • Sólo se debe utilizar el atributo personalizado FlagsAttribute para una enumeración si se va a llevar a cabo una operación bit a bit (AND, OR, EXCLUSIVE OR) con un valor numérico.

  • Las constantes de enumeración se deben definir en potencias de dos, es decir, 1, 2, 4, 8 y así sucesivamente. Esto consigue que en las constantes de enumeración combinadas no se superpongan los indicadores individuales.

  • Hay que plantearse la creación de una constante enumerada para las combinaciones de indicadores utilizadas frecuentemente. Por ejemplo, si una enumeración utilizada para las operaciones de E/S con archivos contiene las constantes enumeradas Read = 1 y Write = 2, considere la creación de la constante enumerada ReadWrite = Read OR Write, que combina los indicadores Read y Write. Además, la operación OR bit a bit usada para combinar los indicadores puede que en algunas circunstancias sea un concepto avanzado que no resulte necesario para las tareas sencillas.

  • Se debe tener cuidado al definir un número negativo como constante enumerada del indicador, puesto que quizás se establezcan muchas de las posiciones del indicador en 1, provocando que el código resulte confuso y que los errores de codificación se produzcan más fácilmente.

  • Una práctica manera de probar si un indicador se ha establecido en un valor numérico es llevar a cabo una operación AND bit a bit entre el valor numérico y la constante enumerada del indicador, que establece en cero todos los bits del valor numérico que no correspondan al indicador, y probar a continuación si el resultado de esa operación es igual a la constante enumerada del indicador.

  • Utilice None como el nombre de la constante enumerada del indicador cuyo valor es cero. No se puede utilizar la constante enumerada None en una operación AND bit a bit para probar un indicador puesto que el resultado siempre es cero. No obstante, se puede llevar a cabo una comparación lógica, no bit a bit, entre el valor numérico y la constante enumerada None para determinar si están establecidos algunos bits del valor numérico.

    Aunque se cree una enumeración de valor en lugar de una enumeración de indicadores, sigue mereciendo la pena crear una constante enumerada None. El motivo es que, de forma predeterminada, Common Language Runtime inicializa a cero la memoria utilizada para la enumeración. Por consiguiente, si no se define una constante cuyo valor sea cero, la enumeración contendrá un valor ilegal al crearla.

    Si existe un caso predeterminado obvio que la aplicación deba representar, considere el uso de una constante enumerada cuyo valor sea cero para que represente al valor predeterminado. Si no hay un caso predeterminado, plantéese el uso de una constante enumerada cuyo valor sea cero y que suponga el caso no representado por ninguna de las demás constantes enumeradas.

  • No se debe definir un valor de enumeración únicamente para reflejar el estado de la propia enumeración. Por ejemplo, no defina una constante enumerada que meramente marque el final de la enumeración. Si necesita determinar el último valor de la enumeración, compruebe ese valor explícitamente. Además, puede realizar una verificación de intervalo para la primera y la última de las constantes enumeradas si todos los valores del intervalo son válidos.

  • No hay que especificar constantes enumeradas que estén reservadas para un uso futuro.

  • Cuando se define un método o propiedad que toma una constante enumerada como un valor, se debe considerar la validación del valor. El motivo es que se puede convertir un valor numérico en el tipo de enumeración incluso en el caso de que dicho valor numérico no esté definido en la enumeración.

En el siguiente ejemplo de código se muestra cómo usar el atributo FlagsAttribute y se muestra el efecto sobre el método ToString cuando se usa el atributo FlagsAttribute en una declaración Enum.

// Example of the FlagsAttribute attribute.
using System;

class FlagsAttributeDemo
{
    // Define an Enum without FlagsAttribute.
    enum SingleHue : short
    {
        Black = 0,
        Red = 1,
        Green = 2,
        Blue = 4
    };

    // Define an Enum with FlagsAttribute.
    [FlagsAttribute] 
    enum MultiHue : short
    {
        Black = 0,
        Red = 1,
        Green = 2,
        Blue = 4
    };

    static void Main( )
    {
        Console.WriteLine( 
            "This example of the FlagsAttribute attribute \n" +
            "generates the following output." );
        Console.WriteLine( 
            "\nAll possible combinations of values of an \n" +
            "Enum without FlagsAttribute:\n" );

        // Display all possible combinations of values.
        for( int val = 0; val <= 8; val++ )
            Console.WriteLine( "{0,3} - {1}", 
                val, ( (SingleHue)val ).ToString( ) );

        Console.WriteLine( 
            "\nAll possible combinations of values of an \n" +
            "Enum with FlagsAttribute:\n" );

        // Display all possible combinations of values.
        // Also display an invalid value.
        for( int val = 0; val <= 8; val++ )
            Console.WriteLine( "{0,3} - {1}", 
                val, ( (MultiHue)val ).ToString( ) );
    } 
} 

/*
This example of the FlagsAttribute attribute
generates the following output.

All possible combinations of values of an
Enum without FlagsAttribute:

  0 - Black
  1 - Red
  2 - Green
  3 - 3
  4 - Blue
  5 - 5
  6 - 6
  7 - 7
  8 - 8

All possible combinations of values of an
Enum with FlagsAttribute:

  0 - Black
  1 - Red
  2 - Green
  3 - Red, Green
  4 - Blue
  5 - Red, Blue
  6 - Green, Blue
  7 - Red, Green, Blue
  8 - 8
*/


Todos los miembros static (Shared en Visual Basic) públicos de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile para Smartphone, Windows Mobile para Pocket PC, Xbox 360

.NET Framework y .NET Compact Framework no admiten todas las versiones de cada plataforma. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

.NET Framework

Compatible con: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Compatible con: 3.5, 2.0, 1.0

XNA Framework

Compatible con: 2.0, 1.0

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft