Public Class A
    Public Overridable Function method() As Integer
        Return 0
    End Function
End Class

Public Class B
    Public Overridable Function method() As Integer
        Return 1
    End Function
End Class

Class Mymethodinfo

    Public Shared Function Main() As Integer
        Console.WriteLine("Reflection.MethodInfo")
        Console.WriteLine()
        Dim MyA As New A()
        Dim MyB As New B()

        'Get the Type and MethodInfo
        Dim MyTypea As Type = Type.GetType("A")
        Dim Mymethodinfoa As MethodInfo = MyTypea.GetMethod("method")

        Dim MyTypeb As Type = Type.GetType("B")
        Dim Mymethodinfob As MethodInfo = MyTypeb.GetMethod("method")

        'Get and display the Invoke method
        Console.WriteLine("First method - {0} returns {1}", MyTypea.FullName, _
            Mymethodinfoa.Invoke(MyA, Nothing).ToString())
        Console.WriteLine("Second method - {0} returns {1}", MyTypeb.FullName, _
           Mymethodinfob.Invoke(MyB, Nothing).ToString())
        Return 0
    End Function
End Class

using System;
using System.Reflection;
using System.Windows.Forms;

public class A
{
    public virtual int method () {return 0;}
}

public class B
{
    public virtual int method () {return 1;}
}

class Mymethodinfo
{
    public static int Main()
    {
        Console.WriteLine ("\nReflection.MethodInfo");
        A MyA = new A();
        B MyB = new B();

        // Get the Type and MethodInfo.
        Type MyTypea = Type.GetType("A");
        MethodInfo Mymethodinfoa = MyTypea.GetMethod("method");

        Type MyTypeb = Type.GetType("B");
        MethodInfo Mymethodinfob = MyTypeb.GetMethod("method");

        // Get and display the Invoke method.
        Console.Write("\nFirst method - " + MyTypea.FullName +
            " returns " + Mymethodinfoa.Invoke(MyA, null));
        Console.Write("\nSecond method - " + MyTypeb.FullName +
            " returns " + Mymethodinfob.Invoke(MyB, null));
        return 0;
    }
}

#using <System.DLL>

using namespace System;
using namespace System::Reflection;

#define NULL 0
ref class A: public Object
{
public:
   virtual int method()
   {
      return 0;
   }

};

ref class B: public A
{
public:
   virtual int method() override
   {
      return 1;
   }

};

int main()
{
   A^ objA = gcnew A;
   B^ objB = gcnew B;
   Type^ typeA = objA->GetType();
   Type^ typeB = objB->GetType();
   MethodInfo^ methodA = typeA->GetMethod( L"method" );
   MethodInfo^ methodB = typeB->GetMethod( L"method" );
   Console::WriteLine( "\tUsing reflection to invoke A::method on objB returns {0}.", dynamic_cast<Object^>(methodA->Invoke( objB, nullptr )) );
   Console::WriteLine( "\tUsing Invoke on objB after converting to type A returns {0}.", dynamic_cast<Object^>(methodA->Invoke( dynamic_cast<A^>(objB), nullptr )) );
   Console::WriteLine( "\r\nThe same behavior is seen when the method " );
   Console::WriteLine( "is invoked without reflection:\r\n" );
   Console::WriteLine( "\tDirectly invoking B::method on objB returns {0}.", objB->method() );
   Console::WriteLine( "\tDirectly invoking B::method on objB after converting to type A returns {0}.", dynamic_cast<A^>(objB)->method() );
}

import System.*;
import System.Reflection.*;
import System.Windows.Forms.*;

public class A
{
    public int Method()
    {
        return 0;
    } //Method
} //A

public class B
{
    public int Method()
    {
        return 1;
    } //Method
} //B

class MyMethodInfo
{
    public static void main(String[] args)
    {
        Console.WriteLine("\nReflection.MethodInfo");
        A myA =  new A();
        B myB =  new B();

        // Get the Type and MethodInfo.
        Type myTypeA = Type.GetType("A");
        MethodInfo myMethodInfoA = myTypeA.GetMethod("Method");

        Type myTypeB = Type.GetType("B");
        MethodInfo myMethodInfoB = myTypeB.GetMethod("Method");

        // Get and display the Invoke method.
        Console.Write(("\nFirst method - " + myTypeA.get_FullName() 
            + " returns " + myMethodInfoA.Invoke(myA, null)));
        Console.Write(("\nSecond method - " + myTypeB.get_FullName() 
            + " returns " + myMethodInfoB.Invoke(myB, null)));
    } //main
} //MyMethodInfo

public class A
{
   public function method () : int {return 0;}
}

public class B
{
   public function method () : int {return 1;}
}

class Mymethodinfo
{
   public static function Main() : void
   {
      Console.WriteLine ("\nReflection.MethodInfo");
      var MyA : A = new A();
      var MyB : B = new B();

      //Get the Type and MethodInfo
      var MyTypea : Type = Type.GetType("A");
      var Mymethodinfoa : MethodInfo = MyTypea.GetMethod("method");

      var MyTypeb : Type = Type.GetType("B");
      var Mymethodinfob : MethodInfo = MyTypeb.GetMethod("method");

      //Get and display the Invoke method
      Console.Write("\nFirst method - " + MyTypea.FullName +
         " returns " + Mymethodinfoa.Invoke(MyA, null));
      Console.Write("\nSecond method - " + MyTypeb.FullName +
         " returns " + Mymethodinfob.Invoke(MyB, null));
    }
}
Mymethodinfo.Main();