C# Future类代码示例

		public void Adding_operations_to_a_fiber()
		{
			_count = 10000;
			_values = new int[_count];
			Fiber fiber = new PoolFiber();

			int index = 0;
			var completed = new Future<int>();

			var go = new Future<bool>();

			fiber.Add(() => { go.WaitUntilCompleted(10.Seconds()); });

			for (int i = 0; i < _count; i++)
			{
				int offset = i;
				fiber.Add(() =>
					{
						_values[offset] = index++;

						if (offset == _count - 1)
							completed.Complete(offset);
					});
			}

			go.Complete(true);

			completed.WaitUntilCompleted(10.Seconds()).ShouldBeTrue();
		}

        public void A_file_is_created()
        {
            _baseDirectory = AppDomain.CurrentDomain.BaseDirectory;

            _filename = "test2.dat";
            _path = Path.Combine(_baseDirectory, _filename);

            System.IO.File.Delete(_path);

            _listener = new Future<FileCreated>();

            _channel = new ChannelAdapter();
            FiberFactory fiberFactory = () => new SynchronousFiber();
            _scheduler = new TimerScheduler(fiberFactory());
            _producer = new PollingFileSystemEventProducer(_baseDirectory, _channel, _scheduler, fiberFactory(),
                                                           20.Seconds());

            Thread.Sleep(5.Seconds());

            using (_channel.Connect(x => x.AddConsumerOf<FileCreated>().UsingConsumer(m => _listener.Complete(m))))
            {
                System.IO.File.Create(_path);

                _listener.WaitUntilCompleted(25.Seconds());
            }

            _producer.Dispose();
        }

 public void RequestingValueAfterSourceHasDataPerformsTransformation()
 {
     Future<string> source = new Future<string>();
     FutureProxy<int> subject = FutureProxy<int>.FromFuture(source, x => x.Length);
     source.Value = "hello";
     Assert.AreEqual(5, subject.Value);
 }

        public void Should_be_fast()
        {
            Fiber fiber = new ThreadPoolFiber();

            const int limit = 5000000;

            var complete = new Future<int>();

            Channel<MsgStruct> channel = new ConsumerChannel<MsgStruct>(fiber, message =>
                {
                    if (message.Count == limit)
                        complete.Complete(limit);
                });

            using (var timer = new FunctionTimer("Throughput", x =>
                {
                    Trace.WriteLine("Time to execute: " + (int) x.ElapsedMilliseconds + "ms");

                    Trace.WriteLine("Per second throughput: " + (int) (limit/(x.ElapsedMilliseconds/1000)));
                }))
            {
                for (int i = 1; i <= limit; i++)
                {
                    channel.Send(new MsgStruct
                        {
                            Count = i,
                            Other = i*8,
                        });
                }

                timer.Mark();

                complete.WaitUntilCompleted(30.Seconds()).ShouldBeTrue();
            }
        }

        public void AttachToStack(CardStack s, Future IsLocalPlayer)
        {
            var c = this;

            if (c.CurrentStack != null)
            {
                c.CurrentStack.Cards.Remove(c);
            }

            c.PreviousStack = c.CurrentStack;
            c.CurrentStack = s;

            s.Cards.Add(c);

            if (this.Moved != null)
                this.Moved();

            // if the IsLocalPlayer is null then we are not meant to raise MovedByLocalPlayer
            if (IsLocalPlayer != null)
                IsLocalPlayer.Continue(
                    delegate
                    {
                        if (this.MovedByLocalPlayer != null)
                            this.MovedByLocalPlayer();
                    }
                );
        }

        public void A_single_registered_service_throws_on_start()
        {
            _future = new Future<Exception>();
            ServiceCoordinator.ShelfFaulted += _future.Complete;
            IList<Func<IServiceController>> services = new List<Func<IServiceController>>
                {
                    () => new ServiceController<TestService>("test", WellknownAddresses.GetServiceCoordinatorProxy())
                        {
                            BuildService = s => new TestService(),
                            StartAction = x => { throw new Exception(); },
                            StopAction = x => x.Stop(),
                            ContinueAction = x => x.Continue(),
                            PauseAction = x => x.Pause()
                        },
                    () => new ServiceController<TestService>("test2", WellknownAddresses.GetServiceCoordinatorProxy())
                        {
                            BuildService = s => new TestService(),
                            StartAction = x => x.Start(),
                            StopAction = x => x.Stop(),
                            ContinueAction = x => x.Continue(),
                            PauseAction = x => x.Pause()
                        }
                };

            ServiceCoordinator.RegisterServices(services);

            ServiceCoordinator.Start();
        }

			public Subject()
			{
				FutureA = new Future<Message<A>>();
				FutureB = new Future<Message<B>>();
				FutureC = new Future<Message<C>>();
				FutureD = new FutureChannel<Message<D>>();
			}

        public void A_request_is_sent_via_wcf()
        {
            _pipeUri = new Uri("net.pipe://localhost/pipe");

            _response = new Future<Response<TestMessage>>();

            _client = new ChannelAdapter();
            _clientConnection = _client.Connect(x =>
                {
                    x.SendToWcfChannel(_pipeUri, _pipeName)
                        .HandleOnCallingThread();

                    x.AddConsumerOf<Response<TestMessage>>()
                        .UsingConsumer(_response.Complete);
                });

            _server = new ChannelAdapter();
            _serverConnection = _server.Connect(x =>
                {
                    x.ReceiveFromWcfChannel(_pipeUri, _pipeName);

                    x.AddConsumerOf<Request<TestMessage>>()
                        .UsingConsumer(request => request.Respond(request.Body));
                });
        }

        public GetStockDetailsTest()
        {
            this.symbol = "AnySymbol";
            this.detail = new Future<StockDetailModel>();

            this.stockService = new Mock<IStockService>();
        }

        public static IActionBuilder ConductDefaultContent(this IActionBuilder builder, Conductor<IStockTickerContentViewModel> conductor)
        {
            var future = new Future<StockDetailModel>();
            future.SetValue(null);

            return builder.ConductContent(future, conductor);
        }

 public void Should_downconvert_a_request_message_of_type_to_a_request_message()
 {
     var received = new Future<Request<Simple>>();
     HeaderTypeAdapter<Request<Simple>>.TryConvert(new RequestImpl<Simple>(null, new SimpleImpl()), received.Complete).ShouldBeTrue();
     received.IsCompleted.ShouldBeTrue();
     received.Value.ShouldNotBeNull();
 }

		public void Should_properly_arrive_at_the_destination()
		{
			var serviceUri = new Uri("net.pipe://localhost/pipe");
			string pipeName = "test";

			var future = new Future<TestMessage>();
			var message = new TestMessage
				{
					Id = Guid.NewGuid(),
					Name = "Alpha",
				};

			UntypedChannel adapter = new ChannelAdapter();
			using (var remote = new WcfChannelHost(new SynchronousFiber(), adapter, serviceUri, pipeName))
			{
				using (adapter.Connect(x =>
					{
						x.AddConsumerOf<TestMessage>()
							.UsingConsumer(m => future.Complete(m));
					}))
				{
					var client = new WcfChannelProxy(new SynchronousFiber(), serviceUri, pipeName);

					client.Send(message);

					future.WaitUntilCompleted(2.Seconds()).ShouldBeTrue();
				}
			}

			future.Value.ShouldNotBeNull();
			future.Value.ShouldEqual(message);
			future.Value.ShouldNotBeTheSameAs(message);
		}

        public void Should_support_the_username_password_for_a_host()
        {
            var inputAddress = new Uri("rabbitmq://localhost/mt/test_queue");
            var future = new Future<IConsumeContext<A>>();

            using (IServiceBus bus = ServiceBusFactory.New(c =>
                {
                    c.ReceiveFrom(inputAddress);
                    c.UseRabbitMq(r =>
                        {
                            r.ConfigureHost(inputAddress, h =>
                                {
                                    h.SetUsername("testUser");
                                    h.SetPassword("test");
                                });
                        });

                    c.Subscribe(s => s.Handler<A>((context, message) => future.Complete(context)));
                }))
            {
                bus.Publish(new A());

                Assert.IsTrue(future.WaitUntilCompleted(TimeSpan.FromSeconds(8)));
            }

            Assert.AreEqual(inputAddress.ToString(), future.Value.SourceAddress.ToString());
        }

 public Future<int> Read (byte[] buffer, int offset, int count) {
     var f = new Future<int>();
     if (!_Socket.Connected) {
         if (ThrowOnDisconnect)
             f.Fail(new SocketDisconnectedException());
         else
             f.Complete(0);
     } else {
         SocketError errorCode;
         if (_Socket.Available >= count) {
             try {
                 int bytesRead = _Socket.Receive(buffer, offset, count, SocketFlags.None, out errorCode);
                 if (ThrowOnDisconnect && (bytesRead == 0)) {
                     f.Fail(new SocketDisconnectedException());
                 } else {
                     f.Complete(bytesRead);
                 }
             } catch (Exception ex) {
                 f.Fail(ex);
             }
         } else {
             _Socket.BeginReceive(buffer, offset, count, SocketFlags.None, out errorCode, _ReadCallback, f);
         }
     }
     return f;
 }

        public void Should_publish_to_non_transactional_queue()
        {
            using (IServiceBus transactionalBus = ServiceBusFactory.New(x =>
                {
                    x.UseMsmq();
                    x.ReceiveFrom(_transactionalUri);
                    x.UseMulticastSubscriptionClient();
                    x.SetCreateMissingQueues(true);
                    x.SetCreateTransactionalQueues(true);
                }))
            {
                using (IServiceBus nonTransactionalBus = ServiceBusFactory.New(x =>
                    {
                        x.UseMsmq();
                        x.ReceiveFrom(_nonTransactionalUri);
                        x.UseMulticastSubscriptionClient();
                        x.SetCreateMissingQueues(true);
                        x.SetCreateTransactionalQueues(false);
                    }))
                {
                    var future = new Future<MyMessage>();

                    nonTransactionalBus.SubscribeHandler<MyMessage>(future.Complete);

                    transactionalBus.ShouldHaveSubscriptionFor<MyMessage>();

                    transactionalBus.Publish(new MyMessage(),
                        ctx => ctx.IfNoSubscribers(() => { throw new Exception("NoSubscribers"); }));

                    future.WaitUntilCompleted(8.Seconds()).ShouldBeTrue("The published message was not received>");
                }
            }
        }