如何用C#编写程序遍历文件夹中各类的构造函数参数？

核心思路是利用语言专属的语法分析工具直接解析类文件的抽象语法树（AST），精准识别命名空间、类、构造函数及其参数，完全规避文本匹配带来的误判问题。

以下针对两种主流编程语言给出具体实现：

针对C#项目（使用Roslyn分析引擎） #

Roslyn是微软官方的C#语法分析工具，能直接解析.cs文件生成结构化的AST，完美适配命名空间、类、构造函数的层级关系：

1. 先安装NuGet依赖：Microsoft.CodeAnalysis.CSharp、Microsoft.CodeAnalysis.CSharp.Workspaces
2. 编写遍历解析代码：

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using System.IO;
using System.Linq;

public class ConstructorParamExtractor
{
    public static void ScanFolder(string targetFolder)
    {
        // 递归遍历所有.cs文件
        foreach (var filePath in Directory.EnumerateFiles(targetFolder, "*.cs", SearchOption.AllDirectories))
        {
            var syntaxTree = CSharpSyntaxTree.ParseText(File.ReadAllText(filePath));
            var rootNode = syntaxTree.GetRoot() as CompilationUnitSyntax;

            // 遍历所有命名空间节点
            foreach (var nsNode in rootNode.Members.OfType<NamespaceDeclarationSyntax>())
            {
                Console.WriteLine($"命名空间: {nsNode.Name}");
                // 遍历命名空间下的类
                foreach (var classNode in nsNode.Members.OfType<ClassDeclarationSyntax>())
                {
                    Console.WriteLine($"  类名: {classNode.Identifier.Text}");
                    // 遍历类的所有构造函数
                    foreach (var ctorNode in classNode.Members.OfType<ConstructorDeclarationSyntax>())
                    {
                        Console.WriteLine($"    构造函数参数:");
                        foreach (var param in ctorNode.ParameterList.Parameters)
                        {
                            Console.WriteLine($"      - {param.Type} {param.Identifier.Text}");
                        }
                    }
                }
            }
        }
    }
}

针对Java项目（使用JavaParser分析库） #

JavaParser是开源的Java语法解析工具，能直接解析.java文件生成AST，精准识别代码结构：

1. 先添加Maven依赖：

<dependency>
    <groupId>com.github.javaparser</groupId>
    <artifactId>javaparser-core</artifactId>
    <version>3.25.8</version>
</dependency>

2. 编写遍历解析代码：

import com.github.javaparser.JavaParser;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
import com.github.javaparser.ast.body.ConstructorDeclaration;
import com.github.javaparser.ast.body.Parameter;

import java.io.File;
import java.io.IOException;
import java.util.List;

public class ConstructorParamExtractor {
    public static void scanFolder(String targetFolder) {
        File folder = new File(targetFolder);
        File[] javaFiles = folder.listFiles((dir, name) -> name.endsWith(".java"));
        if (javaFiles == null) return;

        for (File file : javaFiles) {
            try {
                CompilationUnit compUnit = JavaParser.parse(file);
                // 获取命名空间（包名）
                String packageName = compUnit.getPackageDeclaration()
                        .map(pkg -> pkg.getNameAsString())
                        .orElse("无包名");
                System.out.println("命名空间: " + packageName);

                // 遍历所有类（排除接口）
                List<ClassOrInterfaceDeclaration> classes = compUnit.findAll(ClassOrInterfaceDeclaration.class);
                for (ClassOrInterfaceDeclaration cls : classes) {
                    if (!cls.isInterface()) {
                        System.out.println("  类名: " + cls.getNameAsString());
                        // 遍历类的构造函数
                        List<ConstructorDeclaration> ctors = cls.getConstructors();
                        for (ConstructorDeclaration ctor : ctors) {
                            System.out.println("    构造函数参数:");
                            for (Parameter param : ctor.getParameters()) {
                                System.out.println("      - " + param.getType() + " " + param.getNameAsString());
                            }
                        }
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

为什么放弃文本匹配？ #

• 误判率高：注释、字符串中的constructor关键词会被错误识别
• 兼容性差：无法覆盖不同语言的构造函数语法变体（比如C#的静态构造函数、Java的重载构造函数）
• 层级混乱：无法精准关联类与所属命名空间的对应关系

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