C# Barrier.Dispose方法代码示例

        /// <summary>
        /// Download all the images for the current session
        /// </summary>
        public void DownloadAllTreatmentImages()
        {
            Barrier barrier = new Barrier(_patient.PatientTreatment.TrainingList.Count + 2);

            Task treatmentThread = new Task(() =>
            {
                //Downloading all thumbs in treatment
                DownloadTreatment();

                barrier.SignalAndWait();
            });
            treatmentThread.Start();

            foreach(Training t in _patient.PatientTreatment.TrainingList)
            {
                Task tt = new Task(() =>
                {
                    DownloadTraining(_patient.PatientTreatment.TrainingList.IndexOf(t));
                    barrier.SignalAndWait();
                });
                tt.Start();

            }

            barrier.SignalAndWait();
            barrier.Dispose();
        }

		public async Task ExecuteTasksSequentiallyAndInOrder()
		{
			using (var testSubject = new MissionControl())
			{
				var fool = testSubject.SpawnFool();
				var sentMessage = new SimpleTestMessage();
				SimpleTestMessage receivedMessage = null;
				var barrier = new Barrier(2);
				var first = fool.DoWork(
					sentMessage,
					msg =>
					{
						barrier.SignalAndWait();
						receivedMessage = msg;
					});
				var second = fool.DoWork(sentMessage, msg => { barrier.SignalAndWait(); });
				var done = Task.WhenAll(first, second)
					.ContinueWith(
						t =>
						{
							barrier.Dispose();
							return Work.Completed;
						});
				var timeout = Task.Delay(100.Milliseconds())
					.ContinueWith(t => Work.TimedOut);
				var result = await await Task.WhenAny(done, timeout);
				result.Should()
					.Be(Work.TimedOut);
			}
		}

 public void Start()
 {
     _barrier = new Barrier(2);
     _worker = new Thread(Worker);
     _worker.Start();
     _barrier.SignalAndWait();
     _barrier.Dispose();
     _barrier = null;
 }

        public static bool CancelBeforeWait()
        {
            TestHarness.TestLog("* BarrierCancellationTests.CancelBeforeWait()");
            bool passed = true;

            Barrier barrier = new Barrier(3);
            
            CancellationTokenSource cs = new CancellationTokenSource();
            cs.Cancel();
            CancellationToken ct = cs.Token;
            
            const int millisec = 100;
            TimeSpan timeSpan = new TimeSpan(100);
            
            passed &= TestHarnessAssert.EnsureOperationCanceledExceptionThrown(() => barrier.SignalAndWait(ct), ct, "An OCE should have been thrown.");
            passed &= TestHarnessAssert.EnsureOperationCanceledExceptionThrown(() => barrier.SignalAndWait(millisec, ct), ct, "An OCE should have been thrown.");
            passed &= TestHarnessAssert.EnsureOperationCanceledExceptionThrown(() => barrier.SignalAndWait(timeSpan, ct), ct, "An OCE should have been thrown.");

            barrier.Dispose();
            return passed;
        }

        public static void BarrierCancellationTestsCancelBeforeWait()
        {
            Barrier barrier = new Barrier(3);

            CancellationTokenSource cs = new CancellationTokenSource();
            cs.Cancel();
            CancellationToken ct = cs.Token;

            const int millisec = 100;
            TimeSpan timeSpan = new TimeSpan(100);

            EnsureOperationCanceledExceptionThrown(
               () => barrier.SignalAndWait(ct), ct,
               "CancelBeforeWait:  An OCE should have been thrown.");
            EnsureOperationCanceledExceptionThrown(
               () => barrier.SignalAndWait(millisec, ct), ct,
               "CancelBeforeWait:  An OCE should have been thrown.");
            EnsureOperationCanceledExceptionThrown(
               () => barrier.SignalAndWait(timeSpan, ct), ct,
               "CancelBeforeWait:  An OCE should have been thrown.");

            barrier.Dispose();
        }

        private void BtnAll_Click(object sender, EventArgs e)
        {
            EnableUI(false);
            _sorterRunning = int.MaxValue;

            bool fast = ModifierKeys == Keys.Shift;

            _cts = new CancellationTokenSource();
            var barrier = new Barrier(0, DrawArrays);
            var tasks = new List<Task>(_sorters.Count)
            {
                // Dummy task, so that the continuation below is run for sure.
                Task.Run(() => { return; }),
            };

            var ui = SynchronizationContext.Current;
            for (int i = 0; i < _sorters.Count; ++i)
            {
                var sorter = _sorters[i];
                if (sorter.Run)
                {
                    sorter.Abort = _cts.Token;
                    if (!fast)
                    {
                        sorter.SteppedExecution = barrier;
                        sorter.SteppedExecution.AddParticipant();
                    }
                    sorter.Numbers = _numbers;
                    tasks.Add(Task.Factory.StartNew(() =>
                    {
                        sorter.Sort();
                    }, _cts.Token, TaskCreationOptions.LongRunning, TaskScheduler.Current));
                }
            }

            Task.WhenAll(tasks).ContinueWith(_ =>
            {
                ui.Post(delegate
                {
                    EnableUI(true);
                    DrawArrays(null);
                    DgvSorters.Refresh();
                }, null);
                barrier.Dispose();
                _cts.Dispose();
                _cts = null;
            });
        }

        /// <summary>
        /// Download training preview images for the treatment screen
        /// </summary>
        public void DownloadTreatment()
        {
            //crearte dir for user (if not already created)
            //string newDir = CreateDir(dir, _patient.AccountId.ToString());
            //newDir = CreateDir(newDir, _patient.PatientTreatment.TreatmentNumber.ToString());
            string newDir = CreateDir(dir, "treatmentThumb");

            //initilaize the barrier
            int size = _patient.PatientTreatment.TrainingList.Count;
            //Barrier _barrier = new Barrier(size + 1);
            Barrier _barrier = new Barrier(1);

            for (int i = 0; i < size; i++)
            {
                int temp = i;

                string _from = _patient.PatientTreatment.TrainingList[temp].TrainingThumbs;
                string _to = newDir + "\\" + _patient.PatientTreatment.TrainingList[temp].TrainingId + ".png";
                _patient.PatientTreatment.TrainingList[temp].TrainingThumbs = _to;

                if (!File.Exists(_to))
                {
                    _barrier.AddParticipant();
                    Task tempThread = new Task(() =>
                    {
                        DownloadFile(_from, _to);
                        _barrier.SignalAndWait();
                    });
                    tempThread.Start();
                }

            }

            _barrier.SignalAndWait();

            _barrier.Dispose();
        }

 private void TerminateWorker()
 {
     _barrier = new Barrier(2);
     _terminate = true;
     _barrier.SignalAndWait();
     _barrier.Dispose();
     _barrier = null;
 }

 /// <summary>
 /// Test Dispose
 /// </summary>
 /// <returns>Tru if the test succeeded, false otherwise</returns>
 private static bool RunBarrierTest6_Dispose()
 {
     TestHarness.TestLog("*RunBarrierTest6_Dispose");
     Barrier b = new Barrier(1);
     b.Dispose();
     try
     {
         b.SignalAndWait();
     }
     catch (ObjectDisposedException)
     {
         TestHarness.TestLog("Dispose succeeded");
         return true;
     }
     TestHarness.TestLog("Cancel failed, SignalAndWait didn't throw exceptions after Dispose.");
     return false;
 }

        /// <summary>
        /// Parallel Dijkstra algorithm
        /// </summary>
        /// 
        /// <param name="graph">
        /// <see cref="Graph"/> object to check the path for
        /// </param>
        /// 
        /// <param name="start">
        /// Start
        /// </param>
        /// 
        /// <returns>
        /// List of <see cref="Link"/> objects
        /// </returns>
        private static List<Link> Dijkstra_p(Graph graph, int start)
        {
            List<Vertex> P =
                (from v in graph.Vertices
                 select new Vertex(v, graph.Links)).ToList();

            var qT =
                from vertex in P
                where vertex.ID != start
                orderby vertex.ID ascending
                select vertex;

            Queue<Vertex> Q = new Queue<Vertex>(qT);

            Vertex curr = P[start];
            curr.closest_distance = 0.0f;

            while (Q.Count > 0)
            {
                Barrier barrier = new Barrier(curr.neighbors.Count + 1);

                foreach (Tuple<int, double> n in curr.neighbors)
                {
                    var tuple = n;
                    ThreadPool.QueueUserWorkItem(
                        obj =>
                        {
                            Vertex neighbor = P[tuple.Item1];
                            double dist = tuple.Item2 + curr.closest_distance;

                            bool contains = (from v in Q where v.ID == tuple.Item1 select v).Count() > 0;

                            if (contains && (dist < neighbor.closest_distance))
                            {
                                neighbor.closest = curr;
                                neighbor.closest_distance = dist;
                            }

                            barrier.SignalAndWait();
                        },
                        null);
                }

                barrier.SignalAndWait();

                barrier.Dispose();

                curr = Q.Dequeue();
            }

            return
                (from v in P
                 where v.ID != start
                 select new Link(v.ID, v.closest.ID, v.closest_distance)).ToList();
        }

		public void NotifyCallQueueOnEveryUserButPostingUser()
		{
			var service = GetService();
			var topic = new Topic(123);
			var user = new User(768, DateTime.MinValue);
			var list = new List<User> { user, new User(2, DateTime.MinValue) };
			_mockSubRepo.Setup(s => s.GetSubscribedUsersThatHaveViewed(topic.TopicID)).Returns(list);
			var topicLink = "foo";
			Func<User, string> gen = u => "x" + u.UserID;
			var barrier = new Barrier(1);
			Action action = () =>
			{
				service.NotifySubscribers(topic, user, topicLink, gen);
				barrier.SignalAndWait();
			};
			action.Invoke();
			barrier.Dispose();
			_mockSubTopicEmail.Verify(s => s.ComposeAndQueue(topic, It.IsAny<User>(), topicLink, It.IsAny<string>()), Times.Exactly(1));
			_mockSubTopicEmail.Verify(s => s.ComposeAndQueue(topic, list[0], topicLink, "x" + list[0].UserID), Times.Exactly(0));
			_mockSubTopicEmail.Verify(s => s.ComposeAndQueue(topic, list[1], topicLink, "x" + list[1].UserID), Times.Exactly(1));
		}