C# Future.IsAvailable方法代码示例

        public void Should_pass_derived_types_through_the_filter()
        {
            var received = new Future<bool>();

            Pipe consumer = PipeSegment.Consumer<BaseClass>(x => received.Complete(true));
            Pipe filter = PipeSegment.Filter<object>(consumer);

            filter.Send(new SubClass());

            received.IsAvailable(TimeSpan.Zero).ShouldBeTrue();
        }

        public void Should_not_stall_the_scheduler()
        {
            ActionQueue queue = new ThreadPoolActionQueue();
            ActionScheduler scheduler = new TimerActionScheduler(new ThreadPoolActionQueue());

            var called = new Future<bool>();

            scheduler.Schedule(200.Milliseconds(), queue, () => { throw new InvalidOperationException("Bugger!"); });
            scheduler.Schedule(400.Milliseconds(), queue, () => called.Complete(true));

            called.IsAvailable(1.Seconds()).ShouldBeTrue();
        }

        public void Should_schedule_events()
        {
            Channel<UserUpdate> channel = new SynchronousChannel<UserUpdate>();

            var update = new UserUpdate {LastActivity = DateTime.Now - 5.Minutes()};

            CommandQueue queue = new SynchronousCommandQueue();

            var scheduler = new ThreadPoolScheduler();

            var future = new Future<UserUpdate>();

            channel.Subscribe(queue, future.Complete);

            scheduler.Schedule(1000, () => channel.Publish(update));

            Thread.Sleep(500);

            Assert.IsFalse(future.IsAvailable(0.Seconds()));

            Assert.IsTrue(future.IsAvailable(1.Seconds()));
        }

        public void Should_wait_until_the_appropriate_time_for_the_action_to_execute()
        {
            ActionQueue queue = new ThreadPoolActionQueue();
            ActionScheduler scheduler = new TimerActionScheduler(new SynchronousActionQueue());

            var called = new Future<bool>();

            scheduler.Schedule(100.Milliseconds(), queue, () => called.Complete(true));

            called.IsAvailable(0.Seconds()).ShouldBeFalse();

            called.IsAvailable(1.Seconds()).ShouldBeTrue();
        }

        public void Should_not_run_any_pending_actions()
        {
            ActionQueue queue = new ThreadPoolActionQueue();
            ActionScheduler scheduler = new TimerActionScheduler(new ThreadPoolActionQueue());

            var called = new Future<bool>();

            scheduler.Schedule(1.Seconds(), queue, () => called.Complete(true));

            scheduler.Disable();

            called.IsAvailable(2.Seconds()).ShouldBeFalse();
        }

        public void Should_prevent_new_actions_from_being_queued()
        {
            ActionQueue queue = new ThreadPoolActionQueue();

            var called = new Future<bool>();

            queue.StopAcceptingActions();

            Assert.Throws<ActionQueueException>(() => queue.Enqueue(() => called.Complete(true)));

            queue.ExecuteAll(10.Seconds());

            called.IsAvailable().ShouldBeFalse();
        }

        public void Should_deliver_the_message_once_the_endpoint_is_available()
        {
            var received = new Future<PingMessage>();

            using (RemoteBus.Subscribe<PingMessage>(received.Complete).Disposable())
            {
                Thread.Sleep(100);

                var ping = new PingMessage();
                LocalBus.Publish(ping);

                received.IsAvailable(5.Seconds()).ShouldBeTrue();
            }
        }

        public void Should_filter_out_unwanted_messages()
        {
            Channel<UserUpdate> channel = new SynchronousChannel<UserUpdate>();

            UserUpdate update = new UserUpdate {LastActivity = DateTime.Now - 5.Minutes()};

            CommandQueue queue = new SynchronousCommandQueue();

            var future = new Future<UserUpdate>();

            channel.Subscribe(queue, future.Complete, message => message.LastActivity > DateTime.Now);

            var result = channel.Publish(update);
            Assert.IsTrue(result);

            Assert.IsFalse(future.IsAvailable(1.Seconds()));
        }

		public void Should_invoke_the_continuation()
		{
			var transport = MockRepository.GenerateStub<IMsmqTransport>();
			transport.Stub(x => x.Receive(null))
				.Callback(new Func<Func<Message, Action<Message>>, bool>(Forwarder));

			var address = MockRepository.GenerateMock<IMsmqEndpointAddress>();

			IEndpoint endpoint = new MsmqEndpoint(address, new XmlMessageSerializer(), transport, MockRepository.GenerateMock<IMsmqTransport>());

			var future = new Future<object>();

			endpoint.Receive(m =>
			                 message =>
			                 	{
			                 		Assert.IsInstanceOf<SimpleMessage>(message);

			                 		Assert.AreEqual(((SimpleMessage) message).Name, "Chris");

			                 		future.Complete(message);
			                 	});

			Assert.IsTrue(future.IsAvailable(), "Receive was not called");
		}

        public void Should_result_in_no_waiting_actions_in_the_queue()
        {
            TraceLogProvider.Configure(LogLevel.Debug);

            ActionQueue queue = new ThreadPoolActionQueue();

            queue.Enqueue(() => Thread.Sleep(1000));

            var called = new Future<bool>();

            queue.Enqueue(() => called.Complete(true));

            queue.ExecuteAll(8.Seconds());

            called.IsAvailable().ShouldBeTrue();
        }

		public void Should_receive_the_message_when_a_transaction_is_rolled_back()
		{
			var future = new Future<DeleteMessage>();

			using (TransactionScope transaction = new TransactionScope())
			{
				Endpoint.Receive(message => m => { future.Complete(m as DeleteMessage); });

				// do not complete the transaction (implicit rollback)
			}

			future.IsAvailable().ShouldBeTrue();

			Endpoint.ShouldContain<DeleteMessage>();
		}

		public void Should_receive_the_message_when_a_transaction_is_completed()
		{
			var future = new Future<DeleteMessage>();

			using (TransactionScope transaction = new TransactionScope())
			{
				Endpoint.Receive(message => m => { future.Complete(m as DeleteMessage); });

				transaction.Complete();
			}

			future.IsAvailable().ShouldBeTrue();
			Endpoint.ShouldNotContain<DeleteMessage>();
		}

        public void Should_work_for_thread_static_instances()
        {
            int message = 27;

            var result = MockRepository.GenerateMock<Channel<int>>();
            result.Expect(x => x.Send(message)).Repeat.Twice();

            var provider = MockRepository.GenerateMock<ChannelProvider<int>>();
            provider.Expect(x => x(message)).Return(result).Repeat.Twice();

            var channel = new InstanceChannel<int>(new ThreadStaticChannelProvider<int>(provider).GetChannel);

            Future<bool> first = new Future<bool>();
            Future<bool> second = new Future<bool>();

            ThreadPool.QueueUserWorkItem(x =>
                {
                    long k;
                    for (int i = 0; i < 10000000; i++)
                    {
                        k = i*777;

                    }
                    channel.Send(message);
                    first.Complete(true);
                });
            ThreadPool.QueueUserWorkItem(x =>
                {
                    long k;
                    for (int i = 0; i < 10000000; i++)
                    {
                        k = i * 777;

                    }
                    channel.Send(message);
                    second.Complete(true);
                });

            first.IsAvailable(5.Seconds()).ShouldBeTrue();
            second.IsAvailable(5.Seconds()).ShouldBeTrue();

            provider.VerifyAllExpectations();
            result.VerifyAllExpectations();
        }

        public void Should_run_the_action_immediately()
        {
            ActionQueue queue = new ThreadPoolActionQueue();
            ActionScheduler scheduler = new TimerActionScheduler(new SynchronousActionQueue());

            var called = new Future<bool>();

            scheduler.Schedule(TimeSpan.Zero, queue, () => called.Complete(true));

            called.IsAvailable(1.Seconds()).ShouldBeTrue();
        }

        public void Should_run_the_action_until_disabled()
        {
            ActionQueue queue = new ThreadPoolActionQueue();
            ActionScheduler scheduler = new TimerActionScheduler(new ThreadPoolActionQueue());

            Stopwatch elapsed = Stopwatch.StartNew();

            int count = 0;
            var called = new Future<int>();
            var failed = new Future<bool>();

            ScheduledAction scheduledAction = null;
            scheduledAction = scheduler.Schedule(TimeSpan.Zero, 100.Milliseconds(), queue, () =>
                {
                    count++;
                    if (count == 10)
                    {
                        called.Complete(count);
                        scheduledAction.Cancel();
                    }
                    else if (count > 10)
                    {
                        failed.Complete(true);
                    }
                });

            called.IsAvailable(5.Seconds()).ShouldBeTrue();

            elapsed.Stop();

            failed.IsAvailable(200.Milliseconds()).ShouldBeFalse();

            Trace.WriteLine("Time Period: " + elapsed.ElapsedMilliseconds);
        }