public async Task WriteInConcurrentObservableCollectionMultiThread() { using (var collection = new ConcurrentObservableCollection <string>()) using (var resetEvent = new ManualResetEvent(false)) { _collectionChangedCount = 0; collection.CollectionChanged += Collection_CollectionChanged; var tasks = new List <Task>(); for (int i = 0; i < 100; i++) { tasks.Add(Task.Run(() => { resetEvent.WaitOne(); for (int j = 0; j < 10000; j++) { collection.Add(i.ToString(CultureInfo.InvariantCulture) + " - " + j.ToString(CultureInfo.InvariantCulture)); } })); } resetEvent.Set(); await Task.WhenAll(tasks).ConfigureAwait(false); int count = collection.Count; Assert.AreEqual(1000000, count); Assert.AreEqual(1000000, _collectionChangedCount); } }
public void RemoveRange_NotSequentialRemove3_FiresRemoveEvent() { var col = new ConcurrentObservableCollection <string>(new[] { "a", "b", "c", "d", "e", "f", "g" }); var received = new List <NotifyCollectionChangedEventArgs>(); col.CollectionChanged += (sender, args) => { if (args.Action == NotifyCollectionChangedAction.Remove) { received.Add(args); } }; col.RemoveRange(new[] { "b", "c", "a", "g" }); Assert.That(received.Count, Is.EqualTo(3)); CollectionAssert.AreEquivalent(received[0].OldItems, new[] { "b", "c" }); Assert.That(received[0].OldStartingIndex, Is.EqualTo(1)); CollectionAssert.AreEquivalent(received[1].OldItems, new[] { "a" }); Assert.That(received[1].OldStartingIndex, Is.EqualTo(0)); CollectionAssert.AreEquivalent(received[2].OldItems, new[] { "g" }); Assert.That(received[2].OldStartingIndex, Is.EqualTo(3)); CollectionAssert.AreEquivalent(col, new[] { "d", "e", "f" }); }
public void RemoveRange_NotSequentialRemove3_FiresRemoveEvent() { var col = new ConcurrentObservableCollection <string>(new[] { "a", "b", "c", "d", "e", "f", "g" }); var received = new List <NotifyCollectionChangedEventArgs>(); col.CollectionChanged += (sender, args) => { if (args.Action == NotifyCollectionChangedAction.Remove) { received.Add(args); } }; col.RemoveRange(new[] { "b", "c", "a", "g" }); received.Count.Should().Be(3); received[0].OldItems.Should().BeEquivalentTo(new[] { "b", "c" }); received[0].OldStartingIndex.Should().Be(1); received[1].OldItems.Should().BeEquivalentTo(new[] { "a" }); received[1].OldStartingIndex.Should().Be(0); received[2].OldItems.Should().BeEquivalentTo(new[] { "g" }); received[2].OldStartingIndex.Should().Be(3); col.Should().BeEquivalentTo("d", "e", "f"); }
public void Write_ReplaceElement_ElementReplaced() { var col = new ConcurrentObservableCollection <string>(new[] { "a", "b", "c" }); col[2] = "z"; CollectionAssert.AreEqual(new[] { "a", "b", "z" }, col); }
public async Task WriteInConcurrentObservableCollectionUIThread() { using (var collection = new ConcurrentObservableCollection <int>()) { _collectionChangedCount = 0; collection.CollectionChanged += Collection_CollectionChanged; await TaskHelper.RunOnUIThreadAsync(() => { for (int i = 1; i < 10000; i++) { for (int j = 1; j < 10; j++) { collection.Add(i *j); } collection.RemoveAt(collection.Count - 1); collection.Remove(i); collection.Move(0, 6); collection.Insert(0, i *i); } }).ConfigureAwait(false); Assert.AreEqual(79992, collection.Count); Assert.AreEqual(129987, _collectionChangedCount); } }
public void Write_RemoveNotExisting_DoesntFail() { var col = new ConcurrentObservableCollection <string>(new[] { "b", "c", "d" }); col.RemoveRange(new[] { "b", "X" }); CollectionAssert.AreEquivalent(new[] { "c", "d" }, col); }
public void Write_RemoveRange_ElementsRemoved() { var col = new ConcurrentObservableCollection <string>(new[] { "b", "c", "d" }); col.RemoveRange(new[] { "b", "c" }); CollectionAssert.AreEquivalent(new[] { "d" }, col); }
public void Write_RemoveElementAtIndex_ElementRemoved() { var col = new ConcurrentObservableCollection <string>(new[] { "a", "b", "c" }); col.RemoveAt(1); CollectionAssert.AreEqual(new[] { "a", "c" }, col); }
public void Write_RemoveElement_ElementRemoved() { var col = new ConcurrentObservableCollection <string>(new[] { "b", "c", "d" }); col.Remove("b"); CollectionAssert.AreEquivalent(col, new[] { "c", "d" }); }
public void Write_InsertElement_ElementInserted() { var col = new ConcurrentObservableCollection <string>(new[] { "a", "b", "c" }); col.Insert(1, "x"); CollectionAssert.AreEqual(col, new[] { "a", "x", "b", "c" }); }
public void Performance_MonitorNumberOfAllocatedThreads() { int maxNumberOfThreads = 0; int currentNumberOfThreads = Process.GetCurrentProcess().Threads.Count; Console.WriteLine("Number of threads before run {0}", currentNumberOfThreads); for (int j = 0; j < 100; j++) { var threadSafe = new ConcurrentObservableCollection <int>(); for (int i = 0; i < 100; i++) { threadSafe.Add(i); if (i % 10 == 0) { int tmp = Process.GetCurrentProcess().Threads.Count; if (tmp > maxNumberOfThreads) { maxNumberOfThreads = tmp; } } } } Console.WriteLine("Max number of threads {0}", maxNumberOfThreads); Assert.That(maxNumberOfThreads - currentNumberOfThreads, Is.LessThan(10), "too many threads created"); }
public void Write_AddElement_ElementAdded() { var col = new ConcurrentObservableCollection <string>(); col.Add("a"); Assert.That(col.First(), Is.EqualTo("a")); }
public void Write_ConcurrentWrite_SuccessfullyWritesElementsToCollection() { var col = new ConcurrentObservableCollection <int>(); var task1 = new Task(() => { for (int i = 0; i < 1000; i++) { col.Add(i); Thread.Sleep(1); } }); var task2 = new Task(() => { for (int i = 0; i < 1000; i++) { col.Clear(); Thread.Sleep(1); } }); task1.Start(); task2.Start(); Task.WaitAll(new[] { task1, task2 }); Assert.That(col.Count, Is.LessThan(1000)); #if NET45 Debug.Print("Collection size: {0}", col.Count); #endif }
public void WriteAndRead_ConcurrentReadAndWrite_SuccessfullyWritesElementsToCollection() { var array = new int[50]; for (int i = 0; i < 50; i++) { array[i] = i; } var col = new ConcurrentObservableCollection <int>(array); var task1 = new Task(() => { for (int i = 50; i < 100; i++) { col.Add(i); } }); int current = 0; var task2 = new Task(() => col.ForEach(c => { current = c; })); task1.Start(); task2.Start(); Task.WaitAll(new[] { task1, task2 }); Assert.That(col.Count, Is.EqualTo(100), "collection was not filled"); Assert.That(current, Is.InRange(49, 100), "enumeration was not running simultaneously with update"); #if NET45 Debug.Print("Collection size: {0}", col.Count); Debug.Print("current: {0}", current); #endif }
public void Read_ExceptionDuringEnumeration_LockReleased() { var array = new int[100]; for (int i = 0; i < 100; i++) { array[i] = i; } var col = new ConcurrentObservableCollection <int>(array); try { int x = 0; col.ForEach(c => { if (x++ > 50) { throw new Exception(); } }); } catch (Exception) { Console.WriteLine("Exception was fired"); } col.Add(3); Assert.That(col.Count, Is.EqualTo(101)); }
public void CopyTo_CopyCollectionWhileRemoving() { var array = new int[100]; for (int i = 0; i < 100; i++) { array[i] = i; } var col = new ConcurrentObservableCollection <int>(array); var task1 = new Task(() => { for (int i = 100; i >= 0; i--) { col.Remove(i); Thread.Sleep(1); } }); var copy = new int[100]; var task2 = new Task(() => col.CopyTo(copy, 0)); task1.Start(); Thread.Sleep(10); task2.Start(); Task.WaitAll(new[] { task1, task2 }); Assert.That(copy[2], Is.EqualTo(2)); }
public void Read_2ConcurrentEnumerations_BothEnumerationsAreExecutedAtSameTime() { var array = new int[100]; for (int i = 0; i < 100; i++) { array[i] = i; } var col = new ConcurrentObservableCollection <int>(array); int res1 = 1; var task1 = new Task(() => col.ForEach(c => { Thread.Sleep(1); res1 = 1; })); var task2 = new Task(() => col.ForEach(c => { Thread.Sleep(1); res1++; })); task1.Start(); task2.Start(); Task.WaitAll(new[] { task1, task2 }); Assert.That(res1, Is.LessThan(99)); #if NET45 Debug.Print("result: {0}", res1); #endif }
private void InitObservers() { var deletedRows = new ConcurrentObservableCollection<ApplicationViewModel>(); deletedRows.ToObservableRx<ApplicationViewModel>().ObserveOnDispatcher().Subscribe((appVm) => { ApplicationQueue.Remove(appVm); }); _deleteAppObserver = Observer.Create<ApplicationViewModel>((item) => { var model = item.GetModel(); if (item.State != AppState.ToDelete) { return; } item.State = AppState.Deleting; try { _applicationManager.DeleteApp(model); deletedRows.Add(item); } catch (Exception ex) { item.State = AppState.DeleteError; item.ErrorMsg = ex.ToString(); } }); this.ObserveProperty("SearchText") .Throttle(TimeSpan.FromMilliseconds(500)) .Select(args => SearchText) .DistinctUntilChanged() .ObserveOnDispatcher() .Subscribe(Observer.Create((string text) => UpdateAppList())); }
public Project() { Programs = new ObservableRangeCollection <Program>(); MetadataFiles = new ObservableRangeCollection <MetadataFile>(); ScriptFiles = new ConcurrentObservableCollection <ScriptFile>(); LoadedMetadata = new TypeLibrary(); }
public void Performance_MonitorNumberOfAllocatedThreads() { int maxNumberOfThreads = 0; int currentNumberOfThreads = Process.GetCurrentProcess().Threads.Count; _testOutputHelper.WriteLine("Number of threads before run {0}", currentNumberOfThreads); for (int j = 0; j < 100; j++) { var threadSafe = new ConcurrentObservableCollection <int>(); for (int i = 0; i < 100; i++) { threadSafe.Add(i); if (i % 10 == 0) { int tmp = Process.GetCurrentProcess().Threads.Count; if (tmp > maxNumberOfThreads) { maxNumberOfThreads = tmp; } } } } _testOutputHelper.WriteLine("Max number of threads {0}", maxNumberOfThreads); (maxNumberOfThreads - currentNumberOfThreads).Should() .BeLessThan(10, "the number of threads should be low"); }
public void Write_ConcurrentWrite_SuccessfullyWritesElementsToCollection() { var col = new ConcurrentObservableCollection <int>(); var task1 = new Task(() => { for (int i = 0; i < 1000; i++) { col.Add(i); Thread.Sleep(1); } }); var task2 = new Task(() => { for (int i = 0; i < 1000; i++) { col.Clear(); Thread.Sleep(1); } }); task1.Start(); task2.Start(); Task.WaitAll(task1, task2); col.Count.Should().BeLessThan(1000); }
public void WriteAndRead_ConcurrentReadAndWrite_SuccessfullyWritesElementsToCollection() { var array = new int[50]; for (int i = 0; i < 50; i++) { array[i] = i; } var col = new ConcurrentObservableCollection <int>(array); var task1 = new Task(() => { for (int i = 50; i < 100; i++) { col.Add(i); } }); int current = 0; var task2 = new Task(() => col.ForEach(c => { current = c; })); task1.Start(); task2.Start(); Task.WaitAll(task1, task2); col.Count.Should().Be(100, "the collection should be populated properly"); current.Should().BeInRange(49, 100, " the enumeration should have run in-sync with the update"); }
public void CopyTo_CopyCollectionWhileRemoving() { var array = new int[100]; for (int i = 0; i < 100; i++) { array[i] = i; } var col = new ConcurrentObservableCollection <int>(array); var task1 = new Task(() => { for (int i = 100; i >= 0; i--) { col.Remove(i); Task.Delay(1).Wait(); } }); var copy = new int[100]; var task2 = new Task(() => col.CopyTo(copy, 0)); task1.Start(); Task.Delay(10).Wait(); task2.Start(); Task.WaitAll(task1, task2); copy[2].Should().Be(2); }
public void Read_2ConcurrentEnumerations_BothEnumerationsAreExecutedAtSameTime() { var array = new int[100]; for (int i = 0; i < 100; i++) { array[i] = i; } var col = new ConcurrentObservableCollection <int>(array); int res1 = 1; var task1 = new Task(() => col.ForEach(c => { Task.Delay(1).Wait(); res1 = 1; })); var task2 = new Task(() => col.ForEach(c => { Task.Delay(1).Wait(); res1++; })); task1.Start(); task2.Start(); Task.WaitAll(task1, task2); res1.Should().BeLessThan(99); }
public void Read_ExceptionDuringEnumeration_LockReleased() { var array = new int[100]; for (int i = 0; i < 100; i++) { array[i] = i; } var col = new ConcurrentObservableCollection <int>(array); try { int x = 0; col.ForEach(c => { if (x++ > 50) { throw new Exception(); } }); } catch (Exception) { _testOutputHelper.WriteLine("Exception was fired"); } col.Add(3); col.Count.Should().Be(101); }
public void ContainsIsThreadSafe() { var test = new ConcurrentObservableCollection <int>(Concurrent) { 1, 2, 3 }; var task1 = Task.Run(() => { for (var i = 0; i < 10; i++) { test.Contains(2); Task.Delay(DelayTime).Wait(); test.Contains(4); } }); var task2 = Task.Run(() => { for (var i = 0; i < 10; i++) { test.Add(4); Task.Delay(DelayTime).Wait(); test.Add(5); } }); Task.WaitAll(task1, task2); }
public void CopyToIsThreadSafe() { var test = new ConcurrentObservableCollection <int>(Concurrent) { 1, 2, 3 }; var out1 = new int[5]; var out2 = new int[5]; var task1 = Task.Run(() => { for (var i = 0; i < 10; i++) { test.CopyTo(out1, 0); Task.Delay(DelayTime).Wait(); test.CopyTo(out2, 0); } }); var task2 = Task.Run(() => { for (var i = 0; i < 10; i++) { test.Add(4); Task.Delay(DelayTime).Wait(); test.Remove(4); } }); Task.WaitAll(task1, task2); }
public async void ClaymoreMinerStatusDetails() { // cleanup ?? Process.GetProcessesByName(fixture.claymoreETHDualMinerProcess.ComputerSoftwareProgram.ProcessName).ToList().ForEach(x => x.Kill()); ConcurrentObservableCollection <string> stdErrorLines = new ConcurrentObservableCollection <string>(); ConcurrentObservableCollection <string> stdOutLines = new ConcurrentObservableCollection <string>(); fixture.claymoreETHDualMinerProcess.Command.RedirectStandardErrorTo(stdErrorLines); fixture.claymoreETHDualMinerProcess.Command.RedirectTo(stdOutLines); var pid = fixture.claymoreETHDualMinerProcess.Start(); // delay to settle Thread.Sleep(5); // get a status to prove it is running // ToDo: Better handling of exceptions var status = await fixture.claymoreETHDualMinerProcess.StatusFetchAsync(); status.Should() .NotBeNull(); // stop it fixture.claymoreETHDualMinerProcess.Close(); // get running processes and ensure the pid is no longer there var processes = Process.GetProcesses(); bool none = processes.Where(p => p.Id == pid) .Take(1) .Count() == 0; none.Should() .Be(true); }
public void Test_ConcurrentObservableCollection_RemoveRange_ByIndex() { var initial = Enumerable.Range(0, 100).ToList(); var startIndex = 50; var removeCount = 40; var collection = new ConcurrentObservableCollection <int>(); collection.AddRange(initial); Assert.AreEqual(100, collection.Count); // Record all the collection changed events List <(object, NotifyCollectionChangedEventArgs)> returnedList = new List <(object, NotifyCollectionChangedEventArgs)>(); collection.CollectionChanged += (s, e) => returnedList.Add((s, e)); collection.RemoveRange(startIndex, removeCount); // Check just one collection changed event was fired Assert.AreEqual(1, returnedList.Count); (var returnedObject, var returnedArgs) = returnedList[0]; Assert.IsNotNull(returnedObject); Assert.IsNotNull(returnedArgs); Assert.AreEqual(returnedObject, collection); Assert.AreEqual(NotifyCollectionChangedAction.Remove, returnedArgs.Action); Assert.AreEqual(startIndex, returnedArgs.OldStartingIndex); Assert.IsNull(returnedArgs.NewItems); Assert.IsNotNull(returnedArgs.OldItems); Assert.AreEqual(removeCount, returnedArgs.OldItems.Count); var toRemove = initial.Skip(startIndex).Take(removeCount).ToList(); Assert.IsTrue(CollectionsAreEqual(toRemove, returnedArgs.OldItems)); }
public void Test_ConcurrentObservableCollection_Clear() { var initial = Enumerable.Range(0, 100).ToList(); var collection = new ConcurrentObservableCollection <int>(); collection.AddRange(initial); Assert.AreEqual(100, collection.Count); // Record all the collection changed events List <(object, NotifyCollectionChangedEventArgs)> returnedList = new List <(object, NotifyCollectionChangedEventArgs)>(); collection.CollectionChanged += (s, e) => returnedList.Add((s, e)); collection.Clear(); // Check just one collection changed event was fired Assert.AreEqual(1, returnedList.Count); (var returnedObject, var returnedArgs) = returnedList[0]; Assert.IsNotNull(returnedObject); Assert.IsNotNull(returnedArgs); Assert.AreEqual(0, collection.Count); Assert.AreEqual(returnedObject, collection); Assert.AreEqual(NotifyCollectionChangedAction.Remove, returnedArgs.Action); Assert.IsNull(returnedArgs.NewItems); Assert.IsNotNull(returnedArgs.OldItems); Assert.AreEqual(initial.Count(), returnedArgs.OldItems.Count); Assert.IsTrue(CollectionsAreEqual(initial, returnedArgs.OldItems)); }
public void Write_ReplaceElement_ElementReplaced() { var col = new ConcurrentObservableCollection <string>(new[] { "a", "b", "c" }); col[2] = "z"; col.Should().BeEquivalentTo("a", "b", "z"); }
public void VerifyPreAssignedCollectionIsClearedAndFilledButNotReInitialized() { var collection = new ConcurrentObservableCollection<CustomerViewModel>(); var viewModel = new PreAssignedCollectionViewModel(collection, factoryHelper.ServiceFactory); viewModel.CustomerCollection.Should().Be.SameInstanceAs(collection); viewModel.CustomerCollection.Should().Have.Count.EqualTo(3); }
public MainWindow() { InitializeComponent(); _itemsSource = new ConcurrentObservableCollection<string>(); var observer = new ConsoleWindowLogObserver(_itemsSource); Logging.Log.Observer = observer; BindingOperations.EnableCollectionSynchronization(_itemsSource, ConsoleWindowLogObserver.Lock); lstConsoleWindow.ItemsSource = _itemsSource; _itemsSource.CollectionChanged += (sender, args) => { try { var lastItem = lstConsoleWindow.Items[lstConsoleWindow.Items.Count - 1]; lstConsoleWindow.ScrollIntoView(lastItem); } catch (Exception e) { } }; _bot = new Bot(); }
public void TestSetUp() { runner = new Mock<ICollectionRunner>(); collection = new ConcurrentObservableCollection<int>(runner.Object); runner.Setup(r => r.Run(It.IsAny<Action>())).Callback<Action>(t => t()).Verifiable("ICollectionRunner.Run was not called!"); }