Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Proprietà Type.GenericParameterPosition

 

Data di pubblicazione: ottobre 2016

Ottiene la posizione del parametro di tipo nell'elenco di parametri di tipo del tipo o del metodo generico che ha dichiarato il parametro, quando l'oggetto Type rappresenta un parametro di tipo di un tipo o un metodo generico.

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

public virtual int GenericParameterPosition { get; }

Valore proprietà

Type: System.Int32

Posizione del parametro di tipo nell'elenco dei parametri di tipo del tipo o del metodo generico che definisce il parametro. I numeri di posizione iniziano da 0.

Exception Condition
InvalidOperationException

Il tipo corrente non rappresenta un parametro di tipo. Ciò significa che IsGenericParameter restituisce false.

Il GenericParameterPosition proprietà restituisce la posizione di un parametro di tipo nell'elenco dei parametri della definizione di tipo generico o definizione di metodo generico in cui è stato originariamente definito il parametro di tipo. Il DeclaringType e DeclaringMethod identificano la definizione di tipo o metodo generica:

  • Se il DeclaringMethod restituisce un MethodInfo, che MethodInfo rappresenta una definizione di metodo generico e corrente Type oggetto rappresenta un parametro di tipo della definizione di metodo generico.

  • Se il DeclaringMethod restituisce proprietà null, la DeclaringType proprietà restituisce sempre un Type oggetto che rappresenta una definizione di tipo generico e corrente Type oggetto rappresenta un parametro di tipo della definizione di tipo generico.

Per fornire il contesto corretto per il valore di GenericParameterPosition proprietà, è necessario identificare il tipo o metodo generico appartiene a un parametro di tipo. Si consideri ad esempio il valore restituito del metodo generico GetSomething nel codice seguente:

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

Il tipo restituito da GetSomething dipende dagli argomenti di tipo forniti alla classe A e GetSomething stesso. È possibile ottenere un MethodInfo per GetSomething, e da cui è possibile ottenere il tipo restituito. Quando si esaminano i parametri di tipo del tipo restituito, GenericParameterPosition restituisce 0 per entrambi. La posizione di V è 0 perché V è il primo parametro di tipo nell'elenco dei parametri di tipo per la classe A. La posizione di X è 0 perché X è il primo parametro di tipo nell'elenco dei parametri di tipo per GetSomething.

System_CAPS_noteNota

La chiamata di GenericParameterPosition proprietà genera un'eccezione se l'oggetto corrente Type non rappresenta un parametro di tipo. Quando si esaminano gli argomenti di tipo di un tipo costruito aperto, utilizzare il IsGenericParameter proprietà per indicare che sono parametri di tipo e i tipi. Il IsGenericParameter restituisce proprietà true per un parametro di tipo; è quindi possibile utilizzare il GenericParameterPosition metodo per ottenere la posizione e utilizzare il DeclaringMethod e DeclaringType proprietà per determinare il metodo generico o di tipo definizione che lo definisce.

Nell'esempio seguente definisce una classe generica con due parametri di tipo e una seconda classe generica da cui deriva la prima classe. Classe di base della classe derivata dispone di due argomenti di tipo: il primo è Int32, e il secondo è un parametro di tipo del tipo derivato. Nell'esempio vengono visualizzate informazioni su queste classi generiche, incluse le posizioni riportate per il GenericParameterPosition proprietà.

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)
 */

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 2.0
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: