| Algorithms Class |
Algorithms contains a number of static methods that implement
algorithms that work on collections. Most of the methods deal with
the standard generic collection interfaces such as IEnumerable<T>,
ICollection<T> and IList<T>.
Inheritance HierarchyNamespace: X3Platform.Collections
Assembly: X3Platform.Support (in X3Platform.Support.dll) Version: 1.0.0.0 (2.0.0.0)
SyntaxThe Algorithms type exposes the following members.
Methods| Name | Description | |
|---|---|---|
  | BinarySearchT(IListT, T, Int32) |
Searches a sorted list for an item via binary search. The list must be sorted
by the natural ordering of the type (it's implementation of IComparable<T>).
|
| BinarySearchT(IListT, T, IComparerT, Int32) |
Searches a sorted list for an item via binary search. The list must be sorted
by the ordering in the passed instance of IComparer<T>.
|
| BinarySearchT(IListT, T, ComparisonT, Int32) |
Searches a sorted list for an item via binary search. The list must be sorted
by the ordering in the passed Comparison<T> delegate.
|
| CartesianProductTFirst, TSecond |
Computes the cartestian product of two collections: all possible pairs of items, with the first item taken from the first collection and
the second item taken from the second collection. If the first collection has N items, and the second collection has M items, the cartesian
product will have N * M pairs.
|
| ConcatenateT |
Concatenates all the items from several collections. The collections need not be of the same type, but
must have the same item type.
|
| ConvertTSource, TDest |
Convert a collection of items by applying a delegate to each item in the collection. The resulting collection
contains the result of applying converter to each item in sourceCollection, in
order.
|
| CopyT(IEnumerableT, IListT, Int32) |
Copies all of the items from the collection source to the list dest, starting
at the index destIndex. If necessary, the size of the destination list is expanded.
|
| CopyT(IEnumerableT, T, Int32) |
Copies all of the items from the collection source to the array dest, starting
at the index destIndex.
|
| CopyT(IEnumerableT, IListT, Int32, Int32) |
Copies at most count items from the collection source to the list dest, starting
at the index destIndex. If necessary, the size of the destination list is expanded. The source collection must not be
the destination list or part thereof.
|
| CopyT(IEnumerableT, T, Int32, Int32) |
Copies at most count items from the collection source to the array dest, starting
at the index destIndex. The source collection must not be
the destination array or part thereof.
|
| CopyT(IListT, Int32, IListT, Int32, Int32) |
Copies count items from the list source, starting at the index sourceIndex,
to the list dest, starting at the index destIndex. If necessary, the size of the destination list is expanded.
The source and destination lists may be the same.
|
| CopyT(IListT, Int32, T, Int32, Int32) |
Copies count items from the list or array source, starting at the index sourceIndex,
to the array dest, starting at the index destIndex.
The source may be the same as the destination array.
|
| CountT |
Count the number of items in an IEnumerable<T> collection. If
a more specific collection type is being used, it is more efficient to use
the Count property, if one is provided.
|
| CountEqualT(IEnumerableT, T) |
Counts the number of items in the collection that are equal to find.
|
| CountEqualT(IEnumerableT, T, IEqualityComparerT) |
Counts the number of items in the collection that are equal to find.
|
| CountWhereT |
Counts the number of items in the collection that satisfy the condition
defined by predicate.
|
| DisjointSetsT(IEnumerableT, IEnumerableT) |
Determines if two collections are disjoint, considered as sets. Two sets are disjoint if they
have no common items.
|
| DisjointSetsT(IEnumerableT, IEnumerableT, IEqualityComparerT) |
Determines if two collections are disjoint, considered as sets. Two sets are disjoint if they
have no common items.
|
| EqualCollectionsT(IEnumerableT, IEnumerableT) |
Determines if the two collections contain equal items in the same order. The two collections do not need
to be of the same type; it is permissible to compare an array and an OrderedBag, for instance.
|
| EqualCollectionsT(IEnumerableT, IEnumerableT, IEqualityComparerT) |
Determines if the two collections contain equal items in the same order. The passed
instance of IEqualityComparer<T> is used for determining if two items are equal.
|
| EqualCollectionsT(IEnumerableT, IEnumerableT, BinaryPredicateT) |
Determines if the two collections contain "equal" items in the same order. The passed
BinaryPredicate is used to determine if two items are "equal".
|
| EqualSetsT(IEnumerableT, IEnumerableT) |
Determines if two collections are equal, considered as sets. Two sets are equal if they
have have the same items, with order not being significant.
|
| EqualSetsT(IEnumerableT, IEnumerableT, IEqualityComparerT) |
Determines if two collections are equal, considered as sets. Two sets are equal if they
have have the same items, with order not being significant.
|
| ExistsT |
Determines if a collection contains any item that satisfies the condition
defined by predicate.
|
| FillT(IListT, T) |
Replaces each item in a list with a given value. The list does not change in size.
|
| FillT(T, T) |
Replaces each item in a array with a given value.
|
| FillRangeT(IListT, Int32, Int32, T) |
Replaces each item in a part of a list with a given value.
|
| FillRangeT(T, Int32, Int32, T) |
Replaces each item in a part of a array with a given value.
|
| FindFirstIndexWhereT |
Finds the index of the first item in a list that satisfies the condition
defined by predicate.
|
| FindFirstWhereT |
Finds the first item in a collection that satisfies the condition
defined by predicate.
|
| FindIndicesWhereT |
Enumerates the indices of all the items in list that satisfy the condition defined
by predicate.
|
| FindLastIndexWhereT |
Finds the index of the last item in a list that satisfies the condition
defined by predicate.
|
| FindLastWhereT |
Finds the last item in a collection that satisfies the condition
defined by predicate.
|
| FindWhereT |
Enumerates all the items in collection that satisfy the condition defined
by predicate.
|
| FirstConsecutiveEqualT(IListT, Int32) |
Finds the first occurence of count consecutive equal items in the
list.
|
| FirstConsecutiveEqualT(IListT, Int32, IEqualityComparerT) |
Finds the first occurence of count consecutive equal items in the
list. A passed IEqualityComparer is used to determine equality.
|
| FirstConsecutiveEqualT(IListT, Int32, BinaryPredicateT) |
Finds the first occurence of count consecutive "equal" items in the
list. The passed BinaryPredicate is used to determine if two items are "equal".
|
| FirstConsecutiveWhereT |
Finds the first occurence of count consecutive items in the
list for which a given predicate returns true.
|
| FirstIndexOfT(IListT, T) |
Finds the index of the first item in a list equal to a given item.
|
| FirstIndexOfT(IListT, T, IEqualityComparerT) |
Finds the index of the first item in a list equal to a given item. A passed
IEqualityComparer is used to determine equality.
|
| FirstIndexOfManyT(IListT, IEnumerableT) |
Finds the index of the first item in a list equal to one of several given items.
|
| FirstIndexOfManyT(IListT, IEnumerableT, IEqualityComparerT) |
Finds the index of the first item in a list equal to one of several given items. A passed
IEqualityComparer is used to determine equality.
|
| FirstIndexOfManyT(IListT, IEnumerableT, BinaryPredicateT) |
Finds the index of the first item in a list "equal" to one of several given items. The passed
BinaryPredicate is used to determine if two items are "equal".
|
| ForEachT |
Performs the specified action on each item in a collection.
|
| GeneratePermutationsT |
Generates all the possible permutations of the items in collection. If collection
has N items, then N factorial permutations will be generated. This method does not compare the items to determine if
any of them are equal. If some items are equal, the same permutation may be generated more than once. For example,
if the collections contains the three items A, A, and B, then this method will generate the six permutations, AAB, AAB,
ABA, ABA, BAA, BAA (not necessarily in that order). To take equal items into account, use the GenerateSortedPermutations
method.
|
| GenerateSortedPermutationsT(IEnumerableT) |
Generates all the possible permutations of the items in collection, in lexicographical order.
Even if some items are equal, the same permutation will not be generated more than once. For example,
if the collections contains the three items A, A, and B, then this method will generate only the three permutations, AAB, ABA,
BAA.
|
| GenerateSortedPermutationsT(IEnumerableT, IComparerT) |
Generates all the possible permutations of the items in collection, in lexicographical order. A
supplied IComparer<T> instance is used to compare the items.
Even if some items are equal, the same permutation will not be generated more than once. For example,
if the collections contains the three items A, A, and B, then this method will generate only the three permutations, AAB, ABA,
BAA.
|
| GenerateSortedPermutationsT(IEnumerableT, ComparisonT) |
Generates all the possible permutations of the items in collection, in lexicographical order. A
supplied Comparison<T> delegate is used to compare the items.
Even if some items are equal, the same permutation will not be generated more than once. For example,
if the collections contains the three items A, A, and B, then this method will generate only the three permutations, AAB, ABA,
BAA.
|
 | GetCollectionEqualityComparerT |
Gets an IEqualityComparer<IEnumerable<T>> implementation
that can be used to compare collections of elements (of type T). Two collections
of T's are equal if they have the same number of items, and corresponding
items are equal, considered in order. This is the same notion of equality as
in Algorithms.EqualCollections, but encapsulated in an IEqualityComparer<IEnumerable<T>> implementation.
|
| GetCollectionEqualityComparerT(IEqualityComparerT) | Gets an IEqualityComparer<IEnumerable<T>> implementation that can be used to compare collections of elements (of type T). Two collections of T's are equal if they have the same number of items, and corresponding items are equal, considered in order. This is the same notion of equality as in Algorithms.EqualCollections, but encapsulated in an IEqualityComparer<IEnumerable<T>> implementation. An IEqualityComparer<T> is used to determine if individual T's are equal |
| GetComparerFromComparisonT |
Given a comparison delegate that compares two items of type T, gets an
IComparer<T> instance that performs the same comparison.
|
| GetComparisonFromComparerT |
Given in IComparer<T> instenace that comparers two items from type T,
gets a Comparison delegate that performs the same comparison.
|
| GetDictionaryConverterTKey, TValue(IDictionaryTKey, TValue) |
Creates a delegate that converts keys to values by used a dictionary to map values. Keys
that a not present in the dictionary are converted to the default value (zero or null).
|
| GetDictionaryConverterTKey, TValue(IDictionaryTKey, TValue, TValue) |
Creates a delegate that converts keys to values by used a dictionary to map values. Keys
that a not present in the dictionary are converted to a supplied default value.
|
| GetIdentityComparerT |
Gets an IEqualityComparer<T> instance that can be used to compare objects
of type T for object identity only. Two objects compare equal only if they
are references to the same object.
|
| GetLexicographicalComparerT |
Creates an IComparer instance that can be used for comparing ordered
sequences of type T; that is IEnumerable<Tgt;. This comparer can be used
for collections or algorithms that use sequences of T as an item type. The Lexicographical
ordered of sequences is for comparison.
|
| GetLexicographicalComparerT(IComparerT) |
Creates an IComparer instance that can be used for comparing ordered
sequences of type T; that is IEnumerable<Tgt;. This comparer can be uses
for collections or algorithms that use sequences of T as an item type. The Lexicographics
ordered of sequences is for comparison.
|
| GetLexicographicalComparerT(ComparisonT) |
Creates an IComparer instance that can be used for comparing ordered
sequences of type T; that is IEnumerable<Tgt;. This comparer can be uses
for collections or algorithms that use sequences of T as an item type. The Lexicographics
ordered of sequences is for comparison.
|
| GetReverseComparerT |
Reverses the order of comparison of an IComparer<T>. The resulting comparer can be used,
for example, to sort a collection in descending order. Equality and hash codes are unchanged.
|
| GetReverseComparisonT |
Reverses the order of comparison of an Comparison<T>. The resulting comparison can be used,
for example, to sort a collection in descending order.
|
| GetSetEqualityComparerT | Gets an IEqualityComparer<IEnumerable<T>> implementation that can be used to compare collections of elements (of type T). Two collections of T's are equal if they have the same number of items, and corresponding items are equal, without regard to order. This is the same notion of equality as in Algorithms.EqualSets, but encapsulated in an IEqualityComparer<IEnumerable<T>> implementation. An IEqualityComparer<T> is used to determine if individual T's are equal |
| GetSetEqualityComparerT(IEqualityComparerT) |
Gets an IEqualityComparer<IEnumerable<T>> implementation
that can be used to compare collections of elements (of type T). Two collections
of T's are equal if they have the same number of items, and corresponding
items are equal, without regard to order. This is the same notion of equality as
in Algorithms.EqualSets, but encapsulated in an IEqualityComparer<IEnumerable<T>> implementation.
|
| IndexOfMaximumT(IListT) |
Finds the index of the maximum value in a list.
|
| IndexOfMaximumT(IListT, IComparerT) |
Finds the index of the maximum value in a list. A supplied IComparer<T> is used
to compare the items in the collection.
|
| IndexOfMaximumT(IListT, ComparisonT) |
Finds the index of the maximum value in a list. A supplied Comparison<T> delegate is used
to compare the items in the collection.
|
| IndexOfMinimumT(IListT) |
Finds the index of the minimum value in a list.
|
| IndexOfMinimumT(IListT, IComparerT) |
Finds the index of the minimum value in a list. A supplied IComparer<T> is used
to compare the items in the collection.
|
| IndexOfMinimumT(IListT, ComparisonT) |
Finds the index of the minimum value in a list. A supplied Comparison<T> delegate is used
to compare the items in the collection.
|
| IndicesOfT(IListT, T) |
Enumerates the indices of all the items in a list equal to a given item.
|
| IndicesOfT(IListT, T, IEqualityComparerT) |
Enumerates the indices of all the items in a list equal to a given item. A passed
IEqualityComparer is used to determine equality.
|
| IndicesOfManyT(IListT, IEnumerableT) |
Enumerates the indices of all the items in a list equal to one of several given items.
|
| IndicesOfManyT(IListT, IEnumerableT, IEqualityComparerT) |
Enumerates the indices of all the items in a list equal to one of several given items. A passed
IEqualityComparer is used to determine equality.
|
| IndicesOfManyT(IListT, IEnumerableT, BinaryPredicateT) |
Enumerates the indices of all the items in a list equal to one of several given items. The passed
BinaryPredicate is used to determine if two items are "equal".
|
| IsProperSubsetOfT(IEnumerableT, IEnumerableT) |
Determines if one collection is a proper subset of another, considered as sets. The first set is a proper subset
of the second set if every item in the first set also occurs in the second set, and the first set is strictly smaller than
the second set. If an item appears X times in the first set,
it must appear at least X times in the second set.
|
| IsProperSubsetOfT(IEnumerableT, IEnumerableT, IEqualityComparerT) |
Determines if one collection is a proper subset of another, considered as sets. The first set is a proper subset
of the second set if every item in the first set also occurs in the second set, and the first set is strictly smaller than
the second set. If an item appears X times in the first set,
it must appear at least X times in the second set.
|
| IsSubsetOfT(IEnumerableT, IEnumerableT) |
Determines if one collection is a subset of another, considered as sets. The first set is a subset
of the second set if every item in the first set also occurs in the second set. If an item appears X times in the first set,
it must appear at least X times in the second set.
|
| IsSubsetOfT(IEnumerableT, IEnumerableT, IEqualityComparerT) |
Determines if one collection is a subset of another, considered as sets. The first set is a subset
of the second set if every item in the first set also occurs in the second set. If an item appears X times in the first set,
it must appear at least X times in the second set.
|
| LastIndexOfT(IListT, T) |
Finds the index of the last item in a list equal to a given item.
|
| LastIndexOfT(IListT, T, IEqualityComparerT) |
Finds the index of the last item in a list equal to a given item. A passed
IEqualityComparer is used to determine equality.
|
| LastIndexOfManyT(IListT, IEnumerableT) |
Finds the index of the last item in a list equal to one of several given items.
|
| LastIndexOfManyT(IListT, IEnumerableT, IEqualityComparerT) |
Finds the index of the last item in a list equal to one of several given items. A passed
IEqualityComparer is used to determine equality.
|
| LastIndexOfManyT(IListT, IEnumerableT, BinaryPredicateT) |
Finds the index of the last item in a list "equal" to one of several given items. The passed
BinaryPredicate is used to determine if two items are "equal".
|
| LexicographicalCompareT(IEnumerableT, IEnumerableT) |
Performs a lexicographical comparison of two sequences of values. A lexicographical comparison compares corresponding
pairs of elements from two sequences in order. If the first element of sequence1 is less than the first element of sequence2,
then the comparison ends and the first sequence is lexicographically less than the second. If the first elements of each sequence
are equal, then the comparison proceeds to the second element of each sequence. If one sequence is shorter than the other,
but corresponding elements are all equal, then the shorter sequence is considered less than the longer one.
|
| LexicographicalCompareT(IEnumerableT, IEnumerableT, IComparerT) |
Performs a lexicographical comparison of two sequences of values, using a supplied comparer interface. A lexicographical comparison compares corresponding
pairs of elements from two sequences in order. If the first element of sequence1 is less than the first element of sequence2,
then the comparison ends and the first sequence is lexicographically less than the second. If the first elements of each sequence
are equal, then the comparison proceeds to the second element of each sequence. If one sequence is shorter than the other,
but corresponding elements are all equal, then the shorter sequence is considered less than the longer one.
|
| LexicographicalCompareT(IEnumerableT, IEnumerableT, ComparisonT) |
Performs a lexicographical comparison of two sequences of values, using a supplied comparison delegate. A lexicographical comparison compares corresponding
pairs of elements from two sequences in order. If the first element of sequence1 is less than the first element of sequence2,
then the comparison ends and the first sequence is lexicographically less than the second. If the first elements of each sequence
are equal, then the comparison proceeds to the second element of each sequence. If one sequence is shorter than the other,
but corresponding elements are all equal, then the shorter sequence is considered less than the longer one.
|
| MaximumT(IEnumerableT) |
Finds the maximum value in a collection.
|
| MaximumT(IEnumerableT, IComparerT) |
Finds the maximum value in a collection. A supplied IComparer<T> is used
to compare the items in the collection.
|
| MaximumT(IEnumerableT, ComparisonT) |
Finds the maximum value in a collection. A supplied Comparison<T> delegate is used
to compare the items in the collection.
|
| MergeSortedT(IEnumerableT) |
Merge several sorted collections into a single sorted collection. Each input collection must be sorted
by the natural ordering of the type (it's implementation of IComparable<T>). The merging
is stable; equal items maintain their ordering, and equal items in different collections are placed
in the order of the collections.
|
| MergeSortedT(IComparerT, IEnumerableT) |
Merge several sorted collections into a single sorted collection. Each input collection must be sorted
by the ordering in the passed instance of IComparer<T>. The merging
is stable; equal items maintain their ordering, and equal items in different collections are placed
in the order of the collections.
|
| MergeSortedT(ComparisonT, IEnumerableT) |
Merge several sorted collections into a single sorted collection. Each input collection must be sorted
by the ordering in the passed Comparison<T> delegate. The merging
is stable; equal items maintain their ordering, and equal items in different collections are placed
in the order of the collections.
|
| MinimumT(IEnumerableT) |
Finds the minimum value in a collection.
|
| MinimumT(IEnumerableT, IComparerT) |
Finds the minimum value in a collection. A supplied IComparer<T> is used
to compare the items in the collection.
|
| MinimumT(IEnumerableT, ComparisonT) |
Finds the minimum value in a collection. A supplied Comparison<T> delegate is used
to compare the items in the collection.
|
| NCopiesOfT |
Creates an IEnumerator that enumerates a given item n times.
|
| PartitionT |
Partition a list or array based on a predicate. After partitioning, all items for which
the predicate returned true precede all items for which the predicate returned false.
|
| RandomShuffleT(IEnumerableT) |
Randomly shuffles the items in a collection, yielding a new collection.
|
| RandomShuffleT(IEnumerableT, Random) |
Randomly shuffles the items in a collection, yielding a new collection.
|
| RandomShuffleInPlaceT(IListT) |
Randomly shuffles the items in a list or array, in place.
|
| RandomShuffleInPlaceT(IListT, Random) |
Randomly shuffles the items in a list or array, in place.
|
| RandomSubsetT(IEnumerableT, Int32) |
Picks a random subset of count items from collection, and places
those items into a random order. No item is selected more than once.
|
| RandomSubsetT(IEnumerableT, Int32, Random) |
Picks a random subset of count items from collection, and places
those items into a random order. No item is selected more than once.
|
| RangeT(IListT, Int32, Int32) |
Returns a view onto a sub-range of a list. Items from list are not copied; the
returned IList<T> is simply a different view onto the same underlying items. Changes to list
are reflected in the view, and vice versa. Insertions and deletions in the view change the size of the
view, but insertions and deletions in the underlying list do not.
|
| RangeT(T, Int32, Int32) |
Returns a view onto a sub-range of an array. Items from array are not copied; the
returned IList<T> is simply a different view onto the same underlying items. Changes to array
are reflected in the view, and vice versa. Insertions and deletions in the view change the size of the
view. After an insertion, the last item in array "falls off the end". After a deletion, the
last item in array becomes the default value (0 or null).
|
| ReadOnlyT(ICollectionT) |
Returns a read-only view onto a collection. The returned ICollection<T> interface
only allows operations that do not change the collection: GetEnumerator, Contains, CopyTo,
Count. The ReadOnly property returns false, indicating that the collection is read-only. All other
methods on the interface throw a NotSupportedException.
|
| ReadOnlyT(IListT) |
Returns a read-only view onto a list. The returned IList<T> interface
only allows operations that do not change the list: GetEnumerator, Contains, CopyTo,
Count, IndexOf, and the get accessor of the indexer.
The IsReadOnly property returns true, indicating that the list is read-only. All other
methods on the interface throw a NotSupportedException.
|
| ReadOnlyTKey, TValue(IDictionaryTKey, TValue) |
Returns a read-only view onto a dictionary. The returned IDictionary<TKey,TValue> interface
only allows operations that do not change the dictionary.
The IsReadOnly property returns true, indicating that the dictionary is read-only. All other
methods on the interface throw a NotSupportedException.
|
| ReadWriteListT | Creates a read-write IList<T> wrapper around an array. When an array is implicitely converted to an IList<T>, changes to the items in the array cannot be made through the interface. This method creates a read-write IList<T> wrapper on an array that can be used to make changes to the array. Use this method when you need to pass an array to an algorithms that takes an IList<T> and that tries to modify items in the list. Algorithms in this class generally do not need this method, since they have been design to operate on arrays even when they are passed as an IList<T>. |
| RemoveDuplicatesT(IEnumerableT) |
Remove consecutive equal items from a collection, yielding another collection. In each run of consecutive equal items
in the collection, all items after the first item in the run are removed.
|
| RemoveDuplicatesT(IEnumerableT, IEqualityComparerT) |
Remove consecutive equal items from a collection, yielding another collection. In each run of consecutive equal items
in the collection, all items after the first item in the run are removed. A passed
IEqualityComparer is used to determine equality.
|
| RemoveDuplicatesT(IEnumerableT, BinaryPredicateT) |
Remove consecutive "equal" items from a collection, yielding another collection. In each run of consecutive equal items
in the collection, all items after the first item in the run are removed. The passed
BinaryPredicate is used to determine if two items are "equal".
|
| RemoveDuplicatesInPlaceT(IListT) |
Remove consecutive equal items from a list or array. In each run of consecutive equal items
in the list, all items after the first item in the run are removed. The removal is done in-place, changing
the list.
|
| RemoveDuplicatesInPlaceT(IListT, IEqualityComparerT) |
Remove subsequent consecutive equal items from a list or array. In each run of consecutive equal items
in the list, all items after the first item in the run are removed.
The replacement is done in-place, changing
the list. A passed IEqualityComparer is used to determine equality.
|
| RemoveDuplicatesInPlaceT(IListT, BinaryPredicateT) |
Remove consecutive "equal" items from a list or array. In each run of consecutive equal items
in the list, all items after the first item in the run are removed. The replacement is done in-place, changing
the list. The passed BinaryPredicate is used to determine if two items are "equal".
|
| RemoveWhereT |
Removes all the items in the collection that satisfy the condition
defined by predicate.
|
| ReplaceT(IEnumerableT, PredicateT, T) |
Replace all items in a collection that a predicate evalues at true with a value, yielding another collection. .
|
| ReplaceT(IEnumerableT, T, T) |
Replace all items in a collection equal to a particular value with another values, yielding another collection.
|
| ReplaceT(IEnumerableT, T, T, IEqualityComparerT) |
Replace all items in a collection equal to a particular value with another values, yielding another collection. A passed
IEqualityComparer is used to determine equality.
|
| ReplaceInPlaceT(IListT, PredicateT, T) |
Replace all items in a list or array that a predicate evaluates at true with a value. The replacement is done in-place, changing
the list.
|
| ReplaceInPlaceT(IListT, T, T) |
Replace all items in a list or array equal to a particular value with another value. The replacement is done in-place, changing
the list.
|
| ReplaceInPlaceT(IListT, T, T, IEqualityComparerT) |
Replace all items in a list or array equal to a particular value with another values.
The replacement is done in-place, changing
the list. A passed IEqualityComparer is used to determine equality.
|
| ReverseT |
Reverses a list and returns the reversed list, without changing the source list.
|
| ReverseInPlaceT |
Reverses a list or array in place.
|
| RotateT |
Rotates a list and returns the rotated list, without changing the source list.
|
| RotateInPlaceT |
Rotates a list or array in place.
|
| SearchForSubsequenceT(IListT, IEnumerableT) |
Searchs a list for a sub-sequence of items that match a particular pattern. A subsequence
of list matches pattern at index i if list[i] is equal to the first item
in pattern, list[i+1] is equal to the second item in pattern,
and so forth for all the items in pattern.
|
| SearchForSubsequenceT(IListT, IEnumerableT, IEqualityComparerT) |
Searchs a list for a sub-sequence of items that match a particular pattern. A subsequence
of list matches pattern at index i if list[i] is equal to the first item
in pattern, list[i+1] is equal to the second item in pattern,
and so forth for all the items in pattern. The passed
instance of IEqualityComparer<T> is used for determining if two items are equal.
|
| SearchForSubsequenceT(IListT, IEnumerableT, BinaryPredicateT) |
Searchs a list for a sub-sequence of items that match a particular pattern. A subsequence
of list matches pattern at index i if list[i] is "equal" to the first item
in pattern, list[i+1] is "equal" to the second item in pattern,
and so forth for all the items in pattern. The passed
BinaryPredicate is used to determine if two items are "equal".
|
| SetDifferenceT(IEnumerableT, IEnumerableT) |
Computes the set-theoretic difference of two collections. The difference of two sets
is all items that appear in the first set, but not in the second. If an item appears X times in the first set,
and Y times in the second set, the difference contains the item X - Y times (0 times if X < Y).
The source collections are not changed.
A new collection is created with the difference of the collections; the order of the
items in this collection is undefined.
|
| SetDifferenceT(IEnumerableT, IEnumerableT, IEqualityComparerT) |
Computes the set-theoretic difference of two collections. The difference of two sets
is all items that appear in the first set, but not in the second. If an item appears X times in the first set,
and Y times in the second set, the difference contains the item X - Y times (0 times if X < Y).
The source collections are not changed.
A new collection is created with the difference of the collections; the order of the
items in this collection is undefined.
|
| SetIntersectionT(IEnumerableT, IEnumerableT) |
Computes the set-theoretic intersection of two collections. The intersection of two sets
is all items that appear in both of the sets. If an item appears X times in one set,
and Y times in the other set, the intersection contains the item Minimum(X,Y) times.
The source collections are not changed.
A new collection is created with the intersection of the collections; the order of the
items in this collection is undefined.
|
| SetIntersectionT(IEnumerableT, IEnumerableT, IEqualityComparerT) |
Computes the set-theoretic intersection of two collections. The intersection of two sets
is all items that appear in both of the sets. If an item appears X times in one set,
and Y times in the other set, the intersection contains the item Minimum(X,Y) times.
The source collections are not changed.
A new collection is created with the intersection of the collections; the order of the
items in this collection is undefined.
|
| SetSymmetricDifferenceT(IEnumerableT, IEnumerableT) |
Computes the set-theoretic symmetric difference of two collections. The symmetric difference of two sets
is all items that appear in the one of the sets, but not in the other. If an item appears X times in the one set,
and Y times in the other set, the symmetric difference contains the item AbsoluteValue(X - Y) times.
The source collections are not changed.
A new collection is created with the symmetric difference of the collections; the order of the
items in this collection is undefined.
|
| SetSymmetricDifferenceT(IEnumerableT, IEnumerableT, IEqualityComparerT) |
Computes the set-theoretic symmetric difference of two collections. The symmetric difference of two sets
is all items that appear in the one of the sets, but not in the other. If an item appears X times in the one set,
and Y times in the other set, the symmetric difference contains the item AbsoluteValue(X - Y) times.
The source collections are not changed.
A new collection is created with the symmetric difference of the collections; the order of the
items in this collection is undefined.
|
| SetUnionT(IEnumerableT, IEnumerableT) |
Computes the set-theoretic union of two collections. The union of two sets
is all items that appear in either of the sets. If an item appears X times in one set,
and Y times in the other set, the union contains the item Maximum(X,Y) times.
The source collections are not changed.
A new collection is created with the union of the collections; the order of the
items in this collection is undefined.
|
| SetUnionT(IEnumerableT, IEnumerableT, IEqualityComparerT) |
Computes the set-theoretic union of two collections. The union of two sets
is all items that appear in either of the sets. If an item appears X times in one set,
and Y times in the other set, the union contains the item Maximum(X,Y) times.
The source collections are not changed.
A new collection is created with the union of the collections; the order of the
items in this collection is undefined.
|
| SortT(IEnumerableT) |
Creates a sorted version of a collection.
|
| SortT(IEnumerableT, IComparerT) |
Creates a sorted version of a collection. A supplied IComparer<T> is used
to compare the items in the collection.
|
| SortT(IEnumerableT, ComparisonT) |
Creates a sorted version of a collection. A supplied Comparison<T> delegate is used
to compare the items in the collection.
|
| SortInPlaceT(IListT) |
Sorts a list or array in place.
|
| SortInPlaceT(IListT, IComparerT) |
Sorts a list or array in place. A supplied IComparer<T> is used
to compare the items in the list.
|
| SortInPlaceT(IListT, ComparisonT) |
Sorts a list or array in place. A supplied Comparison<T> delegate is used
to compare the items in the list.
|
| StablePartitionT |
Partition a list or array based on a predicate. After partitioning, all items for which
the predicate returned true precede all items for which the predicate returned false.
The partition is stable, which means that if items X and Y have the same result from
the predicate, and X precedes Y in the original list, X will precede Y in the
partitioned list.
|
| StableSortT(IEnumerableT) |
Creates a sorted version of a collection. The sort is stable, which means that if items X and Y are equal,
and X precedes Y in the unsorted collection, X will precede Y is the sorted collection.
|
| StableSortT(IEnumerableT, IComparerT) |
Creates a sorted version of a collection. The sort is stable, which means that if items X and Y are equal,
and X precedes Y in the unsorted collection, X will precede Y is the sorted collection. A supplied IComparer<T> is used
to compare the items in the collection.
|
| StableSortT(IEnumerableT, ComparisonT) |
Creates a sorted version of a collection. The sort is stable, which means that if items X and Y are equal,
and X precedes Y in the unsorted collection, X will precede Y is the sorted collection.
A supplied Comparison<T> delegate is used
to compare the items in the collection.
|
| StableSortInPlaceT(IListT) |
Sorts a list or array in place. The sort is stable, which means that if items X and Y are equal,
and X precedes Y in the unsorted collection, X will precede Y is the sorted collection.
|
| StableSortInPlaceT(IListT, IComparerT) |
Sorts a list or array in place. The sort is stable, which means that if items X and Y are equal,
and X precedes Y in the unsorted collection, X will precede Y is the sorted collection.
A supplied IComparer<T> is used
to compare the items in the list.
|
| StableSortInPlaceT(IListT, ComparisonT) |
Sorts a list or array in place. The sort is stable, which means that if items X and Y are equal,
and X precedes Y in the unsorted collection, X will precede Y is the sorted collection.
A supplied Comparison<T> delegate is used
to compare the items in the list.
|
| ToArrayT |
Create an array with the items in a collection.
|
| ToStringT(IEnumerableT) |
Gets a string representation of the elements in the collection.
The string representation starts with "{", has a list of items separated
by commas (","), and ends with "}". Each item in the collection is
converted to a string by calling its ToString method (null is represented by "null").
Contained collections (except strings) are recursively converted to strings by this method.
|
| ToStringT(IEnumerableT, Boolean, String, String, String) |
Gets a string representation of the elements in the collection.
The string to used at the beginning and end, and to separate items,
and supplied by parameters. Each item in the collection is
converted to a string by calling its ToString method (null is represented by "null").
|
| ToStringTKey, TValue(IDictionaryTKey, TValue) |
Gets a string representation of the mappings in a dictionary.
The string representation starts with "{", has a list of mappings separated
by commas (", "), and ends with "}". Each mapping is represented
by "key->value". Each key and value in the dictionary is
converted to a string by calling its ToString method (null is represented by "null").
Contained collections (except strings) are recursively converted to strings by this method.
|
| TrueForAllT |
Determines if all of the items in the collection satisfy the condition
defined by predicate.
|
| TryFindFirstWhereT |
Finds the first item in a collection that satisfies the condition
defined by predicate.
|
| TryFindLastWhereT |
Finds the last item in a collection that satisfies the condition
defined by predicate.
|
| TypedAsT(ICollection) |
Given a non-generic ICollection interface, wrap a generic ICollection<T>
interface around it. The generic interface will enumerate the same objects as the
underlying non-generic collection, but can be used in places that require a generic interface.
The underlying non-generic collection must contain only items that
are of type T or a type derived from it. This method is useful
when interfacing older, non-generic collections to newer code that uses generic interfaces.
|
| TypedAsT(IEnumerable) |
Given a non-generic IEnumerable interface, wrap a generic IEnumerable<T>
interface around it. The generic interface will enumerate the same objects as the
underlying non-generic collection, but can be used in places that require a generic interface.
The underlying non-generic collection must contain only items that
are of type T or a type derived from it. This method is useful
when interfacing older, non-generic collections to newer code that uses generic interfaces.
|
| TypedAsT(IList) |
Given a non-generic IList interface, wrap a generic IList<T>
interface around it. The generic interface will enumerate the same objects as the
underlying non-generic list, but can be used in places that require a generic interface.
The underlying non-generic list must contain only items that
are of type T or a type derived from it. This method is useful
when interfacing older, non-generic lists to newer code that uses generic interfaces.
|
| UntypedT(ICollectionT) |
Given a generic ICollection<T> interface, wrap a non-generic (untyped)
ICollection interface around it. The non-generic interface will contain the same objects as the
underlying generic collection, but can be used in places that require a non-generic interface.
This method is useful when interfacing generic interfaces with older code that uses non-generic interfaces.
|
| UntypedT(IListT) |
Given a generic IList<T> interface, wrap a non-generic (untyped)
IList interface around it. The non-generic interface will contain the same objects as the
underlying generic list, but can be used in places that require a non-generic interface.
This method is useful when interfacing generic interfaces with older code that uses non-generic interfaces.
|
See Also