从PDB文件中检索本地变量名

System.Diagnostics.SymbolStore

public class LocalVariableNameReader
{
    Dictionary<int, string> _names = new Dictionary<int, string> ();

    public string this [int index]
    {
        get
        {
            if (!_names.ContainsKey (index)) return null;
            return _names [index];
        }
    }

    public LocalVariableNameReader (MethodInfo m)
    {
        ISymbolReader symReader = SymUtil.GetSymbolReaderForFile (m.DeclaringType.Assembly.Location, null);
        ISymbolMethod met = symReader.GetMethod (new SymbolToken (m.MetadataToken));
        VisitLocals (met.RootScope);
    }

    void VisitLocals (ISymbolScope iSymbolScope)
    {
        foreach (var s in iSymbolScope.GetLocals ()) _names [s.AddressField1] = s.Name;
        foreach (var c in iSymbolScope.GetChildren ()) VisitLocals (c);
    }
}

SymUtil

using System;
using System.Diagnostics.SymbolStore;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;

namespace PdbTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Assembly ass = Assembly.GetExecutingAssembly();
            ISymbolReader symreader = SymUtil.GetSymbolReaderForFile(ass.Location, null);

            MethodInfo m = ass.GetType(\"PdbTest.TestClass\").GetMethod(\"GetStringRepresentation\");
            ISymbolMethod met = symreader.GetMethod(new SymbolToken(m.MetadataToken));

            int count = met.SequencePointCount;

            ISymbolDocument[] docs = new ISymbolDocument[count];
            int[] offsets = new int[count];
            int[] lines = new int[count];
            int[] columns = new int[count];
            int[] endlines = new int[count];
            int[] endcolumns = new int[count];

            met.GetSequencePoints(offsets, docs, lines, columns, endlines, endcolumns);

            StreamReader reader = new StreamReader(docs[0].URL);
            string[] linesOfCode = reader.ReadToEnd().Split(\'n\');
            reader.Close();

            Console.WriteLine(\"The content of method PdbTest.TestClass.GetStringRepresentation\");
            for (int i = lines[0]; i < endlines[count - 1] - 1; i++)
            {
                Console.WriteLine(linesOfCode[i]);
            }
        }
    }


    #region test class

    public enum MyEnum
    {
        Apples,
        Oranges
    }

    public partial class TestClass
    {
        public string GetStringRepresentation(MyEnum e)
        {
            MyEnum e2 = MyEnum.Apples;
            return e.ToString() + e2.ToString();
        }
    }

    #endregion test class

    #region Get a symbol reader for the given module

    // Encapsulate a set of helper classes to get a symbol reader from a file.
    // The symbol interfaces require an unmanaged metadata interface.
    static class SymUtil
    {
        static class NativeMethods
        {
            [DllImport(\"ole32.dll\")]
            public static extern int CoCreateInstance(
                [In] ref Guid rclsid,
                [In, MarshalAs(UnmanagedType.IUnknown)] Object pUnkOuter,
                [In] uint dwClsContext,
                [In] ref Guid riid,
                [Out, MarshalAs(UnmanagedType.Interface)] out Object ppv);
        }

        // Wrapper.
        public static ISymbolReader GetSymbolReaderForFile(string pathModule, string searchPath)
        {
            return SymUtil.GetSymbolReaderForFile(
                new System.Diagnostics.SymbolStore.SymBinder(), pathModule, searchPath);
        }

        // We demand Unmanaged code permissions because we\'re reading from the file 
        // system and calling out to the Symbol Reader
        // @TODO - make this more specific.
        [System.Security.Permissions.SecurityPermission(
            System.Security.Permissions.SecurityAction.Demand,
            Flags = System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode)]
        public static ISymbolReader GetSymbolReaderForFile(
           System.Diagnostics.SymbolStore.SymBinder binder, string pathModule, string searchPath)
        {
            // Guids for imported metadata interfaces.
            Guid dispenserClassID = new Guid(0xe5cb7a31, 0x7512, 0x11d2, 0x89, 
                0xce, 0x00, 0x80, 0xc7, 0x92, 0xe5, 0xd8); // CLSID_CorMetaDataDispenser
            Guid dispenserIID = new Guid(0x809c652e, 0x7396, 0x11d2, 0x97, 0x71, 
                0x00, 0xa0, 0xc9, 0xb4, 0xd5, 0x0c); // IID_IMetaDataDispenser
            Guid importerIID = new Guid(0x7dac8207, 0xd3ae, 0x4c75, 0x9b, 0x67, 
                0x92, 0x80, 0x1a, 0x49, 0x7d, 0x44); // IID_IMetaDataImport

            // First create the Metadata dispenser.
            object objDispenser;
            NativeMethods.CoCreateInstance(ref dispenserClassID, null, 1, 
                ref dispenserIID, out objDispenser);

            // Now open an Importer on the given filename. We\'ll end up passing this importer 
            // straight through to the Binder.
            object objImporter;
            IMetaDataDispenser dispenser = (IMetaDataDispenser)objDispenser;
            dispenser.OpenScope(pathModule, 0, ref importerIID, out objImporter);

            IntPtr importerPtr = IntPtr.Zero;
            ISymbolReader reader;
            try
            {
                // This will manually AddRef the underlying object, so we need to 
                // be very careful to Release it.
                importerPtr = Marshal.GetComInterfaceForObject(objImporter, 
                    typeof(IMetadataImport));

                reader = binder.GetReader(importerPtr, pathModule, searchPath);
            }
            finally
            {
                if (importerPtr != IntPtr.Zero)
                {
                    Marshal.Release(importerPtr);
                }
            }
            return reader;
        }
    }
    #region Metadata Imports

    // We can use reflection-only load context to use reflection to query for 
    // metadata information rather
    // than painfully import the com-classic metadata interfaces.
    [Guid(\"809c652e-7396-11d2-9771-00a0c9b4d50c\"), 
        InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    [ComVisible(true)]
    interface IMetaDataDispenser
    {
        // We need to be able to call OpenScope, which is the 2nd vtable slot.
        // Thus we need this one placeholder here to occupy the first slot..
        void DefineScope_Placeholder();

        //STDMETHOD(OpenScope)(                   // Return code.
        //LPCWSTR     szScope,                // [in] The scope to open.
        //  DWORD       dwOpenFlags,            // [in] Open mode flags.
        //  REFIID      riid,                   // [in] The interface desired.
        //  IUnknown    **ppIUnk) PURE;         // [out] Return interface on success.
        void OpenScope([In, MarshalAs(UnmanagedType.LPWStr)] String szScope, 
            [In] Int32 dwOpenFlags, [In] ref Guid riid, 
            [Out, MarshalAs(UnmanagedType.IUnknown)] out Object punk);

        // Don\'t need any other methods.
    }

    // Since we\'re just blindly passing this interface through managed code to the Symbinder, 
    // we don\'t care about actually importing the specific methods.
    // This needs to be public so that we can call Marshal.GetComInterfaceForObject() on 
    // it to get the underlying metadata pointer.
    [Guid(\"7DAC8207-D3AE-4c75-9B67-92801A497D44\"), 
        InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    [ComVisible(true)]
    [CLSCompliant(true)]
    public interface IMetadataImport
    {
        // Just need a single placeholder method so that it doesn\'t complain
        // about an empty interface.
        void Placeholder();
    }
    #endregion

    #endregion Get a symbol reader for the given module
}

public class VariableInfo : IEquatable<VariableInfo>
{
    public int Index { get; }
    public string Name { get; }
    public Type Type { get; }

    public VariableInfo(int index, Type type, string name) =>
        (Index, Type, Name) = (index, type, name);

    public override bool Equals(object obj) =>
        Equals(obj as VariableInfo);

    public bool Equals(VariableInfo info) =>
        info != null &&
        Index.Equals(info.Index) &&
        Name.Equals(info.Name) &&
        Type.Equals(info.Type);

    public override int GetHashCode()
    {
        unchecked
        {
            var hash = 17;
            hash = 23 * hash + Index.GetHashCode();
            hash = 23 * hash + Name.GetHashCode();
            hash = 23 * hash + Type.GetHashCode();
            return hash;
        }
    }

    public override string ToString() =>
        $\"Index {Index}, Type {Type}, Name {Name}\";
}

public interface ILocalsReader
{
    VariableInfo[] Read(MethodBase info);
}

Microsoft.Samples.Debugging.CorApi

public class MicrosoftDebuggingReader : ILocalsReader
{
    public VariableInfo[] Read(MethodBase info)
    {
        var il = info.GetMethodBody().LocalVariables.ToArray();

        return SymbolAccess
            .GetReaderForFile(info.DeclaringType.Assembly.Location)
            .GetMethod(new SymbolToken(info.MetadataToken))
            .RootScope
            .GetInnerScopesRecursive()
            .SelectMany(scope => scope.GetLocals())
            .Select(local =>
                new VariableInfo(local.AddressField1,
                                 il[local.AddressField1].LocalType,
                                 local.Name))
           .ToArray();
    }
}

internal static class SymbolScopeExtensions
{
    public static IEnumerable<ISymbolScope> GetInnerScopesRecursive(this ISymbolScope scope)
    {
        yield return scope;
        foreach (var innerScope in scope.GetChildren()
            .SelectMany(innerScope => innerScope.GetInnerScopesRecursive()))
            yield return innerScope;
    }
}

Mono.Cecil

public class MonoCecilReader : ILocalsReader
{
    public VariableInfo[] Read(MethodBase info)
    {
        var method = info.GetMethodDefinition();
        method.Module.ReadSymbols();

        var pdb = Path.ChangeExtension(info.DeclaringType.Assembly.Location, \"pdb\");
        new PdbReaderProvider().GetSymbolReader(method.Module, pdb)
                               .Read(method);

        var il = info.GetMethodBody().LocalVariables;
        return Read(method, il);
    }

    public VariableInfo[] Read(MethodDefinition method, IList<LocalVariableInfo> il)
    {
        return method
               .DebugInformation
               .Scope
               .GetInnerScopesRecursive()
               .SelectMany(scope => scope.Variables)
               .Select(local =>
                   new VariableInfo(local.Index,
                                    il[local.Index].LocalType,
                                    local.Name))
               .ToArray();
    }
}

public static class MethodDefinitionExtensions
{
    public static MethodDefinition GetMethodDefinition(this MethodBase info) =>
        AssemblyDefinition
        .ReadAssembly(info.DeclaringType.Assembly.Location)
        .Modules
        .SelectMany(module => module.GetTypes())
        .Single(type => type.FullNameMatches(info.DeclaringType))
        .Methods
        .FirstOrDefault(method =>
            method.Name.Equals(info.Name) &&
            method.ReturnType.FullName.Equals(info.GetReturnType().FullName) &&
            method.Parameters.Select(parameter => parameter.ParameterType.FullName)
                  .SequenceEqual(info.GetParameters().Select(parameter => parameter.ParameterType.FullName)));
}

GetReturnType

public static class MethodBaseExtensions
{
    public static Type GetReturnType(this MethodBase method)
    {
        if (method is MethodInfo info)
            return info.ReturnType;

        if (method is ConstructorInfo ctor)
            return typeof(void);

        throw new ArgumentException($\"Argument {nameof(method)} has unsupported type {method.GetType()}.\");
    }
}

FullNameMatches

internal static class TypeDefinitionExtensions
{
    public static bool FullNameMatches(this TypeDefinition typeDefinition, Type type) =>
        typeDefinition.FullName.Replace(\"/\", \"\").Equals(type.FullName.Replace(\"+\", \"\"));
}

GetInnerScopesRecursive

internal static class ScopeDebugInformationExtensions
{
    public static IEnumerable<ScopeDebugInformation> GetInnerScopesRecursive(this ScopeDebugInformation scope)
    {
        yield return scope;
        foreach (var innerScope in scope.Scopes
            .SelectMany(innerScope => innerScope.GetInnerScopesRecursive()))
            yield return innerScope;
    }
}

class Program
{
    static void Main(string[] args)
    {
        var info = new Action<string>(Foo).GetMethodInfo();

        Console.WriteLine(\"\\tMicrosoft.Samples.Debugging.CorSymbolStore\");
        foreach (var v in new MicrosoftDebuggingReader().Read(info))
            Console.WriteLine(v);

        Console.WriteLine(\"\\tMono.Cecil\");
        foreach (var v in new MonoCecilReader().Read(info))
            Console.WriteLine(v);
    }

    public static void Foo(string s)
    {
        for (int i; ;)
            for (double j; ;)
                for (bool k; ;)
                    for (object m = 0; ;)
                        for (DateTime n; ;) { }
    }
}

        Microsoft.Samples.Debugging.CorSymbolStore
Index 0, Type System.Int32, Name i
Index 1, Type System.Double, Name j
Index 2, Type System.Boolean, Name k
Index 3, Type System.Object, Name m
Index 4, Type System.DateTime, Name n
        Mono.Cecil
Index 0, Type System.Int32, Name i
Index 1, Type System.Double, Name j
Index 2, Type System.Boolean, Name k
Index 3, Type System.Object, Name m
Index 4, Type System.DateTime, Name n

Microsoft.Samples.Debugging.CorApi

Mono.Cecil