/// <summary>Returns an enumerator that iterates through the collection.</summary>
 /// <returns>An enumerator that can be used to iterate through the collection.</returns>
 public IEnumerator <KeyValuePair <IJaggedIndex <TKey>, TValue> > GetEnumerator()
 {
     return(new Enumerator <KeyValuePair <IJaggedIndex <TKey>, TValue> >(this,
                                                                         enums => new KeyValuePair <IJaggedIndex <TKey>, TValue>(
                                                                             JaggedIndex.Create <TKey>(enums.Select(e => (TKey)e.Key).ToArray()),
                                                                             (TValue)enums.Last().Value)));
 }
        public void EnumerateBasic_2Dimension()
        {
            var indexes = new[] {
                new[] { 1, 1 },
                new[] { 1, 2 },
                new[] { 1, 3 },
                new[] { 2, 1 },
                new[] { 2, 2 },
                new[] { 2, 3 },
                new[] { 3, 1 },
                new[] { 3, 2 },
                new[] { 3, 3 }
            };

            var sut  = new JaggedDictionary <int, int>(indexes.First().Length, SortedDictionaryFactory <int> .Default);
            var keys = indexes.Select(a => JaggedIndex.Create(a)).ToList();

            foreach (var key in keys)
            {
                sut[key] = 0;
            }

            var keyValuePairs = sut.ToList();

            Assert.Equal(keys.Count, keyValuePairs.Count);
            foreach (var kvp in keyValuePairs)
            {
                Assert.True(keys.Cast <IJaggedIndex <int> >().Contains(kvp.Key));
                Assert.Equal(0, kvp.Value);
            }
        }
Beispiel #3
0
 internal KeyCollection(JaggedDictionary <TKey, TValue> dictionary)
     : base(dictionary, enums => JaggedIndex.Create <TKey>(enums.Select(e => (TKey)e.Key).ToArray()))
 {
 }