Type.DeclaringMethod Property
Microsoft Silverlight will reach end of support after October 2021. Learn more.
Gets a MethodBase that represents the declaring method, if the current Type represents a type parameter of a generic method.
Namespace: System
Assembly: mscorlib (in mscorlib.dll)
Syntax
'Declaration
Public Overridable ReadOnly Property DeclaringMethod As MethodBase
public virtual MethodBase DeclaringMethod { get; }
Property Value
Type: System.Reflection.MethodBase
If the current Type represents a type parameter of a generic method, a MethodBase that represents declaring method; otherwise, nulla null reference (Nothing in Visual Basic).
Remarks
The declaring method is a generic method definition. That is, if DeclaringMethod does not return nulla null reference (Nothing in Visual Basic), then DeclaringMethod.IsGenericMethodDefinition returns true.
The DeclaringType and DeclaringMethod properties identify the generic type definition or generic method definition in which the generic type parameter was originally defined:
If the DeclaringMethod property returns a MethodInfo, that MethodInfo represents a generic method definition, and the current Type object represents a type parameter of that generic method definition.
If the DeclaringMethod property returns nulla null reference (Nothing in Visual Basic), then the DeclaringType property always returns a Type object representing a generic type definition, and the current Type object represents a type parameter of that generic type definition.
Getting the DeclaringMethod property on a type whose IsGenericParameter property is false throws an InvalidOperationException.
The MethodBase that is returned by the DeclaringMethod property is either a MethodInfo in the case of a generic method, or a ConstructorInfo in the case of a generic constructor.
.gif "Note") Note: |
|---|
In Silverlight, generic constructors are not supported. |
For a list of the invariant conditions for terms used in generic reflection, see the IsGenericType property remarks.
Examples
The following code example defines a class that has a generic method, assigns a type argument to the method, and invokes the resulting constructed generic method. It also displays information about the generic method definition and the constructed method. When displaying information about the type parameters of the generic method definition, in the DisplayGenericMethodInfo method, the example code shows the value of the DeclaringMethod property for the method's generic type parameter.
Imports System.Reflection
' Define a class with a generic method.
Public Class Test
Public Shared Sub Generic(Of T)(ByVal outputBlock As System.Windows.Controls.TextBlock, ByVal toDisplay As T)
outputBlock.Text &= String.Format(vbCrLf & "Here it is: {0}", toDisplay) & vbCrLf
End Sub
End Class
Public Class Example
Public Shared Sub Demo(ByVal outputBlock As System.Windows.Controls.TextBlock)
outputBlock.Text &= vbCrLf & "--- Examine a generic method." & vbCrLf
' Create a Type object representing class Test, and
' get a MethodInfo representing the generic method.
'
Dim ex As Type = GetType(Test)
Dim mi As MethodInfo = ex.GetMethod("Generic")
DisplayGenericMethodInfo(outputBlock, mi)
' Assign the Integer type to the type parameter of the Example
' method.
'
Dim arguments() As Type = {GetType(Integer)}
Dim miConstructed As MethodInfo = mi.MakeGenericMethod(arguments)
DisplayGenericMethodInfo(outputBlock, miConstructed)
' Invoke the method.
Dim args() As Object = {outputBlock, 42}
miConstructed.Invoke(Nothing, args)
' Invoke the method normally.
Test.Generic(Of Integer)(outputBlock, 42)
' Get the generic type definition from the constructed method,
' and show that it's the same as the original definition.
'
Dim miDef As MethodInfo = miConstructed.GetGenericMethodDefinition()
outputBlock.Text &= String.Format(vbCrLf & "The definition is the same: {0}", _
miDef Is mi) & vbCrLf
End Sub 'Main
Private Shared Sub DisplayGenericMethodInfo(ByVal outputBlock As System.Windows.Controls.TextBlock, ByVal mi As MethodInfo)
outputBlock.Text &= vbCrLf & mi.ToString() & vbCrLf
outputBlock.Text &= String.Format(vbTab _
& "Is this a generic method definition? {0}", _
mi.IsGenericMethodDefinition) & vbCrLf
outputBlock.Text &= String.Format(vbTab & "Is it a generic method? {0}", _
mi.IsGenericMethod) & vbCrLf
outputBlock.Text &= String.Format(vbTab _
& "Does it have unassigned generic parameters? {0}", _
mi.ContainsGenericParameters) & vbCrLf
' If this is a generic method, display its type arguments.
'
If mi.IsGenericMethod Then
Dim typeArguments As Type() = mi.GetGenericArguments()
outputBlock.Text &= String.Format(vbTab & "List type arguments ({0}) & vbCrLf:", _
typeArguments.Length)
For Each tParam As Type In typeArguments
' IsGenericParameter is true only for generic type
' parameters.
'
If tParam.IsGenericParameter Then
outputBlock.Text &= String.Format(vbTab & vbTab _
& "{0} parameter position: {1}" _
& vbCrLf & vbTab & vbTab _
& " declaring method: {2}", _
tParam, _
tParam.GenericParameterPosition, _
tParam.DeclaringMethod) & vbCrLf
Else
outputBlock.Text &= vbTab & vbTab & tParam.ToString() & vbCrLf
End If
Next tParam
End If
End Sub
End Class
' This example produces the following output:
'
'--- Examine a generic method.
'
'Void Generic[T](T)
' Is this a generic method definition? True
' Is it a generic method? True
' Does it have unassigned generic parameters? True
' List type arguments (1):
' T parameter position: 0
' declaring method: Void Generic[T](T)
'
'Void Generic[Int32](Int32)
' Is this a generic method definition? False
' Is it a generic method? True
' Does it have unassigned generic parameters? False
' List type arguments (1):
' System.Int32
'
'Here it is: 42
'
'Here it is: 42
'
'The definition is the same: True
'
using System;
using System.Reflection;
// Define a class with a generic method.
public class Test
{
public static void Generic<T>(System.Windows.Controls.TextBlock outputBlock, T toDisplay)
{
outputBlock.Text += String.Format("\r\nHere it is: {0}", toDisplay) + "\n";
}
}
public class Example
{
public static void Demo(System.Windows.Controls.TextBlock outputBlock)
{
outputBlock.Text += "\r\n--- Examine a generic method." + "\n";
// Create a Type object representing class Test, and
// get a MethodInfo representing the generic method.
//
Type ex = typeof(Test);
MethodInfo mi = ex.GetMethod("Generic");
DisplayGenericMethodInfo(outputBlock, mi);
// Assign the int type to the type parameter of the Example
// method.
//
MethodInfo miConstructed = mi.MakeGenericMethod(typeof(int));
DisplayGenericMethodInfo(outputBlock, miConstructed);
// Invoke the method.
object[] args = {outputBlock, 42};
miConstructed.Invoke(null, args);
// Invoke the method normally.
Test.Generic<int>(outputBlock, 42);
// Get the generic type definition from the closed method,
// and show it's the same as the original definition.
//
MethodInfo miDef = miConstructed.GetGenericMethodDefinition();
outputBlock.Text += String.Format("\r\nThe definition is the same: {0}",
miDef == mi) + "\n";
}
private static void DisplayGenericMethodInfo(System.Windows.Controls.TextBlock outputBlock, MethodInfo mi)
{
outputBlock.Text += String.Format("\r\n{0}", mi) + "\n";
outputBlock.Text += String.Format("\tIs this a generic method definition? {0}",
mi.IsGenericMethodDefinition) + "\n";
outputBlock.Text += String.Format("\tIs it a generic method? {0}",
mi.IsGenericMethod) + "\n";
outputBlock.Text += String.Format("\tDoes it have unassigned generic parameters? {0}",
mi.ContainsGenericParameters) + "\n";
// If this is a generic method, display its type arguments.
//
if (mi.IsGenericMethod)
{
Type[] typeArguments = mi.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} parameter position {1}" +
"\n\t\t declaring method: {2}",
tParam,
tParam.GenericParameterPosition,
tParam.DeclaringMethod) + "\n";
}
else
{
outputBlock.Text += String.Format("\t\t{0}", tParam) + "\n";
}
}
}
}
}
/* This example produces the following output:
--- Examine a generic method.
Void Generic[T](T)
Is this a generic method definition? True
Is it a generic method? True
Does it have unassigned generic parameters? True
List type arguments (1):
T parameter position 0
declaring method: Void Generic[T](T)
Void Generic[Int32](Int32)
Is this a generic method definition? False
Is it a generic method? True
Does it have unassigned generic parameters? False
List type arguments (1):
System.Int32
Here it is: 42
Here it is: 42
The definition is the same: True
*/
Version Information
Silverlight
Supported in: 5, 4, 3
Silverlight for Windows Phone
Supported in: Windows Phone OS 7.1, Windows Phone OS 7.0
XNA Framework
Supported in: Xbox 360, Windows Phone OS 7.0
Platforms
For a list of the operating systems and browsers that are supported by Silverlight, see Supported Operating Systems and Browsers.
See Also