Type.IsGenericType Özellik

Tanım

Ad Alanı:: System

Bütünleştirilmiş Kodlar:: netstandard.dll, System.Runtime.dll

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

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ı gösteren 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 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.

Uyarı

Özelliği, IsGenericType anlık 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	Değişmez
genel tür tanımı	IsGenericTypeDefinition özelliği `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. Herhangi bir genel tür tanımı genel bir türdür ( IsGenericType özelliği ), `true`ancak tersi doğru değildir.
genel tür	IsGenericType özelliği `true`. Genel bir tür tanımı, açık bir yapılı 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 türe yönelik bir Type işaretçiyi temsil eden nesne için de geçerlidir.
açık yapılı tür	ContainsGenericParameters özelliği `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 yapılı türün örneğini oluşturmak mümkün değildir. Açık olan tüm 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 türe yönelik işaretçi genel değildir.
kapalı yapılı tür	ContainsGenericParameters özelliği `false`. Özyinelemeli olarak incelendiğinde, türün atanmamış genel parametresi yoktur.
genel tür parametresi	IsGenericParameter özelliği `true`. ContainsGenericParameters özelliği `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, oluşturulduğunda genel 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 bir karışımına sahip olan oluşturulmuş bir tür olduğundan, sınıfı özellikle ilgi çekicidir.

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.

Example	Değişmezler
`Derived(Of V)` `Derived<V>`	Bu tür için: IsGenericType, `true`'e eşittir. IsGenericTypeDefinition, `true`'e eşittir. ContainsGenericParameters, `true`'e eşittir.
`Base(Of String, V)` `Base<String,V>` `Base<String^,V>`	Bu tür için: IsGenericType, `true`'e eşittir. IsGenericTypeDefinition, `false`'e eşittir. ContainsGenericParameters, `true`'e eşittir.
`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`'e eşittir. ContainsGenericParameters, `false`'e eşittir.
`T`, `U`ve `V` (göründükleri her yerde)	IsGenericParameter, `true`'e eşittir. IsGenericType bunun nedeni, tür parametresini genel türlere sınırlamanın hiçbir yolu olmamasıdır `false` . IsGenericTypeDefinition, `false`'e eşittir. ContainsGenericParameters, `trueTU`ve `V` değerlerinin kendi genel tür parametreleri olmasıdır. Bu, daha sonra kendilerine atanan tür bağımsız değişkenleriyle ilgili hiçbir şey ifade etmez.
Alan türü `F`	IsGenericType, `true`'e eşittir. IsGenericTypeDefinition , `false` türü parametresine `G`bir tür atandığı içindir. Bunun yöntemini çağırmaya MakeGenericType eşdeğer olduğunu unutmayın. ContainsGenericParameters bunun `true` nedeni, alan `F` türünün açık olarak oluşturulan bir 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ı türü açık. Bu, özelliğin özyinelemeli doğasını 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`'e eşittir. Başka 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 doğasını ContainsGenericParameters gösterir.

Şunlara uygulanır

Ayrıca bkz.

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?