mirror of
https://git.huckle.dev/Huckles-Minecraft-Archive/PCK-Studio.git
synced 2026-07-02 17:54:18 +00:00
12499 lines
759 KiB
XML
12499 lines
759 KiB
XML
<?xml version="1.0"?>
|
|
<doc>
|
|
<assembly>
|
|
<name>MoreLinq</name>
|
|
</assembly>
|
|
<members>
|
|
<member name="T:MoreLinq.MoreEnumerable">
|
|
<summary>
|
|
Provides a set of static methods for querying objects that
|
|
implement <see cref="T:System.Collections.Generic.IEnumerable`1" />.
|
|
</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Acquire``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Ensures that a source sequence of <see cref="T:System.IDisposable"/>
|
|
objects are all acquired successfully. If the acquisition of any
|
|
one <see cref="T:System.IDisposable"/> fails then those successfully
|
|
acquired till that point are disposed.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
|
|
<param name="source">Source sequence of <see cref="T:System.IDisposable"/> objects.</param>
|
|
<returns>
|
|
Returns an array of all the acquired <see cref="T:System.IDisposable"/>
|
|
objects in source order.
|
|
</returns>
|
|
<remarks>
|
|
This operator executes immediately.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Aggregate``4(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},System.Func{``1,``2,``3})">
|
|
<summary>
|
|
Applies two accumulators sequentially in a single pass over a
|
|
sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
|
|
<typeparam name="TResult">The type of the accumulated result.</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="seed1">The seed value for the first accumulator.</param>
|
|
<param name="accumulator1">The first accumulator.</param>
|
|
<param name="seed2">The seed value for the second accumulator.</param>
|
|
<param name="accumulator2">The second accumulator.</param>
|
|
<param name="resultSelector">
|
|
A function that projects a single result given the result of each
|
|
accumulator.</param>
|
|
<returns>The value returned by <paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
This operator executes immediately.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Aggregate``5(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},System.Func{``1,``2,``3,``4})">
|
|
<summary>
|
|
Applies three accumulators sequentially in a single pass over a
|
|
sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
|
|
<typeparam name="TResult">The type of the accumulated result.</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="seed1">The seed value for the first accumulator.</param>
|
|
<param name="accumulator1">The first accumulator.</param>
|
|
<param name="seed2">The seed value for the second accumulator.</param>
|
|
<param name="accumulator2">The second accumulator.</param>
|
|
<param name="seed3">The seed value for the third accumulator.</param>
|
|
<param name="accumulator3">The third accumulator.</param>
|
|
<param name="resultSelector">
|
|
A function that projects a single result given the result of each
|
|
accumulator.</param>
|
|
<returns>The value returned by <paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
This operator executes immediately.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Aggregate``6(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},System.Func{``1,``2,``3,``4,``5})">
|
|
<summary>
|
|
Applies four accumulators sequentially in a single pass over a
|
|
sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
|
|
<typeparam name="TResult">The type of the accumulated result.</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="seed1">The seed value for the first accumulator.</param>
|
|
<param name="accumulator1">The first accumulator.</param>
|
|
<param name="seed2">The seed value for the second accumulator.</param>
|
|
<param name="accumulator2">The second accumulator.</param>
|
|
<param name="seed3">The seed value for the third accumulator.</param>
|
|
<param name="accumulator3">The third accumulator.</param>
|
|
<param name="seed4">The seed value for the fourth accumulator.</param>
|
|
<param name="accumulator4">The fourth accumulator.</param>
|
|
<param name="resultSelector">
|
|
A function that projects a single result given the result of each
|
|
accumulator.</param>
|
|
<returns>The value returned by <paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
This operator executes immediately.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Aggregate``7(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},System.Func{``1,``2,``3,``4,``5,``6})">
|
|
<summary>
|
|
Applies five accumulators sequentially in a single pass over a
|
|
sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
|
|
<typeparam name="TResult">The type of the accumulated result.</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="seed1">The seed value for the first accumulator.</param>
|
|
<param name="accumulator1">The first accumulator.</param>
|
|
<param name="seed2">The seed value for the second accumulator.</param>
|
|
<param name="accumulator2">The second accumulator.</param>
|
|
<param name="seed3">The seed value for the third accumulator.</param>
|
|
<param name="accumulator3">The third accumulator.</param>
|
|
<param name="seed4">The seed value for the fourth accumulator.</param>
|
|
<param name="accumulator4">The fourth accumulator.</param>
|
|
<param name="seed5">The seed value for the fifth accumulator.</param>
|
|
<param name="accumulator5">The fifth accumulator.</param>
|
|
<param name="resultSelector">
|
|
A function that projects a single result given the result of each
|
|
accumulator.</param>
|
|
<returns>The value returned by <paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
This operator executes immediately.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Aggregate``8(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},``6,System.Func{``6,``0,``6},System.Func{``1,``2,``3,``4,``5,``6,``7})">
|
|
<summary>
|
|
Applies six accumulators sequentially in a single pass over a
|
|
sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate6">The type of sixth accumulator value.</typeparam>
|
|
<typeparam name="TResult">The type of the accumulated result.</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="seed1">The seed value for the first accumulator.</param>
|
|
<param name="accumulator1">The first accumulator.</param>
|
|
<param name="seed2">The seed value for the second accumulator.</param>
|
|
<param name="accumulator2">The second accumulator.</param>
|
|
<param name="seed3">The seed value for the third accumulator.</param>
|
|
<param name="accumulator3">The third accumulator.</param>
|
|
<param name="seed4">The seed value for the fourth accumulator.</param>
|
|
<param name="accumulator4">The fourth accumulator.</param>
|
|
<param name="seed5">The seed value for the fifth accumulator.</param>
|
|
<param name="accumulator5">The fifth accumulator.</param>
|
|
<param name="seed6">The seed value for the sixth accumulator.</param>
|
|
<param name="accumulator6">The sixth accumulator.</param>
|
|
<param name="resultSelector">
|
|
A function that projects a single result given the result of each
|
|
accumulator.</param>
|
|
<returns>The value returned by <paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
This operator executes immediately.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Aggregate``9(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},``6,System.Func{``6,``0,``6},``7,System.Func{``7,``0,``7},System.Func{``1,``2,``3,``4,``5,``6,``7,``8})">
|
|
<summary>
|
|
Applies seven accumulators sequentially in a single pass over a
|
|
sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate6">The type of sixth accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate7">The type of seventh accumulator value.</typeparam>
|
|
<typeparam name="TResult">The type of the accumulated result.</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="seed1">The seed value for the first accumulator.</param>
|
|
<param name="accumulator1">The first accumulator.</param>
|
|
<param name="seed2">The seed value for the second accumulator.</param>
|
|
<param name="accumulator2">The second accumulator.</param>
|
|
<param name="seed3">The seed value for the third accumulator.</param>
|
|
<param name="accumulator3">The third accumulator.</param>
|
|
<param name="seed4">The seed value for the fourth accumulator.</param>
|
|
<param name="accumulator4">The fourth accumulator.</param>
|
|
<param name="seed5">The seed value for the fifth accumulator.</param>
|
|
<param name="accumulator5">The fifth accumulator.</param>
|
|
<param name="seed6">The seed value for the sixth accumulator.</param>
|
|
<param name="accumulator6">The sixth accumulator.</param>
|
|
<param name="seed7">The seed value for the seventh accumulator.</param>
|
|
<param name="accumulator7">The seventh accumulator.</param>
|
|
<param name="resultSelector">
|
|
A function that projects a single result given the result of each
|
|
accumulator.</param>
|
|
<returns>The value returned by <paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
This operator executes immediately.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Aggregate``10(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},``6,System.Func{``6,``0,``6},``7,System.Func{``7,``0,``7},``8,System.Func{``8,``0,``8},System.Func{``1,``2,``3,``4,``5,``6,``7,``8,``9})">
|
|
<summary>
|
|
Applies eight accumulators sequentially in a single pass over a
|
|
sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate6">The type of sixth accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate7">The type of seventh accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate8">The type of eighth accumulator value.</typeparam>
|
|
<typeparam name="TResult">The type of the accumulated result.</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="seed1">The seed value for the first accumulator.</param>
|
|
<param name="accumulator1">The first accumulator.</param>
|
|
<param name="seed2">The seed value for the second accumulator.</param>
|
|
<param name="accumulator2">The second accumulator.</param>
|
|
<param name="seed3">The seed value for the third accumulator.</param>
|
|
<param name="accumulator3">The third accumulator.</param>
|
|
<param name="seed4">The seed value for the fourth accumulator.</param>
|
|
<param name="accumulator4">The fourth accumulator.</param>
|
|
<param name="seed5">The seed value for the fifth accumulator.</param>
|
|
<param name="accumulator5">The fifth accumulator.</param>
|
|
<param name="seed6">The seed value for the sixth accumulator.</param>
|
|
<param name="accumulator6">The sixth accumulator.</param>
|
|
<param name="seed7">The seed value for the seventh accumulator.</param>
|
|
<param name="accumulator7">The seventh accumulator.</param>
|
|
<param name="seed8">The seed value for the eighth accumulator.</param>
|
|
<param name="accumulator8">The eighth accumulator.</param>
|
|
<param name="resultSelector">
|
|
A function that projects a single result given the result of each
|
|
accumulator.</param>
|
|
<returns>The value returned by <paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
This operator executes immediately.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.AggregateRight``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})">
|
|
<summary>
|
|
Applies a right-associative accumulator function over a sequence.
|
|
This operator is the right-associative version of the
|
|
<see cref="M:System.Linq.Enumerable.Aggregate``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})"/> LINQ operator.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of source.</typeparam>
|
|
<param name="source">Source sequence.</param>
|
|
<param name="func">A right-associative accumulator function to be invoked on each element.</param>
|
|
<returns>The final accumulator value.</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
string result = Enumerable.Range(1, 5).Select(i => i.ToString()).AggregateRight((a, b) => string.Format("({0}/{1})", a, b));
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>"(1/(2/(3/(4/5))))"</c>.
|
|
</example>
|
|
<remarks>
|
|
This operator executes immediately.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.AggregateRight``2(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``0,``1,``1})">
|
|
<summary>
|
|
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
|
|
<see cref="M:System.Linq.Enumerable.Aggregate``2(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1})"/> LINQ operator.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of source.</typeparam>
|
|
<typeparam name="TAccumulate">The type of the accumulator value.</typeparam>
|
|
<param name="source">Source sequence.</param>
|
|
<param name="seed">The initial accumulator value.</param>
|
|
<param name="func">A right-associative accumulator function to be invoked on each element.</param>
|
|
<returns>The final accumulator value.</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = Enumerable.Range(1, 5);
|
|
string result = numbers.AggregateRight("6", (a, b) => string.Format("({0}/{1})", a, b));
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>"(1/(2/(3/(4/(5/6)))))"</c>.
|
|
</example>
|
|
<remarks>
|
|
This operator executes immediately.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.AggregateRight``3(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``0,``1,``1},System.Func{``1,``2})">
|
|
<summary>
|
|
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
|
|
<see cref="M:System.Linq.Enumerable.Aggregate``3(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},System.Func{``1,``2})"/> LINQ operator.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of source.</typeparam>
|
|
<typeparam name="TAccumulate">The type of the accumulator value.</typeparam>
|
|
<typeparam name="TResult">The type of the resulting value.</typeparam>
|
|
<param name="source">Source sequence.</param>
|
|
<param name="seed">The initial accumulator value.</param>
|
|
<param name="func">A right-associative accumulator function to be invoked on each element.</param>
|
|
<param name="resultSelector">A function to transform the final accumulator value into the result value.</param>
|
|
<returns>The transformed final accumulator value.</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = Enumerable.Range(1, 5);
|
|
int result = numbers.AggregateRight("6", (a, b) => string.Format("({0}/{1})", a, b), str => str.Length);
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>21</c>.
|
|
</example>
|
|
<remarks>
|
|
This operator executes immediately.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Append``1(System.Collections.Generic.IEnumerable{``0},``0)">
|
|
<summary>
|
|
Returns a sequence consisting of the head elements and the given tail element.
|
|
</summary>
|
|
<typeparam name="T">Type of sequence</typeparam>
|
|
<param name="head">All elements of the head. Must not be null.</param>
|
|
<param name="tail">Tail element of the new sequence.</param>
|
|
<returns>A sequence consisting of the head elements and the given tail element.</returns>
|
|
<remarks>This operator uses deferred execution and streams its results.</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Concat``1(System.Collections.Generic.IEnumerable{``0},``0)">
|
|
<summary>
|
|
Returns a sequence consisting of the head elements and the given tail element.
|
|
</summary>
|
|
<typeparam name="T">Type of sequence</typeparam>
|
|
<param name="head">All elements of the head. Must not be null.</param>
|
|
<param name="tail">Tail element of the new sequence.</param>
|
|
<returns>A sequence consisting of the head elements and the given tail element.</returns>
|
|
<remarks>This operator uses deferred execution and streams its results.</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Assert``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})">
|
|
<summary>
|
|
Asserts that all elements of a sequence meet a given condition
|
|
otherwise throws an <see cref="T:System.Exception"/> object.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
|
|
<param name="source">Source sequence.</param>
|
|
<param name="predicate">Function that asserts an element of the <paramref name="source"/> sequence for a condition.</param>
|
|
<returns>
|
|
Returns the original sequence.
|
|
</returns>
|
|
<exception cref="T:System.InvalidOperationException">The input sequence
|
|
contains an element that does not meet the condition being
|
|
asserted.</exception>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Assert``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},System.Func{``0,System.Exception})">
|
|
<summary>
|
|
Asserts that all elements of a sequence meet a given condition
|
|
otherwise throws an <see cref="T:System.Exception"/> object.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
|
|
<param name="source">Source sequence.</param>
|
|
<param name="predicate">Function that asserts an element of the input sequence for a condition.</param>
|
|
<param name="errorSelector">Function that returns the <see cref="T:System.Exception"/> object to throw.</param>
|
|
<returns>
|
|
Returns the original sequence.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.AssertCount``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Asserts that a source sequence contains a given count of elements.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
|
|
<param name="source">Source sequence.</param>
|
|
<param name="count">Count to assert.</param>
|
|
<returns>
|
|
Returns the original sequence as long it is contains the
|
|
number of elements specified by <paramref name="count"/>.
|
|
Otherwise it throws <see cref="T:System.Exception" />.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.AssertCount``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Int32,System.Int32,System.Exception})">
|
|
<summary>
|
|
Asserts that a source sequence contains a given count of elements.
|
|
A parameter specifies the exception to be thrown.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
|
|
<param name="source">Source sequence.</param>
|
|
<param name="count">Count to assert.</param>
|
|
<param name="errorSelector">
|
|
Function that receives a comparison (a negative integer if actual
|
|
count is less than <paramref name="count"/> and a positive integer
|
|
if actual count is greater than <paramref name="count"/>) and
|
|
<paramref name="count"/> as arguments and which returns the
|
|
<see cref="T:System.Exception"/> object to throw.</param>
|
|
<returns>
|
|
Returns the original sequence as long it is contains the
|
|
number of elements specified by <paramref name="count"/>.
|
|
Otherwise it throws the <see cref="T:System.Exception" /> object
|
|
returned by calling <paramref name="errorSelector"/>.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Backsert``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Inserts the elements of a sequence into another sequence at a
|
|
specified index from the tail of the sequence, where zero always
|
|
represents the last position, one represents the second-last
|
|
element, two represents the third-last element and so on.
|
|
</summary>
|
|
<typeparam name="T">
|
|
Type of elements in all sequences.</typeparam>
|
|
<param name="first">The source sequence.</param>
|
|
<param name="second">The sequence that will be inserted.</param>
|
|
<param name="index">
|
|
The zero-based index from the end of <paramref name="first"/> where
|
|
elements from <paramref name="second"/> should be inserted.
|
|
<paramref name="second"/>.</param>
|
|
<returns>
|
|
A sequence that contains the elements of <paramref name="first"/>
|
|
plus the elements of <paramref name="second"/> inserted at
|
|
the given index from the end of <paramref name="first"/>.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="first"/> is null.</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="second"/> is null.</exception>
|
|
<exception cref="T:System.ArgumentOutOfRangeException">
|
|
Thrown if <paramref name="index"/> is negative.
|
|
</exception>
|
|
<exception cref="T:System.ArgumentOutOfRangeException">
|
|
Thrown lazily if <paramref name="index"/> is greater than the
|
|
length of <paramref name="first"/>. The validation occurs when
|
|
the resulting sequence is iterated.
|
|
</exception>
|
|
<remarks>
|
|
This method uses deferred execution and streams its results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Batch``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Batches the source sequence into sized buckets.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="size">Size of buckets.</param>
|
|
<returns>A sequence of equally sized buckets containing elements of the source collection.</returns>
|
|
<remarks>
|
|
<para>
|
|
This operator uses deferred execution and streams its results
|
|
(buckets are streamed but their content buffered).</para>
|
|
<para>
|
|
When more than one bucket is streamed, all buckets except the last
|
|
is guaranteed to have <paramref name="size"/> elements. The last
|
|
bucket may be smaller depending on the remaining elements in the
|
|
<paramref name="source"/> sequence.</para>
|
|
<para>
|
|
Each bucket is pre-allocated to <paramref name="size"/> elements.
|
|
If <paramref name="size"/> is set to a very large value, e.g.
|
|
<see cref="F:System.Int32.MaxValue"/> to effectively disable batching by just
|
|
hoping for a single bucket, then it can lead to memory exhaustion
|
|
(<see cref="T:System.OutOfMemoryException"/>).
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Batch``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1})">
|
|
<summary>
|
|
Batches the source sequence into sized buckets and applies a projection to each bucket.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
|
|
<typeparam name="TResult">Type of result returned by <paramref name="resultSelector"/>.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="size">Size of buckets.</param>
|
|
<param name="resultSelector">The projection to apply to each bucket.</param>
|
|
<returns>A sequence of projections on equally sized buckets containing elements of the source collection.</returns>
|
|
<para>
|
|
This operator uses deferred execution and streams its results
|
|
(buckets are streamed but their content buffered).</para>
|
|
<para>
|
|
<para>
|
|
When more than one bucket is streamed, all buckets except the last
|
|
is guaranteed to have <paramref name="size"/> elements. The last
|
|
bucket may be smaller depending on the remaining elements in the
|
|
<paramref name="source"/> sequence.</para>
|
|
Each bucket is pre-allocated to <paramref name="size"/> elements.
|
|
If <paramref name="size"/> is set to a very large value, e.g.
|
|
<see cref="F:System.Int32.MaxValue"/> to effectively disable batching by just
|
|
hoping for a single bucket, then it can lead to memory exhaustion
|
|
(<see cref="T:System.OutOfMemoryException"/>).
|
|
</para>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Cartesian``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
|
|
<summary>
|
|
Returns the Cartesian product of two sequences by enumerating all
|
|
possible combinations of one item from each sequence, and applying
|
|
a user-defined projection to the items in a given combination.
|
|
</summary>
|
|
<typeparam name="T1">
|
|
The type of the elements of <paramref name="first"/>.</typeparam>
|
|
<typeparam name="T2">
|
|
The type of the elements of <paramref name="second"/>.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the elements of the result sequence.</typeparam>
|
|
<param name="first">The first sequence of elements.</param>
|
|
<param name="second">The second sequence of elements.</param>
|
|
<param name="resultSelector">A projection function that combines
|
|
elements from all of the sequences.</param>
|
|
<returns>A sequence of elements returned by
|
|
<paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
<para>
|
|
The method returns items in the same order as a nested foreach
|
|
loop, but all sequences except for <paramref name="first"/> are
|
|
cached when iterated over. The cache is then re-used for any
|
|
subsequent iterations.</para>
|
|
<para>
|
|
This method uses deferred execution and stream its results.</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Cartesian``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
|
|
<summary>
|
|
Returns the Cartesian product of three sequences by enumerating all
|
|
possible combinations of one item from each sequence, and applying
|
|
a user-defined projection to the items in a given combination.
|
|
</summary>
|
|
<typeparam name="T1">
|
|
The type of the elements of <paramref name="first"/>.</typeparam>
|
|
<typeparam name="T2">
|
|
The type of the elements of <paramref name="second"/>.</typeparam>
|
|
<typeparam name="T3">
|
|
The type of the elements of <paramref name="third"/>.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the elements of the result sequence.</typeparam>
|
|
<param name="first">The first sequence of elements.</param>
|
|
<param name="second">The second sequence of elements.</param>
|
|
<param name="third">The third sequence of elements.</param>
|
|
<param name="resultSelector">A projection function that combines
|
|
elements from all of the sequences.</param>
|
|
<returns>A sequence of elements returned by
|
|
<paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
<para>
|
|
The method returns items in the same order as a nested foreach
|
|
loop, but all sequences except for <paramref name="first"/> are
|
|
cached when iterated over. The cache is then re-used for any
|
|
subsequent iterations.</para>
|
|
<para>
|
|
This method uses deferred execution and stream its results.</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Cartesian``5(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Func{``0,``1,``2,``3,``4})">
|
|
<summary>
|
|
Returns the Cartesian product of four sequences by enumerating all
|
|
possible combinations of one item from each sequence, and applying
|
|
a user-defined projection to the items in a given combination.
|
|
</summary>
|
|
<typeparam name="T1">
|
|
The type of the elements of <paramref name="first"/>.</typeparam>
|
|
<typeparam name="T2">
|
|
The type of the elements of <paramref name="second"/>.</typeparam>
|
|
<typeparam name="T3">
|
|
The type of the elements of <paramref name="third"/>.</typeparam>
|
|
<typeparam name="T4">
|
|
The type of the elements of <paramref name="fourth"/>.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the elements of the result sequence.</typeparam>
|
|
<param name="first">The first sequence of elements.</param>
|
|
<param name="second">The second sequence of elements.</param>
|
|
<param name="third">The third sequence of elements.</param>
|
|
<param name="fourth">The fourth sequence of elements.</param>
|
|
<param name="resultSelector">A projection function that combines
|
|
elements from all of the sequences.</param>
|
|
<returns>A sequence of elements returned by
|
|
<paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
<para>
|
|
The method returns items in the same order as a nested foreach
|
|
loop, but all sequences except for <paramref name="first"/> are
|
|
cached when iterated over. The cache is then re-used for any
|
|
subsequent iterations.</para>
|
|
<para>
|
|
This method uses deferred execution and stream its results.</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Cartesian``6(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Collections.Generic.IEnumerable{``4},System.Func{``0,``1,``2,``3,``4,``5})">
|
|
<summary>
|
|
Returns the Cartesian product of five sequences by enumerating all
|
|
possible combinations of one item from each sequence, and applying
|
|
a user-defined projection to the items in a given combination.
|
|
</summary>
|
|
<typeparam name="T1">
|
|
The type of the elements of <paramref name="first"/>.</typeparam>
|
|
<typeparam name="T2">
|
|
The type of the elements of <paramref name="second"/>.</typeparam>
|
|
<typeparam name="T3">
|
|
The type of the elements of <paramref name="third"/>.</typeparam>
|
|
<typeparam name="T4">
|
|
The type of the elements of <paramref name="fourth"/>.</typeparam>
|
|
<typeparam name="T5">
|
|
The type of the elements of <paramref name="fifth"/>.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the elements of the result sequence.</typeparam>
|
|
<param name="first">The first sequence of elements.</param>
|
|
<param name="second">The second sequence of elements.</param>
|
|
<param name="third">The third sequence of elements.</param>
|
|
<param name="fourth">The fourth sequence of elements.</param>
|
|
<param name="fifth">The fifth sequence of elements.</param>
|
|
<param name="resultSelector">A projection function that combines
|
|
elements from all of the sequences.</param>
|
|
<returns>A sequence of elements returned by
|
|
<paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
<para>
|
|
The method returns items in the same order as a nested foreach
|
|
loop, but all sequences except for <paramref name="first"/> are
|
|
cached when iterated over. The cache is then re-used for any
|
|
subsequent iterations.</para>
|
|
<para>
|
|
This method uses deferred execution and stream its results.</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Cartesian``7(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Collections.Generic.IEnumerable{``4},System.Collections.Generic.IEnumerable{``5},System.Func{``0,``1,``2,``3,``4,``5,``6})">
|
|
<summary>
|
|
Returns the Cartesian product of six sequences by enumerating all
|
|
possible combinations of one item from each sequence, and applying
|
|
a user-defined projection to the items in a given combination.
|
|
</summary>
|
|
<typeparam name="T1">
|
|
The type of the elements of <paramref name="first"/>.</typeparam>
|
|
<typeparam name="T2">
|
|
The type of the elements of <paramref name="second"/>.</typeparam>
|
|
<typeparam name="T3">
|
|
The type of the elements of <paramref name="third"/>.</typeparam>
|
|
<typeparam name="T4">
|
|
The type of the elements of <paramref name="fourth"/>.</typeparam>
|
|
<typeparam name="T5">
|
|
The type of the elements of <paramref name="fifth"/>.</typeparam>
|
|
<typeparam name="T6">
|
|
The type of the elements of <paramref name="sixth"/>.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the elements of the result sequence.</typeparam>
|
|
<param name="first">The first sequence of elements.</param>
|
|
<param name="second">The second sequence of elements.</param>
|
|
<param name="third">The third sequence of elements.</param>
|
|
<param name="fourth">The fourth sequence of elements.</param>
|
|
<param name="fifth">The fifth sequence of elements.</param>
|
|
<param name="sixth">The sixth sequence of elements.</param>
|
|
<param name="resultSelector">A projection function that combines
|
|
elements from all of the sequences.</param>
|
|
<returns>A sequence of elements returned by
|
|
<paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
<para>
|
|
The method returns items in the same order as a nested foreach
|
|
loop, but all sequences except for <paramref name="first"/> are
|
|
cached when iterated over. The cache is then re-used for any
|
|
subsequent iterations.</para>
|
|
<para>
|
|
This method uses deferred execution and stream its results.</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Cartesian``8(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Collections.Generic.IEnumerable{``4},System.Collections.Generic.IEnumerable{``5},System.Collections.Generic.IEnumerable{``6},System.Func{``0,``1,``2,``3,``4,``5,``6,``7})">
|
|
<summary>
|
|
Returns the Cartesian product of seven sequences by enumerating all
|
|
possible combinations of one item from each sequence, and applying
|
|
a user-defined projection to the items in a given combination.
|
|
</summary>
|
|
<typeparam name="T1">
|
|
The type of the elements of <paramref name="first"/>.</typeparam>
|
|
<typeparam name="T2">
|
|
The type of the elements of <paramref name="second"/>.</typeparam>
|
|
<typeparam name="T3">
|
|
The type of the elements of <paramref name="third"/>.</typeparam>
|
|
<typeparam name="T4">
|
|
The type of the elements of <paramref name="fourth"/>.</typeparam>
|
|
<typeparam name="T5">
|
|
The type of the elements of <paramref name="fifth"/>.</typeparam>
|
|
<typeparam name="T6">
|
|
The type of the elements of <paramref name="sixth"/>.</typeparam>
|
|
<typeparam name="T7">
|
|
The type of the elements of <paramref name="seventh"/>.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the elements of the result sequence.</typeparam>
|
|
<param name="first">The first sequence of elements.</param>
|
|
<param name="second">The second sequence of elements.</param>
|
|
<param name="third">The third sequence of elements.</param>
|
|
<param name="fourth">The fourth sequence of elements.</param>
|
|
<param name="fifth">The fifth sequence of elements.</param>
|
|
<param name="sixth">The sixth sequence of elements.</param>
|
|
<param name="seventh">The seventh sequence of elements.</param>
|
|
<param name="resultSelector">A projection function that combines
|
|
elements from all of the sequences.</param>
|
|
<returns>A sequence of elements returned by
|
|
<paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
<para>
|
|
The method returns items in the same order as a nested foreach
|
|
loop, but all sequences except for <paramref name="first"/> are
|
|
cached when iterated over. The cache is then re-used for any
|
|
subsequent iterations.</para>
|
|
<para>
|
|
This method uses deferred execution and stream its results.</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Cartesian``9(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Collections.Generic.IEnumerable{``4},System.Collections.Generic.IEnumerable{``5},System.Collections.Generic.IEnumerable{``6},System.Collections.Generic.IEnumerable{``7},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8})">
|
|
<summary>
|
|
Returns the Cartesian product of eight sequences by enumerating all
|
|
possible combinations of one item from each sequence, and applying
|
|
a user-defined projection to the items in a given combination.
|
|
</summary>
|
|
<typeparam name="T1">
|
|
The type of the elements of <paramref name="first"/>.</typeparam>
|
|
<typeparam name="T2">
|
|
The type of the elements of <paramref name="second"/>.</typeparam>
|
|
<typeparam name="T3">
|
|
The type of the elements of <paramref name="third"/>.</typeparam>
|
|
<typeparam name="T4">
|
|
The type of the elements of <paramref name="fourth"/>.</typeparam>
|
|
<typeparam name="T5">
|
|
The type of the elements of <paramref name="fifth"/>.</typeparam>
|
|
<typeparam name="T6">
|
|
The type of the elements of <paramref name="sixth"/>.</typeparam>
|
|
<typeparam name="T7">
|
|
The type of the elements of <paramref name="seventh"/>.</typeparam>
|
|
<typeparam name="T8">
|
|
The type of the elements of <paramref name="eighth"/>.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the elements of the result sequence.</typeparam>
|
|
<param name="first">The first sequence of elements.</param>
|
|
<param name="second">The second sequence of elements.</param>
|
|
<param name="third">The third sequence of elements.</param>
|
|
<param name="fourth">The fourth sequence of elements.</param>
|
|
<param name="fifth">The fifth sequence of elements.</param>
|
|
<param name="sixth">The sixth sequence of elements.</param>
|
|
<param name="seventh">The seventh sequence of elements.</param>
|
|
<param name="eighth">The eighth sequence of elements.</param>
|
|
<param name="resultSelector">A projection function that combines
|
|
elements from all of the sequences.</param>
|
|
<returns>A sequence of elements returned by
|
|
<paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
<para>
|
|
The method returns items in the same order as a nested foreach
|
|
loop, but all sequences except for <paramref name="first"/> are
|
|
cached when iterated over. The cache is then re-used for any
|
|
subsequent iterations.</para>
|
|
<para>
|
|
This method uses deferred execution and stream its results.</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Choose``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.ValueTuple{System.Boolean,``1}})">
|
|
<summary>
|
|
Applies a function to each element of the source sequence and
|
|
returns a new sequence of result elements for source elements
|
|
where the function returns a couple (2-tuple) having a <c>true</c>
|
|
as its first element and result as the second.
|
|
</summary>
|
|
<typeparam name="T">
|
|
The type of the elements in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the elements in the returned sequence.</typeparam>
|
|
<param name="source"> The source sequence.</param>
|
|
<param name="chooser">The function that is applied to each source
|
|
element.</param>
|
|
<returns>A sequence <typeparamref name="TResult"/> elements.</returns>
|
|
<remarks>
|
|
This method uses deferred execution semantics and streams its
|
|
results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
var str = "O,l,2,3,4,S,6,7,B,9";
|
|
var xs = str.Split(',').Choose(s => (int.TryParse(s, out var n), n));
|
|
]]></code>
|
|
The <c>xs</c> variable will be a sequence of the integers 2, 3, 4,
|
|
6, 7 and 9.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Consume``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Completely consumes the given sequence. This method uses immediate execution,
|
|
and doesn't store any data during execution.
|
|
</summary>
|
|
<typeparam name="T">Element type of the sequence</typeparam>
|
|
<param name="source">Source to consume</param>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.CountBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TSource">Type of the elements of the source sequence.</typeparam>
|
|
<typeparam name="TKey">Type of the projected element.</typeparam>
|
|
<param name="source">Source sequence.</param>
|
|
<param name="keySelector">Function that transforms each item of source sequence into a key to be compared against the others.</param>
|
|
<returns>A sequence of unique keys and their number of occurrences in the original sequence.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.CountBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TSource">Type of the elements of the source sequence.</typeparam>
|
|
<typeparam name="TKey">Type of the projected element.</typeparam>
|
|
<param name="source">Source sequence.</param>
|
|
<param name="keySelector">Function that transforms each item of source sequence into a key to be compared against the others.</param>
|
|
<param name="comparer">The equality comparer to use to determine whether or not keys are equal.
|
|
If null, the default equality comparer for <typeparamref name="TSource"/> is used.</param>
|
|
<returns>A sequence of unique keys and their number of occurrences in the original sequence.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.CountDown``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,System.Nullable{System.Int32},``1})">
|
|
<summary>
|
|
Provides a countdown counter for a given count of elements at the
|
|
tail of the sequence where zero always represents the last element,
|
|
one represents the second-last element, two represents the
|
|
third-last element and so on.
|
|
</summary>
|
|
<typeparam name="T">
|
|
The type of elements of <paramref name="source"/></typeparam>
|
|
<typeparam name="TResult">
|
|
The type of elements of the resulting sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="count">Count of tail elements of
|
|
<paramref name="source"/> to count down.</param>
|
|
<param name="resultSelector">
|
|
A function that receives the element and the current countdown
|
|
value for the element and which returns those mapped to a
|
|
result returned in the resulting sequence. For elements before
|
|
the last <paramref name="count"/>, the coundown value is
|
|
<c>null</c>.</param>
|
|
<returns>
|
|
A sequence of results returned by
|
|
<paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
This method uses deferred execution semantics and streams its
|
|
results. At most, <paramref name="count"/> elements of the source
|
|
sequence may be buffered at any one time unless
|
|
<paramref name="source"/> is a collection or a list.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.AtLeast``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Determines whether or not the number of elements in the sequence is greater than
|
|
or equal to the given integer.
|
|
</summary>
|
|
<typeparam name="T">Element type of sequence</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="count">The minimum number of items a sequence must have for this
|
|
function to return true</param>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentOutOfRangeException"><paramref name="count"/> is negative</exception>
|
|
<returns><c>true</c> if the number of elements in the sequence is greater than
|
|
or equal to the given integer or <c>false</c> otherwise.</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = new[] { 123, 456, 789 };
|
|
var result = numbers.AtLeast(2);
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>true</c>.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.AtMost``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Determines whether or not the number of elements in the sequence is lesser than
|
|
or equal to the given integer.
|
|
</summary>
|
|
<typeparam name="T">Element type of sequence</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="count">The maximun number of items a sequence must have for this
|
|
function to return true</param>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentOutOfRangeException"><paramref name="count"/> is negative</exception>
|
|
<returns><c>true</c> if the number of elements in the sequence is lesser than
|
|
or equal to the given integer or <c>false</c> otherwise.</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = new[] { 123, 456, 789 };
|
|
var result = numbers.AtMost(2);
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>false</c>.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Exactly``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Determines whether or not the number of elements in the sequence is equals to the given integer.
|
|
</summary>
|
|
<typeparam name="T">Element type of sequence</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="count">The exactly number of items a sequence must have for this
|
|
function to return true</param>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentOutOfRangeException"><paramref name="count"/> is negative</exception>
|
|
<returns><c>true</c> if the number of elements in the sequence is equals
|
|
to the given integer or <c>false</c> otherwise.</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = new[] { 123, 456, 789 };
|
|
var result = numbers.Exactly(3);
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>true</c>.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.CountBetween``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Int32)">
|
|
<summary>
|
|
Determines whether or not the number of elements in the sequence is between
|
|
an inclusive range of minimum and maximum integers.
|
|
</summary>
|
|
<typeparam name="T">Element type of sequence</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="min">The minimum number of items a sequence must have for this
|
|
function to return true</param>
|
|
<param name="max">The maximun number of items a sequence must have for this
|
|
function to return true</param>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentOutOfRangeException"><paramref name="min"/> is negative or <paramref name="max"/> is less than min</exception>
|
|
<returns><c>true</c> if the number of elements in the sequence is between (inclusive)
|
|
the min and max given integers or <c>false</c> otherwise.</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = new[] { 123, 456, 789 };
|
|
var result = numbers.CountBetween(1, 2);
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>false</c>.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.CompareCount``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1})">
|
|
<summary>
|
|
Compares two sequences and returns an integer that indicates whether the first sequence
|
|
has fewer, the same or more elements than the second sequence.
|
|
</summary>
|
|
<typeparam name="TFirst">Element type of the first sequence</typeparam>
|
|
<typeparam name="TSecond">Element type of the second sequence</typeparam>
|
|
<param name="first">The first sequence</param>
|
|
<param name="second">The second sequence</param>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="first"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="second"/> is null</exception>
|
|
<returns><c>-1</c> if the first sequence has the fewest elements, <c>0</c> if the two sequences have the same number of elements
|
|
or <c>1</c> if the first sequence has the most elements.</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var first = new[] { 123, 456 };
|
|
var second = new[] { 789 };
|
|
var result = first.CompareCount(second);
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>1</c>.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.DistinctBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
|
|
<summary>
|
|
Returns all distinct elements of the given source, where "distinctness"
|
|
is determined via a projection and the default equality comparer for the projected type.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses deferred execution and streams the results, although
|
|
a set of already-seen keys is retained. If a key is seen multiple times,
|
|
only the first element with that key is returned.
|
|
</remarks>
|
|
<typeparam name="TSource">Type of the source sequence</typeparam>
|
|
<typeparam name="TKey">Type of the projected element</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<param name="keySelector">Projection for determining "distinctness"</param>
|
|
<returns>A sequence consisting of distinct elements from the source sequence,
|
|
comparing them by the specified key projection.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.DistinctBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
|
|
<summary>
|
|
Returns all distinct elements of the given source, where "distinctness"
|
|
is determined via a projection and the specified comparer for the projected type.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses deferred execution and streams the results, although
|
|
a set of already-seen keys is retained. If a key is seen multiple times,
|
|
only the first element with that key is returned.
|
|
</remarks>
|
|
<typeparam name="TSource">Type of the source sequence</typeparam>
|
|
<typeparam name="TKey">Type of the projected element</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<param name="keySelector">Projection for determining "distinctness"</param>
|
|
<param name="comparer">The equality comparer to use to determine whether or not keys are equal.
|
|
If null, the default equality comparer for <c>TSource</c> is used.</param>
|
|
<returns>A sequence consisting of distinct elements from the source sequence,
|
|
comparing them by the specified key projection.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.EndsWith``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Determines whether the end of the first sequence is equivalent to
|
|
the second sequence, using the default equality comparer.
|
|
</summary>
|
|
<typeparam name="T">Type of elements.</typeparam>
|
|
<param name="first">The sequence to check.</param>
|
|
<param name="second">The sequence to compare to.</param>
|
|
<returns>
|
|
<c>true</c> if <paramref name="first" /> ends with elements
|
|
equivalent to <paramref name="second" />.
|
|
</returns>
|
|
<remarks>
|
|
This is the <see cref="T:System.Collections.Generic.IEnumerable`1" /> equivalent of
|
|
<see cref="M:System.String.EndsWith(System.String)" /> and
|
|
it calls <see cref="M:System.Collections.Generic.IEqualityComparer`1.Equals(`0,`0)" /> using
|
|
<see cref="P:System.Collections.Generic.EqualityComparer`1.Default" /> on pairs of elements at
|
|
the same index.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.EndsWith``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
|
|
<summary>
|
|
Determines whether the end of the first sequence is equivalent to
|
|
the second sequence, using the specified element equality comparer.
|
|
</summary>
|
|
<typeparam name="T">Type of elements.</typeparam>
|
|
<param name="first">The sequence to check.</param>
|
|
<param name="second">The sequence to compare to.</param>
|
|
<param name="comparer">Equality comparer to use.</param>
|
|
<returns>
|
|
<c>true</c> if <paramref name="first" /> ends with elements
|
|
equivalent to <paramref name="second" />.
|
|
</returns>
|
|
<remarks>
|
|
This is the <see cref="T:System.Collections.Generic.IEnumerable`1" /> equivalent of
|
|
<see cref="M:System.String.EndsWith(System.String)" /> and it calls
|
|
<see cref="M:System.Collections.Generic.IEqualityComparer`1.Equals(`0,`0)" /> on pairs of
|
|
elements at the same index.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.EquiZip``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
|
|
<summary>
|
|
Returns a projection of tuples, where each tuple contains the N-th
|
|
element from each of the argument sequences. An exception is thrown
|
|
if the input sequences are of different lengths.
|
|
</summary>
|
|
<typeparam name="TFirst">Type of elements in first sequence.</typeparam>
|
|
<typeparam name="TSecond">Type of elements in second sequence.</typeparam>
|
|
<typeparam name="TResult">Type of elements in result sequence.</typeparam>
|
|
<param name="first">The first sequence.</param>
|
|
<param name="second">The second sequence.</param>
|
|
<param name="resultSelector">
|
|
Function to apply to each pair of elements.</param>
|
|
<returns>
|
|
A sequence that contains elements of the two input sequences,
|
|
combined by <paramref name="resultSelector"/>.
|
|
</returns>
|
|
<exception cref="T:System.InvalidOperationException">
|
|
The input sequences are of different lengths.
|
|
</exception>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = new[] { 1, 2, 3, 4 };
|
|
var letters = new[] { "A", "B", "C", "D" };
|
|
var zipped = numbers.EquiZip(letters, (n, l) => n + l);
|
|
]]></code>
|
|
The <c>zipped</c> variable, when iterated over, will yield "1A",
|
|
"2B", "3C", "4D" in turn.
|
|
</example>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.EquiZip``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
|
|
<summary>
|
|
Returns a projection of tuples, where each tuple contains the N-th
|
|
element from each of the argument sequences. An exception is thrown
|
|
if the input sequences are of different lengths.
|
|
</summary>
|
|
<typeparam name="T1">Type of elements in first sequence.</typeparam>
|
|
<typeparam name="T2">Type of elements in second sequence.</typeparam>
|
|
<typeparam name="T3">Type of elements in third sequence.</typeparam>
|
|
<typeparam name="TResult">Type of elements in result sequence.</typeparam>
|
|
<param name="first">The first sequence.</param>
|
|
<param name="second">The second sequence.</param>
|
|
<param name="third">The third sequence.</param>
|
|
<param name="resultSelector">
|
|
Function to apply to each triplet of elements.</param>
|
|
<returns>
|
|
A sequence that contains elements of the three input sequences,
|
|
combined by <paramref name="resultSelector"/>.
|
|
</returns>
|
|
<exception cref="T:System.InvalidOperationException">
|
|
The input sequences are of different lengths.
|
|
</exception>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = new[] { 1, 2, 3, 4 };
|
|
var letters = new[] { "A", "B", "C", "D" };
|
|
var chars = new[] { 'a', 'b', 'c', 'd' };
|
|
var zipped = numbers.EquiZip(letters, chars, (n, l, c) => n + l + c);
|
|
]]></code>
|
|
The <c>zipped</c> variable, when iterated over, will yield "1Aa",
|
|
"2Bb", "3Cc", "4Dd" in turn.
|
|
</example>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.EquiZip``5(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Func{``0,``1,``2,``3,``4})">
|
|
<summary>
|
|
Returns a projection of tuples, where each tuple contains the N-th
|
|
element from each of the argument sequences. An exception is thrown
|
|
if the input sequences are of different lengths.
|
|
</summary>
|
|
<typeparam name="T1">Type of elements in first sequence</typeparam>
|
|
<typeparam name="T2">Type of elements in second sequence</typeparam>
|
|
<typeparam name="T3">Type of elements in third sequence</typeparam>
|
|
<typeparam name="T4">Type of elements in fourth sequence</typeparam>
|
|
<typeparam name="TResult">Type of elements in result sequence</typeparam>
|
|
<param name="first">The first sequence.</param>
|
|
<param name="second">The second sequence.</param>
|
|
<param name="third">The third sequence.</param>
|
|
<param name="fourth">The fourth sequence.</param>
|
|
<param name="resultSelector">
|
|
Function to apply to each quadruplet of elements.</param>
|
|
<returns>
|
|
A sequence that contains elements of the four input sequences,
|
|
combined by <paramref name="resultSelector"/>.
|
|
</returns>
|
|
<exception cref="T:System.InvalidOperationException">
|
|
The input sequences are of different lengths.
|
|
</exception>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = new[] { 1, 2, 3, 4 };
|
|
var letters = new[] { "A", "B", "C", "D" };
|
|
var chars = new[] { 'a', 'b', 'c', 'd' };
|
|
var flags = new[] { true, false, true, false };
|
|
var zipped = numbers.EquiZip(letters, chars, flags, (n, l, c, f) => n + l + c + f);
|
|
]]></code>
|
|
The <c>zipped</c> variable, when iterated over, will yield "1AaTrue",
|
|
"2BbFalse", "3CcTrue", "4DdFalse" in turn.
|
|
</example>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Evaluate``1(System.Collections.Generic.IEnumerable{System.Func{``0}})">
|
|
<summary>
|
|
Returns a sequence containing the values resulting from invoking (in order) each function in the source sequence of functions.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses deferred execution and streams the results.
|
|
If the resulting sequence is enumerated multiple times, the functions will be
|
|
evaluated multiple times too.
|
|
</remarks>
|
|
<typeparam name="T">The type of the object returned by the functions.</typeparam>
|
|
<param name="functions">The functions to evaluate.</param>
|
|
<returns>A sequence with results from invoking <paramref name="functions"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException">When <paramref name="functions"/> is <c>null</c>.</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ExceptBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
|
|
<summary>
|
|
Returns the set of elements in the first sequence which aren't
|
|
in the second sequence, according to a given key selector.
|
|
</summary>
|
|
<remarks>
|
|
This is a set operation; if multiple elements in <paramref name="first"/> have
|
|
equal keys, only the first such element is returned.
|
|
This operator uses deferred execution and streams the results, although
|
|
a set of keys from <paramref name="second"/> is immediately selected and retained.
|
|
</remarks>
|
|
<typeparam name="TSource">The type of the elements in the input sequences.</typeparam>
|
|
<typeparam name="TKey">The type of the key returned by <paramref name="keySelector"/>.</typeparam>
|
|
<param name="first">The sequence of potentially included elements.</param>
|
|
<param name="second">The sequence of elements whose keys may prevent elements in
|
|
<paramref name="first"/> from being returned.</param>
|
|
<param name="keySelector">The mapping from source element to key.</param>
|
|
<returns>A sequence of elements from <paramref name="first"/> whose key was not also a key for
|
|
any element in <paramref name="second"/>.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ExceptBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
|
|
<summary>
|
|
Returns the set of elements in the first sequence which aren't
|
|
in the second sequence, according to a given key selector.
|
|
</summary>
|
|
<remarks>
|
|
This is a set operation; if multiple elements in <paramref name="first"/> have
|
|
equal keys, only the first such element is returned.
|
|
This operator uses deferred execution and streams the results, although
|
|
a set of keys from <paramref name="second"/> is immediately selected and retained.
|
|
</remarks>
|
|
<typeparam name="TSource">The type of the elements in the input sequences.</typeparam>
|
|
<typeparam name="TKey">The type of the key returned by <paramref name="keySelector"/>.</typeparam>
|
|
<param name="first">The sequence of potentially included elements.</param>
|
|
<param name="second">The sequence of elements whose keys may prevent elements in
|
|
<paramref name="first"/> from being returned.</param>
|
|
<param name="keySelector">The mapping from source element to key.</param>
|
|
<param name="keyComparer">The equality comparer to use to determine whether or not keys are equal.
|
|
If null, the default equality comparer for <c>TSource</c> is used.</param>
|
|
<returns>A sequence of elements from <paramref name="first"/> whose key was not also a key for
|
|
any element in <paramref name="second"/>.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Exclude``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Int32)">
|
|
<summary>
|
|
Excludes a contiguous number of elements from a sequence starting
|
|
at a given index.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements of the sequence</typeparam>
|
|
<param name="sequence">The sequence to exclude elements from</param>
|
|
<param name="startIndex">The zero-based index at which to begin excluding elements</param>
|
|
<param name="count">The number of elements to exclude</param>
|
|
<returns>A sequence that excludes the specified portion of elements</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.FallbackIfEmpty``1(System.Collections.Generic.IEnumerable{``0},``0)">
|
|
<summary>
|
|
Returns the elements of the specified sequence or the specified
|
|
value in a singleton collection if the sequence is empty.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequences.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="fallback">The value to return in a singleton
|
|
collection if <paramref name="source"/> is empty.</param>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that contains <paramref name="fallback"/>
|
|
if <paramref name="source"/> is empty; otherwise, <paramref name="source"/>.
|
|
</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = new[] { 123, 456, 789 };
|
|
var result = numbers.Where(x => x == 100).FallbackIfEmpty(-1).Single();
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>-1</c>.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.FallbackIfEmpty``1(System.Collections.Generic.IEnumerable{``0},``0,``0)">
|
|
<summary>
|
|
Returns the elements of a sequence, but if it is empty then
|
|
returns an alternate sequence of values.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequences.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="fallback1">First value of the alternate sequence that
|
|
is returned if <paramref name="source"/> is empty.</param>
|
|
<param name="fallback2">Second value of the alternate sequence that
|
|
is returned if <paramref name="source"/> is empty.</param>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that containing fallback values
|
|
if <paramref name="source"/> is empty; otherwise, <paramref name="source"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.FallbackIfEmpty``1(System.Collections.Generic.IEnumerable{``0},``0,``0,``0)">
|
|
<summary>
|
|
Returns the elements of a sequence, but if it is empty then
|
|
returns an alternate sequence of values.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequences.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="fallback1">First value of the alternate sequence that
|
|
is returned if <paramref name="source"/> is empty.</param>
|
|
<param name="fallback2">Second value of the alternate sequence that
|
|
is returned if <paramref name="source"/> is empty.</param>
|
|
<param name="fallback3">Third value of the alternate sequence that
|
|
is returned if <paramref name="source"/> is empty.</param>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that containing fallback values
|
|
if <paramref name="source"/> is empty; otherwise, <paramref name="source"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.FallbackIfEmpty``1(System.Collections.Generic.IEnumerable{``0},``0,``0,``0,``0)">
|
|
<summary>
|
|
Returns the elements of a sequence, but if it is empty then
|
|
returns an alternate sequence of values.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequences.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="fallback1">First value of the alternate sequence that
|
|
is returned if <paramref name="source"/> is empty.</param>
|
|
<param name="fallback2">Second value of the alternate sequence that
|
|
is returned if <paramref name="source"/> is empty.</param>
|
|
<param name="fallback3">Third value of the alternate sequence that
|
|
is returned if <paramref name="source"/> is empty.</param>
|
|
<param name="fallback4">Fourth value of the alternate sequence that
|
|
is returned if <paramref name="source"/> is empty.</param>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that containing fallback values
|
|
if <paramref name="source"/> is empty; otherwise, <paramref name="source"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.FallbackIfEmpty``1(System.Collections.Generic.IEnumerable{``0},``0[])">
|
|
<summary>
|
|
Returns the elements of a sequence, but if it is empty then
|
|
returns an alternate sequence from an array of values.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequences.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="fallback">The array that is returned as the alternate
|
|
sequence if <paramref name="source"/> is empty.</param>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that containing fallback values
|
|
if <paramref name="source"/> is empty; otherwise, <paramref name="source"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.FallbackIfEmpty``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Returns the elements of a sequence, but if it is empty then
|
|
returns an alternate sequence of values.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequences.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="fallback">The alternate sequence that is returned
|
|
if <paramref name="source"/> is empty.</param>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that containing fallback values
|
|
if <paramref name="source"/> is empty; otherwise, <paramref name="source"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.FillBackward``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Returns a sequence with each null reference or value in the source
|
|
replaced with the following non-null reference or value in
|
|
that sequence.
|
|
</summary>
|
|
<param name="source">The source sequence.</param>
|
|
<typeparam name="T">Type of the elements in the source sequence.</typeparam>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> with null references or values
|
|
replaced.
|
|
</returns>
|
|
<remarks>
|
|
This method uses deferred execution semantics and streams its
|
|
results. If references or values are null at the end of the
|
|
sequence then they remain null.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.FillBackward``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="predicate">The function used to determine if
|
|
an element in the sequence is considered missing.</param>
|
|
<typeparam name="T">Type of the elements in the source sequence.</typeparam>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> with missing values replaced.
|
|
</returns>
|
|
<remarks>
|
|
This method uses deferred execution semantics and streams its
|
|
results. If elements are missing at the end of the sequence then
|
|
they remain missing.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.FillBackward``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},System.Func{``0,``0,``0})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="predicate">The function used to determine if
|
|
an element in the sequence is considered missing.</param>
|
|
<param name="fillSelector">The function used to produce the element
|
|
that will replace the missing one. Its first argument receives the
|
|
current element considered missing while the second argument
|
|
receives the next non-missing element.</param>
|
|
<typeparam name="T">Type of the elements in the source sequence.</typeparam>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> with missing values replaced.
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> with missing elements filled.
|
|
</returns>
|
|
<remarks>
|
|
This method uses deferred execution semantics and streams its
|
|
results. If elements are missing at the end of the sequence then
|
|
they remain missing.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.FillForward``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<param name="source">The source sequence.</param>
|
|
<typeparam name="T">Type of the elements in the source sequence.</typeparam>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> with null references or values
|
|
replaced.
|
|
</returns>
|
|
<remarks>
|
|
This method uses deferred execution semantics and streams its
|
|
results. If references or values are null at the start of the
|
|
sequence then they remain null.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.FillForward``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="predicate">The function used to determine if
|
|
an element in the sequence is considered missing.</param>
|
|
<typeparam name="T">Type of the elements in the source sequence.</typeparam>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> with missing values replaced.
|
|
</returns>
|
|
<remarks>
|
|
This method uses deferred execution semantics and streams its
|
|
results. If elements are missing at the start of the sequence then
|
|
they remain missing.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.FillForward``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},System.Func{``0,``0,``0})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="predicate">The function used to determine if
|
|
an element in the sequence is considered missing.</param>
|
|
<param name="fillSelector">The function used to produce the element
|
|
that will replace the missing one. Its first argument receives the
|
|
current element considered missing while the second argument
|
|
receives the previous non-missing element.</param>
|
|
<typeparam name="T">Type of the elements in the source sequence.</typeparam>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> with missing values replaced.
|
|
</returns>
|
|
<remarks>
|
|
This method uses deferred execution semantics and streams its
|
|
results. If elements are missing at the start of the sequence then
|
|
they remain missing.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Flatten(System.Collections.IEnumerable)">
|
|
<summary>
|
|
Flattens a sequence containing arbitrarily-nested sequences.
|
|
</summary>
|
|
<param name="source">The sequence that will be flattened.</param>
|
|
<returns>
|
|
A sequence that contains the elements of <paramref name="source"/>
|
|
and all nested sequences (except strings).
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null.</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Flatten(System.Collections.IEnumerable,System.Func{System.Collections.IEnumerable,System.Boolean})">
|
|
<summary>
|
|
Flattens a sequence containing arbitrarily-nested sequences. An
|
|
additional parameter specifies a predicate function used to
|
|
determine whether a nested <see cref="T:System.Collections.IEnumerable"/> should be
|
|
flattened or not.
|
|
</summary>
|
|
<param name="source">The sequence that will be flattened.</param>
|
|
<param name="predicate">
|
|
A function that receives each element that implements
|
|
<see cref="T:System.Collections.IEnumerable"/> and indicates if its elements should be
|
|
recursively flattened into the resulting sequence.
|
|
</param>
|
|
<returns>
|
|
A sequence that contains the elements of <paramref name="source"/>
|
|
and all nested sequences for which the predicate function
|
|
returned <c>true</c>.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> is <c>null</c>.</exception>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="predicate"/> is <c>null</c>.</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Flatten(System.Collections.IEnumerable,System.Func{System.Object,System.Collections.IEnumerable})">
|
|
<summary>
|
|
Flattens a sequence containing arbitrarily-nested sequences. An
|
|
additional parameter specifies a function that projects an inner
|
|
sequence via a property of an object.
|
|
</summary>
|
|
<param name="source">The sequence that will be flattened.</param>
|
|
<param name="selector">
|
|
A function that receives each element of the sequence as an object
|
|
and projects an inner sequence to be flattened. If the function
|
|
returns <c>null</c> then the object argument is considered a leaf
|
|
of the flattening process.
|
|
</param>
|
|
<returns>
|
|
A sequence that contains the elements of <paramref name="source"/>
|
|
and all nested sequences projected via the
|
|
<paramref name="selector"/> function.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> is <c>null</c>.</exception>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="selector"/> is <c>null</c>.</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
1 element.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 1 element</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
2 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 2 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
3 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 3 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
4 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 4 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
5 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 5 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
6 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 6 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
7 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 7 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
8 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 8 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
9 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 9 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
10 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 10 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
11 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 11 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
12 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 12 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
13 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 13 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
14 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 14 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
15 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 15 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
16 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 16 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0})">
|
|
<summary>
|
|
Immediately executes the given action on each element in the source sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequence</typeparam>
|
|
<param name="source">The sequence of elements</param>
|
|
<param name="action">The action to execute on each element</param>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0,System.Int32})">
|
|
<summary>
|
|
Immediately executes the given action on each element in the source sequence.
|
|
Each element's index is used in the logic of the action.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequence</typeparam>
|
|
<param name="source">The sequence of elements</param>
|
|
<param name="action">The action to execute on each element; the second parameter
|
|
of the action represents the index of the source element.</param>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.From``1(System.Func{``0})">
|
|
<summary>
|
|
Returns a single-element sequence containing the result of invoking the function.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses deferred execution and streams the results.
|
|
If the resulting sequence is enumerated multiple times, the function will be
|
|
invoked multiple times too.
|
|
</remarks>
|
|
<typeparam name="T">The type of the object returned by the function.</typeparam>
|
|
<param name="function">The function to evaluate.</param>
|
|
<returns>A sequence with the value resulting from invoking <paramref name="function"/>.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.From``1(System.Func{``0},System.Func{``0})">
|
|
<summary>
|
|
Returns a sequence containing the result of invoking each parameter function in order.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses deferred execution and streams the results.
|
|
If the resulting sequence is enumerated multiple times, the functions will be
|
|
invoked multiple times too.
|
|
</remarks>
|
|
<typeparam name="T">The type of the object returned by the functions.</typeparam>
|
|
<param name="function1">The first function to evaluate.</param>
|
|
<param name="function2">The second function to evaluate.</param>
|
|
<returns>A sequence with the values resulting from invoking <paramref name="function1"/> and <paramref name="function2"/>.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.From``1(System.Func{``0},System.Func{``0},System.Func{``0})">
|
|
<summary>
|
|
Returns a sequence containing the result of invoking each parameter function in order.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses deferred execution and streams the results.
|
|
If the resulting sequence is enumerated multiple times, the functions will be
|
|
invoked multiple times too.
|
|
</remarks>
|
|
<typeparam name="T">The type of the object returned by the functions.</typeparam>
|
|
<param name="function1">The first function to evaluate.</param>
|
|
<param name="function2">The second function to evaluate.</param>
|
|
<param name="function3">The third function to evaluate.</param>
|
|
<returns>A sequence with the values resulting from invoking <paramref name="function1"/>, <paramref name="function2"/> and <paramref name="function3"/>.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.From``1(System.Func{``0}[])">
|
|
<summary>
|
|
Returns a sequence containing the values resulting from invoking (in order) each function in the source sequence of functions.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses deferred execution and streams the results.
|
|
If the resulting sequence is enumerated multiple times, the functions will be
|
|
invoked multiple times too.
|
|
</remarks>
|
|
<typeparam name="T">The type of the object returned by the functions.</typeparam>
|
|
<param name="functions">The functions to evaluate.</param>
|
|
<returns>A sequence with the values resulting from invoking all of the <paramref name="functions"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException">When <paramref name="functions"/> is <c>null</c>.</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.FullGroupJoin``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2})">
|
|
<summary>
|
|
Performs a Full Group Join between the <paramref name="first"/> and <paramref name="second"/> sequences.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses deferred execution and streams the results.
|
|
The results are yielded in the order of the elements found in the first sequence
|
|
followed by those found only in the second. In addition, the callback responsible
|
|
for projecting the results is supplied with sequences which preserve their source order.
|
|
</remarks>
|
|
<typeparam name="TFirst">The type of the elements in the first input sequence</typeparam>
|
|
<typeparam name="TSecond">The type of the elements in the second input sequence</typeparam>
|
|
<typeparam name="TKey">The type of the key to use to join</typeparam>
|
|
<param name="first">First sequence</param>
|
|
<param name="second">Second sequence</param>
|
|
<param name="firstKeySelector">The mapping from first sequence to key</param>
|
|
<param name="secondKeySelector">The mapping from second sequence to key</param>
|
|
<returns>A sequence of elements joined from <paramref name="first"/> and <paramref name="second"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.FullGroupJoin``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Collections.Generic.IEqualityComparer{``2})">
|
|
<summary>
|
|
Performs a Full Group Join between the <paramref name="first"/> and <paramref name="second"/> sequences.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses deferred execution and streams the results.
|
|
The results are yielded in the order of the elements found in the first sequence
|
|
followed by those found only in the second. In addition, the callback responsible
|
|
for projecting the results is supplied with sequences which preserve their source order.
|
|
</remarks>
|
|
<typeparam name="TFirst">The type of the elements in the first input sequence</typeparam>
|
|
<typeparam name="TSecond">The type of the elements in the second input sequence</typeparam>
|
|
<typeparam name="TKey">The type of the key to use to join</typeparam>
|
|
<param name="first">First sequence</param>
|
|
<param name="second">Second sequence</param>
|
|
<param name="firstKeySelector">The mapping from first sequence to key</param>
|
|
<param name="secondKeySelector">The mapping from second sequence to key</param>
|
|
<param name="comparer">The equality comparer to use to determine whether or not keys are equal.
|
|
If null, the default equality comparer for <c>TKey</c> is used.</param>
|
|
<returns>A sequence of elements joined from <paramref name="first"/> and <paramref name="second"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.FullGroupJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``2,System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},``3})">
|
|
<summary>
|
|
Performs a full group-join between two sequences.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses deferred execution and streams the results.
|
|
The results are yielded in the order of the elements found in the first sequence
|
|
followed by those found only in the second. In addition, the callback responsible
|
|
for projecting the results is supplied with sequences which preserve their source order.
|
|
</remarks>
|
|
<typeparam name="TFirst">The type of the elements in the first input sequence</typeparam>
|
|
<typeparam name="TSecond">The type of the elements in the second input sequence</typeparam>
|
|
<typeparam name="TKey">The type of the key to use to join</typeparam>
|
|
<typeparam name="TResult">The type of the elements of the resulting sequence</typeparam>
|
|
<param name="first">First sequence</param>
|
|
<param name="second">Second sequence</param>
|
|
<param name="firstKeySelector">The mapping from first sequence to key</param>
|
|
<param name="secondKeySelector">The mapping from second sequence to key</param>
|
|
<param name="resultSelector">Function to apply to each pair of elements plus the key</param>
|
|
<returns>A sequence of elements joined from <paramref name="first"/> and <paramref name="second"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.FullGroupJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``2,System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},``3},System.Collections.Generic.IEqualityComparer{``2})">
|
|
<summary>
|
|
Performs a full group-join between two sequences.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses deferred execution and streams the results.
|
|
The results are yielded in the order of the elements found in the first sequence
|
|
followed by those found only in the second. In addition, the callback responsible
|
|
for projecting the results is supplied with sequences which preserve their source order.
|
|
</remarks>
|
|
<typeparam name="TFirst">The type of the elements in the first input sequence</typeparam>
|
|
<typeparam name="TSecond">The type of the elements in the second input sequence</typeparam>
|
|
<typeparam name="TKey">The type of the key to use to join</typeparam>
|
|
<typeparam name="TResult">The type of the elements of the resulting sequence</typeparam>
|
|
<param name="first">First sequence</param>
|
|
<param name="second">Second sequence</param>
|
|
<param name="firstKeySelector">The mapping from first sequence to key</param>
|
|
<param name="secondKeySelector">The mapping from second sequence to key</param>
|
|
<param name="resultSelector">Function to apply to each pair of elements plus the key</param>
|
|
<param name="comparer">The equality comparer to use to determine whether or not keys are equal.
|
|
If null, the default equality comparer for <c>TKey</c> is used.</param>
|
|
<returns>A sequence of elements joined from <paramref name="first"/> and <paramref name="second"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.FullJoin``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``0,``2},System.Func{``0,``0,``2})">
|
|
<summary>
|
|
Performs a full outer join on two homogeneous sequences.
|
|
Additional arguments specify key selection functions and result
|
|
projection functions.
|
|
</summary>
|
|
<typeparam name="TSource">
|
|
The type of elements in the source sequence.</typeparam>
|
|
<typeparam name="TKey">
|
|
The type of the key returned by the key selector function.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the result elements.</typeparam>
|
|
<param name="first">
|
|
The first sequence to join fully.</param>
|
|
<param name="second">
|
|
The second sequence to join fully.</param>
|
|
<param name="keySelector">
|
|
Function that projects the key given an element of one of the
|
|
sequences to join.</param>
|
|
<param name="firstSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="first"/> where there is no corresponding element
|
|
in <paramref name="second"/>.</param>
|
|
<param name="secondSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="second"/> where there is no corresponding element
|
|
in <paramref name="first"/>.</param>
|
|
<param name="bothSelector">
|
|
Function that projects the result given an element from
|
|
<paramref name="first"/> and an element from <paramref name="second"/>
|
|
that match on a common key.</param>
|
|
<returns>A sequence containing results projected from a full
|
|
outer join of the two input sequences.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.FullJoin``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``0,``2},System.Func{``0,``0,``2},System.Collections.Generic.IEqualityComparer{``1})">
|
|
<summary>
|
|
Performs a full outer join on two homogeneous sequences.
|
|
Additional arguments specify key selection functions, result
|
|
projection functions and a key comparer.
|
|
</summary>
|
|
<typeparam name="TSource">
|
|
The type of elements in the source sequence.</typeparam>
|
|
<typeparam name="TKey">
|
|
The type of the key returned by the key selector function.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the result elements.</typeparam>
|
|
<param name="first">
|
|
The first sequence to join fully.</param>
|
|
<param name="second">
|
|
The second sequence to join fully.</param>
|
|
<param name="keySelector">
|
|
Function that projects the key given an element of one of the
|
|
sequences to join.</param>
|
|
<param name="firstSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="first"/> where there is no corresponding element
|
|
in <paramref name="second"/>.</param>
|
|
<param name="secondSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="second"/> where there is no corresponding element
|
|
in <paramref name="first"/>.</param>
|
|
<param name="bothSelector">
|
|
Function that projects the result given an element from
|
|
<paramref name="first"/> and an element from <paramref name="second"/>
|
|
that match on a common key.</param>
|
|
<param name="comparer">
|
|
The <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> instance used to compare
|
|
keys for equality.</param>
|
|
<returns>A sequence containing results projected from a full
|
|
outer join of the two input sequences.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.FullJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,``3},System.Func{``1,``3},System.Func{``0,``1,``3})">
|
|
<summary>
|
|
Performs a full outer join on two heterogeneous sequences.
|
|
Additional arguments specify key selection functions and result
|
|
projection functions.
|
|
</summary>
|
|
<typeparam name="TFirst">
|
|
The type of elements in the first sequence.</typeparam>
|
|
<typeparam name="TSecond">
|
|
The type of elements in the second sequence.</typeparam>
|
|
<typeparam name="TKey">
|
|
The type of the key returned by the key selector functions.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the result elements.</typeparam>
|
|
<param name="first">
|
|
The first sequence to join fully.</param>
|
|
<param name="second">
|
|
The second sequence to join fully.</param>
|
|
<param name="firstKeySelector">
|
|
Function that projects the key given an element from <paramref name="first"/>.</param>
|
|
<param name="secondKeySelector">
|
|
Function that projects the key given an element from <paramref name="second"/>.</param>
|
|
<param name="firstSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="first"/> where there is no corresponding element
|
|
in <paramref name="second"/>.</param>
|
|
<param name="secondSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="second"/> where there is no corresponding element
|
|
in <paramref name="first"/>.</param>
|
|
<param name="bothSelector">
|
|
Function that projects the result given an element from
|
|
<paramref name="first"/> and an element from <paramref name="second"/>
|
|
that match on a common key.</param>
|
|
<returns>A sequence containing results projected from a full
|
|
outer join of the two input sequences.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.FullJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,``3},System.Func{``1,``3},System.Func{``0,``1,``3},System.Collections.Generic.IEqualityComparer{``2})">
|
|
<summary>
|
|
Performs a full outer join on two heterogeneous sequences.
|
|
Additional arguments specify key selection functions, result
|
|
projection functions and a key comparer.
|
|
</summary>
|
|
<typeparam name="TFirst">
|
|
The type of elements in the first sequence.</typeparam>
|
|
<typeparam name="TSecond">
|
|
The type of elements in the second sequence.</typeparam>
|
|
<typeparam name="TKey">
|
|
The type of the key returned by the key selector functions.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the result elements.</typeparam>
|
|
<param name="first">
|
|
The first sequence to join fully.</param>
|
|
<param name="second">
|
|
The second sequence to join fully.</param>
|
|
<param name="firstKeySelector">
|
|
Function that projects the key given an element from <paramref name="first"/>.</param>
|
|
<param name="secondKeySelector">
|
|
Function that projects the key given an element from <paramref name="second"/>.</param>
|
|
<param name="firstSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="first"/> where there is no corresponding element
|
|
in <paramref name="second"/>.</param>
|
|
<param name="secondSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="second"/> where there is no corresponding element
|
|
in <paramref name="first"/>.</param>
|
|
<param name="bothSelector">
|
|
Function that projects the result given an element from
|
|
<paramref name="first"/> and an element from <paramref name="second"/>
|
|
that match on a common key.</param>
|
|
<param name="comparer">
|
|
The <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> instance used to compare
|
|
keys for equality.</param>
|
|
<returns>A sequence containing results projected from a full
|
|
outer join of the two input sequences.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Generate``1(``0,System.Func{``0,``0})">
|
|
<summary>
|
|
Returns a sequence of values consecutively generated by a generator function.
|
|
</summary>
|
|
<typeparam name="TResult">Type of elements to generate.</typeparam>
|
|
<param name="initial">Value of first element in sequence</param>
|
|
<param name="generator">
|
|
Generator function which takes the previous series element and uses it to generate the next element.
|
|
</param>
|
|
<returns>A sequence containing the generated values.</returns>
|
|
<remarks>
|
|
This function defers element generation until needed and streams the results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
var result = MoreEnumerable.Generate(2, n => n * n).Take(5);
|
|
]]></code>
|
|
The <c>result</c> variable, when iterated over, will yield 2, 4, 16, 256, and 65536, in turn.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.GenerateByIndex``1(System.Func{System.Int32,``0})">
|
|
<summary>
|
|
Returns a sequence of values based on indexes.
|
|
</summary>
|
|
<typeparam name="TResult">
|
|
The type of the value returned by <paramref name="generator"/>
|
|
and therefore the elements of the generated sequence.</typeparam>
|
|
<param name="generator">
|
|
Generation function to apply to each index.</param>
|
|
<returns>A sequence of generated results.</returns>
|
|
<remarks>
|
|
<para>
|
|
The sequence is (practically) infinite where the index ranges from
|
|
zero to <see cref="F:System.Int32.MaxValue"/> inclusive.</para>
|
|
<para>
|
|
This function defers execution and streams the results.</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.GroupAdjacent``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
|
|
<summary>
|
|
Groups the adjacent elements of a sequence according to a
|
|
specified key selector function.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of
|
|
<paramref name="source"/>.</typeparam>
|
|
<typeparam name="TKey">The type of the key returned by
|
|
<paramref name="keySelector"/>.</typeparam>
|
|
<param name="source">A sequence whose elements to group.</param>
|
|
<param name="keySelector">A function to extract the key for each
|
|
element.</param>
|
|
<returns>A sequence of groupings where each grouping
|
|
(<see cref="T:System.Linq.IGrouping`2"/>) contains the key
|
|
and the adjacent elements in the same order as found in the
|
|
source sequence.</returns>
|
|
<remarks>
|
|
This method is implemented by using deferred execution and
|
|
streams the groupings. The grouping elements, however, are
|
|
buffered. Each grouping is therefore yielded as soon as it
|
|
is complete and before the next grouping occurs.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.GroupAdjacent``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
|
|
<summary>
|
|
Groups the adjacent elements of a sequence according to a
|
|
specified key selector function and compares the keys by using a
|
|
specified comparer.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of
|
|
<paramref name="source"/>.</typeparam>
|
|
<typeparam name="TKey">The type of the key returned by
|
|
<paramref name="keySelector"/>.</typeparam>
|
|
<param name="source">A sequence whose elements to group.</param>
|
|
<param name="keySelector">A function to extract the key for each
|
|
element.</param>
|
|
<param name="comparer">An <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> to
|
|
compare keys.</param>
|
|
<returns>A sequence of groupings where each grouping
|
|
(<see cref="T:System.Linq.IGrouping`2"/>) contains the key
|
|
and the adjacent elements in the same order as found in the
|
|
source sequence.</returns>
|
|
<remarks>
|
|
This method is implemented by using deferred execution and
|
|
streams the groupings. The grouping elements, however, are
|
|
buffered. Each grouping is therefore yielded as soon as it
|
|
is complete and before the next grouping occurs.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.GroupAdjacent``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of
|
|
<paramref name="source"/>.</typeparam>
|
|
<typeparam name="TKey">The type of the key returned by
|
|
<paramref name="keySelector"/>.</typeparam>
|
|
<typeparam name="TElement">The type of the elements in the
|
|
resulting groupings.</typeparam>
|
|
<param name="source">A sequence whose elements to group.</param>
|
|
<param name="keySelector">A function to extract the key for each
|
|
element.</param>
|
|
<param name="elementSelector">A function to map each source
|
|
element to an element in the resulting grouping.</param>
|
|
<returns>A sequence of groupings where each grouping
|
|
(<see cref="T:System.Linq.IGrouping`2"/>) contains the key
|
|
and the adjacent elements (of type <typeparamref name="TElement"/>)
|
|
in the same order as found in the source sequence.</returns>
|
|
<remarks>
|
|
This method is implemented by using deferred execution and
|
|
streams the groupings. The grouping elements, however, are
|
|
buffered. Each grouping is therefore yielded as soon as it
|
|
is complete and before the next grouping occurs.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.GroupAdjacent``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IEqualityComparer{``1})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of
|
|
<paramref name="source"/>.</typeparam>
|
|
<typeparam name="TKey">The type of the key returned by
|
|
<paramref name="keySelector"/>.</typeparam>
|
|
<typeparam name="TElement">The type of the elements in the
|
|
resulting groupings.</typeparam>
|
|
<param name="source">A sequence whose elements to group.</param>
|
|
<param name="keySelector">A function to extract the key for each
|
|
element.</param>
|
|
<param name="elementSelector">A function to map each source
|
|
element to an element in the resulting grouping.</param>
|
|
<param name="comparer">An <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> to
|
|
compare keys.</param>
|
|
<returns>A sequence of groupings where each grouping
|
|
(<see cref="T:System.Linq.IGrouping`2"/>) contains the key
|
|
and the adjacent elements (of type <typeparamref name="TElement"/>)
|
|
in the same order as found in the source sequence.</returns>
|
|
<remarks>
|
|
This method is implemented by using deferred execution and
|
|
streams the groupings. The grouping elements, however, are
|
|
buffered. Each grouping is therefore yielded as soon as it
|
|
is complete and before the next grouping occurs.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.GroupAdjacent``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,System.Collections.Generic.IEnumerable{``0},``2})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of
|
|
<paramref name="source"/>.</typeparam>
|
|
<typeparam name="TKey">The type of the key returned by
|
|
<paramref name="keySelector"/>.</typeparam>
|
|
<typeparam name="TResult">The type of the elements in the
|
|
resulting sequence.</typeparam>
|
|
<param name="source">A sequence whose elements to group.</param>
|
|
<param name="keySelector">A function to extract the key for each
|
|
element.</param>
|
|
<param name="resultSelector">A function to map each key and
|
|
associated source elements to a result object.</param>
|
|
<returns>A collection of elements of type
|
|
<typeparamref name="TResult" /> where each element represents
|
|
a projection over a group and its key.</returns>
|
|
<remarks>
|
|
This method is implemented by using deferred execution and
|
|
streams the groupings. The grouping elements, however, are
|
|
buffered. Each grouping is therefore yielded as soon as it
|
|
is complete and before the next grouping occurs.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.GroupAdjacent``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,System.Collections.Generic.IEnumerable{``0},``2},System.Collections.Generic.IEqualityComparer{``1})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of
|
|
<paramref name="source"/>.</typeparam>
|
|
<typeparam name="TKey">The type of the key returned by
|
|
<paramref name="keySelector"/>.</typeparam>
|
|
<typeparam name="TResult">The type of the elements in the
|
|
resulting sequence.</typeparam>
|
|
<param name="source">A sequence whose elements to group.</param>
|
|
<param name="keySelector">A function to extract the key for each
|
|
element.</param>
|
|
<param name="resultSelector">A function to map each key and
|
|
associated source elements to a result object.</param>
|
|
<param name="comparer">An <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> to
|
|
compare keys.</param>
|
|
<returns>A collection of elements of type
|
|
<typeparamref name="TResult" /> where each element represents
|
|
a projection over a group and its key.</returns>
|
|
<remarks>
|
|
This method is implemented by using deferred execution and
|
|
streams the groupings. The grouping elements, however, are
|
|
buffered. Each grouping is therefore yielded as soon as it
|
|
is complete and before the next grouping occurs.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Index``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Returns a sequence of <see cref="T:System.Collections.Generic.KeyValuePair`2"/>
|
|
where the key is the zero-based index of the value in the source
|
|
sequence.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<returns>A sequence of <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.</returns>
|
|
<remarks>This operator uses deferred execution and streams its
|
|
results.</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Index``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Returns a sequence of <see cref="T:System.Collections.Generic.KeyValuePair`2"/>
|
|
where the key is the index of the value in the source sequence.
|
|
An additional parameter specifies the starting index.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="startIndex"></param>
|
|
<returns>A sequence of <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.</returns>
|
|
<remarks>This operator uses deferred execution and streams its
|
|
results.</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.IndexBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
|
|
<summary>
|
|
Applies a key-generating function to each element of a sequence and
|
|
returns a sequence that contains the elements of the original
|
|
sequence as well its key and index inside the group of its key.
|
|
</summary>
|
|
<typeparam name="TSource">Type of the source sequence elements.</typeparam>
|
|
<typeparam name="TKey">Type of the projected key.</typeparam>
|
|
<param name="source">Source sequence.</param>
|
|
<param name="keySelector">
|
|
Function that projects the key given an element in the source sequence.</param>
|
|
<returns>
|
|
A sequence of elements paired with their index within the key-group.
|
|
The index is the key and the element is the value of the pair.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.IndexBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
|
|
<summary>
|
|
Applies a key-generating function to each element of a sequence and
|
|
returns a sequence that contains the elements of the original
|
|
sequence as well its key and index inside the group of its key.
|
|
An additional parameter specifies a comparer to use for testing the
|
|
equivalence of keys.
|
|
</summary>
|
|
<typeparam name="TSource">Type of the source sequence elements.</typeparam>
|
|
<typeparam name="TKey">Type of the projected key.</typeparam>
|
|
<param name="source">Source sequence.</param>
|
|
<param name="keySelector">
|
|
Function that projects the key given an element in the source sequence.</param>
|
|
<param name="comparer">
|
|
The equality comparer to use to determine whether or not keys are
|
|
equal. If <c>null</c>, the default equality comparer for
|
|
<typeparamref name="TSource"/> is used.</param>
|
|
<returns>
|
|
A sequence of elements paired with their index within the key-group.
|
|
The index is the key and the element is the value of the pair.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Insert``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Inserts the elements of a sequence into another sequence at a
|
|
specified index.
|
|
</summary>
|
|
<typeparam name="T">Type of the elements of the source sequence.</typeparam>
|
|
<param name="first">The source sequence.</param>
|
|
<param name="second">The sequence that will be inserted.</param>
|
|
<param name="index">
|
|
The zero-based index at which to insert elements from
|
|
<paramref name="second"/>.</param>
|
|
<returns>
|
|
A sequence that contains the elements of <paramref name="first"/>
|
|
plus the elements of <paramref name="second"/> inserted at
|
|
the given index.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="first"/> is null.</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="second"/> is null.</exception>
|
|
<exception cref="T:System.ArgumentOutOfRangeException">
|
|
Thrown if <paramref name="index"/> is negative.
|
|
</exception>
|
|
<exception cref="T:System.ArgumentOutOfRangeException">
|
|
Thrown lazily if <paramref name="index"/> is greater than the
|
|
length of <paramref name="first"/>. The validation occurs when
|
|
yielding the next element after having iterated
|
|
<paramref name="first"/> entirely.
|
|
</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Interleave``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0}[])">
|
|
<summary>
|
|
Interleaves the elements of two or more sequences into a single sequence, skipping sequences as they are consumed
|
|
</summary>
|
|
<remarks>
|
|
Interleave combines sequences by visiting each in turn, and returning the first element of each, followed
|
|
by the second, then the third, and so on. So, for example:<br/>
|
|
<code><![CDATA[
|
|
{1,1,1}.Interleave( {2,2,2}, {3,3,3} ) => { 1,2,3,1,2,3,1,2,3 }
|
|
]]></code>
|
|
This operator behaves in a deferred and streaming manner.<br/>
|
|
When sequences are of unequal length, this method will skip those sequences that have been fully consumed
|
|
and continue interleaving the remaining sequences.<br/>
|
|
The sequences are interleaved in the order that they appear in the <paramref name="otherSequences"/>
|
|
collection, with <paramref name="sequence"/> as the first sequence.
|
|
</remarks>
|
|
<typeparam name="T">The type of the elements of the source sequences</typeparam>
|
|
<param name="sequence">The first sequence in the interleave group</param>
|
|
<param name="otherSequences">The other sequences in the interleave group</param>
|
|
<returns>A sequence of interleaved elements from all of the source sequences</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Lag``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,``0,``1})">
|
|
<summary>
|
|
Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset.
|
|
</summary>
|
|
<remarks>
|
|
This operator evaluates in a deferred and streaming manner.<br/>
|
|
For elements prior to the lag offset, <c>default(T)</c> is used as the lagged value.<br/>
|
|
</remarks>
|
|
<typeparam name="TSource">The type of the elements of the source sequence</typeparam>
|
|
<typeparam name="TResult">The type of the elements of the result sequence</typeparam>
|
|
<param name="source">The sequence over which to evaluate lag</param>
|
|
<param name="offset">The offset (expressed as a positive number) by which to lag each value of the sequence</param>
|
|
<param name="resultSelector">A projection function which accepts the current and lagged items (in that order) and returns a result</param>
|
|
<returns>A sequence produced by projecting each element of the sequence with its lagged pairing</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Lag``2(System.Collections.Generic.IEnumerable{``0},System.Int32,``0,System.Func{``0,``0,``1})">
|
|
<summary>
|
|
Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset.
|
|
</summary>
|
|
<remarks>
|
|
This operator evaluates in a deferred and streaming manner.<br/>
|
|
</remarks>
|
|
<typeparam name="TSource">The type of the elements of the source sequence</typeparam>
|
|
<typeparam name="TResult">The type of the elements of the result sequence</typeparam>
|
|
<param name="source">The sequence over which to evaluate lag</param>
|
|
<param name="offset">The offset (expressed as a positive number) by which to lag each value of the sequence</param>
|
|
<param name="defaultLagValue">A default value supplied for the lagged value prior to the lag offset</param>
|
|
<param name="resultSelector">A projection function which accepts the current and lagged items (in that order) and returns a result</param>
|
|
<returns>A sequence produced by projecting each element of the sequence with its lagged pairing</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Lead``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,``0,``1})">
|
|
<summary>
|
|
Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset.
|
|
</summary>
|
|
<remarks>
|
|
This operator evaluates in a deferred and streaming manner.<br/>
|
|
For elements of the sequence that are less than <paramref name="offset"/> items from the end,
|
|
default(T) is used as the lead value.<br/>
|
|
</remarks>
|
|
<typeparam name="TSource">The type of the elements in the source sequence</typeparam>
|
|
<typeparam name="TResult">The type of the elements in the result sequence</typeparam>
|
|
<param name="source">The sequence over which to evaluate Lead</param>
|
|
<param name="offset">The offset (expressed as a positive number) by which to lead each element of the sequence</param>
|
|
<param name="resultSelector">A projection function which accepts the current and subsequent (lead) element (in that order) and produces a result</param>
|
|
<returns>A sequence produced by projecting each element of the sequence with its lead pairing</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Lead``2(System.Collections.Generic.IEnumerable{``0},System.Int32,``0,System.Func{``0,``0,``1})">
|
|
<summary>
|
|
Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset.
|
|
</summary>
|
|
<remarks>
|
|
This operator evaluates in a deferred and streaming manner.<br/>
|
|
</remarks>
|
|
<typeparam name="TSource">The type of the elements in the source sequence</typeparam>
|
|
<typeparam name="TResult">The type of the elements in the result sequence</typeparam>
|
|
<param name="source">The sequence over which to evaluate Lead</param>
|
|
<param name="offset">The offset (expressed as a positive number) by which to lead each element of the sequence</param>
|
|
<param name="defaultLeadValue">A default value supplied for the leading element when none is available</param>
|
|
<param name="resultSelector">A projection function which accepts the current and subsequent (lead) element (in that order) and produces a result</param>
|
|
<returns>A sequence produced by projecting each element of the sequence with its lead pairing</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.LeftJoin``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``0,``0,``2})">
|
|
<summary>
|
|
Performs a left outer join on two homogeneous sequences.
|
|
Additional arguments specify key selection functions and result
|
|
projection functions.
|
|
</summary>
|
|
<typeparam name="TSource">
|
|
The type of elements in the source sequence.</typeparam>
|
|
<typeparam name="TKey">
|
|
The type of the key returned by the key selector function.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the result elements.</typeparam>
|
|
<param name="first">
|
|
The first sequence of the join operation.</param>
|
|
<param name="second">
|
|
The second sequence of the join operation.</param>
|
|
<param name="keySelector">
|
|
Function that projects the key given an element of one of the
|
|
sequences to join.</param>
|
|
<param name="firstSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="first"/> where there is no corresponding element
|
|
in <paramref name="second"/>.</param>
|
|
<param name="bothSelector">
|
|
Function that projects the result given an element from
|
|
<paramref name="first"/> and an element from <paramref name="second"/>
|
|
that match on a common key.</param>
|
|
<returns>A sequence containing results projected from a left
|
|
outer join of the two input sequences.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.LeftJoin``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``0,``0,``2},System.Collections.Generic.IEqualityComparer{``1})">
|
|
<summary>
|
|
Performs a left outer join on two homogeneous sequences.
|
|
Additional arguments specify key selection functions, result
|
|
projection functions and a key comparer.
|
|
</summary>
|
|
<typeparam name="TSource">
|
|
The type of elements in the source sequence.</typeparam>
|
|
<typeparam name="TKey">
|
|
The type of the key returned by the key selector function.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the result elements.</typeparam>
|
|
<param name="first">
|
|
The first sequence of the join operation.</param>
|
|
<param name="second">
|
|
The second sequence of the join operation.</param>
|
|
<param name="keySelector">
|
|
Function that projects the key given an element of one of the
|
|
sequences to join.</param>
|
|
<param name="firstSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="first"/> where there is no corresponding element
|
|
in <paramref name="second"/>.</param>
|
|
<param name="bothSelector">
|
|
Function that projects the result given an element from
|
|
<paramref name="first"/> and an element from <paramref name="second"/>
|
|
that match on a common key.</param>
|
|
<param name="comparer">
|
|
The <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> instance used to compare
|
|
keys for equality.</param>
|
|
<returns>A sequence containing results projected from a left
|
|
outer join of the two input sequences.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.LeftJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,``3},System.Func{``0,``1,``3})">
|
|
<summary>
|
|
Performs a left outer join on two heterogeneous sequences.
|
|
Additional arguments specify key selection functions and result
|
|
projection functions.
|
|
</summary>
|
|
<typeparam name="TFirst">
|
|
The type of elements in the first sequence.</typeparam>
|
|
<typeparam name="TSecond">
|
|
The type of elements in the second sequence.</typeparam>
|
|
<typeparam name="TKey">
|
|
The type of the key returned by the key selector functions.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the result elements.</typeparam>
|
|
<param name="first">
|
|
The first sequence of the join operation.</param>
|
|
<param name="second">
|
|
The second sequence of the join operation.</param>
|
|
<param name="firstKeySelector">
|
|
Function that projects the key given an element from <paramref name="first"/>.</param>
|
|
<param name="secondKeySelector">
|
|
Function that projects the key given an element from <paramref name="second"/>.</param>
|
|
<param name="firstSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="first"/> where there is no corresponding element
|
|
in <paramref name="second"/>.</param>
|
|
<param name="bothSelector">
|
|
Function that projects the result given an element from
|
|
<paramref name="first"/> and an element from <paramref name="second"/>
|
|
that match on a common key.</param>
|
|
<returns>A sequence containing results projected from a left
|
|
outer join of the two input sequences.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.LeftJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,``3},System.Func{``0,``1,``3},System.Collections.Generic.IEqualityComparer{``2})">
|
|
<summary>
|
|
Performs a left outer join on two heterogeneous sequences.
|
|
Additional arguments specify key selection functions, result
|
|
projection functions and a key comparer.
|
|
</summary>
|
|
<typeparam name="TFirst">
|
|
The type of elements in the first sequence.</typeparam>
|
|
<typeparam name="TSecond">
|
|
The type of elements in the second sequence.</typeparam>
|
|
<typeparam name="TKey">
|
|
The type of the key returned by the key selector functions.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the result elements.</typeparam>
|
|
<param name="first">
|
|
The first sequence of the join operation.</param>
|
|
<param name="second">
|
|
The second sequence of the join operation.</param>
|
|
<param name="firstKeySelector">
|
|
Function that projects the key given an element from <paramref name="first"/>.</param>
|
|
<param name="secondKeySelector">
|
|
Function that projects the key given an element from <paramref name="second"/>.</param>
|
|
<param name="firstSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="first"/> where there is no corresponding element
|
|
in <paramref name="second"/>.</param>
|
|
<param name="bothSelector">
|
|
Function that projects the result given an element from
|
|
<paramref name="first"/> and an element from <paramref name="second"/>
|
|
that match on a common key.</param>
|
|
<param name="comparer">
|
|
The <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> instance used to compare
|
|
keys for equality.</param>
|
|
<returns>A sequence containing results projected from a left
|
|
outer join of the two input sequences.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.First``1(MoreLinq.IExtremaEnumerable{``0})">
|
|
<summary>
|
|
Returns the first element of a sequence.
|
|
</summary>
|
|
<typeparam name="T">
|
|
The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The input sequence.</param>
|
|
<exception cref="T:System.InvalidOperationException">
|
|
The input sequence is empty.</exception>
|
|
<returns>
|
|
The first element of the input sequence.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.FirstOrDefault``1(MoreLinq.IExtremaEnumerable{``0})">
|
|
<summary>
|
|
Returns the first element of a sequence, or a default value if the
|
|
sequence contains no elements.
|
|
</summary>
|
|
<typeparam name="T">
|
|
The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The input sequence.</param>
|
|
<returns>
|
|
Default value of type <typeparamref name="T"/> if source is empty;
|
|
otherwise, the first element in source.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Last``1(MoreLinq.IExtremaEnumerable{``0})">
|
|
<summary>
|
|
Returns the last element of a sequence.
|
|
</summary>
|
|
<typeparam name="T">
|
|
The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The input sequence.</param>
|
|
<exception cref="T:System.InvalidOperationException">
|
|
The input sequence is empty.</exception>
|
|
<returns>
|
|
The last element of the input sequence.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.LastOrDefault``1(MoreLinq.IExtremaEnumerable{``0})">
|
|
<summary>
|
|
Returns the last element of a sequence, or a default value if the
|
|
sequence contains no elements.
|
|
</summary>
|
|
<typeparam name="T">
|
|
The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The input sequence.</param>
|
|
<returns>
|
|
Default value of type <typeparamref name="T"/> if source is empty;
|
|
otherwise, the last element in source.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Single``1(MoreLinq.IExtremaEnumerable{``0})">
|
|
<summary>
|
|
Returns the only element of a sequence, and throws an exception if
|
|
there is not exactly one element in the sequence.
|
|
</summary>
|
|
<typeparam name="T">
|
|
The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The input sequence.</param>
|
|
<exception cref="T:System.InvalidOperationException">
|
|
The input sequence contains more than one element.</exception>
|
|
<returns>
|
|
The single element of the input sequence.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.SingleOrDefault``1(MoreLinq.IExtremaEnumerable{``0})">
|
|
<summary>
|
|
Returns the only element of a sequence, or a default value if the
|
|
sequence is empty; this method throws an exception if there is more
|
|
than one element in the sequence.
|
|
</summary>
|
|
<typeparam name="T">
|
|
The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The input sequence.</param>
|
|
<returns>
|
|
The single element of the input sequence, or default value of type
|
|
<typeparamref name="T"/> if the sequence contains no elements.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.MaxBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
|
|
<summary>
|
|
Returns the maximal elements of the given sequence, based on
|
|
the given projection.
|
|
</summary>
|
|
<remarks>
|
|
This overload uses the default comparer for the projected type.
|
|
This operator uses deferred execution. The results are evaluated
|
|
and cached on first use to returned sequence.
|
|
</remarks>
|
|
<typeparam name="TSource">Type of the source sequence</typeparam>
|
|
<typeparam name="TKey">Type of the projected element</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<param name="selector">Selector to use to pick the results to compare</param>
|
|
<returns>The maximal element, according to the projection.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.MaxBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})">
|
|
<summary>
|
|
Returns the maximal elements of the given sequence, based on
|
|
the given projection and the specified comparer for projected values.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses deferred execution. The results are evaluated
|
|
and cached on first use to returned sequence.
|
|
</remarks>
|
|
<typeparam name="TSource">Type of the source sequence</typeparam>
|
|
<typeparam name="TKey">Type of the projected element</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<param name="selector">Selector to use to pick the results to compare</param>
|
|
<param name="comparer">Comparer to use to compare projected values</param>
|
|
<returns>The maximal element, according to the projection.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/>, <paramref name="selector"/>
|
|
or <paramref name="comparer"/> is null</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.MinBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
|
|
<summary>
|
|
Returns the minimal elements of the given sequence, based on
|
|
the given projection.
|
|
</summary>
|
|
<remarks>
|
|
This overload uses the default comparer for the projected type.
|
|
This operator uses deferred execution. The results are evaluated
|
|
and cached on first use to returned sequence.
|
|
</remarks>
|
|
<typeparam name="TSource">Type of the source sequence</typeparam>
|
|
<typeparam name="TKey">Type of the projected element</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<param name="selector">Selector to use to pick the results to compare</param>
|
|
<returns>The minimal element, according to the projection.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.MinBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})">
|
|
<summary>
|
|
Returns the minimal elements of the given sequence, based on
|
|
the given projection and the specified comparer for projected values.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses deferred execution. The results are evaluated
|
|
and cached on first use to returned sequence.
|
|
</remarks>
|
|
<typeparam name="TSource">Type of the source sequence</typeparam>
|
|
<typeparam name="TKey">Type of the projected element</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<param name="selector">Selector to use to pick the results to compare</param>
|
|
<param name="comparer">Comparer to use to compare projected values</param>
|
|
<returns>The minimal element, according to the projection.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/>, <paramref name="selector"/>
|
|
or <paramref name="comparer"/> is null</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Move``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Int32,System.Int32)">
|
|
<summary>
|
|
Returns a sequence with a range of elements in the source sequence
|
|
moved to a new offset.
|
|
</summary>
|
|
<typeparam name="T">Type of the source sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="fromIndex">
|
|
The zero-based index identifying the first element in the range of
|
|
elements to move.</param>
|
|
<param name="count">The count of items to move.</param>
|
|
<param name="toIndex">
|
|
The index where the specified range will be moved.</param>
|
|
<returns>
|
|
A sequence with the specified range moved to the new position.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
var result = Enumerable.Range(0, 6).Move(3, 2, 0);
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>{ 3, 4, 0, 1, 2, 5 }</c>.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.NestedLoops(System.Action,System.Collections.Generic.IEnumerable{System.Int32})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<param name="action">Action delegate for which to produce a nested loop sequence</param>
|
|
<param name="loopCounts">A sequence of loop repetition counts</param>
|
|
<returns>A sequence of Action representing the expansion of a set of nested loops</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},MoreLinq.OrderByDirection)">
|
|
<summary>
|
|
Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the source sequence</typeparam>
|
|
<typeparam name="TKey">The type of the key used to order elements</typeparam>
|
|
<param name="source">The sequence to order</param>
|
|
<param name="keySelector">A key selector function</param>
|
|
<param name="direction">A direction in which to order the elements (ascending, descending)</param>
|
|
<returns>An ordered copy of the source sequence</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1},MoreLinq.OrderByDirection)">
|
|
<summary>
|
|
Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the source sequence</typeparam>
|
|
<typeparam name="TKey">The type of the key used to order elements</typeparam>
|
|
<param name="source">The sequence to order</param>
|
|
<param name="keySelector">A key selector function</param>
|
|
<param name="direction">A direction in which to order the elements (ascending, descending)</param>
|
|
<param name="comparer">A comparer used to define the semantics of element comparison</param>
|
|
<returns>An ordered copy of the source sequence</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ThenBy``2(System.Linq.IOrderedEnumerable{``0},System.Func{``0,``1},MoreLinq.OrderByDirection)">
|
|
<summary>
|
|
Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the source sequence</typeparam>
|
|
<typeparam name="TKey">The type of the key used to order elements</typeparam>
|
|
<param name="source">The sequence to order</param>
|
|
<param name="keySelector">A key selector function</param>
|
|
<param name="direction">A direction in which to order the elements (ascending, descending)</param>
|
|
<returns>An ordered copy of the source sequence</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ThenBy``2(System.Linq.IOrderedEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1},MoreLinq.OrderByDirection)">
|
|
<summary>
|
|
Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the source sequence</typeparam>
|
|
<typeparam name="TKey">The type of the key used to order elements</typeparam>
|
|
<param name="source">The sequence to order</param>
|
|
<param name="keySelector">A key selector function</param>
|
|
<param name="direction">A direction in which to order the elements (ascending, descending)</param>
|
|
<param name="comparer">A comparer used to define the semantics of element comparison</param>
|
|
<returns>An ordered copy of the source sequence</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.OrderedMerge``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="T">Type of elements in input and output sequences.</typeparam>
|
|
<param name="first">The first input sequence.</param>
|
|
<param name="second">The second input sequence.</param>
|
|
<returns>
|
|
A sequence with elements from the two input sequences merged, as
|
|
in a full outer join.</returns>
|
|
<remarks>
|
|
This method uses deferred execution. The behavior is undefined
|
|
if the sequences are unordered as inputs.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.OrderedMerge``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="T">Type of elements in input and output sequences.</typeparam>
|
|
<param name="first">The first input sequence.</param>
|
|
<param name="second">The second input sequence.</param>
|
|
<param name="comparer">An <see cref="T:System.Collections.Generic.IComparer`1"/> to compare elements.</param>
|
|
<returns>
|
|
A sequence with elements from the two input sequences merged, as
|
|
in a full outer join.</returns>
|
|
<remarks>
|
|
This method uses deferred execution. The behavior is undefined
|
|
if the sequences are unordered as inputs.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.OrderedMerge``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="T">Type of elements in input and output sequences.</typeparam>
|
|
<typeparam name="TKey">Type of keys used for merging.</typeparam>
|
|
<param name="first">The first input sequence.</param>
|
|
<param name="second">The second input sequence.</param>
|
|
<param name="keySelector">Function to extract a key given an element.</param>
|
|
<returns>
|
|
A sequence with elements from the two input sequences merged
|
|
according to a key, as in a full outer join.</returns>
|
|
<remarks>
|
|
This method uses deferred execution. The behavior is undefined
|
|
if the sequences are unordered (by key) as inputs.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.OrderedMerge``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``0,``2},System.Func{``0,``0,``2})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="T">Type of elements in source sequences.</typeparam>
|
|
<typeparam name="TKey">Type of keys used for merging.</typeparam>
|
|
<typeparam name="TResult">Type of elements in the returned sequence.</typeparam>
|
|
<param name="first">The first input sequence.</param>
|
|
<param name="second">The second input sequence.</param>
|
|
<param name="keySelector">Function to extract a key given an element.</param>
|
|
<param name="firstSelector">Function to project the result element
|
|
when only the first sequence yields a source element.</param>
|
|
<param name="secondSelector">Function to project the result element
|
|
when only the second sequence yields a source element.</param>
|
|
<param name="bothSelector">Function to project the result element
|
|
when only both sequences yield a source element whose keys are
|
|
equal.</param>
|
|
<returns>
|
|
A sequence with projections from the two input sequences merged
|
|
according to a key, as in a full outer join.</returns>
|
|
<remarks>
|
|
This method uses deferred execution. The behavior is undefined
|
|
if the sequences are unordered (by key) as inputs.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.OrderedMerge``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``0,``2},System.Func{``0,``0,``2},System.Collections.Generic.IComparer{``1})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="T">Type of elements in source sequences.</typeparam>
|
|
<typeparam name="TKey">Type of keys used for merging.</typeparam>
|
|
<typeparam name="TResult">Type of elements in the returned sequence.</typeparam>
|
|
<param name="first">The first input sequence.</param>
|
|
<param name="second">The second input sequence.</param>
|
|
<param name="keySelector">Function to extract a key given an element.</param>
|
|
<param name="firstSelector">Function to project the result element
|
|
when only the first sequence yields a source element.</param>
|
|
<param name="secondSelector">Function to project the result element
|
|
when only the second sequence yields a source element.</param>
|
|
<param name="bothSelector">Function to project the result element
|
|
when only both sequences yield a source element whose keys are
|
|
equal.</param>
|
|
<param name="comparer">An <see cref="T:System.Collections.Generic.IComparer`1"/> to compare keys.</param>
|
|
<returns>
|
|
A sequence with projections from the two input sequences merged
|
|
according to a key, as in a full outer join.</returns>
|
|
<remarks>
|
|
This method uses deferred execution. The behavior is undefined
|
|
if the sequences are unordered (by key) as inputs.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.OrderedMerge``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,``3},System.Func{``1,``3},System.Func{``0,``1,``3})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TFirst">Type of elements in the first sequence.</typeparam>
|
|
<typeparam name="TSecond">Type of elements in the second sequence.</typeparam>
|
|
<typeparam name="TKey">Type of keys used for merging.</typeparam>
|
|
<typeparam name="TResult">Type of elements in the returned sequence.</typeparam>
|
|
<param name="first">The first input sequence.</param>
|
|
<param name="second">The second input sequence.</param>
|
|
<param name="firstKeySelector">Function to extract a key given an
|
|
element from the first sequence.</param>
|
|
<param name="secondKeySelector">Function to extract a key given an
|
|
element from the second sequence.</param>
|
|
<param name="firstSelector">Function to project the result element
|
|
when only the first sequence yields a source element.</param>
|
|
<param name="secondSelector">Function to project the result element
|
|
when only the second sequence yields a source element.</param>
|
|
<param name="bothSelector">Function to project the result element
|
|
when only both sequences yield a source element whose keys are
|
|
equal.</param>
|
|
<returns>
|
|
A sequence with projections from the two input sequences merged
|
|
according to a key, as in a full outer join.</returns>
|
|
<remarks>
|
|
This method uses deferred execution. The behavior is undefined
|
|
if the sequences are unordered (by key) as inputs.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.OrderedMerge``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,``3},System.Func{``1,``3},System.Func{``0,``1,``3},System.Collections.Generic.IComparer{``2})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TFirst">Type of elements in the first sequence.</typeparam>
|
|
<typeparam name="TSecond">Type of elements in the second sequence.</typeparam>
|
|
<typeparam name="TKey">Type of keys used for merging.</typeparam>
|
|
<typeparam name="TResult">Type of elements in the returned sequence.</typeparam>
|
|
<param name="first">The first input sequence.</param>
|
|
<param name="second">The second input sequence.</param>
|
|
<param name="firstKeySelector">Function to extract a key given an
|
|
element from the first sequence.</param>
|
|
<param name="secondKeySelector">Function to extract a key given an
|
|
element from the second sequence.</param>
|
|
<param name="firstSelector">Function to project the result element
|
|
when only the first sequence yields a source element.</param>
|
|
<param name="secondSelector">Function to project the result element
|
|
when only the second sequence yields a source element.</param>
|
|
<param name="bothSelector">Function to project the result element
|
|
when only both sequences yield a source element whose keys are
|
|
equal.</param>
|
|
<param name="comparer">An <see cref="T:System.Collections.Generic.IComparer`1"/> to compare keys.</param>
|
|
<returns>
|
|
A sequence with projections from the two input sequences merged
|
|
according to a key, as in a full outer join.</returns>
|
|
<remarks>
|
|
This method uses deferred execution. The behavior is undefined
|
|
if the sequences are unordered (by key) as inputs.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Pad``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Pads a sequence with default values if it is narrower (shorter
|
|
in length) than a given width.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The sequence to pad.</param>
|
|
<param name="width">The width/length below which to pad.</param>
|
|
<returns>
|
|
Returns a sequence that is at least as wide/long as the width/length
|
|
specified by the <paramref name="width"/> parameter.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
int[] numbers = { 123, 456, 789 };
|
|
var result = numbers.Pad(5);
|
|
]]></code>
|
|
The <c>result</c> variable, when iterated over, will yield
|
|
123, 456, 789 and two zeroes, in turn.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Pad``1(System.Collections.Generic.IEnumerable{``0},System.Int32,``0)">
|
|
<summary>
|
|
Pads a sequence with a given filler value if it is narrower (shorter
|
|
in length) than a given width.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The sequence to pad.</param>
|
|
<param name="width">The width/length below which to pad.</param>
|
|
<param name="padding">The value to use for padding.</param>
|
|
<returns>
|
|
Returns a sequence that is at least as wide/long as the width/length
|
|
specified by the <paramref name="width"/> parameter.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
int[] numbers = { 123, 456, 789 };
|
|
var result = numbers.Pad(5, -1);
|
|
]]></code>
|
|
The <c>result</c> variable, when iterated over, will yield
|
|
123, 456, and 789 followed by two occurrences of -1, in turn.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Pad``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Int32,``0})">
|
|
<summary>
|
|
Pads a sequence with a dynamic filler value if it is narrower (shorter
|
|
in length) than a given width.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The sequence to pad.</param>
|
|
<param name="width">The width/length below which to pad.</param>
|
|
<param name="paddingSelector">Function to calculate padding.</param>
|
|
<returns>
|
|
Returns a sequence that is at least as wide/long as the width/length
|
|
specified by the <paramref name="width"/> parameter.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
int[] numbers = { 0, 1, 2 };
|
|
var result = numbers.Pad(5, i => -i);
|
|
]]></code>
|
|
The <c>result</c> variable, when iterated over, will yield
|
|
0, 1, 2, -3 and -4, in turn.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.PadStart``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Pads a sequence with default values in the beginning if it is narrower (shorter
|
|
in length) than a given width.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The sequence to pad.</param>
|
|
<param name="width">The width/length below which to pad.</param>
|
|
<returns>
|
|
Returns a sequence that is at least as wide/long as the width/length
|
|
specified by the <paramref name="width"/> parameter.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
int[] numbers = { 123, 456, 789 };
|
|
var result = numbers.PadStart(5);
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>{ 0, 0, 123, 456, 789 }</c>.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.PadStart``1(System.Collections.Generic.IEnumerable{``0},System.Int32,``0)">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The sequence to pad.</param>
|
|
<param name="width">The width/length below which to pad.</param>
|
|
<param name="padding">The value to use for padding.</param>
|
|
<returns>
|
|
Returns a sequence that is at least as wide/long as the width/length
|
|
specified by the <paramref name="width"/> parameter.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
int[] numbers = { 123, 456, 789 };
|
|
var result = numbers.PadStart(5, -1);
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>{ -1, -1, 123, 456, 789 }</c>.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.PadStart``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Int32,``0})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The sequence to pad.</param>
|
|
<param name="width">The width/length below which to pad.</param>
|
|
<param name="paddingSelector">
|
|
Function to calculate padding given the index of the missing element.
|
|
</param>
|
|
<returns>
|
|
Returns a sequence that is at least as wide/long as the width/length
|
|
specified by the <paramref name="width"/> parameter.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
int[] numbers = { 123, 456, 789 };
|
|
var result = numbers.PadStart(6, i => -i);
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>{ 0, -1, -2, 123, 456, 789 }</c>.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Pairwise``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``1})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TResult">The type of the element of the returned sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="resultSelector">A transform function to apply to
|
|
each pair of sequence.</param>
|
|
<returns>
|
|
Returns the resulting sequence.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
var source = new[] { "a", "b", "c", "d" };
|
|
var result = source.Pairwise((a, b) => a + b);
|
|
]]></code>
|
|
The <c>result</c> variable, when iterated over, will yield
|
|
"ab", "bc" and "cd", in turn.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.PartialSort``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Combines <see cref="M:System.Linq.Enumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})"/>,
|
|
where each element is its key, and <see cref="M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32)"/>
|
|
in a single operation.
|
|
</summary>
|
|
<typeparam name="T">Type of elements in the sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="count">Number of (maximum) elements to return.</param>
|
|
<returns>A sequence containing at most top <paramref name="count"/>
|
|
elements from source, in their ascending order.</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams it results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.PartialSort``1(System.Collections.Generic.IEnumerable{``0},System.Int32,MoreLinq.OrderByDirection)">
|
|
<summary>
|
|
Combines <see cref="M:MoreLinq.MoreEnumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1},MoreLinq.OrderByDirection)"/>,
|
|
where each element is its key, and <see cref="M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32)"/>
|
|
in a single operation.
|
|
An additional parameter specifies the direction of the sort
|
|
</summary>
|
|
<typeparam name="T">Type of elements in the sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="count">Number of (maximum) elements to return.</param>
|
|
<param name="direction">The direction in which to sort the elements</param>
|
|
<returns>A sequence containing at most top <paramref name="count"/>
|
|
elements from source, in the specified order.</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams it results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.PartialSort``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Collections.Generic.IComparer{``0})">
|
|
<summary>
|
|
Combines <see cref="M:System.Linq.Enumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})"/>,
|
|
where each element is its key, and <see cref="M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32)"/>
|
|
in a single operation. An additional parameter specifies how the
|
|
elements compare to each other.
|
|
</summary>
|
|
<typeparam name="T">Type of elements in the sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="count">Number of (maximum) elements to return.</param>
|
|
<param name="comparer">A <see cref="T:System.Collections.Generic.IComparer`1"/> to compare elements.</param>
|
|
<returns>A sequence containing at most top <paramref name="count"/>
|
|
elements from source, in their ascending order.</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams it results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.PartialSort``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Collections.Generic.IComparer{``0},MoreLinq.OrderByDirection)">
|
|
<summary>
|
|
Combines <see cref="M:MoreLinq.MoreEnumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1},MoreLinq.OrderByDirection)"/>,
|
|
where each element is its key, and <see cref="M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32)"/>
|
|
in a single operation.
|
|
Additional parameters specify how the elements compare to each other and
|
|
the direction of the sort.
|
|
</summary>
|
|
<typeparam name="T">Type of elements in the sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="count">Number of (maximum) elements to return.</param>
|
|
<param name="comparer">A <see cref="T:System.Collections.Generic.IComparer`1"/> to compare elements.</param>
|
|
<param name="direction">The direction in which to sort the elements</param>
|
|
<returns>A sequence containing at most top <paramref name="count"/>
|
|
elements from source, in the specified order.</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams it results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.PartialSortBy``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,``1})">
|
|
<summary>
|
|
Combines <see cref="M:System.Linq.Enumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})"/>,
|
|
and <see cref="M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32)"/> in a single operation.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in the sequence.</typeparam>
|
|
<typeparam name="TKey">Type of keys.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="keySelector">A function to extract a key from an element.</param>
|
|
<param name="count">Number of (maximum) elements to return.</param>
|
|
<returns>A sequence containing at most top <paramref name="count"/>
|
|
elements from source, in ascending order of their keys.</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams it results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.PartialSortBy``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,``1},MoreLinq.OrderByDirection)">
|
|
<summary>
|
|
Combines <see cref="M:MoreLinq.MoreEnumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},MoreLinq.OrderByDirection)"/>,
|
|
and <see cref="M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32)"/> in a single operation.
|
|
An additional parameter specifies the direction of the sort
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in the sequence.</typeparam>
|
|
<typeparam name="TKey">Type of keys.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="keySelector">A function to extract a key from an element.</param>
|
|
<param name="count">Number of (maximum) elements to return.</param>
|
|
<param name="direction">The direction in which to sort the elements</param>
|
|
<returns>A sequence containing at most top <paramref name="count"/>
|
|
elements from source, in the specified order of their keys.</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams it results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.PartialSortBy``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,``1},System.Collections.Generic.IComparer{``1})">
|
|
<summary>
|
|
Combines <see cref="M:System.Linq.Enumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})"/>,
|
|
and <see cref="M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32)"/> in a single operation.
|
|
An additional parameter specifies how the keys compare to each other.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in the sequence.</typeparam>
|
|
<typeparam name="TKey">Type of keys.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="keySelector">A function to extract a key from an element.</param>
|
|
<param name="count">Number of (maximum) elements to return.</param>
|
|
<param name="comparer">A <see cref="T:System.Collections.Generic.IComparer`1"/> to compare elements.</param>
|
|
<returns>A sequence containing at most top <paramref name="count"/>
|
|
elements from source, in ascending order of their keys.</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams it results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.PartialSortBy``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,``1},System.Collections.Generic.IComparer{``1},MoreLinq.OrderByDirection)">
|
|
<summary>
|
|
Combines <see cref="M:MoreLinq.MoreEnumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},MoreLinq.OrderByDirection)"/>,
|
|
and <see cref="M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32)"/> in a single operation.
|
|
Additional parameters specify how the elements compare to each other and
|
|
the direction of the sort.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in the sequence.</typeparam>
|
|
<typeparam name="TKey">Type of keys.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="keySelector">A function to extract a key from an element.</param>
|
|
<param name="count">Number of (maximum) elements to return.</param>
|
|
<param name="comparer">A <see cref="T:System.Collections.Generic.IComparer`1"/> to compare elements.</param>
|
|
<param name="direction">The direction in which to sort the elements</param>
|
|
<returns>A sequence containing at most top <paramref name="count"/>
|
|
elements from source, in the specified order of their keys.</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams it results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Partition``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})">
|
|
<summary>
|
|
Partitions or splits a sequence in two using a predicate.
|
|
</summary>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="predicate">The predicate function.</param>
|
|
<typeparam name="T">Type of source elements.</typeparam>
|
|
<returns>
|
|
A tuple of elements staisfying the predicate and those that do not,
|
|
respectively.
|
|
</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var (evens, odds) =
|
|
Enumerable.Range(0, 10).Partition(x => x % 2 == 0);
|
|
]]></code>
|
|
The <c>evens</c> variable, when iterated over, will yield 0, 2, 4, 6
|
|
and then 8. The <c>odds</c> variable, when iterated over, will yield
|
|
1, 3, 5, 7 and then 9.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Partition``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},System.Func{System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},``1})">
|
|
<summary>
|
|
Partitions or splits a sequence in two using a predicate and then
|
|
projects a result from the two.
|
|
</summary>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="predicate">The predicate function.</param>
|
|
<param name="resultSelector">
|
|
Function that projects the result from sequences of elements that
|
|
satisfy the predicate and those that do not, respectively, passed as
|
|
arguments.
|
|
</param>
|
|
<typeparam name="T">Type of source elements.</typeparam>
|
|
<typeparam name="TResult">Type of the result.</typeparam>
|
|
<returns>
|
|
The return value from <paramref name="resultSelector"/>.
|
|
</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var (evens, odds) =
|
|
Enumerable.Range(0, 10)
|
|
.Partition(x => x % 2 == 0, ValueTuple.Create);
|
|
]]></code>
|
|
The <c>evens</c> variable, when iterated over, will yield 0, 2, 4, 6
|
|
and then 8. The <c>odds</c> variable, when iterated over, will yield
|
|
1, 3, 5, 7 and then 9.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Partition``2(System.Collections.Generic.IEnumerable{System.Linq.IGrouping{System.Boolean,``0}},System.Func{System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},``1})">
|
|
<summary>
|
|
Partitions a grouping by Boolean keys into a projection of true
|
|
elements and false elements, respectively.
|
|
</summary>
|
|
<typeparam name="T">Type of elements in source groupings.</typeparam>
|
|
<typeparam name="TResult">Type of the result.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="resultSelector">
|
|
Function that projects the result from sequences of true elements
|
|
and false elements, respectively, passed as arguments.
|
|
</param>
|
|
<returns>
|
|
The return value from <paramref name="resultSelector"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Partition``2(System.Collections.Generic.IEnumerable{System.Linq.IGrouping{System.Nullable{System.Boolean},``0}},System.Func{System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},``1})">
|
|
<summary>
|
|
Partitions a grouping by nullable Boolean keys into a projection of
|
|
true elements, false elements and null elements, respectively.
|
|
</summary>
|
|
<typeparam name="T">Type of elements in source groupings.</typeparam>
|
|
<typeparam name="TResult">Type of the result.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="resultSelector">
|
|
Function that projects the result from sequences of true elements,
|
|
false elements and null elements, respectively, passed as
|
|
arguments.
|
|
</param>
|
|
<returns>
|
|
The return value from <paramref name="resultSelector"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Partition``3(System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``0,System.Func{System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``2})">
|
|
<summary>
|
|
Partitions a grouping and projects a result from group elements
|
|
matching a key and those groups that do not.
|
|
</summary>
|
|
<typeparam name="TKey">Type of keys in source groupings.</typeparam>
|
|
<typeparam name="TElement">Type of elements in source groupings.</typeparam>
|
|
<typeparam name="TResult">Type of the result.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="key">The key to partition.</param>
|
|
<param name="resultSelector">
|
|
Function that projects the result from sequences of elements
|
|
matching <paramref name="key"/> and those groups that do not (in
|
|
the order in which they appear in <paramref name="source"/>),
|
|
passed as arguments.
|
|
</param>
|
|
<returns>
|
|
The return value from <paramref name="resultSelector"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Partition``3(System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``0,System.Collections.Generic.IEqualityComparer{``0},System.Func{System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``2})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TKey">Type of keys in source groupings.</typeparam>
|
|
<typeparam name="TElement">Type of elements in source groupings.</typeparam>
|
|
<typeparam name="TResult">Type of the result.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="key">The key to partition on.</param>
|
|
<param name="comparer">The comparer for keys.</param>
|
|
<param name="resultSelector">
|
|
Function that projects the result from elements of the group
|
|
matching <paramref name="key"/> and those groups that do not (in
|
|
the order in which they appear in <paramref name="source"/>),
|
|
passed as arguments.
|
|
</param>
|
|
<returns>
|
|
The return value from <paramref name="resultSelector"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Partition``3(System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``0,``0,System.Func{System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``2})">
|
|
<summary>
|
|
Partitions a grouping and projects a result from elements of
|
|
groups matching a set of two keys and those groups that do not.
|
|
</summary>
|
|
<typeparam name="TKey">Type of keys in source groupings.</typeparam>
|
|
<typeparam name="TElement">Type of elements in source groupings.</typeparam>
|
|
<typeparam name="TResult">Type of the result.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="key1">The first key to partition on.</param>
|
|
<param name="key2">The second key to partition on.</param>
|
|
<param name="resultSelector">
|
|
Function that projects the result from elements of the group
|
|
matching <paramref name="key1"/>, elements of the group matching
|
|
<paramref name="key2"/> and those groups that do not (in the order
|
|
in which they appear in <paramref name="source"/>), passed as
|
|
arguments.
|
|
</param>
|
|
<returns>
|
|
The return value from <paramref name="resultSelector"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Partition``3(System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``0,``0,System.Collections.Generic.IEqualityComparer{``0},System.Func{System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``2})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TKey">Type of keys in source groupings.</typeparam>
|
|
<typeparam name="TElement">Type of elements in source groupings.</typeparam>
|
|
<typeparam name="TResult">Type of the result.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="key1">The first key to partition on.</param>
|
|
<param name="key2">The second key to partition on.</param>
|
|
<param name="comparer">The comparer for keys.</param>
|
|
<param name="resultSelector">
|
|
Function that projects the result from elements of the group
|
|
matching <paramref name="key1"/>, elements of the group matching
|
|
<paramref name="key2"/> and those groups that do not (in the order
|
|
in which they appear in <paramref name="source"/>), passed as
|
|
arguments.
|
|
</param>
|
|
<returns>
|
|
The return value from <paramref name="resultSelector"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Partition``3(System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``0,``0,``0,System.Func{System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``2})">
|
|
<summary>
|
|
Partitions a grouping and projects a result from elements groups
|
|
matching a set of three keys and those groups that do not.
|
|
</summary>
|
|
<typeparam name="TKey">Type of keys in source groupings.</typeparam>
|
|
<typeparam name="TElement">Type of elements in source groupings.</typeparam>
|
|
<typeparam name="TResult">Type of the result.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="key1">The first key to partition on.</param>
|
|
<param name="key2">The second key to partition on.</param>
|
|
<param name="key3">The third key to partition on.</param>
|
|
<param name="resultSelector">
|
|
Function that projects the result from elements of groups
|
|
matching <paramref name="key1"/>, <paramref name="key2"/> and
|
|
<paramref name="key3"/> and those groups that do not (in the order
|
|
in which they appear in <paramref name="source"/>), passed as
|
|
arguments.
|
|
</param>
|
|
<returns>
|
|
The return value from <paramref name="resultSelector"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Partition``3(System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``0,``0,``0,System.Collections.Generic.IEqualityComparer{``0},System.Func{System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``2})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TKey">Type of keys in source groupings.</typeparam>
|
|
<typeparam name="TElement">Type of elements in source groupings.</typeparam>
|
|
<typeparam name="TResult">Type of the result.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="key1">The first key to partition on.</param>
|
|
<param name="key2">The second key to partition on.</param>
|
|
<param name="key3">The third key to partition on.</param>
|
|
<param name="comparer">The comparer for keys.</param>
|
|
<param name="resultSelector">
|
|
Function that projects the result from elements of groups
|
|
matching <paramref name="key1"/>, <paramref name="key2"/> and
|
|
<paramref name="key3"/> and those groups that do not (in
|
|
the order in which they appear in <paramref name="source"/>),
|
|
passed as arguments.
|
|
</param>
|
|
<returns>
|
|
The return value from <paramref name="resultSelector"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.MoreEnumerable.PermutationEnumerator`1">
|
|
<summary>
|
|
The private implementation class that produces permutations of a sequence.
|
|
</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.PermutationEnumerator`1.NextPermutation">
|
|
<summary>
|
|
Transposes elements in the cached permutation array to produce the next permutation
|
|
</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.PermutationEnumerator`1.PermuteValueSet">
|
|
<summary>
|
|
Creates a new list containing the values from the original
|
|
set in their new permuted order.
|
|
</summary>
|
|
<remarks>
|
|
The reason we return a new permuted value set, rather than reuse
|
|
an existing collection, is that we have no control over what the
|
|
consumer will do with the results produced. They could very easily
|
|
generate and store a set of permutations and only then begin to
|
|
process them. If we reused the same collection, the caller would
|
|
be surprised to discover that all of the permutations looked the
|
|
same.
|
|
</remarks>
|
|
<returns>List of permuted source sequence values</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Permutations``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Generates a sequence of lists that represent the permutations of the original sequence.
|
|
</summary>
|
|
<remarks>
|
|
A permutation is a unique re-ordering of the elements of the sequence.<br/>
|
|
This operator returns permutations in a deferred, streaming fashion; however, each
|
|
permutation is materialized into a new list. There are N! permutations of a sequence,
|
|
where N => sequence.Count().<br/>
|
|
Be aware that the original sequence is considered one of the permutations and will be
|
|
returned as one of the results.
|
|
</remarks>
|
|
<typeparam name="T">The type of the elements in the sequence</typeparam>
|
|
<param name="sequence">The original sequence to permute</param>
|
|
<returns>A sequence of lists representing permutations of the original sequence</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Pipe``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0})">
|
|
<summary>
|
|
Executes the given action on each element in the source sequence
|
|
and yields it.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequence</typeparam>
|
|
<param name="source">The sequence of elements</param>
|
|
<param name="action">The action to execute on each element</param>
|
|
<returns>A sequence with source elements in their original order.</returns>
|
|
<remarks>
|
|
The returned sequence is essentially a duplicate of
|
|
the original, but with the extra action being executed while the
|
|
sequence is evaluated. The action is always taken before the element
|
|
is yielded, so any changes made by the action will be visible in the
|
|
returned sequence. This operator uses deferred execution and streams it results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Prepend``1(System.Collections.Generic.IEnumerable{``0},``0)">
|
|
<summary>
|
|
Prepends a single value to a sequence.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The sequence to prepend to.</param>
|
|
<param name="value">The value to prepend.</param>
|
|
<returns>
|
|
Returns a sequence where a value is prepended to it.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
<code><![CDATA[
|
|
int[] numbers = { 1, 2, 3 };
|
|
var result = numbers.Prepend(0);
|
|
]]></code>
|
|
The <c>result</c> variable, when iterated over, will yield
|
|
0, 1, 2 and 3, in turn.
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.PreScan``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0},``0)">
|
|
<summary>
|
|
Performs a pre-scan (exclusive prefix sum) on a sequence of elements.
|
|
</summary>
|
|
<remarks>
|
|
An exclusive prefix sum returns an equal-length sequence where the
|
|
N-th element is the sum of the first N-1 input elements (the first
|
|
element is a special case, it is set to the identity). More
|
|
generally, the pre-scan allows any commutative binary operation,
|
|
not just a sum.
|
|
The inclusive version of PreScan is <see cref="M:MoreLinq.MoreEnumerable.Scan``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})"/>.
|
|
This operator uses deferred execution and streams its result.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
int[] values = { 1, 2, 3, 4 };
|
|
var prescan = values.PreScan((a, b) => a + b, 0);
|
|
var scan = values.Scan((a, b) => a + b);
|
|
var result = values.EquiZip(prescan, ValueTuple.Create);
|
|
]]></code>
|
|
<c>prescan</c> will yield <c>{ 0, 1, 3, 6 }</c>, while <c>scan</c>
|
|
and <c>result</c> will both yield <c>{ 1, 3, 6, 10 }</c>. This
|
|
shows the relationship between the inclusive and exclusive prefix sum.
|
|
</example>
|
|
<typeparam name="TSource">Type of elements in source sequence</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<param name="transformation">Transformation operation</param>
|
|
<param name="identity">Identity element (see remarks)</param>
|
|
<returns>The scanned sequence</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Random">
|
|
<summary>
|
|
Returns an infinite sequence of random integers using the standard
|
|
.NET random number generator.
|
|
</summary>
|
|
<returns>An infinite sequence of random integers</returns>
|
|
<remarks>
|
|
The implementation internally uses a shared, thread-local instance of
|
|
<see cref="T:System.Random" /> to generate a random number on each
|
|
iteration. The actual <see cref="T:System.Random" /> instance used
|
|
therefore will depend on the thread on which a single iteration is
|
|
taking place; that is the call to
|
|
<see cref="M:System.Collections.IEnumerator.MoveNext" />. If the
|
|
overall iteration takes place on different threads (e.g.
|
|
via asynchronous awaits completing on different threads) then various
|
|
different <see cref="T:System.Random" /> instances will be involved
|
|
in the generation of the sequence of random numbers. Because the
|
|
<see cref="T:System.Random" /> instance is shared, if multiple sequences
|
|
are generated on the same thread, the order of enumeration affects the
|
|
resulting sequences.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Random(System.Random)">
|
|
<summary>
|
|
Returns an infinite sequence of random integers using the supplied
|
|
random number generator.
|
|
</summary>
|
|
<param name="rand">Random generator used to produce random numbers</param>
|
|
<returns>An infinite sequence of random integers</returns>
|
|
<exception cref="T:System.ArgumentNullException">Thrown if <paramref name="rand"/> is <see langword="null"/>.</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Random(System.Int32)">
|
|
<summary>
|
|
Returns an infinite sequence of random integers between zero and
|
|
a given maximum.
|
|
</summary>
|
|
<param name="maxValue">exclusive upper bound for the random values returned</param>
|
|
<returns>An infinite sequence of random integers</returns>
|
|
<remarks>
|
|
The implementation internally uses a shared, thread-local instance of
|
|
<see cref="T:System.Random" /> to generate a random number on each
|
|
iteration. The actual <see cref="T:System.Random" /> instance used
|
|
therefore will depend on the thread on which a single iteration is
|
|
taking place; that is the call to
|
|
<see cref="M:System.Collections.IEnumerator.MoveNext" />. If the
|
|
overall iteration takes place on different threads (e.g.
|
|
via asynchronous awaits completing on different threads) then various
|
|
different <see cref="T:System.Random" /> instances will be involved
|
|
in the generation of the sequence of random numbers. Because the
|
|
<see cref="T:System.Random" /> instance is shared, if multiple sequences
|
|
are generated on the same thread, the order of enumeration affects the
|
|
resulting sequences.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Random(System.Random,System.Int32)">
|
|
<summary>
|
|
Returns an infinite sequence of random integers between zero and a
|
|
given maximum using the supplied random number generator.
|
|
</summary>
|
|
<param name="rand">Random generator used to produce values</param>
|
|
<param name="maxValue">Exclusive upper bound for random values returned</param>
|
|
<returns>An infinite sequence of random integers</returns>
|
|
<exception cref="T:System.ArgumentNullException">Thrown if <paramref name="rand"/> is <see langword="null"/>.</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Random(System.Int32,System.Int32)">
|
|
<summary>
|
|
Returns an infinite sequence of random integers between a given
|
|
minimum and a maximum.
|
|
</summary>
|
|
<param name="minValue">Inclusive lower bound of the values returned</param>
|
|
<param name="maxValue">Exclusive upper bound of the values returned</param>
|
|
<returns>An infinite sequence of random integers</returns>
|
|
<remarks>
|
|
The implementation internally uses a shared, thread-local instance of
|
|
<see cref="T:System.Random" /> to generate a random number on each
|
|
iteration. The actual <see cref="T:System.Random" /> instance used
|
|
therefore will depend on the thread on which a single iteration is
|
|
taking place; that is the call to
|
|
<see cref="M:System.Collections.IEnumerator.MoveNext" />. If the
|
|
overall iteration takes place on different threads (e.g.
|
|
via asynchronous awaits completing on different threads) then various
|
|
different <see cref="T:System.Random" /> instances will be involved
|
|
in the generation of the sequence of random numbers. Because the
|
|
<see cref="T:System.Random" /> instance is shared, if multiple sequences
|
|
are generated on the same thread, the order of enumeration affects the
|
|
resulting sequences.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Random(System.Random,System.Int32,System.Int32)">
|
|
<summary>
|
|
Returns an infinite sequence of random integers between a given
|
|
minumum and a maximum using the supplied random number generator.
|
|
</summary>
|
|
<param name="rand">Generator used to produce random numbers</param>
|
|
<param name="minValue">Inclusive lower bound of the values returned</param>
|
|
<param name="maxValue">Exclusive upper bound of the values returned</param>
|
|
<returns>An infinite sequence of random integers</returns>
|
|
<exception cref="T:System.ArgumentNullException">Thrown if <paramref name="rand"/> is <see langword="null"/>.</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.RandomDouble">
|
|
<summary>
|
|
Returns an infinite sequence of random double values between 0.0 and 1.0
|
|
</summary>
|
|
<returns>An infinite sequence of random doubles</returns>
|
|
<remarks>
|
|
The implementation internally uses a shared, thread-local instance of
|
|
<see cref="T:System.Random" /> to generate a random number on each
|
|
iteration. The actual <see cref="T:System.Random" /> instance used
|
|
therefore will depend on the thread on which a single iteration is
|
|
taking place; that is the call to
|
|
<see cref="M:System.Collections.IEnumerator.MoveNext" />. If the
|
|
overall iteration takes place on different threads (e.g.
|
|
via asynchronous awaits completing on different threads) then various
|
|
different <see cref="T:System.Random" /> instances will be involved
|
|
in the generation of the sequence of random numbers. Because the
|
|
<see cref="T:System.Random" /> instance is shared, if multiple sequences
|
|
are generated on the same thread, the order of enumeration affects the
|
|
resulting sequences.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.RandomDouble(System.Random)">
|
|
<summary>
|
|
Returns an infinite sequence of random double values between 0.0 and 1.0
|
|
using the supplied random number generator.
|
|
</summary>
|
|
<param name="rand">Generator used to produce random numbers</param>
|
|
<returns>An infinite sequence of random doubles</returns>
|
|
<exception cref="T:System.ArgumentNullException">Thrown if <paramref name="rand"/> is <see langword="null"/>.</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.RandomImpl``1(System.Random,System.Func{System.Random,``0})">
|
|
<summary>
|
|
This is the underlying implementation that all random operators use to
|
|
produce a sequence of random values.
|
|
</summary>
|
|
<typeparam name="T">The type of value returned (either Int32 or Double)</typeparam>
|
|
<param name="rand">Random generators used to produce the sequence</param>
|
|
<param name="nextValue">Generator function that actually produces the next value - specific to T</param>
|
|
<returns>An infinite sequence of random numbers of type T</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.MoreEnumerable.GlobalRandom">
|
|
<remarks>
|
|
<see cref="T:System.Random"/> is not thread-safe so the following
|
|
implementation uses thread-local <see cref="T:System.Random"/>
|
|
instances to create the illusion of a global
|
|
<see cref="T:System.Random"/> implementation. For some background,
|
|
see <a href="https://blogs.msdn.microsoft.com/pfxteam/2009/02/19/getting-random-numbers-in-a-thread-safe-way/">Getting
|
|
random numbers in a thread-safe way</a>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.RandomSubset``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Returns a sequence of a specified size of random elements from the
|
|
original sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of source sequence elements.</typeparam>
|
|
<param name="source">
|
|
The sequence from which to return random elements.</param>
|
|
<param name="subsetSize">The size of the random subset to return.</param>
|
|
<returns>
|
|
A random sequence of elements in random order from the original
|
|
sequence.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.RandomSubset``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Random)">
|
|
<summary>
|
|
Returns a sequence of a specified size of random elements from the
|
|
original sequence. An additional parameter specifies a random
|
|
generator to be used for the random selection algorithm.
|
|
</summary>
|
|
<typeparam name="T">The type of source sequence elements.</typeparam>
|
|
<param name="source">
|
|
The sequence from which to return random elements.</param>
|
|
<param name="subsetSize">The size of the random subset to return.</param>
|
|
<param name="rand">
|
|
A random generator used as part of the selection algorithm.</param>
|
|
<returns>
|
|
A random sequence of elements in random order from the original
|
|
sequence.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Rank``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Ranks each item in the sequence in descending ordering using a default comparer.
|
|
</summary>
|
|
<typeparam name="TSource">Type of item in the sequence</typeparam>
|
|
<param name="source">The sequence whose items will be ranked</param>
|
|
<returns>A sequence of position integers representing the ranks of the corresponding items in the sequence</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Rank``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0})">
|
|
<summary>
|
|
Rank each item in the sequence using a caller-supplied comparer.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements in the source sequence</typeparam>
|
|
<param name="source">The sequence of items to rank</param>
|
|
<param name="comparer">A object that defines comparison semantics for the elements in the sequence</param>
|
|
<returns>A sequence of position integers representing the ranks of the corresponding items in the sequence</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.RankBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
|
|
<summary>
|
|
Ranks each item in the sequence in descending ordering by a specified key using a default comparer
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements in the source sequence</typeparam>
|
|
<typeparam name="TKey">The type of the key used to rank items in the sequence</typeparam>
|
|
<param name="source">The sequence of items to rank</param>
|
|
<param name="keySelector">A key selector function which returns the value by which to rank items in the sequence</param>
|
|
<returns>A sequence of position integers representing the ranks of the corresponding items in the sequence</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.RankBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})">
|
|
<summary>
|
|
Ranks each item in a sequence using a specified key and a caller-supplied comparer
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements in the source sequence</typeparam>
|
|
<typeparam name="TKey">The type of the key used to rank items in the sequence</typeparam>
|
|
<param name="source">The sequence of items to rank</param>
|
|
<param name="keySelector">A key selector function which returns the value by which to rank items in the sequence</param>
|
|
<param name="comparer">An object that defines the comparison semantics for keys used to rank items</param>
|
|
<returns>A sequence of position integers representing the ranks of the corresponding items in the sequence</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Repeat``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Repeats the sequence the specified number of times.
|
|
</summary>
|
|
<typeparam name="T">Type of elements in sequence</typeparam>
|
|
<param name="sequence">The sequence to repeat</param>
|
|
<param name="count">Number of times to repeat the sequence</param>
|
|
<returns>A sequence produced from the repetition of the original source sequence</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Repeat``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Repeats the sequence forever.
|
|
</summary>
|
|
<typeparam name="T">Type of elements in sequence</typeparam>
|
|
<param name="sequence">The sequence to repeat</param>
|
|
<returns>A sequence produced from the infinite repetition of the original source sequence</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Return``1(``0)">
|
|
<summary>
|
|
Returns a single-element sequence containing the item provided.
|
|
</summary>
|
|
<typeparam name="T">The type of the item.</typeparam>
|
|
<param name="item">The item to return in a sequence.</param>
|
|
<returns>A sequence containing only <paramref name="item"/>.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.RightJoin``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``0,``0,``2})">
|
|
<summary>
|
|
Performs a right outer join on two homogeneous sequences.
|
|
Additional arguments specify key selection functions and result
|
|
projection functions.
|
|
</summary>
|
|
<typeparam name="TSource">
|
|
The type of elements in the source sequence.</typeparam>
|
|
<typeparam name="TKey">
|
|
The type of the key returned by the key selector function.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the result elements.</typeparam>
|
|
<param name="first">
|
|
The first sequence of the join operation.</param>
|
|
<param name="second">
|
|
The second sequence of the join operation.</param>
|
|
<param name="keySelector">
|
|
Function that projects the key given an element of one of the
|
|
sequences to join.</param>
|
|
<param name="secondSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="second"/> where there is no corresponding element
|
|
in <paramref name="first"/>.</param>
|
|
<param name="bothSelector">
|
|
Function that projects the result given an element from
|
|
<paramref name="first"/> and an element from <paramref name="second"/>
|
|
that match on a common key.</param>
|
|
<returns>A sequence containing results projected from a right
|
|
outer join of the two input sequences.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.RightJoin``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``0,``0,``2},System.Collections.Generic.IEqualityComparer{``1})">
|
|
<summary>
|
|
Performs a right outer join on two homogeneous sequences.
|
|
Additional arguments specify key selection functions, result
|
|
projection functions and a key comparer.
|
|
</summary>
|
|
<typeparam name="TSource">
|
|
The type of elements in the source sequence.</typeparam>
|
|
<typeparam name="TKey">
|
|
The type of the key returned by the key selector function.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the result elements.</typeparam>
|
|
<param name="first">
|
|
The first sequence of the join operation.</param>
|
|
<param name="second">
|
|
The second sequence of the join operation.</param>
|
|
<param name="keySelector">
|
|
Function that projects the key given an element of one of the
|
|
sequences to join.</param>
|
|
<param name="secondSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="second"/> where there is no corresponding element
|
|
in <paramref name="first"/>.</param>
|
|
<param name="bothSelector">
|
|
Function that projects the result given an element from
|
|
<paramref name="first"/> and an element from <paramref name="second"/>
|
|
that match on a common key.</param>
|
|
<param name="comparer">
|
|
The <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> instance used to compare
|
|
keys for equality.</param>
|
|
<returns>A sequence containing results projected from a right
|
|
outer join of the two input sequences.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.RightJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``1,``3},System.Func{``0,``1,``3})">
|
|
<summary>
|
|
Performs a right outer join on two heterogeneous sequences.
|
|
Additional arguments specify key selection functions and result
|
|
projection functions.
|
|
</summary>
|
|
<typeparam name="TFirst">
|
|
The type of elements in the first sequence.</typeparam>
|
|
<typeparam name="TSecond">
|
|
The type of elements in the second sequence.</typeparam>
|
|
<typeparam name="TKey">
|
|
The type of the key returned by the key selector functions.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the result elements.</typeparam>
|
|
<param name="first">
|
|
The first sequence of the join operation.</param>
|
|
<param name="second">
|
|
The second sequence of the join operation.</param>
|
|
<param name="firstKeySelector">
|
|
Function that projects the key given an element from <paramref name="first"/>.</param>
|
|
<param name="secondKeySelector">
|
|
Function that projects the key given an element from <paramref name="second"/>.</param>
|
|
<param name="secondSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="second"/> where there is no corresponding element
|
|
in <paramref name="first"/>.</param>
|
|
<param name="bothSelector">
|
|
Function that projects the result given an element from
|
|
<paramref name="first"/> and an element from <paramref name="second"/>
|
|
that match on a common key.</param>
|
|
<returns>A sequence containing results projected from a right
|
|
outer join of the two input sequences.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.RightJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``1,``3},System.Func{``0,``1,``3},System.Collections.Generic.IEqualityComparer{``2})">
|
|
<summary>
|
|
Performs a right outer join on two heterogeneous sequences.
|
|
Additional arguments specify key selection functions, result
|
|
projection functions and a key comparer.
|
|
</summary>
|
|
<typeparam name="TFirst">
|
|
The type of elements in the first sequence.</typeparam>
|
|
<typeparam name="TSecond">
|
|
The type of elements in the second sequence.</typeparam>
|
|
<typeparam name="TKey">
|
|
The type of the key returned by the key selector functions.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the result elements.</typeparam>
|
|
<param name="first">
|
|
The first sequence of the join operation.</param>
|
|
<param name="second">
|
|
The second sequence of the join operation.</param>
|
|
<param name="firstKeySelector">
|
|
Function that projects the key given an element from <paramref name="first"/>.</param>
|
|
<param name="secondKeySelector">
|
|
Function that projects the key given an element from <paramref name="second"/>.</param>
|
|
<param name="secondSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="second"/> where there is no corresponding element
|
|
in <paramref name="first"/>.</param>
|
|
<param name="bothSelector">
|
|
Function that projects the result given an element from
|
|
<paramref name="first"/> and an element from <paramref name="second"/>
|
|
that match on a common key.</param>
|
|
<param name="comparer">
|
|
The <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> instance used to compare
|
|
keys for equality.</param>
|
|
<returns>A sequence containing results projected from a right
|
|
outer join of the two input sequences.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.RunLengthEncode``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Run-length encodes a sequence by converting consecutive instances of the same element into
|
|
a <c>KeyValuePair{T,int}</c> representing the item and its occurrence count.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequence</typeparam>
|
|
<param name="sequence">The sequence to run length encode</param>
|
|
<returns>A sequence of <c>KeyValuePair{T,int}</c> where the key is the element and the value is the occurrence count</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.RunLengthEncode``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
|
|
<summary>
|
|
Run-length encodes a sequence by converting consecutive instances of the same element into
|
|
a <c>KeyValuePair{T,int}</c> representing the item and its occurrence count. This overload
|
|
uses a custom equality comparer to identify equivalent items.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequence</typeparam>
|
|
<param name="sequence">The sequence to run length encode</param>
|
|
<param name="comparer">The comparer used to identify equivalent items</param>
|
|
<returns>A sequence of <c>KeyValuePair{T,int}</c> where they key is the element and the value is the occurrence count</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Scan``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})">
|
|
<summary>
|
|
Performs a scan (inclusive prefix sum) on a sequence of elements.
|
|
</summary>
|
|
<remarks>
|
|
An inclusive prefix sum returns an equal-length sequence where the
|
|
N-th element is the sum of the first N input elements. More
|
|
generally, the scan allows any commutative binary operation, not
|
|
just a sum.
|
|
The exclusive version of Scan is <see cref="M:MoreLinq.MoreEnumerable.PreScan``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0},``0)"/>.
|
|
This operator uses deferred execution and streams its result.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
int[] values = { 1, 2, 3, 4 };
|
|
var prescan = values.PreScan((a, b) => a + b, 0);
|
|
var scan = values.Scan((a, b) => a + b);
|
|
var result = values.EquiZip(scan, ValueTuple.Create);
|
|
]]></code>
|
|
<c>prescan</c> will yield <c>{ 0, 1, 3, 6 }</c>, while <c>scan</c>
|
|
and <c>result</c> will both yield <c>{ 1, 3, 6, 10 }</c>. This
|
|
shows the relationship between the inclusive and exclusive prefix sum.
|
|
</example>
|
|
<typeparam name="TSource">Type of elements in source sequence</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<param name="transformation">Transformation operation</param>
|
|
<returns>The scanned sequence</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Scan``2(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1})">
|
|
<summary>
|
|
Like <see cref="M:System.Linq.Enumerable.Aggregate``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})"/> except returns
|
|
the sequence of intermediate results as well as the final one.
|
|
An additional parameter specifies a seed.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its result.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
var result = Enumerable.Range(1, 5).Scan(0, (a, b) => a + b);
|
|
]]></code>
|
|
When iterated, <c>result</c> will yield <c>{ 0, 1, 3, 6, 10, 15 }</c>.
|
|
</example>
|
|
<typeparam name="TSource">Type of elements in source sequence</typeparam>
|
|
<typeparam name="TState">Type of state</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<param name="seed">Initial state to seed</param>
|
|
<param name="transformation">Transformation operation</param>
|
|
<returns>The scanned sequence</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ScanBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,``2},System.Func{``2,``1,``0,``2})">
|
|
<summary>
|
|
Applies an accumulator function over sequence element keys,
|
|
returning the keys along with intermediate accumulator states.
|
|
</summary>
|
|
<typeparam name="TSource">Type of the elements of the source sequence.</typeparam>
|
|
<typeparam name="TKey">The type of the key.</typeparam>
|
|
<typeparam name="TState">Type of the state.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="keySelector">
|
|
A function that returns the key given an element.</param>
|
|
<param name="seedSelector">
|
|
A function to determine the initial value for the accumulator that is
|
|
invoked once per key encountered.</param>
|
|
<param name="accumulator">
|
|
An accumulator function invoked for each element.</param>
|
|
<returns>
|
|
A sequence of keys paired with intermediate accumulator states.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ScanBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,``2},System.Func{``2,``1,``0,``2},System.Collections.Generic.IEqualityComparer{``1})">
|
|
<summary>
|
|
Applies an accumulator function over sequence element keys,
|
|
returning the keys along with intermediate accumulator states. An
|
|
additional parameter specifies the comparer to use to compare keys.
|
|
</summary>
|
|
<typeparam name="TSource">Type of the elements of the source sequence.</typeparam>
|
|
<typeparam name="TKey">The type of the key.</typeparam>
|
|
<typeparam name="TState">Type of the state.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="keySelector">
|
|
A function that returns the key given an element.</param>
|
|
<param name="seedSelector">
|
|
A function to determine the initial value for the accumulator that is
|
|
invoked once per key encountered.</param>
|
|
<param name="accumulator">
|
|
An accumulator function invoked for each element.</param>
|
|
<param name="comparer">The equality comparer to use to determine
|
|
whether or not keys are equal. If <c>null</c>, the default equality
|
|
comparer for <typeparamref name="TSource"/> is used.</param>
|
|
<returns>
|
|
A sequence of keys paired with intermediate accumulator states.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ScanRight``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})">
|
|
<summary>
|
|
Peforms a right-associative scan (inclusive prefix) on a sequence of elements.
|
|
This operator is the right-associative version of the
|
|
<see cref="M:MoreLinq.MoreEnumerable.Scan``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})"/> LINQ operator.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in source sequence.</typeparam>
|
|
<param name="source">Source sequence.</param>
|
|
<param name="func">
|
|
A right-associative accumulator function to be invoked on each element.
|
|
Its first argument is the current value in the sequence; second argument is the previous accumulator value.
|
|
</param>
|
|
<returns>The scanned sequence.</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var result = Enumerable.Range(1, 5).Select(i => i.ToString()).ScanRight((a, b) => string.Format("({0}/{1})", a, b));
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>[ "(1+(2+(3+(4+5))))", "(2+(3+(4+5)))", "(3+(4+5))", "(4+5)", "5" ]</c>.
|
|
</example>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
Source sequence is consumed greedily when an iteration of the resulting sequence begins.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ScanRight``2(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``0,``1,``1})">
|
|
<summary>
|
|
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
|
|
<see cref="M:MoreLinq.MoreEnumerable.Scan``2(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1})"/> LINQ operator.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of source.</typeparam>
|
|
<typeparam name="TAccumulate">The type of the accumulator value.</typeparam>
|
|
<param name="source">Source sequence.</param>
|
|
<param name="seed">The initial accumulator value.</param>
|
|
<param name="func">A right-associative accumulator function to be invoked on each element.</param>
|
|
<returns>The scanned sequence.</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var result = Enumerable.Range(1, 4).ScanRight("5", (a, b) => string.Format("({0}/{1})", a, b));
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>[ "(1+(2+(3+(4+5))))", "(2+(3+(4+5)))", "(3+(4+5))", "(4+5)", "5" ]</c>.
|
|
</example>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
Source sequence is consumed greedily when an iteration of the resulting sequence begins.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Segment``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})">
|
|
<summary>
|
|
Divides a sequence into multiple sequences by using a segment detector based on the original sequence
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequence</typeparam>
|
|
<param name="source">The sequence to segment</param>
|
|
<param name="newSegmentPredicate">A function, which returns <c>true</c> if the given element begins a new segment, and <c>false</c> otherwise</param>
|
|
<returns>A sequence of segment, each of which is a portion of the original sequence</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
Thrown if either <paramref name="source"/> or <paramref name="newSegmentPredicate"/> are <see langword="null"/>.
|
|
</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Segment``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32,System.Boolean})">
|
|
<summary>
|
|
Divides a sequence into multiple sequences by using a segment detector based on the original sequence
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequence</typeparam>
|
|
<param name="source">The sequence to segment</param>
|
|
<param name="newSegmentPredicate">A function, which returns <c>true</c> if the given element or index indicate a new segment, and <c>false</c> otherwise</param>
|
|
<returns>A sequence of segment, each of which is a portion of the original sequence</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
Thrown if either <paramref name="source"/> or <paramref name="newSegmentPredicate"/> are <see langword="null"/>.
|
|
</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Segment``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,System.Int32,System.Boolean})">
|
|
<summary>
|
|
Divides a sequence into multiple sequences by using a segment detector based on the original sequence
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequence</typeparam>
|
|
<param name="source">The sequence to segment</param>
|
|
<param name="newSegmentPredicate">A function, which returns <c>true</c> if the given current element, previous element or index indicate a new segment, and <c>false</c> otherwise</param>
|
|
<returns>A sequence of segment, each of which is a portion of the original sequence</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
Thrown if either <paramref name="source"/> or <paramref name="newSegmentPredicate"/> are <see langword="null"/>.
|
|
</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Sequence(System.Int32,System.Int32)">
|
|
<summary>
|
|
Generates a sequence of integral numbers within the (inclusive) specified range.
|
|
If sequence is ascending the step is +1, otherwise -1.
|
|
</summary>
|
|
<param name="start">The value of the first integer in the sequence.</param>
|
|
<param name="stop">The value of the last integer in the sequence.</param>
|
|
<returns>An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that contains a range of sequential integral numbers.</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
var result = MoreEnumerable.Sequence(6, 0);
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>{ 6, 5, 4, 3, 2, 1, 0 }</c>.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Sequence(System.Int32,System.Int32,System.Int32)">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<param name="start">The value of the first integer in the sequence.</param>
|
|
<param name="stop">The value of the last integer in the sequence.</param>
|
|
<param name="step">The step to define the next number.</param>
|
|
<returns>An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that contains a range of sequential integral numbers.</returns>
|
|
<remarks>
|
|
When <paramref name="step"/> is equal to zero, this operator returns an
|
|
infinite sequence where all elements are equals to <paramref name="start"/>.
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
var result = MoreEnumerable.Sequence(6, 0, -2);
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>{ 6, 4, 2, 0 }</c>.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Shuffle``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Returns a sequence of elements in random order from the original
|
|
sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of source sequence elements.</typeparam>
|
|
<param name="source">
|
|
The sequence from which to return random elements.</param>
|
|
<returns>
|
|
A sequence of elements <paramref name="source"/> randomized in
|
|
their order.
|
|
</returns>
|
|
<remarks>
|
|
This method uses deferred execution and streams its results. The
|
|
source sequence is entirely buffered before the results are
|
|
streamed.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Shuffle``1(System.Collections.Generic.IEnumerable{``0},System.Random)">
|
|
<summary>
|
|
Returns a sequence of elements in random order from the original
|
|
sequence. An additional parameter specifies a random generator to be
|
|
used for the random selection algorithm.
|
|
</summary>
|
|
<typeparam name="T">The type of source sequence elements.</typeparam>
|
|
<param name="source">
|
|
The sequence from which to return random elements.</param>
|
|
<param name="rand">
|
|
A random generator used as part of the selection algorithm.</param>
|
|
<returns>
|
|
A sequence of elements <paramref name="source"/> randomized in
|
|
their order.
|
|
</returns>
|
|
<remarks>
|
|
This method uses deferred execution and streams its results. The
|
|
source sequence is entirely buffered before the results are
|
|
streamed.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.SkipLast``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Bypasses a specified number of elements at the end of the sequence.
|
|
</summary>
|
|
<typeparam name="T">Type of the source sequence</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="count">The number of elements to bypass at the end of the source sequence.</param>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> containing the source sequence elements except for the bypassed ones at the end.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.SkipUntil``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
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.
|
|
</para>
|
|
<para>
|
|
Secondly, SkipUntil skips the element which causes the predicate to return true. For
|
|
example, in a sequence <code><![CDATA[{ 1, 2, 3, 4, 5 }]]></code> and with a predicate of
|
|
<code><![CDATA[x => x == 3]]></code>, the result would be <code><![CDATA[{ 4, 5 }]]></code>.
|
|
</para>
|
|
<para>
|
|
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.)
|
|
</para>
|
|
</remarks>
|
|
<typeparam name="TSource">Type of the source sequence</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<param name="predicate">Predicate used to determine when to stop yielding results from the source.</param>
|
|
<returns>Items from the source sequence after the predicate first returns true when applied to the item.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is null</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Slice``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Int32)">
|
|
<summary>
|
|
Extracts a contiguous count of elements from a sequence at a particular zero-based starting index
|
|
</summary>
|
|
<remarks>
|
|
If the starting position or count specified result in slice extending past the end of the sequence,
|
|
it will return all elements up to that point. There is no guarantee that the resulting sequence will
|
|
contain the number of elements requested - it may have anywhere from 0 to <paramref name="count"/>.<br/>
|
|
This method is implemented in an optimized manner for any sequence implementing <c>IList{T}</c>.<br/>
|
|
The result of Slice() is identical to: <c>sequence.Skip(startIndex).Take(count)</c>
|
|
</remarks>
|
|
<typeparam name="T">The type of the elements in the source sequence</typeparam>
|
|
<param name="sequence">The sequence from which to extract elements</param>
|
|
<param name="startIndex">The zero-based index at which to begin slicing</param>
|
|
<param name="count">The number of items to slice out of the index</param>
|
|
<returns>A new sequence containing any elements sliced out from the source sequence</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.SortedMerge``1(System.Collections.Generic.IEnumerable{``0},MoreLinq.OrderByDirection,System.Collections.Generic.IEnumerable{``0}[])">
|
|
<summary>
|
|
Merges two or more sequences that are in a common order (either ascending or descending) into
|
|
a single sequence that preserves that order.
|
|
</summary>
|
|
<remarks>
|
|
Using SortedMerge on sequences that are not ordered or are not in the same order produces
|
|
undefined results.<br/>
|
|
<c>SortedMerge</c> uses performs the merge in a deferred, streaming manner. <br/>
|
|
|
|
Here is an example of a merge, as well as the produced result:
|
|
<code><![CDATA[
|
|
var 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 }
|
|
]]></code>
|
|
</remarks>
|
|
<typeparam name="TSource">The type of the elements of the sequence</typeparam>
|
|
<param name="source">The primary sequence with which to merge</param>
|
|
<param name="direction">The ordering that all sequences must already exhibit</param>
|
|
<param name="otherSequences">A variable argument array of zero or more other sequences to merge with</param>
|
|
<returns>A merged, order-preserving sequence containing all of the elements of the original sequences</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.SortedMerge``1(System.Collections.Generic.IEnumerable{``0},MoreLinq.OrderByDirection,System.Collections.Generic.IComparer{``0},System.Collections.Generic.IEnumerable{``0}[])">
|
|
<summary>
|
|
Merges two or more sequences that are in a common order (either ascending or descending) into
|
|
a single sequence that preserves that order.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements in the sequence</typeparam>
|
|
<param name="source">The primary sequence with which to merge</param>
|
|
<param name="direction">The ordering that all sequences must already exhibit</param>
|
|
<param name="comparer">The comparer used to evaluate the relative order between elements</param>
|
|
<param name="otherSequences">A variable argument array of zero or more other sequences to merge with</param>
|
|
<returns>A merged, order-preserving sequence containing al of the elements of the original sequences</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.MoreEnumerable.DisposableGroup`1">
|
|
<summary>
|
|
Class used to assist in ensuring that groups of disposable iterators
|
|
are disposed - either when Excluded or when the DisposableGroup is disposed.
|
|
</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Split``1(System.Collections.Generic.IEnumerable{``0},``0)">
|
|
<summary>
|
|
Splits the source sequence by a separator.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="separator">Separator element.</param>
|
|
<returns>A sequence of splits of elements.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Split``1(System.Collections.Generic.IEnumerable{``0},``0,System.Int32)">
|
|
<summary>
|
|
Splits the source sequence by a separator given a maximum count of splits.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="separator">Separator element.</param>
|
|
<param name="count">Maximum number of splits.</param>
|
|
<returns>A sequence of splits of elements.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Split``2(System.Collections.Generic.IEnumerable{``0},``0,System.Func{System.Collections.Generic.IEnumerable{``0},``1})">
|
|
<summary>
|
|
Splits the source sequence by a separator and then transforms
|
|
the splits into results.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence.</typeparam>
|
|
<typeparam name="TResult">Type of the result sequence elements.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="separator">Separator element.</param>
|
|
<param name="resultSelector">Function used to project splits
|
|
of source elements into elements of the resulting sequence.</param>
|
|
<returns>
|
|
A sequence of values typed as <typeparamref name="TResult"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Split``2(System.Collections.Generic.IEnumerable{``0},``0,System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1})">
|
|
<summary>
|
|
Splits the source sequence by a separator, given a maximum count
|
|
of splits, and then transforms the splits into results.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence.</typeparam>
|
|
<typeparam name="TResult">Type of the result sequence elements.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="separator">Separator element.</param>
|
|
<param name="count">Maximum number of splits.</param>
|
|
<param name="resultSelector">Function used to project splits
|
|
of source elements into elements of the resulting sequence.</param>
|
|
<returns>
|
|
A sequence of values typed as <typeparamref name="TResult"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Split``1(System.Collections.Generic.IEnumerable{``0},``0,System.Collections.Generic.IEqualityComparer{``0})">
|
|
<summary>
|
|
Splits the source sequence by a separator and then transforms the
|
|
splits into results.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="separator">Separator element.</param>
|
|
<param name="comparer">Comparer used to determine separator
|
|
element equality.</param>
|
|
<returns>A sequence of splits of elements.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Split``1(System.Collections.Generic.IEnumerable{``0},``0,System.Collections.Generic.IEqualityComparer{``0},System.Int32)">
|
|
<summary>
|
|
Splits the source sequence by a separator, given a maximum count
|
|
of splits. A parameter specifies how the separator is compared
|
|
for equality.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="separator">Separator element.</param>
|
|
<param name="comparer">Comparer used to determine separator
|
|
element equality.</param>
|
|
<param name="count">Maximum number of splits.</param>
|
|
<returns>A sequence of splits of elements.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Split``2(System.Collections.Generic.IEnumerable{``0},``0,System.Collections.Generic.IEqualityComparer{``0},System.Func{System.Collections.Generic.IEnumerable{``0},``1})">
|
|
<summary>
|
|
Splits the source sequence by a separator and then transforms the
|
|
splits into results. A parameter specifies how the separator is
|
|
compared for equality.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence.</typeparam>
|
|
<typeparam name="TResult">Type of the result sequence elements.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="separator">Separator element.</param>
|
|
<param name="comparer">Comparer used to determine separator
|
|
element equality.</param>
|
|
<param name="resultSelector">Function used to project splits
|
|
of source elements into elements of the resulting sequence.</param>
|
|
<returns>
|
|
A sequence of values typed as <typeparamref name="TResult"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Split``2(System.Collections.Generic.IEnumerable{``0},``0,System.Collections.Generic.IEqualityComparer{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence.</typeparam>
|
|
<typeparam name="TResult">Type of the result sequence elements.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="separator">Separator element.</param>
|
|
<param name="comparer">Comparer used to determine separator
|
|
element equality.</param>
|
|
<param name="count">Maximum number of splits.</param>
|
|
<param name="resultSelector">Function used to project splits
|
|
of source elements into elements of the resulting sequence.</param>
|
|
<returns>
|
|
A sequence of values typed as <typeparamref name="TResult"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Split``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})">
|
|
<summary>
|
|
Splits the source sequence by separator elements identified by a
|
|
function.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="separatorFunc">Predicate function used to determine
|
|
the splitter elements in the source sequence.</param>
|
|
<returns>A sequence of splits of elements.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Split``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},System.Int32)">
|
|
<summary>
|
|
Splits the source sequence by separator elements identified by a
|
|
function, given a maximum count of splits.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="separatorFunc">Predicate function used to determine
|
|
the splitter elements in the source sequence.</param>
|
|
<param name="count">Maximum number of splits.</param>
|
|
<returns>A sequence of splits of elements.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Split``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},System.Func{System.Collections.Generic.IEnumerable{``0},``1})">
|
|
<summary>
|
|
Splits the source sequence by separator elements identified by
|
|
a function and then transforms the splits into results.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence.</typeparam>
|
|
<typeparam name="TResult">Type of the result sequence elements.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="separatorFunc">Predicate function used to determine
|
|
the splitter elements in the source sequence.</param>
|
|
<param name="resultSelector">Function used to project splits
|
|
of source elements into elements of the resulting sequence.</param>
|
|
<returns>
|
|
A sequence of values typed as <typeparamref name="TResult"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Split``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1})">
|
|
<summary>
|
|
Splits the source sequence by separator elements identified by
|
|
a function, given a maximum count of splits, and then transforms
|
|
the splits into results.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence.</typeparam>
|
|
<typeparam name="TResult">Type of the result sequence elements.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="separatorFunc">Predicate function used to determine
|
|
the splitter elements in the source sequence.</param>
|
|
<param name="count">Maximum number of splits.</param>
|
|
<param name="resultSelector">Function used to project a split
|
|
group of source elements into an element of the resulting sequence.</param>
|
|
<returns>
|
|
A sequence of values typed as <typeparamref name="TResult"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.StartsWith``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Determines whether the beginning of the first sequence is
|
|
equivalent to the second sequence, using the default equality
|
|
comparer.
|
|
</summary>
|
|
<typeparam name="T">Type of elements.</typeparam>
|
|
<param name="first">The sequence to check.</param>
|
|
<param name="second">The sequence to compare to.</param>
|
|
<returns>
|
|
<c>true</c> if <paramref name="first" /> begins with elements
|
|
equivalent to <paramref name="second" />.
|
|
</returns>
|
|
<remarks>
|
|
This is the <see cref="T:System.Collections.Generic.IEnumerable`1" /> equivalent of
|
|
<see cref="M:System.String.StartsWith(System.String)" /> and it calls
|
|
<see cref="M:System.Collections.Generic.IEqualityComparer`1.Equals(`0,`0)" /> using
|
|
<see cref="P:System.Collections.Generic.EqualityComparer`1.Default"/> on pairs of elements at
|
|
the same index.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.StartsWith``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
|
|
<summary>
|
|
Determines whether the beginning of the first sequence is
|
|
equivalent to the second sequence, using the specified element
|
|
equality comparer.
|
|
</summary>
|
|
<typeparam name="T">Type of elements.</typeparam>
|
|
<param name="first">The sequence to check.</param>
|
|
<param name="second">The sequence to compare to.</param>
|
|
<param name="comparer">Equality comparer to use.</param>
|
|
<returns>
|
|
<c>true</c> if <paramref name="first" /> begins with elements
|
|
equivalent to <paramref name="second" />.
|
|
</returns>
|
|
<remarks>
|
|
This is the <see cref="T:System.Collections.Generic.IEnumerable`1" /> equivalent of
|
|
<see cref="M:System.String.StartsWith(System.String)" /> and
|
|
it calls <see cref="M:System.Collections.Generic.IEqualityComparer`1.Equals(`0,`0)" /> on pairs
|
|
of elements at the same index.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Subsets``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Returns a sequence of <see cref="T:System.Collections.Generic.IList`1"/> representing all of
|
|
the subsets of any size that are part of the original sequence. In
|
|
mathematics, it is equivalent to the <em>power set</em> of a set.
|
|
</summary>
|
|
<remarks>
|
|
This operator produces all of the subsets of a given sequence. Subsets are returned
|
|
in increasing cardinality, starting with the empty set and terminating with the
|
|
entire original sequence.<br/>
|
|
Subsets are produced in a deferred, streaming manner; however, each subset is returned
|
|
as a materialized list.<br/>
|
|
There are 2^N subsets of a given sequence, where N => sequence.Count().
|
|
</remarks>
|
|
<param name="sequence">Sequence for which to produce subsets</param>
|
|
<typeparam name="T">The type of the elements in the sequence</typeparam>
|
|
<returns>A sequence of lists that represent the all subsets of the original sequence</returns>
|
|
<exception cref="T:System.ArgumentNullException">Thrown if <paramref name="sequence"/> is <see langword="null"/></exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Subsets``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Returns a sequence of <see cref="T:System.Collections.Generic.IList`1"/> representing all
|
|
subsets of a given size that are part of the original sequence. In
|
|
mathematics, it is equivalent to the <em>combinations</em> or
|
|
<em>k-subsets</em> of a set.
|
|
</summary>
|
|
<param name="sequence">Sequence for which to produce subsets</param>
|
|
<param name="subsetSize">The size of the subsets to produce</param>
|
|
<typeparam name="T">The type of the elements in the sequence</typeparam>
|
|
<returns>A sequence of lists that represents of K-sized subsets of the original sequence</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
Thrown if <paramref name="sequence"/> is <see langword="null"/>
|
|
</exception>
|
|
<exception cref="T:System.ArgumentOutOfRangeException">
|
|
Thrown if <paramref name="subsetSize"/> is less than zero.
|
|
</exception>
|
|
</member>
|
|
<member name="T:MoreLinq.MoreEnumerable.SubsetGenerator`1">
|
|
<summary>
|
|
This class is responsible for producing the lexographically ordered k-subsets
|
|
</summary>
|
|
</member>
|
|
<member name="T:MoreLinq.MoreEnumerable.SubsetGenerator`1.SubsetEnumerator">
|
|
<summary>
|
|
SubsetEnumerator uses a snapshot of the original sequence, and an
|
|
iterative, reductive swap algorithm to produce all subsets of a
|
|
predetermined size less than or equal to the original set size.
|
|
</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.SubsetGenerator`1.GetEnumerator">
|
|
<summary>
|
|
Returns an enumerator that produces all of the k-sized
|
|
subsets of the initial value set. The enumerator returns
|
|
and <see cref="T:System.Collections.Generic.IList`1"/> for each subset.
|
|
</summary>
|
|
<returns>an <see cref="T:System.Collections.IEnumerator"/> that enumerates all k-sized subsets</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.TagFirstLast``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean,System.Boolean,``1})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TResult">The type of the element of the returned sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="resultSelector">A function that determines how to
|
|
project the each element along with its first or last tag.</param>
|
|
<returns>
|
|
Returns the resulting sequence.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = new[] { 123, 456, 789 };
|
|
var result = numbers.TagFirstLast((num, fst, lst) => new
|
|
{
|
|
Number = num,
|
|
IsFirst = fst, IsLast = lst
|
|
});
|
|
]]></code>
|
|
The <c>result</c> variable, when iterated over, will yield
|
|
<c>{ Number = 123, IsFirst = True, IsLast = False }</c>,
|
|
<c>{ Number = 456, IsFirst = False, IsLast = False }</c> and
|
|
<c>{ Number = 789, IsFirst = False, IsLast = True }</c> in turn.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.TakeEvery``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Returns every N-th element of a sequence.
|
|
</summary>
|
|
<typeparam name="TSource">Type of the source sequence</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<param name="step">Number of elements to bypass before returning the next element.</param>
|
|
<returns>
|
|
A sequence with every N-th element of the input sequence.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
int[] numbers = { 1, 2, 3, 4, 5 };
|
|
var result = numbers.TakeEvery(2);
|
|
]]></code>
|
|
The <c>result</c> variable, when iterated over, will yield 1, 3 and 5, in turn.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.TakeLast``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Returns a specified number of contiguous elements from the end of
|
|
a sequence.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The sequence to return the last element of.</param>
|
|
<param name="count">The number of elements to return.</param>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that contains the specified number of
|
|
elements from the end of the input sequence.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
int[] numbers = { 12, 34, 56, 78 };
|
|
var result = numbers.TakeLast(2);
|
|
]]></code>
|
|
The <c>result</c> variable, when iterated over, will yield
|
|
56 and 78 in turn.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.TakeUntil``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
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.
|
|
</para>
|
|
<para>
|
|
Secondly, TakeUntil yields the element which causes the predicate to return true. For
|
|
example, in a sequence <code><![CDATA[{ 1, 2, 3, 4, 5 }]]></code> and with a predicate of
|
|
<code><![CDATA[x => x == 3]]></code>, the result would be <code><![CDATA[{ 1, 2, 3 }]]></code>.
|
|
</para>
|
|
<para>
|
|
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.)
|
|
</para>
|
|
</remarks>
|
|
<typeparam name="TSource">Type of the source sequence</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<param name="predicate">Predicate used to determine when to stop yielding results from the source.</param>
|
|
<returns>Items from the source sequence, until the predicate returns true when applied to the item.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is null</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToArrayByIndex``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32})">
|
|
<summary>
|
|
Creates an array from an <see cref="T:System.Collections.Generic.IEnumerable`1"/> where a
|
|
function is used to determine the index at which an element will
|
|
be placed in the array.
|
|
</summary>
|
|
<param name="source">The source sequence for the array.</param>
|
|
<param name="indexSelector">
|
|
A function that maps an element to its index.</param>
|
|
<typeparam name="T">
|
|
The type of the element in <paramref name="source"/>.</typeparam>
|
|
<returns>
|
|
An array that contains the elements from the input sequence. The
|
|
size of the array will be as large as the highest index returned
|
|
by the <paramref name="indexSelector"/> plus 1.
|
|
</returns>
|
|
<remarks>
|
|
This method forces immediate query evaluation. It should not be
|
|
used on infinite sequences. If more than one element maps to the
|
|
same index then the latter element overwrites the former in the
|
|
resulting array.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToArrayByIndex``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32},System.Func{``0,``1})">
|
|
<summary>
|
|
Creates an array from an <see cref="T:System.Collections.Generic.IEnumerable`1"/> 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.
|
|
</summary>
|
|
<param name="source">The source sequence for the array.</param>
|
|
<param name="indexSelector">
|
|
A function that maps an element to its index.</param>
|
|
<param name="resultSelector">
|
|
A function to project a source element into an element of the
|
|
resulting array.</param>
|
|
<typeparam name="T">
|
|
The type of the element in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the element in the resulting array.</typeparam>
|
|
<returns>
|
|
An array that contains the projected elements from the input
|
|
sequence. The size of the array will be as large as the highest
|
|
index returned by the <paramref name="indexSelector"/> plus 1.
|
|
</returns>
|
|
<remarks>
|
|
This method forces immediate query evaluation. It should not be
|
|
used on infinite sequences. If more than one element maps to the
|
|
same index then the latter element overwrites the former in the
|
|
resulting array.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToArrayByIndex``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32},System.Func{``0,System.Int32,``1})">
|
|
<summary>
|
|
Creates an array from an <see cref="T:System.Collections.Generic.IEnumerable`1"/> 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.
|
|
</summary>
|
|
<param name="source">The source sequence for the array.</param>
|
|
<param name="indexSelector">
|
|
A function that maps an element to its index.</param>
|
|
<param name="resultSelector">
|
|
A function to project a source element into an element of the
|
|
resulting array.</param>
|
|
<typeparam name="T">
|
|
The type of the element in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the element in the resulting array.</typeparam>
|
|
<returns>
|
|
An array that contains the projected elements from the input
|
|
sequence. The size of the array will be as large as the highest
|
|
index returned by the <paramref name="indexSelector"/> plus 1.
|
|
</returns>
|
|
<remarks>
|
|
This method forces immediate query evaluation. It should not be
|
|
used on infinite sequences. If more than one element maps to the
|
|
same index then the latter element overwrites the former in the
|
|
resulting array.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToArrayByIndex``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,System.Int32})">
|
|
<summary>
|
|
Creates an array of user-specified length from an
|
|
<see cref="T:System.Collections.Generic.IEnumerable`1"/> where a function is used to determine
|
|
the index at which an element will be placed in the array.
|
|
</summary>
|
|
<param name="source">The source sequence for the array.</param>
|
|
<param name="length">The (non-negative) length of the resulting array.</param>
|
|
<param name="indexSelector">
|
|
A function that maps an element to its index.</param>
|
|
<typeparam name="T">
|
|
The type of the element in <paramref name="source"/>.</typeparam>
|
|
<returns>
|
|
An array of size <paramref name="length"/> that contains the
|
|
elements from the input sequence.
|
|
</returns>
|
|
<remarks>
|
|
This method forces immediate query evaluation. It should not be
|
|
used on infinite sequences. If more than one element maps to the
|
|
same index then the latter element overwrites the former in the
|
|
resulting array.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToArrayByIndex``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,System.Int32},System.Func{``0,``1})">
|
|
<summary>
|
|
Creates an array of user-specified length from an
|
|
<see cref="T:System.Collections.Generic.IEnumerable`1"/> 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.
|
|
</summary>
|
|
<param name="source">The source sequence for the array.</param>
|
|
<param name="length">The (non-negative) length of the resulting array.</param>
|
|
<param name="indexSelector">
|
|
A function that maps an element to its index.</param>
|
|
<param name="resultSelector">
|
|
A function to project a source element into an element of the
|
|
resulting array.</param>
|
|
<typeparam name="T">
|
|
The type of the element in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the element in the resulting array.</typeparam>
|
|
<returns>
|
|
An array of size <paramref name="length"/> that contains the
|
|
projected elements from the input sequence.
|
|
</returns>
|
|
<remarks>
|
|
This method forces immediate query evaluation. It should not be
|
|
used on infinite sequences. If more than one element maps to the
|
|
same index then the latter element overwrites the former in the
|
|
resulting array.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToArrayByIndex``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,System.Int32},System.Func{``0,System.Int32,``1})">
|
|
<summary>
|
|
Creates an array of user-specified length from an
|
|
<see cref="T:System.Collections.Generic.IEnumerable`1"/> 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.
|
|
</summary>
|
|
<param name="source">The source sequence for the array.</param>
|
|
<param name="length">The (non-negative) length of the resulting array.</param>
|
|
<param name="indexSelector">
|
|
A function that maps an element to its index.</param>
|
|
<param name="resultSelector">
|
|
A function to project a source element into an element of the
|
|
resulting array.</param>
|
|
<typeparam name="T">
|
|
The type of the element in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the element in the resulting array.</typeparam>
|
|
<returns>
|
|
An array of size <paramref name="length"/> that contains the
|
|
projected elements from the input sequence.
|
|
</returns>
|
|
<remarks>
|
|
This method forces immediate query evaluation. It should not be
|
|
used on infinite sequences. If more than one element maps to the
|
|
same index then the latter element overwrites the former in the
|
|
resulting array.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToDataTable``2(System.Collections.Generic.IEnumerable{``0},``1)">
|
|
<summary>
|
|
Appends elements in the sequence as rows of a given <see cref="T:System.Data.DataTable"/> object.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TTable"></typeparam>
|
|
<param name="source">The source.</param>
|
|
<param name="table"></param>
|
|
<returns>
|
|
A <see cref="T:System.Data.DataTable"/> or subclass representing the source.
|
|
</returns>
|
|
<remarks>This operator uses immediate execution.</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToDataTable``1(System.Collections.Generic.IEnumerable{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Object}}[])">
|
|
<summary>
|
|
Appends elements in the sequence as rows of a given <see cref="T:System.Data.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.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The source.</param>
|
|
<param name="expressions">Expressions providing access to element members.</param>
|
|
<returns>
|
|
A <see cref="T:System.Data.DataTable"/> representing the source.
|
|
</returns>
|
|
<remarks>This operator uses immediate execution.</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToDataTable``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Converts a sequence to a <see cref="T:System.Data.DataTable"/> object.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The source.</param>
|
|
<returns>
|
|
A <see cref="T:System.Data.DataTable"/> representing the source.
|
|
</returns>
|
|
<remarks>This operator uses immediate execution.</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToDataTable``2(System.Collections.Generic.IEnumerable{``0},``1,System.Linq.Expressions.Expression{System.Func{``0,System.Object}}[])">
|
|
<summary>
|
|
Appends elements in the sequence as rows of a given <see cref="T:System.Data.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.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TTable">The type of the input and resulting <see cref="T:System.Data.DataTable"/> object.</typeparam>
|
|
<param name="source">The source.</param>
|
|
<param name="table">The <see cref="T:System.Data.DataTable"/> type of object where to add rows</param>
|
|
<param name="expressions">Expressions providing access to element members.</param>
|
|
<returns>
|
|
A <see cref="T:System.Data.DataTable"/> or subclass representing the source.
|
|
</returns>
|
|
<remarks>This operator uses immediate execution.</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.BuildOrBindSchema(System.Data.DataTable,System.Reflection.MemberInfo[])">
|
|
<remarks>
|
|
The resulting array may contain null entries and those represent
|
|
columns for which there is no source member supplying a value.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToDelimitedString``1(System.Collections.Generic.IEnumerable{``0},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence</typeparam>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Boolean},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Byte},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Char},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Decimal},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Double},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Single},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Int32},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Int64},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.SByte},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Int16},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.String},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.UInt32},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.UInt64},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.UInt16},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}})">
|
|
<summary>
|
|
Creates a <see cref="T:System.Collections.Generic.Dictionary`2" /> from a sequence of
|
|
<see cref="T:System.Collections.Generic.KeyValuePair`2" /> elements.
|
|
</summary>
|
|
<typeparam name="TKey">The type of the key.</typeparam>
|
|
<typeparam name="TValue">The type of the value.</typeparam>
|
|
<param name="source">The source sequence of key-value pairs.</param>
|
|
<returns>
|
|
A <see cref="T:System.Collections.Generic.Dictionary`2"/> containing the values
|
|
mapped to their keys.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}},System.Collections.Generic.IEqualityComparer{``0})">
|
|
<summary>
|
|
Creates a <see cref="T:System.Collections.Generic.Dictionary`2" /> from a sequence of
|
|
<see cref="T:System.Collections.Generic.KeyValuePair`2" /> elements. An additional
|
|
parameter specifies a comparer for keys.
|
|
</summary>
|
|
<typeparam name="TKey">The type of the key.</typeparam>
|
|
<typeparam name="TValue">The type of the value.</typeparam>
|
|
<param name="source">The source sequence of key-value pairs.</param>
|
|
<param name="comparer">The comparer for keys.</param>
|
|
<returns>
|
|
A <see cref="T:System.Collections.Generic.Dictionary`2"/> containing the values
|
|
mapped to their keys.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{System.ValueTuple{``0,``1}})">
|
|
<summary>
|
|
Creates a <see cref="T:System.Collections.Generic.Dictionary`2" /> from a sequence of
|
|
tuples of 2 where the first item is the key and the second the
|
|
value.
|
|
</summary>
|
|
<typeparam name="TKey">The type of the key.</typeparam>
|
|
<typeparam name="TValue">The type of the value.</typeparam>
|
|
<param name="source">The source sequence of couples (tuple of 2).</param>
|
|
<returns>
|
|
A <see cref="T:System.Collections.Generic.Dictionary`2"/> containing the values
|
|
mapped to their keys.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{System.ValueTuple{``0,``1}},System.Collections.Generic.IEqualityComparer{``0})">
|
|
<summary>
|
|
Creates a <see cref="T:System.Collections.Generic.Dictionary`2" /> 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.
|
|
</summary>
|
|
<typeparam name="TKey">The type of the key.</typeparam>
|
|
<typeparam name="TValue">The type of the value.</typeparam>
|
|
<param name="source">The source sequence of couples (tuple of 2).</param>
|
|
<param name="comparer">The comparer for keys.</param>
|
|
<returns>
|
|
A <see cref="T:System.Collections.Generic.Dictionary`2"/> containing the values
|
|
mapped to their keys.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToHashSet``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Returns a <see cref="T:System.Collections.Generic.HashSet`1"/> of the source items using the default equality
|
|
comparer for the type.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in source sequence.</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<returns>A hash set of the items in the sequence, using the default equality comparer.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<remarks>
|
|
This evaluates the input sequence completely.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToHashSet``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
|
|
<summary>
|
|
Returns a <see cref="T:System.Collections.Generic.HashSet`1"/> of the source items using the specified equality
|
|
comparer for the type.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in source sequence.</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<param name="comparer">Equality comparer to use; a value of null will cause the type's default equality comparer to be used</param>
|
|
<returns>A hash set of the items in the sequence, using the default equality comparer.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<remarks>
|
|
This evaluates the input sequence completely.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToLookup``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}})">
|
|
<summary>
|
|
Creates a <see cref="T:System.Linq.ILookup`2" /> from a sequence of
|
|
<see cref="T:System.Collections.Generic.KeyValuePair`2" /> elements.
|
|
</summary>
|
|
<typeparam name="TKey">The type of the key.</typeparam>
|
|
<typeparam name="TValue">The type of the value.</typeparam>
|
|
<param name="source">The source sequence of key-value pairs.</param>
|
|
<returns>
|
|
A <see cref="T:System.Linq.ILookup`2"/> containing the values
|
|
mapped to their keys.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToLookup``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}},System.Collections.Generic.IEqualityComparer{``0})">
|
|
<summary>
|
|
Creates a <see cref="T:System.Linq.ILookup`2" /> from a sequence of
|
|
<see cref="T:System.Collections.Generic.KeyValuePair`2" /> elements. An additional
|
|
parameter specifies a comparer for keys.
|
|
</summary>
|
|
<typeparam name="TKey">The type of the key.</typeparam>
|
|
<typeparam name="TValue">The type of the value.</typeparam>
|
|
<param name="source">The source sequence of key-value pairs.</param>
|
|
<param name="comparer">The comparer for keys.</param>
|
|
<returns>
|
|
A <see cref="T:System.Linq.ILookup`2"/> containing the values
|
|
mapped to their keys.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToLookup``2(System.Collections.Generic.IEnumerable{System.ValueTuple{``0,``1}})">
|
|
<summary>
|
|
Creates a <see cref="T:MoreLinq.Lookup`2" /> from a sequence of
|
|
tuples of 2 where the first item is the key and the second the
|
|
value.
|
|
</summary>
|
|
<typeparam name="TKey">The type of the key.</typeparam>
|
|
<typeparam name="TValue">The type of the value.</typeparam>
|
|
<param name="source">The source sequence of tuples of 2.</param>
|
|
<returns>
|
|
A <see cref="T:MoreLinq.Lookup`2"/> containing the values
|
|
mapped to their keys.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ToLookup``2(System.Collections.Generic.IEnumerable{System.ValueTuple{``0,``1}},System.Collections.Generic.IEqualityComparer{``0})">
|
|
<summary>
|
|
Creates a <see cref="T:MoreLinq.Lookup`2" /> 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.
|
|
</summary>
|
|
<typeparam name="TKey">The type of the key.</typeparam>
|
|
<typeparam name="TValue">The type of the value.</typeparam>
|
|
<param name="source">The source sequence of tuples of 2.</param>
|
|
<param name="comparer">The comparer for keys.</param>
|
|
<returns>
|
|
A <see cref="T:MoreLinq.Lookup`2"/> containing the values
|
|
mapped to their keys.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Trace``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Traces the elements of a source sequence for diagnostics.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence</typeparam>
|
|
<param name="source">Source sequence whose elements to trace.</param>
|
|
<returns>
|
|
Return the source sequence unmodified.
|
|
</returns>
|
|
<remarks>
|
|
This a pass-through operator that uses deferred execution and
|
|
streams the results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Trace``1(System.Collections.Generic.IEnumerable{``0},System.String)">
|
|
<summary>
|
|
Traces the elements of a source sequence for diagnostics using
|
|
custom formatting.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence</typeparam>
|
|
<param name="source">Source sequence whose elements to trace.</param>
|
|
<param name="format">
|
|
String to use to format the trace message. If null then the
|
|
element value becomes the traced message.
|
|
</param>
|
|
<returns>
|
|
Return the source sequence unmodified.
|
|
</returns>
|
|
<remarks>
|
|
This a pass-through operator that uses deferred execution and
|
|
streams the results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Trace``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.String})">
|
|
<summary>
|
|
Traces the elements of a source sequence for diagnostics using
|
|
a custom formatter.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence</typeparam>
|
|
<param name="source">Source sequence whose elements to trace.</param>
|
|
<param name="formatter">Function used to format each source element into a string.</param>
|
|
<returns>
|
|
Return the source sequence unmodified.
|
|
</returns>
|
|
<remarks>
|
|
This a pass-through operator that uses deferred execution and
|
|
streams the results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Transpose``1(System.Collections.Generic.IEnumerable{System.Collections.Generic.IEnumerable{``0}})">
|
|
<summary>
|
|
Transposes a sequence of rows into a sequence of columns.
|
|
</summary>
|
|
<typeparam name="T">Type of source sequence elements.</typeparam>
|
|
<param name="source">Source sequence to transpose.</param>
|
|
<returns>
|
|
Returns a sequence of columns in the source swapped into rows.
|
|
</returns>
|
|
<remarks>
|
|
If a rows is shorter than a follow it then the shorter row's
|
|
elements are skipped in the corresponding column sequences.
|
|
This operator uses deferred execution and streams its results.
|
|
Source sequence is consumed greedily when an iteration begins.
|
|
The inner sequences representing rows are consumed lazily and
|
|
resulting sequences of columns are streamed.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
var matrix = new[]
|
|
{
|
|
new[] { 10, 11 },
|
|
new[] { 20 },
|
|
new[] { 30, 31, 32 }
|
|
};
|
|
var result = matrix.Transpose();
|
|
]]></code>
|
|
The <c>result</c> variable will contain [[10, 20, 30], [11, 31], [32]].
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.TraverseBreadthFirst``1(``0,System.Func{``0,System.Collections.Generic.IEnumerable{``0}})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="T">The tree node type</typeparam>
|
|
<param name="root">The root of the tree to traverse.</param>
|
|
<param name="childrenSelector">
|
|
The function that produces the children of each element.</param>
|
|
<returns>A sequence containing the traversed values.</returns>
|
|
<remarks>
|
|
<para>
|
|
The tree is not checked for loops. If the resulting sequence needs
|
|
to be finite then it is the responsibility of
|
|
<paramref name="childrenSelector"/> to ensure that loops are not
|
|
produced.</para>
|
|
<para>
|
|
This function defers traversal until needed and streams the
|
|
results.</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.TraverseDepthFirst``1(``0,System.Func{``0,System.Collections.Generic.IEnumerable{``0}})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="T">The tree node type.</typeparam>
|
|
<param name="root">The root of the tree to traverse.</param>
|
|
<param name="childrenSelector">
|
|
The function that produces the children of each element.</param>
|
|
<returns>A sequence containing the traversed values.</returns>
|
|
<remarks>
|
|
<para>
|
|
The tree is not checked for loops. If the resulting sequence needs
|
|
to be finite then it is the responsibility of
|
|
<paramref name="childrenSelector"/> to ensure that loops are not
|
|
produced.</para>
|
|
<para>
|
|
This function defers traversal until needed and streams the
|
|
results.</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Unfold``3(``0,System.Func{``0,``1},System.Func{``1,System.Boolean},System.Func{``1,``0},System.Func{``1,``2})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TState">Type of state elements.</typeparam>
|
|
<typeparam name="T">Type of the elements generated by the generator function.</typeparam>
|
|
<typeparam name="TResult">The type of the elements of the result sequence.</typeparam>
|
|
<param name="state">The initial state.</param>
|
|
<param name="generator">
|
|
Function that takes a state and computes the next state and the next element of the sequence.
|
|
</param>
|
|
<param name="predicate">
|
|
Function to determine if the unfolding should continue based the
|
|
result of the <paramref name="generator"/> function.
|
|
</param>
|
|
<param name="stateSelector">
|
|
Function to select the state from the output of the <paramref name="generator"/> function.
|
|
</param>
|
|
<param name="resultSelector">
|
|
Function to select the result from the output of the <paramref name="generator"/> function.
|
|
</param>
|
|
<returns>A sequence containing the results generated by the <paramref name="resultSelector"/> function.</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Window``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Processes a sequence into a series of subsequences representing a windowed subset of the original
|
|
</summary>
|
|
<remarks>
|
|
The number of sequences returned is: <c>Max(0, sequence.Count() - windowSize) + 1</c><br/>
|
|
Returned subsequences are buffered, but the overall operation is streamed.<br/>
|
|
</remarks>
|
|
<typeparam name="TSource">The type of the elements of the source sequence</typeparam>
|
|
<param name="source">The sequence to evaluate a sliding window over</param>
|
|
<param name="size">The size (number of elements) in each window</param>
|
|
<returns>A series of sequences representing each sliding window subsequence</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.Windowed``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Processes a sequence into a series of subsequences representing a windowed subset of the original
|
|
</summary>
|
|
<remarks>
|
|
The number of sequences returned is: <c>Max(0, sequence.Count() - windowSize) + 1</c><br/>
|
|
Returned subsequences are buffered, but the overall operation is streamed.<br/>
|
|
</remarks>
|
|
<typeparam name="TSource">The type of the elements of the source sequence</typeparam>
|
|
<param name="source">The sequence to evaluate a sliding window over</param>
|
|
<param name="size">The size (number of elements) in each window</param>
|
|
<returns>A series of sequences representing each sliding window subsequence</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.WindowLeft``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Creates a left-aligned sliding window of a given size over the
|
|
source sequence.
|
|
</summary>
|
|
<typeparam name="TSource">
|
|
The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">
|
|
The sequence over which to create the sliding window.</param>
|
|
<param name="size">Size of the sliding window.</param>
|
|
<returns>A sequence representing each sliding window.</returns>
|
|
<remarks>
|
|
<para>
|
|
A window can contain fewer elements than <paramref name="size"/>,
|
|
especially as it slides over the end of the sequence.</para>
|
|
<para>
|
|
This operator uses deferred execution and streams its results.</para>
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
Console.WriteLine(
|
|
Enumerable
|
|
.Range(1, 5)
|
|
.WindowLeft(3)
|
|
.Select(w => "AVG(" + w.ToDelimitedString(",") + ") = " + w.Average())
|
|
.ToDelimitedString(Environment.NewLine));
|
|
|
|
// Output:
|
|
// AVG(1,2,3) = 2
|
|
// AVG(2,3,4) = 3
|
|
// AVG(3,4,5) = 4
|
|
// AVG(4,5) = 4.5
|
|
// AVG(5) = 5
|
|
]]></code>
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.WindowRight``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Creates a right-aligned sliding window over the source sequence
|
|
of a given size.
|
|
</summary>
|
|
<typeparam name="TSource">
|
|
The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">
|
|
The sequence over which to create the sliding window.</param>
|
|
<param name="size">Size of the sliding window.</param>
|
|
<returns>A sequence representing each sliding window.</returns>
|
|
<remarks>
|
|
<para>
|
|
A window can contain fewer elements than <paramref name="size"/>,
|
|
especially as it slides over the start of the sequence.</para>
|
|
<para>
|
|
This operator uses deferred execution and streams its results.</para>
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
Console.WriteLine(
|
|
Enumerable
|
|
.Range(1, 5)
|
|
.WindowRight(3)
|
|
.Select(w => "AVG(" + w.ToDelimitedString(",") + ") = " + w.Average())
|
|
.ToDelimitedString(Environment.NewLine));
|
|
|
|
// Output:
|
|
// AVG(1) = 1
|
|
// AVG(1,2) = 1.5
|
|
// AVG(1,2,3) = 2
|
|
// AVG(2,3,4) = 3
|
|
// AVG(3,4,5) = 4
|
|
]]></code>
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.WindowRightWhile``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32,System.Boolean})">
|
|
<summary>
|
|
Creates a right-aligned sliding window over the source sequence
|
|
with a predicate function determining the window range.
|
|
</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ZipLongest``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
|
|
<summary>
|
|
Returns a projection of tuples, where each tuple contains the N-th
|
|
element from each of the argument sequences. The resulting sequence
|
|
will always be as long as the longest of input sequences where the
|
|
default value of each of the shorter sequence element types is used
|
|
for padding.
|
|
</summary>
|
|
<typeparam name="TFirst">Type of elements in first sequence.</typeparam>
|
|
<typeparam name="TSecond">Type of elements in second sequence.</typeparam>
|
|
<typeparam name="TResult">Type of elements in result sequence.</typeparam>
|
|
<param name="first">The first sequence.</param>
|
|
<param name="second">The second sequence.</param>
|
|
<param name="resultSelector">
|
|
Function to apply to each pair of elements.</param>
|
|
<returns>
|
|
A sequence that contains elements of the two input sequences,
|
|
combined by <paramref name="resultSelector"/>.
|
|
</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = { 1, 2, 3 };
|
|
var letters = { "A", "B", "C", "D" };
|
|
var zipped = numbers.ZipLongest(letters, (n, l) => n + l);
|
|
]]></code>
|
|
The <c>zipped</c> variable, when iterated over, will yield "1A",
|
|
"2B", "3C", "0D" in turn.
|
|
</example>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ZipLongest``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
|
|
<summary>
|
|
Returns a projection of tuples, where each tuple contains the N-th
|
|
element from each of the argument sequences. The resulting sequence
|
|
will always be as long as the longest of input sequences where the
|
|
default value of each of the shorter sequence element types is used
|
|
for padding.
|
|
</summary>
|
|
<typeparam name="T1">Type of elements in first sequence.</typeparam>
|
|
<typeparam name="T2">Type of elements in second sequence.</typeparam>
|
|
<typeparam name="T3">Type of elements in third sequence.</typeparam>
|
|
<typeparam name="TResult">Type of elements in result sequence.</typeparam>
|
|
<param name="first">The first sequence.</param>
|
|
<param name="second">The second sequence.</param>
|
|
<param name="third">The third sequence.</param>
|
|
<param name="resultSelector">
|
|
Function to apply to each triplet of elements.</param>
|
|
<returns>
|
|
A sequence that contains elements of the three input sequences,
|
|
combined by <paramref name="resultSelector"/>.
|
|
</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = new[] { 1, 2, 3 };
|
|
var letters = new[] { "A", "B", "C", "D" };
|
|
var chars = new[] { 'a', 'b', 'c', 'd', 'e' };
|
|
var zipped = numbers.ZipLongest(letters, chars, (n, l, c) => n + l + c);
|
|
]]></code>
|
|
The <c>zipped</c> variable, when iterated over, will yield "1Aa",
|
|
"2Bb", "3Cc", "0Dd", "0e" in turn.
|
|
</example>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ZipLongest``5(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Func{``0,``1,``2,``3,``4})">
|
|
<summary>
|
|
Returns a projection of tuples, where each tuple contains the N-th
|
|
element from each of the argument sequences. The resulting sequence
|
|
will always be as long as the longest of input sequences where the
|
|
default value of each of the shorter sequence element types is used
|
|
for padding.
|
|
</summary>
|
|
<typeparam name="T1">Type of elements in first sequence</typeparam>
|
|
<typeparam name="T2">Type of elements in second sequence</typeparam>
|
|
<typeparam name="T3">Type of elements in third sequence</typeparam>
|
|
<typeparam name="T4">Type of elements in fourth sequence</typeparam>
|
|
<typeparam name="TResult">Type of elements in result sequence</typeparam>
|
|
<param name="first">The first sequence.</param>
|
|
<param name="second">The second sequence.</param>
|
|
<param name="third">The third sequence.</param>
|
|
<param name="fourth">The fourth sequence.</param>
|
|
<param name="resultSelector">
|
|
Function to apply to each quadruplet of elements.</param>
|
|
<returns>
|
|
A sequence that contains elements of the four input sequences,
|
|
combined by <paramref name="resultSelector"/>.
|
|
</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var 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, true, false, true, false };
|
|
var zipped = numbers.ZipLongest(letters, chars, flags, (n, l, c, f) => n + l + c + f);
|
|
]]></code>
|
|
The <c>zipped</c> variable, when iterated over, will yield "1AaTrue",
|
|
"2BbFalse", "3CcTrue", "0DdFalse", "0eTrue", "0\0False" in turn.
|
|
</example>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ZipShortest``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
|
|
<summary>
|
|
Returns a projection of tuples, where each tuple contains the N-th
|
|
element from each of the argument sequences. The resulting sequence
|
|
is as short as the shortest input sequence.
|
|
</summary>
|
|
<typeparam name="TFirst">Type of elements in first sequence.</typeparam>
|
|
<typeparam name="TSecond">Type of elements in second sequence.</typeparam>
|
|
<typeparam name="TResult">Type of elements in result sequence.</typeparam>
|
|
<param name="first">The first sequence.</param>
|
|
<param name="second">The second sequence.</param>
|
|
<param name="resultSelector">
|
|
Function to apply to each pair of elements.</param>
|
|
<returns>
|
|
A projection of tuples, where each tuple contains the N-th element
|
|
from each of the argument sequences.</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = new[] { 1, 2, 3 };
|
|
var letters = new[] { "A", "B", "C", "D" };
|
|
var zipped = numbers.ZipShortest(letters, (n, l) => n + l);
|
|
]]></code>
|
|
The <c>zipped</c> variable, when iterated over, will yield "1A", "2B", "3C", in turn.
|
|
</example>
|
|
<remarks>
|
|
<para>
|
|
If the input sequences are of different lengths, the result sequence
|
|
is terminated as soon as the shortest input sequence is exhausted
|
|
and remainder elements from the longer sequences are never consumed.
|
|
</para>
|
|
<para>
|
|
This operator uses deferred execution and streams its results.</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ZipShortest``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
|
|
<summary>
|
|
Returns a projection of tuples, where each tuple contains the N-th
|
|
element from each of the argument sequences. The resulting sequence
|
|
is as short as the shortest input sequence.
|
|
</summary>
|
|
<typeparam name="T1">Type of elements in first sequence.</typeparam>
|
|
<typeparam name="T2">Type of elements in second sequence.</typeparam>
|
|
<typeparam name="T3">Type of elements in third sequence.</typeparam>
|
|
<typeparam name="TResult">Type of elements in result sequence.</typeparam>
|
|
<param name="first">First sequence</param>
|
|
<param name="second">Second sequence</param>
|
|
<param name="third">Third sequence</param>
|
|
<param name="resultSelector">
|
|
Function to apply to each triplet of elements.</param>
|
|
<returns>
|
|
A projection of tuples, where each tuple contains the N-th element
|
|
from each of the argument sequences.</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var 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);
|
|
]]></code>
|
|
The <c>zipped</c> variable, when iterated over, will yield
|
|
"98A", "100B", "102C", in turn.
|
|
</example>
|
|
<remarks>
|
|
<para>
|
|
If the input sequences are of different lengths, the result sequence
|
|
is terminated as soon as the shortest input sequence is exhausted
|
|
and remainder elements from the longer sequences are never consumed.
|
|
</para>
|
|
<para>
|
|
This operator uses deferred execution and streams its results.</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.MoreEnumerable.ZipShortest``5(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Func{``0,``1,``2,``3,``4})">
|
|
<summary>
|
|
Returns a projection of tuples, where each tuple contains the N-th
|
|
element from each of the argument sequences. The resulting sequence
|
|
is as short as the shortest input sequence.
|
|
</summary>
|
|
<typeparam name="T1">Type of elements in first sequence.</typeparam>
|
|
<typeparam name="T2">Type of elements in second sequence.</typeparam>
|
|
<typeparam name="T3">Type of elements in third sequence.</typeparam>
|
|
<typeparam name="T4">Type of elements in fourth sequence.</typeparam>
|
|
<typeparam name="TResult">Type of elements in result sequence.</typeparam>
|
|
<param name="first">The first sequence.</param>
|
|
<param name="second">The second sequence.</param>
|
|
<param name="third">The third sequence.</param>
|
|
<param name="fourth">The fourth sequence.</param>
|
|
<param name="resultSelector">
|
|
Function to apply to each quadruplet of elements.</param>
|
|
<returns>
|
|
A projection of tuples, where each tuple contains the N-th element
|
|
from each of the argument sequences.</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var 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);
|
|
]]></code>
|
|
The <c>zipped</c> variable, when iterated over, will yield
|
|
"1AaTrue", "2BbFalse" in turn.
|
|
</example>
|
|
<remarks>
|
|
<para>
|
|
If the input sequences are of different lengths, the result sequence
|
|
is terminated as soon as the shortest input sequence is exhausted
|
|
and remainder elements from the longer sequences are never consumed.
|
|
</para>
|
|
<para>
|
|
This operator uses deferred execution and streams its results.</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Experimental.ExperimentalEnumerable">
|
|
<summary>
|
|
<para>
|
|
Provides a set of static methods for querying objects that
|
|
implement <see cref="T:System.Collections.Generic.IEnumerable`1" />.</para>
|
|
<para>
|
|
<strong>THE METHODS ARE EXPERIMENTAL. THEY MAY BE UNSTABLE AND
|
|
UNTESTED. THEY MAY BE REMOVED FROM A FUTURE MAJOR OR MINOR RELEASE AND
|
|
POSSIBLY WITHOUT NOTICE. USE THEM AT YOUR OWN RISK. THE METHODS ARE
|
|
PUBLISHED FOR FIELD EXPERIMENTATION TO SOLICIT FEEDBACK ON THEIR
|
|
UTILITY AND DESIGN/IMPLEMENTATION DEFECTS.</strong></para>
|
|
</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``4(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{``1,``2,``3})">
|
|
<summary>
|
|
Applies two accumulator queries sequentially in a single
|
|
pass over a sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
|
|
<typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
|
|
<typeparam name="TResult">The type of the accumulated result.</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="accumulator1">The first accumulator.</param>
|
|
<param name="accumulator2">The second accumulator.</param>
|
|
<param name="resultSelector">
|
|
A function that projects a single result given the result of each
|
|
accumulator.</param>
|
|
<returns>The value returned by <paramref name="resultSelector"/>.</returns>
|
|
<exception cref="T:System.InvalidOperationException">
|
|
An <see cref="T:System.IObservable`1"/> returned by an accumulator function
|
|
produced zero or more than a single aggregate result.
|
|
</exception>
|
|
<remarks>
|
|
<para>This operator executes immediately.</para>
|
|
<para>
|
|
Each accumulator argument is a function that receives an
|
|
<see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
|
|
items in the <paramref name="source"/> sequence and in original
|
|
order; the function must then return an <see cref="T:System.IObservable`1"/>
|
|
that produces a single aggregate on completion (when
|
|
<see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
|
|
at run-time if the <see cref="T:System.IObserver`1"/> returned by an
|
|
accumulator function produces no result or produces more than a
|
|
single result.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``5(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{System.IObservable{``0},System.IObservable{``3}},System.Func{``1,``2,``3,``4})">
|
|
<summary>
|
|
Applies three accumulator queries sequentially in a single
|
|
pass over a sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
|
|
<typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
|
|
<typeparam name="TResult3">The type of the result of the third accumulator.</typeparam>
|
|
<typeparam name="TResult">The type of the accumulated result.</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="accumulator1">The first accumulator.</param>
|
|
<param name="accumulator2">The second accumulator.</param>
|
|
<param name="accumulator3">The third accumulator.</param>
|
|
<param name="resultSelector">
|
|
A function that projects a single result given the result of each
|
|
accumulator.</param>
|
|
<returns>The value returned by <paramref name="resultSelector"/>.</returns>
|
|
<exception cref="T:System.InvalidOperationException">
|
|
An <see cref="T:System.IObservable`1"/> returned by an accumulator function
|
|
produced zero or more than a single aggregate result.
|
|
</exception>
|
|
<remarks>
|
|
<para>This operator executes immediately.</para>
|
|
<para>
|
|
Each accumulator argument is a function that receives an
|
|
<see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
|
|
items in the <paramref name="source"/> sequence and in original
|
|
order; the function must then return an <see cref="T:System.IObservable`1"/>
|
|
that produces a single aggregate on completion (when
|
|
<see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
|
|
at run-time if the <see cref="T:System.IObserver`1"/> returned by an
|
|
accumulator function produces no result or produces more than a
|
|
single result.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``6(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{System.IObservable{``0},System.IObservable{``3}},System.Func{System.IObservable{``0},System.IObservable{``4}},System.Func{``1,``2,``3,``4,``5})">
|
|
<summary>
|
|
Applies four accumulator queries sequentially in a single
|
|
pass over a sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
|
|
<typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
|
|
<typeparam name="TResult3">The type of the result of the third accumulator.</typeparam>
|
|
<typeparam name="TResult4">The type of the result of the fourth accumulator.</typeparam>
|
|
<typeparam name="TResult">The type of the accumulated result.</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="accumulator1">The first accumulator.</param>
|
|
<param name="accumulator2">The second accumulator.</param>
|
|
<param name="accumulator3">The third accumulator.</param>
|
|
<param name="accumulator4">The fourth accumulator.</param>
|
|
<param name="resultSelector">
|
|
A function that projects a single result given the result of each
|
|
accumulator.</param>
|
|
<returns>The value returned by <paramref name="resultSelector"/>.</returns>
|
|
<exception cref="T:System.InvalidOperationException">
|
|
An <see cref="T:System.IObservable`1"/> returned by an accumulator function
|
|
produced zero or more than a single aggregate result.
|
|
</exception>
|
|
<remarks>
|
|
<para>This operator executes immediately.</para>
|
|
<para>
|
|
Each accumulator argument is a function that receives an
|
|
<see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
|
|
items in the <paramref name="source"/> sequence and in original
|
|
order; the function must then return an <see cref="T:System.IObservable`1"/>
|
|
that produces a single aggregate on completion (when
|
|
<see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
|
|
at run-time if the <see cref="T:System.IObserver`1"/> returned by an
|
|
accumulator function produces no result or produces more than a
|
|
single result.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``7(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{System.IObservable{``0},System.IObservable{``3}},System.Func{System.IObservable{``0},System.IObservable{``4}},System.Func{System.IObservable{``0},System.IObservable{``5}},System.Func{``1,``2,``3,``4,``5,``6})">
|
|
<summary>
|
|
Applies five accumulator queries sequentially in a single
|
|
pass over a sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
|
|
<typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
|
|
<typeparam name="TResult3">The type of the result of the third accumulator.</typeparam>
|
|
<typeparam name="TResult4">The type of the result of the fourth accumulator.</typeparam>
|
|
<typeparam name="TResult5">The type of the result of the fifth accumulator.</typeparam>
|
|
<typeparam name="TResult">The type of the accumulated result.</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="accumulator1">The first accumulator.</param>
|
|
<param name="accumulator2">The second accumulator.</param>
|
|
<param name="accumulator3">The third accumulator.</param>
|
|
<param name="accumulator4">The fourth accumulator.</param>
|
|
<param name="accumulator5">The fifth accumulator.</param>
|
|
<param name="resultSelector">
|
|
A function that projects a single result given the result of each
|
|
accumulator.</param>
|
|
<returns>The value returned by <paramref name="resultSelector"/>.</returns>
|
|
<exception cref="T:System.InvalidOperationException">
|
|
An <see cref="T:System.IObservable`1"/> returned by an accumulator function
|
|
produced zero or more than a single aggregate result.
|
|
</exception>
|
|
<remarks>
|
|
<para>This operator executes immediately.</para>
|
|
<para>
|
|
Each accumulator argument is a function that receives an
|
|
<see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
|
|
items in the <paramref name="source"/> sequence and in original
|
|
order; the function must then return an <see cref="T:System.IObservable`1"/>
|
|
that produces a single aggregate on completion (when
|
|
<see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
|
|
at run-time if the <see cref="T:System.IObserver`1"/> returned by an
|
|
accumulator function produces no result or produces more than a
|
|
single result.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``8(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{System.IObservable{``0},System.IObservable{``3}},System.Func{System.IObservable{``0},System.IObservable{``4}},System.Func{System.IObservable{``0},System.IObservable{``5}},System.Func{System.IObservable{``0},System.IObservable{``6}},System.Func{``1,``2,``3,``4,``5,``6,``7})">
|
|
<summary>
|
|
Applies six accumulator queries sequentially in a single
|
|
pass over a sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
|
|
<typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
|
|
<typeparam name="TResult3">The type of the result of the third accumulator.</typeparam>
|
|
<typeparam name="TResult4">The type of the result of the fourth accumulator.</typeparam>
|
|
<typeparam name="TResult5">The type of the result of the fifth accumulator.</typeparam>
|
|
<typeparam name="TResult6">The type of the result of the sixth accumulator.</typeparam>
|
|
<typeparam name="TResult">The type of the accumulated result.</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="accumulator1">The first accumulator.</param>
|
|
<param name="accumulator2">The second accumulator.</param>
|
|
<param name="accumulator3">The third accumulator.</param>
|
|
<param name="accumulator4">The fourth accumulator.</param>
|
|
<param name="accumulator5">The fifth accumulator.</param>
|
|
<param name="accumulator6">The sixth accumulator.</param>
|
|
<param name="resultSelector">
|
|
A function that projects a single result given the result of each
|
|
accumulator.</param>
|
|
<returns>The value returned by <paramref name="resultSelector"/>.</returns>
|
|
<exception cref="T:System.InvalidOperationException">
|
|
An <see cref="T:System.IObservable`1"/> returned by an accumulator function
|
|
produced zero or more than a single aggregate result.
|
|
</exception>
|
|
<remarks>
|
|
<para>This operator executes immediately.</para>
|
|
<para>
|
|
Each accumulator argument is a function that receives an
|
|
<see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
|
|
items in the <paramref name="source"/> sequence and in original
|
|
order; the function must then return an <see cref="T:System.IObservable`1"/>
|
|
that produces a single aggregate on completion (when
|
|
<see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
|
|
at run-time if the <see cref="T:System.IObserver`1"/> returned by an
|
|
accumulator function produces no result or produces more than a
|
|
single result.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``9(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{System.IObservable{``0},System.IObservable{``3}},System.Func{System.IObservable{``0},System.IObservable{``4}},System.Func{System.IObservable{``0},System.IObservable{``5}},System.Func{System.IObservable{``0},System.IObservable{``6}},System.Func{System.IObservable{``0},System.IObservable{``7}},System.Func{``1,``2,``3,``4,``5,``6,``7,``8})">
|
|
<summary>
|
|
Applies seven accumulator queries sequentially in a single
|
|
pass over a sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
|
|
<typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
|
|
<typeparam name="TResult3">The type of the result of the third accumulator.</typeparam>
|
|
<typeparam name="TResult4">The type of the result of the fourth accumulator.</typeparam>
|
|
<typeparam name="TResult5">The type of the result of the fifth accumulator.</typeparam>
|
|
<typeparam name="TResult6">The type of the result of the sixth accumulator.</typeparam>
|
|
<typeparam name="TResult7">The type of the result of the seventh accumulator.</typeparam>
|
|
<typeparam name="TResult">The type of the accumulated result.</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="accumulator1">The first accumulator.</param>
|
|
<param name="accumulator2">The second accumulator.</param>
|
|
<param name="accumulator3">The third accumulator.</param>
|
|
<param name="accumulator4">The fourth accumulator.</param>
|
|
<param name="accumulator5">The fifth accumulator.</param>
|
|
<param name="accumulator6">The sixth accumulator.</param>
|
|
<param name="accumulator7">The seventh accumulator.</param>
|
|
<param name="resultSelector">
|
|
A function that projects a single result given the result of each
|
|
accumulator.</param>
|
|
<returns>The value returned by <paramref name="resultSelector"/>.</returns>
|
|
<exception cref="T:System.InvalidOperationException">
|
|
An <see cref="T:System.IObservable`1"/> returned by an accumulator function
|
|
produced zero or more than a single aggregate result.
|
|
</exception>
|
|
<remarks>
|
|
<para>This operator executes immediately.</para>
|
|
<para>
|
|
Each accumulator argument is a function that receives an
|
|
<see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
|
|
items in the <paramref name="source"/> sequence and in original
|
|
order; the function must then return an <see cref="T:System.IObservable`1"/>
|
|
that produces a single aggregate on completion (when
|
|
<see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
|
|
at run-time if the <see cref="T:System.IObserver`1"/> returned by an
|
|
accumulator function produces no result or produces more than a
|
|
single result.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``10(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{System.IObservable{``0},System.IObservable{``3}},System.Func{System.IObservable{``0},System.IObservable{``4}},System.Func{System.IObservable{``0},System.IObservable{``5}},System.Func{System.IObservable{``0},System.IObservable{``6}},System.Func{System.IObservable{``0},System.IObservable{``7}},System.Func{System.IObservable{``0},System.IObservable{``8}},System.Func{``1,``2,``3,``4,``5,``6,``7,``8,``9})">
|
|
<summary>
|
|
Applies eight accumulator queries sequentially in a single
|
|
pass over a sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
|
|
<typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
|
|
<typeparam name="TResult3">The type of the result of the third accumulator.</typeparam>
|
|
<typeparam name="TResult4">The type of the result of the fourth accumulator.</typeparam>
|
|
<typeparam name="TResult5">The type of the result of the fifth accumulator.</typeparam>
|
|
<typeparam name="TResult6">The type of the result of the sixth accumulator.</typeparam>
|
|
<typeparam name="TResult7">The type of the result of the seventh accumulator.</typeparam>
|
|
<typeparam name="TResult8">The type of the result of the eighth accumulator.</typeparam>
|
|
<typeparam name="TResult">The type of the accumulated result.</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="accumulator1">The first accumulator.</param>
|
|
<param name="accumulator2">The second accumulator.</param>
|
|
<param name="accumulator3">The third accumulator.</param>
|
|
<param name="accumulator4">The fourth accumulator.</param>
|
|
<param name="accumulator5">The fifth accumulator.</param>
|
|
<param name="accumulator6">The sixth accumulator.</param>
|
|
<param name="accumulator7">The seventh accumulator.</param>
|
|
<param name="accumulator8">The eighth accumulator.</param>
|
|
<param name="resultSelector">
|
|
A function that projects a single result given the result of each
|
|
accumulator.</param>
|
|
<returns>The value returned by <paramref name="resultSelector"/>.</returns>
|
|
<exception cref="T:System.InvalidOperationException">
|
|
An <see cref="T:System.IObservable`1"/> returned by an accumulator function
|
|
produced zero or more than a single aggregate result.
|
|
</exception>
|
|
<remarks>
|
|
<para>This operator executes immediately.</para>
|
|
<para>
|
|
Each accumulator argument is a function that receives an
|
|
<see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
|
|
items in the <paramref name="source"/> sequence and in original
|
|
order; the function must then return an <see cref="T:System.IObservable`1"/>
|
|
that produces a single aggregate on completion (when
|
|
<see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
|
|
at run-time if the <see cref="T:System.IObserver`1"/> returned by an
|
|
accumulator function produces no result or produces more than a
|
|
single result.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Experimental.ExperimentalEnumerable.AsSequential``1(MoreLinq.Experimental.IAwaitQuery{``0})">
|
|
<summary>
|
|
Converts a query whose results evaluate asynchronously to use
|
|
sequential instead of concurrent evaluation.
|
|
</summary>
|
|
<typeparam name="T">The type of the source elements.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<returns>The converted sequence.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Experimental.ExperimentalEnumerable.MaxConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0},System.Int32)">
|
|
<summary>
|
|
Returns a query whose results evaluate asynchronously to use a
|
|
concurrency limit.
|
|
</summary>
|
|
<typeparam name="T">The type of the source elements.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="value"></param>
|
|
<returns>
|
|
A query whose results evaluate asynchronously using the given
|
|
concurrency limit.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Experimental.ExperimentalEnumerable.UnboundedConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0})">
|
|
<summary>
|
|
Returns a query whose results evaluate asynchronously and
|
|
concurrently with no defined limitation on concurrency.
|
|
</summary>
|
|
<typeparam name="T">The type of the source elements.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<returns>
|
|
A query whose results evaluate asynchronously using no defined
|
|
limitation on concurrency.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Scheduler``1(MoreLinq.Experimental.IAwaitQuery{``0},System.Threading.Tasks.TaskScheduler)">
|
|
<summary>
|
|
Returns a query whose results evaluate asynchronously and uses the
|
|
given scheduler for the workhorse task.
|
|
</summary>
|
|
<typeparam name="T">The type of the source elements.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="value">The scheduler to use.</param>
|
|
<returns>
|
|
A query whose results evaluate asynchronously and uses the
|
|
given scheduler for the workhorse task.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered``1(MoreLinq.Experimental.IAwaitQuery{``0})">
|
|
<summary>
|
|
Returns a query whose results evaluate asynchronously but which
|
|
are returned in the order of the source.
|
|
</summary>
|
|
<typeparam name="T">The type of the source elements.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<returns>
|
|
A query whose results evaluate asynchronously but which
|
|
are returned in the order of the source.</returns>
|
|
<remarks>
|
|
Internally, the asynchronous operations will be done concurrently
|
|
but the results will be yielded in order.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Experimental.ExperimentalEnumerable.AsUnordered``1(MoreLinq.Experimental.IAwaitQuery{``0})">
|
|
<summary>
|
|
Returns a query whose results evaluate asynchronously but which
|
|
are returned without guarantee of the source order.
|
|
</summary>
|
|
<typeparam name="T">The type of the source elements.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<returns>
|
|
A query whose results evaluate asynchronously but which
|
|
are returned without guarantee of the source order.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Experimental.ExperimentalEnumerable.PreserveOrder``1(MoreLinq.Experimental.IAwaitQuery{``0},System.Boolean)">
|
|
<summary>
|
|
Returns a query whose results evaluate asynchronously and a Boolean
|
|
argument indicating whether the source order of the results is
|
|
preserved.
|
|
</summary>
|
|
<typeparam name="T">The type of the source elements.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="value">
|
|
A Boolean where <c>true</c> means results are in source order and
|
|
<c>false</c> means that results can be delivered in order of
|
|
efficiency.</param>
|
|
<returns>
|
|
A query whose results evaluate asynchronously and returns the
|
|
results ordered or unordered based on <paramref name="value"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Await``1(System.Collections.Generic.IEnumerable{System.Threading.Tasks.Task{``0}})">
|
|
<summary>
|
|
Creates a sequence query that streams the result of each task in
|
|
the source sequence as it completes asynchronously.
|
|
</summary>
|
|
<typeparam name="T">
|
|
The type of each task's result as well as the type of the elements
|
|
of the resulting sequence.</typeparam>
|
|
<param name="source">The source sequence of tasks.</param>
|
|
<returns>
|
|
A sequence query that streams the result of each task in
|
|
<paramref name="source"/> as it completes asynchronously.
|
|
</returns>
|
|
<remarks>
|
|
<para>
|
|
This method uses deferred execution semantics. The results are
|
|
yielded as each asynchronous task completes and, by default,
|
|
not guaranteed to be based on the source sequence order. If order
|
|
is important, compose further with
|
|
<see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered``1(MoreLinq.Experimental.IAwaitQuery{``0})"/>.</para>
|
|
<para>
|
|
This method starts a new task where the tasks are awaited. If the
|
|
resulting sequence is partially consumed then there's a good chance
|
|
that some tasks will be wasted, those that are in flight.</para>
|
|
<para>
|
|
The tasks in <paramref name="source"/> are already assumed to be in
|
|
flight therefore changing concurrency options via
|
|
<see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.AsSequential``1(MoreLinq.Experimental.IAwaitQuery{``0})"/>, <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.MaxConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0},System.Int32)"/> or
|
|
<see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.UnboundedConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0})"/> will only change how many
|
|
tasks are awaited at any given moment, not how many will be
|
|
kept in flight. For the latter effect, use the other overload.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Await``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Threading.CancellationToken,System.Threading.Tasks.Task{``1}})">
|
|
<summary>
|
|
Creates a sequence query that streams the result of each task in
|
|
the source sequence as it completes asynchronously. A
|
|
<see cref="T:System.Threading.CancellationToken"/> is passed for each asynchronous
|
|
evaluation to abort any asynchronous operations in flight if the
|
|
sequence is not fully iterated.
|
|
</summary>
|
|
<typeparam name="T">The type of the source elements.</typeparam>
|
|
<typeparam name="TResult">The type of the result elements.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="evaluator">A function to begin the asynchronous
|
|
evaluation of each element, the second parameter of which is a
|
|
<see cref="T:System.Threading.CancellationToken"/> that can be used to abort
|
|
asynchronous operations.</param>
|
|
<returns>
|
|
A sequence query that stream its results as they are
|
|
evaluated asynchronously.
|
|
</returns>
|
|
<remarks>
|
|
<para>
|
|
This method uses deferred execution semantics. The results are
|
|
yielded as each asynchronous evaluation completes and, by default,
|
|
not guaranteed to be based on the source sequence order. If order
|
|
is important, compose further with
|
|
<see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered``1(MoreLinq.Experimental.IAwaitQuery{``0})"/>.</para>
|
|
<para>
|
|
This method starts a new task where the asynchronous evaluations
|
|
take place and awaited. If the resulting sequence is partially
|
|
consumed then there's a good chance that some projection work will
|
|
be wasted and a cooperative effort is done that depends on the
|
|
<paramref name="evaluator"/> function (via a
|
|
<see cref="T:System.Threading.CancellationToken"/> as its second argument) to cancel
|
|
those in flight.</para>
|
|
<para>
|
|
The <paramref name="evaluator"/> function should be designed to be
|
|
thread-agnostic.</para>
|
|
<para>
|
|
The task returned by <paramref name="evaluator"/> should be started
|
|
when the function is called (and not just a mere projection)
|
|
otherwise changing concurrency options via
|
|
<see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.AsSequential``1(MoreLinq.Experimental.IAwaitQuery{``0})"/>, <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.MaxConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0},System.Int32)"/> or
|
|
<see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.UnboundedConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0})"/> will only change how many
|
|
tasks are awaited at any given moment, not how many will be
|
|
kept in flight.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Experimental.ExperimentalEnumerable.AwaitCompletion``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Threading.CancellationToken,System.Threading.Tasks.Task{``1}},System.Func{``0,System.Threading.Tasks.Task{``1},``2})">
|
|
<summary>
|
|
Awaits completion of all asynchronous evaluations irrespective of
|
|
whether they succeed or fail. An additional argument specifies a
|
|
function that projects the final result given the source item and
|
|
completed task.
|
|
</summary>
|
|
<typeparam name="T">The type of the source elements.</typeparam>
|
|
<typeparam name="TTaskResult"> The type of the tasks's result.</typeparam>
|
|
<typeparam name="TResult">The type of the result elements.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="evaluator">A function to begin the asynchronous
|
|
evaluation of each element, the second parameter of which is a
|
|
<see cref="T:System.Threading.CancellationToken"/> that can be used to abort
|
|
asynchronous operations.</param>
|
|
<param name="resultSelector">A fucntion that projects the final
|
|
result given the source item and its asynchronous completion
|
|
result.</param>
|
|
<returns>
|
|
A sequence query that stream its results as they are
|
|
evaluated asynchronously.
|
|
</returns>
|
|
<remarks>
|
|
<para>
|
|
This method uses deferred execution semantics. The results are
|
|
yielded as each asynchronous evaluation completes and, by default,
|
|
not guaranteed to be based on the source sequence order. If order
|
|
is important, compose further with
|
|
<see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered``1(MoreLinq.Experimental.IAwaitQuery{``0})"/>.</para>
|
|
<para>
|
|
This method starts a new task where the asynchronous evaluations
|
|
take place and awaited. If the resulting sequence is partially
|
|
consumed then there's a good chance that some projection work will
|
|
be wasted and a cooperative effort is done that depends on the
|
|
<paramref name="evaluator"/> function (via a
|
|
<see cref="T:System.Threading.CancellationToken"/> as its second argument) to cancel
|
|
those in flight.</para>
|
|
<para>
|
|
The <paramref name="evaluator"/> function should be designed to be
|
|
thread-agnostic.</para>
|
|
<para>
|
|
The task returned by <paramref name="evaluator"/> should be started
|
|
when the function is called (and not just a mere projection)
|
|
otherwise changing concurrency options via
|
|
<see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.AsSequential``1(MoreLinq.Experimental.IAwaitQuery{``0})"/>, <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.MaxConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0},System.Int32)"/> or
|
|
<see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.UnboundedConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0})"/> will only change how many
|
|
tasks are awaited at any given moment, not how many will be
|
|
kept in flight.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Memoize``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Creates a sequence that lazily caches the source as it is iterated
|
|
for the first time, reusing the cache thereafter for future
|
|
re-iterations. If the source is already cached or buffered then it
|
|
is returned verbatim.
|
|
</summary>
|
|
<typeparam name="T">
|
|
Type of elements in <paramref name="source"/>.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<returns>
|
|
Returns a sequence that corresponds to a cached version of the
|
|
input sequence.</returns>
|
|
<remarks>
|
|
The returned <see cref="T:System.Collections.Generic.IEnumerable`1"/> will cache items from
|
|
<paramref name="source"/> in a thread-safe manner. Each thread can
|
|
call its <see cref="M:System.Collections.Generic.IEnumerable`1.GetEnumerator"/> to acquire an
|
|
iterator but the same iterator should not be used simultanesouly
|
|
from multiple threads. The sequence supplied in
|
|
<paramref name="source"/> is not expected to be thread-safe but it
|
|
is required to be thread-agnostic because different threads
|
|
(though never simultaneously) may iterate over the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Experimental.ExperimentalEnumerable.TrySingle``2(System.Collections.Generic.IEnumerable{``0},``1,``1,``1)">
|
|
<summary>
|
|
Returns a tuple with the cardinality of the sequence and the
|
|
single element in the sequence if it contains exactly one element.
|
|
similar to <see cref="M:System.Linq.Enumerable.Single``1(System.Collections.Generic.IEnumerable{``0})"/>.
|
|
</summary>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="zero">
|
|
The value that is returned in the tuple if the sequence has zero
|
|
elements.</param>
|
|
<param name="one">
|
|
The value that is returned in the tuple if the sequence has a
|
|
single element only.</param>
|
|
<param name="many">
|
|
The value that is returned in the tuple if the sequence has two or
|
|
more elements.</param>
|
|
<typeparam name="T">
|
|
The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TCardinality">
|
|
The type that expresses cardinality.</typeparam>
|
|
<returns>
|
|
A tuple containing the identified <typeparamref name="TCardinality"/>
|
|
and either the single value of <typeparamref name="T"/> in the sequence
|
|
or its default value.</returns>
|
|
<remarks>
|
|
This operator uses immediate execution, but never consumes more
|
|
than two elements from the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Experimental.ExperimentalEnumerable.TrySingle``3(System.Collections.Generic.IEnumerable{``0},``1,``1,``1,System.Func{``1,``0,``2})">
|
|
<summary>
|
|
Returns a result projected from the the cardinality of the sequence
|
|
and the single element in the sequence if it contains exactly one
|
|
element.
|
|
</summary>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="zero">
|
|
The value that is passed as the first argument to
|
|
<paramref name="resultSelector" /> if the sequence has zero
|
|
elements.</param>
|
|
<param name="one">
|
|
The value that is passed as the first argument to
|
|
<paramref name="resultSelector" /> if the sequence has a
|
|
single element only.</param>
|
|
<param name="many">
|
|
The value that is passed as the first argument to
|
|
<paramref name="resultSelector" /> if the sequence has two or
|
|
more elements.</param>
|
|
<param name="resultSelector">
|
|
A function that receives the cardinality and, if the
|
|
sequence has just one element, the value of that element as
|
|
argument and projects a resulting value of type
|
|
<typeparamref name="TResult"/>.</param>
|
|
<typeparam name="T">
|
|
The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TCardinality">
|
|
The type that expresses cardinality.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the result value returned by the
|
|
<paramref name="resultSelector"/> function. </typeparam>
|
|
<returns>
|
|
The value returned by <paramref name="resultSelector"/>.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses immediate execution, but never consumes more
|
|
than two elements from the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Experimental.AwaitQueryOptions">
|
|
<summary>
|
|
Represents options for a query whose results evaluate asynchronously.
|
|
</summary>
|
|
</member>
|
|
<member name="F:MoreLinq.Experimental.AwaitQueryOptions.Default">
|
|
<summary>
|
|
The default options used for a query whose results evaluate
|
|
asynchronously.
|
|
</summary>
|
|
</member>
|
|
<member name="P:MoreLinq.Experimental.AwaitQueryOptions.MaxConcurrency">
|
|
<summary>
|
|
Gets a positive (non-zero) integer that specifies the maximum
|
|
number of asynchronous operations to have in-flight concurrently
|
|
or <c>null</c> to mean unlimited concurrency.
|
|
</summary>
|
|
</member>
|
|
<member name="P:MoreLinq.Experimental.AwaitQueryOptions.Scheduler">
|
|
<summary>
|
|
Get the scheduler to be used for any workhorse task.
|
|
</summary>
|
|
</member>
|
|
<member name="P:MoreLinq.Experimental.AwaitQueryOptions.PreserveOrder">
|
|
<summary>
|
|
Get a Boolean that determines whether results should be ordered
|
|
the same as the source.
|
|
</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Experimental.AwaitQueryOptions.WithMaxConcurrency(System.Nullable{System.Int32})">
|
|
<summary>
|
|
Returns new options with the given concurrency limit.
|
|
</summary>
|
|
<param name="value">
|
|
The maximum concurrent asynchronous operation to keep in flight.
|
|
Use <c>null</c> to mean unbounded concurrency.</param>
|
|
<returns>Options with the new setting.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Experimental.AwaitQueryOptions.WithScheduler(System.Threading.Tasks.TaskScheduler)">
|
|
<summary>
|
|
Returns new options with the given scheduler.
|
|
</summary>
|
|
<param name="value">
|
|
The scheduler to use to for the workhorse task.</param>
|
|
<returns>Options with the new setting.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Experimental.AwaitQueryOptions.WithPreserveOrder(System.Boolean)">
|
|
<summary>
|
|
Returns new options with the given Boolean indicating whether or
|
|
not the results should be returned in the order of the source.
|
|
</summary>
|
|
<param name="value">
|
|
A Boolean where <c>true</c> means results are in source order and
|
|
<c>false</c> means that results can be delivered in order of
|
|
efficiency.</param>
|
|
<returns>Options with the new setting.</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Experimental.IAwaitQuery`1">
|
|
<summary>
|
|
Represents a sequence whose elements or results evaluate asynchronously.
|
|
</summary>
|
|
<inheritdoc />
|
|
<typeparam name="T">The type of the source elements.</typeparam>
|
|
</member>
|
|
<member name="P:MoreLinq.Experimental.IAwaitQuery`1.Options">
|
|
<summary>
|
|
The options that determine how the sequence evaluation behaves when
|
|
it is iterated.
|
|
</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Experimental.IAwaitQuery`1.WithOptions(MoreLinq.Experimental.AwaitQueryOptions)">
|
|
<summary>
|
|
Returns a new query that will use the given options.
|
|
</summary>
|
|
<param name="options">The new options to use.</param>
|
|
<returns>
|
|
Returns a new query using the supplied options.
|
|
</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.AcquireExtension">
|
|
<summary><c>Acquire</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.AcquireExtension.Acquire``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Ensures that a source sequence of <see cref="T:System.IDisposable"/>
|
|
objects are all acquired successfully. If the acquisition of any
|
|
one <see cref="T:System.IDisposable"/> fails then those successfully
|
|
acquired till that point are disposed.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
|
|
<param name="source">Source sequence of <see cref="T:System.IDisposable"/> objects.</param>
|
|
<returns>
|
|
Returns an array of all the acquired <see cref="T:System.IDisposable"/>
|
|
objects in source order.
|
|
</returns>
|
|
<remarks>
|
|
This operator executes immediately.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.AggregateExtension">
|
|
<summary><c>Aggregate</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``4(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},System.Func{``1,``2,``3})">
|
|
<summary>
|
|
Applies two accumulators sequentially in a single pass over a
|
|
sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
|
|
<typeparam name="TResult">The type of the accumulated result.</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="seed1">The seed value for the first accumulator.</param>
|
|
<param name="accumulator1">The first accumulator.</param>
|
|
<param name="seed2">The seed value for the second accumulator.</param>
|
|
<param name="accumulator2">The second accumulator.</param>
|
|
<param name="resultSelector">
|
|
A function that projects a single result given the result of each
|
|
accumulator.</param>
|
|
<returns>The value returned by <paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
This operator executes immediately.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``5(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},System.Func{``1,``2,``3,``4})">
|
|
<summary>
|
|
Applies three accumulators sequentially in a single pass over a
|
|
sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
|
|
<typeparam name="TResult">The type of the accumulated result.</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="seed1">The seed value for the first accumulator.</param>
|
|
<param name="accumulator1">The first accumulator.</param>
|
|
<param name="seed2">The seed value for the second accumulator.</param>
|
|
<param name="accumulator2">The second accumulator.</param>
|
|
<param name="seed3">The seed value for the third accumulator.</param>
|
|
<param name="accumulator3">The third accumulator.</param>
|
|
<param name="resultSelector">
|
|
A function that projects a single result given the result of each
|
|
accumulator.</param>
|
|
<returns>The value returned by <paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
This operator executes immediately.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``6(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},System.Func{``1,``2,``3,``4,``5})">
|
|
<summary>
|
|
Applies four accumulators sequentially in a single pass over a
|
|
sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
|
|
<typeparam name="TResult">The type of the accumulated result.</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="seed1">The seed value for the first accumulator.</param>
|
|
<param name="accumulator1">The first accumulator.</param>
|
|
<param name="seed2">The seed value for the second accumulator.</param>
|
|
<param name="accumulator2">The second accumulator.</param>
|
|
<param name="seed3">The seed value for the third accumulator.</param>
|
|
<param name="accumulator3">The third accumulator.</param>
|
|
<param name="seed4">The seed value for the fourth accumulator.</param>
|
|
<param name="accumulator4">The fourth accumulator.</param>
|
|
<param name="resultSelector">
|
|
A function that projects a single result given the result of each
|
|
accumulator.</param>
|
|
<returns>The value returned by <paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
This operator executes immediately.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``7(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},System.Func{``1,``2,``3,``4,``5,``6})">
|
|
<summary>
|
|
Applies five accumulators sequentially in a single pass over a
|
|
sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
|
|
<typeparam name="TResult">The type of the accumulated result.</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="seed1">The seed value for the first accumulator.</param>
|
|
<param name="accumulator1">The first accumulator.</param>
|
|
<param name="seed2">The seed value for the second accumulator.</param>
|
|
<param name="accumulator2">The second accumulator.</param>
|
|
<param name="seed3">The seed value for the third accumulator.</param>
|
|
<param name="accumulator3">The third accumulator.</param>
|
|
<param name="seed4">The seed value for the fourth accumulator.</param>
|
|
<param name="accumulator4">The fourth accumulator.</param>
|
|
<param name="seed5">The seed value for the fifth accumulator.</param>
|
|
<param name="accumulator5">The fifth accumulator.</param>
|
|
<param name="resultSelector">
|
|
A function that projects a single result given the result of each
|
|
accumulator.</param>
|
|
<returns>The value returned by <paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
This operator executes immediately.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``8(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},``6,System.Func{``6,``0,``6},System.Func{``1,``2,``3,``4,``5,``6,``7})">
|
|
<summary>
|
|
Applies six accumulators sequentially in a single pass over a
|
|
sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate6">The type of sixth accumulator value.</typeparam>
|
|
<typeparam name="TResult">The type of the accumulated result.</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="seed1">The seed value for the first accumulator.</param>
|
|
<param name="accumulator1">The first accumulator.</param>
|
|
<param name="seed2">The seed value for the second accumulator.</param>
|
|
<param name="accumulator2">The second accumulator.</param>
|
|
<param name="seed3">The seed value for the third accumulator.</param>
|
|
<param name="accumulator3">The third accumulator.</param>
|
|
<param name="seed4">The seed value for the fourth accumulator.</param>
|
|
<param name="accumulator4">The fourth accumulator.</param>
|
|
<param name="seed5">The seed value for the fifth accumulator.</param>
|
|
<param name="accumulator5">The fifth accumulator.</param>
|
|
<param name="seed6">The seed value for the sixth accumulator.</param>
|
|
<param name="accumulator6">The sixth accumulator.</param>
|
|
<param name="resultSelector">
|
|
A function that projects a single result given the result of each
|
|
accumulator.</param>
|
|
<returns>The value returned by <paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
This operator executes immediately.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``9(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},``6,System.Func{``6,``0,``6},``7,System.Func{``7,``0,``7},System.Func{``1,``2,``3,``4,``5,``6,``7,``8})">
|
|
<summary>
|
|
Applies seven accumulators sequentially in a single pass over a
|
|
sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate6">The type of sixth accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate7">The type of seventh accumulator value.</typeparam>
|
|
<typeparam name="TResult">The type of the accumulated result.</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="seed1">The seed value for the first accumulator.</param>
|
|
<param name="accumulator1">The first accumulator.</param>
|
|
<param name="seed2">The seed value for the second accumulator.</param>
|
|
<param name="accumulator2">The second accumulator.</param>
|
|
<param name="seed3">The seed value for the third accumulator.</param>
|
|
<param name="accumulator3">The third accumulator.</param>
|
|
<param name="seed4">The seed value for the fourth accumulator.</param>
|
|
<param name="accumulator4">The fourth accumulator.</param>
|
|
<param name="seed5">The seed value for the fifth accumulator.</param>
|
|
<param name="accumulator5">The fifth accumulator.</param>
|
|
<param name="seed6">The seed value for the sixth accumulator.</param>
|
|
<param name="accumulator6">The sixth accumulator.</param>
|
|
<param name="seed7">The seed value for the seventh accumulator.</param>
|
|
<param name="accumulator7">The seventh accumulator.</param>
|
|
<param name="resultSelector">
|
|
A function that projects a single result given the result of each
|
|
accumulator.</param>
|
|
<returns>The value returned by <paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
This operator executes immediately.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``10(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},``6,System.Func{``6,``0,``6},``7,System.Func{``7,``0,``7},``8,System.Func{``8,``0,``8},System.Func{``1,``2,``3,``4,``5,``6,``7,``8,``9})">
|
|
<summary>
|
|
Applies eight accumulators sequentially in a single pass over a
|
|
sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate6">The type of sixth accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate7">The type of seventh accumulator value.</typeparam>
|
|
<typeparam name="TAccumulate8">The type of eighth accumulator value.</typeparam>
|
|
<typeparam name="TResult">The type of the accumulated result.</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="seed1">The seed value for the first accumulator.</param>
|
|
<param name="accumulator1">The first accumulator.</param>
|
|
<param name="seed2">The seed value for the second accumulator.</param>
|
|
<param name="accumulator2">The second accumulator.</param>
|
|
<param name="seed3">The seed value for the third accumulator.</param>
|
|
<param name="accumulator3">The third accumulator.</param>
|
|
<param name="seed4">The seed value for the fourth accumulator.</param>
|
|
<param name="accumulator4">The fourth accumulator.</param>
|
|
<param name="seed5">The seed value for the fifth accumulator.</param>
|
|
<param name="accumulator5">The fifth accumulator.</param>
|
|
<param name="seed6">The seed value for the sixth accumulator.</param>
|
|
<param name="accumulator6">The sixth accumulator.</param>
|
|
<param name="seed7">The seed value for the seventh accumulator.</param>
|
|
<param name="accumulator7">The seventh accumulator.</param>
|
|
<param name="seed8">The seed value for the eighth accumulator.</param>
|
|
<param name="accumulator8">The eighth accumulator.</param>
|
|
<param name="resultSelector">
|
|
A function that projects a single result given the result of each
|
|
accumulator.</param>
|
|
<returns>The value returned by <paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
This operator executes immediately.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.AggregateRightExtension">
|
|
<summary><c>AggregateRight</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.AggregateRightExtension.AggregateRight``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})">
|
|
<summary>
|
|
Applies a right-associative accumulator function over a sequence.
|
|
This operator is the right-associative version of the
|
|
<see cref="M:System.Linq.Enumerable.Aggregate``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})"/> LINQ operator.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of source.</typeparam>
|
|
<param name="source">Source sequence.</param>
|
|
<param name="func">A right-associative accumulator function to be invoked on each element.</param>
|
|
<returns>The final accumulator value.</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
string result = Enumerable.Range(1, 5).Select(i => i.ToString()).AggregateRight((a, b) => string.Format("({0}/{1})", a, b));
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>"(1/(2/(3/(4/5))))"</c>.
|
|
</example>
|
|
<remarks>
|
|
This operator executes immediately.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.AggregateRightExtension.AggregateRight``2(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``0,``1,``1})">
|
|
<summary>
|
|
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
|
|
<see cref="M:System.Linq.Enumerable.Aggregate``2(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1})"/> LINQ operator.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of source.</typeparam>
|
|
<typeparam name="TAccumulate">The type of the accumulator value.</typeparam>
|
|
<param name="source">Source sequence.</param>
|
|
<param name="seed">The initial accumulator value.</param>
|
|
<param name="func">A right-associative accumulator function to be invoked on each element.</param>
|
|
<returns>The final accumulator value.</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = Enumerable.Range(1, 5);
|
|
string result = numbers.AggregateRight("6", (a, b) => string.Format("({0}/{1})", a, b));
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>"(1/(2/(3/(4/(5/6)))))"</c>.
|
|
</example>
|
|
<remarks>
|
|
This operator executes immediately.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.AggregateRightExtension.AggregateRight``3(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``0,``1,``1},System.Func{``1,``2})">
|
|
<summary>
|
|
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
|
|
<see cref="M:System.Linq.Enumerable.Aggregate``3(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},System.Func{``1,``2})"/> LINQ operator.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of source.</typeparam>
|
|
<typeparam name="TAccumulate">The type of the accumulator value.</typeparam>
|
|
<typeparam name="TResult">The type of the resulting value.</typeparam>
|
|
<param name="source">Source sequence.</param>
|
|
<param name="seed">The initial accumulator value.</param>
|
|
<param name="func">A right-associative accumulator function to be invoked on each element.</param>
|
|
<param name="resultSelector">A function to transform the final accumulator value into the result value.</param>
|
|
<returns>The transformed final accumulator value.</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = Enumerable.Range(1, 5);
|
|
int result = numbers.AggregateRight("6", (a, b) => string.Format("({0}/{1})", a, b), str => str.Length);
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>21</c>.
|
|
</example>
|
|
<remarks>
|
|
This operator executes immediately.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.AppendExtension">
|
|
<summary><c>Append</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.AppendExtension.Append``1(System.Collections.Generic.IEnumerable{``0},``0)">
|
|
<summary>
|
|
Returns a sequence consisting of the head elements and the given tail element.
|
|
</summary>
|
|
<typeparam name="T">Type of sequence</typeparam>
|
|
<param name="head">All elements of the head. Must not be null.</param>
|
|
<param name="tail">Tail element of the new sequence.</param>
|
|
<returns>A sequence consisting of the head elements and the given tail element.</returns>
|
|
<remarks>This operator uses deferred execution and streams its results.</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.AssertExtension">
|
|
<summary><c>Assert</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.AssertExtension.Assert``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})">
|
|
<summary>
|
|
Asserts that all elements of a sequence meet a given condition
|
|
otherwise throws an <see cref="T:System.Exception"/> object.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
|
|
<param name="source">Source sequence.</param>
|
|
<param name="predicate">Function that asserts an element of the <paramref name="source"/> sequence for a condition.</param>
|
|
<returns>
|
|
Returns the original sequence.
|
|
</returns>
|
|
<exception cref="T:System.InvalidOperationException">The input sequence
|
|
contains an element that does not meet the condition being
|
|
asserted.</exception>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.AssertExtension.Assert``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},System.Func{``0,System.Exception})">
|
|
<summary>
|
|
Asserts that all elements of a sequence meet a given condition
|
|
otherwise throws an <see cref="T:System.Exception"/> object.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
|
|
<param name="source">Source sequence.</param>
|
|
<param name="predicate">Function that asserts an element of the input sequence for a condition.</param>
|
|
<param name="errorSelector">Function that returns the <see cref="T:System.Exception"/> object to throw.</param>
|
|
<returns>
|
|
Returns the original sequence.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.AssertCountExtension">
|
|
<summary><c>AssertCount</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.AssertCountExtension.AssertCount``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Asserts that a source sequence contains a given count of elements.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
|
|
<param name="source">Source sequence.</param>
|
|
<param name="count">Count to assert.</param>
|
|
<returns>
|
|
Returns the original sequence as long it is contains the
|
|
number of elements specified by <paramref name="count"/>.
|
|
Otherwise it throws <see cref="T:System.Exception" />.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.AssertCountExtension.AssertCount``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Int32,System.Int32,System.Exception})">
|
|
<summary>
|
|
Asserts that a source sequence contains a given count of elements.
|
|
A parameter specifies the exception to be thrown.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
|
|
<param name="source">Source sequence.</param>
|
|
<param name="count">Count to assert.</param>
|
|
<param name="errorSelector">
|
|
Function that receives a comparison (a negative integer if actual
|
|
count is less than <paramref name="count"/> and a positive integer
|
|
if actual count is greater than <paramref name="count"/>) and
|
|
<paramref name="count"/> as arguments and which returns the
|
|
<see cref="T:System.Exception"/> object to throw.</param>
|
|
<returns>
|
|
Returns the original sequence as long it is contains the
|
|
number of elements specified by <paramref name="count"/>.
|
|
Otherwise it throws the <see cref="T:System.Exception" /> object
|
|
returned by calling <paramref name="errorSelector"/>.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.AtLeastExtension">
|
|
<summary><c>AtLeast</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.AtLeastExtension.AtLeast``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Determines whether or not the number of elements in the sequence is greater than
|
|
or equal to the given integer.
|
|
</summary>
|
|
<typeparam name="T">Element type of sequence</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="count">The minimum number of items a sequence must have for this
|
|
function to return true</param>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentOutOfRangeException"><paramref name="count"/> is negative</exception>
|
|
<returns><c>true</c> if the number of elements in the sequence is greater than
|
|
or equal to the given integer or <c>false</c> otherwise.</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = new[] { 123, 456, 789 };
|
|
var result = numbers.AtLeast(2);
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>true</c>.
|
|
</example>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.AtMostExtension">
|
|
<summary><c>AtMost</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.AtMostExtension.AtMost``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Determines whether or not the number of elements in the sequence is lesser than
|
|
or equal to the given integer.
|
|
</summary>
|
|
<typeparam name="T">Element type of sequence</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="count">The maximun number of items a sequence must have for this
|
|
function to return true</param>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentOutOfRangeException"><paramref name="count"/> is negative</exception>
|
|
<returns><c>true</c> if the number of elements in the sequence is lesser than
|
|
or equal to the given integer or <c>false</c> otherwise.</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = new[] { 123, 456, 789 };
|
|
var result = numbers.AtMost(2);
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>false</c>.
|
|
</example>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.BacksertExtension">
|
|
<summary><c>Backsert</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.BacksertExtension.Backsert``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Inserts the elements of a sequence into another sequence at a
|
|
specified index from the tail of the sequence, where zero always
|
|
represents the last position, one represents the second-last
|
|
element, two represents the third-last element and so on.
|
|
</summary>
|
|
<typeparam name="T">
|
|
Type of elements in all sequences.</typeparam>
|
|
<param name="first">The source sequence.</param>
|
|
<param name="second">The sequence that will be inserted.</param>
|
|
<param name="index">
|
|
The zero-based index from the end of <paramref name="first"/> where
|
|
elements from <paramref name="second"/> should be inserted.
|
|
<paramref name="second"/>.</param>
|
|
<returns>
|
|
A sequence that contains the elements of <paramref name="first"/>
|
|
plus the elements of <paramref name="second"/> inserted at
|
|
the given index from the end of <paramref name="first"/>.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="first"/> is null.</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="second"/> is null.</exception>
|
|
<exception cref="T:System.ArgumentOutOfRangeException">
|
|
Thrown if <paramref name="index"/> is negative.
|
|
</exception>
|
|
<exception cref="T:System.ArgumentOutOfRangeException">
|
|
Thrown lazily if <paramref name="index"/> is greater than the
|
|
length of <paramref name="first"/>. The validation occurs when
|
|
the resulting sequence is iterated.
|
|
</exception>
|
|
<remarks>
|
|
This method uses deferred execution and streams its results.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.BatchExtension">
|
|
<summary><c>Batch</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.BatchExtension.Batch``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Batches the source sequence into sized buckets.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="size">Size of buckets.</param>
|
|
<returns>A sequence of equally sized buckets containing elements of the source collection.</returns>
|
|
<remarks>
|
|
<para>
|
|
This operator uses deferred execution and streams its results
|
|
(buckets are streamed but their content buffered).</para>
|
|
<para>
|
|
When more than one bucket is streamed, all buckets except the last
|
|
is guaranteed to have <paramref name="size"/> elements. The last
|
|
bucket may be smaller depending on the remaining elements in the
|
|
<paramref name="source"/> sequence.</para>
|
|
<para>
|
|
Each bucket is pre-allocated to <paramref name="size"/> elements.
|
|
If <paramref name="size"/> is set to a very large value, e.g.
|
|
<see cref="F:System.Int32.MaxValue"/> to effectively disable batching by just
|
|
hoping for a single bucket, then it can lead to memory exhaustion
|
|
(<see cref="T:System.OutOfMemoryException"/>).
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.BatchExtension.Batch``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1})">
|
|
<summary>
|
|
Batches the source sequence into sized buckets and applies a projection to each bucket.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
|
|
<typeparam name="TResult">Type of result returned by <paramref name="resultSelector"/>.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="size">Size of buckets.</param>
|
|
<param name="resultSelector">The projection to apply to each bucket.</param>
|
|
<returns>A sequence of projections on equally sized buckets containing elements of the source collection.</returns>
|
|
<para>
|
|
This operator uses deferred execution and streams its results
|
|
(buckets are streamed but their content buffered).</para>
|
|
<para>
|
|
<para>
|
|
When more than one bucket is streamed, all buckets except the last
|
|
is guaranteed to have <paramref name="size"/> elements. The last
|
|
bucket may be smaller depending on the remaining elements in the
|
|
<paramref name="source"/> sequence.</para>
|
|
Each bucket is pre-allocated to <paramref name="size"/> elements.
|
|
If <paramref name="size"/> is set to a very large value, e.g.
|
|
<see cref="F:System.Int32.MaxValue"/> to effectively disable batching by just
|
|
hoping for a single bucket, then it can lead to memory exhaustion
|
|
(<see cref="T:System.OutOfMemoryException"/>).
|
|
</para>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.CartesianExtension">
|
|
<summary><c>Cartesian</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.CartesianExtension.Cartesian``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
|
|
<summary>
|
|
Returns the Cartesian product of two sequences by enumerating all
|
|
possible combinations of one item from each sequence, and applying
|
|
a user-defined projection to the items in a given combination.
|
|
</summary>
|
|
<typeparam name="T1">
|
|
The type of the elements of <paramref name="first"/>.</typeparam>
|
|
<typeparam name="T2">
|
|
The type of the elements of <paramref name="second"/>.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the elements of the result sequence.</typeparam>
|
|
<param name="first">The first sequence of elements.</param>
|
|
<param name="second">The second sequence of elements.</param>
|
|
<param name="resultSelector">A projection function that combines
|
|
elements from all of the sequences.</param>
|
|
<returns>A sequence of elements returned by
|
|
<paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
<para>
|
|
The method returns items in the same order as a nested foreach
|
|
loop, but all sequences except for <paramref name="first"/> are
|
|
cached when iterated over. The cache is then re-used for any
|
|
subsequent iterations.</para>
|
|
<para>
|
|
This method uses deferred execution and stream its results.</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.CartesianExtension.Cartesian``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
|
|
<summary>
|
|
Returns the Cartesian product of three sequences by enumerating all
|
|
possible combinations of one item from each sequence, and applying
|
|
a user-defined projection to the items in a given combination.
|
|
</summary>
|
|
<typeparam name="T1">
|
|
The type of the elements of <paramref name="first"/>.</typeparam>
|
|
<typeparam name="T2">
|
|
The type of the elements of <paramref name="second"/>.</typeparam>
|
|
<typeparam name="T3">
|
|
The type of the elements of <paramref name="third"/>.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the elements of the result sequence.</typeparam>
|
|
<param name="first">The first sequence of elements.</param>
|
|
<param name="second">The second sequence of elements.</param>
|
|
<param name="third">The third sequence of elements.</param>
|
|
<param name="resultSelector">A projection function that combines
|
|
elements from all of the sequences.</param>
|
|
<returns>A sequence of elements returned by
|
|
<paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
<para>
|
|
The method returns items in the same order as a nested foreach
|
|
loop, but all sequences except for <paramref name="first"/> are
|
|
cached when iterated over. The cache is then re-used for any
|
|
subsequent iterations.</para>
|
|
<para>
|
|
This method uses deferred execution and stream its results.</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.CartesianExtension.Cartesian``5(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Func{``0,``1,``2,``3,``4})">
|
|
<summary>
|
|
Returns the Cartesian product of four sequences by enumerating all
|
|
possible combinations of one item from each sequence, and applying
|
|
a user-defined projection to the items in a given combination.
|
|
</summary>
|
|
<typeparam name="T1">
|
|
The type of the elements of <paramref name="first"/>.</typeparam>
|
|
<typeparam name="T2">
|
|
The type of the elements of <paramref name="second"/>.</typeparam>
|
|
<typeparam name="T3">
|
|
The type of the elements of <paramref name="third"/>.</typeparam>
|
|
<typeparam name="T4">
|
|
The type of the elements of <paramref name="fourth"/>.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the elements of the result sequence.</typeparam>
|
|
<param name="first">The first sequence of elements.</param>
|
|
<param name="second">The second sequence of elements.</param>
|
|
<param name="third">The third sequence of elements.</param>
|
|
<param name="fourth">The fourth sequence of elements.</param>
|
|
<param name="resultSelector">A projection function that combines
|
|
elements from all of the sequences.</param>
|
|
<returns>A sequence of elements returned by
|
|
<paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
<para>
|
|
The method returns items in the same order as a nested foreach
|
|
loop, but all sequences except for <paramref name="first"/> are
|
|
cached when iterated over. The cache is then re-used for any
|
|
subsequent iterations.</para>
|
|
<para>
|
|
This method uses deferred execution and stream its results.</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.CartesianExtension.Cartesian``6(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Collections.Generic.IEnumerable{``4},System.Func{``0,``1,``2,``3,``4,``5})">
|
|
<summary>
|
|
Returns the Cartesian product of five sequences by enumerating all
|
|
possible combinations of one item from each sequence, and applying
|
|
a user-defined projection to the items in a given combination.
|
|
</summary>
|
|
<typeparam name="T1">
|
|
The type of the elements of <paramref name="first"/>.</typeparam>
|
|
<typeparam name="T2">
|
|
The type of the elements of <paramref name="second"/>.</typeparam>
|
|
<typeparam name="T3">
|
|
The type of the elements of <paramref name="third"/>.</typeparam>
|
|
<typeparam name="T4">
|
|
The type of the elements of <paramref name="fourth"/>.</typeparam>
|
|
<typeparam name="T5">
|
|
The type of the elements of <paramref name="fifth"/>.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the elements of the result sequence.</typeparam>
|
|
<param name="first">The first sequence of elements.</param>
|
|
<param name="second">The second sequence of elements.</param>
|
|
<param name="third">The third sequence of elements.</param>
|
|
<param name="fourth">The fourth sequence of elements.</param>
|
|
<param name="fifth">The fifth sequence of elements.</param>
|
|
<param name="resultSelector">A projection function that combines
|
|
elements from all of the sequences.</param>
|
|
<returns>A sequence of elements returned by
|
|
<paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
<para>
|
|
The method returns items in the same order as a nested foreach
|
|
loop, but all sequences except for <paramref name="first"/> are
|
|
cached when iterated over. The cache is then re-used for any
|
|
subsequent iterations.</para>
|
|
<para>
|
|
This method uses deferred execution and stream its results.</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.CartesianExtension.Cartesian``7(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Collections.Generic.IEnumerable{``4},System.Collections.Generic.IEnumerable{``5},System.Func{``0,``1,``2,``3,``4,``5,``6})">
|
|
<summary>
|
|
Returns the Cartesian product of six sequences by enumerating all
|
|
possible combinations of one item from each sequence, and applying
|
|
a user-defined projection to the items in a given combination.
|
|
</summary>
|
|
<typeparam name="T1">
|
|
The type of the elements of <paramref name="first"/>.</typeparam>
|
|
<typeparam name="T2">
|
|
The type of the elements of <paramref name="second"/>.</typeparam>
|
|
<typeparam name="T3">
|
|
The type of the elements of <paramref name="third"/>.</typeparam>
|
|
<typeparam name="T4">
|
|
The type of the elements of <paramref name="fourth"/>.</typeparam>
|
|
<typeparam name="T5">
|
|
The type of the elements of <paramref name="fifth"/>.</typeparam>
|
|
<typeparam name="T6">
|
|
The type of the elements of <paramref name="sixth"/>.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the elements of the result sequence.</typeparam>
|
|
<param name="first">The first sequence of elements.</param>
|
|
<param name="second">The second sequence of elements.</param>
|
|
<param name="third">The third sequence of elements.</param>
|
|
<param name="fourth">The fourth sequence of elements.</param>
|
|
<param name="fifth">The fifth sequence of elements.</param>
|
|
<param name="sixth">The sixth sequence of elements.</param>
|
|
<param name="resultSelector">A projection function that combines
|
|
elements from all of the sequences.</param>
|
|
<returns>A sequence of elements returned by
|
|
<paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
<para>
|
|
The method returns items in the same order as a nested foreach
|
|
loop, but all sequences except for <paramref name="first"/> are
|
|
cached when iterated over. The cache is then re-used for any
|
|
subsequent iterations.</para>
|
|
<para>
|
|
This method uses deferred execution and stream its results.</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.CartesianExtension.Cartesian``8(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Collections.Generic.IEnumerable{``4},System.Collections.Generic.IEnumerable{``5},System.Collections.Generic.IEnumerable{``6},System.Func{``0,``1,``2,``3,``4,``5,``6,``7})">
|
|
<summary>
|
|
Returns the Cartesian product of seven sequences by enumerating all
|
|
possible combinations of one item from each sequence, and applying
|
|
a user-defined projection to the items in a given combination.
|
|
</summary>
|
|
<typeparam name="T1">
|
|
The type of the elements of <paramref name="first"/>.</typeparam>
|
|
<typeparam name="T2">
|
|
The type of the elements of <paramref name="second"/>.</typeparam>
|
|
<typeparam name="T3">
|
|
The type of the elements of <paramref name="third"/>.</typeparam>
|
|
<typeparam name="T4">
|
|
The type of the elements of <paramref name="fourth"/>.</typeparam>
|
|
<typeparam name="T5">
|
|
The type of the elements of <paramref name="fifth"/>.</typeparam>
|
|
<typeparam name="T6">
|
|
The type of the elements of <paramref name="sixth"/>.</typeparam>
|
|
<typeparam name="T7">
|
|
The type of the elements of <paramref name="seventh"/>.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the elements of the result sequence.</typeparam>
|
|
<param name="first">The first sequence of elements.</param>
|
|
<param name="second">The second sequence of elements.</param>
|
|
<param name="third">The third sequence of elements.</param>
|
|
<param name="fourth">The fourth sequence of elements.</param>
|
|
<param name="fifth">The fifth sequence of elements.</param>
|
|
<param name="sixth">The sixth sequence of elements.</param>
|
|
<param name="seventh">The seventh sequence of elements.</param>
|
|
<param name="resultSelector">A projection function that combines
|
|
elements from all of the sequences.</param>
|
|
<returns>A sequence of elements returned by
|
|
<paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
<para>
|
|
The method returns items in the same order as a nested foreach
|
|
loop, but all sequences except for <paramref name="first"/> are
|
|
cached when iterated over. The cache is then re-used for any
|
|
subsequent iterations.</para>
|
|
<para>
|
|
This method uses deferred execution and stream its results.</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.CartesianExtension.Cartesian``9(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Collections.Generic.IEnumerable{``4},System.Collections.Generic.IEnumerable{``5},System.Collections.Generic.IEnumerable{``6},System.Collections.Generic.IEnumerable{``7},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8})">
|
|
<summary>
|
|
Returns the Cartesian product of eight sequences by enumerating all
|
|
possible combinations of one item from each sequence, and applying
|
|
a user-defined projection to the items in a given combination.
|
|
</summary>
|
|
<typeparam name="T1">
|
|
The type of the elements of <paramref name="first"/>.</typeparam>
|
|
<typeparam name="T2">
|
|
The type of the elements of <paramref name="second"/>.</typeparam>
|
|
<typeparam name="T3">
|
|
The type of the elements of <paramref name="third"/>.</typeparam>
|
|
<typeparam name="T4">
|
|
The type of the elements of <paramref name="fourth"/>.</typeparam>
|
|
<typeparam name="T5">
|
|
The type of the elements of <paramref name="fifth"/>.</typeparam>
|
|
<typeparam name="T6">
|
|
The type of the elements of <paramref name="sixth"/>.</typeparam>
|
|
<typeparam name="T7">
|
|
The type of the elements of <paramref name="seventh"/>.</typeparam>
|
|
<typeparam name="T8">
|
|
The type of the elements of <paramref name="eighth"/>.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the elements of the result sequence.</typeparam>
|
|
<param name="first">The first sequence of elements.</param>
|
|
<param name="second">The second sequence of elements.</param>
|
|
<param name="third">The third sequence of elements.</param>
|
|
<param name="fourth">The fourth sequence of elements.</param>
|
|
<param name="fifth">The fifth sequence of elements.</param>
|
|
<param name="sixth">The sixth sequence of elements.</param>
|
|
<param name="seventh">The seventh sequence of elements.</param>
|
|
<param name="eighth">The eighth sequence of elements.</param>
|
|
<param name="resultSelector">A projection function that combines
|
|
elements from all of the sequences.</param>
|
|
<returns>A sequence of elements returned by
|
|
<paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
<para>
|
|
The method returns items in the same order as a nested foreach
|
|
loop, but all sequences except for <paramref name="first"/> are
|
|
cached when iterated over. The cache is then re-used for any
|
|
subsequent iterations.</para>
|
|
<para>
|
|
This method uses deferred execution and stream its results.</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.ChooseExtension">
|
|
<summary><c>Choose</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ChooseExtension.Choose``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.ValueTuple{System.Boolean,``1}})">
|
|
<summary>
|
|
Applies a function to each element of the source sequence and
|
|
returns a new sequence of result elements for source elements
|
|
where the function returns a couple (2-tuple) having a <c>true</c>
|
|
as its first element and result as the second.
|
|
</summary>
|
|
<typeparam name="T">
|
|
The type of the elements in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the elements in the returned sequence.</typeparam>
|
|
<param name="source"> The source sequence.</param>
|
|
<param name="chooser">The function that is applied to each source
|
|
element.</param>
|
|
<returns>A sequence <typeparamref name="TResult"/> elements.</returns>
|
|
<remarks>
|
|
This method uses deferred execution semantics and streams its
|
|
results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
var str = "O,l,2,3,4,S,6,7,B,9";
|
|
var xs = str.Split(',').Choose(s => (int.TryParse(s, out var n), n));
|
|
]]></code>
|
|
The <c>xs</c> variable will be a sequence of the integers 2, 3, 4,
|
|
6, 7 and 9.
|
|
</example>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.CompareCountExtension">
|
|
<summary><c>CompareCount</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.CompareCountExtension.CompareCount``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1})">
|
|
<summary>
|
|
Compares two sequences and returns an integer that indicates whether the first sequence
|
|
has fewer, the same or more elements than the second sequence.
|
|
</summary>
|
|
<typeparam name="TFirst">Element type of the first sequence</typeparam>
|
|
<typeparam name="TSecond">Element type of the second sequence</typeparam>
|
|
<param name="first">The first sequence</param>
|
|
<param name="second">The second sequence</param>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="first"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="second"/> is null</exception>
|
|
<returns><c>-1</c> if the first sequence has the fewest elements, <c>0</c> if the two sequences have the same number of elements
|
|
or <c>1</c> if the first sequence has the most elements.</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var first = new[] { 123, 456 };
|
|
var second = new[] { 789 };
|
|
var result = first.CompareCount(second);
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>1</c>.
|
|
</example>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.ConsumeExtension">
|
|
<summary><c>Consume</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ConsumeExtension.Consume``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Completely consumes the given sequence. This method uses immediate execution,
|
|
and doesn't store any data during execution.
|
|
</summary>
|
|
<typeparam name="T">Element type of the sequence</typeparam>
|
|
<param name="source">Source to consume</param>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.CountBetweenExtension">
|
|
<summary><c>CountBetween</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.CountBetweenExtension.CountBetween``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Int32)">
|
|
<summary>
|
|
Determines whether or not the number of elements in the sequence is between
|
|
an inclusive range of minimum and maximum integers.
|
|
</summary>
|
|
<typeparam name="T">Element type of sequence</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="min">The minimum number of items a sequence must have for this
|
|
function to return true</param>
|
|
<param name="max">The maximun number of items a sequence must have for this
|
|
function to return true</param>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentOutOfRangeException"><paramref name="min"/> is negative or <paramref name="max"/> is less than min</exception>
|
|
<returns><c>true</c> if the number of elements in the sequence is between (inclusive)
|
|
the min and max given integers or <c>false</c> otherwise.</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = new[] { 123, 456, 789 };
|
|
var result = numbers.CountBetween(1, 2);
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>false</c>.
|
|
</example>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.CountByExtension">
|
|
<summary><c>CountBy</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.CountByExtension.CountBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TSource">Type of the elements of the source sequence.</typeparam>
|
|
<typeparam name="TKey">Type of the projected element.</typeparam>
|
|
<param name="source">Source sequence.</param>
|
|
<param name="keySelector">Function that transforms each item of source sequence into a key to be compared against the others.</param>
|
|
<returns>A sequence of unique keys and their number of occurrences in the original sequence.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.CountByExtension.CountBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TSource">Type of the elements of the source sequence.</typeparam>
|
|
<typeparam name="TKey">Type of the projected element.</typeparam>
|
|
<param name="source">Source sequence.</param>
|
|
<param name="keySelector">Function that transforms each item of source sequence into a key to be compared against the others.</param>
|
|
<param name="comparer">The equality comparer to use to determine whether or not keys are equal.
|
|
If null, the default equality comparer for <typeparamref name="TSource"/> is used.</param>
|
|
<returns>A sequence of unique keys and their number of occurrences in the original sequence.</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.CountDownExtension">
|
|
<summary><c>CountDown</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.CountDownExtension.CountDown``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,System.Nullable{System.Int32},``1})">
|
|
<summary>
|
|
Provides a countdown counter for a given count of elements at the
|
|
tail of the sequence where zero always represents the last element,
|
|
one represents the second-last element, two represents the
|
|
third-last element and so on.
|
|
</summary>
|
|
<typeparam name="T">
|
|
The type of elements of <paramref name="source"/></typeparam>
|
|
<typeparam name="TResult">
|
|
The type of elements of the resulting sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="count">Count of tail elements of
|
|
<paramref name="source"/> to count down.</param>
|
|
<param name="resultSelector">
|
|
A function that receives the element and the current countdown
|
|
value for the element and which returns those mapped to a
|
|
result returned in the resulting sequence. For elements before
|
|
the last <paramref name="count"/>, the coundown value is
|
|
<c>null</c>.</param>
|
|
<returns>
|
|
A sequence of results returned by
|
|
<paramref name="resultSelector"/>.</returns>
|
|
<remarks>
|
|
This method uses deferred execution semantics and streams its
|
|
results. At most, <paramref name="count"/> elements of the source
|
|
sequence may be buffered at any one time unless
|
|
<paramref name="source"/> is a collection or a list.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.DistinctByExtension">
|
|
<summary><c>DistinctBy</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.DistinctByExtension.DistinctBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
|
|
<summary>
|
|
Returns all distinct elements of the given source, where "distinctness"
|
|
is determined via a projection and the default equality comparer for the projected type.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses deferred execution and streams the results, although
|
|
a set of already-seen keys is retained. If a key is seen multiple times,
|
|
only the first element with that key is returned.
|
|
</remarks>
|
|
<typeparam name="TSource">Type of the source sequence</typeparam>
|
|
<typeparam name="TKey">Type of the projected element</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<param name="keySelector">Projection for determining "distinctness"</param>
|
|
<returns>A sequence consisting of distinct elements from the source sequence,
|
|
comparing them by the specified key projection.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.DistinctByExtension.DistinctBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
|
|
<summary>
|
|
Returns all distinct elements of the given source, where "distinctness"
|
|
is determined via a projection and the specified comparer for the projected type.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses deferred execution and streams the results, although
|
|
a set of already-seen keys is retained. If a key is seen multiple times,
|
|
only the first element with that key is returned.
|
|
</remarks>
|
|
<typeparam name="TSource">Type of the source sequence</typeparam>
|
|
<typeparam name="TKey">Type of the projected element</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<param name="keySelector">Projection for determining "distinctness"</param>
|
|
<param name="comparer">The equality comparer to use to determine whether or not keys are equal.
|
|
If null, the default equality comparer for <c>TSource</c> is used.</param>
|
|
<returns>A sequence consisting of distinct elements from the source sequence,
|
|
comparing them by the specified key projection.</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.EndsWithExtension">
|
|
<summary><c>EndsWith</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.EndsWithExtension.EndsWith``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Determines whether the end of the first sequence is equivalent to
|
|
the second sequence, using the default equality comparer.
|
|
</summary>
|
|
<typeparam name="T">Type of elements.</typeparam>
|
|
<param name="first">The sequence to check.</param>
|
|
<param name="second">The sequence to compare to.</param>
|
|
<returns>
|
|
<c>true</c> if <paramref name="first" /> ends with elements
|
|
equivalent to <paramref name="second" />.
|
|
</returns>
|
|
<remarks>
|
|
This is the <see cref="T:System.Collections.Generic.IEnumerable`1" /> equivalent of
|
|
<see cref="M:System.String.EndsWith(System.String)" /> and
|
|
it calls <see cref="M:System.Collections.Generic.IEqualityComparer`1.Equals(`0,`0)" /> using
|
|
<see cref="P:System.Collections.Generic.EqualityComparer`1.Default" /> on pairs of elements at
|
|
the same index.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.EndsWithExtension.EndsWith``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
|
|
<summary>
|
|
Determines whether the end of the first sequence is equivalent to
|
|
the second sequence, using the specified element equality comparer.
|
|
</summary>
|
|
<typeparam name="T">Type of elements.</typeparam>
|
|
<param name="first">The sequence to check.</param>
|
|
<param name="second">The sequence to compare to.</param>
|
|
<param name="comparer">Equality comparer to use.</param>
|
|
<returns>
|
|
<c>true</c> if <paramref name="first" /> ends with elements
|
|
equivalent to <paramref name="second" />.
|
|
</returns>
|
|
<remarks>
|
|
This is the <see cref="T:System.Collections.Generic.IEnumerable`1" /> equivalent of
|
|
<see cref="M:System.String.EndsWith(System.String)" /> and it calls
|
|
<see cref="M:System.Collections.Generic.IEqualityComparer`1.Equals(`0,`0)" /> on pairs of
|
|
elements at the same index.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.EquiZipExtension">
|
|
<summary><c>EquiZip</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.EquiZipExtension.EquiZip``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
|
|
<summary>
|
|
Returns a projection of tuples, where each tuple contains the N-th
|
|
element from each of the argument sequences. An exception is thrown
|
|
if the input sequences are of different lengths.
|
|
</summary>
|
|
<typeparam name="TFirst">Type of elements in first sequence.</typeparam>
|
|
<typeparam name="TSecond">Type of elements in second sequence.</typeparam>
|
|
<typeparam name="TResult">Type of elements in result sequence.</typeparam>
|
|
<param name="first">The first sequence.</param>
|
|
<param name="second">The second sequence.</param>
|
|
<param name="resultSelector">
|
|
Function to apply to each pair of elements.</param>
|
|
<returns>
|
|
A sequence that contains elements of the two input sequences,
|
|
combined by <paramref name="resultSelector"/>.
|
|
</returns>
|
|
<exception cref="T:System.InvalidOperationException">
|
|
The input sequences are of different lengths.
|
|
</exception>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = new[] { 1, 2, 3, 4 };
|
|
var letters = new[] { "A", "B", "C", "D" };
|
|
var zipped = numbers.EquiZip(letters, (n, l) => n + l);
|
|
]]></code>
|
|
The <c>zipped</c> variable, when iterated over, will yield "1A",
|
|
"2B", "3C", "4D" in turn.
|
|
</example>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.EquiZipExtension.EquiZip``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
|
|
<summary>
|
|
Returns a projection of tuples, where each tuple contains the N-th
|
|
element from each of the argument sequences. An exception is thrown
|
|
if the input sequences are of different lengths.
|
|
</summary>
|
|
<typeparam name="T1">Type of elements in first sequence.</typeparam>
|
|
<typeparam name="T2">Type of elements in second sequence.</typeparam>
|
|
<typeparam name="T3">Type of elements in third sequence.</typeparam>
|
|
<typeparam name="TResult">Type of elements in result sequence.</typeparam>
|
|
<param name="first">The first sequence.</param>
|
|
<param name="second">The second sequence.</param>
|
|
<param name="third">The third sequence.</param>
|
|
<param name="resultSelector">
|
|
Function to apply to each triplet of elements.</param>
|
|
<returns>
|
|
A sequence that contains elements of the three input sequences,
|
|
combined by <paramref name="resultSelector"/>.
|
|
</returns>
|
|
<exception cref="T:System.InvalidOperationException">
|
|
The input sequences are of different lengths.
|
|
</exception>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = new[] { 1, 2, 3, 4 };
|
|
var letters = new[] { "A", "B", "C", "D" };
|
|
var chars = new[] { 'a', 'b', 'c', 'd' };
|
|
var zipped = numbers.EquiZip(letters, chars, (n, l, c) => n + l + c);
|
|
]]></code>
|
|
The <c>zipped</c> variable, when iterated over, will yield "1Aa",
|
|
"2Bb", "3Cc", "4Dd" in turn.
|
|
</example>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.EquiZipExtension.EquiZip``5(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Func{``0,``1,``2,``3,``4})">
|
|
<summary>
|
|
Returns a projection of tuples, where each tuple contains the N-th
|
|
element from each of the argument sequences. An exception is thrown
|
|
if the input sequences are of different lengths.
|
|
</summary>
|
|
<typeparam name="T1">Type of elements in first sequence</typeparam>
|
|
<typeparam name="T2">Type of elements in second sequence</typeparam>
|
|
<typeparam name="T3">Type of elements in third sequence</typeparam>
|
|
<typeparam name="T4">Type of elements in fourth sequence</typeparam>
|
|
<typeparam name="TResult">Type of elements in result sequence</typeparam>
|
|
<param name="first">The first sequence.</param>
|
|
<param name="second">The second sequence.</param>
|
|
<param name="third">The third sequence.</param>
|
|
<param name="fourth">The fourth sequence.</param>
|
|
<param name="resultSelector">
|
|
Function to apply to each quadruplet of elements.</param>
|
|
<returns>
|
|
A sequence that contains elements of the four input sequences,
|
|
combined by <paramref name="resultSelector"/>.
|
|
</returns>
|
|
<exception cref="T:System.InvalidOperationException">
|
|
The input sequences are of different lengths.
|
|
</exception>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = new[] { 1, 2, 3, 4 };
|
|
var letters = new[] { "A", "B", "C", "D" };
|
|
var chars = new[] { 'a', 'b', 'c', 'd' };
|
|
var flags = new[] { true, false, true, false };
|
|
var zipped = numbers.EquiZip(letters, chars, flags, (n, l, c, f) => n + l + c + f);
|
|
]]></code>
|
|
The <c>zipped</c> variable, when iterated over, will yield "1AaTrue",
|
|
"2BbFalse", "3CcTrue", "4DdFalse" in turn.
|
|
</example>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.EvaluateExtension">
|
|
<summary><c>Evaluate</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.EvaluateExtension.Evaluate``1(System.Collections.Generic.IEnumerable{System.Func{``0}})">
|
|
<summary>
|
|
Returns a sequence containing the values resulting from invoking (in order) each function in the source sequence of functions.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses deferred execution and streams the results.
|
|
If the resulting sequence is enumerated multiple times, the functions will be
|
|
evaluated multiple times too.
|
|
</remarks>
|
|
<typeparam name="T">The type of the object returned by the functions.</typeparam>
|
|
<param name="functions">The functions to evaluate.</param>
|
|
<returns>A sequence with results from invoking <paramref name="functions"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException">When <paramref name="functions"/> is <c>null</c>.</exception>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.ExactlyExtension">
|
|
<summary><c>Exactly</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ExactlyExtension.Exactly``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Determines whether or not the number of elements in the sequence is equals to the given integer.
|
|
</summary>
|
|
<typeparam name="T">Element type of sequence</typeparam>
|
|
<param name="source">The source sequence</param>
|
|
<param name="count">The exactly number of items a sequence must have for this
|
|
function to return true</param>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentOutOfRangeException"><paramref name="count"/> is negative</exception>
|
|
<returns><c>true</c> if the number of elements in the sequence is equals
|
|
to the given integer or <c>false</c> otherwise.</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = new[] { 123, 456, 789 };
|
|
var result = numbers.Exactly(3);
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>true</c>.
|
|
</example>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.ExceptByExtension">
|
|
<summary><c>ExceptBy</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ExceptByExtension.ExceptBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
|
|
<summary>
|
|
Returns the set of elements in the first sequence which aren't
|
|
in the second sequence, according to a given key selector.
|
|
</summary>
|
|
<remarks>
|
|
This is a set operation; if multiple elements in <paramref name="first"/> have
|
|
equal keys, only the first such element is returned.
|
|
This operator uses deferred execution and streams the results, although
|
|
a set of keys from <paramref name="second"/> is immediately selected and retained.
|
|
</remarks>
|
|
<typeparam name="TSource">The type of the elements in the input sequences.</typeparam>
|
|
<typeparam name="TKey">The type of the key returned by <paramref name="keySelector"/>.</typeparam>
|
|
<param name="first">The sequence of potentially included elements.</param>
|
|
<param name="second">The sequence of elements whose keys may prevent elements in
|
|
<paramref name="first"/> from being returned.</param>
|
|
<param name="keySelector">The mapping from source element to key.</param>
|
|
<returns>A sequence of elements from <paramref name="first"/> whose key was not also a key for
|
|
any element in <paramref name="second"/>.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ExceptByExtension.ExceptBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
|
|
<summary>
|
|
Returns the set of elements in the first sequence which aren't
|
|
in the second sequence, according to a given key selector.
|
|
</summary>
|
|
<remarks>
|
|
This is a set operation; if multiple elements in <paramref name="first"/> have
|
|
equal keys, only the first such element is returned.
|
|
This operator uses deferred execution and streams the results, although
|
|
a set of keys from <paramref name="second"/> is immediately selected and retained.
|
|
</remarks>
|
|
<typeparam name="TSource">The type of the elements in the input sequences.</typeparam>
|
|
<typeparam name="TKey">The type of the key returned by <paramref name="keySelector"/>.</typeparam>
|
|
<param name="first">The sequence of potentially included elements.</param>
|
|
<param name="second">The sequence of elements whose keys may prevent elements in
|
|
<paramref name="first"/> from being returned.</param>
|
|
<param name="keySelector">The mapping from source element to key.</param>
|
|
<param name="keyComparer">The equality comparer to use to determine whether or not keys are equal.
|
|
If null, the default equality comparer for <c>TSource</c> is used.</param>
|
|
<returns>A sequence of elements from <paramref name="first"/> whose key was not also a key for
|
|
any element in <paramref name="second"/>.</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.ExcludeExtension">
|
|
<summary><c>Exclude</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ExcludeExtension.Exclude``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Int32)">
|
|
<summary>
|
|
Excludes a contiguous number of elements from a sequence starting
|
|
at a given index.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements of the sequence</typeparam>
|
|
<param name="sequence">The sequence to exclude elements from</param>
|
|
<param name="startIndex">The zero-based index at which to begin excluding elements</param>
|
|
<param name="count">The number of elements to exclude</param>
|
|
<returns>A sequence that excludes the specified portion of elements</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.FallbackIfEmptyExtension">
|
|
<summary><c>FallbackIfEmpty</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty``1(System.Collections.Generic.IEnumerable{``0},``0)">
|
|
<summary>
|
|
Returns the elements of the specified sequence or the specified
|
|
value in a singleton collection if the sequence is empty.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequences.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="fallback">The value to return in a singleton
|
|
collection if <paramref name="source"/> is empty.</param>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that contains <paramref name="fallback"/>
|
|
if <paramref name="source"/> is empty; otherwise, <paramref name="source"/>.
|
|
</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = new[] { 123, 456, 789 };
|
|
var result = numbers.Where(x => x == 100).FallbackIfEmpty(-1).Single();
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>-1</c>.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Returns the elements of a sequence, but if it is empty then
|
|
returns an alternate sequence of values.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequences.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="fallback">The alternate sequence that is returned
|
|
if <paramref name="source"/> is empty.</param>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that containing fallback values
|
|
if <paramref name="source"/> is empty; otherwise, <paramref name="source"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty``1(System.Collections.Generic.IEnumerable{``0},``0[])">
|
|
<summary>
|
|
Returns the elements of a sequence, but if it is empty then
|
|
returns an alternate sequence from an array of values.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequences.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="fallback">The array that is returned as the alternate
|
|
sequence if <paramref name="source"/> is empty.</param>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that containing fallback values
|
|
if <paramref name="source"/> is empty; otherwise, <paramref name="source"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty``1(System.Collections.Generic.IEnumerable{``0},``0,``0)">
|
|
<summary>
|
|
Returns the elements of a sequence, but if it is empty then
|
|
returns an alternate sequence of values.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequences.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="fallback1">First value of the alternate sequence that
|
|
is returned if <paramref name="source"/> is empty.</param>
|
|
<param name="fallback2">Second value of the alternate sequence that
|
|
is returned if <paramref name="source"/> is empty.</param>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that containing fallback values
|
|
if <paramref name="source"/> is empty; otherwise, <paramref name="source"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty``1(System.Collections.Generic.IEnumerable{``0},``0,``0,``0)">
|
|
<summary>
|
|
Returns the elements of a sequence, but if it is empty then
|
|
returns an alternate sequence of values.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequences.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="fallback1">First value of the alternate sequence that
|
|
is returned if <paramref name="source"/> is empty.</param>
|
|
<param name="fallback2">Second value of the alternate sequence that
|
|
is returned if <paramref name="source"/> is empty.</param>
|
|
<param name="fallback3">Third value of the alternate sequence that
|
|
is returned if <paramref name="source"/> is empty.</param>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that containing fallback values
|
|
if <paramref name="source"/> is empty; otherwise, <paramref name="source"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty``1(System.Collections.Generic.IEnumerable{``0},``0,``0,``0,``0)">
|
|
<summary>
|
|
Returns the elements of a sequence, but if it is empty then
|
|
returns an alternate sequence of values.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequences.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="fallback1">First value of the alternate sequence that
|
|
is returned if <paramref name="source"/> is empty.</param>
|
|
<param name="fallback2">Second value of the alternate sequence that
|
|
is returned if <paramref name="source"/> is empty.</param>
|
|
<param name="fallback3">Third value of the alternate sequence that
|
|
is returned if <paramref name="source"/> is empty.</param>
|
|
<param name="fallback4">Fourth value of the alternate sequence that
|
|
is returned if <paramref name="source"/> is empty.</param>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that containing fallback values
|
|
if <paramref name="source"/> is empty; otherwise, <paramref name="source"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.FillBackwardExtension">
|
|
<summary><c>FillBackward</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FillBackwardExtension.FillBackward``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Returns a sequence with each null reference or value in the source
|
|
replaced with the following non-null reference or value in
|
|
that sequence.
|
|
</summary>
|
|
<param name="source">The source sequence.</param>
|
|
<typeparam name="T">Type of the elements in the source sequence.</typeparam>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> with null references or values
|
|
replaced.
|
|
</returns>
|
|
<remarks>
|
|
This method uses deferred execution semantics and streams its
|
|
results. If references or values are null at the end of the
|
|
sequence then they remain null.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FillBackwardExtension.FillBackward``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="predicate">The function used to determine if
|
|
an element in the sequence is considered missing.</param>
|
|
<typeparam name="T">Type of the elements in the source sequence.</typeparam>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> with missing values replaced.
|
|
</returns>
|
|
<remarks>
|
|
This method uses deferred execution semantics and streams its
|
|
results. If elements are missing at the end of the sequence then
|
|
they remain missing.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FillBackwardExtension.FillBackward``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},System.Func{``0,``0,``0})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="predicate">The function used to determine if
|
|
an element in the sequence is considered missing.</param>
|
|
<param name="fillSelector">The function used to produce the element
|
|
that will replace the missing one. Its first argument receives the
|
|
current element considered missing while the second argument
|
|
receives the next non-missing element.</param>
|
|
<typeparam name="T">Type of the elements in the source sequence.</typeparam>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> with missing values replaced.
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> with missing elements filled.
|
|
</returns>
|
|
<remarks>
|
|
This method uses deferred execution semantics and streams its
|
|
results. If elements are missing at the end of the sequence then
|
|
they remain missing.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.FillForwardExtension">
|
|
<summary><c>FillForward</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FillForwardExtension.FillForward``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<param name="source">The source sequence.</param>
|
|
<typeparam name="T">Type of the elements in the source sequence.</typeparam>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> with null references or values
|
|
replaced.
|
|
</returns>
|
|
<remarks>
|
|
This method uses deferred execution semantics and streams its
|
|
results. If references or values are null at the start of the
|
|
sequence then they remain null.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FillForwardExtension.FillForward``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="predicate">The function used to determine if
|
|
an element in the sequence is considered missing.</param>
|
|
<typeparam name="T">Type of the elements in the source sequence.</typeparam>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> with missing values replaced.
|
|
</returns>
|
|
<remarks>
|
|
This method uses deferred execution semantics and streams its
|
|
results. If elements are missing at the start of the sequence then
|
|
they remain missing.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FillForwardExtension.FillForward``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},System.Func{``0,``0,``0})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="predicate">The function used to determine if
|
|
an element in the sequence is considered missing.</param>
|
|
<param name="fillSelector">The function used to produce the element
|
|
that will replace the missing one. Its first argument receives the
|
|
current element considered missing while the second argument
|
|
receives the previous non-missing element.</param>
|
|
<typeparam name="T">Type of the elements in the source sequence.</typeparam>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> with missing values replaced.
|
|
</returns>
|
|
<remarks>
|
|
This method uses deferred execution semantics and streams its
|
|
results. If elements are missing at the start of the sequence then
|
|
they remain missing.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.FirstExtension">
|
|
<summary><c>First</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FirstExtension.First``1(MoreLinq.IExtremaEnumerable{``0})">
|
|
<summary>
|
|
Returns the first element of a sequence.
|
|
</summary>
|
|
<typeparam name="T">
|
|
The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The input sequence.</param>
|
|
<exception cref="T:System.InvalidOperationException">
|
|
The input sequence is empty.</exception>
|
|
<returns>
|
|
The first element of the input sequence.
|
|
</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.FirstOrDefaultExtension">
|
|
<summary><c>FirstOrDefault</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FirstOrDefaultExtension.FirstOrDefault``1(MoreLinq.IExtremaEnumerable{``0})">
|
|
<summary>
|
|
Returns the first element of a sequence, or a default value if the
|
|
sequence contains no elements.
|
|
</summary>
|
|
<typeparam name="T">
|
|
The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The input sequence.</param>
|
|
<returns>
|
|
Default value of type <typeparamref name="T"/> if source is empty;
|
|
otherwise, the first element in source.
|
|
</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.FlattenExtension">
|
|
<summary><c>Flatten</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FlattenExtension.Flatten(System.Collections.IEnumerable)">
|
|
<summary>
|
|
Flattens a sequence containing arbitrarily-nested sequences.
|
|
</summary>
|
|
<param name="source">The sequence that will be flattened.</param>
|
|
<returns>
|
|
A sequence that contains the elements of <paramref name="source"/>
|
|
and all nested sequences (except strings).
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null.</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FlattenExtension.Flatten(System.Collections.IEnumerable,System.Func{System.Collections.IEnumerable,System.Boolean})">
|
|
<summary>
|
|
Flattens a sequence containing arbitrarily-nested sequences. An
|
|
additional parameter specifies a predicate function used to
|
|
determine whether a nested <see cref="T:System.Collections.IEnumerable"/> should be
|
|
flattened or not.
|
|
</summary>
|
|
<param name="source">The sequence that will be flattened.</param>
|
|
<param name="predicate">
|
|
A function that receives each element that implements
|
|
<see cref="T:System.Collections.IEnumerable"/> and indicates if its elements should be
|
|
recursively flattened into the resulting sequence.
|
|
</param>
|
|
<returns>
|
|
A sequence that contains the elements of <paramref name="source"/>
|
|
and all nested sequences for which the predicate function
|
|
returned <c>true</c>.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> is <c>null</c>.</exception>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="predicate"/> is <c>null</c>.</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FlattenExtension.Flatten(System.Collections.IEnumerable,System.Func{System.Object,System.Collections.IEnumerable})">
|
|
<summary>
|
|
Flattens a sequence containing arbitrarily-nested sequences. An
|
|
additional parameter specifies a function that projects an inner
|
|
sequence via a property of an object.
|
|
</summary>
|
|
<param name="source">The sequence that will be flattened.</param>
|
|
<param name="selector">
|
|
A function that receives each element of the sequence as an object
|
|
and projects an inner sequence to be flattened. If the function
|
|
returns <c>null</c> then the object argument is considered a leaf
|
|
of the flattening process.
|
|
</param>
|
|
<returns>
|
|
A sequence that contains the elements of <paramref name="source"/>
|
|
and all nested sequences projected via the
|
|
<paramref name="selector"/> function.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> is <c>null</c>.</exception>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="selector"/> is <c>null</c>.</exception>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.FoldExtension">
|
|
<summary><c>Fold</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FoldExtension.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
1 element.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 1 element</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FoldExtension.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
2 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 2 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FoldExtension.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
3 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 3 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FoldExtension.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
4 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 4 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FoldExtension.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
5 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 5 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FoldExtension.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
6 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 6 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FoldExtension.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
7 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 7 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FoldExtension.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
8 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 8 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FoldExtension.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
9 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 9 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FoldExtension.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
10 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 10 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FoldExtension.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
11 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 11 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FoldExtension.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
12 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 12 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FoldExtension.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
13 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 13 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FoldExtension.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
14 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 14 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FoldExtension.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
15 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 15 elements</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FoldExtension.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``1})">
|
|
<summary>
|
|
Returns the result of applying a function to a sequence of
|
|
16 elements.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers
|
|
as many items of the source sequence as necessary.
|
|
</remarks>
|
|
<typeparam name="T">Type of element in the source sequence</typeparam>
|
|
<typeparam name="TResult">Type of the result</typeparam>
|
|
<param name="source">The sequence of items to fold.</param>
|
|
<param name="folder">Function to apply to the elements in the sequence.</param>
|
|
<returns>The folded value returned by <paramref name="folder"/>.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
|
|
<exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 16 elements</exception>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.ForEachExtension">
|
|
<summary><c>ForEach</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ForEachExtension.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0})">
|
|
<summary>
|
|
Immediately executes the given action on each element in the source sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequence</typeparam>
|
|
<param name="source">The sequence of elements</param>
|
|
<param name="action">The action to execute on each element</param>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ForEachExtension.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0,System.Int32})">
|
|
<summary>
|
|
Immediately executes the given action on each element in the source sequence.
|
|
Each element's index is used in the logic of the action.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequence</typeparam>
|
|
<param name="source">The sequence of elements</param>
|
|
<param name="action">The action to execute on each element; the second parameter
|
|
of the action represents the index of the source element.</param>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.FullGroupJoinExtension">
|
|
<summary><c>FullGroupJoin</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2})">
|
|
<summary>
|
|
Performs a Full Group Join between the <paramref name="first"/> and <paramref name="second"/> sequences.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses deferred execution and streams the results.
|
|
The results are yielded in the order of the elements found in the first sequence
|
|
followed by those found only in the second. In addition, the callback responsible
|
|
for projecting the results is supplied with sequences which preserve their source order.
|
|
</remarks>
|
|
<typeparam name="TFirst">The type of the elements in the first input sequence</typeparam>
|
|
<typeparam name="TSecond">The type of the elements in the second input sequence</typeparam>
|
|
<typeparam name="TKey">The type of the key to use to join</typeparam>
|
|
<param name="first">First sequence</param>
|
|
<param name="second">Second sequence</param>
|
|
<param name="firstKeySelector">The mapping from first sequence to key</param>
|
|
<param name="secondKeySelector">The mapping from second sequence to key</param>
|
|
<returns>A sequence of elements joined from <paramref name="first"/> and <paramref name="second"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Collections.Generic.IEqualityComparer{``2})">
|
|
<summary>
|
|
Performs a Full Group Join between the <paramref name="first"/> and <paramref name="second"/> sequences.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses deferred execution and streams the results.
|
|
The results are yielded in the order of the elements found in the first sequence
|
|
followed by those found only in the second. In addition, the callback responsible
|
|
for projecting the results is supplied with sequences which preserve their source order.
|
|
</remarks>
|
|
<typeparam name="TFirst">The type of the elements in the first input sequence</typeparam>
|
|
<typeparam name="TSecond">The type of the elements in the second input sequence</typeparam>
|
|
<typeparam name="TKey">The type of the key to use to join</typeparam>
|
|
<param name="first">First sequence</param>
|
|
<param name="second">Second sequence</param>
|
|
<param name="firstKeySelector">The mapping from first sequence to key</param>
|
|
<param name="secondKeySelector">The mapping from second sequence to key</param>
|
|
<param name="comparer">The equality comparer to use to determine whether or not keys are equal.
|
|
If null, the default equality comparer for <c>TKey</c> is used.</param>
|
|
<returns>A sequence of elements joined from <paramref name="first"/> and <paramref name="second"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``2,System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},``3})">
|
|
<summary>
|
|
Performs a full group-join between two sequences.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses deferred execution and streams the results.
|
|
The results are yielded in the order of the elements found in the first sequence
|
|
followed by those found only in the second. In addition, the callback responsible
|
|
for projecting the results is supplied with sequences which preserve their source order.
|
|
</remarks>
|
|
<typeparam name="TFirst">The type of the elements in the first input sequence</typeparam>
|
|
<typeparam name="TSecond">The type of the elements in the second input sequence</typeparam>
|
|
<typeparam name="TKey">The type of the key to use to join</typeparam>
|
|
<typeparam name="TResult">The type of the elements of the resulting sequence</typeparam>
|
|
<param name="first">First sequence</param>
|
|
<param name="second">Second sequence</param>
|
|
<param name="firstKeySelector">The mapping from first sequence to key</param>
|
|
<param name="secondKeySelector">The mapping from second sequence to key</param>
|
|
<param name="resultSelector">Function to apply to each pair of elements plus the key</param>
|
|
<returns>A sequence of elements joined from <paramref name="first"/> and <paramref name="second"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``2,System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},``3},System.Collections.Generic.IEqualityComparer{``2})">
|
|
<summary>
|
|
Performs a full group-join between two sequences.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses deferred execution and streams the results.
|
|
The results are yielded in the order of the elements found in the first sequence
|
|
followed by those found only in the second. In addition, the callback responsible
|
|
for projecting the results is supplied with sequences which preserve their source order.
|
|
</remarks>
|
|
<typeparam name="TFirst">The type of the elements in the first input sequence</typeparam>
|
|
<typeparam name="TSecond">The type of the elements in the second input sequence</typeparam>
|
|
<typeparam name="TKey">The type of the key to use to join</typeparam>
|
|
<typeparam name="TResult">The type of the elements of the resulting sequence</typeparam>
|
|
<param name="first">First sequence</param>
|
|
<param name="second">Second sequence</param>
|
|
<param name="firstKeySelector">The mapping from first sequence to key</param>
|
|
<param name="secondKeySelector">The mapping from second sequence to key</param>
|
|
<param name="resultSelector">Function to apply to each pair of elements plus the key</param>
|
|
<param name="comparer">The equality comparer to use to determine whether or not keys are equal.
|
|
If null, the default equality comparer for <c>TKey</c> is used.</param>
|
|
<returns>A sequence of elements joined from <paramref name="first"/> and <paramref name="second"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.FullJoinExtension">
|
|
<summary><c>FullJoin</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FullJoinExtension.FullJoin``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``0,``2},System.Func{``0,``0,``2})">
|
|
<summary>
|
|
Performs a full outer join on two homogeneous sequences.
|
|
Additional arguments specify key selection functions and result
|
|
projection functions.
|
|
</summary>
|
|
<typeparam name="TSource">
|
|
The type of elements in the source sequence.</typeparam>
|
|
<typeparam name="TKey">
|
|
The type of the key returned by the key selector function.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the result elements.</typeparam>
|
|
<param name="first">
|
|
The first sequence to join fully.</param>
|
|
<param name="second">
|
|
The second sequence to join fully.</param>
|
|
<param name="keySelector">
|
|
Function that projects the key given an element of one of the
|
|
sequences to join.</param>
|
|
<param name="firstSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="first"/> where there is no corresponding element
|
|
in <paramref name="second"/>.</param>
|
|
<param name="secondSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="second"/> where there is no corresponding element
|
|
in <paramref name="first"/>.</param>
|
|
<param name="bothSelector">
|
|
Function that projects the result given an element from
|
|
<paramref name="first"/> and an element from <paramref name="second"/>
|
|
that match on a common key.</param>
|
|
<returns>A sequence containing results projected from a full
|
|
outer join of the two input sequences.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FullJoinExtension.FullJoin``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``0,``2},System.Func{``0,``0,``2},System.Collections.Generic.IEqualityComparer{``1})">
|
|
<summary>
|
|
Performs a full outer join on two homogeneous sequences.
|
|
Additional arguments specify key selection functions, result
|
|
projection functions and a key comparer.
|
|
</summary>
|
|
<typeparam name="TSource">
|
|
The type of elements in the source sequence.</typeparam>
|
|
<typeparam name="TKey">
|
|
The type of the key returned by the key selector function.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the result elements.</typeparam>
|
|
<param name="first">
|
|
The first sequence to join fully.</param>
|
|
<param name="second">
|
|
The second sequence to join fully.</param>
|
|
<param name="keySelector">
|
|
Function that projects the key given an element of one of the
|
|
sequences to join.</param>
|
|
<param name="firstSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="first"/> where there is no corresponding element
|
|
in <paramref name="second"/>.</param>
|
|
<param name="secondSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="second"/> where there is no corresponding element
|
|
in <paramref name="first"/>.</param>
|
|
<param name="bothSelector">
|
|
Function that projects the result given an element from
|
|
<paramref name="first"/> and an element from <paramref name="second"/>
|
|
that match on a common key.</param>
|
|
<param name="comparer">
|
|
The <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> instance used to compare
|
|
keys for equality.</param>
|
|
<returns>A sequence containing results projected from a full
|
|
outer join of the two input sequences.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FullJoinExtension.FullJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,``3},System.Func{``1,``3},System.Func{``0,``1,``3})">
|
|
<summary>
|
|
Performs a full outer join on two heterogeneous sequences.
|
|
Additional arguments specify key selection functions and result
|
|
projection functions.
|
|
</summary>
|
|
<typeparam name="TFirst">
|
|
The type of elements in the first sequence.</typeparam>
|
|
<typeparam name="TSecond">
|
|
The type of elements in the second sequence.</typeparam>
|
|
<typeparam name="TKey">
|
|
The type of the key returned by the key selector functions.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the result elements.</typeparam>
|
|
<param name="first">
|
|
The first sequence to join fully.</param>
|
|
<param name="second">
|
|
The second sequence to join fully.</param>
|
|
<param name="firstKeySelector">
|
|
Function that projects the key given an element from <paramref name="first"/>.</param>
|
|
<param name="secondKeySelector">
|
|
Function that projects the key given an element from <paramref name="second"/>.</param>
|
|
<param name="firstSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="first"/> where there is no corresponding element
|
|
in <paramref name="second"/>.</param>
|
|
<param name="secondSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="second"/> where there is no corresponding element
|
|
in <paramref name="first"/>.</param>
|
|
<param name="bothSelector">
|
|
Function that projects the result given an element from
|
|
<paramref name="first"/> and an element from <paramref name="second"/>
|
|
that match on a common key.</param>
|
|
<returns>A sequence containing results projected from a full
|
|
outer join of the two input sequences.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.FullJoinExtension.FullJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,``3},System.Func{``1,``3},System.Func{``0,``1,``3},System.Collections.Generic.IEqualityComparer{``2})">
|
|
<summary>
|
|
Performs a full outer join on two heterogeneous sequences.
|
|
Additional arguments specify key selection functions, result
|
|
projection functions and a key comparer.
|
|
</summary>
|
|
<typeparam name="TFirst">
|
|
The type of elements in the first sequence.</typeparam>
|
|
<typeparam name="TSecond">
|
|
The type of elements in the second sequence.</typeparam>
|
|
<typeparam name="TKey">
|
|
The type of the key returned by the key selector functions.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the result elements.</typeparam>
|
|
<param name="first">
|
|
The first sequence to join fully.</param>
|
|
<param name="second">
|
|
The second sequence to join fully.</param>
|
|
<param name="firstKeySelector">
|
|
Function that projects the key given an element from <paramref name="first"/>.</param>
|
|
<param name="secondKeySelector">
|
|
Function that projects the key given an element from <paramref name="second"/>.</param>
|
|
<param name="firstSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="first"/> where there is no corresponding element
|
|
in <paramref name="second"/>.</param>
|
|
<param name="secondSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="second"/> where there is no corresponding element
|
|
in <paramref name="first"/>.</param>
|
|
<param name="bothSelector">
|
|
Function that projects the result given an element from
|
|
<paramref name="first"/> and an element from <paramref name="second"/>
|
|
that match on a common key.</param>
|
|
<param name="comparer">
|
|
The <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> instance used to compare
|
|
keys for equality.</param>
|
|
<returns>A sequence containing results projected from a full
|
|
outer join of the two input sequences.</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.GroupAdjacentExtension">
|
|
<summary><c>GroupAdjacent</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
|
|
<summary>
|
|
Groups the adjacent elements of a sequence according to a
|
|
specified key selector function.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of
|
|
<paramref name="source"/>.</typeparam>
|
|
<typeparam name="TKey">The type of the key returned by
|
|
<paramref name="keySelector"/>.</typeparam>
|
|
<param name="source">A sequence whose elements to group.</param>
|
|
<param name="keySelector">A function to extract the key for each
|
|
element.</param>
|
|
<returns>A sequence of groupings where each grouping
|
|
(<see cref="T:System.Linq.IGrouping`2"/>) contains the key
|
|
and the adjacent elements in the same order as found in the
|
|
source sequence.</returns>
|
|
<remarks>
|
|
This method is implemented by using deferred execution and
|
|
streams the groupings. The grouping elements, however, are
|
|
buffered. Each grouping is therefore yielded as soon as it
|
|
is complete and before the next grouping occurs.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
|
|
<summary>
|
|
Groups the adjacent elements of a sequence according to a
|
|
specified key selector function and compares the keys by using a
|
|
specified comparer.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of
|
|
<paramref name="source"/>.</typeparam>
|
|
<typeparam name="TKey">The type of the key returned by
|
|
<paramref name="keySelector"/>.</typeparam>
|
|
<param name="source">A sequence whose elements to group.</param>
|
|
<param name="keySelector">A function to extract the key for each
|
|
element.</param>
|
|
<param name="comparer">An <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> to
|
|
compare keys.</param>
|
|
<returns>A sequence of groupings where each grouping
|
|
(<see cref="T:System.Linq.IGrouping`2"/>) contains the key
|
|
and the adjacent elements in the same order as found in the
|
|
source sequence.</returns>
|
|
<remarks>
|
|
This method is implemented by using deferred execution and
|
|
streams the groupings. The grouping elements, however, are
|
|
buffered. Each grouping is therefore yielded as soon as it
|
|
is complete and before the next grouping occurs.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of
|
|
<paramref name="source"/>.</typeparam>
|
|
<typeparam name="TKey">The type of the key returned by
|
|
<paramref name="keySelector"/>.</typeparam>
|
|
<typeparam name="TElement">The type of the elements in the
|
|
resulting groupings.</typeparam>
|
|
<param name="source">A sequence whose elements to group.</param>
|
|
<param name="keySelector">A function to extract the key for each
|
|
element.</param>
|
|
<param name="elementSelector">A function to map each source
|
|
element to an element in the resulting grouping.</param>
|
|
<returns>A sequence of groupings where each grouping
|
|
(<see cref="T:System.Linq.IGrouping`2"/>) contains the key
|
|
and the adjacent elements (of type <typeparamref name="TElement"/>)
|
|
in the same order as found in the source sequence.</returns>
|
|
<remarks>
|
|
This method is implemented by using deferred execution and
|
|
streams the groupings. The grouping elements, however, are
|
|
buffered. Each grouping is therefore yielded as soon as it
|
|
is complete and before the next grouping occurs.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,System.Collections.Generic.IEnumerable{``0},``2})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of
|
|
<paramref name="source"/>.</typeparam>
|
|
<typeparam name="TKey">The type of the key returned by
|
|
<paramref name="keySelector"/>.</typeparam>
|
|
<typeparam name="TResult">The type of the elements in the
|
|
resulting sequence.</typeparam>
|
|
<param name="source">A sequence whose elements to group.</param>
|
|
<param name="keySelector">A function to extract the key for each
|
|
element.</param>
|
|
<param name="resultSelector">A function to map each key and
|
|
associated source elements to a result object.</param>
|
|
<returns>A collection of elements of type
|
|
<typeparamref name="TResult" /> where each element represents
|
|
a projection over a group and its key.</returns>
|
|
<remarks>
|
|
This method is implemented by using deferred execution and
|
|
streams the groupings. The grouping elements, however, are
|
|
buffered. Each grouping is therefore yielded as soon as it
|
|
is complete and before the next grouping occurs.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IEqualityComparer{``1})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of
|
|
<paramref name="source"/>.</typeparam>
|
|
<typeparam name="TKey">The type of the key returned by
|
|
<paramref name="keySelector"/>.</typeparam>
|
|
<typeparam name="TElement">The type of the elements in the
|
|
resulting groupings.</typeparam>
|
|
<param name="source">A sequence whose elements to group.</param>
|
|
<param name="keySelector">A function to extract the key for each
|
|
element.</param>
|
|
<param name="elementSelector">A function to map each source
|
|
element to an element in the resulting grouping.</param>
|
|
<param name="comparer">An <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> to
|
|
compare keys.</param>
|
|
<returns>A sequence of groupings where each grouping
|
|
(<see cref="T:System.Linq.IGrouping`2"/>) contains the key
|
|
and the adjacent elements (of type <typeparamref name="TElement"/>)
|
|
in the same order as found in the source sequence.</returns>
|
|
<remarks>
|
|
This method is implemented by using deferred execution and
|
|
streams the groupings. The grouping elements, however, are
|
|
buffered. Each grouping is therefore yielded as soon as it
|
|
is complete and before the next grouping occurs.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,System.Collections.Generic.IEnumerable{``0},``2},System.Collections.Generic.IEqualityComparer{``1})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of
|
|
<paramref name="source"/>.</typeparam>
|
|
<typeparam name="TKey">The type of the key returned by
|
|
<paramref name="keySelector"/>.</typeparam>
|
|
<typeparam name="TResult">The type of the elements in the
|
|
resulting sequence.</typeparam>
|
|
<param name="source">A sequence whose elements to group.</param>
|
|
<param name="keySelector">A function to extract the key for each
|
|
element.</param>
|
|
<param name="resultSelector">A function to map each key and
|
|
associated source elements to a result object.</param>
|
|
<param name="comparer">An <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> to
|
|
compare keys.</param>
|
|
<returns>A collection of elements of type
|
|
<typeparamref name="TResult" /> where each element represents
|
|
a projection over a group and its key.</returns>
|
|
<remarks>
|
|
This method is implemented by using deferred execution and
|
|
streams the groupings. The grouping elements, however, are
|
|
buffered. Each grouping is therefore yielded as soon as it
|
|
is complete and before the next grouping occurs.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.IndexExtension">
|
|
<summary><c>Index</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.IndexExtension.Index``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Returns a sequence of <see cref="T:System.Collections.Generic.KeyValuePair`2"/>
|
|
where the key is the zero-based index of the value in the source
|
|
sequence.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<returns>A sequence of <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.</returns>
|
|
<remarks>This operator uses deferred execution and streams its
|
|
results.</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.IndexExtension.Index``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Returns a sequence of <see cref="T:System.Collections.Generic.KeyValuePair`2"/>
|
|
where the key is the index of the value in the source sequence.
|
|
An additional parameter specifies the starting index.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="startIndex"></param>
|
|
<returns>A sequence of <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.</returns>
|
|
<remarks>This operator uses deferred execution and streams its
|
|
results.</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.IndexByExtension">
|
|
<summary><c>IndexBy</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.IndexByExtension.IndexBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
|
|
<summary>
|
|
Applies a key-generating function to each element of a sequence and
|
|
returns a sequence that contains the elements of the original
|
|
sequence as well its key and index inside the group of its key.
|
|
</summary>
|
|
<typeparam name="TSource">Type of the source sequence elements.</typeparam>
|
|
<typeparam name="TKey">Type of the projected key.</typeparam>
|
|
<param name="source">Source sequence.</param>
|
|
<param name="keySelector">
|
|
Function that projects the key given an element in the source sequence.</param>
|
|
<returns>
|
|
A sequence of elements paired with their index within the key-group.
|
|
The index is the key and the element is the value of the pair.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.IndexByExtension.IndexBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
|
|
<summary>
|
|
Applies a key-generating function to each element of a sequence and
|
|
returns a sequence that contains the elements of the original
|
|
sequence as well its key and index inside the group of its key.
|
|
An additional parameter specifies a comparer to use for testing the
|
|
equivalence of keys.
|
|
</summary>
|
|
<typeparam name="TSource">Type of the source sequence elements.</typeparam>
|
|
<typeparam name="TKey">Type of the projected key.</typeparam>
|
|
<param name="source">Source sequence.</param>
|
|
<param name="keySelector">
|
|
Function that projects the key given an element in the source sequence.</param>
|
|
<param name="comparer">
|
|
The equality comparer to use to determine whether or not keys are
|
|
equal. If <c>null</c>, the default equality comparer for
|
|
<typeparamref name="TSource"/> is used.</param>
|
|
<returns>
|
|
A sequence of elements paired with their index within the key-group.
|
|
The index is the key and the element is the value of the pair.
|
|
</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.InsertExtension">
|
|
<summary><c>Insert</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.InsertExtension.Insert``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Inserts the elements of a sequence into another sequence at a
|
|
specified index.
|
|
</summary>
|
|
<typeparam name="T">Type of the elements of the source sequence.</typeparam>
|
|
<param name="first">The source sequence.</param>
|
|
<param name="second">The sequence that will be inserted.</param>
|
|
<param name="index">
|
|
The zero-based index at which to insert elements from
|
|
<paramref name="second"/>.</param>
|
|
<returns>
|
|
A sequence that contains the elements of <paramref name="first"/>
|
|
plus the elements of <paramref name="second"/> inserted at
|
|
the given index.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="first"/> is null.</exception>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="second"/> is null.</exception>
|
|
<exception cref="T:System.ArgumentOutOfRangeException">
|
|
Thrown if <paramref name="index"/> is negative.
|
|
</exception>
|
|
<exception cref="T:System.ArgumentOutOfRangeException">
|
|
Thrown lazily if <paramref name="index"/> is greater than the
|
|
length of <paramref name="first"/>. The validation occurs when
|
|
yielding the next element after having iterated
|
|
<paramref name="first"/> entirely.
|
|
</exception>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.InterleaveExtension">
|
|
<summary><c>Interleave</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.InterleaveExtension.Interleave``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0}[])">
|
|
<summary>
|
|
Interleaves the elements of two or more sequences into a single sequence, skipping sequences as they are consumed
|
|
</summary>
|
|
<remarks>
|
|
Interleave combines sequences by visiting each in turn, and returning the first element of each, followed
|
|
by the second, then the third, and so on. So, for example:<br/>
|
|
<code><![CDATA[
|
|
{1,1,1}.Interleave( {2,2,2}, {3,3,3} ) => { 1,2,3,1,2,3,1,2,3 }
|
|
]]></code>
|
|
This operator behaves in a deferred and streaming manner.<br/>
|
|
When sequences are of unequal length, this method will skip those sequences that have been fully consumed
|
|
and continue interleaving the remaining sequences.<br/>
|
|
The sequences are interleaved in the order that they appear in the <paramref name="otherSequences"/>
|
|
collection, with <paramref name="sequence"/> as the first sequence.
|
|
</remarks>
|
|
<typeparam name="T">The type of the elements of the source sequences</typeparam>
|
|
<param name="sequence">The first sequence in the interleave group</param>
|
|
<param name="otherSequences">The other sequences in the interleave group</param>
|
|
<returns>A sequence of interleaved elements from all of the source sequences</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.LagExtension">
|
|
<summary><c>Lag</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.LagExtension.Lag``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,``0,``1})">
|
|
<summary>
|
|
Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset.
|
|
</summary>
|
|
<remarks>
|
|
This operator evaluates in a deferred and streaming manner.<br/>
|
|
For elements prior to the lag offset, <c>default(T)</c> is used as the lagged value.<br/>
|
|
</remarks>
|
|
<typeparam name="TSource">The type of the elements of the source sequence</typeparam>
|
|
<typeparam name="TResult">The type of the elements of the result sequence</typeparam>
|
|
<param name="source">The sequence over which to evaluate lag</param>
|
|
<param name="offset">The offset (expressed as a positive number) by which to lag each value of the sequence</param>
|
|
<param name="resultSelector">A projection function which accepts the current and lagged items (in that order) and returns a result</param>
|
|
<returns>A sequence produced by projecting each element of the sequence with its lagged pairing</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.LagExtension.Lag``2(System.Collections.Generic.IEnumerable{``0},System.Int32,``0,System.Func{``0,``0,``1})">
|
|
<summary>
|
|
Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset.
|
|
</summary>
|
|
<remarks>
|
|
This operator evaluates in a deferred and streaming manner.<br/>
|
|
</remarks>
|
|
<typeparam name="TSource">The type of the elements of the source sequence</typeparam>
|
|
<typeparam name="TResult">The type of the elements of the result sequence</typeparam>
|
|
<param name="source">The sequence over which to evaluate lag</param>
|
|
<param name="offset">The offset (expressed as a positive number) by which to lag each value of the sequence</param>
|
|
<param name="defaultLagValue">A default value supplied for the lagged value prior to the lag offset</param>
|
|
<param name="resultSelector">A projection function which accepts the current and lagged items (in that order) and returns a result</param>
|
|
<returns>A sequence produced by projecting each element of the sequence with its lagged pairing</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.LastExtension">
|
|
<summary><c>Last</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.LastExtension.Last``1(MoreLinq.IExtremaEnumerable{``0})">
|
|
<summary>
|
|
Returns the last element of a sequence.
|
|
</summary>
|
|
<typeparam name="T">
|
|
The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The input sequence.</param>
|
|
<exception cref="T:System.InvalidOperationException">
|
|
The input sequence is empty.</exception>
|
|
<returns>
|
|
The last element of the input sequence.
|
|
</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.LastOrDefaultExtension">
|
|
<summary><c>LastOrDefault</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.LastOrDefaultExtension.LastOrDefault``1(MoreLinq.IExtremaEnumerable{``0})">
|
|
<summary>
|
|
Returns the last element of a sequence, or a default value if the
|
|
sequence contains no elements.
|
|
</summary>
|
|
<typeparam name="T">
|
|
The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The input sequence.</param>
|
|
<returns>
|
|
Default value of type <typeparamref name="T"/> if source is empty;
|
|
otherwise, the last element in source.
|
|
</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.LeadExtension">
|
|
<summary><c>Lead</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.LeadExtension.Lead``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,``0,``1})">
|
|
<summary>
|
|
Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset.
|
|
</summary>
|
|
<remarks>
|
|
This operator evaluates in a deferred and streaming manner.<br/>
|
|
For elements of the sequence that are less than <paramref name="offset"/> items from the end,
|
|
default(T) is used as the lead value.<br/>
|
|
</remarks>
|
|
<typeparam name="TSource">The type of the elements in the source sequence</typeparam>
|
|
<typeparam name="TResult">The type of the elements in the result sequence</typeparam>
|
|
<param name="source">The sequence over which to evaluate Lead</param>
|
|
<param name="offset">The offset (expressed as a positive number) by which to lead each element of the sequence</param>
|
|
<param name="resultSelector">A projection function which accepts the current and subsequent (lead) element (in that order) and produces a result</param>
|
|
<returns>A sequence produced by projecting each element of the sequence with its lead pairing</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.LeadExtension.Lead``2(System.Collections.Generic.IEnumerable{``0},System.Int32,``0,System.Func{``0,``0,``1})">
|
|
<summary>
|
|
Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset.
|
|
</summary>
|
|
<remarks>
|
|
This operator evaluates in a deferred and streaming manner.<br/>
|
|
</remarks>
|
|
<typeparam name="TSource">The type of the elements in the source sequence</typeparam>
|
|
<typeparam name="TResult">The type of the elements in the result sequence</typeparam>
|
|
<param name="source">The sequence over which to evaluate Lead</param>
|
|
<param name="offset">The offset (expressed as a positive number) by which to lead each element of the sequence</param>
|
|
<param name="defaultLeadValue">A default value supplied for the leading element when none is available</param>
|
|
<param name="resultSelector">A projection function which accepts the current and subsequent (lead) element (in that order) and produces a result</param>
|
|
<returns>A sequence produced by projecting each element of the sequence with its lead pairing</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.LeftJoinExtension">
|
|
<summary><c>LeftJoin</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.LeftJoinExtension.LeftJoin``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``0,``0,``2})">
|
|
<summary>
|
|
Performs a left outer join on two homogeneous sequences.
|
|
Additional arguments specify key selection functions and result
|
|
projection functions.
|
|
</summary>
|
|
<typeparam name="TSource">
|
|
The type of elements in the source sequence.</typeparam>
|
|
<typeparam name="TKey">
|
|
The type of the key returned by the key selector function.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the result elements.</typeparam>
|
|
<param name="first">
|
|
The first sequence of the join operation.</param>
|
|
<param name="second">
|
|
The second sequence of the join operation.</param>
|
|
<param name="keySelector">
|
|
Function that projects the key given an element of one of the
|
|
sequences to join.</param>
|
|
<param name="firstSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="first"/> where there is no corresponding element
|
|
in <paramref name="second"/>.</param>
|
|
<param name="bothSelector">
|
|
Function that projects the result given an element from
|
|
<paramref name="first"/> and an element from <paramref name="second"/>
|
|
that match on a common key.</param>
|
|
<returns>A sequence containing results projected from a left
|
|
outer join of the two input sequences.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.LeftJoinExtension.LeftJoin``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``0,``0,``2},System.Collections.Generic.IEqualityComparer{``1})">
|
|
<summary>
|
|
Performs a left outer join on two homogeneous sequences.
|
|
Additional arguments specify key selection functions, result
|
|
projection functions and a key comparer.
|
|
</summary>
|
|
<typeparam name="TSource">
|
|
The type of elements in the source sequence.</typeparam>
|
|
<typeparam name="TKey">
|
|
The type of the key returned by the key selector function.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the result elements.</typeparam>
|
|
<param name="first">
|
|
The first sequence of the join operation.</param>
|
|
<param name="second">
|
|
The second sequence of the join operation.</param>
|
|
<param name="keySelector">
|
|
Function that projects the key given an element of one of the
|
|
sequences to join.</param>
|
|
<param name="firstSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="first"/> where there is no corresponding element
|
|
in <paramref name="second"/>.</param>
|
|
<param name="bothSelector">
|
|
Function that projects the result given an element from
|
|
<paramref name="first"/> and an element from <paramref name="second"/>
|
|
that match on a common key.</param>
|
|
<param name="comparer">
|
|
The <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> instance used to compare
|
|
keys for equality.</param>
|
|
<returns>A sequence containing results projected from a left
|
|
outer join of the two input sequences.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.LeftJoinExtension.LeftJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,``3},System.Func{``0,``1,``3})">
|
|
<summary>
|
|
Performs a left outer join on two heterogeneous sequences.
|
|
Additional arguments specify key selection functions and result
|
|
projection functions.
|
|
</summary>
|
|
<typeparam name="TFirst">
|
|
The type of elements in the first sequence.</typeparam>
|
|
<typeparam name="TSecond">
|
|
The type of elements in the second sequence.</typeparam>
|
|
<typeparam name="TKey">
|
|
The type of the key returned by the key selector functions.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the result elements.</typeparam>
|
|
<param name="first">
|
|
The first sequence of the join operation.</param>
|
|
<param name="second">
|
|
The second sequence of the join operation.</param>
|
|
<param name="firstKeySelector">
|
|
Function that projects the key given an element from <paramref name="first"/>.</param>
|
|
<param name="secondKeySelector">
|
|
Function that projects the key given an element from <paramref name="second"/>.</param>
|
|
<param name="firstSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="first"/> where there is no corresponding element
|
|
in <paramref name="second"/>.</param>
|
|
<param name="bothSelector">
|
|
Function that projects the result given an element from
|
|
<paramref name="first"/> and an element from <paramref name="second"/>
|
|
that match on a common key.</param>
|
|
<returns>A sequence containing results projected from a left
|
|
outer join of the two input sequences.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.LeftJoinExtension.LeftJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,``3},System.Func{``0,``1,``3},System.Collections.Generic.IEqualityComparer{``2})">
|
|
<summary>
|
|
Performs a left outer join on two heterogeneous sequences.
|
|
Additional arguments specify key selection functions, result
|
|
projection functions and a key comparer.
|
|
</summary>
|
|
<typeparam name="TFirst">
|
|
The type of elements in the first sequence.</typeparam>
|
|
<typeparam name="TSecond">
|
|
The type of elements in the second sequence.</typeparam>
|
|
<typeparam name="TKey">
|
|
The type of the key returned by the key selector functions.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the result elements.</typeparam>
|
|
<param name="first">
|
|
The first sequence of the join operation.</param>
|
|
<param name="second">
|
|
The second sequence of the join operation.</param>
|
|
<param name="firstKeySelector">
|
|
Function that projects the key given an element from <paramref name="first"/>.</param>
|
|
<param name="secondKeySelector">
|
|
Function that projects the key given an element from <paramref name="second"/>.</param>
|
|
<param name="firstSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="first"/> where there is no corresponding element
|
|
in <paramref name="second"/>.</param>
|
|
<param name="bothSelector">
|
|
Function that projects the result given an element from
|
|
<paramref name="first"/> and an element from <paramref name="second"/>
|
|
that match on a common key.</param>
|
|
<param name="comparer">
|
|
The <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> instance used to compare
|
|
keys for equality.</param>
|
|
<returns>A sequence containing results projected from a left
|
|
outer join of the two input sequences.</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.MaxByExtension">
|
|
<summary><c>MaxBy</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.MaxByExtension.MaxBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
|
|
<summary>
|
|
Returns the maximal elements of the given sequence, based on
|
|
the given projection.
|
|
</summary>
|
|
<remarks>
|
|
This overload uses the default comparer for the projected type.
|
|
This operator uses deferred execution. The results are evaluated
|
|
and cached on first use to returned sequence.
|
|
</remarks>
|
|
<typeparam name="TSource">Type of the source sequence</typeparam>
|
|
<typeparam name="TKey">Type of the projected element</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<param name="selector">Selector to use to pick the results to compare</param>
|
|
<returns>The maximal element, according to the projection.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.MaxByExtension.MaxBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})">
|
|
<summary>
|
|
Returns the maximal elements of the given sequence, based on
|
|
the given projection and the specified comparer for projected values.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses deferred execution. The results are evaluated
|
|
and cached on first use to returned sequence.
|
|
</remarks>
|
|
<typeparam name="TSource">Type of the source sequence</typeparam>
|
|
<typeparam name="TKey">Type of the projected element</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<param name="selector">Selector to use to pick the results to compare</param>
|
|
<param name="comparer">Comparer to use to compare projected values</param>
|
|
<returns>The maximal element, according to the projection.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/>, <paramref name="selector"/>
|
|
or <paramref name="comparer"/> is null</exception>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.MinByExtension">
|
|
<summary><c>MinBy</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.MinByExtension.MinBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
|
|
<summary>
|
|
Returns the minimal elements of the given sequence, based on
|
|
the given projection.
|
|
</summary>
|
|
<remarks>
|
|
This overload uses the default comparer for the projected type.
|
|
This operator uses deferred execution. The results are evaluated
|
|
and cached on first use to returned sequence.
|
|
</remarks>
|
|
<typeparam name="TSource">Type of the source sequence</typeparam>
|
|
<typeparam name="TKey">Type of the projected element</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<param name="selector">Selector to use to pick the results to compare</param>
|
|
<returns>The minimal element, according to the projection.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.MinByExtension.MinBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})">
|
|
<summary>
|
|
Returns the minimal elements of the given sequence, based on
|
|
the given projection and the specified comparer for projected values.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses deferred execution. The results are evaluated
|
|
and cached on first use to returned sequence.
|
|
</remarks>
|
|
<typeparam name="TSource">Type of the source sequence</typeparam>
|
|
<typeparam name="TKey">Type of the projected element</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<param name="selector">Selector to use to pick the results to compare</param>
|
|
<param name="comparer">Comparer to use to compare projected values</param>
|
|
<returns>The minimal element, according to the projection.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/>, <paramref name="selector"/>
|
|
or <paramref name="comparer"/> is null</exception>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.MoveExtension">
|
|
<summary><c>Move</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.MoveExtension.Move``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Int32,System.Int32)">
|
|
<summary>
|
|
Returns a sequence with a range of elements in the source sequence
|
|
moved to a new offset.
|
|
</summary>
|
|
<typeparam name="T">Type of the source sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="fromIndex">
|
|
The zero-based index identifying the first element in the range of
|
|
elements to move.</param>
|
|
<param name="count">The count of items to move.</param>
|
|
<param name="toIndex">
|
|
The index where the specified range will be moved.</param>
|
|
<returns>
|
|
A sequence with the specified range moved to the new position.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
var result = Enumerable.Range(0, 6).Move(3, 2, 0);
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>{ 3, 4, 0, 1, 2, 5 }</c>.
|
|
</example>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.OrderByExtension">
|
|
<summary><c>OrderBy</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.OrderByExtension.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},MoreLinq.OrderByDirection)">
|
|
<summary>
|
|
Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the source sequence</typeparam>
|
|
<typeparam name="TKey">The type of the key used to order elements</typeparam>
|
|
<param name="source">The sequence to order</param>
|
|
<param name="keySelector">A key selector function</param>
|
|
<param name="direction">A direction in which to order the elements (ascending, descending)</param>
|
|
<returns>An ordered copy of the source sequence</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.OrderByExtension.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1},MoreLinq.OrderByDirection)">
|
|
<summary>
|
|
Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the source sequence</typeparam>
|
|
<typeparam name="TKey">The type of the key used to order elements</typeparam>
|
|
<param name="source">The sequence to order</param>
|
|
<param name="keySelector">A key selector function</param>
|
|
<param name="direction">A direction in which to order the elements (ascending, descending)</param>
|
|
<param name="comparer">A comparer used to define the semantics of element comparison</param>
|
|
<returns>An ordered copy of the source sequence</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.OrderedMergeExtension">
|
|
<summary><c>OrderedMerge</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="T">Type of elements in input and output sequences.</typeparam>
|
|
<param name="first">The first input sequence.</param>
|
|
<param name="second">The second input sequence.</param>
|
|
<returns>
|
|
A sequence with elements from the two input sequences merged, as
|
|
in a full outer join.</returns>
|
|
<remarks>
|
|
This method uses deferred execution. The behavior is undefined
|
|
if the sequences are unordered as inputs.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="T">Type of elements in input and output sequences.</typeparam>
|
|
<param name="first">The first input sequence.</param>
|
|
<param name="second">The second input sequence.</param>
|
|
<param name="comparer">An <see cref="T:System.Collections.Generic.IComparer`1"/> to compare elements.</param>
|
|
<returns>
|
|
A sequence with elements from the two input sequences merged, as
|
|
in a full outer join.</returns>
|
|
<remarks>
|
|
This method uses deferred execution. The behavior is undefined
|
|
if the sequences are unordered as inputs.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="T">Type of elements in input and output sequences.</typeparam>
|
|
<typeparam name="TKey">Type of keys used for merging.</typeparam>
|
|
<param name="first">The first input sequence.</param>
|
|
<param name="second">The second input sequence.</param>
|
|
<param name="keySelector">Function to extract a key given an element.</param>
|
|
<returns>
|
|
A sequence with elements from the two input sequences merged
|
|
according to a key, as in a full outer join.</returns>
|
|
<remarks>
|
|
This method uses deferred execution. The behavior is undefined
|
|
if the sequences are unordered (by key) as inputs.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``0,``2},System.Func{``0,``0,``2})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="T">Type of elements in source sequences.</typeparam>
|
|
<typeparam name="TKey">Type of keys used for merging.</typeparam>
|
|
<typeparam name="TResult">Type of elements in the returned sequence.</typeparam>
|
|
<param name="first">The first input sequence.</param>
|
|
<param name="second">The second input sequence.</param>
|
|
<param name="keySelector">Function to extract a key given an element.</param>
|
|
<param name="firstSelector">Function to project the result element
|
|
when only the first sequence yields a source element.</param>
|
|
<param name="secondSelector">Function to project the result element
|
|
when only the second sequence yields a source element.</param>
|
|
<param name="bothSelector">Function to project the result element
|
|
when only both sequences yield a source element whose keys are
|
|
equal.</param>
|
|
<returns>
|
|
A sequence with projections from the two input sequences merged
|
|
according to a key, as in a full outer join.</returns>
|
|
<remarks>
|
|
This method uses deferred execution. The behavior is undefined
|
|
if the sequences are unordered (by key) as inputs.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``0,``2},System.Func{``0,``0,``2},System.Collections.Generic.IComparer{``1})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="T">Type of elements in source sequences.</typeparam>
|
|
<typeparam name="TKey">Type of keys used for merging.</typeparam>
|
|
<typeparam name="TResult">Type of elements in the returned sequence.</typeparam>
|
|
<param name="first">The first input sequence.</param>
|
|
<param name="second">The second input sequence.</param>
|
|
<param name="keySelector">Function to extract a key given an element.</param>
|
|
<param name="firstSelector">Function to project the result element
|
|
when only the first sequence yields a source element.</param>
|
|
<param name="secondSelector">Function to project the result element
|
|
when only the second sequence yields a source element.</param>
|
|
<param name="bothSelector">Function to project the result element
|
|
when only both sequences yield a source element whose keys are
|
|
equal.</param>
|
|
<param name="comparer">An <see cref="T:System.Collections.Generic.IComparer`1"/> to compare keys.</param>
|
|
<returns>
|
|
A sequence with projections from the two input sequences merged
|
|
according to a key, as in a full outer join.</returns>
|
|
<remarks>
|
|
This method uses deferred execution. The behavior is undefined
|
|
if the sequences are unordered (by key) as inputs.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,``3},System.Func{``1,``3},System.Func{``0,``1,``3})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TFirst">Type of elements in the first sequence.</typeparam>
|
|
<typeparam name="TSecond">Type of elements in the second sequence.</typeparam>
|
|
<typeparam name="TKey">Type of keys used for merging.</typeparam>
|
|
<typeparam name="TResult">Type of elements in the returned sequence.</typeparam>
|
|
<param name="first">The first input sequence.</param>
|
|
<param name="second">The second input sequence.</param>
|
|
<param name="firstKeySelector">Function to extract a key given an
|
|
element from the first sequence.</param>
|
|
<param name="secondKeySelector">Function to extract a key given an
|
|
element from the second sequence.</param>
|
|
<param name="firstSelector">Function to project the result element
|
|
when only the first sequence yields a source element.</param>
|
|
<param name="secondSelector">Function to project the result element
|
|
when only the second sequence yields a source element.</param>
|
|
<param name="bothSelector">Function to project the result element
|
|
when only both sequences yield a source element whose keys are
|
|
equal.</param>
|
|
<returns>
|
|
A sequence with projections from the two input sequences merged
|
|
according to a key, as in a full outer join.</returns>
|
|
<remarks>
|
|
This method uses deferred execution. The behavior is undefined
|
|
if the sequences are unordered (by key) as inputs.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,``3},System.Func{``1,``3},System.Func{``0,``1,``3},System.Collections.Generic.IComparer{``2})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TFirst">Type of elements in the first sequence.</typeparam>
|
|
<typeparam name="TSecond">Type of elements in the second sequence.</typeparam>
|
|
<typeparam name="TKey">Type of keys used for merging.</typeparam>
|
|
<typeparam name="TResult">Type of elements in the returned sequence.</typeparam>
|
|
<param name="first">The first input sequence.</param>
|
|
<param name="second">The second input sequence.</param>
|
|
<param name="firstKeySelector">Function to extract a key given an
|
|
element from the first sequence.</param>
|
|
<param name="secondKeySelector">Function to extract a key given an
|
|
element from the second sequence.</param>
|
|
<param name="firstSelector">Function to project the result element
|
|
when only the first sequence yields a source element.</param>
|
|
<param name="secondSelector">Function to project the result element
|
|
when only the second sequence yields a source element.</param>
|
|
<param name="bothSelector">Function to project the result element
|
|
when only both sequences yield a source element whose keys are
|
|
equal.</param>
|
|
<param name="comparer">An <see cref="T:System.Collections.Generic.IComparer`1"/> to compare keys.</param>
|
|
<returns>
|
|
A sequence with projections from the two input sequences merged
|
|
according to a key, as in a full outer join.</returns>
|
|
<remarks>
|
|
This method uses deferred execution. The behavior is undefined
|
|
if the sequences are unordered (by key) as inputs.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.PadExtension">
|
|
<summary><c>Pad</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PadExtension.Pad``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Pads a sequence with default values if it is narrower (shorter
|
|
in length) than a given width.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The sequence to pad.</param>
|
|
<param name="width">The width/length below which to pad.</param>
|
|
<returns>
|
|
Returns a sequence that is at least as wide/long as the width/length
|
|
specified by the <paramref name="width"/> parameter.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
int[] numbers = { 123, 456, 789 };
|
|
var result = numbers.Pad(5);
|
|
]]></code>
|
|
The <c>result</c> variable, when iterated over, will yield
|
|
123, 456, 789 and two zeroes, in turn.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PadExtension.Pad``1(System.Collections.Generic.IEnumerable{``0},System.Int32,``0)">
|
|
<summary>
|
|
Pads a sequence with a given filler value if it is narrower (shorter
|
|
in length) than a given width.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The sequence to pad.</param>
|
|
<param name="width">The width/length below which to pad.</param>
|
|
<param name="padding">The value to use for padding.</param>
|
|
<returns>
|
|
Returns a sequence that is at least as wide/long as the width/length
|
|
specified by the <paramref name="width"/> parameter.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
int[] numbers = { 123, 456, 789 };
|
|
var result = numbers.Pad(5, -1);
|
|
]]></code>
|
|
The <c>result</c> variable, when iterated over, will yield
|
|
123, 456, and 789 followed by two occurrences of -1, in turn.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PadExtension.Pad``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Int32,``0})">
|
|
<summary>
|
|
Pads a sequence with a dynamic filler value if it is narrower (shorter
|
|
in length) than a given width.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The sequence to pad.</param>
|
|
<param name="width">The width/length below which to pad.</param>
|
|
<param name="paddingSelector">Function to calculate padding.</param>
|
|
<returns>
|
|
Returns a sequence that is at least as wide/long as the width/length
|
|
specified by the <paramref name="width"/> parameter.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
int[] numbers = { 0, 1, 2 };
|
|
var result = numbers.Pad(5, i => -i);
|
|
]]></code>
|
|
The <c>result</c> variable, when iterated over, will yield
|
|
0, 1, 2, -3 and -4, in turn.
|
|
</example>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.PadStartExtension">
|
|
<summary><c>PadStart</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PadStartExtension.PadStart``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Pads a sequence with default values in the beginning if it is narrower (shorter
|
|
in length) than a given width.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The sequence to pad.</param>
|
|
<param name="width">The width/length below which to pad.</param>
|
|
<returns>
|
|
Returns a sequence that is at least as wide/long as the width/length
|
|
specified by the <paramref name="width"/> parameter.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
int[] numbers = { 123, 456, 789 };
|
|
var result = numbers.PadStart(5);
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>{ 0, 0, 123, 456, 789 }</c>.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PadStartExtension.PadStart``1(System.Collections.Generic.IEnumerable{``0},System.Int32,``0)">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The sequence to pad.</param>
|
|
<param name="width">The width/length below which to pad.</param>
|
|
<param name="padding">The value to use for padding.</param>
|
|
<returns>
|
|
Returns a sequence that is at least as wide/long as the width/length
|
|
specified by the <paramref name="width"/> parameter.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
int[] numbers = { 123, 456, 789 };
|
|
var result = numbers.PadStart(5, -1);
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>{ -1, -1, 123, 456, 789 }</c>.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PadStartExtension.PadStart``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Int32,``0})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The sequence to pad.</param>
|
|
<param name="width">The width/length below which to pad.</param>
|
|
<param name="paddingSelector">
|
|
Function to calculate padding given the index of the missing element.
|
|
</param>
|
|
<returns>
|
|
Returns a sequence that is at least as wide/long as the width/length
|
|
specified by the <paramref name="width"/> parameter.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
int[] numbers = { 123, 456, 789 };
|
|
var result = numbers.PadStart(6, i => -i);
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>{ 0, -1, -2, 123, 456, 789 }</c>.
|
|
</example>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.PairwiseExtension">
|
|
<summary><c>Pairwise</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PairwiseExtension.Pairwise``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``1})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TResult">The type of the element of the returned sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="resultSelector">A transform function to apply to
|
|
each pair of sequence.</param>
|
|
<returns>
|
|
Returns the resulting sequence.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
var source = new[] { "a", "b", "c", "d" };
|
|
var result = source.Pairwise((a, b) => a + b);
|
|
]]></code>
|
|
The <c>result</c> variable, when iterated over, will yield
|
|
"ab", "bc" and "cd", in turn.
|
|
</example>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.PartialSortExtension">
|
|
<summary><c>PartialSort</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PartialSortExtension.PartialSort``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Combines <see cref="M:System.Linq.Enumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})"/>,
|
|
where each element is its key, and <see cref="M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32)"/>
|
|
in a single operation.
|
|
</summary>
|
|
<typeparam name="T">Type of elements in the sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="count">Number of (maximum) elements to return.</param>
|
|
<returns>A sequence containing at most top <paramref name="count"/>
|
|
elements from source, in their ascending order.</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams it results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PartialSortExtension.PartialSort``1(System.Collections.Generic.IEnumerable{``0},System.Int32,MoreLinq.OrderByDirection)">
|
|
<summary>
|
|
Combines <see cref="M:MoreLinq.MoreEnumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1},MoreLinq.OrderByDirection)"/>,
|
|
where each element is its key, and <see cref="M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32)"/>
|
|
in a single operation.
|
|
An additional parameter specifies the direction of the sort
|
|
</summary>
|
|
<typeparam name="T">Type of elements in the sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="count">Number of (maximum) elements to return.</param>
|
|
<param name="direction">The direction in which to sort the elements</param>
|
|
<returns>A sequence containing at most top <paramref name="count"/>
|
|
elements from source, in the specified order.</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams it results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PartialSortExtension.PartialSort``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Collections.Generic.IComparer{``0})">
|
|
<summary>
|
|
Combines <see cref="M:System.Linq.Enumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})"/>,
|
|
where each element is its key, and <see cref="M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32)"/>
|
|
in a single operation. An additional parameter specifies how the
|
|
elements compare to each other.
|
|
</summary>
|
|
<typeparam name="T">Type of elements in the sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="count">Number of (maximum) elements to return.</param>
|
|
<param name="comparer">A <see cref="T:System.Collections.Generic.IComparer`1"/> to compare elements.</param>
|
|
<returns>A sequence containing at most top <paramref name="count"/>
|
|
elements from source, in their ascending order.</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams it results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PartialSortExtension.PartialSort``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Collections.Generic.IComparer{``0},MoreLinq.OrderByDirection)">
|
|
<summary>
|
|
Combines <see cref="M:MoreLinq.MoreEnumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1},MoreLinq.OrderByDirection)"/>,
|
|
where each element is its key, and <see cref="M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32)"/>
|
|
in a single operation.
|
|
Additional parameters specify how the elements compare to each other and
|
|
the direction of the sort.
|
|
</summary>
|
|
<typeparam name="T">Type of elements in the sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="count">Number of (maximum) elements to return.</param>
|
|
<param name="comparer">A <see cref="T:System.Collections.Generic.IComparer`1"/> to compare elements.</param>
|
|
<param name="direction">The direction in which to sort the elements</param>
|
|
<returns>A sequence containing at most top <paramref name="count"/>
|
|
elements from source, in the specified order.</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams it results.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.PartialSortByExtension">
|
|
<summary><c>PartialSortBy</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PartialSortByExtension.PartialSortBy``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,``1})">
|
|
<summary>
|
|
Combines <see cref="M:System.Linq.Enumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})"/>,
|
|
and <see cref="M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32)"/> in a single operation.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in the sequence.</typeparam>
|
|
<typeparam name="TKey">Type of keys.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="keySelector">A function to extract a key from an element.</param>
|
|
<param name="count">Number of (maximum) elements to return.</param>
|
|
<returns>A sequence containing at most top <paramref name="count"/>
|
|
elements from source, in ascending order of their keys.</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams it results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PartialSortByExtension.PartialSortBy``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,``1},MoreLinq.OrderByDirection)">
|
|
<summary>
|
|
Combines <see cref="M:MoreLinq.MoreEnumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},MoreLinq.OrderByDirection)"/>,
|
|
and <see cref="M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32)"/> in a single operation.
|
|
An additional parameter specifies the direction of the sort
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in the sequence.</typeparam>
|
|
<typeparam name="TKey">Type of keys.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="keySelector">A function to extract a key from an element.</param>
|
|
<param name="count">Number of (maximum) elements to return.</param>
|
|
<param name="direction">The direction in which to sort the elements</param>
|
|
<returns>A sequence containing at most top <paramref name="count"/>
|
|
elements from source, in the specified order of their keys.</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams it results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PartialSortByExtension.PartialSortBy``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,``1},System.Collections.Generic.IComparer{``1})">
|
|
<summary>
|
|
Combines <see cref="M:System.Linq.Enumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})"/>,
|
|
and <see cref="M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32)"/> in a single operation.
|
|
An additional parameter specifies how the keys compare to each other.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in the sequence.</typeparam>
|
|
<typeparam name="TKey">Type of keys.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="keySelector">A function to extract a key from an element.</param>
|
|
<param name="count">Number of (maximum) elements to return.</param>
|
|
<param name="comparer">A <see cref="T:System.Collections.Generic.IComparer`1"/> to compare elements.</param>
|
|
<returns>A sequence containing at most top <paramref name="count"/>
|
|
elements from source, in ascending order of their keys.</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams it results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PartialSortByExtension.PartialSortBy``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,``1},System.Collections.Generic.IComparer{``1},MoreLinq.OrderByDirection)">
|
|
<summary>
|
|
Combines <see cref="M:MoreLinq.MoreEnumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},MoreLinq.OrderByDirection)"/>,
|
|
and <see cref="M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32)"/> in a single operation.
|
|
Additional parameters specify how the elements compare to each other and
|
|
the direction of the sort.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in the sequence.</typeparam>
|
|
<typeparam name="TKey">Type of keys.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="keySelector">A function to extract a key from an element.</param>
|
|
<param name="count">Number of (maximum) elements to return.</param>
|
|
<param name="comparer">A <see cref="T:System.Collections.Generic.IComparer`1"/> to compare elements.</param>
|
|
<param name="direction">The direction in which to sort the elements</param>
|
|
<returns>A sequence containing at most top <paramref name="count"/>
|
|
elements from source, in the specified order of their keys.</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams it results.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.PartitionExtension">
|
|
<summary><c>Partition</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PartitionExtension.Partition``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})">
|
|
<summary>
|
|
Partitions or splits a sequence in two using a predicate.
|
|
</summary>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="predicate">The predicate function.</param>
|
|
<typeparam name="T">Type of source elements.</typeparam>
|
|
<returns>
|
|
A tuple of elements staisfying the predicate and those that do not,
|
|
respectively.
|
|
</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var (evens, odds) =
|
|
Enumerable.Range(0, 10).Partition(x => x % 2 == 0);
|
|
]]></code>
|
|
The <c>evens</c> variable, when iterated over, will yield 0, 2, 4, 6
|
|
and then 8. The <c>odds</c> variable, when iterated over, will yield
|
|
1, 3, 5, 7 and then 9.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PartitionExtension.Partition``2(System.Collections.Generic.IEnumerable{System.Linq.IGrouping{System.Boolean,``0}},System.Func{System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},``1})">
|
|
<summary>
|
|
Partitions a grouping by Boolean keys into a projection of true
|
|
elements and false elements, respectively.
|
|
</summary>
|
|
<typeparam name="T">Type of elements in source groupings.</typeparam>
|
|
<typeparam name="TResult">Type of the result.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="resultSelector">
|
|
Function that projects the result from sequences of true elements
|
|
and false elements, respectively, passed as arguments.
|
|
</param>
|
|
<returns>
|
|
The return value from <paramref name="resultSelector"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PartitionExtension.Partition``2(System.Collections.Generic.IEnumerable{System.Linq.IGrouping{System.Nullable{System.Boolean},``0}},System.Func{System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},``1})">
|
|
<summary>
|
|
Partitions a grouping by nullable Boolean keys into a projection of
|
|
true elements, false elements and null elements, respectively.
|
|
</summary>
|
|
<typeparam name="T">Type of elements in source groupings.</typeparam>
|
|
<typeparam name="TResult">Type of the result.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="resultSelector">
|
|
Function that projects the result from sequences of true elements,
|
|
false elements and null elements, respectively, passed as
|
|
arguments.
|
|
</param>
|
|
<returns>
|
|
The return value from <paramref name="resultSelector"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PartitionExtension.Partition``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},System.Func{System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},``1})">
|
|
<summary>
|
|
Partitions or splits a sequence in two using a predicate and then
|
|
projects a result from the two.
|
|
</summary>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="predicate">The predicate function.</param>
|
|
<param name="resultSelector">
|
|
Function that projects the result from sequences of elements that
|
|
satisfy the predicate and those that do not, respectively, passed as
|
|
arguments.
|
|
</param>
|
|
<typeparam name="T">Type of source elements.</typeparam>
|
|
<typeparam name="TResult">Type of the result.</typeparam>
|
|
<returns>
|
|
The return value from <paramref name="resultSelector"/>.
|
|
</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var (evens, odds) =
|
|
Enumerable.Range(0, 10)
|
|
.Partition(x => x % 2 == 0, ValueTuple.Create);
|
|
]]></code>
|
|
The <c>evens</c> variable, when iterated over, will yield 0, 2, 4, 6
|
|
and then 8. The <c>odds</c> variable, when iterated over, will yield
|
|
1, 3, 5, 7 and then 9.
|
|
</example>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PartitionExtension.Partition``3(System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``0,System.Func{System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``2})">
|
|
<summary>
|
|
Partitions a grouping and projects a result from group elements
|
|
matching a key and those groups that do not.
|
|
</summary>
|
|
<typeparam name="TKey">Type of keys in source groupings.</typeparam>
|
|
<typeparam name="TElement">Type of elements in source groupings.</typeparam>
|
|
<typeparam name="TResult">Type of the result.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="key">The key to partition.</param>
|
|
<param name="resultSelector">
|
|
Function that projects the result from sequences of elements
|
|
matching <paramref name="key"/> and those groups that do not (in
|
|
the order in which they appear in <paramref name="source"/>),
|
|
passed as arguments.
|
|
</param>
|
|
<returns>
|
|
The return value from <paramref name="resultSelector"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PartitionExtension.Partition``3(System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``0,``0,System.Func{System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``2})">
|
|
<summary>
|
|
Partitions a grouping and projects a result from elements of
|
|
groups matching a set of two keys and those groups that do not.
|
|
</summary>
|
|
<typeparam name="TKey">Type of keys in source groupings.</typeparam>
|
|
<typeparam name="TElement">Type of elements in source groupings.</typeparam>
|
|
<typeparam name="TResult">Type of the result.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="key1">The first key to partition on.</param>
|
|
<param name="key2">The second key to partition on.</param>
|
|
<param name="resultSelector">
|
|
Function that projects the result from elements of the group
|
|
matching <paramref name="key1"/>, elements of the group matching
|
|
<paramref name="key2"/> and those groups that do not (in the order
|
|
in which they appear in <paramref name="source"/>), passed as
|
|
arguments.
|
|
</param>
|
|
<returns>
|
|
The return value from <paramref name="resultSelector"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PartitionExtension.Partition``3(System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``0,System.Collections.Generic.IEqualityComparer{``0},System.Func{System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``2})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TKey">Type of keys in source groupings.</typeparam>
|
|
<typeparam name="TElement">Type of elements in source groupings.</typeparam>
|
|
<typeparam name="TResult">Type of the result.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="key">The key to partition on.</param>
|
|
<param name="comparer">The comparer for keys.</param>
|
|
<param name="resultSelector">
|
|
Function that projects the result from elements of the group
|
|
matching <paramref name="key"/> and those groups that do not (in
|
|
the order in which they appear in <paramref name="source"/>),
|
|
passed as arguments.
|
|
</param>
|
|
<returns>
|
|
The return value from <paramref name="resultSelector"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PartitionExtension.Partition``3(System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``0,``0,``0,System.Func{System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``2})">
|
|
<summary>
|
|
Partitions a grouping and projects a result from elements groups
|
|
matching a set of three keys and those groups that do not.
|
|
</summary>
|
|
<typeparam name="TKey">Type of keys in source groupings.</typeparam>
|
|
<typeparam name="TElement">Type of elements in source groupings.</typeparam>
|
|
<typeparam name="TResult">Type of the result.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="key1">The first key to partition on.</param>
|
|
<param name="key2">The second key to partition on.</param>
|
|
<param name="key3">The third key to partition on.</param>
|
|
<param name="resultSelector">
|
|
Function that projects the result from elements of groups
|
|
matching <paramref name="key1"/>, <paramref name="key2"/> and
|
|
<paramref name="key3"/> and those groups that do not (in the order
|
|
in which they appear in <paramref name="source"/>), passed as
|
|
arguments.
|
|
</param>
|
|
<returns>
|
|
The return value from <paramref name="resultSelector"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PartitionExtension.Partition``3(System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``0,``0,System.Collections.Generic.IEqualityComparer{``0},System.Func{System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``2})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TKey">Type of keys in source groupings.</typeparam>
|
|
<typeparam name="TElement">Type of elements in source groupings.</typeparam>
|
|
<typeparam name="TResult">Type of the result.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="key1">The first key to partition on.</param>
|
|
<param name="key2">The second key to partition on.</param>
|
|
<param name="comparer">The comparer for keys.</param>
|
|
<param name="resultSelector">
|
|
Function that projects the result from elements of the group
|
|
matching <paramref name="key1"/>, elements of the group matching
|
|
<paramref name="key2"/> and those groups that do not (in the order
|
|
in which they appear in <paramref name="source"/>), passed as
|
|
arguments.
|
|
</param>
|
|
<returns>
|
|
The return value from <paramref name="resultSelector"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PartitionExtension.Partition``3(System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``0,``0,``0,System.Collections.Generic.IEqualityComparer{``0},System.Func{System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``2})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TKey">Type of keys in source groupings.</typeparam>
|
|
<typeparam name="TElement">Type of elements in source groupings.</typeparam>
|
|
<typeparam name="TResult">Type of the result.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="key1">The first key to partition on.</param>
|
|
<param name="key2">The second key to partition on.</param>
|
|
<param name="key3">The third key to partition on.</param>
|
|
<param name="comparer">The comparer for keys.</param>
|
|
<param name="resultSelector">
|
|
Function that projects the result from elements of groups
|
|
matching <paramref name="key1"/>, <paramref name="key2"/> and
|
|
<paramref name="key3"/> and those groups that do not (in
|
|
the order in which they appear in <paramref name="source"/>),
|
|
passed as arguments.
|
|
</param>
|
|
<returns>
|
|
The return value from <paramref name="resultSelector"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.PermutationsExtension">
|
|
<summary><c>Permutations</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PermutationsExtension.Permutations``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Generates a sequence of lists that represent the permutations of the original sequence.
|
|
</summary>
|
|
<remarks>
|
|
A permutation is a unique re-ordering of the elements of the sequence.<br/>
|
|
This operator returns permutations in a deferred, streaming fashion; however, each
|
|
permutation is materialized into a new list. There are N! permutations of a sequence,
|
|
where N => sequence.Count().<br/>
|
|
Be aware that the original sequence is considered one of the permutations and will be
|
|
returned as one of the results.
|
|
</remarks>
|
|
<typeparam name="T">The type of the elements in the sequence</typeparam>
|
|
<param name="sequence">The original sequence to permute</param>
|
|
<returns>A sequence of lists representing permutations of the original sequence</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.PipeExtension">
|
|
<summary><c>Pipe</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PipeExtension.Pipe``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0})">
|
|
<summary>
|
|
Executes the given action on each element in the source sequence
|
|
and yields it.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequence</typeparam>
|
|
<param name="source">The sequence of elements</param>
|
|
<param name="action">The action to execute on each element</param>
|
|
<returns>A sequence with source elements in their original order.</returns>
|
|
<remarks>
|
|
The returned sequence is essentially a duplicate of
|
|
the original, but with the extra action being executed while the
|
|
sequence is evaluated. The action is always taken before the element
|
|
is yielded, so any changes made by the action will be visible in the
|
|
returned sequence. This operator uses deferred execution and streams it results.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.PrependExtension">
|
|
<summary><c>Prepend</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PrependExtension.Prepend``1(System.Collections.Generic.IEnumerable{``0},``0)">
|
|
<summary>
|
|
Prepends a single value to a sequence.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The sequence to prepend to.</param>
|
|
<param name="value">The value to prepend.</param>
|
|
<returns>
|
|
Returns a sequence where a value is prepended to it.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
<code><![CDATA[
|
|
int[] numbers = { 1, 2, 3 };
|
|
var result = numbers.Prepend(0);
|
|
]]></code>
|
|
The <c>result</c> variable, when iterated over, will yield
|
|
0, 1, 2 and 3, in turn.
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.PreScanExtension">
|
|
<summary><c>PreScan</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.PreScanExtension.PreScan``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0},``0)">
|
|
<summary>
|
|
Performs a pre-scan (exclusive prefix sum) on a sequence of elements.
|
|
</summary>
|
|
<remarks>
|
|
An exclusive prefix sum returns an equal-length sequence where the
|
|
N-th element is the sum of the first N-1 input elements (the first
|
|
element is a special case, it is set to the identity). More
|
|
generally, the pre-scan allows any commutative binary operation,
|
|
not just a sum.
|
|
The inclusive version of PreScan is <see cref="M:MoreLinq.MoreEnumerable.Scan``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})"/>.
|
|
This operator uses deferred execution and streams its result.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
int[] values = { 1, 2, 3, 4 };
|
|
var prescan = values.PreScan((a, b) => a + b, 0);
|
|
var scan = values.Scan((a, b) => a + b);
|
|
var result = values.EquiZip(prescan, ValueTuple.Create);
|
|
]]></code>
|
|
<c>prescan</c> will yield <c>{ 0, 1, 3, 6 }</c>, while <c>scan</c>
|
|
and <c>result</c> will both yield <c>{ 1, 3, 6, 10 }</c>. This
|
|
shows the relationship between the inclusive and exclusive prefix sum.
|
|
</example>
|
|
<typeparam name="TSource">Type of elements in source sequence</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<param name="transformation">Transformation operation</param>
|
|
<param name="identity">Identity element (see remarks)</param>
|
|
<returns>The scanned sequence</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.RandomSubsetExtension">
|
|
<summary><c>RandomSubset</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.RandomSubsetExtension.RandomSubset``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Returns a sequence of a specified size of random elements from the
|
|
original sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of source sequence elements.</typeparam>
|
|
<param name="source">
|
|
The sequence from which to return random elements.</param>
|
|
<param name="subsetSize">The size of the random subset to return.</param>
|
|
<returns>
|
|
A random sequence of elements in random order from the original
|
|
sequence.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.RandomSubsetExtension.RandomSubset``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Random)">
|
|
<summary>
|
|
Returns a sequence of a specified size of random elements from the
|
|
original sequence. An additional parameter specifies a random
|
|
generator to be used for the random selection algorithm.
|
|
</summary>
|
|
<typeparam name="T">The type of source sequence elements.</typeparam>
|
|
<param name="source">
|
|
The sequence from which to return random elements.</param>
|
|
<param name="subsetSize">The size of the random subset to return.</param>
|
|
<param name="rand">
|
|
A random generator used as part of the selection algorithm.</param>
|
|
<returns>
|
|
A random sequence of elements in random order from the original
|
|
sequence.</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.RankExtension">
|
|
<summary><c>Rank</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.RankExtension.Rank``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Ranks each item in the sequence in descending ordering using a default comparer.
|
|
</summary>
|
|
<typeparam name="TSource">Type of item in the sequence</typeparam>
|
|
<param name="source">The sequence whose items will be ranked</param>
|
|
<returns>A sequence of position integers representing the ranks of the corresponding items in the sequence</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.RankExtension.Rank``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0})">
|
|
<summary>
|
|
Rank each item in the sequence using a caller-supplied comparer.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements in the source sequence</typeparam>
|
|
<param name="source">The sequence of items to rank</param>
|
|
<param name="comparer">A object that defines comparison semantics for the elements in the sequence</param>
|
|
<returns>A sequence of position integers representing the ranks of the corresponding items in the sequence</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.RankByExtension">
|
|
<summary><c>RankBy</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.RankByExtension.RankBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
|
|
<summary>
|
|
Ranks each item in the sequence in descending ordering by a specified key using a default comparer
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements in the source sequence</typeparam>
|
|
<typeparam name="TKey">The type of the key used to rank items in the sequence</typeparam>
|
|
<param name="source">The sequence of items to rank</param>
|
|
<param name="keySelector">A key selector function which returns the value by which to rank items in the sequence</param>
|
|
<returns>A sequence of position integers representing the ranks of the corresponding items in the sequence</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.RankByExtension.RankBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})">
|
|
<summary>
|
|
Ranks each item in a sequence using a specified key and a caller-supplied comparer
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements in the source sequence</typeparam>
|
|
<typeparam name="TKey">The type of the key used to rank items in the sequence</typeparam>
|
|
<param name="source">The sequence of items to rank</param>
|
|
<param name="keySelector">A key selector function which returns the value by which to rank items in the sequence</param>
|
|
<param name="comparer">An object that defines the comparison semantics for keys used to rank items</param>
|
|
<returns>A sequence of position integers representing the ranks of the corresponding items in the sequence</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.RepeatExtension">
|
|
<summary><c>Repeat</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.RepeatExtension.Repeat``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Repeats the sequence forever.
|
|
</summary>
|
|
<typeparam name="T">Type of elements in sequence</typeparam>
|
|
<param name="sequence">The sequence to repeat</param>
|
|
<returns>A sequence produced from the infinite repetition of the original source sequence</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.RepeatExtension.Repeat``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Repeats the sequence the specified number of times.
|
|
</summary>
|
|
<typeparam name="T">Type of elements in sequence</typeparam>
|
|
<param name="sequence">The sequence to repeat</param>
|
|
<param name="count">Number of times to repeat the sequence</param>
|
|
<returns>A sequence produced from the repetition of the original source sequence</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.RightJoinExtension">
|
|
<summary><c>RightJoin</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.RightJoinExtension.RightJoin``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``0,``0,``2})">
|
|
<summary>
|
|
Performs a right outer join on two homogeneous sequences.
|
|
Additional arguments specify key selection functions and result
|
|
projection functions.
|
|
</summary>
|
|
<typeparam name="TSource">
|
|
The type of elements in the source sequence.</typeparam>
|
|
<typeparam name="TKey">
|
|
The type of the key returned by the key selector function.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the result elements.</typeparam>
|
|
<param name="first">
|
|
The first sequence of the join operation.</param>
|
|
<param name="second">
|
|
The second sequence of the join operation.</param>
|
|
<param name="keySelector">
|
|
Function that projects the key given an element of one of the
|
|
sequences to join.</param>
|
|
<param name="secondSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="second"/> where there is no corresponding element
|
|
in <paramref name="first"/>.</param>
|
|
<param name="bothSelector">
|
|
Function that projects the result given an element from
|
|
<paramref name="first"/> and an element from <paramref name="second"/>
|
|
that match on a common key.</param>
|
|
<returns>A sequence containing results projected from a right
|
|
outer join of the two input sequences.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.RightJoinExtension.RightJoin``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``0,``0,``2},System.Collections.Generic.IEqualityComparer{``1})">
|
|
<summary>
|
|
Performs a right outer join on two homogeneous sequences.
|
|
Additional arguments specify key selection functions, result
|
|
projection functions and a key comparer.
|
|
</summary>
|
|
<typeparam name="TSource">
|
|
The type of elements in the source sequence.</typeparam>
|
|
<typeparam name="TKey">
|
|
The type of the key returned by the key selector function.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the result elements.</typeparam>
|
|
<param name="first">
|
|
The first sequence of the join operation.</param>
|
|
<param name="second">
|
|
The second sequence of the join operation.</param>
|
|
<param name="keySelector">
|
|
Function that projects the key given an element of one of the
|
|
sequences to join.</param>
|
|
<param name="secondSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="second"/> where there is no corresponding element
|
|
in <paramref name="first"/>.</param>
|
|
<param name="bothSelector">
|
|
Function that projects the result given an element from
|
|
<paramref name="first"/> and an element from <paramref name="second"/>
|
|
that match on a common key.</param>
|
|
<param name="comparer">
|
|
The <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> instance used to compare
|
|
keys for equality.</param>
|
|
<returns>A sequence containing results projected from a right
|
|
outer join of the two input sequences.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.RightJoinExtension.RightJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``1,``3},System.Func{``0,``1,``3})">
|
|
<summary>
|
|
Performs a right outer join on two heterogeneous sequences.
|
|
Additional arguments specify key selection functions and result
|
|
projection functions.
|
|
</summary>
|
|
<typeparam name="TFirst">
|
|
The type of elements in the first sequence.</typeparam>
|
|
<typeparam name="TSecond">
|
|
The type of elements in the second sequence.</typeparam>
|
|
<typeparam name="TKey">
|
|
The type of the key returned by the key selector functions.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the result elements.</typeparam>
|
|
<param name="first">
|
|
The first sequence of the join operation.</param>
|
|
<param name="second">
|
|
The second sequence of the join operation.</param>
|
|
<param name="firstKeySelector">
|
|
Function that projects the key given an element from <paramref name="first"/>.</param>
|
|
<param name="secondKeySelector">
|
|
Function that projects the key given an element from <paramref name="second"/>.</param>
|
|
<param name="secondSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="second"/> where there is no corresponding element
|
|
in <paramref name="first"/>.</param>
|
|
<param name="bothSelector">
|
|
Function that projects the result given an element from
|
|
<paramref name="first"/> and an element from <paramref name="second"/>
|
|
that match on a common key.</param>
|
|
<returns>A sequence containing results projected from a right
|
|
outer join of the two input sequences.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.RightJoinExtension.RightJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``1,``3},System.Func{``0,``1,``3},System.Collections.Generic.IEqualityComparer{``2})">
|
|
<summary>
|
|
Performs a right outer join on two heterogeneous sequences.
|
|
Additional arguments specify key selection functions, result
|
|
projection functions and a key comparer.
|
|
</summary>
|
|
<typeparam name="TFirst">
|
|
The type of elements in the first sequence.</typeparam>
|
|
<typeparam name="TSecond">
|
|
The type of elements in the second sequence.</typeparam>
|
|
<typeparam name="TKey">
|
|
The type of the key returned by the key selector functions.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the result elements.</typeparam>
|
|
<param name="first">
|
|
The first sequence of the join operation.</param>
|
|
<param name="second">
|
|
The second sequence of the join operation.</param>
|
|
<param name="firstKeySelector">
|
|
Function that projects the key given an element from <paramref name="first"/>.</param>
|
|
<param name="secondKeySelector">
|
|
Function that projects the key given an element from <paramref name="second"/>.</param>
|
|
<param name="secondSelector">
|
|
Function that projects the result given just an element from
|
|
<paramref name="second"/> where there is no corresponding element
|
|
in <paramref name="first"/>.</param>
|
|
<param name="bothSelector">
|
|
Function that projects the result given an element from
|
|
<paramref name="first"/> and an element from <paramref name="second"/>
|
|
that match on a common key.</param>
|
|
<param name="comparer">
|
|
The <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> instance used to compare
|
|
keys for equality.</param>
|
|
<returns>A sequence containing results projected from a right
|
|
outer join of the two input sequences.</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.RunLengthEncodeExtension">
|
|
<summary><c>RunLengthEncode</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Run-length encodes a sequence by converting consecutive instances of the same element into
|
|
a <c>KeyValuePair{T,int}</c> representing the item and its occurrence count.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequence</typeparam>
|
|
<param name="sequence">The sequence to run length encode</param>
|
|
<returns>A sequence of <c>KeyValuePair{T,int}</c> where the key is the element and the value is the occurrence count</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
|
|
<summary>
|
|
Run-length encodes a sequence by converting consecutive instances of the same element into
|
|
a <c>KeyValuePair{T,int}</c> representing the item and its occurrence count. This overload
|
|
uses a custom equality comparer to identify equivalent items.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequence</typeparam>
|
|
<param name="sequence">The sequence to run length encode</param>
|
|
<param name="comparer">The comparer used to identify equivalent items</param>
|
|
<returns>A sequence of <c>KeyValuePair{T,int}</c> where they key is the element and the value is the occurrence count</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.ScanExtension">
|
|
<summary><c>Scan</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ScanExtension.Scan``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})">
|
|
<summary>
|
|
Performs a scan (inclusive prefix sum) on a sequence of elements.
|
|
</summary>
|
|
<remarks>
|
|
An inclusive prefix sum returns an equal-length sequence where the
|
|
N-th element is the sum of the first N input elements. More
|
|
generally, the scan allows any commutative binary operation, not
|
|
just a sum.
|
|
The exclusive version of Scan is <see cref="M:MoreLinq.MoreEnumerable.PreScan``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0},``0)"/>.
|
|
This operator uses deferred execution and streams its result.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
int[] values = { 1, 2, 3, 4 };
|
|
var prescan = values.PreScan((a, b) => a + b, 0);
|
|
var scan = values.Scan((a, b) => a + b);
|
|
var result = values.EquiZip(scan, ValueTuple.Create);
|
|
]]></code>
|
|
<c>prescan</c> will yield <c>{ 0, 1, 3, 6 }</c>, while <c>scan</c>
|
|
and <c>result</c> will both yield <c>{ 1, 3, 6, 10 }</c>. This
|
|
shows the relationship between the inclusive and exclusive prefix sum.
|
|
</example>
|
|
<typeparam name="TSource">Type of elements in source sequence</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<param name="transformation">Transformation operation</param>
|
|
<returns>The scanned sequence</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ScanExtension.Scan``2(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1})">
|
|
<summary>
|
|
Like <see cref="M:System.Linq.Enumerable.Aggregate``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})"/> except returns
|
|
the sequence of intermediate results as well as the final one.
|
|
An additional parameter specifies a seed.
|
|
</summary>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its result.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
var result = Enumerable.Range(1, 5).Scan(0, (a, b) => a + b);
|
|
]]></code>
|
|
When iterated, <c>result</c> will yield <c>{ 0, 1, 3, 6, 10, 15 }</c>.
|
|
</example>
|
|
<typeparam name="TSource">Type of elements in source sequence</typeparam>
|
|
<typeparam name="TState">Type of state</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<param name="seed">Initial state to seed</param>
|
|
<param name="transformation">Transformation operation</param>
|
|
<returns>The scanned sequence</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.ScanByExtension">
|
|
<summary><c>ScanBy</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ScanByExtension.ScanBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,``2},System.Func{``2,``1,``0,``2})">
|
|
<summary>
|
|
Applies an accumulator function over sequence element keys,
|
|
returning the keys along with intermediate accumulator states.
|
|
</summary>
|
|
<typeparam name="TSource">Type of the elements of the source sequence.</typeparam>
|
|
<typeparam name="TKey">The type of the key.</typeparam>
|
|
<typeparam name="TState">Type of the state.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="keySelector">
|
|
A function that returns the key given an element.</param>
|
|
<param name="seedSelector">
|
|
A function to determine the initial value for the accumulator that is
|
|
invoked once per key encountered.</param>
|
|
<param name="accumulator">
|
|
An accumulator function invoked for each element.</param>
|
|
<returns>
|
|
A sequence of keys paired with intermediate accumulator states.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ScanByExtension.ScanBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,``2},System.Func{``2,``1,``0,``2},System.Collections.Generic.IEqualityComparer{``1})">
|
|
<summary>
|
|
Applies an accumulator function over sequence element keys,
|
|
returning the keys along with intermediate accumulator states. An
|
|
additional parameter specifies the comparer to use to compare keys.
|
|
</summary>
|
|
<typeparam name="TSource">Type of the elements of the source sequence.</typeparam>
|
|
<typeparam name="TKey">The type of the key.</typeparam>
|
|
<typeparam name="TState">Type of the state.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="keySelector">
|
|
A function that returns the key given an element.</param>
|
|
<param name="seedSelector">
|
|
A function to determine the initial value for the accumulator that is
|
|
invoked once per key encountered.</param>
|
|
<param name="accumulator">
|
|
An accumulator function invoked for each element.</param>
|
|
<param name="comparer">The equality comparer to use to determine
|
|
whether or not keys are equal. If <c>null</c>, the default equality
|
|
comparer for <typeparamref name="TSource"/> is used.</param>
|
|
<returns>
|
|
A sequence of keys paired with intermediate accumulator states.
|
|
</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.ScanRightExtension">
|
|
<summary><c>ScanRight</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ScanRightExtension.ScanRight``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})">
|
|
<summary>
|
|
Peforms a right-associative scan (inclusive prefix) on a sequence of elements.
|
|
This operator is the right-associative version of the
|
|
<see cref="M:MoreLinq.MoreEnumerable.Scan``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})"/> LINQ operator.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in source sequence.</typeparam>
|
|
<param name="source">Source sequence.</param>
|
|
<param name="func">
|
|
A right-associative accumulator function to be invoked on each element.
|
|
Its first argument is the current value in the sequence; second argument is the previous accumulator value.
|
|
</param>
|
|
<returns>The scanned sequence.</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var result = Enumerable.Range(1, 5).Select(i => i.ToString()).ScanRight((a, b) => string.Format("({0}/{1})", a, b));
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>[ "(1+(2+(3+(4+5))))", "(2+(3+(4+5)))", "(3+(4+5))", "(4+5)", "5" ]</c>.
|
|
</example>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
Source sequence is consumed greedily when an iteration of the resulting sequence begins.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ScanRightExtension.ScanRight``2(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``0,``1,``1})">
|
|
<summary>
|
|
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
|
|
<see cref="M:MoreLinq.MoreEnumerable.Scan``2(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1})"/> LINQ operator.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of source.</typeparam>
|
|
<typeparam name="TAccumulate">The type of the accumulator value.</typeparam>
|
|
<param name="source">Source sequence.</param>
|
|
<param name="seed">The initial accumulator value.</param>
|
|
<param name="func">A right-associative accumulator function to be invoked on each element.</param>
|
|
<returns>The scanned sequence.</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var result = Enumerable.Range(1, 4).ScanRight("5", (a, b) => string.Format("({0}/{1})", a, b));
|
|
]]></code>
|
|
The <c>result</c> variable will contain <c>[ "(1+(2+(3+(4+5))))", "(2+(3+(4+5)))", "(3+(4+5))", "(4+5)", "5" ]</c>.
|
|
</example>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
Source sequence is consumed greedily when an iteration of the resulting sequence begins.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.SegmentExtension">
|
|
<summary><c>Segment</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.SegmentExtension.Segment``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})">
|
|
<summary>
|
|
Divides a sequence into multiple sequences by using a segment detector based on the original sequence
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequence</typeparam>
|
|
<param name="source">The sequence to segment</param>
|
|
<param name="newSegmentPredicate">A function, which returns <c>true</c> if the given element begins a new segment, and <c>false</c> otherwise</param>
|
|
<returns>A sequence of segment, each of which is a portion of the original sequence</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
Thrown if either <paramref name="source"/> or <paramref name="newSegmentPredicate"/> are <see langword="null"/>.
|
|
</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.SegmentExtension.Segment``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32,System.Boolean})">
|
|
<summary>
|
|
Divides a sequence into multiple sequences by using a segment detector based on the original sequence
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequence</typeparam>
|
|
<param name="source">The sequence to segment</param>
|
|
<param name="newSegmentPredicate">A function, which returns <c>true</c> if the given element or index indicate a new segment, and <c>false</c> otherwise</param>
|
|
<returns>A sequence of segment, each of which is a portion of the original sequence</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
Thrown if either <paramref name="source"/> or <paramref name="newSegmentPredicate"/> are <see langword="null"/>.
|
|
</exception>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.SegmentExtension.Segment``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,System.Int32,System.Boolean})">
|
|
<summary>
|
|
Divides a sequence into multiple sequences by using a segment detector based on the original sequence
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the sequence</typeparam>
|
|
<param name="source">The sequence to segment</param>
|
|
<param name="newSegmentPredicate">A function, which returns <c>true</c> if the given current element, previous element or index indicate a new segment, and <c>false</c> otherwise</param>
|
|
<returns>A sequence of segment, each of which is a portion of the original sequence</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
Thrown if either <paramref name="source"/> or <paramref name="newSegmentPredicate"/> are <see langword="null"/>.
|
|
</exception>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.ShuffleExtension">
|
|
<summary><c>Shuffle</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ShuffleExtension.Shuffle``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Returns a sequence of elements in random order from the original
|
|
sequence.
|
|
</summary>
|
|
<typeparam name="T">The type of source sequence elements.</typeparam>
|
|
<param name="source">
|
|
The sequence from which to return random elements.</param>
|
|
<returns>
|
|
A sequence of elements <paramref name="source"/> randomized in
|
|
their order.
|
|
</returns>
|
|
<remarks>
|
|
This method uses deferred execution and streams its results. The
|
|
source sequence is entirely buffered before the results are
|
|
streamed.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ShuffleExtension.Shuffle``1(System.Collections.Generic.IEnumerable{``0},System.Random)">
|
|
<summary>
|
|
Returns a sequence of elements in random order from the original
|
|
sequence. An additional parameter specifies a random generator to be
|
|
used for the random selection algorithm.
|
|
</summary>
|
|
<typeparam name="T">The type of source sequence elements.</typeparam>
|
|
<param name="source">
|
|
The sequence from which to return random elements.</param>
|
|
<param name="rand">
|
|
A random generator used as part of the selection algorithm.</param>
|
|
<returns>
|
|
A sequence of elements <paramref name="source"/> randomized in
|
|
their order.
|
|
</returns>
|
|
<remarks>
|
|
This method uses deferred execution and streams its results. The
|
|
source sequence is entirely buffered before the results are
|
|
streamed.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.SingleExtension">
|
|
<summary><c>Single</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.SingleExtension.Single``1(MoreLinq.IExtremaEnumerable{``0})">
|
|
<summary>
|
|
Returns the only element of a sequence, and throws an exception if
|
|
there is not exactly one element in the sequence.
|
|
</summary>
|
|
<typeparam name="T">
|
|
The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The input sequence.</param>
|
|
<exception cref="T:System.InvalidOperationException">
|
|
The input sequence contains more than one element.</exception>
|
|
<returns>
|
|
The single element of the input sequence.
|
|
</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.SingleOrDefaultExtension">
|
|
<summary><c>SingleOrDefault</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.SingleOrDefaultExtension.SingleOrDefault``1(MoreLinq.IExtremaEnumerable{``0})">
|
|
<summary>
|
|
Returns the only element of a sequence, or a default value if the
|
|
sequence is empty; this method throws an exception if there is more
|
|
than one element in the sequence.
|
|
</summary>
|
|
<typeparam name="T">
|
|
The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The input sequence.</param>
|
|
<returns>
|
|
The single element of the input sequence, or default value of type
|
|
<typeparamref name="T"/> if the sequence contains no elements.
|
|
</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.SkipLastExtension">
|
|
<summary><c>SkipLast</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.SkipLastExtension.SkipLast``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Bypasses a specified number of elements at the end of the sequence.
|
|
</summary>
|
|
<typeparam name="T">Type of the source sequence</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="count">The number of elements to bypass at the end of the source sequence.</param>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> containing the source sequence elements except for the bypassed ones at the end.
|
|
</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.SkipUntilExtension">
|
|
<summary><c>SkipUntil</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.SkipUntilExtension.SkipUntil``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
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.
|
|
</para>
|
|
<para>
|
|
Secondly, SkipUntil skips the element which causes the predicate to return true. For
|
|
example, in a sequence <code><![CDATA[{ 1, 2, 3, 4, 5 }]]></code> and with a predicate of
|
|
<code><![CDATA[x => x == 3]]></code>, the result would be <code><![CDATA[{ 4, 5 }]]></code>.
|
|
</para>
|
|
<para>
|
|
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.)
|
|
</para>
|
|
</remarks>
|
|
<typeparam name="TSource">Type of the source sequence</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<param name="predicate">Predicate used to determine when to stop yielding results from the source.</param>
|
|
<returns>Items from the source sequence after the predicate first returns true when applied to the item.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is null</exception>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.SliceExtension">
|
|
<summary><c>Slice</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.SliceExtension.Slice``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Int32)">
|
|
<summary>
|
|
Extracts a contiguous count of elements from a sequence at a particular zero-based starting index
|
|
</summary>
|
|
<remarks>
|
|
If the starting position or count specified result in slice extending past the end of the sequence,
|
|
it will return all elements up to that point. There is no guarantee that the resulting sequence will
|
|
contain the number of elements requested - it may have anywhere from 0 to <paramref name="count"/>.<br/>
|
|
This method is implemented in an optimized manner for any sequence implementing <c>IList{T}</c>.<br/>
|
|
The result of Slice() is identical to: <c>sequence.Skip(startIndex).Take(count)</c>
|
|
</remarks>
|
|
<typeparam name="T">The type of the elements in the source sequence</typeparam>
|
|
<param name="sequence">The sequence from which to extract elements</param>
|
|
<param name="startIndex">The zero-based index at which to begin slicing</param>
|
|
<param name="count">The number of items to slice out of the index</param>
|
|
<returns>A new sequence containing any elements sliced out from the source sequence</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.SortedMergeExtension">
|
|
<summary><c>SortedMerge</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.SortedMergeExtension.SortedMerge``1(System.Collections.Generic.IEnumerable{``0},MoreLinq.OrderByDirection,System.Collections.Generic.IEnumerable{``0}[])">
|
|
<summary>
|
|
Merges two or more sequences that are in a common order (either ascending or descending) into
|
|
a single sequence that preserves that order.
|
|
</summary>
|
|
<remarks>
|
|
Using SortedMerge on sequences that are not ordered or are not in the same order produces
|
|
undefined results.<br/>
|
|
<c>SortedMerge</c> uses performs the merge in a deferred, streaming manner. <br/>
|
|
|
|
Here is an example of a merge, as well as the produced result:
|
|
<code><![CDATA[
|
|
var 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 }
|
|
]]></code>
|
|
</remarks>
|
|
<typeparam name="TSource">The type of the elements of the sequence</typeparam>
|
|
<param name="source">The primary sequence with which to merge</param>
|
|
<param name="direction">The ordering that all sequences must already exhibit</param>
|
|
<param name="otherSequences">A variable argument array of zero or more other sequences to merge with</param>
|
|
<returns>A merged, order-preserving sequence containing all of the elements of the original sequences</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.SortedMergeExtension.SortedMerge``1(System.Collections.Generic.IEnumerable{``0},MoreLinq.OrderByDirection,System.Collections.Generic.IComparer{``0},System.Collections.Generic.IEnumerable{``0}[])">
|
|
<summary>
|
|
Merges two or more sequences that are in a common order (either ascending or descending) into
|
|
a single sequence that preserves that order.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements in the sequence</typeparam>
|
|
<param name="source">The primary sequence with which to merge</param>
|
|
<param name="direction">The ordering that all sequences must already exhibit</param>
|
|
<param name="comparer">The comparer used to evaluate the relative order between elements</param>
|
|
<param name="otherSequences">A variable argument array of zero or more other sequences to merge with</param>
|
|
<returns>A merged, order-preserving sequence containing al of the elements of the original sequences</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.SplitExtension">
|
|
<summary><c>Split</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.SplitExtension.Split``1(System.Collections.Generic.IEnumerable{``0},``0)">
|
|
<summary>
|
|
Splits the source sequence by a separator.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="separator">Separator element.</param>
|
|
<returns>A sequence of splits of elements.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.SplitExtension.Split``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})">
|
|
<summary>
|
|
Splits the source sequence by separator elements identified by a
|
|
function.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="separatorFunc">Predicate function used to determine
|
|
the splitter elements in the source sequence.</param>
|
|
<returns>A sequence of splits of elements.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.SplitExtension.Split``1(System.Collections.Generic.IEnumerable{``0},``0,System.Int32)">
|
|
<summary>
|
|
Splits the source sequence by a separator given a maximum count of splits.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="separator">Separator element.</param>
|
|
<param name="count">Maximum number of splits.</param>
|
|
<returns>A sequence of splits of elements.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.SplitExtension.Split``1(System.Collections.Generic.IEnumerable{``0},``0,System.Collections.Generic.IEqualityComparer{``0})">
|
|
<summary>
|
|
Splits the source sequence by a separator and then transforms the
|
|
splits into results.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="separator">Separator element.</param>
|
|
<param name="comparer">Comparer used to determine separator
|
|
element equality.</param>
|
|
<returns>A sequence of splits of elements.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.SplitExtension.Split``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},System.Int32)">
|
|
<summary>
|
|
Splits the source sequence by separator elements identified by a
|
|
function, given a maximum count of splits.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="separatorFunc">Predicate function used to determine
|
|
the splitter elements in the source sequence.</param>
|
|
<param name="count">Maximum number of splits.</param>
|
|
<returns>A sequence of splits of elements.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.SplitExtension.Split``1(System.Collections.Generic.IEnumerable{``0},``0,System.Collections.Generic.IEqualityComparer{``0},System.Int32)">
|
|
<summary>
|
|
Splits the source sequence by a separator, given a maximum count
|
|
of splits. A parameter specifies how the separator is compared
|
|
for equality.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="separator">Separator element.</param>
|
|
<param name="comparer">Comparer used to determine separator
|
|
element equality.</param>
|
|
<param name="count">Maximum number of splits.</param>
|
|
<returns>A sequence of splits of elements.</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.SplitExtension.Split``2(System.Collections.Generic.IEnumerable{``0},``0,System.Func{System.Collections.Generic.IEnumerable{``0},``1})">
|
|
<summary>
|
|
Splits the source sequence by a separator and then transforms
|
|
the splits into results.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence.</typeparam>
|
|
<typeparam name="TResult">Type of the result sequence elements.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="separator">Separator element.</param>
|
|
<param name="resultSelector">Function used to project splits
|
|
of source elements into elements of the resulting sequence.</param>
|
|
<returns>
|
|
A sequence of values typed as <typeparamref name="TResult"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.SplitExtension.Split``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},System.Func{System.Collections.Generic.IEnumerable{``0},``1})">
|
|
<summary>
|
|
Splits the source sequence by separator elements identified by
|
|
a function and then transforms the splits into results.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence.</typeparam>
|
|
<typeparam name="TResult">Type of the result sequence elements.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="separatorFunc">Predicate function used to determine
|
|
the splitter elements in the source sequence.</param>
|
|
<param name="resultSelector">Function used to project splits
|
|
of source elements into elements of the resulting sequence.</param>
|
|
<returns>
|
|
A sequence of values typed as <typeparamref name="TResult"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.SplitExtension.Split``2(System.Collections.Generic.IEnumerable{``0},``0,System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1})">
|
|
<summary>
|
|
Splits the source sequence by a separator, given a maximum count
|
|
of splits, and then transforms the splits into results.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence.</typeparam>
|
|
<typeparam name="TResult">Type of the result sequence elements.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="separator">Separator element.</param>
|
|
<param name="count">Maximum number of splits.</param>
|
|
<param name="resultSelector">Function used to project splits
|
|
of source elements into elements of the resulting sequence.</param>
|
|
<returns>
|
|
A sequence of values typed as <typeparamref name="TResult"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.SplitExtension.Split``2(System.Collections.Generic.IEnumerable{``0},``0,System.Collections.Generic.IEqualityComparer{``0},System.Func{System.Collections.Generic.IEnumerable{``0},``1})">
|
|
<summary>
|
|
Splits the source sequence by a separator and then transforms the
|
|
splits into results. A parameter specifies how the separator is
|
|
compared for equality.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence.</typeparam>
|
|
<typeparam name="TResult">Type of the result sequence elements.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="separator">Separator element.</param>
|
|
<param name="comparer">Comparer used to determine separator
|
|
element equality.</param>
|
|
<param name="resultSelector">Function used to project splits
|
|
of source elements into elements of the resulting sequence.</param>
|
|
<returns>
|
|
A sequence of values typed as <typeparamref name="TResult"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.SplitExtension.Split``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1})">
|
|
<summary>
|
|
Splits the source sequence by separator elements identified by
|
|
a function, given a maximum count of splits, and then transforms
|
|
the splits into results.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence.</typeparam>
|
|
<typeparam name="TResult">Type of the result sequence elements.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="separatorFunc">Predicate function used to determine
|
|
the splitter elements in the source sequence.</param>
|
|
<param name="count">Maximum number of splits.</param>
|
|
<param name="resultSelector">Function used to project a split
|
|
group of source elements into an element of the resulting sequence.</param>
|
|
<returns>
|
|
A sequence of values typed as <typeparamref name="TResult"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.SplitExtension.Split``2(System.Collections.Generic.IEnumerable{``0},``0,System.Collections.Generic.IEqualityComparer{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence.</typeparam>
|
|
<typeparam name="TResult">Type of the result sequence elements.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="separator">Separator element.</param>
|
|
<param name="comparer">Comparer used to determine separator
|
|
element equality.</param>
|
|
<param name="count">Maximum number of splits.</param>
|
|
<param name="resultSelector">Function used to project splits
|
|
of source elements into elements of the resulting sequence.</param>
|
|
<returns>
|
|
A sequence of values typed as <typeparamref name="TResult"/>.
|
|
</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.StartsWithExtension">
|
|
<summary><c>StartsWith</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.StartsWithExtension.StartsWith``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Determines whether the beginning of the first sequence is
|
|
equivalent to the second sequence, using the default equality
|
|
comparer.
|
|
</summary>
|
|
<typeparam name="T">Type of elements.</typeparam>
|
|
<param name="first">The sequence to check.</param>
|
|
<param name="second">The sequence to compare to.</param>
|
|
<returns>
|
|
<c>true</c> if <paramref name="first" /> begins with elements
|
|
equivalent to <paramref name="second" />.
|
|
</returns>
|
|
<remarks>
|
|
This is the <see cref="T:System.Collections.Generic.IEnumerable`1" /> equivalent of
|
|
<see cref="M:System.String.StartsWith(System.String)" /> and it calls
|
|
<see cref="M:System.Collections.Generic.IEqualityComparer`1.Equals(`0,`0)" /> using
|
|
<see cref="P:System.Collections.Generic.EqualityComparer`1.Default"/> on pairs of elements at
|
|
the same index.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.StartsWithExtension.StartsWith``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
|
|
<summary>
|
|
Determines whether the beginning of the first sequence is
|
|
equivalent to the second sequence, using the specified element
|
|
equality comparer.
|
|
</summary>
|
|
<typeparam name="T">Type of elements.</typeparam>
|
|
<param name="first">The sequence to check.</param>
|
|
<param name="second">The sequence to compare to.</param>
|
|
<param name="comparer">Equality comparer to use.</param>
|
|
<returns>
|
|
<c>true</c> if <paramref name="first" /> begins with elements
|
|
equivalent to <paramref name="second" />.
|
|
</returns>
|
|
<remarks>
|
|
This is the <see cref="T:System.Collections.Generic.IEnumerable`1" /> equivalent of
|
|
<see cref="M:System.String.StartsWith(System.String)" /> and
|
|
it calls <see cref="M:System.Collections.Generic.IEqualityComparer`1.Equals(`0,`0)" /> on pairs
|
|
of elements at the same index.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.SubsetsExtension">
|
|
<summary><c>Subsets</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.SubsetsExtension.Subsets``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Returns a sequence of <see cref="T:System.Collections.Generic.IList`1"/> representing all of
|
|
the subsets of any size that are part of the original sequence. In
|
|
mathematics, it is equivalent to the <em>power set</em> of a set.
|
|
</summary>
|
|
<remarks>
|
|
This operator produces all of the subsets of a given sequence. Subsets are returned
|
|
in increasing cardinality, starting with the empty set and terminating with the
|
|
entire original sequence.<br/>
|
|
Subsets are produced in a deferred, streaming manner; however, each subset is returned
|
|
as a materialized list.<br/>
|
|
There are 2^N subsets of a given sequence, where N => sequence.Count().
|
|
</remarks>
|
|
<param name="sequence">Sequence for which to produce subsets</param>
|
|
<typeparam name="T">The type of the elements in the sequence</typeparam>
|
|
<returns>A sequence of lists that represent the all subsets of the original sequence</returns>
|
|
<exception cref="T:System.ArgumentNullException">Thrown if <paramref name="sequence"/> is <see langword="null"/></exception>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.SubsetsExtension.Subsets``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Returns a sequence of <see cref="T:System.Collections.Generic.IList`1"/> representing all
|
|
subsets of a given size that are part of the original sequence. In
|
|
mathematics, it is equivalent to the <em>combinations</em> or
|
|
<em>k-subsets</em> of a set.
|
|
</summary>
|
|
<param name="sequence">Sequence for which to produce subsets</param>
|
|
<param name="subsetSize">The size of the subsets to produce</param>
|
|
<typeparam name="T">The type of the elements in the sequence</typeparam>
|
|
<returns>A sequence of lists that represents of K-sized subsets of the original sequence</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
Thrown if <paramref name="sequence"/> is <see langword="null"/>
|
|
</exception>
|
|
<exception cref="T:System.ArgumentOutOfRangeException">
|
|
Thrown if <paramref name="subsetSize"/> is less than zero.
|
|
</exception>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.TagFirstLastExtension">
|
|
<summary><c>TagFirstLast</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.TagFirstLastExtension.TagFirstLast``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean,System.Boolean,``1})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TResult">The type of the element of the returned sequence.</typeparam>
|
|
<param name="source">The source sequence.</param>
|
|
<param name="resultSelector">A function that determines how to
|
|
project the each element along with its first or last tag.</param>
|
|
<returns>
|
|
Returns the resulting sequence.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = new[] { 123, 456, 789 };
|
|
var result = numbers.TagFirstLast((num, fst, lst) => new
|
|
{
|
|
Number = num,
|
|
IsFirst = fst, IsLast = lst
|
|
});
|
|
]]></code>
|
|
The <c>result</c> variable, when iterated over, will yield
|
|
<c>{ Number = 123, IsFirst = True, IsLast = False }</c>,
|
|
<c>{ Number = 456, IsFirst = False, IsLast = False }</c> and
|
|
<c>{ Number = 789, IsFirst = False, IsLast = True }</c> in turn.
|
|
</example>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.TakeEveryExtension">
|
|
<summary><c>TakeEvery</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.TakeEveryExtension.TakeEvery``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Returns every N-th element of a sequence.
|
|
</summary>
|
|
<typeparam name="TSource">Type of the source sequence</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<param name="step">Number of elements to bypass before returning the next element.</param>
|
|
<returns>
|
|
A sequence with every N-th element of the input sequence.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
int[] numbers = { 1, 2, 3, 4, 5 };
|
|
var result = numbers.TakeEvery(2);
|
|
]]></code>
|
|
The <c>result</c> variable, when iterated over, will yield 1, 3 and 5, in turn.
|
|
</example>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.TakeLastExtension">
|
|
<summary><c>TakeLast</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.TakeLastExtension.TakeLast``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Returns a specified number of contiguous elements from the end of
|
|
a sequence.
|
|
</summary>
|
|
<typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The sequence to return the last element of.</param>
|
|
<param name="count">The number of elements to return.</param>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that contains the specified number of
|
|
elements from the end of the input sequence.
|
|
</returns>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
int[] numbers = { 12, 34, 56, 78 };
|
|
var result = numbers.TakeLast(2);
|
|
]]></code>
|
|
The <c>result</c> variable, when iterated over, will yield
|
|
56 and 78 in turn.
|
|
</example>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.TakeUntilExtension">
|
|
<summary><c>TakeUntil</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.TakeUntilExtension.TakeUntil``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})">
|
|
<summary>
|
|
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.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
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.
|
|
</para>
|
|
<para>
|
|
Secondly, TakeUntil yields the element which causes the predicate to return true. For
|
|
example, in a sequence <code><![CDATA[{ 1, 2, 3, 4, 5 }]]></code> and with a predicate of
|
|
<code><![CDATA[x => x == 3]]></code>, the result would be <code><![CDATA[{ 1, 2, 3 }]]></code>.
|
|
</para>
|
|
<para>
|
|
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.)
|
|
</para>
|
|
</remarks>
|
|
<typeparam name="TSource">Type of the source sequence</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<param name="predicate">Predicate used to determine when to stop yielding results from the source.</param>
|
|
<returns>Items from the source sequence, until the predicate returns true when applied to the item.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is null</exception>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.ThenByExtension">
|
|
<summary><c>ThenBy</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ThenByExtension.ThenBy``2(System.Linq.IOrderedEnumerable{``0},System.Func{``0,``1},MoreLinq.OrderByDirection)">
|
|
<summary>
|
|
Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the source sequence</typeparam>
|
|
<typeparam name="TKey">The type of the key used to order elements</typeparam>
|
|
<param name="source">The sequence to order</param>
|
|
<param name="keySelector">A key selector function</param>
|
|
<param name="direction">A direction in which to order the elements (ascending, descending)</param>
|
|
<returns>An ordered copy of the source sequence</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ThenByExtension.ThenBy``2(System.Linq.IOrderedEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1},MoreLinq.OrderByDirection)">
|
|
<summary>
|
|
Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key
|
|
</summary>
|
|
<typeparam name="T">The type of the elements in the source sequence</typeparam>
|
|
<typeparam name="TKey">The type of the key used to order elements</typeparam>
|
|
<param name="source">The sequence to order</param>
|
|
<param name="keySelector">A key selector function</param>
|
|
<param name="direction">A direction in which to order the elements (ascending, descending)</param>
|
|
<param name="comparer">A comparer used to define the semantics of element comparison</param>
|
|
<returns>An ordered copy of the source sequence</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.ToArrayByIndexExtension">
|
|
<summary><c>ToArrayByIndex</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32})">
|
|
<summary>
|
|
Creates an array from an <see cref="T:System.Collections.Generic.IEnumerable`1"/> where a
|
|
function is used to determine the index at which an element will
|
|
be placed in the array.
|
|
</summary>
|
|
<param name="source">The source sequence for the array.</param>
|
|
<param name="indexSelector">
|
|
A function that maps an element to its index.</param>
|
|
<typeparam name="T">
|
|
The type of the element in <paramref name="source"/>.</typeparam>
|
|
<returns>
|
|
An array that contains the elements from the input sequence. The
|
|
size of the array will be as large as the highest index returned
|
|
by the <paramref name="indexSelector"/> plus 1.
|
|
</returns>
|
|
<remarks>
|
|
This method forces immediate query evaluation. It should not be
|
|
used on infinite sequences. If more than one element maps to the
|
|
same index then the latter element overwrites the former in the
|
|
resulting array.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,System.Int32})">
|
|
<summary>
|
|
Creates an array of user-specified length from an
|
|
<see cref="T:System.Collections.Generic.IEnumerable`1"/> where a function is used to determine
|
|
the index at which an element will be placed in the array.
|
|
</summary>
|
|
<param name="source">The source sequence for the array.</param>
|
|
<param name="length">The (non-negative) length of the resulting array.</param>
|
|
<param name="indexSelector">
|
|
A function that maps an element to its index.</param>
|
|
<typeparam name="T">
|
|
The type of the element in <paramref name="source"/>.</typeparam>
|
|
<returns>
|
|
An array of size <paramref name="length"/> that contains the
|
|
elements from the input sequence.
|
|
</returns>
|
|
<remarks>
|
|
This method forces immediate query evaluation. It should not be
|
|
used on infinite sequences. If more than one element maps to the
|
|
same index then the latter element overwrites the former in the
|
|
resulting array.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32},System.Func{``0,``1})">
|
|
<summary>
|
|
Creates an array from an <see cref="T:System.Collections.Generic.IEnumerable`1"/> 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.
|
|
</summary>
|
|
<param name="source">The source sequence for the array.</param>
|
|
<param name="indexSelector">
|
|
A function that maps an element to its index.</param>
|
|
<param name="resultSelector">
|
|
A function to project a source element into an element of the
|
|
resulting array.</param>
|
|
<typeparam name="T">
|
|
The type of the element in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the element in the resulting array.</typeparam>
|
|
<returns>
|
|
An array that contains the projected elements from the input
|
|
sequence. The size of the array will be as large as the highest
|
|
index returned by the <paramref name="indexSelector"/> plus 1.
|
|
</returns>
|
|
<remarks>
|
|
This method forces immediate query evaluation. It should not be
|
|
used on infinite sequences. If more than one element maps to the
|
|
same index then the latter element overwrites the former in the
|
|
resulting array.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32},System.Func{``0,System.Int32,``1})">
|
|
<summary>
|
|
Creates an array from an <see cref="T:System.Collections.Generic.IEnumerable`1"/> 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.
|
|
</summary>
|
|
<param name="source">The source sequence for the array.</param>
|
|
<param name="indexSelector">
|
|
A function that maps an element to its index.</param>
|
|
<param name="resultSelector">
|
|
A function to project a source element into an element of the
|
|
resulting array.</param>
|
|
<typeparam name="T">
|
|
The type of the element in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the element in the resulting array.</typeparam>
|
|
<returns>
|
|
An array that contains the projected elements from the input
|
|
sequence. The size of the array will be as large as the highest
|
|
index returned by the <paramref name="indexSelector"/> plus 1.
|
|
</returns>
|
|
<remarks>
|
|
This method forces immediate query evaluation. It should not be
|
|
used on infinite sequences. If more than one element maps to the
|
|
same index then the latter element overwrites the former in the
|
|
resulting array.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,System.Int32},System.Func{``0,``1})">
|
|
<summary>
|
|
Creates an array of user-specified length from an
|
|
<see cref="T:System.Collections.Generic.IEnumerable`1"/> 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.
|
|
</summary>
|
|
<param name="source">The source sequence for the array.</param>
|
|
<param name="length">The (non-negative) length of the resulting array.</param>
|
|
<param name="indexSelector">
|
|
A function that maps an element to its index.</param>
|
|
<param name="resultSelector">
|
|
A function to project a source element into an element of the
|
|
resulting array.</param>
|
|
<typeparam name="T">
|
|
The type of the element in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the element in the resulting array.</typeparam>
|
|
<returns>
|
|
An array of size <paramref name="length"/> that contains the
|
|
projected elements from the input sequence.
|
|
</returns>
|
|
<remarks>
|
|
This method forces immediate query evaluation. It should not be
|
|
used on infinite sequences. If more than one element maps to the
|
|
same index then the latter element overwrites the former in the
|
|
resulting array.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,System.Int32},System.Func{``0,System.Int32,``1})">
|
|
<summary>
|
|
Creates an array of user-specified length from an
|
|
<see cref="T:System.Collections.Generic.IEnumerable`1"/> 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.
|
|
</summary>
|
|
<param name="source">The source sequence for the array.</param>
|
|
<param name="length">The (non-negative) length of the resulting array.</param>
|
|
<param name="indexSelector">
|
|
A function that maps an element to its index.</param>
|
|
<param name="resultSelector">
|
|
A function to project a source element into an element of the
|
|
resulting array.</param>
|
|
<typeparam name="T">
|
|
The type of the element in <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TResult">
|
|
The type of the element in the resulting array.</typeparam>
|
|
<returns>
|
|
An array of size <paramref name="length"/> that contains the
|
|
projected elements from the input sequence.
|
|
</returns>
|
|
<remarks>
|
|
This method forces immediate query evaluation. It should not be
|
|
used on infinite sequences. If more than one element maps to the
|
|
same index then the latter element overwrites the former in the
|
|
resulting array.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.ToDelimitedStringExtension">
|
|
<summary><c>ToDelimitedString</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Boolean},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Byte},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Char},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Decimal},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Double},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Single},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Int32},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Int64},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(System.Collections.Generic.IEnumerable{System.SByte},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Int16},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(System.Collections.Generic.IEnumerable{System.String},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(System.Collections.Generic.IEnumerable{System.UInt32},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(System.Collections.Generic.IEnumerable{System.UInt64},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(System.Collections.Generic.IEnumerable{System.UInt16},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString``1(System.Collections.Generic.IEnumerable{``0},System.String)">
|
|
<summary>
|
|
Creates a delimited string from a sequence of values and
|
|
a given delimiter.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence</typeparam>
|
|
<param name="source">The sequence of items to delimit. Each is converted to a string using the
|
|
simple ToString() conversion.</param>
|
|
<param name="delimiter">The delimiter to inject between elements.</param>
|
|
<returns>
|
|
A string that consists of the elements in <paramref name="source"/>
|
|
delimited by <paramref name="delimiter"/>. If the source sequence
|
|
is empty, the method returns an empty string.
|
|
</returns>
|
|
<exception cref="T:System.ArgumentNullException">
|
|
<paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
|
|
</exception>
|
|
<remarks>
|
|
This operator uses immediate execution and effectively buffers the sequence.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.ToDictionaryExtension">
|
|
<summary><c>ToDictionary</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToDictionaryExtension.ToDictionary``2(System.Collections.Generic.IEnumerable{System.ValueTuple{``0,``1}})">
|
|
<summary>
|
|
Creates a <see cref="T:System.Collections.Generic.Dictionary`2" /> from a sequence of
|
|
tuples of 2 where the first item is the key and the second the
|
|
value.
|
|
</summary>
|
|
<typeparam name="TKey">The type of the key.</typeparam>
|
|
<typeparam name="TValue">The type of the value.</typeparam>
|
|
<param name="source">The source sequence of couples (tuple of 2).</param>
|
|
<returns>
|
|
A <see cref="T:System.Collections.Generic.Dictionary`2"/> containing the values
|
|
mapped to their keys.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToDictionaryExtension.ToDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}})">
|
|
<summary>
|
|
Creates a <see cref="T:System.Collections.Generic.Dictionary`2" /> from a sequence of
|
|
<see cref="T:System.Collections.Generic.KeyValuePair`2" /> elements.
|
|
</summary>
|
|
<typeparam name="TKey">The type of the key.</typeparam>
|
|
<typeparam name="TValue">The type of the value.</typeparam>
|
|
<param name="source">The source sequence of key-value pairs.</param>
|
|
<returns>
|
|
A <see cref="T:System.Collections.Generic.Dictionary`2"/> containing the values
|
|
mapped to their keys.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToDictionaryExtension.ToDictionary``2(System.Collections.Generic.IEnumerable{System.ValueTuple{``0,``1}},System.Collections.Generic.IEqualityComparer{``0})">
|
|
<summary>
|
|
Creates a <see cref="T:System.Collections.Generic.Dictionary`2" /> 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.
|
|
</summary>
|
|
<typeparam name="TKey">The type of the key.</typeparam>
|
|
<typeparam name="TValue">The type of the value.</typeparam>
|
|
<param name="source">The source sequence of couples (tuple of 2).</param>
|
|
<param name="comparer">The comparer for keys.</param>
|
|
<returns>
|
|
A <see cref="T:System.Collections.Generic.Dictionary`2"/> containing the values
|
|
mapped to their keys.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToDictionaryExtension.ToDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}},System.Collections.Generic.IEqualityComparer{``0})">
|
|
<summary>
|
|
Creates a <see cref="T:System.Collections.Generic.Dictionary`2" /> from a sequence of
|
|
<see cref="T:System.Collections.Generic.KeyValuePair`2" /> elements. An additional
|
|
parameter specifies a comparer for keys.
|
|
</summary>
|
|
<typeparam name="TKey">The type of the key.</typeparam>
|
|
<typeparam name="TValue">The type of the value.</typeparam>
|
|
<param name="source">The source sequence of key-value pairs.</param>
|
|
<param name="comparer">The comparer for keys.</param>
|
|
<returns>
|
|
A <see cref="T:System.Collections.Generic.Dictionary`2"/> containing the values
|
|
mapped to their keys.
|
|
</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.ToHashSetExtension">
|
|
<summary><c>ToHashSet</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToHashSetExtension.ToHashSet``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Returns a <see cref="T:System.Collections.Generic.HashSet`1"/> of the source items using the default equality
|
|
comparer for the type.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in source sequence.</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<returns>A hash set of the items in the sequence, using the default equality comparer.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<remarks>
|
|
This evaluates the input sequence completely.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToHashSetExtension.ToHashSet``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
|
|
<summary>
|
|
Returns a <see cref="T:System.Collections.Generic.HashSet`1"/> of the source items using the specified equality
|
|
comparer for the type.
|
|
</summary>
|
|
<typeparam name="TSource">Type of elements in source sequence.</typeparam>
|
|
<param name="source">Source sequence</param>
|
|
<param name="comparer">Equality comparer to use; a value of null will cause the type's default equality comparer to be used</param>
|
|
<returns>A hash set of the items in the sequence, using the default equality comparer.</returns>
|
|
<exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
|
|
<remarks>
|
|
This evaluates the input sequence completely.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.ToLookupExtension">
|
|
<summary><c>ToLookup</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToLookupExtension.ToLookup``2(System.Collections.Generic.IEnumerable{System.ValueTuple{``0,``1}})">
|
|
<summary>
|
|
Creates a <see cref="T:System.Linq.Lookup`2" /> from a sequence of
|
|
tuples of 2 where the first item is the key and the second the
|
|
value.
|
|
</summary>
|
|
<typeparam name="TKey">The type of the key.</typeparam>
|
|
<typeparam name="TValue">The type of the value.</typeparam>
|
|
<param name="source">The source sequence of tuples of 2.</param>
|
|
<returns>
|
|
A <see cref="T:System.Linq.Lookup`2"/> containing the values
|
|
mapped to their keys.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToLookupExtension.ToLookup``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}})">
|
|
<summary>
|
|
Creates a <see cref="T:System.Linq.ILookup`2" /> from a sequence of
|
|
<see cref="T:System.Collections.Generic.KeyValuePair`2" /> elements.
|
|
</summary>
|
|
<typeparam name="TKey">The type of the key.</typeparam>
|
|
<typeparam name="TValue">The type of the value.</typeparam>
|
|
<param name="source">The source sequence of key-value pairs.</param>
|
|
<returns>
|
|
A <see cref="T:System.Linq.ILookup`2"/> containing the values
|
|
mapped to their keys.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToLookupExtension.ToLookup``2(System.Collections.Generic.IEnumerable{System.ValueTuple{``0,``1}},System.Collections.Generic.IEqualityComparer{``0})">
|
|
<summary>
|
|
Creates a <see cref="T:System.Linq.Lookup`2" /> 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.
|
|
</summary>
|
|
<typeparam name="TKey">The type of the key.</typeparam>
|
|
<typeparam name="TValue">The type of the value.</typeparam>
|
|
<param name="source">The source sequence of tuples of 2.</param>
|
|
<param name="comparer">The comparer for keys.</param>
|
|
<returns>
|
|
A <see cref="T:System.Linq.Lookup`2"/> containing the values
|
|
mapped to their keys.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToLookupExtension.ToLookup``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}},System.Collections.Generic.IEqualityComparer{``0})">
|
|
<summary>
|
|
Creates a <see cref="T:System.Linq.ILookup`2" /> from a sequence of
|
|
<see cref="T:System.Collections.Generic.KeyValuePair`2" /> elements. An additional
|
|
parameter specifies a comparer for keys.
|
|
</summary>
|
|
<typeparam name="TKey">The type of the key.</typeparam>
|
|
<typeparam name="TValue">The type of the value.</typeparam>
|
|
<param name="source">The source sequence of key-value pairs.</param>
|
|
<param name="comparer">The comparer for keys.</param>
|
|
<returns>
|
|
A <see cref="T:System.Linq.ILookup`2"/> containing the values
|
|
mapped to their keys.
|
|
</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.TraceExtension">
|
|
<summary><c>Trace</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.TraceExtension.Trace``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Traces the elements of a source sequence for diagnostics.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence</typeparam>
|
|
<param name="source">Source sequence whose elements to trace.</param>
|
|
<returns>
|
|
Return the source sequence unmodified.
|
|
</returns>
|
|
<remarks>
|
|
This a pass-through operator that uses deferred execution and
|
|
streams the results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.TraceExtension.Trace``1(System.Collections.Generic.IEnumerable{``0},System.String)">
|
|
<summary>
|
|
Traces the elements of a source sequence for diagnostics using
|
|
custom formatting.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence</typeparam>
|
|
<param name="source">Source sequence whose elements to trace.</param>
|
|
<param name="format">
|
|
String to use to format the trace message. If null then the
|
|
element value becomes the traced message.
|
|
</param>
|
|
<returns>
|
|
Return the source sequence unmodified.
|
|
</returns>
|
|
<remarks>
|
|
This a pass-through operator that uses deferred execution and
|
|
streams the results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.TraceExtension.Trace``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.String})">
|
|
<summary>
|
|
Traces the elements of a source sequence for diagnostics using
|
|
a custom formatter.
|
|
</summary>
|
|
<typeparam name="TSource">Type of element in the source sequence</typeparam>
|
|
<param name="source">Source sequence whose elements to trace.</param>
|
|
<param name="formatter">Function used to format each source element into a string.</param>
|
|
<returns>
|
|
Return the source sequence unmodified.
|
|
</returns>
|
|
<remarks>
|
|
This a pass-through operator that uses deferred execution and
|
|
streams the results.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.TransposeExtension">
|
|
<summary><c>Transpose</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.TransposeExtension.Transpose``1(System.Collections.Generic.IEnumerable{System.Collections.Generic.IEnumerable{``0}})">
|
|
<summary>
|
|
Transposes a sequence of rows into a sequence of columns.
|
|
</summary>
|
|
<typeparam name="T">Type of source sequence elements.</typeparam>
|
|
<param name="source">Source sequence to transpose.</param>
|
|
<returns>
|
|
Returns a sequence of columns in the source swapped into rows.
|
|
</returns>
|
|
<remarks>
|
|
If a rows is shorter than a follow it then the shorter row's
|
|
elements are skipped in the corresponding column sequences.
|
|
This operator uses deferred execution and streams its results.
|
|
Source sequence is consumed greedily when an iteration begins.
|
|
The inner sequences representing rows are consumed lazily and
|
|
resulting sequences of columns are streamed.
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
var matrix = new[]
|
|
{
|
|
new[] { 10, 11 },
|
|
new[] { 20 },
|
|
new[] { 30, 31, 32 }
|
|
};
|
|
var result = matrix.Transpose();
|
|
]]></code>
|
|
The <c>result</c> variable will contain [[10, 20, 30], [11, 31], [32]].
|
|
</example>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.WindowExtension">
|
|
<summary><c>Window</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.WindowExtension.Window``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Processes a sequence into a series of subsequences representing a windowed subset of the original
|
|
</summary>
|
|
<remarks>
|
|
The number of sequences returned is: <c>Max(0, sequence.Count() - windowSize) + 1</c><br/>
|
|
Returned subsequences are buffered, but the overall operation is streamed.<br/>
|
|
</remarks>
|
|
<typeparam name="TSource">The type of the elements of the source sequence</typeparam>
|
|
<param name="source">The sequence to evaluate a sliding window over</param>
|
|
<param name="size">The size (number of elements) in each window</param>
|
|
<returns>A series of sequences representing each sliding window subsequence</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.WindowLeftExtension">
|
|
<summary><c>WindowLeft</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.WindowLeftExtension.WindowLeft``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Creates a left-aligned sliding window of a given size over the
|
|
source sequence.
|
|
</summary>
|
|
<typeparam name="TSource">
|
|
The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">
|
|
The sequence over which to create the sliding window.</param>
|
|
<param name="size">Size of the sliding window.</param>
|
|
<returns>A sequence representing each sliding window.</returns>
|
|
<remarks>
|
|
<para>
|
|
A window can contain fewer elements than <paramref name="size"/>,
|
|
especially as it slides over the end of the sequence.</para>
|
|
<para>
|
|
This operator uses deferred execution and streams its results.</para>
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
Console.WriteLine(
|
|
Enumerable
|
|
.Range(1, 5)
|
|
.WindowLeft(3)
|
|
.Select(w => "AVG(" + w.ToDelimitedString(",") + ") = " + w.Average())
|
|
.ToDelimitedString(Environment.NewLine));
|
|
|
|
// Output:
|
|
// AVG(1,2,3) = 2
|
|
// AVG(2,3,4) = 3
|
|
// AVG(3,4,5) = 4
|
|
// AVG(4,5) = 4.5
|
|
// AVG(5) = 5
|
|
]]></code>
|
|
</example>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.WindowRightExtension">
|
|
<summary><c>WindowRight</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.WindowRightExtension.WindowRight``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
|
|
<summary>
|
|
Creates a right-aligned sliding window over the source sequence
|
|
of a given size.
|
|
</summary>
|
|
<typeparam name="TSource">
|
|
The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">
|
|
The sequence over which to create the sliding window.</param>
|
|
<param name="size">Size of the sliding window.</param>
|
|
<returns>A sequence representing each sliding window.</returns>
|
|
<remarks>
|
|
<para>
|
|
A window can contain fewer elements than <paramref name="size"/>,
|
|
especially as it slides over the start of the sequence.</para>
|
|
<para>
|
|
This operator uses deferred execution and streams its results.</para>
|
|
</remarks>
|
|
<example>
|
|
<code><![CDATA[
|
|
Console.WriteLine(
|
|
Enumerable
|
|
.Range(1, 5)
|
|
.WindowRight(3)
|
|
.Select(w => "AVG(" + w.ToDelimitedString(",") + ") = " + w.Average())
|
|
.ToDelimitedString(Environment.NewLine));
|
|
|
|
// Output:
|
|
// AVG(1) = 1
|
|
// AVG(1,2) = 1.5
|
|
// AVG(1,2,3) = 2
|
|
// AVG(2,3,4) = 3
|
|
// AVG(3,4,5) = 4
|
|
]]></code>
|
|
</example>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.ZipLongestExtension">
|
|
<summary><c>ZipLongest</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ZipLongestExtension.ZipLongest``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
|
|
<summary>
|
|
Returns a projection of tuples, where each tuple contains the N-th
|
|
element from each of the argument sequences. The resulting sequence
|
|
will always be as long as the longest of input sequences where the
|
|
default value of each of the shorter sequence element types is used
|
|
for padding.
|
|
</summary>
|
|
<typeparam name="TFirst">Type of elements in first sequence.</typeparam>
|
|
<typeparam name="TSecond">Type of elements in second sequence.</typeparam>
|
|
<typeparam name="TResult">Type of elements in result sequence.</typeparam>
|
|
<param name="first">The first sequence.</param>
|
|
<param name="second">The second sequence.</param>
|
|
<param name="resultSelector">
|
|
Function to apply to each pair of elements.</param>
|
|
<returns>
|
|
A sequence that contains elements of the two input sequences,
|
|
combined by <paramref name="resultSelector"/>.
|
|
</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = { 1, 2, 3 };
|
|
var letters = { "A", "B", "C", "D" };
|
|
var zipped = numbers.ZipLongest(letters, (n, l) => n + l);
|
|
]]></code>
|
|
The <c>zipped</c> variable, when iterated over, will yield "1A",
|
|
"2B", "3C", "0D" in turn.
|
|
</example>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ZipLongestExtension.ZipLongest``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
|
|
<summary>
|
|
Returns a projection of tuples, where each tuple contains the N-th
|
|
element from each of the argument sequences. The resulting sequence
|
|
will always be as long as the longest of input sequences where the
|
|
default value of each of the shorter sequence element types is used
|
|
for padding.
|
|
</summary>
|
|
<typeparam name="T1">Type of elements in first sequence.</typeparam>
|
|
<typeparam name="T2">Type of elements in second sequence.</typeparam>
|
|
<typeparam name="T3">Type of elements in third sequence.</typeparam>
|
|
<typeparam name="TResult">Type of elements in result sequence.</typeparam>
|
|
<param name="first">The first sequence.</param>
|
|
<param name="second">The second sequence.</param>
|
|
<param name="third">The third sequence.</param>
|
|
<param name="resultSelector">
|
|
Function to apply to each triplet of elements.</param>
|
|
<returns>
|
|
A sequence that contains elements of the three input sequences,
|
|
combined by <paramref name="resultSelector"/>.
|
|
</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = new[] { 1, 2, 3 };
|
|
var letters = new[] { "A", "B", "C", "D" };
|
|
var chars = new[] { 'a', 'b', 'c', 'd', 'e' };
|
|
var zipped = numbers.ZipLongest(letters, chars, (n, l, c) => n + l + c);
|
|
]]></code>
|
|
The <c>zipped</c> variable, when iterated over, will yield "1Aa",
|
|
"2Bb", "3Cc", "0Dd", "0e" in turn.
|
|
</example>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ZipLongestExtension.ZipLongest``5(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Func{``0,``1,``2,``3,``4})">
|
|
<summary>
|
|
Returns a projection of tuples, where each tuple contains the N-th
|
|
element from each of the argument sequences. The resulting sequence
|
|
will always be as long as the longest of input sequences where the
|
|
default value of each of the shorter sequence element types is used
|
|
for padding.
|
|
</summary>
|
|
<typeparam name="T1">Type of elements in first sequence</typeparam>
|
|
<typeparam name="T2">Type of elements in second sequence</typeparam>
|
|
<typeparam name="T3">Type of elements in third sequence</typeparam>
|
|
<typeparam name="T4">Type of elements in fourth sequence</typeparam>
|
|
<typeparam name="TResult">Type of elements in result sequence</typeparam>
|
|
<param name="first">The first sequence.</param>
|
|
<param name="second">The second sequence.</param>
|
|
<param name="third">The third sequence.</param>
|
|
<param name="fourth">The fourth sequence.</param>
|
|
<param name="resultSelector">
|
|
Function to apply to each quadruplet of elements.</param>
|
|
<returns>
|
|
A sequence that contains elements of the four input sequences,
|
|
combined by <paramref name="resultSelector"/>.
|
|
</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var 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, true, false, true, false };
|
|
var zipped = numbers.ZipLongest(letters, chars, flags, (n, l, c, f) => n + l + c + f);
|
|
]]></code>
|
|
The <c>zipped</c> variable, when iterated over, will yield "1AaTrue",
|
|
"2BbFalse", "3CcTrue", "0DdFalse", "0eTrue", "0\0False" in turn.
|
|
</example>
|
|
<remarks>
|
|
This operator uses deferred execution and streams its results.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.ZipShortestExtension">
|
|
<summary><c>ZipShortest</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ZipShortestExtension.ZipShortest``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
|
|
<summary>
|
|
Returns a projection of tuples, where each tuple contains the N-th
|
|
element from each of the argument sequences. The resulting sequence
|
|
is as short as the shortest input sequence.
|
|
</summary>
|
|
<typeparam name="TFirst">Type of elements in first sequence.</typeparam>
|
|
<typeparam name="TSecond">Type of elements in second sequence.</typeparam>
|
|
<typeparam name="TResult">Type of elements in result sequence.</typeparam>
|
|
<param name="first">The first sequence.</param>
|
|
<param name="second">The second sequence.</param>
|
|
<param name="resultSelector">
|
|
Function to apply to each pair of elements.</param>
|
|
<returns>
|
|
A projection of tuples, where each tuple contains the N-th element
|
|
from each of the argument sequences.</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var numbers = new[] { 1, 2, 3 };
|
|
var letters = new[] { "A", "B", "C", "D" };
|
|
var zipped = numbers.ZipShortest(letters, (n, l) => n + l);
|
|
]]></code>
|
|
The <c>zipped</c> variable, when iterated over, will yield "1A", "2B", "3C", in turn.
|
|
</example>
|
|
<remarks>
|
|
<para>
|
|
If the input sequences are of different lengths, the result sequence
|
|
is terminated as soon as the shortest input sequence is exhausted
|
|
and remainder elements from the longer sequences are never consumed.
|
|
</para>
|
|
<para>
|
|
This operator uses deferred execution and streams its results.</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ZipShortestExtension.ZipShortest``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
|
|
<summary>
|
|
Returns a projection of tuples, where each tuple contains the N-th
|
|
element from each of the argument sequences. The resulting sequence
|
|
is as short as the shortest input sequence.
|
|
</summary>
|
|
<typeparam name="T1">Type of elements in first sequence.</typeparam>
|
|
<typeparam name="T2">Type of elements in second sequence.</typeparam>
|
|
<typeparam name="T3">Type of elements in third sequence.</typeparam>
|
|
<typeparam name="TResult">Type of elements in result sequence.</typeparam>
|
|
<param name="first">First sequence</param>
|
|
<param name="second">Second sequence</param>
|
|
<param name="third">Third sequence</param>
|
|
<param name="resultSelector">
|
|
Function to apply to each triplet of elements.</param>
|
|
<returns>
|
|
A projection of tuples, where each tuple contains the N-th element
|
|
from each of the argument sequences.</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var 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);
|
|
]]></code>
|
|
The <c>zipped</c> variable, when iterated over, will yield
|
|
"98A", "100B", "102C", in turn.
|
|
</example>
|
|
<remarks>
|
|
<para>
|
|
If the input sequences are of different lengths, the result sequence
|
|
is terminated as soon as the shortest input sequence is exhausted
|
|
and remainder elements from the longer sequences are never consumed.
|
|
</para>
|
|
<para>
|
|
This operator uses deferred execution and streams its results.</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ZipShortestExtension.ZipShortest``5(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Func{``0,``1,``2,``3,``4})">
|
|
<summary>
|
|
Returns a projection of tuples, where each tuple contains the N-th
|
|
element from each of the argument sequences. The resulting sequence
|
|
is as short as the shortest input sequence.
|
|
</summary>
|
|
<typeparam name="T1">Type of elements in first sequence.</typeparam>
|
|
<typeparam name="T2">Type of elements in second sequence.</typeparam>
|
|
<typeparam name="T3">Type of elements in third sequence.</typeparam>
|
|
<typeparam name="T4">Type of elements in fourth sequence.</typeparam>
|
|
<typeparam name="TResult">Type of elements in result sequence.</typeparam>
|
|
<param name="first">The first sequence.</param>
|
|
<param name="second">The second sequence.</param>
|
|
<param name="third">The third sequence.</param>
|
|
<param name="fourth">The fourth sequence.</param>
|
|
<param name="resultSelector">
|
|
Function to apply to each quadruplet of elements.</param>
|
|
<returns>
|
|
A projection of tuples, where each tuple contains the N-th element
|
|
from each of the argument sequences.</returns>
|
|
<example>
|
|
<code><![CDATA[
|
|
var 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);
|
|
]]></code>
|
|
The <c>zipped</c> variable, when iterated over, will yield
|
|
"1AaTrue", "2BbFalse" in turn.
|
|
</example>
|
|
<remarks>
|
|
<para>
|
|
If the input sequences are of different lengths, the result sequence
|
|
is terminated as soon as the shortest input sequence is exhausted
|
|
and remainder elements from the longer sequences are never consumed.
|
|
</para>
|
|
<para>
|
|
This operator uses deferred execution and streams its results.</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.Extensions.ToDataTableExtension">
|
|
<summary><c>ToDataTable</c> extension.</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToDataTableExtension.ToDataTable``1(System.Collections.Generic.IEnumerable{``0})">
|
|
<summary>
|
|
Converts a sequence to a <see cref="T:System.Data.DataTable"/> object.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The source.</param>
|
|
<returns>
|
|
A <see cref="T:System.Data.DataTable"/> representing the source.
|
|
</returns>
|
|
<remarks>This operator uses immediate execution.</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToDataTableExtension.ToDataTable``1(System.Collections.Generic.IEnumerable{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Object}}[])">
|
|
<summary>
|
|
Appends elements in the sequence as rows of a given <see cref="T:System.Data.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.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<param name="source">The source.</param>
|
|
<param name="expressions">Expressions providing access to element members.</param>
|
|
<returns>
|
|
A <see cref="T:System.Data.DataTable"/> representing the source.
|
|
</returns>
|
|
<remarks>This operator uses immediate execution.</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToDataTableExtension.ToDataTable``2(System.Collections.Generic.IEnumerable{``0},``1)">
|
|
<summary>
|
|
Appends elements in the sequence as rows of a given <see cref="T:System.Data.DataTable"/> object.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TTable"></typeparam>
|
|
<param name="source">The source.</param>
|
|
<param name="table"></param>
|
|
<returns>
|
|
A <see cref="T:System.Data.DataTable"/> or subclass representing the source.
|
|
</returns>
|
|
<remarks>This operator uses immediate execution.</remarks>
|
|
</member>
|
|
<member name="M:MoreLinq.Extensions.ToDataTableExtension.ToDataTable``2(System.Collections.Generic.IEnumerable{``0},``1,System.Linq.Expressions.Expression{System.Func{``0,System.Object}}[])">
|
|
<summary>
|
|
Appends elements in the sequence as rows of a given <see cref="T:System.Data.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.
|
|
</summary>
|
|
<typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
|
|
<typeparam name="TTable">The type of the input and resulting <see cref="T:System.Data.DataTable"/> object.</typeparam>
|
|
<param name="source">The source.</param>
|
|
<param name="table">The <see cref="T:System.Data.DataTable"/> type of object where to add rows</param>
|
|
<param name="expressions">Expressions providing access to element members.</param>
|
|
<returns>
|
|
A <see cref="T:System.Data.DataTable"/> or subclass representing the source.
|
|
</returns>
|
|
<remarks>This operator uses immediate execution.</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.IListLike`1">
|
|
<summary>
|
|
Represents an list-like (indexable) data structure.
|
|
</summary>
|
|
</member>
|
|
<member name="T:MoreLinq.Lookup`2">
|
|
<summary>
|
|
A <see cref="T:System.Linq.ILookup`2"/> implementation that preserves insertion order
|
|
</summary>
|
|
<typeparam name="TKey">The type of the keys in the <see cref="T:MoreLinq.Lookup`2"/></typeparam>
|
|
<typeparam name="TElement">The type of the elements in the <see cref="T:System.Collections.Generic.IEnumerable`1"/> sequences that make up the values in the <see cref="T:MoreLinq.Lookup`2"/></typeparam>
|
|
<remarks>
|
|
This implementation preserves insertion order of keys and elements within each <see cref="T:System.Collections.Generic.IEnumerable`1"/>
|
|
Copied over from CoreFX on 2015-10-27
|
|
https://github.com/dotnet/corefx/blob/6f1c2a86fb8fa1bdaee7c6e70a684d27842d804c/src/System.Linq/src/System/Linq/Enumerable.cs#L3230-L3403
|
|
Modified to remove internal interfaces
|
|
</remarks>
|
|
</member>
|
|
<member name="T:MoreLinq.IExtremaEnumerable`1">
|
|
<summary>
|
|
Exposes the enumerator, which supports iteration over a sequence of
|
|
some extremum property (maximum or minimum) of a specified type.
|
|
</summary>
|
|
<typeparam name="T">The type of objects to enumerate.</typeparam>
|
|
</member>
|
|
<member name="M:MoreLinq.IExtremaEnumerable`1.Take(System.Int32)">
|
|
<summary>
|
|
Returns a specified number of contiguous elements from the start of
|
|
the sequence.
|
|
</summary>
|
|
<param name="count">The number of elements to return.</param>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that contains the specified number
|
|
of elements from the start of the input sequence.
|
|
</returns>
|
|
</member>
|
|
<member name="M:MoreLinq.IExtremaEnumerable`1.TakeLast(System.Int32)">
|
|
<summary>
|
|
Returns a specified number of contiguous elements at the end of the
|
|
sequence.
|
|
</summary>
|
|
<param name="count">The number of elements to return.</param>
|
|
<returns>
|
|
An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that contains the specified number
|
|
of elements at the end of the input sequence.
|
|
</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.OrderByDirection">
|
|
<summary>
|
|
Enumeration that defines values representing valid ordering directions for a sequence.
|
|
</summary>
|
|
</member>
|
|
<member name="F:MoreLinq.OrderByDirection.Ascending">
|
|
<summary>
|
|
Elements are ordered by increasing value
|
|
</summary>
|
|
</member>
|
|
<member name="F:MoreLinq.OrderByDirection.Descending">
|
|
<summary>
|
|
Elements are ordered by decreasing value
|
|
</summary>
|
|
</member>
|
|
<member name="T:MoreLinq.PendNode`1">
|
|
<summary>
|
|
Prepend-Append node is a single linked-list of the discriminated union
|
|
of an item to prepend, an item to append and the source.
|
|
</summary>
|
|
</member>
|
|
<member name="T:MoreLinq.Reactive.Observable">
|
|
<summary>
|
|
Provides a set of static methods for writing in-memory queries over observable sequences.
|
|
</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.Reactive.Observable.Subscribe``1(System.IObservable{``0},System.Action{``0},System.Action{System.Exception},System.Action)">
|
|
<summary>
|
|
Subscribes an element handler and a completion handler to an
|
|
observable sequence.
|
|
</summary>
|
|
<typeparam name="T">Type of elements in <paramref name="source"/>.</typeparam>
|
|
<param name="source">Observable sequence to subscribe to.</param>
|
|
<param name="onNext">
|
|
Action to invoke for each element in <paramref name="source"/>.</param>
|
|
<param name="onError">
|
|
Action to invoke upon exceptional termination of the
|
|
<paramref name="source"/>.</param>
|
|
<param name="onCompleted">
|
|
Action to invoke upon graceful termination of <paramref name="source"/>.</param>
|
|
<returns>The subscription, which when disposed, will unsubscribe
|
|
from <paramref name="source"/>.</returns>
|
|
</member>
|
|
<member name="T:MoreLinq.SequenceException">
|
|
<summary>
|
|
The exception that is thrown for a sequence that fails a condition.
|
|
</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.SequenceException.#ctor">
|
|
<summary>
|
|
Initializes a new instance of the <see cref="T:MoreLinq.SequenceException"/> class.
|
|
</summary>
|
|
</member>
|
|
<member name="M:MoreLinq.SequenceException.#ctor(System.String)">
|
|
<summary>
|
|
Initializes a new instance of the <see cref="T:MoreLinq.SequenceException"/> class
|
|
with a given error message.
|
|
</summary>
|
|
<param name="message">A message that describes the error.</param>
|
|
</member>
|
|
<member name="M:MoreLinq.SequenceException.#ctor(System.String,System.Exception)">
|
|
<summary>
|
|
Initializes a new instance of the <see cref="T:MoreLinq.SequenceException"/> class
|
|
with a given error message and a reference to the inner exception
|
|
that is the cause of the exception.
|
|
</summary>
|
|
<param name="message">A message that describes the error.</param>
|
|
<param name="innerException">The exception that is the cause of the current exception.</param>
|
|
</member>
|
|
<member name="M:MoreLinq.SequenceException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
|
|
<summary>
|
|
Initializes a new instance of the <see cref="T:MoreLinq.SequenceException"/> class
|
|
with serialized data.
|
|
</summary>
|
|
<param name="info">The object that holds the serialized object data.</param>
|
|
<param name="context">The contextual information about the source or destination.</param>
|
|
</member>
|
|
</members>
|
|
</doc>
|