Ich habe die Kapselung verwendet, um ein IDictionary mit einem Verhalten zu erstellen, das einer STL-Map sehr ähnlich ist , für diejenigen unter Ihnen, die mit C ++ vertraut sind. Für diejenigen, die nicht sind:
- Der Indexer get {} in SafeDictionary unten gibt den Standardwert zurück, wenn kein Schlüssel vorhanden ist, und fügt diesen Schlüssel dem Wörterbuch mit einem Standardwert hinzu. Dies ist häufig das gewünschte Verhalten, da Sie nach Elementen suchen, die irgendwann angezeigt werden oder eine gute Chance haben, angezeigt zu werden.
- Die Methode Add (TK-Taste, TV-Wert) verhält sich wie eine AddOrUpdate-Methode und ersetzt den vorhandenen Wert, falls vorhanden, anstatt zu werfen. Ich verstehe nicht, warum m $ keine AddOrUpdate-Methode hat und halte es für eine gute Idee, Fehler in sehr häufigen Szenarien zu werfen.
TL / DR - SafeDictionary wurde so geschrieben, dass unter keinen Umständen Ausnahmen außer in perversen Szenarien ausgelöst werden , z. B. wenn der Computer nicht Speicher hat (oder in Flammen steht). Dazu wird Add durch AddOrUpdate-Verhalten ersetzt und der Standardwert zurückgegeben, anstatt NotFoundException aus dem Indexer auszulösen.
Hier ist der Code:
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();
}
}