Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Clase FlagsAttribute

 

Publicado: octubre de 2016

Indica que una enumeración se puede tratar como un campo de bits, es decir, un conjunto de marcas.

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

System.Object
  System.Attribute
    System.FlagsAttribute

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

NombreDescripción
System_CAPS_pubmethodFlagsAttribute()

Inicializa una nueva instancia de la clase FlagsAttribute.

NombreDescripción
System_CAPS_pubpropertyTypeId

Cuando se implementa en una clase derivada, obtiene un identificador único para este Attribute.(Heredado de Attribute).

NombreDescripción
System_CAPS_pubmethodEquals(Object)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Devuelve un valor que indica si esta instancia equivale al objeto especificado. (Heredado de Attribute).

System_CAPS_protmethodFinalize()

Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de ser reclamado por el recolector de basura. (Heredado de Object).

System_CAPS_pubmethodGetHashCode()

Devuelve el código hash de esta instancia.(Heredado de Attribute).

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object).

System_CAPS_pubmethodIsDefaultAttribute()

Si se reemplaza en una clase derivada, indica si el valor de esta instancia es el valor predeterminado de la clase derivada.(Heredado de Attribute).

System_CAPS_pubmethodMatch(Object)

Cuando se invalida en una clase derivada, devuelve un valor que indica si esta instancia es igual al objeto especificado. (Heredado de Attribute).

System_CAPS_protmethodMemberwiseClone()

Crea una copia superficial del Object actual.(Heredado de Object).

System_CAPS_pubmethodToString()

Devuelve una cadena que representa al objeto actual. (Heredado de Object).

NombreDescripción
System_CAPS_pubinterfaceSystem_CAPS_privmethod_Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Asigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío.(Heredado de Attribute).

System_CAPS_pubinterfaceSystem_CAPS_privmethod_Attribute.GetTypeInfo(UInt32, UInt32, IntPtr)

Obtiene la información del tipo de un objeto, que puede utilizarse para obtener la información del tipo de una interfaz. (Heredado de Attribute).

System_CAPS_pubinterfaceSystem_CAPS_privmethod_Attribute.GetTypeInfoCount(UInt32)

Recupera el número de interfaces de tipo de información que suministra un objeto (0 ó 1)

(Heredado de Attribute).

System_CAPS_pubinterfaceSystem_CAPS_privmethod_Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Proporciona acceso a las propiedades y los métodos expuestos por un objeto.(Heredado de Attribute).

Campos de bits se utilizan normalmente para listas de elementos que pueden producirse en combinaciones, mientras que las constantes de enumeración se utilizan generalmente para listas de elementos mutuamente excluyentes. Por lo tanto, los campos de bits están diseñados para combinarse con una operación OR bit a bit para generar valores sin nombre, mientras que las constantes enumeradas que no lo son. Idiomas varían en su uso de campos de bits en comparación con las constantes de enumeración.

AttributeUsageAttributese aplica a esta clase y sus Inherited propiedad especifica false. Este atributo solo puede aplicarse a las enumeraciones.

  • Use la FlagsAttribute atributos personalizados para una enumeración solo si una operación bit a bit (AND, OR exclusivo o) se pueden realizar en un valor numérico.

  • Definir constantes de enumeración en potencias de dos, es decir, 1, 2, 4, 8 y así sucesivamente. Esto significa que las marcas individuales en constantes de enumeración combinadas no se superpongan.

  • Considere la creación de una constante enumerada para las combinaciones de indicadores utilizadas frecuentemente. Por ejemplo, si tiene una enumeración que se usa para las operaciones de E/S de archivo que contiene las constantes enumeradas Read = 1 y Write = 2, considere la posibilidad de crear la constante enumerada ReadWrite = Read OR Write, que combina la Read y Write marcas. Además, la operación de OR bit a bit usada para combinar los indicadores se pueden considerar un concepto avanzado en algunas circunstancias que no debería ser necesario para tareas sencillas.

  • Tenga cuidado si define un número negativo como constante enumerada del marcador porque muchas de las posiciones indicador pueden establecerse en 1, lo que podría hacer que el código confuso y le animamos a errores de codificación.

  • Una manera cómoda para comprobar si se establece un indicador en un valor numérico es realizar un bit a bit y operación entre el valor numérico y la constante enumerada de marca, que establece todos los bits del valor numérico en cero que no se corresponden con la marca, a continuación, pruebe si el resultado de esa operación es igual a la constante enumerada del indicador.

  • Use None como el nombre de la marca enumerada constante cuyo valor es cero. No se puede utilizar el None constante enumerada en una operación AND bit a bit para probar un indicador porque el resultado siempre es cero. Sin embargo, puede realizar una operación lógica, no una comparación bit a bit, entre el valor numérico y el None constante enumerada para determinar si se establecen los bits del valor numérico.

    Si crea un valor de enumeración en lugar de una enumeración de marcas, merece la pena seguir para crear un None constante enumerada. La razón es que, de forma predeterminada, la memoria utilizada para la enumeración se inicializa en cero por common language runtime. Por lo tanto, si no se define una constante cuyo valor es cero, la enumeración contendrá un valor no válido cuando se crea.

    Si hay un caso predeterminado obvio que la aplicación necesita para representar, considere el uso de una constante enumerada cuyo valor sea cero para representar el valor predeterminado. Si no hay ningún caso predeterminado, considere la posibilidad de usar una constante enumerada cuyo valor sea cero que significa que el caso de que no está representado por cualquiera de las demás constantes enumeradas.

  • No se define un valor de enumeración únicamente para reflejar el estado de la propia enumeración. Por ejemplo, no defina una constante enumerada que simplemente marca 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 comprobación de intervalo para la constante enumerada primera y última si todos los valores dentro del intervalo son válidos.

  • No especifique las constantes enumeradas que se han reservado para uso futuro.

  • Cuando se define un método o propiedad que toma una constante enumerada como un valor, considere la posibilidad de validar el valor. La razón es que puede convertir un valor numérico para el tipo de enumeración incluso si dicho valor numérico no está definido en la enumeración.

En el ejemplo siguiente se muestra el uso de la FlagsAttribute de atributo y se muestra el efecto en el ToString método de utilizar FlagsAttribute en un Enum declaración.

using System;

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

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

   static void Main( )
   {
      // Display all possible combinations of values.
      Console.WriteLine( 
           "All possible combinations of values without FlagsAttribute:");
      for(int val = 0; val <= 16; val++ )
         Console.WriteLine( "{0,3} - {1:G}", val, (SingleHue)val);

      // Display all combinations of values, and invalid values.
      Console.WriteLine( 
           "\nAll possible combinations of values with FlagsAttribute:");
      for( int val = 0; val <= 16; val++ )
         Console.WriteLine( "{0,3} - {1:G}", val, (MultiHue)val);
   } 
} 
// The example displays the following output:
//       All possible combinations of values without FlagsAttribute:
//         0 - None
//         1 - Black
//         2 - Red
//         3 - 3
//         4 - Green
//         5 - 5
//         6 - 6
//         7 - 7
//         8 - Blue
//         9 - 9
//        10 - 10
//        11 - 11
//        12 - 12
//        13 - 13
//        14 - 14
//        15 - 15
//        16 - 16
//       
//       All possible combinations of values with FlagsAttribute:
//         0 - None
//         1 - Black
//         2 - Red
//         3 - Black, Red
//         4 - Green
//         5 - Black, Green
//         6 - Red, Green
//         7 - Black, Red, Green
//         8 - Blue
//         9 - Black, Blue
//        10 - Red, Blue
//        11 - Black, Red, Blue
//        12 - Green, Blue
//        13 - Black, Green, Blue
//        14 - Red, Green, Blue
//        15 - Black, Red, Green, Blue
//        16 - 16

El siguiente ejemplo define dos enumeraciones relacionadas con el color, SingleHue y MultiHue. El segundo tiene la FlagsAttribute atributo; no es el primero. En el ejemplo se muestra la diferencia de comportamiento cuando un intervalo de enteros, incluidos los enteros que no representen valores subyacentes del tipo de enumeración, se convierte en el tipo de enumeración y sus representaciones de cadena que se muestra. Por ejemplo, tenga en cuenta que 3 no se puede representar como un SingleHue valor porque 3 no es el valor subyacente de cualquier SingleHue miembro, mientras que la FlagsAttribute atributo hace posible representar 3 como un MultiHue valo Black, Red.

using System;

[FlagsAttribute] public enum PhoneService
{
   None = 0,
   LandLine = 1,
   Cell = 2,
   Fax = 4,
   Internet = 8,
   Other = 16
}

public class Example
{
   public static void Main()
   {
      // Define three variables representing the types of phone service
      // in three households.
      var household1 = PhoneService.LandLine | PhoneService.Cell |
                       PhoneService.Internet;
      var household2 = PhoneService.None;
      var household3 = PhoneService.Cell | PhoneService.Internet;

      // Store the variables in an array for ease of access.
      PhoneService[] households = { household1, household2, household3 };

      // Which households have no service?
      for (int ctr = 0; ctr < households.Length; ctr++)
         Console.WriteLine("Household {0} has phone service: {1}",
                           ctr + 1,
                           households[ctr] == PhoneService.None ?
                               "No" : "Yes");
      Console.WriteLine();

      // Which households have cell phone service?
      for (int ctr = 0; ctr < households.Length; ctr++)
         Console.WriteLine("Household {0} has cell phone service: {1}",
                           ctr + 1,
                           (households[ctr] & PhoneService.Cell) == PhoneService.Cell ?
                              "Yes" : "No");
      Console.WriteLine();

      // Which households have cell phones and land lines?
      var cellAndLand = PhoneService.Cell | PhoneService.LandLine;
      for (int ctr = 0; ctr < households.Length; ctr++)
         Console.WriteLine("Household {0} has cell and land line service: {1}",
                           ctr + 1,
                           (households[ctr] & cellAndLand) == cellAndLand ?
                              "Yes" : "No");
      Console.WriteLine();

      // List all types of service of each household?//
      for (int ctr = 0; ctr < households.Length; ctr++)
         Console.WriteLine("Household {0} has: {1:G}",
                           ctr + 1, households[ctr]);
      Console.WriteLine();
   }
}
// The example displays the following output:
//    Household 1 has phone service: Yes
//    Household 2 has phone service: No
//    Household 3 has phone service: Yes
//
//    Household 1 has cell phone service: Yes
//    Household 2 has cell phone service: No
//    Household 3 has cell phone service: Yes
//
//    Household 1 has cell and land line service: Yes
//    Household 2 has cell and land line service: No
//    Household 3 has cell and land line service: No
//
//    Household 1 has: LandLine, Cell, Internet
//    Household 2 has: None
//    Household 3 has: Cell, Internet

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1

Cualquier miembro ( Compartido en Visual Basic) estático público de este tipo es seguro para subprocesos. No se garantiza que los miembros de instancia sean seguros para subprocesos.

Volver al principio
Mostrar: