public void Insert(int index, T item)
{
DoBaseWrite(() =>
{
WriteCollection.Insert(index, item);
});
}
public void Collections_Add()
{
ReadCollection.AssertEmpty();
var item = CreateItem1();
WriteCollection.Add(item);
ReadCollection.AssertContainsOnly(item);
WriteCollection.Add(item);
if (AllowDuplicateEntries)
{
ReadCollection.AssertSequence(item, item);
}
else
{
ReadCollection.AssertContainsOnly(item);
}
WriteCollection.Remove(item);
if (AllowDuplicateEntries)
{
ReadCollection.AssertContainsOnly(item);
}
else
{
ReadCollection.AssertEmpty();
}
}
public void Add(T item)
{
DoBaseWrite(() =>
{
WriteCollection.Add(item);
});
}
public void RemoveAt(int index)
{
DoBaseWrite(() =>
{
WriteCollection.RemoveAt(index);
});
}
public bool Remove(T item)
{
return(DoBaseWrite(() =>
{
return WriteCollection.Remove(item);
}));
}
/// <summary>
///
/// </summary>
/// <param name="Item"></param>
/// <returns></returns>
public bool Remove(T Item)
{
var Result = DoBaseWrite(() => WriteCollection.Remove(Item));
OnItemRemoved(Item);
OnItemsChanged();
return(Result);
}
/// <summary>
///
/// </summary>
/// <param name="i"></param>
public void RemoveAt(int i)
{
var Item = this[i];
DoBaseWrite(() => WriteCollection.RemoveAt(i));
OnItemRemoved(Item);
OnItemsChanged();
}
protected virtual void BaseAdd(TKey key, TValue value)
{
var node = new DoubleLinkListIndexNode(_lastNode, _keyToIndex.Count);
_keyToIndex.Add(key, node);
_lastNode = node;
WriteCollection.Add(new KeyValuePair <TKey, TValue>(key, value));
}
// ************************************************************************
// Protected Methods
// ************************************************************************
#region Protected Methods
/// <summary>
/// Removes all items from the ICollection<T>.
/// </summary>
protected void DoBaseClear(Action action)
{
// Don't use BaseCollection.Clear(), it causes problems because it
// sends a reset event, and then the collection needs to be read out through
// an enumerator. Use RemoveAt instead until the collection is empty.
// Using remove from end after testing with this speed test:
//
// // speed test for using RemoveAt(int index);
// using System;
// using System.Collections.Generic;
// using System.Collections.ObjectModel;
// using System.Diagnostics;
//
// namespace ConsoleApplication1 {
// class Program {
// static void Main(string[] args) {
// var coll = new Collection<int>();
// for (int ix = 0; ix < 100000; ++ix) coll.Add(ix);
// var sw = Stopwatch.StartNew();
// while (coll.Count > 0) coll.RemoveAt(0);
// sw.Stop();
// Console.WriteLine("Removed from start {0}ms",sw.ElapsedMilliseconds);
// for (int ix = 0; ix < 100000; ++ix) coll.Add(ix);
// sw = Stopwatch.StartNew();
// while (coll.Count > 0) coll.RemoveAt(coll.Count - 1);
// Console.WriteLine("Removed from end {0}ms",sw.ElapsedMilliseconds);
// Console.ReadLine();
// }
// }
// }
//
// Output:
// Removed from start 4494ms
// Removed from end 3ms
// Need a special case of DoBaseWrite for a set changes to make sure that nothing else does a change
// while we are in the middle of doing a collection of changes.
_readWriteLock.TryEnterUpgradeableReadLock(Timeout.Infinite);
try {
_readWriteLock.TryEnterWriteLock(Timeout.Infinite);
action();
while (WriteCollection.Count > 0)
{
_newSnapshotRequired = true;
WriteCollection.RemoveAt(WriteCollection.Count - 1);
}
} finally {
if (_readWriteLock.IsWriteLockHeld)
{
_readWriteLock.ExitWriteLock();
}
_readWriteLock.ExitUpgradeableReadLock();
}
}
public void Collections_Clear()
{
var item1 = CreateItem1();
var item2 = CreateItem2();
WriteCollection.Add(item1);
WriteCollection.Add(item2);
WriteCollection.Clear();
ReadCollection.AssertEmpty();
}
/// <summary>
/// Initializes a new instance of the FileByteProvider class.
/// </summary>
/// <param name = "fileName"></param>
public FileByteProvider(string fileName) {
_writes = new WriteCollection();
FileName = fileName;
try {
// try to open in write mode
_fileStream = File.Open(fileName, FileMode.Open, FileAccess.ReadWrite, FileShare.Read);
} catch {
// write mode failed, try to open in read-only and fileshare friendly mode.
_fileStream = File.Open(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
_readOnly = true;
}
}
/// <summary>
/// Initializes a new instance of the FileByteProvider class.
/// </summary>
/// <param name = "fileName"></param>
public FileByteProvider(string fileName)
{
_writes = new WriteCollection();
FileName = fileName;
try {
// try to open in write mode
_fileStream = File.Open(fileName, FileMode.Open, FileAccess.ReadWrite, FileShare.Read);
} catch {
// write mode failed, try to open in read-only and fileshare friendly mode.
_fileStream = File.Open(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
_readOnly = true;
}
}
/// <summary>
/// Removes the element with the specified key from the IDictionary<TKey, TValue>.
/// </summary>
/// <param name="key">
/// The key of the element to remove.
/// </param>
/// <returns>
/// True if the element is successfully removed; otherwise, false. This method also returns false if key was not found in the original IDictionary<TKey, TValue>.
/// </returns>
public bool Remove(TKey key)
{
return(DoBaseWrite(() => {
DoubleLinkListIndexNode node;
if (_keyToIndex.TryGetValue(key, out node))
{
WriteCollection.RemoveAt(node.Index);
if (node == _lastNode)
{
_lastNode = node.Previous;
}
node.Remove();
}
return _keyToIndex.Remove(key);
}));
}
public void Collections_Order()
{
var item1 = CreateItem1();
var item2 = CreateItem2();
WriteCollection.Add(item1);
WriteCollection.Add(item2);
if (PreservesOrder)
{
ReadCollection.AssertSequence(item1, item2);
}
else
{
ReadCollection.AssertContainsOnly(item1, item2);
}
}
public void Collections_CopyTo()
{
WriteCollection.Add(CreateItem1());
WriteCollection.Add(CreateItem2());
WriteCollection.Add(CreateItem3());
WriteCollection.Add(CreateItem2());
T[] array = new T[ReadCollection.Count];
ReadCollection.CopyTo(array, 0);
if (PreservesOrder)
{
ReadCollection.AssertSequence(array);
}
else
{
ReadCollection.AssertContainsOnly(array);
}
}
/// <summary>
/// Adds an element with the provided key and value to the IDictionary<TKey, TValue>.
/// </summary>
/// <param name="key">
/// The object to use as the key of the element to add.
/// </param>
/// <param name="value">
/// The object to use as the value of the element to add.
/// </param>
protected override void BaseAdd(TKey key, TValue value)
{
int index = _sorter.GetInsertIndex(WriteCollection.Count, key, delegate(int testIndex) {
return(WriteCollection[testIndex].Key);
});
if (index >= WriteCollection.Count)
{
base.BaseAdd(key, value);
}
else
{
TKey listKey = WriteCollection[index].Key;
DoubleLinkListIndexNode next = _keyToIndex[listKey];
DoubleLinkListIndexNode newNode = new DoubleLinkListIndexNode(next.Previous, next);
_keyToIndex[key] = newNode;
WriteCollection.Insert(index, new KeyValuePair <TKey, TValue>(key, value));
}
}
protected void DoBaseClear(Action action)
{
_readWriteLock.TryEnterUpgradeableReadLock(Timeout.Infinite);
try
{
_readWriteLock.TryEnterWriteLock(Timeout.Infinite);
action();
while (WriteCollection.Count > 0)
{
_newSnapshotRequired = true;
WriteCollection.RemoveAt(WriteCollection.Count - 1);
}
}
finally
{
if (_readWriteLock.IsWriteLockHeld)
{
_readWriteLock.ExitWriteLock();
}
_readWriteLock.ExitUpgradeableReadLock();
}
}
/// <summary>
///
/// </summary>
/// <param name="Item"></param>
public void Add(T Item)
{
DoBaseWrite(() => WriteCollection.Add(Item));
OnItemAdded(Item);
OnItemsChanged();
}
/// <summary>
///
/// </summary>
/// <param name="i"></param>
/// <param name="Item"></param>
public void Insert(int i, T Item)
{
DoBaseWrite(() => WriteCollection.Insert(i, Item));
OnItemInserted(Item, i);
OnItemsChanged();
}
/// <summary>
///
/// </summary>
/// <param name="Items"></param>
public void Add(IEnumerable <T> Items)
{
Items.ForEach(i => DoBaseWrite(() => WriteCollection.Add(i)));
OnItemsAdded(Items);
OnItemsChanged();
}
