Поможет ли какое-нибудь разбиение?
Я использовал подход, в котором я вычисляю байтовый хэш, используя XOR GetHashCode() ключа словаря, чтобы разделить словарь на 256 меньших. В основном у вас есть внутренний Dictionary<byte, Dictionary<K, V>>, который содержит значения для внешнего IDictionary<K, V>.
Если вы начали с большого словарного класса, подобного этому:
public class LargeDictionary<K, V> : IDictionary<K, V>
{
private readonly Dictionary<byte, Dictionary<K, V>> _inner =
new Dictionary<byte, Dictionary<K, V>>();
private Dictionary<K, V> GetInner(K key)
{
var bs = BitConverter.GetBytes(key.GetHashCode());
var prekey = (byte)(bs[0] ^ bs[1] ^ bs[2] ^ bs[3]);
if (!_inner.ContainsKey(prekey))
{
_inner.Add(prekey, new Dictionary<K, V>());
}
return _inner[prekey];
}
/* See below */
}
Сможете ли вы начать с этого и, возможно, перестроить части внутреннего словаря, чтобы восстановить память по мере продвижения?
Вот остальные классы:
public void Add(K key, V value)
{
this.GetInner(key).Add(key, value);
}
public bool ContainsKey(K key)
{
return this.GetInner(key).ContainsKey(key);
}
public ICollection<K> Keys
{
get
{
var keys = from pk in _inner.Keys
from k in _inner[pk].Keys
select k;
return keys.ToList();
}
}
public bool Remove(K key)
{
return this.GetInner(key).Remove(key);
}
public bool TryGetValue(K key, out V value)
{
return this.GetInner(key).TryGetValue(key, out value);
}
public ICollection<V> Values
{
get
{
var values = from pk in _inner.Keys
from v in _inner[pk].Values
select v;
return values.ToList();
}
}
public V this[K key]
{
get
{
return this.GetInner(key)[key];
}
set
{
this.GetInner(key)[key] = value;
}
}
public void Add(KeyValuePair<K, V> item)
{
this.GetInner(item.Key).Add(item.Key, item.Value);
}
public void Clear()
{
_inner.Clear();
}
public bool Contains(KeyValuePair<K, V> item)
{
var inner = this.GetInner(item.Key);
return inner.ContainsKey(item.Key)
&& inner[item.Key].Equals(item.Value);
}
public void CopyTo(KeyValuePair<K, V>[] array, int arrayIndex)
{
var source = this.ToArray();
Array.Copy(source, 0, array, arrayIndex, source.Length);
}
public int Count
{
get
{
var counts = from pk in _inner.Keys
select _inner[pk].Count;
return counts.Sum();
}
}
public bool IsReadOnly
{
get { return false; }
}
public bool Remove(KeyValuePair<K, V> item)
{
return this.GetInner(item.Key).Remove(item.Key);
}
public IEnumerator<KeyValuePair<K, V>> GetEnumerator()
{
return _inner.Keys.SelectMany(pk => _inner[pk]).GetEnumerator();
}
System.Collections.IEnumerator
System.Collections.IEnumerable.GetEnumerator()
{
return this.GetEnumerator();
}