客户端应用程序

        public class DriverLifecycleExample : IDisposable
        {
            public DriverLifecycleExample(string uri, string user, string password)
            {
                Driver = GraphDatabase.Driver(uri, AuthTokens.Basic(user, password));
            }

            public IDriver Driver { get; }

            public void Dispose()
            {
                Driver?.Dispose();
            }
        }
    }

    public class HelloWorldExampleTest : BaseExample
    {
        public HelloWorldExampleTest(ITestOutputHelper output, StandAloneIntegrationTestFixture fixture)
            : base(output, fixture)
        {
        }

        [RequireServerFact]
        public void TestHelloWorldExample()
        {
            // Given
            using var example = new HelloWorldExample(Uri, User, Password);
            // When & Then
            example.PrintGreeting("Hello, world");
        }

        public class HelloWorldExample : IDisposable
        {
            private readonly IDriver _driver;

            public HelloWorldExample(string uri, string user, string password)
            {
                _driver = GraphDatabase.Driver(uri, AuthTokens.Basic(user, password));
            }

            public void Dispose()
            {
                _driver?.Dispose();
            }

            public void PrintGreeting(string message)
            {
                using var session = _driver.Session();
                var greeting = session.ExecuteWrite(
                    tx =>
                    {
                        var result = tx.Run(
                            "CREATE (a:Greeting) " +
                            "SET a.message = $message " +
                            "RETURN a.message + ', from node ' + id(a)",
                            new { message });

                        return result.Single()[0].As<string>();
                    });

                Console.WriteLine(greeting);
            }

            public static void Main()
            {
                using var greeter = new HelloWorldExample("bolt://:7687", "neo4j", "password");

                greeter.PrintGreeting("hello, world");
            }
        }
    }

    public class ReadWriteTransactionExample : BaseExample
    {
        public ReadWriteTransactionExample(ITestOutputHelper output, StandAloneIntegrationTestFixture fixture)
            : base(output, fixture)
        {
        }

        [RequireServerFact]
        public void TestReadWriteTransactionExample()
        {
            // When & Then
            AddPerson("Alice").Should().BeGreaterOrEqualTo(0L);
        }

        public long AddPerson(string name)
        {
            using var session = Driver.Session();
            session.ExecuteWrite(tx => CreatePersonNode(tx, name));
            return session.ExecuteRead(tx => MatchPersonNode(tx, name));
        }

        private static IResultSummary CreatePersonNode(IQueryRunner tx, string name)
        {
            return tx.Run("CREATE (a:Person {name: $name})", new { name }).Consume();
        }

        private static long MatchPersonNode(IQueryRunner tx, string name)
        {
            var result = tx.Run("MATCH (a:Person {name: $name}) RETURN id(a)", new { name });
            return result.Single()[0].As<long>();
        }

    }

    public class ResultConsumeExample : BaseExample
    {
        public ResultConsumeExample(ITestOutputHelper output, StandAloneIntegrationTestFixture fixture)
            : base(output, fixture)
        {
        }

        public List<string> GetPeople()
        {
            using var session = Driver.Session();
            return session.ExecuteRead(
                tx =>
                {
                    var result = tx.Run("MATCH (a:Person) RETURN a.name ORDER BY a.name");
                    return result.Select(record => record[0].As<string>()).ToList();
                });
        }

        [RequireServerFact]
        public void TestResultConsumeExample()
        {
            // Given
            Write("CREATE (a:Person {name: 'Alice'})");
            Write("CREATE (a:Person {name: 'Bob'})");
            // When & Then
            GetPeople().Should().Contain(new[] { "Alice", "Bob" });
        }
    }

    public class ResultRetainExample : BaseExample
    {
        public ResultRetainExample(ITestOutputHelper output, StandAloneIntegrationTestFixture fixture)
            : base(output, fixture)
        {
        }

        public int AddEmployees(string companyName)
        {
            using var session = Driver.Session();
            var persons = session.ExecuteRead(tx => tx.Run("MATCH (a:Person) RETURN a.name AS name").ToList());
            return persons.Sum(
                person => session.ExecuteWrite(
                    tx =>
                    {
                        var result = tx.Run(
                            "MATCH (emp:Person {name: $person_name}) " +
                            "MERGE (com:Company {name: $company_name}) " +
                            "MERGE (emp)-[:WORKS_FOR]->(com)",
                            new { person_name = person["name"].As<string>(), company_name = companyName });

                        result.Consume();
                        return 1;
                    }));
        }

        [RequireServerFact]
        public void TestResultConsumeExample()
        {
            // Given
            Write("CREATE (a:Person {name: 'Alice'})");
            Write("CREATE (a:Person {name: 'Bob'})");
            // When & Then
            AddEmployees("Example").Should().Be(2);
            Read("MATCH (emp:Person)-[WORKS_FOR]->(com:Company) WHERE com.name = 'Example' RETURN count(emp)")
                .Single()[0]
                .As<int>()
                .Should()
                .Be(2);
        }
    }

    public class ServiceUnavailableExample : BaseExample
    {
        private readonly IDriver _baseDriver;

        public ServiceUnavailableExample(ITestOutputHelper output, StandAloneIntegrationTestFixture fixture)
            : base(output, fixture)
        {
            _baseDriver = Driver;
            Driver = GraphDatabase.Driver(
                "bolt://:8080",
                AuthTokens.Basic(User, Password),
                o => o.WithMaxTransactionRetryTime(TimeSpan.FromSeconds(3)));
        }

        protected override void Dispose(bool isDisposing)
        {
            if (!isDisposing)
            {
                return;
            }

            Driver = _baseDriver;
            base.Dispose(true);
        }

        public bool AddItem()
        {
            try
            {
                using var session = Driver.Session();
                return session.ExecuteWrite(
                    tx =>
                    {
                        tx.Run("CREATE (a:Item)").Consume();
                        return true;
                    });
            }
            catch (ServiceUnavailableException)
            {
                return false;
            }
        }

        [RequireServerFact]
        public void TestServiceUnavailableExample()
        {
            AddItem().Should().BeFalse();
        }
    }

    [SuppressMessage("ReSharper", "xUnit1013")]
    public class SessionExample : BaseExample
    {
        public SessionExample(ITestOutputHelper output, StandAloneIntegrationTestFixture fixture)
            : base(output, fixture)
        {
        }

        public void AddPerson(string name)
        {
            using var session = Driver.Session();
            session.Run("CREATE (a:Person {name: $name})", new { name });
        }

        [RequireServerFact]
        public void TestSessionExample()
        {
            // Given & When
            AddPerson("Alice");
            // Then
            CountPerson("Alice").Should().Be(1);
        }
    }

    [SuppressMessage("ReSharper", "xUnit1013")]
    public class TransactionFunctionExample : BaseExample
    {
        public TransactionFunctionExample(ITestOutputHelper output, StandAloneIntegrationTestFixture fixture)
            : base(output, fixture)
        {
        }

        public void AddPerson(string name)
        {
            using var session = Driver.Session();
            session.ExecuteWrite(tx => tx.Run("CREATE (a:Person {name: $name})", new { name }).Consume());
        }

        [RequireServerFact]
        public void TestTransactionFunctionExample()
        {
            // Given & When
            AddPerson("Alice");
            // Then
            CountPerson("Alice").Should().Be(1);
        }
    }

    [SuppressMessage("ReSharper", "xUnit1013")]
    public class TransactionTimeoutConfigExample : BaseExample
    {
        public TransactionTimeoutConfigExample(ITestOutputHelper output, StandAloneIntegrationTestFixture fixture)
            : base(output, fixture)
        {
        }

        public void AddPerson(string name)
        {
            using var session = Driver.Session();
            session.ExecuteWrite(
                tx => tx.Run("CREATE (a:Person {name: $name})", new { name }).Consume(),
                txConfig => txConfig.WithTimeout(TimeSpan.FromSeconds(5)));
        }

        [RequireServerFact]
        public void TestTransactionTimeoutConfigExample()
        {
            // Given & When
            AddPerson("Alice");
            // Then
            CountPerson("Alice").Should().Be(1);
        }
    }

    [SuppressMessage("ReSharper", "xUnit1013")]
    public class TransactionMetadataConfigExample : BaseExample
    {
        public TransactionMetadataConfigExample(ITestOutputHelper output, StandAloneIntegrationTestFixture fixture)
            : base(output, fixture)
        {
        }

        public void AddPerson(string name)
        {
            using var session = Driver.Session();
            var txMetadata = new Dictionary<string, object> { { "applicationId", "123" } };

            session.ExecuteWrite(
                tx => tx.Run("CREATE (a:Person {name: $name})", new { name }).Consume(),
                txConfig => txConfig.WithMetadata(txMetadata));
        }

        [RequireServerFact]
        public void TestTransactionMetadataConfigExample()
        {
            // Given & When
            AddPerson("Alice");
            // Then
            CountPerson("Alice").Should().Be(1);
        }
    }

    public class DatabaseSelectionExampleTest : BaseExample
    {
        public DatabaseSelectionExampleTest(ITestOutputHelper output, StandAloneIntegrationTestFixture fixture)
            : base(output, fixture)
        {
        }

        [RequireEnterpriseEdition("4.0.0", "5.0.0", VersionComparison.Between)]
        public async void TestUseAnotherDatabaseExample()
        {
            try
            {
                await DropDatabase(Driver, "examples");
            }
            catch (FatalDiscoveryException)
            {
                // Its a new server instance, the database didn't exist yet
            }

            await CreateDatabase(Driver, "examples");

            // Given
            using var example = new DatabaseSelectionExample(Uri, User, Password);
            // When
            example.UseAnotherDatabaseExample();

            // Then
            var greetingCount = ReadInt("examples", "MATCH (a:Greeting) RETURN count(a)");
            greetingCount.Should().Be(1);
        }

        [RequireEnterpriseEdition("5.0.0", VersionComparison.GreaterThanOrEqualTo)]
        public async void TestUseAnotherDatabaseExampleAsync()
        {
            try
            {
                await DropDatabase(Driver, "examples", true);
            }
            catch (FatalDiscoveryException)
            {
                // Its a new server instance, the database didn't exist yet
            }

            await CreateDatabase(Driver, "examples", true);

            // Given
            using var example = new DatabaseSelectionExample(Uri, User, Password);
            // When
            example.UseAnotherDatabaseExample();

            // Then
            var greetingCount = ReadInt("examples", "MATCH (a:Greeting) RETURN count(a)");
            greetingCount.Should().Be(1);
        }

        private int ReadInt(string database, string query)
        {
            using var session = Driver.Session(SessionConfigBuilder.ForDatabase(database));
            return session.Run(query).Single()[0].As<int>();
        }

        private class DatabaseSelectionExample : IDisposable
        {
            private readonly IDriver _driver;
            private bool _disposed;

            public DatabaseSelectionExample(string uri, string user, string password)
            {
                _driver = GraphDatabase.Driver(uri, AuthTokens.Basic(user, password));
            }

            public void Dispose()
            {
                Dispose(true);
                GC.SuppressFinalize(this);
            }

            ~DatabaseSelectionExample()
            {
                Dispose(false);
            }

            public void UseAnotherDatabaseExample()
            {
                using (var session = _driver.Session(SessionConfigBuilder.ForDatabase("examples")))
                {
                    session.Run("CREATE (a:Greeting {message: 'Hello, Example-Database'}) RETURN a").Consume();
                }

                void SessionConfig(SessionConfigBuilder configBuilder)
                {
                    configBuilder.WithDatabase("examples")
                        .WithDefaultAccessMode(AccessMode.Read)
                        .Build();
                }

                using (var session = _driver.Session(SessionConfig))
                {
                    var result = session.Run("MATCH (a:Greeting) RETURN a.message as msg");
                    var msg = result.Single()[0].As<string>();
                    Console.WriteLine(msg);
                }
            }

            private void Dispose(bool disposing)
            {
                if (_disposed)
                {
                    return;
                }

                if (disposing)
                {
                    _driver?.Dispose();
                }

                _disposed = true;
            }
        }
    }

    [SuppressMessage("ReSharper", "xUnit1013")]
    public class PassBookmarksExample : BaseExample
    {
        public PassBookmarksExample(ITestOutputHelper output, StandAloneIntegrationTestFixture fixture)
            : base(output, fixture)
        {
        }

        // Create a company node
        private IResultSummary AddCompany(IQueryRunner tx, string name)
        {
            return tx.Run("CREATE (a:Company {name: $name})", new { name }).Consume();
        }

        // Create a person node
        private IResultSummary AddPerson(IQueryRunner tx, string name)
        {
            return tx.Run("CREATE (a:Person {name: $name})", new { name }).Consume();
        }

        // Create an employment relationship to a pre-existing company node.
        // This relies on the person first having been created.
        private IResultSummary Employ(IQueryRunner tx, string personName, string companyName)
        {
            return tx.Run(
                    @"MATCH (person:Person {name: $personName}) 
                         MATCH (company:Company {name: $companyName}) 
                         CREATE (person)-[:WORKS_FOR]->(company)",
                    new { personName, companyName })
                .Consume();
        }

        // Create a friendship between two people.
        private IResultSummary MakeFriends(IQueryRunner tx, string name1, string name2)
        {
            return tx.Run(
                    @"MATCH (a:Person {name: $name1}) 
                         MATCH (b:Person {name: $name2})
                         MERGE (a)-[:KNOWS]->(b)",
                    new { name1, name2 })
                .Consume();
        }

        // Match and display all friendships.
        private int PrintFriendships(IQueryRunner tx)
        {
            var result = tx.Run("MATCH (a)-[:KNOWS]->(b) RETURN a.name, b.name");

            var count = 0;
            foreach (var record in result)
            {
                count++;
                Console.WriteLine($"{record["a.name"]} knows {record["b.name"]}");
            }

            return count;
        }

        public void AddEmployAndMakeFriends()
        {
            // To collect the session bookmarks
            var savedBookmarks = new List<Bookmarks>();

            // Create the first person and employment relationship.
            using (var session1 = Driver.Session(o => o.WithDefaultAccessMode(AccessMode.Write)))
            {
                session1.ExecuteWrite(tx => AddCompany(tx, "Wayne Enterprises"));
                session1.ExecuteWrite(tx => AddPerson(tx, "Alice"));
                session1.ExecuteWrite(tx => Employ(tx, "Alice", "Wayne Enterprises"));

                savedBookmarks.Add(session1.LastBookmarks);
            }

            // Create the second person and employment relationship.
            using (var session2 = Driver.Session(o => o.WithDefaultAccessMode(AccessMode.Write)))
            {
                session2.ExecuteWrite(tx => AddCompany(tx, "LexCorp"));
                session2.ExecuteWrite(tx => AddPerson(tx, "Bob"));
                session2.ExecuteWrite(tx => Employ(tx, "Bob", "LexCorp"));

                savedBookmarks.Add(session2.LastBookmarks);
            }

            // Create a friendship between the two people created above.
            using (var session3 = Driver.Session(
                       o =>
                           o.WithDefaultAccessMode(AccessMode.Write).WithBookmarks(savedBookmarks.ToArray())))
            {
                session3.ExecuteWrite(tx => MakeFriends(tx, "Alice", "Bob"));

                session3.ExecuteRead(PrintFriendships);
            }
        }


        [RequireServerFact]
        public void TestPassBookmarksExample()
        {
            // Given & When
            AddEmployAndMakeFriends();

            // Then
            CountNodes("Person", "name", "Alice").Should().Be(1);
            CountNodes("Person", "name", "Bob").Should().Be(1);
            CountNodes("Company", "name", "Wayne Enterprises").Should().Be(1);
            CountNodes("Company", "name", "LexCorp").Should().Be(1);

            var works1 = Read(
                "MATCH (a:Person {name: $person})-[:WORKS_FOR]->(b:Company {name: $company}) RETURN count(a)",
                new { person = "Alice", company = "Wayne Enterprises" });

            works1.Count().Should().Be(1);

            var works2 = Read(
                "MATCH (a:Person {name: $person})-[:WORKS_FOR]->(b:Company {name: $company}) RETURN count(a)",
                new { person = "Bob", company = "LexCorp" });

            works2.Count().Should().Be(1);

            var friends = Read(
                "MATCH (a:Person {name: $person1})-[:KNOWS]->(b:Person {name: $person2}) RETURN count(a)",
                new { person1 = "Alice", person2 = "Bob" });

            friends.Count().Should().Be(1);
        }
    }
}

[Collection(SaIntegrationCollection.CollectionName)]
public abstract class BaseExample : IDisposable
{
    private bool _disposed;
    protected string Password = DefaultInstallation.Password;
    protected string Uri = DefaultInstallation.BoltUri;
    protected string User = DefaultInstallation.User;

    protected BaseExample(ITestOutputHelper output, StandAloneIntegrationTestFixture fixture)
    {
        Output = output;
        Driver = fixture.StandAloneSharedInstance.Driver;
    }

    protected ITestOutputHelper Output { get; }
    protected IDriver Driver { set; get; }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    ~BaseExample()
    {
        Dispose(false);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (_disposed)
        {
            return;
        }

        if (disposing)
        {
            using (var session = Driver.Session())
            {
                session.Run("MATCH (n) DETACH DELETE n").Consume();
            }
        }

        _disposed = true;
    }

    protected int CountNodes(string label, string property, string value)
    {
        using var session = Driver.Session();
        return session.ExecuteRead(
            tx => tx.Run(
                    $"MATCH (a:{label} {{{property}: $value}}) RETURN count(a)",
                    new { value })
                .Single()[0]
                .As<int>());
    }

    protected int CountPerson(string name)
    {
        return CountNodes("Person", "name", name);
    }

    protected void Write(string query, object parameters = null)
    {
        using var session = Driver.Session();
        session.ExecuteWrite(
            tx =>
                tx.Run(query, parameters).Consume());
    }

    protected List<IRecord> Read(string query, object parameters = null)
    {
        using var session = Driver.Session();
        return session.ExecuteRead(tx => tx.Run(query, parameters).ToList());
    }
}