如何使用Neo4jClient在C#Net中创建neo4j现有节点和新节点之间的关系？

我使用Neo4j数据库处理C#.net项目，无法在Neo4j中的现有节点和使用C#.net的新节点之间创建关系

我使用以下代码创建节点

// Create entities
var refA = client.Create(new Person() { FName = "Person A" });
var refB = client.Create(new Person() { FName = "Person B" });
var refC = client.Create(new Person() { FName = "Person C" });
var refD = client.Create(new Person() { FName = "Person D" });

// Create relationships
client.CreateRelationship(refA, new KnowsRelationship(refB));
client.CreateRelationship(refB, new KnowsRelationship(refC));
client.CreateRelationship(refB, new HatesRelationship(refD, new HatesData("Crazy guy")));
client.CreateRelationship(refC, new HatesRelationship(refD, new HatesData("Don't know why...")));

---

现在，我想在使用某种条件从数据库获取的一个现有节点和创建新节点之间创建关系。但是如果你想使用C#的Neo4J，你就不能这么做，你仍然需要对Cypher有深入的了解

您可以在此处找到关于它的详细文档：

我创建了一个示例程序，用于创建3个节点和它们之间的2个关系，然后查询与节点1相邻的节点

using Neo4jClient;
using Neo4jClient.Cypher;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Neo4JTest
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                GraphClient client = new GraphClient(new Uri("http://localhost:7474/db/data"));
                client.Connect();

                // Create nodes and relationship
                MyNode node1 = new MyNode() { Name = "Test 1" };
                MyNode node2 = new MyNode() { Name = "Test 2" };

                NodeReference<MyNode> node1ref = client.Create<MyNode>(node1);
                NodeReference<MyNode> node2ref = client.Create<MyNode>(node2);

                MyRelationShip rel12 = new MyRelationShip(node2ref);

                var Rel1 = client.CreateRelationship<MyNode, MyRelationShip>(node1ref, rel12);               

                MyNode node3 = new MyNode() { Name = "Test 3" };
                NodeReference<MyNode> node3ref = client.Create<MyNode>(node3);

                MyRelationShip rel13 = new MyRelationShip(node3ref);
                var Rel13 = client.CreateRelationship<MyNode, MyRelationShip>(node1ref, rel13);

                var query = client.Cypher.Start(new { n1 = node1ref })
                                        .Match("n1-[:MYRELATIONSHIP]->targetnode")
                                        .Return<MyNode>(targetnode => targetnode.As<MyNode>());
                var res = query.Results;

                int i = 0;
                foreach (MyNode n in res)
                {
                    i++;
                    Console.WriteLine(i + ". Name: '" + n.Name + "'");
                }
            }
            catch(NeoException ex)
            {
                Console.WriteLine(ex.ToString());
            }
            Console.ReadKey();
        }


        class MyNode
        {
            private string _name = "";

            public string Name
            {
                get
                {
                    return _name;
                }

                set
                {
                    _name = value;
                }
            }
        }
        public class MyRelationShip : Relationship, IRelationshipAllowingSourceNode<MyNode>, IRelationshipAllowingTargetNode<MyNode>
        {
            public static readonly string TypeKey = "MYRELATIONSHIP";

            public MyRelationShip(NodeReference targetNode)
                : base(targetNode)
            { }

            public override string RelationshipTypeKey
            {
                get { return TypeKey; }
            }
        }
    }
}

使用Neo4jClient；
使用Neo4jClient.Cypher；
使用制度；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
使用System.Threading.Tasks；
名称空间Neo4JTest
{
班级计划
{
静态void Main（字符串[]参数）
{
尝试
{
GraphClient=新GraphClient（新Uri（“http://localhost:7474/db/data"));
client.Connect（）；
//创建节点和关系
MyNode node1=新的MyNode（）{Name=“Test 1”}；
MyNode node2=新的MyNode（）{Name=“Test 2”}；
NodeReference node1ref=client.Create（node1）；
NodeReference node2ref=client.Create（node2）；
MyRelationShip rel12=新的MyRelationShip（node2ref）；
var Rel1=client.CreateRelationship（node1ref，rel12）；
MyNode node3=新的MyNode（）{Name=“Test 3”}；
NodeReference node3ref=client.Create（node3）；
MyRelationShip rel13=新的MyRelationShip（node3ref）；
var Rel13=client.CreateRelationship（node1ref，Rel13）；
var query=client.Cypher.Start（新的{n1=node1ref}）
.Match（“n1-[：MYRELATIONSHIP]->targetnode”）
.Return（targetnode=>targetnode.As（））；
var res=query.Results；
int i=0；
foreach（在res中为MyNode n）
{
i++；
Console.WriteLine（i+”.Name:“+n.Name+”）；
}
}
捕获（新异常）
{
Console.WriteLine（例如ToString（））；
}
Console.ReadKey（）；
}
类MyNode
{
私有字符串_name=“”；
公共字符串名
{
得到
{
返回_name；
}
设置
{
_名称=值；
}
}
}
公共类MyRelationShip:RelationshipRelationshipAllowingSourceNode、IRelationshipAllowingTargetNode
{
公共静态只读字符串TypeKey=“MYRELATIONSHIP”；
公共MyRelationShip（节点引用目标节点）
：base（targetNode）
{ }
公共重写字符串RelationshipTypeKey
{
获取{return TypeKey；}
}
}
}
}

请提供更多详细信息“但不能这样做”-请编辑您的问题以显示您已尝试过的内容。请写下您希望完成的内容的更多详细信息，因为毫无线索的情况下很难提供帮助。非常感谢。