C # sözlüklerini kullanmanın TryGetValue'dan daha iyi bir yolu var mı?

Kendimi çevrimiçi olarak sık sık soru ararken buluyorum ve birçok çözüm sözlükler içeriyor. Ancak, bunları uygulamaya çalıştığımda, kodumda bu korkunç reek var. Örneğin, her değer kullanmak istediğimde:

int x;
if (dict.TryGetValue("key", out x)) {
    DoSomethingWith(x);
}

Bu esasen aşağıdakileri yapmak için 4 kod satırıdır: DoSomethingWith(dict["key"])

Out anahtar kelime kullanarak bir anti-desen olduğunu duydum çünkü fonksiyonları parametrelerini mutasyon yapar.

Ayrıca, kendimi genellikle anahtarları ve değerleri çevirdiğim "tersine çevrilmiş" bir sözlüğe ihtiyaç duyuyorum.

Benzer şekilde, genellikle bir sözlükteki öğeleri yinelemek ve kendimi daha iyi yapmak için anahtarları veya değerleri listelere vb.

Sözlükleri kullanmanın neredeyse her zaman daha iyi, daha zarif bir yolu olduğunu hissediyorum, ama kaybım var.

Sözlükler (C # veya başka türlü), bir anahtara dayalı bir değer aradığınız bir kapsayıcıdır. Birçok dilde daha doğru bir Harita olarak tanımlanır ve en yaygın uygulama HashMap'tır.

Dikkate alınması gereken sorun, bir anahtar olmadığında ne olacağıdır. Bazı diller geri nullveya nilbaşka bir eşdeğer değerle davranır . Bir değerin var olmadığını bildirmek yerine sessizce bir değeri varsayılan olarak ayarlamak.

Daha iyi ya da kötü için, C # kütüphane tasarımcıları davranış ile başa çıkmak için bir deyim ortaya çıktı. Var olmayan bir değeri aramak için varsayılan davranışın bir istisna atmak olduğunu düşündüler. İstisnalardan kaçınmak istiyorsanız, Tryvaryantı kullanabilirsiniz . Dizeleri tamsayılara veya tarih / saat nesnelerine ayrıştırmak için kullandıkları yaklaşımla aynıdır. Temel olarak, etki şöyle:

T count = int.Parse("12T45"); // throws exception

if (int.TryParse("12T45", out count))
{
    // Does not throw exception
}

Ve bu, dizinleyici delege olan sözlüğe iletildi Get(index):

var myvalue = dict["12345"]; // throws exception
myvalue = dict.Get("12345"); // throws exception

if (dict.TryGet("12345", out myvalue))
{
    // Does not throw exception
}

Bu, dilin tasarlanma şeklidir.

Should outdeğişkenler cesaretini?

C #, onlara sahip olan ilk dil değildir ve belirli durumlarda amaçları vardır. Yüksek düzeyde eşzamanlı bir sistem oluşturmaya çalışıyorsanız out, eşzamanlılık sınırlarında değişkenleri kullanamazsınız .

Birçok yönden, dil ve çekirdek kütüphane sağlayıcıları tarafından benimsenen bir deyim varsa, API'larımdaki bu deyimleri benimsemeye çalışırım. Bu, API'yi bu dilde daha tutarlı ve evde hissettirir. Yani Ruby'de yazılmış bir yöntem C #, C veya Python'da yazılmış bir yöntem gibi görünmeyecektir. Her birinin kod oluşturmanın tercih edilen bir yolu vardır ve API'nızın kullanıcılarının bunu daha hızlı öğrenmesine yardımcı olacak şekilde çalışmaktır.

Haritalar Genel Olarak Bir Anti-Desen midir?

Amaçları vardır, ancak çoğu zaman sahip olduğunuz amaç için yanlış çözüm olabilirler. Özellikle çift yönlü bir eşlemeniz varsa ihtiyacınız vardır. Verileri düzenlemenin birçok kapsayıcı ve yolu vardır. Kullanabileceğiniz birçok yaklaşım vardır ve bazen bu kabı seçmeden önce biraz düşünmeniz gerekir.

Çok yönlü bir çift yönlü haritalama değerleri listeniz varsa, yalnızca bir grup listeye ihtiyacınız olabilir. Veya eşleştirmenin her iki tarafında ilk eşleşmeyi kolayca bulabileceğiniz bir yapı listesi.

Sorunlu alanı düşünün ve iş için en uygun aracı seçin. Bir tane yoksa, oluşturun.

Burada hashtable / sözlüklerin genel ilkeleri hakkında bazı iyi cevaplar. Ama kod örneğine dokunacağımı sanıyordum,

int x;
if (dict.TryGetValue("key", out x)) 
{
    DoSomethingWith(x);
}

C # 7 (yaklaşık iki yaşında olduğunu düşünüyorum) itibariyle, bu basitleştirilebilir:

if (dict.TryGetValue("key", out var x))
{
    DoSomethingWith(x);
}

Ve elbette bir satıra indirgenebilir:

if (dict.TryGetValue("key", out var x)) DoSomethingWith(x);

Anahtarın olmadığı zaman için varsayılan bir değeriniz varsa, aşağıdakine dönüşebilir:

DoSomethingWith(dict.TryGetValue("key", out var x) ? x : defaultValue);

Böylece, makul düzeyde yeni dil eklemeleri kullanarak kompakt formlar elde edebilirsiniz.

Bu bir kod kokusu veya anti-desen değildir, çünkü bir out parametresiyle TryGet tarzı işlevler kullanmak deyimsel C # 'dır. Ancak, bir Sözlük ile çalışmak için C # sağlanan 3 seçenek vardır, bu yüzden durumunuz için doğru olanı kullandığınızdan emin olmalısınız. Ben bir out parametresi kullanarak bir sorun olduğu söylentisi nereden geldiğini biliyorum, bu yüzden sonunda ele alacağım.

Bir C # Sözlüğü ile çalışırken kullanılacak özellikler:

1. Anahtarın Sözlük'te olacağından eminseniz Item [TKey] özelliğini kullanın
2. Anahtar genellikle sözlükte olmalı, ancak orada olmaması kötü / nadir / sorunluysa, Try ... Catch komutunu kullanmalısınız, böylece bir hata ortaya çıkar ve hatayı incelikle ele almayı deneyebilirsiniz
3. Anahtarın Sözlük'te olacağından emin değilseniz, out parametresiyle TryGet kullanın

Bunu haklı çıkarmak için, sadece "Açıklamalar" altındaki Sözlük TryGetValue belgelerine başvurmanız gerekir :

Bu yöntem ContainsKey yönteminin ve Item [TKey] özelliğinin işlevselliğini birleştirir.

...

Kodunuz sık sık sözlükte olmayan anahtarlara erişmeye çalışırsa TryGetValue yöntemini kullanın. Bu yöntemi kullanmak Item [TKey] özelliği tarafından atılan KeyNotFoundException özelliğinin yakalanmasından daha etkilidir.

Bu yöntem bir O (1) işlemine yaklaşır.

TryGetValue'nun var olmasının tüm nedeni, ContainsKey ve Item [TKey] 'i kullanmak için daha uygun bir yol olarak hareket etmek, aynı zamanda sözlüğü iki kez aramak zorunda kalmamaktır - bu yüzden mevcut olmadığını ve iki şeyi elle yapmak oldukça gariptir. seçim.

Pratikte, bu basit maxim nedeniyle nadiren ham bir Sözlük kullandım: size ihtiyacınız olan işlevselliği veren en genel sınıfı / kapsayıcıyı seçin . Sözlük, anahtardan ziyade değere bakmak için tasarlanmamıştır (örneğin), bu istediğiniz bir şeyse, alternatif bir yapı kullanmak daha mantıklı olabilir. Geçen yıl yaptığım kalkınma projesinde Sözlük'ü bir kez kullanmış olabileceğimi düşünüyorum, çünkü yapmaya çalıştığım iş için nadiren doğru araçtı. Sözlük kesinlikle C # araç kutusunun İsviçre çakısı değil.

Out parametrelerinde yanlış olan ne?

CA1021: Parametreleri önleme

Dönüş değerleri yaygın ve yoğun olarak kullanılsa da, çıkış ve ref parametrelerinin doğru uygulanması ara tasarım ve kodlama becerileri gerektirir. Genel bir kitle için tasarım yapan kütüphane mimarları, kullanıcıların dışarıda çalışma veya ref parametreleriyle çalışmalarını beklememelidir.

Tahmin ediyorum ki parametreler bir anti-desen gibi bir şey duydunuz. Tüm kurallarda olduğu gibi, 'neden'i anlamak için daha yakından okumalısınız ve bu durumda Deneme deseninin kuralı nasıl ihlal etmediği konusunda açık bir söz bile vardır :

Try desenini uygulayan System.Int32.TryParse gibi yöntemler bu ihlali artırmaz.

Bence diğer dillerde birçok durumda kodu önemli ölçüde temizlemek C # sözlükleri eksik en az iki yöntem vardır. Birincisi Option, Scala'da aşağıdaki gibi bir kod yazmanıza izin veren bir döndürme :

dict.get("key").map(doSomethingWith)

İkincisi, anahtar bulunmazsa kullanıcı tarafından belirtilen bir varsayılan değer döndürür:

doSomethingWith(dict.getOrElse("key", "key not found"))

Bir dilin uygun olduğunda, Trydesen gibi sağladığı deyimleri kullanmak için söylenecek bir şey vardır , ancak bu sadece dilin sağladığı şeyi kullanmanız gerektiği anlamına gelmez . Biz programcıyız. Özel durumumuzu daha kolay anlaşılır kılmak için, özellikle de tekrarları ortadan kaldırırsa, yeni soyutlamalar oluşturmakta fayda vardır. Sıklıkla geriye doğru arama veya değerler arasında yineleme gibi bir şeye ihtiyacınız varsa, bunu gerçekleştirin. İstediğiniz arayüzü oluşturun.

Bu esasen aşağıdakileri yapmak için 4 kod satırıdır: DoSomethingWith(dict["key"])

Bunun yetersiz olduğuna katılıyorum. Değerin bir yapı türü olduğu bu durumda kullanmayı sevdiğim bir mekanizma:

public static V? TryGetValue<K, V>(
      this Dictionary<K, V> dict, K key) where V : struct => 
  dict.TryGetValue(key, out V v)) ? new V?(v) : new V?();

Şimdi yeni bir sürümüne sahip TryGetValueolduğunu getiri int?. Daha sonra uzatmak için benzer bir numara yapabiliriz T?:

public static void DoIt<T>(
      this T? item, Action<T> action) where T : struct
{
  if (item != null) action(item.GetValueOrDefault());
}

Ve şimdi bir araya getirin:

dict.TryGetValue("key").DoIt(DoSomethingWith);

ve tek ve net bir ifadeye düştük.

Out anahtar kelime kullanarak bir anti-desen olduğunu duydum çünkü fonksiyonları parametrelerini mutasyon yapar.

Biraz daha az güçlü bir şekilde ifade edeceğim ve mümkün olduğunda mutasyonlardan kaçınmanın iyi bir fikir olduğunu söyleyebilirim.

Kendimi genellikle anahtarları ve değerleri çevirdiğim "tersine çevrilmiş" bir sözlüğe ihtiyaç duyuyorum.

Ardından çift yönlü bir sözlük uygulayın veya edinin. Yazmak kolaydır veya internette çok sayıda uygulama vardır. Burada bir dizi uygulama var, örneğin:

/programming/268321/bidirectional-1-to-1-dictionary-in-c-sharp

Benzer şekilde, genellikle bir sözlükteki öğeleri yinelemek ve kendimi daha iyi yapmak için anahtarları veya değerleri listelere vb.

Tabii, hepimiz yapıyoruz.

Sözlükleri kullanmanın neredeyse her zaman daha iyi, daha zarif bir yolu olduğunu hissediyorum, ama kaybım var.

Kendinize "varsayalım Dictionarytam olarak yapmak istediğim işlemi uygulayandan başka bir sınıfım olduğunu düşünün ; bu sınıf neye benzeyecekti?" Ardından, bu soruyu cevapladıktan sonra, o sınıfı uygulayın . Sen bir bilgisayar programcısısın. Bilgisayar programları yazarak sorunlarınızı çözün!

TryGetValue()Eğer "anahtar" sözlüğe ya da olmasın içinde bir anahtar olarak mevcut olup olmadığını bilmiyorsanız yapı aksi takdirde sadece gerekli olduğu DoSomethingWith(dict["key"])mükemmel geçerlidir.

"Daha az kirli" bir yaklaşım ContainsKey()bunun yerine çek olarak kullanılabilir.

Diğer cevaplar harika noktalar içeriyor, bu yüzden onları burada yeniden ifade etmeyeceğim, ancak bunun yerine şimdiye kadar büyük ölçüde göz ardı edilen bu bölüme odaklanacağım:

Benzer şekilde, genellikle bir sözlükteki öğeleri yinelemek ve kendimi daha iyi yapmak için anahtarları veya değerleri listelere vb.

Aslında, bir sözlük üzerinde yineleme yapmak oldukça kolaydır, çünkü aşağıdakileri uygular IEnumerable:

var dict = new Dictionary<int, string>();

foreach ( var item in dict ) {
    Console.WriteLine("{0} => {1}", item.Key, item.Value);
}

Linq'i tercih ederseniz, bu da iyi çalışır:

dict.Select(x=>x.Value).WhateverElseYouWant();

Sonuçta, sözlüklerin bir karşıtlık olduğunu düşünmüyorum - sadece belirli kullanımları olan belirli bir araç.

Ayrıca, daha da spesifikasyonlar için, SortedDictionary(daha tahmin edilebilir bir performans için RB ağaçlarını kullanır) ve SortedList(bu aynı zamanda arama hızı için ekleme hızından ödün veren, ancak sabit, önceden belirlenmiş bir sıralı küme). Bir yerine bir büyüklük daha hızlı yürütme sırası Dictionaryile SortedDictionarysonuçlanan bir dava yaşadım (ama başka bir şekilde de olabilir).

Bir sözlük kullanmanın garip olduğunu düşünüyorsanız, probleminiz için doğru seçim olmayabilir. Sözlükler harika, ancak bir yorumcu fark ettiği gibi, genellikle bir sınıf olması gereken bir şey için kısayol olarak kullanılırlar. Ya da sözlüğün kendisi bir çekirdek depolama yöntemi olarak doğru olabilir, ancak istenen hizmet yöntemlerini sağlamak için etrafında bir sarmalayıcı sınıf olmalıdır.

Dict [key] ve TryGet hakkında çok şey söylendi. Ne çok kullandığım KeyValuePair kullanarak sözlük üzerinde yineleme olduğunu. Görünüşe göre bu daha az bilinen bir yapıdır.

Bir sözlüğün ana nimetini, öğe sayısı arttıkça diğer koleksiyonlara kıyasla gerçekten hızlı olmasıdır. Bir anahtarın çok fazla olup olmadığını kontrol etmeniz gerekiyorsa, kendinize bir sözlük kullanımınızın uygun olup olmadığını sormak isteyebilirsiniz. Bir müşteri olarak, oraya ne koyduğunuzu ve böylece neyin sorgulanmasının güvenli olacağını bilmelisiniz.