Type.GetGenericParameterConstraints Method

Returns an array of Type objects that represent the constraints on the current generic type parameter.

Return Value

Type: array<System.Type[]
An array of Type objects that represent the constraints on the current generic type parameter.

Imports System.Reflection
' Define a sample interface to use as an interface constraint.
Public Interface ITest
End Interface
' Define a base type to use as a base class constraint.
Public Class Base
End Class
' Define the generic type to examine. The first generic type parameter,
' T, derives from the class Base and implements ITest. This demonstrates
' a base class constraint and an interface constraint. The second generic 
' type parameter, U, must be a reference type (Class) and must have a 
' default constructor (New). This demonstrates special constraints.
'
Public Class Test(Of T As {Base, ITest}, U As {New, Class})
End Class
' Define a type that derives from Base and implements ITtest. This type
' satisfies the constraints on T in class Test.
Public Class Derived
 Inherits Base
 Implements ITest
End Class
Public Class Example
 Public Shared Sub Demo(ByVal outputBlock As System.Windows.Controls.TextBlock)
 ' To get the generic type definition, omit the type
 ' arguments but retain the comma to indicate the number
 ' of type arguments. 
 '
 Dim def As Type = GetType(Test(Of ,))
 outputBlock.Text += String.Format(vbCrLf & "Examining generic type {0}", def) & vbCrLf
 ' Get the type parameters of the generic type definition,
 ' and display them.
 '
 Dim defparams() As Type = def.GetGenericArguments()
 For Each tp As Type In defparams
 outputBlock.Text += String.Format(vbCrLf & "Type parameter: {0}", tp.Name) & vbCrLf
 outputBlock.Text &= vbTab & ListGenericParameterAttributes(tp) & vbCrLf
 ' List the base class and interface constraints. The
 ' constraints do not appear in any particular order. An
 ' empty array is returned if there are no constraints.
 '
 Dim tpConstraints As Type() = _
 tp.GetGenericParameterConstraints()
 For Each tpc As Type In tpConstraints
 outputBlock.Text &= vbTab & tpc.ToString() & vbCrLf
 Next tpc
 Next tp
 End Sub
 ' List the variance and special constraint flags.
 '
 Private Shared Function ListGenericParameterAttributes(ByVal t As Type) As String
 Dim retval As String
 Dim gpa As GenericParameterAttributes = t.GenericParameterAttributes
 ' Select the variance flags.
 Dim variance As GenericParameterAttributes = _
 gpa And GenericParameterAttributes.VarianceMask
 If variance = GenericParameterAttributes.None Then
 retval = "No variance flag;"
 Else
 If (variance And GenericParameterAttributes.Covariant) <> 0 Then
 retval = "Covariant;"
 Else
 retval = "Contravariant;"
 End If
 End If
 ' Select the constraint flags.
 Dim constraints As GenericParameterAttributes = _
 gpa And GenericParameterAttributes.SpecialConstraintMask
 If constraints = GenericParameterAttributes.None Then
 retval &= " no special constraints."
 Else
 If (constraints And GenericParameterAttributes.ReferenceTypeConstraint) <> 0 Then
 retval &= " ReferenceTypeConstraint"
 End If
 If (constraints And GenericParameterAttributes.NotNullableValueTypeConstraint) <> 0 Then
 retval &= " NotNullableValueTypeConstraint"
 End If
 If (constraints And GenericParameterAttributes.DefaultConstructorConstraint) <> 0 Then
 retval &= " DefaultConstructorConstraint"
 End If
 End If
 Return retval
 End Function
End Class
' This example produces the following output:
'
'Examining generic type Test`2[T,U]
'
'Type parameter: T
' No variance flag; no special constraints.
' Base
' ITest
'
'Type parameter: U
' No variance flag; ReferenceTypeConstraint DefaultConstructorConstraint
' 

using System;
using System.Reflection;
// Define a sample interface to use as an interface constraint.
public interface ITest { }
// Define a base type to use as a base class constraint.
public class Base { }
// Define the generic type to examine. The first generic type parameter,
// T, derives from the class Base and implements ITest. This demonstrates
// a base class constraint and an interface constraint. The second generic 
// type parameter, U, must be a reference type (class) and must have a 
// default constructor (new()). This demonstrates special constraints.
//
public class Test<T, U>
 where T : Base, ITest
 where U : class, new() { }
// Define a type that derives from Base and implements ITest. This type
// satisfies the constraints on T in class Test.
public class Derived : Base, ITest { }
public class Example
{
 public static void Demo(System.Windows.Controls.TextBlock outputBlock)
 {
 // To get the generic type definition, omit the type
 // arguments but retain the comma to indicate the number
 // of type arguments. 
 //
 Type def = typeof(Test<,>);
 outputBlock.Text += String.Format("\r\nExamining generic type {0}", def) + "\n";
 // Get the type parameters of the generic type definition,
 // and display them.
 //
 Type[] defparams = def.GetGenericArguments();
 foreach (Type tp in defparams)
 {
 outputBlock.Text += String.Format("\r\nType parameter: {0}", tp.Name) + "\n";
 outputBlock.Text += String.Format("\t{0}",
 ListGenericParameterAttributes(tp)) + "\n";
 // List the base class and interface constraints. The
 // constraints are returned in no particular order. If 
 // there are no class or interface constraints, an empty
 // array is returned.
 //
 Type[] tpConstraints = tp.GetGenericParameterConstraints();
 foreach (Type tpc in tpConstraints)
 {
 outputBlock.Text += String.Format("\t{0}", tpc) + "\n";
 }
 }
 }
 // List the variance and special constraint flags. 
 //
 private static string ListGenericParameterAttributes(Type t)
 {
 string retval;
 GenericParameterAttributes gpa = t.GenericParameterAttributes;
 GenericParameterAttributes variance = gpa &
 GenericParameterAttributes.VarianceMask;
 // Select the variance flags.
 if (variance == GenericParameterAttributes.None)
 retval = "No variance flag;";
 else
 {
 if ((variance & GenericParameterAttributes.Covariant) != 0)
 retval = "Covariant;";
 else
 retval = "Contravariant;";
 }
 // Select 
 GenericParameterAttributes constraints = gpa &
 GenericParameterAttributes.SpecialConstraintMask;
 if (constraints == GenericParameterAttributes.None)
 retval += " No special constraints";
 else
 {
 if ((constraints & GenericParameterAttributes.ReferenceTypeConstraint) != 0)
 retval += " ReferenceTypeConstraint";
 if ((constraints & GenericParameterAttributes.NotNullableValueTypeConstraint) != 0)
 retval += " NotNullableValueTypeConstraint";
 if ((constraints & GenericParameterAttributes.DefaultConstructorConstraint) != 0)
 retval += " DefaultConstructorConstraint";
 }
 return retval;
 }
}
/* This example produces the following output:
Examining generic type Test`2[T,U]
Type parameter: T
 No variance flag; no special constraints.
 Base
 ITest
Type parameter: U
 No variance flag; ReferenceTypeConstraint DefaultConstructorConstraint
 */

Type Class

System Namespace

GenericParameterAttributes

IsGenericParameter

How to: Examine and Instantiate Generic Types with Reflection