Este artigo foi traduzido por máquina. Para visualizar o arquivo em inglês, marque a caixa de seleção Inglês. Você também pode exibir o texto Em inglês em uma janela pop-up, movendo o ponteiro do mouse sobre o texto.
Tradução
Inglês

Propriedade Type.ContainsGenericParameters

 

Obtém um valor que indica se o objeto Type atual tem parâmetros de tipo que não foram substituídos por tipos específicos.

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

public virtual bool ContainsGenericParameters { get; }

Valor da Propriedade

Type: System.Boolean

true se o Type objeto é um parâmetro de tipo genérico ou tem parâmetros de tipo para os quais tipos específicos não foram fornecidos; caso contrário, false.

Para criar uma instância de um tipo, não deve haver nenhuma definição de tipo genérico ou tipos construídos abertos nos argumentos de tipo do tipo, em qualquer delimitadores tipos genéricos ou em todos os elementos do tipo. Outra forma de dizer isso é que, quando examinados recursivamente, o tipo não deve conter nenhum parâmetro de tipo genérico.

Como tipos podem ser arbitrariamente complexos, é difícil fazer essa determinação. Para conveniência e reduzir a chance de erro, o ContainsGenericParameters propriedade fornece uma maneira padrão para distinguir entre tipos construídos fechados, que podem ser instanciados e aberta construída tipos, que não é possível. Se o ContainsGenericParameters propriedade retorna true, o tipo não pode ser instanciado.

O ContainsGenericParameters propriedade pesquisa recursivamente para parâmetros de tipo. Por exemplo, ele retorna true para uma matriz cujos elementos são tipo A<T> (A(Of T) no Visual Basic), mesmo que a matriz propriamente dito não é genérico. Compare isso com o comportamento do IsGenericType propriedade, que retorna false para matrizes.

Para um conjunto de classes de exemplo e uma tabela que mostra os valores de ContainsGenericParameters propriedade, consulte IsGenericType.

O exemplo a seguir define uma classe genérica com dois parâmetros de tipo e, em seguida, define uma classe genérica segundo que deriva da classe primeiro. Classe base a classe derivada da tem dois argumentos de tipo: a primeira é Int32 e o segundo é um parâmetro de tipo do tipo derivado. O exemplo exibe informações sobre essas classes genéricas, incluindo as posições relatados pelo GenericParameterPosition propriedade.

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
Disponível desde 2.0
Biblioteca de Classes Portátil
Com suporte no: plataformas portáteis do .NET
Silverlight
Disponível desde 2.0
Windows Phone Silverlight
Disponível desde 7.0
Retornar ao início
Mostrar: