Here's sample code along those lines:

---8<---
using System;
using System.Reflection.Emit;
using System.Reflection;
using System.IO;

class Program
{
   delegate void Method();
   
   static void Main()
   {
       DynamicMethod dynMeth = new DynamicMethod("foo",
           typeof(void), new Type[0], typeof(Program));
       
       // the "easy" way
       //WriteHello(dynMeth.GetILGenerator());
       
       // the "hard" way
       WriteHelloViaBytes(dynMeth.GetDynamicILInfo());
       
       Method meth = (Method) dynMeth.CreateDelegate(typeof(Method));
       meth();
   }
   
   static void WriteHelloViaBytes(DynamicILInfo info)
   {
       MethodInfo writeLineMethod =
           typeof(System.Console).GetMethod("WriteLine",
               new Type[] { typeof(string) });
       int writeLineToken = info.GetTokenFor(
           writeLineMethod.MethodHandle);
       int helloWorldToken = info.GetTokenFor("Hello World!");
       
       MemoryStream codeStream = new MemoryStream();
       BinaryWriter codeWriter = new BinaryWriter(codeStream);
       
       codeWriter.Write((byte) OpCodes.Ldstr.Value);
       codeWriter.Write(helloWorldToken);
       
       codeWriter.Write((byte) OpCodes.Call.Value);
       codeWriter.Write(writeLineToken);
       
       codeWriter.Write((byte) OpCodes.Ret.Value);
       
       codeWriter.Flush();
       
       info.SetCode(codeStream.ToArray(), 1);
       
       MemoryStream sigStream = new MemoryStream();
       BinaryWriter sigWriter = new BinaryWriter(sigStream);
       
       // Signature format is tricky, described in 23.3 of
       // ECMA 335; see also CorHdr.h of .NET SDK.
       // Takes some time to work out; it's not well
       // described, IMHO.
       
       // IMAGE_CEE_CS_CALLCONV_LOCAL_SIG from CorHdr.h
       sigWriter.Write((byte) 0x7);
       // no of parameters (signatures follow return type, recursively)
       sigWriter.Write((byte) 0);
       // return type; here I use ELEMENT_TYPE_VOID as in CorHdr.h
       sigWriter.Write((byte) 1);
       
       sigWriter.Flush();
       
       info.SetLocalSignature(sigStream.ToArray());
   }
   
   static void WriteHello(ILGenerator cg)
   {
       cg.Emit(OpCodes.Ldstr, "Hello World!");
       cg.Emit(OpCodes.Call,
           typeof(System.Console).GetMethod("WriteLine",
               new Type[] { typeof(string) }));
       cg.Emit(OpCodes.Ret);
   }
}
--->8---

Be aware that you need to create tokens for all things imported into the
dynamic method; this is a PIA, as is generating the signature. I don't
think you gain a lot by avoiding ILGenerator, unless you've got an
existing .NET compiler and you want to leverage it for DynamicMethod.

The "file image" is certainly true for an assembly loaded by bytes, but
the data provided to DynamicMethod is not an entire assembly. It's 4
things:

1) Tokens created for imports, used in code bytes etc.; not just any
bytes will do, they need to be patched up for imports
2) Signature bytes of the method
3) Code bytes
4) Exception bytes

... and they need to be all poked in individually via DynamicILInfo,
like above.

-- Barry

I think that the RAIL(Runtime Assembly Instrumentation Library)  may help

http://csharp-source.net/open-source/aspect-oriented-frameworks/runtime-assembly
-instrumentation-library

My be a litter later :-)