运行您自己的事务

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

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();

// Create & employ 100 people to 10 different organizations
using var session = driver.AsyncSession(conf => conf.WithDatabase("<database-name>"));
for (int i=0; i<100; i++) {
    var name = $"Thor{i}";
    try {
        string orgId = await session.ExecuteWriteAsync(async tx => {
            return await employPersonTx(tx, name);
        });
        Console.WriteLine($"User {name} added to organization {orgId}.");
    } catch (Neo4jException e) {
        Console.WriteLine(e);
    }
}

async Task<string> employPersonTx(IAsyncQueryRunner tx, string name) {
    var employeeThreshold = 10;

    // Create new Person node with given name, if not exists already
    await tx.RunAsync("MERGE (p:Person {name: $name})", new { name = name });

    // Obtain most recent organization ID and the number of people linked to it
    var result = await tx.RunAsync(@"
        MATCH (o:Organization)
        RETURN o.id AS id, COUNT{(p:Person)-[r:WORKS_FOR]->(o)} AS employeesN
        ORDER BY o.createdDate DESC
        LIMIT 1
        ");

    string orgId = "";
    int employeesN = 0;
    bool org = await result.FetchAsync();
    if (org == false) {
        // If no organization exists, create one and add Person to it
        orgId = await createOrganization(tx);
        Console.WriteLine($"No orgs available, created {orgId}.");
    } else {
        orgId = result.Current.Get<string>("id");
        employeesN = result.Current.Get<int>("employeesN");
    }

    // If org does not have too many employees, add this Person to it
    if (employeesN < employeeThreshold) {
        await addPersonToOrganization(tx, name, orgId);
        // If the above throws, the transaction will roll back
        // -> not even Person is created!

    // Otherwise, create a new Organization and link Person to it
    } else {
        orgId = await createOrganization(tx);
        Console.WriteLine($"Latest org is full, created {orgId}.");
        await addPersonToOrganization(tx, name, orgId);
        // If any of the above throws, the transaction will roll back
        // -> not even Person is created!
    }

    return orgId;  // Organization ID to which the new Person ends up in
}

async Task<string> createOrganization(IAsyncQueryRunner tx) {
    var result = await tx.RunAsync(@"
        CREATE (o:Organization {id: randomuuid(), createdDate: datetime()})
        RETURN o.id AS id
    ");
    bool org = await result.FetchAsync();  // can't be false
    string orgId = result.Current.Get<string>("id");
    return orgId;
}

async Task addPersonToOrganization(IAsyncQueryRunner tx, string personName, string orgId) {
    await tx.RunAsync(@"
        MATCH (o:Organization {id: $orgId})
        MATCH (p:Person {name: $name})
        MERGE (p)-[:WORKS_FOR]->(o)
        ", new { orgId = orgId, name = personName }
    );
}

using var session = driver.AsyncSession(SessionConfigBuilder.ForDatabase("<database-name>"));
using var tx = await session.BeginTransactionAsync();
// use tx.RunAsync()      to run queries
//     tx.CommitAsync()   to commit the transaction
//     tx.RollbackAsync() to roll the transaction back

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();

string customerId = await createCustomer(driver);
int otherBankId = 42;
await transferToOtherBank(driver, customerId, otherBankId, 999);

async Task<string> createCustomer(IDriver driver) {
    var result = await driver.ExecutableQuery(@"
        MERGE (c:Customer {id: randomUUID(), balance: 1000})
        RETURN c.id AS id
        ")
        .WithConfig(new QueryConfig(database: "<database-name>"))
        .ExecuteAsync();
    return result.Result[0].Get<string>("id");
}

async Task transferToOtherBank(IDriver driver, string customerId, int otherBankId, float amount) {
    using var session = driver.AsyncSession(conf => conf.WithDatabase("<database-name>"));
    using var tx = await session.BeginTransactionAsync();

    if (! await customerBalanceCheck(tx, customerId, amount)) {
        Console.WriteLine($"Customer {customerId} doesn't have enough funds.");
        return;  // give up
    }

    otherBankTransferApi(customerId, otherBankId, amount);
    // Now the money has been transferred => can't rollback anymore
    // (cannot rollback external services interactions)

    try {
        await decreaseCustomerBalance(tx, customerId, amount);
        await tx.CommitAsync();
        Console.WriteLine($"Transferred {amount} to {customerId}.");
    } catch (Neo4jException e) {
        requestInspection(customerId, otherBankId, amount, e);
        throw new InvalidOperationException(e.Message);
    }
}

async Task<bool> customerBalanceCheck(IAsyncTransaction tx, string customerId, float amount) {
    var result = await tx.RunAsync(@"
        MATCH (c:Customer {id: $id})
        RETURN c.balance >= $amount AS sufficient
        ", new { id = customerId, amount = amount }
    );
    bool isRecord = await result.FetchAsync();
    if (isRecord == false) {
        return false;
    }
    var record = result.Current;
    return record.Get<bool>("sufficient");
}

void otherBankTransferApi(string customerId, int otherBankId, float amount) {
    // make some API call to other bank
}

async Task decreaseCustomerBalance(IAsyncTransaction tx, string customerId, float amount) {
    await tx.RunAsync(@"
        MATCH (c:Customer {id: $id})
        SET c.balance = c.balance - $amount
        ", new { id = customerId, amount = amount }
    );
}

void requestInspection(string customerId, int otherBankId, float amount, Exception e) {
    // manual cleanup required; log this or similar
    Console.WriteLine($"WARNING: transaction rolled back due to exception: {e.Message}.");
    Console.WriteLine($"customerId: {customerId}, otherBankId: {otherBankId}, amount: {amount}.");
}

using var session = driver.AsyncSession(conf => conf.WithDatabase("<database-name>"));
var people = await session.ExecuteReadAsync(
    async tx => {
        var result = await tx.RunAsync("MATCH (p:Person) RETURN p");
        return await result.ToListAsync();
    },
    conf => conf
        .WithTimeout(new TimeSpan(5))
        .WithMetadata(new Dictionary<string, object>{ { "appName", "peopleTracker" } })
);
foreach (var person in people) {
    Console.WriteLine(person);
}

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

// session usage

await session.DisposeAsync();