如何在C#中获取Neo4j最短路径查询的指定JSON格式结果？

1. 前置准备：安装APOC插件 #

确保Neo4j已安装APOC工具库：

• 若是Neo4j Desktop：在插件市场搜索APOC并安装，重启数据库。
• 若是服务器版本：下载对应Neo4j版本的APOC jar包，放入plugins目录，修改neo4j.conf添加apoc.export.file.enabled=true后重启服务。

2. 编写Cypher查询构建目标JSON #

原查询仅返回节点和关联节点，无法直接生成指定的graph结构JSON。通过Cypher列表生成式结合属性处理能力，直接构建符合要求的JSON结构：

MATCH p = shortestPath((p1:Person { name: 'Kevin Bacon' })-[*..15]-(p2:Person { name: 'Meg Ryan' }))
WITH nodes(p) AS pathNodes
// 匹配路径节点的所有出边（任意深度），收集所有相关节点和关系
MATCH path = (n)-[r*]->(q)
WHERE n IN pathNodes
// 展开多深度关系数组并去重
WITH 
  COLLECT(DISTINCT n) + COLLECT(DISTINCT q) AS allNodes,
  REDUCE(rels = [], relColl IN COLLECT(r) | rels + relColl) AS allRels
WITH allNodes, COLLECT(DISTINCT rel IN allRels | rel) AS uniqueRels
// 构建目标JSON结构
RETURN {
  results: [
    {
      data: [
        {
          graph: {
            nodes: [
              node IN allNodes | {
                id: toString(node.id),
                labels: labels(node),
                properties: properties(node)
              }
            ],
            relationships: [
              rel IN uniqueRels | {
                id: toString(rel.id),
                type: type(rel),
                startNode: toString(startNode(rel).id),
                endNode: toString(endNode(rel).id),
                properties: properties(rel)
              }
            ]
          }
        }
      ]
    }
  ],
  errors: []
} AS output

说明： #

• 若仅需路径节点的直接出边（而非任意深度），将MATCH path = (n)-[r*]->(q)改为MATCH (n)-[r]->(q)，并去掉REDUCE逻辑，直接用COLLECT(DISTINCT r)获取关系。
• toString(node.id)将Neo4j内部数值ID转为字符串，匹配目标JSON格式。
• COLLECT(DISTINCT)确保节点和关系不重复。

3. C#中执行查询并解析结果 #

使用Neo4j官方.NET驱动（NuGet包Neo4j.Driver）执行查询，直接获取并解析JSON：

using Neo4j.Driver;
using Newtonsoft.Json;

// 初始化Neo4j驱动
var uri = "bolt://localhost:7687";
var username = "neo4j";
var password = "你的数据库密码";

using var driver = GraphDatabase.Driver(uri, AuthTokens.Basic(username, password));
using var session = driver.Session();

// 执行上述Cypher查询
var query = @"
MATCH p = shortestPath((p1:Person { name: 'Kevin Bacon' })-[*..15]-(p2:Person { name: 'Meg Ryan' }))
WITH nodes(p) AS pathNodes
MATCH path = (n)-[r*]->(q)
WHERE n IN pathNodes
WITH 
  COLLECT(DISTINCT n) + COLLECT(DISTINCT q) AS allNodes,
  REDUCE(rels = [], relColl IN COLLECT(r) | rels + relColl) AS allRels
WITH allNodes, COLLECT(DISTINCT rel IN allRels | rel) AS uniqueRels
RETURN {
  results: [
    {
      data: [
        {
          graph: {
            nodes: [
              node IN allNodes | {
                id: toString(node.id),
                labels: labels(node),
                properties: properties(node)
              }
            ],
            relationships: [
              rel IN uniqueRels | {
                id: toString(rel.id),
                type: type(rel),
                startNode: toString(startNode(rel).id),
                endNode: toString(endNode(rel).id),
                properties: properties(rel)
              }
            ]
          }
        }
      ]
    }
  ],
  errors: []
} AS output";

var resultRecord = session.Run(query).Single();
var jsonResult = resultRecord["output"].As<string>();

// 若需反序列化为C#对象，定义对应实体类
var graphData = JsonConvert.DeserializeObject<GraphResult>(jsonResult);

// 实体类定义
public class GraphResult
{
    public List<ResultItem> Results { get; set; }
    public List<object> Errors { get; set; }
}

public class ResultItem
{
    public List<DataItem> Data { get; set; }
}

public class DataItem
{
    public GraphContent Graph { get; set; }
}

public class GraphContent
{
    public List<Node> Nodes { get; set; }
    public List<Relationship> Relationships { get; set; }
}

public class Node
{
    public string Id { get; set; }
    public List<string> Labels { get; set; }
    public Dictionary<string, object> Properties { get; set; }
}

public class Relationship
{
    public string Id { get; set; }
    public string Type { get; set; }
    public string StartNode { get; set; }
    public string EndNode { get; set; }
    public Dictionary<string, object> Properties { get; set; }
}

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