Export (0) Print
Expand All
1 out of 1 rated this helpful - Rate this topic

Type.GetMethod Method (String, BindingFlags, Binder, Type[], ParameterModifier[])

.NET Framework 1.1

Searches for the specified method whose parameters match the specified argument types and modifiers, using the specified binding constraints.

[Visual Basic]
Overloads Public Overridable Function GetMethod( _
   ByVal name As String, _
   ByVal bindingAttr As BindingFlags, _
   ByVal binder As Binder, _
   ByVal types() As Type, _
   ByVal modifiers() As ParameterModifier _
) As MethodInfo Implements IReflect.GetMethod
[C#]
public virtual MethodInfo GetMethod(
 string name,
 BindingFlags bindingAttr,
 Binder binder,
 Type[] types,
 ParameterModifier[] modifiers
);
[C++]
public: virtual MethodInfo* GetMethod(
 String* name,
 BindingFlags bindingAttr,
 Binder* binder,
 Type* types[],
 ParameterModifier modifiers[]
);
[JScript]
public function GetMethod(
   name : String,
 bindingAttr : BindingFlags,
 binder : Binder,
 types : Type[],
 modifiers : ParameterModifier[]
) : MethodInfo;

Parameters

name
The String containing the name of the method to get.
bindingAttr
A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

-or-

Zero, to return a null reference (Nothing in Visual Basic).

binder
A Binder object that defines a set of properties and enables binding, which can involve selection of an overloaded method, coercion of argument types, and invocation of a member through reflection.

-or-

A null reference (Nothing in Visual Basic), to use the DefaultBinder.

types
An array of Type objects representing the number, order, and type of the parameters for the method to get.

-or-

An empty array of the type Type (that is, Type[] types = new Type[0]) to get a method that takes no parameters.

modifiers
An array of ParameterModifier objects representing the attributes associated with the corresponding element in the types array. The default binder does not process this parameter.

Return Value

A MethodInfo object representing the method that matches the specified requirements, if found; otherwise, a null reference (Nothing in Visual Basic).

Implements

IReflect.GetMethod

Exceptions

Exception Type Condition
AmbiguousMatchException More than one method is found with the specified name and matching the specified binding constraints.
ArgumentNullException name is a null reference (Nothing in Visual Basic).

-or-

types is a null reference (Nothing).

-or-

One of the elements in types is a null reference (Nothing).

ArgumentException types is multidimensional.

-or-

modifiers is multidimensional.

-or-

types and modifiers do not have the same length.

Remarks

Although the default binder does not process ParameterModifier (the modifiers parameter), you can use the abstract System.Reflection.Binder class to write a custom binder that does process modifiers. ParameterModifier is only used when calling through COM interop, and only parameters that are passed by reference are handled.

The types array and the modifiers array have the same length. A parameter specified in the types array can have the following attributes, which are specified in the modifiers array: pdIn, pdOut, pdLcid, pdRetval, pdOptional, and pdHasDefault, which represent [In], [Out], [lcid], [retval], [optional], and a value specifying whether the parameter has a default value. A parameter's associated attributes are stored in the metadata and enhance interoperability.

The following BindingFlags filter flags can be used to define which methods to include in the search:

  • You must specify either BindingFlags.Instance or BindingFlags.Static in order to get a return.
  • Specify BindingFlags.Public to include public methods in the search.
  • Specify BindingFlags.NonPublic to include non-public methods (that is, private and protected members) in the search.
  • Specify BindingFlags.FlattenHierarchy to include static methods up the hierarchy.

The following BindingFlags modifier flags can be used to change how the search works:

  • BindingFlags.IgnoreCase to ignore the case of name.
  • BindingFlags.DeclaredOnly to search only the methods declared on the Type, not methods that were simply inherited.

See System.Reflection.BindingFlags for more information.

If the requested type is non-public and the caller does not have ReflectionPermission to reflect non-public objects outside the current assembly, this method returns a null reference (Nothing in Visual Basic).

Note   You cannot omit parameters when looking up constructors and methods. You can only omit parameters when invoking.

Example

[Visual Basic, C#, C++] The following example gets method information and displays the signature and declaring type.

[Visual Basic] 

Imports System
Imports System.Reflection
Imports Microsoft.VisualBasic

Public Class [MyClass]
    Public i As Integer = 10
    Public k As String = "My Field"
    Public Overloads Function MyMethod(ByVal i As Integer) As Integer
        Me.i = i
        Return i
    End Function 'MyMethod
    Public Overloads Function MyMethod(ByVal k As String) As String
        Me.k = k
        Return k
    End Function 'MyMethod
End Class '[MyClass]
Public Class Type_GetMethod
    Public Shared Sub Main()
        Try
            ' Get the type of MyClass.
            Dim myType As Type = GetType([MyClass])
            ' Get the attributes and metadata of MyMethod.
            Dim myMethodInfo As MethodInfo = myType.GetMethod("MyMethod", BindingFlags.Public Or BindingFlags.Instance, Nothing, New Type() {GetType(Integer)}, Nothing)
            Console.WriteLine(ControlChars.Cr + "Declaring type of the method {0} is : " + " {1}", myMethodInfo, myMethodInfo.DeclaringType.ToString())
            ' Get the attributes and metadata of MyMethod.
            Dim myMethodInfo1 As MethodInfo = myType.GetMethod("MyMethod", BindingFlags.Public Or BindingFlags.Instance, Nothing, New Type() {GetType(String)}, Nothing)
            Console.WriteLine(ControlChars.Cr + "Declaring type of the method {0} is : " + " {1}", myMethodInfo1, myMethodInfo1.DeclaringType.ToString())
        Catch e As Exception
            Console.WriteLine("Exception: {0}", e.Message.ToString())
        End Try
    End Sub 'Main
End Class 'Type_GetMethod

[C#] 

using System;
using System.Reflection;

public class MyClass
{
    public int i = 10;
    public string k = "My Field";
    public int MyMethod(int i)
    {
        this.i = i;
        return i;
    }
    public string MyMethod(string k)
    {
        this.k = k;
        return k;
    }
}
public class Type_GetMethod
{
    public static void Main()
    {
        try
        {
            // Get the type of MyClass.
            Type myType = typeof(MyClass);
            // Get the attributes and metadata of MyMethod.
            MethodInfo myMethodInfo = myType.GetMethod("MyMethod", 
                BindingFlags.Public | BindingFlags.Instance, null, 
                new Type[] {typeof(int)}, null);
            Console.WriteLine("\n Declaring type of the method {0} is: \n {1}", myMethodInfo,
                myMethodInfo.DeclaringType);
            // Get the attributes and metadata of MyMethod.
            MethodInfo myMethodInfo1 = myType.GetMethod("MyMethod", 
                BindingFlags.Public | BindingFlags.Instance, null, 
                new Type[] {typeof(string)}, null);
            Console.WriteLine("\n Declaring type of the method {0} is: \n {1}", myMethodInfo1,
                myMethodInfo1.DeclaringType);
        }
        catch(Exception e)
        {
            Console.WriteLine("Exception: {0}", e.Message);
        }
    }
}

[C++] 

#using <mscorlib.dll>

using namespace System;
using namespace System::Reflection;

public __gc class MyClass {
public:
    int  i;
    String* k ;
    int MyMethod(int i) {
        this->i = i;
        return i;
    }
    String* MyMethod(String* k) {
        this->k = k;
        return k;
    }
};

int main() {
    try {
        // Get the type of MyClass.
        Type*  myType = __typeof(MyClass);
        // Get the attributes and metadata of MyMethod.
        Type* temp0[] = {__typeof(int)};
        MethodInfo*  myMethodInfo = myType->GetMethod(S"MyMethod",
            static_cast<BindingFlags>(BindingFlags::Public | BindingFlags::Instance), 0,
            temp0, 0);
        Console::WriteLine(S"\n Declaring type of the method {0} is: \n {1}", myMethodInfo,
            myMethodInfo->DeclaringType);
        // Get the attributes and metadata of MyMethod.
        Type* temp1[] = {__typeof(String)};
        MethodInfo*  myMethodInfo1 = myType->GetMethod(S"MyMethod",
            static_cast<BindingFlags>(BindingFlags::Public | BindingFlags::Instance), 0,
            temp1, 0);
        Console::WriteLine(S"\n Declaring type of the method {0} is: \n {1}", myMethodInfo1,
            myMethodInfo1->DeclaringType);
    } catch (Exception* e) {
        Console::WriteLine(S"Exception: {0}", e->Message);
    }
}

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button Language Filter in the upper-left corner of the page.

Requirements

Platforms: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 family, .NET Compact Framework, Common Language Infrastructure (CLI) Standard

.NET Framework Security: 

See Also

Type Class | Type Members | System Namespace | Type.GetMethod Overload List | MethodInfo | String | BindingFlags | Binder | DefaultBinder | ParameterModifier | ReflectionPermission | GetMethodImpl | GetMethods

Did you find this helpful?
(1500 characters remaining)
Thank you for your feedback
Show:
© 2014 Microsoft. All rights reserved.