如何在Visual Studio/VS Code中生成智能复杂代码片段？

这绝对是个能大幅提升团队开发效率的需求！针对这种需要精准插入位置、基于输入自动生成复杂样板代码的场景，我有几个从简单到进阶的实用方案，完全贴合你的需求：

1. IDE自定义高级代码片段（快速上手） #

如果不想折腾复杂的工具，先试试主流IDE的高级参数化代码片段，比如Visual Studio或Rider里的自定义模板：

• 你可以创建一个模板，定义好私有只读字段和构造函数的结构，把类名设为可输入的参数（比如$Dependency1$、$Dependency2$）
• 关键是利用IDE的上下文感知：比如在VS的代码片段里，用$selected$定位到你想插入的区域，或者配置模板插入到类的私有字段区（部分IDE支持指定插入位置，比如Rider的模板可以设置"插入到成员列表的开头/特定区域"）
• 举个VS代码片段的简化示例（.snippet文件）：

<?xml version="1.0" encoding="utf-8"?>
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <CodeSnippet Format="1.0.0">
    <Header>
      <Title>Generate Dependencies</Title>
      <Shortcut>gendeps</Shortcut>
    </Header>
    <Snippet>
      <Declarations>
        <Literal>
          <ID>Dependency1</ID>
          <ToolTip>First dependency class name</ToolTip>
          <Default>DependencyOne</Default>
        </Literal>
        <Literal>
          <ID>Dependency2</ID>
          <ToolTip>Second dependency class name</ToolTip>
          <Default>DependencyTwo</Default>
        </Literal>
      </Declarations>
      <Code Language="csharp">
        <![CDATA[
private readonly $Dependency1$ _$Dependency1.ToCamelCase()$;
private readonly $Dependency2$ _$Dependency2.ToCamelCase()$;

public $ClassName$($Dependency1$ $Dependency1.ToCamelCase()$, $Dependency2$ $Dependency2.ToCamelCase()$)
{
    _$Dependency1.ToCamelCase()$ = $Dependency1.ToCamelCase()$;
    _$Dependency2.ToCamelCase()$ = $Dependency2.ToCamelCase()$;
}
        ]]>
      </Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

不过这个方案的局限性是，如果你需要自动识别现有代码的结构（比如把字段插到已有私有字段的区域，而不是随便放），就得用更智能的方案了。

2. Roslyn分析器+代码修复（最贴合IntelliSense快速修复体验） #

这是最符合你需求的方案——完全模拟IDE内置的快速修复功能，能自动分析代码结构、精准插入代码：

核心思路 #

利用.NET的Roslyn编译器API，编写一个自定义的分析器和代码修复提供器：

1. 触发逻辑：可以通过右键菜单、快捷键，或者识别特定的注释标记（比如// GenerateDeps: DependencyOne, DependencyTwo）来触发
2. 代码分析：Roslyn会解析当前代码的语法树，找到目标类的位置，识别已有私有字段的区域、现有构造函数
3. 代码生成：自动生成私有只读字段，插入到类中合适的位置（比如和其他私有字段放在一起）；如果构造函数存在，就添加对应的参数和赋值语句；如果不存在，就新建构造函数

简化代码示例（C#） #

这里是核心逻辑的简化版，你可以基于这个扩展：

// 找到目标类的语法节点
var classDeclaration = root.FindNode(context.Node.Span)
    .FirstAncestorOrSelf<ClassDeclarationSyntax>();

// 生成私有只读字段
var dependencies = new[] { "DependencyOne", "DependencyTwo" }; // 这里替换为你的输入参数
var fieldDeclarations = dependencies.Select(dep =>
{
    var camelCaseName = char.ToLowerInvariant(dep[0]) + dep.Substring(1);
    return SyntaxFactory.FieldDeclaration(
            SyntaxFactory.VariableDeclaration(SyntaxFactory.ParseTypeName(dep))
                .WithVariables(SyntaxFactory.SingletonSeparatedList(
                    SyntaxFactory.VariableDeclarator($"_{camelCaseName}"))))
        .WithModifiers(SyntaxFactory.TokenList(
            SyntaxFactory.Token(SyntaxKind.PrivateKeyword),
            SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)));
});

// 确定字段插入位置（比如第一个非字段成员之前）
var insertionPoint = classDeclaration.Members
    .FirstOrDefault(m => !m.IsKind(SyntaxKind.FieldDeclaration)) 
    ?? classDeclaration.Members.Last();
var updatedClass = classDeclaration.InsertBefore(insertionPoint, fieldDeclarations);

// 处理构造函数
var existingConstructor = updatedClass.Members
    .OfType<ConstructorDeclarationSyntax>()
    .FirstOrDefault();

if (existingConstructor == null)
{
    // 创建新构造函数
    var parameters = dependencies.Select(dep =>
    {
        var camelCaseName = char.ToLowerInvariant(dep[0]) + dep.Substring(1);
        return SyntaxFactory.Parameter(SyntaxFactory.Identifier(camelCaseName))
            .WithType(SyntaxFactory.ParseTypeName(dep));
    });
    var assignmentStatements = dependencies.Select(dep =>
    {
        var camelCaseName = char.ToLowerInvariant(dep[0]) + dep.Substring(1);
        return SyntaxFactory.ExpressionStatement(
            SyntaxFactory.AssignmentExpression(
                SyntaxKind.SimpleAssignmentExpression,
                SyntaxFactory.IdentifierName($"_{camelCaseName}"),
                SyntaxFactory.IdentifierName(camelCaseName)));
    });
    var newConstructor = SyntaxFactory.ConstructorDeclaration(classDeclaration.Identifier)
        .WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)))
        .WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(parameters)))
        .WithBody(SyntaxFactory.Block(assignmentStatements));
    updatedClass = updatedClass.AddMembers(newConstructor);
}
else
{
    // 更新现有构造函数：添加参数和赋值语句
    var newParameters = existingConstructor.ParameterList.Parameters.AddRange(
        dependencies.Select(dep =>
        {
            var camelCaseName = char.ToLowerInvariant(dep[0]) + dep.Substring(1);
            return SyntaxFactory.Parameter(SyntaxFactory.Identifier(camelCaseName))
                .WithType(SyntaxFactory.ParseTypeName(dep));
        }));
    var newBody = existingConstructor.Body.AddStatements(
        dependencies.Select(dep =>
        {
            var camelCaseName = char.ToLowerInvariant(dep[0]) + dep.Substring(1);
            return SyntaxFactory.ExpressionStatement(
                SyntaxFactory.AssignmentExpression(
                    SyntaxKind.SimpleAssignmentExpression,
                    SyntaxFactory.IdentifierName($"_{camelCaseName}"),
                    SyntaxFactory.IdentifierName(camelCaseName))).ToArray();
        }));
    var updatedConstructor = existingConstructor
        .WithParameterList(newParameters)
        .WithBody(newBody);
    updatedClass = updatedClass.ReplaceNode(existingConstructor, updatedConstructor);
}

// 应用代码修改
context.Document = context.Document.WithSyntaxRoot(root.ReplaceNode(classDeclaration, updatedClass));

落地步骤 #

1. 在Visual Studio里新建一个**"Roslyn分析器和代码修复"**项目
2. 编写上述分析和修复逻辑，打包成VSIX插件
3. 安装插件后，就能像使用内置的快速修复一样，一键生成符合要求的代码了

3. 代码生成工具（批量/场景化需求） #

如果需要批量处理代码，或者和其他流程集成，可以用：

• T4模板：创建一个带参数的T4模板，输入依赖类名，直接生成对应的代码片段，甚至可以嵌入到现有文件中
• 自定义CLI工具：用Roslyn或其他代码解析库，读取目标文件，分析结构后插入代码，适合批量处理多个文件

总结 #

• 快速上手选IDE自定义代码片段
• 追求IntelliSense级体验选Roslyn分析器+代码修复
• 批量处理选T4模板/CLI工具

内容的提问来源于stack exchange，提问作者Jordi