Esporta (0) Stampa
Espandi tutto
Espandi Riduci a icona
Il presente articolo è stato tradotto automaticamente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

Proprietà Type.GenericParameterPosition

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à

Tipo: 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.

EccezioneCondizione
InvalidOperationException

Il tipo corrente non rappresenta un parametro di tipo, ovvero la proprietà IsGenericParameter restituisce false.

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

  • Se la proprietà DeclaringMethod restituisce una classe MethodInfo, tale classe MethodInfo rappresenta una definizione di metodo generico e l'oggetto Type corrente rappresenta un parametro di tipo della definizione di metodo generico.

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

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


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 a GetSomething. È possibile ottenere una classe MethodInfo per GetSomething e ottenere da essa il tipo restituito. Quando si esaminano i parametri di tipo del tipo restituito, la proprietà GenericParameterPosition restituisce 0 per entrambi. La posizione di V è 0 poiché V è il primo parametro di tipo nell'elenco di parametri di tipo per la classe A. La posizione di X è 0 poiché X è il primo parametro di tipo nell'elenco di parametri di tipo per GetSomething.

NotaNota

Se l'oggetto Type corrente non rappresenta un parametro di tipo, la chiamata della proprietà GenericParameterPosition genera un'eccezione. Quando si esaminano gli argomenti di tipo di un tipo costruito aperto, utilizzare la proprietà IsGenericParameter per individuare i parametri di tipo e i tipi. La proprietà IsGenericParameter restituisce true per un parametro di tipo. È quindi possibile utilizzare il metodo della proprietà GenericParameterPosition per ottenerne la posizione e le proprietà DeclaringMethod e DeclaringType per determinare la definizione del tipo o del metodo generico che lo definisce.

Nell'esempio riportato di seguito vengono definite una classe generica con due parametri di tipo e una seconda classe generica che deriva dalla prima. La classe base della classe derivata comprende 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 dalla proprietà GenericParameterPosition.


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


.NET Framework

Supportato in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Supportato in: 4, 3.5 SP1

Libreria di classi portabile

Supportato in: Libreria di classi portabile

.NET per applicazioni Windows Store

Supportato in: Windows 8

.NET per applicazioni Windows Phone

Supportato in: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (ruoli di base del server non supportati), Windows Server 2008 R2 (ruoli di base del server supportati con SP1 o versione successiva, Itanium non supportato)

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft