HashMapBase.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.Serialization;
 
namespace MPewsey.Common.Collections
{
    [DataContract(Name = "HashMap", Namespace = Constants.DataContractNamespace)]
    public abstract class HashMapBase<TKey, TValue> : ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue>, ICollection
    {
        public Dictionary<TKey, TValue> Dictionary { get; protected set; } = new Dictionary<TKey, TValue>();
 
        public TValue this[TKey key] { get => Dictionary[key]; set => Dictionary[key] = value; }
 
        public int Count => Dictionary.Count;
 
        public bool IsReadOnly => ((ICollection<KeyValuePair<TKey, TValue>>)Dictionary).IsReadOnly;
 
        public Dictionary<TKey, TValue>.KeyCollection Keys => Dictionary.Keys;
 
        ICollection<TKey> IDictionary<TKey, TValue>.Keys => Dictionary.Keys;
 
        public Dictionary<TKey, TValue>.ValueCollection Values => Dictionary.Values;
 
        ICollection<TValue> IDictionary<TKey, TValue>.Values => Dictionary.Values;
 
        public bool IsSynchronized => ((ICollection)Dictionary).IsSynchronized;
 
        public object SyncRoot => ((ICollection)Dictionary).SyncRoot;
 
        IEnumerable<TKey> IReadOnlyDictionary<TKey, TValue>.Keys => ((IReadOnlyDictionary<TKey, TValue>)Dictionary).Keys;
 
        IEnumerable<TValue> IReadOnlyDictionary<TKey, TValue>.Values => ((IReadOnlyDictionary<TKey, TValue>)Dictionary).Values;
 
        public void Add(KeyValuePair<TKey, TValue> item)
        {
            ((ICollection<KeyValuePair<TKey, TValue>>)Dictionary).Add(item);
        }
 
        public void Add(TKey key, TValue value)
        {
            Dictionary.Add(key, value);
        }
 
        public void Clear()
        {
            Dictionary.Clear();
        }
 
        public bool Contains(KeyValuePair<TKey, TValue> item)
        {
            return ((ICollection<KeyValuePair<TKey, TValue>>)Dictionary).Contains(item);
        }
 
        public bool ContainsKey(TKey key)
        {
            return Dictionary.ContainsKey(key);
        }
 
        public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
        {
            ((ICollection<KeyValuePair<TKey, TValue>>)Dictionary).CopyTo(array, arrayIndex);
        }
 
        public void CopyTo(Array array, int index)
        {
            ((ICollection)Dictionary).CopyTo(array, index);
        }
 
        public Dictionary<TKey, TValue>.Enumerator GetEnumerator()
        {
            return Dictionary.GetEnumerator();
        }
 
        IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
        {
            return Dictionary.GetEnumerator();
        }
 
        public bool Remove(KeyValuePair<TKey, TValue> item)
        {
            return ((ICollection<KeyValuePair<TKey, TValue>>)Dictionary).Remove(item);
        }
 
        public bool Remove(TKey key)
        {
            return Dictionary.Remove(key);
        }
 
        public bool TryGetValue(TKey key, out TValue value)
        {
            return Dictionary.TryGetValue(key, out value);
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerable)Dictionary).GetEnumerator();
        }
    }
}