独立开发者@董川民

Just So So ...

使用C#编写.NET分析器（三）

译者注

这是在Datadog公司任职的Kevin Gosse大佬使用C#编写.NET分析器的系列文章之一，在国内只有很少很少的人了解和研究.NET分析器，它常被用于APM（应用性能诊断）、IDE、诊断工具中，比如Datadog的APM，Visual Studio的分析器以及Rider和Reshaper等等。之前只能使用C++编写，自从.NET NativeAOT发布以后，使用C#编写变为可能。

笔者最近也在尝试开发一个运行时方法注入的工具，欢迎熟悉MSIL 、PE Metadata 布局、CLR 源码、CLR Profiler API的大佬，或者对这个感兴趣的朋友留联系方式或者在公众号留言，一起交流学习。.

原作者：Kevin Gosse

原文链接：https://minidump.net/writing-a-net-profiler-in-c-part-3-7d2c59fc017f

项目链接：https://github.com/kevingosse/ManagedDotnetProfiler

使用C#编写.NET分析器-第一部分：https://mp.weixin.qq.com/s/faa9CFD2sEyGdiLMFJnyxw

使用C#编写.NET分析器-第二部分：

https://mp.weixin.qq.com/s/uZDtrc1py0wvCcUERZnKIw

正文

在第一部分中，我们了解了如何使用 NativeAOT让我们用C#编写一个分析器，以及如何暴露一个伪造的 COM对象来使用分析API。在第二部分中，我们改进了解决方案，使用实例方法替代静态方法。现在我们知道了如何与分析API进行交互，我们将编写一个源代码生成器，自动生成实现 ICorProfilerCallback接口中声明的70多个方法所需的样板代码。

首先，我们需要手动将 ICorProfilerCallback接口转换为C#。从技术上讲，本可以从C++头文件中自动生成这些代码，但是相同的C++代码在C#中可以用不同的方式翻译，因此了解函数的目的以正确语义进行转换十分重要。

以 JITInlining函数为实际例子。在C++中的原型是：


 

  1. HRESULT JITInlining(FunctionID callerId, FunctionID calleeId, BOOL *pfShouldInline);

一个简单的C#版本转换可能是：


 

  1. HResult JITInlining(FunctionId callerId, FunctionId calleeId, in bool pfShouldInline);

但是，如果我们查看函数的文档，我们可以了解到pfShouldInline是一个应由函数自身设置的值。所以我们应该使用out关键字：


 

  1. Result JITInlining(FunctionId callerId, FunctionId calleeId, out bool pfShouldInline);

在其他情况下，我们会根据意图使用in或ref关键字。这就是为什么我们无法完全自动化这个过程。

在将接口转换为C#之后，我们可以继续创建源代码生成器。请注意，我并不打算编写一个最先进的源代码生成器，主要原因是API非常复杂（是的，这话来自于一个教你如何用C#编写分析器的人），你可以查看Andrew Lock的精彩文章来了解如何编写高级源代码生成器。

编写源代码生成器

要创建源代码生成器，我们在解决方案中添加一个针对 netstandard2.0的类库项目，并添加对 Microsoft.CodeAnalysis.CSharp和 Microsoft.CodeAnalysis.Analyzers的引用：


 

  1. <Project Sdk="Microsoft.NET.Sdk">

  3. <PropertyGroup>

  4. <TargetFramework>netstandard2.0</TargetFramework>

  5. <ImplicitUsings>enable</ImplicitUsings>

  6. <LangVersion>latest</LangVersion>

  7. <IsRoslynComponent>true</IsRoslynComponent>

  8. </PropertyGroup>

  10. <ItemGroup>

  11. <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.0.1" PrivateAssets="all" />

  12. <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.3">

  13. <PrivateAssets>all</PrivateAssets>

  14. <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

  15. </PackageReference>

  16. </ItemGroup>

  18. </Project>

接下来，我们添加一个实现 ISourceGenerator接口的类，并用 [Generator]属性进行修饰：


 

  1. [Generator]

  2. public class NativeObjectGenerator : ISourceGenerator

  3. {

  4. public void Initialize(GeneratorInitializationContext context)

  5. {

  6. }

  8. public void Execute(GeneratorExecutionContext context)

  9. {

  10. }

  11. }

我们要做的第一件事是生成一个 [NativeObject]属性。我们将用它来修饰我们想要在源代码生成器上运行的接口。我们使用 RegisterForPostInitialization在管道早期运行这段代码：


 

  1. [Generator]

  2. public class NativeObjectGenerator : ISourceGenerator

  3. {

  4. public void Initialize(GeneratorInitializationContext context)

  5. {

  6. context.RegisterForPostInitialization(EmitAttribute);

  8. }

  10. public void Execute(GeneratorExecutionContext context)

  11. {

  12. }

  14. private void EmitAttribute(GeneratorPostInitializationContext context)

  15. {

  16. context.AddSource("NativeObjectAttribute.g.cs", """

  17. using System;

  19. [AttributeUsage(AttributeTargets.Interface, Inherited = false, AllowMultiple = false)]

  20. internal class NativeObjectAttribute : Attribute { }

  21. """);

  22. }

  23. }

现在我们需要注册一个 ISyntaxContextReceiver来检查类型并检测哪些类型被我们的 [NativeObject] 属性修饰。


 

  1. public class SyntaxReceiver : ISyntaxContextReceiver

  2. {

  3. public List<INamedTypeSymbol> Interfaces { get; } = new();

  5. public void OnVisitSyntaxNode(GeneratorSyntaxContext context)

  6. {

  7. if (context.Node is InterfaceDeclarationSyntax classDeclarationSyntax

  8. && classDeclarationSyntax.AttributeLists.Count > 0)

  9. {

  10. var symbol = (INamedTypeSymbol)context.SemanticModel.GetDeclaredSymbol(classDeclarationSyntax);

  12. if (symbol.GetAttributes().Any(a => a.AttributeClass.ToDisplayString() == "NativeObjectAttribute"))

  13. {

  14. Interfaces.Add(symbol);

  15. }

  16. }

  17. }

  18. }

基本上，语法接收器将被用于访问语法树中的每个节点。我们检查该节点是否是一个接口声明，如果是，我们检查属性以查找 NativeObjectAttribute。可能有很多事情都可以改进，特别是确认它是否是我们的 NativeObjectAttribute，但我们认为对于我们的目的来说这已经足够好了。

在源代码生成器初始化期间，需要注册语法接收器：


 

  1. public void Initialize(GeneratorInitializationContext context)

  2. {

  3. context.RegisterForPostInitialization(EmitAttribute);

  4. context.RegisterForSyntaxNotifications(() => new SyntaxReceiver());

  5. }

最后，在 Execute方法中，我们获取存储在语法接收器中的接口列表，并为其生成代码：


 

  1. public void Execute(GeneratorExecutionContext context)

  2. {

  3. if (!(context.SyntaxContextReceiver is SyntaxReceiver receiver))

  4. {

  5. return;

  6. }

  8. foreach (var symbol in receiver.Interfaces)

  9. {

  10. EmitStubForInterface(context, symbol);

  11. }

  12. }

使用C#编写.NET分析器（三）

生成Native包装器

对于EmitStubForInterface方法，我们可以使用模板引擎，但是我们将依赖于一个经典的StringBuilder和Replace调用。

首先，我们创建我们的模板:


 

  1. var sourceBuilder = new StringBuilder("""

  2. using System;

  3. using System.Runtime.InteropServices;

  5. namespace NativeObjects

  6. {

  7. {visibility} unsafe class {typeName} : IDisposable

  8. {

  9. private {typeName}({interfaceName} implementation)

  10. {

  11. const int delegateCount = {delegateCount};

  13. var obj = (IntPtr*)NativeMemory.Alloc((nuint)2 + delegateCount, (nuint)IntPtr.Size);

  15. var vtable = obj + 2;

  17. *obj = (IntPtr)vtable;

  19. var handle = GCHandle.Alloc(implementation);

  20. *(obj + 1) = GCHandle.ToIntPtr(handle);

  22. {functionPointers}

  24. Object = (IntPtr)obj;

  25. }

  27. public IntPtr Object { get; private set; }

  29. public static {typeName} Wrap({interfaceName} implementation) => new(implementation);

  31. public static implicit operator IntPtr({typeName} stub) => stub.Object;

  33. ~{typeName}()

  34. {

  35. Dispose();

  36. }

  38. public void Dispose()

  39. {

  40. if (Object != IntPtr.Zero)

  41. {

  42. NativeMemory.Free((void*)Object);

  43. Object = IntPtr.Zero;

  44. }

  46. GC.SuppressFinalize(this);

  47. }

  49. private static class Exports

  50. {

  51. {exports}

  52. }

  53. }

  54. }

  55. """);

如果你对某些部分不理解，请记得查看前一篇文章。这里唯一的新内容是析构函数和 Dispose方法，我们在其中调用 NativeMemory.Free来释放为该对象分配的内存。接下来，我们需要填充所有的模板部分：{visibility}、 {typeName}、 {interfaceName}、 {delegateCount}、 {functionPointers} 和 {exports}。

首先是简单的部分：


 

  1. var interfaceName = symbol.ToString();

  2. var typeName = $"{symbol.Name}";

  3. var visibility = symbol.DeclaredAccessibility.ToString().ToLower();

  5. // To be filled later

  6. int delegateCount = 0;

  7. var exports = new StringBuilder();

  8. var functionPointers = new StringBuilder();

对于一个接口 MyProfiler.ICorProfilerCallback，我们将生成一个类型为 NativeObjects.ICorProfilerCallback的包装器。这就是为什么我们将完全限定名存储在 interfaceName(= MyProfiler.ICorProfilerCallback)中，而仅将类型名存储在 typeName(= ICorProfilerCallback)中。

接下来我们想要生成导出列表及其函数指针。我希望源代码生成器支持继承，以避免代码重复，因为 ICorProfilerCallback13实现了 ICorProfilerCallback12，而 ICorProfilerCallback12本身又实现了 ICorProfilerCallback11，依此类推。因此我们提取目标接口继承自的接口列表，并为它们中的每一个提取方法：


 

  1. var interfaceList = symbol.AllInterfaces.ToList();

  2. interfaceList.Reverse();

  3. interfaceList.Add(symbol);

  5. foreach (var @interface in interfaceList)

  6. {

  7. foreach (var member in @interface.GetMembers())

  8. {

  9. if (member is not IMethodSymbol method)

  10. {

  11. continue;

  12. }

  14. // TODO: Inspect the method

  15. }

  16. }

对于一个 QueryInterface(inGuidguid,outIntPtrptr)方法，我们将生成的导出看起来像这样：


 

  1. [UnmanagedCallersOnly]

  2. public static int QueryInterface(IntPtr* self, Guid* __arg1, IntPtr* __arg2)

  3. {

  4. var handleAddress = *(self + 1);

  5. var handle = GCHandle.FromIntPtr(handleAddress);

  6. var obj = (IUnknown)handle.Target;

  8. var result = obj.QueryInterface(*__arg1, out var __local2);

  10. *__arg2 = __local2;

  12. return result;

  13. }

由于这些方法是实例方法，我们添加了 IntPtr*self参数。另外，如果托管接口中的函数带有 in/out/ref关键字修饰，我们将参数声明为指针类型，因为 UnmanagedCallersOnly方法不支持 in/out/ref。

生成导出所需的代码为：


 

  1. var parameterList = new StringBuilder();

  3. parameterList.Append("IntPtr* self");

  5. foreach (var parameter in method.Parameters)

  6. {

  7. var isPointer = parameter.RefKind == RefKind.None ? "" : "*";

  8. parameterList.Append($", {parameter.Type}{isPointer} __arg{parameter.Ordinal}");

  9. }

  11. exports.AppendLine($" [UnmanagedCallersOnly]");

  12. exports.AppendLine($" public static {method.ReturnType} {method.Name}({parameterList})");

  13. exports.AppendLine($" {{");

  14. exports.AppendLine($" var handle = GCHandle.FromIntPtr(*(self + 1));");

  15. exports.AppendLine($" var obj = ({interfaceName})handle.Target;");

  16. exports.Append($" ");

  18. if (!method.ReturnsVoid)

  19. {

  20. exports.Append("var result = ");

  21. }

  23. exports.Append($"obj.{method.Name}(");

  25. for (int i = 0; i < method.Parameters.Length; i++)

  26. {

  27. if (i > 0)

  28. {

  29. exports.Append(", ");

  30. }

  32. if (method.Parameters[i].RefKind == RefKind.In)

  33. {

  34. exports.Append($"*__arg{i}");

  35. }

  36. else if (method.Parameters[i].RefKind is RefKind.Out)

  37. {

  38. exports.Append($"out var __local{i}");

  39. }

  40. else

  41. {

  42. exports.Append($"__arg{i}");

  43. }

  44. }

  46. exports.AppendLine(");");

  48. for (int i = 0; i < method.Parameters.Length; i++)

  49. {

  50. if (method.Parameters[i].RefKind is RefKind.Out)

  51. {

  52. exports.AppendLine($" *__arg{i} = __local{i};");

  53. }

  54. }

  56. if (!method.ReturnsVoid)

  57. {

  58. exports.AppendLine($" return result;");

  59. }

  61. exports.AppendLine($" }}");

  63. exports.AppendLine();

  64. exports.AppendLine();

对于函数指针，给定与前面相同的方法，我们希望建立：


 

  1. *(vtable + 1) = (IntPtr)(delegate* unmanaged<IntPtr*, Guid*, IntPtr*>)&Exports.QueryInterface;

生成代码如下：


 

  1. var sourceArgsList = new StringBuilder();

  2. sourceArgsList.Append("IntPtr _");

  4. for (int i = 0; i < method.Parameters.Length; i++)

  5. {

  6. sourceArgsList.Append($", {method.Parameters[i].OriginalDefinition} a{i}");

  7. }

  9. functionPointers.Append($" *(vtable + {delegateCount}) = (IntPtr)(delegate* unmanaged<IntPtr*");

  11. for (int i = 0; i < method.Parameters.Length; i++)

  12. {

  13. functionPointers.Append($", {method.Parameters[i].Type}");

  15. if (method.Parameters[i].RefKind != RefKind.None)

  16. {

  17. functionPointers.Append("*");

  18. }

  19. }

  21. if (method.ReturnsVoid)

  22. {

  23. functionPointers.Append(", void");

  24. }

  25. else

  26. {

  27. functionPointers.Append($", {method.ReturnType}");

  28. }

  30. functionPointers.AppendLine($">)&Exports.{method.Name};");

  32. delegateCount++;

我们在接口的每个方法都完成了这个操作后，我们只需替换模板中的值并添加生成的源文件：


 

  1. sourceBuilder.Replace("{typeName}", typeName);

  2. sourceBuilder.Replace("{visibility}", visibility);

  3. sourceBuilder.Replace("{exports}", exports.ToString());

  4. sourceBuilder.Replace("{interfaceName}", interfaceName);

  5. sourceBuilder.Replace("{delegateCount}", delegateCount.ToString());

  6. sourceBuilder.Replace("{functionPointers}", functionPointers.ToString());

  8. context.AddSource($"{symbol.ContainingNamespace?.Name ?? "_"}.{symbol.Name}.g.cs", sourceBuilder.ToString());

就这样，我们的源代码生成器现在准备好了。

使用生成的代码

要使用我们的源代码生成器，我们可以声明 IUnknown、 IClassFactory和 ICorProfilerCallback接口，并用 [NativeObject]属性修饰它们：


 

  1. [NativeObject]

  2. public interface IUnknown

  3. {

  4. HResult QueryInterface(in Guid guid, out IntPtr ptr);

  5. int AddRef();

  6. int Release();

  7. }


 

  1. [NativeObject]

  2. internal interface IClassFactory : IUnknown

  3. {

  4. HResult CreateInstance(IntPtr outer, in Guid guid, out IntPtr instance);

  5. HResult LockServer(bool @lock);

  6. }


 

  1. [NativeObject]

  2. public unsafe interface ICorProfilerCallback : IUnknown

  3. {

  4. HResult Initialize(IntPtr pICorProfilerInfoUnk);

  6. // 70+ 多个方法，在这里省略

  7. }

然后我们实现 IClassFactory并调用 NativeObjects.IClassFactory.Wrap来创建本机包装器并暴露我们的 ICorProfilerCallback实例：


 

  1. public unsafe class ClassFactory : IClassFactory

  2. {

  3. private NativeObjects.IClassFactory _classFactory;

  4. private CorProfilerCallback2 _corProfilerCallback;

  6. public ClassFactory()

  7. {

  8. _classFactory = NativeObjects.IClassFactory.Wrap(this);

  9. }

  11. // The native wrapper has an implicit cast operator to IntPtr

  12. public IntPtr Object => _classFactory;

  14. public HResult CreateInstance(IntPtr outer, in Guid guid, out IntPtr instance)

  15. {

  16. Console.WriteLine("[Profiler] ClassFactory - CreateInstance");

  18. _corProfilerCallback = new();

  20. instance = _corProfilerCallback.Object;

  21. return HResult.S_OK;

  22. }

  24. public HResult LockServer(bool @lock)

  25. {

  26. return default;

  27. }

  29. public HResult QueryInterface(in Guid guid, out IntPtr ptr)

  30. {

  31. Console.WriteLine("[Profiler] ClassFactory - QueryInterface - " + guid);

  33. if (guid == KnownGuids.ClassFactoryGuid)

  34. {

  35. ptr = Object;

  36. return HResult.S_OK;

  37. }

  39. ptr = IntPtr.Zero;

  40. return HResult.E_NOTIMPL;

  41. }

  43. public int AddRef()

  44. {

  45. return 1; // TODO: 做实际的引用计数

  46. }

  48. public int Release()

  49. {

  50. return 0; // TODO: 做实际的引用计数

  51. }

  52. }

并在 DllGetClassObject中暴露它：


 

  1. public class DllMain

  2. {

  3. private static ClassFactory Instance;

  5. [UnmanagedCallersOnly(EntryPoint = "DllGetClassObject")]

  6. public static unsafe int DllGetClassObject(void* rclsid, void* riid, nint* ppv)

  7. {

  8. Console.WriteLine("[Profiler] DllGetClassObject");

  10. Instance = new ClassFactory();

  11. *ppv = Instance.Object;

  13. return 0;

  14. }

  15. }

最后，我们可以实现 ICorProfilerCallback的实例：


 

  1. public unsafe class CorProfilerCallback2 : ICorProfilerCallback2

  2. {

  3. private static readonly Guid ICorProfilerCallback2Guid = Guid.Parse("8a8cc829-ccf2-49fe-bbae-0f022228071a");

  5. private readonly NativeObjects.ICorProfilerCallback2 _corProfilerCallback2;

  7. public CorProfilerCallback2()

  8. {

  9. _corProfilerCallback2 = NativeObjects.ICorProfilerCallback2.Wrap(this);

  10. }

  12. public IntPtr Object => _corProfilerCallback2;

  14. public HResult Initialize(IntPtr pICorProfilerInfoUnk)

  15. {

  16. Console.WriteLine("[Profiler] ICorProfilerCallback2 - Initialize");

  18. // TODO: To be implemented in next article

  20. return HResult.S_OK;

  21. }

  23. public HResult QueryInterface(in Guid guid, out IntPtr ptr)

  24. {

  25. if (guid == ICorProfilerCallback2Guid)

  26. {

  27. Console.WriteLine("[Profiler] ICorProfilerCallback2 - QueryInterface");

  29. ptr = Object;

  30. return HResult.S_OK;

  31. }

  33. ptr = IntPtr.Zero;

  34. return HResult.E_NOTIMPL;

  35. }

  37. // Stripped for brevity: the default implementation of all 70+ methods of the interface

  38. // Automatically generated by the IDE

  39. }

如果我们使用一个测试应用程序运行它，我们会发现这些功能能按预期工作：


 

  1. [Profiler] DllGetClassObject

  2. [Profiler] ClassFactory - CreateInstance

  3. [Profiler] ICorProfilerCallback2 - QueryInterface

  4. [Profiler] ICorProfilerCallback2 - Initialize

  5. Hello, World!

在下一步中，我们将处理拼图的最后一个缺失部分：实现ICorProfilerCallback.Initialize方法并获取ICorProfilerInfo的实例。这样我们就拥有了与性能分析器API实际交互所需的一切。

本文作者：INCerryCS信息来源：公众号 InCerry所属分类：C#

董川民

Life is like a box of chocolates,you never know what you're going to get.
ChongQing Movie Motorcycle Website