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.GenericParameterPosition-Eigenschaft

 

Veröffentlicht: Oktober 2016

Ruft die Position des Typparameters in der Typparameterliste des generischen Typs oder der Methode ab, der bzw. die den Parameter deklariert hat, wenn das Type-Objekt einen Typparameter eines generischen Typs oder einer generischen Methode darstellt.

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

public virtual int GenericParameterPosition { get; }

Eigenschaftswert

Type: System.Int32

Die Position eines Typparameters in der Typparameterliste des generischen Typs oder der generischen Methode, der bzw. die den Parameter definiert. Die Positionsnummern beginnen mit 0.

Exception Condition
InvalidOperationException

Der aktuelle Typ stellt keinen Typparameter dar. Das heißt, IsGenericParameter gibt false zurück.

Die GenericParameterPosition -Eigenschaft gibt die Position eines Typparameters in der Parameterliste der generischen Typ- oder Methodendefinition, in der Typparameter ursprünglich definiert wurde. Die DeclaringType und DeclaringMethod Eigenschaften identifizieren die generische Typ- oder Methodendefinition:

  • Wenn die DeclaringMethod -Eigenschaft gibt eine MethodInfo, MethodInfo stellt eine generische Methodendefinition, und das aktuelle Type -Objekt einen Typparameter eines generischen Methodendefinition darstellt.

  • Wenn die DeclaringMethod -Eigenschaft gibt null, die DeclaringType -Eigenschaft gibt immer eine Type darstellt, eine generische Typdefinition, und das aktuelle Objekt Type -Objekt stellt einen Typparameter eines generischen Typdefinition dar.

Zu den richtigen Kontext für den Wert der GenericParameterPosition -Eigenschaft, es ist erforderlich, die generischen Typs oder einer Methode, die ein Typparameter gehört zu identifizieren. Betrachten Sie z. B. den Rückgabewert der generischen Methode GetSomething in den folgenden Code:

public class B<T, U> { }
public class A<V>
{
    public B<V, X> GetSomething<X>()
    {
        return new B<V, X>();
    }
}

Der zurückgegebene Typ GetSomething richtet sich nach der angegebenen Klasse Typargumente A und GetSomething selbst. Sie erhalten eine MethodInfo für GetSomething, und von dem Sie den Rückgabetyp erhalten. Wenn Sie die Typparameter des Rückgabetyps, untersuchen GenericParameterPosition gibt 0 für beide. Die Position des V ist 0, da V ist der erste Typparameter in der Typparameterliste für die Klasse A. Die Position des X ist 0, da X ist der erste Typparameter in der Typparameterliste für GetSomething.

System_CAPS_noteHinweis

Aufrufen der GenericParameterPosition Eigenschaft eine Ausnahme ausgelöst, wenn die aktuelle Type keinen Typparameter darstellt. Verwenden Sie bei der Überprüfung die Typargumente eines offen konstruierten Typs die IsGenericParameter Eigenschaft, die die Typparameter sind und welche Typen anzeigt. Die IsGenericParameter -Eigenschaft gibt true für einen Typparameter; danach können Sie die GenericParameterPosition Methode, um seine Position zu erhalten und die DeclaringMethod und DeclaringType Eigenschaften, die die generische Methode bestimmen oder Typdefinition, der ihn definiert.

Das folgende Beispiel definiert eine generische Klasse mit zwei Typparametern und eine zweiten generische Klasse, die von der ersten Klasse abgeleitet ist. Die Basis der abgeleiteten Klasse verfügt über zwei Typargumente: das erste ist Int32, und das zweite ein Typparameter des abgeleiteten Typs. Im Beispiel werden Informationen über diese generischen Klassen angezeigt, einschließlich der Positionen lt. die GenericParameterPosition Eigenschaft.

using System;
using System.Reflection;
using System.Collections.Generic;

// Define a base class with two type parameters.
public class Base<T, U> { }

// Define a derived class. The derived class inherits from a constructed
// class that meets the following criteria:
//   (1) Its generic type definition is Base<T, U>.
//   (2) It specifies int for the first type parameter.
//   (3) For the second type parameter, it uses the same type that is used
//       for the type parameter of the derived class.
// Thus, the derived class is a generic type with one type parameter, but
// its base class is an open constructed type with one type argument and
// one type parameter.
public class Derived<V> : Base<int, V> { }

public class Test
{
    public static void Main()
    {
        Console.WriteLine(
            "\r\n--- Display a generic type and the open constructed");
        Console.WriteLine("    type from which it is derived.");

        // Create a Type object representing the generic type definition 
        // for the Derived type, by omitting the type argument. (For
        // types with multiple type parameters, supply the commas but
        // omit the type arguments.) 
        //
        Type derivedType = typeof(Derived<>);
        DisplayGenericTypeInfo(derivedType);

        // Display its open constructed base type.
        DisplayGenericTypeInfo(derivedType.BaseType);
    }

    private static void DisplayGenericTypeInfo(Type t)
    {
        Console.WriteLine("\r\n{0}", t);

        Console.WriteLine("\tIs this a generic type definition? {0}", 
            t.IsGenericTypeDefinition);

        Console.WriteLine("\tIs it a generic type? {0}", 
            t.IsGenericType);

        Console.WriteLine("\tDoes it have unassigned generic parameters? {0}", 
            t.ContainsGenericParameters);

        if (t.IsGenericType)
        {
            // If this is a generic type, display the type arguments.
            //
            Type[] typeArguments = t.GetGenericArguments();

            Console.WriteLine("\tList type arguments ({0}):", 
                typeArguments.Length);

            foreach (Type tParam in typeArguments)
            {
                // IsGenericParameter is true only for generic type
                // parameters.
                //
                if (tParam.IsGenericParameter)
                {
                    Console.WriteLine(
                        "\t\t{0}  (unassigned - parameter position {1})",
                        tParam,
                        tParam.GenericParameterPosition);
                }
                else
                {
                    Console.WriteLine("\t\t{0}", tParam);
                }
            }
        }
    }
}

/* This example produces the following output:

--- Display a generic type and the open constructed
    type from which it is derived.

Derived`1[V]
        Is this a generic type definition? True
        Is it a generic type? True
        Does it have unassigned generic parameters? True
        List type arguments (1):
                V  (unassigned - parameter position 0)

Base`2[System.Int32,V]
        Is this a generic type definition? False
        Is it a generic type? True
        Does it have unassigned generic parameters? True
        List type arguments (2):
                System.Int32
                V  (unassigned - parameter position 0)
 */

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