Пример #1
0
        public void ThrowArgumentException()
        {
            var entry = RpcMethodEntry.ExplicitParams <IntParam>(param =>
            {
                if (param.i < 0)
                {
                    throw new ArgumentOutOfRangeException();
                }
                return;
            });
            var handle = NewMethodAtA <IntParam>("VerifyIsNotNegative", entry);

            Assert.ThrowsAsync <ArgumentException>(() => handle.RequestAsync(new IntParam()
            {
                i = -1
            }).AsTask());
        }
Пример #2
0
        public Task PipeDuplex()
        {
            var methodEntry   = RpcMethodEntry.ExplicitParams <IntParam, int>(p => p.i);
            var aMethodHandle = NewMethodAtB <IntParam, int>("getI", methodEntry);
            var bMethodHandle = NewMethodAtA <IntParam, int>("getI", methodEntry);

            var tasks    = new Task[200000];
            var a2bTasks = tasks.AsSpan(100000);
            var b2aTasks = tasks.AsSpan(0, 100000);

            for (int i = 0; i < a2bTasks.Length; i++)
            {
                var taskLocalI = i;
                a2bTasks[i] = Task.Run(async() =>
                {
                    var task = aMethodHandle.RequestAsync(new IntParam()
                    {
                        i = taskLocalI
                    });
                    var resultI = await task;
                    Assert.AreEqual(taskLocalI, resultI);
                });
            }
            for (int i = 0; i < b2aTasks.Length; i++)
            {
                var taskLocalI = i;
                b2aTasks[i] = Task.Run(async() =>
                {
                    var task = bMethodHandle.RequestAsync(new IntParam()
                    {
                        i = taskLocalI
                    });
                    var resultI = await task;
                    Assert.AreEqual(taskLocalI, resultI);
                });
            }
            return(Task.WhenAll(tasks));
        }