Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

Type.Attributes-Eigenschaft

 

Veröffentlicht: Oktober 2016

Ruft die dem Type zugeordneten Attribute ab.

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)

public TypeAttributes Attributes { get; }

Eigenschaftswert

Type: System.Reflection.TypeAttributes

Ein TypeAttributes-Objekt, das die Attributgruppe von Type darstellt. Falls Type jedoch einen generischen Typparameter darstellt, ist der Wert nicht festgelegt.

Implementiert

_Type.Attributes

Einige Member der TypeAttributes Enumeration sind Masken, die eine Gruppe von Werten darstellen. Jede Gruppe enthält ein Element, dessen zugrunde liegenden Wert 0 (null) ist. Z. B. den zugrunde liegenden Wert von der TypeAttributes.NotPublic Element in der TypeAttributes.VisibilityMask Gruppe ist 0 (null), ist die TypeAttributes.AutoLayout Element in der TypeAttributes.SequentialLayout Gruppe. Aus diesem Grund müssen Sie die Maske verwenden, bevor Sie für diese Werte testen. Dies wird im Beispiel veranschaulicht.

System_CAPS_tipTipp

Für die meisten Zwecke Eigenschaften wieIsClass,IsAutoLayout, undIsSpecialName sind einfacher zu verwenden als Attribute des Typs.

Wenn die aktuelle Type stellt ein konstruierter generischer Typ, diese Eigenschaft gibt die Attribute der generischen Typdefinition. Z. B. die Attribute, die für die zurückgegebenen MyGenericClass<int> (MyGenericClass(Of Integer) in Visual Basic) sind die Attribute des MyGenericClass<T> (MyGenericClass(Of T) in Visual Basic).

Wenn die aktuelle Type einen generischen Typparameter darstellt – d. h. wenn die IsGenericParameter -Eigenschaft gibt true – die TypeAttributes von dieser Eigenschaft zurückgegebene Wert ist nicht angegeben.

Das folgende Beispiel verwenden bewirkt, dassdie Attributes Eigenschaft.

using System;
using System.Reflection;

internal struct S
{
    public int X;
}

public abstract class Example
{
    protected sealed class NestedClass {}

    public interface INested {}

    public static void Main()
    {
        // Create an array of types.
        Type[] types = { typeof(Example), typeof(NestedClass),
                         typeof(INested), typeof(S) };

        foreach (var t in types) {
           Console.WriteLine("Attributes for type {0}:", t.Name);

           TypeAttributes attr = t.Attributes;

           // To test for visibility attributes, you must use the visibility mask.
           TypeAttributes visibility = attr & TypeAttributes.VisibilityMask;
           switch (visibility)
           {
               case TypeAttributes.NotPublic:
                   Console.WriteLine("   ...is not public");
                   break;
               case TypeAttributes.Public:
                   Console.WriteLine("   ...is public");
                   break;
               case TypeAttributes.NestedPublic:
                   Console.WriteLine("   ...is nested and public");
                   break;
               case TypeAttributes.NestedPrivate:
                   Console.WriteLine("   ...is nested and private");
                   break;
               case TypeAttributes.NestedFamANDAssem:
                   Console.WriteLine("   ...is nested, and inheritable only within the assembly" +
                      "\n         (cannot be declared in C#)");
                   break;
               case TypeAttributes.NestedAssembly:
                   Console.WriteLine("   ...is nested and internal");
                   break;
               case TypeAttributes.NestedFamily:
                   Console.WriteLine("   ...is nested and protected");
                   break;
               case TypeAttributes.NestedFamORAssem:
                   Console.WriteLine("   ...is nested and protected internal");
                   break;
           }

           ' Use the layout mask to test for layout attributes.
           TypeAttributes layout = attr & TypeAttributes.LayoutMask;
           switch (layout)
           {
               case TypeAttributes.AutoLayout:
                   Console.WriteLine("   ...is AutoLayout");
                   break;
               case TypeAttributes.SequentialLayout:
                   Console.WriteLine("   ...is SequentialLayout");
                   break;
               case TypeAttributes.ExplicitLayout:
                   Console.WriteLine("   ...is ExplicitLayout");
                   break;
           }

           ' Use the class semantics mask to test for class semantics attributes.
           TypeAttributes classSemantics = attr & TypeAttributes.ClassSemanticsMask;
           switch (classSemantics)
           {
               case TypeAttributes.Class:
                   if (t.IsValueType)
                   {
                       Console.WriteLine("   ...is a value type");
                   }
                   else
                   {
                       Console.WriteLine("   ...is a class");
                   }
                   break;
               case TypeAttributes.Interface:
                   Console.WriteLine("   ...is an interface");
                   break;
           }

           if (0!=(attr & TypeAttributes.Abstract))
           {
               Console.WriteLine("   ...is abstract");
           }

           if (0!=(attr & TypeAttributes.Sealed))
           {
               Console.WriteLine("   ...is sealed");
           }
           Console.WriteLine();
       }
    }
}
// The example displays the following output:
//       Attributes for type Example:
//          ...is Public
//          ...is AutoLayout
//          ...is a class
//          ...is MustInherit
//
//       Attributes for type NestedClass:
//          ...is nested and Protected
//          ...is AutoLayout
//          ...is a class
//          ...is NotInheritable
//
//       Attributes for type INested:
//          ...is nested and Public
//          ...is AutoLayout
//          ...is an interface
//          ...is MustInherit
//
//       Attributes for type S:
//          ...is not Public
//          ...is SequentialLayout
//          ...is a value type
//          ...is NotInheritable

.NET Framework
Verfügbar seit 1.1
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Zurück zum Anfang
Anzeigen: