Exemple #1
0
        public void ReduceProduct()
        {
            var tasks = new List <Task>();

            for (var i = 0; i < batchCount; i++)
            {
                for (var j = 0; j < _createProducts.Count; j++)
                {
                    var reduceProduct = new ReduceProduct
                    {
                        ProductId   = _createProducts[j].ProductId,
                        ReduceCount = 1
                    };
                    tasks.Add(Task.Run(() => ExceptionManager.Process(() => ExecuteCommand(reduceProduct), true)));
                }
            }
            Task.WaitAll(tasks.ToArray());

            var products = ExecuteCommand(new GetProducts
            {
                ProductIds = _createProducts.Select(p => p.ProductId).ToList()
            }) as List <Project>;

            for (var i = 0; i < _createProducts.Count; i++)
            {
                Assert.AreEqual(products.FirstOrDefault(p => p.Id == _createProducts[i].ProductId)
                                .Count,
                                _createProducts[i].Count - batchCount);
            }
        }
Exemple #2
0
        static void ServiceTest()
        {
            ReduceProduct reduceProduct = new ReduceProduct
            {
                ProductId   = new Guid("2B6FDE83-A319-433B-9FA5-399D382D0CD3"),
                ReduceCount = 1
            };

            var _commandBus = IoCFactory.Resolve <ICommandBus>();

            _commandBus.Start();

            var t = _commandBus.SendAsync(reduceProduct, true).Result;

            Console.WriteLine(t.Reply.Result);


            var products = _commandBus.SendAsync(new GetProducts
            {
                ProductIds = new List <Guid> {
                    reduceProduct.ProductId
                }
            }, true).Result.ReadAsAsync <List <Project> >().Result;

            Console.WriteLine(products.ToJson());
            Console.ReadLine();
        }
Exemple #3
0
        public void CommandBusReduceProductTest()
        {
            _commandBus = MessageQueueFactory.GetCommandBus();
            _commandBus.Start();
            var           startTime     = DateTime.Now;
            ReduceProduct reduceProduct = new ReduceProduct
            {
                ProductId   = _createProducts[0].ProductId,
                ReduceCount = 1
            };
            var t = _commandBus.SendAsync(reduceProduct, true).Result;

            Console.WriteLine(t.Reply.Result);

            var costTime = (DateTime.Now - startTime).TotalMilliseconds;

            _logger.ErrorFormat("cost time : {0} ms", costTime);

            var products = _commandBus.SendAsync(new GetProducts
            {
                ProductIds = _createProducts.Select(p => p.ProductId).ToList()
            }, true).Result.ReadAsAsync <List <Project> >().Result;
            var success = true;

            Console.WriteLine(products.ToJson());
            for (int i = 0; i < _createProducts.Count; i++)
            {
                success = success && products.FirstOrDefault(p => p.Id == _createProducts[i].ProductId)
                          .Count ==
                          _createProducts[i].Count - batchCount;
            }
            Console.WriteLine($"test success {success}");
            Stop();
        }
Exemple #4
0
        public async Task <ApiResult> ReduceProduct([FromBody] ReduceProduct reduceProduct)
        {
            // command bus processing
            return(await ExceptionManager.ProcessAsync(() => _commandBus.ExecuteAsync(reduceProduct)));

            // classic processing
            //return await ProcessAsync(() => _productService.Handle(reduceProduct), true);
        }
Exemple #5
0
        public async Task Handle(ReduceProduct command)
        {
            var product = await _repository.GetByKeyAsync <Product>(command.ProductId);

            product.ReduceCount(command.ReduceCount);
            await _unitOfWork.CommitAsync()
            .ConfigureAwait(false);

            _commandContext.Reply = product.Count;
        }
Exemple #6
0
        public void CommandBusExecuteAsyncTest()
        {
            _commandBus = MessageQueueFactory.GetCommandBus();
            _commandBus.Start();
            var reduceProduct = new ReduceProduct
            {
                ProductId   = _createProducts.First().ProductId,
                ReduceCount = 1
            };
            var result = _commandBus.ExecuteAsync(reduceProduct).Result;

            Stop();
        }
        public async Task <int> Handle(ReduceProduct command)
        {
            var product = await _repository.GetByKeyAsync <Product>(command.ProductId);

            product.ReduceCount(command.ReduceCount);

            await _unitOfWork.CommitAsync()
            .ConfigureAwait(false);

            await _messagePublisher.SendAsync(_eventBus.GetEvents().ToArray())
            .ConfigureAwait(false);

            return(product.Count);
        }
Exemple #8
0
        public void CommandBusPressureTest()
        {
            _commandBus = MessageQueueFactory.GetCommandBus();
            _commandBus.Start();
            var startTime = DateTime.Now;
            var tasks     = new List <Task>();

            for (var i = 0; i < batchCount; i++)
            {
                for (var j = 0; j < _createProducts.Count; j++)
                {
                    var reduceProduct = new ReduceProduct
                    {
                        ProductId   = _createProducts[j].ProductId,
                        ReduceCount = 1
                    };
                    var t = _commandBus.ExecuteAsync(reduceProduct);
                    tasks.Add(t);
                }
            }
            Task.WaitAll(tasks.ToArray());
            var costTime = (DateTime.Now - startTime).TotalMilliseconds;

            Console.WriteLine("cost time : {0} ms", costTime);

            var products = _commandBus.ExecuteAsync <List <Project> >(new GetProducts
            {
                ProductIds = _createProducts.Select(p => p.ProductId).ToList()
            })
                           .Result;
            var success = true;

            for (var i = 0; i < _createProducts.Count; i++)
            {
                success = success && products.FirstOrDefault(p => p.Id == _createProducts[i].ProductId)
                          .Count ==
                          _createProducts[i].Count - batchCount;
            }
            Console.WriteLine($"test success {success}");
            Assert.IsTrue(success);
            Stop();
        }
Exemple #9
0
        public void ReduceProductByMailbox()
        {
            var messageProcessor = new MessageProcessor(new DefaultProcessingMessageScheduler <IMessageContext>());

            messageProcessor.Start();
            for (var i = 0; i < batchCount; i++)
            {
                for (var j = 0; j < _createProducts.Count; j++)
                {
                    var reduceProduct = new ReduceProduct
                    {
                        ProductId   = _createProducts[j].ProductId,
                        ReduceCount = 1
                    };
                    var commandContext =
                        new MessageContext {
                        Message = reduceProduct, Key = reduceProduct.ProductId.ToString()
                    };

                    messageProcessor.Process(commandContext, messageContext => ExecuteCommand(messageContext));
                }
            }
            do
            {
                Task.Delay(100).Wait();
            } while (ProcessingMailbox <IMessageContext> .ProcessedCount != batchCount * productCount);

            var products = ExecuteCommand(new GetProducts
            {
                ProductIds = _createProducts.Select(p => p.ProductId).ToList()
            }) as List <Project>;

            for (var i = 0; i < _createProducts.Count; i++)
            {
                Assert.AreEqual(products.FirstOrDefault(p => p.Id == _createProducts[i].ProductId)
                                .Count,
                                _createProducts[i].Count - batchCount);
            }
        }
        public void CommandBusPressureTest()
        {
            var startTime = DateTime.Now;

            var tasks = new List <Task>();

            for (int i = 0; i < batchCount; i++)
            {
                for (int j = 0; j < _createProducts.Count; j++)
                {
                    ReduceProduct reduceProduct = new ReduceProduct
                    {
                        ProductId   = _createProducts[j].ProductId,
                        ReduceCount = 1
                    };
                    tasks.Add(_commandBus.SendAsync(reduceProduct, true).Result.Reply);
                }
            }
            Task.WaitAll(tasks.ToArray());
            var costTime = (DateTime.Now - startTime).TotalMilliseconds;

            _logger.ErrorFormat("cost time : {0} ms", costTime);
        }