FlagsAttribute Class

Definition

Gibt an, dass eine Enumeration als Bitfeld, d. h. als Gruppe von Flags, behandelt werden kann. Indicates that an enumeration can be treated as a bit field; that is, a set of flags.

[System.AttributeUsage(System.AttributeTargets.Enum, Inherited=false)]
[System.Runtime.InteropServices.ComVisible(true)]
public class FlagsAttribute : Attribute
Vererbung
FlagsAttribute
Attribute

Beispiele

Das folgende Beispiel veranschaulicht die Verwendung von der FlagsAttribute Attribut, und zeigt die Auswirkungen auf die ToString Methode der Verwendung von FlagsAttribute auf eine Enum Deklaration.The following example illustrates the use of the FlagsAttribute attribute and shows the effect on the ToString method of using FlagsAttribute on an Enum declaration.

using namespace System;

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

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

int 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);
      
   Console::WriteLine(
        "\nAll possible combinations of values with FlagsAttribute:");
   
   // Display all combinations of values, and invalid values.
   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
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
Module Example
   ' Define an Enum without FlagsAttribute.
   Enum SingleHue As Short
      None = 0
      Black = 1
      Red = 2
      Green = 4
      Blue = 8
   End Enum

   ' Define an Enum with FlagsAttribute.
   <FlagsAttribute> 
   Enum MultiHue As Short
      None = 0
      Black = 1
      Red = 2
      Green = 4
      Blue = 8
   End Enum

   Sub Main()
      ' Display all possible combinations of values.
      Console.WriteLine(
           "All possible combinations of values without FlagsAttribute:")
      For val As Integer = 0 To 16
         Console.WriteLine("{0,3} - {1:G}", val, CType(val, SingleHue))
     Next 
     Console.WriteLine()
     
     ' Display all combinations of values, and invalid values.
     Console.WriteLine( 
          "All possible combinations of values with FlagsAttribute:")
     For val As Integer = 0 To 16
        Console.WriteLine( "{0,3} - {1:G}", val, CType(val, MultiHue))
     Next 
   End Sub 
End Module 
' 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

Das folgende Beispiel definiert zwei Enumerationen, die farbbezogene, SingleHue und MultiHue.The following example defines two color-related enumerations, SingleHue and MultiHue. Die zweite über die die FlagsAttribute -Attribut im ersten Fall ist dies nicht.The latter has the FlagsAttribute attribute; the former does not. Im Beispiel des unterschiedliche Verhalten bei der ein Bereich von ganzen Zahlen, einschließlich von ganzen Zahlen, die nicht der zugrunde liegenden Werte des Enumerationstyps, darstellen, in den Enumerationstyp und deren Zeichenfolgenrepräsentationen angezeigt umgewandelt werden.The example shows the difference in behavior when a range of integers, including integers that do not represent underlying values of the enumeration type, are cast to the enumeration type and their string representations displayed. Beachten Sie, dass es sich bei 3 dargestellt werden kann, wie z. B. eine SingleHue bewertet werden, da 3 nicht den zugrunde liegenden Wert eines beliebigen ist SingleHue Member, während der FlagsAttribute Attribut ermöglicht, die als 3 darstellen eine MultiHue Wert Black, Red.For example, note that 3 cannot be represented as a SingleHue value because 3 is not the underlying value of any SingleHue member, whereas the FlagsAttribute attribute makes it possible to represent 3 as a MultiHue value of Black, Red.

using namespace System;

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

void main()
{
   // Define three variables representing the types of phone service
   // in three households.
   PhoneService household1 = PhoneService::LandLine | PhoneService::Cell |
                             PhoneService::Internet;
   PhoneService household2 = PhoneService::None;
   PhoneService household3 = PhoneService::Cell | PhoneService::Internet;

   // Store the variables in an array for ease of access.
   array<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?
   PhoneService 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
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
<FlagsAttribute> Public Enum PhoneService As Integer
   None = 0
   LandLine = 1
   Cell = 2
   Fax = 4
   Internet = 8
   Other = 16
End Enum

Module Example
   Public Sub Main()
      ' Define three variables representing the types of phone service
      ' in three households.
      Dim household1 As PhoneService = PhoneService.LandLine Or
                                       PhoneService.Cell Or
                                       PhoneService.Internet
      Dim household2 As PhoneService = PhoneService.None
      Dim household3 As PhoneService = PhoneService.Cell Or
                                       PhoneService.Internet

      ' Store the variables in an array for ease of access.
      Dim households() As PhoneService = { household1, household2,
                                           household3 }

      ' Which households have no service?
      For ctr As Integer = 0 To households.Length - 1
         Console.WriteLine("Household {0} has phone service: {1}",
                           ctr + 1,
                           If(households(ctr) = PhoneService.None,
                              "No", "Yes"))
      Next
      Console.WriteLine()
      
      ' Which households have cell phone service?
      For ctr As Integer = 0 To households.Length - 1
         Console.WriteLine("Household {0} has cell phone service: {1}",
                           ctr + 1,
                           If((households(ctr) And PhoneService.Cell) = PhoneService.Cell,
                              "Yes", "No"))
      Next
      Console.WriteLine()
      
      ' Which households have cell phones and land lines?
      Dim cellAndLand As PhoneService = PhoneService.Cell Or PhoneService.LandLine
      For ctr As Integer = 0 To households.Length - 1
         Console.WriteLine("Household {0} has cell and land line service: {1}",
                           ctr + 1,
                           If((households(ctr) And cellAndLand) = cellAndLand,
                              "Yes", "No"))
      Next
      Console.WriteLine()
      
      ' List all types of service of each household?'
      For ctr As Integer = 0 To households.Length - 1
         Console.WriteLine("Household {0} has: {1:G}",
                           ctr + 1, households(ctr))
      Next
      Console.WriteLine()
   End Sub
End Module
' 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

Hinweise

Bitfelder werden in der Regel für Listen von Elementen, die auftreten können, in Kombination verwendet, während Enumerationskonstanten in der Regel für die Listen sich gegenseitig ausschließende Elemente verwendet werden.Bit fields are generally used for lists of elements that might occur in combination, whereas enumeration constants are generally used for lists of mutually exclusive elements. Daher sollen Bitfelder mit einer bitweisen OR-Operation zum Generieren nicht benannter Werte kombiniert werden, während Enumerationskonstanten nicht sind.Therefore, bit fields are designed to be combined with a bitwise OR operation to generate unnamed values, whereas enumerated constants are not. Sprachen, die bei der Verwendung von Bitfeldern, die im Vergleich zu Enumerationskonstanten unterschiedlich sein.Languages vary in their use of bit fields compared to enumeration constants.

Attribute von FlagsAttributeAttributes of the FlagsAttribute

AttributeUsageAttribute auf diese Klasse angewendet wird und die zugehörige Inherited Eigenschaft gibt an, false.AttributeUsageAttribute is applied to this class, and its Inherited property specifies false. Dieses Attribut kann nur auf Enumerationen angewendet werden.This attribute can only be applied to enumerations.

Richtlinien für die FlagsAttribute "und" EnumGuidelines for FlagsAttribute and Enum

  • Verwenden der FlagsAttribute benutzerdefiniertes Attribut für eine Enumeration, die nur dann, wenn eine bitweise Operation (AND, OR EXKLUSIVES oder) ausgeführt wird, die auf einem numerischen Wert.Use the FlagsAttribute custom attribute for an enumeration only if a bitwise operation (AND, OR, EXCLUSIVE OR) is to be performed on a numeric value.

  • Definieren Sie Enumerationskonstanten in Potenzen von 2, d. h. 1, 2, 4, 8 und So weiter.Define enumeration constants in powers of two, that is, 1, 2, 4, 8, and so on. Dies bedeutet, dass die einzelnen Flags in der kombinierten Enumerationskonstanten nicht überschneiden.This means the individual flags in combined enumeration constants do not overlap.

  • Es empfiehlt sich eine Enumerationskonstante für häufig verwendete Flagkombinationen.Consider creating an enumerated constant for commonly used flag combinations. Z. B. Wenn Sie eine Enumeration, der für e/a-Vorgänge verwendet haben, enthält die Enumerationskonstanten Read = 1 und Write = 2, es empfiehlt sich die Enumerationskonstante ReadWrite = Read OR Write, welche kombiniert die Read und Write Flags.For example, if you have an enumeration used for file I/O operations that contains the enumerated constants Read = 1 and Write = 2, consider creating the enumerated constant ReadWrite = Read OR Write, which combines the Read and Write flags. Darüber hinaus kann die bitweise OR-Operation zum Kombinieren der Flags verwendet einen erweiterten Ansatz in einigen Fällen berücksichtigt werden, die nicht für einfache Aufgaben erforderlich sein sollte.In addition, the bitwise OR operation used to combine the flags might be considered an advanced concept in some circumstances that should not be required for simple tasks.

  • Verwenden Sie vorsichtig, wenn Sie eine negative Zahl als eine Flag-Enumerationskonstanten definieren, da viele Flagpositionen auf 1 festgelegt werden können, die möglicherweise, dass Ihr Code verwirrend und codierungsangewohnheiten Fehler.Use caution if you define a negative number as a flag enumerated constant because many flag positions might be set to 1, which might make your code confusing and encourage coding errors.

  • Eine praktische Möglichkeit zu prüfen, ob ein Flag in einem numerischen Wert festgelegt ist ist, führen Sie eine bitweise AND-Operation zwischen den numerischen Wert und die Flag-Enumerationskonstante, die legt alle Bits in den numerischen Wert 0 (null), die nicht auf das Flag entsprechen , testen, ob das Ergebnis des Vorgangs das Flag Enumerationskonstante.A convenient way to test whether a flag is set in a numeric value is to perform a bitwise AND operation between the numeric value and the flag enumerated constant, which sets all bits in the numeric value to zero that do not correspond to the flag, then test whether the result of that operation is equal to the flag enumerated constant.

  • Verwendung None wie der Name des Flags Konstante aufgelistet, deren Wert 0 (null ist).Use None as the name of the flag enumerated constant whose value is zero. Sie können keine der None Enumerationskonstante, die in einer bitweisen AND-Operation für ein Flag zu testen, da das Ergebnis immer 0 (null) ist.You cannot use the None enumerated constant in a bitwise AND operation to test for a flag because the result is always zero. Allerdings können Sie ein logisches ausführen keinen bitweisen Vergleich zwischen den numerischen Wert und die None Enumerationskonstante, um zu bestimmen, ob alle Bits im numerischen Wert festgelegt werden.However, you can perform a logical, not a bitwise, comparison between the numeric value and the None enumerated constant to determine whether any bits in the numeric value are set.

    Wenn Sie eine Value-Aufzählung, anstatt eine Flags-Enumeration erstellen, lohnt es weiterhin zum Erstellen einer None Enumerationskonstante.If you create a value enumeration instead of a flags enumeration, it is still worthwhile to create a None enumerated constant. Der Grund ist, wird standardmäßig der für die Enumeration verwendete Arbeitsspeicher mit 0 (null) initialisiert wird von der common Language Runtime.The reason is that by default the memory used for the enumeration is initialized to zero by the common language runtime. Daher, wenn Sie keine Konstante definieren, deren Wert 0 (null) ist, die Enumeration einen unzulässigen Wert enthält bei der Erstellung.Consequently, if you do not define a constant whose value is zero, the enumeration will contain an illegal value when it is created.

    Ist eine offensichtliche Groß-/Kleinschreibung, Ihre Anwendung benötigt, um darzustellen, sollten erwägen Sie, eine Enumerationskonstante, deren Wert 0 (null) zur Darstellung der Standardwert ist, zu verwenden.If there is an obvious default case your application needs to represent, consider using an enumerated constant whose value is zero to represent the default. Wenn keine Standardfall wird sollten Sie Sie, dass es sich bei Verwendung eine Enumerationskonstante, dessen Wert NULL, wird, die Groß-/Kleinschreibung hat zur Folge, die nicht von einem anderen aufgelisteten Konstanten dargestellt wird.If there is no default case, consider using an enumerated constant whose value is zero that means the case that is not represented by any of the other enumerated constants.

  • Einen Enumerationswert, nur um spiegeln den Zustand der Enumeration selbst ist nicht definiert werden.Do not define an enumeration value solely to mirror the state of the enumeration itself. Definieren Sie z. B. keine Enumerationskonstante, die nur am Ende der Enumeration markiert.For example, do not define an enumerated constant that merely marks the end of the enumeration. Wenn Sie bestimmen Sie den letzten Wert der Enumeration, die explizit für diesen Wert überprüfen möchten.If you need to determine the last value of the enumeration, check for that value explicitly. Darüber hinaus können Sie eine bereichsüberprüfung für die erste und letzte Enumerationskonstante durchführen, wenn alle Werte innerhalb des Bereichs gültig sind.In addition, you can perform a range check for the first and last enumerated constant if all values within the range are valid.

  • Geben Sie keine Enumerationskonstanten, die für die zukünftige Verwendung reserviert sind.Do not specify enumerated constants that are reserved for future use.

  • Berücksichtigen Sie Sie definieren eine Methode oder Eigenschaft, die eine aufgezählte Konstante als Wert annimmt, beim Überprüfen des Werts.When you define a method or property that takes an enumerated constant as a value, consider validating the value. Der Grund ist, dass Sie einen numerischen Wert in den Enumerationstyp umwandeln können, selbst wenn diese numerische Wert nicht in der Enumeration definiert ist.The reason is that you can cast a numeric value to the enumeration type even if that numeric value is not defined in the enumeration.

Konstruktoren

FlagsAttribute()

Initialisiert eine neue Instanz der FlagsAttribute-Klasse. Initializes a new instance of the FlagsAttribute class.

Methoden

Equals(Object)

Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist. Returns a value that indicates whether this instance is equal to a specified object.

(Inherited from Attribute)
GetHashCode()

Gibt den Hashcode für diese Instanz zurück. Returns the hash code for this instance.

(Inherited from Attribute)
GetType()

Ruft den Type der aktuellen Instanz ab. Gets the Type of the current instance.

(Inherited from Object)
IsDefaultAttribute()

Gibt beim Überschreiben in einer abgeleiteten Klasse an, ob der Wert der Instanz der Standardwert für die abgeleitete Klasse ist. When overridden in a derived class, indicates whether the value of this instance is the default value for the derived class.

(Inherited from Attribute)
Match(Object)

Beim Überschreiben in einer abgeleiteten Klasse wird ein Wert zurückgegeben, der angibt, ob diese Instanz einem bestimmten Objekt entspricht. When overridden in a derived class, returns a value that indicates whether this instance equals a specified object.

(Inherited from Attribute)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object. Creates a shallow copy of the current Object.

(Inherited from Object)
ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. Returns a string that represents the current object.

(Inherited from Object)

Explizite Schnittstellenimplementierungen

_Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Ordnet eine Reihe von Namen einer entsprechenden Reihe von Dispatchbezeichnern zu. Maps a set of names to a corresponding set of dispatch identifiers.

(Inherited from Attribute)
_Attribute.GetTypeInfo(UInt32, UInt32, IntPtr)

Ruft die Typinformationen für ein Objekt ab, mit deren Hilfe die Typinformationen für eine Schnittstelle abgerufen werden können. Retrieves the type information for an object, which can be used to get the type information for an interface.

(Inherited from Attribute)
_Attribute.GetTypeInfoCount(UInt32)

Ruft die Anzahl der Schnittstellen mit Typinformationen ab, die von einem Objekt bereitgestellt werden (0 oder 1). Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Inherited from Attribute)
_Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Stellt den Zugriff auf von einem Objekt verfügbar gemachte Eigenschaften und Methoden bereit. Provides access to properties and methods exposed by an object.

(Inherited from Attribute)

Eigenschaften

TypeId

Ruft bei Implementierung in einer abgeleiteten Klasse einen eindeutigen Bezeichner für dieses Attribute ab. When implemented in a derived class, gets a unique identifier for this Attribute.

(Inherited from Attribute)

Gilt für: