TypeBuilder.DefineMethodOverride Method

Parameters

• methodInfoBody
  Type: System.Reflection.MethodInfo
  The method body to be used.

• methodInfoDeclaration
  Type: System.Reflection.MethodInfo
  The method whose declaration is to be used.

Imports System.Reflection
Imports System.Reflection.Emit

Public Interface I
   Function M() As String
End Interface

Public Class A
   Public Overridable Function M() As String
      Return "In method A.M" 
   End Function
End Class

' The object of this code example is to emit code equivalent to
' the following C# code:
'
Public Class C
   Inherits A
   Implements I

   Public Overrides Function M() As String
      Return "Overriding A.M from C.M" 
   End Function

   ' In order to provide a different implementation from C.M when 
   ' emitting the following explicit interface implementation, 
   ' it is necessary to use a MethodImpl.
   '
   Private Function IM() As String Implements I.M
      Return "The I.M implementation of C" 
   End Function
End Class

Class Example

   Public Shared Sub Demo(ByVal outputBlock As System.Windows.Controls.TextBlock)

      Dim name As String = "DefineMethodOverrideExample"
      Dim asmName As New AssemblyName(name)
      Dim ab As AssemblyBuilder = _
          AppDomain.CurrentDomain.DefineDynamicAssembly( _
              asmName, AssemblyBuilderAccess.Run)
      Dim mb As ModuleBuilder = ab.DefineDynamicModule(name)

      Dim tb As TypeBuilder = _
          mb.DefineType("C", TypeAttributes.Public, GetType(A))
      tb.AddInterfaceImplementation(GetType(I))

      ' Build the method body for the explicit interface 
      ' implementation. The name used for the method body 
      ' can be anything. Here, it is the name of the method,
      ' qualified by the interface name.
      '
      Dim mbIM As MethodBuilder = _
          tb.DefineMethod("I.M", _
          MethodAttributes.Private Or MethodAttributes.HideBySig Or _
              MethodAttributes.NewSlot Or MethodAttributes.Virtual Or _
              MethodAttributes.Final, _
          GetType(String), _
          Type.EmptyTypes)
      Dim il As ILGenerator = mbIM.GetILGenerator()
      il.Emit(OpCodes.Ldstr, "The I.M implementation of C")
      il.Emit(OpCodes.Ret)

      ' DefineMethodOverride is used to associate the method 
      ' body with the interface method that is being implemented.
      '
      tb.DefineMethodOverride(mbIM, GetType(I).GetMethod("M"))

      Dim mbM As MethodBuilder = tb.DefineMethod("M", _
          MethodAttributes.Public Or MethodAttributes.ReuseSlot Or _
              MethodAttributes.Virtual Or MethodAttributes.HideBySig, _
          GetType(String), _
          Type.EmptyTypes)
      il = mbM.GetILGenerator()
      il.Emit(OpCodes.Ldstr, "Overriding A.M from C.M")
      il.Emit(OpCodes.Ret)

      Dim tc As Type = tb.CreateType()

      Dim test As Object = Activator.CreateInstance(tc)

      Dim mi As MethodInfo = GetType(I).GetMethod("M")
      outputBlock.Text &= mi.Invoke(test, Nothing) & vbLf

      mi = GetType(A).GetMethod("M")
      outputBlock.Text &= mi.Invoke(test, Nothing) & vbLf

   End Sub
End Class

' This code example produces the following output:
'
'The I.M implementation of C
'Overriding A.M from C.M
' 

using System;
using System.Reflection;
using System.Reflection.Emit;

public interface I
{
   string M();
}

public class A
{
   public virtual string M() { return "In method A.M"; }
}

// The object of this code example is to emit code equivalent to
// the following C# code:
//
public class C : A, I
{
   public override string M()
   {
      return "Overriding A.M from C.M";
   }

   // In order to provide a different implementation from C.M when 
   // emitting the following explicit interface implementation, 
   // it is necessary to use a MethodImpl.
   //
   string I.M()
   {
      return "The I.M implementation of C";
   }
}

class Example
{
   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      string name = "DefineMethodOverrideExample";
      AssemblyName asmName = new AssemblyName(name);
      AssemblyBuilder ab =
          AppDomain.CurrentDomain.DefineDynamicAssembly(
              asmName, AssemblyBuilderAccess.Run);
      ModuleBuilder mb = ab.DefineDynamicModule(name);

      TypeBuilder tb =
          mb.DefineType("C", TypeAttributes.Public, typeof(A));
      tb.AddInterfaceImplementation(typeof(I));

      // Build the method body for the explicit interface 
      // implementation. The name used for the method body 
      // can be anything. Here, it is the name of the method,
      // qualified by the interface name.
      //
      MethodBuilder mbIM = tb.DefineMethod("I.M",
          MethodAttributes.Private | MethodAttributes.HideBySig |
              MethodAttributes.NewSlot | MethodAttributes.Virtual |
              MethodAttributes.Final,
          typeof(string),
          Type.EmptyTypes);
      ILGenerator il = mbIM.GetILGenerator();
      il.Emit(OpCodes.Ldstr, "The I.M implementation of C");
      il.Emit(OpCodes.Ret);

      // DefineMethodOverride is used to associate the method 
      // body with the interface method that is being implemented.
      //
      tb.DefineMethodOverride(mbIM, typeof(I).GetMethod("M"));

      MethodBuilder mbM = tb.DefineMethod("M",
          MethodAttributes.Public | MethodAttributes.ReuseSlot |
              MethodAttributes.Virtual | MethodAttributes.HideBySig,
          typeof(string),
          Type.EmptyTypes);
      il = mbM.GetILGenerator();
      il.Emit(OpCodes.Ldstr, "Overriding A.M from C.M");
      il.Emit(OpCodes.Ret);

      Type tc = tb.CreateType();

      Object test = Activator.CreateInstance(tc);

      MethodInfo mi = typeof(I).GetMethod("M");
      outputBlock.Text += mi.Invoke(test, null) + "\n";

      mi = typeof(A).GetMethod("M");
      outputBlock.Text += mi.Invoke(test, null) + "\n";
   }
}

/* This code example produces the following output:

The I.M implementation of C
Overriding A.M from C.M
 */