C# IScheduler.Post方法代码示例

        public void Start()
        {
            m_Scheduler = KayakScheduler.Factory.Create(new SchedulerDelegate());
            m_Server = KayakServer.Factory.CreateHttp(new NancyRequestDelegate(m_Engine), m_Scheduler);

            IDisposable disposable = m_Server.Listen(m_EndPoint);
            Thread schedulerWorkerThread = new Thread(SchedulerWorker);
            schedulerWorkerThread.IsBackground = true;
            schedulerWorkerThread.Start(disposable);
            m_Scheduler.Post(GetLocalPort);
        }

        static BodyDelegate RescheduleBody(IScheduler theScheduler, BodyDelegate body)
        {
            // flush and end are tranported on theScheduler.
            // write is not, because you want the return value to be
            // false when the data is not buffering.

            return (write, flush, end, cancel) =>
                theScheduler.Post(() =>
                    body(
                        write,
                        drained =>
                        {
                            theScheduler.Post(() =>
                            {
                                if (!flush(() => if (drained != null) theScheduler.Post(drained)))
                                    if (drained != null) drained.Invoke();
                            });

        public void SetUp()
        {
            ep = new IPEndPoint(IPAddress.Loopback, Config.Port);

            wh = new ManualResetEventSlim();

            schedulerDelegate = new SchedulerDelegate();
            scheduler = new DefaultKayakScheduler(schedulerDelegate);

            schedulerDelegate.OnStoppedAction = () =>
            {
                stopListening.Dispose();
                stopListening = null;
                wh.Set();
            };
            schedulerDelegate.OnExceptionAction = e =>
            {
                schedulerError = e;
                Debug.WriteLine("Error on scheduler");
                e.DebugStackTrace();
                scheduler.Stop();
            };

            scheduler.Post(() =>
            {
                stopListening = server.Listen(ep);
                schedulerStartedAction();
            });

            serverDelegate = new ServerDelegate();
            server = new DefaultKayakServer(serverDelegate, scheduler);

            clientSocketDelegate = new SocketDelegate();
            client = new DefaultKayakSocket(clientSocketDelegate, scheduler);
        }

        static BodyDelegate RescheduleBody(IScheduler theScheduler, BodyDelegate body)
        {
            // flush and end are tranported on theScheduler.
            // write is not, because you want the return value to be
            // false when the data is not buffering.

            return (write, end, cancel) =>
                theScheduler.Post(() =>
                    body(
                        (data, callback) =>
                        {
                            if (callback == null)
                            {
                                return write(data, callback);
                            }

                            theScheduler.Post(() =>
                            {
                                if (!write(data, () => { theScheduler.Post(callback); }))
                                    callback.Invoke();
                            });
                            return true;
                        },
                        ex => theScheduler.Post(() => end(ex)),
                        cancel));
        }

        public void RunApplication(int port, Action<FubuRuntime> activation)
        {
            _port = port;

            _listeningEndpoint = new IPEndPoint(IPAddress.Any, _port);
            Console.WriteLine("Listening on " + _listeningEndpoint);

            _applicationDelegate = AppBuilder.BuildConfiguration(x => x.RescheduleCallbacks().Run(ExecuteRequest));

            _scheduler = KayakScheduler.Factory.Create(_schedulerDelegate);
            _server = KayakServer.Factory.CreateGate(_applicationDelegate, _scheduler, null);

            if (_listeningEndpoint == null)
            {
                throw new InvalidOperationException("Start() can only be called after RunApplication() and Stop()");
            }

            var runtime = rebuildFubuMVCApplication();

            _kayakListenerDisposer = _server.Listen(_listeningEndpoint);
                _scheduler.Post(() => ThreadPool.QueueUserWorkItem(o => activation(runtime)));
                _scheduler.Start();
        }

        public void SetUp()
        {
            ep = new IPEndPoint(IPAddress.Loopback, Config.Port);

            wh = new ManualResetEventSlim();

            IDisposable d = null;

            var schedulerDelegate = new SchedulerDelegate();
            schedulerDelegate.OnStoppedAction = () =>
            {
                d.Dispose();
                wh.Set();
            };

            scheduler = new KayakScheduler(schedulerDelegate);
            scheduler.Post(() =>
            {
                d = server.Listen(ep);
                schedulerStartedAction();
            });

            var serverDelegate = new ServerDelegate();
            server = new KayakServer(serverDelegate, scheduler);

            clientSocketDelegate = new SocketDelegate();
            client = new KayakSocket(clientSocketDelegate, scheduler);
        }