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!");
}
