Questa pagina è stata utile?
I suggerimenti relativi al contenuto di questa pagina sono importanti. Comunicaceli.
Altri suggerimenti?
1500 caratteri rimanenti
Esporta (0) Stampa
Espandi tutto
Espandi Riduci a icona

Proprietà Type.GenericParameterPosition

Nota: questa proprietà è stata introdotta con .NET Framework versione 2.0.

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; }
/** @property */
public int get_GenericParameterPosition ()

public function get GenericParameterPosition () : int

Valore proprietà

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.

Tipo di 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 riferimento null (Nothing in Visual Basic), 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)
 */

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile per Pocket PC, Windows Mobile per Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

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

.NET Framework

Supportato in: 2.0

Aggiunte alla community

AGGIUNGI
Mostra:
© 2015 Microsoft