public DiffViewer(TaskScheduler scheduler, HeapRecording instance)
            : base(scheduler)
        {
            InitializeComponent();

            ListFormat = new StringFormat {
                Trimming = StringTrimming.None,
                FormatFlags = StringFormatFlags.NoWrap | StringFormatFlags.FitBlackBox
            };

            Timeline.ItemValueGetter = GetBytesTotal;
            Timeline.ItemValueFormatter = MainWindow.FormatSizeBytes;

            Instance = instance;
            if (Instance != null) {
                Timeline.Items = Instance.Snapshots;
                Instance.TracebacksFiltered += Instance_TracebacksFiltered;
                ViewHistogramByModuleMenu.Enabled = ViewHistogramByFunctionMenu.Enabled = true;
                ViewHistogramBySourceFolderMenu.Enabled = ViewHistogramBySourceFileMenu.Enabled = true;
                ViewHistogramByNamespaceMenu.Enabled = ViewTreemapMenu.Enabled = true;
            } else {
                Timeline.Visible = false;
                MainSplit.Height += Timeline.Bottom - MainSplit.Bottom;
                ViewHistogramByModuleMenu.Enabled = ViewHistogramByFunctionMenu.Enabled = false;
                ViewHistogramBySourceFolderMenu.Enabled = ViewHistogramBySourceFileMenu.Enabled = false;
                ViewHistogramByNamespaceMenu.Enabled = ViewTreemapMenu.Enabled = false;
            }
        }

        public virtual void SetUp()
        {
            Scheduler = new TaskScheduler();

            TestFile = Path.GetTempFileName();
            Storage = new AlternateStreamSource(TestFile);
        }

        public void TaskScheduler_Shutdownで登録済みのタスクの終了待ちできる()
        {
            var scheduler = new TaskScheduler();
            var skipScheduler = new TaskScheduler();
            List<Task> tasks = new List<Task>();

            for (int i = 0; i < 100; i++)
            {
                var t = Util.RandomTask(scheduler, skipScheduler);
                tasks.Add(t);
                scheduler.Update();
                skipScheduler.Update();
            }

            // RandomTask と WaitShutdown の実装上、5秒も待てば終わるはず
            var s = scheduler.BeginShutdown(TimeSpan.FromSeconds(10));

            while (true)
            {
                if (s.IsFaulted || s.IsCompleted || s.IsCanceled) break;
                for (int i = 0; i < 50; i++) scheduler.Update();
                for (int i = 0; i < 5; i++) skipScheduler.Update();
                System.Threading.Thread.Sleep(1);
            }

            Assert.AreEqual(TaskSchedulerStatus.ShutdownCompleted, scheduler.Status);

            foreach (var t in tasks)
            {
                Assert.AreEqual(TaskStatus.RanToCompletion, t.Status);
            }
        }

        public void TestClonePipelining()
        {
            DoQuery("DROP TABLE IF EXISTS Test");
            DoQuery("CREATE TABLE Test (value int)");
            for (int i = 0; i < 10; i++)
                DoQuery(String.Format("INSERT INTO Test (value) VALUES ({0})", i));

            using (var scheduler = new TaskScheduler())
            using (var qm = new ConnectionWrapper(scheduler, Connection)) {
                var q = qm.BuildQuery("SELECT * FROM Test");
                var iter = q.Execute();
                var iterF = scheduler.Start(iter.Fetch());
                var fClone = qm.Clone();

                Assert.IsFalse(fClone.Completed);

                iter.Dispose();
                iterF.Dispose();
                scheduler.WaitFor(fClone);
                using (var dupe = fClone.Result) {
                    q = dupe.BuildQuery("SELECT COUNT(value) FROM Test WHERE value = ?");
                    var f = q.ExecuteScalar(5);
                    var result = scheduler.WaitFor(f);
                    Assert.AreEqual(result, 1);
                }
            }
        }

 void ISchedulable.Schedule(TaskScheduler scheduler, IFuture future)
 {
     _Future = future;
     _Scheduler = scheduler;
     _Future.RegisterOnDispose(this.OnDisposed);
     QueueStep();
 }

        public void InsertBenchmark (int warmupLength, int numInsertions, Func<IJobQueue> jobQueueFactory, Func<ConnectionWrapper, Query, int, IEnumerator<object>> insertTask) {
            DoQuery("CREATE TABLE Test (A INTEGER NOT NULL, B INTEGER NOT NULL)");

            var jobQueue = jobQueueFactory();
            var wjq = jobQueue as WindowsMessageJobQueue;

            using (var scheduler = new TaskScheduler(() => jobQueue))
            using (var cw = new ConnectionWrapper(scheduler, Connection))
            using (var query = cw.BuildQuery("INSERT INTO Test (A, B) VALUES (?, ?)")) {
                scheduler.WaitFor(insertTask(cw, query, warmupLength));
                DoQuery("DELETE FROM Test");

                var e = insertTask(cw, query, numInsertions);
                long timeStart = Time.Ticks;

                scheduler.WaitFor(e);

                long elapsed = Time.Ticks - timeStart;
                var elapsedSeconds = (decimal)elapsed / Time.SecondInTicks;

                Console.WriteLine(
                    "Inserted {0} row(s) in {1:00.000} second(s) at ~{2:000000.00} rows/sec.",
                    numInsertions, elapsedSeconds, numInsertions / elapsedSeconds
                );
            }
        }

        public LogWindow(TaskScheduler scheduler)
            : base(scheduler)
        {
            InitializeComponent();

            GC.Collect();
        }

        public RunSettingTaskDetail(TaskScheduler task)
        {
            InitializeComponent();
            this.LayoutRoot.DataContext = task;

            this.ContentTextBox.Text = this.GetParameterSettings(task);
        }

            public Registration () {
                Scope = CancellationScope.Current;
                Scheduler = TaskScheduler.Current;

                if (Scheduler == null)
                    throw new InvalidOperationException("No implicitly active TaskScheduler on this thread.");
            }

        public void タスクの2重起動防止()
        {
            const int Frame = 30;
            const int N = 10;

            var scheduler = new TaskScheduler();

            Func<Task> starter = () => Util.DelayFrame(Frame, scheduler);
            var distinct = TaskUtility.Distinct(starter);

            Task task = distinct();

            for (int i = 0; i < (Frame + 1) * N; i++)
            {
                var t = distinct();

                if (task.IsCompleted)
                {
                    // タスク完了してたら次のタスクを起動してるはず。
                    Assert.IsFalse(object.ReferenceEquals(task, t));

                    task = t;
                }
                else
                {
                    // タスク完了するまでは同じタスクが何度も帰ってくるはず。
                    Assert.IsTrue(object.ReferenceEquals(task, t));
                }

                scheduler.Update();
            }
        }

    public MyForm() {
        // Get a reference to a synchronization context task scheduler
        m_syncContextTaskScheduler = TaskScheduler.FromCurrentSynchronizationContext();

        Text = "Synchronization Context Task Scheduler Demo";
        Visible = true; Width = 600; Height = 100;
    }

        public ProcessWatcher(TaskScheduler scheduler, params string[] processNames)
        {
            Scheduler = scheduler;

            foreach (var pname in processNames) {
                var invariant = Path.GetFileNameWithoutExtension(pname).ToLowerInvariant();
                ProcessNames.Add(invariant);

                foreach (var process in Process.GetProcessesByName(invariant)) {
                    RunningProcessIds.Add(process.Id);
                    NewProcesses.Enqueue(process);
                }
            }

            try {
                var query = new WqlEventQuery(@"SELECT * FROM Win32_ProcessStartTrace");
                Watcher = new ManagementEventWatcher(query);
                Watcher.Options.BlockSize = 1;
                Watcher.EventArrived += new EventArrivedEventHandler(OnEventArrived);
                Watcher.Start();
                WatcherEnabled = true;
            } catch {
                Watcher = null;
                WatcherEnabled = false;

                TimerTask = Scheduler.Start(InitTimer(), TaskExecutionPolicy.RunAsBackgroundTask);
            }
        }

        public HttpServer(TaskScheduler scheduler)
        {
            EndPoints = new EndPointList(this);

            Scheduler = scheduler;

            RequestOnComplete = _RequestOnComplete;
        }

 public frmSchedule(DataStorage data, TaskScheduler.ScheduledTasks tasks, DataStorage.JobRow job, bool newJob)
 {
     Localization.ChangeLanguage();
     InitializeComponent();
     m_Data = data;
     m_NewJob = newJob;
     m_Job = job;
     m_Tasks = tasks;
 }

 public SchedulerProvider()
 {
     Task = new TaskScheduler();
     IOCompletion = new IOCompletionScheduler();
     Current = new CurrentScheduler();
     Immediate = new ImmediateScheduler();
     NewThread = new NewThreadScheduler();
     ThreadPool = new ThreadPoolScheduler();
 }

        void Application_Start(object sender, EventArgs e)
        {
            XmlDocument xml = new XmlDocument();
            xml.Load(Server.MapPath(@"\config\tasks.config"));
            XmlNodeList nodes = xml.SelectNodes("Tasks/Task");

            this._scheduler = new TaskScheduler(nodes);
            this._scheduler.StartTasks();
        }

        public void SetUp()
        {
            _tasks = CreateTasks();

            _timer = new Mock<ITimer>();
            _taskRunner = new Mock<ITaskRunner>();

            _taskScheduler = new TaskScheduler(_timer.Object, _taskRunner.Object);
        }

        void ISchedulable.Schedule(TaskScheduler scheduler, IFuture future)
        {
            if (future == null)
                throw new ArgumentNullException("future");

            _Future = future;
            _Scheduler = scheduler;
            _Future.RegisterOnDispose(this.OnDisposed);
            QueueStep();
        }

        private string GetParameterSettings(TaskScheduler task)
        {
            string parameterString = string.Empty;

            foreach (ParameterSettingTask setting in task.ParameterSettings)
            {
                parameterString += setting.ParameterKey + ":" + setting.ParameterValue;
            }
            return parameterString;
        }

        /// <summary>
        ///     Initialisiert eine neue Instanz der <see cref="CommonApplication" /> Klasse.
        /// </summary>
        /// <param name="doStartup">
        ///     The do startup.
        /// </param>
        /// <param name="service">
        ///     The service.
        /// </param>
        /// <param name="factory">
        ///     The factory.
        /// </param>
        protected CommonApplication(bool doStartup, [CanBeNull] ISplashService service, [NotNull] IUIControllerFactory factory)
        {
            Contract.Requires<ArgumentNullException>(factory != null, "factory");

            Factory = factory;
            Current = this;
            _scheduler = new TaskScheduler(UiSynchronize.Synchronize);
            _splash = service ?? new NullSplash();
            _doStartup = doStartup;
            SourceAssembly = new AssemblyName(Assembly.GetAssembly(GetType()).FullName).Name;
        }