A way to extract strings from the body of a method in c#

Have a modifed script i use for extracting strings from MSIL methods at runtime.
original source here https://web.archive.org/web/20200727042639/https://stackoverflow.com/questions/14243284/how-can-i-retrieve-string-literals-using-reflection#

I mainly modified it so it doesnt throw as many null refrence exceptions (see the // commented code pieces).

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.InteropServices;
using System.Text;
//source of code https://web.archive.org/web/20200727042639/https://stackoverflow.com/questions/14243284/how-can-i-retrieve-string-literals-using-reflection#
class StringExtractors
{
    public static IEnumerable<string> FindLiterals(MethodInfo method)
    {
        var reader = new ILReader(method);
        foreach (var instruction in reader.Instructions)
        {
            if (instruction.Op == OpCodes.Ldstr)
            {
                yield return instruction.Data as string;
            }
        }
    }
}

public interface IILReaderProvider
{
    byte[] GetMethodBody();

    FieldInfo ResolveField(int metadataToken);
    MemberInfo ResolveMember(int metadataToken);

    MethodBase ResolveMethod(int metadataToken);
    byte[] ResolveSignature(int metadataToken);

    string ResolveString(int metadataToken);
    Type ResolveType(int metadataToken);
}

[StructLayout(LayoutKind.Sequential)]
public struct ILInstruction
{
    private readonly OpCode
        operationCode; // 40.  56-64.  The entire structure is very big.  maybe do array lookup for opcode instead.

    private readonly byte[] instructionRawData;

    private readonly object instructionData;

    private readonly int instructionAddress;

    private readonly int index;

    internal ILInstruction(OpCode code, byte[] instructionRawData, int instructionAddress, object instructionData,
        int index)
    {
        this.operationCode = code;
        this.instructionRawData = instructionRawData;
        this.instructionAddress = instructionAddress;
        this.instructionData = instructionData;
        this.index = index;
    }

    public OpCode Op
    {
        get { return this.operationCode; }
    }

    /// 
    /// Gets the raw data.
    /// 
    public byte[] RawData
    {
        get { return this.instructionRawData; }
    }

    /// 
    /// Gets the data.
    /// 
    public object Data
    {
        get { return this.instructionData; }
    }

    /// 
    /// Gets the address of the instruction.
    /// 
    public int Address
    {
        get { return this.instructionAddress; }
    }

    /// 
    /// Gets the index of the instruction.
    /// 
    /// 
    /// The index of the instruction.
    /// 
    public int InstructionIndex => this.index;

    /// 
    /// Gets the value as integer
    /// 
    /// The data value.
    public int DataValue
    {
        get
        {
            var value = 0;
            if (this.Data == null) return value;
            if (this.Data is byte)
            {
                value = (byte) Data;
            }
            else if (this.Data is short)
            {
                value = (short) this.Data;
            }
            else if (this.Data is int)
            {
                value = (int) this.Data;
            }

            return value;
        }
    }

    /// 
    /// Gets the length of the instructions and operands.
    /// 
    /// The length.
    public int Length => this.Op.Size + (RawData?.Length ?? 0);

    /// 
    /// Returns a  that represents this instance.
    /// 
    /// 
    /// A  that represents this instance.
    /// 
    public override string ToString()
    {
        var builder = new StringBuilder();
        builder.AppendFormat("0x{0:x4} {1,-10}", this.Address, this.Op.Name);

        if (this.Data != null)
        {
            builder.Append(this.Data);
        }

        if (this.RawData == null || this.RawData.Length <= 0) return builder.ToString();
        builder.Append(" [0x");
        for (var i = this.RawData.Length - 1; i >= 0; i--)
        {
            builder.Append(this.RawData[i].ToString("x2", CultureInfo.InvariantCulture));
        }

        builder.Append(']');

        return builder.ToString();
    }
}

/// 
/// Reads IL instructions from a byte stream.
/// 
/// Allows generated code to be viewed without debugger or enabled debug assemblies.
public sealed class ILReader
{
    /// 
    /// The _instruction lookup.
    /// 
    private static readonly Lazy<Dictionary<short, OpCode>> instructionLookup =
        new Lazy<Dictionary<short, OpCode>>(ILReader.GetLookupTable,
            System.Threading.LazyThreadSafetyMode.ExecutionAndPublication);

    /// 
    /// The IL reader provider.
    /// 
    private IILReaderProvider intermediateLanguageProvider;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// 
    /// The method.
    /// 
    public ILReader(MethodInfo method)
    {
        if (method == null)
        {
            throw new ArgumentNullException(nameof(method));
        }

        this.intermediateLanguageProvider = ILReader.CreateILReaderProvider(method);
    }

    /// 
    /// Gets the instructions.
    /// 
    /// The instructions.
    public IEnumerable<ILInstruction> Instructions
    {
        get
        {
            var instructionBytes = this.intermediateLanguageProvider.GetMethodBody();
            int instructionIndex = 0, startAddress;
            for (var position = 0; position < instructionBytes.Length;)
            {
                startAddress = position;
                short operationData = instructionBytes[position];
                if (IsInstructionPrefix(operationData))
                {
                    operationData = (short) ((operationData << 8) | instructionBytes[++position]);
                }

                position++;

                if (!instructionLookup.Value.TryGetValue(operationData, out var code))
                {
                    throw new InvalidProgramException($"0x{operationData:X2} is not a valid op code.");
                }

                var dataSize = GetSize(code.OperandType);
                var data = new byte[dataSize];
                Buffer.BlockCopy(instructionBytes, position, data, 0, dataSize);
                var objData = this.GetData(code, data);
                position += dataSize;

                if (code.OperandType == OperandType.InlineSwitch)
                {
                    dataSize = (int) objData;
                    int[] labels = new int[dataSize];
                    for (int index = 0; index < labels.Length; index++)
                    {
                        labels[index] = BitConverter.ToInt32(instructionBytes, position);
                        position += 4;
                    }

                    objData = labels;
                }

                yield return new ILInstruction(code, data, startAddress, objData, instructionIndex);
                instructionIndex++;
            }
        }
    }


    /// 
    /// Creates the IL reader provider.
    /// 
    /// The MethodInfo object that represents the method to read..
    /// 
    /// The ILReader provider.
    /// 
    private static IILReaderProvider CreateILReaderProvider(MethodInfo methodInfo)
    {
        IILReaderProvider reader = DynamicILReaderProvider.Create(methodInfo);
        return reader ?? new ILReaderProvider(methodInfo);
    }

    /// 
    /// Checks to see if the IL instruction is a prefix indicating the length of the instruction is two bytes long.
    /// 
    /// The IL instruction as a byte.
    /// IL instructions can either be 1 or 2 bytes.
    /// True if this IL instruction is a prefix indicating the instruction is two bytes long.
    private static bool IsInstructionPrefix(short value)
    {
        return ((value & OpCodes.Prefix1.Value) == OpCodes.Prefix1.Value) || ((value & OpCodes.Prefix2.Value) ==
                                                                              OpCodes.Prefix2.Value)
                                                                          || ((value & OpCodes.Prefix3.Value) ==
                                                                              OpCodes.Prefix3.Value) ||
                                                                          ((value & OpCodes.Prefix4.Value) ==
                                                                           OpCodes.Prefix4.Value)
                                                                          || ((value & OpCodes.Prefix5.Value) ==
                                                                              OpCodes.Prefix5.Value) ||
                                                                          ((value & OpCodes.Prefix6.Value) ==
                                                                           OpCodes.Prefix6.Value)
                                                                          || ((value & OpCodes.Prefix7.Value) ==
                                                                              OpCodes.Prefix7.Value) ||
                                                                          ((value & OpCodes.Prefixref.Value) ==
                                                                           OpCodes.Prefixref.Value);
    }

    /// 
    /// The get lookup table.
    /// 
    /// 
    /// A dictionary of IL instructions.
    /// 
    private static Dictionary<short, OpCode> GetLookupTable()
    {
        // Might be better to do an array lookup.  Use a seperate arrary for instructions without a prefix and array for each prefix.
        var fields = typeof(OpCodes).GetFields(BindingFlags.Static | BindingFlags.Public);

        return fields.Select(field => (OpCode) field.GetValue(null)).ToDictionary(code => code.Value);
    }

    /// 
    /// Gets the size of a operand.
    /// 
    /// Defines the type of operand.
    /// The size in bytes of the operand type.
    private static int GetSize(OperandType operandType)
    {
        switch (operandType)
        {
            case OperandType.InlineNone:
                return 0;
            case OperandType.ShortInlineBrTarget:
            case OperandType.ShortInlineI:
            case OperandType.ShortInlineVar:
                return 1;
            case OperandType.InlineVar:
                return 2;
            case OperandType.InlineBrTarget:
            case OperandType.InlineField:
            case OperandType.InlineI:
            case OperandType.InlineMethod:
            case OperandType.InlineSig:
            case OperandType.InlineString:
            case OperandType.InlineSwitch:
            case OperandType.InlineTok:
            case OperandType.InlineType:
            case OperandType.ShortInlineR:
                return 4;
            case OperandType.InlineI8:
            case OperandType.InlineR:
                return 8;
            default:
                return 0;
        }
    }

    private object GetData(OpCode code, byte[] rawData)
    {
        object data = null;
        switch (code.OperandType)
        {
            case OperandType.InlineField:
                data = this.intermediateLanguageProvider.ResolveField(BitConverter.ToInt32(rawData, 0));
                break;
            case OperandType.InlineSwitch:
                data = BitConverter.ToInt32(rawData, 0);

                break;
            case OperandType.InlineBrTarget:
            case OperandType.InlineI:
                data = BitConverter.ToInt32(rawData, 0);
                break;
            case OperandType.InlineI8:
                data = BitConverter.ToInt64(rawData, 0);
                break;
            case OperandType.InlineMethod:
                data = this.intermediateLanguageProvider.ResolveMethod(BitConverter.ToInt32(rawData, 0));
                break;
            case OperandType.InlineR:
                data = BitConverter.ToDouble(rawData, 0);
                break;
            case OperandType.InlineSig:
                data = this.intermediateLanguageProvider.ResolveSignature(BitConverter.ToInt32(rawData, 0));
                break;
            case OperandType.InlineString:
                data = this.intermediateLanguageProvider.ResolveString(BitConverter.ToInt32(rawData, 0));
                break;
            case OperandType.InlineTok:
            case OperandType.InlineType:
                data = this.intermediateLanguageProvider.ResolveType(BitConverter.ToInt32(rawData, 0));
                break;
            case OperandType.InlineVar:
                data = BitConverter.ToInt16(rawData, 0);
                break;
            case OperandType.ShortInlineVar:
            case OperandType.ShortInlineI:
            case OperandType.ShortInlineBrTarget:
                data = rawData[0];
                break;
            case OperandType.ShortInlineR:
                data = BitConverter.ToSingle(rawData, 0);
                break;
        }

        return data;
    }
}

internal class DynamicILReaderProvider : IILReaderProvider
{
    public const int TypeRidPrefix = 0x02000000;

    public const int MethodRidPrefix = 0x06000000;

    public const int FieldRidPrefix = 0x04000000;

    public static readonly Type RuntimeDynamicMethodType;

    private static readonly FieldInfo fileLengthField =
        typeof(ILGenerator).GetField("m_length", BindingFlags.NonPublic | BindingFlags.Instance);

    private static readonly FieldInfo IntermediateLanguageBytesField =
        typeof(ILGenerator).GetField("m_ILStream", BindingFlags.NonPublic | BindingFlags.Instance);

    private static readonly MethodInfo bakeByteArrayMethod =
        typeof(ILGenerator).GetMethod("BakeByteArray", BindingFlags.NonPublic | BindingFlags.Instance);

    private static readonly PropertyInfo dynamicScopeIndexor;

    private static readonly FieldInfo dynamicScopeField;

    private static readonly Type genericMethodInfoType;

    private static readonly FieldInfo genericMethodHandleField;

    private static readonly FieldInfo genericMethodContextField;

    private static readonly Type varArgMethodType;

    private static readonly FieldInfo varArgMethodMethod;

    private static readonly Type genericFieldInfoType;

    private static readonly FieldInfo genericFieldInfoHandle;

    private static readonly FieldInfo genericFieldInfoContext;

    private static readonly FieldInfo ownerField;

    private object dynamicScope;

    private ILGenerator generator;

    static DynamicILReaderProvider()
    {
      // this section here with the comments is where i had to fix it
        var bindingFlags = BindingFlags.NonPublic | BindingFlags.Instance;
        //dynamicScopeIndexor = Type.GetType("System.Reflection.Emit.DynamicScope").GetProperty("Item", bindingFlags);
        //dynamicScopeField = Type.GetType("System.Reflection.Emit.DynamicILGenerator").GetField("m_scope", bindingFlags);

        //varArgMethodType = Type.GetType("System.Reflection.Emit.VarArgMethod");
        //varArgMethodMethod = varArgMethodType.GetField("m_method", bindingFlags);

        //genericMethodInfoType = Type.GetType("System.Reflection.Emit.GenericMethodInfo");
        //genericMethodHandleField = genericMethodInfoType.GetField("m_methodHandle", bindingFlags);
        //genericMethodContextField = genericMethodInfoType.GetField("m_context", bindingFlags);

        // genericFieldInfoType = Type.GetType("System.Reflection.Emit.GenericFieldInfo", false);
        // if (genericFieldInfoType != null)
        // {
        //     genericFieldInfoHandle = genericFieldInfoType.GetField("m_fieldHandle", bindingFlags);
        //     genericFieldInfoContext = genericFieldInfoType.GetField("m_context", bindingFlags);
        // }
        // else
        // {
        //     genericFieldInfoHandle = genericFieldInfoContext = null;
        //}

        RuntimeDynamicMethodType = typeof(DynamicMethod);
        ownerField = RuntimeDynamicMethodType.GetField("m_owner", bindingFlags);
    }

    private DynamicILReaderProvider(DynamicMethod method)
    {
        this.Method = method;
        this.generator = method.GetILGenerator();
        this.dynamicScope = dynamicScopeField.GetValue(this.generator);
    }

    public DynamicMethod Method { get; private set; }

    internal object this[int token]
    {
        get { return dynamicScopeIndexor.GetValue(this.dynamicScope, new object[] {token}); }
    }

    public static DynamicILReaderProvider Create(MethodInfo method)
    {
        if (method == null)
        {
            throw new ArgumentNullException(nameof(method));
        }

        var dynamicMethod = method as DynamicMethod;
        if (dynamicMethod != null)
        {
            return new DynamicILReaderProvider(dynamicMethod);
        }

        var methodType = method.GetType();
        if (RuntimeDynamicMethodType.IsAssignableFrom(methodType))
        {
            return new DynamicILReaderProvider(ownerField.GetValue(method) as DynamicMethod);
        }

        return null;
    }

    public byte[] GetMethodBody()
    {
        byte[] data = null;
        var ilgen = this.Method.GetILGenerator();

        try
        {
            data = (byte[]) bakeByteArrayMethod.Invoke(ilgen, null) ?? new byte[0];
        }
        catch (TargetInvocationException)
        {
            var length = (int) fileLengthField.GetValue(ilgen);
            data = new byte[length];
            Array.Copy((byte[]) IntermediateLanguageBytesField.GetValue(ilgen), data, length);
        }

        return data;
    }

    public FieldInfo ResolveField(int metadataToken)
    {
        var tokenValue = this[metadataToken];
        if (tokenValue is RuntimeFieldHandle)
        {
            return FieldInfo.GetFieldFromHandle((RuntimeFieldHandle) tokenValue);
        }

        if (tokenValue.GetType() == DynamicILReaderProvider.genericFieldInfoType)
        {
            return FieldInfo.GetFieldFromHandle(
                (RuntimeFieldHandle) genericFieldInfoHandle.GetValue(tokenValue),
                (RuntimeTypeHandle) genericFieldInfoContext.GetValue(tokenValue));
        }

        return null;
    }

    public MemberInfo ResolveMember(int metadataToken)
    {
        if ((metadataToken & TypeRidPrefix) != 0)
        {
            return this.ResolveType(metadataToken);
        }

        if ((metadataToken & MethodRidPrefix) != 0)
        {
            return this.ResolveMethod(metadataToken);
        }

        if ((metadataToken & FieldRidPrefix) != 0)
        {
            return this.ResolveField(metadataToken);
        }

        return null;
    }

    public MethodBase ResolveMethod(int metadataToken)
    {
        var tokenValue = this[metadataToken];
        DynamicMethod dynamicMethod = tokenValue as DynamicMethod;
        if (dynamicMethod != null)
        {
            return dynamicMethod;
        }

        if (tokenValue is RuntimeMethodHandle)
        {
            return MethodBase.GetMethodFromHandle((RuntimeMethodHandle) this[metadataToken]);
        }

        if (tokenValue.GetType() == genericFieldInfoType)
        {
            return MethodBase.GetMethodFromHandle(
                (RuntimeMethodHandle) genericMethodHandleField.GetValue(tokenValue),
                (RuntimeTypeHandle) genericMethodContextField.GetValue(tokenValue));
        }

        if (tokenValue.GetType() == varArgMethodType)
        {
            return DynamicILReaderProvider.varArgMethodMethod.GetValue(tokenValue) as MethodInfo;
        }

        return null;
    }

    public byte[] ResolveSignature(int metadataToken)
    {
        return this[metadataToken] as byte[];
    }

    public string ResolveString(int metadataToken)
    {
        return this[metadataToken] as string;
    }

    public Type ResolveType(int metadataToken)
    {
        return Type.GetTypeFromHandle((RuntimeTypeHandle) this[metadataToken]);
    }
}

internal class ILReaderProvider : IILReaderProvider
{
    public ILReaderProvider(MethodInfo method)
    {
        this.Method = method;
        this.MethodBody = method.GetMethodBody();
        this.MethodModule = method.Module;
    }

    public MethodInfo Method { get; private set; }

    public MethodBody MethodBody { get; private set; }

    public Module MethodModule { get; private set; }

    public byte[] GetMethodBody()
    {
        return this.MethodBody.GetILAsByteArray();
    }

    public FieldInfo ResolveField(int metadataToken)
    {
        return this.MethodModule.ResolveField(metadataToken);
    }

    public MemberInfo ResolveMember(int metadataToken)
    {
        return this.MethodModule.ResolveMember(metadataToken);
    }

    public MethodBase ResolveMethod(int metadataToken)
    {
        return this.MethodModule.ResolveMethod(metadataToken);
    }

    public byte[] ResolveSignature(int metadataToken)
    {
        return this.MethodModule.ResolveSignature(metadataToken);
    }

    public string ResolveString(int metadataToken)
    {
        return this.MethodModule.ResolveString(metadataToken);
    }

    public Type ResolveType(int metadataToken)
    {
        return this.MethodModule.ResolveType(metadataToken);
    }
}