コード例 #1
0
        private static async void LaunchServer()
        {
            var host = new ProtocolHost();

            host.LoadFromReference <Program>();

            var dbOptions = new DbOptions();

            dbOptions.SetCreateIfMissing();
            var rocksDb = RocksDbSharp.RocksDb.Open(dbOptions, @"C:\rocks\primaryservicetest\");

            host.Resolver.Register(rocksDb, false);

            var primaryRepository = new RocksPrimaryRepository(rocksDb, nameof(TestEntity));

            primaryRepository.WriteOptions.SetSync(false);
            host.Resolver.Register(primaryRepository);

            var indexMaps = new IndexMapProvider <TestEntity>();

            host.Resolver.Register(indexMaps);

            indexMaps.AddScoreIndex(e => e.Score, IndexLevel.Entity, OrderType.Asc | OrderType.Desc);

            host.RegisterHandler <PrimaryRepositoryService <TestEntity> >(true);

            var serverTask = host.StartServerAsync("127.0.0.1", 8080, CancellationToken.None);

            Console.WriteLine("Service Started");
        }
コード例 #2
0
        public static async Task LaunchClient()
        {
            var host = new ProtocolHost();

            host.LoadFromReference <Program>();

            using (var session = await host.StartClientAsync("127.0.0.1", 8080, CancellationToken.None))
            {
                Console.WriteLine("Client connected");

                var repository = session.CreateChannel <IPrimaryRepositoryService <TestEntity> >();

                var entityId = Enumerable.Range(0, 10000).Select(i => ByteArray.New(32)).ToArray();

                List <Task> tasks = new List <Task>();

                var rand = new Random();

                var watch = Stopwatch.StartNew();
                //for (int i = 0; i < entityId.Length; i++)
                //{
                //    var score = rand.Next();

                //    var task = repository.SaveAsync(new TestEntity()
                //    {
                //        Id = entityId[i],
                //        Name= "card 1",
                //        Value = 1,
                //        Score = i,
                //    });
                //    tasks.Add(task);

                //    //var card = await repository.Get(entityId[i]);
                //}

                //await Task.WhenAll(tasks);

                for (int i = 0; i < 3; i++)
                {
                    await repository.SaveAsync(new TestEntity()
                    {
                        Id    = ByteArray.New(32),
                        Name  = "card 1",
                        Value = 1,
                        Score = i,
                    });
                }

                var firstTen = await repository.GetAsync(OrderType.Asc, false, 0, 10);

                watch.Stop();
                // save async: 10k 0.82s

                Console.WriteLine($"Done in {watch.Elapsed}");
                Console.WriteLine($"{watch.Elapsed.TotalMilliseconds} ms.");
            }
        }
コード例 #3
0
        public async Task HostAndChannelFactory()
        {
            var host = new ProtocolHost();

            host.LoadFromReference <ProtocolHostTests>();
            host.Resolver.Register(new CalculatorParameter()
            {
                First = 10
            });

            var cts        = new CancellationTokenSource();
            var serverTask = host.StartServerAsync("127.0.0.1", 91, cts.Token);

            var channelProvider = new ChannelProvider("127.0.0.1", 91);

            channelProvider.LoadFromReference <ProtocolHostTests>();
            var calculator = await channelProvider.GetChannelAsync <ICalculator>();

            var result = await calculator.AddAsync("9");

            Assert.AreEqual(19, result.Result);

            cts.Cancel();
            try
            {
                await serverTask;
            }
            catch { };

            host = new ProtocolHost();
            host.LoadFromReference <ProtocolHostTests>();
            host.Resolver.Register(new CalculatorParameter()
            {
                First = 10
            });

            serverTask = host.StartServerAsync("127.0.0.1", 91, CancellationToken.None);

            var channelProviderCollection = new ChannelProviderCollection(channelProvider);

            calculator = await channelProviderCollection.GetChannelAsync <ICalculator>();

            result = await calculator.AddAsync("9");

            Assert.AreEqual(19, result.Result);
        }
コード例 #4
0
        public async Task HostAndCreateChannel()
        {
            // Create host
            var host = new ProtocolHost();

            // Load controllers from reference.
            host.LoadFromReference <ProtocolHostTests>();

            // Register object to dependency injection. Just an example. This test doesn't require this.
            host.Resolver.Register(new CalculatorParameter()
            {
                First = 10
            });

            // Start server. Should be skiped on client side.
            var serverTask = host.StartServerAsync("127.0.0.1", 90, CancellationToken.None);


            IResolverSession clientSession = null;

            // Handle client connections.
            host.ClientConnected += (h, s) =>
            {
                // Session of client connected to server.
                clientSession = s;
            };

            // Can be used in Program.Main to run server. Task ends when server socket stops listening.
            // await serverTask;


            // Connect client. Should be skiped on server side.
            var session = await host.StartClientAsync("127.0.0.1", 90);

            // Create channel of IAddMethod interface on client side and call method from client to server.
            var serverSideCalculator = session.CreateChannel <IAddMethod>();

            // Create Stopwatch for performance measure.
            var watch = Stopwatch.StartNew();

            var tasks = new List <Task <CalculatorResult> >();

            // Run asynchronous 10k requests.
            for (int i = 0; i < 10000; i++)
            {
                // From client call method on server side.
                var task = serverSideCalculator.AddAsync(10, 9);
                tasks.Add(task);
            }

            // Wait when all 10k requests ends.
            var serverResults = await Task.WhenAll(tasks);

            // Stop Stopwatch.
            watch.Stop();

            // Check result.
            foreach (var serverResult in serverResults)
            {
                Assert.AreEqual(19, serverResult.Result);
            }

            // Check if elapsed time is less than one second.
            Assert.IsTrue(watch.ElapsedMilliseconds < 1000, $"Elapsed time is more than one second. Elapsed time in milliseconds: {watch.ElapsedMilliseconds}");

            // Since we created both server and client from same ProtocolHost, they have same controllers that we can call.
            // Create channel of IAddMethod interface on server side and call method from server to client.
            var clientSideCalculator = clientSession.CreateChannel <IAddMethod>();
            var clientResult         = await clientSideCalculator.AddAsync(10, 10);

            Assert.AreEqual(20, clientResult.Result);

            // Close client connection.
            session.Dispose();
        }