源生成器与 Roslyn 分析器

// 初代写法：每次编译全量执行
[Generator]
public class LegacyGenerator : ISourceGenerator
{
    public void Initialize(GeneratorInitializationContext context) { }

    public void Execute(GeneratorExecutionContext context)
    {
        // 遍历所有语法树，代价高
        foreach (var tree in context.Compilation.SyntaxTrees)
        {
            // ... 拼代码
        }
        context.AddSource("Generated.g.cs", "// ...");
    }
}

// 增量写法：管道 + 缓存
[Generator]
public class IncrementalGenerator : IIncrementalGenerator
{
    public void Initialize(IncrementalGeneratorInitializationContext context)
    {
        // 语法提供器：只挑带特性的类
        var candidates = context.SyntaxProvider
            .ForAttributeWithMetadataName(
                "MyLib.GenerateDtoAttribute",
                predicate: (node, _) => node is ClassDeclarationSyntax,
                transform: (ctx, ct) => GetModel(ctx, ct))
            .Where(m => m is not null);

        // 收集后生成
        context.RegisterSourceOutput(candidates.Collect(), (spc, models) =>
        {
            var source = Emit(models!);
            spc.AddSource("Dtos.g.cs", source);
        });
    }
}

private static DtoModel? GetModel(GeneratorAttributeSyntaxContext ctx, CancellationToken ct)
{
    if (ctx.TargetSymbol is not INamedTypeSymbol type) return null;

    var ns = type.ContainingNamespace.IsGlobalNamespace
        ? null
        : type.ContainingNamespace.ToDisplayString();

    // 语义模型：把每个属性解析成类型
    var props = type.GetMembers()
        .OfType<IPropertySymbol>()
        .Where(p => p.DeclaredAccessibility == Accessibility.Public)
        .Select(p => new PropModel(
            p.Name,
            p.Type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)))
        .ToArray();

    return new DtoModel(ns, type.Name, props);
}

private sealed record PropModel(string Name, string Type);
private sealed record DtoModel(string? Namespace, string Name, PropModel[] Props);

[DiagnosticAnalyzer(LanguageNames.CSharp)]
public class SyncOverAsyncAnalyzer : DiagnosticAnalyzer
{
    public static readonly DiagnosticDescriptor Rule = new(
        id: "MYLIB001",
        title: "避免同步等待异步方法",
        messageFormat: "方法 {0} 返回 Task，请使用 await 而非 .Result",
        category: "Performance",
        defaultSeverity: DiagnosticSeverity.Warning,
        isEnabledByDefault: true);

    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
        => ImmutableArray.Create(Rule);

    public override void Initialize(AnalysisContext context)
    {
        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
        context.EnableConcurrentExecution();
        context.RegisterOperationAction(Analyze, OperationKind.PropertyReference);
    }

    private static void Analyze(OperationAnalysisContext context)
    {
        var prop = (IPropertyReferenceOperation)context.Operation;
        if (prop.Property.Name is not ("Result" or "Wait")) return;

        var type = prop.Instance?.Type;
        if (type is null || type.Name != "Task") return;

        context.ReportDiagnostic(Diagnostic.Create(Rule, prop.Syntax.GetLocation(), "Task"));
    }
}

[ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(SyncOverAsyncFix))]
[Shared]
public class SyncOverAsyncFix : CodeFixProvider
{
    public override ImmutableArray<string> FixableDiagnosticIds
        => ImmutableArray.Create(SyncOverAsyncAnalyzer.Rule.Id);

    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
    {
        var root = await context.Document.GetSyntaxRootAsync();
        var node = root!.FindNode(context.Span);

        context.RegisterCodeFix(
            CodeAction.Create(
                title: "改用 await",
                createChangedDocument: ct => ReplaceWithAwaitAsync(context.Document, node!, ct),
                equivalenceKey: "AwaitInsteadOfResult"),
            context.Diagnostics.First());
    }

    private static async Task<Document> ReplaceWithAwaitAsync(
        Document doc, SyntaxNode node, CancellationToken ct)
    {
        var root = await doc.GetSyntaxRootAsync(ct);
        var awaitExpr = SyntaxFactory.AwaitExpression((ExpressionSyntax)node);
        return doc.WithSyntaxRoot(root!.ReplaceNode(node, awaitExpr));
    }
}

// 官方源生成序列化上下文
[JsonSourceGenerationOptions(
    PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase,
    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull)]
[JsonSerializable(typeof(OrderDto))]
[JsonSerializable(typeof(List<OrderDto>))]
public partial class AppJsonContext : JsonSerializerContext { }

// 使用生成好的上下文（无反射）
var json = JsonSerializer.Serialize(order, AppJsonContext.Default.OrderDto);
var back = JsonSerializer.Deserialize(json, AppJsonContext.Default.OrderDto);

// 自定义生成器：为 [GenerateMapper] 类型产出映射方法
// 生成结果示例（Generated.g.cs）
namespace MyApp;

public static partial class OrderMapper
{
    public static OrderDto ToDto(this Order source) => new()
    {
        Id = source.Id,
        Total = source.Total,
        CreatedAt = source.CreatedAt,
    };
}

// 反例：模型持有 ISymbol，内存与缓存双重灾难
private sealed class BadModel
{
    public ISymbol Symbol { get; init; } = null!;   // 钉住整个编译单元
}

// 正例：只保留纯值，且用 record 获得值相等
private sealed record GoodModel(string Name, string FullTypeName, string? Namespace);

// 正例：把昂贵的语义计算放在 transform 里，缓存会自动复用
var models = context.SyntaxProvider
    .ForAttributeWithMetadataName("MyLib.GenerateDtoAttribute",
        (n, _) => n is ClassDeclarationSyntax,
        (ctx, ct) => BuildPureModel(ctx, ct))
    .Where(m => m is not null)
    .Collect();     // 收集后再统一生成

<!-- 生成器项目 .csproj 关键片段 -->
<PropertyGroup>
  <TargetFramework>netstandard2.0</TargetFramework>
  <EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
  <IncludeBuildOutput>false</IncludeBuildOutput>
  <IsRoslynComponent>true</IsRoslynComponent>
</PropertyGroup>

<ItemGroup>
  <PackageReference Include="Microsoft.CodeAnalysis.CSharp"
                    Version="4.8.0" PrivateAssets="all" />
  <None Include="$(OutputPath)\$(AssemblyName).dll"
        Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
</ItemGroup>

<!-- 使用者项目：按需引入，避免传递到下游 -->
<ItemGroup>
  <PackageReference Include="MyLib.Generators" Version="1.0.0"
                    PrivateAssets="all" />
</ItemGroup>