Develop Reference

How to make a custom Linked List using IEnumerable, IEnumerator

I'm trying to create a simple Linked List that allows me to iterate each element.
But when I try to iterate the list on the method GetReservation() the foreach imidiatly stops and I don't understand why.
I supose that 'this' instruction returns the Enumerable part of the class.
But I'm not sure.
I need some help to figure it out.
public class Reservation
{
public string reference;
public string client;
public string state;
public Reservation(string reference, string client, string state)
{
this.reference = reference;
this.client = client;
this.state = state;
}
public Reservation()
{
}
public override bool Equals(object obj)
{
return obj is Reservation reservation &&
reference == reservation.reference &&
client == reservation.client &&
state == reservation.state;
}
}
public class Row
{
public Reservation reservation;
public Row nextRow;
}
public class Lista : IEnumerable, IEnumerator
{
private Row _header;
private Row Current;
private int counter;
public Lista()
{
_header = Current = null;
counter = 0;
}
public bool MoveNext()
{
if (Current.nextRow != null)
{
Current = Current.nextRow;
return true;
}
else
{
return false;
}
}
public void Reset()
{
Current = _header;
}
object IEnumerator.Current
{
get
{
return Current;
}
}
public IEnumerator GetEnumerator()
{
return this;
}
public void Add(Reservation data)
{
Row newRow = new Row();
newRow.reservation = data;
if (counter == 0)
{
_header = Current = newRow;
} else
{
Current.nextRow = newRow;
Current = newRow;
}
counter++;
}
public Reservation GetReservation(int index)
{
int x = 0;
foreach (Row row in this)
{
if (x == index)
{
return row.reservation;
}
x++;
}
return null;
}
public Reservation Remove(Reservation data)
{
Reservation reservation = null;
if (_header.reservation.Equals(data)){
reservation = _header.reservation;
_header = _header.nextRow;
} else
{
foreach (Row row in this)
{
if (row.nextRow.reservation.Equals(data))
{
if(row.nextRow.nextRow == null)
{
reservation = row.nextRow.reservation;
row.nextRow = null;
} else
{
reservation = row.nextRow.reservation;
row.nextRow = row.nextRow.nextRow;
}
}
}
}
if (reservation != null)
{
counter--;
}
return reservation;
}
}

The main issue is that both the linked list and the enumerator share the current row for different purposes.
When the Add method is called, Current is set to the new row which is the last item of the linked list.
The foreach block in GetReservation calls GetEnumerator which returns the instance of this list. But the current row of the list is the last added row. So when MoveNext is called during the iteration, false is returned since the last row has no next row. That ends the loop.
To solve this problem it is best to create a separate class which implements IEnumerator e.g.
public class Lista : IEnumerable
{
...
GetEnumerator()
{
return new ListaEnumerator(_header);
}
private class ListaEnumerator : IEnumerator
{
private Row _current;
public ListaEnumerator(Row header)
{
_current = header;
}
...
}
}
This way it is possible to have several enumerators that do not affect each other or the list.

You need the IEnumerable implementation to return a new instance of a new class ListEnumerator : IEnumeratorsuch that ListEnumerator will have Current so different instances of ListEnumerator can iterate the list instance independently.
You better of implementing generic versions e.g. IEnumerable<T> and IEnumerator<T>
Usually the IEnumerator implementation is a private class nested under the IEnumerable implementation and it has a data member pointing to the instance of IEnumerable implementation which is being iterated.

Using reflection on generics recursively

I have the following classes:
public class BaseDataEntity
{
private List<string> _Changes = new List<string>();
public IEnumerable<string> GetChanges()
{
return _Changes;
}
public bool HasDataChanged
{
get { return (GetChanges().Count() > 0); }
}
public bool HasChildRecords
{
get { return (GetType().GetChildRecords().Count() > 0); }
}
}
public class ChildRecords : IList<T> where T : BaseDataEntity
{
}
And a few helper methods:
public static PropertyInfo[] GetChildRecords(this Type aType)
{
return aType.GetProperties().Where(pi => pi.IsChildRecords()).ToArray();
}
public static bool IsChildRecords(this PropertyInfo info)
{
return (info.GetCustomAttributes(typeof(ChildRecordsAttribute), false).Length > 0);
}
What I'm trying to do is implement a property called HaveChildRecordsChanged using reflection. My question is how would I go about using reflection to check the HasDataChanged property of all ChildRecords of arbitrary depth?
I tried something like:
var isChanged = false;
foreach (var info in GetType().GetChildRecords())
{
var childRecordObject = info.GetValue(this, null);
var childRecords = childRecordObject as ChildRecords<BaseDataEntity>; //cannot unbox this, it evaluates as null
if (null != childRecords && childRecords.Any(x => x.HasDataChanged))
{
isChanged = true; //never hit
}
}
return isChanged;

ChildRecords<T> is generic so ChildRecords<Company> can't be cast to ChildRecords<BaseDataEntity>.
Since you already filter the property marked with the ChildRecordsAttribute the simplest solution would be to cast to IEnumerable and use OfType<BaseDataEntity>()
var childRecords = childRecordObject as IEnumerable; // IList<T> will be IEnumerable
if (null != childRecords && childRecords.OfType<BaseDataEntity>().Any(x => x.HasDataChanged))
{
isChanged = true;
}

Using BindingOperations with ObservableCollection

I'm trying to use the static methods of the BindingOperations class to make an async wrapper for the ObservableCollection but it's difficult to find any good examples of how to use it.
Simply calling BindingOperations.EnableCollectionSynchronization(this, _lock) in the constructor of the wrapper appears to work very well as I'm able to add items to the collection from threads other than the UI-thread without problem.
However, I'm also trying to use BindingOperations.AccessCollection(this, ()=>{...}, true) to sort the collection and limit the amount of items but I'm getting exceptions as if it has been modified elsewhere while it was supposed to be locked.
For example:
RemoveAt(Count - 1); randomly gives a ArgumentOutOfRangeException
And:
MoveItem(oldIndex, newIndex); sometimes gives a InvalidOperationException: collection was modified
So clearly it's not locking despite msdn saying:
"Provides access to a collection by using the synchronization
mechanism that the application specified when it called
EnableCollectionSynchronization."
https://msdn.microsoft.com/en-us/library/system.windows.data.bindingoperations.accesscollection(v=vs.110).aspx
Any idea what I have missed?
public class AsyncObservableCollection<T> : ObservableCollection<T>
{
private object _collectionLock = new object();
private int _maxLength = 0;
private bool _reversed = false;
private Func<T, object> _sortOrder = null;
public AsyncObservableCollection()
: this(0, null)
{
}
public AsyncObservableCollection(int maxLength)
: this(maxLength, null)
{
}
public AsyncObservableCollection(int maxLength, bool reversed)
: this(maxLength, reversed, null)
{
}
public AsyncObservableCollection(int maxLength, Func<T, object> sortOrder)
: this(maxLength, false, sortOrder)
{
}
public AsyncObservableCollection(int maxLength, bool reversed, Func<T, object> sortOrder)
{
BindingOperations.EnableCollectionSynchronization(this, _collectionLock);
if (maxLength > 0)
_maxLength = maxLength;
_reversed = reversed;
_sortOrder = sortOrder;
}
public new void Add(T item)
{
BindingOperations.AccessCollection(this, () => {
if (!_reversed)
base.Add(item);
else
Insert(0, item);
}, true);
Sort();
Limit();
}
public void Limit()
{
Limit(_maxLength);
}
public void Limit(int maxLength)
{
if (maxLength > 0)
{
BindingOperations.AccessCollection(this, () => {
while (Count > 0 && Count > maxLength)
if (!_reversed)
RemoveAt(0);
else
RemoveAt(Count - 1);
}, true);
}
}
public void Sort()
{
Sort(_sortOrder);
}
public void Sort(Func<T, object> order)
{
if (order != null)
{
BindingOperations.AccessCollection(this, () => {
List<T> list = this.ToList();
List<T> sortedList = !_reversed ? list.OrderBy(order).ToList() : list.OrderByDescending(order).ToList();
foreach (T item in list)
{
int oldIndex = list.IndexOf(item);
int newIndex = sortedList.IndexOf(item);
if (oldIndex != newIndex)
MoveItem(oldIndex, newIndex);
}
}, true);
}
}
}
Solution (not an answer to the actual question regarding the BindingOperations class):
Problem solved by simply locking using the same lock-object supplied to BindingOperations.EnableCollectionSynchronization():
public class AsyncObservableCollection<T> : ObservableCollection<T>
{
private object _collectionLock = new object();
private int _maxLength = 0;
private bool _reversed = false;
private Func<T, object> _sortOrder = null;
public AsyncObservableCollection()
: this(0, null)
{
}
public AsyncObservableCollection(int maxLength)
: this(maxLength, null)
{
}
public AsyncObservableCollection(int maxLength, bool reversed)
: this(maxLength, reversed, null)
{
}
public AsyncObservableCollection(int maxLength, Func<T, object> sortOrder)
: this(maxLength, false, sortOrder)
{
}
public AsyncObservableCollection(int maxLength, bool reversed, Func<T, object> sortOrder)
{
BindingOperations.EnableCollectionSynchronization(this, _collectionLock);
if (maxLength > 0)
_maxLength = maxLength;
_reversed = reversed;
_sortOrder = sortOrder;
}
public void AddSortLimit(T item)
{
lock (_collectionLock)
if (!_reversed)
Add(item);
else
Insert(0, item);
Sort();
Limit();
}
public void Limit()
{
Limit(_maxLength);
}
public void Limit(int maxLength)
{
if (maxLength > 0)
{
lock (_collectionLock)
while (Count > 0 && Count > maxLength)
if (!_reversed)
RemoveAt(0);
else
RemoveAt(Count - 1);
}
}
public void Sort()
{
Sort(_sortOrder);
}
public void Sort(Func<T, object> order)
{
if (order != null)
{
lock (_collectionLock)
{
List<T> list = this.ToList();
List<T> sortedList = !_reversed ? list.OrderBy(order).ToList() : list.OrderByDescending(order).ToList();
foreach (T item in list)
{
int oldIndex = IndexOf(item);
int newIndex = sortedList.IndexOf(item);
if (oldIndex != newIndex)
MoveItem(oldIndex, newIndex);
}
}
}
}
}

1) MoveItem(oldIndex, newIndex); sometimes gives a InvalidOperationException: >collection was modified.
You are getting error because you are modifying the same list on which you are iterating. So iterate on sorted list and move item is the list collection.
2) RemoveAt(Count - 1); randomly gives a ArgumentOutOfRangeException
Put a condition to check (Count-1) is less then the list.Count.

Generic Dictionary Comparison

I have a problem I can't seem to wrap my head around. I am creating a class to hold a dictionary of items that have generic types. The problem I'm faced with is needed to force this dictionary to be InvariantCultureIgnoreCase if the index type is a string.
For example:
public class Cache<TIndex, TItem>
{
protected IDictionary<TIndex, TItem> _cache { get; set; }
public Cache()
{
this._cache = new Dictionary<TIndex, TItem>();
}
public bool Exists(TIndex index)
{
if (!_cache.ContainsKey(index))
{
//....do other stuff here
this._cache.Add(databaseResult.Key, databaseResult.Value);
return false;
}
return true;
}
}
So the first problem was dealing with strings that had various capitalization; I solved this by forcing the data to be upper-case. Now, however, I've found that there are some characters which are culture specific, so without the invariant culture switch, ContainsKey will return false.
I've tried creating a new IEqualityComparer, but that never gets fired. Any ideas?

Please try the following:
public Cache()
{
if (typeof(TIndex) == typeof(string))
{
this._cache = new Dictionary<TIndex, TItem>((IEqualityComparer<TIndex>)StringComparer.InvariantCultureIgnoreCase);
}
else
{
this._cache = new Dictionary<TIndex, TItem>();
}
}
Or (with ternary operator):
public Cache()
{
this._cache = typeof(TIndex) == typeof(string)
? new Dictionary<TIndex, TItem>((IEqualityComparer<TIndex>)StringComparer.InvariantCultureIgnoreCase)
: new Dictionary<TIndex, TItem>();
}
Or (really short, as suggested by #Rawling):
public Cache()
{
this._cache = new Dictionary<TIndex, TItem>(StringComparer.InvariantCultureIgnoreCase as IEqualityComparer<TIndex>);
}

Here's a fully functional version of what I THINK you're asking for (I had to add a Set function, otherwise it is based on your own code). It is, as the if/Console.WriteLine checks show, ignoring case. If this isn't what you're looking for, please clarify your question further.
class Program
{
static void Main(string[] args)
{
Cache<string, string> stringCache = new Cache<string, string>();
stringCache.Set("A String Index", "A String Item");
if (stringCache.Exists("A String Index"))
Console.WriteLine("Title Case exists");
if (stringCache.Exists("A STRING INDEX"))
Console.WriteLine("All Caps Exists");
if (stringCache.Exists("a string index"))
Console.WriteLine("All Lowercase Exists");
}
}
class Cache<TIndex, TItem>
{
private IDictionary<TIndex, TItem> _cache { get; set; }
public Cache()
{
if (typeof(TIndex) == typeof(string))
{
_cache = new Dictionary<TIndex, TItem>((IEqualityComparer<TIndex>)StringComparer.InvariantCultureIgnoreCase);
}
else
{
_cache = new Dictionary<TIndex, TItem>();
}
}
public void Set(TIndex index, TItem item)
{
_cache[index] = item;
}
public bool Exists(TIndex index)
{
if (!_cache.ContainsKey(index))
{
return false;
}
return true;
}
}

Get list of active items from ConditionalWeakTable<T>

The .NET 4.0 ConditionalWeakTable<T> is effectively a dictionary where the dictionary's keys are weak referenced and can be collected, which is exactly what I need. The problem is that I need to be able to get all live keys from this dictionary, but MSDN states:
It does not include all the methods (such as GetEnumerator or
Contains) that a dictionary typically has.
Is there a possibility to retrieve the live keys or key-value pairs from a ConditionalWeakTable<T>?

I ended up creating my own wrapper:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
public sealed class ConditionalHashSet<T> where T : class
{
private readonly object locker = new object();
private readonly List<WeakReference> weakList = new List<WeakReference>();
private readonly ConditionalWeakTable<T, WeakReference> weakDictionary =
new ConditionalWeakTable<T, WeakReference>();
public void Add(T item)
{
lock (this.locker)
{
var reference = new WeakReference(item);
this.weakDictionary.Add(item, reference);
this.weakList.Add(reference);
this.Shrink();
}
}
public void Remove(T item)
{
lock (this.locker)
{
WeakReference reference;
if (this.weakDictionary.TryGetValue(item, out reference))
{
reference.Target = null;
this.weakDictionary.Remove(item);
}
}
}
public T[] ToArray()
{
lock (this.locker)
{
return (
from weakReference in this.weakList
let item = (T)weakReference.Target
where item != null
select item)
.ToArray();
}
}
private void Shrink()
{
// This method prevents the List<T> from growing indefinitely, but
// might also cause a performance problem in some cases.
if (this.weakList.Capacity == this.weakList.Count)
{
this.weakList.RemoveAll(weak => !weak.IsAlive);
}
}
}

In some recent framework version, the ConditionalWeakTable<TKey,TValue> now implements IEnumerator interface. Check out Microsoft Docs.
This applies to
.NET Core >= 2.0
.NET Standard >= 2.1
This is not solving the problem if someone is stuck with .NET Framework. Otherwise, this may help if, like me, it's only a matter of updating from .NET Standard 2.0 to 2.1.

This will work without the performance problems.
The key to the problem is to use a "holder" object as a value in the ConditionalWeakTable, so that when the key gets dropped, the holder's finalizer will trigger, which removes the key from the "active list" of keys.
I tested this and it works.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace Util
{
public class WeakDictionary<TKey, TValue> : IDictionary<TKey, TValue>, IDisposable
where TKey : class
where TValue : class
{
private readonly object locker = new object();
//private readonly HashSet<WeakReference> weakKeySet = new HashSet<WeakReference>(new ObjectReferenceEqualityComparer<WeakReference>());
private ConditionalWeakTable<TKey, WeakKeyHolder> keyHolderMap = new ConditionalWeakTable<TKey, WeakKeyHolder>();
private Dictionary<WeakReference, TValue> valueMap = new Dictionary<WeakReference, TValue>(new ObjectReferenceEqualityComparer<WeakReference>());
private class WeakKeyHolder
{
private WeakDictionary<TKey, TValue> outer;
private WeakReference keyRef;
public WeakKeyHolder(WeakDictionary<TKey, TValue> outer, TKey key)
{
this.outer = outer;
this.WeakRef = new WeakReference(key);
}
public WeakReference WeakRef { get; private set; }
~WeakKeyHolder()
{
this.outer?.onKeyDrop(this.WeakRef); // Nullable operator used just in case this.outer gets set to null by GC before this finalizer runs. But I haven't had this happen.
}
}
private void onKeyDrop(WeakReference weakKeyRef)
{
lock(this.locker)
{
if (!this.bAlive)
return;
//this.weakKeySet.Remove(weakKeyRef);
this.valueMap.Remove(weakKeyRef);
}
}
// The reason for this is in case (for some reason which I have never seen) the finalizer trigger doesn't work
// There is not much performance penalty with this, since this is only called in cases when we would be enumerating the inner collections anyway.
private void manualShrink()
{
var keysToRemove = this.valueMap.Keys.Where(k => !k.IsAlive).ToList();
foreach (var key in keysToRemove)
valueMap.Remove(key);
}
private Dictionary<TKey, TValue> currentDictionary
{
get
{
lock(this.locker)
{
this.manualShrink();
return this.valueMap.ToDictionary(p => (TKey) p.Key.Target, p => p.Value);
}
}
}
public TValue this[TKey key]
{
get
{
if (this.TryGetValue(key, out var val))
return val;
throw new KeyNotFoundException();
}
set
{
this.set(key, value, isUpdateOkay: true);
}
}
private bool set(TKey key, TValue val, bool isUpdateOkay)
{
lock (this.locker)
{
if (this.keyHolderMap.TryGetValue(key, out var weakKeyHolder))
{
if (!isUpdateOkay)
return false;
this.valueMap[weakKeyHolder.WeakRef] = val;
return true;
}
weakKeyHolder = new WeakKeyHolder(this, key);
this.keyHolderMap.Add(key, weakKeyHolder);
//this.weakKeySet.Add(weakKeyHolder.WeakRef);
this.valueMap.Add(weakKeyHolder.WeakRef, val);
return true;
}
}
public ICollection<TKey> Keys
{
get
{
lock(this.locker)
{
this.manualShrink();
return this.valueMap.Keys.Select(k => (TKey) k.Target).ToList();
}
}
}
public ICollection<TValue> Values
{
get
{
lock (this.locker)
{
this.manualShrink();
return this.valueMap.Select(p => p.Value).ToList();
}
}
}
public int Count
{
get
{
lock (this.locker)
{
this.manualShrink();
return this.valueMap.Count;
}
}
}
public bool IsReadOnly => false;
public void Add(TKey key, TValue value)
{
if (!this.set(key, value, isUpdateOkay: false))
throw new ArgumentException("Key already exists");
}
public void Add(KeyValuePair<TKey, TValue> item)
{
this.Add(item.Key, item.Value);
}
public void Clear()
{
lock(this.locker)
{
this.keyHolderMap = new ConditionalWeakTable<TKey, WeakKeyHolder>();
this.valueMap.Clear();
}
}
public bool Contains(KeyValuePair<TKey, TValue> item)
{
WeakKeyHolder weakKeyHolder = null;
object curVal = null;
lock (this.locker)
{
if (!this.keyHolderMap.TryGetValue(item.Key, out weakKeyHolder))
return false;
curVal = weakKeyHolder.WeakRef.Target;
}
return (curVal?.Equals(item.Value) == true);
}
public bool ContainsKey(TKey key)
{
lock (this.locker)
{
return this.keyHolderMap.TryGetValue(key, out var weakKeyHolder);
}
}
public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
{
((IDictionary<TKey, TValue>) this.currentDictionary).CopyTo(array, arrayIndex);
}
public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
{
return this.currentDictionary.GetEnumerator();
}
public bool Remove(TKey key)
{
lock (this.locker)
{
if (!this.keyHolderMap.TryGetValue(key, out var weakKeyHolder))
return false;
this.keyHolderMap.Remove(key);
this.valueMap.Remove(weakKeyHolder.WeakRef);
return true;
}
}
public bool Remove(KeyValuePair<TKey, TValue> item)
{
lock (this.locker)
{
if (!this.keyHolderMap.TryGetValue(item.Key, out var weakKeyHolder))
return false;
if (weakKeyHolder.WeakRef.Target?.Equals(item.Value) != true)
return false;
this.keyHolderMap.Remove(item.Key);
this.valueMap.Remove(weakKeyHolder.WeakRef);
return true;
}
}
public bool TryGetValue(TKey key, out TValue value)
{
lock (this.locker)
{
if (!this.keyHolderMap.TryGetValue(key, out var weakKeyHolder))
{
value = default(TValue);
return false;
}
value = this.valueMap[weakKeyHolder.WeakRef];
return true;
}
}
IEnumerator IEnumerable.GetEnumerator()
{
return this.GetEnumerator();
}
private bool bAlive = true;
public void Dispose()
{
this.Dispose(true);
}
protected void Dispose(bool bManual)
{
if (bManual)
{
Monitor.Enter(this.locker);
if (!this.bAlive)
return;
}
try
{
this.keyHolderMap = null;
this.valueMap = null;
this.bAlive = false;
}
finally
{
if (bManual)
Monitor.Exit(this.locker);
}
}
~WeakDictionary()
{
this.Dispose(false);
}
}
public class ObjectReferenceEqualityComparer<T> : IEqualityComparer<T>
{
public static ObjectReferenceEqualityComparer<T> Default = new ObjectReferenceEqualityComparer<T>();
public bool Equals(T x, T y)
{
return ReferenceEquals(x, y);
}
public int GetHashCode(T obj)
{
return RuntimeHelpers.GetHashCode(obj);
}
}
public class ObjectReferenceEqualityComparer : ObjectReferenceEqualityComparer<object>
{
}
}