The keys are compared in one of three ways. If TKey implements IComparable<TKey> or IComparable,\n then the CompareTo method of that interface will be used to compare elements. Alternatively, a comparison\n function can be passed in either as a delegate, or as an instance of IComparer<TKey>.
\nOrderedDictionary is implemented as a balanced binary tree. Inserting, deleting, and looking up an\n an element all are done in log(N) type, where N is the number of keys in the tree.
\nThis method is not abstract, although derived classes should always\n override it. It is not abstract because some derived classes may wish to reimplement\n Add with a different return type (typically bool). In C#, this can be accomplished\n with code like the following:
\n\n public class MyCollection<T>: CollectionBase<T>, ICollection<T>\n {\n public new bool Add(T item) {\n /* Add the item */\n }\n \n void ICollection<T>.Add(T item) {\n Add(item);\n }\n }\n \n Typically, this method is used in conjunction with a foreach statement. For example:\n \n foreach(KeyValuePair<TKey, TValue> pair in dictionary.Reversed()) {\n // process pair\n }\n
If an entry is added to or deleted from the dictionary while the View is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nCalling Reverse does not copy the data in the dictionary, and the operation takes constant time.
\nIf
The sorted order of the keys is determined by the comparison instance or delegate used\n to create the dictionary.
\nTypically, this property is used in conjunction with a foreach statement. For example:
\n\n foreach(KeyValuePair<TKey, TValue> pair in dictionary.Range(from, true, to, false)) {\n // process pair\n }\n \n Calling Range does not copy the data in the dictionary, and the operation takes constant time.
The sorted order of the keys is determined by the comparison instance or delegate used\n to create the dictionary.
\nTypically, this property is used in conjunction with a foreach statement. For example:
\n\n foreach(KeyValuePair<TKey, TValue> pair in dictionary.RangeFrom(from, true)) {\n // process pair\n }\n \n Calling RangeFrom does not copy of the data in the dictionary, and the operation takes constant time.
\nThe sorted order of the keys is determined by the comparison instance or delegate used\n to create the dictionary.
\nTypically, this property is used in conjunction with a foreach statement. For example:
\n\n foreach(KeyValuePair<TKey, TValue> pair in dictionary.RangeFrom(from, false)) {\n // process pair\n }\n \n Calling RangeTo does not copy the data in the dictionary, and the operation takes constant time.
\nUnlike adding or removing an element, changing the value associated with a key\n can be performed while an enumeration (foreach) on the the dictionary is in progress.
\nEquality between keys is determined by the comparison instance or delegate used\n to create the dictionary.
\nReplace takes time O(log N), where N is the number of entries in the dictionary.
Typically, this method is not called directly. Instead the \"foreach\" statement is used\n to enumerate the elements of the dictionary, which uses this method implicitly.
\nIf an element is added to or deleted from the dictionary while it is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nEnumeration all the entries in the dictionary takes time O(N log N), where N is the number\n of entries in the dictionary.
\nViews are dynamic. If the underlying dictionary changes, the view changes in sync. If a change is made\n to the view, the underlying dictionary changes accordingly.
\nTypically, this class is used in conjunction with a foreach statement to enumerate the keys\n and values in a subset of the OrderedDictionary. For example:
\n\n foreach(KeyValuePair<TKey, TValue> pair in dictionary.Range(from, to)) {\n // process pair\n }\n \n \n dictionary.Range(\"A\", \"B\").Clear();\n \n The items are compared in one of three ways. If T implements IComparable<TKey> or IComparable,\n then the CompareTo method of that interface will be used to compare items. Alternatively, a comparison\n function can be passed in either as a delegate, or as an instance of IComparer<TKey>.
\nOrderedBag is implemented as a balanced binary tree. Inserting, deleting, and looking up an\n an element all are done in log(N) + M time, where N is the number of keys in the tree, and M is the current number\n of copies of the element being handled.
\nTypically, this method is not called directly. Instead the \"foreach\" statement is used\n to enumerate the items, which uses this method implicitly.
\nIf an item is added to or deleted from the bag while it is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nEnumeration all the items in the bag takes time O(N), where N is the number\n of items in the bag.
\nTypically, this method is used in conjunction with a foreach statement. For example:\n \n foreach(T item in bag.Reversed()) {\n // process item\n }\n
If an item is added to or deleted from the bag while the View is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nCalling Reverse does not copy the data in the tree, and the operation takes constant time.
\nIf
Typically, this method is used in conjunction with a foreach statement. For example:\n \n foreach(T item in bag.Range(from, true, to, false)) {\n // process item\n }\n
If an item is added to or deleted from the bag while the View is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nCalling Range does not copy the data in the tree, and the operation takes constant time.
\nTypically, this method is used in conjunction with a foreach statement. For example:\n \n foreach(T item in bag.RangeFrom(from, true)) {\n // process item\n }\n
If an item is added to or deleted from the bag while the View is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nCalling RangeFrom does not copy the data in the tree, and the operation takes constant time.
\nTypically, this method is used in conjunction with a foreach statement. For example:\n \n foreach(T item in bag.RangeTo(to, false)) {\n // process item\n }\n
If an item is added to or deleted from the bag while the View is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nCalling RangeTo does not copy the data in the tree, and the operation takes constant time.
\nAlgorithms.Reverse(deque.Range(3, 6))\n will return the reverse opf the 6 items beginning at index 3.Views are dynamic. If the underlying bag changes, the view changes in sync. If a change is made\n to the view, the underlying bag changes accordingly.
\nTypically, this class is used in conjunction with a foreach statement to enumerate the items \n in a subset of the OrderedBag. For example:
\n\n foreach(T item in bag.Range(from, to)) {\n // process item\n }\n \n \n bag.Range(\"A\", \"B\").Clear();\n \n Insert(Count, item)\n Algorithms.ReverseInPlace(deque.Range(3, 6))\n will reverse the 6 items beginning at index 3.Insert(Count, item)\n The items are compared in one of two ways. If T implements IComparable<T> \n then the Equals method of that interface will be used to compare items, otherwise the Equals\n method from Object will be used. Alternatively, an instance of IComparer<T> can be passed\n to the constructor to use to compare items.
\nSet is implemented as a hash table. Inserting, deleting, and looking up an\n an element all are done in approximately constant time, regardless of the number of items in the Set.
\nTypically, this method is not called directly. Instead the \"foreach\" statement is used\n to enumerate the items, which uses this method implicitly.
\nIf an item is added to or deleted from the set while it is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nEnumerating all the items in the set takes time O(N), where N is the number\n of items in the set.
\n\n Set<string> set = new Set<string>(StringComparer.CurrentCultureIgnoreCase);\n set.Add(\"HELLO\");\n string s;\n bool b = set.TryGetItem(\"Hello\", out s); // b receives true, s receives \"HELLO\".\n \n Algorithms.ReverseInPlace(Algorithms.Range(list, 3, 6))\n will reverse the 6 items beginning at index 3.Algorithms.ReverseInPlace(Algorithms.Range(array, 3, 6))\n will reverse the 6 items beginning at index 3.\n Dictionary<IEnumerable<string>, int> = \n new Dictionary<IEnumerable<string>, int>(Algorithms.GetCollectionEqualityComparer<string>());\n \n \n Dictionary<IEnumerable<string>, int> = \n new Dictionary<IEnumerable<string>, int>(Algorithms.GetCollectionEqualityComparer<string>(StringComparer.CurrentCultureIgnoreCase));\n \n \n Dictionary<IEnumerable<string>, int> = \n new Dictionary<IEnumerable<string>, int>(Algorithms.GetSetEqualityComparer<string>(StringComparer.CurrentCultureIgnoreCase));\n \n \n Dictionary<IEnumerable<string>, int> = \n new Dictionary<IEnumerable<string>, int>(Algorithms.GetSetEqualityComparer<string>());\n \n \n List<int> list1, list2;\n if (EqualCollections(list1, list2, delegate(int x, int y) { return x <= y; }) {\n // the check is true...\n }\n \n \n List<double> list = new List<double>(Algorithms.NCopiesOf(1000, 1.0));\n Algorithms.ReverseInPlace(list.Range(3, 6))\n will reverse the 6 items beginning at index 3.The items are compared in one of three ways. If T implements IComparable<TKey> or IComparable,\n then the CompareTo method of that interface will be used to compare items. Alternatively, a comparison\n function can be passed in either as a delegate, or as an instance of IComparer<TKey>.
\nOrderedSet is implemented as a balanced binary tree. Inserting, deleting, and looking up an\n an element all are done in log(N) type, where N is the number of keys in the tree.
\nTypically, this method is not called directly. Instead the \"foreach\" statement is used\n to enumerate the items, which uses this method implicitly.
\nIf an item is added to or deleted from the set while it is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nEnumeration all the items in the set takes time O(N log N), where N is the number\n of items in the set.
\n\n OrderedSet<string> set = new OrderedSet<string>(StringComparer.CurrentCultureIgnoreCase);\n set.Add(\"HELLO\");\n string s;\n bool b = set.TryGetItem(\"Hello\", out s); // b receives true, s receives \"HELLO\".\n \n Typically, this method is used in conjunction with a foreach statement. For example:\n \n foreach(T item in set.Reversed()) {\n // process item\n }\n
If an item is added to or deleted from the set while the View is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nCalling Reverse does not copy the data in the tree, and the operation takes constant time.
\nIf
Typically, this method is used in conjunction with a foreach statement. For example:\n \n foreach(T item in set.Range(from, true, to, false)) {\n // process item\n }\n
If an item is added to or deleted from the set while the View is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nCalling Range does not copy the data in the tree, and the operation takes constant time.
\nTypically, this method is used in conjunction with a foreach statement. For example:\n \n foreach(T item in set.RangeFrom(from, true)) {\n // process item\n }\n
If an item is added to or deleted from the set while the View is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nCalling RangeFrom does not copy the data in the tree, and the operation takes constant time.
\nTypically, this method is used in conjunction with a foreach statement. For example:\n \n foreach(T item in set.RangeTo(to, false)) {\n // process item\n }\n
If an item is added to or deleted from the set while the View is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nCalling RangeTo does not copy the data in the tree, and the operation takes constant time.
\nViews are dynamic. If the underlying set changes, the view changes in sync. If a change is made\n to the view, the underlying set changes accordingly.
\nTypically, this class is used in conjunction with a foreach statement to enumerate the items \n in a subset of the OrderedSet. For example:
\n\n foreach(T item in set.Range(from, to)) {\n // process item\n }\n \n \n set.Range(\"A\", \"B\").Clear();\n \n The items are compared in one of two ways. If T implements IComparable<T> \n then the Equals method of that interface will be used to compare items, otherwise the Equals\n method from Object will be used. Alternatively, an instance of IComparer<T> can be passed\n to the constructor to use to compare items.
\nBag is implemented as a hash table. Inserting, deleting, and looking up an\n an element all are done in approximately constant time, regardless of the number of items in the bag.
\nWhen multiple equal items are stored in the bag, they are stored as a representative item and a count. \n If equal items can be distinguished, this may be noticable. For example, if a case-insensitive\n comparer is used with a Bag<string>, and both \"hello\", and \"HELLO\" are added to the bag, then the\n bag will appear to contain two copies of \"hello\" (the representative item).
\nTypically, this method is not called directly. Instead the \"foreach\" statement is used\n to enumerate the items, which uses this method implicitly.
\nIf an item is added to or deleted from the bag while it is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nEnumeration all the items in the bag takes time O(N), where N is the number\n of items in the bag.
\nTypically, this method is used in conjunction with a foreach statement. For example:\n \n foreach(KeyValuePair<TKey, TValue> pair in dictionary.Reversed()) {\n // process pair\n }\n
If an entry is added to or deleted from the dictionary while the View is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nCalling Reverse does not copy the data in the dictionary, and the operation takes constant time.
\nIf
The sorted order of the keys is determined by the comparison instance or delegate used\n to create the dictionary.
\nTypically, this property is used in conjunction with a foreach statement. For example:
\n\n foreach(KeyValuePair<TKey, TValue> pair in dictionary.Range(from, true, to, false)) {\n // process pair\n }\n \n Calling Range does not copy the data in the dictionary, and the operation takes constant time.
The sorted order of the keys is determined by the comparison instance or delegate used\n to create the dictionary.
\nTypically, this property is used in conjunction with a foreach statement. For example:
\n\n foreach(KeyValuePair<TKey, TValue> pair in dictionary.RangeFrom(from, true)) {\n // process pair\n }\n \n Calling RangeFrom does not copy of the data in the dictionary, and the operation takes constant time.
\nThe sorted order of the keys is determined by the comparison instance or delegate used\n to create the dictionary.
\nTypically, this property is used in conjunction with a foreach statement. For example:
\n\n foreach(KeyValuePair<TKey, TValue> pair in dictionary.RangeFrom(from, false)) {\n // process pair\n }\n \n Calling RangeTo does not copy the data in the dictionary, and the operation takes constant time.
\nViews are dynamic. If the underlying dictionary changes, the view changes in sync. If a change is made\n to the view, the underlying dictionary changes accordingly.
\nTypically, this class is used in conjunction with a foreach statement to enumerate the keys\n and values in a subset of the OrderedMultiDictionary. For example:
\n\n foreach(KeyValuePair<TKey, TValue> pair in dictionary.Range(from, to)) {\n // process pair\n }\n \n \n dictionary.Range(\"A\", \"B\").Clear();\n \n Algorithms.ReverseInPlace(Algorithms.Range(list, 3, 6))\n will reverse the 6 items beginning at index 3.Algorithms.ReverseInPlace(Algorithms.Range(array, 3, 6))\n will reverse the 6 items beginning at index 3.\n Dictionary<IEnumerable<string>, int> = \n new Dictionary<IEnumerable<string>, int>(Algorithms.GetCollectionEqualityComparer<string>());\n \n \n Dictionary<IEnumerable<string>, int> = \n new Dictionary<IEnumerable<string>, int>(Algorithms.GetCollectionEqualityComparer<string>(StringComparer.CurrentCultureIgnoreCase));\n \n \n Dictionary<IEnumerable<string>, int> = \n new Dictionary<IEnumerable<string>, int>(Algorithms.GetSetEqualityComparer<string>(StringComparer.CurrentCultureIgnoreCase));\n \n \n Dictionary<IEnumerable<string>, int> = \n new Dictionary<IEnumerable<string>, int>(Algorithms.GetSetEqualityComparer<string>());\n \n \n List<int> list1, list2;\n if (EqualCollections(list1, list2, delegate(int x, int y) { return x <= y; }) {\n // the check is true...\n }\n \n \n List<double> list = new List<double>(Algorithms.NCopiesOf(1000, 1.0));\n This method is not abstract, although derived classes should always\n override it. It is not abstract because some derived classes may wish to reimplement\n Add with a different return type (typically bool). In C#, this can be accomplished\n with code like the following:
\n\n public class MyCollection<T>: CollectionBase<T>, ICollection<T>\n {\n public new bool Add(T item) {\n /* Add the item */\n }\n \n void ICollection<T>.Add(T item) {\n Add(item);\n }\n }\n \n Insert(Count, item)\n Algorithms.ReverseInPlace(deque.Range(3, 6))\n will reverse the 6 items beginning at index 3.Insert(Count, item)\n The items are compared in one of two ways. If T implements IComparable<T> \n then the Equals method of that interface will be used to compare items, otherwise the Equals\n method from Object will be used. Alternatively, an instance of IComparer<T> can be passed\n to the constructor to use to compare items.
\nBag is implemented as a hash table. Inserting, deleting, and looking up an\n an element all are done in approximately constant time, regardless of the number of items in the bag.
\nWhen multiple equal items are stored in the bag, they are stored as a representative item and a count. \n If equal items can be distinguished, this may be noticable. For example, if a case-insensitive\n comparer is used with a Bag<string>, and both \"hello\", and \"HELLO\" are added to the bag, then the\n bag will appear to contain two copies of \"hello\" (the representative item).
\nTypically, this method is not called directly. Instead the \"foreach\" statement is used\n to enumerate the items, which uses this method implicitly.
\nIf an item is added to or deleted from the bag while it is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nEnumeration all the items in the bag takes time O(N), where N is the number\n of items in the bag.
\nThe items are compared in one of three ways. If T implements IComparable<TKey> or IComparable,\n then the CompareTo method of that interface will be used to compare items. Alternatively, a comparison\n function can be passed in either as a delegate, or as an instance of IComparer<TKey>.
\nOrderedBag is implemented as a balanced binary tree. Inserting, deleting, and looking up an\n an element all are done in log(N) + M time, where N is the number of keys in the tree, and M is the current number\n of copies of the element being handled.
\nTypically, this method is not called directly. Instead the \"foreach\" statement is used\n to enumerate the items, which uses this method implicitly.
\nIf an item is added to or deleted from the bag while it is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nEnumeration all the items in the bag takes time O(N), where N is the number\n of items in the bag.
\nTypically, this method is used in conjunction with a foreach statement. For example:\n \n foreach(T item in bag.Reversed()) {\n // process item\n }\n
If an item is added to or deleted from the bag while the View is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nCalling Reverse does not copy the data in the tree, and the operation takes constant time.
\nIf
Typically, this method is used in conjunction with a foreach statement. For example:\n \n foreach(T item in bag.Range(from, true, to, false)) {\n // process item\n }\n
If an item is added to or deleted from the bag while the View is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nCalling Range does not copy the data in the tree, and the operation takes constant time.
\nTypically, this method is used in conjunction with a foreach statement. For example:\n \n foreach(T item in bag.RangeFrom(from, true)) {\n // process item\n }\n
If an item is added to or deleted from the bag while the View is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nCalling RangeFrom does not copy the data in the tree, and the operation takes constant time.
\nTypically, this method is used in conjunction with a foreach statement. For example:\n \n foreach(T item in bag.RangeTo(to, false)) {\n // process item\n }\n
If an item is added to or deleted from the bag while the View is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nCalling RangeTo does not copy the data in the tree, and the operation takes constant time.
\nAlgorithms.Reverse(deque.Range(3, 6))\n will return the reverse opf the 6 items beginning at index 3.Views are dynamic. If the underlying bag changes, the view changes in sync. If a change is made\n to the view, the underlying bag changes accordingly.
\nTypically, this class is used in conjunction with a foreach statement to enumerate the items \n in a subset of the OrderedBag. For example:
\n\n foreach(T item in bag.Range(from, to)) {\n // process item\n }\n \n \n bag.Range(\"A\", \"B\").Clear();\n \n Typically, this method is used in conjunction with a foreach statement. For example:\n \n foreach(KeyValuePair<TKey, TValue> pair in dictionary.Reversed()) {\n // process pair\n }\n
If an entry is added to or deleted from the dictionary while the View is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nCalling Reverse does not copy the data in the dictionary, and the operation takes constant time.
\nIf
The sorted order of the keys is determined by the comparison instance or delegate used\n to create the dictionary.
\nTypically, this property is used in conjunction with a foreach statement. For example:
\n\n foreach(KeyValuePair<TKey, TValue> pair in dictionary.Range(from, true, to, false)) {\n // process pair\n }\n \n Calling Range does not copy the data in the dictionary, and the operation takes constant time.
The sorted order of the keys is determined by the comparison instance or delegate used\n to create the dictionary.
\nTypically, this property is used in conjunction with a foreach statement. For example:
\n\n foreach(KeyValuePair<TKey, TValue> pair in dictionary.RangeFrom(from, true)) {\n // process pair\n }\n \n Calling RangeFrom does not copy of the data in the dictionary, and the operation takes constant time.
\nThe sorted order of the keys is determined by the comparison instance or delegate used\n to create the dictionary.
\nTypically, this property is used in conjunction with a foreach statement. For example:
\n\n foreach(KeyValuePair<TKey, TValue> pair in dictionary.RangeFrom(from, false)) {\n // process pair\n }\n \n Calling RangeTo does not copy the data in the dictionary, and the operation takes constant time.
\nViews are dynamic. If the underlying dictionary changes, the view changes in sync. If a change is made\n to the view, the underlying dictionary changes accordingly.
\nTypically, this class is used in conjunction with a foreach statement to enumerate the keys\n and values in a subset of the OrderedMultiDictionary. For example:
\n\n foreach(KeyValuePair<TKey, TValue> pair in dictionary.Range(from, to)) {\n // process pair\n }\n \n \n dictionary.Range(\"A\", \"B\").Clear();\n \n The items are compared in one of three ways. If T implements IComparable<TKey> or IComparable,\n then the CompareTo method of that interface will be used to compare items. Alternatively, a comparison\n function can be passed in either as a delegate, or as an instance of IComparer<TKey>.
\nOrderedSet is implemented as a balanced binary tree. Inserting, deleting, and looking up an\n an element all are done in log(N) type, where N is the number of keys in the tree.
\nTypically, this method is not called directly. Instead the \"foreach\" statement is used\n to enumerate the items, which uses this method implicitly.
\nIf an item is added to or deleted from the set while it is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nEnumeration all the items in the set takes time O(N log N), where N is the number\n of items in the set.
\n\n OrderedSet<string> set = new OrderedSet<string>(StringComparer.CurrentCultureIgnoreCase);\n set.Add(\"HELLO\");\n string s;\n bool b = set.TryGetItem(\"Hello\", out s); // b receives true, s receives \"HELLO\".\n \n Typically, this method is used in conjunction with a foreach statement. For example:\n \n foreach(T item in set.Reversed()) {\n // process item\n }\n
If an item is added to or deleted from the set while the View is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nCalling Reverse does not copy the data in the tree, and the operation takes constant time.
\nIf
Typically, this method is used in conjunction with a foreach statement. For example:\n \n foreach(T item in set.Range(from, true, to, false)) {\n // process item\n }\n
If an item is added to or deleted from the set while the View is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nCalling Range does not copy the data in the tree, and the operation takes constant time.
\nTypically, this method is used in conjunction with a foreach statement. For example:\n \n foreach(T item in set.RangeFrom(from, true)) {\n // process item\n }\n
If an item is added to or deleted from the set while the View is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nCalling RangeFrom does not copy the data in the tree, and the operation takes constant time.
\nTypically, this method is used in conjunction with a foreach statement. For example:\n \n foreach(T item in set.RangeTo(to, false)) {\n // process item\n }\n
If an item is added to or deleted from the set while the View is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nCalling RangeTo does not copy the data in the tree, and the operation takes constant time.
\nViews are dynamic. If the underlying set changes, the view changes in sync. If a change is made\n to the view, the underlying set changes accordingly.
\nTypically, this class is used in conjunction with a foreach statement to enumerate the items \n in a subset of the OrderedSet. For example:
\n\n foreach(T item in set.Range(from, to)) {\n // process item\n }\n \n \n set.Range(\"A\", \"B\").Clear();\n \n Algorithms.ReverseInPlace(list.Range(3, 6))\n will reverse the 6 items beginning at index 3.The items are compared in one of two ways. If T implements IComparable<T> \n then the Equals method of that interface will be used to compare items, otherwise the Equals\n method from Object will be used. Alternatively, an instance of IComparer<T> can be passed\n to the constructor to use to compare items.
\nSet is implemented as a hash table. Inserting, deleting, and looking up an\n an element all are done in approximately constant time, regardless of the number of items in the Set.
\nTypically, this method is not called directly. Instead the \"foreach\" statement is used\n to enumerate the items, which uses this method implicitly.
\nIf an item is added to or deleted from the set while it is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nEnumerating all the items in the set takes time O(N), where N is the number\n of items in the set.
\n\n Set<string> set = new Set<string>(StringComparer.CurrentCultureIgnoreCase);\n set.Add(\"HELLO\");\n string s;\n bool b = set.TryGetItem(\"Hello\", out s); // b receives true, s receives \"HELLO\".\n \n The keys are compared in one of three ways. If TKey implements IComparable<TKey> or IComparable,\n then the CompareTo method of that interface will be used to compare elements. Alternatively, a comparison\n function can be passed in either as a delegate, or as an instance of IComparer<TKey>.
\nOrderedDictionary is implemented as a balanced binary tree. Inserting, deleting, and looking up an\n an element all are done in log(N) type, where N is the number of keys in the tree.
\nTypically, this method is used in conjunction with a foreach statement. For example:\n \n foreach(KeyValuePair<TKey, TValue> pair in dictionary.Reversed()) {\n // process pair\n }\n
If an entry is added to or deleted from the dictionary while the View is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nCalling Reverse does not copy the data in the dictionary, and the operation takes constant time.
\nIf
The sorted order of the keys is determined by the comparison instance or delegate used\n to create the dictionary.
\nTypically, this property is used in conjunction with a foreach statement. For example:
\n\n foreach(KeyValuePair<TKey, TValue> pair in dictionary.Range(from, true, to, false)) {\n // process pair\n }\n \n Calling Range does not copy the data in the dictionary, and the operation takes constant time.
The sorted order of the keys is determined by the comparison instance or delegate used\n to create the dictionary.
\nTypically, this property is used in conjunction with a foreach statement. For example:
\n\n foreach(KeyValuePair<TKey, TValue> pair in dictionary.RangeFrom(from, true)) {\n // process pair\n }\n \n Calling RangeFrom does not copy of the data in the dictionary, and the operation takes constant time.
\nThe sorted order of the keys is determined by the comparison instance or delegate used\n to create the dictionary.
\nTypically, this property is used in conjunction with a foreach statement. For example:
\n\n foreach(KeyValuePair<TKey, TValue> pair in dictionary.RangeFrom(from, false)) {\n // process pair\n }\n \n Calling RangeTo does not copy the data in the dictionary, and the operation takes constant time.
\nUnlike adding or removing an element, changing the value associated with a key\n can be performed while an enumeration (foreach) on the the dictionary is in progress.
\nEquality between keys is determined by the comparison instance or delegate used\n to create the dictionary.
\nReplace takes time O(log N), where N is the number of entries in the dictionary.
Typically, this method is not called directly. Instead the \"foreach\" statement is used\n to enumerate the elements of the dictionary, which uses this method implicitly.
\nIf an element is added to or deleted from the dictionary while it is being enumerated, then \n the enumeration will end with an InvalidOperationException.
\nEnumeration all the entries in the dictionary takes time O(N log N), where N is the number\n of entries in the dictionary.
\nViews are dynamic. If the underlying dictionary changes, the view changes in sync. If a change is made\n to the view, the underlying dictionary changes accordingly.
\nTypically, this class is used in conjunction with a foreach statement to enumerate the keys\n and values in a subset of the OrderedDictionary. For example:
\n\n foreach(KeyValuePair<TKey, TValue> pair in dictionary.Range(from, to)) {\n // process pair\n }\n \n \n dictionary.Range(\"A\", \"B\").Clear();\n \n