title: Reflection.emit System.InvalidProgramException: Common Language Runtime detected an invalid program
body: <p>I'm new to reflection.emit and have been trying to produce the following c# code:</p>
  
  <pre><code>public class RepositoryWrapper
  {
      public void CallRepositoryMethod(IAddressRepository repository, Address address)
      {
          repository.NODE_I_NodeExtendedDetails_Address3(address.NodeId);
      }
  }
  </code></pre>
  
  <p>Here is the il Representation of it:</p>
  
  <pre><code>    IL_0000: nop
      IL_0001: ldarg.1
      IL_0002: ldarg.2
      IL_0003: callvirt instance int32 ReflectionServices.Node::get_NodeId()
      IL_0008: callvirt instance void ReflectionServices.IAddressRepository::NODE_I_NodeExtendedDetails_Address3(int32)
      IL_000d: nop
      IL_000e: ret
  </code></pre>
  
  <p>And here is my code used to create it:</p>
  
  <pre><code> internal static void Generate(this System.Reflection.Emit.ILGenerator @this, Type target,string method,Type instance)
          {
  
          var methodToCall = target.GetMethod(method);
          var methodParams = methodToCall.GetParameters();
          var instanceProperties = instance.GetProperties(BindingFlags.Public | BindingFlags.Instance);
  
          var orderedProperties = (from mp in methodParams
                                join p in instanceProperties
                                on mp.Name.ToLower() equals p.Name.ToLower()
                                select p).ToArray();
  
          //add properties to the string builder
  
          //load the object reference onto the stack sothat we can access its methods
          @this.Emit(OpCodes.Nop);
          @this.Emit(OpCodes.Ldarg_1);
          @this.Emit(OpCodes.Ldarg_2);
  
              var property = orderedProperties.FirstOrDefault(x =&gt; x.Name == "NodeId");
              if (property != null)
              {
                  var getMethod = property.GetGetMethod();
                  @this.Emit(getMethod.IsVirtual ? OpCodes.Callvirt : OpCodes.Call, getMethod);
  
              }
  
  
          //call method 
              @this.Emit(methodToCall.IsVirtual ? OpCodes.Callvirt : OpCodes.Call, methodToCall);
              @this.Emit(OpCodes.Nop);
          //return from function
          @this.Emit(OpCodes.Ret);
          }
  </code></pre>
  
  <p>Here is the error I am getting:</p>
  
  <pre><code>System.InvalidProgramException: Common Language Runtime detected an invalid program.
  Result StackTrace:  
  at ReflectionServices.Repository.NODE_I_NodeExtendedDetails3_Address40807399(Repository      target, Address )
  </code></pre>
  
  <p>here is the generated il:</p>
  
  <pre><code>nop
  ldarg.1
  ldarg.2
  call instance int32 ReflectionServices.Node::get_NodeId()
  callvirt instance void            
  ReflectionServices.Repository::
                                 NODE_I_NodeExtendedDetails3_Address(int32)
  nop
  </code></pre>
  
  <p>ret</p>
  
  <p>Can anybody see what the issue is i'm stuck?</p>
  
  <p>thanks</p>
  
  <p>here is my dll and method as requested:</p>
  
  <pre><code> public sealed class ReflectionEmitWithDebuggingMethodGenerator
  {
      private AssemblyBuilder Assembly { get; set; }
      private ModuleBuilder Module { get; set; }
      private AssemblyName Name { get; set; }
  
      public ReflectionEmitWithDebuggingMethodGenerator()
          : base()
      {
          this.Name = new AssemblyName() { Name = Guid.NewGuid().ToString("N") };
          this.Assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(
              this.Name, AssemblyBuilderAccess.RunAndSave,@"C:\Users\darren\Documents\Visual Studio 2012\Projects\UnityInjection");
          this.AddDebuggingAttribute(this.Assembly);
          this.Module = this.Assembly.DefineDynamicModule(this.Name.Name + ".dll", true);
      }
     public Action&lt;TObject, TInstance&gt; Generate&lt;TObject, TInstance&gt;(Type target, string methodN, Type instanceType)
      {
          var type = this.Module.DefineType(target.Namespace + "." + target.Name);
          var methodName = methodN + target.GetHashCode().ToString();
          var method = type.DefineMethod(methodName, MethodAttributes.Static | MethodAttributes.Public, typeof(void), new Type[] { target, instanceType });
          method.DefineParameter(1, ParameterAttributes.In, "target");
          method.DefineParameter(2, ParameterAttributes.In, "instance");
  
          ILGenerator.Generate(method.GetILGenerator(), target,methodN,instanceType);
  
          var createdType = type.CreateType();
  
          var createdMethod = createdType.GetMethod(methodName);
          return (Action&lt;TObject, TInstance&gt;)Delegate.CreateDelegate(typeof(Action&lt;TObject, TInstance&gt;), createdMethod);
      }
  
  
  }
  </code></pre>