Apakah ada implementasi IDictionary yang, pada kunci yang hilang, mengembalikan nilai default daripada melempar?

Pengindeks ke Kamus mengeluarkan pengecualian jika kunci hilang. Apakah ada implementasi IDictionary yang akan mengembalikan default (T)?

Saya tahu tentang metode "TryGetValue", tapi itu tidak mungkin untuk digunakan dengan LINQ.

Apakah ini secara efisien akan melakukan apa yang saya butuhkan ?:

myDict.FirstOrDefault(a => a.Key == someKeyKalue);

Saya tidak berpikir itu akan karena saya pikir itu akan mengulangi kunci daripada menggunakan pencarian Hash.

Memang, itu tidak akan efisien sama sekali.

Anda selalu bisa menulis metode ekstensi:

public static TValue GetValueOrDefault<TKey,TValue>
    (this IDictionary<TKey, TValue> dictionary, TKey key)
{
    TValue ret;
    // Ignore return value
    dictionary.TryGetValue(key, out ret);
    return ret;
}

Atau dengan C # 7.1:

public static TValue GetValueOrDefault<TKey,TValue>
    (this IDictionary<TKey, TValue> dictionary, TKey key) =>
    dictionary.TryGetValue(key, out var ret) ? ret : default;

Itu menggunakan:

• Metode ekspresi-tubuh (C # 6)
• Variabel keluar (C # 7.0)
• Literal default (C # 7.1)

Membawa metode ekstensi ini dapat membantu ..

public static V GetValueOrDefault<K, V>(this IDictionary<K, V> dict, K key)
{
    return dict.GetValueOrDefault(key, default(V));
}

public static V GetValueOrDefault<K, V>(this IDictionary<K, V> dict, K key, V defVal)
{
    return dict.GetValueOrDefault(key, () => defVal);
}

public static V GetValueOrDefault<K, V>(this IDictionary<K, V> dict, K key, Func<V> defValSelector)
{
    V value;
    return dict.TryGetValue(key, out value) ? value : defValSelector();
}

Jika seseorang menggunakan .net core 2 dan di atasnya (C # 7.X), kelas CollectionExtensions diperkenalkan dan dapat menggunakan metode GetValueOrDefault untuk mendapatkan nilai default jika kunci tidak ada dalam kamus.

Dictionary<string, string> colorData = new  Dictionary<string, string>();
string color = colorData.GetValueOrDefault("colorId", string.Empty);

Collections.Specialized.StringDictionarymemberikan hasil non-pengecualian saat mencari nilai kunci yang hilang. Ini juga case-insensitive secara default.

Peringatan

Ini hanya berlaku untuk penggunaan khusus, dan - dirancang sebelum obat generik - tidak memiliki enumerator yang sangat baik jika Anda perlu meninjau seluruh koleksi.

Jika Anda menggunakan .Net Core, Anda dapat menggunakan metode CollectionExtensions.GetValueOrDefault . Ini sama dengan implementasi yang disediakan dalam jawaban yang diterima.

public static TValue GetValueOrDefault<TKey,TValue> (
   this System.Collections.Generic.IReadOnlyDictionary<TKey,TValue> dictionary,
   TKey key);

public class DefaultIndexerDictionary<TKey, TValue> : IDictionary<TKey, TValue>
{
    private IDictionary<TKey, TValue> _dict = new Dictionary<TKey, TValue>();

    public TValue this[TKey key]
    {
        get
        {
            TValue val;
            if (!TryGetValue(key, out val))
                return default(TValue);
            return val;
        }

        set { _dict[key] = value; }
    }

    public ICollection<TKey> Keys => _dict.Keys;

    public ICollection<TValue> Values => _dict.Values;

    public int Count => _dict.Count;

    public bool IsReadOnly => _dict.IsReadOnly;

    public void Add(TKey key, TValue value)
    {
        _dict.Add(key, value);
    }

    public void Add(KeyValuePair<TKey, TValue> item)
    {
        _dict.Add(item);
    }

    public void Clear()
    {
        _dict.Clear();
    }

    public bool Contains(KeyValuePair<TKey, TValue> item)
    {
        return _dict.Contains(item);
    }

    public bool ContainsKey(TKey key)
    {
        return _dict.ContainsKey(key);
    }

    public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
    {
        _dict.CopyTo(array, arrayIndex);
    }

    public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
    {
        return _dict.GetEnumerator();
    }

    public bool Remove(TKey key)
    {
        return _dict.Remove(key);
    }

    public bool Remove(KeyValuePair<TKey, TValue> item)
    {
        return _dict.Remove(item);
    }

    public bool TryGetValue(TKey key, out TValue value)
    {
        return _dict.TryGetValue(key, out value);
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return _dict.GetEnumerator();
    }
}

Seseorang dapat mendefinisikan antarmuka untuk fungsi pencarian kunci kamus. Saya mungkin akan mendefinisikannya sebagai sesuatu seperti:

Interface IKeyLookup(Of Out TValue)
  Function Contains(Key As Object)
  Function GetValueIfExists(Key As Object) As TValue
  Function GetValueIfExists(Key As Object, ByRef Succeeded As Boolean) As TValue
End Interface

Interface IKeyLookup(Of In TKey, Out TValue)
  Inherits IKeyLookup(Of Out TValue)
  Function Contains(Key As TKey)
  Function GetValue(Key As TKey) As TValue
  Function GetValueIfExists(Key As TKey) As TValue
  Function GetValueIfExists(Key As TKey, ByRef Succeeded As Boolean) As TValue
End Interface

Versi dengan kunci non-generik akan memungkinkan kode yang menggunakan kode menggunakan tipe kunci non-struktur untuk memungkinkan varian kunci sewenang-wenang, yang tidak mungkin dilakukan dengan parameter tipe generik. Seseorang seharusnya tidak diizinkan untuk menggunakan yang bisa berubah Dictionary(Of Cat, String)sebagai yang bisa berubah Dictionary(Of Animal, String)karena yang terakhir akan memungkinkan SomeDictionaryOfCat.Add(FionaTheFish, "Fiona"). Tetapi tidak ada yang salah dengan menggunakan bisa berubah Dictionary(Of Cat, String)sebagai tidak berubah Dictionary(Of Animal, String), karena SomeDictionaryOfCat.Contains(FionaTheFish)harus dianggap sebagai ekspresi yang terbentuk dengan baik (harus kembali false, tanpa harus mencari kamus, untuk apa pun yang bukan tipe Cat).

Sayangnya, satu-satunya cara seseorang dapat benar-benar menggunakan antarmuka seperti itu adalah jika seseorang membungkus Dictionaryobjek di kelas yang mengimplementasikan antarmuka. Bergantung pada apa yang Anda lakukan, antarmuka seperti itu dan varians yang dibolehkan mungkin membuatnya sepadan.

Jika Anda menggunakan ASP.NET MVC, Anda bisa memanfaatkan kelas RouteValueDictionary yang melakukan pekerjaan itu.

public object this[string key]
{
  get
  {
    object obj;
    this.TryGetValue(key, out obj);
    return obj;
  }
  set
  {
    this._dictionary[key] = value;
  }
}

Pertanyaan ini membantu mengonfirmasi bahwa TryGetValuedrama tersebutFirstOrDefault peran di sini.

Salah satu fitur C # 7 yang menarik yang ingin saya sebutkan adalah fitur variabel keluar , dan jika Anda menambahkan operator null-kondisional dari C # 6 ke persamaan kode Anda bisa jauh lebih sederhana tanpa perlu metode ekstensi tambahan.

var dic = new Dictionary<string, MyClass>();
dic.TryGetValue("Test", out var item);
item?.DoSomething();

Kelemahan dari ini adalah bahwa Anda tidak dapat melakukan semuanya sesuai seperti ini;

dic.TryGetValue("Test", out var item)?.DoSomething();

Jika kita perlu / ingin melakukan ini kita harus mengkode satu metode ekstensi seperti Jon.

Ini adalah versi dari @ JonSkeet untuk dunia C # 7.1 yang juga memungkinkan untuk melewatinya opsional opsional:

public static TV GetValueOrDefault<TK, TV>(this IDictionary<TK, TV> dict, TK key, TV defaultValue = default) => dict.TryGetValue(key, out TV value) ? value : defaultValue;

Mungkin lebih efisien untuk memiliki dua fungsi untuk mengoptimalkan kasing tempat Anda ingin kembali default(TV):

public static TV GetValueOrDefault<TK, TV>(this IDictionary<TK, TV> dict, TK key, TV defaultValue) => dict.TryGetValue(key, out TV value) ? value : defaultValue;
public static TV GetValueOrDefault2<TK, TV>(this IDictionary<TK, TV> dict, TK key) {
    dict.TryGetValue(key, out TV value);
    return value;
}

Sayangnya C # belum (belum?) Memiliki operator koma (atau operator titik koma C # 6 yang diusulkan) sehingga Anda harus memiliki badan fungsi aktual (terkesiap!) Untuk salah satu kelebihan beban.

Saya menggunakan enkapsulasi untuk membuat IDictionary dengan perilaku yang sangat mirip dengan peta STL , bagi Anda yang terbiasa dengan c ++. Bagi mereka yang tidak:

• indexer dapatkan {} di SafeDictionary di bawah ini mengembalikan nilai default jika kunci tidak ada, dan menambahkan kunci itu ke kamus dengan nilai default. Ini sering merupakan perilaku yang diinginkan, karena Anda mencari item yang nantinya akan muncul atau memiliki peluang bagus untuk muncul.
• metode Add (kunci TK, val TV) berperilaku sebagai metode AddOrUpdate, menggantikan nilai sekarang jika ada, bukan melempar. Saya tidak mengerti mengapa m $ tidak memiliki metode AddOrUpdate dan berpikir melempar kesalahan dalam skenario yang sangat umum adalah ide yang bagus.

TL / DR - SafeDictionary ditulis agar tidak pernah membuat pengecualian dalam keadaan apa pun, selain skenario sesat , seperti komputer kehabisan memori (atau terbakar). Ini dilakukan dengan mengganti Add dengan perilaku AddOrUpdate dan mengembalikan default alih-alih melempar NotFoundException dari pengindeks.

Berikut kodenya:

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();
    }
}

Sejak .NET core 2.0 Anda dapat menggunakan:

myDict.GetValueOrDefault(someKeyKalue)

Bagaimana dengan satu-liner ini yang memeriksa apakah kunci hadir menggunakan ContainsKeydan kemudian mengembalikan nilai yang biasanya diambil kembali atau nilai default menggunakan operator kondisional?

var myValue = myDictionary.ContainsKey(myKey) ? myDictionary[myKey] : myDefaultValue;

Tidak perlu menerapkan kelas Kamus baru yang mendukung nilai default, cukup ganti pernyataan pencarian Anda dengan garis pendek di atas.

Ini bisa menjadi satu-liner untuk memeriksa TryGetValuedan mengembalikan nilai default jika ya false.

 Dictionary<string, int> myDic = new Dictionary<string, int>() { { "One", 1 }, { "Four", 4} };
 string myKey = "One"
 int value = myDic.TryGetValue(myKey, out value) ? value : 100;

myKey = "One" => value = 1

myKey = "two" => value = 100

myKey = "Four" => value = 4

Cobalah online

Tidak, karena jika tidak, bagaimana Anda tahu bedanya ketika kunci ada tetapi menyimpan nilai nol? Itu bisa penting.