public async Task MatchOutputsByInputAndResult()
        {
            var batcher = BatchExecutorFactory.Create(
                new BatchPolicy(
                    maxAge: TimeSpan.FromDays(1),
                    maxBatchSize: 3),
                async(IEnumerable <double> values) =>
            {
                var result = values.Reverse().Select(i => Tuple.Create((int)i, i.ToString())).ToList();
                return((IList <Tuple <int, string> >)result);
            },
                OutputToInputMatchFunction.CreateByMatchingPartOfInputAndResult(
                    (double input) => (int)input,
                    (int resultIndex, Tuple <int, string> resultValue) => resultValue.Item1));

            var task1 = batcher.ExecuteAsync(1.0);
            var task2 = batcher.ExecuteAsync(2.0);
            var task3 = batcher.ExecuteAsync(3.0);

            task1.Wait(TimeSpan.FromMilliseconds(100));

            Assert.AreEqual("1", task1.Result.Item2);
            Assert.AreEqual("2", task2.Result.Item2);
            Assert.AreEqual("3", task3.Result.Item2);
        }
Example #2
0
        public async Task TimeBatch()
        {
            var batcher = BatchExecutorFactory.Create(
                new BatchPolicy(
                    maxAge: TimeSpan.FromSeconds(1),
                    maxBatchSize: int.MaxValue),
                (IEnumerable <int> values) => Task.FromResult((IList <int>)values.ToList()),
                OutputToInputMatchFunction.OutputOrderMatchesInputOrder);

            var task1 = batcher.ExecuteAsync(1);
            var task2 = batcher.ExecuteAsync(2);

            await Task.Delay(100);

            Assert.IsFalse(task1.IsCompleted);
            Assert.IsFalse(task1.IsCompleted);

            task1.Wait(TimeSpan.FromSeconds(1));

            Assert.IsTrue(task1.IsCompleted);
            Assert.IsTrue(task2.IsCompleted);

            Assert.AreEqual(1, task1.Result);
            Assert.AreEqual(2, task2.Result);
        }
Example #3
0
        public async Task SingleItemTest()
        {
            int singleCalls = 0;
            int batchCalls  = 0;
            var batcher     = BatchExecutorFactory.Create(
                new BatchPolicy(
                    maxAge: TimeSpan.FromDays(1),
                    maxBatchSize: 1),
                (int value) =>
            {
                singleCalls++;
                return(Task.FromResult(value));
            },
                (IEnumerable <int> values) =>
            {
                batchCalls++;
                return(Task.FromResult((IList <int>)values.ToList()));
            },
                OutputToInputMatchFunction.OutputOrderMatchesInputOrder);

            var task1 = batcher.ExecuteAsync(1);

            task1.Wait(TimeSpan.FromMilliseconds(100));

            Assert.IsTrue(task1.IsCompleted);

            Assert.AreEqual(1, task1.Result);

            Assert.AreEqual(1, singleCalls);
            Assert.AreEqual(0, batchCalls);
        }
Example #4
0
        public void DisposeCancels()
        {
            var batcher = BatchExecutorFactory.Create(
                new BatchPolicy(
                    maxAge: TimeSpan.FromSeconds(1),
                    maxBatchSize: int.MaxValue),
                (IEnumerable <int> values) => Task.FromResult((IList <int>)values.ToList()),
                OutputToInputMatchFunction.OutputOrderMatchesInputOrder);

            var task1 = batcher.ExecuteAsync(1);
            var task2 = batcher.ExecuteAsync(2);

            Assert.IsFalse(task1.IsCompleted);
            Assert.IsFalse(task2.IsCompleted);

            batcher.Dispose();

            Assert.IsFalse(task1.IsCanceled);
            Assert.IsFalse(task2.IsCanceled);
        }