Utilicé la encapsulación para crear un IDictionary con un comportamiento muy similar a un mapa STL , para aquellos de ustedes que están familiarizados con c ++. Para aquellos que no son:
- indexer get {} en SafeDictionary a continuación devuelve el valor predeterminado si una clave no está presente, y agrega esa clave al diccionario con un valor predeterminado. Este suele ser el comportamiento deseado, ya que está buscando elementos que aparecerán eventualmente o que tendrán una buena posibilidad de aparecer.
- El método Add (tecla TK, TV val) se comporta como un método AddOrUpdate, reemplazando el valor presente si existe en lugar de arrojarlo. No veo por qué m $ no tiene un método AddOrUpdate y creo que arrojar errores en escenarios muy comunes es una buena idea.
TL / DR: SafeDictionary está escrito para no arrojar excepciones bajo ninguna circunstancia, que no sean escenarios perversos , como que la computadora se quede sin memoria (o en llamas). Para ello, reemplaza Agregar con el comportamiento AddOrUpdate y devuelve el valor predeterminado en lugar de lanzar NotFoundException desde el indexador.
Aquí está el código:
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
public class SafeDictionary<TK, TD>: IDictionary<TK, TD> {
Dictionary<TK, TD> _underlying = new Dictionary<TK, TD>();
public ICollection<TK> Keys => _underlying.Keys;
public ICollection<TD> Values => _underlying.Values;
public int Count => _underlying.Count;
public bool IsReadOnly => false;
public TD this[TK index] {
get {
TD data;
if (_underlying.TryGetValue(index, out data)) {
return data;
}
_underlying[index] = default(TD);
return default(TD);
}
set {
_underlying[index] = value;
}
}
public void CopyTo(KeyValuePair<TK, TD>[] array, int arrayIndex) {
Array.Copy(_underlying.ToArray(), 0, array, arrayIndex,
Math.Min(array.Length - arrayIndex, _underlying.Count));
}
public void Add(TK key, TD value) {
_underlying[key] = value;
}
public void Add(KeyValuePair<TK, TD> item) {
_underlying[item.Key] = item.Value;
}
public void Clear() {
_underlying.Clear();
}
public bool Contains(KeyValuePair<TK, TD> item) {
return _underlying.Contains(item);
}
public bool ContainsKey(TK key) {
return _underlying.ContainsKey(key);
}
public IEnumerator<KeyValuePair<TK, TD>> GetEnumerator() {
return _underlying.GetEnumerator();
}
public bool Remove(TK key) {
return _underlying.Remove(key);
}
public bool Remove(KeyValuePair<TK, TD> item) {
return _underlying.Remove(item.Key);
}
public bool TryGetValue(TK key, out TD value) {
return _underlying.TryGetValue(key, out value);
}
IEnumerator IEnumerable.GetEnumerator() {
return _underlying.GetEnumerator();
}
}