SequenceException Events |
The SequenceException type exposes the following members.
Events| + + | Name | Description |
|---|---|---|
 | SerializeObjectState | Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception. (Inherited from Exception.) |
See AlsoMoreEnumerableAcquireTSource Method |
+ Namespace: + MoreLinq
Syntaxpublic static TSource[] Acquire<TSource>( + this IEnumerable<TSource> source +) +where TSource : IDisposable +
RemarksSee AlsoMoreEnumerableAggregateRightTSource Method (IEnumerableTSource, FuncTSource, TSource, TSource) |
+ Namespace: + MoreLinq
Syntaxpublic static TSource AggregateRight<TSource>( + this IEnumerable<TSource> source, + Func<TSource, TSource, TSource> func +) +
RemarksExamplesstring result = Enumerable.Range(1, 5).Select(i => i.ToString()).AggregateRight((a, b) => string.Format("({0}/{1})", a, b));
See AlsoMoreEnumerableAggregateRightTSource, TAccumulate Method (IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate) |
+ Namespace: + MoreLinq
Syntaxpublic static TAccumulate AggregateRight<TSource, TAccumulate>( + this IEnumerable<TSource> source, + TAccumulate seed, + Func<TSource, TAccumulate, TAccumulate> func +) +
RemarksExamplesvar numbers = Enumerable.Range(1, 5); +string result = numbers.AggregateRight("6", (a, b) => string.Format("({0}/{1})", a, b));
See AlsoMoreEnumerableAggregateRightTSource, TAccumulate, TResult Method (IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate, FuncTAccumulate, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult AggregateRight<TSource, TAccumulate, TResult>( + this IEnumerable<TSource> source, + TAccumulate seed, + Func<TSource, TAccumulate, TAccumulate> func, + Func<TAccumulate, TResult> resultSelector +) +
RemarksExamplesvar numbers = Enumerable.Range(1, 5); +int result = numbers.AggregateRight("6", (a, b) => string.Format("({0}/{1})", a, b), str => str.Length);
See AlsoMoreEnumerableAssertCountTSource Method (IEnumerableTSource, Int32) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> AssertCount<TSource>( + this IEnumerable<TSource> source, + int count +) +
RemarksSee AlsoMoreEnumerableAssertCountTSource Method (IEnumerableTSource, Int32, FuncInt32, Int32, Exception) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> AssertCount<TSource>( + this IEnumerable<TSource> source, + int count, + Func<int, int, Exception> errorSelector +) +
RemarksSee AlsoMoreEnumerableAssertTSource Method (IEnumerableTSource, FuncTSource, Boolean) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> Assert<TSource>( + this IEnumerable<TSource> source, + Func<TSource, bool> predicate +) +
Exceptions| Exception | Condition |
|---|---|
| InvalidOperationException | The input sequence + contains an element that does not meet the condition being + asserted. |
RemarksSee AlsoMoreEnumerableAssertTSource Method (IEnumerableTSource, FuncTSource, Boolean, FuncTSource, Exception) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> Assert<TSource>( + this IEnumerable<TSource> source, + Func<TSource, bool> predicate, + Func<TSource, Exception> errorSelector +) +
RemarksSee AlsoMoreEnumerableAtLeastT Method |
+ Namespace: + MoreLinq
SyntaxExceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source is null |
| ArgumentOutOfRangeException | count is negative |
Examplesvar numbers = { 123, 456, 789 }; +var result = numbers.AtLeast(2);
See AlsoMoreEnumerableAtMostT Method |
+ Namespace: + MoreLinq
SyntaxExceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source is null |
| ArgumentOutOfRangeException | count is negative |
Examplesvar numbers = { 123, 456, 789 }; +var result = numbers.AtMost(2);
See AlsoMoreEnumerableBatchTSource Method (IEnumerableTSource, Int32) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<IEnumerable<TSource>> Batch<TSource>( + this IEnumerable<TSource> source, + int size +) +
RemarksSee AlsoMoreEnumerableBatchTSource, TResult Method (IEnumerableTSource, Int32, FuncIEnumerableTSource, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> Batch<TSource, TResult>( + this IEnumerable<TSource> source, + int size, + Func<IEnumerable<TSource>, TResult> resultSelector +) +
RemarksSee AlsoMoreEnumerableCartesianTFirst, TSecond, TResult Method |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> Cartesian<TFirst, TSecond, TResult>( + this IEnumerable<TFirst> first, + IEnumerable<TSecond> second, + Func<TFirst, TSecond, TResult> resultSelector +) +
See AlsoMoreEnumerableConcatT Method (IEnumerableT, T) |
+ Namespace: + MoreLinq
SyntaxRemarksSee AlsoMoreEnumerableConcatT Method (T, IEnumerableT) |
+ Namespace: + MoreLinq
SyntaxRemarksSee AlsoMoreEnumerableConsumeT Method |
+ Namespace: + MoreLinq
SyntaxSee AlsoMoreEnumerableCountBetweenT Method |
+ Namespace: + MoreLinq
Syntaxpublic static bool CountBetween<T>( + this IEnumerable<T> source, + int min, + int max +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source is null |
| ArgumentOutOfRangeException | min is negative or max is less than min |
Examplesvar numbers = { 123, 456, 789 }; +var result = numbers.CountBetween(1, 2);
See AlsoMoreEnumerableCountByTSource, TKey Method (IEnumerableTSource, FuncTSource, TKey) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<KeyValuePair<TKey, int>> CountBy<TSource, TKey>( + this IEnumerable<TSource> source, + Func<TSource, TKey> keySelector +) +
See AlsoMoreEnumerableCountByTSource, TKey Method (IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<KeyValuePair<TKey, int>> CountBy<TSource, TKey>( + this IEnumerable<TSource> source, + Func<TSource, TKey> keySelector, + IEqualityComparer<TKey> comparer +) +
See AlsoMoreEnumerableDistinctByTSource, TKey Method (IEnumerableTSource, FuncTSource, TKey) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> DistinctBy<TSource, TKey>( + this IEnumerable<TSource> source, + Func<TSource, TKey> keySelector +) +
RemarksSee AlsoMoreEnumerableDistinctByTSource, TKey Method (IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> DistinctBy<TSource, TKey>( + this IEnumerable<TSource> source, + Func<TSource, TKey> keySelector, + IEqualityComparer<TKey> comparer +) +
RemarksSee AlsoMoreEnumerableEndsWithT Method (IEnumerableT, IEnumerableT) |
+ Namespace: + MoreLinq
Syntaxpublic static bool EndsWith<T>( + this IEnumerable<T> first, + IEnumerable<T> second +) +
RemarksSee AlsoMoreEnumerableEndsWithT Method (IEnumerableT, IEnumerableT, IEqualityComparerT) |
+ Namespace: + MoreLinq
Syntaxpublic static bool EndsWith<T>( + this IEnumerable<T> first, + IEnumerable<T> second, + IEqualityComparer<T> comparer +) +
RemarksSee AlsoMoreEnumerableEquiZipTFirst, TSecond, TResult Method (IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> EquiZip<TFirst, TSecond, TResult>( + this IEnumerable<TFirst> first, + IEnumerable<TSecond> second, + Func<TFirst, TSecond, TResult> resultSelector +) +
RemarksExamplesint[] numbers = { 1, 2, 3, 4 }; +string[] letters = { "A", "B", "C", "D" }; +var zipped = numbers.EquiZip(letters, (n, l) => n + l);
See AlsoMoreEnumerableEquiZipT1, T2, T3, TResult Method (IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> EquiZip<T1, T2, T3, TResult>( + this IEnumerable<T1> first, + IEnumerable<T2> second, + IEnumerable<T3> third, + Func<T1, T2, T3, TResult> resultSelector +) +
RemarksExamplesvar numbers = { 1, 2, 3, 4 }; +var letters = { "A", "B", "C", "D" }; +var chars = { 'a', 'b', 'c', 'd' }; +var zipped = numbers.EquiZip(letters, chars, (n, l, c) => n + l + c);
See AlsoMoreEnumerableEquiZipT1, T2, T3, T4, TResult Method (IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, TResult>( + this IEnumerable<T1> first, + IEnumerable<T2> second, + IEnumerable<T3> third, + IEnumerable<T4> fourth, + Func<T1, T2, T3, T4, TResult> resultSelector +) +
RemarksExamplesvar numbers = { 1, 2, 3, 4 }; +var letters = { "A", "B", "C", "D" }; +var chars = { 'a', 'b', 'c', 'd' }; +var flags = { true, false, true, false }; +var zipped = numbers.EquiZip(letters, chars, flags, (n, l, c, f) => n + l + c + f);
See AlsoMoreEnumerableEvaluateT Method |
+ Namespace: + MoreLinq
SyntaxExceptions| Exception | Condition |
|---|---|
| ArgumentNullException | When functions is null. |
RemarksSee AlsoMoreEnumerableExactlyT Method |
+ Namespace: + MoreLinq
SyntaxExceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source is null |
| ArgumentOutOfRangeException | count is negative |
Examplesvar numbers = { 123, 456, 789 }; +var result = numbers.Exactly(3);
See AlsoMoreEnumerableExceptByTSource, TKey Method (IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> ExceptBy<TSource, TKey>( + this IEnumerable<TSource> first, + IEnumerable<TSource> second, + Func<TSource, TKey> keySelector +) +
RemarksSee AlsoMoreEnumerableExceptByTSource, TKey Method (IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> ExceptBy<TSource, TKey>( + this IEnumerable<TSource> first, + IEnumerable<TSource> second, + Func<TSource, TKey> keySelector, + IEqualityComparer<TKey> keyComparer +) +
RemarksSee AlsoMoreEnumerableExcludeT Method |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> Exclude<T>( + this IEnumerable<T> sequence, + int startIndex, + int count +) +
See AlsoMoreEnumerableFallbackIfEmptyT Method (IEnumerableT, IEnumerableT) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> FallbackIfEmpty<T>( + this IEnumerable<T> source, + IEnumerable<T> fallback +) +
See AlsoMoreEnumerableFallbackIfEmptyT Method (IEnumerableT, T) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> FallbackIfEmpty<T>( + this IEnumerable<T> source, + T fallback +) +
Examplesvar numbers = { 123, 456, 789 }; +var result = numbers.Where(x => x == 100).FallbackIfEmpty(-1).Single();
See AlsoMoreEnumerableFallbackIfEmptyT Method (IEnumerableT, T, T) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> FallbackIfEmpty<T>( + this IEnumerable<T> source, + T fallback1, + T fallback2 +) +
See AlsoMoreEnumerableFallbackIfEmptyT Method (IEnumerableT, T, T, T) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> FallbackIfEmpty<T>( + this IEnumerable<T> source, + T fallback1, + T fallback2, + T fallback3 +) +
See AlsoMoreEnumerableFallbackIfEmptyT Method (IEnumerableT, T, T, T, T) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> FallbackIfEmpty<T>( + this IEnumerable<T> source, + T fallback1, + T fallback2, + T fallback3, + T fallback4 +) +
See AlsoMoreEnumerableFallbackIfEmptyT Method (IEnumerableT, T) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> FallbackIfEmpty<T>( + this IEnumerable<T> source, + params T[] fallback +) +
See AlsoMoreEnumerableFillBackwardT Method (IEnumerableT) |
+ Namespace: + MoreLinq
SyntaxRemarksSee AlsoMoreEnumerableFillBackwardT Method (IEnumerableT, FuncT, Boolean) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> FillBackward<T>( + this IEnumerable<T> source, + Func<T, bool> predicate +) +
RemarksSee AlsoMoreEnumerableFillBackwardT Method (IEnumerableT, FuncT, Boolean, FuncT, T, T) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> FillBackward<T>( + this IEnumerable<T> source, + Func<T, bool> predicate, + Func<T, T, T> fillSelector +) +
RemarksSee AlsoMoreEnumerableFillForwardT Method (IEnumerableT) |
+ Namespace: + MoreLinq
SyntaxRemarksSee AlsoMoreEnumerableFillForwardT Method (IEnumerableT, FuncT, Boolean) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> FillForward<T>( + this IEnumerable<T> source, + Func<T, bool> predicate +) +
RemarksSee AlsoMoreEnumerableFillForwardT Method (IEnumerableT, FuncT, Boolean, FuncT, T, T) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> FillForward<T>( + this IEnumerable<T> source, + Func<T, bool> predicate, + Func<T, T, T> fillSelector +) +
RemarksSee AlsoMoreEnumerableFlatten Method (IEnumerable) |
+ Namespace: + MoreLinq
SyntaxExceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source is null. |
See AlsoMoreEnumerableFlatten Method (IEnumerable, FuncIEnumerable, Boolean) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<Object> Flatten( + this IEnumerable source, + Func<IEnumerable, bool> predicate +)
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source is null. |
| ArgumentNullException | predicate is null. |
See AlsoMoreEnumerableFoldT, TResult Method (IEnumerableT, FuncT, T, T, T, T, T, T, T, T, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult Fold<T, TResult>( + this IEnumerable<T> source, + Func<T, T, T, T, T, T, T, T, T, TResult> folder +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source is null |
| ArgumentNullException | folder is null |
| InvalidOperationException | source does not contain exactly 9 elements |
RemarksSee AlsoMoreEnumerableFoldT, TResult Method (IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult Fold<T, TResult>( + this IEnumerable<T> source, + Func<T, T, T, T, T, T, T, T, T, T, TResult> folder +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source is null |
| ArgumentNullException | folder is null |
| InvalidOperationException | source does not contain exactly 10 elements |
RemarksSee AlsoMoreEnumerableFoldT, TResult Method (IEnumerableT, FuncT, T, T, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult Fold<T, TResult>( + this IEnumerable<T> source, + Func<T, T, T, TResult> folder +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source is null |
| ArgumentNullException | folder is null |
| InvalidOperationException | source does not contain exactly 3 elements |
RemarksSee AlsoMoreEnumerableFoldT, TResult Method (IEnumerableT, FuncT, T, T, T, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult Fold<T, TResult>( + this IEnumerable<T> source, + Func<T, T, T, T, TResult> folder +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source is null |
| ArgumentNullException | folder is null |
| InvalidOperationException | source does not contain exactly 4 elements |
RemarksSee AlsoMoreEnumerableFoldT, TResult Method (IEnumerableT, FuncT, T, T, T, T, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult Fold<T, TResult>( + this IEnumerable<T> source, + Func<T, T, T, T, T, TResult> folder +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source is null |
| ArgumentNullException | folder is null |
| InvalidOperationException | source does not contain exactly 5 elements |
RemarksSee AlsoMoreEnumerableFoldT, TResult Method (IEnumerableT, FuncT, T, T, T, T, T, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult Fold<T, TResult>( + this IEnumerable<T> source, + Func<T, T, T, T, T, T, TResult> folder +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source is null |
| ArgumentNullException | folder is null |
| InvalidOperationException | source does not contain exactly 6 elements |
RemarksSee AlsoMoreEnumerableFoldT, TResult Method (IEnumerableT, FuncT, T, T, T, T, T, T, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult Fold<T, TResult>( + this IEnumerable<T> source, + Func<T, T, T, T, T, T, T, TResult> folder +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source is null |
| ArgumentNullException | folder is null |
| InvalidOperationException | source does not contain exactly 7 elements |
RemarksSee AlsoMoreEnumerableFoldT, TResult Method (IEnumerableT, FuncT, T, T, T, T, T, T, T, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult Fold<T, TResult>( + this IEnumerable<T> source, + Func<T, T, T, T, T, T, T, T, TResult> folder +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source is null |
| ArgumentNullException | folder is null |
| InvalidOperationException | source does not contain exactly 8 elements |
RemarksSee AlsoMoreEnumerableFoldT, TResult Method (IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult Fold<T, TResult>( + this IEnumerable<T> source, + Func<T, T, T, T, T, T, T, T, T, T, T, TResult> folder +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source is null |
| ArgumentNullException | folder is null |
| InvalidOperationException | source does not contain exactly 11 elements |
RemarksSee AlsoMoreEnumerableFoldT, TResult Method (IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult Fold<T, TResult>( + this IEnumerable<T> source, + Func<T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source is null |
| ArgumentNullException | folder is null |
| InvalidOperationException | source does not contain exactly 12 elements |
RemarksSee AlsoMoreEnumerableFoldT, TResult Method (IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult Fold<T, TResult>( + this IEnumerable<T> source, + Func<T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source is null |
| ArgumentNullException | folder is null |
| InvalidOperationException | source does not contain exactly 13 elements |
RemarksSee AlsoMoreEnumerableFoldT, TResult Method (IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult Fold<T, TResult>( + this IEnumerable<T> source, + Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source is null |
| ArgumentNullException | folder is null |
| InvalidOperationException | source does not contain exactly 14 elements |
RemarksSee AlsoMoreEnumerableFoldT, TResult Method (IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult Fold<T, TResult>( + this IEnumerable<T> source, + Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source is null |
| ArgumentNullException | folder is null |
| InvalidOperationException | source does not contain exactly 15 elements |
RemarksSee AlsoMoreEnumerableFoldT, TResult Method (IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult Fold<T, TResult>( + this IEnumerable<T> source, + Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source is null |
| ArgumentNullException | folder is null |
| InvalidOperationException | source does not contain exactly 16 elements |
RemarksSee AlsoMoreEnumerableFoldT, TResult Method (IEnumerableT, FuncT, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult Fold<T, TResult>( + this IEnumerable<T> source, + Func<T, TResult> folder +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source is null |
| ArgumentNullException | folder is null |
| InvalidOperationException | source does not contain exactly 1 element |
RemarksSee AlsoMoreEnumerableFoldT, TResult Method (IEnumerableT, FuncT, T, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult Fold<T, TResult>( + this IEnumerable<T> source, + Func<T, T, TResult> folder +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source is null |
| ArgumentNullException | folder is null |
| InvalidOperationException | source does not contain exactly 2 elements |
RemarksSee AlsoMoreEnumerableForEachT Method (IEnumerableT, ActionT) |
+ Namespace: + MoreLinq
SyntaxSee AlsoMoreEnumerableForEachT Method (IEnumerableT, ActionT, Int32) |
+ Namespace: + MoreLinq
Syntaxpublic static void ForEach<T>( + this IEnumerable<T> source, + Action<T, int> action +) +
See AlsoMoreEnumerableFromT Method (FuncT) |
+ Namespace: + MoreLinq
SyntaxRemarksSee AlsoMoreEnumerableFromT Method (FuncT, FuncT) |
+ Namespace: + MoreLinq
SyntaxRemarksSee AlsoMoreEnumerableFromT Method (FuncT, FuncT, FuncT) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> From<T>( + Func<T> function1, + Func<T> function2, + Func<T> function3 +) +
RemarksSee AlsoMoreEnumerableFromT Method (FuncT) |
+ Namespace: + MoreLinq
SyntaxExceptions| Exception | Condition |
|---|---|
| ArgumentNullException | When functions is null. |
RemarksSee AlsoMoreEnumerableFullGroupJoinTFirst, TSecond, TKey Method (IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<ValueTuple<TKey, IEnumerable<TFirst>, IEnumerable<TSecond>>> FullGroupJoin<TFirst, TSecond, TKey>( + this IEnumerable<TFirst> first, + IEnumerable<TSecond> second, + Func<TFirst, TKey> firstKeySelector, + Func<TSecond, TKey> secondKeySelector +) +
RemarksSee AlsoMoreEnumerableFullGroupJoinTFirst, TSecond, TKey Method (IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, IEqualityComparerTKey) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<ValueTuple<TKey, IEnumerable<TFirst>, IEnumerable<TSecond>>> FullGroupJoin<TFirst, TSecond, TKey>( + this IEnumerable<TFirst> first, + IEnumerable<TSecond> second, + Func<TFirst, TKey> firstKeySelector, + Func<TSecond, TKey> secondKeySelector, + IEqualityComparer<TKey> comparer +) +
RemarksSee AlsoMoreEnumerableFullGroupJoinTFirst, TSecond, TKey, TResult Method (IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTKey, IEnumerableTFirst, IEnumerableTSecond, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> FullGroupJoin<TFirst, TSecond, TKey, TResult>( + this IEnumerable<TFirst> first, + IEnumerable<TSecond> second, + Func<TFirst, TKey> firstKeySelector, + Func<TSecond, TKey> secondKeySelector, + Func<TKey, IEnumerable<TFirst>, IEnumerable<TSecond>, TResult> resultSelector +) +
RemarksSee AlsoMoreEnumerableFullGroupJoinTFirst, TSecond, TKey, TResult Method (IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTKey, IEnumerableTFirst, IEnumerableTSecond, TResult, IEqualityComparerTKey) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> FullGroupJoin<TFirst, TSecond, TKey, TResult>( + this IEnumerable<TFirst> first, + IEnumerable<TSecond> second, + Func<TFirst, TKey> firstKeySelector, + Func<TSecond, TKey> secondKeySelector, + Func<TKey, IEnumerable<TFirst>, IEnumerable<TSecond>, TResult> resultSelector, + IEqualityComparer<TKey> comparer +) +
RemarksSee AlsoMoreEnumerableFullJoinTSource, TKey, TResult Method (IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TResult, FuncTSource, TSource, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> FullJoin<TSource, TKey, TResult>( + this IEnumerable<TSource> first, + IEnumerable<TSource> second, + Func<TSource, TKey> keySelector, + Func<TSource, TResult> firstSelector, + Func<TSource, TResult> secondSelector, + Func<TSource, TSource, TResult> bothSelector +) +
See AlsoMoreEnumerableFullJoinTSource, TKey, TResult Method (IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TResult, FuncTSource, TSource, TResult, IEqualityComparerTKey) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> FullJoin<TSource, TKey, TResult>( + this IEnumerable<TSource> first, + IEnumerable<TSource> second, + Func<TSource, TKey> keySelector, + Func<TSource, TResult> firstSelector, + Func<TSource, TResult> secondSelector, + Func<TSource, TSource, TResult> bothSelector, + IEqualityComparer<TKey> comparer +) +
See AlsoMoreEnumerableFullJoinTFirst, TSecond, TKey, TResult Method (IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> FullJoin<TFirst, TSecond, TKey, TResult>( + this IEnumerable<TFirst> first, + IEnumerable<TSecond> second, + Func<TFirst, TKey> firstKeySelector, + Func<TSecond, TKey> secondKeySelector, + Func<TFirst, TResult> firstSelector, + Func<TSecond, TResult> secondSelector, + Func<TFirst, TSecond, TResult> bothSelector +) +
See AlsoMoreEnumerableFullJoinTFirst, TSecond, TKey, TResult Method (IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult, IEqualityComparerTKey) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> FullJoin<TFirst, TSecond, TKey, TResult>( + this IEnumerable<TFirst> first, + IEnumerable<TSecond> second, + Func<TFirst, TKey> firstKeySelector, + Func<TSecond, TKey> secondKeySelector, + Func<TFirst, TResult> firstSelector, + Func<TSecond, TResult> secondSelector, + Func<TFirst, TSecond, TResult> bothSelector, + IEqualityComparer<TKey> comparer +) +
See AlsoMoreEnumerableGenerateByIndexTResult Method |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> GenerateByIndex<TResult>( + Func<int, TResult> generator +) +
RemarksSee AlsoMoreEnumerableGenerateTResult Method |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> Generate<TResult>( + TResult initial, + Func<TResult, TResult> generator +) +
RemarksExamplesIEnumerable<int> result = Sequence.Generate(2, n => n * n).Take(5);
See AlsoMoreEnumerableGroupAdjacentTSource, TKey Method (IEnumerableTSource, FuncTSource, TKey) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<IGrouping<TKey, TSource>> GroupAdjacent<TSource, TKey>( + this IEnumerable<TSource> source, + Func<TSource, TKey> keySelector +) +
RemarksSee AlsoMoreEnumerableGroupAdjacentTSource, TKey Method (IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<IGrouping<TKey, TSource>> GroupAdjacent<TSource, TKey>( + this IEnumerable<TSource> source, + Func<TSource, TKey> keySelector, + IEqualityComparer<TKey> comparer +) +
RemarksSee AlsoMoreEnumerableGroupAdjacentTSource, TKey, TElement Method (IEnumerableTSource, FuncTSource, TKey, FuncTSource, TElement) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<IGrouping<TKey, TElement>> GroupAdjacent<TSource, TKey, TElement>( + this IEnumerable<TSource> source, + Func<TSource, TKey> keySelector, + Func<TSource, TElement> elementSelector +) +
RemarksSee AlsoMoreEnumerableGroupAdjacentTSource, TKey, TElement Method (IEnumerableTSource, FuncTSource, TKey, FuncTSource, TElement, IEqualityComparerTKey) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<IGrouping<TKey, TElement>> GroupAdjacent<TSource, TKey, TElement>( + this IEnumerable<TSource> source, + Func<TSource, TKey> keySelector, + Func<TSource, TElement> elementSelector, + IEqualityComparer<TKey> comparer +) +
RemarksSee AlsoMoreEnumerableGroupAdjacentTSource, TKey, TResult Method (IEnumerableTSource, FuncTSource, TKey, FuncTKey, IEnumerableTSource, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> GroupAdjacent<TSource, TKey, TResult>( + this IEnumerable<TSource> source, + Func<TSource, TKey> keySelector, + Func<TKey, IEnumerable<TSource>, TResult> resultSelector +) +
RemarksSee AlsoMoreEnumerableGroupAdjacentTSource, TKey, TResult Method (IEnumerableTSource, FuncTSource, TKey, FuncTKey, IEnumerableTSource, TResult, IEqualityComparerTKey) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> GroupAdjacent<TSource, TKey, TResult>( + this IEnumerable<TSource> source, + Func<TSource, TKey> keySelector, + Func<TKey, IEnumerable<TSource>, TResult> resultSelector, + IEqualityComparer<TKey> comparer +) +
RemarksSee AlsoMoreEnumerableIncrementalTSource, TResult Method (IEnumerableTSource, FuncTSource, TSource, TResult) |
Note: This API is now obsolete.
+ Namespace: + MoreLinq
Syntax[ObsoleteAttribute("Use Pairwise instead, which is identical to Incremental. Incremental will be removed in a future version.")] +public static IEnumerable<TResult> Incremental<TSource, TResult>( + this IEnumerable<TSource> sequence, + Func<TSource, TSource, TResult> resultSelector +) +
RemarksSee AlsoMoreEnumerableIncrementalTSource, TResult Method (IEnumerableTSource, FuncTSource, TSource, Int32, TResult) |
Note: This API is now obsolete.
+ Namespace: + MoreLinq
Syntax[ObsoleteAttribute("Use Index with Pairwise instead.Incremental will be removed in a future version.")] +public static IEnumerable<TResult> Incremental<TSource, TResult>( + this IEnumerable<TSource> sequence, + Func<TSource, TSource, int, TResult> resultSelector +) +
RemarksSee AlsoMoreEnumerableIndexTSource Method (IEnumerableTSource) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<KeyValuePair<int, TSource>> Index<TSource>( + this IEnumerable<TSource> source +) +
RemarksSee AlsoMoreEnumerableIndexTSource Method (IEnumerableTSource, Int32) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<KeyValuePair<int, TSource>> Index<TSource>( + this IEnumerable<TSource> source, + int startIndex +) +
RemarksSee AlsoMoreEnumerableInsertT Method |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> Insert<T>( + this IEnumerable<T> first, + IEnumerable<T> second, + int index +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | first is null. |
| ArgumentNullException | second is null. |
| ArgumentOutOfRangeException | + Thrown if index is negative. + |
| ArgumentOutOfRangeException | + Thrown lazily if index is greater than the + length of first. The validation occurs when + yielding the next element after having iterated + first entirely. + |
See AlsoMoreEnumerableInterleaveT Method |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> Interleave<T>( + this IEnumerable<T> sequence, + params IEnumerable<T>[] otherSequences +) +
Remarks
{1,1,1}.Interleave( {2,2,2}, {3,3,3} ) => { 1,2,3,1,2,3,1,2,3 }See AlsoMoreEnumerableLagTSource, TResult Method (IEnumerableTSource, Int32, FuncTSource, TSource, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> Lag<TSource, TResult>( + this IEnumerable<TSource> source, + int offset, + Func<TSource, TSource, TResult> resultSelector +) +
RemarksSee AlsoMoreEnumerableLagTSource, TResult Method (IEnumerableTSource, Int32, TSource, FuncTSource, TSource, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> Lag<TSource, TResult>( + this IEnumerable<TSource> source, + int offset, + TSource defaultLagValue, + Func<TSource, TSource, TResult> resultSelector +) +
RemarksSee AlsoMoreEnumerableLeadTSource, TResult Method (IEnumerableTSource, Int32, FuncTSource, TSource, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> Lead<TSource, TResult>( + this IEnumerable<TSource> source, + int offset, + Func<TSource, TSource, TResult> resultSelector +) +
RemarksSee AlsoMoreEnumerableLeadTSource, TResult Method (IEnumerableTSource, Int32, TSource, FuncTSource, TSource, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> Lead<TSource, TResult>( + this IEnumerable<TSource> source, + int offset, + TSource defaultLeadValue, + Func<TSource, TSource, TResult> resultSelector +) +
RemarksSee AlsoMoreEnumerableLeftJoinTSource, TKey, TResult Method (IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TSource, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> LeftJoin<TSource, TKey, TResult>( + this IEnumerable<TSource> first, + IEnumerable<TSource> second, + Func<TSource, TKey> keySelector, + Func<TSource, TResult> firstSelector, + Func<TSource, TSource, TResult> bothSelector +) +
See AlsoMoreEnumerableLeftJoinTSource, TKey, TResult Method (IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TSource, TResult, IEqualityComparerTKey) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> LeftJoin<TSource, TKey, TResult>( + this IEnumerable<TSource> first, + IEnumerable<TSource> second, + Func<TSource, TKey> keySelector, + Func<TSource, TResult> firstSelector, + Func<TSource, TSource, TResult> bothSelector, + IEqualityComparer<TKey> comparer +) +
See AlsoMoreEnumerableLeftJoinTFirst, TSecond, TKey, TResult Method (IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTFirst, TSecond, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> LeftJoin<TFirst, TSecond, TKey, TResult>( + this IEnumerable<TFirst> first, + IEnumerable<TSecond> second, + Func<TFirst, TKey> firstKeySelector, + Func<TSecond, TKey> secondKeySelector, + Func<TFirst, TResult> firstSelector, + Func<TFirst, TSecond, TResult> bothSelector +) +
See AlsoMoreEnumerableLeftJoinTFirst, TSecond, TKey, TResult Method (IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTFirst, TSecond, TResult, IEqualityComparerTKey) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> LeftJoin<TFirst, TSecond, TKey, TResult>( + this IEnumerable<TFirst> first, + IEnumerable<TSecond> second, + Func<TFirst, TKey> firstKeySelector, + Func<TSecond, TKey> secondKeySelector, + Func<TFirst, TResult> firstSelector, + Func<TFirst, TSecond, TResult> bothSelector, + IEqualityComparer<TKey> comparer +) +
See AlsoMoreEnumerableMaxByTSource, TKey Method (IEnumerableTSource, FuncTSource, TKey) |
+ Namespace: + MoreLinq
Syntaxpublic static TSource MaxBy<TSource, TKey>( + this IEnumerable<TSource> source, + Func<TSource, TKey> selector +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source or selector is null |
| InvalidOperationException | source is empty |
RemarksSee AlsoMoreEnumerableMaxByTSource, TKey Method (IEnumerableTSource, FuncTSource, TKey, IComparerTKey) |
+ Namespace: + MoreLinq
Syntaxpublic static TSource MaxBy<TSource, TKey>( + this IEnumerable<TSource> source, + Func<TSource, TKey> selector, + IComparer<TKey> comparer +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source, selector + or comparer is null |
| InvalidOperationException | source is empty |
RemarksSee AlsoMoreEnumerableMinByTSource, TKey Method (IEnumerableTSource, FuncTSource, TKey) |
+ Namespace: + MoreLinq
Syntaxpublic static TSource MinBy<TSource, TKey>( + this IEnumerable<TSource> source, + Func<TSource, TKey> selector +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source or selector is null |
| InvalidOperationException | source is empty |
RemarksSee AlsoMoreEnumerableMinByTSource, TKey Method (IEnumerableTSource, FuncTSource, TKey, IComparerTKey) |
+ Namespace: + MoreLinq
Syntaxpublic static TSource MinBy<TSource, TKey>( + this IEnumerable<TSource> source, + Func<TSource, TKey> selector, + IComparer<TKey> comparer +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source, selector + or comparer is null |
| InvalidOperationException | source is empty |
RemarksSee AlsoMoreEnumerableMoveT Method |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> Move<T>( + this IEnumerable<T> source, + int fromIndex, + int count, + int toIndex +) +
RemarksExamplesvar result = Enumerable.Range(0, 6).Move(3, 2, 0);
See AlsoMoreEnumerableNestedLoops Method |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<Action> NestedLoops( + this Action action, + IEnumerable<int> loopCounts +)
See AlsoMoreEnumerableOrderByT, TKey Method (IEnumerableT, FuncT, TKey, OrderByDirection) |
+ Namespace: + MoreLinq
Syntaxpublic static IOrderedEnumerable<T> OrderBy<T, TKey>( + this IEnumerable<T> source, + Func<T, TKey> keySelector, + OrderByDirection direction +) +
See AlsoMoreEnumerableOrderByT, TKey Method (IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection) |
+ Namespace: + MoreLinq
Syntaxpublic static IOrderedEnumerable<T> OrderBy<T, TKey>( + this IEnumerable<T> source, + Func<T, TKey> keySelector, + IComparer<TKey> comparer, + OrderByDirection direction +) +
See AlsoMoreEnumerableOrderedMergeT Method (IEnumerableT, IEnumerableT) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> OrderedMerge<T>( + this IEnumerable<T> first, + IEnumerable<T> second +) +
RemarksSee AlsoMoreEnumerableOrderedMergeT Method (IEnumerableT, IEnumerableT, IComparerT) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> OrderedMerge<T>( + this IEnumerable<T> first, + IEnumerable<T> second, + IComparer<T> comparer +) +
RemarksSee AlsoMoreEnumerableOrderedMergeT, TKey Method (IEnumerableT, IEnumerableT, FuncT, TKey) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> OrderedMerge<T, TKey>( + this IEnumerable<T> first, + IEnumerable<T> second, + Func<T, TKey> keySelector +) +
RemarksSee AlsoMoreEnumerableOrderedMergeT, TKey, TResult Method (IEnumerableT, IEnumerableT, FuncT, TKey, FuncT, TResult, FuncT, TResult, FuncT, T, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> OrderedMerge<T, TKey, TResult>( + this IEnumerable<T> first, + IEnumerable<T> second, + Func<T, TKey> keySelector, + Func<T, TResult> firstSelector, + Func<T, TResult> secondSelector, + Func<T, T, TResult> bothSelector +) +
RemarksSee AlsoMoreEnumerableOrderedMergeT, TKey, TResult Method (IEnumerableT, IEnumerableT, FuncT, TKey, FuncT, TResult, FuncT, TResult, FuncT, T, TResult, IComparerTKey) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> OrderedMerge<T, TKey, TResult>( + this IEnumerable<T> first, + IEnumerable<T> second, + Func<T, TKey> keySelector, + Func<T, TResult> firstSelector, + Func<T, TResult> secondSelector, + Func<T, T, TResult> bothSelector, + IComparer<TKey> comparer +) +
RemarksSee AlsoMoreEnumerableOrderedMergeTFirst, TSecond, TKey, TResult Method (IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> OrderedMerge<TFirst, TSecond, TKey, TResult>( + this IEnumerable<TFirst> first, + IEnumerable<TSecond> second, + Func<TFirst, TKey> firstKeySelector, + Func<TSecond, TKey> secondKeySelector, + Func<TFirst, TResult> firstSelector, + Func<TSecond, TResult> secondSelector, + Func<TFirst, TSecond, TResult> bothSelector +) +
RemarksSee AlsoMoreEnumerableOrderedMergeTFirst, TSecond, TKey, TResult Method (IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult, IComparerTKey) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> OrderedMerge<TFirst, TSecond, TKey, TResult>( + this IEnumerable<TFirst> first, + IEnumerable<TSecond> second, + Func<TFirst, TKey> firstKeySelector, + Func<TSecond, TKey> secondKeySelector, + Func<TFirst, TResult> firstSelector, + Func<TSecond, TResult> secondSelector, + Func<TFirst, TSecond, TResult> bothSelector, + IComparer<TKey> comparer +) +
RemarksSee AlsoMoreEnumerablePadStartTSource Method (IEnumerableTSource, Int32) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> PadStart<TSource>( + this IEnumerable<TSource> source, + int width +) +
RemarksExamplesint[] numbers = { 123, 456, 789 }; +var result = numbers.PadLeft(5);
See AlsoMoreEnumerablePadStartTSource Method (IEnumerableTSource, Int32, FuncInt32, TSource) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> PadStart<TSource>( + this IEnumerable<TSource> source, + int width, + Func<int, TSource> paddingSelector +) +
RemarksExamplesint[] numbers = { 123, 456, 789 }; +var result = numbers.PadLeft(6, i => -i);
See AlsoMoreEnumerablePadStartTSource Method (IEnumerableTSource, Int32, TSource) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> PadStart<TSource>( + this IEnumerable<TSource> source, + int width, + TSource padding +) +
RemarksExamplesint[] numbers = { 123, 456, 789 }; +var result = numbers.PadLeft(5, -1);
See AlsoMoreEnumerablePadTSource Method (IEnumerableTSource, Int32) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> Pad<TSource>( + this IEnumerable<TSource> source, + int width +) +
RemarksExamplesint[] numbers = { 123, 456, 789 }; +IEnumerable<int> result = numbers.Pad(5);
See AlsoMoreEnumerablePadTSource Method (IEnumerableTSource, Int32, FuncInt32, TSource) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> Pad<TSource>( + this IEnumerable<TSource> source, + int width, + Func<int, TSource> paddingSelector +) +
RemarksExamplesint[] numbers = { 0, 1, 2 }; +IEnumerable<int> result = numbers.Pad(5, i => -i);
See AlsoMoreEnumerablePadTSource Method (IEnumerableTSource, Int32, TSource) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> Pad<TSource>( + this IEnumerable<TSource> source, + int width, + TSource padding +) +
RemarksExamplesint[] numbers = { 123, 456, 789 }; +IEnumerable<int> result = numbers.Pad(5, -1);
See AlsoMoreEnumerablePairwiseTSource, TResult Method |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> Pairwise<TSource, TResult>( + this IEnumerable<TSource> source, + Func<TSource, TSource, TResult> resultSelector +) +
RemarksExamplesint[] numbers = { 123, 456, 789 }; +IEnumerable<int> result = numbers.Pairwise((a, b) => a + b);
See AlsoMoreEnumerablePartialSortByTSource, TKey Method (IEnumerableTSource, Int32, FuncTSource, TKey) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> PartialSortBy<TSource, TKey>( + this IEnumerable<TSource> source, + int count, + Func<TSource, TKey> keySelector +) +
RemarksSee AlsoMoreEnumerablePartialSortByTSource, TKey Method (IEnumerableTSource, Int32, FuncTSource, TKey, OrderByDirection) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> PartialSortBy<TSource, TKey>( + this IEnumerable<TSource> source, + int count, + Func<TSource, TKey> keySelector, + OrderByDirection direction +) +
RemarksSee AlsoMoreEnumerablePartialSortByTSource, TKey Method (IEnumerableTSource, Int32, FuncTSource, TKey, IComparerTKey) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> PartialSortBy<TSource, TKey>( + this IEnumerable<TSource> source, + int count, + Func<TSource, TKey> keySelector, + IComparer<TKey> comparer +) +
RemarksSee AlsoMoreEnumerablePartialSortByTSource, TKey Method (IEnumerableTSource, Int32, FuncTSource, TKey, IComparerTKey, OrderByDirection) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> PartialSortBy<TSource, TKey>( + this IEnumerable<TSource> source, + int count, + Func<TSource, TKey> keySelector, + IComparer<TKey> comparer, + OrderByDirection direction +) +
RemarksSee AlsoMoreEnumerablePartialSortT Method (IEnumerableT, Int32) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> PartialSort<T>( + this IEnumerable<T> source, + int count +) +
RemarksSee AlsoMoreEnumerablePartialSortT Method (IEnumerableT, Int32, OrderByDirection) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> PartialSort<T>( + this IEnumerable<T> source, + int count, + OrderByDirection direction +) +
RemarksSee AlsoMoreEnumerablePartialSortT Method (IEnumerableT, Int32, IComparerT) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> PartialSort<T>( + this IEnumerable<T> source, + int count, + IComparer<T> comparer +) +
RemarksSee AlsoMoreEnumerablePartialSortT Method (IEnumerableT, Int32, IComparerT, OrderByDirection) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> PartialSort<T>( + this IEnumerable<T> source, + int count, + IComparer<T> comparer, + OrderByDirection direction +) +
RemarksSee AlsoMoreEnumerablePartitionT Method (IEnumerableT, FuncT, Boolean) |
+ Namespace: + MoreLinq
Syntaxpublic static ValueTuple<IEnumerable<T>, IEnumerable<T>> Partition<T>( + this IEnumerable<T> source, + Func<T, bool> predicate +) +
Examplesvar (evens, odds) = + Enumerable.Range(0, 10).Partition(x => x % 2 == 0);
See AlsoMoreEnumerablePartitionT, TResult Method (IEnumerableIGroupingBoolean, T, FuncIEnumerableT, IEnumerableT, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult Partition<T, TResult>( + this IEnumerable<IGrouping<bool, T>> source, + Func<IEnumerable<T>, IEnumerable<T>, TResult> resultSelector +) +
See AlsoMoreEnumerablePartitionT, TResult Method (IEnumerableIGroupingNullableBoolean, T, FuncIEnumerableT, IEnumerableT, IEnumerableT, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult Partition<T, TResult>( + this IEnumerable<IGrouping<Nullable<bool>, T>> source, + Func<IEnumerable<T>, IEnumerable<T>, IEnumerable<T>, TResult> resultSelector +) +
See AlsoMoreEnumerablePartitionT, TResult Method (IEnumerableT, FuncT, Boolean, FuncIEnumerableT, IEnumerableT, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult Partition<T, TResult>( + this IEnumerable<T> source, + Func<T, bool> predicate, + Func<IEnumerable<T>, IEnumerable<T>, TResult> resultSelector +) +
Examplesvar (evens, odds) = + Enumerable.Range(0, 10) + .Partition(x => x % 2 == 0, ValueTuple.Create);
See AlsoMoreEnumerablePartitionTKey, TElement, TResult Method (IEnumerableIGroupingTKey, TElement, TKey, IEqualityComparerTKey, FuncIEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult Partition<TKey, TElement, TResult>( + this IEnumerable<IGrouping<TKey, TElement>> source, + TKey key, + IEqualityComparer<TKey> comparer, + Func<IEnumerable<TElement>, IEnumerable<IGrouping<TKey, TElement>>, TResult> resultSelector +) +
See AlsoMoreEnumerablePartitionTKey, TElement, TResult Method (IEnumerableIGroupingTKey, TElement, TKey, FuncIEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult Partition<TKey, TElement, TResult>( + this IEnumerable<IGrouping<TKey, TElement>> source, + TKey key, + Func<IEnumerable<TElement>, IEnumerable<IGrouping<TKey, TElement>>, TResult> resultSelector +) +
See AlsoMoreEnumerablePartitionTKey, TElement, TResult Method (IEnumerableIGroupingTKey, TElement, TKey, TKey, IEqualityComparerTKey, FuncIEnumerableTElement, IEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult Partition<TKey, TElement, TResult>( + this IEnumerable<IGrouping<TKey, TElement>> source, + TKey key1, + TKey key2, + IEqualityComparer<TKey> comparer, + Func<IEnumerable<TElement>, IEnumerable<TElement>, IEnumerable<IGrouping<TKey, TElement>>, TResult> resultSelector +) +
See AlsoMoreEnumerablePartitionTKey, TElement, TResult Method (IEnumerableIGroupingTKey, TElement, TKey, TKey, FuncIEnumerableTElement, IEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult Partition<TKey, TElement, TResult>( + this IEnumerable<IGrouping<TKey, TElement>> source, + TKey key1, + TKey key2, + Func<IEnumerable<TElement>, IEnumerable<TElement>, IEnumerable<IGrouping<TKey, TElement>>, TResult> resultSelector +) +
See AlsoMoreEnumerablePartitionTKey, TElement, TResult Method (IEnumerableIGroupingTKey, TElement, TKey, TKey, TKey, IEqualityComparerTKey, FuncIEnumerableTElement, IEnumerableTElement, IEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult Partition<TKey, TElement, TResult>( + this IEnumerable<IGrouping<TKey, TElement>> source, + TKey key1, + TKey key2, + TKey key3, + IEqualityComparer<TKey> comparer, + Func<IEnumerable<TElement>, IEnumerable<TElement>, IEnumerable<TElement>, IEnumerable<IGrouping<TKey, TElement>>, TResult> resultSelector +) +
See AlsoMoreEnumerablePartitionTKey, TElement, TResult Method (IEnumerableIGroupingTKey, TElement, TKey, TKey, TKey, FuncIEnumerableTElement, IEnumerableTElement, IEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult Partition<TKey, TElement, TResult>( + this IEnumerable<IGrouping<TKey, TElement>> source, + TKey key1, + TKey key2, + TKey key3, + Func<IEnumerable<TElement>, IEnumerable<TElement>, IEnumerable<TElement>, IEnumerable<IGrouping<TKey, TElement>>, TResult> resultSelector +) +
See AlsoMoreEnumerablePermutationsT Method |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<IList<T>> Permutations<T>( + this IEnumerable<T> sequence +) +
RemarksSee AlsoMoreEnumerablePipeT Method |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> Pipe<T>( + this IEnumerable<T> source, + Action<T> action +) +
RemarksSee AlsoMoreEnumerablePreScanTSource Method |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> PreScan<TSource>( + this IEnumerable<TSource> source, + Func<TSource, TSource, TSource> transformation, + TSource identity +) +
RemarksExamplesFunc<int, int, int> plus = (a, b) => a + b; +int[] values = { 1, 2, 3, 4 }; +IEnumerable<int> prescan = values.PreScan(plus, 0); +IEnumerable<int> scan = values.Scan(plus; a + b); +IEnumerable<int> result = values.ZipShortest(prescan, plus);
See AlsoMoreEnumerablePrependTSource Method |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> Prepend<TSource>( + this IEnumerable<TSource> source, + TSource value +) +
RemarksSee AlsoMoreEnumerableRandom Method |
+ Namespace: + MoreLinq
SyntaxRemarksSee AlsoMoreEnumerableRandomDouble Method |
+ Namespace: + MoreLinq
SyntaxRemarksSee AlsoMoreEnumerableRandomDouble Method (Random) |
+ Namespace: + MoreLinq
SyntaxExceptions| Exception | Condition |
|---|---|
| ArgumentNullException | Thrown if rand is . |
See AlsoMoreEnumerableRandomSubsetT Method (IEnumerableT, Int32) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> RandomSubset<T>( + this IEnumerable<T> sequence, + int subsetSize +) +
See AlsoMoreEnumerableRandomSubsetT Method (IEnumerableT, Int32, Random) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> RandomSubset<T>( + this IEnumerable<T> sequence, + int subsetSize, + Random rand +) +
See AlsoMoreEnumerableRandom Method (Int32) |
+ Namespace: + MoreLinq
SyntaxRemarksSee AlsoMoreEnumerableRandom Method (Int32, Int32) |
+ Namespace: + MoreLinq
SyntaxRemarksSee AlsoMoreEnumerableRandom Method (Random) |
+ Namespace: + MoreLinq
SyntaxExceptions| Exception | Condition |
|---|---|
| ArgumentNullException | Thrown if rand is . |
See AlsoMoreEnumerableRandom Method (Random, Int32) |
+ Namespace: + MoreLinq
SyntaxExceptions| Exception | Condition |
|---|---|
| ArgumentNullException | Thrown if rand is . |
See AlsoMoreEnumerableRandom Method (Random, Int32, Int32) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<int> Random( + Random rand, + int minValue, + int maxValue +)
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | Thrown if rand is . |
See AlsoMoreEnumerableRankByTSource, TKey Method (IEnumerableTSource, FuncTSource, TKey) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<int> RankBy<TSource, TKey>( + this IEnumerable<TSource> source, + Func<TSource, TKey> keySelector +) +
See AlsoMoreEnumerableRankByTSource, TKey Method (IEnumerableTSource, FuncTSource, TKey, IComparerTKey) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<int> RankBy<TSource, TKey>( + this IEnumerable<TSource> source, + Func<TSource, TKey> keySelector, + IComparer<TKey> comparer +) +
See AlsoMoreEnumerableRankTSource Method (IEnumerableTSource) |
+ Namespace: + MoreLinq
SyntaxSee AlsoMoreEnumerableRankTSource Method (IEnumerableTSource, IComparerTSource) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<int> Rank<TSource>( + this IEnumerable<TSource> source, + IComparer<TSource> comparer +) +
See AlsoMoreEnumerableRepeatT Method (IEnumerableT) |
+ Namespace: + MoreLinq
SyntaxSee AlsoMoreEnumerableRepeatT Method (IEnumerableT, Int32) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> Repeat<T>( + this IEnumerable<T> sequence, + int count +) +
See AlsoMoreEnumerableRightJoinTSource, TKey, TResult Method (IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TSource, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> RightJoin<TSource, TKey, TResult>( + this IEnumerable<TSource> first, + IEnumerable<TSource> second, + Func<TSource, TKey> keySelector, + Func<TSource, TResult> secondSelector, + Func<TSource, TSource, TResult> bothSelector +) +
See AlsoMoreEnumerableRightJoinTSource, TKey, TResult Method (IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TSource, TResult, IEqualityComparerTKey) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> RightJoin<TSource, TKey, TResult>( + this IEnumerable<TSource> first, + IEnumerable<TSource> second, + Func<TSource, TKey> keySelector, + Func<TSource, TResult> secondSelector, + Func<TSource, TSource, TResult> bothSelector, + IEqualityComparer<TKey> comparer +) +
See AlsoMoreEnumerableRightJoinTFirst, TSecond, TKey, TResult Method (IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTSecond, TResult, FuncTFirst, TSecond, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> RightJoin<TFirst, TSecond, TKey, TResult>( + this IEnumerable<TFirst> first, + IEnumerable<TSecond> second, + Func<TFirst, TKey> firstKeySelector, + Func<TSecond, TKey> secondKeySelector, + Func<TSecond, TResult> secondSelector, + Func<TFirst, TSecond, TResult> bothSelector +) +
See AlsoMoreEnumerableRightJoinTFirst, TSecond, TKey, TResult Method (IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTSecond, TResult, FuncTFirst, TSecond, TResult, IEqualityComparerTKey) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> RightJoin<TFirst, TSecond, TKey, TResult>( + this IEnumerable<TFirst> first, + IEnumerable<TSecond> second, + Func<TFirst, TKey> firstKeySelector, + Func<TSecond, TKey> secondKeySelector, + Func<TSecond, TResult> secondSelector, + Func<TFirst, TSecond, TResult> bothSelector, + IEqualityComparer<TKey> comparer +) +
See AlsoMoreEnumerableRunLengthEncodeT Method (IEnumerableT) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<KeyValuePair<T, int>> RunLengthEncode<T>( + this IEnumerable<T> sequence +) +
See AlsoMoreEnumerableRunLengthEncodeT Method (IEnumerableT, IEqualityComparerT) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<KeyValuePair<T, int>> RunLengthEncode<T>( + this IEnumerable<T> sequence, + IEqualityComparer<T> comparer +) +
See AlsoMoreEnumerableScanRightTSource Method (IEnumerableTSource, FuncTSource, TSource, TSource) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> ScanRight<TSource>( + this IEnumerable<TSource> source, + Func<TSource, TSource, TSource> func +) +
RemarksExamplesvar result = Enumerable.Range(1, 5).Select(i => i.ToString()).ScanRight((a, b) => string.Format("({0}/{1})", a, b));
See AlsoMoreEnumerableScanRightTSource, TAccumulate Method (IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TAccumulate> ScanRight<TSource, TAccumulate>( + this IEnumerable<TSource> source, + TAccumulate seed, + Func<TSource, TAccumulate, TAccumulate> func +) +
RemarksExamplesvar result = Enumerable.Range(1, 4).ScanRight("5", (a, b) => string.Format("({0}/{1})", a, b));
See AlsoMoreEnumerableScanTSource Method (IEnumerableTSource, FuncTSource, TSource, TSource) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> Scan<TSource>( + this IEnumerable<TSource> source, + Func<TSource, TSource, TSource> transformation +) +
RemarksExamplesFunc<int, int, int> plus = (a, b) => a + b; +int[] values = { 1, 2, 3, 4 }; +IEnumerable<int> prescan = values.PreScan(plus, 0); +IEnumerable<int> scan = values.Scan(plus; a + b); +IEnumerable<int> result = values.ZipShortest(prescan, plus);
See AlsoMoreEnumerableScanTSource, TState Method (IEnumerableTSource, TState, FuncTState, TSource, TState) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TState> Scan<TSource, TState>( + this IEnumerable<TSource> source, + TState seed, + Func<TState, TSource, TState> transformation +) +
RemarksExamplesvar result = Enumerable.Range(1, 5).Scan(0, (a, b) => a + b);
See AlsoMoreEnumerableSegmentT Method (IEnumerableT, FuncT, Boolean) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<IEnumerable<T>> Segment<T>( + this IEnumerable<T> source, + Func<T, bool> newSegmentPredicate +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | + Thrown if either source or newSegmentPredicate are . + |
See AlsoMoreEnumerableSegmentT Method (IEnumerableT, FuncT, Int32, Boolean) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<IEnumerable<T>> Segment<T>( + this IEnumerable<T> source, + Func<T, int, bool> newSegmentPredicate +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | + Thrown if either source or newSegmentPredicate are . + |
See AlsoMoreEnumerableSegmentT Method (IEnumerableT, FuncT, T, Int32, Boolean) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<IEnumerable<T>> Segment<T>( + this IEnumerable<T> source, + Func<T, T, int, bool> newSegmentPredicate +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | + Thrown if either source or newSegmentPredicate are . + |
See AlsoMoreEnumerableSequence Method (Int32, Int32) |
+ Namespace: + MoreLinq
SyntaxRemarksExamplesvar result = MoreEnumerable.Sequence(6, 0);
See AlsoMoreEnumerableSequence Method (Int32, Int32, Int32) |
+ Namespace: + MoreLinq
SyntaxRemarksExamplesvar result = MoreEnumerable.Sequence(6, 0, -2);
See AlsoMoreEnumerableSingleOrFallbackTSource Method |
Note: This API is now obsolete.
+ Namespace: + MoreLinq
Syntax[ObsoleteAttribute("Consider using FallbackIfEmpty instead. SingleOrFallback may be removed in a future version. For more information, see https://github.com/morelinq/MoreLINQ/issues/122.")] +public static TSource SingleOrFallback<TSource>( + this IEnumerable<TSource> source, + Func<TSource> fallback +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source or fallback is null |
| InvalidOperationException | The sequence has more than one element |
RemarksExamplesvar numbers = { 123, 456, 789 }; +var result = numbers.Where(x => x == 100).SingleOrFallback(() => -1);
See AlsoMoreEnumerableSkipLastT Method |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> SkipLast<T>( + this IEnumerable<T> source, + int count +) +
See AlsoMoreEnumerableSkipUntilTSource Method |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> SkipUntil<TSource>( + this IEnumerable<TSource> source, + Func<TSource, bool> predicate +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source or predicate is null |
Remarks+ SkipUntil differs from Enumerable.SkipWhile in two respects. Firstly, the sense + of the predicate is reversed: it is expected that the predicate will return false + to start with, and then return true - for example, when trying to find a matching + item in a sequence. +
+ Secondly, SkipUntil skips the element which causes the predicate to return true. For + example, in a sequence
{ 1, 2, 3, 4, 5 }x => x == 3{ 4, 5 }+ SkipUntil is as lazy as possible: it will not iterate over the source sequence + until it has to, it won't iterate further than it has to, and it won't evaluate + the predicate until it has to. (This means that an item may be returned which would + actually cause the predicate to throw an exception if it were evaluated, so long as + it comes after the first item causing the predicate to return true.) +
See AlsoMoreEnumerableSliceT Method |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> Slice<T>( + this IEnumerable<T> sequence, + int startIndex, + int count +) +
RemarksSee AlsoMoreEnumerableSortedMergeTSource Method (IEnumerableTSource, OrderByDirection, IComparerTSource, IEnumerableTSource) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> SortedMerge<TSource>( + this IEnumerable<TSource> source, + OrderByDirection direction, + IComparer<TSource> comparer, + params IEnumerable<TSource>[] otherSequences +) +
See AlsoMoreEnumerableSortedMergeTSource Method (IEnumerableTSource, OrderByDirection, IEnumerableTSource) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> SortedMerge<TSource>( + this IEnumerable<TSource> source, + OrderByDirection direction, + params IEnumerable<TSource>[] otherSequences +) +
Remarksvar s1 = new[] { 3, 7, 11 }; +var s2 = new[] { 2, 4, 20 }; +var s3 = new[] { 17, 19, 25 }; +var merged = s1.SortedMerge( OrderByDirection.Ascending, s2, s3 ); +var result = merged.ToArray(); +// result will be: +// { 2, 3, 4, 7, 11, 17, 19, 20, 25 }
See AlsoMoreEnumerableSplitTSource Method (IEnumerableTSource, FuncTSource, Boolean) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<IEnumerable<TSource>> Split<TSource>( + this IEnumerable<TSource> source, + Func<TSource, bool> separatorFunc +) +
See AlsoMoreEnumerableSplitTSource Method (IEnumerableTSource, FuncTSource, Boolean, Int32) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<IEnumerable<TSource>> Split<TSource>( + this IEnumerable<TSource> source, + Func<TSource, bool> separatorFunc, + int count +) +
See AlsoMoreEnumerableSplitTSource Method (IEnumerableTSource, TSource) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<IEnumerable<TSource>> Split<TSource>( + this IEnumerable<TSource> source, + TSource separator +) +
See AlsoMoreEnumerableSplitTSource Method (IEnumerableTSource, TSource, IEqualityComparerTSource) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<IEnumerable<TSource>> Split<TSource>( + this IEnumerable<TSource> source, + TSource separator, + IEqualityComparer<TSource> comparer +) +
See AlsoMoreEnumerableSplitTSource Method (IEnumerableTSource, TSource, IEqualityComparerTSource, Int32) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<IEnumerable<TSource>> Split<TSource>( + this IEnumerable<TSource> source, + TSource separator, + IEqualityComparer<TSource> comparer, + int count +) +
See AlsoMoreEnumerableSplitTSource Method (IEnumerableTSource, TSource, Int32) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<IEnumerable<TSource>> Split<TSource>( + this IEnumerable<TSource> source, + TSource separator, + int count +) +
See AlsoMoreEnumerableSplitTSource, TResult Method (IEnumerableTSource, FuncTSource, Boolean, FuncIEnumerableTSource, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> Split<TSource, TResult>( + this IEnumerable<TSource> source, + Func<TSource, bool> separatorFunc, + Func<IEnumerable<TSource>, TResult> resultSelector +) +
See AlsoMoreEnumerableSplitTSource, TResult Method (IEnumerableTSource, FuncTSource, Boolean, Int32, FuncIEnumerableTSource, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> Split<TSource, TResult>( + this IEnumerable<TSource> source, + Func<TSource, bool> separatorFunc, + int count, + Func<IEnumerable<TSource>, TResult> resultSelector +) +
See AlsoMoreEnumerableSplitTSource, TResult Method (IEnumerableTSource, TSource, IEqualityComparerTSource, FuncIEnumerableTSource, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> Split<TSource, TResult>( + this IEnumerable<TSource> source, + TSource separator, + IEqualityComparer<TSource> comparer, + Func<IEnumerable<TSource>, TResult> resultSelector +) +
See AlsoMoreEnumerableSplitTSource, TResult Method (IEnumerableTSource, TSource, IEqualityComparerTSource, Int32, FuncIEnumerableTSource, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> Split<TSource, TResult>( + this IEnumerable<TSource> source, + TSource separator, + IEqualityComparer<TSource> comparer, + int count, + Func<IEnumerable<TSource>, TResult> resultSelector +) +
See AlsoMoreEnumerableSplitTSource, TResult Method (IEnumerableTSource, TSource, FuncIEnumerableTSource, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> Split<TSource, TResult>( + this IEnumerable<TSource> source, + TSource separator, + Func<IEnumerable<TSource>, TResult> resultSelector +) +
See AlsoMoreEnumerableSplitTSource, TResult Method (IEnumerableTSource, TSource, Int32, FuncIEnumerableTSource, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> Split<TSource, TResult>( + this IEnumerable<TSource> source, + TSource separator, + int count, + Func<IEnumerable<TSource>, TResult> resultSelector +) +
See AlsoMoreEnumerableStartsWithT Method (IEnumerableT, IEnumerableT) |
+ Namespace: + MoreLinq
Syntaxpublic static bool StartsWith<T>( + this IEnumerable<T> first, + IEnumerable<T> second +) +
RemarksSee AlsoMoreEnumerableStartsWithT Method (IEnumerableT, IEnumerableT, IEqualityComparerT) |
+ Namespace: + MoreLinq
Syntaxpublic static bool StartsWith<T>( + this IEnumerable<T> first, + IEnumerable<T> second, + IEqualityComparer<T> comparer +) +
RemarksSee AlsoMoreEnumerableSubsetsT Method (IEnumerableT) |
+ Namespace: + MoreLinq
SyntaxExceptions| Exception | Condition |
|---|---|
| ArgumentNullException | Thrown if sequence is |
RemarksSee AlsoMoreEnumerableSubsetsT Method (IEnumerableT, Int32) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<IList<T>> Subsets<T>( + this IEnumerable<T> sequence, + int subsetSize +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | + Thrown if sequence is |
| ArgumentOutOfRangeException | + Thrown if subsetSize is less than zero. + |
See AlsoMoreEnumerableTagFirstLastTSource, TResult Method |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> TagFirstLast<TSource, TResult>( + this IEnumerable<TSource> source, + Func<TSource, bool, bool, TResult> resultSelector +) +
RemarksExamplesvar numbers = new[] { 123, 456, 789 }; +var result = numbers.TagFirstLast((num, fst, lst) => new + { + Number = num, + IsFirst = fst, IsLast = lst + });
See AlsoMoreEnumerableTakeEveryTSource Method |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> TakeEvery<TSource>( + this IEnumerable<TSource> source, + int step +) +
RemarksExamplesint[] numbers = { 1, 2, 3, 4, 5 }; +IEnumerable<int> result = numbers.TakeEvery(2);
See AlsoMoreEnumerableTakeLastTSource Method |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> TakeLast<TSource>( + this IEnumerable<TSource> source, + int count +) +
RemarksExamplesint[] numbers = { 12, 34, 56, 78 }; +IEnumerable<int> result = numbers.TakeLast(2);
See AlsoMoreEnumerableTakeUntilTSource Method |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> TakeUntil<TSource>( + this IEnumerable<TSource> source, + Func<TSource, bool> predicate +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source or predicate is null |
Remarks+ TakeUntil differs from Enumerable.TakeWhile in two respects. Firstly, the sense + of the predicate is reversed: it is expected that the predicate will return false + to start with, and then return true - for example, when trying to find a matching + item in a sequence. +
+ Secondly, TakeUntil yields the element which causes the predicate to return true. For + example, in a sequence
{ 1, 2, 3, 4, 5 }x => x == 3{ 1, 2, 3 }+ TakeUntil is as lazy as possible: it will not iterate over the source sequence + until it has to, it won't iterate further than it has to, and it won't evaluate + the predicate until it has to. (This means that an item may be returned which would + actually cause the predicate to throw an exception if it were evaluated, so long as + no more items of data are requested.) +
See AlsoMoreEnumerableThenByT, TKey Method (IOrderedEnumerableT, FuncT, TKey, OrderByDirection) |
+ Namespace: + MoreLinq
Syntaxpublic static IOrderedEnumerable<T> ThenBy<T, TKey>( + this IOrderedEnumerable<T> source, + Func<T, TKey> keySelector, + OrderByDirection direction +) +
See AlsoMoreEnumerableThenByT, TKey Method (IOrderedEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection) |
+ Namespace: + MoreLinq
Syntaxpublic static IOrderedEnumerable<T> ThenBy<T, TKey>( + this IOrderedEnumerable<T> source, + Func<T, TKey> keySelector, + IComparer<TKey> comparer, + OrderByDirection direction +) +
See AlsoMoreEnumerableToArrayByIndexT Method (IEnumerableT, FuncT, Int32) |
+ Namespace: + MoreLinq
Syntaxpublic static T[] ToArrayByIndex<T>( + this IEnumerable<T> source, + Func<T, int> indexSelector +) +
RemarksSee AlsoMoreEnumerableToArrayByIndexT Method (IEnumerableT, Int32, FuncT, Int32) |
+ Namespace: + MoreLinq
Syntaxpublic static T[] ToArrayByIndex<T>( + this IEnumerable<T> source, + int length, + Func<T, int> indexSelector +) +
RemarksSee AlsoMoreEnumerableToArrayByIndexT, TResult Method (IEnumerableT, FuncT, Int32, FuncT, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult[] ToArrayByIndex<T, TResult>( + this IEnumerable<T> source, + Func<T, int> indexSelector, + Func<T, TResult> resultSelector +) +
RemarksSee AlsoMoreEnumerableToArrayByIndexT, TResult Method (IEnumerableT, FuncT, Int32, FuncT, Int32, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult[] ToArrayByIndex<T, TResult>( + this IEnumerable<T> source, + Func<T, int> indexSelector, + Func<T, int, TResult> resultSelector +) +
RemarksSee AlsoMoreEnumerableToArrayByIndexT, TResult Method (IEnumerableT, Int32, FuncT, Int32, FuncT, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult[] ToArrayByIndex<T, TResult>( + this IEnumerable<T> source, + int length, + Func<T, int> indexSelector, + Func<T, TResult> resultSelector +) +
RemarksSee AlsoMoreEnumerableToArrayByIndexT, TResult Method (IEnumerableT, Int32, FuncT, Int32, FuncT, Int32, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static TResult[] ToArrayByIndex<T, TResult>( + this IEnumerable<T> source, + int length, + Func<T, int> indexSelector, + Func<T, int, TResult> resultSelector +) +
RemarksSee AlsoMoreEnumerableToDataTableT Method (IEnumerableT) |
+ Namespace: + MoreLinq
SyntaxRemarksSee AlsoMoreEnumerableToDataTableT Method (IEnumerableT, ExpressionFuncT, Object) |
+ Namespace: + MoreLinq
Syntaxpublic static DataTable ToDataTable<T>( + this IEnumerable<T> source, + params Expression<Func<T, Object>>[] expressions +) +
RemarksSee AlsoMoreEnumerableToDataTableT, TTable Method (IEnumerableT, TTable) |
+ Namespace: + MoreLinq
Syntaxpublic static TTable ToDataTable<T, TTable>( + this IEnumerable<T> source, + TTable table +) +where TTable : DataTable +
RemarksSee AlsoMoreEnumerableToDataTableT, TTable Method (IEnumerableT, TTable, ExpressionFuncT, Object) |
+ Namespace: + MoreLinq
Syntaxpublic static TTable ToDataTable<T, TTable>( + this IEnumerable<T> source, + TTable table, + params Expression<Func<T, Object>>[] expressions +) +where TTable : DataTable +
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableBoolean) |
Note: This API is now obsolete.
+ Namespace: + MoreLinq
Syntax[ObsoleteAttribute] +public static string ToDelimitedString( + this IEnumerable<bool> source +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableBoolean, String) |
+ Namespace: + MoreLinq
Syntaxpublic static string ToDelimitedString( + this IEnumerable<bool> source, + string delimiter +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableInt16) |
Note: This API is now obsolete.
+ Namespace: + MoreLinq
Syntax[ObsoleteAttribute] +public static string ToDelimitedString( + this IEnumerable<short> source +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableInt16, String) |
+ Namespace: + MoreLinq
Syntaxpublic static string ToDelimitedString( + this IEnumerable<short> source, + string delimiter +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableInt32) |
Note: This API is now obsolete.
+ Namespace: + MoreLinq
Syntax[ObsoleteAttribute] +public static string ToDelimitedString( + this IEnumerable<int> source +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableInt32, String) |
+ Namespace: + MoreLinq
Syntaxpublic static string ToDelimitedString( + this IEnumerable<int> source, + string delimiter +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableInt64) |
Note: This API is now obsolete.
+ Namespace: + MoreLinq
Syntax[ObsoleteAttribute] +public static string ToDelimitedString( + this IEnumerable<long> source +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableInt64, String) |
+ Namespace: + MoreLinq
Syntaxpublic static string ToDelimitedString( + this IEnumerable<long> source, + string delimiter +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableSByte) |
Note: This API is now obsolete.
+ Namespace: + MoreLinq
Syntax[ObsoleteAttribute] +public static string ToDelimitedString( + this IEnumerable<sbyte> source +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableSByte, String) |
+ Namespace: + MoreLinq
Syntaxpublic static string ToDelimitedString( + this IEnumerable<sbyte> source, + string delimiter +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableSingle) |
Note: This API is now obsolete.
+ Namespace: + MoreLinq
Syntax[ObsoleteAttribute] +public static string ToDelimitedString( + this IEnumerable<float> source +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableSingle, String) |
+ Namespace: + MoreLinq
Syntaxpublic static string ToDelimitedString( + this IEnumerable<float> source, + string delimiter +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableByte) |
Note: This API is now obsolete.
+ Namespace: + MoreLinq
Syntax[ObsoleteAttribute] +public static string ToDelimitedString( + this IEnumerable<byte> source +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableString) |
Note: This API is now obsolete.
+ Namespace: + MoreLinq
Syntax[ObsoleteAttribute] +public static string ToDelimitedString( + this IEnumerable<string> source +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableString, String) |
+ Namespace: + MoreLinq
Syntaxpublic static string ToDelimitedString( + this IEnumerable<string> source, + string delimiter +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableUInt16) |
Note: This API is now obsolete.
+ Namespace: + MoreLinq
Syntax[ObsoleteAttribute] +public static string ToDelimitedString( + this IEnumerable<ushort> source +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableUInt16, String) |
+ Namespace: + MoreLinq
Syntaxpublic static string ToDelimitedString( + this IEnumerable<ushort> source, + string delimiter +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableUInt32) |
Note: This API is now obsolete.
+ Namespace: + MoreLinq
Syntax[ObsoleteAttribute] +public static string ToDelimitedString( + this IEnumerable<uint> source +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableUInt32, String) |
+ Namespace: + MoreLinq
Syntaxpublic static string ToDelimitedString( + this IEnumerable<uint> source, + string delimiter +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableUInt64) |
Note: This API is now obsolete.
+ Namespace: + MoreLinq
Syntax[ObsoleteAttribute] +public static string ToDelimitedString( + this IEnumerable<ulong> source +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableUInt64, String) |
+ Namespace: + MoreLinq
Syntaxpublic static string ToDelimitedString( + this IEnumerable<ulong> source, + string delimiter +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableByte, String) |
+ Namespace: + MoreLinq
Syntaxpublic static string ToDelimitedString( + this IEnumerable<byte> source, + string delimiter +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableChar) |
Note: This API is now obsolete.
+ Namespace: + MoreLinq
Syntax[ObsoleteAttribute] +public static string ToDelimitedString( + this IEnumerable<char> source +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableChar, String) |
+ Namespace: + MoreLinq
Syntaxpublic static string ToDelimitedString( + this IEnumerable<char> source, + string delimiter +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableDecimal) |
Note: This API is now obsolete.
+ Namespace: + MoreLinq
Syntax[ObsoleteAttribute] +public static string ToDelimitedString( + this IEnumerable<decimal> source +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableDecimal, String) |
+ Namespace: + MoreLinq
Syntaxpublic static string ToDelimitedString( + this IEnumerable<decimal> source, + string delimiter +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableDouble) |
Note: This API is now obsolete.
+ Namespace: + MoreLinq
Syntax[ObsoleteAttribute] +public static string ToDelimitedString( + this IEnumerable<double> source +)
RemarksSee AlsoMoreEnumerableToDelimitedString Method (IEnumerableDouble, String) |
+ Namespace: + MoreLinq
Syntaxpublic static string ToDelimitedString( + this IEnumerable<double> source, + string delimiter +)
RemarksSee AlsoMoreEnumerableToDelimitedStringTSource Method (IEnumerableTSource) |
Note: This API is now obsolete.
+ Namespace: + MoreLinq
Syntax[ObsoleteAttribute] +public static string ToDelimitedString<TSource>( + this IEnumerable<TSource> source +) +
RemarksSee AlsoMoreEnumerableToDelimitedStringTSource Method (IEnumerableTSource, String) |
+ Namespace: + MoreLinq
Syntaxpublic static string ToDelimitedString<TSource>( + this IEnumerable<TSource> source, + string delimiter +) +
RemarksSee AlsoMoreEnumerableToDictionaryTKey, TValue Method (IEnumerableKeyValuePairTKey, TValue) |
+ Namespace: + MoreLinq
Syntaxpublic static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>( + this IEnumerable<KeyValuePair<TKey, TValue>> source +) +
See AlsoMoreEnumerableToDictionaryTKey, TValue Method (IEnumerableKeyValuePairTKey, TValue, IEqualityComparerTKey) |
+ Namespace: + MoreLinq
Syntaxpublic static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>( + this IEnumerable<KeyValuePair<TKey, TValue>> source, + IEqualityComparer<TKey> comparer +) +
See AlsoMoreEnumerableToDictionaryTKey, TValue Method (IEnumerableValueTuple`2TKey, TValue) |
+ Namespace: + MoreLinq
Syntaxpublic static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>( + this IEnumerable<ValueTuple<TKey, TValue>> source +) +
See AlsoMoreEnumerableToDictionaryTKey, TValue Method (IEnumerableValueTuple`2TKey, TValue, IEqualityComparerTKey) |
+ Namespace: + MoreLinq
Syntaxpublic static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>( + this IEnumerable<ValueTuple<TKey, TValue>> source, + IEqualityComparer<TKey> comparer +) +
See AlsoMoreEnumerableToHashSetTSource Method (IEnumerableTSource) |
+ Namespace: + MoreLinq
Syntaxpublic static HashSet<TSource> ToHashSet<TSource>( + this IEnumerable<TSource> source +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source is null |
RemarksSee AlsoMoreEnumerableToHashSetTSource Method (IEnumerableTSource, IEqualityComparerTSource) |
+ Namespace: + MoreLinq
Syntaxpublic static HashSet<TSource> ToHashSet<TSource>( + this IEnumerable<TSource> source, + IEqualityComparer<TSource> comparer +) +
Exceptions| Exception | Condition |
|---|---|
| ArgumentNullException | source is null |
RemarksSee AlsoMoreEnumerableToLookupTKey, TValue Method (IEnumerableKeyValuePairTKey, TValue) |
+ Namespace: + MoreLinq
Syntaxpublic static ILookup<TKey, TValue> ToLookup<TKey, TValue>( + this IEnumerable<KeyValuePair<TKey, TValue>> source +) +
See AlsoMoreEnumerableToLookupTKey, TValue Method (IEnumerableKeyValuePairTKey, TValue, IEqualityComparerTKey) |
+ Namespace: + MoreLinq
Syntaxpublic static ILookup<TKey, TValue> ToLookup<TKey, TValue>( + this IEnumerable<KeyValuePair<TKey, TValue>> source, + IEqualityComparer<TKey> comparer +) +
See AlsoMoreEnumerableToLookupTKey, TValue Method (IEnumerableValueTuple`2TKey, TValue) |
+ Namespace: + MoreLinq
Syntaxpublic static ILookup<TKey, TValue> ToLookup<TKey, TValue>( + this IEnumerable<ValueTuple<TKey, TValue>> source +) +
See AlsoMoreEnumerableToLookupTKey, TValue Method (IEnumerableValueTuple`2TKey, TValue, IEqualityComparerTKey) |
+ Namespace: + MoreLinq
Syntaxpublic static ILookup<TKey, TValue> ToLookup<TKey, TValue>( + this IEnumerable<ValueTuple<TKey, TValue>> source, + IEqualityComparer<TKey> comparer +) +
See AlsoMoreEnumerableTraceTSource Method (IEnumerableTSource) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> Trace<TSource>( + this IEnumerable<TSource> source +) +
RemarksSee AlsoMoreEnumerableTraceTSource Method (IEnumerableTSource, FuncTSource, String) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> Trace<TSource>( + this IEnumerable<TSource> source, + Func<TSource, string> formatter +) +
RemarksSee AlsoMoreEnumerableTraceTSource Method (IEnumerableTSource, String) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TSource> Trace<TSource>( + this IEnumerable<TSource> source, + string format +) +
RemarksSee AlsoMoreEnumerableTraverseBreadthFirstT Method |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> TraverseBreadthFirst<T>( + T root, + Func<T, IEnumerable<T>> childrenSelector +) +
RemarksSee AlsoMoreEnumerableTraverseDepthFirstT Method |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<T> TraverseDepthFirst<T>( + T root, + Func<T, IEnumerable<T>> childrenSelector +) +
RemarksSee AlsoMoreEnumerableUnfoldTState, T, TResult Method |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> Unfold<TState, T, TResult>( + TState state, + Func<TState, T> generator, + Func<T, bool> predicate, + Func<T, TState> stateSelector, + Func<T, TResult> resultSelector +) +
RemarksSee AlsoMoreEnumerableWindowedTSource Method |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<IEnumerable<TSource>> Windowed<TSource>( + this IEnumerable<TSource> source, + int size +) +
RemarksSee AlsoMoreEnumerableZipLongestTFirst, TSecond, TResult Method |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> ZipLongest<TFirst, TSecond, TResult>( + this IEnumerable<TFirst> first, + IEnumerable<TSecond> second, + Func<TFirst, TSecond, TResult> resultSelector +) +
RemarksExamplesint[] numbers = { 1, 2, 3 }; +string[] letters = { "A", "B", "C", "D" }; +var zipped = numbers.EquiZip(letters, (n, l) => n + l);
See AlsoMoreEnumerableZipShortestTFirst, TSecond, TResult Method (IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> ZipShortest<TFirst, TSecond, TResult>( + this IEnumerable<TFirst> first, + IEnumerable<TSecond> second, + Func<TFirst, TSecond, TResult> resultSelector +) +
RemarksExamplesvar numbers = new[] { 1, 2, 3 }; +var letters = new[] { "A", "B", "C", "D" }; +var zipped = numbers.ZipShortest(letters, (n, l) => n + l);
See AlsoMoreEnumerableZipShortestT1, T2, T3, TResult Method (IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> ZipShortest<T1, T2, T3, TResult>( + this IEnumerable<T1> first, + IEnumerable<T2> second, + IEnumerable<T3> third, + Func<T1, T2, T3, TResult> resultSelector +) +
RemarksExamplesvar numbers = new[] { 1, 2, 3 }; +var letters = new[] { "A", "B", "C", "D" }; +var chars = new[] { 'a', 'b', 'c', 'd', 'e' }; +var zipped = numbers.ZipShortest(letters, chars, (n, l, c) => c + n + l);
See AlsoMoreEnumerableZipShortestT1, T2, T3, T4, TResult Method (IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) |
+ Namespace: + MoreLinq
Syntaxpublic static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, TResult>( + this IEnumerable<T1> first, + IEnumerable<T2> second, + IEnumerable<T3> third, + IEnumerable<T4> fourth, + Func<T1, T2, T3, T4, TResult> resultSelector +) +
RemarksExamplesvar numbers = new[] { 1, 2, 3 }; +var letters = new[] { "A", "B", "C", "D" }; +var chars = new[] { 'a', 'b', 'c', 'd', 'e' }; +var flags = new[] { true, false }; +var zipped = numbers.ZipShortest(letters, chars, flags (n, l, c, f) => n + l + c + f);
See AlsoSequenceException Constructor |
+ Namespace: + MoreLinq
SyntaxSee AlsoSequenceException Constructor (SerializationInfo, StreamingContext) |
+ Namespace: + MoreLinq
SyntaxSee AlsoSequenceException Constructor (String) |
+ Namespace: + MoreLinq
SyntaxSee AlsoSequenceException Constructor (String, Exception) |
+ Namespace: + MoreLinq
SyntaxSee AlsoMoreEnumerable Methods |
The MoreEnumerable type exposes the following members.
Methods| + + | Name | Description |
|---|---|---|
  | AcquireTSource |
+ Ensures that a source sequence of IDisposable
+ objects are all acquired successfully. If the acquisition of any
+ one IDisposable fails then those successfully
+ acquired till that point are disposed.
+ |
 | AggregateRightTSource(IEnumerableTSource, FuncTSource, TSource, TSource) |
+ Applies a right-associative accumulator function over a sequence.
+ This operator is the right-associative version of the
+ AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ |
| AggregateRightTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate) |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate) LINQ operator.
+ |
| AggregateRightTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate, FuncTAccumulate, TResult) |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value,
+ and the specified function is used to select the result value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate, FuncTAccumulate, TResult) LINQ operator.
+ |
| AssertTSource(IEnumerableTSource, FuncTSource, Boolean) |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ |
| AssertTSource(IEnumerableTSource, FuncTSource, Boolean, FuncTSource, Exception) |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ |
| AssertCountTSource(IEnumerableTSource, Int32) |
+ Asserts that a source sequence contains a given count of elements.
+ |
| AssertCountTSource(IEnumerableTSource, Int32, FuncInt32, Int32, Exception) |
+ Asserts that a source sequence contains a given count of elements.
+ A parameter specifies the exception to be thrown.
+ |
| AtLeastT |
+ Determines whether or not the number of elements in the sequence is greater than
+ or equal to the given integer.
+ |
| AtMostT |
+ Determines whether or not the number of elements in the sequence is lesser than
+ or equal to the given integer.
+ |
| BatchTSource(IEnumerableTSource, Int32) |
+ Batches the source sequence into sized buckets.
+ |
| BatchTSource, TResult(IEnumerableTSource, Int32, FuncIEnumerableTSource, TResult) |
+ Batches the source sequence into sized buckets and applies a projection to each bucket.
+ |
| CartesianTFirst, TSecond, TResult |
+ Returns the Cartesian product of two sequences by combining each element of the first set with each in the second
+ and applying the user=define projection to the pair.
+ |
| ConcatT(IEnumerableT, T) |
+ Returns a sequence consisting of the head elements and the given tail element.
+ |
| ConcatT(T, IEnumerableT) |
+ Returns a sequence consisting of the head element and the given tail elements.
+ |
| ConsumeT |
+ Completely consumes the given sequence. This method uses immediate execution,
+ and doesn't store any data during execution.
+ |
| CountBetweenT |
+ Determines whether or not the number of elements in the sequence is between
+ an inclusive range of minimum and maximum integers.
+ |
| CountByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ |
| CountByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ An additional argument specifies a comparer to use for testing equivalence of keys.
+ |
| DistinctByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the default equality comparer for the projected type.
+ |
| DistinctByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the specified comparer for the projected type.
+ |
| EndsWithT(IEnumerableT, IEnumerableT) |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the default equality comparer.
+ |
| EndsWithT(IEnumerableT, IEnumerableT, IEqualityComparerT) |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the specified element equality comparer.
+ |
| EquiZipTFirst, TSecond, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) |
+ Returns a projection of tuples, where each tuple contains the N-th element
+ from each of the argument sequences.
+ |
| EquiZipT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) |
+ Returns a projection of tuples, where each tuple contains the N-th element
+ from each of the argument sequences.
+ |
| EquiZipT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) |
+ Returns a projection of tuples, where each tuple contains the N-th element
+ from each of the argument sequences.
+ |
| EvaluateT |
+ Returns a sequence containing the values resulting from invoking (in order) each function in the source sequence of functions.
+ |
| ExactlyT |
+ Determines whether or not the number of elements in the sequence is equals to the given integer.
+ |
| ExceptByTSource, TKey(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey) |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ |
| ExceptByTSource, TKey(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ |
| ExcludeT |
+ Excludes a contiguous number of elements from a sequence starting
+ at a given index.
+ |
| FallbackIfEmptyT(IEnumerableT, IEnumerableT) |
+ Returns the elements of a sequence, but if it is empty then
+ returns an altenate sequence of values.
+ |
| FallbackIfEmptyT(IEnumerableT, T) |
+ Returns the elements of the specified sequence or the specified
+ value in a singleton collection if the sequence is empty.
+ |
| FallbackIfEmptyT(IEnumerableT, T) |
+ Returns the elements of a sequence, but if it is empty then
+ returns an altenate sequence from an array of values.
+ |
| FallbackIfEmptyT(IEnumerableT, T, T) |
+ Returns the elements of a sequence, but if it is empty then
+ returns an altenate sequence of values.
+ |
| FallbackIfEmptyT(IEnumerableT, T, T, T) |
+ Returns the elements of a sequence, but if it is empty then
+ returns an altenate sequence of values.
+ |
| FallbackIfEmptyT(IEnumerableT, T, T, T, T) |
+ Returns the elements of a sequence, but if it is empty then
+ returns an altenate sequence of values.
+ |
| FillBackwardT(IEnumerableT) |
+ Returns a sequence with each null reference or value in the source
+ replaced with the following non-null reference or value in
+ that sequence.
+ |
| FillBackwardT(IEnumerableT, FuncT, Boolean) |
+ Returns a sequence with each missing element in the source replaced
+ with the following non-missing element in that sequence. An
+ additional parameter specifies a function used to determine if an
+ element is considered missing or not.
+ |
| FillBackwardT(IEnumerableT, FuncT, Boolean, FuncT, T, T) |
+ Returns a sequence with each missing element in the source replaced
+ with the following non-missing element in that sequence. Additional
+ parameters specifiy two functions, one used to determine if an
+ element is considered missing or not and another to provide the
+ replacement for the missing element.
+ |
| FillForwardT(IEnumerableT) |
+ Returns a sequence with each null reference or value in the source
+ replaced with the previous non-null reference or value seen in
+ that sequence.
+ |
| FillForwardT(IEnumerableT, FuncT, Boolean) |
+ Returns a sequence with each missing element in the source replaced
+ with the previous non-missing element seen in that sequence. An
+ additional parameter specifies a function used to determine if an
+ element is considered missing or not.
+ |
| FillForwardT(IEnumerableT, FuncT, Boolean, FuncT, T, T) |
+ Returns a sequence with each missing element in the source replaced
+ with one based on the previous non-missing element seen in that
+ sequence. Additional parameters specifiy two functions, one used to
+ determine if an element is considered missing or not and another
+ to provide the replacement for the missing element.
+ |
| Flatten(IEnumerable) |
+ Flattens a sequence containing arbitrarily-nested sequences.
+ |
| Flatten(IEnumerable, FuncIEnumerable, Boolean) |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a predicate function used to
+ determine whether a nested IEnumerable should be
+ flattened or not.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 9 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 10 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 11 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 12 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 13 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 14 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 15 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 16 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, TResult) |
+ Returns the result of applying a function to a sequence of
+ 1 element.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 2 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 3 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 4 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 5 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 6 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 7 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 8 elements.
+ |
| ForEachT(IEnumerableT, ActionT) |
+ Immediately executes the given action on each element in the source sequence.
+ |
| ForEachT(IEnumerableT, ActionT, Int32) |
+ Immediately executes the given action on each element in the source sequence.
+ Each element's index is used in the logic of the action.
+ |
| FromT(FuncT) |
+ Returns a single-element sequence containing the result of invoking the function.
+ |
| FromT(FuncT) |
+ Returns a sequence containing the values resulting from invoking (in order) each function in the source sequence of functions.
+ |
| FromT(FuncT, FuncT) |
+ Returns a sequence containing the result of invoking each parameter function in order.
+ |
| FromT(FuncT, FuncT, FuncT) |
+ Returns a sequence containing the result of invoking each parameter function in order.
+ |
| FullGroupJoinTFirst, TSecond, TKey(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey) |
+ Performs a Full Group Join between the first and second sequences.
+ |
| FullGroupJoinTFirst, TSecond, TKey(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, IEqualityComparerTKey) |
+ Performs a Full Group Join between the first and second sequences.
+ |
| FullGroupJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTKey, IEnumerableTFirst, IEnumerableTSecond, TResult) |
+ Performs a full group-join between two sequences.
+ |
| FullGroupJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTKey, IEnumerableTFirst, IEnumerableTSecond, TResult, IEqualityComparerTKey) |
+ Performs a full group-join between two sequences.
+ |
| FullJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TResult, FuncTSource, TSource, TResult) |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ |
| FullJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TResult, FuncTSource, TSource, TResult, IEqualityComparerTKey) |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ |
| FullJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult) |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ |
| FullJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult, IEqualityComparerTKey) |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ |
| GenerateTResult |
+ Returns a sequence of values consecutively generated by a generator function.
+ |
| GenerateByIndexTResult |
+ Returns a sequence of values based on indexes.
+ |
| GroupAdjacentTSource, TKey(IEnumerableTSource, FuncTSource, TKey) |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function.
+ |
| GroupAdjacentTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and compares the keys by using a
+ specified comparer.
+ |
| GroupAdjacentTSource, TKey, TElement(IEnumerableTSource, FuncTSource, TKey, FuncTSource, TElement) |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and projects the elements for
+ each group by using a specified function.
+ |
| GroupAdjacentTSource, TKey, TResult(IEnumerableTSource, FuncTSource, TKey, FuncTKey, IEnumerableTSource, TResult) |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ |
| GroupAdjacentTSource, TKey, TElement(IEnumerableTSource, FuncTSource, TKey, FuncTSource, TElement, IEqualityComparerTKey) |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ |
| GroupAdjacentTSource, TKey, TResult(IEnumerableTSource, FuncTSource, TKey, FuncTKey, IEnumerableTSource, TResult, IEqualityComparerTKey) |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ |
| IncrementalTSource, TResult(IEnumerableTSource, FuncTSource, TSource, TResult) | Obsolete.
+ Computes an incremental value between every adjacent element in a sequence: {N,N+1}, {N+1,N+2}, ...
+ |
| IncrementalTSource, TResult(IEnumerableTSource, FuncTSource, TSource, Int32, TResult) | Obsolete.
+ Computes an incremental value between every adjacent element in a sequence: {N,N+1}, {N+1,N+2}, ...
+ |
| IndexTSource(IEnumerableTSource) |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the zero-based index of the value in the source
+ sequence.
+ |
| IndexTSource(IEnumerableTSource, Int32) |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the index of the value in the source sequence.
+ An additional parameter specifies the starting index.
+ |
| InsertT |
+ Inserts the elements of a sequence into another sequence at a
+ specified index.
+ |
| InterleaveT |
+ Interleaves the elements of two or more sequences into a single sequence, skipping sequences as they are consumed
+ |
| LagTSource, TResult(IEnumerableTSource, Int32, FuncTSource, TSource, TResult) |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset.
+ |
| LagTSource, TResult(IEnumerableTSource, Int32, TSource, FuncTSource, TSource, TResult) |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset.
+ |
| LeadTSource, TResult(IEnumerableTSource, Int32, FuncTSource, TSource, TResult) |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset.
+ |
| LeadTSource, TResult(IEnumerableTSource, Int32, TSource, FuncTSource, TSource, TResult) |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset.
+ |
| LeftJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TSource, TResult) |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ |
| LeftJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TSource, TResult, IEqualityComparerTKey) |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ |
| LeftJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTFirst, TSecond, TResult) |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ |
| LeftJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTFirst, TSecond, TResult, IEqualityComparerTKey) |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ |
| MaxByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) |
+ Returns the maximal element of the given sequence, based on
+ the given projection.
+ |
| MaxByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) |
+ Returns the maximal element of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ |
| MinByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) |
+ Returns the minimal element of the given sequence, based on
+ the given projection.
+ |
| MinByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) |
+ Returns the minimal element of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ |
| MoveT |
+ Returns a sequence with a range of elements in the source sequence
+ moved to a new offset.
+ |
| NestedLoops |
+ Produces a sequence from an action based on the dynamic generation of N nested loops
+ whose iteration counts are defined by a sequence of loop counts.
+ |
| OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection) |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ |
| OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection) |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ |
| OrderedMergeT(IEnumerableT, IEnumerableT) |
+ Merges two ordered sequences into one. Where the elements equal
+ in both sequences, the element from the first sequence is
+ returned in the resulting sequence.
+ |
| OrderedMergeT(IEnumerableT, IEnumerableT, IComparerT) |
+ Merges two ordered sequences into one with an additional
+ parameter specifying how to compare the elements of the
+ sequences. Where the elements equal in both sequences, the
+ element from the first sequence is returned in the resulting
+ sequence.
+ |
| OrderedMergeT, TKey(IEnumerableT, IEnumerableT, FuncT, TKey) |
+ Merges two ordered sequences into one with an additional
+ parameter specifying the element key by which the sequences are
+ ordered. Where the keys equal in both sequences, the
+ element from the first sequence is returned in the resulting
+ sequence.
+ |
| OrderedMergeT, TKey, TResult(IEnumerableT, IEnumerableT, FuncT, TKey, FuncT, TResult, FuncT, TResult, FuncT, T, TResult) |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first and the result when elements are found in
+ both sequences.
+ |
| OrderedMergeT, TKey, TResult(IEnumerableT, IEnumerableT, FuncT, TKey, FuncT, TResult, FuncT, TResult, FuncT, T, TResult, IComparerTKey) |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first, the result when elements are found in
+ both sequences and a method for comparing keys.
+ |
| OrderedMergeTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult) |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second and
+ the result when element is found in second sequence but not in
+ the first, the result when elements are found in both sequences.
+ |
| OrderedMergeTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult, IComparerTKey) |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second,
+ the result when element is found in second sequence but not in
+ the first, the result when elements are found in both sequences
+ and a method for comparing keys.
+ |
| PadTSource(IEnumerableTSource, Int32) |
+ Pads a sequence with default values if it is narrower (shorter
+ in length) than a given width.
+ |
| PadTSource(IEnumerableTSource, Int32, FuncInt32, TSource) |
+ Pads a sequence with a dynamic filler value if it is narrower (shorter
+ in length) than a given width.
+ |
| PadTSource(IEnumerableTSource, Int32, TSource) |
+ Pads a sequence with a given filler value if it is narrower (shorter
+ in length) than a given width.
+ |
| PadStartTSource(IEnumerableTSource, Int32) |
+ Pads a sequence with default values in the beginning if it is narrower (shorter
+ in length) than a given width.
+ |
| PadStartTSource(IEnumerableTSource, Int32, FuncInt32, TSource) |
+ Pads a sequence with a dynamic filler value in the beginning if it is narrower (shorter
+ in length) than a given width.
+ An additional parameter specifies the function to calculate padding.
+ |
| PadStartTSource(IEnumerableTSource, Int32, TSource) |
+ Pads a sequence with a given filler value in the beginning if it is narrower (shorter
+ in length) than a given width.
+ An additional parameter specifies the value to use for padding.
+ |
| PairwiseTSource, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence and its
+ predecessor, with the exception of the first element which is
+ only returned as the predecessor of the second element.
+ |
| PartialSortT(IEnumerableT, Int32) |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ |
| PartialSortT(IEnumerableT, Int32, OrderByDirection) |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ An additional parameter specifies the direction of the sort
+ |
| PartialSortT(IEnumerableT, Int32, IComparerT) |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation. An additional parameter specifies how the
+ elements compare to each other.
+ |
| PartialSortT(IEnumerableT, Int32, IComparerT, OrderByDirection) |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ |
| PartialSortByTSource, TKey(IEnumerableTSource, Int32, FuncTSource, TKey) |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ |
| PartialSortByTSource, TKey(IEnumerableTSource, Int32, FuncTSource, TKey, OrderByDirection) |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies the direction of the sort
+ |
| PartialSortByTSource, TKey(IEnumerableTSource, Int32, FuncTSource, TKey, IComparerTKey) |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies how the keys compare to each other.
+ |
| PartialSortByTSource, TKey(IEnumerableTSource, Int32, FuncTSource, TKey, IComparerTKey, OrderByDirection) |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ |
| PartitionT(IEnumerableT, FuncT, Boolean) |
+ Partitions or splits a sequence in two using a predicate.
+ |
| PartitionT, TResult(IEnumerableIGroupingBoolean, T, FuncIEnumerableT, IEnumerableT, TResult) |
+ Partitions a grouping by Boolean keys into a projection of true
+ elements and false elements, respectively.
+ |
| PartitionT, TResult(IEnumerableIGroupingNullableBoolean, T, FuncIEnumerableT, IEnumerableT, IEnumerableT, TResult) |
+ Partitions a grouping by nullable Boolean keys into a projection of
+ true elements, false elements and null elements, respectively.
+ |
| PartitionT, TResult(IEnumerableT, FuncT, Boolean, FuncIEnumerableT, IEnumerableT, TResult) |
+ Partitions or splits a sequence in two using a predicate and then
+ projects a result from the two.
+ |
| PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, FuncIEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) |
+ Partitions a grouping and projects a result from group elements
+ matching a key and those groups that do not.
+ |
| PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, IEqualityComparerTKey, FuncIEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) |
+ Partitions a grouping and projects a result from group elements
+ matching a key and those groups that do not. An additional parameter
+ specifies how to compare keys for equality.
+ |
| PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, TKey, FuncIEnumerableTElement, IEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) |
+ Partitions a grouping and projects a result from elements of
+ groups matching a set of two keys and those groups that do not.
+ |
| PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, TKey, IEqualityComparerTKey, FuncIEnumerableTElement, IEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) |
+ Partitions a grouping and projects a result from elements of
+ groups matching a set of two keys and those groups that do not.
+ An additional parameter specifies how to compare keys for equality.
+ |
| PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, TKey, TKey, FuncIEnumerableTElement, IEnumerableTElement, IEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) |
+ Partitions a grouping and projects a result from elements groups
+ matching a set of three keys and those groups that do not.
+ |
| PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, TKey, TKey, IEqualityComparerTKey, FuncIEnumerableTElement, IEnumerableTElement, IEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) |
+ Partitions a grouping and projects a result from elements groups
+ matching a set of three keys and those groups that do not. An
+ additional parameter specifies how to compare keys for equality.
+ |
| PermutationsT |
+ Generates a sequence of lists that represent the permutations of the original sequence.
+ |
| PipeT |
+ Executes the given action on each element in the source sequence
+ and yields it.
+ |
| PrependTSource |
+ Prepends a single value to a sequence.
+ |
| PreScanTSource |
+ Performs a pre-scan (exclusive prefix sum) on a sequence of elements.
+ |
| Random |
+ Returns an infinite sequence of random integers using the standard
+ .NET random number generator.
+ |
| Random(Int32) |
+ Returns an infinite sequence of random integers between zero and
+ a given maximum.
+ |
| Random(Random) |
+ Returns an infinite sequence of random integers using the supplied
+ random number generator.
+ |
| Random(Int32, Int32) |
+ Returns an infinite sequence of random integers between a given
+ minimum and a maximum.
+ |
| Random(Random, Int32) |
+ Returns an infinite sequence of random integers between zero and a
+ given maximum using the supplied random number generator.
+ |
| Random(Random, Int32, Int32) |
+ Returns an infinite sequence of random integers between a given
+ minumum and a maximum using the supplied random number generator.
+ |
| RandomDouble |
+ Returns an infinite sequence of random double values between 0.0 and 1.0
+ |
| RandomDouble(Random) |
+ Returns an infinite sequence of random double values between 0.0 and 1.0
+ using the supplied random number generator.
+ |
| RandomSubsetT(IEnumerableT, Int32) |
+ Returns a sequence of a specified size of random elements from the original sequence
+ |
| RandomSubsetT(IEnumerableT, Int32, Random) |
+ Returns a sequence of a specified size of random elements from the original sequence
+ |
| RankTSource(IEnumerableTSource) |
+ Ranks each item in the sequence in descending ordering using a default comparer.
+ |
| RankTSource(IEnumerableTSource, IComparerTSource) |
+ Rank each item in the sequence using a caller-supplied comparer.
+ |
| RankByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) |
+ Ranks each item in the sequence in descending ordering by a specified key using a default comparer
+ |
| RankByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) |
+ Ranks each item in a sequence using a specified key and a caller-supplied comparer
+ |
| RepeatT(IEnumerableT) |
+ Repeats the sequence forever.
+ |
| RepeatT(IEnumerableT, Int32) |
+ Repeats the sequence the specified number of times.
+ |
| RightJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TSource, TResult) |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ |
| RightJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TSource, TResult, IEqualityComparerTKey) |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ |
| RightJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTSecond, TResult, FuncTFirst, TSecond, TResult) |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ |
| RightJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTSecond, TResult, FuncTFirst, TSecond, TResult, IEqualityComparerTKey) |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ |
| RunLengthEncodeT(IEnumerableT) |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count.
+ |
| RunLengthEncodeT(IEnumerableT, IEqualityComparerT) |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count. This overload
+ uses a custom equality comparer to identify equivalent items.
+ |
| ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) |
+ Peforms a scan (inclusive prefix sum) on a sequence of elements.
+ |
| ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) |
+ Like AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) except returns
+ the sequence of intermediate results as well as the final one.
+ An additional parameter specifies a seed.
+ |
| ScanRightTSource(IEnumerableTSource, FuncTSource, TSource, TSource) |
+ Peforms a right-associative scan (inclusive prefix) on a sequence of elements.
+ This operator is the right-associative version of the
+ ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ |
| ScanRightTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate) |
+ Peforms a right-associative scan (inclusive prefix) on a sequence of elements.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) LINQ operator.
+ |
| SegmentT(IEnumerableT, FuncT, Boolean) |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ |
| SegmentT(IEnumerableT, FuncT, Int32, Boolean) |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ |
| SegmentT(IEnumerableT, FuncT, T, Int32, Boolean) |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ |
| Sequence(Int32, Int32) |
+ Generates a sequence of integral numbers within the (inclusive) specified range.
+ If sequence is ascending the step is +1, otherwise -1.
+ |
| Sequence(Int32, Int32, Int32) |
+ Generates a sequence of integral numbers within the (inclusive) specified range.
+ An additional parameter specifies the steps in which the integers of the sequence increase or decrease.
+ |
| SingleOrFallbackTSource | Obsolete.
+ Returns the single element in the given sequence, or the result
+ of executing a fallback delegate if the sequence is empty.
+ This method throws an exception if there is more than one element in the sequence.
+ |
| SkipLastT |
+ Bypasses a specified number of elements at the end of the sequence.
+ |
| SkipUntilTSource |
+ Skips items from the input sequence until the given predicate returns true
+ when applied to the current source item; that item will be the last skipped.
+ |
| SliceT |
+ Extracts a contiguous count of elements from a sequence at a particular zero-based starting index
+ |
| SortedMergeTSource(IEnumerableTSource, OrderByDirection, IEnumerableTSource) |
+ Merges two or more sequences that are in a common order (either ascending or descending) into
+ a single sequence that preserves that order.
+ |
| SortedMergeTSource(IEnumerableTSource, OrderByDirection, IComparerTSource, IEnumerableTSource) |
+ Merges two or more sequences that are in a common order (either ascending or descending) into
+ a single sequence that preserves that order.
+ |
| SplitTSource(IEnumerableTSource, FuncTSource, Boolean) |
+ Splits the source sequence by separator elements identified by a
+ function.
+ |
| SplitTSource(IEnumerableTSource, TSource) |
+ Splits the source sequence by a separator.
+ |
| SplitTSource(IEnumerableTSource, FuncTSource, Boolean, Int32) |
+ Splits the source sequence by separator elements identified by a
+ function, given a maximum count of splits.
+ |
| SplitTSource(IEnumerableTSource, TSource, IEqualityComparerTSource) |
+ Splits the source sequence by a separator and then transforms the
+ splits into results.
+ |
| SplitTSource(IEnumerableTSource, TSource, Int32) |
+ Splits the source sequence by a separator given a maximum count of splits.
+ |
| SplitTSource(IEnumerableTSource, TSource, IEqualityComparerTSource, Int32) |
+ Splits the source sequence by a separator, given a maximum count
+ of splits. A parameter specifies how the separator is compared
+ for equality.
+ |
| SplitTSource, TResult(IEnumerableTSource, FuncTSource, Boolean, FuncIEnumerableTSource, TResult) |
+ Splits the source sequence by separator elements identified by
+ a function and then transforms the splits into results.
+ |
| SplitTSource, TResult(IEnumerableTSource, TSource, FuncIEnumerableTSource, TResult) |
+ Splits the source sequence by a separator and then transforms
+ the splits into results.
+ |
| SplitTSource, TResult(IEnumerableTSource, FuncTSource, Boolean, Int32, FuncIEnumerableTSource, TResult) |
+ Splits the source sequence by separator elements identified by
+ a function, given a maximum count of splits, and then transforms
+ the splits into results.
+ |
| SplitTSource, TResult(IEnumerableTSource, TSource, IEqualityComparerTSource, FuncIEnumerableTSource, TResult) |
+ Splits the source sequence by a separator and then transforms the
+ splits into results. A parameter specifies how the separator is
+ compared for equality.
+ |
| SplitTSource, TResult(IEnumerableTSource, TSource, Int32, FuncIEnumerableTSource, TResult) |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results.
+ |
| SplitTSource, TResult(IEnumerableTSource, TSource, IEqualityComparerTSource, Int32, FuncIEnumerableTSource, TResult) |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results. A
+ parameter specifies how the separator is compared for equality.
+ |
| StartsWithT(IEnumerableT, IEnumerableT) |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the default equality
+ comparer.
+ |
| StartsWithT(IEnumerableT, IEnumerableT, IEqualityComparerT) |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the specified element
+ equality comparer.
+ |
| SubsetsT(IEnumerableT) |
+ Returns a sequence of IListT representing all of
+ the subsets of any size that are part of the original sequence. In
+ mathematics, it is equivalent to the power set of a set.
+ |
| SubsetsT(IEnumerableT, Int32) |
+ Returns a sequence of IListT representing all
+ subsets of a given size that are part of the original sequence. In
+ mathematics, it is equivalent to the combinations or
+ k-subsets of a set.
+ |
| TagFirstLastTSource, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence with additional parameters
+ indicating whether the element is the first and/or last of the
+ sequence.
+ |
| TakeEveryTSource |
+ Returns every N-th element of a sequence.
+ |
| TakeLastTSource |
+ Returns a specified number of contiguous elements from the end of
+ a sequence.
+ |
| TakeUntilTSource |
+ Returns items from the input sequence until the given predicate returns true
+ when applied to the current source item; that item will be the last returned.
+ |
| ThenByT, TKey(IOrderedEnumerableT, FuncT, TKey, OrderByDirection) |
+ Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key
+ |
| ThenByT, TKey(IOrderedEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection) |
+ Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key
+ |
| ToArrayByIndexT(IEnumerableT, FuncT, Int32) |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array.
+ |
| ToArrayByIndexT(IEnumerableT, Int32, FuncT, Int32) |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array.
+ |
| ToArrayByIndexT, TResult(IEnumerableT, FuncT, Int32, FuncT, TResult) |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ |
| ToArrayByIndexT, TResult(IEnumerableT, FuncT, Int32, FuncT, Int32, TResult) |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ |
| ToArrayByIndexT, TResult(IEnumerableT, Int32, FuncT, Int32, FuncT, TResult) |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ |
| ToArrayByIndexT, TResult(IEnumerableT, Int32, FuncT, Int32, FuncT, Int32, TResult) |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ |
| ToDataTableT(IEnumerableT) |
+ Converts a sequence to a DataTable object.
+ |
| ToDataTableT(IEnumerableT, ExpressionFuncT, Object) |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ |
| ToDataTableT, TTable(IEnumerableT, TTable) |
+ Appends elements in the sequence as rows of a given DataTable object.
+ |
| ToDataTableT, TTable(IEnumerableT, TTable, ExpressionFuncT, Object) |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ |
| ToDelimitedString(IEnumerableBoolean) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableByte) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableChar) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableDecimal) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableDouble) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableInt16) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableInt32) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableInt64) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableSByte) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableSingle) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableString) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableUInt16) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableUInt32) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableUInt64) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableBoolean, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableByte, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableChar, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableDecimal, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableDouble, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableInt16, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableInt32, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableInt64, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableSByte, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableSingle, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableString, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableUInt16, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableUInt32, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableUInt64, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedStringTSource(IEnumerableTSource) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedStringTSource(IEnumerableTSource, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDictionaryTKey, TValue(IEnumerableKeyValuePairTKey, TValue) |
+ Creates a DictionaryTKey, TValue from a sequence of
+ KeyValuePairTKey, TValue elements.
+ |
| ToDictionaryTKey, TValue(IEnumerableValueTupleTKey, TValue) |
+ Creates a DictionaryTKey, TValue from a sequence of
+ tuples of 2 where the first item is the key and the second the
+ value.
+ |
| ToDictionaryTKey, TValue(IEnumerableKeyValuePairTKey, TValue, IEqualityComparerTKey) |
+ Creates a DictionaryTKey, TValue from a sequence of
+ KeyValuePairTKey, TValue elements. An additional
+ parameter specifies a comparer for keys.
+ |
| ToDictionaryTKey, TValue(IEnumerableValueTupleTKey, TValue, IEqualityComparerTKey) |
+ Creates a DictionaryTKey, TValue from a sequence of
+ tuples of 2 where the first item is the key and the second the
+ value. An additional parameter specifies a comparer for keys.
+ |
| ToHashSetTSource(IEnumerableTSource) |
+ Returns a HashSetT of the source items using the default equality
+ comparer for the type.
+ |
| ToHashSetTSource(IEnumerableTSource, IEqualityComparerTSource) |
+ Returns a HashSetT of the source items using the specified equality
+ comparer for the type.
+ |
| ToLookupTKey, TValue(IEnumerableKeyValuePairTKey, TValue) |
+ Creates a ILookupTKey, TElement from a sequence of
+ KeyValuePairTKey, TValue elements.
+ |
| ToLookupTKey, TValue(IEnumerableValueTupleTKey, TValue) |
+ Creates a Lookup from a sequence of
+ tuples of 2 where the first item is the key and the second the
+ value.
+ |
| ToLookupTKey, TValue(IEnumerableKeyValuePairTKey, TValue, IEqualityComparerTKey) |
+ Creates a ILookupTKey, TElement from a sequence of
+ KeyValuePairTKey, TValue elements. An additional
+ parameter specifies a comparer for keys.
+ |
| ToLookupTKey, TValue(IEnumerableValueTupleTKey, TValue, IEqualityComparerTKey) |
+ Creates a Lookup from a sequence of
+ tuples of 2 where the first item is the key and the second the
+ value. An additional parameter specifies a comparer for keys.
+ |
| TraceTSource(IEnumerableTSource) |
+ Traces the elements of a source sequence for diagnostics.
+ |
| TraceTSource(IEnumerableTSource, FuncTSource, String) |
+ Traces the elements of a source sequence for diagnostics using
+ a custom formatter.
+ |
| TraceTSource(IEnumerableTSource, String) |
+ Traces the elements of a source sequence for diagnostics using
+ custom formatting.
+ |
| TraverseBreadthFirstT |
+ Traverses a tree in a breadth-first fashion, starting at a root node and using a user-defined
+ function to get the children at each node of the tree.
+ |
| TraverseDepthFirstT |
+ Traverses a tree in a depth-first fashion, starting at a root node and using a user-defined
+ function to get the children at each node of the tree.
+ |
| UnfoldTState, T, TResult |
+ Returns a sequence generated by applying a state to the generator function,
+ and from its result, determines if the sequence should have a next element, its value,
+ and the next state in the recursive call.
+ |
| WindowedTSource |
+ Processes a sequence into a series of subsequences representing a windowed subset of the original
+ |
| ZipLongestTFirst, TSecond, TResult |
+ Returns a projection of tuples, where each tuple contains the N-th element
+ from each of the argument sequences.
+ |
| ZipShortestTFirst, TSecond, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) |
+ Returns a projection of tuples, where each tuple contains the N-th element
+ from each of the argument sequences.
+ |
| ZipShortestT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) |
+ Returns a projection of tuples, where each tuple contains the N-th element
+ from each of the argument sequences.
+ |
| ZipShortestT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) |
+ Returns a projection of tuples, where each tuple contains the N-th element
+ from each of the argument sequences.
+ |
See AlsoSequenceException Methods |
The SequenceException type exposes the following members.
Methods| + + | Name | Description |
|---|---|---|
| Equals | (Inherited from Object.) |
 | Finalize | Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection. (Inherited from Object.) |
| GetBaseException | When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions. (Inherited from Exception.) |
| GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.) |
| GetObjectData | When overridden in a derived class, sets the SerializationInfo with information about the exception. (Inherited from Exception.) |
| GetType | Gets the runtime type of the current instance. (Inherited from Exception.) |
| MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.) |
| ToString | Creates and returns a string representation of the current exception. (Inherited from Exception.) |
See AlsoMoreLinq Namespace |
Classes| + + | Class | Description |
|---|---|---|
 | MoreEnumerable |
+ Provides a set of static methods for querying objects that
+ implement IEnumerableT. The actual methods
+ are implemented in files reflecting the method name.
+ |
| SequenceException |
+ The exception that is thrown for a sequence that fails a condition.
+ |
Enumerations| + + | Enumeration | Description |
|---|---|---|
 | OrderByDirection |
+ Enumeration that defines values representing valid ordering directions for a sequence.
+ |
MoreEnumerableAggregateRight Method |
Overload List| + + | Name | Description |
|---|---|---|
| AggregateRightTSource(IEnumerableTSource, FuncTSource, TSource, TSource) |
+ Applies a right-associative accumulator function over a sequence.
+ This operator is the right-associative version of the
+ AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ |
| AggregateRightTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate) |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate) LINQ operator.
+ |
| AggregateRightTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate, FuncTAccumulate, TResult) |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value,
+ and the specified function is used to select the result value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate, FuncTAccumulate, TResult) LINQ operator.
+ |
See AlsoMoreEnumerableAssert Method |
Overload List| + + | Name | Description |
|---|---|---|
| AssertTSource(IEnumerableTSource, FuncTSource, Boolean) |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ |
| AssertTSource(IEnumerableTSource, FuncTSource, Boolean, FuncTSource, Exception) |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ |
See AlsoMoreEnumerableAssertCount Method |
Overload List| + + | Name | Description |
|---|---|---|
| AssertCountTSource(IEnumerableTSource, Int32) |
+ Asserts that a source sequence contains a given count of elements.
+ |
| AssertCountTSource(IEnumerableTSource, Int32, FuncInt32, Int32, Exception) |
+ Asserts that a source sequence contains a given count of elements.
+ A parameter specifies the exception to be thrown.
+ |
See AlsoMoreEnumerableBatch Method |
Overload List| + + | Name | Description |
|---|---|---|
| BatchTSource(IEnumerableTSource, Int32) |
+ Batches the source sequence into sized buckets.
+ |
| BatchTSource, TResult(IEnumerableTSource, Int32, FuncIEnumerableTSource, TResult) |
+ Batches the source sequence into sized buckets and applies a projection to each bucket.
+ |
See AlsoMoreEnumerableConcat Method |
Overload List| + + | Name | Description |
|---|---|---|
| ConcatT(IEnumerableT, T) |
+ Returns a sequence consisting of the head elements and the given tail element.
+ |
| ConcatT(T, IEnumerableT) |
+ Returns a sequence consisting of the head element and the given tail elements.
+ |
See AlsoMoreEnumerableCountBy Method |
Overload List| + + | Name | Description |
|---|---|---|
| CountByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ |
| CountByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ An additional argument specifies a comparer to use for testing equivalence of keys.
+ |
See AlsoMoreEnumerableDistinctBy Method |
Overload List| + + | Name | Description |
|---|---|---|
| DistinctByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the default equality comparer for the projected type.
+ |
| DistinctByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the specified comparer for the projected type.
+ |
See AlsoMoreEnumerableEndsWith Method |
Overload List| + + | Name | Description |
|---|---|---|
| EndsWithT(IEnumerableT, IEnumerableT) |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the default equality comparer.
+ |
| EndsWithT(IEnumerableT, IEnumerableT, IEqualityComparerT) |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the specified element equality comparer.
+ |
See AlsoMoreEnumerableEquiZip Method |
Overload List| + + | Name | Description |
|---|---|---|
| EquiZipTFirst, TSecond, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) |
+ Returns a projection of tuples, where each tuple contains the N-th element
+ from each of the argument sequences.
+ |
| EquiZipT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) |
+ Returns a projection of tuples, where each tuple contains the N-th element
+ from each of the argument sequences.
+ |
| EquiZipT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) |
+ Returns a projection of tuples, where each tuple contains the N-th element
+ from each of the argument sequences.
+ |
See AlsoMoreEnumerableExceptBy Method |
Overload List| + + | Name | Description |
|---|---|---|
| ExceptByTSource, TKey(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey) |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ |
| ExceptByTSource, TKey(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ |
See AlsoMoreEnumerableFallbackIfEmpty Method |
Overload List| + + | Name | Description |
|---|---|---|
| FallbackIfEmptyT(IEnumerableT, IEnumerableT) |
+ Returns the elements of a sequence, but if it is empty then
+ returns an altenate sequence of values.
+ |
| FallbackIfEmptyT(IEnumerableT, T) |
+ Returns the elements of the specified sequence or the specified
+ value in a singleton collection if the sequence is empty.
+ |
| FallbackIfEmptyT(IEnumerableT, T) |
+ Returns the elements of a sequence, but if it is empty then
+ returns an altenate sequence from an array of values.
+ |
| FallbackIfEmptyT(IEnumerableT, T, T) |
+ Returns the elements of a sequence, but if it is empty then
+ returns an altenate sequence of values.
+ |
| FallbackIfEmptyT(IEnumerableT, T, T, T) |
+ Returns the elements of a sequence, but if it is empty then
+ returns an altenate sequence of values.
+ |
| FallbackIfEmptyT(IEnumerableT, T, T, T, T) |
+ Returns the elements of a sequence, but if it is empty then
+ returns an altenate sequence of values.
+ |
See AlsoMoreEnumerableFillBackward Method |
Overload List| + + | Name | Description |
|---|---|---|
| FillBackwardT(IEnumerableT) |
+ Returns a sequence with each null reference or value in the source
+ replaced with the following non-null reference or value in
+ that sequence.
+ |
| FillBackwardT(IEnumerableT, FuncT, Boolean) |
+ Returns a sequence with each missing element in the source replaced
+ with the following non-missing element in that sequence. An
+ additional parameter specifies a function used to determine if an
+ element is considered missing or not.
+ |
| FillBackwardT(IEnumerableT, FuncT, Boolean, FuncT, T, T) |
+ Returns a sequence with each missing element in the source replaced
+ with the following non-missing element in that sequence. Additional
+ parameters specifiy two functions, one used to determine if an
+ element is considered missing or not and another to provide the
+ replacement for the missing element.
+ |
See AlsoMoreEnumerableFillForward Method |
Overload List| + + | Name | Description |
|---|---|---|
| FillForwardT(IEnumerableT) |
+ Returns a sequence with each null reference or value in the source
+ replaced with the previous non-null reference or value seen in
+ that sequence.
+ |
| FillForwardT(IEnumerableT, FuncT, Boolean) |
+ Returns a sequence with each missing element in the source replaced
+ with the previous non-missing element seen in that sequence. An
+ additional parameter specifies a function used to determine if an
+ element is considered missing or not.
+ |
| FillForwardT(IEnumerableT, FuncT, Boolean, FuncT, T, T) |
+ Returns a sequence with each missing element in the source replaced
+ with one based on the previous non-missing element seen in that
+ sequence. Additional parameters specifiy two functions, one used to
+ determine if an element is considered missing or not and another
+ to provide the replacement for the missing element.
+ |
See AlsoMoreEnumerableFlatten Method |
Overload List| + + | Name | Description |
|---|---|---|
| Flatten(IEnumerable) |
+ Flattens a sequence containing arbitrarily-nested sequences.
+ |
| Flatten(IEnumerable, FuncIEnumerable, Boolean) |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a predicate function used to
+ determine whether a nested IEnumerable should be
+ flattened or not.
+ |
See AlsoMoreEnumerableFold Method |
Overload List| + + | Name | Description |
|---|---|---|
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 9 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 10 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 11 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 12 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 13 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 14 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 15 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 16 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, TResult) |
+ Returns the result of applying a function to a sequence of
+ 1 element.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 2 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 3 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 4 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 5 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 6 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 7 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 8 elements.
+ |
See AlsoMoreEnumerableForEach Method |
Overload List| + + | Name | Description |
|---|---|---|
| ForEachT(IEnumerableT, ActionT) |
+ Immediately executes the given action on each element in the source sequence.
+ |
| ForEachT(IEnumerableT, ActionT, Int32) |
+ Immediately executes the given action on each element in the source sequence.
+ Each element's index is used in the logic of the action.
+ |
See AlsoMoreEnumerableFrom Method |
Overload List| + + | Name | Description |
|---|---|---|
| FromT(FuncT) |
+ Returns a single-element sequence containing the result of invoking the function.
+ |
| FromT(FuncT) |
+ Returns a sequence containing the values resulting from invoking (in order) each function in the source sequence of functions.
+ |
| FromT(FuncT, FuncT) |
+ Returns a sequence containing the result of invoking each parameter function in order.
+ |
| FromT(FuncT, FuncT, FuncT) |
+ Returns a sequence containing the result of invoking each parameter function in order.
+ |
See AlsoMoreEnumerableFullGroupJoin Method |
Overload List| + + | Name | Description |
|---|---|---|
| FullGroupJoinTFirst, TSecond, TKey(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey) |
+ Performs a Full Group Join between the first and second sequences.
+ |
| FullGroupJoinTFirst, TSecond, TKey(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, IEqualityComparerTKey) |
+ Performs a Full Group Join between the first and second sequences.
+ |
| FullGroupJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTKey, IEnumerableTFirst, IEnumerableTSecond, TResult) |
+ Performs a full group-join between two sequences.
+ |
| FullGroupJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTKey, IEnumerableTFirst, IEnumerableTSecond, TResult, IEqualityComparerTKey) |
+ Performs a full group-join between two sequences.
+ |
See AlsoMoreEnumerableFullJoin Method |
Overload ListSee AlsoMoreEnumerableGroupAdjacent Method |
Overload List| + + | Name | Description |
|---|---|---|
| GroupAdjacentTSource, TKey(IEnumerableTSource, FuncTSource, TKey) |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function.
+ |
| GroupAdjacentTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and compares the keys by using a
+ specified comparer.
+ |
| GroupAdjacentTSource, TKey, TElement(IEnumerableTSource, FuncTSource, TKey, FuncTSource, TElement) |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and projects the elements for
+ each group by using a specified function.
+ |
| GroupAdjacentTSource, TKey, TResult(IEnumerableTSource, FuncTSource, TKey, FuncTKey, IEnumerableTSource, TResult) |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ |
| GroupAdjacentTSource, TKey, TElement(IEnumerableTSource, FuncTSource, TKey, FuncTSource, TElement, IEqualityComparerTKey) |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ |
| GroupAdjacentTSource, TKey, TResult(IEnumerableTSource, FuncTSource, TKey, FuncTKey, IEnumerableTSource, TResult, IEqualityComparerTKey) |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ |
See AlsoMoreEnumerableIncremental Method |
Overload List| + + | Name | Description |
|---|---|---|
| IncrementalTSource, TResult(IEnumerableTSource, FuncTSource, TSource, TResult) | Obsolete.
+ Computes an incremental value between every adjacent element in a sequence: {N,N+1}, {N+1,N+2}, ...
+ |
| IncrementalTSource, TResult(IEnumerableTSource, FuncTSource, TSource, Int32, TResult) | Obsolete.
+ Computes an incremental value between every adjacent element in a sequence: {N,N+1}, {N+1,N+2}, ...
+ |
See AlsoMoreEnumerableIndex Method |
Overload List| + + | Name | Description |
|---|---|---|
| IndexTSource(IEnumerableTSource) |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the zero-based index of the value in the source
+ sequence.
+ |
| IndexTSource(IEnumerableTSource, Int32) |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the index of the value in the source sequence.
+ An additional parameter specifies the starting index.
+ |
See AlsoMoreEnumerableLag Method |
Overload List| + + | Name | Description |
|---|---|---|
| LagTSource, TResult(IEnumerableTSource, Int32, FuncTSource, TSource, TResult) |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset.
+ |
| LagTSource, TResult(IEnumerableTSource, Int32, TSource, FuncTSource, TSource, TResult) |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset.
+ |
See AlsoMoreEnumerableLead Method |
Overload List| + + | Name | Description |
|---|---|---|
| LeadTSource, TResult(IEnumerableTSource, Int32, FuncTSource, TSource, TResult) |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset.
+ |
| LeadTSource, TResult(IEnumerableTSource, Int32, TSource, FuncTSource, TSource, TResult) |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset.
+ |
See AlsoMoreEnumerableLeftJoin Method |
Overload List| + + | Name | Description |
|---|---|---|
| LeftJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TSource, TResult) |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ |
| LeftJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTFirst, TSecond, TResult) |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ |
| LeftJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TSource, TResult, IEqualityComparerTKey) |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ |
| LeftJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTFirst, TSecond, TResult, IEqualityComparerTKey) |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ |
See AlsoMoreEnumerableMaxBy Method |
Overload List| + + | Name | Description |
|---|---|---|
| MaxByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) |
+ Returns the maximal element of the given sequence, based on
+ the given projection.
+ |
| MaxByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) |
+ Returns the maximal element of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ |
See AlsoMoreEnumerableMinBy Method |
Overload List| + + | Name | Description |
|---|---|---|
| MinByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) |
+ Returns the minimal element of the given sequence, based on
+ the given projection.
+ |
| MinByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) |
+ Returns the minimal element of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ |
See AlsoMoreEnumerableOrderBy Method |
Overload List| + + | Name | Description |
|---|---|---|
| OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection) |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ |
| OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection) |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ |
See AlsoMoreEnumerableOrderedMerge Method |
Overload List| + + | Name | Description |
|---|---|---|
| OrderedMergeT(IEnumerableT, IEnumerableT) |
+ Merges two ordered sequences into one. Where the elements equal
+ in both sequences, the element from the first sequence is
+ returned in the resulting sequence.
+ |
| OrderedMergeT(IEnumerableT, IEnumerableT, IComparerT) |
+ Merges two ordered sequences into one with an additional
+ parameter specifying how to compare the elements of the
+ sequences. Where the elements equal in both sequences, the
+ element from the first sequence is returned in the resulting
+ sequence.
+ |
| OrderedMergeT, TKey(IEnumerableT, IEnumerableT, FuncT, TKey) |
+ Merges two ordered sequences into one with an additional
+ parameter specifying the element key by which the sequences are
+ ordered. Where the keys equal in both sequences, the
+ element from the first sequence is returned in the resulting
+ sequence.
+ |
| OrderedMergeT, TKey, TResult(IEnumerableT, IEnumerableT, FuncT, TKey, FuncT, TResult, FuncT, TResult, FuncT, T, TResult) |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first and the result when elements are found in
+ both sequences.
+ |
| OrderedMergeT, TKey, TResult(IEnumerableT, IEnumerableT, FuncT, TKey, FuncT, TResult, FuncT, TResult, FuncT, T, TResult, IComparerTKey) |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first, the result when elements are found in
+ both sequences and a method for comparing keys.
+ |
| OrderedMergeTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult) |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second and
+ the result when element is found in second sequence but not in
+ the first, the result when elements are found in both sequences.
+ |
| OrderedMergeTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult, IComparerTKey) |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second,
+ the result when element is found in second sequence but not in
+ the first, the result when elements are found in both sequences
+ and a method for comparing keys.
+ |
See AlsoMoreEnumerablePad Method |
Overload List| + + | Name | Description |
|---|---|---|
| PadTSource(IEnumerableTSource, Int32) |
+ Pads a sequence with default values if it is narrower (shorter
+ in length) than a given width.
+ |
| PadTSource(IEnumerableTSource, Int32, FuncInt32, TSource) |
+ Pads a sequence with a dynamic filler value if it is narrower (shorter
+ in length) than a given width.
+ |
| PadTSource(IEnumerableTSource, Int32, TSource) |
+ Pads a sequence with a given filler value if it is narrower (shorter
+ in length) than a given width.
+ |
See AlsoMoreEnumerablePadStart Method |
Overload List| + + | Name | Description |
|---|---|---|
| PadStartTSource(IEnumerableTSource, Int32) |
+ Pads a sequence with default values in the beginning if it is narrower (shorter
+ in length) than a given width.
+ |
| PadStartTSource(IEnumerableTSource, Int32, FuncInt32, TSource) |
+ Pads a sequence with a dynamic filler value in the beginning if it is narrower (shorter
+ in length) than a given width.
+ An additional parameter specifies the function to calculate padding.
+ |
| PadStartTSource(IEnumerableTSource, Int32, TSource) |
+ Pads a sequence with a given filler value in the beginning if it is narrower (shorter
+ in length) than a given width.
+ An additional parameter specifies the value to use for padding.
+ |
See AlsoMoreEnumerablePartialSort Method |
Overload ListSee AlsoMoreEnumerablePartialSortBy Method |
Overload ListSee AlsoMoreEnumerablePartition Method |
Overload ListSee AlsoMoreEnumerableRandom Method |
Overload List| + + | Name | Description |
|---|---|---|
| Random |
+ Returns an infinite sequence of random integers using the standard
+ .NET random number generator.
+ |
| Random(Int32) |
+ Returns an infinite sequence of random integers between zero and
+ a given maximum.
+ |
| Random(Random) |
+ Returns an infinite sequence of random integers using the supplied
+ random number generator.
+ |
| Random(Int32, Int32) |
+ Returns an infinite sequence of random integers between a given
+ minimum and a maximum.
+ |
| Random(Random, Int32) |
+ Returns an infinite sequence of random integers between zero and a
+ given maximum using the supplied random number generator.
+ |
| Random(Random, Int32, Int32) |
+ Returns an infinite sequence of random integers between a given
+ minumum and a maximum using the supplied random number generator.
+ |
See AlsoMoreEnumerableRandomDouble Method |
Overload List| + + | Name | Description |
|---|---|---|
| RandomDouble |
+ Returns an infinite sequence of random double values between 0.0 and 1.0
+ |
| RandomDouble(Random) |
+ Returns an infinite sequence of random double values between 0.0 and 1.0
+ using the supplied random number generator.
+ |
See AlsoMoreEnumerableRandomSubset Method |
Overload List| + + | Name | Description |
|---|---|---|
| RandomSubsetT(IEnumerableT, Int32) |
+ Returns a sequence of a specified size of random elements from the original sequence
+ |
| RandomSubsetT(IEnumerableT, Int32, Random) |
+ Returns a sequence of a specified size of random elements from the original sequence
+ |
See AlsoMoreEnumerableRank Method |
Overload List| + + | Name | Description |
|---|---|---|
| RankTSource(IEnumerableTSource) |
+ Ranks each item in the sequence in descending ordering using a default comparer.
+ |
| RankTSource(IEnumerableTSource, IComparerTSource) |
+ Rank each item in the sequence using a caller-supplied comparer.
+ |
See AlsoMoreEnumerableRankBy Method |
Overload List| + + | Name | Description |
|---|---|---|
| RankByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) |
+ Ranks each item in the sequence in descending ordering by a specified key using a default comparer
+ |
| RankByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) |
+ Ranks each item in a sequence using a specified key and a caller-supplied comparer
+ |
See AlsoMoreEnumerableRepeat Method |
Overload List| + + | Name | Description |
|---|---|---|
| RepeatT(IEnumerableT) |
+ Repeats the sequence forever.
+ |
| RepeatT(IEnumerableT, Int32) |
+ Repeats the sequence the specified number of times.
+ |
See AlsoMoreEnumerableRightJoin Method |
Overload List| + + | Name | Description |
|---|---|---|
| RightJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TSource, TResult) |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ |
| RightJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTSecond, TResult, FuncTFirst, TSecond, TResult) |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ |
| RightJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TSource, TResult, IEqualityComparerTKey) |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ |
| RightJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTSecond, TResult, FuncTFirst, TSecond, TResult, IEqualityComparerTKey) |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ |
See AlsoMoreEnumerableRunLengthEncode Method |
Overload List| + + | Name | Description |
|---|---|---|
| RunLengthEncodeT(IEnumerableT) |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count.
+ |
| RunLengthEncodeT(IEnumerableT, IEqualityComparerT) |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count. This overload
+ uses a custom equality comparer to identify equivalent items.
+ |
See AlsoMoreEnumerableScan Method |
Overload List| + + | Name | Description |
|---|---|---|
| ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) |
+ Peforms a scan (inclusive prefix sum) on a sequence of elements.
+ |
| ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) |
+ Like AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) except returns
+ the sequence of intermediate results as well as the final one.
+ An additional parameter specifies a seed.
+ |
See AlsoMoreEnumerableScanRight Method |
Overload List| + + | Name | Description |
|---|---|---|
| ScanRightTSource(IEnumerableTSource, FuncTSource, TSource, TSource) |
+ Peforms a right-associative scan (inclusive prefix) on a sequence of elements.
+ This operator is the right-associative version of the
+ ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ |
| ScanRightTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate) |
+ Peforms a right-associative scan (inclusive prefix) on a sequence of elements.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) LINQ operator.
+ |
See AlsoMoreEnumerableSegment Method |
Overload List| + + | Name | Description |
|---|---|---|
| SegmentT(IEnumerableT, FuncT, Boolean) |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ |
| SegmentT(IEnumerableT, FuncT, Int32, Boolean) |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ |
| SegmentT(IEnumerableT, FuncT, T, Int32, Boolean) |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ |
See AlsoMoreEnumerableSequence Method |
Overload List| + + | Name | Description |
|---|---|---|
| Sequence(Int32, Int32) |
+ Generates a sequence of integral numbers within the (inclusive) specified range.
+ If sequence is ascending the step is +1, otherwise -1.
+ |
| Sequence(Int32, Int32, Int32) |
+ Generates a sequence of integral numbers within the (inclusive) specified range.
+ An additional parameter specifies the steps in which the integers of the sequence increase or decrease.
+ |
See AlsoMoreEnumerableSortedMerge Method |
Overload List| + + | Name | Description |
|---|---|---|
| SortedMergeTSource(IEnumerableTSource, OrderByDirection, IEnumerableTSource) |
+ Merges two or more sequences that are in a common order (either ascending or descending) into
+ a single sequence that preserves that order.
+ |
| SortedMergeTSource(IEnumerableTSource, OrderByDirection, IComparerTSource, IEnumerableTSource) |
+ Merges two or more sequences that are in a common order (either ascending or descending) into
+ a single sequence that preserves that order.
+ |
See AlsoMoreEnumerableSplit Method |
Overload List| + + | Name | Description |
|---|---|---|
| SplitTSource(IEnumerableTSource, FuncTSource, Boolean) |
+ Splits the source sequence by separator elements identified by a
+ function.
+ |
| SplitTSource(IEnumerableTSource, TSource) |
+ Splits the source sequence by a separator.
+ |
| SplitTSource, TResult(IEnumerableTSource, FuncTSource, Boolean, FuncIEnumerableTSource, TResult) |
+ Splits the source sequence by separator elements identified by
+ a function and then transforms the splits into results.
+ |
| SplitTSource(IEnumerableTSource, FuncTSource, Boolean, Int32) |
+ Splits the source sequence by separator elements identified by a
+ function, given a maximum count of splits.
+ |
| SplitTSource(IEnumerableTSource, TSource, IEqualityComparerTSource) |
+ Splits the source sequence by a separator and then transforms the
+ splits into results.
+ |
| SplitTSource, TResult(IEnumerableTSource, TSource, FuncIEnumerableTSource, TResult) |
+ Splits the source sequence by a separator and then transforms
+ the splits into results.
+ |
| SplitTSource(IEnumerableTSource, TSource, Int32) |
+ Splits the source sequence by a separator given a maximum count of splits.
+ |
| SplitTSource, TResult(IEnumerableTSource, FuncTSource, Boolean, Int32, FuncIEnumerableTSource, TResult) |
+ Splits the source sequence by separator elements identified by
+ a function, given a maximum count of splits, and then transforms
+ the splits into results.
+ |
| SplitTSource, TResult(IEnumerableTSource, TSource, IEqualityComparerTSource, FuncIEnumerableTSource, TResult) |
+ Splits the source sequence by a separator and then transforms the
+ splits into results. A parameter specifies how the separator is
+ compared for equality.
+ |
| SplitTSource(IEnumerableTSource, TSource, IEqualityComparerTSource, Int32) |
+ Splits the source sequence by a separator, given a maximum count
+ of splits. A parameter specifies how the separator is compared
+ for equality.
+ |
| SplitTSource, TResult(IEnumerableTSource, TSource, Int32, FuncIEnumerableTSource, TResult) |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results.
+ |
| SplitTSource, TResult(IEnumerableTSource, TSource, IEqualityComparerTSource, Int32, FuncIEnumerableTSource, TResult) |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results. A
+ parameter specifies how the separator is compared for equality.
+ |
See AlsoMoreEnumerableStartsWith Method |
Overload List| + + | Name | Description |
|---|---|---|
| StartsWithT(IEnumerableT, IEnumerableT) |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the default equality
+ comparer.
+ |
| StartsWithT(IEnumerableT, IEnumerableT, IEqualityComparerT) |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the specified element
+ equality comparer.
+ |
See AlsoMoreEnumerableSubsets Method |
Overload List| + + | Name | Description |
|---|---|---|
| SubsetsT(IEnumerableT) |
+ Returns a sequence of IListT representing all of
+ the subsets of any size that are part of the original sequence. In
+ mathematics, it is equivalent to the power set of a set.
+ |
| SubsetsT(IEnumerableT, Int32) |
+ Returns a sequence of IListT representing all
+ subsets of a given size that are part of the original sequence. In
+ mathematics, it is equivalent to the combinations or
+ k-subsets of a set.
+ |
See AlsoMoreEnumerableThenBy Method |
Overload List| + + | Name | Description |
|---|---|---|
| ThenByT, TKey(IOrderedEnumerableT, FuncT, TKey, OrderByDirection) |
+ Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key
+ |
| ThenByT, TKey(IOrderedEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection) |
+ Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key
+ |
See AlsoMoreEnumerableToArrayByIndex Method |
Overload List| + + | Name | Description |
|---|---|---|
| ToArrayByIndexT(IEnumerableT, FuncT, Int32) |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array.
+ |
| ToArrayByIndexT, TResult(IEnumerableT, FuncT, Int32, FuncT, TResult) |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ |
| ToArrayByIndexT, TResult(IEnumerableT, FuncT, Int32, FuncT, Int32, TResult) |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ |
| ToArrayByIndexT(IEnumerableT, Int32, FuncT, Int32) |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array.
+ |
| ToArrayByIndexT, TResult(IEnumerableT, Int32, FuncT, Int32, FuncT, TResult) |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ |
| ToArrayByIndexT, TResult(IEnumerableT, Int32, FuncT, Int32, FuncT, Int32, TResult) |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ |
See AlsoMoreEnumerableToDataTable Method |
Overload List| + + | Name | Description |
|---|---|---|
| ToDataTableT(IEnumerableT) |
+ Converts a sequence to a DataTable object.
+ |
| ToDataTableT(IEnumerableT, ExpressionFuncT, Object) |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ |
| ToDataTableT, TTable(IEnumerableT, TTable) |
+ Appends elements in the sequence as rows of a given DataTable object.
+ |
| ToDataTableT, TTable(IEnumerableT, TTable, ExpressionFuncT, Object) |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ |
See AlsoMoreEnumerableToDelimitedString Method |
Overload List| + + | Name | Description |
|---|---|---|
| ToDelimitedString(IEnumerableBoolean) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableByte) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableChar) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableDecimal) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableDouble) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableInt16) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableInt32) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableInt64) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableSByte) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableSingle) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableString) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableUInt16) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableUInt32) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableUInt64) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedStringTSource(IEnumerableTSource) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableBoolean, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableByte, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableChar, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableDecimal, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableDouble, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableInt16, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableInt32, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableInt64, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableSByte, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableSingle, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableString, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableUInt16, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableUInt32, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableUInt64, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedStringTSource(IEnumerableTSource, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
See AlsoMoreEnumerableToDictionary Method |
Overload List| + + | Name | Description |
|---|---|---|
| ToDictionaryTKey, TValue(IEnumerableKeyValuePairTKey, TValue) |
+ Creates a DictionaryTKey, TValue from a sequence of
+ KeyValuePairTKey, TValue elements.
+ |
| ToDictionaryTKey, TValue(IEnumerableValueTupleTKey, TValue) |
+ Creates a DictionaryTKey, TValue from a sequence of
+ tuples of 2 where the first item is the key and the second the
+ value.
+ |
| ToDictionaryTKey, TValue(IEnumerableKeyValuePairTKey, TValue, IEqualityComparerTKey) |
+ Creates a DictionaryTKey, TValue from a sequence of
+ KeyValuePairTKey, TValue elements. An additional
+ parameter specifies a comparer for keys.
+ |
| ToDictionaryTKey, TValue(IEnumerableValueTupleTKey, TValue, IEqualityComparerTKey) |
+ Creates a DictionaryTKey, TValue from a sequence of
+ tuples of 2 where the first item is the key and the second the
+ value. An additional parameter specifies a comparer for keys.
+ |
See AlsoMoreEnumerableToHashSet Method |
Overload List| + + | Name | Description |
|---|---|---|
| ToHashSetTSource(IEnumerableTSource) |
+ Returns a HashSetT of the source items using the default equality
+ comparer for the type.
+ |
| ToHashSetTSource(IEnumerableTSource, IEqualityComparerTSource) |
+ Returns a HashSetT of the source items using the specified equality
+ comparer for the type.
+ |
See AlsoMoreEnumerableToLookup Method |
Overload List| + + | Name | Description |
|---|---|---|
| ToLookupTKey, TValue(IEnumerableKeyValuePairTKey, TValue) |
+ Creates a ILookupTKey, TElement from a sequence of
+ KeyValuePairTKey, TValue elements.
+ |
| ToLookupTKey, TValue(IEnumerableValueTupleTKey, TValue) |
+ Creates a Lookup from a sequence of
+ tuples of 2 where the first item is the key and the second the
+ value.
+ |
| ToLookupTKey, TValue(IEnumerableKeyValuePairTKey, TValue, IEqualityComparerTKey) |
+ Creates a ILookupTKey, TElement from a sequence of
+ KeyValuePairTKey, TValue elements. An additional
+ parameter specifies a comparer for keys.
+ |
| ToLookupTKey, TValue(IEnumerableValueTupleTKey, TValue, IEqualityComparerTKey) |
+ Creates a Lookup from a sequence of
+ tuples of 2 where the first item is the key and the second the
+ value. An additional parameter specifies a comparer for keys.
+ |
See AlsoMoreEnumerableTrace Method |
Overload List| + + | Name | Description |
|---|---|---|
| TraceTSource(IEnumerableTSource) |
+ Traces the elements of a source sequence for diagnostics.
+ |
| TraceTSource(IEnumerableTSource, FuncTSource, String) |
+ Traces the elements of a source sequence for diagnostics using
+ a custom formatter.
+ |
| TraceTSource(IEnumerableTSource, String) |
+ Traces the elements of a source sequence for diagnostics using
+ custom formatting.
+ |
See AlsoMoreEnumerableZipShortest Method |
Overload List| + + | Name | Description |
|---|---|---|
| ZipShortestTFirst, TSecond, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) |
+ Returns a projection of tuples, where each tuple contains the N-th element
+ from each of the argument sequences.
+ |
| ZipShortestT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) |
+ Returns a projection of tuples, where each tuple contains the N-th element
+ from each of the argument sequences.
+ |
| ZipShortestT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) |
+ Returns a projection of tuples, where each tuple contains the N-th element
+ from each of the argument sequences.
+ |
See AlsoSequenceException Constructor |
Overload List| + + | Name | Description |
|---|---|---|
| SequenceException |
+ Initializes a new instance of the SequenceException class.
+ |
| SequenceException(String) |
+ Initializes a new instance of the SequenceException class
+ with a given error message.
+ |
| SequenceException(SerializationInfo, StreamingContext) |
+ Initializes a new instance of the SequenceException class
+ with serialized data.
+ |
| SequenceException(String, Exception) |
+ Initializes a new instance of the SequenceException class
+ with a given error message and a reference to the inner exception
+ that is the cause of the exception.
+ |
See AlsoSequenceException Properties |
The SequenceException type exposes the following members.
Properties| + + | Name | Description |
|---|---|---|
 | Data | Gets a collection of key/value pairs that provide additional user-defined information about the exception. (Inherited from Exception.) |
| HelpLink | Gets or sets a link to the help file associated with this exception. (Inherited from Exception.) |
 | HResult | Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception. (Inherited from Exception.) |
| InnerException | Gets the Exception instance that caused the current exception. (Inherited from Exception.) |
| Message | Gets a message that describes the current exception. (Inherited from Exception.) |
| Source | Gets or sets the name of the application or the object that causes the error. (Inherited from Exception.) |
| StackTrace | Gets a string representation of the immediate frames on the call stack. (Inherited from Exception.) |
| TargetSite | Gets the method that throws the current exception. (Inherited from Exception.) |
See AlsoMoreEnumerable Class |
Inheritance Hierarchy+ Namespace: + MoreLinq
SyntaxThe MoreEnumerable type exposes the following members.
Methods| + + | Name | Description |
|---|---|---|
| AcquireTSource |
+ Ensures that a source sequence of IDisposable
+ objects are all acquired successfully. If the acquisition of any
+ one IDisposable fails then those successfully
+ acquired till that point are disposed.
+ |
| AggregateRightTSource(IEnumerableTSource, FuncTSource, TSource, TSource) |
+ Applies a right-associative accumulator function over a sequence.
+ This operator is the right-associative version of the
+ AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ |
| AggregateRightTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate) |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate) LINQ operator.
+ |
| AggregateRightTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate, FuncTAccumulate, TResult) |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value,
+ and the specified function is used to select the result value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate, FuncTAccumulate, TResult) LINQ operator.
+ |
| AssertTSource(IEnumerableTSource, FuncTSource, Boolean) |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ |
| AssertTSource(IEnumerableTSource, FuncTSource, Boolean, FuncTSource, Exception) |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ |
| AssertCountTSource(IEnumerableTSource, Int32) |
+ Asserts that a source sequence contains a given count of elements.
+ |
| AssertCountTSource(IEnumerableTSource, Int32, FuncInt32, Int32, Exception) |
+ Asserts that a source sequence contains a given count of elements.
+ A parameter specifies the exception to be thrown.
+ |
| AtLeastT |
+ Determines whether or not the number of elements in the sequence is greater than
+ or equal to the given integer.
+ |
| AtMostT |
+ Determines whether or not the number of elements in the sequence is lesser than
+ or equal to the given integer.
+ |
| BatchTSource(IEnumerableTSource, Int32) |
+ Batches the source sequence into sized buckets.
+ |
| BatchTSource, TResult(IEnumerableTSource, Int32, FuncIEnumerableTSource, TResult) |
+ Batches the source sequence into sized buckets and applies a projection to each bucket.
+ |
| CartesianTFirst, TSecond, TResult |
+ Returns the Cartesian product of two sequences by combining each element of the first set with each in the second
+ and applying the user=define projection to the pair.
+ |
| ConcatT(IEnumerableT, T) |
+ Returns a sequence consisting of the head elements and the given tail element.
+ |
| ConcatT(T, IEnumerableT) |
+ Returns a sequence consisting of the head element and the given tail elements.
+ |
| ConsumeT |
+ Completely consumes the given sequence. This method uses immediate execution,
+ and doesn't store any data during execution.
+ |
| CountBetweenT |
+ Determines whether or not the number of elements in the sequence is between
+ an inclusive range of minimum and maximum integers.
+ |
| CountByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ |
| CountByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ An additional argument specifies a comparer to use for testing equivalence of keys.
+ |
| DistinctByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the default equality comparer for the projected type.
+ |
| DistinctByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the specified comparer for the projected type.
+ |
| EndsWithT(IEnumerableT, IEnumerableT) |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the default equality comparer.
+ |
| EndsWithT(IEnumerableT, IEnumerableT, IEqualityComparerT) |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the specified element equality comparer.
+ |
| EquiZipTFirst, TSecond, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) |
+ Returns a projection of tuples, where each tuple contains the N-th element
+ from each of the argument sequences.
+ |
| EquiZipT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) |
+ Returns a projection of tuples, where each tuple contains the N-th element
+ from each of the argument sequences.
+ |
| EquiZipT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) |
+ Returns a projection of tuples, where each tuple contains the N-th element
+ from each of the argument sequences.
+ |
| EvaluateT |
+ Returns a sequence containing the values resulting from invoking (in order) each function in the source sequence of functions.
+ |
| ExactlyT |
+ Determines whether or not the number of elements in the sequence is equals to the given integer.
+ |
| ExceptByTSource, TKey(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey) |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ |
| ExceptByTSource, TKey(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ |
| ExcludeT |
+ Excludes a contiguous number of elements from a sequence starting
+ at a given index.
+ |
| FallbackIfEmptyT(IEnumerableT, IEnumerableT) |
+ Returns the elements of a sequence, but if it is empty then
+ returns an altenate sequence of values.
+ |
| FallbackIfEmptyT(IEnumerableT, T) |
+ Returns the elements of the specified sequence or the specified
+ value in a singleton collection if the sequence is empty.
+ |
| FallbackIfEmptyT(IEnumerableT, T) |
+ Returns the elements of a sequence, but if it is empty then
+ returns an altenate sequence from an array of values.
+ |
| FallbackIfEmptyT(IEnumerableT, T, T) |
+ Returns the elements of a sequence, but if it is empty then
+ returns an altenate sequence of values.
+ |
| FallbackIfEmptyT(IEnumerableT, T, T, T) |
+ Returns the elements of a sequence, but if it is empty then
+ returns an altenate sequence of values.
+ |
| FallbackIfEmptyT(IEnumerableT, T, T, T, T) |
+ Returns the elements of a sequence, but if it is empty then
+ returns an altenate sequence of values.
+ |
| FillBackwardT(IEnumerableT) |
+ Returns a sequence with each null reference or value in the source
+ replaced with the following non-null reference or value in
+ that sequence.
+ |
| FillBackwardT(IEnumerableT, FuncT, Boolean) |
+ Returns a sequence with each missing element in the source replaced
+ with the following non-missing element in that sequence. An
+ additional parameter specifies a function used to determine if an
+ element is considered missing or not.
+ |
| FillBackwardT(IEnumerableT, FuncT, Boolean, FuncT, T, T) |
+ Returns a sequence with each missing element in the source replaced
+ with the following non-missing element in that sequence. Additional
+ parameters specifiy two functions, one used to determine if an
+ element is considered missing or not and another to provide the
+ replacement for the missing element.
+ |
| FillForwardT(IEnumerableT) |
+ Returns a sequence with each null reference or value in the source
+ replaced with the previous non-null reference or value seen in
+ that sequence.
+ |
| FillForwardT(IEnumerableT, FuncT, Boolean) |
+ Returns a sequence with each missing element in the source replaced
+ with the previous non-missing element seen in that sequence. An
+ additional parameter specifies a function used to determine if an
+ element is considered missing or not.
+ |
| FillForwardT(IEnumerableT, FuncT, Boolean, FuncT, T, T) |
+ Returns a sequence with each missing element in the source replaced
+ with one based on the previous non-missing element seen in that
+ sequence. Additional parameters specifiy two functions, one used to
+ determine if an element is considered missing or not and another
+ to provide the replacement for the missing element.
+ |
| Flatten(IEnumerable) |
+ Flattens a sequence containing arbitrarily-nested sequences.
+ |
| Flatten(IEnumerable, FuncIEnumerable, Boolean) |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a predicate function used to
+ determine whether a nested IEnumerable should be
+ flattened or not.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 9 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 10 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 11 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 12 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 13 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 14 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 15 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 16 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, TResult) |
+ Returns the result of applying a function to a sequence of
+ 1 element.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 2 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 3 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 4 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 5 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 6 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 7 elements.
+ |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, TResult) |
+ Returns the result of applying a function to a sequence of
+ 8 elements.
+ |
| ForEachT(IEnumerableT, ActionT) |
+ Immediately executes the given action on each element in the source sequence.
+ |
| ForEachT(IEnumerableT, ActionT, Int32) |
+ Immediately executes the given action on each element in the source sequence.
+ Each element's index is used in the logic of the action.
+ |
| FromT(FuncT) |
+ Returns a single-element sequence containing the result of invoking the function.
+ |
| FromT(FuncT) |
+ Returns a sequence containing the values resulting from invoking (in order) each function in the source sequence of functions.
+ |
| FromT(FuncT, FuncT) |
+ Returns a sequence containing the result of invoking each parameter function in order.
+ |
| FromT(FuncT, FuncT, FuncT) |
+ Returns a sequence containing the result of invoking each parameter function in order.
+ |
| FullGroupJoinTFirst, TSecond, TKey(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey) |
+ Performs a Full Group Join between the first and second sequences.
+ |
| FullGroupJoinTFirst, TSecond, TKey(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, IEqualityComparerTKey) |
+ Performs a Full Group Join between the first and second sequences.
+ |
| FullGroupJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTKey, IEnumerableTFirst, IEnumerableTSecond, TResult) |
+ Performs a full group-join between two sequences.
+ |
| FullGroupJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTKey, IEnumerableTFirst, IEnumerableTSecond, TResult, IEqualityComparerTKey) |
+ Performs a full group-join between two sequences.
+ |
| FullJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TResult, FuncTSource, TSource, TResult) |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ |
| FullJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TResult, FuncTSource, TSource, TResult, IEqualityComparerTKey) |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ |
| FullJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult) |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ |
| FullJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult, IEqualityComparerTKey) |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ |
| GenerateTResult |
+ Returns a sequence of values consecutively generated by a generator function.
+ |
| GenerateByIndexTResult |
+ Returns a sequence of values based on indexes.
+ |
| GroupAdjacentTSource, TKey(IEnumerableTSource, FuncTSource, TKey) |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function.
+ |
| GroupAdjacentTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and compares the keys by using a
+ specified comparer.
+ |
| GroupAdjacentTSource, TKey, TElement(IEnumerableTSource, FuncTSource, TKey, FuncTSource, TElement) |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and projects the elements for
+ each group by using a specified function.
+ |
| GroupAdjacentTSource, TKey, TResult(IEnumerableTSource, FuncTSource, TKey, FuncTKey, IEnumerableTSource, TResult) |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ |
| GroupAdjacentTSource, TKey, TElement(IEnumerableTSource, FuncTSource, TKey, FuncTSource, TElement, IEqualityComparerTKey) |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ |
| GroupAdjacentTSource, TKey, TResult(IEnumerableTSource, FuncTSource, TKey, FuncTKey, IEnumerableTSource, TResult, IEqualityComparerTKey) |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ |
| IncrementalTSource, TResult(IEnumerableTSource, FuncTSource, TSource, TResult) | Obsolete.
+ Computes an incremental value between every adjacent element in a sequence: {N,N+1}, {N+1,N+2}, ...
+ |
| IncrementalTSource, TResult(IEnumerableTSource, FuncTSource, TSource, Int32, TResult) | Obsolete.
+ Computes an incremental value between every adjacent element in a sequence: {N,N+1}, {N+1,N+2}, ...
+ |
| IndexTSource(IEnumerableTSource) |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the zero-based index of the value in the source
+ sequence.
+ |
| IndexTSource(IEnumerableTSource, Int32) |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the index of the value in the source sequence.
+ An additional parameter specifies the starting index.
+ |
| InsertT |
+ Inserts the elements of a sequence into another sequence at a
+ specified index.
+ |
| InterleaveT |
+ Interleaves the elements of two or more sequences into a single sequence, skipping sequences as they are consumed
+ |
| LagTSource, TResult(IEnumerableTSource, Int32, FuncTSource, TSource, TResult) |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset.
+ |
| LagTSource, TResult(IEnumerableTSource, Int32, TSource, FuncTSource, TSource, TResult) |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset.
+ |
| LeadTSource, TResult(IEnumerableTSource, Int32, FuncTSource, TSource, TResult) |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset.
+ |
| LeadTSource, TResult(IEnumerableTSource, Int32, TSource, FuncTSource, TSource, TResult) |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset.
+ |
| LeftJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TSource, TResult) |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ |
| LeftJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TSource, TResult, IEqualityComparerTKey) |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ |
| LeftJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTFirst, TSecond, TResult) |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ |
| LeftJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTFirst, TSecond, TResult, IEqualityComparerTKey) |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ |
| MaxByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) |
+ Returns the maximal element of the given sequence, based on
+ the given projection.
+ |
| MaxByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) |
+ Returns the maximal element of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ |
| MinByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) |
+ Returns the minimal element of the given sequence, based on
+ the given projection.
+ |
| MinByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) |
+ Returns the minimal element of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ |
| MoveT |
+ Returns a sequence with a range of elements in the source sequence
+ moved to a new offset.
+ |
| NestedLoops |
+ Produces a sequence from an action based on the dynamic generation of N nested loops
+ whose iteration counts are defined by a sequence of loop counts.
+ |
| OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection) |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ |
| OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection) |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ |
| OrderedMergeT(IEnumerableT, IEnumerableT) |
+ Merges two ordered sequences into one. Where the elements equal
+ in both sequences, the element from the first sequence is
+ returned in the resulting sequence.
+ |
| OrderedMergeT(IEnumerableT, IEnumerableT, IComparerT) |
+ Merges two ordered sequences into one with an additional
+ parameter specifying how to compare the elements of the
+ sequences. Where the elements equal in both sequences, the
+ element from the first sequence is returned in the resulting
+ sequence.
+ |
| OrderedMergeT, TKey(IEnumerableT, IEnumerableT, FuncT, TKey) |
+ Merges two ordered sequences into one with an additional
+ parameter specifying the element key by which the sequences are
+ ordered. Where the keys equal in both sequences, the
+ element from the first sequence is returned in the resulting
+ sequence.
+ |
| OrderedMergeT, TKey, TResult(IEnumerableT, IEnumerableT, FuncT, TKey, FuncT, TResult, FuncT, TResult, FuncT, T, TResult) |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first and the result when elements are found in
+ both sequences.
+ |
| OrderedMergeT, TKey, TResult(IEnumerableT, IEnumerableT, FuncT, TKey, FuncT, TResult, FuncT, TResult, FuncT, T, TResult, IComparerTKey) |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first, the result when elements are found in
+ both sequences and a method for comparing keys.
+ |
| OrderedMergeTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult) |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second and
+ the result when element is found in second sequence but not in
+ the first, the result when elements are found in both sequences.
+ |
| OrderedMergeTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult, IComparerTKey) |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second,
+ the result when element is found in second sequence but not in
+ the first, the result when elements are found in both sequences
+ and a method for comparing keys.
+ |
| PadTSource(IEnumerableTSource, Int32) |
+ Pads a sequence with default values if it is narrower (shorter
+ in length) than a given width.
+ |
| PadTSource(IEnumerableTSource, Int32, FuncInt32, TSource) |
+ Pads a sequence with a dynamic filler value if it is narrower (shorter
+ in length) than a given width.
+ |
| PadTSource(IEnumerableTSource, Int32, TSource) |
+ Pads a sequence with a given filler value if it is narrower (shorter
+ in length) than a given width.
+ |
| PadStartTSource(IEnumerableTSource, Int32) |
+ Pads a sequence with default values in the beginning if it is narrower (shorter
+ in length) than a given width.
+ |
| PadStartTSource(IEnumerableTSource, Int32, FuncInt32, TSource) |
+ Pads a sequence with a dynamic filler value in the beginning if it is narrower (shorter
+ in length) than a given width.
+ An additional parameter specifies the function to calculate padding.
+ |
| PadStartTSource(IEnumerableTSource, Int32, TSource) |
+ Pads a sequence with a given filler value in the beginning if it is narrower (shorter
+ in length) than a given width.
+ An additional parameter specifies the value to use for padding.
+ |
| PairwiseTSource, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence and its
+ predecessor, with the exception of the first element which is
+ only returned as the predecessor of the second element.
+ |
| PartialSortT(IEnumerableT, Int32) |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ |
| PartialSortT(IEnumerableT, Int32, OrderByDirection) |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ An additional parameter specifies the direction of the sort
+ |
| PartialSortT(IEnumerableT, Int32, IComparerT) |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation. An additional parameter specifies how the
+ elements compare to each other.
+ |
| PartialSortT(IEnumerableT, Int32, IComparerT, OrderByDirection) |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ |
| PartialSortByTSource, TKey(IEnumerableTSource, Int32, FuncTSource, TKey) |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ |
| PartialSortByTSource, TKey(IEnumerableTSource, Int32, FuncTSource, TKey, OrderByDirection) |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies the direction of the sort
+ |
| PartialSortByTSource, TKey(IEnumerableTSource, Int32, FuncTSource, TKey, IComparerTKey) |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies how the keys compare to each other.
+ |
| PartialSortByTSource, TKey(IEnumerableTSource, Int32, FuncTSource, TKey, IComparerTKey, OrderByDirection) |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ |
| PartitionT(IEnumerableT, FuncT, Boolean) |
+ Partitions or splits a sequence in two using a predicate.
+ |
| PartitionT, TResult(IEnumerableIGroupingBoolean, T, FuncIEnumerableT, IEnumerableT, TResult) |
+ Partitions a grouping by Boolean keys into a projection of true
+ elements and false elements, respectively.
+ |
| PartitionT, TResult(IEnumerableIGroupingNullableBoolean, T, FuncIEnumerableT, IEnumerableT, IEnumerableT, TResult) |
+ Partitions a grouping by nullable Boolean keys into a projection of
+ true elements, false elements and null elements, respectively.
+ |
| PartitionT, TResult(IEnumerableT, FuncT, Boolean, FuncIEnumerableT, IEnumerableT, TResult) |
+ Partitions or splits a sequence in two using a predicate and then
+ projects a result from the two.
+ |
| PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, FuncIEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) |
+ Partitions a grouping and projects a result from group elements
+ matching a key and those groups that do not.
+ |
| PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, IEqualityComparerTKey, FuncIEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) |
+ Partitions a grouping and projects a result from group elements
+ matching a key and those groups that do not. An additional parameter
+ specifies how to compare keys for equality.
+ |
| PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, TKey, FuncIEnumerableTElement, IEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) |
+ Partitions a grouping and projects a result from elements of
+ groups matching a set of two keys and those groups that do not.
+ |
| PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, TKey, IEqualityComparerTKey, FuncIEnumerableTElement, IEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) |
+ Partitions a grouping and projects a result from elements of
+ groups matching a set of two keys and those groups that do not.
+ An additional parameter specifies how to compare keys for equality.
+ |
| PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, TKey, TKey, FuncIEnumerableTElement, IEnumerableTElement, IEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) |
+ Partitions a grouping and projects a result from elements groups
+ matching a set of three keys and those groups that do not.
+ |
| PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, TKey, TKey, IEqualityComparerTKey, FuncIEnumerableTElement, IEnumerableTElement, IEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) |
+ Partitions a grouping and projects a result from elements groups
+ matching a set of three keys and those groups that do not. An
+ additional parameter specifies how to compare keys for equality.
+ |
| PermutationsT |
+ Generates a sequence of lists that represent the permutations of the original sequence.
+ |
| PipeT |
+ Executes the given action on each element in the source sequence
+ and yields it.
+ |
| PrependTSource |
+ Prepends a single value to a sequence.
+ |
| PreScanTSource |
+ Performs a pre-scan (exclusive prefix sum) on a sequence of elements.
+ |
| Random |
+ Returns an infinite sequence of random integers using the standard
+ .NET random number generator.
+ |
| Random(Int32) |
+ Returns an infinite sequence of random integers between zero and
+ a given maximum.
+ |
| Random(Random) |
+ Returns an infinite sequence of random integers using the supplied
+ random number generator.
+ |
| Random(Int32, Int32) |
+ Returns an infinite sequence of random integers between a given
+ minimum and a maximum.
+ |
| Random(Random, Int32) |
+ Returns an infinite sequence of random integers between zero and a
+ given maximum using the supplied random number generator.
+ |
| Random(Random, Int32, Int32) |
+ Returns an infinite sequence of random integers between a given
+ minumum and a maximum using the supplied random number generator.
+ |
| RandomDouble |
+ Returns an infinite sequence of random double values between 0.0 and 1.0
+ |
| RandomDouble(Random) |
+ Returns an infinite sequence of random double values between 0.0 and 1.0
+ using the supplied random number generator.
+ |
| RandomSubsetT(IEnumerableT, Int32) |
+ Returns a sequence of a specified size of random elements from the original sequence
+ |
| RandomSubsetT(IEnumerableT, Int32, Random) |
+ Returns a sequence of a specified size of random elements from the original sequence
+ |
| RankTSource(IEnumerableTSource) |
+ Ranks each item in the sequence in descending ordering using a default comparer.
+ |
| RankTSource(IEnumerableTSource, IComparerTSource) |
+ Rank each item in the sequence using a caller-supplied comparer.
+ |
| RankByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) |
+ Ranks each item in the sequence in descending ordering by a specified key using a default comparer
+ |
| RankByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) |
+ Ranks each item in a sequence using a specified key and a caller-supplied comparer
+ |
| RepeatT(IEnumerableT) |
+ Repeats the sequence forever.
+ |
| RepeatT(IEnumerableT, Int32) |
+ Repeats the sequence the specified number of times.
+ |
| RightJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TSource, TResult) |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ |
| RightJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TSource, TResult, IEqualityComparerTKey) |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ |
| RightJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTSecond, TResult, FuncTFirst, TSecond, TResult) |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ |
| RightJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTSecond, TResult, FuncTFirst, TSecond, TResult, IEqualityComparerTKey) |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ |
| RunLengthEncodeT(IEnumerableT) |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count.
+ |
| RunLengthEncodeT(IEnumerableT, IEqualityComparerT) |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count. This overload
+ uses a custom equality comparer to identify equivalent items.
+ |
| ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) |
+ Peforms a scan (inclusive prefix sum) on a sequence of elements.
+ |
| ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) |
+ Like AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) except returns
+ the sequence of intermediate results as well as the final one.
+ An additional parameter specifies a seed.
+ |
| ScanRightTSource(IEnumerableTSource, FuncTSource, TSource, TSource) |
+ Peforms a right-associative scan (inclusive prefix) on a sequence of elements.
+ This operator is the right-associative version of the
+ ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ |
| ScanRightTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate) |
+ Peforms a right-associative scan (inclusive prefix) on a sequence of elements.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) LINQ operator.
+ |
| SegmentT(IEnumerableT, FuncT, Boolean) |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ |
| SegmentT(IEnumerableT, FuncT, Int32, Boolean) |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ |
| SegmentT(IEnumerableT, FuncT, T, Int32, Boolean) |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ |
| Sequence(Int32, Int32) |
+ Generates a sequence of integral numbers within the (inclusive) specified range.
+ If sequence is ascending the step is +1, otherwise -1.
+ |
| Sequence(Int32, Int32, Int32) |
+ Generates a sequence of integral numbers within the (inclusive) specified range.
+ An additional parameter specifies the steps in which the integers of the sequence increase or decrease.
+ |
| SingleOrFallbackTSource | Obsolete.
+ Returns the single element in the given sequence, or the result
+ of executing a fallback delegate if the sequence is empty.
+ This method throws an exception if there is more than one element in the sequence.
+ |
| SkipLastT |
+ Bypasses a specified number of elements at the end of the sequence.
+ |
| SkipUntilTSource |
+ Skips items from the input sequence until the given predicate returns true
+ when applied to the current source item; that item will be the last skipped.
+ |
| SliceT |
+ Extracts a contiguous count of elements from a sequence at a particular zero-based starting index
+ |
| SortedMergeTSource(IEnumerableTSource, OrderByDirection, IEnumerableTSource) |
+ Merges two or more sequences that are in a common order (either ascending or descending) into
+ a single sequence that preserves that order.
+ |
| SortedMergeTSource(IEnumerableTSource, OrderByDirection, IComparerTSource, IEnumerableTSource) |
+ Merges two or more sequences that are in a common order (either ascending or descending) into
+ a single sequence that preserves that order.
+ |
| SplitTSource(IEnumerableTSource, FuncTSource, Boolean) |
+ Splits the source sequence by separator elements identified by a
+ function.
+ |
| SplitTSource(IEnumerableTSource, TSource) |
+ Splits the source sequence by a separator.
+ |
| SplitTSource(IEnumerableTSource, FuncTSource, Boolean, Int32) |
+ Splits the source sequence by separator elements identified by a
+ function, given a maximum count of splits.
+ |
| SplitTSource(IEnumerableTSource, TSource, IEqualityComparerTSource) |
+ Splits the source sequence by a separator and then transforms the
+ splits into results.
+ |
| SplitTSource(IEnumerableTSource, TSource, Int32) |
+ Splits the source sequence by a separator given a maximum count of splits.
+ |
| SplitTSource(IEnumerableTSource, TSource, IEqualityComparerTSource, Int32) |
+ Splits the source sequence by a separator, given a maximum count
+ of splits. A parameter specifies how the separator is compared
+ for equality.
+ |
| SplitTSource, TResult(IEnumerableTSource, FuncTSource, Boolean, FuncIEnumerableTSource, TResult) |
+ Splits the source sequence by separator elements identified by
+ a function and then transforms the splits into results.
+ |
| SplitTSource, TResult(IEnumerableTSource, TSource, FuncIEnumerableTSource, TResult) |
+ Splits the source sequence by a separator and then transforms
+ the splits into results.
+ |
| SplitTSource, TResult(IEnumerableTSource, FuncTSource, Boolean, Int32, FuncIEnumerableTSource, TResult) |
+ Splits the source sequence by separator elements identified by
+ a function, given a maximum count of splits, and then transforms
+ the splits into results.
+ |
| SplitTSource, TResult(IEnumerableTSource, TSource, IEqualityComparerTSource, FuncIEnumerableTSource, TResult) |
+ Splits the source sequence by a separator and then transforms the
+ splits into results. A parameter specifies how the separator is
+ compared for equality.
+ |
| SplitTSource, TResult(IEnumerableTSource, TSource, Int32, FuncIEnumerableTSource, TResult) |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results.
+ |
| SplitTSource, TResult(IEnumerableTSource, TSource, IEqualityComparerTSource, Int32, FuncIEnumerableTSource, TResult) |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results. A
+ parameter specifies how the separator is compared for equality.
+ |
| StartsWithT(IEnumerableT, IEnumerableT) |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the default equality
+ comparer.
+ |
| StartsWithT(IEnumerableT, IEnumerableT, IEqualityComparerT) |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the specified element
+ equality comparer.
+ |
| SubsetsT(IEnumerableT) |
+ Returns a sequence of IListT representing all of
+ the subsets of any size that are part of the original sequence. In
+ mathematics, it is equivalent to the power set of a set.
+ |
| SubsetsT(IEnumerableT, Int32) |
+ Returns a sequence of IListT representing all
+ subsets of a given size that are part of the original sequence. In
+ mathematics, it is equivalent to the combinations or
+ k-subsets of a set.
+ |
| TagFirstLastTSource, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence with additional parameters
+ indicating whether the element is the first and/or last of the
+ sequence.
+ |
| TakeEveryTSource |
+ Returns every N-th element of a sequence.
+ |
| TakeLastTSource |
+ Returns a specified number of contiguous elements from the end of
+ a sequence.
+ |
| TakeUntilTSource |
+ Returns items from the input sequence until the given predicate returns true
+ when applied to the current source item; that item will be the last returned.
+ |
| ThenByT, TKey(IOrderedEnumerableT, FuncT, TKey, OrderByDirection) |
+ Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key
+ |
| ThenByT, TKey(IOrderedEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection) |
+ Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key
+ |
| ToArrayByIndexT(IEnumerableT, FuncT, Int32) |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array.
+ |
| ToArrayByIndexT(IEnumerableT, Int32, FuncT, Int32) |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array.
+ |
| ToArrayByIndexT, TResult(IEnumerableT, FuncT, Int32, FuncT, TResult) |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ |
| ToArrayByIndexT, TResult(IEnumerableT, FuncT, Int32, FuncT, Int32, TResult) |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ |
| ToArrayByIndexT, TResult(IEnumerableT, Int32, FuncT, Int32, FuncT, TResult) |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ |
| ToArrayByIndexT, TResult(IEnumerableT, Int32, FuncT, Int32, FuncT, Int32, TResult) |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ |
| ToDataTableT(IEnumerableT) |
+ Converts a sequence to a DataTable object.
+ |
| ToDataTableT(IEnumerableT, ExpressionFuncT, Object) |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ |
| ToDataTableT, TTable(IEnumerableT, TTable) |
+ Appends elements in the sequence as rows of a given DataTable object.
+ |
| ToDataTableT, TTable(IEnumerableT, TTable, ExpressionFuncT, Object) |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ |
| ToDelimitedString(IEnumerableBoolean) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableByte) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableChar) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableDecimal) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableDouble) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableInt16) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableInt32) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableInt64) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableSByte) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableSingle) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableString) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableUInt16) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableUInt32) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableUInt64) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedString(IEnumerableBoolean, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableByte, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableChar, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableDecimal, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableDouble, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableInt16, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableInt32, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableInt64, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableSByte, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableSingle, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableString, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableUInt16, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableUInt32, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedString(IEnumerableUInt64, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDelimitedStringTSource(IEnumerableTSource) | Obsolete.
+ Creates a delimited string from a sequence of values. The
+ delimiter used depends on the current culture of the executing thread.
+ |
| ToDelimitedStringTSource(IEnumerableTSource, String) |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ |
| ToDictionaryTKey, TValue(IEnumerableKeyValuePairTKey, TValue) |
+ Creates a DictionaryTKey, TValue from a sequence of
+ KeyValuePairTKey, TValue elements.
+ |
| ToDictionaryTKey, TValue(IEnumerableValueTupleTKey, TValue) |
+ Creates a DictionaryTKey, TValue from a sequence of
+ tuples of 2 where the first item is the key and the second the
+ value.
+ |
| ToDictionaryTKey, TValue(IEnumerableKeyValuePairTKey, TValue, IEqualityComparerTKey) |
+ Creates a DictionaryTKey, TValue from a sequence of
+ KeyValuePairTKey, TValue elements. An additional
+ parameter specifies a comparer for keys.
+ |
| ToDictionaryTKey, TValue(IEnumerableValueTupleTKey, TValue, IEqualityComparerTKey) |
+ Creates a DictionaryTKey, TValue from a sequence of
+ tuples of 2 where the first item is the key and the second the
+ value. An additional parameter specifies a comparer for keys.
+ |
| ToHashSetTSource(IEnumerableTSource) |
+ Returns a HashSetT of the source items using the default equality
+ comparer for the type.
+ |
| ToHashSetTSource(IEnumerableTSource, IEqualityComparerTSource) |
+ Returns a HashSetT of the source items using the specified equality
+ comparer for the type.
+ |
| ToLookupTKey, TValue(IEnumerableKeyValuePairTKey, TValue) |
+ Creates a ILookupTKey, TElement from a sequence of
+ KeyValuePairTKey, TValue elements.
+ |
| ToLookupTKey, TValue(IEnumerableValueTupleTKey, TValue) |
+ Creates a Lookup from a sequence of
+ tuples of 2 where the first item is the key and the second the
+ value.
+ |
| ToLookupTKey, TValue(IEnumerableKeyValuePairTKey, TValue, IEqualityComparerTKey) |
+ Creates a ILookupTKey, TElement from a sequence of
+ KeyValuePairTKey, TValue elements. An additional
+ parameter specifies a comparer for keys.
+ |
| ToLookupTKey, TValue(IEnumerableValueTupleTKey, TValue, IEqualityComparerTKey) |
+ Creates a Lookup from a sequence of
+ tuples of 2 where the first item is the key and the second the
+ value. An additional parameter specifies a comparer for keys.
+ |
| TraceTSource(IEnumerableTSource) |
+ Traces the elements of a source sequence for diagnostics.
+ |
| TraceTSource(IEnumerableTSource, FuncTSource, String) |
+ Traces the elements of a source sequence for diagnostics using
+ a custom formatter.
+ |
| TraceTSource(IEnumerableTSource, String) |
+ Traces the elements of a source sequence for diagnostics using
+ custom formatting.
+ |
| TraverseBreadthFirstT |
+ Traverses a tree in a breadth-first fashion, starting at a root node and using a user-defined
+ function to get the children at each node of the tree.
+ |
| TraverseDepthFirstT |
+ Traverses a tree in a depth-first fashion, starting at a root node and using a user-defined
+ function to get the children at each node of the tree.
+ |
| UnfoldTState, T, TResult |
+ Returns a sequence generated by applying a state to the generator function,
+ and from its result, determines if the sequence should have a next element, its value,
+ and the next state in the recursive call.
+ |
| WindowedTSource |
+ Processes a sequence into a series of subsequences representing a windowed subset of the original
+ |
| ZipLongestTFirst, TSecond, TResult |
+ Returns a projection of tuples, where each tuple contains the N-th element
+ from each of the argument sequences.
+ |
| ZipShortestTFirst, TSecond, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) |
+ Returns a projection of tuples, where each tuple contains the N-th element
+ from each of the argument sequences.
+ |
| ZipShortestT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) |
+ Returns a projection of tuples, where each tuple contains the N-th element
+ from each of the argument sequences.
+ |
| ZipShortestT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) |
+ Returns a projection of tuples, where each tuple contains the N-th element
+ from each of the argument sequences.
+ |
See AlsoOrderByDirection Enumeration |
+ Namespace: + MoreLinq
SyntaxMembers| + + | Member name | Value | Description |
|---|---|---|---|
| Ascending | 0 | + Elements are ordered by increasing value + | |
| Descending | 1 | + Elements are ordered by decreasing value + |
See AlsoSequenceException Class |
Inheritance Hierarchy+ Namespace: + MoreLinq
SyntaxThe SequenceException type exposes the following members.
Constructors| + + | Name | Description |
|---|---|---|
| SequenceException |
+ Initializes a new instance of the SequenceException class.
+ |
| SequenceException(String) |
+ Initializes a new instance of the SequenceException class
+ with a given error message.
+ |
| SequenceException(SerializationInfo, StreamingContext) |
+ Initializes a new instance of the SequenceException class
+ with serialized data.
+ |
| SequenceException(String, Exception) |
+ Initializes a new instance of the SequenceException class
+ with a given error message and a reference to the inner exception
+ that is the cause of the exception.
+ |
Properties| + + | Name | Description |
|---|---|---|
| Data | Gets a collection of key/value pairs that provide additional user-defined information about the exception. (Inherited from Exception.) |
| HelpLink | Gets or sets a link to the help file associated with this exception. (Inherited from Exception.) |
| HResult | Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception. (Inherited from Exception.) |
| InnerException | Gets the Exception instance that caused the current exception. (Inherited from Exception.) |
| Message | Gets a message that describes the current exception. (Inherited from Exception.) |
| Source | Gets or sets the name of the application or the object that causes the error. (Inherited from Exception.) |
| StackTrace | Gets a string representation of the immediate frames on the call stack. (Inherited from Exception.) |
| TargetSite | Gets the method that throws the current exception. (Inherited from Exception.) |
Methods| + + | Name | Description |
|---|---|---|
| Equals | (Inherited from Object.) |
| Finalize | Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection. (Inherited from Object.) |
| GetBaseException | When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions. (Inherited from Exception.) |
| GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.) |
| GetObjectData | When overridden in a derived class, sets the SerializationInfo with information about the exception. (Inherited from Exception.) |
| GetType | Gets the runtime type of the current instance. (Inherited from Exception.) |
| MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.) |
| ToString | Creates and returns a string representation of the current exception. (Inherited from Exception.) |
Events| + + | Name | Description |
|---|---|---|
| SerializeObjectState | Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception. (Inherited from Exception.) |
See AlsoIf you are not redirected automatically, follow this link to the default topic.
+ + diff --git a/2.10/ref/api/scripts/branding-Website.js b/2.10/ref/api/scripts/branding-Website.js new file mode 100644 index 0000000..06ab980 --- /dev/null +++ b/2.10/ref/api/scripts/branding-Website.js @@ -0,0 +1,624 @@ +//=============================================================================================================== +// System : Sandcastle Help File Builder +// File : branding-Website.js +// Author : Eric Woodruff (Eric@EWoodruff.us) +// Updated : 03/04/2015 +// Note : Copyright 2014-2015, Eric Woodruff, All rights reserved +// Portions Copyright 2014 Sam Harwell, All rights reserved +// +// This file contains the methods necessary to implement the lightweight TOC and search functionality. +// +// This code is published under the Microsoft Public License (Ms-PL). A copy of the license should be +// distributed with the code. It can also be found at the project website: https://GitHub.com/EWSoftware/SHFB. This +// notice, the author's name, and all copyright notices must remain intact in all applications, documentation, +// and source files. +// +// Date Who Comments +// ============================================================================================================== +// 05/04/2014 EFW Created the code based on a combination of the lightweight TOC code from Sam Harwell and +// the existing search code from SHFB. +//=============================================================================================================== + +// Width of the TOC +var tocWidth; + +// Search method (0 = To be determined, 1 = ASPX, 2 = PHP, anything else = client-side script +var searchMethod = 0; + +// Table of contents script + +// Initialize the TOC by restoring its width from the cookie if present +function InitializeToc() +{ + tocWidth = parseInt(GetCookie("TocWidth", "280")); + ResizeToc(); + $(window).resize(SetNavHeight) +} + +function SetNavHeight() +{ + $leftNav = $("#leftNav") + $topicContent = $("#TopicContent") + leftNavPadding = $leftNav.outerHeight() - $leftNav.height() + contentPadding = $topicContent.outerHeight() - $topicContent.height() + // want outer height of left navigation div to match outer height of content + leftNavHeight = $topicContent.outerHeight() - leftNavPadding + $leftNav.css("min-height", leftNavHeight + "px") +} + +// Increase the TOC width +function OnIncreaseToc() +{ + if(tocWidth < 1) + tocWidth = 280; + else + tocWidth += 100; + + if(tocWidth > 680) + tocWidth = 0; + + ResizeToc(); + SetCookie("TocWidth", tocWidth); +} + +// Reset the TOC to its default width +function OnResetToc() +{ + tocWidth = 0; + + ResizeToc(); + SetCookie("TocWidth", tocWidth); +} + +// Resize the TOC width +function ResizeToc() +{ + var toc = document.getElementById("leftNav"); + + if(toc) + { + // Set TOC width + toc.style.width = tocWidth + "px"; + + var leftNavPadding = 10; + + document.getElementById("TopicContent").style.marginLeft = (tocWidth + leftNavPadding) + "px"; + + // Position images + document.getElementById("TocResize").style.left = (tocWidth + leftNavPadding) + "px"; + + // Hide/show increase TOC width image + document.getElementById("ResizeImageIncrease").style.display = (tocWidth >= 680) ? "none" : ""; + + // Hide/show reset TOC width image + document.getElementById("ResizeImageReset").style.display = (tocWidth < 680) ? "none" : ""; + } + + SetNavHeight() +} + +// Toggle a TOC entry between its collapsed and expanded state +function Toggle(item) +{ + var isExpanded = $(item).hasClass("tocExpanded"); + + $(item).toggleClass("tocExpanded tocCollapsed"); + + if(isExpanded) + { + Collapse($(item).parent()); + } + else + { + var childrenLoaded = $(item).parent().attr("data-childrenloaded"); + + if(childrenLoaded) + { + Expand($(item).parent()); + } + else + { + var tocid = $(item).next().attr("tocid"); + + $.ajax({ + url: "../toc/" + tocid + ".xml", + async: true, + dataType: "xml", + success: function(data) + { + BuildChildren($(item).parent(), data); + } + }); + } + } +} + +// HTML encode a value for use on the page +function HtmlEncode(value) +{ + // Create an in-memory div, set it's inner text (which jQuery automatically encodes) then grab the encoded + // contents back out. The div never exists on the page. + return $('').text(value).html(); +} + +// Build the child entries of a TOC entry +function BuildChildren(tocDiv, data) +{ + var childLevel = +tocDiv.attr("data-toclevel") + 1; + var childTocLevel = childLevel >= 10 ? 10 : childLevel; + var elements = data.getElementsByTagName("HelpTOCNode"); + + var isRoot = true; + + if(data.getElementsByTagName("HelpTOC").length == 0) + { + // The first node is the root node of this group, don't show it again + isRoot = false; + } + + for(var i = elements.length - 1; i > 0 || (isRoot && i == 0); i--) + { + var childHRef, childId = elements[i].getAttribute("Url"); + + if(childId != null && childId.length > 5) + { + // The Url attribute has the form "html/{childId}.htm" + childHRef = childId.substring(5, childId.length); + childId = childId.substring(5, childId.lastIndexOf(".")); + } + else + { + // The Id attribute is in raw form. There is no URL (empty container node). In this case, we'll + // just ignore it and go nowhere. It's a rare case that isn't worth trying to get the first child. + // Instead, we'll just expand the node (see below). + childHRef = "#"; + childId = elements[i].getAttribute("Id"); + } + + var existingItem = null; + + tocDiv.nextAll().each(function() + { + if(!existingItem && $(this).children().last("a").attr("tocid") == childId) + { + existingItem = $(this); + } + }); + + if(existingItem != null) + { + // First move the children of the existing item + var existingChildLevel = +existingItem.attr("data-toclevel"); + var doneMoving = false; + var inserter = tocDiv; + + existingItem.nextAll().each(function() + { + if(!doneMoving && +$(this).attr("data-toclevel") > existingChildLevel) + { + inserter.after($(this)); + inserter = $(this); + $(this).attr("data-toclevel", +$(this).attr("data-toclevel") + childLevel - existingChildLevel); + + if($(this).hasClass("current")) + $(this).attr("class", "toclevel" + (+$(this).attr("data-toclevel") + " current")); + else + $(this).attr("class", "toclevel" + (+$(this).attr("data-toclevel"))); + } + else + { + doneMoving = true; + } + }); + + // Now move the existing item itself + tocDiv.after(existingItem); + existingItem.attr("data-toclevel", childLevel); + existingItem.attr("class", "toclevel" + childLevel); + } + else + { + var hasChildren = elements[i].getAttribute("HasChildren"); + var childTitle = HtmlEncode(elements[i].getAttribute("Title")); + var expander = ""; + + if(hasChildren) + expander = ""; + + var text = "Omitted " + (matchingFileIndices.length - rankings.length) + " more results
"; + + return content; +} diff --git a/2.10/ref/api/scripts/branding.js b/2.10/ref/api/scripts/branding.js new file mode 100644 index 0000000..3e55541 --- /dev/null +++ b/2.10/ref/api/scripts/branding.js @@ -0,0 +1,560 @@ +//=============================================================================================================== +// System : Sandcastle Help File Builder +// File : branding.js +// Author : Eric Woodruff (Eric@EWoodruff.us) +// Updated : 10/08/2015 +// Note : Copyright 2014-2015, Eric Woodruff, All rights reserved +// Portions Copyright 2010-2014 Microsoft, All rights reserved +// +// This file contains the methods necessary to implement the language filtering, collapsible section, and +// copy to clipboard options. +// +// This code is published under the Microsoft Public License (Ms-PL). A copy of the license should be +// distributed with the code and can be found at the project website: https://GitHub.com/EWSoftware/SHFB. This +// notice, the author's name, and all copyright notices must remain intact in all applications, documentation, +// and source files. +// +// Date Who Comments +// ============================================================================================================== +// 05/04/2014 EFW Created the code based on the MS Help Viewer script +//=============================================================================================================== + +// The IDs of all code snippet sets on the same page are stored so that we can keep them in synch when a tab is +// selected. +var allTabSetIds = new Array(); + +// The IDs of language-specific text (LST) spans are used as dictionary keys so that we can get access to the +// spans and update them when the user changes to a different language tab. The values of the dictionary +// objects are pipe separated language-specific attributes (lang1=value|lang2=value|lang3=value). The language +// ID can be specific (cs, vb, cpp, etc.) or may be a neutral entry (nu) which specifies text common to multiple +// languages. If a language is not present and there is no neutral entry, the span is hidden for all languages +// to which it does not apply. +var allLSTSetIds = new Object(); + +// Help 1 persistence support. This code must appear inline. +var isHelp1; + +var curLoc = document.location + "."; + +if(curLoc.indexOf("mk:@MSITStore") == 0) +{ + isHelp1 = true; + curLoc = "ms-its:" + curLoc.substring(14, curLoc.length - 1); + document.location.replace(curLoc); +} +else + if(curLoc.indexOf("ms-its:") == 0) + isHelp1 = true; + else + isHelp1 = false; + +// The OnLoad method +function OnLoad(defaultLanguage) +{ + var defLang; + + if(typeof (defaultLanguage) == "undefined" || defaultLanguage == null || defaultLanguage == "") + defLang = "vb"; + else + defLang = defaultLanguage; + + // In MS Help Viewer, the transform the topic is ran through can move the footer. Move it back where it + // belongs if necessary. + try + { + var footer = document.getElementById("pageFooter") + + if(footer) + { + var footerParent = document.body; + + if(footer.parentElement != footerParent) + { + footer.parentElement.removeChild(footer); + footerParent.appendChild(footer); + } + } + } + catch(e) + { + } + + var language = GetCookie("CodeSnippetContainerLanguage", defLang); + + // If LST exists on the page, set the LST to show the user selected programming language + UpdateLST(language); + + // If code snippet groups exist, set the current language for them + if(allTabSetIds.length > 0) + { + var i = 0; + + while(i < allTabSetIds.length) + { + var tabCount = 1; + + // The tab count may vary so find the last one in this set + while(document.getElementById(allTabSetIds[i] + "_tab" + tabCount) != null) + tabCount++; + + tabCount--; + + // If not grouped, skip it + if(tabCount > 1) + SetCurrentLanguage(allTabSetIds[i], language, tabCount); + + i++; + } + } + + InitializeToc(); +} + +// This is just a place holder. The website script implements this function to initialize it's in-page TOC pane +function InitializeToc() +{ +} + +// This function executes in the OnLoad event and ChangeTab action on code snippets. The function parameter +// is the user chosen programming language. This function iterates through the "allLSTSetIds" dictionary object +// to update the node value of the LST span tag per the user's chosen programming language. +function UpdateLST(language) +{ + for(var lstMember in allLSTSetIds) + { + var devLangSpan = document.getElementById(lstMember); + + if(devLangSpan != null) + { + // There may be a carriage return before the LST span in the content so the replace function below + // is used to trim the whitespace at the end of the previous node of the current LST node. + if(devLangSpan.previousSibling != null && devLangSpan.previousSibling.nodeValue != null) + devLangSpan.previousSibling.nodeValue = devLangSpan.previousSibling.nodeValue.replace(/\s+$/, ""); + + var langs = allLSTSetIds[lstMember].split("|"); + var k = 0; + var keyValue; + + while(k < langs.length) + { + keyValue = langs[k].split("="); + + if(keyValue[0] == language) + { + devLangSpan.innerHTML = keyValue[1]; + + // Help 1 and MS Help Viewer workaround. Add a space if the following text element starts + // with a space to prevent things running together. + if(devLangSpan.parentNode != null && devLangSpan.parentNode.nextSibling != null) + { + if (devLangSpan.parentNode.nextSibling.nodeValue != null && + !devLangSpan.parentNode.nextSibling.nodeValue.substring(0, 1).match(/[.,);:!/?]/)) + { + devLangSpan.innerHTML = keyValue[1] + " "; + } + } + break; + } + + k++; + } + + // If not found, default to the neutral language. If there is no neutral language entry, clear the + // content to hide it. + if(k >= langs.length) + { + if(language != "nu") + { + k = 0; + + while(k < langs.length) + { + keyValue = langs[k].split("="); + + if(keyValue[0] == "nu") + { + devLangSpan.innerHTML = keyValue[1]; + + // Help 1 and MS Help Viewer workaround. Add a space if the following text element + // starts with a space to prevent things running together. + if(devLangSpan.parentNode != null && devLangSpan.parentNode.nextSibling != null) + { + if(devLangSpan.parentNode.nextSibling.nodeValue != null && + !devLangSpan.parentNode.nextSibling.nodeValue.substring(0, 1).match(/[.,);:!/?]/)) + { + devLangSpan.innerHTML = keyValue[1] + " "; + } + } + break; + } + + k++; + } + } + + if(k >= langs.length) + devLangSpan.innerHTML = ""; + } + } + } +} + +// Get the specified cookie. If not found, return the specified default value. +function GetCookie(cookieName, defaultValue) +{ + if(isHelp1) + { + try + { + var globals = Help1Globals; + + var value = globals.Load(cookieName); + + if(value == null) + value = defaultValue; + + return value; + } + catch(e) + { + return defaultValue; + } + } + + var cookie = document.cookie.split("; "); + + for(var i = 0; i < cookie.length; i++) + { + var crumb = cookie[i].split("="); + + if(cookieName == crumb[0]) + return unescape(crumb[1]) + } + + return defaultValue; +} + +// Set the specified cookie to the specified value +function SetCookie(name, value) +{ + if(isHelp1) + { + try + { + var globals = Help1Globals; + + globals.Save(name, value); + } + catch(e) + { + } + + return; + } + + var today = new Date(); + + today.setTime(today.getTime()); + + // Set the expiration time to be 60 days from now (in milliseconds) + var expires_date = new Date(today.getTime() + (60 * 1000 * 60 * 60 * 24)); + + document.cookie = name + "=" + escape(value) + ";expires=" + expires_date.toGMTString() + ";path=/"; +} + +// Add a language-specific text ID +function AddLanguageSpecificTextSet(lstId) +{ + var keyValue = lstId.split("?") + + allLSTSetIds[keyValue[0]] = keyValue[1]; +} + +var clipboardHandler; + +// Add a language tab set ID +function AddLanguageTabSet(tabSetId) +{ + allTabSetIds.push(tabSetId); + + // Create the clipboard handler on first use + if(clipboardHandler == null && typeof (Clipboard) == "function") + { + clipboardHandler = new Clipboard('.copyCodeSnippet', + { + text: function (trigger) + { + // Get the code to copy to the clipboard from the active tab of the given tab set + var i = 1, tabSetId = trigger.id; + var pos = tabSetId.indexOf('_'); + + if(pos == -1) + return ""; + + tabSetId = tabSetId.substring(0, pos); + + do + { + contentId = tabSetId + "_code_Div" + i; + tabTemp = document.getElementById(contentId); + + if(tabTemp != null && tabTemp.style.display != "none") + break; + + i++; + + } while(tabTemp != null); + + if(tabTemp == null) + return ""; + + return document.getElementById(contentId).innerText; + } + }); + } +} + +// Switch the active tab for all of other code snippets +function ChangeTab(tabSetId, language, snippetIdx, snippetCount) +{ + SetCookie("CodeSnippetContainerLanguage", language); + + SetActiveTab(tabSetId, snippetIdx, snippetCount); + + // If LST exists on the page, set the LST to show the user selected programming language + UpdateLST(language); + + var i = 0; + + while(i < allTabSetIds.length) + { + // We just care about other snippets + if(allTabSetIds[i] != tabSetId) + { + // Other tab sets may not have the same number of tabs + var tabCount = 1; + + while(document.getElementById(allTabSetIds[i] + "_tab" + tabCount) != null) + tabCount++; + + tabCount--; + + // If not grouped, skip it + if(tabCount > 1) + SetCurrentLanguage(allTabSetIds[i], language, tabCount); + } + + i++; + } +} + +// Sets the current language in the specified tab set +function SetCurrentLanguage(tabSetId, language, tabCount) +{ + var tabIndex = 1; + + while(tabIndex <= tabCount) + { + var tabTemp = document.getElementById(tabSetId + "_tab" + tabIndex); + + if(tabTemp != null && tabTemp.innerHTML.indexOf("'" + language + "'") != -1) + break; + + tabIndex++; + } + + if(tabIndex > tabCount) + { + // Select the first non-disabled tab + tabIndex = 1; + + if(document.getElementById(tabSetId + "_tab1").className == "codeSnippetContainerTabPhantom") + { + tabIndex++; + + while(tabIndex <= tabCount) + { + var tab = document.getElementById(tabSetId + "_tab" + tabIndex); + + if(tab.className != "codeSnippetContainerTabPhantom") + { + tab.className = "codeSnippetContainerTabActive"; + document.getElementById(tabSetId + "_code_Div" + j).style.display = "block"; + break; + } + + tabIndex++; + } + } + } + + SetActiveTab(tabSetId, tabIndex, tabCount); +} + +// Set the active tab within a tab set +function SetActiveTab(tabSetId, tabIndex, tabCount) +{ + var i = 1; + + while(i <= tabCount) + { + var tabTemp = document.getElementById(tabSetId + "_tab" + i); + + if (tabTemp != null) + { + if(tabTemp.className == "codeSnippetContainerTabActive") + tabTemp.className = "codeSnippetContainerTab"; + else + if(tabTemp.className == "codeSnippetContainerTabPhantom") + tabTemp.style.display = "none"; + + var codeTemp = document.getElementById(tabSetId + "_code_Div" + i); + + if(codeTemp.style.display != "none") + codeTemp.style.display = "none"; + } + + i++; + } + + // Phantom tabs are shown or hidden as needed + if(document.getElementById(tabSetId + "_tab" + tabIndex).className != "codeSnippetContainerTabPhantom") + document.getElementById(tabSetId + "_tab" + tabIndex).className = "codeSnippetContainerTabActive"; + else + document.getElementById(tabSetId + "_tab" + tabIndex).style.display = "block"; + + document.getElementById(tabSetId + "_code_Div" + tabIndex).style.display = "block"; +} + +// Copy the code from the active tab of the given tab set to the clipboard +function CopyToClipboard(tabSetId) +{ + var tabTemp, contentId; + var i = 1; + + if(typeof (Clipboard) == "function") + return; + + do + { + contentId = tabSetId + "_code_Div" + i; + tabTemp = document.getElementById(contentId); + + if(tabTemp != null && tabTemp.style.display != "none") + break; + + i++; + + } while(tabTemp != null); + + if(tabTemp == null) + return; + + if(window.clipboardData) + { + try + { + window.clipboardData.setData("Text", document.getElementById(contentId).innerText); + } + catch(e) + { + alert("Permission denied. Enable copying to the clipboard."); + } + } + else if(window.netscape) + { + try + { + netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect"); + + var clip = Components.classes["@mozilla.org/widget/clipboard;1"].createInstance( + Components.interfaces.nsIClipboard); + + if(!clip) + return; + + var trans = Components.classes["@mozilla.org/widget/transferable;1"].createInstance( + Components.interfaces.nsITransferable); + + if(!trans) + return; + + trans.addDataFlavor("text/unicode"); + + var str = new Object(); + var len = new Object(); + var str = Components.classes["@mozilla.org/supports-string;1"].createInstance( + Components.interfaces.nsISupportsString); + + var copytext = document.getElementById(contentId).textContent; + + str.data = copytext; + trans.setTransferData("text/unicode", str, copytext.length * 2); + + var clipid = Components.interfaces.nsIClipboard; + + clip.setData(trans, null, clipid.kGlobalClipboard); + } + catch(e) + { + alert("Permission denied. Enter \"about:config\" in the address bar and double-click the \"signed.applets.codebase_principal_support\" setting to enable copying to the clipboard."); + } + } +} + +// Expand or collapse a section +function SectionExpandCollapse(togglePrefix) +{ + var image = document.getElementById(togglePrefix + "Toggle"); + var section = document.getElementById(togglePrefix + "Section"); + + if(image != null && section != null) + if(section.style.display == "") + { + image.src = image.src.replace("SectionExpanded.png", "SectionCollapsed.png"); + section.style.display = "none"; + } + else + { + image.src = image.src.replace("SectionCollapsed.png", "SectionExpanded.png"); + section.style.display = ""; + } +} + +// Expand or collapse a section when it has the focus and Enter is hit +function SectionExpandCollapse_CheckKey(togglePrefix, eventArgs) +{ + if(eventArgs.keyCode == 13) + SectionExpandCollapse(togglePrefix); +} + +// Help 1 persistence object. This requires a hidden input element on the page with a class of "userDataStyle" +// defined in the style sheet that implements the user data binary behavior: +// +var Help1Globals = +{ + UserDataCache: function() + { + var userData = document.getElementById("userDataCache"); + + return userData; + }, + + Load: function(key) + { + var userData = this.UserDataCache(); + + userData.load("userDataSettings"); + + var value = userData.getAttribute(key); + + return value; + }, + + Save: function(key, value) + { + var userData = this.UserDataCache(); + userData.setAttribute(key, value); + userData.save("userDataSettings"); + } +}; diff --git a/2.10/ref/api/scripts/clipboard.min.js b/2.10/ref/api/scripts/clipboard.min.js new file mode 100644 index 0000000..580433f --- /dev/null +++ b/2.10/ref/api/scripts/clipboard.min.js @@ -0,0 +1,7 @@ +/*! + * clipboard.js v1.5.12 + * https://zenorocha.github.io/clipboard.js + * + * Licensed MIT © Zeno Rocha + */ +!function(t){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=t();else if("function"==typeof define&&define.amd)define([],t);else{var e;e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this,e.Clipboard=t()}}(function(){var t,e,n;return function t(e,n,o){function i(a,c){if(!n[a]){if(!e[a]){var s="function"==typeof require&&require;if(!c&&s)return s(a,!0);if(r)return r(a,!0);var l=new Error("Cannot find module '"+a+"'");throw l.code="MODULE_NOT_FOUND",l}var u=n[a]={exports:{}};e[a][0].call(u.exports,function(t){var n=e[a][1][t];return i(n?n:t)},u,u.exports,t,e,n,o)}return n[a].exports}for(var r="function"==typeof require&&require,a=0;a| t |