We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Collections.Generic \ KeyValuePairComparer

SSCLI
  1. //------------------------------------------------------------------------------
  2. // <copyright file="SortedDictionary.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  16. namespace System.Collections.Generic
  17. {
  18.     using System;
  19.     using System.Diagnostics;
  20.     using System.Runtime.Serialization;
  21.    
  22.     [Serializable()]
  23.     [DebuggerTypeProxy(typeof(System_DictionaryDebugView<, >))]
  24.     [DebuggerDisplay("Count = {Count}")]
  25.     public class SortedDictionary<TKey, TValue> : IDictionary<TKey, TValue>, IDictionary
  26.     {
  27.         [NonSerialized()]
  28.         private KeyCollection keys;
  29.        
  30.         [NonSerialized()]
  31.         private ValueCollection values;
  32.        
  33.         private TreeSet<KeyValuePair<TKey, TValue>> _set;
  34.        
  35.         public SortedDictionary() : this((IComparer<TKey>)null)
  36.         {
  37.         }
  38.        
  39.         public SortedDictionary(IDictionary<TKey, TValue> dictionary) : this(dictionary, null)
  40.         {
  41.         }
  42.        
  43.         public SortedDictionary(IDictionary<TKey, TValue> dictionary, IComparer<TKey> comparer)
  44.         {
  45.             if (dictionary == null) {
  46.                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.dictionary);
  47.             }
  48.            
  49.             _set = new TreeSet<KeyValuePair<TKey, TValue>>(new KeyValuePairComparer(comparer));
  50.            
  51.             foreach (KeyValuePair<TKey, TValue> pair in dictionary) {
  52.                 _set.Add(pair);
  53.             }
  54.         }
  55.        
  56.         public SortedDictionary(IComparer<TKey> comparer)
  57.         {
  58.             _set = new TreeSet<KeyValuePair<TKey, TValue>>(new KeyValuePairComparer(comparer));
  59.         }
  60.        
  61.         void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> keyValuePair)
  62.         {
  63.             _set.Add(keyValuePair);
  64.         }
  65.        
  66.         bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> keyValuePair)
  67.         {
  68.             TreeSet<KeyValuePair<TKey, TValue>>.Node node = _set.FindNode(keyValuePair);
  69.             if (node == null) {
  70.                 return false;
  71.             }
  72.            
  73.             if (keyValuePair.Value == null) {
  74.                 return node.Item.Value == null;
  75.             }
  76.             else {
  77.                 return EqualityComparer<TValue>.Default.Equals(node.Item.Value, keyValuePair.Value);
  78.             }
  79.         }
  80.        
  81.         bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> keyValuePair)
  82.         {
  83.             TreeSet<KeyValuePair<TKey, TValue>>.Node node = _set.FindNode(keyValuePair);
  84.             if (node == null) {
  85.                 return false;
  86.             }
  87.            
  88.             if (EqualityComparer<TValue>.Default.Equals(node.Item.Value, keyValuePair.Value)) {
  89.                 _set.Remove(keyValuePair);
  90.                 return true;
  91.             }
  92.             return false;
  93.         }
  94.        
  95.         bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly {
  96.             get { return false; }
  97.         }
  98.        
  99.         public TValue this[TKey key]
  100.         {
  101.             get {
  102.                 if (key == null) {
  103.                     ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
  104.                 }
  105.                
  106.                 TreeSet<KeyValuePair<TKey, TValue>>.Node node = _set.FindNode(new KeyValuePair<TKey, TValue>(key, default(TValue)));
  107.                 if (node == null) {
  108.                     ThrowHelper.ThrowKeyNotFoundException();
  109.                 }
  110.                
  111.                 return node.Item.Value;
  112.             }
  113.             set {
  114.                 if (key == null) {
  115.                     ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
  116.                 }
  117.                
  118.                 TreeSet<KeyValuePair<TKey, TValue>>.Node node = _set.FindNode(new KeyValuePair<TKey, TValue>(key, default(TValue)));
  119.                 if (node == null) {
  120.                     _set.Add(new KeyValuePair<TKey, TValue>(key, value));
  121.                 }
  122.                 else {
  123.                     node.Item = new KeyValuePair<TKey, TValue>(node.Item.Key, value);
  124.                     _set.UpdateVersion();
  125.                 }
  126.             }
  127.         }
  128.        
  129.         public int Count {
  130.             get { return _set.Count; }
  131.         }
  132.        
  133.         public IComparer<TKey> Comparer {
  134.             get { return ((KeyValuePairComparer)_set.Comparer).keyComparer; }
  135.         }
  136.        
  137.         public KeyCollection Keys {
  138.             get {
  139.                 if (keys == null)
  140.                     keys = new KeyCollection(this);
  141.                 return keys;
  142.             }
  143.         }
  144.        
  145.         ICollection<TKey> IDictionary<TKey, TValue>.Keys {
  146.             get { return Keys; }
  147.         }
  148.        
  149.         public ValueCollection Values {
  150.             get {
  151.                 if (values == null)
  152.                     values = new ValueCollection(this);
  153.                 return values;
  154.             }
  155.         }
  156.        
  157.         ICollection<TValue> IDictionary<TKey, TValue>.Values {
  158.             get { return Values; }
  159.         }
  160.        
  161.         public void Add(TKey key, TValue value)
  162.         {
  163.             if (key == null) {
  164.                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
  165.             }
  166.             _set.Add(new KeyValuePair<TKey, TValue>(key, value));
  167.         }
  168.        
  169.         public void Clear()
  170.         {
  171.             _set.Clear();
  172.         }
  173.        
  174.         public bool ContainsKey(TKey key)
  175.         {
  176.             if (key == null) {
  177.                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
  178.             }
  179.            
  180.             return _set.Contains(new KeyValuePair<TKey, TValue>(key, default(TValue)));
  181.         }
  182.        
  183.         public bool ContainsValue(TValue value)
  184.         {
  185.             bool found = false;
  186.             if (value == null) {
  187.                 _set.InOrderTreeWalk(delegate(TreeSet<KeyValuePair<TKey, TValue>>.Node node)
  188.                 {
  189.                     if (node.Item.Value == null) {
  190.                         found = true;
  191.                         return false;
  192.                         // stop the walk
  193.                     }
  194.                     return true;
  195.                 }
  196. );
  197.                
  198.             }
  199.             else {
  200.                 EqualityComparer<TValue> valueComparer = EqualityComparer<TValue>.Default;
  201.                 _set.InOrderTreeWalk(delegate(TreeSet<KeyValuePair<TKey, TValue>>.Node node)
  202.                 {
  203.                     if (valueComparer.Equals(node.Item.Value, value)) {
  204.                         found = true;
  205.                         return false;
  206.                         // stop the walk
  207.                     }
  208.                     return true;
  209.                 }
  210. );
  211.             }
  212.             return found;
  213.         }
  214.        
  215.         public void CopyTo(KeyValuePair<TKey, TValue>[] array, int index)
  216.         {
  217.             _set.CopyTo(array, index);
  218.         }
  219.        
  220.         public Enumerator GetEnumerator()
  221.         {
  222.             return new Enumerator(this, Enumerator.KeyValuePair);
  223.         }
  224.        
  225.         IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
  226.         {
  227.             return new Enumerator(this, Enumerator.KeyValuePair);
  228.         }
  229.        
  230.         public bool Remove(TKey key)
  231.         {
  232.             if (key == null) {
  233.                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
  234.             }
  235.            
  236.             return _set.Remove(new KeyValuePair<TKey, TValue>(key, default(TValue)));
  237.         }
  238.        
  239.         public bool TryGetValue(TKey key, out TValue value)
  240.         {
  241.             if (key == null) {
  242.                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
  243.             }
  244.            
  245.             TreeSet<KeyValuePair<TKey, TValue>>.Node node = _set.FindNode(new KeyValuePair<TKey, TValue>(key, default(TValue)));
  246.             if (node == null) {
  247.                 value = default(TValue);
  248.                 return false;
  249.             }
  250.             value = node.Item.Value;
  251.             return true;
  252.         }
  253.        
  254.         void ICollection.CopyTo(Array array, int index)
  255.         {
  256.             ((ICollection)_set).CopyTo(array, index);
  257.         }
  258.        
  259.         bool IDictionary.IsFixedSize {
  260.             get { return false; }
  261.         }
  262.        
  263.         bool IDictionary.IsReadOnly {
  264.             get { return false; }
  265.         }
  266.        
  267.         ICollection IDictionary.Keys {
  268.             get { return (ICollection)Keys; }
  269.         }
  270.        
  271.         ICollection IDictionary.Values {
  272.             get { return (ICollection)Values; }
  273.         }
  274.        
  275.         object IDictionary.this[object key]
  276.         {
  277.             get {
  278.                 if (IsCompatibleKey(key)) {
  279.                     TValue value;
  280.                     if (TryGetValue((TKey)key, out value)) {
  281.                         return value;
  282.                     }
  283.                 }
  284.                 return null;
  285.             }
  286.             set {
  287.                 VerifyKey(key);
  288.                 VerifyValueType(value);
  289.                 this[(TKey)key] = (TValue)value;
  290.             }
  291.         }
  292.        
  293.         void IDictionary.Add(object key, object value)
  294.         {
  295.             VerifyKey(key);
  296.             VerifyValueType(value);
  297.             Add((TKey)key, (TValue)value);
  298.         }
  299.        
  300.         bool IDictionary.Contains(object key)
  301.         {
  302.             if (IsCompatibleKey(key)) {
  303.                 return ContainsKey((TKey)key);
  304.             }
  305.             return false;
  306.         }
  307.        
  308.         private static void VerifyKey(object key)
  309.         {
  310.             if (key == null) {
  311.                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
  312.             }
  313.            
  314.             if (!(key is TKey)) {
  315.                 ThrowHelper.ThrowWrongKeyTypeArgumentException(key, typeof(TKey));
  316.             }
  317.         }
  318.        
  319.         private static bool IsCompatibleKey(object key)
  320.         {
  321.             if (key == null) {
  322.                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
  323.             }
  324.            
  325.             return (key is TKey);
  326.         }
  327.        
  328.         private static void VerifyValueType(object value)
  329.         {
  330.             if ((value is TValue) || (value == null && !typeof(TValue).IsValueType)) {
  331.                 return;
  332.             }
  333.             ThrowHelper.ThrowWrongValueTypeArgumentException(value, typeof(TValue));
  334.         }
  335.        
  336.         IDictionaryEnumerator IDictionary.GetEnumerator()
  337.         {
  338.             return new Enumerator(this, Enumerator.DictEntry);
  339.         }
  340.        
  341.         void IDictionary.Remove(object key)
  342.         {
  343.             if (IsCompatibleKey(key)) {
  344.                 Remove((TKey)key);
  345.             }
  346.         }
  347.        
  348.         bool ICollection.IsSynchronized {
  349.             get { return false; }
  350.         }
  351.        
  352.         object ICollection.SyncRoot {
  353.             get { return ((ICollection)_set).SyncRoot; }
  354.         }
  355.        
  356.         IEnumerator IEnumerable.GetEnumerator()
  357.         {
  358.             return new Enumerator(this, Enumerator.KeyValuePair);
  359.         }
  360.        
  361.         public struct Enumerator : IEnumerator<KeyValuePair<TKey, TValue>>, IDictionaryEnumerator
  362.         {
  363.             private TreeSet<KeyValuePair<TKey, TValue>>.Enumerator treeEnum;
  364.             private int getEnumeratorRetType;
  365.             // What should Enumerator.Current return?
  366.             internal const int KeyValuePair = 1;
  367.             internal const int DictEntry = 2;
  368.            
  369.             internal Enumerator(SortedDictionary<TKey, TValue> dictionary, int getEnumeratorRetType)
  370.             {
  371.                 treeEnum = dictionary._set.GetEnumerator();
  372.                 this.getEnumeratorRetType = getEnumeratorRetType;
  373.             }
  374.            
  375.             public bool MoveNext()
  376.             {
  377.                 return treeEnum.MoveNext();
  378.             }
  379.            
  380.             public void Dispose()
  381.             {
  382.                 treeEnum.Dispose();
  383.             }
  384.            
  385.             public KeyValuePair<TKey, TValue> Current {
  386.                 get { return treeEnum.Current; }
  387.             }
  388.            
  389.             internal bool NotStartedOrEnded {
  390.                 get { return treeEnum.NotStartedOrEnded; }
  391.             }
  392.            
  393.             internal void Reset()
  394.             {
  395.                 treeEnum.Reset();
  396.             }
  397.            
  398.            
  399.             void IEnumerator.Reset()
  400.             {
  401.                 treeEnum.Reset();
  402.             }
  403.            
  404.             object IEnumerator.Current {
  405.                 get {
  406.                     if (NotStartedOrEnded) {
  407.                         ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumOpCantHappen);
  408.                     }
  409.                    
  410.                     if (getEnumeratorRetType == DictEntry) {
  411.                         return new DictionaryEntry(Current.Key, Current.Value);
  412.                     }
  413.                     else {
  414.                         return new KeyValuePair<TKey, TValue>(Current.Key, Current.Value);
  415.                     }
  416.                    
  417.                 }
  418.             }
  419.            
  420.             object IDictionaryEnumerator.Key {
  421.                 get {
  422.                     if (NotStartedOrEnded) {
  423.                         ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumOpCantHappen);
  424.                     }
  425.                    
  426.                     return Current.Key;
  427.                 }
  428.             }
  429.            
  430.             object IDictionaryEnumerator.Value {
  431.                 get {
  432.                     if (NotStartedOrEnded) {
  433.                         ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumOpCantHappen);
  434.                     }
  435.                    
  436.                     return Current.Value;
  437.                 }
  438.             }
  439.            
  440.             DictionaryEntry IDictionaryEnumerator.Entry {
  441.                 get {
  442.                     if (NotStartedOrEnded) {
  443.                         ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumOpCantHappen);
  444.                     }
  445.                    
  446.                     return new DictionaryEntry(Current.Key, Current.Value);
  447.                 }
  448.             }
  449.         }
  450.        
  451.         [DebuggerTypeProxy(typeof(System_DictionaryKeyCollectionDebugView<, >))]
  452.         [DebuggerDisplay("Count = {Count}")]
  453.         [Serializable()]
  454.         public sealed class KeyCollection : ICollection<TKey>, ICollection
  455.         {
  456.             private SortedDictionary<TKey, TValue> dictionary;
  457.            
  458.             public KeyCollection(SortedDictionary<TKey, TValue> dictionary)
  459.             {
  460.                 if (dictionary == null) {
  461.                     ThrowHelper.ThrowArgumentNullException(ExceptionArgument.dictionary);
  462.                 }
  463.                 this.dictionary = dictionary;
  464.             }
  465.            
  466.             public Enumerator GetEnumerator()
  467.             {
  468.                 return new Enumerator(dictionary);
  469.             }
  470.            
  471.             IEnumerator<TKey> IEnumerable<TKey>.GetEnumerator()
  472.             {
  473.                 return new Enumerator(dictionary);
  474.             }
  475.            
  476.             IEnumerator IEnumerable.GetEnumerator()
  477.             {
  478.                 return new Enumerator(dictionary);
  479.             }
  480.            
  481.             public void CopyTo(TKey[] array, int index)
  482.             {
  483.                 if (array == null) {
  484.                     ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
  485.                 }
  486.                
  487.                 if (index < 0) {
  488.                     ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
  489.                 }
  490.                
  491.                 if (array.Length - index < Count) {
  492.                     ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
  493.                 }
  494.                
  495.                 dictionary._set.InOrderTreeWalk(delegate(TreeSet<KeyValuePair<TKey, TValue>>.Node node)
  496.                 {
  497.                     array[index++] = node.Item.Key;
  498.                     return true;
  499.                 }
  500. );
  501.             }
  502.            
  503.             void ICollection.CopyTo(Array array, int index)
  504.             {
  505.                 if (array == null) {
  506.                     ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
  507.                 }
  508.                
  509.                 if (array.Rank != 1) {
  510.                     ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RankMultiDimNotSupported);
  511.                 }
  512.                
  513.                 if (array.GetLowerBound(0) != 0) {
  514.                     ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_NonZeroLowerBound);
  515.                 }
  516.                
  517.                 if (index < 0) {
  518.                     ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.arrayIndex, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
  519.                 }
  520.                
  521.                 if (array.Length - index < dictionary.Count) {
  522.                     ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
  523.                 }
  524.                
  525.                 TKey[] keys = array as TKey[];
  526.                 if (keys != null) {
  527.                     CopyTo(keys, index);
  528.                 }
  529.                 else {
  530.                     object[] objects = (object[])array;
  531.                     if (objects == null) {
  532.                         ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidArrayType);
  533.                     }
  534.                    
  535.                     try {
  536.                         dictionary._set.InOrderTreeWalk(delegate(TreeSet<KeyValuePair<TKey, TValue>>.Node node)
  537.                         {
  538.                             objects[index++] = node.Item.Key;
  539.                             return true;
  540.                         }
  541. );
  542.                     }
  543.                     catch (ArrayTypeMismatchException) {
  544.                         ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidArrayType);
  545.                     }
  546.                 }
  547.             }
  548.            
  549.             public int Count {
  550.                 get { return dictionary.Count; }
  551.             }
  552.            
  553.             bool ICollection<TKey>.IsReadOnly {
  554.                 get { return true; }
  555.             }
  556.            
  557.             void ICollection<TKey>.Add(TKey item)
  558.             {
  559.                 ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_KeyCollectionSet);
  560.             }
  561.            
  562.             void ICollection<TKey>.Clear()
  563.             {
  564.                 ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_KeyCollectionSet);
  565.             }
  566.            
  567.             bool ICollection<TKey>.Contains(TKey item)
  568.             {
  569.                 return dictionary.ContainsKey(item);
  570.             }
  571.            
  572.             bool ICollection<TKey>.Remove(TKey item)
  573.             {
  574.                 ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_KeyCollectionSet);
  575.                 return false;
  576.             }
  577.            
  578.             bool ICollection.IsSynchronized {
  579.                 get { return false; }
  580.             }
  581.            
  582.             object ICollection.SyncRoot {
  583.                 get { return ((ICollection)dictionary).SyncRoot; }
  584.             }
  585.            
  586.             public struct Enumerator : IEnumerator<TKey>, IEnumerator
  587.             {
  588.                 private SortedDictionary<TKey, TValue>.Enumerator dictEnum;
  589.                
  590.                 internal Enumerator(SortedDictionary<TKey, TValue> dictionary)
  591.                 {
  592.                     dictEnum = dictionary.GetEnumerator();
  593.                 }
  594.                
  595.                 public void Dispose()
  596.                 {
  597.                     dictEnum.Dispose();
  598.                 }
  599.                
  600.                 public bool MoveNext()
  601.                 {
  602.                     return dictEnum.MoveNext();
  603.                 }
  604.                
  605.                 public TKey Current {
  606.                     get { return dictEnum.Current.Key; }
  607.                 }
  608.                
  609.                 object IEnumerator.Current {
  610.                     get {
  611.                         if (dictEnum.NotStartedOrEnded) {
  612.                             ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumOpCantHappen);
  613.                         }
  614.                        
  615.                         return Current;
  616.                     }
  617.                 }
  618.                
  619.                 void IEnumerator.Reset()
  620.                 {
  621.                     dictEnum.Reset();
  622.                 }
  623.                
  624.             }
  625.         }
  626.        
  627.         [DebuggerTypeProxy(typeof(System_DictionaryValueCollectionDebugView<, >))]
  628.         [DebuggerDisplay("Count = {Count}")]
  629.         [Serializable()]
  630.         public sealed class ValueCollection : ICollection<TValue>, ICollection
  631.         {
  632.             private SortedDictionary<TKey, TValue> dictionary;
  633.            
  634.             public ValueCollection(SortedDictionary<TKey, TValue> dictionary)
  635.             {
  636.                 if (dictionary == null) {
  637.                     ThrowHelper.ThrowArgumentNullException(ExceptionArgument.dictionary);
  638.                 }
  639.                 this.dictionary = dictionary;
  640.             }
  641.            
  642.             public Enumerator GetEnumerator()
  643.             {
  644.                 return new Enumerator(dictionary);
  645.             }
  646.            
  647.             IEnumerator<TValue> IEnumerable<TValue>.GetEnumerator()
  648.             {
  649.                 return new Enumerator(dictionary);
  650.             }
  651.            
  652.             IEnumerator IEnumerable.GetEnumerator()
  653.             {
  654.                 return new Enumerator(dictionary);
  655.             }
  656.            
  657.             public void CopyTo(TValue[] array, int index)
  658.             {
  659.                 if (array == null) {
  660.                     ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
  661.                 }
  662.                
  663.                 if (index < 0) {
  664.                     ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
  665.                 }
  666.                
  667.                 if (array.Length - index < Count) {
  668.                     ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
  669.                 }
  670.                
  671.                 dictionary._set.InOrderTreeWalk(delegate(TreeSet<KeyValuePair<TKey, TValue>>.Node node)
  672.                 {
  673.                     array[index++] = node.Item.Value;
  674.                     return true;
  675.                 }
  676. );
  677.             }
  678.            
  679.             void ICollection.CopyTo(Array array, int index)
  680.             {
  681.                 if (array == null) {
  682.                     ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
  683.                 }
  684.                
  685.                 if (array.Rank != 1) {
  686.                     ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RankMultiDimNotSupported);
  687.                 }
  688.                
  689.                 if (array.GetLowerBound(0) != 0) {
  690.                     ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_NonZeroLowerBound);
  691.                 }
  692.                
  693.                 if (index < 0) {
  694.                     ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.arrayIndex, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
  695.                 }
  696.                
  697.                 if (array.Length - index < dictionary.Count) {
  698.                     ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
  699.                 }
  700.                
  701.                 TValue[] values = array as TValue[];
  702.                 if (values != null) {
  703.                     CopyTo(values, index);
  704.                 }
  705.                 else {
  706.                     object[] objects = (object[])array;
  707.                     if (objects == null) {
  708.                         ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidArrayType);
  709.                     }
  710.                    
  711.                     try {
  712.                         dictionary._set.InOrderTreeWalk(delegate(TreeSet<KeyValuePair<TKey, TValue>>.Node node)
  713.                         {
  714.                             objects[index++] = node.Item.Value;
  715.                             return true;
  716.                         }
  717. );
  718.                     }
  719.                     catch (ArrayTypeMismatchException) {
  720.                         ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidArrayType);
  721.                     }
  722.                 }
  723.             }
  724.            
  725.             public int Count {
  726.                 get { return dictionary.Count; }
  727.             }
  728.            
  729.             bool ICollection<TValue>.IsReadOnly {
  730.                 get { return true; }
  731.             }
  732.            
  733.             void ICollection<TValue>.Add(TValue item)
  734.             {
  735.                 ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ValueCollectionSet);
  736.             }
  737.            
  738.             void ICollection<TValue>.Clear()
  739.             {
  740.                 ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ValueCollectionSet);
  741.             }
  742.            
  743.             bool ICollection<TValue>.Contains(TValue item)
  744.             {
  745.                 return dictionary.ContainsValue(item);
  746.             }
  747.            
  748.             bool ICollection<TValue>.Remove(TValue item)
  749.             {
  750.                 ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ValueCollectionSet);
  751.                 return false;
  752.             }
  753.            
  754.             bool ICollection.IsSynchronized {
  755.                 get { return false; }
  756.             }
  757.            
  758.             object ICollection.SyncRoot {
  759.                 get { return ((ICollection)dictionary).SyncRoot; }
  760.             }
  761.            
  762.             public struct Enumerator : IEnumerator<TValue>, IEnumerator
  763.             {
  764.                 private SortedDictionary<TKey, TValue>.Enumerator dictEnum;
  765.                
  766.                 internal Enumerator(SortedDictionary<TKey, TValue> dictionary)
  767.                 {
  768.                     dictEnum = dictionary.GetEnumerator();
  769.                 }
  770.                
  771.                 public void Dispose()
  772.                 {
  773.                     dictEnum.Dispose();
  774.                 }
  775.                
  776.                 public bool MoveNext()
  777.                 {
  778.                     return dictEnum.MoveNext();
  779.                 }
  780.                
  781.                 public TValue Current {
  782.                     get { return dictEnum.Current.Value; }
  783.                 }
  784.                
  785.                 object IEnumerator.Current {
  786.                     get {
  787.                         if (dictEnum.NotStartedOrEnded) {
  788.                             ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumOpCantHappen);
  789.                         }
  790.                        
  791.                         return Current;
  792.                     }
  793.                 }
  794.                
  795.                 void IEnumerator.Reset()
  796.                 {
  797.                     dictEnum.Reset();
  798.                 }
  799.             }
  800.         }
  801.        
  802.         [Serializable()]
  803.         internal class KeyValuePairComparer : Comparer<KeyValuePair<TKey, TValue>>
  804.         {
  805.             internal IComparer<TKey> keyComparer;
  806.            
  807.             public KeyValuePairComparer(IComparer<TKey> keyComparer)
  808.             {
  809.                 if (keyComparer == null) {
  810.                     this.keyComparer = Comparer<TKey>.Default;
  811.                 }
  812.                 else {
  813.                     this.keyComparer = keyComparer;
  814.                 }
  815.             }
  816.            
  817.             public override int Compare(KeyValuePair<TKey, TValue> x, KeyValuePair<TKey, TValue> y)
  818.             {
  819.                 return keyComparer.Compare(x.Key, y.Key);
  820.             }
  821.         }
  822.     }
  823. }

Developer Fusion