如何在.NET Core 6中解析Swagger JSON的路径与操作级扩展字段？

针对你的需求，这里提供三种可行的实现方案，覆盖不同场景：

方案1：使用Swashbuckle官方模型类（推荐） #

Swashbuckle.AspNetCore库提供了与Swagger规范完全匹配的强类型模型，直接用它来解析可以避免手动处理JSON结构的麻烦，还能自动处理自定义扩展字段（x-开头的字段会被映射到Extensions属性）。

步骤： #

1. 安装NuGet包：Swashbuckle.AspNetCore.Swagger
2. 读取Swagger JSON并反序列化为OpenApiDocument
3. 遍历路径与操作，提取路由和自定义扩展字段

代码示例： #

using System.IO;
using Microsoft.OpenApi.Models;
using Microsoft.OpenApi.Readers;

var swaggerJsonPath = "你的Swagger JSON文件路径";
var swaggerJsonContent = await File.ReadAllTextAsync(swaggerJsonPath);

// 反序列化Swagger JSON到官方模型
var reader = new OpenApiStringReader();
var openApiDoc = reader.Read(swaggerJsonContent, out var diagnostic);

if (!diagnostic.IsError)
{
    // 遍历所有路由路径
    foreach (var pathEntry in openApiDoc.Paths)
    {
        string route = pathEntry.Key;
        Console.WriteLine($"路由: {route}");

        // 遍历该路径下的所有HTTP操作（GET/POST等）
        foreach (var operationEntry in pathEntry.Value.Operations)
        {
            string httpMethod = operationEntry.Key.ToString();
            Console.WriteLine($"HTTP方法: {httpMethod}");

            // 读取自定义扩展字段（示例：x-custom-operation-data）
            if (operationEntry.Value.Extensions.TryGetValue("x-custom-operation-data", out var extension))
            {
                // 根据扩展字段的实际类型转换
                if (extension is OpenApiString stringValue)
                {
                    Console.WriteLine($"自定义字段值: {stringValue.Value}");
                }
                else if (extension is OpenApiObject objectValue)
                {
                    // 处理对象类型的扩展字段
                    foreach (var prop in objectValue)
                    {
                        Console.WriteLine($"{prop.Key}: {(prop.Value as OpenApiString)?.Value}");
                    }
                }
            }
        }
    }
}

方案2：用System.Text.Json动态解析（无额外依赖） #

如果不想引入Swashbuckle依赖，可以直接用.NET Core内置的System.Text.Json进行动态解析，通过遍历JSON节点提取路由和自定义扩展字段。

代码示例： #

using System.IO;
using System.Text.Json;

var swaggerJsonPath = "你的Swagger JSON文件路径";
var swaggerJsonContent = await File.ReadAllTextAsync(swaggerJsonPath);

using var jsonDoc = JsonDocument.Parse(swaggerJsonContent);
var pathsNode = jsonDoc.RootElement.GetProperty("paths");

// 遍历所有路由
foreach (var pathNode in pathsNode.EnumerateObject())
{
    string route = pathNode.Name;
    Console.WriteLine($"路由: {route}");

    // 遍历该路由下的所有HTTP操作
    foreach (var operationNode in pathNode.Value.EnumerateObject())
    {
        string httpMethod = operationNode.Name;
        Console.WriteLine($"HTTP方法: {httpMethod}");

        // 筛选并读取所有x-开头的自定义扩展字段
        foreach (var prop in operationNode.Value.EnumerateObject())
        {
            if (prop.Name.StartsWith("x-", StringComparison.OrdinalIgnoreCase))
            {
                string value = prop.Value.ValueKind switch
                {
                    JsonValueKind.String => prop.Value.GetString(),
                    JsonValueKind.Number => prop.Value.GetInt32().ToString(),
                    JsonValueKind.Object => JsonSerializer.Serialize(prop.Value),
                    _ => prop.Value.ToString()
                };
                Console.WriteLine($"{prop.Name}: {value}");
            }
        }
    }
}

方案3：用Newtonsoft.Json动态解析（适合已有Json.NET的项目） #

如果你的项目已经在使用Newtonsoft.Json（Json.NET），可以用JObject来简化动态解析过程。

代码示例： #

using System.IO;
using Newtonsoft.Json.Linq;

var swaggerJsonPath = "你的Swagger JSON文件路径";
var swaggerJsonContent = await File.ReadAllTextAsync(swaggerJsonPath);

var swaggerObj = JObject.Parse(swaggerJsonContent);
var pathsObj = swaggerObj["paths"] as JObject;

// 遍历所有路由
foreach (var pathProp in pathsObj.Properties())
{
    string route = pathProp.Name;
    Console.WriteLine($"路由: {route}");

    var operationObj = pathProp.Value as JObject;
    // 遍历所有HTTP操作
    foreach (var operationProp in operationObj.Properties())
    {
        string httpMethod = operationProp.Name;
        Console.WriteLine($"HTTP方法: {httpMethod}");

        // 提取所有x-开头的自定义扩展字段
        foreach (var extensionProp in operationProp.Value.Properties().Where(p => p.Name.StartsWith("x-")))
        {
            Console.WriteLine($"{extensionProp.Name}: {extensionProp.Value.ToString()}");
        }
    }
}

方案对比： #

• 方案1：最贴合Swagger规范，类型安全，自动处理复杂结构，适合使用Swashbuckle的项目，但需要引入额外NuGet包。
• 方案2：无额外依赖，轻量灵活，适合不想加第三方库的场景，但需要手动处理类型转换。
• 方案3：语法简洁，适合已经使用Json.NET的项目，和方案2类似但API更友好。

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