Type.IsGenericType Egenskap

Definition

Namnområde:: System

Sammansättningar:: netstandard.dll, System.Runtime.dll

Sammansättning:: System.Runtime.dll

Sammansättning:: mscorlib.dll

Sammansättning:: netstandard.dll

Källa:: Type.cs

Källa:: Type.cs

Källa:: Type.cs

Källa:: Type.cs

Källa:: Type.cs

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Hämtar ett värde som anger om den aktuella typen är en allmän typ.

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

public virtual bool IsGenericType { get; }

member this.IsGenericType : bool

Public Overridable ReadOnly Property IsGenericType As Boolean

Egenskapsvärde

Boolean

trueom den aktuella typen är en allmän typ; annars . false

Exempel

I följande kodexempel visas värdet IsGenericTypeför egenskaperna , IsGenericTypeDefinition, IsGenericParameteroch ContainsGenericParameters för de typer som beskrivs i avsnittet Kommentarer. Förklaringar av egenskapsvärdena finns i den medföljande tabellen i Kommentarer.

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

Kommentarer

Använd egenskapen IsGenericType för att avgöra om ett Type objekt representerar en allmän typ. Använd egenskapen ContainsGenericParameters för att avgöra om ett Type objekt representerar en öppen konstruktionstyp eller en stängd konstruktionstyp.

Note

Egenskapen IsGenericType returnerar false om den omedelbara typen inte är generisk. Till exempel är en matris vars element är av typen A<int> (A(Of Integer) i Visual Basic) inte i sig en allmän typ.

I följande tabell sammanfattas de invarianta villkoren för vanliga termer som används i allmän reflektion.

Begrepp	Invariant
generisk typdefinition	Egenskapen IsGenericTypeDefinition är `true`. Definierar en allmän typ. En konstruerad typ skapas genom att anropa MakeGenericType metoden för ett Type objekt som representerar en allmän typdefinition och ange en matris av typargument. MakeGenericType kan anropas endast på generiska typdefinitioner. Alla generiska typdefinitioner är en allmän typ (egenskapen IsGenericType är `true`), men converse är inte sant.
generisk typ	Egenskapen IsGenericType är `true`. Kan vara en allmän typdefinition, en öppen konstruktionstyp eller en sluten konstruktionstyp. Observera att en matristyp vars elementtyp är generisk är inte i sig en allmän typ. Detsamma gäller för ett Type objekt som representerar en pekare till en allmän typ.
öppen konstruktionstyp	Egenskapen ContainsGenericParameters är `true`. Exempel är en allmän typ som har parametrar av otilldelad typ, en typ som är kapslad i en allmän typdefinition eller i en öppen konstruktionstyp eller en allmän typ som har ett typargument som ContainsGenericParameters egenskapen är `true`för . Det går inte att skapa en instans av en öppen konstruktionstyp. Observera att inte alla öppna konstruktionstyper är generiska. En matris vars elementtyp är en allmän typdefinition är till exempel inte generisk och en pekare till en öppen konstruktionstyp är inte generisk.
sluten konstruktionstyp	Egenskapen ContainsGenericParameters är `false`. När den granskas rekursivt har typen inga otilldelade generiska parametrar.
generisk typparameter	Egenskapen IsGenericParameter är `true`. Egenskapen ContainsGenericParameters är `true`. I en allmän typdefinition, en platshållare för en typ som kommer att tilldelas senare.
argument av generisk typ	Kan vara vilken typ som helst, inklusive en allmän typparameter. Typargument anges som en matris med Type objekt som skickas till MakeGenericType metoden när du skapar en konstruerad allmän typ. Om instanser av den resulterande typen ska skapas ContainsGenericParameters måste egenskapen vara `false` för alla typargument.

Följande kodexempel och tabell illustrerar några av dessa termer och invarianter. Klassen Derived är särskilt intressant eftersom dess bastyp är en konstruerad typ som har en blandning av typer och typparametrar i sin typargumentlista.

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

I följande tabell visas exempel som använder och bygger på klasserna Base, Derivedoch G. När C++ och C#-koden är samma visas bara en post.

Example	Invarianter
`Derived(Of V)` `Derived<V>`	För den här typen: IsGenericType är `true`. IsGenericTypeDefinition är `true`. ContainsGenericParameters är `true`.
`Base(Of String, V)` `Base<String,V>` `Base<String^,V>`	För den här typen: IsGenericType är `true`. IsGenericTypeDefinition är `false`. ContainsGenericParameters är `true`.
`Dim d() As Derived(Of Integer)` `Derived<int>[] d;` `array<Derived<int>^>^ d;`	För typen av variabel `d`: IsGenericType beror `false` på att `d` är en matris. IsGenericTypeDefinition är `false`. ContainsGenericParameters är `false`.
`T`, `U`och `V` (överallt de visas)	IsGenericParameter är `true`. IsGenericType beror `false` på att det inte finns något sätt att begränsa en typparameter till generiska typer. IsGenericTypeDefinition är `false`. ContainsGenericParameters beror `true` på att `T`, `U`och `V` själva är generiska typparametrar. Detta innebär inte något om typargument som tilldelas dem senare.
Typ av fält `F`	IsGenericType är `true`. IsGenericTypeDefinition beror `false` på att en typ har tilldelats till typparametern `G`för . Observera att detta motsvarar att ha anropat MakeGenericType metoden. ContainsGenericParameters beror `true` på att typen av fält `F` har ett typargument som är en öppen konstruktionstyp. Den konstruerade typen är öppen eftersom dess typargument (dvs. `Base`) är en allmän typdefinition. Detta illustrerar egenskapens rekursiva karaktär IsGenericType .
Den kapslade klassen `Nested`	IsGenericType är `true`, även om `Nested` klassen inte har några egna generiska typparametrar, eftersom den är kapslad i en allmän typ. IsGenericTypeDefinition är `true`. Det vill säga, du kan anropa MakeGenericType metoden och ange typparametern för den omslutande typen, `Derived`. ContainsGenericParameters beror `true` på att omslutningstypen , `Derived`har allmänna typparametrar. Detta illustrerar egenskapens rekursiva karaktär ContainsGenericParameters .

Gäller för

Se även

Feedback

Var den här sidan till hjälp?