Type.ContainsGenericParameters Property

Property Value

Type: System.Boolean
true if the Type object is itself a generic type parameter or has type parameters for which specific types have not been supplied; otherwise, false.

Imports System.Reflection
Imports System.Collections.Generic

' Define a base class with two type parameters.
Public Class Base(Of T, U)
End Class

' 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 uses 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 assigned type
' parameter and one unassigned type parameter.
Public Class Derived(Of V)
   Inherits Base(Of Integer, V)
End Class

Public Class Example

   Public Shared Sub Demo(ByVal outputBlock As System.Windows.Controls.TextBlock)
      outputBlock.Text &= vbCrLf _
          & "--- Display a generic type and the open constructed" & vbCrLf
      outputBlock.Text &= "    type from which it is derived." & vbCrLf

      ' 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.) 
      '
      Dim derivedType As Type = GetType(Derived(Of ))
      DisplayGenericTypeInfo(outputBlock, derivedType)

      ' Display its open constructed base type.
      DisplayGenericTypeInfo(outputBlock, derivedType.BaseType)

   End Sub 'Main

   Private Shared Sub DisplayGenericTypeInfo(ByVal outputBlock As System.Windows.Controls.TextBlock, ByVal t As Type)
      outputBlock.Text &= String.Format(vbCrLf & "{0}", t) & vbCrLf

      outputBlock.Text &= vbTab & "Is this a generic type definition? " _
          & t.IsGenericTypeDefinition & vbCrLf

      outputBlock.Text &= vbTab & "Is it a generic type? " _
          & t.IsGenericType & vbCrLf

      outputBlock.Text &= vbTab _
          & "Does it have unassigned generic parameters? " _
          & t.ContainsGenericParameters & vbCrLf

      If t.IsGenericType Then
         ' If this is a generic type, display the type arguments.
         '
         Dim typeArguments As Type() = t.GetGenericArguments()

         outputBlock.Text &= vbTab & "List type arguments (" _
             & typeArguments.Length & "):" & vbCrLf

         For Each tParam As Type In typeArguments
            ' IsGenericParameter is true only for generic type
            ' parameters.
            '
            If tParam.IsGenericParameter Then
               outputBlock.Text &= vbTab & vbTab & tParam.ToString() & _
                   "  (unassigned - parameter position " _
                   & tParam.GenericParameterPosition & ")"
            Else
               outputBlock.Text &= vbTab & vbTab & tParam.ToString() & vbCrLf
            End If
         Next tParam
      End If

   End Sub 'DisplayGenericTypeInfo
End Class 'Test

' 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 parameters (2):
'                System.Int32
'                V  (unassigned - parameter position 0)
' 

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 Example
{
   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      outputBlock.Text +=
          "\r\n--- Display a generic type and the open constructed" + "\n";
      outputBlock.Text += "    type from which it is derived." + "\n";

      // 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(outputBlock, derivedType);

      // Display its open constructed base type.
      DisplayGenericTypeInfo(outputBlock, derivedType.BaseType);
   }

   private static void DisplayGenericTypeInfo(System.Windows.Controls.TextBlock outputBlock, Type t)
   {
      outputBlock.Text += String.Format("\r\n{0}", t) + "\n";

      outputBlock.Text += String.Format("\tIs this a generic type definition? {0}",
          t.IsGenericTypeDefinition) + "\n";

      outputBlock.Text += String.Format("\tIs it a generic type? {0}",
          t.IsGenericType) + "\n";

      outputBlock.Text += String.Format("\tDoes it have unassigned generic parameters? {0}",
          t.ContainsGenericParameters) + "\n";

      if (t.IsGenericType)
      {
         // If this is a generic type, display the type arguments.
         //
         Type[] typeArguments = t.GetGenericArguments();

         outputBlock.Text += String.Format("\tList type arguments ({0}):",
             typeArguments.Length) + "\n";

         foreach (Type tParam in typeArguments)
         {
            // IsGenericParameter is true only for generic type
            // parameters.
            //
            if (tParam.IsGenericParameter)
            {
               outputBlock.Text += String.Format(
                   "\t\t{0}  (unassigned - parameter position {1})",
                   tParam,
                   tParam.GenericParameterPosition) + "\n";
            }
            else
            {
               outputBlock.Text += String.Format("\t\t{0}", tParam) + "\n";
            }
         }
      }
   }
}

/* 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)
 */