Exportar (0) Imprimir
Expandir todo
Expandir Minimizar
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

Type.ContainsGenericParameters (Propiedad)

Obtiene un valor que indica si el objeto Type actual tiene parámetros de tipo que no han sido reemplazados por tipos específicos.

Espacio de nombres:  System
Ensamblado:  mscorlib (en mscorlib.dll)

public virtual bool ContainsGenericParameters { get; }

Valor de propiedad

Tipo: System.Boolean
true si el objeto Type es un parámetro de tipo genérico o tiene parámetros de tipo para los que no se han proporcionado tipos específicos; de lo contrario, es false.

Para crear una instancia de un tipo, no debe haber definiciones de tipo genérico o tipos construidos abiertos en los argumentos del propio tipo, en ningún tipo genérico envolvente o en ningún elemento del tipo. Otro modo de decir esto es que cuando el tipo se examina de forma recursiva, no debe contener parámetros de tipo genérico.

Dado que los tipos pueden ser arbitrariamente complejos, es difícil tomar esta determinación. Por comodidad y para reducir la posibilidad de errores, la propiedad ContainsGenericParameters proporciona un modo estándar de distinguir entre tipos construidos cerrados, de los que se pueden crear instancias, y tipos construidos abiertos, de los que no se pueden crear instancias. Si la propiedad ContainsGenericParameters devuelve true, no se puede crear una instancia del tipo.

La propiedad ContainsGenericParameters busca los parámetros de tipo de forma recursiva. Por ejemplo, devuelve true para una matriz cuyos elementos son de tipo A<T> (A(Of T) en Visual Basic), aunque la matriz no sea genérica. Compare esto con el comportamiento de la propiedad IsGenericType, que devuelve false para las matrices.

Para obtener un conjunto de clases de ejemplo y una tabla que muestra los valores de la propiedad ContainsGenericParameters, vea IsGenericType.

En el ejemplo siguiente se define una clase genérica con dos parámetros de tipo y, a continuación, se define una segunda clase genérica que se deriva de la primera clase. La clase base de la clase derivada tiene dos argumentos de tipo: el primero es Int32 y el segundo es un parámetro de tipo del tipo derivado. En el ejemplo se muestra información acerca de estas clases genéricas, incluidas las posiciones de las que informa la propiedad 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

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Biblioteca de clases portable

Compatible con: Biblioteca de clases portable

.NET para aplicaciones de Windows Phone

Compatible con: 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 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft