/* This program generates IL Code for the console.WriteLine Method.You can Replace writeLine With Any .Net Methods.ItWill produce the IL Code for that Method */ using System; using System.Collections; using System.Collections.Generic; using System.Reflection; using System.Reflection.Emit; using System.Runtime.CompilerServices; namespace ILDisassembler { public abstract class ILInstruction { protected OpCode op_code; protected Int32 _offset; protected MethodBase _enclosingMethod; protected Module m; protected System.Type[] GenericTypeArgs; protected System.Type[] GenericTypes; public ILInstruction(MethodBase m_enclosingMethod, Int32 offset, OpCode opCode) { _enclosingMethod = m_enclosingMethod; _offset = offset + 1; op_code = opCode; m = Assembly.GetAssembly(_enclosingMethod.DeclaringType).ManifestModule; if (_enclosingMethod.ContainsGenericParameters) GenericTypeArgs = _enclosingMethod.GetGenericArguments(); if (_enclosingMethod.DeclaringType.IsGenericType) GenericTypes = _enclosingMethod.DeclaringType.GetGenericArguments(); } public int IlOffset { get { return _offset; } } public OpCode Code { get { return op_code; } } public abstract object Value { get; } public virtual new string ToString() { string xString = _offset.ToString("X").ToLower().PadLeft(4, '0'); string InstructionName = this.op_code.Name; return string.Format("IL_{0}:{1}{2}{3}{4}", xString, "\t", InstructionName, "\t", "\t"); } } public class InlineNoneInstruction : ILInstruction { public InlineNoneInstruction(MethodBase m_enclosingMethod, Int32 offset, OpCode opCode) : base(m_enclosingMethod, offset, opCode) { } public override object Value { get { return null; } } public override string ToString() { return base.ToString(); } } public class ShortInlineBrTargetInstruction : ILInstruction { private sbyte short_delta; public ShortInlineBrTargetInstruction(MethodBase m_enclosingMethod, Int32 offset, OpCode opCode, sbyte shortdelta) : base(m_enclosingMethod, offset, opCode) { short_delta = shortdelta; } public override object Value { get { return _offset + short_delta + 2; } } public override string ToString() { string baseString = base.ToString(); string Label = "IL_" + (_offset + short_delta + 2).ToString("X").ToLower().PadLeft(4, '0'); return string.Format("{0}{1}", baseString, Label); } } public class InlineBrTargetInstruction : ILInstruction { private Int32 _delta; public InlineBrTargetInstruction(MethodBase m_enclosingMethod, Int32 offset, OpCode opCode, Int32 delta) : base(m_enclosingMethod, offset, opCode) { _delta = delta; } public override object Value { get { return _offset + _delta + 5; } } public override string ToString() { string baseString = base.ToString(); return string.Format("{0}{1}", baseString, ""); } } public class ShortInlinelInstruction : ILInstruction { private sbyte _int8; public ShortInlinelInstruction(MethodBase m_enclosingMethod, Int32 offset, OpCode opCode, sbyte i8) : base(m_enclosingMethod, offset, opCode) { _int8 = i8; } public override object Value { get { return _int8; } } public override string ToString() { string baseString = base.ToString(); return string.Format("{0}{1}", baseString, this.Value); } } public class InlinelInstruction : ILInstruction { private Int32 _int32; public InlinelInstruction(MethodBase m_enclosingMethod, Int32 offset, OpCode opCode, Int32 i32) : base(m_enclosingMethod, offset, opCode) { _int32 = i32; } public override object Value { get { return _int32; } } public override string ToString() { string baseString = base.ToString(); return string.Format("{0}{1}", baseString, this.Value); } } public class Inline8Instruction : ILInstruction { private Int64 _int64; public Inline8Instruction(MethodBase m_enclosingMethod, Int32 offset, OpCode opCode, Int64 i64) : base(m_enclosingMethod, offset, opCode) { _int64 = i64; } public override object Value { get { return _int64; } } public override string ToString() { string baseString = base.ToString(); return string.Format("{0}{1}", baseString, this.Value); } } public class ShortInlineRInstruction : ILInstruction { private Single _float32; public ShortInlineRInstruction(MethodBase m_enclosingMethod, Int32 offset, OpCode opCode, Single f32) : base(m_enclosingMethod, offset, opCode) { _float32 = f32; } public override object Value { get { return _float32; } } public override string ToString() { string baseString = base.ToString(); return string.Format("{0}{1}", baseString, this.Value); } } public class InlineRInstruction : ILInstruction { private Double _float64; public InlineRInstruction(MethodBase m_enclosingMethod, Int32 offset, OpCode opCode, Double f64) : base(m_enclosingMethod, offset, opCode) { _float64 = f64; } public override object Value { get { return _float64; } } public override string ToString() { string baseString = base.ToString(); return string.Format("{0}{1}", baseString, this.Value); } } public class ShortInlineVarInstruction : ILInstruction { private Byte _index8; public ShortInlineVarInstruction(MethodBase m_enclosingMethod, Int32 offset, OpCode opCode, Byte index8) : base(m_enclosingMethod, offset, opCode) { _index8 = index8; } public override object Value { get { return _index8; } } public override string ToString() { Type t = base._enclosingMethod.DeclaringType; string baseString = base.ToString(); return string.Format("{0}{1}", baseString, ""); } } public class InlineVarInstruction : ILInstruction { private UInt16 _index16; public InlineVarInstruction(MethodBase m_enclosingMethod, Int32 offset, OpCode opCode, UInt16 index16) : base(m_enclosingMethod, offset, opCode) { _index16 = index16; } public override object Value { get { return _index16; } } public override string ToString() { string baseString = base.ToString(); return string.Format("{0}{1}", baseString, this.Value); } } public class InlineStringInstruction : ILInstruction { private Int32 _token; public InlineStringInstruction(MethodBase m_enclosingMethod, Int32 offset, OpCode opCode, Int32 token) : base(m_enclosingMethod, offset, opCode) { _token = token; } public override object Value { get { return m.ResolveString(_token); } } public override string ToString() { Type t = base._enclosingMethod.DeclaringType; string baseString = base.ToString(); return string.Format("{0}\"{1}\"", baseString, this.Value); } } public class InlineSigInstruction : ILInstruction { private Int32 _token; public InlineSigInstruction(MethodBase m_enclosingMethod, Int32 offset, OpCode opCode, Int32 token) : base(m_enclosingMethod, offset, opCode) { _token = token; } public override object Value { get { return m.ResolveSignature(_token); } } public override string ToString() { string baseString = base.ToString(); return string.Format("{0}{1}", baseString, this.Value); } } public class InlineFieldInstruction : ILInstruction { private Int32 _token; public InlineFieldInstruction(MethodBase m_enclosingMethod, Int32 offset, OpCode opCode, Int32 token) : base(m_enclosingMethod, offset, opCode) { _token = token; } public override object Value { get { return m.ResolveField(_token, GenericTypes, GenericTypeArgs); } } public override string ToString() { string baseString = base.ToString(); System.Type type = ((FieldInfo)this.Value).DeclaringType; Assembly assem = Assembly.GetAssembly(type); return string.Format("{0}[{1}]{2}::{3}", baseString, assem.FullName.Split(',')[0], type, ((FieldInfo)this.Value).Name); } } public class InlineTypeInstruction : ILInstruction { private Int32 _token; public InlineTypeInstruction(MethodBase m_enclosingMethod, Int32 offset, OpCode opCode, Int32 token) : base(m_enclosingMethod, offset, opCode) { _token = token; } public override object Value { get { return m.ResolveType(_token, GenericTypes, GenericTypeArgs); } } public override string ToString() { string baseString = base.ToString(); return string.Format("{0}{1}", baseString, this.Value.ToString()); } } public class InlineTokInstruction : ILInstruction { private Int32 _token; public InlineTokInstruction(MethodBase m_enclosingMethod, Int32 offset, OpCode opCode, Int32 token) : base(m_enclosingMethod, offset, opCode) { _token = token; } public override object Value { get { return m.ResolveMember(_token, GenericTypes, GenericTypeArgs); } } } public class InlineMethodInstruction : ILInstruction { private Int32 _token; public InlineMethodInstruction(MethodBase m_enclosingMethod, Int32 offset, OpCode opCode, Int32 token) : base(m_enclosingMethod, offset, opCode) { _token = token; } public override object Value { get { return m.ResolveMethod(_token, GenericTypes, GenericTypeArgs); } } public override string ToString() { MethodBase mbase = (MethodBase)Value; Type t = ((MethodBase)Value).DeclaringType; Assembly Assem = Assembly.GetAssembly(t); string baseString = base.ToString(); string AssemblyName = Assem.FullName.Split(',')[0]; string paramString = string.Empty; ParameterInfo[] pinfo = mbase.GetParameters(); foreach (ParameterInfo p in pinfo) paramString += p.ParameterType.ToString() + ","; return string.Format("{0}[{1}]{2}::{3}({4})", baseString, AssemblyName, t.FullName, mbase.Name, paramString.TrimEnd(new char[] { (Char)(32), ',' })); } } public class InlineSwitchInstruction : ILInstruction { private Int32[] _deltas; public InlineSwitchInstruction(MethodBase m_enclosingMethod, Int32 offset, OpCode opCode, Int32[] deltas) : base(m_enclosingMethod, offset, opCode) { _deltas = deltas; } public override object Value { get { List _offsets = new List(); foreach (Int32 deltas in _deltas) _offsets.Add(deltas + 183); return _offsets; } } public override string ToString() { string baseString = base.ToString(); string Label = "( "; for (int i = 0; i <= _deltas.Length - 1; i++) Label += "IL_" + (_deltas[i] + 183).ToString("X").ToLower().PadLeft(4, '0') + ","; Label += " )"; return string.Format("{0}{1}", baseString, Label); } } public class ILReader : System.Collections.Generic.IEnumerable { private List ins = new List(); private byte[] m_byteArray; private int m_position; private MethodBase m_enclosingMethod; private MethodBody methodBody; public static OpCode[] s_OneByteOpCodes = new OpCode[256]; public static OpCode[] s_TwoByteOpCodes = new OpCode[256]; static ILReader() { foreach (FieldInfo fi in typeof(OpCodes).GetFields((BindingFlags.Public | BindingFlags.Static))) { OpCode opCode = (OpCode)(fi.GetValue(null)); int value = opCode.Value; if ((value < 256) && (value > -1)) { s_OneByteOpCodes[value] = opCode; } else if ((value & 65280) == 65024) { s_TwoByteOpCodes[value & 255] = opCode; } } } public ILReader(MethodBase enclosingMethod) { this.m_enclosingMethod = enclosingMethod; this.methodBody = m_enclosingMethod.GetMethodBody(); m_byteArray = methodBody.GetILAsByteArray(); this.m_position = -1; } private ILInstruction NextInstruction() { Int32 offset = m_position; OpCode opCode = OpCodes.Nop; Int32 token = 0; byte value = this.ReadByte(); if ((value != 254)) { opCode = s_OneByteOpCodes[value]; } else { value = this.ReadByte(); opCode = s_TwoByteOpCodes[value]; } switch (opCode.OperandType) { case OperandType.InlineNone: return new InlineNoneInstruction(m_enclosingMethod, offset, opCode); break; case OperandType.ShortInlineBrTarget: sbyte shortDelta = this.ReadSByte(); return new ShortInlineBrTargetInstruction(m_enclosingMethod, offset, opCode, shortDelta); break; case OperandType.InlineBrTarget: Int32 delta = this.ReadInt32(); return new InlineBrTargetInstruction(m_enclosingMethod, offset, opCode, delta); break; case OperandType.ShortInlineI: sbyte i8 = this.ReadSByte(); return new ShortInlinelInstruction(m_enclosingMethod, offset, opCode, i8); break; case OperandType.InlineI: Int32 i32 = this.ReadInt32(); return new InlinelInstruction(m_enclosingMethod, offset, opCode, i32); break; case OperandType.InlineI8: Int64 i64 = this.ReadInt64(); return new Inline8Instruction(m_enclosingMethod, offset, opCode, i64); break; case OperandType.ShortInlineR: Single f32 = this.ReadSingle(); return new ShortInlineRInstruction(m_enclosingMethod, offset, opCode, f32); break; case OperandType.InlineR: double f64 = this.ReadDouble(); return new InlineRInstruction(m_enclosingMethod, offset, opCode, f64); break; case OperandType.ShortInlineVar: byte index8 = this.ReadByte(); return new ShortInlineVarInstruction(m_enclosingMethod, offset, opCode, index8); break; case OperandType.InlineVar: UInt16 index16 = this.ReadUInt16(); return new InlineVarInstruction(m_enclosingMethod, offset, opCode, index16); break; case OperandType.InlineString: token = this.ReadInt32(); return new InlineStringInstruction(m_enclosingMethod, offset, opCode, token); break; case OperandType.InlineSig: token = this.ReadInt32(); return new InlineSigInstruction(m_enclosingMethod, offset, opCode, token); break; case OperandType.InlineField: token = this.ReadInt32(); return new InlineFieldInstruction(m_enclosingMethod, offset, opCode, token); break; case OperandType.InlineType: token = this.ReadInt32(); return new InlineTypeInstruction(m_enclosingMethod, offset, opCode, token); break; case OperandType.InlineTok: token = this.ReadInt32(); return new InlineTokInstruction(m_enclosingMethod, offset, opCode, token); break; case OperandType.InlineMethod: token = this.ReadInt32(); return new InlineMethodInstruction(m_enclosingMethod, offset, opCode, token); break; case OperandType.InlineSwitch: Int32 cases = this.ReadInt32(); Int32[] deltas = new Int32[cases]; for (Int32 i = 0; i <= (cases - 1); i++) { deltas[i] = this.ReadInt32(); } return new InlineSwitchInstruction(m_enclosingMethod, offset, opCode, deltas); break; default: throw new BadImageFormatException(("unexpectedÂ OperandTypeÂ " + opCode.OperandType)); break; } } private byte ReadByte() { return (byte)(m_byteArray[Math.Max(System.Threading.Interlocked.Increment(ref m_position),m_position-1)]); } private sbyte ReadSByte() { sbyte i8; byte b = this.ReadByte(); i8 = Convert.ToSByte((b).ToString("X"), 16); return i8; } private UInt16 ReadUInt16() { m_position += 2; return BitConverter.ToUInt16(m_byteArray, (m_position - 1)); } private UInt32 ReadUInt32() { m_position += 4; return BitConverter.ToUInt32(m_byteArray, (m_position - 3)); } private UInt64 ReadUInt64() { m_position += 8; return BitConverter.ToUInt64(m_byteArray, (m_position - 7)); } private Int32 ReadInt32() { m_position += 4; return BitConverter.ToInt32(m_byteArray, (m_position - 3)); } private Int64 ReadInt64() { m_position += 8; return BitConverter.ToInt64(m_byteArray, (m_position - 7)); } private Single ReadSingle() { m_position += 4; return BitConverter.ToSingle(m_byteArray, (m_position - 3)); } private double ReadDouble() { m_position += 8; return BitConverter.ToDouble(m_byteArray, (m_position - 7)); } public System.Collections.Generic.IEnumerator GetEnumerator() { while ((m_position < (m_byteArray.Length - 1))) { ILInstruction il = this.NextInstruction(); ins.Add(il); } return ins.GetEnumerator(); } System.Collections.IEnumerator IEnumerable.GetEnumerator() { return this.GetEnumerator(); } } class Program { static void Main(string[] args) { MethodInfo minfo = typeof(Console).GetMethod("WriteLine",new Type[] {typeof(string)}); MethodBase mBase = MethodBase.GetMethodFromHandle(minfo.MethodHandle, minfo.DeclaringType.TypeHandle); Console.WriteLine("CIL Code for Console.WriteLine Method \n"); foreach (ILInstruction i in new ILReader(mBase)) { Console.WriteLine(i.ToString()); } MethodInfo mi = typeof(Console).GetMethod("ReadLine"); MethodBase mb = MethodBase.GetMethodFromHandle(mi.MethodHandle, mi.DeclaringType.TypeHandle); Console.WriteLine("\n CIL Code for Console.ReadLine Method \n"); foreach (ILInstruction instruction in new ILReader(mb)) { Console.WriteLine(instruction.ToString()); } MethodInfo m = typeof(ILDisassembler.ILReader).GetMethod("NextInstruction",BindingFlags.NonPublic|BindingFlags.Instance); MethodBase b = MethodBase.GetMethodFromHandle(m.MethodHandle, m.DeclaringType.TypeHandle); Console.WriteLine("\n CIL Code for ILReader.NextInstruction Method \n"); foreach (ILInstruction instruction in new ILReader(b)) { Console.WriteLine(instruction.ToString()); } } } }

CIL Generator(ILDisassembler)