Type.GetProperties Methode

Definition

Ruft die Eigenschaften des aktuellen Type ab.Gets the properties of the current Type.

Überlädt

GetProperties()

Gibt sämtliche öffentlichen Eigenschaften des aktuellen Type zurück.Returns all the public properties of the current Type.

GetProperties(BindingFlags)

Sucht beim Überschreiben in einer abgeleiteten Klasse unter Verwendung der angegebenen Bindungseinschränkungen die Eigenschaften des aktuellen Type.When overridden in a derived class, searches for the properties of the current Type, using the specified binding constraints.

GetProperties()

Gibt sämtliche öffentlichen Eigenschaften des aktuellen Type zurück.Returns all the public properties of the current Type.

public:
 cli::array <System::Reflection::PropertyInfo ^> ^ GetProperties();
public:
 virtual cli::array <System::Reflection::PropertyInfo ^> ^ GetProperties();
public System.Reflection.PropertyInfo[] GetProperties ();
member this.GetProperties : unit -> System.Reflection.PropertyInfo[]
abstract member GetProperties : unit -> System.Reflection.PropertyInfo[]
override this.GetProperties : unit -> System.Reflection.PropertyInfo[]
Public Function GetProperties () As PropertyInfo()

Gibt zurück

Ein Array von PropertyInfo-Objekten, die alle öffentlichen Eigenschaften des aktuellen Type darstellen.An array of PropertyInfo objects representing all public properties of the current Type.

Oder-or- Ein leeres Array vom PropertyInfo-Typ, wenn der aktuelle Type keine öffentlichen Eigenschaften besitzt.An empty array of type PropertyInfo, if the current Type does not have public properties.

Implementiert

Beispiele

Im folgenden Beispiel wird die Verwendung der GetProperties-Methode gezeigt.The following example demonstrates the use of the GetProperties method.

array<PropertyInfo^>^myPropertyInfo;

// Get the properties of 'Type' class object.
myPropertyInfo = Type::GetType( "System.Type" )->GetProperties();
Console::WriteLine( "Properties of System.Type are:" );
for ( int i = 0; i < myPropertyInfo->Length; i++ )
{
   Console::WriteLine( myPropertyInfo[ i ] );

}
PropertyInfo[] myPropertyInfo;
// Get the properties of 'Type' class object.
myPropertyInfo = Type.GetType("System.Type").GetProperties();
Console.WriteLine("Properties of System.Type are:");
for (int i = 0; i < myPropertyInfo.Length; i++)
{
    Console.WriteLine(myPropertyInfo[i].ToString());
}
Dim myPropertyInfo() As PropertyInfo
' Get the properties of 'Type' class object.
myPropertyInfo = Type.GetType("System.Type").GetProperties()
Console.WriteLine("Properties of System.Type are:")
Dim i As Integer
For i = 0 To myPropertyInfo.Length - 1
   Console.WriteLine(myPropertyInfo(i).ToString())
Next i

Hinweise

Das Aufrufen dieser Überladung entspricht dem Aufrufen der GetProperties(BindingFlags) Überladung mit einem bindingAttr-Argument, C# das BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public in und BindingFlags.Instance Or BindingFlags.Static Or BindingFlags.Public in Visual Basic entspricht.Calling this overload is equivalent to calling the GetProperties(BindingFlags) overload with a bindingAttr argument equal to BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public in C# and BindingFlags.Instance Or BindingFlags.Static Or BindingFlags.Public in Visual Basic. Sie gibt alle öffentlichen Instanzen und statischen Eigenschaften zurück, sowohl die, die durch den Typ definiert sind, der durch das aktuelle Type-Objekt dargestellt wird, als auch die, die von den Basis Typen geerbt werdenIt returns all public instance and static properties, both those defined by the type represented by the current Type object as well as those inherited from its base types.

Eine Eigenschaft gilt als öffentlich für Reflektion, wenn Sie über mindestens einen öffentlichen Accessor verfügt.A property is considered public to reflection if it has at least one accessor that is public. Andernfalls wird die-Eigenschaft als privat betrachtet, und Sie müssen | BindingFlags.NonPublic | BindingFlags.Instance BindingFlags.Static verwenden (in Visual Basic die Werte mithilfe Orkombinieren), um Sie zu erhalten.Otherwise the property is considered private, and you must use BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static (in Visual Basic, combine the values using Or) to get it.

Die GetProperties-Methode gibt keine Eigenschaften in einer bestimmten Reihenfolge zurück, z. b. alphabetisch oder Deklarations Reihenfolge.The GetProperties method does not return properties in a particular order, such as alphabetical or declaration order. Der Code darf nicht von der Reihenfolge abhängen, in der Eigenschaften zurückgegeben werden, da diese Reihenfolge variiert.Your code must not depend on the order in which properties are returned, because that order varies.

In der folgenden Tabelle wird gezeigt, welche Member einer Basisklasse von den Get Methoden zurückgegeben werden, wenn ein Typ reflektiert wird.The following table shows what members of a base class are returned by the Get methods when reflecting on a type.

MitgliedstypMember Type statischenStatic Nicht statischNon-Static
KonstruktorConstructor NeinNo NeinNo
FeldField NeinNo Ja.Yes. Ein Feld wird immer nach Name und Signatur ausgeblendet.A field is always hide-by-name-and-signature.
EreignisEvent Nicht verfügbarNot applicable Die allgemeine Typsystem Regel ist, dass die Vererbung mit der der Methoden identisch ist, die die-Eigenschaft implementieren.The common type system rule is that the inheritance is the same as that of the methods that implement the property. Die Reflektion behandelt Eigenschaften als "ausblenden nach Namen" und "Signatur".Reflection treats properties as hide-by-name-and-signature. Siehe Hinweis 2 weiter unten.See note 2 below.
MethodeMethod NeinNo Ja.Yes. Eine Methode (sowohl virtuell als auch nicht virtuell) kann nach Namen oder nach Name und Signatur ausgeblendet werden.A method (both virtual and non-virtual) can be hide-by-name or hide-by-name-and-signature.
Der Typ "Typ"Nested Type NeinNo NeinNo
EigenschaftProperty Nicht verfügbarNot applicable Die allgemeine Typsystem Regel ist, dass die Vererbung mit der der Methoden identisch ist, die die-Eigenschaft implementieren.The common type system rule is that the inheritance is the same as that of the methods that implement the property. Die Reflektion behandelt Eigenschaften als "ausblenden nach Namen" und "Signatur".Reflection treats properties as hide-by-name-and-signature. Siehe Hinweis 2 weiter unten.See note 2 below.
  1. "Hide-by-Name-and-Signature" berücksichtigt alle Teile der Signatur, einschließlich benutzerdefinierter Modifizierer, Rückgabe Typen, Parametertypen, Sentinels und nicht verwalteter Aufruf Konventionen.Hide-by-name-and-signature considers all of the parts of the signature, including custom modifiers, return types, parameter types, sentinels, and unmanaged calling conventions. Dies ist ein binärer Vergleich.This is a binary comparison.

  2. Für Reflektion werden Eigenschaften und Ereignisse nach Name und Signatur ausgeblendet.For reflection, properties and events are hide-by-name-and-signature. Wenn Sie über eine Eigenschaft verfügen, die sowohl einen get-als auch einen Set-Accessor in der Basisklasse aufweist, aber die abgeleitete Klasse nur über einen get-Accessor verfügt, blendet die Eigenschaft der abgeleiteten Klasse die Basisklassen Eigenschaft aus, und Sie können nicht auf den Setter für die Basisklasse zugreifen.If you have a property with both a get and a set accessor in the base class, but the derived class has only a get accessor, the derived class property hides the base class property, and you will not be able to access the setter on the base class.

  3. Benutzerdefinierte Attribute sind nicht Teil des allgemeinen Typsystems.Custom attributes are not part of the common type system.

Wenn die aktuelle Type einen konstruierten generischen Typ darstellt, gibt diese Methode die PropertyInfo Objekte mit den Typparametern zurück, die durch die entsprechenden Typargumente ersetzt werden.If the current Type represents a constructed generic type, this method returns the PropertyInfo objects with the type parameters replaced by the appropriate type arguments.

Wenn die aktuelle Type einen Typparameter in der Definition eines generischen Typs oder einer generischen Methode darstellt, durchsucht diese Methode die Eigenschaften der Klassen Einschränkung.If the current Type represents a type parameter in the definition of a generic type or generic method, this method searches the properties of the class constraint.

Siehe auch

GetProperties(BindingFlags)

Sucht beim Überschreiben in einer abgeleiteten Klasse unter Verwendung der angegebenen Bindungseinschränkungen die Eigenschaften des aktuellen Type.When overridden in a derived class, searches for the properties of the current Type, using the specified binding constraints.

public:
 abstract cli::array <System::Reflection::PropertyInfo ^> ^ GetProperties(System::Reflection::BindingFlags bindingAttr);
public abstract System.Reflection.PropertyInfo[] GetProperties (System.Reflection.BindingFlags bindingAttr);
abstract member GetProperties : System.Reflection.BindingFlags -> System.Reflection.PropertyInfo[]
Public MustOverride Function GetProperties (bindingAttr As BindingFlags) As PropertyInfo()

Parameter

bindingAttr
BindingFlags

Eine bitweise Kombination der Enumerationswerte, die angeben, wie die Suche durchgeführt wird.A bitwise combination of the enumeration values that specify how the search is conducted.

Oder-or-

Default, um ein leeres Array zurückzugeben.Default to return an empty array.

Gibt zurück

Ein Array von Objekten, die sämtliche Eigenschaften des aktuellen Type darstellen, die den angegebenen Bindungseinschränkungen entsprechen.An array of objects representing all properties of the current Type that match the specified binding constraints.

Oder-or- Ein leeres Array vom PropertyInfo-Typ, wenn der aktuelle Type keine Eigenschaften besitzt oder keine der Eigenschaften den Bindungseinschränkungen entspricht.An empty array of type PropertyInfo, if the current Type does not have properties, or if none of the properties match the binding constraints.

Implementiert

Beispiele

Im folgenden Beispiel wird eine Klasse mit dem Namen PropertyClass definiert, die sechs Eigenschaften enthält: zwei sind Public, eine ist privat, eine ist geschützt, eine ist intern (Friend in Visual Basic) und eine ist intern geschützt (Protected Friend in Visual Basic).The following example defines a class named PropertyClass that includes six properties: two are public, one is private, one is protected, one is internal (Friend in Visual Basic), and one is protected internal (Protected Friend in Visual Basic). Anschließend werden einige grundlegende Eigenschafts Informationen (Name und Typ der Eigenschaft, ob es sich um Lese-/Schreibzugriff handelt, und die Sichtbarkeit der get und set Accessoren) für die Eigenschaften angezeigt, die den angegebenen Bindungs Einschränkungen entsprechen.It then displays some basic property information (the property name and type, whether it is read/write, and the visibility of its get and set accessors) for the properties that match the specified binding constraints.

using namespace System;
using namespace System::Reflection;

// Create a class having three properties.
public ref class PropertyClass
{

public:
   property String^ Property1
   {
      String^ get()
      {
         return "hello";
      }
   }

   property String^ Property2 
   {
      String^ get()
      {
         return "hello";
      }
   }

protected:
   property String^ Property3
   {
      String^ get()
      {
         return "hello";
      }
   }

private:
   property int Property4
   {
      int get()
      {
         return 32;
      }
   }

internal:
   property String^ Property5
   {
      String^ get()
      {
         return "value";
      }
   }
   
public protected:
   property String^ Property6
   {
      String^ get()
      {
         return "value";
      }
   }
};

String^ GetVisibility(MethodInfo^ accessor)
{
    if (accessor->IsPublic)
       return "Public";
    else if (accessor->IsPrivate)
       return "Private";
    else if (accessor->IsFamily)
       return "Protected";
    else if (accessor->IsAssembly)
       return "Internal/Friend";
    else
       return "Protected Internal/Friend";
}

void DisplayPropertyInfo(array<PropertyInfo^>^ propInfos )
{
   // Display information for all properties.
   for each(PropertyInfo^ propInfo in propInfos) {
      bool readable = propInfo->CanRead;
      bool writable = propInfo->CanWrite;
      
      Console::WriteLine("   Property name: {0}", propInfo->Name);
      Console::WriteLine("   Property type: {0}", propInfo->PropertyType);
      Console::WriteLine("   Read-Write:    {0}", readable && writable);
      if (readable) {
         MethodInfo^ getAccessor = propInfo->GetMethod;
         Console::WriteLine("   Visibility:    {0}",
                           GetVisibility(getAccessor));
      }
      if (writable) {
         MethodInfo^ setAccessor = propInfo->SetMethod;
         Console::WriteLine("   Visibility:    {0}",
                            GetVisibility(setAccessor));
      }
      Console::WriteLine();
   }
}

void main()
{
   Type^ myType = PropertyClass::typeid;
   
   // Get the public properties.
   array<PropertyInfo^>^propInfos = myType->GetProperties( static_cast<BindingFlags>(BindingFlags::Public | BindingFlags::Instance) );
   Console::WriteLine("The number of public properties: {0}.\n",
                      propInfos->Length);
   // Display the public properties.
   DisplayPropertyInfo( propInfos );
   
   // Get the non-public properties.
   array<PropertyInfo^>^propInfos1 = myType->GetProperties( static_cast<BindingFlags>(BindingFlags::NonPublic | BindingFlags::Instance) );
   Console::WriteLine("The number of non-public properties: {0}.\n",
                      propInfos1->Length);
   // Display all the non-public properties.
   DisplayPropertyInfo(propInfos1);
}
// The example displays the following output:
//       The number of public properties: 2.
//
//          Property name: Property2
//          Property type: System.String
//          Read-Write:    False
//          Visibility:    Public
//
//          Property name: Property1
//          Property type: System.String
//          Read-Write:    False
//          Visibility:    Public
//
//       The number of non-public properties: 4.
//
//          Property name: Property6
//          Property type: System.String
//          Read-Write:    False
//          Visibility:    Protected Internal/Friend
//
//          Property name: Property5
//          Property type: System.String
//          Read-Write:    False
//          Visibility:    Internal/Friend
//
//          Property name: Property4
//          Property type: System.Int32
//          Read-Write:    False
//          Visibility:    Private
//
//          Property name: Property3
//          Property type: System.String
//          Read-Write:    False
//          Visibility:    Protected
using System;
using System.Reflection;

// Create a class having six properties.
public class PropertyClass
{
    public String Property1
    {
        get { return "hello"; }
    }

    public String Property2
    {
        get { return "hello"; }
    }

    protected String Property3
    {
        get { return "hello"; }
    }

    private Int32 Property4
    {
        get { return 32; }
    }

    internal String Property5
    {
       get { return "value"; }
    }

    protected internal String Property6
    {
       get { return "value"; }
    }
}

public class Example
{
    public static void Main() 
    {
        Type t = typeof(PropertyClass);
        // Get the public properties.
        PropertyInfo[] propInfos = t.GetProperties(BindingFlags.Public|BindingFlags.Instance);
        Console.WriteLine("The number of public properties: {0}.\n",
                          propInfos.Length);
        // Display the public properties.
        DisplayPropertyInfo(propInfos);

        // Get the nonpublic properties.
        PropertyInfo[] propInfos1 = t.GetProperties(BindingFlags.NonPublic|BindingFlags.Instance);
        Console.WriteLine("The number of non-public properties: {0}.\n",
                          propInfos1.Length);
        // Display all the nonpublic properties.
        DisplayPropertyInfo(propInfos1);
    }

    public static void DisplayPropertyInfo(PropertyInfo[] propInfos)
    {
        // Display information for all properties.
        foreach (var propInfo in propInfos) {
            bool readable = propInfo.CanRead;
            bool writable = propInfo.CanWrite;
            
            Console.WriteLine("   Property name: {0}", propInfo.Name);
            Console.WriteLine("   Property type: {0}", propInfo.PropertyType);
            Console.WriteLine("   Read-Write:    {0}", readable & writable);
            if (readable) {
               MethodInfo getAccessor = propInfo.GetMethod;
               Console.WriteLine("   Visibility:    {0}",
                                 GetVisibility(getAccessor));
            }
            if (writable) {
               MethodInfo setAccessor = propInfo.SetMethod;
               Console.WriteLine("   Visibility:    {0}",
                                 GetVisibility(setAccessor));
            }
            Console.WriteLine();
        }
    }

    public static String GetVisibility(MethodInfo accessor)
    {
       if (accessor.IsPublic)
          return "Public";
       else if (accessor.IsPrivate)
          return "Private";
       else if (accessor.IsFamily)
          return "Protected";
       else if (accessor.IsAssembly)
          return "Internal/Friend";
       else
          return "Protected Internal/Friend";
    }
}
// The example displays the following output:
//       The number of public properties: 2.
//
//          Property name: Property1
//          Property type: System.String
//          Read-Write:    False
//          Visibility:    Public
//
//          Property name: Property2
//          Property type: System.String
//          Read-Write:    False
//          Visibility:    Public
//
//       The number of non-public properties: 4.
//
//          Property name: Property3
//          Property type: System.String
//          Read-Write:    False
//          Visibility:    Protected
//
//          Property name: Property4
//          Property type: System.Int32
//          Read-Write:    False
//          Visibility:    Private
//
//          Property name: Property5
//          Property type: System.String
//          Read-Write:    False
//          Visibility:    Internal/Friend
//
//          Property name: Property6
//          Property type: System.String
//          Read-Write:    False
//          Visibility:    Protected Internal/Friend
Imports System.Reflection

' Create a class having six properties.
Public Class PropertyClass
    Public ReadOnly Property Property1() As String
        Get
            Return "hello"
        End Get
    End Property

    Public ReadOnly Property Property2() As String
        Get
            Return "hello"
        End Get
    End Property

    Protected ReadOnly Property Property3() As String
        Get
            Return "hello"
        End Get
    End Property

    Private ReadOnly Property Property4 As Integer
        Get
           Return 32
        End Get
    End Property

    Friend ReadOnly Property Property5 As String
       Get
          Return "value"
       End Get
    End Property

    Protected Friend ReadOnly Property Property6 As String
       Get
          Return "value"
       End Get
    End Property
End Class

Public Module Example
    Public Sub Main()
        Dim t As Type = GetType(PropertyClass)
        ' Get the public properties.
        Dim propInfos As PropertyInfo() = t.GetProperties(BindingFlags.Public Or BindingFlags.Instance)
        Console.WriteLine("The number of public properties: {0}",
                          propInfos.Length)
        Console.WriteLine()
        ' Display the public properties.
        DisplayPropertyInfo(propInfos)

        ' Get the non-public properties.
        Dim propInfos1 As PropertyInfo() = t.GetProperties(BindingFlags.NonPublic Or BindingFlags.Instance)
        Console.WriteLine("The number of non-public properties: {0}",
                          propInfos1.Length)
        Console.WriteLine()
        ' Display all the non-public properties.
        DisplayPropertyInfo(propInfos1)
    End Sub

    Public Sub DisplayPropertyInfo(ByVal propInfos() As PropertyInfo)
        ' Display information for all properties.
        For Each propInfo In propInfos
            Dim readable As Boolean = propInfo.CanRead
            Dim writable As Boolean = propInfo.CanWrite
            
            Console.WriteLine("   Property name: {0}", propInfo.Name)
            Console.WriteLine("   Property type: {0}", propInfo.PropertyType)
            Console.WriteLine("   Read-Write:    {0}", readable And writable)
            If readable Then
               Dim getAccessor As MethodInfo = propInfo.GetMethod
               Console.WriteLine("   Visibility:    {0}",
                                 GetVisibility(getAccessor))
            End If
            If writable Then
               Dim setAccessor As MethodInfo = propInfo.SetMethod
               Console.WriteLine("   Visibility:    {0}",
                                 GetVisibility(setAccessor))
            End If
            Console.WriteLine()
        Next
    End Sub
    
    Public Function GetVisibility(accessor As MethodInfo) As String
       If accessor.IsPublic Then
          Return "Public"
       ElseIf accessor.IsPrivate Then
          Return "Private"
       Else If accessor.IsFamily Then
          Return "Protected"
       Else If accessor.IsAssembly Then
          Return "Internal/Friend"
       Else
          Return "Protected Internal/Friend"
       End If
    End Function
End Module
' The example displays the following output:
'       The number of public properties: 2
'
'          Property name: Property1
'          Property type: System.String
'          Read-Write:    False
'          Visibility:    Public
'
'          Property name: Property2
'          Property type: System.String
'          Read-Write:    False
'          Visibility:    Public
'
'       The number of non-public properties: 4
'
'          Property name: Property3
'          Property type: System.String
'          Read-Write:    False
'          Visibility:    Protected
'
'          Property name: Property4
'          Property type: System.Int32
'          Read-Write:    False
'          Visibility:    Private
'
'          Property name: Property5
'          Property type: System.String
'          Read-Write:    False
'          Visibility:    Internal/Friend
'
'          Property name: Property6
'          Property type: System.String
'          Read-Write:    False
'          Visibility:    Protected Internal/Friend

Hinweise

Damit die GetProperties(BindingFlags) Überladung Eigenschaften Informationen erfolgreich abrufen kann, muss das bindingAttr-Argument mindestens eine BindingFlags.Instance und BindingFlags.Staticenthalten, zusammen mit mindestens einer BindingFlags.NonPublic und BindingFlags.Public.For the GetProperties(BindingFlags) overload to successfully retrieve property information, the bindingAttr argument must include at least one of BindingFlags.Instance and BindingFlags.Static, along with at least one of BindingFlags.NonPublic and BindingFlags.Public.

Die folgenden BindingFlags Filterflags können verwendet werden, um zu definieren, welche Eigenschaften in die Suche eingeschlossen werden sollen:The following BindingFlags filter flags can be used to define which properties to include in the search:

  • Geben Sie BindingFlags.Instance an, um Instanzmethoden einzubeziehen.Specify BindingFlags.Instance to include instance methods.

  • Geben Sie BindingFlags.Static an, um statische Methoden einzubeziehen.Specify BindingFlags.Static to include static methods.

  • Geben Sie BindingFlags.Public an, um öffentliche Eigenschaften in die Suche einzubeziehen.Specify BindingFlags.Public to include public properties in the search. Eine Eigenschaft gilt als öffentlich für Reflektion, wenn Sie über mindestens einen öffentlichen Accessor verfügt.A property is considered public to reflection if it has at least one accessor that is public.

  • Geben Sie BindingFlags.NonPublic an, dass nicht öffentliche Eigenschaften (d. h. private, interne und geschützte Eigenschaften) in der Suche enthalten sein sollen.Specify BindingFlags.NonPublic to include non-public properties (that is, private, internal, and protected properties) in the search. Es werden nur geschützte und interne Eigenschaften für Basisklassen zurückgegeben. private Eigenschaften für Basisklassen werden nicht zurückgegeben.Only protected and internal properties on base classes are returned; private properties on base classes are not returned.

  • Geben Sie BindingFlags.FlattenHierarchy an, um public und protected statische Elemente in der Hierarchie einzuschließen. private statische Member in geerbten Klassen sind nicht enthalten.Specify BindingFlags.FlattenHierarchy to include public and protected static members up the hierarchy; private static members in inherited classes are not included.

  • Geben Sie BindingFlags.Default allein an, um ein leeres PropertyInfo Array zurückzugeben.Specify BindingFlags.Default alone to return an empty PropertyInfo array.

Die folgenden BindingFlags-Modifiziererflags können verwendet werden, um die Funktionsweise der Suche zu ändern:The following BindingFlags modifier flags can be used to change how the search works:

  • BindingFlags.DeclaredOnly, um nur die Eigenschaften zu durchsuchen, die auf dem Typedeklariert sind, und keine Eigenschaften, die einfach geerbt wurdenBindingFlags.DeclaredOnly to search only the properties declared on the Type, not properties that were simply inherited.

Weitere Informationen finden Sie unter System.Reflection.BindingFlags.See System.Reflection.BindingFlags for more information.

Die GetProperties-Methode gibt keine Eigenschaften in einer bestimmten Reihenfolge zurück, z. b. alphabetisch oder Deklarations Reihenfolge.The GetProperties method does not return properties in a particular order, such as alphabetical or declaration order. Der Code darf nicht von der Reihenfolge abhängen, in der Eigenschaften zurückgegeben werden, da diese Reihenfolge variiert.Your code must not depend on the order in which properties are returned, because that order varies.

Wenn die aktuelle Type einen konstruierten generischen Typ darstellt, gibt diese Methode die PropertyInfo Objekte mit den Typparametern zurück, die durch die entsprechenden Typargumente ersetzt werden.If the current Type represents a constructed generic type, this method returns the PropertyInfo objects with the type parameters replaced by the appropriate type arguments.

Wenn die aktuelle Type einen Typparameter in der Definition eines generischen Typs oder einer generischen Methode darstellt, durchsucht diese Methode die Eigenschaften der Klassen Einschränkung.If the current Type represents a type parameter in the definition of a generic type or generic method, this method searches the properties of the class constraint.

Siehe auch

Gilt für: