Bileşik Anahtar Sözlük

Question 1

Diyelim ki Listede bazı nesnelerim var List<MyClass>ve Sınıfımın birkaç özelliği var. MyClass'ın 3 özelliğine dayalı olarak bir liste indeksi oluşturmak istiyorum. Bu durumda, özelliklerden 2'si int'e aittir ve bir özellik bir tarih saattir.

Temel olarak şöyle bir şey yapabilmek isterim:

Dictionary< CompositeKey , MyClass > MyClassListIndex = Dictionary< CompositeKey , MyClass >();
//Populate dictionary with items from the List<MyClass> MyClassList
MyClass aMyClass = Dicitonary[(keyTripletHere)];

Bazen, tuttuğu sınıfların farklı özelliklerini indekslemek için bir listede birden çok sözlük oluşturuyorum. Yine de bileşik anahtarları en iyi nasıl kullanacağımdan emin değilim. Üç değerin bir sağlama toplamını yapmayı düşündüm, ancak bu çarpışma riskini doğuruyor.

Question 2

Tuple kullanmalısınız. Bir CompositeKey sınıfına eşdeğerdirler, ancak Equals () ve GetHashCode () sizin için zaten uygulanmıştır.

var myClassIndex = new Dictionary<Tuple<int, bool, string>, MyClass>();
//Populate dictionary with items from the List<MyClass> MyClassList
foreach (var myObj in myClassList)
    myClassIndex.Add(Tuple.Create(myObj.MyInt, myObj.MyBool, myObj.MyString), myObj);
MyClass myObj = myClassIndex[Tuple.Create(4, true, "t")];

Veya System.Linq kullanarak

var myClassIndex = myClassList.ToDictionary(myObj => Tuple.Create(myObj.MyInt, myObj.MyBool, myObj.MyString));
MyClass myObj = myClassIndex[Tuple.Create(4, true, "t")];

Karmanın hesaplamasını özelleştirmeniz gerekmedikçe, demetleri kullanmak daha kolaydır.

Bileşik anahtara dahil etmek istediğiniz çok sayıda özellik varsa, Tuple türü adı oldukça uzun olabilir, ancak Tuple <...> 'den türetilen kendi sınıfınızı oluşturarak adı daha kısa yapabilirsiniz.

** 2017'de düzenlendi **

C # 7 ile başlayan yeni bir seçenek var: değer tuples . Fikir aynı, ancak sözdizimi farklı, daha hafif:

Tür Tuple<int, bool, string>olur (int, bool, string)ve değer Tuple.Create(4, true, "t")olur (4, true, "t").

Değer dizileriyle öğeleri adlandırmak da mümkün hale gelir. Performansların biraz farklı olduğunu unutmayın, bu nedenle sizin için önemliyse bazı kıyaslamalar yapmak isteyebilirsiniz.

Question 3

Düşünebildiğim en iyi yol, bir CompositeKey yapısı oluşturmak ve koleksiyonla çalışırken hız ve doğruluk sağlamak için GetHashCode () ve Equals () yöntemlerini geçersiz kıldığından emin olmaktır:

class Program
{
    static void Main(string[] args)
    {
        DateTime firstTimestamp = DateTime.Now;
        DateTime secondTimestamp = firstTimestamp.AddDays(1);

        /* begin composite key dictionary populate */
        Dictionary<CompositeKey, string> compositeKeyDictionary = new Dictionary<CompositeKey, string>();

        CompositeKey compositeKey1 = new CompositeKey();
        compositeKey1.Int1 = 11;
        compositeKey1.Int2 = 304;
        compositeKey1.DateTime = firstTimestamp;

        compositeKeyDictionary[compositeKey1] = "FirstObject";

        CompositeKey compositeKey2 = new CompositeKey();
        compositeKey2.Int1 = 12;
        compositeKey2.Int2 = 9852;
        compositeKey2.DateTime = secondTimestamp;

        compositeKeyDictionary[compositeKey2] = "SecondObject";
        /* end composite key dictionary populate */

        /* begin composite key dictionary lookup */
        CompositeKey compositeKeyLookup1 = new CompositeKey();
        compositeKeyLookup1.Int1 = 11;
        compositeKeyLookup1.Int2 = 304;
        compositeKeyLookup1.DateTime = firstTimestamp;

        Console.Out.WriteLine(compositeKeyDictionary[compositeKeyLookup1]);

        CompositeKey compositeKeyLookup2 = new CompositeKey();
        compositeKeyLookup2.Int1 = 12;
        compositeKeyLookup2.Int2 = 9852;
        compositeKeyLookup2.DateTime = secondTimestamp;

        Console.Out.WriteLine(compositeKeyDictionary[compositeKeyLookup2]);
        /* end composite key dictionary lookup */
    }

    struct CompositeKey
    {
        public int Int1 { get; set; }
        public int Int2 { get; set; }
        public DateTime DateTime { get; set; }

        public override int GetHashCode()
        {
            return Int1.GetHashCode() ^ Int2.GetHashCode() ^ DateTime.GetHashCode();
        }

        public override bool Equals(object obj)
        {
            if (obj is CompositeKey)
            {
                CompositeKey compositeKey = (CompositeKey)obj;

                return ((this.Int1 == compositeKey.Int1) &&
                        (this.Int2 == compositeKey.Int2) &&
                        (this.DateTime == compositeKey.DateTime));
            }

            return false;
        }
    }
}

GetHashCode () ile ilgili bir MSDN makalesi:

http://msdn.microsoft.com/en-us/library/system.object.gethashcode.aspx

Question 4

Nasıl olur Dictionary<int, Dictionary<int, Dictionary<DateTime, MyClass>>>?

Bu, şunları yapmanıza izin verir:

MyClass item = MyData[8][23923][date];

Question 5

Bunları bir yapıda saklayabilir ve bunu anahtar olarak kullanabilirsiniz:

struct CompositeKey
{
  public int value1;
  public int value2;
  public DateTime value3;
}

Karma kodu almak için bağlantı: http://msdn.microsoft.com/en-us/library/system.valuetype.gethashcode.aspx

Question 6

Şimdi VS2017 / C # 7 çıktı, en iyi cevap ValueTuple kullanmaktır:

// declare:
Dictionary<(string, string, int), MyClass> index;

// populate:
foreach (var m in myClassList) {
  index[(m.Name, m.Path, m.JobId)] = m;
}

// retrieve:
var aMyClass = index[("foo", "bar", 15)];

Sözlüğü anonim bir ValueTuple ile bildirmeyi seçtim (string, string, int). Ama onlara isimler verebilirdim(string name, string path, int id) .

Mükemmel şekilde, yeni ValueTuple, Tuple'dan daha hızlı GetHashCodeancak daha yavaştır Equals. Senaryonuz için hangisinin gerçekten en hızlı olduğunu bulmak için uçtan uca eksiksiz deneyler yapmanız gerektiğini düşünüyorum. Ancak ValueTuple'ın uçtan uca güzelliği ve dil sözdizimi onu kazançlı kılıyor.

// Perf from https://gist.github.com/ljw1004/61bc96700d0b03c17cf83dbb51437a69
//
//              Tuple ValueTuple KeyValuePair
//  Allocation:  160   100        110
//    Argument:   75    80         80    
//      Return:   75   210        210
//        Load:  160   170        320
// GetHashCode:  820   420       2700
//      Equals:  280   470       6800

Question 7

Hemen akla iki yaklaşım gelir:

Kevin'in önerdiği gibi yapın ve anahtarınız olarak hizmet edecek bir yapı yazın. Bu yapının uygulandığından IEquatable<TKey>ve onun Equalsve GetHashCodeyöntemlerini * geçersiz kıldığından emin olun .
İç içe geçmiş sözlükleri dahili olarak kullanan bir sınıf yazın. Bir şey gibi: TripleKeyDictionary<TKey1, TKey2, TKey3, TValue>... Bu sınıf içten tip bir üyesi olurdu Dictionary<TKey1, Dictionary<TKey2, Dictionary<TKey3, TValue>>>ve böyle gibi yöntemleri açığa çıkaracağını this[TKey1 k1, TKey2 k2, TKey3 k3], ContainsKeys(TKey1 k1, TKey2 k2, TKey3 k3)vb

* EqualsYöntemin geçersiz kılınmasının gerekli olup olmadığına dair bir kelime : EqualsBir yapının yönteminin varsayılan olarak her bir üyenin değerini karşılaştırdığı doğru olsa da, bunu yansıma kullanarak yapar - bu da doğal olarak performans maliyetlerini gerektirir - ve bu nedenle çok fazla değildir. sözlükte anahtar olarak kullanılması amaçlanan bir şey için uygun uygulama (benim görüşüme göre, yine de). Aşağıdaki MSDN belgelerine göre ValueType.Equals:

Equals yönteminin varsayılan uygulaması, ilgili obj alanlarını ve bu örneği karşılaştırmak için yansıma kullanır. Yöntemin performansını iyileştirmek ve tür için eşitlik kavramını daha yakından temsil etmek için belirli bir tür için Eşittir yöntemini geçersiz kılın.

Question 8

Anahtar sınıfın bir parçasıysa, kullanın KeyedCollection.
Bu ise Dictionaryönemli bir nesne elde edilir.
O Sözlük olduğunu kapakları altında
Do not anahtarı tekrarlamak zorunda Keyve Value.
Neden anahtar aynı olmayan bir şans Keyolarak Value.
Aynı bilgileri bellekte kopyalamak zorunda değilsiniz.

KeyedCollection Sınıfı

Bileşik anahtarı göstermek için dizin oluşturucu

    using System.Collections.ObjectModel;

    namespace IntIntKeyedCollection
    {
        class Program
        {
            static void Main(string[] args)
            {
                Int32Int32DateO iid1 = new Int32Int32DateO(0, 1, new DateTime(2007, 6, 1, 8, 30, 52));
                Int32Int32DateO iid2 = new Int32Int32DateO(0, 1, new DateTime(2007, 6, 1, 8, 30, 52));
                if (iid1 == iid2) Console.WriteLine("same");
                if (iid1.Equals(iid2)) Console.WriteLine("equals");
                // that are equal but not the same I don't override = so I have both features

                Int32Int32DateCollection int32Int32DateCollection = new Int32Int32DateCollection();
                // dont't have to repeat the key like Dictionary
                int32Int32DateCollection.Add(new Int32Int32DateO(0, 0, new DateTime(2008, 5, 1, 8, 30, 52)));
                int32Int32DateCollection.Add(new Int32Int32DateO(0, 1, new DateTime(2008, 6, 1, 8, 30, 52)));
                int32Int32DateCollection.Add(iid1);
                //this would thow a duplicate key error
                //int32Int32DateCollection.Add(iid2);
                //this would thow a duplicate key error
                //int32Int32DateCollection.Add(new Int32Int32DateO(0, 1, new DateTime(2008, 6, 1, 8, 30, 52)));
                Console.WriteLine("count");
                Console.WriteLine(int32Int32DateCollection.Count.ToString());
                // reference by ordinal postion (note the is not the long key)
                Console.WriteLine("oridinal");
                Console.WriteLine(int32Int32DateCollection[0].GetHashCode().ToString());
                // reference by index
                Console.WriteLine("index");
                Console.WriteLine(int32Int32DateCollection[0, 1, new DateTime(2008, 6, 1, 8, 30, 52)].GetHashCode().ToString());
                Console.WriteLine("foreach");
                foreach (Int32Int32DateO iio in int32Int32DateCollection)
                {
                    Console.WriteLine(string.Format("HashCode {0} Int1 {1} Int2 {2} DateTime {3}", iio.GetHashCode(), iio.Int1, iio.Int2, iio.Date1));
                }
                Console.WriteLine("sorted by date");
                foreach (Int32Int32DateO iio in int32Int32DateCollection.OrderBy(x => x.Date1).ThenBy(x => x.Int1).ThenBy(x => x.Int2))
                {
                    Console.WriteLine(string.Format("HashCode {0} Int1 {1} Int2 {2} DateTime {3}", iio.GetHashCode(), iio.Int1, iio.Int2, iio.Date1));
                }
                Console.ReadLine();
            }
            public class Int32Int32DateCollection : KeyedCollection<Int32Int32DateS, Int32Int32DateO>
            {
                // This parameterless constructor calls the base class constructor 
                // that specifies a dictionary threshold of 0, so that the internal 
                // dictionary is created as soon as an item is added to the  
                // collection. 
                // 
                public Int32Int32DateCollection() : base(null, 0) { }

                // This is the only method that absolutely must be overridden, 
                // because without it the KeyedCollection cannot extract the 
                // keys from the items.  
                // 
                protected override Int32Int32DateS GetKeyForItem(Int32Int32DateO item)
                {
                    // In this example, the key is the part number. 
                    return item.Int32Int32Date;
                }

                //  indexer 
                public Int32Int32DateO this[Int32 Int1, Int32 Int2, DateTime Date1]
                {
                    get { return this[new Int32Int32DateS(Int1, Int2, Date1)]; }
                }
            }

            public struct Int32Int32DateS
            {   // required as KeyCollection Key must be a single item
                // but you don't really need to interact with Int32Int32DateS directly
                public readonly Int32 Int1, Int2;
                public readonly DateTime Date1;
                public Int32Int32DateS(Int32 int1, Int32 int2, DateTime date1)
                { this.Int1 = int1; this.Int2 = int2; this.Date1 = date1; }
            }
            public class Int32Int32DateO : Object
            {
                // implement other properties
                public Int32Int32DateS Int32Int32Date { get; private set; }
                public Int32 Int1 { get { return Int32Int32Date.Int1; } }
                public Int32 Int2 { get { return Int32Int32Date.Int2; } }
                public DateTime Date1 { get { return Int32Int32Date.Date1; } }

                public override bool Equals(Object obj)
                {
                    //Check for null and compare run-time types.
                    if (obj == null || !(obj is Int32Int32DateO)) return false;
                    Int32Int32DateO item = (Int32Int32DateO)obj;
                    return (this.Int32Int32Date.Int1 == item.Int32Int32Date.Int1 &&
                            this.Int32Int32Date.Int2 == item.Int32Int32Date.Int2 &&
                            this.Int32Int32Date.Date1 == item.Int32Int32Date.Date1);
                }
                public override int GetHashCode()
                {
                    return (((Int64)Int32Int32Date.Int1 << 32) + Int32Int32Date.Int2).GetHashCode() ^ Int32Int32Date.GetHashCode();
                }
                public Int32Int32DateO(Int32 Int1, Int32 Int2, DateTime Date1)
                {
                    Int32Int32DateS int32Int32Date = new Int32Int32DateS(Int1, Int2, Date1);
                    this.Int32Int32Date = int32Int32Date;
                }
            }
        }
    }

Fpr değer türünü kullanmaya gelince, Microsoft özellikle buna karşı tavsiye eder.

ValueType.GetHashCode

Tuple teknik olarak bir değer türü değildir, ancak aynı semptomdan muzdariptir (karma çarpışmalar) ve bir anahtar için iyi bir aday değildir.

Question 9

Bir alternatif önerebilir miyim - anonim bir nesne. GroupBy LINQ yönteminde birden çok anahtarla kullandığımızın aynısı.

var dictionary = new Dictionary<object, string> ();
dictionary[new { a = 1, b = 2 }] = "value";

Garip görünebilir, ancak Tuple.GetHashCode'u karşılaştırdım ve yeni {a = 1, b = 2} .GetHashCode yöntemleri ve anonim nesneler makinemde .NET 4.5.1 üzerinde kazanıyor:

Nesne - 89,1732 ms, 1000 döngüde 10000 çağrı için

Tuple - 1000 döngüde 10000 çağrı için 738,4475 ms

Question 10

Daha önce bahsedilenlere başka bir çözüm, şimdiye kadar üretilen tüm anahtarların bir tür listesini saklamaktır ve yeni bir nesne oluşturulduğunda, onun karma kodunu oluşturursunuz (sadece bir başlangıç noktası olarak), zaten listede olup olmadığını kontrol edin. daha sonra benzersiz bir anahtar elde edene kadar ona rastgele bir değer vb. ekleyin, ardından bu anahtarı nesnenin kendisinde ve listede saklayın ve bunu her zaman anahtar olarak geri getirin.