Type.IsGenericType Özellik

Başvuru

Tanım

Ad Alanı:: System

Bütünleştirilmiş Kod:: System.Runtime.dll

Bütünleştirilmiş Kod:: mscorlib.dll

Bütünleştirilmiş Kod:: netstandard.dll

Kaynak:: Type.cs

Kaynak:: Type.cs

Kaynak:: Type.cs

Önemli

Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.

Geçerli türün genel bir tür olup olmadığını belirten bir değer alır.

public:
 virtual property bool IsGenericType { bool get(); };

public virtual bool IsGenericType { get; }

member this.IsGenericType : bool

Public Overridable ReadOnly Property IsGenericType As Boolean

Özellik Değeri

Boolean

true geçerli tür genel bir türse; aksi takdirde , false.

Örnekler

Aşağıdaki kod örneği, Açıklamalar bölümünde açıklanan türlerin , IsGenericTypeDefinition, IsGenericParameterve ContainsGenericParameters özelliklerinin değerini IsGenericTypegörüntüler. Özellik değerlerinin açıklamaları için Açıklamalar'daki eşlik eden tabloya bakın.

using namespace System;
using namespace System::Reflection;

generic<typename T, typename U> public ref class Base {};

generic<typename T> public ref class G {};

generic<typename V> public ref class Derived : Base<String^, V>
{
public: 
    G<Derived<V>^>^ F;

    ref class Nested {};
};

void DisplayGenericType(Type^ t, String^ caption)
{
    Console::WriteLine("\n{0}", caption);
    Console::WriteLine("    Type: {0}", t);

    Console::WriteLine("\t            IsGenericType: {0}", 
        t->IsGenericType);
    Console::WriteLine("\t  IsGenericTypeDefinition: {0}", 
        t->IsGenericTypeDefinition);
    Console::WriteLine("\tContainsGenericParameters: {0}", 
        t->ContainsGenericParameters);
    Console::WriteLine("\t       IsGenericParameter: {0}", 
        t->IsGenericParameter);
}

void main()
{
    // Get the generic type definition for Derived, and the base
    // type for Derived.
    //
    Type^ tDerived = Derived::typeid;
    Type^ tDerivedBase = tDerived->BaseType;

    // Declare an array of Derived<int>, and get its type.
    //
    array<Derived<int>^>^ d = gcnew array<Derived<int>^>(0);
    Type^ tDerivedArray = d->GetType();

    // Get a generic type parameter, the type of a field, and a
    // type that is nested in Derived. Notice that in order to
    // get the nested type it is necessary to either (1) specify
    // the generic type definition Derived::typeid, as shown here,
    // or (2) specify a type parameter for Derived.
    //
    Type^ tT = Base::typeid->GetGenericArguments()[0];
    Type^ tF = tDerived->GetField("F")->FieldType;
    Type^ tNested = Derived::Nested::typeid;

    DisplayGenericType(tDerived, "generic<V> Derived");
    DisplayGenericType(tDerivedBase, "Base type of generic<V> Derived");
    DisplayGenericType(tDerivedArray, "Array of Derived<int>");
    DisplayGenericType(tT, "Type parameter T from generic<T> Base");
    DisplayGenericType(tF, "Field type, G<Derived<V>^>^");
    DisplayGenericType(tNested, "Nested type in generic<V> Derived");
}

/* This code example produces the following output:

generic<V> Derived
    Type: Derived`1[V]
                    IsGenericType: True
          IsGenericTypeDefinition: True
        ContainsGenericParameters: True
               IsGenericParameter: False

Base type of generic<V> Derived
    Type: Base`2[System.String,V]
                    IsGenericType: True
          IsGenericTypeDefinition: False
        ContainsGenericParameters: True
               IsGenericParameter: False

Array of Derived<int>
    Type: Derived`1[System.Int32][]
                    IsGenericType: False
          IsGenericTypeDefinition: False
        ContainsGenericParameters: False
               IsGenericParameter: False

Type parameter T from generic<T> Base
    Type: T
                    IsGenericType: False
          IsGenericTypeDefinition: False
        ContainsGenericParameters: True
               IsGenericParameter: True

Field type, G<Derived<V>^>^
    Type: G`1[Derived`1[V]]
                    IsGenericType: True
          IsGenericTypeDefinition: False
        ContainsGenericParameters: True
               IsGenericParameter: False

Nested type in generic<V> Derived
    Type: Derived`1+Nested[V]
                    IsGenericType: True
          IsGenericTypeDefinition: True
        ContainsGenericParameters: True
               IsGenericParameter: False
 */

using System;
using System.Reflection;

public class Base<T, U> {}

public class Derived<V> : Base<string, V>
{
    public G<Derived <V>> F;

    public class Nested {}
}

public class G<T> {}

class Example
{
    public static void Main()
    {
        // Get the generic type definition for Derived, and the base
        // type for Derived.
        //
        Type tDerived = typeof(Derived<>);
        Type tDerivedBase = tDerived.BaseType;

        // Declare an array of Derived<int>, and get its type.
        //
        Derived<int>[] d = new Derived<int>[0];
        Type tDerivedArray = d.GetType();

        // Get a generic type parameter, the type of a field, and a
        // type that is nested in Derived. Notice that in order to
        // get the nested type it is necessary to either (1) specify
        // the generic type definition Derived<>, as shown here,
        // or (2) specify a type parameter for Derived.
        //
        Type tT = typeof(Base<,>).GetGenericArguments()[0];
        Type tF = tDerived.GetField("F").FieldType;
        Type tNested = typeof(Derived<>.Nested);

        DisplayGenericType(tDerived, "Derived<V>");
        DisplayGenericType(tDerivedBase, "Base type of Derived<V>");
        DisplayGenericType(tDerivedArray, "Array of Derived<int>");
        DisplayGenericType(tT, "Type parameter T from Base<T>");
        DisplayGenericType(tF, "Field type, G<Derived<V>>");
        DisplayGenericType(tNested, "Nested type in Derived<V>");
    }

    public static void DisplayGenericType(Type t, string caption)
    {
        Console.WriteLine("\n{0}", caption);
        Console.WriteLine("    Type: {0}", t);

        Console.WriteLine("\t            IsGenericType: {0}", 
            t.IsGenericType);
        Console.WriteLine("\t  IsGenericTypeDefinition: {0}", 
            t.IsGenericTypeDefinition);
        Console.WriteLine("\tContainsGenericParameters: {0}", 
            t.ContainsGenericParameters);
        Console.WriteLine("\t       IsGenericParameter: {0}", 
            t.IsGenericParameter);
    }
}

/* This code example produces the following output:

Derived<V>
    Type: Derived`1[V]
                    IsGenericType: True
          IsGenericTypeDefinition: True
        ContainsGenericParameters: True
               IsGenericParameter: False

Base type of Derived<V>
    Type: Base`2[System.String,V]
                    IsGenericType: True
          IsGenericTypeDefinition: False
        ContainsGenericParameters: True
               IsGenericParameter: False

Array of Derived<int>
    Type: Derived`1[System.Int32][]
                    IsGenericType: False
          IsGenericTypeDefinition: False
        ContainsGenericParameters: False
               IsGenericParameter: False

Type parameter T from Base<T>
    Type: T
                    IsGenericType: False
          IsGenericTypeDefinition: False
        ContainsGenericParameters: True
               IsGenericParameter: True

Field type, G<Derived<V>>
    Type: G`1[Derived`1[V]]
                    IsGenericType: True
          IsGenericTypeDefinition: False
        ContainsGenericParameters: True
               IsGenericParameter: False

Nested type in Derived<V>
    Type: Derived`1+Nested[V]
                    IsGenericType: True
          IsGenericTypeDefinition: True
        ContainsGenericParameters: True
               IsGenericParameter: False
 */

open System

type Base<'T, 'U>() = class end

type G<'T>() = class end

type Derived<'V>() =
    inherit Base<string, 'V>()
    
    [<DefaultValue>]
    val mutable public F : G<Derived<'V>>

let displayGenericType (t: Type) caption =
    printfn $"\n{caption}"
    printfn $"    Type: {t}"

    printfn $"\t            IsGenericType: {t.IsGenericType}" 
    printfn $"\t  IsGenericTypeDefinition: {t.IsGenericTypeDefinition}" 
    printfn $"\tContainsGenericParameters: {t.ContainsGenericParameters}"
    printfn $"\t       IsGenericParameter: {t.IsGenericParameter}"

// Get the generic type definition for Derived, and the base
// type for Derived.
let tDerived = typeof<Derived<_>>.GetGenericTypeDefinition()
let tDerivedBase = tDerived.BaseType

// Declare an array of Derived<int>, and get its type.
let d = Array.zeroCreate<Derived<int>> 0
let tDerivedArray = d.GetType()

// Get a generic type parameter, the type of a field, and a
// type that is nested in Derived. Notice that in order to
// get the nested type it is necessary to either (1) specify
// the generic type definition Derived<>, as shown here,
// or (2) specify a type parameter for Derived.
let tT = typeof<Base<_,_>>.GetGenericTypeDefinition().GetGenericArguments()[0]
let tF = tDerived.GetField("F").FieldType

displayGenericType tDerived "Derived<V>"
displayGenericType tDerivedBase "Base type of Derived<V>"
displayGenericType tDerivedArray "Array of Derived<int>"
displayGenericType tT "Type parameter T from Base<T>"
displayGenericType tF "Field type, G<Derived<V>>"

(* This code example produces the following output:

Derived<V>
    Type: Derived`1[V]
                    IsGenericType: True
          IsGenericTypeDefinition: True
        ContainsGenericParameters: True
               IsGenericParameter: False

Base type of Derived<V>
    Type: Base`2[System.String,V]
                    IsGenericType: True
          IsGenericTypeDefinition: False
        ContainsGenericParameters: True
               IsGenericParameter: False

Array of Derived<int>
    Type: Derived`1[System.Int32][]
                    IsGenericType: False
          IsGenericTypeDefinition: False
        ContainsGenericParameters: False
               IsGenericParameter: False

Type parameter T from Base<T>
    Type: T
                    IsGenericType: False
          IsGenericTypeDefinition: False
        ContainsGenericParameters: True
               IsGenericParameter: True

Field type, G<Derived<V>>
    Type: G`1[Derived`1[V]]
                    IsGenericType: True
          IsGenericTypeDefinition: False
        ContainsGenericParameters: True
               IsGenericParameter: False
 *)

Imports System.Reflection

' 
Public Class Base(Of T, U)
End Class

Public Class Derived(Of V) 
    Inherits Base(Of String, V)

    Public F As G(Of Derived(Of V))

    Public Class Nested
    End Class
End Class

Public Class G(Of T)
End Class 

Module Example

    Sub Main

        ' Get the generic type definition for Derived, and the base
        ' type for Derived.
        '
        Dim tDerived As Type = GetType(Derived(Of ))
        Dim tDerivedBase As Type = tDerived.BaseType

        ' Declare an array of Derived(Of Integer), and get its type.
        '
        Dim d(0) As Derived(Of Integer)
        Dim tDerivedArray As Type = d.GetType()

        ' Get a generic type parameter, the type of a field, and a
        ' type that is nested in Derived. Notice that in order to
        ' get the nested type it is necessary to either (1) specify
        ' the generic type definition Derived(Of ), as shown here,
        ' or (2) specify a type parameter for Derived.
        '
        Dim tT As Type = GetType(Base(Of ,)).GetGenericArguments()(0)
        Dim tF As Type = tDerived.GetField("F").FieldType
        Dim tNested As Type = GetType(Derived(Of ).Nested)

        DisplayGenericType(tDerived, "Derived(Of V)")
        DisplayGenericType(tDerivedBase, "Base type of Derived(Of V)")
        DisplayGenericType(tDerivedArray, "Array of Derived(Of Integer)")
        DisplayGenericType(tT, "Type parameter T from Base(Of T)")
        DisplayGenericType(tF, "Field type, G(Of Derived(Of V))")
        DisplayGenericType(tNested, "Nested type in Derived(Of V)")

    End Sub

    Sub DisplayGenericType(ByVal t As Type, ByVal caption As String)

        Console.WriteLine(vbLf & caption)
        Console.WriteLine("    Type: {0}", t)

        Console.WriteLine(vbTab & "            IsGenericType: {0}", _
            t.IsGenericType)
        Console.WriteLine(vbTab & "  IsGenericTypeDefinition: {0}", _
            t.IsGenericTypeDefinition)
        Console.WriteLine(vbTab & "ContainsGenericParameters: {0}", _
            t.ContainsGenericParameters)
        Console.WriteLine(vbTab & "       IsGenericParameter: {0}", _
            t.IsGenericParameter)

    End Sub

End Module

' This code example produces the following output:
'
'Derived(Of V)
'    Type: Derived`1[V]
'                    IsGenericType: True
'          IsGenericTypeDefinition: True
'        ContainsGenericParameters: True
'               IsGenericParameter: False
'
'Base type of Derived(Of V)
'    Type: Base`2[System.String,V]
'                    IsGenericType: True
'          IsGenericTypeDefinition: False
'        ContainsGenericParameters: True
'               IsGenericParameter: False
'
'Array of Derived(Of Integer)
'    Type: Derived`1[System.Int32][]
'                    IsGenericType: False
'          IsGenericTypeDefinition: False
'        ContainsGenericParameters: False
'               IsGenericParameter: False
'
'Type parameter T from Base(Of T)
'    Type: T
'                    IsGenericType: False
'          IsGenericTypeDefinition: False
'        ContainsGenericParameters: True
'               IsGenericParameter: True
'
'Field type, G(Of Derived(Of V))
'    Type: G`1[Derived`1[V]]
'                    IsGenericType: True
'          IsGenericTypeDefinition: False
'        ContainsGenericParameters: True
'               IsGenericParameter: False
'
'Nested type in Derived(Of V)
'    Type: Derived`1+Nested[V]
'                    IsGenericType: True
'          IsGenericTypeDefinition: True
'        ContainsGenericParameters: True
'               IsGenericParameter: False

Açıklamalar

Bir nesnenin IsGenericType genel bir Type türü temsil edip etmediğini belirlemek için özelliğini kullanın. Bir nesnenin ContainsGenericParameters açık bir yapılı türü mü yoksa kapalı bir yapılı türü mü temsil edip etmediğini Type belirlemek için özelliğini kullanın.

Not

Özelliği, IsGenericType hemen türü genel değilse döndürür false . Örneğin, öğeleri türünde A<int> olan bir dizi (A(Of Integer) Visual Basic'te) kendisi genel bir tür değildir.

Aşağıdaki tabloda, genel yansımada kullanılan yaygın terimler için sabit koşullar özetlemektedir.

Süre	Sabit
genel tür tanımı	IsGenericTypeDefinition özelliğidir`true`. Genel bir tür tanımlar. Oluşturulan tür, genel tür tanımını temsil eden bir Type nesnede yöntemini çağırarak MakeGenericType ve tür bağımsız değişkenlerinden oluşan bir dizi belirterek oluşturulur. MakeGenericType yalnızca genel tür tanımlarında çağrılabilir. Genel tür tanımları genel bir türdür ( IsGenericType özelliğidir `true`), ancak ters doğru değildir.
genel tür	IsGenericType özelliğidir`true`. Genel bir tür tanımı, açık bir tür veya kapalı bir yapılı tür olabilir. Öğe türü genel olan bir dizi türünün kendisi genel bir tür olmadığını unutmayın. Aynı durum, genel bir türe yönelik işaretçiyi Type temsil eden nesne için de geçerlidir.
açık yapılı tür	ContainsGenericParameters özelliğidir`true`. Örnek olarak atanmamış tür parametreleri olan genel bir tür, genel tür tanımında veya açık bir tür içinde iç içe yerleştirilmiş bir tür veya özelliğinin olduğu tür bağımsız değişkenine ContainsGenericParameters sahip genel bir tür verilebilir `true`. açık bir tür örneği oluşturmak mümkün değildir. Tüm açık yapılı türlerin genel olmadığını unutmayın. Örneğin, öğe türü genel tür tanımı olan bir dizi genel değildir ve açık bir yapılı türün işaretçisi genel değildir.
kapalı yapılı tür	ContainsGenericParameters özelliğidir`false`. Özyinelemeli olarak incelendiğinde, türün atanmamış genel parametreleri yoktur.
genel tür parametresi	IsGenericParameter özelliğidir`true`. ContainsGenericParameters özelliğidir`true`. Genel tür tanımında, daha sonra atanacak bir tür için yer tutucu.
genel tür bağımsız değişkeni	Genel tür parametresi de dahil olmak üzere herhangi bir tür olabilir. Tür bağımsız değişkenleri, bir tür oluşturulurken yöntemine MakeGenericType geçirilen bir nesne dizisi Type olarak belirtilir. Sonuçta elde edilen türün örnekleri oluşturulacaksa, ContainsGenericParameters özelliği tüm tür bağımsız değişkenleri için olmalıdır `false` .

Aşağıdaki kod örneği ve tablosu bu terimlerden ve sabit değerlerden bazılarını göstermektedir. Derived Temel türü, tür bağımsız değişken listesinde türlerin ve tür parametrelerinin karışımına sahip oluşturulmuş bir tür olduğundan, sınıfı özellikle ilgi çekicidir.

generic<typename T, typename U> public ref class Base {};

generic<typename T> public ref class G {};

generic<typename V> public ref class Derived : Base<String^, V>
{
public:
    G<Derived<V>^>^ F;

    ref class Nested {};
};

public class Base<T, U> {}

public class Derived<V> : Base<string, V>
{
    public G<Derived <V>> F;

    public class Nested {}
}

public class G<T> {}

type Base<'T, 'U>() = class end

type G<'T>() = class end

type Derived<'V>() =
    inherit Base<string, 'V>()
    
    [<DefaultValue>]
    val mutable public F : G<Derived<'V>>

Public Class Base(Of T, U)
End Class

Public Class Derived(Of V)
    Inherits Base(Of String, V)

    Public F As G(Of Derived(Of V))

    Public Class Nested
    End Class
End Class

Public Class G(Of T)
End Class

Aşağıdaki tabloda , Derivedve Gsınıflarını Basekullanan ve üzerinde derleyen örnekler gösterilmektedir. C++ ve C# kodu aynı olduğunda, yalnızca bir giriş gösterilir.

Örnek	Invariants
`Derived(Of V)` `Derived<V>`	Bu tür için: IsGenericType, `true` değeridir. IsGenericTypeDefinition, `true` değeridir. ContainsGenericParameters, `true` değeridir.
`Base(Of String, V)` `Base<String,V>` `Base<String^,V>`	Bu tür için: IsGenericType, `true` değeridir. IsGenericTypeDefinition, `false` değeridir. ContainsGenericParameters, `true` değeridir.
`Dim d() As Derived(Of Integer)` `Derived<int>[] d;` `array<Derived<int>^>^ d;`	değişkeninin `d`türü için: IsGenericType çünkü `falsed` bir dizidir. IsGenericTypeDefinition, `false` değeridir. ContainsGenericParameters, `false` değeridir.
`T`, `U`ve `V` (göründükleri her yerde)	IsGenericParameter, `true` değeridir. IsGenericType bunun nedeni, tür parametresini genel türlere kısıtlamanın hiçbir yolu olmamasıdır `false` . IsGenericTypeDefinition, `false` değeridir. ContainsGenericParameters, `T`ve `UV` değerlerinin kendi genel tür parametreleri olmasıdır`true`. Bu, daha sonra kendilerine atanan tür bağımsız değişkenleriyle ilgili hiçbir şey ifade etmez.
Alanın türü `F`	IsGenericType, `true` değeridir. IsGenericTypeDefinition , `false` türün type parametresine atanmış olmasıdır `G`. Bunun yöntemini çağırmakla MakeGenericType eşdeğer olduğunu unutmayın. ContainsGenericParameters bunun `true` nedeni, alan `F` türünün açık bir tür olan tür bağımsız değişkenine sahip olmasıdır. Tür bağımsız değişkeni (yani) genel bir tür tanımı olduğundan, `Base`yapılı tür açık. Bu, özelliğin özyinelemeli niteliğini IsGenericType gösterir.
İç içe geçmiş sınıf `Nested`	IsGenericType sınıfı `true`, kendi genel tür parametrelerine sahip olmasa `Nested` da, genel bir tür içinde iç içe geçmiş olsa da olur. IsGenericTypeDefinition, `true` değeridir. Diğer bir ifadeyle MakeGenericType yöntemini çağırabilir ve kapsayan türün `Derived`type parametresini sağlayabilirsiniz. ContainsGenericParameters, kapsayan türün `Derived`genel tür parametrelerine sahip olmasıdır`true`. Bu, özelliğin özyinelemeli niteliğini ContainsGenericParameters gösterir.

Şunlara uygulanır

Aracılığıyla paylaş