协调并行事务

await driver.ExecutableQuery("<QUERY 1>").ExecuteAsync();

// subsequent .ExecutableQuery() calls will be causally chained

await driver.ExecutableQuery("<QUERY 2>").ExecuteAsync();  // can read result of <QUERY 1>
await driver.ExecutableQuery("<QUERY 3>").ExecuteAsync();  // can read result of <QUERY 2>

await driver.ExecutableQuery("<QUERY>")
    .WithConfig(new QueryConfig(enableBookmarkManager: false))
    .ExecuteAsync();

using var session = driver.AsyncSession(conf => conf.WithDatabase("<database-name>"));
await session.ExecuteWriteAsync(async tx => await tx.RunAsync("<QUERY 1>"));
await session.ExecuteWriteAsync(async tx => await tx.RunAsync("<QUERY 2>"));  // can read QUERY 1
await session.ExecuteWriteAsync(async tx => await tx.RunAsync("<QUERY 3>"));  // can read QUERY 1,2

using Neo4j.Driver;

const string dbUri = "<database-uri>";
const string dbUser = "<username>";
const string dbPassword = "<password>";

await using var driver = GraphDatabase.Driver(dbUri, AuthTokens.Basic(dbUser, dbPassword));
await driver.VerifyConnectivityAsync();

await createSomeFriends(driver);

async Task createSomeFriends(IDriver driver) {
    Bookmarks savedBookmarks = Bookmarks.From(new List<string>());  // to collect the sessions' bookmarks

    // Create the first person and employment relationship
    using var sessionA = driver.AsyncSession(conf => conf.WithDatabase("<database-name>"));
    await sessionA.ExecuteWriteAsync(tx => createPerson(tx, "Alice"));
    await sessionA.ExecuteWriteAsync(tx => employ(tx, "Alice", "Wayne Enterprises"));
    savedBookmarks += sessionA.LastBookmarks;  (1)

    // Create the second person and employment relationship
    using var sessionB = driver.AsyncSession(conf => conf.WithDatabase("<database-name>"));
    await sessionB.ExecuteWriteAsync(tx => createPerson(tx, "Bob"));
    await sessionB.ExecuteWriteAsync(tx => employ(tx, "Bob", "LexCorp"));
    savedBookmarks += sessionB.LastBookmarks;  (1)

    // Create a friendship between the two people created above
    using var sessionC = driver.AsyncSession(conf => conf
        .WithDatabase("<database-name>")
        .WithBookmarks(savedBookmarks)  (2)
    );
    await sessionC.ExecuteWriteAsync(tx => createFriendship(tx, "Alice", "Bob"));
    await sessionC.ExecuteWriteAsync(tx => printFriendships(tx));
}

// Create a person node
async Task createPerson(IAsyncQueryRunner tx, string name) {
    await tx.RunAsync("MERGE (:Person {name: $name})", new { name = name });
}

// Create an employment relationship to a pre-existing company node
// This relies on the person first having been created.
async Task employ(IAsyncQueryRunner tx, string personName, string companyName) {
    await tx.RunAsync(@"
        MATCH (person:Person {name: $personName})
        MATCH (company:Company {name: $companyName})
        CREATE (person)-[:WORKS_FOR]->(company)
        ", new { personName = personName, companyName = companyName }
    );
}

// Create a friendship between two people
async Task createFriendship(IAsyncQueryRunner tx, string nameA, string nameB) {
    await tx.RunAsync(@"
        MATCH (a:Person {name: $nameA})
        MATCH (b:Person {name: $nameB})
        MERGE (a)-[:KNOWS]->(b)
        ", new { nameA = nameA, nameB = nameB }
    );
}

// Retrieve and display all friendships
async Task printFriendships(IAsyncQueryRunner tx) {
    var result = await tx.RunAsync("MATCH (a)-[:KNOWS]->(b) RETURN a.name, b.name");
    while (await result.FetchAsync()) {
        var record = result.Current;
        Console.WriteLine(record.Get<string>("a.name") + " knows " + record.Get<string>("b.name"));
    }
}

await driver.ExecutableQuery("<QUERY 1>").ExecuteAsync();

using var session = driver.AsyncSession(conf => conf.
    WithDatabase("<database-name>")
    .WithBookmarkManager(driver.GetExecutableQueryBookmarkManager()));

// every query inside this session will be causally chained
// (i.e., can read what was written by <QUERY 1>)
await session.ExecuteWriteAsync(async tx => await tx.RunAsync("<QUERY 2>"));


// subsequent ExecutableQuery calls will also be causally chained
// (i.e., can read what was written by <QUERY 2>)
await driver.ExecutableQuery("<QUERY 3>").ExecuteAsync();