Please try to load the page again. If the error persists, please contact the site administrator.
+The URL might be misspelled or the page you are looking for is no longer available. If you typed in the +URL, check that it does not contain a typo. You can return to the main page to +use the table of contents or the search option to try and locate the page.
+| SerializeObjectState | Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception. (Inherited from Exception) Obsolete. |
public static readonly AwaitQueryOptions DefaultPublic Shared ReadOnly Default As AwaitQueryOptionspublic:
+static initonly AwaitQueryOptions^ Defaultstatic val Default: AwaitQueryOptions| Default | + The default options used for a query whose results evaluate + asynchronously. + |
public static IAsyncEnumerable<T> Merge<T>(
+ this IEnumerable<IAsyncEnumerable<T>> sources
+)
+<ExtensionAttribute>
+Public Shared Function Merge(Of T) (
+ sources As IEnumerable(Of IAsyncEnumerable(Of T))
+) As IAsyncEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IAsyncEnumerable<T>^ Merge(
+ IEnumerable<IAsyncEnumerable<T>^>^ sources
+)[<ExtensionAttribute>]
+static member Merge :
+ sources : IEnumerable<IAsyncEnumerable<'T>> -> IAsyncEnumerable<'T> This operator uses deferred execution and streams its results.
+ The elements in the resulting stream may appear in a different order than their order in + sources.
+ When disposed part of the way, there is a best-effort attempt to cancel all iterations + that are in flight. This requires that all asynchronous streams in sources properly honour timely cancellation.
public static IAsyncEnumerable<T> Merge<T>(
+ this IEnumerable<IAsyncEnumerable<T>> sources,
+ int maxConcurrent
+)
+<ExtensionAttribute>
+Public Shared Function Merge(Of T) (
+ sources As IEnumerable(Of IAsyncEnumerable(Of T)),
+ maxConcurrent As Integer
+) As IAsyncEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IAsyncEnumerable<T>^ Merge(
+ IEnumerable<IAsyncEnumerable<T>^>^ sources,
+ int maxConcurrent
+)[<ExtensionAttribute>]
+static member Merge :
+ sources : IEnumerable<IAsyncEnumerable<'T>> *
+ maxConcurrent : int -> IAsyncEnumerable<'T> + This operator uses deferred execution and streams its results.
+ When maxConcurrent is 2 or greater then the elements in the resulting + stream may appear in a different order than their order in sources.
+ When disposed part of the way, there is a best-effort attempt to cancel all iterations + that are in flight. This requires that all asynchronous streams in sources properly honour timely cancellation.
public AwaitQueryOptions WithMaxConcurrency(
+ int? value
+)Public Function WithMaxConcurrency (
+ value As Integer?
+) As AwaitQueryOptionspublic:
+AwaitQueryOptions^ WithMaxConcurrency(
+ Nullable<int> value
+)member WithMaxConcurrency :
+ value : Nullable<int> -> AwaitQueryOptions public AwaitQueryOptions WithPreserveOrder(
+ bool value
+)Public Function WithPreserveOrder (
+ value As Boolean
+) As AwaitQueryOptionspublic:
+AwaitQueryOptions^ WithPreserveOrder(
+ bool value
+)member WithPreserveOrder :
+ value : bool -> AwaitQueryOptions public AwaitQueryOptions WithScheduler(
+ TaskScheduler value
+)Public Function WithScheduler (
+ value As TaskScheduler
+) As AwaitQueryOptionspublic:
+AwaitQueryOptions^ WithScheduler(
+ TaskScheduler^ value
+)member WithScheduler :
+ value : TaskScheduler -> AwaitQueryOptions public static TResult Aggregate<T, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult8, TResult>(
+ this IEnumerable<T> source,
+ Func<IObservable<T>, IObservable<TResult1>> accumulator1,
+ Func<IObservable<T>, IObservable<TResult2>> accumulator2,
+ Func<IObservable<T>, IObservable<TResult3>> accumulator3,
+ Func<IObservable<T>, IObservable<TResult4>> accumulator4,
+ Func<IObservable<T>, IObservable<TResult5>> accumulator5,
+ Func<IObservable<T>, IObservable<TResult6>> accumulator6,
+ Func<IObservable<T>, IObservable<TResult7>> accumulator7,
+ Func<IObservable<T>, IObservable<TResult8>> accumulator8,
+ Func<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult8, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Aggregate(Of T, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult8, TResult) (
+ source As IEnumerable(Of T),
+ accumulator1 As Func(Of IObservable(Of T), IObservable(Of TResult1)),
+ accumulator2 As Func(Of IObservable(Of T), IObservable(Of TResult2)),
+ accumulator3 As Func(Of IObservable(Of T), IObservable(Of TResult3)),
+ accumulator4 As Func(Of IObservable(Of T), IObservable(Of TResult4)),
+ accumulator5 As Func(Of IObservable(Of T), IObservable(Of TResult5)),
+ accumulator6 As Func(Of IObservable(Of T), IObservable(Of TResult6)),
+ accumulator7 As Func(Of IObservable(Of T), IObservable(Of TResult7)),
+ accumulator8 As Func(Of IObservable(Of T), IObservable(Of TResult8)),
+ resultSelector As Func(Of TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult8, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult1, typename TResult2, typename TResult3, typename TResult4, typename TResult5, typename TResult6, typename TResult7, typename TResult8, typename TResult>
+static TResult Aggregate(
+ IEnumerable<T>^ source,
+ Func<IObservable<T>^, IObservable<TResult1>^>^ accumulator1,
+ Func<IObservable<T>^, IObservable<TResult2>^>^ accumulator2,
+ Func<IObservable<T>^, IObservable<TResult3>^>^ accumulator3,
+ Func<IObservable<T>^, IObservable<TResult4>^>^ accumulator4,
+ Func<IObservable<T>^, IObservable<TResult5>^>^ accumulator5,
+ Func<IObservable<T>^, IObservable<TResult6>^>^ accumulator6,
+ Func<IObservable<T>^, IObservable<TResult7>^>^ accumulator7,
+ Func<IObservable<T>^, IObservable<TResult8>^>^ accumulator8,
+ Func<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult8, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Aggregate :
+ source : IEnumerable<'T> *
+ accumulator1 : Func<IObservable<'T>, IObservable<'TResult1>> *
+ accumulator2 : Func<IObservable<'T>, IObservable<'TResult2>> *
+ accumulator3 : Func<IObservable<'T>, IObservable<'TResult3>> *
+ accumulator4 : Func<IObservable<'T>, IObservable<'TResult4>> *
+ accumulator5 : Func<IObservable<'T>, IObservable<'TResult5>> *
+ accumulator6 : Func<IObservable<'T>, IObservable<'TResult6>> *
+ accumulator7 : Func<IObservable<'T>, IObservable<'TResult7>> *
+ accumulator8 : Func<IObservable<'T>, IObservable<'TResult8>> *
+ resultSelector : Func<'TResult1, 'TResult2, 'TResult3, 'TResult4, 'TResult5, 'TResult6, 'TResult7, 'TResult8, 'TResult> -> 'TResult This operator executes immediately.
+ Each accumulator argument is a function that receives an + IObservableT, which when subscribed to, produces the + items in the source sequence and in original + order; the function must then return an IObservableT + that produces a single aggregate on completion (when + OnCompleted is called. An error is raised + at run-time if the IObserverT returned by an + accumulator function produces no result or produces more than a + single result. +
| InvalidOperationException | + An IObservableT returned by an accumulator function + produced zero or more than a single aggregate result. + |
public static TResult Aggregate<T, TResult1, TResult2, TResult>(
+ this IEnumerable<T> source,
+ Func<IObservable<T>, IObservable<TResult1>> accumulator1,
+ Func<IObservable<T>, IObservable<TResult2>> accumulator2,
+ Func<TResult1, TResult2, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Aggregate(Of T, TResult1, TResult2, TResult) (
+ source As IEnumerable(Of T),
+ accumulator1 As Func(Of IObservable(Of T), IObservable(Of TResult1)),
+ accumulator2 As Func(Of IObservable(Of T), IObservable(Of TResult2)),
+ resultSelector As Func(Of TResult1, TResult2, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult1, typename TResult2, typename TResult>
+static TResult Aggregate(
+ IEnumerable<T>^ source,
+ Func<IObservable<T>^, IObservable<TResult1>^>^ accumulator1,
+ Func<IObservable<T>^, IObservable<TResult2>^>^ accumulator2,
+ Func<TResult1, TResult2, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Aggregate :
+ source : IEnumerable<'T> *
+ accumulator1 : Func<IObservable<'T>, IObservable<'TResult1>> *
+ accumulator2 : Func<IObservable<'T>, IObservable<'TResult2>> *
+ resultSelector : Func<'TResult1, 'TResult2, 'TResult> -> 'TResult This operator executes immediately.
+ Each accumulator argument is a function that receives an + IObservableT, which when subscribed to, produces the + items in the source sequence and in original + order; the function must then return an IObservableT + that produces a single aggregate on completion (when + OnCompleted is called. An error is raised + at run-time if the IObserverT returned by an + accumulator function produces no result or produces more than a + single result. +
| InvalidOperationException | + An IObservableT returned by an accumulator function + produced zero or more than a single aggregate result. + |
public static TResult Aggregate<T, TResult1, TResult2, TResult3, TResult>(
+ this IEnumerable<T> source,
+ Func<IObservable<T>, IObservable<TResult1>> accumulator1,
+ Func<IObservable<T>, IObservable<TResult2>> accumulator2,
+ Func<IObservable<T>, IObservable<TResult3>> accumulator3,
+ Func<TResult1, TResult2, TResult3, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Aggregate(Of T, TResult1, TResult2, TResult3, TResult) (
+ source As IEnumerable(Of T),
+ accumulator1 As Func(Of IObservable(Of T), IObservable(Of TResult1)),
+ accumulator2 As Func(Of IObservable(Of T), IObservable(Of TResult2)),
+ accumulator3 As Func(Of IObservable(Of T), IObservable(Of TResult3)),
+ resultSelector As Func(Of TResult1, TResult2, TResult3, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult1, typename TResult2, typename TResult3, typename TResult>
+static TResult Aggregate(
+ IEnumerable<T>^ source,
+ Func<IObservable<T>^, IObservable<TResult1>^>^ accumulator1,
+ Func<IObservable<T>^, IObservable<TResult2>^>^ accumulator2,
+ Func<IObservable<T>^, IObservable<TResult3>^>^ accumulator3,
+ Func<TResult1, TResult2, TResult3, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Aggregate :
+ source : IEnumerable<'T> *
+ accumulator1 : Func<IObservable<'T>, IObservable<'TResult1>> *
+ accumulator2 : Func<IObservable<'T>, IObservable<'TResult2>> *
+ accumulator3 : Func<IObservable<'T>, IObservable<'TResult3>> *
+ resultSelector : Func<'TResult1, 'TResult2, 'TResult3, 'TResult> -> 'TResult This operator executes immediately.
+ Each accumulator argument is a function that receives an + IObservableT, which when subscribed to, produces the + items in the source sequence and in original + order; the function must then return an IObservableT + that produces a single aggregate on completion (when + OnCompleted is called. An error is raised + at run-time if the IObserverT returned by an + accumulator function produces no result or produces more than a + single result. +
| InvalidOperationException | + An IObservableT returned by an accumulator function + produced zero or more than a single aggregate result. + |
public static TResult Aggregate<T, TResult1, TResult2, TResult3, TResult4, TResult>(
+ this IEnumerable<T> source,
+ Func<IObservable<T>, IObservable<TResult1>> accumulator1,
+ Func<IObservable<T>, IObservable<TResult2>> accumulator2,
+ Func<IObservable<T>, IObservable<TResult3>> accumulator3,
+ Func<IObservable<T>, IObservable<TResult4>> accumulator4,
+ Func<TResult1, TResult2, TResult3, TResult4, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Aggregate(Of T, TResult1, TResult2, TResult3, TResult4, TResult) (
+ source As IEnumerable(Of T),
+ accumulator1 As Func(Of IObservable(Of T), IObservable(Of TResult1)),
+ accumulator2 As Func(Of IObservable(Of T), IObservable(Of TResult2)),
+ accumulator3 As Func(Of IObservable(Of T), IObservable(Of TResult3)),
+ accumulator4 As Func(Of IObservable(Of T), IObservable(Of TResult4)),
+ resultSelector As Func(Of TResult1, TResult2, TResult3, TResult4, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult1, typename TResult2, typename TResult3, typename TResult4, typename TResult>
+static TResult Aggregate(
+ IEnumerable<T>^ source,
+ Func<IObservable<T>^, IObservable<TResult1>^>^ accumulator1,
+ Func<IObservable<T>^, IObservable<TResult2>^>^ accumulator2,
+ Func<IObservable<T>^, IObservable<TResult3>^>^ accumulator3,
+ Func<IObservable<T>^, IObservable<TResult4>^>^ accumulator4,
+ Func<TResult1, TResult2, TResult3, TResult4, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Aggregate :
+ source : IEnumerable<'T> *
+ accumulator1 : Func<IObservable<'T>, IObservable<'TResult1>> *
+ accumulator2 : Func<IObservable<'T>, IObservable<'TResult2>> *
+ accumulator3 : Func<IObservable<'T>, IObservable<'TResult3>> *
+ accumulator4 : Func<IObservable<'T>, IObservable<'TResult4>> *
+ resultSelector : Func<'TResult1, 'TResult2, 'TResult3, 'TResult4, 'TResult> -> 'TResult This operator executes immediately.
+ Each accumulator argument is a function that receives an + IObservableT, which when subscribed to, produces the + items in the source sequence and in original + order; the function must then return an IObservableT + that produces a single aggregate on completion (when + OnCompleted is called. An error is raised + at run-time if the IObserverT returned by an + accumulator function produces no result or produces more than a + single result. +
| InvalidOperationException | + An IObservableT returned by an accumulator function + produced zero or more than a single aggregate result. + |
public static TResult Aggregate<T, TResult1, TResult2, TResult3, TResult4, TResult5, TResult>(
+ this IEnumerable<T> source,
+ Func<IObservable<T>, IObservable<TResult1>> accumulator1,
+ Func<IObservable<T>, IObservable<TResult2>> accumulator2,
+ Func<IObservable<T>, IObservable<TResult3>> accumulator3,
+ Func<IObservable<T>, IObservable<TResult4>> accumulator4,
+ Func<IObservable<T>, IObservable<TResult5>> accumulator5,
+ Func<TResult1, TResult2, TResult3, TResult4, TResult5, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Aggregate(Of T, TResult1, TResult2, TResult3, TResult4, TResult5, TResult) (
+ source As IEnumerable(Of T),
+ accumulator1 As Func(Of IObservable(Of T), IObservable(Of TResult1)),
+ accumulator2 As Func(Of IObservable(Of T), IObservable(Of TResult2)),
+ accumulator3 As Func(Of IObservable(Of T), IObservable(Of TResult3)),
+ accumulator4 As Func(Of IObservable(Of T), IObservable(Of TResult4)),
+ accumulator5 As Func(Of IObservable(Of T), IObservable(Of TResult5)),
+ resultSelector As Func(Of TResult1, TResult2, TResult3, TResult4, TResult5, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult1, typename TResult2, typename TResult3, typename TResult4, typename TResult5, typename TResult>
+static TResult Aggregate(
+ IEnumerable<T>^ source,
+ Func<IObservable<T>^, IObservable<TResult1>^>^ accumulator1,
+ Func<IObservable<T>^, IObservable<TResult2>^>^ accumulator2,
+ Func<IObservable<T>^, IObservable<TResult3>^>^ accumulator3,
+ Func<IObservable<T>^, IObservable<TResult4>^>^ accumulator4,
+ Func<IObservable<T>^, IObservable<TResult5>^>^ accumulator5,
+ Func<TResult1, TResult2, TResult3, TResult4, TResult5, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Aggregate :
+ source : IEnumerable<'T> *
+ accumulator1 : Func<IObservable<'T>, IObservable<'TResult1>> *
+ accumulator2 : Func<IObservable<'T>, IObservable<'TResult2>> *
+ accumulator3 : Func<IObservable<'T>, IObservable<'TResult3>> *
+ accumulator4 : Func<IObservable<'T>, IObservable<'TResult4>> *
+ accumulator5 : Func<IObservable<'T>, IObservable<'TResult5>> *
+ resultSelector : Func<'TResult1, 'TResult2, 'TResult3, 'TResult4, 'TResult5, 'TResult> -> 'TResult This operator executes immediately.
+ Each accumulator argument is a function that receives an + IObservableT, which when subscribed to, produces the + items in the source sequence and in original + order; the function must then return an IObservableT + that produces a single aggregate on completion (when + OnCompleted is called. An error is raised + at run-time if the IObserverT returned by an + accumulator function produces no result or produces more than a + single result. +
| InvalidOperationException | + An IObservableT returned by an accumulator function + produced zero or more than a single aggregate result. + |
public static TResult Aggregate<T, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult>(
+ this IEnumerable<T> source,
+ Func<IObservable<T>, IObservable<TResult1>> accumulator1,
+ Func<IObservable<T>, IObservable<TResult2>> accumulator2,
+ Func<IObservable<T>, IObservable<TResult3>> accumulator3,
+ Func<IObservable<T>, IObservable<TResult4>> accumulator4,
+ Func<IObservable<T>, IObservable<TResult5>> accumulator5,
+ Func<IObservable<T>, IObservable<TResult6>> accumulator6,
+ Func<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Aggregate(Of T, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult) (
+ source As IEnumerable(Of T),
+ accumulator1 As Func(Of IObservable(Of T), IObservable(Of TResult1)),
+ accumulator2 As Func(Of IObservable(Of T), IObservable(Of TResult2)),
+ accumulator3 As Func(Of IObservable(Of T), IObservable(Of TResult3)),
+ accumulator4 As Func(Of IObservable(Of T), IObservable(Of TResult4)),
+ accumulator5 As Func(Of IObservable(Of T), IObservable(Of TResult5)),
+ accumulator6 As Func(Of IObservable(Of T), IObservable(Of TResult6)),
+ resultSelector As Func(Of TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult1, typename TResult2, typename TResult3, typename TResult4, typename TResult5, typename TResult6, typename TResult>
+static TResult Aggregate(
+ IEnumerable<T>^ source,
+ Func<IObservable<T>^, IObservable<TResult1>^>^ accumulator1,
+ Func<IObservable<T>^, IObservable<TResult2>^>^ accumulator2,
+ Func<IObservable<T>^, IObservable<TResult3>^>^ accumulator3,
+ Func<IObservable<T>^, IObservable<TResult4>^>^ accumulator4,
+ Func<IObservable<T>^, IObservable<TResult5>^>^ accumulator5,
+ Func<IObservable<T>^, IObservable<TResult6>^>^ accumulator6,
+ Func<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Aggregate :
+ source : IEnumerable<'T> *
+ accumulator1 : Func<IObservable<'T>, IObservable<'TResult1>> *
+ accumulator2 : Func<IObservable<'T>, IObservable<'TResult2>> *
+ accumulator3 : Func<IObservable<'T>, IObservable<'TResult3>> *
+ accumulator4 : Func<IObservable<'T>, IObservable<'TResult4>> *
+ accumulator5 : Func<IObservable<'T>, IObservable<'TResult5>> *
+ accumulator6 : Func<IObservable<'T>, IObservable<'TResult6>> *
+ resultSelector : Func<'TResult1, 'TResult2, 'TResult3, 'TResult4, 'TResult5, 'TResult6, 'TResult> -> 'TResult This operator executes immediately.
+ Each accumulator argument is a function that receives an + IObservableT, which when subscribed to, produces the + items in the source sequence and in original + order; the function must then return an IObservableT + that produces a single aggregate on completion (when + OnCompleted is called. An error is raised + at run-time if the IObserverT returned by an + accumulator function produces no result or produces more than a + single result. +
| InvalidOperationException | + An IObservableT returned by an accumulator function + produced zero or more than a single aggregate result. + |
public static TResult Aggregate<T, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult>(
+ this IEnumerable<T> source,
+ Func<IObservable<T>, IObservable<TResult1>> accumulator1,
+ Func<IObservable<T>, IObservable<TResult2>> accumulator2,
+ Func<IObservable<T>, IObservable<TResult3>> accumulator3,
+ Func<IObservable<T>, IObservable<TResult4>> accumulator4,
+ Func<IObservable<T>, IObservable<TResult5>> accumulator5,
+ Func<IObservable<T>, IObservable<TResult6>> accumulator6,
+ Func<IObservable<T>, IObservable<TResult7>> accumulator7,
+ Func<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Aggregate(Of T, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult) (
+ source As IEnumerable(Of T),
+ accumulator1 As Func(Of IObservable(Of T), IObservable(Of TResult1)),
+ accumulator2 As Func(Of IObservable(Of T), IObservable(Of TResult2)),
+ accumulator3 As Func(Of IObservable(Of T), IObservable(Of TResult3)),
+ accumulator4 As Func(Of IObservable(Of T), IObservable(Of TResult4)),
+ accumulator5 As Func(Of IObservable(Of T), IObservable(Of TResult5)),
+ accumulator6 As Func(Of IObservable(Of T), IObservable(Of TResult6)),
+ accumulator7 As Func(Of IObservable(Of T), IObservable(Of TResult7)),
+ resultSelector As Func(Of TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult1, typename TResult2, typename TResult3, typename TResult4, typename TResult5, typename TResult6, typename TResult7, typename TResult>
+static TResult Aggregate(
+ IEnumerable<T>^ source,
+ Func<IObservable<T>^, IObservable<TResult1>^>^ accumulator1,
+ Func<IObservable<T>^, IObservable<TResult2>^>^ accumulator2,
+ Func<IObservable<T>^, IObservable<TResult3>^>^ accumulator3,
+ Func<IObservable<T>^, IObservable<TResult4>^>^ accumulator4,
+ Func<IObservable<T>^, IObservable<TResult5>^>^ accumulator5,
+ Func<IObservable<T>^, IObservable<TResult6>^>^ accumulator6,
+ Func<IObservable<T>^, IObservable<TResult7>^>^ accumulator7,
+ Func<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Aggregate :
+ source : IEnumerable<'T> *
+ accumulator1 : Func<IObservable<'T>, IObservable<'TResult1>> *
+ accumulator2 : Func<IObservable<'T>, IObservable<'TResult2>> *
+ accumulator3 : Func<IObservable<'T>, IObservable<'TResult3>> *
+ accumulator4 : Func<IObservable<'T>, IObservable<'TResult4>> *
+ accumulator5 : Func<IObservable<'T>, IObservable<'TResult5>> *
+ accumulator6 : Func<IObservable<'T>, IObservable<'TResult6>> *
+ accumulator7 : Func<IObservable<'T>, IObservable<'TResult7>> *
+ resultSelector : Func<'TResult1, 'TResult2, 'TResult3, 'TResult4, 'TResult5, 'TResult6, 'TResult7, 'TResult> -> 'TResult This operator executes immediately.
+ Each accumulator argument is a function that receives an + IObservableT, which when subscribed to, produces the + items in the source sequence and in original + order; the function must then return an IObservableT + that produces a single aggregate on completion (when + OnCompleted is called. An error is raised + at run-time if the IObserverT returned by an + accumulator function produces no result or produces more than a + single result. +
| InvalidOperationException | + An IObservableT returned by an accumulator function + produced zero or more than a single aggregate result. + |
public static IAwaitQuery<T> AsOrdered<T>(
+ this IAwaitQuery<T> source
+)
+<ExtensionAttribute>
+Public Shared Function AsOrdered(Of T) (
+ source As IAwaitQuery(Of T)
+) As IAwaitQuery(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IAwaitQuery<T>^ AsOrdered(
+ IAwaitQuery<T>^ source
+)[<ExtensionAttribute>]
+static member AsOrdered :
+ source : IAwaitQuery<'T> -> IAwaitQuery<'T> public static IEnumerable<T> AsSequential<T>(
+ this IAwaitQuery<T> source
+)
+<ExtensionAttribute>
+Public Shared Function AsSequential(Of T) (
+ source As IAwaitQuery(Of T)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ AsSequential(
+ IAwaitQuery<T>^ source
+)[<ExtensionAttribute>]
+static member AsSequential :
+ source : IAwaitQuery<'T> -> IEnumerable<'T> public static IAwaitQuery<T> AsUnordered<T>(
+ this IAwaitQuery<T> source
+)
+<ExtensionAttribute>
+Public Shared Function AsUnordered(Of T) (
+ source As IAwaitQuery(Of T)
+) As IAwaitQuery(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IAwaitQuery<T>^ AsUnordered(
+ IAwaitQuery<T>^ source
+)[<ExtensionAttribute>]
+static member AsUnordered :
+ source : IAwaitQuery<'T> -> IAwaitQuery<'T> public static IAwaitQuery<TResult> AwaitCompletion<T, TTaskResult, TResult>(
+ this IEnumerable<T> source,
+ Func<T, CancellationToken, Task<TTaskResult>> evaluator,
+ Func<T, Task<TTaskResult>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function AwaitCompletion(Of T, TTaskResult, TResult) (
+ source As IEnumerable(Of T),
+ evaluator As Func(Of T, CancellationToken, Task(Of TTaskResult)),
+ resultSelector As Func(Of T, Task(Of TTaskResult), TResult)
+) As IAwaitQuery(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T, typename TTaskResult, typename TResult>
+static IAwaitQuery<TResult>^ AwaitCompletion(
+ IEnumerable<T>^ source,
+ Func<T, CancellationToken, Task<TTaskResult>^>^ evaluator,
+ Func<T, Task<TTaskResult>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member AwaitCompletion :
+ source : IEnumerable<'T> *
+ evaluator : Func<'T, CancellationToken, Task<'TTaskResult>> *
+ resultSelector : Func<'T, Task<'TTaskResult>, 'TResult> -> IAwaitQuery<'TResult> + 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 + AsOrderedT(IAwaitQueryT).
+ 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 + evaluator function (via a + CancellationToken as its second argument) to cancel + those in flight.
+ The evaluator function should be designed to be + thread-agnostic.
+ The task returned by evaluator should be started + when the function is called (and not just a mere projection) + otherwise changing concurrency options via + AsSequentialT(IAwaitQueryT), MaxConcurrencyT(IAwaitQueryT, Int32) or + UnboundedConcurrencyT(IAwaitQueryT) will only change how many + tasks are awaited at any given moment, not how many will be + kept in flight. +
public static IAwaitQuery<T> Await<T>(
+ this IEnumerable<Task<T>> source
+)
+<ExtensionAttribute>
+Public Shared Function Await(Of T) (
+ source As IEnumerable(Of Task(Of T))
+) As IAwaitQuery(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IAwaitQuery<T>^ Await(
+ IEnumerable<Task<T>^>^ source
+)[<ExtensionAttribute>]
+static member Await :
+ source : IEnumerable<Task<'T>> -> IAwaitQuery<'T> + 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 + AsOrderedT(IAwaitQueryT).
+ 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.
+ The tasks in source are already assumed to be in + flight therefore changing concurrency options via + AsSequentialT(IAwaitQueryT), MaxConcurrencyT(IAwaitQueryT, Int32) or + UnboundedConcurrencyT(IAwaitQueryT) 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. +
public static IAwaitQuery<TResult> Await<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, CancellationToken, Task<TResult>> evaluator
+)
+<ExtensionAttribute>
+Public Shared Function Await(Of T, TResult) (
+ source As IEnumerable(Of T),
+ evaluator As Func(Of T, CancellationToken, Task(Of TResult))
+) As IAwaitQuery(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static IAwaitQuery<TResult>^ Await(
+ IEnumerable<T>^ source,
+ Func<T, CancellationToken, Task<TResult>^>^ evaluator
+)[<ExtensionAttribute>]
+static member Await :
+ source : IEnumerable<'T> *
+ evaluator : Func<'T, CancellationToken, Task<'TResult>> -> IAwaitQuery<'TResult> + 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 + AsOrderedT(IAwaitQueryT).
+ 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 + evaluator function (via a + CancellationToken as its second argument) to cancel + those in flight.
+ The evaluator function should be designed to be + thread-agnostic.
+ The task returned by evaluator should be started + when the function is called (and not just a mere projection) + otherwise changing concurrency options via + AsSequentialT(IAwaitQueryT), MaxConcurrencyT(IAwaitQueryT, Int32) or + UnboundedConcurrencyT(IAwaitQueryT) will only change how many + tasks are awaited at any given moment, not how many will be + kept in flight. +
public static IEnumerable<TResult> Batch<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ int size,
+ ArrayPool<TSource> pool,
+ Func<ICurrentBuffer<TSource>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Batch(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ size As Integer,
+ pool As ArrayPool(Of TSource),
+ resultSelector As Func(Of ICurrentBuffer(Of TSource), TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ Batch(
+ IEnumerable<TSource>^ source,
+ int size,
+ ArrayPool<TSource>^ pool,
+ Func<ICurrentBuffer<TSource>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Batch :
+ source : IEnumerable<'TSource> *
+ size : int *
+ pool : ArrayPool<'TSource> *
+ resultSelector : Func<ICurrentBuffer<'TSource>, 'TResult> -> IEnumerable<'TResult> + This operator uses deferred execution and streams its results + (however, each bucket provided to resultSelector is + buffered).
+ Each bucket is backed by a rented array that may be at least + size in length. +
+ When more than one bucket is produced, all buckets except the last + is guaranteed to have size elements. The last + bucket may be smaller depending on the remaining elements in the + source sequence.
+ Each bucket is pre-allocated to size elements. + If size is set to a very large value, e.g. + MaxValue to effectively disable batching by just + hoping for a single bucket, then it can lead to memory exhaustion + (OutOfMemoryException). +public static IEnumerable<TResult> Batch<TSource, TBucket, TResult>(
+ this IEnumerable<TSource> source,
+ int size,
+ ArrayPool<TSource> pool,
+ Func<ICurrentBuffer<TSource>, IEnumerable<TBucket>> bucketProjectionSelector,
+ Func<IEnumerable<TBucket>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Batch(Of TSource, TBucket, TResult) (
+ source As IEnumerable(Of TSource),
+ size As Integer,
+ pool As ArrayPool(Of TSource),
+ bucketProjectionSelector As Func(Of ICurrentBuffer(Of TSource), IEnumerable(Of TBucket)),
+ resultSelector As Func(Of IEnumerable(Of TBucket), TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TBucket, typename TResult>
+static IEnumerable<TResult>^ Batch(
+ IEnumerable<TSource>^ source,
+ int size,
+ ArrayPool<TSource>^ pool,
+ Func<ICurrentBuffer<TSource>^, IEnumerable<TBucket>^>^ bucketProjectionSelector,
+ Func<IEnumerable<TBucket>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Batch :
+ source : IEnumerable<'TSource> *
+ size : int *
+ pool : ArrayPool<'TSource> *
+ bucketProjectionSelector : Func<ICurrentBuffer<'TSource>, IEnumerable<'TBucket>> *
+ resultSelector : Func<IEnumerable<'TBucket>, 'TResult> -> IEnumerable<'TResult> + This operator uses deferred execution and streams its results + (however, each bucket is buffered).
+ Each bucket is backed by a rented array that may be at least + size in length. +
+ When more than one bucket is produced, all buckets except the last + is guaranteed to have size elements. The last + bucket may be smaller depending on the remaining elements in the + source sequence.
+ Each bucket is pre-allocated to size elements. + If size is set to a very large value, e.g. + MaxValue to effectively disable batching by just + hoping for a single bucket, then it can lead to memory exhaustion + (OutOfMemoryException). +public static IAwaitQuery<T> MaxConcurrency<T>(
+ this IAwaitQuery<T> source,
+ int value
+)
+<ExtensionAttribute>
+Public Shared Function MaxConcurrency(Of T) (
+ source As IAwaitQuery(Of T),
+ value As Integer
+) As IAwaitQuery(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IAwaitQuery<T>^ MaxConcurrency(
+ IAwaitQuery<T>^ source,
+ int value
+)[<ExtensionAttribute>]
+static member MaxConcurrency :
+ source : IAwaitQuery<'T> *
+ value : int -> IAwaitQuery<'T> public static IEnumerable<T> Memoize<T>(
+ this IEnumerable<T> source
+)
+<ExtensionAttribute>
+Public Shared Function Memoize(Of T) (
+ source As IEnumerable(Of T)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Memoize(
+ IEnumerable<T>^ source
+)[<ExtensionAttribute>]
+static member Memoize :
+ source : IEnumerable<'T> -> IEnumerable<'T> | ArgumentNullException | source is . + |
public static IAwaitQuery<T> PreserveOrder<T>(
+ this IAwaitQuery<T> source,
+ bool value
+)
+<ExtensionAttribute>
+Public Shared Function PreserveOrder(Of T) (
+ source As IAwaitQuery(Of T),
+ value As Boolean
+) As IAwaitQuery(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IAwaitQuery<T>^ PreserveOrder(
+ IAwaitQuery<T>^ source,
+ bool value
+)[<ExtensionAttribute>]
+static member PreserveOrder :
+ source : IAwaitQuery<'T> *
+ value : bool -> IAwaitQuery<'T> public static IAwaitQuery<T> Scheduler<T>(
+ this IAwaitQuery<T> source,
+ TaskScheduler value
+)
+<ExtensionAttribute>
+Public Shared Function Scheduler(Of T) (
+ source As IAwaitQuery(Of T),
+ value As TaskScheduler
+) As IAwaitQuery(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IAwaitQuery<T>^ Scheduler(
+ IAwaitQuery<T>^ source,
+ TaskScheduler^ value
+)[<ExtensionAttribute>]
+static member Scheduler :
+ source : IAwaitQuery<'T> *
+ value : TaskScheduler -> IAwaitQuery<'T> public static (TCardinality , T ) TrySingle<T, TCardinality>(
+ this IEnumerable<T> source,
+ TCardinality zero,
+ TCardinality one,
+ TCardinality many
+)
+<ExtensionAttribute>
+Public Shared Function TrySingle(Of T, TCardinality) (
+ source As IEnumerable(Of T),
+ zero As TCardinality,
+ one As TCardinality,
+ many As TCardinality
+) As ( As TCardinality, As T)public:
+[ExtensionAttribute]
+generic<typename T, typename TCardinality>
+static ValueTuple<TCardinality, T> TrySingle(
+ IEnumerable<T>^ source,
+ TCardinality zero,
+ TCardinality one,
+ TCardinality many
+)[<ExtensionAttribute>]
+static member TrySingle :
+ source : IEnumerable<'T> *
+ zero : 'TCardinality *
+ one : 'TCardinality *
+ many : 'TCardinality -> ValueTuple<'TCardinality, 'T> public static TResult TrySingle<T, TCardinality, TResult>(
+ this IEnumerable<T> source,
+ TCardinality zero,
+ TCardinality one,
+ TCardinality many,
+ Func<TCardinality, T, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function TrySingle(Of T, TCardinality, TResult) (
+ source As IEnumerable(Of T),
+ zero As TCardinality,
+ one As TCardinality,
+ many As TCardinality,
+ resultSelector As Func(Of TCardinality, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TCardinality, typename TResult>
+static TResult TrySingle(
+ IEnumerable<T>^ source,
+ TCardinality zero,
+ TCardinality one,
+ TCardinality many,
+ Func<TCardinality, T, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member TrySingle :
+ source : IEnumerable<'T> *
+ zero : 'TCardinality *
+ one : 'TCardinality *
+ many : 'TCardinality *
+ resultSelector : Func<'TCardinality, 'T, 'TResult> -> 'TResult public static IAwaitQuery<T> UnboundedConcurrency<T>(
+ this IAwaitQuery<T> source
+)
+<ExtensionAttribute>
+Public Shared Function UnboundedConcurrency(Of T) (
+ source As IAwaitQuery(Of T)
+) As IAwaitQuery(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IAwaitQuery<T>^ UnboundedConcurrency(
+ IAwaitQuery<T>^ source
+)[<ExtensionAttribute>]
+static member UnboundedConcurrency :
+ source : IAwaitQuery<'T> -> IAwaitQuery<'T> IAwaitQuery<T> WithOptions(
+ AwaitQueryOptions options
+)Function WithOptions (
+ options As AwaitQueryOptions
+) As IAwaitQuery(Of T)IAwaitQuery<T>^ WithOptions(
+ AwaitQueryOptions^ options
+)abstract WithOptions :
+ options : AwaitQueryOptions -> IAwaitQuery<'T> public static TSource[] Acquire<TSource>(
+ this IEnumerable<TSource> source
+)
+where TSource : IDisposable
+<ExtensionAttribute>
+Public Shared Function Acquire(Of TSource As IDisposable) (
+ source As IEnumerable(Of TSource)
+) As TSource()public:
+[ExtensionAttribute]
+generic<typename TSource>
+where TSource : IDisposable
+static array<TSource>^ Acquire(
+ IEnumerable<TSource>^ source
+)[<ExtensionAttribute>]
+static member Acquire :
+ source : IEnumerable<'TSource> -> 'TSource[] when 'TSource : IDisposablepublic static TResult Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult>(
+ this IEnumerable<T> source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1> accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2> accumulator2,
+ TAccumulate3 seed3,
+ Func<TAccumulate3, T, TAccumulate3> accumulator3,
+ TAccumulate4 seed4,
+ Func<TAccumulate4, T, TAccumulate4> accumulator4,
+ TAccumulate5 seed5,
+ Func<TAccumulate5, T, TAccumulate5> accumulator5,
+ TAccumulate6 seed6,
+ Func<TAccumulate6, T, TAccumulate6> accumulator6,
+ TAccumulate7 seed7,
+ Func<TAccumulate7, T, TAccumulate7> accumulator7,
+ TAccumulate8 seed8,
+ Func<TAccumulate8, T, TAccumulate8> accumulator8,
+ Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Aggregate(Of T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult) (
+ source As IEnumerable(Of T),
+ seed1 As TAccumulate1,
+ accumulator1 As Func(Of TAccumulate1, T, TAccumulate1),
+ seed2 As TAccumulate2,
+ accumulator2 As Func(Of TAccumulate2, T, TAccumulate2),
+ seed3 As TAccumulate3,
+ accumulator3 As Func(Of TAccumulate3, T, TAccumulate3),
+ seed4 As TAccumulate4,
+ accumulator4 As Func(Of TAccumulate4, T, TAccumulate4),
+ seed5 As TAccumulate5,
+ accumulator5 As Func(Of TAccumulate5, T, TAccumulate5),
+ seed6 As TAccumulate6,
+ accumulator6 As Func(Of TAccumulate6, T, TAccumulate6),
+ seed7 As TAccumulate7,
+ accumulator7 As Func(Of TAccumulate7, T, TAccumulate7),
+ seed8 As TAccumulate8,
+ accumulator8 As Func(Of TAccumulate8, T, TAccumulate8),
+ resultSelector As Func(Of TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TAccumulate1, typename TAccumulate2, typename TAccumulate3, typename TAccumulate4, typename TAccumulate5, typename TAccumulate6, typename TAccumulate7, typename TAccumulate8, typename TResult>
+static TResult Aggregate(
+ IEnumerable<T>^ source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1>^ accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2>^ accumulator2,
+ TAccumulate3 seed3,
+ Func<TAccumulate3, T, TAccumulate3>^ accumulator3,
+ TAccumulate4 seed4,
+ Func<TAccumulate4, T, TAccumulate4>^ accumulator4,
+ TAccumulate5 seed5,
+ Func<TAccumulate5, T, TAccumulate5>^ accumulator5,
+ TAccumulate6 seed6,
+ Func<TAccumulate6, T, TAccumulate6>^ accumulator6,
+ TAccumulate7 seed7,
+ Func<TAccumulate7, T, TAccumulate7>^ accumulator7,
+ TAccumulate8 seed8,
+ Func<TAccumulate8, T, TAccumulate8>^ accumulator8,
+ Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Aggregate :
+ source : IEnumerable<'T> *
+ seed1 : 'TAccumulate1 *
+ accumulator1 : Func<'TAccumulate1, 'T, 'TAccumulate1> *
+ seed2 : 'TAccumulate2 *
+ accumulator2 : Func<'TAccumulate2, 'T, 'TAccumulate2> *
+ seed3 : 'TAccumulate3 *
+ accumulator3 : Func<'TAccumulate3, 'T, 'TAccumulate3> *
+ seed4 : 'TAccumulate4 *
+ accumulator4 : Func<'TAccumulate4, 'T, 'TAccumulate4> *
+ seed5 : 'TAccumulate5 *
+ accumulator5 : Func<'TAccumulate5, 'T, 'TAccumulate5> *
+ seed6 : 'TAccumulate6 *
+ accumulator6 : Func<'TAccumulate6, 'T, 'TAccumulate6> *
+ seed7 : 'TAccumulate7 *
+ accumulator7 : Func<'TAccumulate7, 'T, 'TAccumulate7> *
+ seed8 : 'TAccumulate8 *
+ accumulator8 : Func<'TAccumulate8, 'T, 'TAccumulate8> *
+ resultSelector : Func<'TAccumulate1, 'TAccumulate2, 'TAccumulate3, 'TAccumulate4, 'TAccumulate5, 'TAccumulate6, 'TAccumulate7, 'TAccumulate8, 'TResult> -> 'TResult public static TResult Aggregate<T, TAccumulate1, TAccumulate2, TResult>(
+ this IEnumerable<T> source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1> accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2> accumulator2,
+ Func<TAccumulate1, TAccumulate2, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Aggregate(Of T, TAccumulate1, TAccumulate2, TResult) (
+ source As IEnumerable(Of T),
+ seed1 As TAccumulate1,
+ accumulator1 As Func(Of TAccumulate1, T, TAccumulate1),
+ seed2 As TAccumulate2,
+ accumulator2 As Func(Of TAccumulate2, T, TAccumulate2),
+ resultSelector As Func(Of TAccumulate1, TAccumulate2, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TAccumulate1, typename TAccumulate2, typename TResult>
+static TResult Aggregate(
+ IEnumerable<T>^ source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1>^ accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2>^ accumulator2,
+ Func<TAccumulate1, TAccumulate2, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Aggregate :
+ source : IEnumerable<'T> *
+ seed1 : 'TAccumulate1 *
+ accumulator1 : Func<'TAccumulate1, 'T, 'TAccumulate1> *
+ seed2 : 'TAccumulate2 *
+ accumulator2 : Func<'TAccumulate2, 'T, 'TAccumulate2> *
+ resultSelector : Func<'TAccumulate1, 'TAccumulate2, 'TResult> -> 'TResult public static TResult Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TResult>(
+ this IEnumerable<T> source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1> accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2> accumulator2,
+ TAccumulate3 seed3,
+ Func<TAccumulate3, T, TAccumulate3> accumulator3,
+ Func<TAccumulate1, TAccumulate2, TAccumulate3, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Aggregate(Of T, TAccumulate1, TAccumulate2, TAccumulate3, TResult) (
+ source As IEnumerable(Of T),
+ seed1 As TAccumulate1,
+ accumulator1 As Func(Of TAccumulate1, T, TAccumulate1),
+ seed2 As TAccumulate2,
+ accumulator2 As Func(Of TAccumulate2, T, TAccumulate2),
+ seed3 As TAccumulate3,
+ accumulator3 As Func(Of TAccumulate3, T, TAccumulate3),
+ resultSelector As Func(Of TAccumulate1, TAccumulate2, TAccumulate3, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TAccumulate1, typename TAccumulate2, typename TAccumulate3, typename TResult>
+static TResult Aggregate(
+ IEnumerable<T>^ source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1>^ accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2>^ accumulator2,
+ TAccumulate3 seed3,
+ Func<TAccumulate3, T, TAccumulate3>^ accumulator3,
+ Func<TAccumulate1, TAccumulate2, TAccumulate3, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Aggregate :
+ source : IEnumerable<'T> *
+ seed1 : 'TAccumulate1 *
+ accumulator1 : Func<'TAccumulate1, 'T, 'TAccumulate1> *
+ seed2 : 'TAccumulate2 *
+ accumulator2 : Func<'TAccumulate2, 'T, 'TAccumulate2> *
+ seed3 : 'TAccumulate3 *
+ accumulator3 : Func<'TAccumulate3, 'T, 'TAccumulate3> *
+ resultSelector : Func<'TAccumulate1, 'TAccumulate2, 'TAccumulate3, 'TResult> -> 'TResult public static TResult Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult>(
+ this IEnumerable<T> source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1> accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2> accumulator2,
+ TAccumulate3 seed3,
+ Func<TAccumulate3, T, TAccumulate3> accumulator3,
+ TAccumulate4 seed4,
+ Func<TAccumulate4, T, TAccumulate4> accumulator4,
+ Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Aggregate(Of T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult) (
+ source As IEnumerable(Of T),
+ seed1 As TAccumulate1,
+ accumulator1 As Func(Of TAccumulate1, T, TAccumulate1),
+ seed2 As TAccumulate2,
+ accumulator2 As Func(Of TAccumulate2, T, TAccumulate2),
+ seed3 As TAccumulate3,
+ accumulator3 As Func(Of TAccumulate3, T, TAccumulate3),
+ seed4 As TAccumulate4,
+ accumulator4 As Func(Of TAccumulate4, T, TAccumulate4),
+ resultSelector As Func(Of TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TAccumulate1, typename TAccumulate2, typename TAccumulate3, typename TAccumulate4, typename TResult>
+static TResult Aggregate(
+ IEnumerable<T>^ source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1>^ accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2>^ accumulator2,
+ TAccumulate3 seed3,
+ Func<TAccumulate3, T, TAccumulate3>^ accumulator3,
+ TAccumulate4 seed4,
+ Func<TAccumulate4, T, TAccumulate4>^ accumulator4,
+ Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Aggregate :
+ source : IEnumerable<'T> *
+ seed1 : 'TAccumulate1 *
+ accumulator1 : Func<'TAccumulate1, 'T, 'TAccumulate1> *
+ seed2 : 'TAccumulate2 *
+ accumulator2 : Func<'TAccumulate2, 'T, 'TAccumulate2> *
+ seed3 : 'TAccumulate3 *
+ accumulator3 : Func<'TAccumulate3, 'T, 'TAccumulate3> *
+ seed4 : 'TAccumulate4 *
+ accumulator4 : Func<'TAccumulate4, 'T, 'TAccumulate4> *
+ resultSelector : Func<'TAccumulate1, 'TAccumulate2, 'TAccumulate3, 'TAccumulate4, 'TResult> -> 'TResult public static TResult Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult>(
+ this IEnumerable<T> source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1> accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2> accumulator2,
+ TAccumulate3 seed3,
+ Func<TAccumulate3, T, TAccumulate3> accumulator3,
+ TAccumulate4 seed4,
+ Func<TAccumulate4, T, TAccumulate4> accumulator4,
+ TAccumulate5 seed5,
+ Func<TAccumulate5, T, TAccumulate5> accumulator5,
+ Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Aggregate(Of T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult) (
+ source As IEnumerable(Of T),
+ seed1 As TAccumulate1,
+ accumulator1 As Func(Of TAccumulate1, T, TAccumulate1),
+ seed2 As TAccumulate2,
+ accumulator2 As Func(Of TAccumulate2, T, TAccumulate2),
+ seed3 As TAccumulate3,
+ accumulator3 As Func(Of TAccumulate3, T, TAccumulate3),
+ seed4 As TAccumulate4,
+ accumulator4 As Func(Of TAccumulate4, T, TAccumulate4),
+ seed5 As TAccumulate5,
+ accumulator5 As Func(Of TAccumulate5, T, TAccumulate5),
+ resultSelector As Func(Of TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TAccumulate1, typename TAccumulate2, typename TAccumulate3, typename TAccumulate4, typename TAccumulate5, typename TResult>
+static TResult Aggregate(
+ IEnumerable<T>^ source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1>^ accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2>^ accumulator2,
+ TAccumulate3 seed3,
+ Func<TAccumulate3, T, TAccumulate3>^ accumulator3,
+ TAccumulate4 seed4,
+ Func<TAccumulate4, T, TAccumulate4>^ accumulator4,
+ TAccumulate5 seed5,
+ Func<TAccumulate5, T, TAccumulate5>^ accumulator5,
+ Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Aggregate :
+ source : IEnumerable<'T> *
+ seed1 : 'TAccumulate1 *
+ accumulator1 : Func<'TAccumulate1, 'T, 'TAccumulate1> *
+ seed2 : 'TAccumulate2 *
+ accumulator2 : Func<'TAccumulate2, 'T, 'TAccumulate2> *
+ seed3 : 'TAccumulate3 *
+ accumulator3 : Func<'TAccumulate3, 'T, 'TAccumulate3> *
+ seed4 : 'TAccumulate4 *
+ accumulator4 : Func<'TAccumulate4, 'T, 'TAccumulate4> *
+ seed5 : 'TAccumulate5 *
+ accumulator5 : Func<'TAccumulate5, 'T, 'TAccumulate5> *
+ resultSelector : Func<'TAccumulate1, 'TAccumulate2, 'TAccumulate3, 'TAccumulate4, 'TAccumulate5, 'TResult> -> 'TResult public static TResult Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult>(
+ this IEnumerable<T> source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1> accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2> accumulator2,
+ TAccumulate3 seed3,
+ Func<TAccumulate3, T, TAccumulate3> accumulator3,
+ TAccumulate4 seed4,
+ Func<TAccumulate4, T, TAccumulate4> accumulator4,
+ TAccumulate5 seed5,
+ Func<TAccumulate5, T, TAccumulate5> accumulator5,
+ TAccumulate6 seed6,
+ Func<TAccumulate6, T, TAccumulate6> accumulator6,
+ Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Aggregate(Of T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult) (
+ source As IEnumerable(Of T),
+ seed1 As TAccumulate1,
+ accumulator1 As Func(Of TAccumulate1, T, TAccumulate1),
+ seed2 As TAccumulate2,
+ accumulator2 As Func(Of TAccumulate2, T, TAccumulate2),
+ seed3 As TAccumulate3,
+ accumulator3 As Func(Of TAccumulate3, T, TAccumulate3),
+ seed4 As TAccumulate4,
+ accumulator4 As Func(Of TAccumulate4, T, TAccumulate4),
+ seed5 As TAccumulate5,
+ accumulator5 As Func(Of TAccumulate5, T, TAccumulate5),
+ seed6 As TAccumulate6,
+ accumulator6 As Func(Of TAccumulate6, T, TAccumulate6),
+ resultSelector As Func(Of TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TAccumulate1, typename TAccumulate2, typename TAccumulate3, typename TAccumulate4, typename TAccumulate5, typename TAccumulate6, typename TResult>
+static TResult Aggregate(
+ IEnumerable<T>^ source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1>^ accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2>^ accumulator2,
+ TAccumulate3 seed3,
+ Func<TAccumulate3, T, TAccumulate3>^ accumulator3,
+ TAccumulate4 seed4,
+ Func<TAccumulate4, T, TAccumulate4>^ accumulator4,
+ TAccumulate5 seed5,
+ Func<TAccumulate5, T, TAccumulate5>^ accumulator5,
+ TAccumulate6 seed6,
+ Func<TAccumulate6, T, TAccumulate6>^ accumulator6,
+ Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Aggregate :
+ source : IEnumerable<'T> *
+ seed1 : 'TAccumulate1 *
+ accumulator1 : Func<'TAccumulate1, 'T, 'TAccumulate1> *
+ seed2 : 'TAccumulate2 *
+ accumulator2 : Func<'TAccumulate2, 'T, 'TAccumulate2> *
+ seed3 : 'TAccumulate3 *
+ accumulator3 : Func<'TAccumulate3, 'T, 'TAccumulate3> *
+ seed4 : 'TAccumulate4 *
+ accumulator4 : Func<'TAccumulate4, 'T, 'TAccumulate4> *
+ seed5 : 'TAccumulate5 *
+ accumulator5 : Func<'TAccumulate5, 'T, 'TAccumulate5> *
+ seed6 : 'TAccumulate6 *
+ accumulator6 : Func<'TAccumulate6, 'T, 'TAccumulate6> *
+ resultSelector : Func<'TAccumulate1, 'TAccumulate2, 'TAccumulate3, 'TAccumulate4, 'TAccumulate5, 'TAccumulate6, 'TResult> -> 'TResult public static TResult Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult>(
+ this IEnumerable<T> source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1> accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2> accumulator2,
+ TAccumulate3 seed3,
+ Func<TAccumulate3, T, TAccumulate3> accumulator3,
+ TAccumulate4 seed4,
+ Func<TAccumulate4, T, TAccumulate4> accumulator4,
+ TAccumulate5 seed5,
+ Func<TAccumulate5, T, TAccumulate5> accumulator5,
+ TAccumulate6 seed6,
+ Func<TAccumulate6, T, TAccumulate6> accumulator6,
+ TAccumulate7 seed7,
+ Func<TAccumulate7, T, TAccumulate7> accumulator7,
+ Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Aggregate(Of T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult) (
+ source As IEnumerable(Of T),
+ seed1 As TAccumulate1,
+ accumulator1 As Func(Of TAccumulate1, T, TAccumulate1),
+ seed2 As TAccumulate2,
+ accumulator2 As Func(Of TAccumulate2, T, TAccumulate2),
+ seed3 As TAccumulate3,
+ accumulator3 As Func(Of TAccumulate3, T, TAccumulate3),
+ seed4 As TAccumulate4,
+ accumulator4 As Func(Of TAccumulate4, T, TAccumulate4),
+ seed5 As TAccumulate5,
+ accumulator5 As Func(Of TAccumulate5, T, TAccumulate5),
+ seed6 As TAccumulate6,
+ accumulator6 As Func(Of TAccumulate6, T, TAccumulate6),
+ seed7 As TAccumulate7,
+ accumulator7 As Func(Of TAccumulate7, T, TAccumulate7),
+ resultSelector As Func(Of TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TAccumulate1, typename TAccumulate2, typename TAccumulate3, typename TAccumulate4, typename TAccumulate5, typename TAccumulate6, typename TAccumulate7, typename TResult>
+static TResult Aggregate(
+ IEnumerable<T>^ source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1>^ accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2>^ accumulator2,
+ TAccumulate3 seed3,
+ Func<TAccumulate3, T, TAccumulate3>^ accumulator3,
+ TAccumulate4 seed4,
+ Func<TAccumulate4, T, TAccumulate4>^ accumulator4,
+ TAccumulate5 seed5,
+ Func<TAccumulate5, T, TAccumulate5>^ accumulator5,
+ TAccumulate6 seed6,
+ Func<TAccumulate6, T, TAccumulate6>^ accumulator6,
+ TAccumulate7 seed7,
+ Func<TAccumulate7, T, TAccumulate7>^ accumulator7,
+ Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Aggregate :
+ source : IEnumerable<'T> *
+ seed1 : 'TAccumulate1 *
+ accumulator1 : Func<'TAccumulate1, 'T, 'TAccumulate1> *
+ seed2 : 'TAccumulate2 *
+ accumulator2 : Func<'TAccumulate2, 'T, 'TAccumulate2> *
+ seed3 : 'TAccumulate3 *
+ accumulator3 : Func<'TAccumulate3, 'T, 'TAccumulate3> *
+ seed4 : 'TAccumulate4 *
+ accumulator4 : Func<'TAccumulate4, 'T, 'TAccumulate4> *
+ seed5 : 'TAccumulate5 *
+ accumulator5 : Func<'TAccumulate5, 'T, 'TAccumulate5> *
+ seed6 : 'TAccumulate6 *
+ accumulator6 : Func<'TAccumulate6, 'T, 'TAccumulate6> *
+ seed7 : 'TAccumulate7 *
+ accumulator7 : Func<'TAccumulate7, 'T, 'TAccumulate7> *
+ resultSelector : Func<'TAccumulate1, 'TAccumulate2, 'TAccumulate3, 'TAccumulate4, 'TAccumulate5, 'TAccumulate6, 'TAccumulate7, 'TResult> -> 'TResult public static TSource AggregateRight<TSource>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TSource, TSource> func
+)
+<ExtensionAttribute>
+Public Shared Function AggregateRight(Of TSource) (
+ source As IEnumerable(Of TSource),
+ func As Func(Of TSource, TSource, TSource)
+) As TSourcepublic:
+[ExtensionAttribute]
+generic<typename TSource>
+static TSource AggregateRight(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TSource, TSource>^ func
+)[<ExtensionAttribute>]
+static member AggregateRight :
+ source : IEnumerable<'TSource> *
+ func : Func<'TSource, 'TSource, 'TSource> -> 'TSource string result = Enumerable.Range(1, 5).Select(i => i.ToString()).AggregateRight((a, b) => $"({a}/{b})");public static TAccumulate AggregateRight<TSource, TAccumulate>(
+ this IEnumerable<TSource> source,
+ TAccumulate seed,
+ Func<TSource, TAccumulate, TAccumulate> func
+)
+<ExtensionAttribute>
+Public Shared Function AggregateRight(Of TSource, TAccumulate) (
+ source As IEnumerable(Of TSource),
+ seed As TAccumulate,
+ func As Func(Of TSource, TAccumulate, TAccumulate)
+) As TAccumulatepublic:
+[ExtensionAttribute]
+generic<typename TSource, typename TAccumulate>
+static TAccumulate AggregateRight(
+ IEnumerable<TSource>^ source,
+ TAccumulate seed,
+ Func<TSource, TAccumulate, TAccumulate>^ func
+)[<ExtensionAttribute>]
+static member AggregateRight :
+ source : IEnumerable<'TSource> *
+ seed : 'TAccumulate *
+ func : Func<'TSource, 'TAccumulate, 'TAccumulate> -> 'TAccumulate var numbers = Enumerable.Range(1, 5);
+string result = numbers.AggregateRight("6", (a, b) => $"({a}/{b})");public static TResult AggregateRight<TSource, TAccumulate, TResult>(
+ this IEnumerable<TSource> source,
+ TAccumulate seed,
+ Func<TSource, TAccumulate, TAccumulate> func,
+ Func<TAccumulate, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function AggregateRight(Of TSource, TAccumulate, TResult) (
+ source As IEnumerable(Of TSource),
+ seed As TAccumulate,
+ func As Func(Of TSource, TAccumulate, TAccumulate),
+ resultSelector As Func(Of TAccumulate, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename TSource, typename TAccumulate, typename TResult>
+static TResult AggregateRight(
+ IEnumerable<TSource>^ source,
+ TAccumulate seed,
+ Func<TSource, TAccumulate, TAccumulate>^ func,
+ Func<TAccumulate, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member AggregateRight :
+ source : IEnumerable<'TSource> *
+ seed : 'TAccumulate *
+ func : Func<'TSource, 'TAccumulate, 'TAccumulate> *
+ resultSelector : Func<'TAccumulate, 'TResult> -> 'TResult var numbers = Enumerable.Range(1, 5);
+int result = numbers.AggregateRight("6", (a, b) => $"({a}/{b})", str => str.Length);public static IEnumerable<T> Append<T>(
+ this IEnumerable<T> head,
+ T tail
+)
+<ExtensionAttribute>
+Public Shared Function Append(Of T) (
+ head As IEnumerable(Of T),
+ tail As T
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Append(
+ IEnumerable<T>^ head,
+ T tail
+)[<ExtensionAttribute>]
+static member Append :
+ head : IEnumerable<'T> *
+ tail : 'T -> IEnumerable<'T> public static IEnumerable<TSource> AssertCount<TSource>(
+ this IEnumerable<TSource> source,
+ int count
+)
+<ExtensionAttribute>
+Public Shared Function AssertCount(Of TSource) (
+ source As IEnumerable(Of TSource),
+ count As Integer
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ AssertCount(
+ IEnumerable<TSource>^ source,
+ int count
+)[<ExtensionAttribute>]
+static member AssertCount :
+ source : IEnumerable<'TSource> *
+ count : int -> IEnumerable<'TSource> public static IEnumerable<TSource> AssertCount<TSource>(
+ this IEnumerable<TSource> source,
+ int count,
+ Func<int, int, Exception> errorSelector
+)
+<ExtensionAttribute>
+Public Shared Function AssertCount(Of TSource) (
+ source As IEnumerable(Of TSource),
+ count As Integer,
+ errorSelector As Func(Of Integer, Integer, Exception)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ AssertCount(
+ IEnumerable<TSource>^ source,
+ int count,
+ Func<int, int, Exception^>^ errorSelector
+)[<ExtensionAttribute>]
+static member AssertCount :
+ source : IEnumerable<'TSource> *
+ count : int *
+ errorSelector : Func<int, int, Exception> -> IEnumerable<'TSource> public static IEnumerable<TSource> Assert<TSource>(
+ this IEnumerable<TSource> source,
+ Func<TSource, bool> predicate
+)
+<ExtensionAttribute>
+Public Shared Function Assert(Of TSource) (
+ source As IEnumerable(Of TSource),
+ predicate As Func(Of TSource, Boolean)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ Assert(
+ IEnumerable<TSource>^ source,
+ Func<TSource, bool>^ predicate
+)[<ExtensionAttribute>]
+static member Assert :
+ source : IEnumerable<'TSource> *
+ predicate : Func<'TSource, bool> -> IEnumerable<'TSource> | InvalidOperationException | The input sequence + contains an element that does not meet the condition being + asserted. |
public static IEnumerable<TSource> Assert<TSource>(
+ this IEnumerable<TSource> source,
+ Func<TSource, bool> predicate,
+ Func<TSource, Exception>? errorSelector
+)
+<ExtensionAttribute>
+Public Shared Function Assert(Of TSource) (
+ source As IEnumerable(Of TSource),
+ predicate As Func(Of TSource, Boolean),
+ errorSelector As Func(Of TSource, Exception)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ Assert(
+ IEnumerable<TSource>^ source,
+ Func<TSource, bool>^ predicate,
+ Func<TSource, Exception^>^ errorSelector
+)[<ExtensionAttribute>]
+static member Assert :
+ source : IEnumerable<'TSource> *
+ predicate : Func<'TSource, bool> *
+ errorSelector : Func<'TSource, Exception> -> IEnumerable<'TSource> public static bool AtLeast<T>(
+ this IEnumerable<T> source,
+ int count
+)
+<ExtensionAttribute>
+Public Shared Function AtLeast(Of T) (
+ source As IEnumerable(Of T),
+ count As Integer
+) As Booleanpublic:
+[ExtensionAttribute]
+generic<typename T>
+static bool AtLeast(
+ IEnumerable<T>^ source,
+ int count
+)[<ExtensionAttribute>]
+static member AtLeast :
+ source : IEnumerable<'T> *
+ count : int -> bool var numbers = new[] { 123, 456, 789 };
+var result = numbers.AtLeast(2);| ArgumentNullException | source is null |
| ArgumentOutOfRangeException | count is negative |
public static bool AtMost<T>(
+ this IEnumerable<T> source,
+ int count
+)
+<ExtensionAttribute>
+Public Shared Function AtMost(Of T) (
+ source As IEnumerable(Of T),
+ count As Integer
+) As Booleanpublic:
+[ExtensionAttribute]
+generic<typename T>
+static bool AtMost(
+ IEnumerable<T>^ source,
+ int count
+)[<ExtensionAttribute>]
+static member AtMost :
+ source : IEnumerable<'T> *
+ count : int -> bool var numbers = new[] { 123, 456, 789 };
+var result = numbers.AtMost(2);| ArgumentNullException | source is null |
| ArgumentOutOfRangeException | count is negative |
public static IEnumerable<T> Backsert<T>(
+ this IEnumerable<T> first,
+ IEnumerable<T> second,
+ int index
+)
+<ExtensionAttribute>
+Public Shared Function Backsert(Of T) (
+ first As IEnumerable(Of T),
+ second As IEnumerable(Of T),
+ index As Integer
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Backsert(
+ IEnumerable<T>^ first,
+ IEnumerable<T>^ second,
+ int index
+)[<ExtensionAttribute>]
+static member Backsert :
+ first : IEnumerable<'T> *
+ second : IEnumerable<'T> *
+ index : int -> IEnumerable<'T> | ArgumentNullException | first is null. |
| ArgumentNullException | second is null. |
| ArgumentOutOfRangeException | + Thrown if index is negative. + |
| ArgumentOutOfRangeException | + Thrown lazily if index is greater than the + length of first. The validation occurs when + the resulting sequence is iterated. + |
public static IEnumerable<IEnumerable<TSource>> Batch<TSource>(
+ this IEnumerable<TSource> source,
+ int size
+)
+<ExtensionAttribute>
+Public Shared Function Batch(Of TSource) (
+ source As IEnumerable(Of TSource),
+ size As Integer
+) As IEnumerable(Of IEnumerable(Of TSource))public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<IEnumerable<TSource>^>^ Batch(
+ IEnumerable<TSource>^ source,
+ int size
+)[<ExtensionAttribute>]
+static member Batch :
+ source : IEnumerable<'TSource> *
+ size : int -> IEnumerable<IEnumerable<'TSource>> + This operator uses deferred execution and streams its results + (buckets are streamed but their content buffered).
+ When more than one bucket is streamed, all buckets except the last + is guaranteed to have size elements. The last + bucket may be smaller depending on the remaining elements in the + source sequence.
+ Each bucket is pre-allocated to size elements. + If size is set to a very large value, e.g. + MaxValue to effectively disable batching by just + hoping for a single bucket, then it can lead to memory exhaustion + (OutOfMemoryException). +
public static IEnumerable<TResult> Batch<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ int size,
+ Func<IEnumerable<TSource>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Batch(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ size As Integer,
+ resultSelector As Func(Of IEnumerable(Of TSource), TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ Batch(
+ IEnumerable<TSource>^ source,
+ int size,
+ Func<IEnumerable<TSource>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Batch :
+ source : IEnumerable<'TSource> *
+ size : int *
+ resultSelector : Func<IEnumerable<'TSource>, 'TResult> -> IEnumerable<'TResult> + This operator uses deferred execution and streams its results + (buckets are streamed but their content buffered).
+ When more than one bucket is streamed, all buckets except the last + is guaranteed to have size elements. The last + bucket may be smaller depending on the remaining elements in the + source sequence.
+ Each bucket is pre-allocated to size elements. + If size is set to a very large value, e.g. + MaxValue to effectively disable batching by just + hoping for a single bucket, then it can lead to memory exhaustion + (OutOfMemoryException). +public static IEnumerable<TResult> Cartesian<T1, T2, TResult>(
+ this IEnumerable<T1> first,
+ IEnumerable<T2> second,
+ Func<T1, T2, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Cartesian(Of T1, T2, TResult) (
+ first As IEnumerable(Of T1),
+ second As IEnumerable(Of T2),
+ resultSelector As Func(Of T1, T2, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T1, typename T2, typename TResult>
+static IEnumerable<TResult>^ Cartesian(
+ IEnumerable<T1>^ first,
+ IEnumerable<T2>^ second,
+ Func<T1, T2, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Cartesian :
+ first : IEnumerable<'T1> *
+ second : IEnumerable<'T2> *
+ resultSelector : Func<'T1, 'T2, 'TResult> -> IEnumerable<'TResult> + The method returns items in the same order as a nested foreach + loop, but all sequences except for first are + cached when iterated over. The cache is then re-used for any + subsequent iterations.
+ This method uses deferred execution and stream its results.
public static IEnumerable<TResult> Cartesian<T1, T2, T3, TResult>(
+ this IEnumerable<T1> first,
+ IEnumerable<T2> second,
+ IEnumerable<T3> third,
+ Func<T1, T2, T3, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Cartesian(Of T1, T2, T3, TResult) (
+ first As IEnumerable(Of T1),
+ second As IEnumerable(Of T2),
+ third As IEnumerable(Of T3),
+ resultSelector As Func(Of T1, T2, T3, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T1, typename T2, typename T3, typename TResult>
+static IEnumerable<TResult>^ Cartesian(
+ IEnumerable<T1>^ first,
+ IEnumerable<T2>^ second,
+ IEnumerable<T3>^ third,
+ Func<T1, T2, T3, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Cartesian :
+ first : IEnumerable<'T1> *
+ second : IEnumerable<'T2> *
+ third : IEnumerable<'T3> *
+ resultSelector : Func<'T1, 'T2, 'T3, 'TResult> -> IEnumerable<'TResult> + The method returns items in the same order as a nested foreach + loop, but all sequences except for first are + cached when iterated over. The cache is then re-used for any + subsequent iterations.
+ This method uses deferred execution and stream its results.
public static IEnumerable<TResult> Cartesian<T1, T2, T3, T4, TResult>(
+ this IEnumerable<T1> first,
+ IEnumerable<T2> second,
+ IEnumerable<T3> third,
+ IEnumerable<T4> fourth,
+ Func<T1, T2, T3, T4, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Cartesian(Of T1, T2, T3, T4, TResult) (
+ first As IEnumerable(Of T1),
+ second As IEnumerable(Of T2),
+ third As IEnumerable(Of T3),
+ fourth As IEnumerable(Of T4),
+ resultSelector As Func(Of T1, T2, T3, T4, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T1, typename T2, typename T3, typename T4, typename TResult>
+static IEnumerable<TResult>^ Cartesian(
+ IEnumerable<T1>^ first,
+ IEnumerable<T2>^ second,
+ IEnumerable<T3>^ third,
+ IEnumerable<T4>^ fourth,
+ Func<T1, T2, T3, T4, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Cartesian :
+ first : IEnumerable<'T1> *
+ second : IEnumerable<'T2> *
+ third : IEnumerable<'T3> *
+ fourth : IEnumerable<'T4> *
+ resultSelector : Func<'T1, 'T2, 'T3, 'T4, 'TResult> -> IEnumerable<'TResult> + The method returns items in the same order as a nested foreach + loop, but all sequences except for first are + cached when iterated over. The cache is then re-used for any + subsequent iterations.
+ This method uses deferred execution and stream its results.
public static IEnumerable<TResult> Cartesian<T1, T2, T3, T4, T5, TResult>(
+ this IEnumerable<T1> first,
+ IEnumerable<T2> second,
+ IEnumerable<T3> third,
+ IEnumerable<T4> fourth,
+ IEnumerable<T5> fifth,
+ Func<T1, T2, T3, T4, T5, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Cartesian(Of T1, T2, T3, T4, T5, TResult) (
+ first As IEnumerable(Of T1),
+ second As IEnumerable(Of T2),
+ third As IEnumerable(Of T3),
+ fourth As IEnumerable(Of T4),
+ fifth As IEnumerable(Of T5),
+ resultSelector As Func(Of T1, T2, T3, T4, T5, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T1, typename T2, typename T3, typename T4, typename T5, typename TResult>
+static IEnumerable<TResult>^ Cartesian(
+ IEnumerable<T1>^ first,
+ IEnumerable<T2>^ second,
+ IEnumerable<T3>^ third,
+ IEnumerable<T4>^ fourth,
+ IEnumerable<T5>^ fifth,
+ Func<T1, T2, T3, T4, T5, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Cartesian :
+ first : IEnumerable<'T1> *
+ second : IEnumerable<'T2> *
+ third : IEnumerable<'T3> *
+ fourth : IEnumerable<'T4> *
+ fifth : IEnumerable<'T5> *
+ resultSelector : Func<'T1, 'T2, 'T3, 'T4, 'T5, 'TResult> -> IEnumerable<'TResult> + The method returns items in the same order as a nested foreach + loop, but all sequences except for first are + cached when iterated over. The cache is then re-used for any + subsequent iterations.
+ This method uses deferred execution and stream its results.
public static IEnumerable<TResult> Cartesian<T1, T2, T3, T4, T5, T6, TResult>(
+ this IEnumerable<T1> first,
+ IEnumerable<T2> second,
+ IEnumerable<T3> third,
+ IEnumerable<T4> fourth,
+ IEnumerable<T5> fifth,
+ IEnumerable<T6> sixth,
+ Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Cartesian(Of T1, T2, T3, T4, T5, T6, TResult) (
+ first As IEnumerable(Of T1),
+ second As IEnumerable(Of T2),
+ third As IEnumerable(Of T3),
+ fourth As IEnumerable(Of T4),
+ fifth As IEnumerable(Of T5),
+ sixth As IEnumerable(Of T6),
+ resultSelector As Func(Of T1, T2, T3, T4, T5, T6, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename TResult>
+static IEnumerable<TResult>^ Cartesian(
+ IEnumerable<T1>^ first,
+ IEnumerable<T2>^ second,
+ IEnumerable<T3>^ third,
+ IEnumerable<T4>^ fourth,
+ IEnumerable<T5>^ fifth,
+ IEnumerable<T6>^ sixth,
+ Func<T1, T2, T3, T4, T5, T6, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Cartesian :
+ first : IEnumerable<'T1> *
+ second : IEnumerable<'T2> *
+ third : IEnumerable<'T3> *
+ fourth : IEnumerable<'T4> *
+ fifth : IEnumerable<'T5> *
+ sixth : IEnumerable<'T6> *
+ resultSelector : Func<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'TResult> -> IEnumerable<'TResult> + The method returns items in the same order as a nested foreach + loop, but all sequences except for first are + cached when iterated over. The cache is then re-used for any + subsequent iterations.
+ This method uses deferred execution and stream its results.
public static IEnumerable<TResult> Cartesian<T1, T2, T3, T4, T5, T6, T7, TResult>(
+ this IEnumerable<T1> first,
+ IEnumerable<T2> second,
+ IEnumerable<T3> third,
+ IEnumerable<T4> fourth,
+ IEnumerable<T5> fifth,
+ IEnumerable<T6> sixth,
+ IEnumerable<T7> seventh,
+ Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Cartesian(Of T1, T2, T3, T4, T5, T6, T7, TResult) (
+ first As IEnumerable(Of T1),
+ second As IEnumerable(Of T2),
+ third As IEnumerable(Of T3),
+ fourth As IEnumerable(Of T4),
+ fifth As IEnumerable(Of T5),
+ sixth As IEnumerable(Of T6),
+ seventh As IEnumerable(Of T7),
+ resultSelector As Func(Of T1, T2, T3, T4, T5, T6, T7, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename TResult>
+static IEnumerable<TResult>^ Cartesian(
+ IEnumerable<T1>^ first,
+ IEnumerable<T2>^ second,
+ IEnumerable<T3>^ third,
+ IEnumerable<T4>^ fourth,
+ IEnumerable<T5>^ fifth,
+ IEnumerable<T6>^ sixth,
+ IEnumerable<T7>^ seventh,
+ Func<T1, T2, T3, T4, T5, T6, T7, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Cartesian :
+ first : IEnumerable<'T1> *
+ second : IEnumerable<'T2> *
+ third : IEnumerable<'T3> *
+ fourth : IEnumerable<'T4> *
+ fifth : IEnumerable<'T5> *
+ sixth : IEnumerable<'T6> *
+ seventh : IEnumerable<'T7> *
+ resultSelector : Func<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'TResult> -> IEnumerable<'TResult> + The method returns items in the same order as a nested foreach + loop, but all sequences except for first are + cached when iterated over. The cache is then re-used for any + subsequent iterations.
+ This method uses deferred execution and stream its results.
public static IEnumerable<TResult> Cartesian<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(
+ this IEnumerable<T1> first,
+ IEnumerable<T2> second,
+ IEnumerable<T3> third,
+ IEnumerable<T4> fourth,
+ IEnumerable<T5> fifth,
+ IEnumerable<T6> sixth,
+ IEnumerable<T7> seventh,
+ IEnumerable<T8> eighth,
+ Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Cartesian(Of T1, T2, T3, T4, T5, T6, T7, T8, TResult) (
+ first As IEnumerable(Of T1),
+ second As IEnumerable(Of T2),
+ third As IEnumerable(Of T3),
+ fourth As IEnumerable(Of T4),
+ fifth As IEnumerable(Of T5),
+ sixth As IEnumerable(Of T6),
+ seventh As IEnumerable(Of T7),
+ eighth As IEnumerable(Of T8),
+ resultSelector As Func(Of T1, T2, T3, T4, T5, T6, T7, T8, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename TResult>
+static IEnumerable<TResult>^ Cartesian(
+ IEnumerable<T1>^ first,
+ IEnumerable<T2>^ second,
+ IEnumerable<T3>^ third,
+ IEnumerable<T4>^ fourth,
+ IEnumerable<T5>^ fifth,
+ IEnumerable<T6>^ sixth,
+ IEnumerable<T7>^ seventh,
+ IEnumerable<T8>^ eighth,
+ Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Cartesian :
+ first : IEnumerable<'T1> *
+ second : IEnumerable<'T2> *
+ third : IEnumerable<'T3> *
+ fourth : IEnumerable<'T4> *
+ fifth : IEnumerable<'T5> *
+ sixth : IEnumerable<'T6> *
+ seventh : IEnumerable<'T7> *
+ eighth : IEnumerable<'T8> *
+ resultSelector : Func<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'TResult> -> IEnumerable<'TResult> + The method returns items in the same order as a nested foreach + loop, but all sequences except for first are + cached when iterated over. The cache is then re-used for any + subsequent iterations.
+ This method uses deferred execution and stream its results.
public static IEnumerable<TResult> Choose<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, (bool , TResult )> chooser
+)
+<ExtensionAttribute>
+Public Shared Function Choose(Of T, TResult) (
+ source As IEnumerable(Of T),
+ chooser As Func(Of T, ( As Boolean, As TResult))
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static IEnumerable<TResult>^ Choose(
+ IEnumerable<T>^ source,
+ Func<T, ValueTuple<bool, TResult>>^ chooser
+)[<ExtensionAttribute>]
+static member Choose :
+ source : IEnumerable<'T> *
+ chooser : Func<'T, ValueTuple<bool, 'TResult>> -> IEnumerable<'TResult> 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));public static int CompareCount<TFirst, TSecond>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second
+)
+<ExtensionAttribute>
+Public Shared Function CompareCount(Of TFirst, TSecond) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond)
+) As Integerpublic:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond>
+static int CompareCount(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second
+)[<ExtensionAttribute>]
+static member CompareCount :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> -> int var first = new[] { 123, 456 };
+var second = new[] { 789 };
+var result = first.CompareCount(second);| ArgumentNullException | first is null |
| ArgumentNullException | second is null |
public static void Consume<T>(
+ this IEnumerable<T> source
+)
+<ExtensionAttribute>
+Public Shared Sub Consume(Of T) (
+ source As IEnumerable(Of T)
+)public:
+[ExtensionAttribute]
+generic<typename T>
+static void Consume(
+ IEnumerable<T>^ source
+)[<ExtensionAttribute>]
+static member Consume :
+ source : IEnumerable<'T> -> unit public static bool CountBetween<T>(
+ this IEnumerable<T> source,
+ int min,
+ int max
+)
+<ExtensionAttribute>
+Public Shared Function CountBetween(Of T) (
+ source As IEnumerable(Of T),
+ min As Integer,
+ max As Integer
+) As Booleanpublic:
+[ExtensionAttribute]
+generic<typename T>
+static bool CountBetween(
+ IEnumerable<T>^ source,
+ int min,
+ int max
+)[<ExtensionAttribute>]
+static member CountBetween :
+ source : IEnumerable<'T> *
+ min : int *
+ max : int -> bool var numbers = new[] { 123, 456, 789 };
+var result = numbers.CountBetween(1, 2);| ArgumentNullException | source is null |
| ArgumentOutOfRangeException | min is negative or max is less than min |
public static IEnumerable<KeyValuePair<TKey, int>> CountBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector
+)
+<ExtensionAttribute>
+Public Shared Function CountBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey)
+) As IEnumerable(Of KeyValuePair(Of TKey, Integer))public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<KeyValuePair<TKey, int>>^ CountBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector
+)[<ExtensionAttribute>]
+static member CountBy :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> -> IEnumerable<KeyValuePair<'TKey, int>> public static IEnumerable<KeyValuePair<TKey, int>> CountBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function CountBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of KeyValuePair(Of TKey, Integer))public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<KeyValuePair<TKey, int>>^ CountBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member CountBy :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<KeyValuePair<'TKey, int>> public static IEnumerable<TResult> CountDown<T, TResult>(
+ this IEnumerable<T> source,
+ int count,
+ Func<T, int?, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function CountDown(Of T, TResult) (
+ source As IEnumerable(Of T),
+ count As Integer,
+ resultSelector As Func(Of T, Integer?, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static IEnumerable<TResult>^ CountDown(
+ IEnumerable<T>^ source,
+ int count,
+ Func<T, Nullable<int>, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member CountDown :
+ source : IEnumerable<'T> *
+ count : int *
+ resultSelector : Func<'T, Nullable<int>, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TSource> DistinctBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector
+)
+<ExtensionAttribute>
+Public Shared Function DistinctBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<TSource>^ DistinctBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector
+)[<ExtensionAttribute>]
+static member DistinctBy :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> -> IEnumerable<'TSource> public static IEnumerable<TSource> DistinctBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function DistinctBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<TSource>^ DistinctBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member DistinctBy :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<'TSource> public static bool EndsWith<T>(
+ this IEnumerable<T> first,
+ IEnumerable<T> second
+)
+<ExtensionAttribute>
+Public Shared Function EndsWith(Of T) (
+ first As IEnumerable(Of T),
+ second As IEnumerable(Of T)
+) As Booleanpublic:
+[ExtensionAttribute]
+generic<typename T>
+static bool EndsWith(
+ IEnumerable<T>^ first,
+ IEnumerable<T>^ second
+)[<ExtensionAttribute>]
+static member EndsWith :
+ first : IEnumerable<'T> *
+ second : IEnumerable<'T> -> bool public static bool EndsWith<T>(
+ this IEnumerable<T> first,
+ IEnumerable<T> second,
+ IEqualityComparer<T>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function EndsWith(Of T) (
+ first As IEnumerable(Of T),
+ second As IEnumerable(Of T),
+ comparer As IEqualityComparer(Of T)
+) As Booleanpublic:
+[ExtensionAttribute]
+generic<typename T>
+static bool EndsWith(
+ IEnumerable<T>^ first,
+ IEnumerable<T>^ second,
+ IEqualityComparer<T>^ comparer
+)[<ExtensionAttribute>]
+static member EndsWith :
+ first : IEnumerable<'T> *
+ second : IEnumerable<'T> *
+ comparer : IEqualityComparer<'T> -> bool public static IEnumerable<TResult> EquiZip<TFirst, TSecond, TResult>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TSecond, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function EquiZip(Of TFirst, TSecond, TResult) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ resultSelector As Func(Of TFirst, TSecond, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TResult>
+static IEnumerable<TResult>^ EquiZip(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TSecond, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member EquiZip :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ resultSelector : Func<'TFirst, 'TSecond, 'TResult> -> IEnumerable<'TResult> var numbers = new[] { 1, 2, 3, 4 };
+var letters = new[] { "A", "B", "C", "D" };
+var zipped = numbers.EquiZip(letters, (n, l) => n + l);| InvalidOperationException | + The input sequences are of different lengths. + |
| ArgumentNullException | first, second, or resultSelector is . + |
public static IEnumerable<TResult> EquiZip<T1, T2, T3, TResult>(
+ this IEnumerable<T1> first,
+ IEnumerable<T2> second,
+ IEnumerable<T3> third,
+ Func<T1, T2, T3, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function EquiZip(Of T1, T2, T3, TResult) (
+ first As IEnumerable(Of T1),
+ second As IEnumerable(Of T2),
+ third As IEnumerable(Of T3),
+ resultSelector As Func(Of T1, T2, T3, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T1, typename T2, typename T3, typename TResult>
+static IEnumerable<TResult>^ EquiZip(
+ IEnumerable<T1>^ first,
+ IEnumerable<T2>^ second,
+ IEnumerable<T3>^ third,
+ Func<T1, T2, T3, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member EquiZip :
+ first : IEnumerable<'T1> *
+ second : IEnumerable<'T2> *
+ third : IEnumerable<'T3> *
+ resultSelector : Func<'T1, 'T2, 'T3, 'TResult> -> IEnumerable<'TResult> 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);| InvalidOperationException | + The input sequences are of different lengths. + |
| ArgumentNullException | first, second, third, or resultSelector is . + |
public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, TResult>(
+ this IEnumerable<T1> first,
+ IEnumerable<T2> second,
+ IEnumerable<T3> third,
+ IEnumerable<T4> fourth,
+ Func<T1, T2, T3, T4, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function EquiZip(Of T1, T2, T3, T4, TResult) (
+ first As IEnumerable(Of T1),
+ second As IEnumerable(Of T2),
+ third As IEnumerable(Of T3),
+ fourth As IEnumerable(Of T4),
+ resultSelector As Func(Of T1, T2, T3, T4, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T1, typename T2, typename T3, typename T4, typename TResult>
+static IEnumerable<TResult>^ EquiZip(
+ IEnumerable<T1>^ first,
+ IEnumerable<T2>^ second,
+ IEnumerable<T3>^ third,
+ IEnumerable<T4>^ fourth,
+ Func<T1, T2, T3, T4, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member EquiZip :
+ first : IEnumerable<'T1> *
+ second : IEnumerable<'T2> *
+ third : IEnumerable<'T3> *
+ fourth : IEnumerable<'T4> *
+ resultSelector : Func<'T1, 'T2, 'T3, 'T4, 'TResult> -> IEnumerable<'TResult> 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);| InvalidOperationException | + The input sequences are of different lengths. + |
| ArgumentNullException | first, second, third, fourth, or resultSelector is . + |
public static IEnumerable<T> Evaluate<T>(
+ this IEnumerable<Func<T>> functions
+)
+<ExtensionAttribute>
+Public Shared Function Evaluate(Of T) (
+ functions As IEnumerable(Of Func(Of T))
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Evaluate(
+ IEnumerable<Func<T>^>^ functions
+)[<ExtensionAttribute>]
+static member Evaluate :
+ functions : IEnumerable<Func<'T>> -> IEnumerable<'T> | ArgumentNullException | When functions is null. |
public static bool Exactly<T>(
+ this IEnumerable<T> source,
+ int count
+)
+<ExtensionAttribute>
+Public Shared Function Exactly(Of T) (
+ source As IEnumerable(Of T),
+ count As Integer
+) As Booleanpublic:
+[ExtensionAttribute]
+generic<typename T>
+static bool Exactly(
+ IEnumerable<T>^ source,
+ int count
+)[<ExtensionAttribute>]
+static member Exactly :
+ source : IEnumerable<'T> *
+ count : int -> bool var numbers = new[] { 123, 456, 789 };
+var result = numbers.Exactly(3);| ArgumentNullException | source is null |
| ArgumentOutOfRangeException | count is negative |
public static IEnumerable<TSource> ExceptBy<TSource, TKey>(
+ this IEnumerable<TSource> first,
+ IEnumerable<TSource> second,
+ Func<TSource, TKey> keySelector
+)
+<ExtensionAttribute>
+Public Shared Function ExceptBy(Of TSource, TKey) (
+ first As IEnumerable(Of TSource),
+ second As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<TSource>^ ExceptBy(
+ IEnumerable<TSource>^ first,
+ IEnumerable<TSource>^ second,
+ Func<TSource, TKey>^ keySelector
+)[<ExtensionAttribute>]
+static member ExceptBy :
+ first : IEnumerable<'TSource> *
+ second : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> -> IEnumerable<'TSource> public static IEnumerable<TSource> ExceptBy<TSource, TKey>(
+ this IEnumerable<TSource> first,
+ IEnumerable<TSource> second,
+ Func<TSource, TKey> keySelector,
+ IEqualityComparer<TKey>? keyComparer
+)
+<ExtensionAttribute>
+Public Shared Function ExceptBy(Of TSource, TKey) (
+ first As IEnumerable(Of TSource),
+ second As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ keyComparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<TSource>^ ExceptBy(
+ IEnumerable<TSource>^ first,
+ IEnumerable<TSource>^ second,
+ Func<TSource, TKey>^ keySelector,
+ IEqualityComparer<TKey>^ keyComparer
+)[<ExtensionAttribute>]
+static member ExceptBy :
+ first : IEnumerable<'TSource> *
+ second : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ keyComparer : IEqualityComparer<'TKey> -> IEnumerable<'TSource> public static IEnumerable<T> Exclude<T>(
+ this IEnumerable<T> sequence,
+ int startIndex,
+ int count
+)
+<ExtensionAttribute>
+Public Shared Function Exclude(Of T) (
+ sequence As IEnumerable(Of T),
+ startIndex As Integer,
+ count As Integer
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Exclude(
+ IEnumerable<T>^ sequence,
+ int startIndex,
+ int count
+)[<ExtensionAttribute>]
+static member Exclude :
+ sequence : IEnumerable<'T> *
+ startIndex : int *
+ count : int -> IEnumerable<'T> public static IEnumerable<T> FallbackIfEmpty<T>(
+ this IEnumerable<T> source,
+ IEnumerable<T> fallback
+)
+<ExtensionAttribute>
+Public Shared Function FallbackIfEmpty(Of T) (
+ source As IEnumerable(Of T),
+ fallback As IEnumerable(Of T)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ FallbackIfEmpty(
+ IEnumerable<T>^ source,
+ IEnumerable<T>^ fallback
+)[<ExtensionAttribute>]
+static member FallbackIfEmpty :
+ source : IEnumerable<'T> *
+ fallback : IEnumerable<'T> -> IEnumerable<'T> public static IEnumerable<T> FallbackIfEmpty<T>(
+ this IEnumerable<T> source,
+ T fallback
+)
+<ExtensionAttribute>
+Public Shared Function FallbackIfEmpty(Of T) (
+ source As IEnumerable(Of T),
+ fallback As T
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ FallbackIfEmpty(
+ IEnumerable<T>^ source,
+ T fallback
+)[<ExtensionAttribute>]
+static member FallbackIfEmpty :
+ source : IEnumerable<'T> *
+ fallback : 'T -> IEnumerable<'T> var numbers = new[] { 123, 456, 789 };
+var result = numbers.Where(x => x == 100).FallbackIfEmpty(-1).Single();public static IEnumerable<T> FallbackIfEmpty<T>(
+ this IEnumerable<T> source,
+ T fallback1,
+ T fallback2
+)
+<ExtensionAttribute>
+Public Shared Function FallbackIfEmpty(Of T) (
+ source As IEnumerable(Of T),
+ fallback1 As T,
+ fallback2 As T
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ FallbackIfEmpty(
+ IEnumerable<T>^ source,
+ T fallback1,
+ T fallback2
+)[<ExtensionAttribute>]
+static member FallbackIfEmpty :
+ source : IEnumerable<'T> *
+ fallback1 : 'T *
+ fallback2 : 'T -> IEnumerable<'T> public static IEnumerable<T> FallbackIfEmpty<T>(
+ this IEnumerable<T> source,
+ T fallback1,
+ T fallback2,
+ T fallback3
+)
+<ExtensionAttribute>
+Public Shared Function FallbackIfEmpty(Of T) (
+ source As IEnumerable(Of T),
+ fallback1 As T,
+ fallback2 As T,
+ fallback3 As T
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ FallbackIfEmpty(
+ IEnumerable<T>^ source,
+ T fallback1,
+ T fallback2,
+ T fallback3
+)[<ExtensionAttribute>]
+static member FallbackIfEmpty :
+ source : IEnumerable<'T> *
+ fallback1 : 'T *
+ fallback2 : 'T *
+ fallback3 : 'T -> IEnumerable<'T> public static IEnumerable<T> FallbackIfEmpty<T>(
+ this IEnumerable<T> source,
+ T fallback1,
+ T fallback2,
+ T fallback3,
+ T fallback4
+)
+<ExtensionAttribute>
+Public Shared Function FallbackIfEmpty(Of T) (
+ source As IEnumerable(Of T),
+ fallback1 As T,
+ fallback2 As T,
+ fallback3 As T,
+ fallback4 As T
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ FallbackIfEmpty(
+ IEnumerable<T>^ source,
+ T fallback1,
+ T fallback2,
+ T fallback3,
+ T fallback4
+)[<ExtensionAttribute>]
+static member FallbackIfEmpty :
+ source : IEnumerable<'T> *
+ fallback1 : 'T *
+ fallback2 : 'T *
+ fallback3 : 'T *
+ fallback4 : 'T -> IEnumerable<'T> public static IEnumerable<T> FallbackIfEmpty<T>(
+ this IEnumerable<T> source,
+ params T[] fallback
+)
+<ExtensionAttribute>
+Public Shared Function FallbackIfEmpty(Of T) (
+ source As IEnumerable(Of T),
+ ParamArray fallback As T()
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ FallbackIfEmpty(
+ IEnumerable<T>^ source,
+ ... array<T>^ fallback
+)[<ExtensionAttribute>]
+static member FallbackIfEmpty :
+ source : IEnumerable<'T> *
+ fallback : 'T[] -> IEnumerable<'T> public static IEnumerable<T> FillBackward<T>(
+ this IEnumerable<T> source
+)
+<ExtensionAttribute>
+Public Shared Function FillBackward(Of T) (
+ source As IEnumerable(Of T)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ FillBackward(
+ IEnumerable<T>^ source
+)[<ExtensionAttribute>]
+static member FillBackward :
+ source : IEnumerable<'T> -> IEnumerable<'T> public static IEnumerable<T> FillBackward<T>(
+ this IEnumerable<T> source,
+ Func<T, bool> predicate
+)
+<ExtensionAttribute>
+Public Shared Function FillBackward(Of T) (
+ source As IEnumerable(Of T),
+ predicate As Func(Of T, Boolean)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ FillBackward(
+ IEnumerable<T>^ source,
+ Func<T, bool>^ predicate
+)[<ExtensionAttribute>]
+static member FillBackward :
+ source : IEnumerable<'T> *
+ predicate : Func<'T, bool> -> IEnumerable<'T> public static IEnumerable<T> FillBackward<T>(
+ this IEnumerable<T> source,
+ Func<T, bool> predicate,
+ Func<T, T, T> fillSelector
+)
+<ExtensionAttribute>
+Public Shared Function FillBackward(Of T) (
+ source As IEnumerable(Of T),
+ predicate As Func(Of T, Boolean),
+ fillSelector As Func(Of T, T, T)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ FillBackward(
+ IEnumerable<T>^ source,
+ Func<T, bool>^ predicate,
+ Func<T, T, T>^ fillSelector
+)[<ExtensionAttribute>]
+static member FillBackward :
+ source : IEnumerable<'T> *
+ predicate : Func<'T, bool> *
+ fillSelector : Func<'T, 'T, 'T> -> IEnumerable<'T> public static IEnumerable<T> FillForward<T>(
+ this IEnumerable<T> source
+)
+<ExtensionAttribute>
+Public Shared Function FillForward(Of T) (
+ source As IEnumerable(Of T)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ FillForward(
+ IEnumerable<T>^ source
+)[<ExtensionAttribute>]
+static member FillForward :
+ source : IEnumerable<'T> -> IEnumerable<'T> public static IEnumerable<T> FillForward<T>(
+ this IEnumerable<T> source,
+ Func<T, bool> predicate
+)
+<ExtensionAttribute>
+Public Shared Function FillForward(Of T) (
+ source As IEnumerable(Of T),
+ predicate As Func(Of T, Boolean)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ FillForward(
+ IEnumerable<T>^ source,
+ Func<T, bool>^ predicate
+)[<ExtensionAttribute>]
+static member FillForward :
+ source : IEnumerable<'T> *
+ predicate : Func<'T, bool> -> IEnumerable<'T> public static IEnumerable<T> FillForward<T>(
+ this IEnumerable<T> source,
+ Func<T, bool> predicate,
+ Func<T, T, T> fillSelector
+)
+<ExtensionAttribute>
+Public Shared Function FillForward(Of T) (
+ source As IEnumerable(Of T),
+ predicate As Func(Of T, Boolean),
+ fillSelector As Func(Of T, T, T)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ FillForward(
+ IEnumerable<T>^ source,
+ Func<T, bool>^ predicate,
+ Func<T, T, T>^ fillSelector
+)[<ExtensionAttribute>]
+static member FillForward :
+ source : IEnumerable<'T> *
+ predicate : Func<'T, bool> *
+ fillSelector : Func<'T, 'T, 'T> -> IEnumerable<'T> public static T First<T>(
+ this IExtremaEnumerable<T> source
+)
+<ExtensionAttribute>
+Public Shared Function First(Of T) (
+ source As IExtremaEnumerable(Of T)
+) As Tpublic:
+[ExtensionAttribute]
+generic<typename T>
+static T First(
+ IExtremaEnumerable<T>^ source
+)[<ExtensionAttribute>]
+static member First :
+ source : IExtremaEnumerable<'T> -> 'T | InvalidOperationException | + The input sequence is empty. |
public static T FirstOrDefault<T>(
+ this IExtremaEnumerable<T> source
+)
+<ExtensionAttribute>
+Public Shared Function FirstOrDefault(Of T) (
+ source As IExtremaEnumerable(Of T)
+) As Tpublic:
+[ExtensionAttribute]
+generic<typename T>
+static T FirstOrDefault(
+ IExtremaEnumerable<T>^ source
+)[<ExtensionAttribute>]
+static member FirstOrDefault :
+ source : IExtremaEnumerable<'T> -> 'T public static IEnumerable<Object> Flatten(
+ this IEnumerable source
+)<ExtensionAttribute>
+Public Shared Function Flatten (
+ source As IEnumerable
+) As IEnumerable(Of Object)public:
+[ExtensionAttribute]
+static IEnumerable<Object^>^ Flatten(
+ IEnumerable^ source
+)[<ExtensionAttribute>]
+static member Flatten :
+ source : IEnumerable -> IEnumerable<Object> | ArgumentNullException | source is null. |
public static IEnumerable<Object> Flatten(
+ this IEnumerable source,
+ Func<IEnumerable, bool> predicate
+)<ExtensionAttribute>
+Public Shared Function Flatten (
+ source As IEnumerable,
+ predicate As Func(Of IEnumerable, Boolean)
+) As IEnumerable(Of Object)public:
+[ExtensionAttribute]
+static IEnumerable<Object^>^ Flatten(
+ IEnumerable^ source,
+ Func<IEnumerable^, bool>^ predicate
+)[<ExtensionAttribute>]
+static member Flatten :
+ source : IEnumerable *
+ predicate : Func<IEnumerable, bool> -> IEnumerable<Object> | ArgumentNullException | source is null. |
| ArgumentNullException | predicate is null. |
public static IEnumerable<Object> Flatten(
+ this IEnumerable source,
+ Func<Object, IEnumerable?> selector
+)<ExtensionAttribute>
+Public Shared Function Flatten (
+ source As IEnumerable,
+ selector As Func(Of Object, IEnumerable)
+) As IEnumerable(Of Object)public:
+[ExtensionAttribute]
+static IEnumerable<Object^>^ Flatten(
+ IEnumerable^ source,
+ Func<Object^, IEnumerable^>^ selector
+)[<ExtensionAttribute>]
+static member Flatten :
+ source : IEnumerable *
+ selector : Func<Object, IEnumerable> -> IEnumerable<Object> | ArgumentNullException | source is null. |
| ArgumentNullException | selector is null. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, T, T, T, T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, T, T, T, T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, T, T, T, T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 9 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, T, T, T, T, T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, T, T, T, T, T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, T, T, T, T, T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 10 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 3 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 4 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 5 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 6 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, T, T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, T, T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, T, T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'T, 'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 7 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, T, T, T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, T, T, T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, T, T, T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 8 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, T, T, T, T, T, T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, T, T, T, T, T, T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, T, T, T, T, T, T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 11 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, T, T, T, T, T, T, T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, T, T, T, T, T, T, T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 12 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, T, T, T, T, T, T, T, T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 13 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 14 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 15 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 16 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 1 element. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 2 elements. |
public static void ForEach<T>(
+ this IEnumerable<T> source,
+ Action<T> action
+)
+<ExtensionAttribute>
+Public Shared Sub ForEach(Of T) (
+ source As IEnumerable(Of T),
+ action As Action(Of T)
+)public:
+[ExtensionAttribute]
+generic<typename T>
+static void ForEach(
+ IEnumerable<T>^ source,
+ Action<T>^ action
+)[<ExtensionAttribute>]
+static member ForEach :
+ source : IEnumerable<'T> *
+ action : Action<'T> -> unit public static void ForEach<T>(
+ this IEnumerable<T> source,
+ Action<T, int> action
+)
+<ExtensionAttribute>
+Public Shared Sub ForEach(Of T) (
+ source As IEnumerable(Of T),
+ action As Action(Of T, Integer)
+)public:
+[ExtensionAttribute]
+generic<typename T>
+static void ForEach(
+ IEnumerable<T>^ source,
+ Action<T, int>^ action
+)[<ExtensionAttribute>]
+static member ForEach :
+ source : IEnumerable<'T> *
+ action : Action<'T, int> -> unit public static IEnumerable<(TKey , IEnumerable<TFirst> First, IEnumerable<TSecond> Second)> FullGroupJoin<TFirst, TSecond, TKey>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TKey> firstKeySelector,
+ Func<TSecond, TKey> secondKeySelector
+)
+<ExtensionAttribute>
+Public Shared Function FullGroupJoin(Of TFirst, TSecond, TKey) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ firstKeySelector As Func(Of TFirst, TKey),
+ secondKeySelector As Func(Of TSecond, TKey)
+) As IEnumerable(Of ( As TKey, First As IEnumerable(Of TFirst), Second As IEnumerable(Of TSecond)))public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TKey>
+static IEnumerable<ValueTuple<TKey, IEnumerable<TFirst>^, IEnumerable<TSecond>^>>^ FullGroupJoin(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TKey>^ firstKeySelector,
+ Func<TSecond, TKey>^ secondKeySelector
+)[<ExtensionAttribute>]
+static member FullGroupJoin :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ firstKeySelector : Func<'TFirst, 'TKey> *
+ secondKeySelector : Func<'TSecond, 'TKey> -> IEnumerable<ValueTuple<'TKey, IEnumerable<'TFirst>, IEnumerable<'TSecond>>> public static IEnumerable<(TKey , IEnumerable<TFirst> First, IEnumerable<TSecond> Second)> FullGroupJoin<TFirst, TSecond, TKey>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TKey> firstKeySelector,
+ Func<TSecond, TKey> secondKeySelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function FullGroupJoin(Of TFirst, TSecond, TKey) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ firstKeySelector As Func(Of TFirst, TKey),
+ secondKeySelector As Func(Of TSecond, TKey),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of ( As TKey, First As IEnumerable(Of TFirst), Second As IEnumerable(Of TSecond)))public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TKey>
+static IEnumerable<ValueTuple<TKey, IEnumerable<TFirst>^, IEnumerable<TSecond>^>>^ FullGroupJoin(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TKey>^ firstKeySelector,
+ Func<TSecond, TKey>^ secondKeySelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member FullGroupJoin :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ firstKeySelector : Func<'TFirst, 'TKey> *
+ secondKeySelector : Func<'TSecond, 'TKey> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<ValueTuple<'TKey, IEnumerable<'TFirst>, IEnumerable<'TSecond>>> public static IEnumerable<TResult> FullGroupJoin<TFirst, TSecond, TKey, TResult>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TKey> firstKeySelector,
+ Func<TSecond, TKey> secondKeySelector,
+ Func<TKey, IEnumerable<TFirst>, IEnumerable<TSecond>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function FullGroupJoin(Of TFirst, TSecond, TKey, TResult) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ firstKeySelector As Func(Of TFirst, TKey),
+ secondKeySelector As Func(Of TSecond, TKey),
+ resultSelector As Func(Of TKey, IEnumerable(Of TFirst), IEnumerable(Of TSecond), TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TKey, typename TResult>
+static IEnumerable<TResult>^ FullGroupJoin(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TKey>^ firstKeySelector,
+ Func<TSecond, TKey>^ secondKeySelector,
+ Func<TKey, IEnumerable<TFirst>^, IEnumerable<TSecond>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member FullGroupJoin :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ firstKeySelector : Func<'TFirst, 'TKey> *
+ secondKeySelector : Func<'TSecond, 'TKey> *
+ resultSelector : Func<'TKey, IEnumerable<'TFirst>, IEnumerable<'TSecond>, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> FullGroupJoin<TFirst, TSecond, TKey, TResult>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TKey> firstKeySelector,
+ Func<TSecond, TKey> secondKeySelector,
+ Func<TKey, IEnumerable<TFirst>, IEnumerable<TSecond>, TResult> resultSelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function FullGroupJoin(Of TFirst, TSecond, TKey, TResult) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ firstKeySelector As Func(Of TFirst, TKey),
+ secondKeySelector As Func(Of TSecond, TKey),
+ resultSelector As Func(Of TKey, IEnumerable(Of TFirst), IEnumerable(Of TSecond), TResult),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TKey, typename TResult>
+static IEnumerable<TResult>^ FullGroupJoin(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TKey>^ firstKeySelector,
+ Func<TSecond, TKey>^ secondKeySelector,
+ Func<TKey, IEnumerable<TFirst>^, IEnumerable<TSecond>^, TResult>^ resultSelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member FullGroupJoin :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ firstKeySelector : Func<'TFirst, 'TKey> *
+ secondKeySelector : Func<'TSecond, 'TKey> *
+ resultSelector : Func<'TKey, IEnumerable<'TFirst>, IEnumerable<'TSecond>, 'TResult> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<'TResult> public static IEnumerable<TResult> FullJoin<TSource, TKey, TResult>(
+ this IEnumerable<TSource> first,
+ IEnumerable<TSource> second,
+ Func<TSource, TKey> keySelector,
+ Func<TSource, TResult> firstSelector,
+ Func<TSource, TResult> secondSelector,
+ Func<TSource, TSource, TResult> bothSelector
+)
+<ExtensionAttribute>
+Public Shared Function FullJoin(Of TSource, TKey, TResult) (
+ first As IEnumerable(Of TSource),
+ second As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ firstSelector As Func(Of TSource, TResult),
+ secondSelector As Func(Of TSource, TResult),
+ bothSelector As Func(Of TSource, TSource, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey, typename TResult>
+static IEnumerable<TResult>^ FullJoin(
+ IEnumerable<TSource>^ first,
+ IEnumerable<TSource>^ second,
+ Func<TSource, TKey>^ keySelector,
+ Func<TSource, TResult>^ firstSelector,
+ Func<TSource, TResult>^ secondSelector,
+ Func<TSource, TSource, TResult>^ bothSelector
+)[<ExtensionAttribute>]
+static member FullJoin :
+ first : IEnumerable<'TSource> *
+ second : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ firstSelector : Func<'TSource, 'TResult> *
+ secondSelector : Func<'TSource, 'TResult> *
+ bothSelector : Func<'TSource, 'TSource, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> FullJoin<TSource, TKey, TResult>(
+ this IEnumerable<TSource> first,
+ IEnumerable<TSource> second,
+ Func<TSource, TKey> keySelector,
+ Func<TSource, TResult> firstSelector,
+ Func<TSource, TResult> secondSelector,
+ Func<TSource, TSource, TResult> bothSelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function FullJoin(Of TSource, TKey, TResult) (
+ first As IEnumerable(Of TSource),
+ second As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ firstSelector As Func(Of TSource, TResult),
+ secondSelector As Func(Of TSource, TResult),
+ bothSelector As Func(Of TSource, TSource, TResult),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey, typename TResult>
+static IEnumerable<TResult>^ FullJoin(
+ IEnumerable<TSource>^ first,
+ IEnumerable<TSource>^ second,
+ Func<TSource, TKey>^ keySelector,
+ Func<TSource, TResult>^ firstSelector,
+ Func<TSource, TResult>^ secondSelector,
+ Func<TSource, TSource, TResult>^ bothSelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member FullJoin :
+ first : IEnumerable<'TSource> *
+ second : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ firstSelector : Func<'TSource, 'TResult> *
+ secondSelector : Func<'TSource, 'TResult> *
+ bothSelector : Func<'TSource, 'TSource, 'TResult> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<'TResult> public static IEnumerable<TResult> FullJoin<TFirst, TSecond, TKey, TResult>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TKey> firstKeySelector,
+ Func<TSecond, TKey> secondKeySelector,
+ Func<TFirst, TResult> firstSelector,
+ Func<TSecond, TResult> secondSelector,
+ Func<TFirst, TSecond, TResult> bothSelector
+)
+<ExtensionAttribute>
+Public Shared Function FullJoin(Of TFirst, TSecond, TKey, TResult) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ firstKeySelector As Func(Of TFirst, TKey),
+ secondKeySelector As Func(Of TSecond, TKey),
+ firstSelector As Func(Of TFirst, TResult),
+ secondSelector As Func(Of TSecond, TResult),
+ bothSelector As Func(Of TFirst, TSecond, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TKey, typename TResult>
+static IEnumerable<TResult>^ FullJoin(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TKey>^ firstKeySelector,
+ Func<TSecond, TKey>^ secondKeySelector,
+ Func<TFirst, TResult>^ firstSelector,
+ Func<TSecond, TResult>^ secondSelector,
+ Func<TFirst, TSecond, TResult>^ bothSelector
+)[<ExtensionAttribute>]
+static member FullJoin :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ firstKeySelector : Func<'TFirst, 'TKey> *
+ secondKeySelector : Func<'TSecond, 'TKey> *
+ firstSelector : Func<'TFirst, 'TResult> *
+ secondSelector : Func<'TSecond, 'TResult> *
+ bothSelector : Func<'TFirst, 'TSecond, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> FullJoin<TFirst, TSecond, TKey, TResult>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TKey> firstKeySelector,
+ Func<TSecond, TKey> secondKeySelector,
+ Func<TFirst, TResult> firstSelector,
+ Func<TSecond, TResult> secondSelector,
+ Func<TFirst, TSecond, TResult> bothSelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function FullJoin(Of TFirst, TSecond, TKey, TResult) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ firstKeySelector As Func(Of TFirst, TKey),
+ secondKeySelector As Func(Of TSecond, TKey),
+ firstSelector As Func(Of TFirst, TResult),
+ secondSelector As Func(Of TSecond, TResult),
+ bothSelector As Func(Of TFirst, TSecond, TResult),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TKey, typename TResult>
+static IEnumerable<TResult>^ FullJoin(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TKey>^ firstKeySelector,
+ Func<TSecond, TKey>^ secondKeySelector,
+ Func<TFirst, TResult>^ firstSelector,
+ Func<TSecond, TResult>^ secondSelector,
+ Func<TFirst, TSecond, TResult>^ bothSelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member FullJoin :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ firstKeySelector : Func<'TFirst, 'TKey> *
+ secondKeySelector : Func<'TSecond, 'TKey> *
+ firstSelector : Func<'TFirst, 'TResult> *
+ secondSelector : Func<'TSecond, 'TResult> *
+ bothSelector : Func<'TFirst, 'TSecond, 'TResult> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<'TResult> public static IEnumerable<IGrouping<TKey, TSource>> GroupAdjacent<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector
+)
+<ExtensionAttribute>
+Public Shared Function GroupAdjacent(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey)
+) As IEnumerable(Of IGrouping(Of TKey, TSource))public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<IGrouping<TKey, TSource>^>^ GroupAdjacent(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector
+)[<ExtensionAttribute>]
+static member GroupAdjacent :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> -> IEnumerable<IGrouping<'TKey, 'TSource>> public static IEnumerable<IGrouping<TKey, TSource>> GroupAdjacent<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function GroupAdjacent(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of IGrouping(Of TKey, TSource))public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<IGrouping<TKey, TSource>^>^ GroupAdjacent(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member GroupAdjacent :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<IGrouping<'TKey, 'TSource>> public static IEnumerable<IGrouping<TKey, TElement>> GroupAdjacent<TSource, TKey, TElement>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector,
+ Func<TSource, TElement> elementSelector
+)
+<ExtensionAttribute>
+Public Shared Function GroupAdjacent(Of TSource, TKey, TElement) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ elementSelector As Func(Of TSource, TElement)
+) As IEnumerable(Of IGrouping(Of TKey, TElement))public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey, typename TElement>
+static IEnumerable<IGrouping<TKey, TElement>^>^ GroupAdjacent(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector,
+ Func<TSource, TElement>^ elementSelector
+)[<ExtensionAttribute>]
+static member GroupAdjacent :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ elementSelector : Func<'TSource, 'TElement> -> IEnumerable<IGrouping<'TKey, 'TElement>> public static IEnumerable<IGrouping<TKey, TElement>> GroupAdjacent<TSource, TKey, TElement>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector,
+ Func<TSource, TElement> elementSelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function GroupAdjacent(Of TSource, TKey, TElement) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ elementSelector As Func(Of TSource, TElement),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of IGrouping(Of TKey, TElement))public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey, typename TElement>
+static IEnumerable<IGrouping<TKey, TElement>^>^ GroupAdjacent(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector,
+ Func<TSource, TElement>^ elementSelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member GroupAdjacent :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ elementSelector : Func<'TSource, 'TElement> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<IGrouping<'TKey, 'TElement>> public static IEnumerable<TResult> GroupAdjacent<TSource, TKey, TResult>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector,
+ Func<TKey, IEnumerable<TSource>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function GroupAdjacent(Of TSource, TKey, TResult) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ resultSelector As Func(Of TKey, IEnumerable(Of TSource), TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey, typename TResult>
+static IEnumerable<TResult>^ GroupAdjacent(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector,
+ Func<TKey, IEnumerable<TSource>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member GroupAdjacent :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ resultSelector : Func<'TKey, IEnumerable<'TSource>, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> GroupAdjacent<TSource, TKey, TResult>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector,
+ Func<TKey, IEnumerable<TSource>, TResult> resultSelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function GroupAdjacent(Of TSource, TKey, TResult) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ resultSelector As Func(Of TKey, IEnumerable(Of TSource), TResult),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey, typename TResult>
+static IEnumerable<TResult>^ GroupAdjacent(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector,
+ Func<TKey, IEnumerable<TSource>^, TResult>^ resultSelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member GroupAdjacent :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ resultSelector : Func<'TKey, IEnumerable<'TSource>, 'TResult> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<'TResult> public static IEnumerable<KeyValuePair<int, TSource>> IndexBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector
+)
+<ExtensionAttribute>
+Public Shared Function IndexBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey)
+) As IEnumerable(Of KeyValuePair(Of Integer, TSource))public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<KeyValuePair<int, TSource>>^ IndexBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector
+)[<ExtensionAttribute>]
+static member IndexBy :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> -> IEnumerable<KeyValuePair<int, 'TSource>> public static IEnumerable<KeyValuePair<int, TSource>> IndexBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function IndexBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of KeyValuePair(Of Integer, TSource))public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<KeyValuePair<int, TSource>>^ IndexBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member IndexBy :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<KeyValuePair<int, 'TSource>> public static IEnumerable<KeyValuePair<int, TSource>> Index<TSource>(
+ this IEnumerable<TSource> source
+)
+<ExtensionAttribute>
+Public Shared Function Index(Of TSource) (
+ source As IEnumerable(Of TSource)
+) As IEnumerable(Of KeyValuePair(Of Integer, TSource))public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<KeyValuePair<int, TSource>>^ Index(
+ IEnumerable<TSource>^ source
+)[<ExtensionAttribute>]
+static member Index :
+ source : IEnumerable<'TSource> -> IEnumerable<KeyValuePair<int, 'TSource>> public static IEnumerable<KeyValuePair<int, TSource>> Index<TSource>(
+ this IEnumerable<TSource> source,
+ int startIndex
+)
+<ExtensionAttribute>
+Public Shared Function Index(Of TSource) (
+ source As IEnumerable(Of TSource),
+ startIndex As Integer
+) As IEnumerable(Of KeyValuePair(Of Integer, TSource))public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<KeyValuePair<int, TSource>>^ Index(
+ IEnumerable<TSource>^ source,
+ int startIndex
+)[<ExtensionAttribute>]
+static member Index :
+ source : IEnumerable<'TSource> *
+ startIndex : int -> IEnumerable<KeyValuePair<int, 'TSource>> public static IEnumerable<T> Insert<T>(
+ this IEnumerable<T> first,
+ IEnumerable<T> second,
+ int index
+)
+<ExtensionAttribute>
+Public Shared Function Insert(Of T) (
+ first As IEnumerable(Of T),
+ second As IEnumerable(Of T),
+ index As Integer
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Insert(
+ IEnumerable<T>^ first,
+ IEnumerable<T>^ second,
+ int index
+)[<ExtensionAttribute>]
+static member Insert :
+ first : IEnumerable<'T> *
+ second : IEnumerable<'T> *
+ index : int -> IEnumerable<'T> | ArgumentNullException | first is null. |
| ArgumentNullException | second is null. |
| ArgumentOutOfRangeException | + Thrown if index is negative. + |
| ArgumentOutOfRangeException | + Thrown lazily if index is greater than the + length of first. The validation occurs when + yielding the next element after having iterated + first entirely. + |
public static IEnumerable<T> Interleave<T>(
+ this IEnumerable<T> sequence,
+ params IEnumerable<T>[] otherSequences
+)
+<ExtensionAttribute>
+Public Shared Function Interleave(Of T) (
+ sequence As IEnumerable(Of T),
+ ParamArray otherSequences As IEnumerable(Of T)()
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Interleave(
+ IEnumerable<T>^ sequence,
+ ... array<IEnumerable<T>^>^ otherSequences
+)[<ExtensionAttribute>]
+static member Interleave :
+ sequence : IEnumerable<'T> *
+ otherSequences : IEnumerable<'T>[] -> IEnumerable<'T> + 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:
var xs = new[] { 1, 1, 1 }.Interleave(new[] { 2, 2, 2 }, new[] { 3, 3, 3 });
+// xs = { 1, 2, 3, 1, 2, 3, 1, 2, 3 }+ This operator behaves in a deferred and streaming manner.
+ When sequences are of unequal length, this method will skip those sequences that have + been fully consumed and continue interleaving the remaining sequences.
+ The sequences are interleaved in the order that they appear in the otherSequences collection, with sequence as the first + sequence.
public static IEnumerable<TResult> Lag<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ int offset,
+ Func<TSource, TSource, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Lag(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ offset As Integer,
+ resultSelector As Func(Of TSource, TSource, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ Lag(
+ IEnumerable<TSource>^ source,
+ int offset,
+ Func<TSource, TSource, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Lag :
+ source : IEnumerable<'TSource> *
+ offset : int *
+ resultSelector : Func<'TSource, 'TSource, 'TResult> -> IEnumerable<'TResult> + This operator evaluates in a deferred and streaming manner.
+ For elements prior to the lag offset, default(T) is used as the lagged + value.
public static IEnumerable<TResult> Lag<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ int offset,
+ TSource defaultLagValue,
+ Func<TSource, TSource, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Lag(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ offset As Integer,
+ defaultLagValue As TSource,
+ resultSelector As Func(Of TSource, TSource, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ Lag(
+ IEnumerable<TSource>^ source,
+ int offset,
+ TSource defaultLagValue,
+ Func<TSource, TSource, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Lag :
+ source : IEnumerable<'TSource> *
+ offset : int *
+ defaultLagValue : 'TSource *
+ resultSelector : Func<'TSource, 'TSource, 'TResult> -> IEnumerable<'TResult> public static T Last<T>(
+ this IExtremaEnumerable<T> source
+)
+<ExtensionAttribute>
+Public Shared Function Last(Of T) (
+ source As IExtremaEnumerable(Of T)
+) As Tpublic:
+[ExtensionAttribute]
+generic<typename T>
+static T Last(
+ IExtremaEnumerable<T>^ source
+)[<ExtensionAttribute>]
+static member Last :
+ source : IExtremaEnumerable<'T> -> 'T | InvalidOperationException | + The input sequence is empty. |
public static T LastOrDefault<T>(
+ this IExtremaEnumerable<T> source
+)
+<ExtensionAttribute>
+Public Shared Function LastOrDefault(Of T) (
+ source As IExtremaEnumerable(Of T)
+) As Tpublic:
+[ExtensionAttribute]
+generic<typename T>
+static T LastOrDefault(
+ IExtremaEnumerable<T>^ source
+)[<ExtensionAttribute>]
+static member LastOrDefault :
+ source : IExtremaEnumerable<'T> -> 'T public static IEnumerable<TResult> Lead<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ int offset,
+ Func<TSource, TSource, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Lead(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ offset As Integer,
+ resultSelector As Func(Of TSource, TSource, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ Lead(
+ IEnumerable<TSource>^ source,
+ int offset,
+ Func<TSource, TSource, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Lead :
+ source : IEnumerable<'TSource> *
+ offset : int *
+ resultSelector : Func<'TSource, 'TSource, 'TResult> -> IEnumerable<'TResult> + This operator evaluates in a deferred and streaming manner.
+ For elements of the sequence that are less than offset items from the + end, default(T) is used as the lead value.
public static IEnumerable<TResult> Lead<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ int offset,
+ TSource defaultLeadValue,
+ Func<TSource, TSource, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Lead(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ offset As Integer,
+ defaultLeadValue As TSource,
+ resultSelector As Func(Of TSource, TSource, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ Lead(
+ IEnumerable<TSource>^ source,
+ int offset,
+ TSource defaultLeadValue,
+ Func<TSource, TSource, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Lead :
+ source : IEnumerable<'TSource> *
+ offset : int *
+ defaultLeadValue : 'TSource *
+ resultSelector : Func<'TSource, 'TSource, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> LeftJoin<TSource, TKey, TResult>(
+ this IEnumerable<TSource> first,
+ IEnumerable<TSource> second,
+ Func<TSource, TKey> keySelector,
+ Func<TSource, TResult> firstSelector,
+ Func<TSource, TSource, TResult> bothSelector
+)
+<ExtensionAttribute>
+Public Shared Function LeftJoin(Of TSource, TKey, TResult) (
+ first As IEnumerable(Of TSource),
+ second As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ firstSelector As Func(Of TSource, TResult),
+ bothSelector As Func(Of TSource, TSource, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey, typename TResult>
+static IEnumerable<TResult>^ LeftJoin(
+ IEnumerable<TSource>^ first,
+ IEnumerable<TSource>^ second,
+ Func<TSource, TKey>^ keySelector,
+ Func<TSource, TResult>^ firstSelector,
+ Func<TSource, TSource, TResult>^ bothSelector
+)[<ExtensionAttribute>]
+static member LeftJoin :
+ first : IEnumerable<'TSource> *
+ second : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ firstSelector : Func<'TSource, 'TResult> *
+ bothSelector : Func<'TSource, 'TSource, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> LeftJoin<TSource, TKey, TResult>(
+ this IEnumerable<TSource> first,
+ IEnumerable<TSource> second,
+ Func<TSource, TKey> keySelector,
+ Func<TSource, TResult> firstSelector,
+ Func<TSource, TSource, TResult> bothSelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function LeftJoin(Of TSource, TKey, TResult) (
+ first As IEnumerable(Of TSource),
+ second As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ firstSelector As Func(Of TSource, TResult),
+ bothSelector As Func(Of TSource, TSource, TResult),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey, typename TResult>
+static IEnumerable<TResult>^ LeftJoin(
+ IEnumerable<TSource>^ first,
+ IEnumerable<TSource>^ second,
+ Func<TSource, TKey>^ keySelector,
+ Func<TSource, TResult>^ firstSelector,
+ Func<TSource, TSource, TResult>^ bothSelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member LeftJoin :
+ first : IEnumerable<'TSource> *
+ second : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ firstSelector : Func<'TSource, 'TResult> *
+ bothSelector : Func<'TSource, 'TSource, 'TResult> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<'TResult> public static IEnumerable<TResult> LeftJoin<TFirst, TSecond, TKey, TResult>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TKey> firstKeySelector,
+ Func<TSecond, TKey> secondKeySelector,
+ Func<TFirst, TResult> firstSelector,
+ Func<TFirst, TSecond, TResult> bothSelector
+)
+<ExtensionAttribute>
+Public Shared Function LeftJoin(Of TFirst, TSecond, TKey, TResult) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ firstKeySelector As Func(Of TFirst, TKey),
+ secondKeySelector As Func(Of TSecond, TKey),
+ firstSelector As Func(Of TFirst, TResult),
+ bothSelector As Func(Of TFirst, TSecond, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TKey, typename TResult>
+static IEnumerable<TResult>^ LeftJoin(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TKey>^ firstKeySelector,
+ Func<TSecond, TKey>^ secondKeySelector,
+ Func<TFirst, TResult>^ firstSelector,
+ Func<TFirst, TSecond, TResult>^ bothSelector
+)[<ExtensionAttribute>]
+static member LeftJoin :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ firstKeySelector : Func<'TFirst, 'TKey> *
+ secondKeySelector : Func<'TSecond, 'TKey> *
+ firstSelector : Func<'TFirst, 'TResult> *
+ bothSelector : Func<'TFirst, 'TSecond, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> LeftJoin<TFirst, TSecond, TKey, TResult>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TKey> firstKeySelector,
+ Func<TSecond, TKey> secondKeySelector,
+ Func<TFirst, TResult> firstSelector,
+ Func<TFirst, TSecond, TResult> bothSelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function LeftJoin(Of TFirst, TSecond, TKey, TResult) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ firstKeySelector As Func(Of TFirst, TKey),
+ secondKeySelector As Func(Of TSecond, TKey),
+ firstSelector As Func(Of TFirst, TResult),
+ bothSelector As Func(Of TFirst, TSecond, TResult),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TKey, typename TResult>
+static IEnumerable<TResult>^ LeftJoin(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TKey>^ firstKeySelector,
+ Func<TSecond, TKey>^ secondKeySelector,
+ Func<TFirst, TResult>^ firstSelector,
+ Func<TFirst, TSecond, TResult>^ bothSelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member LeftJoin :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ firstKeySelector : Func<'TFirst, 'TKey> *
+ secondKeySelector : Func<'TSecond, 'TKey> *
+ firstSelector : Func<'TFirst, 'TResult> *
+ bothSelector : Func<'TFirst, 'TSecond, 'TResult> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<'TResult> public static IExtremaEnumerable<TSource> MaxBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> selector
+)
+<ExtensionAttribute>
+Public Shared Function MaxBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ selector As Func(Of TSource, TKey)
+) As IExtremaEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IExtremaEnumerable<TSource>^ MaxBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ selector
+)[<ExtensionAttribute>]
+static member MaxBy :
+ source : IEnumerable<'TSource> *
+ selector : Func<'TSource, 'TKey> -> IExtremaEnumerable<'TSource> | ArgumentNullException | source or selector is null |
public static IExtremaEnumerable<TSource> MaxBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> selector,
+ IComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function MaxBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ selector As Func(Of TSource, TKey),
+ comparer As IComparer(Of TKey)
+) As IExtremaEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IExtremaEnumerable<TSource>^ MaxBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ selector,
+ IComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member MaxBy :
+ source : IEnumerable<'TSource> *
+ selector : Func<'TSource, 'TKey> *
+ comparer : IComparer<'TKey> -> IExtremaEnumerable<'TSource> | ArgumentNullException | source, selector + or comparer is null |
public static IExtremaEnumerable<TSource> MinBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> selector
+)
+<ExtensionAttribute>
+Public Shared Function MinBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ selector As Func(Of TSource, TKey)
+) As IExtremaEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IExtremaEnumerable<TSource>^ MinBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ selector
+)[<ExtensionAttribute>]
+static member MinBy :
+ source : IEnumerable<'TSource> *
+ selector : Func<'TSource, 'TKey> -> IExtremaEnumerable<'TSource> | ArgumentNullException | source or selector is null |
public static IExtremaEnumerable<TSource> MinBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> selector,
+ IComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function MinBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ selector As Func(Of TSource, TKey),
+ comparer As IComparer(Of TKey)
+) As IExtremaEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IExtremaEnumerable<TSource>^ MinBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ selector,
+ IComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member MinBy :
+ source : IEnumerable<'TSource> *
+ selector : Func<'TSource, 'TKey> *
+ comparer : IComparer<'TKey> -> IExtremaEnumerable<'TSource> | ArgumentNullException | source, selector + or comparer is null |
public static IEnumerable<T> Move<T>(
+ this IEnumerable<T> source,
+ int fromIndex,
+ int count,
+ int toIndex
+)
+<ExtensionAttribute>
+Public Shared Function Move(Of T) (
+ source As IEnumerable(Of T),
+ fromIndex As Integer,
+ count As Integer,
+ toIndex As Integer
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Move(
+ IEnumerable<T>^ source,
+ int fromIndex,
+ int count,
+ int toIndex
+)[<ExtensionAttribute>]
+static member Move :
+ source : IEnumerable<'T> *
+ fromIndex : int *
+ count : int *
+ toIndex : int -> IEnumerable<'T> var result = Enumerable.Range(0, 6).Move(3, 2, 0);public static IOrderedEnumerable<T> OrderBy<T, TKey>(
+ this IEnumerable<T> source,
+ Func<T, TKey> keySelector,
+ OrderByDirection direction
+)
+<ExtensionAttribute>
+Public Shared Function OrderBy(Of T, TKey) (
+ source As IEnumerable(Of T),
+ keySelector As Func(Of T, TKey),
+ direction As OrderByDirection
+) As IOrderedEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T, typename TKey>
+static IOrderedEnumerable<T>^ OrderBy(
+ IEnumerable<T>^ source,
+ Func<T, TKey>^ keySelector,
+ OrderByDirection direction
+)[<ExtensionAttribute>]
+static member OrderBy :
+ source : IEnumerable<'T> *
+ keySelector : Func<'T, 'TKey> *
+ direction : OrderByDirection -> IOrderedEnumerable<'T> public static IOrderedEnumerable<T> OrderBy<T, TKey>(
+ this IEnumerable<T> source,
+ Func<T, TKey> keySelector,
+ IComparer<TKey>? comparer,
+ OrderByDirection direction
+)
+<ExtensionAttribute>
+Public Shared Function OrderBy(Of T, TKey) (
+ source As IEnumerable(Of T),
+ keySelector As Func(Of T, TKey),
+ comparer As IComparer(Of TKey),
+ direction As OrderByDirection
+) As IOrderedEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T, typename TKey>
+static IOrderedEnumerable<T>^ OrderBy(
+ IEnumerable<T>^ source,
+ Func<T, TKey>^ keySelector,
+ IComparer<TKey>^ comparer,
+ OrderByDirection direction
+)[<ExtensionAttribute>]
+static member OrderBy :
+ source : IEnumerable<'T> *
+ keySelector : Func<'T, 'TKey> *
+ comparer : IComparer<'TKey> *
+ direction : OrderByDirection -> IOrderedEnumerable<'T> public static IEnumerable<T> OrderedMerge<T>(
+ this IEnumerable<T> first,
+ IEnumerable<T> second
+)
+<ExtensionAttribute>
+Public Shared Function OrderedMerge(Of T) (
+ first As IEnumerable(Of T),
+ second As IEnumerable(Of T)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ OrderedMerge(
+ IEnumerable<T>^ first,
+ IEnumerable<T>^ second
+)[<ExtensionAttribute>]
+static member OrderedMerge :
+ first : IEnumerable<'T> *
+ second : IEnumerable<'T> -> IEnumerable<'T> public static IEnumerable<T> OrderedMerge<T>(
+ this IEnumerable<T> first,
+ IEnumerable<T> second,
+ IComparer<T>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function OrderedMerge(Of T) (
+ first As IEnumerable(Of T),
+ second As IEnumerable(Of T),
+ comparer As IComparer(Of T)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ OrderedMerge(
+ IEnumerable<T>^ first,
+ IEnumerable<T>^ second,
+ IComparer<T>^ comparer
+)[<ExtensionAttribute>]
+static member OrderedMerge :
+ first : IEnumerable<'T> *
+ second : IEnumerable<'T> *
+ comparer : IComparer<'T> -> IEnumerable<'T> public static IEnumerable<T> OrderedMerge<T, TKey>(
+ this IEnumerable<T> first,
+ IEnumerable<T> second,
+ Func<T, TKey> keySelector
+)
+<ExtensionAttribute>
+Public Shared Function OrderedMerge(Of T, TKey) (
+ first As IEnumerable(Of T),
+ second As IEnumerable(Of T),
+ keySelector As Func(Of T, TKey)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T, typename TKey>
+static IEnumerable<T>^ OrderedMerge(
+ IEnumerable<T>^ first,
+ IEnumerable<T>^ second,
+ Func<T, TKey>^ keySelector
+)[<ExtensionAttribute>]
+static member OrderedMerge :
+ first : IEnumerable<'T> *
+ second : IEnumerable<'T> *
+ keySelector : Func<'T, 'TKey> -> IEnumerable<'T> public static IEnumerable<TResult> OrderedMerge<T, TKey, TResult>(
+ this IEnumerable<T> first,
+ IEnumerable<T> second,
+ Func<T, TKey> keySelector,
+ Func<T, TResult> firstSelector,
+ Func<T, TResult> secondSelector,
+ Func<T, T, TResult> bothSelector
+)
+<ExtensionAttribute>
+Public Shared Function OrderedMerge(Of T, TKey, TResult) (
+ first As IEnumerable(Of T),
+ second As IEnumerable(Of T),
+ keySelector As Func(Of T, TKey),
+ firstSelector As Func(Of T, TResult),
+ secondSelector As Func(Of T, TResult),
+ bothSelector As Func(Of T, T, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T, typename TKey, typename TResult>
+static IEnumerable<TResult>^ OrderedMerge(
+ IEnumerable<T>^ first,
+ IEnumerable<T>^ second,
+ Func<T, TKey>^ keySelector,
+ Func<T, TResult>^ firstSelector,
+ Func<T, TResult>^ secondSelector,
+ Func<T, T, TResult>^ bothSelector
+)[<ExtensionAttribute>]
+static member OrderedMerge :
+ first : IEnumerable<'T> *
+ second : IEnumerable<'T> *
+ keySelector : Func<'T, 'TKey> *
+ firstSelector : Func<'T, 'TResult> *
+ secondSelector : Func<'T, 'TResult> *
+ bothSelector : Func<'T, 'T, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> OrderedMerge<T, TKey, TResult>(
+ this IEnumerable<T> first,
+ IEnumerable<T> second,
+ Func<T, TKey> keySelector,
+ Func<T, TResult> firstSelector,
+ Func<T, TResult> secondSelector,
+ Func<T, T, TResult> bothSelector,
+ IComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function OrderedMerge(Of T, TKey, TResult) (
+ first As IEnumerable(Of T),
+ second As IEnumerable(Of T),
+ keySelector As Func(Of T, TKey),
+ firstSelector As Func(Of T, TResult),
+ secondSelector As Func(Of T, TResult),
+ bothSelector As Func(Of T, T, TResult),
+ comparer As IComparer(Of TKey)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T, typename TKey, typename TResult>
+static IEnumerable<TResult>^ OrderedMerge(
+ IEnumerable<T>^ first,
+ IEnumerable<T>^ second,
+ Func<T, TKey>^ keySelector,
+ Func<T, TResult>^ firstSelector,
+ Func<T, TResult>^ secondSelector,
+ Func<T, T, TResult>^ bothSelector,
+ IComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member OrderedMerge :
+ first : IEnumerable<'T> *
+ second : IEnumerable<'T> *
+ keySelector : Func<'T, 'TKey> *
+ firstSelector : Func<'T, 'TResult> *
+ secondSelector : Func<'T, 'TResult> *
+ bothSelector : Func<'T, 'T, 'TResult> *
+ comparer : IComparer<'TKey> -> IEnumerable<'TResult> public static IEnumerable<TResult> OrderedMerge<TFirst, TSecond, TKey, TResult>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TKey> firstKeySelector,
+ Func<TSecond, TKey> secondKeySelector,
+ Func<TFirst, TResult> firstSelector,
+ Func<TSecond, TResult> secondSelector,
+ Func<TFirst, TSecond, TResult> bothSelector
+)
+<ExtensionAttribute>
+Public Shared Function OrderedMerge(Of TFirst, TSecond, TKey, TResult) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ firstKeySelector As Func(Of TFirst, TKey),
+ secondKeySelector As Func(Of TSecond, TKey),
+ firstSelector As Func(Of TFirst, TResult),
+ secondSelector As Func(Of TSecond, TResult),
+ bothSelector As Func(Of TFirst, TSecond, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TKey, typename TResult>
+static IEnumerable<TResult>^ OrderedMerge(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TKey>^ firstKeySelector,
+ Func<TSecond, TKey>^ secondKeySelector,
+ Func<TFirst, TResult>^ firstSelector,
+ Func<TSecond, TResult>^ secondSelector,
+ Func<TFirst, TSecond, TResult>^ bothSelector
+)[<ExtensionAttribute>]
+static member OrderedMerge :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ firstKeySelector : Func<'TFirst, 'TKey> *
+ secondKeySelector : Func<'TSecond, 'TKey> *
+ firstSelector : Func<'TFirst, 'TResult> *
+ secondSelector : Func<'TSecond, 'TResult> *
+ bothSelector : Func<'TFirst, 'TSecond, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> OrderedMerge<TFirst, TSecond, TKey, TResult>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TKey> firstKeySelector,
+ Func<TSecond, TKey> secondKeySelector,
+ Func<TFirst, TResult> firstSelector,
+ Func<TSecond, TResult> secondSelector,
+ Func<TFirst, TSecond, TResult> bothSelector,
+ IComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function OrderedMerge(Of TFirst, TSecond, TKey, TResult) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ firstKeySelector As Func(Of TFirst, TKey),
+ secondKeySelector As Func(Of TSecond, TKey),
+ firstSelector As Func(Of TFirst, TResult),
+ secondSelector As Func(Of TSecond, TResult),
+ bothSelector As Func(Of TFirst, TSecond, TResult),
+ comparer As IComparer(Of TKey)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TKey, typename TResult>
+static IEnumerable<TResult>^ OrderedMerge(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TKey>^ firstKeySelector,
+ Func<TSecond, TKey>^ secondKeySelector,
+ Func<TFirst, TResult>^ firstSelector,
+ Func<TSecond, TResult>^ secondSelector,
+ Func<TFirst, TSecond, TResult>^ bothSelector,
+ IComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member OrderedMerge :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ firstKeySelector : Func<'TFirst, 'TKey> *
+ secondKeySelector : Func<'TSecond, 'TKey> *
+ firstSelector : Func<'TFirst, 'TResult> *
+ secondSelector : Func<'TSecond, 'TResult> *
+ bothSelector : Func<'TFirst, 'TSecond, 'TResult> *
+ comparer : IComparer<'TKey> -> IEnumerable<'TResult> public static IEnumerable<TSource> Pad<TSource>(
+ this IEnumerable<TSource> source,
+ int width
+)
+<ExtensionAttribute>
+Public Shared Function Pad(Of TSource) (
+ source As IEnumerable(Of TSource),
+ width As Integer
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ Pad(
+ IEnumerable<TSource>^ source,
+ int width
+)[<ExtensionAttribute>]
+static member Pad :
+ source : IEnumerable<'TSource> *
+ width : int -> IEnumerable<'TSource> int[] numbers = { 123, 456, 789 };
+var result = numbers.Pad(5);public static IEnumerable<TSource> Pad<TSource>(
+ this IEnumerable<TSource> source,
+ int width,
+ Func<int, TSource> paddingSelector
+)
+<ExtensionAttribute>
+Public Shared Function Pad(Of TSource) (
+ source As IEnumerable(Of TSource),
+ width As Integer,
+ paddingSelector As Func(Of Integer, TSource)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ Pad(
+ IEnumerable<TSource>^ source,
+ int width,
+ Func<int, TSource>^ paddingSelector
+)[<ExtensionAttribute>]
+static member Pad :
+ source : IEnumerable<'TSource> *
+ width : int *
+ paddingSelector : Func<int, 'TSource> -> IEnumerable<'TSource> int[] numbers = { 0, 1, 2 };
+var result = numbers.Pad(5, i => -i);public static IEnumerable<TSource> Pad<TSource>(
+ this IEnumerable<TSource> source,
+ int width,
+ TSource padding
+)
+<ExtensionAttribute>
+Public Shared Function Pad(Of TSource) (
+ source As IEnumerable(Of TSource),
+ width As Integer,
+ padding As TSource
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ Pad(
+ IEnumerable<TSource>^ source,
+ int width,
+ TSource padding
+)[<ExtensionAttribute>]
+static member Pad :
+ source : IEnumerable<'TSource> *
+ width : int *
+ padding : 'TSource -> IEnumerable<'TSource> int[] numbers = { 123, 456, 789 };
+var result = numbers.Pad(5, -1);public static IEnumerable<TSource> PadStart<TSource>(
+ this IEnumerable<TSource> source,
+ int width
+)
+<ExtensionAttribute>
+Public Shared Function PadStart(Of TSource) (
+ source As IEnumerable(Of TSource),
+ width As Integer
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ PadStart(
+ IEnumerable<TSource>^ source,
+ int width
+)[<ExtensionAttribute>]
+static member PadStart :
+ source : IEnumerable<'TSource> *
+ width : int -> IEnumerable<'TSource> int[] numbers = { 123, 456, 789 };
+var result = numbers.PadStart(5);public static IEnumerable<TSource> PadStart<TSource>(
+ this IEnumerable<TSource> source,
+ int width,
+ Func<int, TSource> paddingSelector
+)
+<ExtensionAttribute>
+Public Shared Function PadStart(Of TSource) (
+ source As IEnumerable(Of TSource),
+ width As Integer,
+ paddingSelector As Func(Of Integer, TSource)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ PadStart(
+ IEnumerable<TSource>^ source,
+ int width,
+ Func<int, TSource>^ paddingSelector
+)[<ExtensionAttribute>]
+static member PadStart :
+ source : IEnumerable<'TSource> *
+ width : int *
+ paddingSelector : Func<int, 'TSource> -> IEnumerable<'TSource> int[] numbers = { 123, 456, 789 };
+var result = numbers.PadStart(6, i => -i);public static IEnumerable<TSource> PadStart<TSource>(
+ this IEnumerable<TSource> source,
+ int width,
+ TSource padding
+)
+<ExtensionAttribute>
+Public Shared Function PadStart(Of TSource) (
+ source As IEnumerable(Of TSource),
+ width As Integer,
+ padding As TSource
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ PadStart(
+ IEnumerable<TSource>^ source,
+ int width,
+ TSource padding
+)[<ExtensionAttribute>]
+static member PadStart :
+ source : IEnumerable<'TSource> *
+ width : int *
+ padding : 'TSource -> IEnumerable<'TSource> int[] numbers = { 123, 456, 789 };
+var result = numbers.PadStart(5, -1);public static IEnumerable<TResult> Pairwise<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TSource, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Pairwise(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ resultSelector As Func(Of TSource, TSource, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ Pairwise(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TSource, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Pairwise :
+ source : IEnumerable<'TSource> *
+ resultSelector : Func<'TSource, 'TSource, 'TResult> -> IEnumerable<'TResult> var source = new[] { "a", "b", "c", "d" };
+var result = source.Pairwise((a, b) => a + b);public static IEnumerable<TSource> PartialSortBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ int count,
+ Func<TSource, TKey> keySelector
+)
+<ExtensionAttribute>
+Public Shared Function PartialSortBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ count As Integer,
+ keySelector As Func(Of TSource, TKey)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<TSource>^ PartialSortBy(
+ IEnumerable<TSource>^ source,
+ int count,
+ Func<TSource, TKey>^ keySelector
+)[<ExtensionAttribute>]
+static member PartialSortBy :
+ source : IEnumerable<'TSource> *
+ count : int *
+ keySelector : Func<'TSource, 'TKey> -> IEnumerable<'TSource> public static IEnumerable<TSource> PartialSortBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ int count,
+ Func<TSource, TKey> keySelector,
+ OrderByDirection direction
+)
+<ExtensionAttribute>
+Public Shared Function PartialSortBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ count As Integer,
+ keySelector As Func(Of TSource, TKey),
+ direction As OrderByDirection
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<TSource>^ PartialSortBy(
+ IEnumerable<TSource>^ source,
+ int count,
+ Func<TSource, TKey>^ keySelector,
+ OrderByDirection direction
+)[<ExtensionAttribute>]
+static member PartialSortBy :
+ source : IEnumerable<'TSource> *
+ count : int *
+ keySelector : Func<'TSource, 'TKey> *
+ direction : OrderByDirection -> IEnumerable<'TSource> public static IEnumerable<TSource> PartialSortBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ int count,
+ Func<TSource, TKey> keySelector,
+ IComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function PartialSortBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ count As Integer,
+ keySelector As Func(Of TSource, TKey),
+ comparer As IComparer(Of TKey)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<TSource>^ PartialSortBy(
+ IEnumerable<TSource>^ source,
+ int count,
+ Func<TSource, TKey>^ keySelector,
+ IComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member PartialSortBy :
+ source : IEnumerable<'TSource> *
+ count : int *
+ keySelector : Func<'TSource, 'TKey> *
+ comparer : IComparer<'TKey> -> IEnumerable<'TSource> public static IEnumerable<TSource> PartialSortBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ int count,
+ Func<TSource, TKey> keySelector,
+ IComparer<TKey>? comparer,
+ OrderByDirection direction
+)
+<ExtensionAttribute>
+Public Shared Function PartialSortBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ count As Integer,
+ keySelector As Func(Of TSource, TKey),
+ comparer As IComparer(Of TKey),
+ direction As OrderByDirection
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<TSource>^ PartialSortBy(
+ IEnumerable<TSource>^ source,
+ int count,
+ Func<TSource, TKey>^ keySelector,
+ IComparer<TKey>^ comparer,
+ OrderByDirection direction
+)[<ExtensionAttribute>]
+static member PartialSortBy :
+ source : IEnumerable<'TSource> *
+ count : int *
+ keySelector : Func<'TSource, 'TKey> *
+ comparer : IComparer<'TKey> *
+ direction : OrderByDirection -> IEnumerable<'TSource> public static IEnumerable<T> PartialSort<T>(
+ this IEnumerable<T> source,
+ int count
+)
+<ExtensionAttribute>
+Public Shared Function PartialSort(Of T) (
+ source As IEnumerable(Of T),
+ count As Integer
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ PartialSort(
+ IEnumerable<T>^ source,
+ int count
+)[<ExtensionAttribute>]
+static member PartialSort :
+ source : IEnumerable<'T> *
+ count : int -> IEnumerable<'T> public static IEnumerable<T> PartialSort<T>(
+ this IEnumerable<T> source,
+ int count,
+ OrderByDirection direction
+)
+<ExtensionAttribute>
+Public Shared Function PartialSort(Of T) (
+ source As IEnumerable(Of T),
+ count As Integer,
+ direction As OrderByDirection
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ PartialSort(
+ IEnumerable<T>^ source,
+ int count,
+ OrderByDirection direction
+)[<ExtensionAttribute>]
+static member PartialSort :
+ source : IEnumerable<'T> *
+ count : int *
+ direction : OrderByDirection -> IEnumerable<'T> public static IEnumerable<T> PartialSort<T>(
+ this IEnumerable<T> source,
+ int count,
+ IComparer<T>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function PartialSort(Of T) (
+ source As IEnumerable(Of T),
+ count As Integer,
+ comparer As IComparer(Of T)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ PartialSort(
+ IEnumerable<T>^ source,
+ int count,
+ IComparer<T>^ comparer
+)[<ExtensionAttribute>]
+static member PartialSort :
+ source : IEnumerable<'T> *
+ count : int *
+ comparer : IComparer<'T> -> IEnumerable<'T> public static IEnumerable<T> PartialSort<T>(
+ this IEnumerable<T> source,
+ int count,
+ IComparer<T>? comparer,
+ OrderByDirection direction
+)
+<ExtensionAttribute>
+Public Shared Function PartialSort(Of T) (
+ source As IEnumerable(Of T),
+ count As Integer,
+ comparer As IComparer(Of T),
+ direction As OrderByDirection
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ PartialSort(
+ IEnumerable<T>^ source,
+ int count,
+ IComparer<T>^ comparer,
+ OrderByDirection direction
+)[<ExtensionAttribute>]
+static member PartialSort :
+ source : IEnumerable<'T> *
+ count : int *
+ comparer : IComparer<'T> *
+ direction : OrderByDirection -> IEnumerable<'T> public static (IEnumerable<T> True, IEnumerable<T> False) Partition<T>(
+ this IEnumerable<T> source,
+ Func<T, bool> predicate
+)
+<ExtensionAttribute>
+Public Shared Function Partition(Of T) (
+ source As IEnumerable(Of T),
+ predicate As Func(Of T, Boolean)
+) As (True As IEnumerable(Of T), False As IEnumerable(Of T))public:
+[ExtensionAttribute]
+generic<typename T>
+static ValueTuple<IEnumerable<T>^, IEnumerable<T>^> Partition(
+ IEnumerable<T>^ source,
+ Func<T, bool>^ predicate
+)[<ExtensionAttribute>]
+static member Partition :
+ source : IEnumerable<'T> *
+ predicate : Func<'T, bool> -> ValueTuple<IEnumerable<'T>, IEnumerable<'T>> var (evens, odds) =
+ Enumerable.Range(0, 10).Partition(x => x % 2 == 0);| ArgumentNullException | source is + . |
public static TResult Partition<T, TResult>(
+ this IEnumerable<IGrouping<bool, T>> source,
+ Func<IEnumerable<T>, IEnumerable<T>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Partition(Of T, TResult) (
+ source As IEnumerable(Of IGrouping(Of Boolean, T)),
+ resultSelector As Func(Of IEnumerable(Of T), IEnumerable(Of T), TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Partition(
+ IEnumerable<IGrouping<bool, T>^>^ source,
+ Func<IEnumerable<T>^, IEnumerable<T>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Partition :
+ source : IEnumerable<IGrouping<bool, 'T>> *
+ resultSelector : Func<IEnumerable<'T>, IEnumerable<'T>, 'TResult> -> 'TResult | ArgumentNullException | source or resultSelector is + . + |
public static TResult Partition<T, TResult>(
+ this IEnumerable<IGrouping<bool?, T>> source,
+ Func<IEnumerable<T>, IEnumerable<T>, IEnumerable<T>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Partition(Of T, TResult) (
+ source As IEnumerable(Of IGrouping(Of Boolean?, T)),
+ resultSelector As Func(Of IEnumerable(Of T), IEnumerable(Of T), IEnumerable(Of T), TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Partition(
+ IEnumerable<IGrouping<Nullable<bool>, T>^>^ source,
+ Func<IEnumerable<T>^, IEnumerable<T>^, IEnumerable<T>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Partition :
+ source : IEnumerable<IGrouping<Nullable<bool>, 'T>> *
+ resultSelector : Func<IEnumerable<'T>, IEnumerable<'T>, IEnumerable<'T>, 'TResult> -> 'TResult | ArgumentNullException | source or resultSelector is + . + |
public static TResult Partition<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, bool> predicate,
+ Func<IEnumerable<T>, IEnumerable<T>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Partition(Of T, TResult) (
+ source As IEnumerable(Of T),
+ predicate As Func(Of T, Boolean),
+ resultSelector As Func(Of IEnumerable(Of T), IEnumerable(Of T), TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Partition(
+ IEnumerable<T>^ source,
+ Func<T, bool>^ predicate,
+ Func<IEnumerable<T>^, IEnumerable<T>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Partition :
+ source : IEnumerable<'T> *
+ predicate : Func<'T, bool> *
+ resultSelector : Func<IEnumerable<'T>, IEnumerable<'T>, 'TResult> -> 'TResult var (evens, odds) =
+ Enumerable.Range(0, 10)
+ .Partition(x => x % 2 == 0, ValueTuple.Create);| ArgumentNullException | source, predicate, or + resultSelector is . + |
public static TResult Partition<TKey, TElement, TResult>(
+ this IEnumerable<IGrouping<TKey, TElement>> source,
+ TKey key,
+ IEqualityComparer<TKey>? comparer,
+ Func<IEnumerable<TElement>, IEnumerable<IGrouping<TKey, TElement>>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Partition(Of TKey, TElement, TResult) (
+ source As IEnumerable(Of IGrouping(Of TKey, TElement)),
+ key As TKey,
+ comparer As IEqualityComparer(Of TKey),
+ resultSelector As Func(Of IEnumerable(Of TElement), IEnumerable(Of IGrouping(Of TKey, TElement)), TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename TKey, typename TElement, typename TResult>
+static TResult Partition(
+ IEnumerable<IGrouping<TKey, TElement>^>^ source,
+ TKey key,
+ IEqualityComparer<TKey>^ comparer,
+ Func<IEnumerable<TElement>^, IEnumerable<IGrouping<TKey, TElement>^>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Partition :
+ source : IEnumerable<IGrouping<'TKey, 'TElement>> *
+ key : 'TKey *
+ comparer : IEqualityComparer<'TKey> *
+ resultSelector : Func<IEnumerable<'TElement>, IEnumerable<IGrouping<'TKey, 'TElement>>, 'TResult> -> 'TResult | ArgumentNullException | source or resultSelector is + . + |
public static TResult Partition<TKey, TElement, TResult>(
+ this IEnumerable<IGrouping<TKey, TElement>> source,
+ TKey key,
+ Func<IEnumerable<TElement>, IEnumerable<IGrouping<TKey, TElement>>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Partition(Of TKey, TElement, TResult) (
+ source As IEnumerable(Of IGrouping(Of TKey, TElement)),
+ key As TKey,
+ resultSelector As Func(Of IEnumerable(Of TElement), IEnumerable(Of IGrouping(Of TKey, TElement)), TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename TKey, typename TElement, typename TResult>
+static TResult Partition(
+ IEnumerable<IGrouping<TKey, TElement>^>^ source,
+ TKey key,
+ Func<IEnumerable<TElement>^, IEnumerable<IGrouping<TKey, TElement>^>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Partition :
+ source : IEnumerable<IGrouping<'TKey, 'TElement>> *
+ key : 'TKey *
+ resultSelector : Func<IEnumerable<'TElement>, IEnumerable<IGrouping<'TKey, 'TElement>>, 'TResult> -> 'TResult | ArgumentNullException | source or resultSelector is + . + |
public static TResult Partition<TKey, TElement, TResult>(
+ this IEnumerable<IGrouping<TKey, TElement>> source,
+ TKey key1,
+ TKey key2,
+ IEqualityComparer<TKey>? comparer,
+ Func<IEnumerable<TElement>, IEnumerable<TElement>, IEnumerable<IGrouping<TKey, TElement>>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Partition(Of TKey, TElement, TResult) (
+ source As IEnumerable(Of IGrouping(Of TKey, TElement)),
+ key1 As TKey,
+ key2 As TKey,
+ comparer As IEqualityComparer(Of TKey),
+ resultSelector As Func(Of IEnumerable(Of TElement), IEnumerable(Of TElement), IEnumerable(Of IGrouping(Of TKey, TElement)), TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename TKey, typename TElement, typename TResult>
+static TResult Partition(
+ IEnumerable<IGrouping<TKey, TElement>^>^ source,
+ TKey key1,
+ TKey key2,
+ IEqualityComparer<TKey>^ comparer,
+ Func<IEnumerable<TElement>^, IEnumerable<TElement>^, IEnumerable<IGrouping<TKey, TElement>^>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Partition :
+ source : IEnumerable<IGrouping<'TKey, 'TElement>> *
+ key1 : 'TKey *
+ key2 : 'TKey *
+ comparer : IEqualityComparer<'TKey> *
+ resultSelector : Func<IEnumerable<'TElement>, IEnumerable<'TElement>, IEnumerable<IGrouping<'TKey, 'TElement>>, 'TResult> -> 'TResult | ArgumentNullException | source or resultSelector is + . + |
public static TResult Partition<TKey, TElement, TResult>(
+ this IEnumerable<IGrouping<TKey, TElement>> source,
+ TKey key1,
+ TKey key2,
+ Func<IEnumerable<TElement>, IEnumerable<TElement>, IEnumerable<IGrouping<TKey, TElement>>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Partition(Of TKey, TElement, TResult) (
+ source As IEnumerable(Of IGrouping(Of TKey, TElement)),
+ key1 As TKey,
+ key2 As TKey,
+ resultSelector As Func(Of IEnumerable(Of TElement), IEnumerable(Of TElement), IEnumerable(Of IGrouping(Of TKey, TElement)), TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename TKey, typename TElement, typename TResult>
+static TResult Partition(
+ IEnumerable<IGrouping<TKey, TElement>^>^ source,
+ TKey key1,
+ TKey key2,
+ Func<IEnumerable<TElement>^, IEnumerable<TElement>^, IEnumerable<IGrouping<TKey, TElement>^>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Partition :
+ source : IEnumerable<IGrouping<'TKey, 'TElement>> *
+ key1 : 'TKey *
+ key2 : 'TKey *
+ resultSelector : Func<IEnumerable<'TElement>, IEnumerable<'TElement>, IEnumerable<IGrouping<'TKey, 'TElement>>, 'TResult> -> 'TResult | ArgumentNullException | source or resultSelector is + . + |
public static TResult Partition<TKey, TElement, TResult>(
+ this IEnumerable<IGrouping<TKey, TElement>> source,
+ TKey key1,
+ TKey key2,
+ TKey key3,
+ IEqualityComparer<TKey>? comparer,
+ Func<IEnumerable<TElement>, IEnumerable<TElement>, IEnumerable<TElement>, IEnumerable<IGrouping<TKey, TElement>>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Partition(Of TKey, TElement, TResult) (
+ source As IEnumerable(Of IGrouping(Of TKey, TElement)),
+ key1 As TKey,
+ key2 As TKey,
+ key3 As TKey,
+ comparer As IEqualityComparer(Of TKey),
+ resultSelector As Func(Of IEnumerable(Of TElement), IEnumerable(Of TElement), IEnumerable(Of TElement), IEnumerable(Of IGrouping(Of TKey, TElement)), TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename TKey, typename TElement, typename TResult>
+static TResult Partition(
+ IEnumerable<IGrouping<TKey, TElement>^>^ source,
+ TKey key1,
+ TKey key2,
+ TKey key3,
+ IEqualityComparer<TKey>^ comparer,
+ Func<IEnumerable<TElement>^, IEnumerable<TElement>^, IEnumerable<TElement>^, IEnumerable<IGrouping<TKey, TElement>^>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Partition :
+ source : IEnumerable<IGrouping<'TKey, 'TElement>> *
+ key1 : 'TKey *
+ key2 : 'TKey *
+ key3 : 'TKey *
+ comparer : IEqualityComparer<'TKey> *
+ resultSelector : Func<IEnumerable<'TElement>, IEnumerable<'TElement>, IEnumerable<'TElement>, IEnumerable<IGrouping<'TKey, 'TElement>>, 'TResult> -> 'TResult | ArgumentNullException | source or resultSelector is + . + |
public static TResult Partition<TKey, TElement, TResult>(
+ this IEnumerable<IGrouping<TKey, TElement>> source,
+ TKey key1,
+ TKey key2,
+ TKey key3,
+ Func<IEnumerable<TElement>, IEnumerable<TElement>, IEnumerable<TElement>, IEnumerable<IGrouping<TKey, TElement>>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Partition(Of TKey, TElement, TResult) (
+ source As IEnumerable(Of IGrouping(Of TKey, TElement)),
+ key1 As TKey,
+ key2 As TKey,
+ key3 As TKey,
+ resultSelector As Func(Of IEnumerable(Of TElement), IEnumerable(Of TElement), IEnumerable(Of TElement), IEnumerable(Of IGrouping(Of TKey, TElement)), TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename TKey, typename TElement, typename TResult>
+static TResult Partition(
+ IEnumerable<IGrouping<TKey, TElement>^>^ source,
+ TKey key1,
+ TKey key2,
+ TKey key3,
+ Func<IEnumerable<TElement>^, IEnumerable<TElement>^, IEnumerable<TElement>^, IEnumerable<IGrouping<TKey, TElement>^>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Partition :
+ source : IEnumerable<IGrouping<'TKey, 'TElement>> *
+ key1 : 'TKey *
+ key2 : 'TKey *
+ key3 : 'TKey *
+ resultSelector : Func<IEnumerable<'TElement>, IEnumerable<'TElement>, IEnumerable<'TElement>, IEnumerable<IGrouping<'TKey, 'TElement>>, 'TResult> -> 'TResult | ArgumentNullException | source or resultSelector is + . + |
public static IEnumerable<IList<T>> Permutations<T>(
+ this IEnumerable<T> sequence
+)
+<ExtensionAttribute>
+Public Shared Function Permutations(Of T) (
+ sequence As IEnumerable(Of T)
+) As IEnumerable(Of IList(Of T))public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<IList<T>^>^ Permutations(
+ IEnumerable<T>^ sequence
+)[<ExtensionAttribute>]
+static member Permutations :
+ sequence : IEnumerable<'T> -> IEnumerable<IList<'T>> + A permutation is a unique re-ordering of the elements of the sequence.
+ 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().
+ Be aware that the original sequence is considered one of the permutations and will be + returned as one of the results.
public static IEnumerable<T> Pipe<T>(
+ this IEnumerable<T> source,
+ Action<T> action
+)
+<ExtensionAttribute>
+Public Shared Function Pipe(Of T) (
+ source As IEnumerable(Of T),
+ action As Action(Of T)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Pipe(
+ IEnumerable<T>^ source,
+ Action<T>^ action
+)[<ExtensionAttribute>]
+static member Pipe :
+ source : IEnumerable<'T> *
+ action : Action<'T> -> IEnumerable<'T> public static IEnumerable<TSource> PreScan<TSource>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TSource, TSource> transformation,
+ TSource identity
+)
+<ExtensionAttribute>
+Public Shared Function PreScan(Of TSource) (
+ source As IEnumerable(Of TSource),
+ transformation As Func(Of TSource, TSource, TSource),
+ identity As TSource
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ PreScan(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TSource, TSource>^ transformation,
+ TSource identity
+)[<ExtensionAttribute>]
+static member PreScan :
+ source : IEnumerable<'TSource> *
+ transformation : Func<'TSource, 'TSource, 'TSource> *
+ identity : 'TSource -> IEnumerable<'TSource> 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);public static IEnumerable<TSource> Prepend<TSource>(
+ this IEnumerable<TSource> source,
+ TSource value
+)
+<ExtensionAttribute>
+Public Shared Function Prepend(Of TSource) (
+ source As IEnumerable(Of TSource),
+ value As TSource
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ Prepend(
+ IEnumerable<TSource>^ source,
+ TSource value
+)[<ExtensionAttribute>]
+static member Prepend :
+ source : IEnumerable<'TSource> *
+ value : 'TSource -> IEnumerable<'TSource> public static IEnumerable<T> RandomSubset<T>(
+ this IEnumerable<T> source,
+ int subsetSize
+)
+<ExtensionAttribute>
+Public Shared Function RandomSubset(Of T) (
+ source As IEnumerable(Of T),
+ subsetSize As Integer
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ RandomSubset(
+ IEnumerable<T>^ source,
+ int subsetSize
+)[<ExtensionAttribute>]
+static member RandomSubset :
+ source : IEnumerable<'T> *
+ subsetSize : int -> IEnumerable<'T> public static IEnumerable<T> RandomSubset<T>(
+ this IEnumerable<T> source,
+ int subsetSize,
+ Random rand
+)
+<ExtensionAttribute>
+Public Shared Function RandomSubset(Of T) (
+ source As IEnumerable(Of T),
+ subsetSize As Integer,
+ rand As Random
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ RandomSubset(
+ IEnumerable<T>^ source,
+ int subsetSize,
+ Random^ rand
+)[<ExtensionAttribute>]
+static member RandomSubset :
+ source : IEnumerable<'T> *
+ subsetSize : int *
+ rand : Random -> IEnumerable<'T> public static IEnumerable<int> RankBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector
+)
+<ExtensionAttribute>
+Public Shared Function RankBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey)
+) As IEnumerable(Of Integer)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<int>^ RankBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector
+)[<ExtensionAttribute>]
+static member RankBy :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> -> IEnumerable<int> public static IEnumerable<int> RankBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector,
+ IComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function RankBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ comparer As IComparer(Of TKey)
+) As IEnumerable(Of Integer)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<int>^ RankBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector,
+ IComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member RankBy :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ comparer : IComparer<'TKey> -> IEnumerable<int> public static IEnumerable<int> Rank<TSource>(
+ this IEnumerable<TSource> source
+)
+<ExtensionAttribute>
+Public Shared Function Rank(Of TSource) (
+ source As IEnumerable(Of TSource)
+) As IEnumerable(Of Integer)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<int>^ Rank(
+ IEnumerable<TSource>^ source
+)[<ExtensionAttribute>]
+static member Rank :
+ source : IEnumerable<'TSource> -> IEnumerable<int> public static IEnumerable<int> Rank<TSource>(
+ this IEnumerable<TSource> source,
+ IComparer<TSource>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function Rank(Of TSource) (
+ source As IEnumerable(Of TSource),
+ comparer As IComparer(Of TSource)
+) As IEnumerable(Of Integer)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<int>^ Rank(
+ IEnumerable<TSource>^ source,
+ IComparer<TSource>^ comparer
+)[<ExtensionAttribute>]
+static member Rank :
+ source : IEnumerable<'TSource> *
+ comparer : IComparer<'TSource> -> IEnumerable<int> public static IEnumerable<T> Repeat<T>(
+ this IEnumerable<T> sequence
+)
+<ExtensionAttribute>
+Public Shared Function Repeat(Of T) (
+ sequence As IEnumerable(Of T)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Repeat(
+ IEnumerable<T>^ sequence
+)[<ExtensionAttribute>]
+static member Repeat :
+ sequence : IEnumerable<'T> -> IEnumerable<'T> public static IEnumerable<T> Repeat<T>(
+ this IEnumerable<T> sequence,
+ int count
+)
+<ExtensionAttribute>
+Public Shared Function Repeat(Of T) (
+ sequence As IEnumerable(Of T),
+ count As Integer
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Repeat(
+ IEnumerable<T>^ sequence,
+ int count
+)[<ExtensionAttribute>]
+static member Repeat :
+ sequence : IEnumerable<'T> *
+ count : int -> IEnumerable<'T> public static IEnumerable<TResult> RightJoin<TSource, TKey, TResult>(
+ this IEnumerable<TSource> first,
+ IEnumerable<TSource> second,
+ Func<TSource, TKey> keySelector,
+ Func<TSource, TResult> secondSelector,
+ Func<TSource, TSource, TResult> bothSelector
+)
+<ExtensionAttribute>
+Public Shared Function RightJoin(Of TSource, TKey, TResult) (
+ first As IEnumerable(Of TSource),
+ second As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ secondSelector As Func(Of TSource, TResult),
+ bothSelector As Func(Of TSource, TSource, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey, typename TResult>
+static IEnumerable<TResult>^ RightJoin(
+ IEnumerable<TSource>^ first,
+ IEnumerable<TSource>^ second,
+ Func<TSource, TKey>^ keySelector,
+ Func<TSource, TResult>^ secondSelector,
+ Func<TSource, TSource, TResult>^ bothSelector
+)[<ExtensionAttribute>]
+static member RightJoin :
+ first : IEnumerable<'TSource> *
+ second : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ secondSelector : Func<'TSource, 'TResult> *
+ bothSelector : Func<'TSource, 'TSource, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> RightJoin<TSource, TKey, TResult>(
+ this IEnumerable<TSource> first,
+ IEnumerable<TSource> second,
+ Func<TSource, TKey> keySelector,
+ Func<TSource, TResult> secondSelector,
+ Func<TSource, TSource, TResult> bothSelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function RightJoin(Of TSource, TKey, TResult) (
+ first As IEnumerable(Of TSource),
+ second As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ secondSelector As Func(Of TSource, TResult),
+ bothSelector As Func(Of TSource, TSource, TResult),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey, typename TResult>
+static IEnumerable<TResult>^ RightJoin(
+ IEnumerable<TSource>^ first,
+ IEnumerable<TSource>^ second,
+ Func<TSource, TKey>^ keySelector,
+ Func<TSource, TResult>^ secondSelector,
+ Func<TSource, TSource, TResult>^ bothSelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member RightJoin :
+ first : IEnumerable<'TSource> *
+ second : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ secondSelector : Func<'TSource, 'TResult> *
+ bothSelector : Func<'TSource, 'TSource, 'TResult> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<'TResult> public static IEnumerable<TResult> RightJoin<TFirst, TSecond, TKey, TResult>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TKey> firstKeySelector,
+ Func<TSecond, TKey> secondKeySelector,
+ Func<TSecond, TResult> secondSelector,
+ Func<TFirst, TSecond, TResult> bothSelector
+)
+<ExtensionAttribute>
+Public Shared Function RightJoin(Of TFirst, TSecond, TKey, TResult) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ firstKeySelector As Func(Of TFirst, TKey),
+ secondKeySelector As Func(Of TSecond, TKey),
+ secondSelector As Func(Of TSecond, TResult),
+ bothSelector As Func(Of TFirst, TSecond, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TKey, typename TResult>
+static IEnumerable<TResult>^ RightJoin(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TKey>^ firstKeySelector,
+ Func<TSecond, TKey>^ secondKeySelector,
+ Func<TSecond, TResult>^ secondSelector,
+ Func<TFirst, TSecond, TResult>^ bothSelector
+)[<ExtensionAttribute>]
+static member RightJoin :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ firstKeySelector : Func<'TFirst, 'TKey> *
+ secondKeySelector : Func<'TSecond, 'TKey> *
+ secondSelector : Func<'TSecond, 'TResult> *
+ bothSelector : Func<'TFirst, 'TSecond, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> RightJoin<TFirst, TSecond, TKey, TResult>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TKey> firstKeySelector,
+ Func<TSecond, TKey> secondKeySelector,
+ Func<TSecond, TResult> secondSelector,
+ Func<TFirst, TSecond, TResult> bothSelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function RightJoin(Of TFirst, TSecond, TKey, TResult) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ firstKeySelector As Func(Of TFirst, TKey),
+ secondKeySelector As Func(Of TSecond, TKey),
+ secondSelector As Func(Of TSecond, TResult),
+ bothSelector As Func(Of TFirst, TSecond, TResult),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TKey, typename TResult>
+static IEnumerable<TResult>^ RightJoin(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TKey>^ firstKeySelector,
+ Func<TSecond, TKey>^ secondKeySelector,
+ Func<TSecond, TResult>^ secondSelector,
+ Func<TFirst, TSecond, TResult>^ bothSelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member RightJoin :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ firstKeySelector : Func<'TFirst, 'TKey> *
+ secondKeySelector : Func<'TSecond, 'TKey> *
+ secondSelector : Func<'TSecond, 'TResult> *
+ bothSelector : Func<'TFirst, 'TSecond, 'TResult> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<'TResult> public static IEnumerable<KeyValuePair<T, int>> RunLengthEncode<T>(
+ this IEnumerable<T> sequence
+)
+<ExtensionAttribute>
+Public Shared Function RunLengthEncode(Of T) (
+ sequence As IEnumerable(Of T)
+) As IEnumerable(Of KeyValuePair(Of T, Integer))public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<KeyValuePair<T, int>>^ RunLengthEncode(
+ IEnumerable<T>^ sequence
+)[<ExtensionAttribute>]
+static member RunLengthEncode :
+ sequence : IEnumerable<'T> -> IEnumerable<KeyValuePair<'T, int>> public static IEnumerable<KeyValuePair<T, int>> RunLengthEncode<T>(
+ this IEnumerable<T> sequence,
+ IEqualityComparer<T>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function RunLengthEncode(Of T) (
+ sequence As IEnumerable(Of T),
+ comparer As IEqualityComparer(Of T)
+) As IEnumerable(Of KeyValuePair(Of T, Integer))public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<KeyValuePair<T, int>>^ RunLengthEncode(
+ IEnumerable<T>^ sequence,
+ IEqualityComparer<T>^ comparer
+)[<ExtensionAttribute>]
+static member RunLengthEncode :
+ sequence : IEnumerable<'T> *
+ comparer : IEqualityComparer<'T> -> IEnumerable<KeyValuePair<'T, int>> public static IEnumerable<KeyValuePair<TKey, TState>> ScanBy<TSource, TKey, TState>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector,
+ Func<TKey, TState> seedSelector,
+ Func<TState, TKey, TSource, TState> accumulator
+)
+<ExtensionAttribute>
+Public Shared Function ScanBy(Of TSource, TKey, TState) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ seedSelector As Func(Of TKey, TState),
+ accumulator As Func(Of TState, TKey, TSource, TState)
+) As IEnumerable(Of KeyValuePair(Of TKey, TState))public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey, typename TState>
+static IEnumerable<KeyValuePair<TKey, TState>>^ ScanBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector,
+ Func<TKey, TState>^ seedSelector,
+ Func<TState, TKey, TSource, TState>^ accumulator
+)[<ExtensionAttribute>]
+static member ScanBy :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ seedSelector : Func<'TKey, 'TState> *
+ accumulator : Func<'TState, 'TKey, 'TSource, 'TState> -> IEnumerable<KeyValuePair<'TKey, 'TState>> public static IEnumerable<KeyValuePair<TKey, TState>> ScanBy<TSource, TKey, TState>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector,
+ Func<TKey, TState> seedSelector,
+ Func<TState, TKey, TSource, TState> accumulator,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function ScanBy(Of TSource, TKey, TState) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ seedSelector As Func(Of TKey, TState),
+ accumulator As Func(Of TState, TKey, TSource, TState),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of KeyValuePair(Of TKey, TState))public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey, typename TState>
+static IEnumerable<KeyValuePair<TKey, TState>>^ ScanBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector,
+ Func<TKey, TState>^ seedSelector,
+ Func<TState, TKey, TSource, TState>^ accumulator,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member ScanBy :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ seedSelector : Func<'TKey, 'TState> *
+ accumulator : Func<'TState, 'TKey, 'TSource, 'TState> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<KeyValuePair<'TKey, 'TState>> public static IEnumerable<TSource> Scan<TSource>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TSource, TSource> transformation
+)
+<ExtensionAttribute>
+Public Shared Function Scan(Of TSource) (
+ source As IEnumerable(Of TSource),
+ transformation As Func(Of TSource, TSource, TSource)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ Scan(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TSource, TSource>^ transformation
+)[<ExtensionAttribute>]
+static member Scan :
+ source : IEnumerable<'TSource> *
+ transformation : Func<'TSource, 'TSource, 'TSource> -> IEnumerable<'TSource> 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);public static IEnumerable<TState> Scan<TSource, TState>(
+ this IEnumerable<TSource> source,
+ TState seed,
+ Func<TState, TSource, TState> transformation
+)
+<ExtensionAttribute>
+Public Shared Function Scan(Of TSource, TState) (
+ source As IEnumerable(Of TSource),
+ seed As TState,
+ transformation As Func(Of TState, TSource, TState)
+) As IEnumerable(Of TState)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TState>
+static IEnumerable<TState>^ Scan(
+ IEnumerable<TSource>^ source,
+ TState seed,
+ Func<TState, TSource, TState>^ transformation
+)[<ExtensionAttribute>]
+static member Scan :
+ source : IEnumerable<'TSource> *
+ seed : 'TState *
+ transformation : Func<'TState, 'TSource, 'TState> -> IEnumerable<'TState> var result = Enumerable.Range(1, 5).Scan(0, (a, b) => a + b);public static IEnumerable<TSource> ScanRight<TSource>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TSource, TSource> func
+)
+<ExtensionAttribute>
+Public Shared Function ScanRight(Of TSource) (
+ source As IEnumerable(Of TSource),
+ func As Func(Of TSource, TSource, TSource)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ ScanRight(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TSource, TSource>^ func
+)[<ExtensionAttribute>]
+static member ScanRight :
+ source : IEnumerable<'TSource> *
+ func : Func<'TSource, 'TSource, 'TSource> -> IEnumerable<'TSource> var result = Enumerable.Range(1, 5).Select(i => i.ToString()).ScanRight((a, b) => $"({a}+{b})");public static IEnumerable<TAccumulate> ScanRight<TSource, TAccumulate>(
+ this IEnumerable<TSource> source,
+ TAccumulate seed,
+ Func<TSource, TAccumulate, TAccumulate> func
+)
+<ExtensionAttribute>
+Public Shared Function ScanRight(Of TSource, TAccumulate) (
+ source As IEnumerable(Of TSource),
+ seed As TAccumulate,
+ func As Func(Of TSource, TAccumulate, TAccumulate)
+) As IEnumerable(Of TAccumulate)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TAccumulate>
+static IEnumerable<TAccumulate>^ ScanRight(
+ IEnumerable<TSource>^ source,
+ TAccumulate seed,
+ Func<TSource, TAccumulate, TAccumulate>^ func
+)[<ExtensionAttribute>]
+static member ScanRight :
+ source : IEnumerable<'TSource> *
+ seed : 'TAccumulate *
+ func : Func<'TSource, 'TAccumulate, 'TAccumulate> -> IEnumerable<'TAccumulate> var result = Enumerable.Range(1, 4).ScanRight("5", (a, b) => $"({a}+{b})");public static IEnumerable<IEnumerable<T>> Segment<T>(
+ this IEnumerable<T> source,
+ Func<T, bool> newSegmentPredicate
+)
+<ExtensionAttribute>
+Public Shared Function Segment(Of T) (
+ source As IEnumerable(Of T),
+ newSegmentPredicate As Func(Of T, Boolean)
+) As IEnumerable(Of IEnumerable(Of T))public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<IEnumerable<T>^>^ Segment(
+ IEnumerable<T>^ source,
+ Func<T, bool>^ newSegmentPredicate
+)[<ExtensionAttribute>]
+static member Segment :
+ source : IEnumerable<'T> *
+ newSegmentPredicate : Func<'T, bool> -> IEnumerable<IEnumerable<'T>> | ArgumentNullException | + Thrown if either source or newSegmentPredicate are . + |
public static IEnumerable<IEnumerable<T>> Segment<T>(
+ this IEnumerable<T> source,
+ Func<T, int, bool> newSegmentPredicate
+)
+<ExtensionAttribute>
+Public Shared Function Segment(Of T) (
+ source As IEnumerable(Of T),
+ newSegmentPredicate As Func(Of T, Integer, Boolean)
+) As IEnumerable(Of IEnumerable(Of T))public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<IEnumerable<T>^>^ Segment(
+ IEnumerable<T>^ source,
+ Func<T, int, bool>^ newSegmentPredicate
+)[<ExtensionAttribute>]
+static member Segment :
+ source : IEnumerable<'T> *
+ newSegmentPredicate : Func<'T, int, bool> -> IEnumerable<IEnumerable<'T>> | ArgumentNullException | + Thrown if either source or newSegmentPredicate are . + |
public static IEnumerable<IEnumerable<T>> Segment<T>(
+ this IEnumerable<T> source,
+ Func<T, T, int, bool> newSegmentPredicate
+)
+<ExtensionAttribute>
+Public Shared Function Segment(Of T) (
+ source As IEnumerable(Of T),
+ newSegmentPredicate As Func(Of T, T, Integer, Boolean)
+) As IEnumerable(Of IEnumerable(Of T))public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<IEnumerable<T>^>^ Segment(
+ IEnumerable<T>^ source,
+ Func<T, T, int, bool>^ newSegmentPredicate
+)[<ExtensionAttribute>]
+static member Segment :
+ source : IEnumerable<'T> *
+ newSegmentPredicate : Func<'T, 'T, int, bool> -> IEnumerable<IEnumerable<'T>> | ArgumentNullException | + Thrown if either source or newSegmentPredicate are . + |
public static IEnumerable<T> Shuffle<T>(
+ this IEnumerable<T> source
+)
+<ExtensionAttribute>
+Public Shared Function Shuffle(Of T) (
+ source As IEnumerable(Of T)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Shuffle(
+ IEnumerable<T>^ source
+)[<ExtensionAttribute>]
+static member Shuffle :
+ source : IEnumerable<'T> -> IEnumerable<'T> public static IEnumerable<T> Shuffle<T>(
+ this IEnumerable<T> source,
+ Random rand
+)
+<ExtensionAttribute>
+Public Shared Function Shuffle(Of T) (
+ source As IEnumerable(Of T),
+ rand As Random
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Shuffle(
+ IEnumerable<T>^ source,
+ Random^ rand
+)[<ExtensionAttribute>]
+static member Shuffle :
+ source : IEnumerable<'T> *
+ rand : Random -> IEnumerable<'T> public static T Single<T>(
+ this IExtremaEnumerable<T> source
+)
+<ExtensionAttribute>
+Public Shared Function Single(Of T) (
+ source As IExtremaEnumerable(Of T)
+) As Tpublic:
+[ExtensionAttribute]
+generic<typename T>
+static T Single(
+ IExtremaEnumerable<T>^ source
+)[<ExtensionAttribute>]
+static member Single :
+ source : IExtremaEnumerable<'T> -> 'T | InvalidOperationException | + The input sequence contains more than one element. |
public static T SingleOrDefault<T>(
+ this IExtremaEnumerable<T> source
+)
+<ExtensionAttribute>
+Public Shared Function SingleOrDefault(Of T) (
+ source As IExtremaEnumerable(Of T)
+) As Tpublic:
+[ExtensionAttribute]
+generic<typename T>
+static T SingleOrDefault(
+ IExtremaEnumerable<T>^ source
+)[<ExtensionAttribute>]
+static member SingleOrDefault :
+ source : IExtremaEnumerable<'T> -> 'T public static IEnumerable<T> SkipLast<T>(
+ this IEnumerable<T> source,
+ int count
+)
+<ExtensionAttribute>
+Public Shared Function SkipLast(Of T) (
+ source As IEnumerable(Of T),
+ count As Integer
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ SkipLast(
+ IEnumerable<T>^ source,
+ int count
+)[<ExtensionAttribute>]
+static member SkipLast :
+ source : IEnumerable<'T> *
+ count : int -> IEnumerable<'T> public static IEnumerable<TSource> SkipUntil<TSource>(
+ this IEnumerable<TSource> source,
+ Func<TSource, bool> predicate
+)
+<ExtensionAttribute>
+Public Shared Function SkipUntil(Of TSource) (
+ source As IEnumerable(Of TSource),
+ predicate As Func(Of TSource, Boolean)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ SkipUntil(
+ IEnumerable<TSource>^ source,
+ Func<TSource, bool>^ predicate
+)[<ExtensionAttribute>]
+static member SkipUntil :
+ source : IEnumerable<'TSource> *
+ predicate : Func<'TSource, bool> -> IEnumerable<'TSource> + SkipUntil differs from Enumerable.SkipWhile in two respects. Firstly, the sense + of the predicate is reversed: it is expected that the predicate will return false + to start with, and then return true - for example, when trying to find a matching + item in a sequence. +
+ Secondly, SkipUntil skips the element which causes the predicate to return true. For + example, in a sequence
{ 1, 2, 3, 4, 5 }x => x == 3{ 4, 5 }+ SkipUntil is as lazy as possible: it will not iterate over the source sequence + until it has to, it won't iterate further than it has to, and it won't evaluate + the predicate until it has to. (This means that an item may be returned which would + actually cause the predicate to throw an exception if it were evaluated, so long as + it comes after the first item causing the predicate to return true.) +
| ArgumentNullException | source or predicate is null |
public static IEnumerable<T> Slice<T>(
+ this IEnumerable<T> sequence,
+ int startIndex,
+ int count
+)
+<ExtensionAttribute>
+Public Shared Function Slice(Of T) (
+ sequence As IEnumerable(Of T),
+ startIndex As Integer,
+ count As Integer
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Slice(
+ IEnumerable<T>^ sequence,
+ int startIndex,
+ int count
+)[<ExtensionAttribute>]
+static member Slice :
+ sequence : IEnumerable<'T> *
+ startIndex : int *
+ count : int -> IEnumerable<'T> + 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 count.
+ This method is implemented in an optimized manner for any sequence implementing IListT.
+ The result of SliceT(IEnumerableT, Int32, Int32) is identical to: + sequence.Skip(startIndex).Take(count)
public static IEnumerable<TSource> SortedMerge<TSource>(
+ this IEnumerable<TSource> source,
+ OrderByDirection direction,
+ IComparer<TSource>? comparer,
+ params IEnumerable<TSource>[] otherSequences
+)
+<ExtensionAttribute>
+Public Shared Function SortedMerge(Of TSource) (
+ source As IEnumerable(Of TSource),
+ direction As OrderByDirection,
+ comparer As IComparer(Of TSource),
+ ParamArray otherSequences As IEnumerable(Of TSource)()
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ SortedMerge(
+ IEnumerable<TSource>^ source,
+ OrderByDirection direction,
+ IComparer<TSource>^ comparer,
+ ... array<IEnumerable<TSource>^>^ otherSequences
+)[<ExtensionAttribute>]
+static member SortedMerge :
+ source : IEnumerable<'TSource> *
+ direction : OrderByDirection *
+ comparer : IComparer<'TSource> *
+ otherSequences : IEnumerable<'TSource>[] -> IEnumerable<'TSource> public static IEnumerable<TSource> SortedMerge<TSource>(
+ this IEnumerable<TSource> source,
+ OrderByDirection direction,
+ params IEnumerable<TSource>[] otherSequences
+)
+<ExtensionAttribute>
+Public Shared Function SortedMerge(Of TSource) (
+ source As IEnumerable(Of TSource),
+ direction As OrderByDirection,
+ ParamArray otherSequences As IEnumerable(Of TSource)()
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ SortedMerge(
+ IEnumerable<TSource>^ source,
+ OrderByDirection direction,
+ ... array<IEnumerable<TSource>^>^ otherSequences
+)[<ExtensionAttribute>]
+static member SortedMerge :
+ source : IEnumerable<'TSource> *
+ direction : OrderByDirection *
+ otherSequences : IEnumerable<'TSource>[] -> IEnumerable<'TSource> + Using SortedMergeTSource(IEnumerableTSource, OrderByDirection, IEnumerableTSource) + on sequences that are not ordered or are not in the same order produces undefined + results.
SortedMergeTSource(IEnumerableTSource, OrderByDirection, IEnumerableTSource) + uses performs the merge in a deferred, streaming manner.
+ Here is an example of a merge, as well as the produced result:
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 }public static IEnumerable<IEnumerable<TSource>> Split<TSource>(
+ this IEnumerable<TSource> source,
+ Func<TSource, bool> separatorFunc
+)
+<ExtensionAttribute>
+Public Shared Function Split(Of TSource) (
+ source As IEnumerable(Of TSource),
+ separatorFunc As Func(Of TSource, Boolean)
+) As IEnumerable(Of IEnumerable(Of TSource))public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<IEnumerable<TSource>^>^ Split(
+ IEnumerable<TSource>^ source,
+ Func<TSource, bool>^ separatorFunc
+)[<ExtensionAttribute>]
+static member Split :
+ source : IEnumerable<'TSource> *
+ separatorFunc : Func<'TSource, bool> -> IEnumerable<IEnumerable<'TSource>> public static IEnumerable<IEnumerable<TSource>> Split<TSource>(
+ this IEnumerable<TSource> source,
+ Func<TSource, bool> separatorFunc,
+ int count
+)
+<ExtensionAttribute>
+Public Shared Function Split(Of TSource) (
+ source As IEnumerable(Of TSource),
+ separatorFunc As Func(Of TSource, Boolean),
+ count As Integer
+) As IEnumerable(Of IEnumerable(Of TSource))public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<IEnumerable<TSource>^>^ Split(
+ IEnumerable<TSource>^ source,
+ Func<TSource, bool>^ separatorFunc,
+ int count
+)[<ExtensionAttribute>]
+static member Split :
+ source : IEnumerable<'TSource> *
+ separatorFunc : Func<'TSource, bool> *
+ count : int -> IEnumerable<IEnumerable<'TSource>> public static IEnumerable<IEnumerable<TSource>> Split<TSource>(
+ this IEnumerable<TSource> source,
+ TSource separator
+)
+<ExtensionAttribute>
+Public Shared Function Split(Of TSource) (
+ source As IEnumerable(Of TSource),
+ separator As TSource
+) As IEnumerable(Of IEnumerable(Of TSource))public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<IEnumerable<TSource>^>^ Split(
+ IEnumerable<TSource>^ source,
+ TSource separator
+)[<ExtensionAttribute>]
+static member Split :
+ source : IEnumerable<'TSource> *
+ separator : 'TSource -> IEnumerable<IEnumerable<'TSource>> public static IEnumerable<IEnumerable<TSource>> Split<TSource>(
+ this IEnumerable<TSource> source,
+ TSource separator,
+ IEqualityComparer<TSource>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function Split(Of TSource) (
+ source As IEnumerable(Of TSource),
+ separator As TSource,
+ comparer As IEqualityComparer(Of TSource)
+) As IEnumerable(Of IEnumerable(Of TSource))public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<IEnumerable<TSource>^>^ Split(
+ IEnumerable<TSource>^ source,
+ TSource separator,
+ IEqualityComparer<TSource>^ comparer
+)[<ExtensionAttribute>]
+static member Split :
+ source : IEnumerable<'TSource> *
+ separator : 'TSource *
+ comparer : IEqualityComparer<'TSource> -> IEnumerable<IEnumerable<'TSource>> public static IEnumerable<IEnumerable<TSource>> Split<TSource>(
+ this IEnumerable<TSource> source,
+ TSource separator,
+ IEqualityComparer<TSource>? comparer,
+ int count
+)
+<ExtensionAttribute>
+Public Shared Function Split(Of TSource) (
+ source As IEnumerable(Of TSource),
+ separator As TSource,
+ comparer As IEqualityComparer(Of TSource),
+ count As Integer
+) As IEnumerable(Of IEnumerable(Of TSource))public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<IEnumerable<TSource>^>^ Split(
+ IEnumerable<TSource>^ source,
+ TSource separator,
+ IEqualityComparer<TSource>^ comparer,
+ int count
+)[<ExtensionAttribute>]
+static member Split :
+ source : IEnumerable<'TSource> *
+ separator : 'TSource *
+ comparer : IEqualityComparer<'TSource> *
+ count : int -> IEnumerable<IEnumerable<'TSource>> public static IEnumerable<IEnumerable<TSource>> Split<TSource>(
+ this IEnumerable<TSource> source,
+ TSource separator,
+ int count
+)
+<ExtensionAttribute>
+Public Shared Function Split(Of TSource) (
+ source As IEnumerable(Of TSource),
+ separator As TSource,
+ count As Integer
+) As IEnumerable(Of IEnumerable(Of TSource))public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<IEnumerable<TSource>^>^ Split(
+ IEnumerable<TSource>^ source,
+ TSource separator,
+ int count
+)[<ExtensionAttribute>]
+static member Split :
+ source : IEnumerable<'TSource> *
+ separator : 'TSource *
+ count : int -> IEnumerable<IEnumerable<'TSource>> public static IEnumerable<TResult> Split<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ Func<TSource, bool> separatorFunc,
+ Func<IEnumerable<TSource>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Split(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ separatorFunc As Func(Of TSource, Boolean),
+ resultSelector As Func(Of IEnumerable(Of TSource), TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ Split(
+ IEnumerable<TSource>^ source,
+ Func<TSource, bool>^ separatorFunc,
+ Func<IEnumerable<TSource>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Split :
+ source : IEnumerable<'TSource> *
+ separatorFunc : Func<'TSource, bool> *
+ resultSelector : Func<IEnumerable<'TSource>, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> Split<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ Func<TSource, bool> separatorFunc,
+ int count,
+ Func<IEnumerable<TSource>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Split(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ separatorFunc As Func(Of TSource, Boolean),
+ count As Integer,
+ resultSelector As Func(Of IEnumerable(Of TSource), TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ Split(
+ IEnumerable<TSource>^ source,
+ Func<TSource, bool>^ separatorFunc,
+ int count,
+ Func<IEnumerable<TSource>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Split :
+ source : IEnumerable<'TSource> *
+ separatorFunc : Func<'TSource, bool> *
+ count : int *
+ resultSelector : Func<IEnumerable<'TSource>, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> Split<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ TSource separator,
+ IEqualityComparer<TSource> comparer,
+ Func<IEnumerable<TSource>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Split(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ separator As TSource,
+ comparer As IEqualityComparer(Of TSource),
+ resultSelector As Func(Of IEnumerable(Of TSource), TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ Split(
+ IEnumerable<TSource>^ source,
+ TSource separator,
+ IEqualityComparer<TSource>^ comparer,
+ Func<IEnumerable<TSource>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Split :
+ source : IEnumerable<'TSource> *
+ separator : 'TSource *
+ comparer : IEqualityComparer<'TSource> *
+ resultSelector : Func<IEnumerable<'TSource>, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> Split<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ TSource separator,
+ IEqualityComparer<TSource>? comparer,
+ int count,
+ Func<IEnumerable<TSource>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Split(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ separator As TSource,
+ comparer As IEqualityComparer(Of TSource),
+ count As Integer,
+ resultSelector As Func(Of IEnumerable(Of TSource), TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ Split(
+ IEnumerable<TSource>^ source,
+ TSource separator,
+ IEqualityComparer<TSource>^ comparer,
+ int count,
+ Func<IEnumerable<TSource>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Split :
+ source : IEnumerable<'TSource> *
+ separator : 'TSource *
+ comparer : IEqualityComparer<'TSource> *
+ count : int *
+ resultSelector : Func<IEnumerable<'TSource>, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> Split<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ TSource separator,
+ Func<IEnumerable<TSource>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Split(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ separator As TSource,
+ resultSelector As Func(Of IEnumerable(Of TSource), TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ Split(
+ IEnumerable<TSource>^ source,
+ TSource separator,
+ Func<IEnumerable<TSource>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Split :
+ source : IEnumerable<'TSource> *
+ separator : 'TSource *
+ resultSelector : Func<IEnumerable<'TSource>, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> Split<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ TSource separator,
+ int count,
+ Func<IEnumerable<TSource>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Split(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ separator As TSource,
+ count As Integer,
+ resultSelector As Func(Of IEnumerable(Of TSource), TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ Split(
+ IEnumerable<TSource>^ source,
+ TSource separator,
+ int count,
+ Func<IEnumerable<TSource>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Split :
+ source : IEnumerable<'TSource> *
+ separator : 'TSource *
+ count : int *
+ resultSelector : Func<IEnumerable<'TSource>, 'TResult> -> IEnumerable<'TResult> public static bool StartsWith<T>(
+ this IEnumerable<T> first,
+ IEnumerable<T> second
+)
+<ExtensionAttribute>
+Public Shared Function StartsWith(Of T) (
+ first As IEnumerable(Of T),
+ second As IEnumerable(Of T)
+) As Booleanpublic:
+[ExtensionAttribute]
+generic<typename T>
+static bool StartsWith(
+ IEnumerable<T>^ first,
+ IEnumerable<T>^ second
+)[<ExtensionAttribute>]
+static member StartsWith :
+ first : IEnumerable<'T> *
+ second : IEnumerable<'T> -> bool public static bool StartsWith<T>(
+ this IEnumerable<T> first,
+ IEnumerable<T> second,
+ IEqualityComparer<T>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function StartsWith(Of T) (
+ first As IEnumerable(Of T),
+ second As IEnumerable(Of T),
+ comparer As IEqualityComparer(Of T)
+) As Booleanpublic:
+[ExtensionAttribute]
+generic<typename T>
+static bool StartsWith(
+ IEnumerable<T>^ first,
+ IEnumerable<T>^ second,
+ IEqualityComparer<T>^ comparer
+)[<ExtensionAttribute>]
+static member StartsWith :
+ first : IEnumerable<'T> *
+ second : IEnumerable<'T> *
+ comparer : IEqualityComparer<'T> -> bool public static IEnumerable<IList<T>> Subsets<T>(
+ this IEnumerable<T> sequence
+)
+<ExtensionAttribute>
+Public Shared Function Subsets(Of T) (
+ sequence As IEnumerable(Of T)
+) As IEnumerable(Of IList(Of T))public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<IList<T>^>^ Subsets(
+ IEnumerable<T>^ sequence
+)[<ExtensionAttribute>]
+static member Subsets :
+ sequence : IEnumerable<'T> -> IEnumerable<IList<'T>> + 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.
+ Subsets are produced in a deferred, streaming manner; however, each subset is returned + as a materialized list.
+ There are 2N subsets of a given sequence, where N ⇒ + sequence.Count().
| ArgumentNullException | Thrown if sequence is . |
public static IEnumerable<IList<T>> Subsets<T>(
+ this IEnumerable<T> sequence,
+ int subsetSize
+)
+<ExtensionAttribute>
+Public Shared Function Subsets(Of T) (
+ sequence As IEnumerable(Of T),
+ subsetSize As Integer
+) As IEnumerable(Of IList(Of T))public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<IList<T>^>^ Subsets(
+ IEnumerable<T>^ sequence,
+ int subsetSize
+)[<ExtensionAttribute>]
+static member Subsets :
+ sequence : IEnumerable<'T> *
+ subsetSize : int -> IEnumerable<IList<'T>> | ArgumentNullException | + Thrown if sequence is . + |
| ArgumentOutOfRangeException | + Thrown if subsetSize is less than zero. + |
public static IEnumerable<TResult> TagFirstLast<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ Func<TSource, bool, bool, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function TagFirstLast(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ resultSelector As Func(Of TSource, Boolean, Boolean, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ TagFirstLast(
+ IEnumerable<TSource>^ source,
+ Func<TSource, bool, bool, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member TagFirstLast :
+ source : IEnumerable<'TSource> *
+ resultSelector : Func<'TSource, bool, bool, 'TResult> -> IEnumerable<'TResult> var numbers = new[] { 123, 456, 789 };
+var result = numbers.TagFirstLast((num, fst, lst) => new
+ {
+ Number = num,
+ IsFirst = fst, IsLast = lst
+ });public static IEnumerable<TSource> TakeEvery<TSource>(
+ this IEnumerable<TSource> source,
+ int step
+)
+<ExtensionAttribute>
+Public Shared Function TakeEvery(Of TSource) (
+ source As IEnumerable(Of TSource),
+ step As Integer
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ TakeEvery(
+ IEnumerable<TSource>^ source,
+ int step
+)[<ExtensionAttribute>]
+static member TakeEvery :
+ source : IEnumerable<'TSource> *
+ step : int -> IEnumerable<'TSource> int[] numbers = { 1, 2, 3, 4, 5 };
+var result = numbers.TakeEvery(2);public static IEnumerable<TSource> TakeLast<TSource>(
+ this IEnumerable<TSource> source,
+ int count
+)
+<ExtensionAttribute>
+Public Shared Function TakeLast(Of TSource) (
+ source As IEnumerable(Of TSource),
+ count As Integer
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ TakeLast(
+ IEnumerable<TSource>^ source,
+ int count
+)[<ExtensionAttribute>]
+static member TakeLast :
+ source : IEnumerable<'TSource> *
+ count : int -> IEnumerable<'TSource> int[] numbers = { 12, 34, 56, 78 };
+var result = numbers.TakeLast(2);public static IEnumerable<TSource> TakeUntil<TSource>(
+ this IEnumerable<TSource> source,
+ Func<TSource, bool> predicate
+)
+<ExtensionAttribute>
+Public Shared Function TakeUntil(Of TSource) (
+ source As IEnumerable(Of TSource),
+ predicate As Func(Of TSource, Boolean)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ TakeUntil(
+ IEnumerable<TSource>^ source,
+ Func<TSource, bool>^ predicate
+)[<ExtensionAttribute>]
+static member TakeUntil :
+ source : IEnumerable<'TSource> *
+ predicate : Func<'TSource, bool> -> IEnumerable<'TSource> + TakeUntil differs from Enumerable.TakeWhile in two respects. Firstly, the sense + of the predicate is reversed: it is expected that the predicate will return false + to start with, and then return true - for example, when trying to find a matching + item in a sequence. +
+ Secondly, TakeUntil yields the element which causes the predicate to return true. For + example, in a sequence
{ 1, 2, 3, 4, 5 }x => x == 3{ 1, 2, 3 }+ TakeUntil is as lazy as possible: it will not iterate over the source sequence + until it has to, it won't iterate further than it has to, and it won't evaluate + the predicate until it has to. (This means that an item may be returned which would + actually cause the predicate to throw an exception if it were evaluated, so long as + no more items of data are requested.) +
| ArgumentNullException | source or predicate is null |
public static IOrderedEnumerable<T> ThenBy<T, TKey>(
+ this IOrderedEnumerable<T> source,
+ Func<T, TKey> keySelector,
+ OrderByDirection direction
+)
+<ExtensionAttribute>
+Public Shared Function ThenBy(Of T, TKey) (
+ source As IOrderedEnumerable(Of T),
+ keySelector As Func(Of T, TKey),
+ direction As OrderByDirection
+) As IOrderedEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T, typename TKey>
+static IOrderedEnumerable<T>^ ThenBy(
+ IOrderedEnumerable<T>^ source,
+ Func<T, TKey>^ keySelector,
+ OrderByDirection direction
+)[<ExtensionAttribute>]
+static member ThenBy :
+ source : IOrderedEnumerable<'T> *
+ keySelector : Func<'T, 'TKey> *
+ direction : OrderByDirection -> IOrderedEnumerable<'T> public static IOrderedEnumerable<T> ThenBy<T, TKey>(
+ this IOrderedEnumerable<T> source,
+ Func<T, TKey> keySelector,
+ IComparer<TKey>? comparer,
+ OrderByDirection direction
+)
+<ExtensionAttribute>
+Public Shared Function ThenBy(Of T, TKey) (
+ source As IOrderedEnumerable(Of T),
+ keySelector As Func(Of T, TKey),
+ comparer As IComparer(Of TKey),
+ direction As OrderByDirection
+) As IOrderedEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T, typename TKey>
+static IOrderedEnumerable<T>^ ThenBy(
+ IOrderedEnumerable<T>^ source,
+ Func<T, TKey>^ keySelector,
+ IComparer<TKey>^ comparer,
+ OrderByDirection direction
+)[<ExtensionAttribute>]
+static member ThenBy :
+ source : IOrderedEnumerable<'T> *
+ keySelector : Func<'T, 'TKey> *
+ comparer : IComparer<'TKey> *
+ direction : OrderByDirection -> IOrderedEnumerable<'T> public static T[] ToArrayByIndex<T>(
+ this IEnumerable<T> source,
+ Func<T, int> indexSelector
+)
+<ExtensionAttribute>
+Public Shared Function ToArrayByIndex(Of T) (
+ source As IEnumerable(Of T),
+ indexSelector As Func(Of T, Integer)
+) As T()public:
+[ExtensionAttribute]
+generic<typename T>
+static array<T>^ ToArrayByIndex(
+ IEnumerable<T>^ source,
+ Func<T, int>^ indexSelector
+)[<ExtensionAttribute>]
+static member ToArrayByIndex :
+ source : IEnumerable<'T> *
+ indexSelector : Func<'T, int> -> 'T[] public static T[] ToArrayByIndex<T>(
+ this IEnumerable<T> source,
+ int length,
+ Func<T, int> indexSelector
+)
+<ExtensionAttribute>
+Public Shared Function ToArrayByIndex(Of T) (
+ source As IEnumerable(Of T),
+ length As Integer,
+ indexSelector As Func(Of T, Integer)
+) As T()public:
+[ExtensionAttribute]
+generic<typename T>
+static array<T>^ ToArrayByIndex(
+ IEnumerable<T>^ source,
+ int length,
+ Func<T, int>^ indexSelector
+)[<ExtensionAttribute>]
+static member ToArrayByIndex :
+ source : IEnumerable<'T> *
+ length : int *
+ indexSelector : Func<'T, int> -> 'T[] public static TResult[] ToArrayByIndex<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, int> indexSelector,
+ Func<T, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function ToArrayByIndex(Of T, TResult) (
+ source As IEnumerable(Of T),
+ indexSelector As Func(Of T, Integer),
+ resultSelector As Func(Of T, TResult)
+) As TResult()public:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static array<TResult>^ ToArrayByIndex(
+ IEnumerable<T>^ source,
+ Func<T, int>^ indexSelector,
+ Func<T, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member ToArrayByIndex :
+ source : IEnumerable<'T> *
+ indexSelector : Func<'T, int> *
+ resultSelector : Func<'T, 'TResult> -> 'TResult[] public static TResult[] ToArrayByIndex<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, int> indexSelector,
+ Func<T, int, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function ToArrayByIndex(Of T, TResult) (
+ source As IEnumerable(Of T),
+ indexSelector As Func(Of T, Integer),
+ resultSelector As Func(Of T, Integer, TResult)
+) As TResult()public:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static array<TResult>^ ToArrayByIndex(
+ IEnumerable<T>^ source,
+ Func<T, int>^ indexSelector,
+ Func<T, int, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member ToArrayByIndex :
+ source : IEnumerable<'T> *
+ indexSelector : Func<'T, int> *
+ resultSelector : Func<'T, int, 'TResult> -> 'TResult[] public static TResult[] ToArrayByIndex<T, TResult>(
+ this IEnumerable<T> source,
+ int length,
+ Func<T, int> indexSelector,
+ Func<T, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function ToArrayByIndex(Of T, TResult) (
+ source As IEnumerable(Of T),
+ length As Integer,
+ indexSelector As Func(Of T, Integer),
+ resultSelector As Func(Of T, TResult)
+) As TResult()public:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static array<TResult>^ ToArrayByIndex(
+ IEnumerable<T>^ source,
+ int length,
+ Func<T, int>^ indexSelector,
+ Func<T, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member ToArrayByIndex :
+ source : IEnumerable<'T> *
+ length : int *
+ indexSelector : Func<'T, int> *
+ resultSelector : Func<'T, 'TResult> -> 'TResult[] public static TResult[] ToArrayByIndex<T, TResult>(
+ this IEnumerable<T> source,
+ int length,
+ Func<T, int> indexSelector,
+ Func<T, int, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function ToArrayByIndex(Of T, TResult) (
+ source As IEnumerable(Of T),
+ length As Integer,
+ indexSelector As Func(Of T, Integer),
+ resultSelector As Func(Of T, Integer, TResult)
+) As TResult()public:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static array<TResult>^ ToArrayByIndex(
+ IEnumerable<T>^ source,
+ int length,
+ Func<T, int>^ indexSelector,
+ Func<T, int, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member ToArrayByIndex :
+ source : IEnumerable<'T> *
+ length : int *
+ indexSelector : Func<'T, int> *
+ resultSelector : Func<'T, int, 'TResult> -> 'TResult[] public static DataTable ToDataTable<T>(
+ this IEnumerable<T> source
+)
+<ExtensionAttribute>
+Public Shared Function ToDataTable(Of T) (
+ source As IEnumerable(Of T)
+) As DataTablepublic:
+[ExtensionAttribute]
+generic<typename T>
+static DataTable^ ToDataTable(
+ IEnumerable<T>^ source
+)[<ExtensionAttribute>]
+static member ToDataTable :
+ source : IEnumerable<'T> -> DataTable public static DataTable ToDataTable<T>(
+ this IEnumerable<T> source,
+ params Expression<Func<T, Object?>>[] expressions
+)
+<ExtensionAttribute>
+Public Shared Function ToDataTable(Of T) (
+ source As IEnumerable(Of T),
+ ParamArray expressions As Expression(Of Func(Of T, Object))()
+) As DataTablepublic:
+[ExtensionAttribute]
+generic<typename T>
+static DataTable^ ToDataTable(
+ IEnumerable<T>^ source,
+ ... array<Expression<Func<T, Object^>^>^>^ expressions
+)[<ExtensionAttribute>]
+static member ToDataTable :
+ source : IEnumerable<'T> *
+ expressions : Expression<Func<'T, Object>>[] -> DataTable public static TTable ToDataTable<T, TTable>(
+ this IEnumerable<T> source,
+ TTable table
+)
+where TTable : DataTable
+<ExtensionAttribute>
+Public Shared Function ToDataTable(Of T, TTable As DataTable) (
+ source As IEnumerable(Of T),
+ table As TTable
+) As TTablepublic:
+[ExtensionAttribute]
+generic<typename T, typename TTable>
+where TTable : DataTable
+static TTable ToDataTable(
+ IEnumerable<T>^ source,
+ TTable table
+)[<ExtensionAttribute>]
+static member ToDataTable :
+ source : IEnumerable<'T> *
+ table : 'TTable -> 'TTable when 'TTable : DataTablepublic static TTable ToDataTable<T, TTable>(
+ this IEnumerable<T> source,
+ TTable table,
+ params Expression<Func<T, Object?>>[] expressions
+)
+where TTable : DataTable
+<ExtensionAttribute>
+Public Shared Function ToDataTable(Of T, TTable As DataTable) (
+ source As IEnumerable(Of T),
+ table As TTable,
+ ParamArray expressions As Expression(Of Func(Of T, Object))()
+) As TTablepublic:
+[ExtensionAttribute]
+generic<typename T, typename TTable>
+where TTable : DataTable
+static TTable ToDataTable(
+ IEnumerable<T>^ source,
+ TTable table,
+ ... array<Expression<Func<T, Object^>^>^>^ expressions
+)[<ExtensionAttribute>]
+static member ToDataTable :
+ source : IEnumerable<'T> *
+ table : 'TTable *
+ expressions : Expression<Func<'T, Object>>[] -> 'TTable when 'TTable : DataTablepublic static string ToDelimitedString(
+ this IEnumerable<bool> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of Boolean),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<bool>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<bool> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString(
+ this IEnumerable<byte> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of Byte),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<unsigned char>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<byte> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString(
+ this IEnumerable<string> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of String),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<String^>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<string> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString(
+ this IEnumerable<ushort> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of UShort),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<unsigned short>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<uint16> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString(
+ this IEnumerable<uint> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of UInteger),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<unsigned int>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<uint32> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString(
+ this IEnumerable<ulong> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of ULong),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<unsigned long long>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<uint64> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString(
+ this IEnumerable<char> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of Char),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<wchar_t>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<char> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString(
+ this IEnumerable<decimal> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of Decimal),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<Decimal>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<decimal> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString(
+ this IEnumerable<double> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of Double),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<double>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<float> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString(
+ this IEnumerable<short> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of Short),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<short>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<int16> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString(
+ this IEnumerable<int> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of Integer),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<int>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<int> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString(
+ this IEnumerable<long> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of Long),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<long long>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<int64> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString(
+ this IEnumerable<sbyte> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of SByte),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<signed char>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<sbyte> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString(
+ this IEnumerable<float> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of Single),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<float>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<float32> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString<TSource>(
+ this IEnumerable<TSource> source,
+ string delimiter
+)
+<ExtensionAttribute>
+Public Shared Function ToDelimitedString(Of TSource) (
+ source As IEnumerable(Of TSource),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+generic<typename TSource>
+static String^ ToDelimitedString(
+ IEnumerable<TSource>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<'TSource> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(
+ this IEnumerable<KeyValuePair<TKey, TValue>> source
+)
+<ExtensionAttribute>
+Public Shared Function ToDictionary(Of TKey, TValue) (
+ source As IEnumerable(Of KeyValuePair(Of TKey, TValue))
+) As Dictionary(Of TKey, TValue)public:
+[ExtensionAttribute]
+generic<typename TKey, typename TValue>
+static Dictionary<TKey, TValue>^ ToDictionary(
+ IEnumerable<KeyValuePair<TKey, TValue>>^ source
+)[<ExtensionAttribute>]
+static member ToDictionary :
+ source : IEnumerable<KeyValuePair<'TKey, 'TValue>> -> Dictionary<'TKey, 'TValue> public static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(
+ this IEnumerable<KeyValuePair<TKey, TValue>> source,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function ToDictionary(Of TKey, TValue) (
+ source As IEnumerable(Of KeyValuePair(Of TKey, TValue)),
+ comparer As IEqualityComparer(Of TKey)
+) As Dictionary(Of TKey, TValue)public:
+[ExtensionAttribute]
+generic<typename TKey, typename TValue>
+static Dictionary<TKey, TValue>^ ToDictionary(
+ IEnumerable<KeyValuePair<TKey, TValue>>^ source,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member ToDictionary :
+ source : IEnumerable<KeyValuePair<'TKey, 'TValue>> *
+ comparer : IEqualityComparer<'TKey> -> Dictionary<'TKey, 'TValue> public static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(
+ this IEnumerable<(TKey , TValue )> source
+)
+<ExtensionAttribute>
+Public Shared Function ToDictionary(Of TKey, TValue) (
+ source As IEnumerable(Of ( As TKey, As TValue))
+) As Dictionary(Of TKey, TValue)public:
+[ExtensionAttribute]
+generic<typename TKey, typename TValue>
+static Dictionary<TKey, TValue>^ ToDictionary(
+ IEnumerable<ValueTuple<TKey, TValue>>^ source
+)[<ExtensionAttribute>]
+static member ToDictionary :
+ source : IEnumerable<ValueTuple<'TKey, 'TValue>> -> Dictionary<'TKey, 'TValue> public static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(
+ this IEnumerable<(TKey , TValue )> source,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function ToDictionary(Of TKey, TValue) (
+ source As IEnumerable(Of ( As TKey, As TValue)),
+ comparer As IEqualityComparer(Of TKey)
+) As Dictionary(Of TKey, TValue)public:
+[ExtensionAttribute]
+generic<typename TKey, typename TValue>
+static Dictionary<TKey, TValue>^ ToDictionary(
+ IEnumerable<ValueTuple<TKey, TValue>>^ source,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member ToDictionary :
+ source : IEnumerable<ValueTuple<'TKey, 'TValue>> *
+ comparer : IEqualityComparer<'TKey> -> Dictionary<'TKey, 'TValue> public static HashSet<TSource> ToHashSet<TSource>(
+ this IEnumerable<TSource> source
+)
+<ExtensionAttribute>
+Public Shared Function ToHashSet(Of TSource) (
+ source As IEnumerable(Of TSource)
+) As HashSet(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static HashSet<TSource>^ ToHashSet(
+ IEnumerable<TSource>^ source
+)[<ExtensionAttribute>]
+static member ToHashSet :
+ source : IEnumerable<'TSource> -> HashSet<'TSource> | ArgumentNullException | source is null |
public static HashSet<TSource> ToHashSet<TSource>(
+ this IEnumerable<TSource> source,
+ IEqualityComparer<TSource>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function ToHashSet(Of TSource) (
+ source As IEnumerable(Of TSource),
+ comparer As IEqualityComparer(Of TSource)
+) As HashSet(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static HashSet<TSource>^ ToHashSet(
+ IEnumerable<TSource>^ source,
+ IEqualityComparer<TSource>^ comparer
+)[<ExtensionAttribute>]
+static member ToHashSet :
+ source : IEnumerable<'TSource> *
+ comparer : IEqualityComparer<'TSource> -> HashSet<'TSource> | ArgumentNullException | source is null |
public static ILookup<TKey, TValue> ToLookup<TKey, TValue>(
+ this IEnumerable<KeyValuePair<TKey, TValue>> source
+)
+<ExtensionAttribute>
+Public Shared Function ToLookup(Of TKey, TValue) (
+ source As IEnumerable(Of KeyValuePair(Of TKey, TValue))
+) As ILookup(Of TKey, TValue)public:
+[ExtensionAttribute]
+generic<typename TKey, typename TValue>
+static ILookup<TKey, TValue>^ ToLookup(
+ IEnumerable<KeyValuePair<TKey, TValue>>^ source
+)[<ExtensionAttribute>]
+static member ToLookup :
+ source : IEnumerable<KeyValuePair<'TKey, 'TValue>> -> ILookup<'TKey, 'TValue> public static ILookup<TKey, TValue> ToLookup<TKey, TValue>(
+ this IEnumerable<KeyValuePair<TKey, TValue>> source,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function ToLookup(Of TKey, TValue) (
+ source As IEnumerable(Of KeyValuePair(Of TKey, TValue)),
+ comparer As IEqualityComparer(Of TKey)
+) As ILookup(Of TKey, TValue)public:
+[ExtensionAttribute]
+generic<typename TKey, typename TValue>
+static ILookup<TKey, TValue>^ ToLookup(
+ IEnumerable<KeyValuePair<TKey, TValue>>^ source,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member ToLookup :
+ source : IEnumerable<KeyValuePair<'TKey, 'TValue>> *
+ comparer : IEqualityComparer<'TKey> -> ILookup<'TKey, 'TValue> public static ILookup<TKey, TValue> ToLookup<TKey, TValue>(
+ this IEnumerable<(TKey , TValue )> source
+)
+<ExtensionAttribute>
+Public Shared Function ToLookup(Of TKey, TValue) (
+ source As IEnumerable(Of ( As TKey, As TValue))
+) As ILookup(Of TKey, TValue)public:
+[ExtensionAttribute]
+generic<typename TKey, typename TValue>
+static ILookup<TKey, TValue>^ ToLookup(
+ IEnumerable<ValueTuple<TKey, TValue>>^ source
+)[<ExtensionAttribute>]
+static member ToLookup :
+ source : IEnumerable<ValueTuple<'TKey, 'TValue>> -> ILookup<'TKey, 'TValue> public static ILookup<TKey, TValue> ToLookup<TKey, TValue>(
+ this IEnumerable<(TKey , TValue )> source,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function ToLookup(Of TKey, TValue) (
+ source As IEnumerable(Of ( As TKey, As TValue)),
+ comparer As IEqualityComparer(Of TKey)
+) As ILookup(Of TKey, TValue)public:
+[ExtensionAttribute]
+generic<typename TKey, typename TValue>
+static ILookup<TKey, TValue>^ ToLookup(
+ IEnumerable<ValueTuple<TKey, TValue>>^ source,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member ToLookup :
+ source : IEnumerable<ValueTuple<'TKey, 'TValue>> *
+ comparer : IEqualityComparer<'TKey> -> ILookup<'TKey, 'TValue> public static IEnumerable<TSource> Trace<TSource>(
+ this IEnumerable<TSource> source
+)
+<ExtensionAttribute>
+Public Shared Function Trace(Of TSource) (
+ source As IEnumerable(Of TSource)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ Trace(
+ IEnumerable<TSource>^ source
+)[<ExtensionAttribute>]
+static member Trace :
+ source : IEnumerable<'TSource> -> IEnumerable<'TSource> public static IEnumerable<TSource> Trace<TSource>(
+ this IEnumerable<TSource> source,
+ Func<TSource, string> formatter
+)
+<ExtensionAttribute>
+Public Shared Function Trace(Of TSource) (
+ source As IEnumerable(Of TSource),
+ formatter As Func(Of TSource, String)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ Trace(
+ IEnumerable<TSource>^ source,
+ Func<TSource, String^>^ formatter
+)[<ExtensionAttribute>]
+static member Trace :
+ source : IEnumerable<'TSource> *
+ formatter : Func<'TSource, string> -> IEnumerable<'TSource> public static IEnumerable<TSource> Trace<TSource>(
+ this IEnumerable<TSource> source,
+ string? format
+)
+<ExtensionAttribute>
+Public Shared Function Trace(Of TSource) (
+ source As IEnumerable(Of TSource),
+ format As String
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ Trace(
+ IEnumerable<TSource>^ source,
+ String^ format
+)[<ExtensionAttribute>]
+static member Trace :
+ source : IEnumerable<'TSource> *
+ format : string -> IEnumerable<'TSource> public static IEnumerable<IEnumerable<T>> Transpose<T>(
+ this IEnumerable<IEnumerable<T>> source
+)
+<ExtensionAttribute>
+Public Shared Function Transpose(Of T) (
+ source As IEnumerable(Of IEnumerable(Of T))
+) As IEnumerable(Of IEnumerable(Of T))public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<IEnumerable<T>^>^ Transpose(
+ IEnumerable<IEnumerable<T>^>^ source
+)[<ExtensionAttribute>]
+static member Transpose :
+ source : IEnumerable<IEnumerable<'T>> -> IEnumerable<IEnumerable<'T>> var matrix = new[]
+{
+ new[] { 10, 11 },
+ new[] { 20 },
+ new[] { 30, 31, 32 }
+};
+var result = matrix.Transpose();public static IEnumerable<IList<TSource>> Window<TSource>(
+ this IEnumerable<TSource> source,
+ int size
+)
+<ExtensionAttribute>
+Public Shared Function Window(Of TSource) (
+ source As IEnumerable(Of TSource),
+ size As Integer
+) As IEnumerable(Of IList(Of TSource))public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<IList<TSource>^>^ Window(
+ IEnumerable<TSource>^ source,
+ int size
+)[<ExtensionAttribute>]
+static member Window :
+ source : IEnumerable<'TSource> *
+ size : int -> IEnumerable<IList<'TSource>> + The number of sequences returned is: Max(0, sequence.Count() - windowSize) + + 1
+ Returned sub-sequences are buffered, but the overall operation is streamed.
public static IEnumerable<IList<TSource>> WindowLeft<TSource>(
+ this IEnumerable<TSource> source,
+ int size
+)
+<ExtensionAttribute>
+Public Shared Function WindowLeft(Of TSource) (
+ source As IEnumerable(Of TSource),
+ size As Integer
+) As IEnumerable(Of IList(Of TSource))public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<IList<TSource>^>^ WindowLeft(
+ IEnumerable<TSource>^ source,
+ int size
+)[<ExtensionAttribute>]
+static member WindowLeft :
+ source : IEnumerable<'TSource> *
+ size : int -> IEnumerable<IList<'TSource>> + A window can contain fewer elements than size, + especially as it slides over the end of the sequence.
+ This operator uses deferred execution and streams its results.
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) = 5public static IEnumerable<IList<TSource>> WindowRight<TSource>(
+ this IEnumerable<TSource> source,
+ int size
+)
+<ExtensionAttribute>
+Public Shared Function WindowRight(Of TSource) (
+ source As IEnumerable(Of TSource),
+ size As Integer
+) As IEnumerable(Of IList(Of TSource))public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<IList<TSource>^>^ WindowRight(
+ IEnumerable<TSource>^ source,
+ int size
+)[<ExtensionAttribute>]
+static member WindowRight :
+ source : IEnumerable<'TSource> *
+ size : int -> IEnumerable<IList<'TSource>> + A window can contain fewer elements than size, + especially as it slides over the start of the sequence.
+ This operator uses deferred execution and streams its results.
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) = 4public static IEnumerable<TResult> ZipLongest<TFirst, TSecond, TResult>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TSecond, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function ZipLongest(Of TFirst, TSecond, TResult) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ resultSelector As Func(Of TFirst, TSecond, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TResult>
+static IEnumerable<TResult>^ ZipLongest(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TSecond, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member ZipLongest :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ resultSelector : Func<'TFirst, 'TSecond, 'TResult> -> IEnumerable<'TResult> var numbers = { 1, 2, 3 };
+var letters = { "A", "B", "C", "D" };
+var zipped = numbers.ZipLongest(letters, (n, l) => n + l);| ArgumentNullException | first, second, or resultSelector is . + |
public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
+ this IEnumerable<T1> first,
+ IEnumerable<T2> second,
+ IEnumerable<T3> third,
+ Func<T1, T2, T3, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function ZipLongest(Of T1, T2, T3, TResult) (
+ first As IEnumerable(Of T1),
+ second As IEnumerable(Of T2),
+ third As IEnumerable(Of T3),
+ resultSelector As Func(Of T1, T2, T3, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T1, typename T2, typename T3, typename TResult>
+static IEnumerable<TResult>^ ZipLongest(
+ IEnumerable<T1>^ first,
+ IEnumerable<T2>^ second,
+ IEnumerable<T3>^ third,
+ Func<T1, T2, T3, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member ZipLongest :
+ first : IEnumerable<'T1> *
+ second : IEnumerable<'T2> *
+ third : IEnumerable<'T3> *
+ resultSelector : Func<'T1, 'T2, 'T3, 'TResult> -> IEnumerable<'TResult> 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);| ArgumentNullException | first, second, third, or resultSelector is . + |
public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
+ this IEnumerable<T1> first,
+ IEnumerable<T2> second,
+ IEnumerable<T3> third,
+ IEnumerable<T4> fourth,
+ Func<T1, T2, T3, T4, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function ZipLongest(Of T1, T2, T3, T4, TResult) (
+ first As IEnumerable(Of T1),
+ second As IEnumerable(Of T2),
+ third As IEnumerable(Of T3),
+ fourth As IEnumerable(Of T4),
+ resultSelector As Func(Of T1, T2, T3, T4, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T1, typename T2, typename T3, typename T4, typename TResult>
+static IEnumerable<TResult>^ ZipLongest(
+ IEnumerable<T1>^ first,
+ IEnumerable<T2>^ second,
+ IEnumerable<T3>^ third,
+ IEnumerable<T4>^ fourth,
+ Func<T1, T2, T3, T4, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member ZipLongest :
+ first : IEnumerable<'T1> *
+ second : IEnumerable<'T2> *
+ third : IEnumerable<'T3> *
+ fourth : IEnumerable<'T4> *
+ resultSelector : Func<'T1, 'T2, 'T3, 'T4, 'TResult> -> IEnumerable<'TResult> 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);| ArgumentNullException | first, second, third, fourth, or resultSelector is . + |
public static IEnumerable<TResult> ZipShortest<TFirst, TSecond, TResult>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TSecond, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function ZipShortest(Of TFirst, TSecond, TResult) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ resultSelector As Func(Of TFirst, TSecond, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TResult>
+static IEnumerable<TResult>^ ZipShortest(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TSecond, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member ZipShortest :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ resultSelector : Func<'TFirst, 'TSecond, 'TResult> -> IEnumerable<'TResult> + 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. +
+ This operator uses deferred execution and streams its results.
var numbers = new[] { 1, 2, 3 };
+var letters = new[] { "A", "B", "C", "D" };
+var zipped = numbers.ZipShortest(letters, (n, l) => n + l);public static IEnumerable<TResult> ZipShortest<T1, T2, T3, TResult>(
+ this IEnumerable<T1> first,
+ IEnumerable<T2> second,
+ IEnumerable<T3> third,
+ Func<T1, T2, T3, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function ZipShortest(Of T1, T2, T3, TResult) (
+ first As IEnumerable(Of T1),
+ second As IEnumerable(Of T2),
+ third As IEnumerable(Of T3),
+ resultSelector As Func(Of T1, T2, T3, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T1, typename T2, typename T3, typename TResult>
+static IEnumerable<TResult>^ ZipShortest(
+ IEnumerable<T1>^ first,
+ IEnumerable<T2>^ second,
+ IEnumerable<T3>^ third,
+ Func<T1, T2, T3, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member ZipShortest :
+ first : IEnumerable<'T1> *
+ second : IEnumerable<'T2> *
+ third : IEnumerable<'T3> *
+ resultSelector : Func<'T1, 'T2, 'T3, 'TResult> -> IEnumerable<'TResult> + 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. +
+ This operator uses deferred execution and streams its results.
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);| ArgumentNullException | first, second, third, or resultSelector is . + |
public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, TResult>(
+ this IEnumerable<T1> first,
+ IEnumerable<T2> second,
+ IEnumerable<T3> third,
+ IEnumerable<T4> fourth,
+ Func<T1, T2, T3, T4, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function ZipShortest(Of T1, T2, T3, T4, TResult) (
+ first As IEnumerable(Of T1),
+ second As IEnumerable(Of T2),
+ third As IEnumerable(Of T3),
+ fourth As IEnumerable(Of T4),
+ resultSelector As Func(Of T1, T2, T3, T4, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T1, typename T2, typename T3, typename T4, typename TResult>
+static IEnumerable<TResult>^ ZipShortest(
+ IEnumerable<T1>^ first,
+ IEnumerable<T2>^ second,
+ IEnumerable<T3>^ third,
+ IEnumerable<T4>^ fourth,
+ Func<T1, T2, T3, T4, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member ZipShortest :
+ first : IEnumerable<'T1> *
+ second : IEnumerable<'T2> *
+ third : IEnumerable<'T3> *
+ fourth : IEnumerable<'T4> *
+ resultSelector : Func<'T1, 'T2, 'T3, 'T4, 'TResult> -> IEnumerable<'TResult> + 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. +
+ This operator uses deferred execution and streams its results.
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);| ArgumentNullException | first, second, third, fourth, or resultSelector is . + |
IEnumerable<T> Take(
+ int count
+)Function Take (
+ count As Integer
+) As IEnumerable(Of T)IEnumerable<T>^ Take(
+ int count
+)abstract Take :
+ count : int -> IEnumerable<'T> IEnumerable<T> TakeLast(
+ int count
+)Function TakeLast (
+ count As Integer
+) As IEnumerable(Of T)IEnumerable<T>^ TakeLast(
+ int count
+)abstract TakeLast :
+ count : int -> IEnumerable<'T> public static TSource[] Acquire<TSource>(
+ this IEnumerable<TSource> source
+)
+where TSource : IDisposable
+<ExtensionAttribute>
+Public Shared Function Acquire(Of TSource As IDisposable) (
+ source As IEnumerable(Of TSource)
+) As TSource()public:
+[ExtensionAttribute]
+generic<typename TSource>
+where TSource : IDisposable
+static array<TSource>^ Acquire(
+ IEnumerable<TSource>^ source
+)[<ExtensionAttribute>]
+static member Acquire :
+ source : IEnumerable<'TSource> -> 'TSource[] when 'TSource : IDisposablepublic static TSource AggregateRight<TSource>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TSource, TSource> func
+)
+<ExtensionAttribute>
+Public Shared Function AggregateRight(Of TSource) (
+ source As IEnumerable(Of TSource),
+ func As Func(Of TSource, TSource, TSource)
+) As TSourcepublic:
+[ExtensionAttribute]
+generic<typename TSource>
+static TSource AggregateRight(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TSource, TSource>^ func
+)[<ExtensionAttribute>]
+static member AggregateRight :
+ source : IEnumerable<'TSource> *
+ func : Func<'TSource, 'TSource, 'TSource> -> 'TSource string result = Enumerable.Range(1, 5).Select(i => i.ToString()).AggregateRight((a, b) => $"({a}/{b})");public static TAccumulate AggregateRight<TSource, TAccumulate>(
+ this IEnumerable<TSource> source,
+ TAccumulate seed,
+ Func<TSource, TAccumulate, TAccumulate> func
+)
+<ExtensionAttribute>
+Public Shared Function AggregateRight(Of TSource, TAccumulate) (
+ source As IEnumerable(Of TSource),
+ seed As TAccumulate,
+ func As Func(Of TSource, TAccumulate, TAccumulate)
+) As TAccumulatepublic:
+[ExtensionAttribute]
+generic<typename TSource, typename TAccumulate>
+static TAccumulate AggregateRight(
+ IEnumerable<TSource>^ source,
+ TAccumulate seed,
+ Func<TSource, TAccumulate, TAccumulate>^ func
+)[<ExtensionAttribute>]
+static member AggregateRight :
+ source : IEnumerable<'TSource> *
+ seed : 'TAccumulate *
+ func : Func<'TSource, 'TAccumulate, 'TAccumulate> -> 'TAccumulate var numbers = Enumerable.Range(1, 5);
+string result = numbers.AggregateRight("6", (a, b) => $"({a}/{b})");public static TResult AggregateRight<TSource, TAccumulate, TResult>(
+ this IEnumerable<TSource> source,
+ TAccumulate seed,
+ Func<TSource, TAccumulate, TAccumulate> func,
+ Func<TAccumulate, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function AggregateRight(Of TSource, TAccumulate, TResult) (
+ source As IEnumerable(Of TSource),
+ seed As TAccumulate,
+ func As Func(Of TSource, TAccumulate, TAccumulate),
+ resultSelector As Func(Of TAccumulate, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename TSource, typename TAccumulate, typename TResult>
+static TResult AggregateRight(
+ IEnumerable<TSource>^ source,
+ TAccumulate seed,
+ Func<TSource, TAccumulate, TAccumulate>^ func,
+ Func<TAccumulate, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member AggregateRight :
+ source : IEnumerable<'TSource> *
+ seed : 'TAccumulate *
+ func : Func<'TSource, 'TAccumulate, 'TAccumulate> *
+ resultSelector : Func<'TAccumulate, 'TResult> -> 'TResult var numbers = Enumerable.Range(1, 5);
+int result = numbers.AggregateRight("6", (a, b) => $"({a}/{b})", str => str.Length);public static TResult Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult>(
+ this IEnumerable<T> source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1> accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2> accumulator2,
+ TAccumulate3 seed3,
+ Func<TAccumulate3, T, TAccumulate3> accumulator3,
+ TAccumulate4 seed4,
+ Func<TAccumulate4, T, TAccumulate4> accumulator4,
+ TAccumulate5 seed5,
+ Func<TAccumulate5, T, TAccumulate5> accumulator5,
+ TAccumulate6 seed6,
+ Func<TAccumulate6, T, TAccumulate6> accumulator6,
+ TAccumulate7 seed7,
+ Func<TAccumulate7, T, TAccumulate7> accumulator7,
+ TAccumulate8 seed8,
+ Func<TAccumulate8, T, TAccumulate8> accumulator8,
+ Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Aggregate(Of T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult) (
+ source As IEnumerable(Of T),
+ seed1 As TAccumulate1,
+ accumulator1 As Func(Of TAccumulate1, T, TAccumulate1),
+ seed2 As TAccumulate2,
+ accumulator2 As Func(Of TAccumulate2, T, TAccumulate2),
+ seed3 As TAccumulate3,
+ accumulator3 As Func(Of TAccumulate3, T, TAccumulate3),
+ seed4 As TAccumulate4,
+ accumulator4 As Func(Of TAccumulate4, T, TAccumulate4),
+ seed5 As TAccumulate5,
+ accumulator5 As Func(Of TAccumulate5, T, TAccumulate5),
+ seed6 As TAccumulate6,
+ accumulator6 As Func(Of TAccumulate6, T, TAccumulate6),
+ seed7 As TAccumulate7,
+ accumulator7 As Func(Of TAccumulate7, T, TAccumulate7),
+ seed8 As TAccumulate8,
+ accumulator8 As Func(Of TAccumulate8, T, TAccumulate8),
+ resultSelector As Func(Of TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TAccumulate1, typename TAccumulate2, typename TAccumulate3, typename TAccumulate4, typename TAccumulate5, typename TAccumulate6, typename TAccumulate7, typename TAccumulate8, typename TResult>
+static TResult Aggregate(
+ IEnumerable<T>^ source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1>^ accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2>^ accumulator2,
+ TAccumulate3 seed3,
+ Func<TAccumulate3, T, TAccumulate3>^ accumulator3,
+ TAccumulate4 seed4,
+ Func<TAccumulate4, T, TAccumulate4>^ accumulator4,
+ TAccumulate5 seed5,
+ Func<TAccumulate5, T, TAccumulate5>^ accumulator5,
+ TAccumulate6 seed6,
+ Func<TAccumulate6, T, TAccumulate6>^ accumulator6,
+ TAccumulate7 seed7,
+ Func<TAccumulate7, T, TAccumulate7>^ accumulator7,
+ TAccumulate8 seed8,
+ Func<TAccumulate8, T, TAccumulate8>^ accumulator8,
+ Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Aggregate :
+ source : IEnumerable<'T> *
+ seed1 : 'TAccumulate1 *
+ accumulator1 : Func<'TAccumulate1, 'T, 'TAccumulate1> *
+ seed2 : 'TAccumulate2 *
+ accumulator2 : Func<'TAccumulate2, 'T, 'TAccumulate2> *
+ seed3 : 'TAccumulate3 *
+ accumulator3 : Func<'TAccumulate3, 'T, 'TAccumulate3> *
+ seed4 : 'TAccumulate4 *
+ accumulator4 : Func<'TAccumulate4, 'T, 'TAccumulate4> *
+ seed5 : 'TAccumulate5 *
+ accumulator5 : Func<'TAccumulate5, 'T, 'TAccumulate5> *
+ seed6 : 'TAccumulate6 *
+ accumulator6 : Func<'TAccumulate6, 'T, 'TAccumulate6> *
+ seed7 : 'TAccumulate7 *
+ accumulator7 : Func<'TAccumulate7, 'T, 'TAccumulate7> *
+ seed8 : 'TAccumulate8 *
+ accumulator8 : Func<'TAccumulate8, 'T, 'TAccumulate8> *
+ resultSelector : Func<'TAccumulate1, 'TAccumulate2, 'TAccumulate3, 'TAccumulate4, 'TAccumulate5, 'TAccumulate6, 'TAccumulate7, 'TAccumulate8, 'TResult> -> 'TResult public static TResult Aggregate<T, TAccumulate1, TAccumulate2, TResult>(
+ this IEnumerable<T> source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1> accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2> accumulator2,
+ Func<TAccumulate1, TAccumulate2, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Aggregate(Of T, TAccumulate1, TAccumulate2, TResult) (
+ source As IEnumerable(Of T),
+ seed1 As TAccumulate1,
+ accumulator1 As Func(Of TAccumulate1, T, TAccumulate1),
+ seed2 As TAccumulate2,
+ accumulator2 As Func(Of TAccumulate2, T, TAccumulate2),
+ resultSelector As Func(Of TAccumulate1, TAccumulate2, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TAccumulate1, typename TAccumulate2, typename TResult>
+static TResult Aggregate(
+ IEnumerable<T>^ source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1>^ accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2>^ accumulator2,
+ Func<TAccumulate1, TAccumulate2, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Aggregate :
+ source : IEnumerable<'T> *
+ seed1 : 'TAccumulate1 *
+ accumulator1 : Func<'TAccumulate1, 'T, 'TAccumulate1> *
+ seed2 : 'TAccumulate2 *
+ accumulator2 : Func<'TAccumulate2, 'T, 'TAccumulate2> *
+ resultSelector : Func<'TAccumulate1, 'TAccumulate2, 'TResult> -> 'TResult public static TResult Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TResult>(
+ this IEnumerable<T> source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1> accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2> accumulator2,
+ TAccumulate3 seed3,
+ Func<TAccumulate3, T, TAccumulate3> accumulator3,
+ Func<TAccumulate1, TAccumulate2, TAccumulate3, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Aggregate(Of T, TAccumulate1, TAccumulate2, TAccumulate3, TResult) (
+ source As IEnumerable(Of T),
+ seed1 As TAccumulate1,
+ accumulator1 As Func(Of TAccumulate1, T, TAccumulate1),
+ seed2 As TAccumulate2,
+ accumulator2 As Func(Of TAccumulate2, T, TAccumulate2),
+ seed3 As TAccumulate3,
+ accumulator3 As Func(Of TAccumulate3, T, TAccumulate3),
+ resultSelector As Func(Of TAccumulate1, TAccumulate2, TAccumulate3, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TAccumulate1, typename TAccumulate2, typename TAccumulate3, typename TResult>
+static TResult Aggregate(
+ IEnumerable<T>^ source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1>^ accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2>^ accumulator2,
+ TAccumulate3 seed3,
+ Func<TAccumulate3, T, TAccumulate3>^ accumulator3,
+ Func<TAccumulate1, TAccumulate2, TAccumulate3, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Aggregate :
+ source : IEnumerable<'T> *
+ seed1 : 'TAccumulate1 *
+ accumulator1 : Func<'TAccumulate1, 'T, 'TAccumulate1> *
+ seed2 : 'TAccumulate2 *
+ accumulator2 : Func<'TAccumulate2, 'T, 'TAccumulate2> *
+ seed3 : 'TAccumulate3 *
+ accumulator3 : Func<'TAccumulate3, 'T, 'TAccumulate3> *
+ resultSelector : Func<'TAccumulate1, 'TAccumulate2, 'TAccumulate3, 'TResult> -> 'TResult public static TResult Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult>(
+ this IEnumerable<T> source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1> accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2> accumulator2,
+ TAccumulate3 seed3,
+ Func<TAccumulate3, T, TAccumulate3> accumulator3,
+ TAccumulate4 seed4,
+ Func<TAccumulate4, T, TAccumulate4> accumulator4,
+ Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Aggregate(Of T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult) (
+ source As IEnumerable(Of T),
+ seed1 As TAccumulate1,
+ accumulator1 As Func(Of TAccumulate1, T, TAccumulate1),
+ seed2 As TAccumulate2,
+ accumulator2 As Func(Of TAccumulate2, T, TAccumulate2),
+ seed3 As TAccumulate3,
+ accumulator3 As Func(Of TAccumulate3, T, TAccumulate3),
+ seed4 As TAccumulate4,
+ accumulator4 As Func(Of TAccumulate4, T, TAccumulate4),
+ resultSelector As Func(Of TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TAccumulate1, typename TAccumulate2, typename TAccumulate3, typename TAccumulate4, typename TResult>
+static TResult Aggregate(
+ IEnumerable<T>^ source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1>^ accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2>^ accumulator2,
+ TAccumulate3 seed3,
+ Func<TAccumulate3, T, TAccumulate3>^ accumulator3,
+ TAccumulate4 seed4,
+ Func<TAccumulate4, T, TAccumulate4>^ accumulator4,
+ Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Aggregate :
+ source : IEnumerable<'T> *
+ seed1 : 'TAccumulate1 *
+ accumulator1 : Func<'TAccumulate1, 'T, 'TAccumulate1> *
+ seed2 : 'TAccumulate2 *
+ accumulator2 : Func<'TAccumulate2, 'T, 'TAccumulate2> *
+ seed3 : 'TAccumulate3 *
+ accumulator3 : Func<'TAccumulate3, 'T, 'TAccumulate3> *
+ seed4 : 'TAccumulate4 *
+ accumulator4 : Func<'TAccumulate4, 'T, 'TAccumulate4> *
+ resultSelector : Func<'TAccumulate1, 'TAccumulate2, 'TAccumulate3, 'TAccumulate4, 'TResult> -> 'TResult public static TResult Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult>(
+ this IEnumerable<T> source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1> accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2> accumulator2,
+ TAccumulate3 seed3,
+ Func<TAccumulate3, T, TAccumulate3> accumulator3,
+ TAccumulate4 seed4,
+ Func<TAccumulate4, T, TAccumulate4> accumulator4,
+ TAccumulate5 seed5,
+ Func<TAccumulate5, T, TAccumulate5> accumulator5,
+ Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Aggregate(Of T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult) (
+ source As IEnumerable(Of T),
+ seed1 As TAccumulate1,
+ accumulator1 As Func(Of TAccumulate1, T, TAccumulate1),
+ seed2 As TAccumulate2,
+ accumulator2 As Func(Of TAccumulate2, T, TAccumulate2),
+ seed3 As TAccumulate3,
+ accumulator3 As Func(Of TAccumulate3, T, TAccumulate3),
+ seed4 As TAccumulate4,
+ accumulator4 As Func(Of TAccumulate4, T, TAccumulate4),
+ seed5 As TAccumulate5,
+ accumulator5 As Func(Of TAccumulate5, T, TAccumulate5),
+ resultSelector As Func(Of TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TAccumulate1, typename TAccumulate2, typename TAccumulate3, typename TAccumulate4, typename TAccumulate5, typename TResult>
+static TResult Aggregate(
+ IEnumerable<T>^ source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1>^ accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2>^ accumulator2,
+ TAccumulate3 seed3,
+ Func<TAccumulate3, T, TAccumulate3>^ accumulator3,
+ TAccumulate4 seed4,
+ Func<TAccumulate4, T, TAccumulate4>^ accumulator4,
+ TAccumulate5 seed5,
+ Func<TAccumulate5, T, TAccumulate5>^ accumulator5,
+ Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Aggregate :
+ source : IEnumerable<'T> *
+ seed1 : 'TAccumulate1 *
+ accumulator1 : Func<'TAccumulate1, 'T, 'TAccumulate1> *
+ seed2 : 'TAccumulate2 *
+ accumulator2 : Func<'TAccumulate2, 'T, 'TAccumulate2> *
+ seed3 : 'TAccumulate3 *
+ accumulator3 : Func<'TAccumulate3, 'T, 'TAccumulate3> *
+ seed4 : 'TAccumulate4 *
+ accumulator4 : Func<'TAccumulate4, 'T, 'TAccumulate4> *
+ seed5 : 'TAccumulate5 *
+ accumulator5 : Func<'TAccumulate5, 'T, 'TAccumulate5> *
+ resultSelector : Func<'TAccumulate1, 'TAccumulate2, 'TAccumulate3, 'TAccumulate4, 'TAccumulate5, 'TResult> -> 'TResult public static TResult Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult>(
+ this IEnumerable<T> source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1> accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2> accumulator2,
+ TAccumulate3 seed3,
+ Func<TAccumulate3, T, TAccumulate3> accumulator3,
+ TAccumulate4 seed4,
+ Func<TAccumulate4, T, TAccumulate4> accumulator4,
+ TAccumulate5 seed5,
+ Func<TAccumulate5, T, TAccumulate5> accumulator5,
+ TAccumulate6 seed6,
+ Func<TAccumulate6, T, TAccumulate6> accumulator6,
+ Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Aggregate(Of T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult) (
+ source As IEnumerable(Of T),
+ seed1 As TAccumulate1,
+ accumulator1 As Func(Of TAccumulate1, T, TAccumulate1),
+ seed2 As TAccumulate2,
+ accumulator2 As Func(Of TAccumulate2, T, TAccumulate2),
+ seed3 As TAccumulate3,
+ accumulator3 As Func(Of TAccumulate3, T, TAccumulate3),
+ seed4 As TAccumulate4,
+ accumulator4 As Func(Of TAccumulate4, T, TAccumulate4),
+ seed5 As TAccumulate5,
+ accumulator5 As Func(Of TAccumulate5, T, TAccumulate5),
+ seed6 As TAccumulate6,
+ accumulator6 As Func(Of TAccumulate6, T, TAccumulate6),
+ resultSelector As Func(Of TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TAccumulate1, typename TAccumulate2, typename TAccumulate3, typename TAccumulate4, typename TAccumulate5, typename TAccumulate6, typename TResult>
+static TResult Aggregate(
+ IEnumerable<T>^ source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1>^ accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2>^ accumulator2,
+ TAccumulate3 seed3,
+ Func<TAccumulate3, T, TAccumulate3>^ accumulator3,
+ TAccumulate4 seed4,
+ Func<TAccumulate4, T, TAccumulate4>^ accumulator4,
+ TAccumulate5 seed5,
+ Func<TAccumulate5, T, TAccumulate5>^ accumulator5,
+ TAccumulate6 seed6,
+ Func<TAccumulate6, T, TAccumulate6>^ accumulator6,
+ Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Aggregate :
+ source : IEnumerable<'T> *
+ seed1 : 'TAccumulate1 *
+ accumulator1 : Func<'TAccumulate1, 'T, 'TAccumulate1> *
+ seed2 : 'TAccumulate2 *
+ accumulator2 : Func<'TAccumulate2, 'T, 'TAccumulate2> *
+ seed3 : 'TAccumulate3 *
+ accumulator3 : Func<'TAccumulate3, 'T, 'TAccumulate3> *
+ seed4 : 'TAccumulate4 *
+ accumulator4 : Func<'TAccumulate4, 'T, 'TAccumulate4> *
+ seed5 : 'TAccumulate5 *
+ accumulator5 : Func<'TAccumulate5, 'T, 'TAccumulate5> *
+ seed6 : 'TAccumulate6 *
+ accumulator6 : Func<'TAccumulate6, 'T, 'TAccumulate6> *
+ resultSelector : Func<'TAccumulate1, 'TAccumulate2, 'TAccumulate3, 'TAccumulate4, 'TAccumulate5, 'TAccumulate6, 'TResult> -> 'TResult public static TResult Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult>(
+ this IEnumerable<T> source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1> accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2> accumulator2,
+ TAccumulate3 seed3,
+ Func<TAccumulate3, T, TAccumulate3> accumulator3,
+ TAccumulate4 seed4,
+ Func<TAccumulate4, T, TAccumulate4> accumulator4,
+ TAccumulate5 seed5,
+ Func<TAccumulate5, T, TAccumulate5> accumulator5,
+ TAccumulate6 seed6,
+ Func<TAccumulate6, T, TAccumulate6> accumulator6,
+ TAccumulate7 seed7,
+ Func<TAccumulate7, T, TAccumulate7> accumulator7,
+ Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Aggregate(Of T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult) (
+ source As IEnumerable(Of T),
+ seed1 As TAccumulate1,
+ accumulator1 As Func(Of TAccumulate1, T, TAccumulate1),
+ seed2 As TAccumulate2,
+ accumulator2 As Func(Of TAccumulate2, T, TAccumulate2),
+ seed3 As TAccumulate3,
+ accumulator3 As Func(Of TAccumulate3, T, TAccumulate3),
+ seed4 As TAccumulate4,
+ accumulator4 As Func(Of TAccumulate4, T, TAccumulate4),
+ seed5 As TAccumulate5,
+ accumulator5 As Func(Of TAccumulate5, T, TAccumulate5),
+ seed6 As TAccumulate6,
+ accumulator6 As Func(Of TAccumulate6, T, TAccumulate6),
+ seed7 As TAccumulate7,
+ accumulator7 As Func(Of TAccumulate7, T, TAccumulate7),
+ resultSelector As Func(Of TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TAccumulate1, typename TAccumulate2, typename TAccumulate3, typename TAccumulate4, typename TAccumulate5, typename TAccumulate6, typename TAccumulate7, typename TResult>
+static TResult Aggregate(
+ IEnumerable<T>^ source,
+ TAccumulate1 seed1,
+ Func<TAccumulate1, T, TAccumulate1>^ accumulator1,
+ TAccumulate2 seed2,
+ Func<TAccumulate2, T, TAccumulate2>^ accumulator2,
+ TAccumulate3 seed3,
+ Func<TAccumulate3, T, TAccumulate3>^ accumulator3,
+ TAccumulate4 seed4,
+ Func<TAccumulate4, T, TAccumulate4>^ accumulator4,
+ TAccumulate5 seed5,
+ Func<TAccumulate5, T, TAccumulate5>^ accumulator5,
+ TAccumulate6 seed6,
+ Func<TAccumulate6, T, TAccumulate6>^ accumulator6,
+ TAccumulate7 seed7,
+ Func<TAccumulate7, T, TAccumulate7>^ accumulator7,
+ Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Aggregate :
+ source : IEnumerable<'T> *
+ seed1 : 'TAccumulate1 *
+ accumulator1 : Func<'TAccumulate1, 'T, 'TAccumulate1> *
+ seed2 : 'TAccumulate2 *
+ accumulator2 : Func<'TAccumulate2, 'T, 'TAccumulate2> *
+ seed3 : 'TAccumulate3 *
+ accumulator3 : Func<'TAccumulate3, 'T, 'TAccumulate3> *
+ seed4 : 'TAccumulate4 *
+ accumulator4 : Func<'TAccumulate4, 'T, 'TAccumulate4> *
+ seed5 : 'TAccumulate5 *
+ accumulator5 : Func<'TAccumulate5, 'T, 'TAccumulate5> *
+ seed6 : 'TAccumulate6 *
+ accumulator6 : Func<'TAccumulate6, 'T, 'TAccumulate6> *
+ seed7 : 'TAccumulate7 *
+ accumulator7 : Func<'TAccumulate7, 'T, 'TAccumulate7> *
+ resultSelector : Func<'TAccumulate1, 'TAccumulate2, 'TAccumulate3, 'TAccumulate4, 'TAccumulate5, 'TAccumulate6, 'TAccumulate7, 'TResult> -> 'TResult public static IEnumerable<T> Append<T>(
+ this IEnumerable<T> head,
+ T tail
+)
+<ExtensionAttribute>
+Public Shared Function Append(Of T) (
+ head As IEnumerable(Of T),
+ tail As T
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Append(
+ IEnumerable<T>^ head,
+ T tail
+)[<ExtensionAttribute>]
+static member Append :
+ head : IEnumerable<'T> *
+ tail : 'T -> IEnumerable<'T> public static IEnumerable<TSource> AssertCount<TSource>(
+ this IEnumerable<TSource> source,
+ int count
+)
+<ExtensionAttribute>
+Public Shared Function AssertCount(Of TSource) (
+ source As IEnumerable(Of TSource),
+ count As Integer
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ AssertCount(
+ IEnumerable<TSource>^ source,
+ int count
+)[<ExtensionAttribute>]
+static member AssertCount :
+ source : IEnumerable<'TSource> *
+ count : int -> IEnumerable<'TSource> public static IEnumerable<TSource> AssertCount<TSource>(
+ this IEnumerable<TSource> source,
+ int count,
+ Func<int, int, Exception> errorSelector
+)
+<ExtensionAttribute>
+Public Shared Function AssertCount(Of TSource) (
+ source As IEnumerable(Of TSource),
+ count As Integer,
+ errorSelector As Func(Of Integer, Integer, Exception)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ AssertCount(
+ IEnumerable<TSource>^ source,
+ int count,
+ Func<int, int, Exception^>^ errorSelector
+)[<ExtensionAttribute>]
+static member AssertCount :
+ source : IEnumerable<'TSource> *
+ count : int *
+ errorSelector : Func<int, int, Exception> -> IEnumerable<'TSource> public static IEnumerable<TSource> Assert<TSource>(
+ this IEnumerable<TSource> source,
+ Func<TSource, bool> predicate
+)
+<ExtensionAttribute>
+Public Shared Function Assert(Of TSource) (
+ source As IEnumerable(Of TSource),
+ predicate As Func(Of TSource, Boolean)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ Assert(
+ IEnumerable<TSource>^ source,
+ Func<TSource, bool>^ predicate
+)[<ExtensionAttribute>]
+static member Assert :
+ source : IEnumerable<'TSource> *
+ predicate : Func<'TSource, bool> -> IEnumerable<'TSource> | InvalidOperationException | The input sequence + contains an element that does not meet the condition being + asserted. |
public static IEnumerable<TSource> Assert<TSource>(
+ this IEnumerable<TSource> source,
+ Func<TSource, bool> predicate,
+ Func<TSource, Exception>? errorSelector
+)
+<ExtensionAttribute>
+Public Shared Function Assert(Of TSource) (
+ source As IEnumerable(Of TSource),
+ predicate As Func(Of TSource, Boolean),
+ errorSelector As Func(Of TSource, Exception)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ Assert(
+ IEnumerable<TSource>^ source,
+ Func<TSource, bool>^ predicate,
+ Func<TSource, Exception^>^ errorSelector
+)[<ExtensionAttribute>]
+static member Assert :
+ source : IEnumerable<'TSource> *
+ predicate : Func<'TSource, bool> *
+ errorSelector : Func<'TSource, Exception> -> IEnumerable<'TSource> public static bool AtLeast<T>(
+ this IEnumerable<T> source,
+ int count
+)
+<ExtensionAttribute>
+Public Shared Function AtLeast(Of T) (
+ source As IEnumerable(Of T),
+ count As Integer
+) As Booleanpublic:
+[ExtensionAttribute]
+generic<typename T>
+static bool AtLeast(
+ IEnumerable<T>^ source,
+ int count
+)[<ExtensionAttribute>]
+static member AtLeast :
+ source : IEnumerable<'T> *
+ count : int -> bool var numbers = new[] { 123, 456, 789 };
+var result = numbers.AtLeast(2);| ArgumentNullException | source is null |
| ArgumentOutOfRangeException | count is negative |
public static bool AtMost<T>(
+ this IEnumerable<T> source,
+ int count
+)
+<ExtensionAttribute>
+Public Shared Function AtMost(Of T) (
+ source As IEnumerable(Of T),
+ count As Integer
+) As Booleanpublic:
+[ExtensionAttribute]
+generic<typename T>
+static bool AtMost(
+ IEnumerable<T>^ source,
+ int count
+)[<ExtensionAttribute>]
+static member AtMost :
+ source : IEnumerable<'T> *
+ count : int -> bool var numbers = new[] { 123, 456, 789 };
+var result = numbers.AtMost(2);| ArgumentNullException | source is null |
| ArgumentOutOfRangeException | count is negative |
public static IEnumerable<T> Backsert<T>(
+ this IEnumerable<T> first,
+ IEnumerable<T> second,
+ int index
+)
+<ExtensionAttribute>
+Public Shared Function Backsert(Of T) (
+ first As IEnumerable(Of T),
+ second As IEnumerable(Of T),
+ index As Integer
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Backsert(
+ IEnumerable<T>^ first,
+ IEnumerable<T>^ second,
+ int index
+)[<ExtensionAttribute>]
+static member Backsert :
+ first : IEnumerable<'T> *
+ second : IEnumerable<'T> *
+ index : int -> IEnumerable<'T> | ArgumentNullException | first is null. |
| ArgumentNullException | second is null. |
| ArgumentOutOfRangeException | + Thrown if index is negative. + |
| ArgumentOutOfRangeException | + Thrown lazily if index is greater than the + length of first. The validation occurs when + the resulting sequence is iterated. + |
public static IEnumerable<IEnumerable<TSource>> Batch<TSource>(
+ this IEnumerable<TSource> source,
+ int size
+)
+<ExtensionAttribute>
+Public Shared Function Batch(Of TSource) (
+ source As IEnumerable(Of TSource),
+ size As Integer
+) As IEnumerable(Of IEnumerable(Of TSource))public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<IEnumerable<TSource>^>^ Batch(
+ IEnumerable<TSource>^ source,
+ int size
+)[<ExtensionAttribute>]
+static member Batch :
+ source : IEnumerable<'TSource> *
+ size : int -> IEnumerable<IEnumerable<'TSource>> + This operator uses deferred execution and streams its results + (buckets are streamed but their content buffered).
+ When more than one bucket is streamed, all buckets except the last + is guaranteed to have size elements. The last + bucket may be smaller depending on the remaining elements in the + source sequence.
+ Each bucket is pre-allocated to size elements. + If size is set to a very large value, e.g. + MaxValue to effectively disable batching by just + hoping for a single bucket, then it can lead to memory exhaustion + (OutOfMemoryException). +
public static IEnumerable<TResult> Batch<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ int size,
+ Func<IEnumerable<TSource>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Batch(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ size As Integer,
+ resultSelector As Func(Of IEnumerable(Of TSource), TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ Batch(
+ IEnumerable<TSource>^ source,
+ int size,
+ Func<IEnumerable<TSource>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Batch :
+ source : IEnumerable<'TSource> *
+ size : int *
+ resultSelector : Func<IEnumerable<'TSource>, 'TResult> -> IEnumerable<'TResult> + This operator uses deferred execution and streams its results + (buckets are streamed but their content buffered).
+ When more than one bucket is streamed, all buckets except the last + is guaranteed to have size elements. The last + bucket may be smaller depending on the remaining elements in the + source sequence.
+ Each bucket is pre-allocated to size elements. + If size is set to a very large value, e.g. + MaxValue to effectively disable batching by just + hoping for a single bucket, then it can lead to memory exhaustion + (OutOfMemoryException). +public static IEnumerable<TResult> Cartesian<T1, T2, TResult>(
+ this IEnumerable<T1> first,
+ IEnumerable<T2> second,
+ Func<T1, T2, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Cartesian(Of T1, T2, TResult) (
+ first As IEnumerable(Of T1),
+ second As IEnumerable(Of T2),
+ resultSelector As Func(Of T1, T2, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T1, typename T2, typename TResult>
+static IEnumerable<TResult>^ Cartesian(
+ IEnumerable<T1>^ first,
+ IEnumerable<T2>^ second,
+ Func<T1, T2, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Cartesian :
+ first : IEnumerable<'T1> *
+ second : IEnumerable<'T2> *
+ resultSelector : Func<'T1, 'T2, 'TResult> -> IEnumerable<'TResult> + The method returns items in the same order as a nested foreach + loop, but all sequences except for first are + cached when iterated over. The cache is then re-used for any + subsequent iterations.
+ This method uses deferred execution and stream its results.
public static IEnumerable<TResult> Cartesian<T1, T2, T3, TResult>(
+ this IEnumerable<T1> first,
+ IEnumerable<T2> second,
+ IEnumerable<T3> third,
+ Func<T1, T2, T3, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Cartesian(Of T1, T2, T3, TResult) (
+ first As IEnumerable(Of T1),
+ second As IEnumerable(Of T2),
+ third As IEnumerable(Of T3),
+ resultSelector As Func(Of T1, T2, T3, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T1, typename T2, typename T3, typename TResult>
+static IEnumerable<TResult>^ Cartesian(
+ IEnumerable<T1>^ first,
+ IEnumerable<T2>^ second,
+ IEnumerable<T3>^ third,
+ Func<T1, T2, T3, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Cartesian :
+ first : IEnumerable<'T1> *
+ second : IEnumerable<'T2> *
+ third : IEnumerable<'T3> *
+ resultSelector : Func<'T1, 'T2, 'T3, 'TResult> -> IEnumerable<'TResult> + The method returns items in the same order as a nested foreach + loop, but all sequences except for first are + cached when iterated over. The cache is then re-used for any + subsequent iterations.
+ This method uses deferred execution and stream its results.
public static IEnumerable<TResult> Cartesian<T1, T2, T3, T4, TResult>(
+ this IEnumerable<T1> first,
+ IEnumerable<T2> second,
+ IEnumerable<T3> third,
+ IEnumerable<T4> fourth,
+ Func<T1, T2, T3, T4, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Cartesian(Of T1, T2, T3, T4, TResult) (
+ first As IEnumerable(Of T1),
+ second As IEnumerable(Of T2),
+ third As IEnumerable(Of T3),
+ fourth As IEnumerable(Of T4),
+ resultSelector As Func(Of T1, T2, T3, T4, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T1, typename T2, typename T3, typename T4, typename TResult>
+static IEnumerable<TResult>^ Cartesian(
+ IEnumerable<T1>^ first,
+ IEnumerable<T2>^ second,
+ IEnumerable<T3>^ third,
+ IEnumerable<T4>^ fourth,
+ Func<T1, T2, T3, T4, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Cartesian :
+ first : IEnumerable<'T1> *
+ second : IEnumerable<'T2> *
+ third : IEnumerable<'T3> *
+ fourth : IEnumerable<'T4> *
+ resultSelector : Func<'T1, 'T2, 'T3, 'T4, 'TResult> -> IEnumerable<'TResult> + The method returns items in the same order as a nested foreach + loop, but all sequences except for first are + cached when iterated over. The cache is then re-used for any + subsequent iterations.
+ This method uses deferred execution and stream its results.
public static IEnumerable<TResult> Cartesian<T1, T2, T3, T4, T5, TResult>(
+ this IEnumerable<T1> first,
+ IEnumerable<T2> second,
+ IEnumerable<T3> third,
+ IEnumerable<T4> fourth,
+ IEnumerable<T5> fifth,
+ Func<T1, T2, T3, T4, T5, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Cartesian(Of T1, T2, T3, T4, T5, TResult) (
+ first As IEnumerable(Of T1),
+ second As IEnumerable(Of T2),
+ third As IEnumerable(Of T3),
+ fourth As IEnumerable(Of T4),
+ fifth As IEnumerable(Of T5),
+ resultSelector As Func(Of T1, T2, T3, T4, T5, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T1, typename T2, typename T3, typename T4, typename T5, typename TResult>
+static IEnumerable<TResult>^ Cartesian(
+ IEnumerable<T1>^ first,
+ IEnumerable<T2>^ second,
+ IEnumerable<T3>^ third,
+ IEnumerable<T4>^ fourth,
+ IEnumerable<T5>^ fifth,
+ Func<T1, T2, T3, T4, T5, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Cartesian :
+ first : IEnumerable<'T1> *
+ second : IEnumerable<'T2> *
+ third : IEnumerable<'T3> *
+ fourth : IEnumerable<'T4> *
+ fifth : IEnumerable<'T5> *
+ resultSelector : Func<'T1, 'T2, 'T3, 'T4, 'T5, 'TResult> -> IEnumerable<'TResult> + The method returns items in the same order as a nested foreach + loop, but all sequences except for first are + cached when iterated over. The cache is then re-used for any + subsequent iterations.
+ This method uses deferred execution and stream its results.
public static IEnumerable<TResult> Cartesian<T1, T2, T3, T4, T5, T6, TResult>(
+ this IEnumerable<T1> first,
+ IEnumerable<T2> second,
+ IEnumerable<T3> third,
+ IEnumerable<T4> fourth,
+ IEnumerable<T5> fifth,
+ IEnumerable<T6> sixth,
+ Func<T1, T2, T3, T4, T5, T6, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Cartesian(Of T1, T2, T3, T4, T5, T6, TResult) (
+ first As IEnumerable(Of T1),
+ second As IEnumerable(Of T2),
+ third As IEnumerable(Of T3),
+ fourth As IEnumerable(Of T4),
+ fifth As IEnumerable(Of T5),
+ sixth As IEnumerable(Of T6),
+ resultSelector As Func(Of T1, T2, T3, T4, T5, T6, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename TResult>
+static IEnumerable<TResult>^ Cartesian(
+ IEnumerable<T1>^ first,
+ IEnumerable<T2>^ second,
+ IEnumerable<T3>^ third,
+ IEnumerable<T4>^ fourth,
+ IEnumerable<T5>^ fifth,
+ IEnumerable<T6>^ sixth,
+ Func<T1, T2, T3, T4, T5, T6, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Cartesian :
+ first : IEnumerable<'T1> *
+ second : IEnumerable<'T2> *
+ third : IEnumerable<'T3> *
+ fourth : IEnumerable<'T4> *
+ fifth : IEnumerable<'T5> *
+ sixth : IEnumerable<'T6> *
+ resultSelector : Func<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'TResult> -> IEnumerable<'TResult> + The method returns items in the same order as a nested foreach + loop, but all sequences except for first are + cached when iterated over. The cache is then re-used for any + subsequent iterations.
+ This method uses deferred execution and stream its results.
public static IEnumerable<TResult> Cartesian<T1, T2, T3, T4, T5, T6, T7, TResult>(
+ this IEnumerable<T1> first,
+ IEnumerable<T2> second,
+ IEnumerable<T3> third,
+ IEnumerable<T4> fourth,
+ IEnumerable<T5> fifth,
+ IEnumerable<T6> sixth,
+ IEnumerable<T7> seventh,
+ Func<T1, T2, T3, T4, T5, T6, T7, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Cartesian(Of T1, T2, T3, T4, T5, T6, T7, TResult) (
+ first As IEnumerable(Of T1),
+ second As IEnumerable(Of T2),
+ third As IEnumerable(Of T3),
+ fourth As IEnumerable(Of T4),
+ fifth As IEnumerable(Of T5),
+ sixth As IEnumerable(Of T6),
+ seventh As IEnumerable(Of T7),
+ resultSelector As Func(Of T1, T2, T3, T4, T5, T6, T7, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename TResult>
+static IEnumerable<TResult>^ Cartesian(
+ IEnumerable<T1>^ first,
+ IEnumerable<T2>^ second,
+ IEnumerable<T3>^ third,
+ IEnumerable<T4>^ fourth,
+ IEnumerable<T5>^ fifth,
+ IEnumerable<T6>^ sixth,
+ IEnumerable<T7>^ seventh,
+ Func<T1, T2, T3, T4, T5, T6, T7, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Cartesian :
+ first : IEnumerable<'T1> *
+ second : IEnumerable<'T2> *
+ third : IEnumerable<'T3> *
+ fourth : IEnumerable<'T4> *
+ fifth : IEnumerable<'T5> *
+ sixth : IEnumerable<'T6> *
+ seventh : IEnumerable<'T7> *
+ resultSelector : Func<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'TResult> -> IEnumerable<'TResult> + The method returns items in the same order as a nested foreach + loop, but all sequences except for first are + cached when iterated over. The cache is then re-used for any + subsequent iterations.
+ This method uses deferred execution and stream its results.
public static IEnumerable<TResult> Cartesian<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(
+ this IEnumerable<T1> first,
+ IEnumerable<T2> second,
+ IEnumerable<T3> third,
+ IEnumerable<T4> fourth,
+ IEnumerable<T5> fifth,
+ IEnumerable<T6> sixth,
+ IEnumerable<T7> seventh,
+ IEnumerable<T8> eighth,
+ Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Cartesian(Of T1, T2, T3, T4, T5, T6, T7, T8, TResult) (
+ first As IEnumerable(Of T1),
+ second As IEnumerable(Of T2),
+ third As IEnumerable(Of T3),
+ fourth As IEnumerable(Of T4),
+ fifth As IEnumerable(Of T5),
+ sixth As IEnumerable(Of T6),
+ seventh As IEnumerable(Of T7),
+ eighth As IEnumerable(Of T8),
+ resultSelector As Func(Of T1, T2, T3, T4, T5, T6, T7, T8, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename TResult>
+static IEnumerable<TResult>^ Cartesian(
+ IEnumerable<T1>^ first,
+ IEnumerable<T2>^ second,
+ IEnumerable<T3>^ third,
+ IEnumerable<T4>^ fourth,
+ IEnumerable<T5>^ fifth,
+ IEnumerable<T6>^ sixth,
+ IEnumerable<T7>^ seventh,
+ IEnumerable<T8>^ eighth,
+ Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Cartesian :
+ first : IEnumerable<'T1> *
+ second : IEnumerable<'T2> *
+ third : IEnumerable<'T3> *
+ fourth : IEnumerable<'T4> *
+ fifth : IEnumerable<'T5> *
+ sixth : IEnumerable<'T6> *
+ seventh : IEnumerable<'T7> *
+ eighth : IEnumerable<'T8> *
+ resultSelector : Func<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8, 'TResult> -> IEnumerable<'TResult> + The method returns items in the same order as a nested foreach + loop, but all sequences except for first are + cached when iterated over. The cache is then re-used for any + subsequent iterations.
+ This method uses deferred execution and stream its results.
public static IEnumerable<TResult> Choose<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, (bool , TResult )> chooser
+)
+<ExtensionAttribute>
+Public Shared Function Choose(Of T, TResult) (
+ source As IEnumerable(Of T),
+ chooser As Func(Of T, ( As Boolean, As TResult))
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static IEnumerable<TResult>^ Choose(
+ IEnumerable<T>^ source,
+ Func<T, ValueTuple<bool, TResult>>^ chooser
+)[<ExtensionAttribute>]
+static member Choose :
+ source : IEnumerable<'T> *
+ chooser : Func<'T, ValueTuple<bool, 'TResult>> -> IEnumerable<'TResult> 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));public static int CompareCount<TFirst, TSecond>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second
+)
+<ExtensionAttribute>
+Public Shared Function CompareCount(Of TFirst, TSecond) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond)
+) As Integerpublic:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond>
+static int CompareCount(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second
+)[<ExtensionAttribute>]
+static member CompareCount :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> -> int var first = new[] { 123, 456 };
+var second = new[] { 789 };
+var result = first.CompareCount(second);| ArgumentNullException | first is null |
| ArgumentNullException | second is null |
[ObsoleteAttribute("Use Append instead.")]
+public static IEnumerable<T> Concat<T>(
+ this IEnumerable<T> head,
+ T tail
+)
+<ExtensionAttribute>
+<ObsoleteAttribute("Use Append instead.")>
+Public Shared Function Concat(Of T) (
+ head As IEnumerable(Of T),
+ tail As T
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+[ObsoleteAttribute(L"Use Append instead.")]
+generic<typename T>
+static IEnumerable<T>^ Concat(
+ IEnumerable<T>^ head,
+ T tail
+)[<ExtensionAttribute>]
+[<ObsoleteAttribute("Use Append instead.")>]
+static member Concat :
+ head : IEnumerable<'T> *
+ tail : 'T -> IEnumerable<'T> public static void Consume<T>(
+ this IEnumerable<T> source
+)
+<ExtensionAttribute>
+Public Shared Sub Consume(Of T) (
+ source As IEnumerable(Of T)
+)public:
+[ExtensionAttribute]
+generic<typename T>
+static void Consume(
+ IEnumerable<T>^ source
+)[<ExtensionAttribute>]
+static member Consume :
+ source : IEnumerable<'T> -> unit public static bool CountBetween<T>(
+ this IEnumerable<T> source,
+ int min,
+ int max
+)
+<ExtensionAttribute>
+Public Shared Function CountBetween(Of T) (
+ source As IEnumerable(Of T),
+ min As Integer,
+ max As Integer
+) As Booleanpublic:
+[ExtensionAttribute]
+generic<typename T>
+static bool CountBetween(
+ IEnumerable<T>^ source,
+ int min,
+ int max
+)[<ExtensionAttribute>]
+static member CountBetween :
+ source : IEnumerable<'T> *
+ min : int *
+ max : int -> bool var numbers = new[] { 123, 456, 789 };
+var result = numbers.CountBetween(1, 2);| ArgumentNullException | source is null |
| ArgumentOutOfRangeException | min is negative or max is less than min |
public static IEnumerable<KeyValuePair<TKey, int>> CountBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector
+)
+<ExtensionAttribute>
+Public Shared Function CountBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey)
+) As IEnumerable(Of KeyValuePair(Of TKey, Integer))public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<KeyValuePair<TKey, int>>^ CountBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector
+)[<ExtensionAttribute>]
+static member CountBy :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> -> IEnumerable<KeyValuePair<'TKey, int>> public static IEnumerable<KeyValuePair<TKey, int>> CountBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function CountBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of KeyValuePair(Of TKey, Integer))public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<KeyValuePair<TKey, int>>^ CountBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member CountBy :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<KeyValuePair<'TKey, int>> public static IEnumerable<TResult> CountDown<T, TResult>(
+ this IEnumerable<T> source,
+ int count,
+ Func<T, int?, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function CountDown(Of T, TResult) (
+ source As IEnumerable(Of T),
+ count As Integer,
+ resultSelector As Func(Of T, Integer?, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static IEnumerable<TResult>^ CountDown(
+ IEnumerable<T>^ source,
+ int count,
+ Func<T, Nullable<int>, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member CountDown :
+ source : IEnumerable<'T> *
+ count : int *
+ resultSelector : Func<'T, Nullable<int>, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TSource> DistinctBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector
+)
+<ExtensionAttribute>
+Public Shared Function DistinctBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<TSource>^ DistinctBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector
+)[<ExtensionAttribute>]
+static member DistinctBy :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> -> IEnumerable<'TSource> public static IEnumerable<TSource> DistinctBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function DistinctBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<TSource>^ DistinctBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member DistinctBy :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<'TSource> public static bool EndsWith<T>(
+ this IEnumerable<T> first,
+ IEnumerable<T> second
+)
+<ExtensionAttribute>
+Public Shared Function EndsWith(Of T) (
+ first As IEnumerable(Of T),
+ second As IEnumerable(Of T)
+) As Booleanpublic:
+[ExtensionAttribute]
+generic<typename T>
+static bool EndsWith(
+ IEnumerable<T>^ first,
+ IEnumerable<T>^ second
+)[<ExtensionAttribute>]
+static member EndsWith :
+ first : IEnumerable<'T> *
+ second : IEnumerable<'T> -> bool public static bool EndsWith<T>(
+ this IEnumerable<T> first,
+ IEnumerable<T> second,
+ IEqualityComparer<T>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function EndsWith(Of T) (
+ first As IEnumerable(Of T),
+ second As IEnumerable(Of T),
+ comparer As IEqualityComparer(Of T)
+) As Booleanpublic:
+[ExtensionAttribute]
+generic<typename T>
+static bool EndsWith(
+ IEnumerable<T>^ first,
+ IEnumerable<T>^ second,
+ IEqualityComparer<T>^ comparer
+)[<ExtensionAttribute>]
+static member EndsWith :
+ first : IEnumerable<'T> *
+ second : IEnumerable<'T> *
+ comparer : IEqualityComparer<'T> -> bool public static IEnumerable<TResult> EquiZip<TFirst, TSecond, TResult>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TSecond, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function EquiZip(Of TFirst, TSecond, TResult) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ resultSelector As Func(Of TFirst, TSecond, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TResult>
+static IEnumerable<TResult>^ EquiZip(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TSecond, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member EquiZip :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ resultSelector : Func<'TFirst, 'TSecond, 'TResult> -> IEnumerable<'TResult> var numbers = new[] { 1, 2, 3, 4 };
+var letters = new[] { "A", "B", "C", "D" };
+var zipped = numbers.EquiZip(letters, (n, l) => n + l);| InvalidOperationException | + The input sequences are of different lengths. + |
| ArgumentNullException | first, second, or resultSelector is . + |
public static IEnumerable<TResult> EquiZip<T1, T2, T3, TResult>(
+ this IEnumerable<T1> first,
+ IEnumerable<T2> second,
+ IEnumerable<T3> third,
+ Func<T1, T2, T3, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function EquiZip(Of T1, T2, T3, TResult) (
+ first As IEnumerable(Of T1),
+ second As IEnumerable(Of T2),
+ third As IEnumerable(Of T3),
+ resultSelector As Func(Of T1, T2, T3, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T1, typename T2, typename T3, typename TResult>
+static IEnumerable<TResult>^ EquiZip(
+ IEnumerable<T1>^ first,
+ IEnumerable<T2>^ second,
+ IEnumerable<T3>^ third,
+ Func<T1, T2, T3, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member EquiZip :
+ first : IEnumerable<'T1> *
+ second : IEnumerable<'T2> *
+ third : IEnumerable<'T3> *
+ resultSelector : Func<'T1, 'T2, 'T3, 'TResult> -> IEnumerable<'TResult> 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);| InvalidOperationException | + The input sequences are of different lengths. + |
| ArgumentNullException | first, second, third, or resultSelector is . + |
public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, TResult>(
+ this IEnumerable<T1> first,
+ IEnumerable<T2> second,
+ IEnumerable<T3> third,
+ IEnumerable<T4> fourth,
+ Func<T1, T2, T3, T4, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function EquiZip(Of T1, T2, T3, T4, TResult) (
+ first As IEnumerable(Of T1),
+ second As IEnumerable(Of T2),
+ third As IEnumerable(Of T3),
+ fourth As IEnumerable(Of T4),
+ resultSelector As Func(Of T1, T2, T3, T4, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T1, typename T2, typename T3, typename T4, typename TResult>
+static IEnumerable<TResult>^ EquiZip(
+ IEnumerable<T1>^ first,
+ IEnumerable<T2>^ second,
+ IEnumerable<T3>^ third,
+ IEnumerable<T4>^ fourth,
+ Func<T1, T2, T3, T4, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member EquiZip :
+ first : IEnumerable<'T1> *
+ second : IEnumerable<'T2> *
+ third : IEnumerable<'T3> *
+ fourth : IEnumerable<'T4> *
+ resultSelector : Func<'T1, 'T2, 'T3, 'T4, 'TResult> -> IEnumerable<'TResult> 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);| InvalidOperationException | + The input sequences are of different lengths. + |
| ArgumentNullException | first, second, third, fourth, or resultSelector is . + |
public static IEnumerable<T> Evaluate<T>(
+ this IEnumerable<Func<T>> functions
+)
+<ExtensionAttribute>
+Public Shared Function Evaluate(Of T) (
+ functions As IEnumerable(Of Func(Of T))
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Evaluate(
+ IEnumerable<Func<T>^>^ functions
+)[<ExtensionAttribute>]
+static member Evaluate :
+ functions : IEnumerable<Func<'T>> -> IEnumerable<'T> | ArgumentNullException | When functions is null. |
public static bool Exactly<T>(
+ this IEnumerable<T> source,
+ int count
+)
+<ExtensionAttribute>
+Public Shared Function Exactly(Of T) (
+ source As IEnumerable(Of T),
+ count As Integer
+) As Booleanpublic:
+[ExtensionAttribute]
+generic<typename T>
+static bool Exactly(
+ IEnumerable<T>^ source,
+ int count
+)[<ExtensionAttribute>]
+static member Exactly :
+ source : IEnumerable<'T> *
+ count : int -> bool var numbers = new[] { 123, 456, 789 };
+var result = numbers.Exactly(3);| ArgumentNullException | source is null |
| ArgumentOutOfRangeException | count is negative |
public static IEnumerable<TSource> ExceptBy<TSource, TKey>(
+ this IEnumerable<TSource> first,
+ IEnumerable<TSource> second,
+ Func<TSource, TKey> keySelector
+)
+<ExtensionAttribute>
+Public Shared Function ExceptBy(Of TSource, TKey) (
+ first As IEnumerable(Of TSource),
+ second As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<TSource>^ ExceptBy(
+ IEnumerable<TSource>^ first,
+ IEnumerable<TSource>^ second,
+ Func<TSource, TKey>^ keySelector
+)[<ExtensionAttribute>]
+static member ExceptBy :
+ first : IEnumerable<'TSource> *
+ second : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> -> IEnumerable<'TSource> public static IEnumerable<TSource> ExceptBy<TSource, TKey>(
+ this IEnumerable<TSource> first,
+ IEnumerable<TSource> second,
+ Func<TSource, TKey> keySelector,
+ IEqualityComparer<TKey>? keyComparer
+)
+<ExtensionAttribute>
+Public Shared Function ExceptBy(Of TSource, TKey) (
+ first As IEnumerable(Of TSource),
+ second As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ keyComparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<TSource>^ ExceptBy(
+ IEnumerable<TSource>^ first,
+ IEnumerable<TSource>^ second,
+ Func<TSource, TKey>^ keySelector,
+ IEqualityComparer<TKey>^ keyComparer
+)[<ExtensionAttribute>]
+static member ExceptBy :
+ first : IEnumerable<'TSource> *
+ second : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ keyComparer : IEqualityComparer<'TKey> -> IEnumerable<'TSource> public static IEnumerable<T> Exclude<T>(
+ this IEnumerable<T> sequence,
+ int startIndex,
+ int count
+)
+<ExtensionAttribute>
+Public Shared Function Exclude(Of T) (
+ sequence As IEnumerable(Of T),
+ startIndex As Integer,
+ count As Integer
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Exclude(
+ IEnumerable<T>^ sequence,
+ int startIndex,
+ int count
+)[<ExtensionAttribute>]
+static member Exclude :
+ sequence : IEnumerable<'T> *
+ startIndex : int *
+ count : int -> IEnumerable<'T> public static IEnumerable<T> FallbackIfEmpty<T>(
+ this IEnumerable<T> source,
+ IEnumerable<T> fallback
+)
+<ExtensionAttribute>
+Public Shared Function FallbackIfEmpty(Of T) (
+ source As IEnumerable(Of T),
+ fallback As IEnumerable(Of T)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ FallbackIfEmpty(
+ IEnumerable<T>^ source,
+ IEnumerable<T>^ fallback
+)[<ExtensionAttribute>]
+static member FallbackIfEmpty :
+ source : IEnumerable<'T> *
+ fallback : IEnumerable<'T> -> IEnumerable<'T> public static IEnumerable<T> FallbackIfEmpty<T>(
+ this IEnumerable<T> source,
+ T fallback
+)
+<ExtensionAttribute>
+Public Shared Function FallbackIfEmpty(Of T) (
+ source As IEnumerable(Of T),
+ fallback As T
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ FallbackIfEmpty(
+ IEnumerable<T>^ source,
+ T fallback
+)[<ExtensionAttribute>]
+static member FallbackIfEmpty :
+ source : IEnumerable<'T> *
+ fallback : 'T -> IEnumerable<'T> var numbers = new[] { 123, 456, 789 };
+var result = numbers.Where(x => x == 100).FallbackIfEmpty(-1).Single();public static IEnumerable<T> FallbackIfEmpty<T>(
+ this IEnumerable<T> source,
+ T fallback1,
+ T fallback2
+)
+<ExtensionAttribute>
+Public Shared Function FallbackIfEmpty(Of T) (
+ source As IEnumerable(Of T),
+ fallback1 As T,
+ fallback2 As T
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ FallbackIfEmpty(
+ IEnumerable<T>^ source,
+ T fallback1,
+ T fallback2
+)[<ExtensionAttribute>]
+static member FallbackIfEmpty :
+ source : IEnumerable<'T> *
+ fallback1 : 'T *
+ fallback2 : 'T -> IEnumerable<'T> public static IEnumerable<T> FallbackIfEmpty<T>(
+ this IEnumerable<T> source,
+ T fallback1,
+ T fallback2,
+ T fallback3
+)
+<ExtensionAttribute>
+Public Shared Function FallbackIfEmpty(Of T) (
+ source As IEnumerable(Of T),
+ fallback1 As T,
+ fallback2 As T,
+ fallback3 As T
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ FallbackIfEmpty(
+ IEnumerable<T>^ source,
+ T fallback1,
+ T fallback2,
+ T fallback3
+)[<ExtensionAttribute>]
+static member FallbackIfEmpty :
+ source : IEnumerable<'T> *
+ fallback1 : 'T *
+ fallback2 : 'T *
+ fallback3 : 'T -> IEnumerable<'T> public static IEnumerable<T> FallbackIfEmpty<T>(
+ this IEnumerable<T> source,
+ T fallback1,
+ T fallback2,
+ T fallback3,
+ T fallback4
+)
+<ExtensionAttribute>
+Public Shared Function FallbackIfEmpty(Of T) (
+ source As IEnumerable(Of T),
+ fallback1 As T,
+ fallback2 As T,
+ fallback3 As T,
+ fallback4 As T
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ FallbackIfEmpty(
+ IEnumerable<T>^ source,
+ T fallback1,
+ T fallback2,
+ T fallback3,
+ T fallback4
+)[<ExtensionAttribute>]
+static member FallbackIfEmpty :
+ source : IEnumerable<'T> *
+ fallback1 : 'T *
+ fallback2 : 'T *
+ fallback3 : 'T *
+ fallback4 : 'T -> IEnumerable<'T> public static IEnumerable<T> FallbackIfEmpty<T>(
+ this IEnumerable<T> source,
+ params T[] fallback
+)
+<ExtensionAttribute>
+Public Shared Function FallbackIfEmpty(Of T) (
+ source As IEnumerable(Of T),
+ ParamArray fallback As T()
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ FallbackIfEmpty(
+ IEnumerable<T>^ source,
+ ... array<T>^ fallback
+)[<ExtensionAttribute>]
+static member FallbackIfEmpty :
+ source : IEnumerable<'T> *
+ fallback : 'T[] -> IEnumerable<'T> public static IEnumerable<T> FillBackward<T>(
+ this IEnumerable<T> source
+)
+<ExtensionAttribute>
+Public Shared Function FillBackward(Of T) (
+ source As IEnumerable(Of T)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ FillBackward(
+ IEnumerable<T>^ source
+)[<ExtensionAttribute>]
+static member FillBackward :
+ source : IEnumerable<'T> -> IEnumerable<'T> public static IEnumerable<T> FillBackward<T>(
+ this IEnumerable<T> source,
+ Func<T, bool> predicate
+)
+<ExtensionAttribute>
+Public Shared Function FillBackward(Of T) (
+ source As IEnumerable(Of T),
+ predicate As Func(Of T, Boolean)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ FillBackward(
+ IEnumerable<T>^ source,
+ Func<T, bool>^ predicate
+)[<ExtensionAttribute>]
+static member FillBackward :
+ source : IEnumerable<'T> *
+ predicate : Func<'T, bool> -> IEnumerable<'T> public static IEnumerable<T> FillBackward<T>(
+ this IEnumerable<T> source,
+ Func<T, bool> predicate,
+ Func<T, T, T> fillSelector
+)
+<ExtensionAttribute>
+Public Shared Function FillBackward(Of T) (
+ source As IEnumerable(Of T),
+ predicate As Func(Of T, Boolean),
+ fillSelector As Func(Of T, T, T)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ FillBackward(
+ IEnumerable<T>^ source,
+ Func<T, bool>^ predicate,
+ Func<T, T, T>^ fillSelector
+)[<ExtensionAttribute>]
+static member FillBackward :
+ source : IEnumerable<'T> *
+ predicate : Func<'T, bool> *
+ fillSelector : Func<'T, 'T, 'T> -> IEnumerable<'T> public static IEnumerable<T> FillForward<T>(
+ this IEnumerable<T> source
+)
+<ExtensionAttribute>
+Public Shared Function FillForward(Of T) (
+ source As IEnumerable(Of T)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ FillForward(
+ IEnumerable<T>^ source
+)[<ExtensionAttribute>]
+static member FillForward :
+ source : IEnumerable<'T> -> IEnumerable<'T> public static IEnumerable<T> FillForward<T>(
+ this IEnumerable<T> source,
+ Func<T, bool> predicate
+)
+<ExtensionAttribute>
+Public Shared Function FillForward(Of T) (
+ source As IEnumerable(Of T),
+ predicate As Func(Of T, Boolean)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ FillForward(
+ IEnumerable<T>^ source,
+ Func<T, bool>^ predicate
+)[<ExtensionAttribute>]
+static member FillForward :
+ source : IEnumerable<'T> *
+ predicate : Func<'T, bool> -> IEnumerable<'T> public static IEnumerable<T> FillForward<T>(
+ this IEnumerable<T> source,
+ Func<T, bool> predicate,
+ Func<T, T, T> fillSelector
+)
+<ExtensionAttribute>
+Public Shared Function FillForward(Of T) (
+ source As IEnumerable(Of T),
+ predicate As Func(Of T, Boolean),
+ fillSelector As Func(Of T, T, T)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ FillForward(
+ IEnumerable<T>^ source,
+ Func<T, bool>^ predicate,
+ Func<T, T, T>^ fillSelector
+)[<ExtensionAttribute>]
+static member FillForward :
+ source : IEnumerable<'T> *
+ predicate : Func<'T, bool> *
+ fillSelector : Func<'T, 'T, 'T> -> IEnumerable<'T> public static T FirstOrDefault<T>(
+ this IExtremaEnumerable<T> source
+)
+<ExtensionAttribute>
+Public Shared Function FirstOrDefault(Of T) (
+ source As IExtremaEnumerable(Of T)
+) As Tpublic:
+[ExtensionAttribute]
+generic<typename T>
+static T FirstOrDefault(
+ IExtremaEnumerable<T>^ source
+)[<ExtensionAttribute>]
+static member FirstOrDefault :
+ source : IExtremaEnumerable<'T> -> 'T public static T First<T>(
+ this IExtremaEnumerable<T> source
+)
+<ExtensionAttribute>
+Public Shared Function First(Of T) (
+ source As IExtremaEnumerable(Of T)
+) As Tpublic:
+[ExtensionAttribute]
+generic<typename T>
+static T First(
+ IExtremaEnumerable<T>^ source
+)[<ExtensionAttribute>]
+static member First :
+ source : IExtremaEnumerable<'T> -> 'T | InvalidOperationException | + The input sequence is empty. |
public static IEnumerable<Object> Flatten(
+ this IEnumerable source
+)<ExtensionAttribute>
+Public Shared Function Flatten (
+ source As IEnumerable
+) As IEnumerable(Of Object)public:
+[ExtensionAttribute]
+static IEnumerable<Object^>^ Flatten(
+ IEnumerable^ source
+)[<ExtensionAttribute>]
+static member Flatten :
+ source : IEnumerable -> IEnumerable<Object> | ArgumentNullException | source is null. |
public static IEnumerable<Object> Flatten(
+ this IEnumerable source,
+ Func<IEnumerable, bool> predicate
+)<ExtensionAttribute>
+Public Shared Function Flatten (
+ source As IEnumerable,
+ predicate As Func(Of IEnumerable, Boolean)
+) As IEnumerable(Of Object)public:
+[ExtensionAttribute]
+static IEnumerable<Object^>^ Flatten(
+ IEnumerable^ source,
+ Func<IEnumerable^, bool>^ predicate
+)[<ExtensionAttribute>]
+static member Flatten :
+ source : IEnumerable *
+ predicate : Func<IEnumerable, bool> -> IEnumerable<Object> | ArgumentNullException | source is null. |
| ArgumentNullException | predicate is null. |
public static IEnumerable<Object> Flatten(
+ this IEnumerable source,
+ Func<Object, IEnumerable?> selector
+)<ExtensionAttribute>
+Public Shared Function Flatten (
+ source As IEnumerable,
+ selector As Func(Of Object, IEnumerable)
+) As IEnumerable(Of Object)public:
+[ExtensionAttribute]
+static IEnumerable<Object^>^ Flatten(
+ IEnumerable^ source,
+ Func<Object^, IEnumerable^>^ selector
+)[<ExtensionAttribute>]
+static member Flatten :
+ source : IEnumerable *
+ selector : Func<Object, IEnumerable> -> IEnumerable<Object> | ArgumentNullException | source is null. |
| ArgumentNullException | selector is null. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, T, T, T, T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, T, T, T, T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, T, T, T, T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 9 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, T, T, T, T, T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, T, T, T, T, T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, T, T, T, T, T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 10 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 3 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 4 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 5 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 6 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, T, T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, T, T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, T, T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'T, 'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 7 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, T, T, T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, T, T, T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, T, T, T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 8 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, T, T, T, T, T, T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, T, T, T, T, T, T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, T, T, T, T, T, T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 11 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, T, T, T, T, T, T, T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, T, T, T, T, T, T, T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 12 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, T, T, T, T, T, T, T, T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 13 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 14 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 15 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 16 elements. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 1 element. |
public static TResult Fold<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, T, TResult> folder
+)
+<ExtensionAttribute>
+Public Shared Function Fold(Of T, TResult) (
+ source As IEnumerable(Of T),
+ folder As Func(Of T, T, TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Fold(
+ IEnumerable<T>^ source,
+ Func<T, T, TResult>^ folder
+)[<ExtensionAttribute>]
+static member Fold :
+ source : IEnumerable<'T> *
+ folder : Func<'T, 'T, 'TResult> -> 'TResult | ArgumentNullException | + Either source or folder is . + |
| InvalidOperationException | source does not contain exactly 2 elements. |
public static void ForEach<T>(
+ this IEnumerable<T> source,
+ Action<T> action
+)
+<ExtensionAttribute>
+Public Shared Sub ForEach(Of T) (
+ source As IEnumerable(Of T),
+ action As Action(Of T)
+)public:
+[ExtensionAttribute]
+generic<typename T>
+static void ForEach(
+ IEnumerable<T>^ source,
+ Action<T>^ action
+)[<ExtensionAttribute>]
+static member ForEach :
+ source : IEnumerable<'T> *
+ action : Action<'T> -> unit public static void ForEach<T>(
+ this IEnumerable<T> source,
+ Action<T, int> action
+)
+<ExtensionAttribute>
+Public Shared Sub ForEach(Of T) (
+ source As IEnumerable(Of T),
+ action As Action(Of T, Integer)
+)public:
+[ExtensionAttribute]
+generic<typename T>
+static void ForEach(
+ IEnumerable<T>^ source,
+ Action<T, int>^ action
+)[<ExtensionAttribute>]
+static member ForEach :
+ source : IEnumerable<'T> *
+ action : Action<'T, int> -> unit public static IEnumerable<T> From<T>(
+ Func<T> function
+)
+Public Shared Function From(Of T) (
+ function As Func(Of T)
+) As IEnumerable(Of T)public:
+generic<typename T>
+static IEnumerable<T>^ From(
+ Func<T>^ function
+)static member From :
+ function : Func<'T> -> IEnumerable<'T> public static IEnumerable<T> From<T>(
+ Func<T> function1,
+ Func<T> function2
+)
+Public Shared Function From(Of T) (
+ function1 As Func(Of T),
+ function2 As Func(Of T)
+) As IEnumerable(Of T)public:
+generic<typename T>
+static IEnumerable<T>^ From(
+ Func<T>^ function1,
+ Func<T>^ function2
+)static member From :
+ function1 : Func<'T> *
+ function2 : Func<'T> -> IEnumerable<'T> public static IEnumerable<T> From<T>(
+ Func<T> function1,
+ Func<T> function2,
+ Func<T> function3
+)
+Public Shared Function From(Of T) (
+ function1 As Func(Of T),
+ function2 As Func(Of T),
+ function3 As Func(Of T)
+) As IEnumerable(Of T)public:
+generic<typename T>
+static IEnumerable<T>^ From(
+ Func<T>^ function1,
+ Func<T>^ function2,
+ Func<T>^ function3
+)static member From :
+ function1 : Func<'T> *
+ function2 : Func<'T> *
+ function3 : Func<'T> -> IEnumerable<'T> public static IEnumerable<T> From<T>(
+ params Func<T>[] functions
+)
+Public Shared Function From(Of T) (
+ ParamArray functions As Func(Of T)()
+) As IEnumerable(Of T)public:
+generic<typename T>
+static IEnumerable<T>^ From(
+ ... array<Func<T>^>^ functions
+)static member From :
+ functions : Func<'T>[] -> IEnumerable<'T> | ArgumentNullException | When functions is null. |
public static IEnumerable<(TKey , IEnumerable<TFirst> First, IEnumerable<TSecond> Second)> FullGroupJoin<TFirst, TSecond, TKey>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TKey> firstKeySelector,
+ Func<TSecond, TKey> secondKeySelector
+)
+<ExtensionAttribute>
+Public Shared Function FullGroupJoin(Of TFirst, TSecond, TKey) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ firstKeySelector As Func(Of TFirst, TKey),
+ secondKeySelector As Func(Of TSecond, TKey)
+) As IEnumerable(Of ( As TKey, First As IEnumerable(Of TFirst), Second As IEnumerable(Of TSecond)))public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TKey>
+static IEnumerable<ValueTuple<TKey, IEnumerable<TFirst>^, IEnumerable<TSecond>^>>^ FullGroupJoin(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TKey>^ firstKeySelector,
+ Func<TSecond, TKey>^ secondKeySelector
+)[<ExtensionAttribute>]
+static member FullGroupJoin :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ firstKeySelector : Func<'TFirst, 'TKey> *
+ secondKeySelector : Func<'TSecond, 'TKey> -> IEnumerable<ValueTuple<'TKey, IEnumerable<'TFirst>, IEnumerable<'TSecond>>> public static IEnumerable<(TKey , IEnumerable<TFirst> First, IEnumerable<TSecond> Second)> FullGroupJoin<TFirst, TSecond, TKey>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TKey> firstKeySelector,
+ Func<TSecond, TKey> secondKeySelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function FullGroupJoin(Of TFirst, TSecond, TKey) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ firstKeySelector As Func(Of TFirst, TKey),
+ secondKeySelector As Func(Of TSecond, TKey),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of ( As TKey, First As IEnumerable(Of TFirst), Second As IEnumerable(Of TSecond)))public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TKey>
+static IEnumerable<ValueTuple<TKey, IEnumerable<TFirst>^, IEnumerable<TSecond>^>>^ FullGroupJoin(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TKey>^ firstKeySelector,
+ Func<TSecond, TKey>^ secondKeySelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member FullGroupJoin :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ firstKeySelector : Func<'TFirst, 'TKey> *
+ secondKeySelector : Func<'TSecond, 'TKey> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<ValueTuple<'TKey, IEnumerable<'TFirst>, IEnumerable<'TSecond>>> public static IEnumerable<TResult> FullGroupJoin<TFirst, TSecond, TKey, TResult>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TKey> firstKeySelector,
+ Func<TSecond, TKey> secondKeySelector,
+ Func<TKey, IEnumerable<TFirst>, IEnumerable<TSecond>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function FullGroupJoin(Of TFirst, TSecond, TKey, TResult) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ firstKeySelector As Func(Of TFirst, TKey),
+ secondKeySelector As Func(Of TSecond, TKey),
+ resultSelector As Func(Of TKey, IEnumerable(Of TFirst), IEnumerable(Of TSecond), TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TKey, typename TResult>
+static IEnumerable<TResult>^ FullGroupJoin(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TKey>^ firstKeySelector,
+ Func<TSecond, TKey>^ secondKeySelector,
+ Func<TKey, IEnumerable<TFirst>^, IEnumerable<TSecond>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member FullGroupJoin :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ firstKeySelector : Func<'TFirst, 'TKey> *
+ secondKeySelector : Func<'TSecond, 'TKey> *
+ resultSelector : Func<'TKey, IEnumerable<'TFirst>, IEnumerable<'TSecond>, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> FullGroupJoin<TFirst, TSecond, TKey, TResult>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TKey> firstKeySelector,
+ Func<TSecond, TKey> secondKeySelector,
+ Func<TKey, IEnumerable<TFirst>, IEnumerable<TSecond>, TResult> resultSelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function FullGroupJoin(Of TFirst, TSecond, TKey, TResult) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ firstKeySelector As Func(Of TFirst, TKey),
+ secondKeySelector As Func(Of TSecond, TKey),
+ resultSelector As Func(Of TKey, IEnumerable(Of TFirst), IEnumerable(Of TSecond), TResult),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TKey, typename TResult>
+static IEnumerable<TResult>^ FullGroupJoin(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TKey>^ firstKeySelector,
+ Func<TSecond, TKey>^ secondKeySelector,
+ Func<TKey, IEnumerable<TFirst>^, IEnumerable<TSecond>^, TResult>^ resultSelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member FullGroupJoin :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ firstKeySelector : Func<'TFirst, 'TKey> *
+ secondKeySelector : Func<'TSecond, 'TKey> *
+ resultSelector : Func<'TKey, IEnumerable<'TFirst>, IEnumerable<'TSecond>, 'TResult> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<'TResult> public static IEnumerable<TResult> FullJoin<TSource, TKey, TResult>(
+ this IEnumerable<TSource> first,
+ IEnumerable<TSource> second,
+ Func<TSource, TKey> keySelector,
+ Func<TSource, TResult> firstSelector,
+ Func<TSource, TResult> secondSelector,
+ Func<TSource, TSource, TResult> bothSelector
+)
+<ExtensionAttribute>
+Public Shared Function FullJoin(Of TSource, TKey, TResult) (
+ first As IEnumerable(Of TSource),
+ second As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ firstSelector As Func(Of TSource, TResult),
+ secondSelector As Func(Of TSource, TResult),
+ bothSelector As Func(Of TSource, TSource, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey, typename TResult>
+static IEnumerable<TResult>^ FullJoin(
+ IEnumerable<TSource>^ first,
+ IEnumerable<TSource>^ second,
+ Func<TSource, TKey>^ keySelector,
+ Func<TSource, TResult>^ firstSelector,
+ Func<TSource, TResult>^ secondSelector,
+ Func<TSource, TSource, TResult>^ bothSelector
+)[<ExtensionAttribute>]
+static member FullJoin :
+ first : IEnumerable<'TSource> *
+ second : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ firstSelector : Func<'TSource, 'TResult> *
+ secondSelector : Func<'TSource, 'TResult> *
+ bothSelector : Func<'TSource, 'TSource, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> FullJoin<TSource, TKey, TResult>(
+ this IEnumerable<TSource> first,
+ IEnumerable<TSource> second,
+ Func<TSource, TKey> keySelector,
+ Func<TSource, TResult> firstSelector,
+ Func<TSource, TResult> secondSelector,
+ Func<TSource, TSource, TResult> bothSelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function FullJoin(Of TSource, TKey, TResult) (
+ first As IEnumerable(Of TSource),
+ second As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ firstSelector As Func(Of TSource, TResult),
+ secondSelector As Func(Of TSource, TResult),
+ bothSelector As Func(Of TSource, TSource, TResult),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey, typename TResult>
+static IEnumerable<TResult>^ FullJoin(
+ IEnumerable<TSource>^ first,
+ IEnumerable<TSource>^ second,
+ Func<TSource, TKey>^ keySelector,
+ Func<TSource, TResult>^ firstSelector,
+ Func<TSource, TResult>^ secondSelector,
+ Func<TSource, TSource, TResult>^ bothSelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member FullJoin :
+ first : IEnumerable<'TSource> *
+ second : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ firstSelector : Func<'TSource, 'TResult> *
+ secondSelector : Func<'TSource, 'TResult> *
+ bothSelector : Func<'TSource, 'TSource, 'TResult> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<'TResult> public static IEnumerable<TResult> FullJoin<TFirst, TSecond, TKey, TResult>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TKey> firstKeySelector,
+ Func<TSecond, TKey> secondKeySelector,
+ Func<TFirst, TResult> firstSelector,
+ Func<TSecond, TResult> secondSelector,
+ Func<TFirst, TSecond, TResult> bothSelector
+)
+<ExtensionAttribute>
+Public Shared Function FullJoin(Of TFirst, TSecond, TKey, TResult) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ firstKeySelector As Func(Of TFirst, TKey),
+ secondKeySelector As Func(Of TSecond, TKey),
+ firstSelector As Func(Of TFirst, TResult),
+ secondSelector As Func(Of TSecond, TResult),
+ bothSelector As Func(Of TFirst, TSecond, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TKey, typename TResult>
+static IEnumerable<TResult>^ FullJoin(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TKey>^ firstKeySelector,
+ Func<TSecond, TKey>^ secondKeySelector,
+ Func<TFirst, TResult>^ firstSelector,
+ Func<TSecond, TResult>^ secondSelector,
+ Func<TFirst, TSecond, TResult>^ bothSelector
+)[<ExtensionAttribute>]
+static member FullJoin :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ firstKeySelector : Func<'TFirst, 'TKey> *
+ secondKeySelector : Func<'TSecond, 'TKey> *
+ firstSelector : Func<'TFirst, 'TResult> *
+ secondSelector : Func<'TSecond, 'TResult> *
+ bothSelector : Func<'TFirst, 'TSecond, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> FullJoin<TFirst, TSecond, TKey, TResult>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TKey> firstKeySelector,
+ Func<TSecond, TKey> secondKeySelector,
+ Func<TFirst, TResult> firstSelector,
+ Func<TSecond, TResult> secondSelector,
+ Func<TFirst, TSecond, TResult> bothSelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function FullJoin(Of TFirst, TSecond, TKey, TResult) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ firstKeySelector As Func(Of TFirst, TKey),
+ secondKeySelector As Func(Of TSecond, TKey),
+ firstSelector As Func(Of TFirst, TResult),
+ secondSelector As Func(Of TSecond, TResult),
+ bothSelector As Func(Of TFirst, TSecond, TResult),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TKey, typename TResult>
+static IEnumerable<TResult>^ FullJoin(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TKey>^ firstKeySelector,
+ Func<TSecond, TKey>^ secondKeySelector,
+ Func<TFirst, TResult>^ firstSelector,
+ Func<TSecond, TResult>^ secondSelector,
+ Func<TFirst, TSecond, TResult>^ bothSelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member FullJoin :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ firstKeySelector : Func<'TFirst, 'TKey> *
+ secondKeySelector : Func<'TSecond, 'TKey> *
+ firstSelector : Func<'TFirst, 'TResult> *
+ secondSelector : Func<'TSecond, 'TResult> *
+ bothSelector : Func<'TFirst, 'TSecond, 'TResult> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<'TResult> public static IEnumerable<TResult> GenerateByIndex<TResult>(
+ Func<int, TResult> generator
+)
+Public Shared Function GenerateByIndex(Of TResult) (
+ generator As Func(Of Integer, TResult)
+) As IEnumerable(Of TResult)public:
+generic<typename TResult>
+static IEnumerable<TResult>^ GenerateByIndex(
+ Func<int, TResult>^ generator
+)static member GenerateByIndex :
+ generator : Func<int, 'TResult> -> IEnumerable<'TResult> + The sequence is (practically) infinite where the index ranges from + zero to MaxValue inclusive.
+ This function defers execution and streams the results.
public static IEnumerable<TResult> Generate<TResult>(
+ TResult initial,
+ Func<TResult, TResult> generator
+)
+Public Shared Function Generate(Of TResult) (
+ initial As TResult,
+ generator As Func(Of TResult, TResult)
+) As IEnumerable(Of TResult)public:
+generic<typename TResult>
+static IEnumerable<TResult>^ Generate(
+ TResult initial,
+ Func<TResult, TResult>^ generator
+)static member Generate :
+ initial : 'TResult *
+ generator : Func<'TResult, 'TResult> -> IEnumerable<'TResult> var result = MoreEnumerable.Generate(2, n => n * n).Take(5);public static IEnumerable<IGrouping<TKey, TSource>> GroupAdjacent<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector
+)
+<ExtensionAttribute>
+Public Shared Function GroupAdjacent(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey)
+) As IEnumerable(Of IGrouping(Of TKey, TSource))public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<IGrouping<TKey, TSource>^>^ GroupAdjacent(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector
+)[<ExtensionAttribute>]
+static member GroupAdjacent :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> -> IEnumerable<IGrouping<'TKey, 'TSource>> public static IEnumerable<IGrouping<TKey, TSource>> GroupAdjacent<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function GroupAdjacent(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of IGrouping(Of TKey, TSource))public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<IGrouping<TKey, TSource>^>^ GroupAdjacent(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member GroupAdjacent :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<IGrouping<'TKey, 'TSource>> public static IEnumerable<IGrouping<TKey, TElement>> GroupAdjacent<TSource, TKey, TElement>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector,
+ Func<TSource, TElement> elementSelector
+)
+<ExtensionAttribute>
+Public Shared Function GroupAdjacent(Of TSource, TKey, TElement) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ elementSelector As Func(Of TSource, TElement)
+) As IEnumerable(Of IGrouping(Of TKey, TElement))public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey, typename TElement>
+static IEnumerable<IGrouping<TKey, TElement>^>^ GroupAdjacent(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector,
+ Func<TSource, TElement>^ elementSelector
+)[<ExtensionAttribute>]
+static member GroupAdjacent :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ elementSelector : Func<'TSource, 'TElement> -> IEnumerable<IGrouping<'TKey, 'TElement>> public static IEnumerable<IGrouping<TKey, TElement>> GroupAdjacent<TSource, TKey, TElement>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector,
+ Func<TSource, TElement> elementSelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function GroupAdjacent(Of TSource, TKey, TElement) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ elementSelector As Func(Of TSource, TElement),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of IGrouping(Of TKey, TElement))public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey, typename TElement>
+static IEnumerable<IGrouping<TKey, TElement>^>^ GroupAdjacent(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector,
+ Func<TSource, TElement>^ elementSelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member GroupAdjacent :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ elementSelector : Func<'TSource, 'TElement> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<IGrouping<'TKey, 'TElement>> public static IEnumerable<TResult> GroupAdjacent<TSource, TKey, TResult>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector,
+ Func<TKey, IEnumerable<TSource>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function GroupAdjacent(Of TSource, TKey, TResult) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ resultSelector As Func(Of TKey, IEnumerable(Of TSource), TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey, typename TResult>
+static IEnumerable<TResult>^ GroupAdjacent(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector,
+ Func<TKey, IEnumerable<TSource>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member GroupAdjacent :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ resultSelector : Func<'TKey, IEnumerable<'TSource>, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> GroupAdjacent<TSource, TKey, TResult>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector,
+ Func<TKey, IEnumerable<TSource>, TResult> resultSelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function GroupAdjacent(Of TSource, TKey, TResult) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ resultSelector As Func(Of TKey, IEnumerable(Of TSource), TResult),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey, typename TResult>
+static IEnumerable<TResult>^ GroupAdjacent(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector,
+ Func<TKey, IEnumerable<TSource>^, TResult>^ resultSelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member GroupAdjacent :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ resultSelector : Func<'TKey, IEnumerable<'TSource>, 'TResult> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<'TResult> public static IEnumerable<KeyValuePair<int, TSource>> IndexBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector
+)
+<ExtensionAttribute>
+Public Shared Function IndexBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey)
+) As IEnumerable(Of KeyValuePair(Of Integer, TSource))public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<KeyValuePair<int, TSource>>^ IndexBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector
+)[<ExtensionAttribute>]
+static member IndexBy :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> -> IEnumerable<KeyValuePair<int, 'TSource>> public static IEnumerable<KeyValuePair<int, TSource>> IndexBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function IndexBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of KeyValuePair(Of Integer, TSource))public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<KeyValuePair<int, TSource>>^ IndexBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member IndexBy :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<KeyValuePair<int, 'TSource>> public static IEnumerable<KeyValuePair<int, TSource>> Index<TSource>(
+ this IEnumerable<TSource> source
+)
+<ExtensionAttribute>
+Public Shared Function Index(Of TSource) (
+ source As IEnumerable(Of TSource)
+) As IEnumerable(Of KeyValuePair(Of Integer, TSource))public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<KeyValuePair<int, TSource>>^ Index(
+ IEnumerable<TSource>^ source
+)[<ExtensionAttribute>]
+static member Index :
+ source : IEnumerable<'TSource> -> IEnumerable<KeyValuePair<int, 'TSource>> public static IEnumerable<KeyValuePair<int, TSource>> Index<TSource>(
+ this IEnumerable<TSource> source,
+ int startIndex
+)
+<ExtensionAttribute>
+Public Shared Function Index(Of TSource) (
+ source As IEnumerable(Of TSource),
+ startIndex As Integer
+) As IEnumerable(Of KeyValuePair(Of Integer, TSource))public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<KeyValuePair<int, TSource>>^ Index(
+ IEnumerable<TSource>^ source,
+ int startIndex
+)[<ExtensionAttribute>]
+static member Index :
+ source : IEnumerable<'TSource> *
+ startIndex : int -> IEnumerable<KeyValuePair<int, 'TSource>> public static IEnumerable<T> Insert<T>(
+ this IEnumerable<T> first,
+ IEnumerable<T> second,
+ int index
+)
+<ExtensionAttribute>
+Public Shared Function Insert(Of T) (
+ first As IEnumerable(Of T),
+ second As IEnumerable(Of T),
+ index As Integer
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Insert(
+ IEnumerable<T>^ first,
+ IEnumerable<T>^ second,
+ int index
+)[<ExtensionAttribute>]
+static member Insert :
+ first : IEnumerable<'T> *
+ second : IEnumerable<'T> *
+ index : int -> IEnumerable<'T> | ArgumentNullException | first is null. |
| ArgumentNullException | second is null. |
| ArgumentOutOfRangeException | + Thrown if index is negative. + |
| ArgumentOutOfRangeException | + Thrown lazily if index is greater than the + length of first. The validation occurs when + yielding the next element after having iterated + first entirely. + |
public static IEnumerable<T> Interleave<T>(
+ this IEnumerable<T> sequence,
+ params IEnumerable<T>[] otherSequences
+)
+<ExtensionAttribute>
+Public Shared Function Interleave(Of T) (
+ sequence As IEnumerable(Of T),
+ ParamArray otherSequences As IEnumerable(Of T)()
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Interleave(
+ IEnumerable<T>^ sequence,
+ ... array<IEnumerable<T>^>^ otherSequences
+)[<ExtensionAttribute>]
+static member Interleave :
+ sequence : IEnumerable<'T> *
+ otherSequences : IEnumerable<'T>[] -> IEnumerable<'T> + 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:
var xs = new[] { 1, 1, 1 }.Interleave(new[] { 2, 2, 2 }, new[] { 3, 3, 3 });
+// xs = { 1, 2, 3, 1, 2, 3, 1, 2, 3 }+ This operator behaves in a deferred and streaming manner.
+ When sequences are of unequal length, this method will skip those sequences that have + been fully consumed and continue interleaving the remaining sequences.
+ The sequences are interleaved in the order that they appear in the otherSequences collection, with sequence as the first + sequence.
public static IEnumerable<TResult> Lag<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ int offset,
+ Func<TSource, TSource, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Lag(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ offset As Integer,
+ resultSelector As Func(Of TSource, TSource, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ Lag(
+ IEnumerable<TSource>^ source,
+ int offset,
+ Func<TSource, TSource, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Lag :
+ source : IEnumerable<'TSource> *
+ offset : int *
+ resultSelector : Func<'TSource, 'TSource, 'TResult> -> IEnumerable<'TResult> + This operator evaluates in a deferred and streaming manner.
+ For elements prior to the lag offset, default(T) is used as the lagged + value.
public static IEnumerable<TResult> Lag<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ int offset,
+ TSource defaultLagValue,
+ Func<TSource, TSource, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Lag(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ offset As Integer,
+ defaultLagValue As TSource,
+ resultSelector As Func(Of TSource, TSource, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ Lag(
+ IEnumerable<TSource>^ source,
+ int offset,
+ TSource defaultLagValue,
+ Func<TSource, TSource, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Lag :
+ source : IEnumerable<'TSource> *
+ offset : int *
+ defaultLagValue : 'TSource *
+ resultSelector : Func<'TSource, 'TSource, 'TResult> -> IEnumerable<'TResult> public static T LastOrDefault<T>(
+ this IExtremaEnumerable<T> source
+)
+<ExtensionAttribute>
+Public Shared Function LastOrDefault(Of T) (
+ source As IExtremaEnumerable(Of T)
+) As Tpublic:
+[ExtensionAttribute]
+generic<typename T>
+static T LastOrDefault(
+ IExtremaEnumerable<T>^ source
+)[<ExtensionAttribute>]
+static member LastOrDefault :
+ source : IExtremaEnumerable<'T> -> 'T public static T Last<T>(
+ this IExtremaEnumerable<T> source
+)
+<ExtensionAttribute>
+Public Shared Function Last(Of T) (
+ source As IExtremaEnumerable(Of T)
+) As Tpublic:
+[ExtensionAttribute]
+generic<typename T>
+static T Last(
+ IExtremaEnumerable<T>^ source
+)[<ExtensionAttribute>]
+static member Last :
+ source : IExtremaEnumerable<'T> -> 'T | InvalidOperationException | + The input sequence is empty. |
public static IEnumerable<TResult> Lead<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ int offset,
+ Func<TSource, TSource, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Lead(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ offset As Integer,
+ resultSelector As Func(Of TSource, TSource, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ Lead(
+ IEnumerable<TSource>^ source,
+ int offset,
+ Func<TSource, TSource, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Lead :
+ source : IEnumerable<'TSource> *
+ offset : int *
+ resultSelector : Func<'TSource, 'TSource, 'TResult> -> IEnumerable<'TResult> + This operator evaluates in a deferred and streaming manner.
+ For elements of the sequence that are less than offset items from the + end, default(T) is used as the lead value.
public static IEnumerable<TResult> Lead<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ int offset,
+ TSource defaultLeadValue,
+ Func<TSource, TSource, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Lead(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ offset As Integer,
+ defaultLeadValue As TSource,
+ resultSelector As Func(Of TSource, TSource, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ Lead(
+ IEnumerable<TSource>^ source,
+ int offset,
+ TSource defaultLeadValue,
+ Func<TSource, TSource, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Lead :
+ source : IEnumerable<'TSource> *
+ offset : int *
+ defaultLeadValue : 'TSource *
+ resultSelector : Func<'TSource, 'TSource, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> LeftJoin<TSource, TKey, TResult>(
+ this IEnumerable<TSource> first,
+ IEnumerable<TSource> second,
+ Func<TSource, TKey> keySelector,
+ Func<TSource, TResult> firstSelector,
+ Func<TSource, TSource, TResult> bothSelector
+)
+<ExtensionAttribute>
+Public Shared Function LeftJoin(Of TSource, TKey, TResult) (
+ first As IEnumerable(Of TSource),
+ second As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ firstSelector As Func(Of TSource, TResult),
+ bothSelector As Func(Of TSource, TSource, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey, typename TResult>
+static IEnumerable<TResult>^ LeftJoin(
+ IEnumerable<TSource>^ first,
+ IEnumerable<TSource>^ second,
+ Func<TSource, TKey>^ keySelector,
+ Func<TSource, TResult>^ firstSelector,
+ Func<TSource, TSource, TResult>^ bothSelector
+)[<ExtensionAttribute>]
+static member LeftJoin :
+ first : IEnumerable<'TSource> *
+ second : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ firstSelector : Func<'TSource, 'TResult> *
+ bothSelector : Func<'TSource, 'TSource, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> LeftJoin<TSource, TKey, TResult>(
+ this IEnumerable<TSource> first,
+ IEnumerable<TSource> second,
+ Func<TSource, TKey> keySelector,
+ Func<TSource, TResult> firstSelector,
+ Func<TSource, TSource, TResult> bothSelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function LeftJoin(Of TSource, TKey, TResult) (
+ first As IEnumerable(Of TSource),
+ second As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ firstSelector As Func(Of TSource, TResult),
+ bothSelector As Func(Of TSource, TSource, TResult),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey, typename TResult>
+static IEnumerable<TResult>^ LeftJoin(
+ IEnumerable<TSource>^ first,
+ IEnumerable<TSource>^ second,
+ Func<TSource, TKey>^ keySelector,
+ Func<TSource, TResult>^ firstSelector,
+ Func<TSource, TSource, TResult>^ bothSelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member LeftJoin :
+ first : IEnumerable<'TSource> *
+ second : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ firstSelector : Func<'TSource, 'TResult> *
+ bothSelector : Func<'TSource, 'TSource, 'TResult> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<'TResult> public static IEnumerable<TResult> LeftJoin<TFirst, TSecond, TKey, TResult>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TKey> firstKeySelector,
+ Func<TSecond, TKey> secondKeySelector,
+ Func<TFirst, TResult> firstSelector,
+ Func<TFirst, TSecond, TResult> bothSelector
+)
+<ExtensionAttribute>
+Public Shared Function LeftJoin(Of TFirst, TSecond, TKey, TResult) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ firstKeySelector As Func(Of TFirst, TKey),
+ secondKeySelector As Func(Of TSecond, TKey),
+ firstSelector As Func(Of TFirst, TResult),
+ bothSelector As Func(Of TFirst, TSecond, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TKey, typename TResult>
+static IEnumerable<TResult>^ LeftJoin(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TKey>^ firstKeySelector,
+ Func<TSecond, TKey>^ secondKeySelector,
+ Func<TFirst, TResult>^ firstSelector,
+ Func<TFirst, TSecond, TResult>^ bothSelector
+)[<ExtensionAttribute>]
+static member LeftJoin :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ firstKeySelector : Func<'TFirst, 'TKey> *
+ secondKeySelector : Func<'TSecond, 'TKey> *
+ firstSelector : Func<'TFirst, 'TResult> *
+ bothSelector : Func<'TFirst, 'TSecond, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> LeftJoin<TFirst, TSecond, TKey, TResult>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TKey> firstKeySelector,
+ Func<TSecond, TKey> secondKeySelector,
+ Func<TFirst, TResult> firstSelector,
+ Func<TFirst, TSecond, TResult> bothSelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function LeftJoin(Of TFirst, TSecond, TKey, TResult) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ firstKeySelector As Func(Of TFirst, TKey),
+ secondKeySelector As Func(Of TSecond, TKey),
+ firstSelector As Func(Of TFirst, TResult),
+ bothSelector As Func(Of TFirst, TSecond, TResult),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TKey, typename TResult>
+static IEnumerable<TResult>^ LeftJoin(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TKey>^ firstKeySelector,
+ Func<TSecond, TKey>^ secondKeySelector,
+ Func<TFirst, TResult>^ firstSelector,
+ Func<TFirst, TSecond, TResult>^ bothSelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member LeftJoin :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ firstKeySelector : Func<'TFirst, 'TKey> *
+ secondKeySelector : Func<'TSecond, 'TKey> *
+ firstSelector : Func<'TFirst, 'TResult> *
+ bothSelector : Func<'TFirst, 'TSecond, 'TResult> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<'TResult> public static IExtremaEnumerable<TSource> MaxBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> selector
+)
+<ExtensionAttribute>
+Public Shared Function MaxBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ selector As Func(Of TSource, TKey)
+) As IExtremaEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IExtremaEnumerable<TSource>^ MaxBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ selector
+)[<ExtensionAttribute>]
+static member MaxBy :
+ source : IEnumerable<'TSource> *
+ selector : Func<'TSource, 'TKey> -> IExtremaEnumerable<'TSource> | ArgumentNullException | source or selector is null |
public static IExtremaEnumerable<TSource> MaxBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> selector,
+ IComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function MaxBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ selector As Func(Of TSource, TKey),
+ comparer As IComparer(Of TKey)
+) As IExtremaEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IExtremaEnumerable<TSource>^ MaxBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ selector,
+ IComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member MaxBy :
+ source : IEnumerable<'TSource> *
+ selector : Func<'TSource, 'TKey> *
+ comparer : IComparer<'TKey> -> IExtremaEnumerable<'TSource> | ArgumentNullException | source, selector + or comparer is null |
public static IExtremaEnumerable<TSource> MinBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> selector
+)
+<ExtensionAttribute>
+Public Shared Function MinBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ selector As Func(Of TSource, TKey)
+) As IExtremaEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IExtremaEnumerable<TSource>^ MinBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ selector
+)[<ExtensionAttribute>]
+static member MinBy :
+ source : IEnumerable<'TSource> *
+ selector : Func<'TSource, 'TKey> -> IExtremaEnumerable<'TSource> | ArgumentNullException | source or selector is null |
public static IExtremaEnumerable<TSource> MinBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> selector,
+ IComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function MinBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ selector As Func(Of TSource, TKey),
+ comparer As IComparer(Of TKey)
+) As IExtremaEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IExtremaEnumerable<TSource>^ MinBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ selector,
+ IComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member MinBy :
+ source : IEnumerable<'TSource> *
+ selector : Func<'TSource, 'TKey> *
+ comparer : IComparer<'TKey> -> IExtremaEnumerable<'TSource> | ArgumentNullException | source, selector + or comparer is null |
public static IEnumerable<T> Move<T>(
+ this IEnumerable<T> source,
+ int fromIndex,
+ int count,
+ int toIndex
+)
+<ExtensionAttribute>
+Public Shared Function Move(Of T) (
+ source As IEnumerable(Of T),
+ fromIndex As Integer,
+ count As Integer,
+ toIndex As Integer
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Move(
+ IEnumerable<T>^ source,
+ int fromIndex,
+ int count,
+ int toIndex
+)[<ExtensionAttribute>]
+static member Move :
+ source : IEnumerable<'T> *
+ fromIndex : int *
+ count : int *
+ toIndex : int -> IEnumerable<'T> var result = Enumerable.Range(0, 6).Move(3, 2, 0);public static IOrderedEnumerable<T> OrderBy<T, TKey>(
+ this IEnumerable<T> source,
+ Func<T, TKey> keySelector,
+ OrderByDirection direction
+)
+<ExtensionAttribute>
+Public Shared Function OrderBy(Of T, TKey) (
+ source As IEnumerable(Of T),
+ keySelector As Func(Of T, TKey),
+ direction As OrderByDirection
+) As IOrderedEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T, typename TKey>
+static IOrderedEnumerable<T>^ OrderBy(
+ IEnumerable<T>^ source,
+ Func<T, TKey>^ keySelector,
+ OrderByDirection direction
+)[<ExtensionAttribute>]
+static member OrderBy :
+ source : IEnumerable<'T> *
+ keySelector : Func<'T, 'TKey> *
+ direction : OrderByDirection -> IOrderedEnumerable<'T> public static IOrderedEnumerable<T> OrderBy<T, TKey>(
+ this IEnumerable<T> source,
+ Func<T, TKey> keySelector,
+ IComparer<TKey>? comparer,
+ OrderByDirection direction
+)
+<ExtensionAttribute>
+Public Shared Function OrderBy(Of T, TKey) (
+ source As IEnumerable(Of T),
+ keySelector As Func(Of T, TKey),
+ comparer As IComparer(Of TKey),
+ direction As OrderByDirection
+) As IOrderedEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T, typename TKey>
+static IOrderedEnumerable<T>^ OrderBy(
+ IEnumerable<T>^ source,
+ Func<T, TKey>^ keySelector,
+ IComparer<TKey>^ comparer,
+ OrderByDirection direction
+)[<ExtensionAttribute>]
+static member OrderBy :
+ source : IEnumerable<'T> *
+ keySelector : Func<'T, 'TKey> *
+ comparer : IComparer<'TKey> *
+ direction : OrderByDirection -> IOrderedEnumerable<'T> public static IEnumerable<T> OrderedMerge<T>(
+ this IEnumerable<T> first,
+ IEnumerable<T> second
+)
+<ExtensionAttribute>
+Public Shared Function OrderedMerge(Of T) (
+ first As IEnumerable(Of T),
+ second As IEnumerable(Of T)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ OrderedMerge(
+ IEnumerable<T>^ first,
+ IEnumerable<T>^ second
+)[<ExtensionAttribute>]
+static member OrderedMerge :
+ first : IEnumerable<'T> *
+ second : IEnumerable<'T> -> IEnumerable<'T> public static IEnumerable<T> OrderedMerge<T>(
+ this IEnumerable<T> first,
+ IEnumerable<T> second,
+ IComparer<T>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function OrderedMerge(Of T) (
+ first As IEnumerable(Of T),
+ second As IEnumerable(Of T),
+ comparer As IComparer(Of T)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ OrderedMerge(
+ IEnumerable<T>^ first,
+ IEnumerable<T>^ second,
+ IComparer<T>^ comparer
+)[<ExtensionAttribute>]
+static member OrderedMerge :
+ first : IEnumerable<'T> *
+ second : IEnumerable<'T> *
+ comparer : IComparer<'T> -> IEnumerable<'T> public static IEnumerable<T> OrderedMerge<T, TKey>(
+ this IEnumerable<T> first,
+ IEnumerable<T> second,
+ Func<T, TKey> keySelector
+)
+<ExtensionAttribute>
+Public Shared Function OrderedMerge(Of T, TKey) (
+ first As IEnumerable(Of T),
+ second As IEnumerable(Of T),
+ keySelector As Func(Of T, TKey)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T, typename TKey>
+static IEnumerable<T>^ OrderedMerge(
+ IEnumerable<T>^ first,
+ IEnumerable<T>^ second,
+ Func<T, TKey>^ keySelector
+)[<ExtensionAttribute>]
+static member OrderedMerge :
+ first : IEnumerable<'T> *
+ second : IEnumerable<'T> *
+ keySelector : Func<'T, 'TKey> -> IEnumerable<'T> public static IEnumerable<TResult> OrderedMerge<T, TKey, TResult>(
+ this IEnumerable<T> first,
+ IEnumerable<T> second,
+ Func<T, TKey> keySelector,
+ Func<T, TResult> firstSelector,
+ Func<T, TResult> secondSelector,
+ Func<T, T, TResult> bothSelector
+)
+<ExtensionAttribute>
+Public Shared Function OrderedMerge(Of T, TKey, TResult) (
+ first As IEnumerable(Of T),
+ second As IEnumerable(Of T),
+ keySelector As Func(Of T, TKey),
+ firstSelector As Func(Of T, TResult),
+ secondSelector As Func(Of T, TResult),
+ bothSelector As Func(Of T, T, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T, typename TKey, typename TResult>
+static IEnumerable<TResult>^ OrderedMerge(
+ IEnumerable<T>^ first,
+ IEnumerable<T>^ second,
+ Func<T, TKey>^ keySelector,
+ Func<T, TResult>^ firstSelector,
+ Func<T, TResult>^ secondSelector,
+ Func<T, T, TResult>^ bothSelector
+)[<ExtensionAttribute>]
+static member OrderedMerge :
+ first : IEnumerable<'T> *
+ second : IEnumerable<'T> *
+ keySelector : Func<'T, 'TKey> *
+ firstSelector : Func<'T, 'TResult> *
+ secondSelector : Func<'T, 'TResult> *
+ bothSelector : Func<'T, 'T, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> OrderedMerge<T, TKey, TResult>(
+ this IEnumerable<T> first,
+ IEnumerable<T> second,
+ Func<T, TKey> keySelector,
+ Func<T, TResult> firstSelector,
+ Func<T, TResult> secondSelector,
+ Func<T, T, TResult> bothSelector,
+ IComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function OrderedMerge(Of T, TKey, TResult) (
+ first As IEnumerable(Of T),
+ second As IEnumerable(Of T),
+ keySelector As Func(Of T, TKey),
+ firstSelector As Func(Of T, TResult),
+ secondSelector As Func(Of T, TResult),
+ bothSelector As Func(Of T, T, TResult),
+ comparer As IComparer(Of TKey)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T, typename TKey, typename TResult>
+static IEnumerable<TResult>^ OrderedMerge(
+ IEnumerable<T>^ first,
+ IEnumerable<T>^ second,
+ Func<T, TKey>^ keySelector,
+ Func<T, TResult>^ firstSelector,
+ Func<T, TResult>^ secondSelector,
+ Func<T, T, TResult>^ bothSelector,
+ IComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member OrderedMerge :
+ first : IEnumerable<'T> *
+ second : IEnumerable<'T> *
+ keySelector : Func<'T, 'TKey> *
+ firstSelector : Func<'T, 'TResult> *
+ secondSelector : Func<'T, 'TResult> *
+ bothSelector : Func<'T, 'T, 'TResult> *
+ comparer : IComparer<'TKey> -> IEnumerable<'TResult> public static IEnumerable<TResult> OrderedMerge<TFirst, TSecond, TKey, TResult>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TKey> firstKeySelector,
+ Func<TSecond, TKey> secondKeySelector,
+ Func<TFirst, TResult> firstSelector,
+ Func<TSecond, TResult> secondSelector,
+ Func<TFirst, TSecond, TResult> bothSelector
+)
+<ExtensionAttribute>
+Public Shared Function OrderedMerge(Of TFirst, TSecond, TKey, TResult) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ firstKeySelector As Func(Of TFirst, TKey),
+ secondKeySelector As Func(Of TSecond, TKey),
+ firstSelector As Func(Of TFirst, TResult),
+ secondSelector As Func(Of TSecond, TResult),
+ bothSelector As Func(Of TFirst, TSecond, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TKey, typename TResult>
+static IEnumerable<TResult>^ OrderedMerge(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TKey>^ firstKeySelector,
+ Func<TSecond, TKey>^ secondKeySelector,
+ Func<TFirst, TResult>^ firstSelector,
+ Func<TSecond, TResult>^ secondSelector,
+ Func<TFirst, TSecond, TResult>^ bothSelector
+)[<ExtensionAttribute>]
+static member OrderedMerge :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ firstKeySelector : Func<'TFirst, 'TKey> *
+ secondKeySelector : Func<'TSecond, 'TKey> *
+ firstSelector : Func<'TFirst, 'TResult> *
+ secondSelector : Func<'TSecond, 'TResult> *
+ bothSelector : Func<'TFirst, 'TSecond, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> OrderedMerge<TFirst, TSecond, TKey, TResult>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TKey> firstKeySelector,
+ Func<TSecond, TKey> secondKeySelector,
+ Func<TFirst, TResult> firstSelector,
+ Func<TSecond, TResult> secondSelector,
+ Func<TFirst, TSecond, TResult> bothSelector,
+ IComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function OrderedMerge(Of TFirst, TSecond, TKey, TResult) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ firstKeySelector As Func(Of TFirst, TKey),
+ secondKeySelector As Func(Of TSecond, TKey),
+ firstSelector As Func(Of TFirst, TResult),
+ secondSelector As Func(Of TSecond, TResult),
+ bothSelector As Func(Of TFirst, TSecond, TResult),
+ comparer As IComparer(Of TKey)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TKey, typename TResult>
+static IEnumerable<TResult>^ OrderedMerge(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TKey>^ firstKeySelector,
+ Func<TSecond, TKey>^ secondKeySelector,
+ Func<TFirst, TResult>^ firstSelector,
+ Func<TSecond, TResult>^ secondSelector,
+ Func<TFirst, TSecond, TResult>^ bothSelector,
+ IComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member OrderedMerge :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ firstKeySelector : Func<'TFirst, 'TKey> *
+ secondKeySelector : Func<'TSecond, 'TKey> *
+ firstSelector : Func<'TFirst, 'TResult> *
+ secondSelector : Func<'TSecond, 'TResult> *
+ bothSelector : Func<'TFirst, 'TSecond, 'TResult> *
+ comparer : IComparer<'TKey> -> IEnumerable<'TResult> public static IEnumerable<TSource> PadStart<TSource>(
+ this IEnumerable<TSource> source,
+ int width
+)
+<ExtensionAttribute>
+Public Shared Function PadStart(Of TSource) (
+ source As IEnumerable(Of TSource),
+ width As Integer
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ PadStart(
+ IEnumerable<TSource>^ source,
+ int width
+)[<ExtensionAttribute>]
+static member PadStart :
+ source : IEnumerable<'TSource> *
+ width : int -> IEnumerable<'TSource> int[] numbers = { 123, 456, 789 };
+var result = numbers.PadStart(5);public static IEnumerable<TSource> PadStart<TSource>(
+ this IEnumerable<TSource> source,
+ int width,
+ Func<int, TSource> paddingSelector
+)
+<ExtensionAttribute>
+Public Shared Function PadStart(Of TSource) (
+ source As IEnumerable(Of TSource),
+ width As Integer,
+ paddingSelector As Func(Of Integer, TSource)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ PadStart(
+ IEnumerable<TSource>^ source,
+ int width,
+ Func<int, TSource>^ paddingSelector
+)[<ExtensionAttribute>]
+static member PadStart :
+ source : IEnumerable<'TSource> *
+ width : int *
+ paddingSelector : Func<int, 'TSource> -> IEnumerable<'TSource> int[] numbers = { 123, 456, 789 };
+var result = numbers.PadStart(6, i => -i);public static IEnumerable<TSource> PadStart<TSource>(
+ this IEnumerable<TSource> source,
+ int width,
+ TSource padding
+)
+<ExtensionAttribute>
+Public Shared Function PadStart(Of TSource) (
+ source As IEnumerable(Of TSource),
+ width As Integer,
+ padding As TSource
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ PadStart(
+ IEnumerable<TSource>^ source,
+ int width,
+ TSource padding
+)[<ExtensionAttribute>]
+static member PadStart :
+ source : IEnumerable<'TSource> *
+ width : int *
+ padding : 'TSource -> IEnumerable<'TSource> int[] numbers = { 123, 456, 789 };
+var result = numbers.PadStart(5, -1);public static IEnumerable<TSource> Pad<TSource>(
+ this IEnumerable<TSource> source,
+ int width
+)
+<ExtensionAttribute>
+Public Shared Function Pad(Of TSource) (
+ source As IEnumerable(Of TSource),
+ width As Integer
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ Pad(
+ IEnumerable<TSource>^ source,
+ int width
+)[<ExtensionAttribute>]
+static member Pad :
+ source : IEnumerable<'TSource> *
+ width : int -> IEnumerable<'TSource> int[] numbers = { 123, 456, 789 };
+var result = numbers.Pad(5);public static IEnumerable<TSource> Pad<TSource>(
+ this IEnumerable<TSource> source,
+ int width,
+ Func<int, TSource> paddingSelector
+)
+<ExtensionAttribute>
+Public Shared Function Pad(Of TSource) (
+ source As IEnumerable(Of TSource),
+ width As Integer,
+ paddingSelector As Func(Of Integer, TSource)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ Pad(
+ IEnumerable<TSource>^ source,
+ int width,
+ Func<int, TSource>^ paddingSelector
+)[<ExtensionAttribute>]
+static member Pad :
+ source : IEnumerable<'TSource> *
+ width : int *
+ paddingSelector : Func<int, 'TSource> -> IEnumerable<'TSource> int[] numbers = { 0, 1, 2 };
+var result = numbers.Pad(5, i => -i);public static IEnumerable<TSource> Pad<TSource>(
+ this IEnumerable<TSource> source,
+ int width,
+ TSource padding
+)
+<ExtensionAttribute>
+Public Shared Function Pad(Of TSource) (
+ source As IEnumerable(Of TSource),
+ width As Integer,
+ padding As TSource
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ Pad(
+ IEnumerable<TSource>^ source,
+ int width,
+ TSource padding
+)[<ExtensionAttribute>]
+static member Pad :
+ source : IEnumerable<'TSource> *
+ width : int *
+ padding : 'TSource -> IEnumerable<'TSource> int[] numbers = { 123, 456, 789 };
+var result = numbers.Pad(5, -1);public static IEnumerable<TResult> Pairwise<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TSource, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Pairwise(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ resultSelector As Func(Of TSource, TSource, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ Pairwise(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TSource, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Pairwise :
+ source : IEnumerable<'TSource> *
+ resultSelector : Func<'TSource, 'TSource, 'TResult> -> IEnumerable<'TResult> var source = new[] { "a", "b", "c", "d" };
+var result = source.Pairwise((a, b) => a + b);public static IEnumerable<TSource> PartialSortBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ int count,
+ Func<TSource, TKey> keySelector
+)
+<ExtensionAttribute>
+Public Shared Function PartialSortBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ count As Integer,
+ keySelector As Func(Of TSource, TKey)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<TSource>^ PartialSortBy(
+ IEnumerable<TSource>^ source,
+ int count,
+ Func<TSource, TKey>^ keySelector
+)[<ExtensionAttribute>]
+static member PartialSortBy :
+ source : IEnumerable<'TSource> *
+ count : int *
+ keySelector : Func<'TSource, 'TKey> -> IEnumerable<'TSource> public static IEnumerable<TSource> PartialSortBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ int count,
+ Func<TSource, TKey> keySelector,
+ OrderByDirection direction
+)
+<ExtensionAttribute>
+Public Shared Function PartialSortBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ count As Integer,
+ keySelector As Func(Of TSource, TKey),
+ direction As OrderByDirection
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<TSource>^ PartialSortBy(
+ IEnumerable<TSource>^ source,
+ int count,
+ Func<TSource, TKey>^ keySelector,
+ OrderByDirection direction
+)[<ExtensionAttribute>]
+static member PartialSortBy :
+ source : IEnumerable<'TSource> *
+ count : int *
+ keySelector : Func<'TSource, 'TKey> *
+ direction : OrderByDirection -> IEnumerable<'TSource> public static IEnumerable<TSource> PartialSortBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ int count,
+ Func<TSource, TKey> keySelector,
+ IComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function PartialSortBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ count As Integer,
+ keySelector As Func(Of TSource, TKey),
+ comparer As IComparer(Of TKey)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<TSource>^ PartialSortBy(
+ IEnumerable<TSource>^ source,
+ int count,
+ Func<TSource, TKey>^ keySelector,
+ IComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member PartialSortBy :
+ source : IEnumerable<'TSource> *
+ count : int *
+ keySelector : Func<'TSource, 'TKey> *
+ comparer : IComparer<'TKey> -> IEnumerable<'TSource> public static IEnumerable<TSource> PartialSortBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ int count,
+ Func<TSource, TKey> keySelector,
+ IComparer<TKey>? comparer,
+ OrderByDirection direction
+)
+<ExtensionAttribute>
+Public Shared Function PartialSortBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ count As Integer,
+ keySelector As Func(Of TSource, TKey),
+ comparer As IComparer(Of TKey),
+ direction As OrderByDirection
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<TSource>^ PartialSortBy(
+ IEnumerable<TSource>^ source,
+ int count,
+ Func<TSource, TKey>^ keySelector,
+ IComparer<TKey>^ comparer,
+ OrderByDirection direction
+)[<ExtensionAttribute>]
+static member PartialSortBy :
+ source : IEnumerable<'TSource> *
+ count : int *
+ keySelector : Func<'TSource, 'TKey> *
+ comparer : IComparer<'TKey> *
+ direction : OrderByDirection -> IEnumerable<'TSource> public static IEnumerable<T> PartialSort<T>(
+ this IEnumerable<T> source,
+ int count
+)
+<ExtensionAttribute>
+Public Shared Function PartialSort(Of T) (
+ source As IEnumerable(Of T),
+ count As Integer
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ PartialSort(
+ IEnumerable<T>^ source,
+ int count
+)[<ExtensionAttribute>]
+static member PartialSort :
+ source : IEnumerable<'T> *
+ count : int -> IEnumerable<'T> public static IEnumerable<T> PartialSort<T>(
+ this IEnumerable<T> source,
+ int count,
+ OrderByDirection direction
+)
+<ExtensionAttribute>
+Public Shared Function PartialSort(Of T) (
+ source As IEnumerable(Of T),
+ count As Integer,
+ direction As OrderByDirection
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ PartialSort(
+ IEnumerable<T>^ source,
+ int count,
+ OrderByDirection direction
+)[<ExtensionAttribute>]
+static member PartialSort :
+ source : IEnumerable<'T> *
+ count : int *
+ direction : OrderByDirection -> IEnumerable<'T> public static IEnumerable<T> PartialSort<T>(
+ this IEnumerable<T> source,
+ int count,
+ IComparer<T>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function PartialSort(Of T) (
+ source As IEnumerable(Of T),
+ count As Integer,
+ comparer As IComparer(Of T)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ PartialSort(
+ IEnumerable<T>^ source,
+ int count,
+ IComparer<T>^ comparer
+)[<ExtensionAttribute>]
+static member PartialSort :
+ source : IEnumerable<'T> *
+ count : int *
+ comparer : IComparer<'T> -> IEnumerable<'T> public static IEnumerable<T> PartialSort<T>(
+ this IEnumerable<T> source,
+ int count,
+ IComparer<T>? comparer,
+ OrderByDirection direction
+)
+<ExtensionAttribute>
+Public Shared Function PartialSort(Of T) (
+ source As IEnumerable(Of T),
+ count As Integer,
+ comparer As IComparer(Of T),
+ direction As OrderByDirection
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ PartialSort(
+ IEnumerable<T>^ source,
+ int count,
+ IComparer<T>^ comparer,
+ OrderByDirection direction
+)[<ExtensionAttribute>]
+static member PartialSort :
+ source : IEnumerable<'T> *
+ count : int *
+ comparer : IComparer<'T> *
+ direction : OrderByDirection -> IEnumerable<'T> public static (IEnumerable<T> True, IEnumerable<T> False) Partition<T>(
+ this IEnumerable<T> source,
+ Func<T, bool> predicate
+)
+<ExtensionAttribute>
+Public Shared Function Partition(Of T) (
+ source As IEnumerable(Of T),
+ predicate As Func(Of T, Boolean)
+) As (True As IEnumerable(Of T), False As IEnumerable(Of T))public:
+[ExtensionAttribute]
+generic<typename T>
+static ValueTuple<IEnumerable<T>^, IEnumerable<T>^> Partition(
+ IEnumerable<T>^ source,
+ Func<T, bool>^ predicate
+)[<ExtensionAttribute>]
+static member Partition :
+ source : IEnumerable<'T> *
+ predicate : Func<'T, bool> -> ValueTuple<IEnumerable<'T>, IEnumerable<'T>> var (evens, odds) =
+ Enumerable.Range(0, 10).Partition(x => x % 2 == 0);| ArgumentNullException | source is + . |
public static TResult Partition<T, TResult>(
+ this IEnumerable<IGrouping<bool, T>> source,
+ Func<IEnumerable<T>, IEnumerable<T>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Partition(Of T, TResult) (
+ source As IEnumerable(Of IGrouping(Of Boolean, T)),
+ resultSelector As Func(Of IEnumerable(Of T), IEnumerable(Of T), TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Partition(
+ IEnumerable<IGrouping<bool, T>^>^ source,
+ Func<IEnumerable<T>^, IEnumerable<T>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Partition :
+ source : IEnumerable<IGrouping<bool, 'T>> *
+ resultSelector : Func<IEnumerable<'T>, IEnumerable<'T>, 'TResult> -> 'TResult | ArgumentNullException | source or resultSelector is + . + |
public static TResult Partition<T, TResult>(
+ this IEnumerable<IGrouping<bool?, T>> source,
+ Func<IEnumerable<T>, IEnumerable<T>, IEnumerable<T>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Partition(Of T, TResult) (
+ source As IEnumerable(Of IGrouping(Of Boolean?, T)),
+ resultSelector As Func(Of IEnumerable(Of T), IEnumerable(Of T), IEnumerable(Of T), TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Partition(
+ IEnumerable<IGrouping<Nullable<bool>, T>^>^ source,
+ Func<IEnumerable<T>^, IEnumerable<T>^, IEnumerable<T>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Partition :
+ source : IEnumerable<IGrouping<Nullable<bool>, 'T>> *
+ resultSelector : Func<IEnumerable<'T>, IEnumerable<'T>, IEnumerable<'T>, 'TResult> -> 'TResult | ArgumentNullException | source or resultSelector is + . + |
public static TResult Partition<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, bool> predicate,
+ Func<IEnumerable<T>, IEnumerable<T>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Partition(Of T, TResult) (
+ source As IEnumerable(Of T),
+ predicate As Func(Of T, Boolean),
+ resultSelector As Func(Of IEnumerable(Of T), IEnumerable(Of T), TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static TResult Partition(
+ IEnumerable<T>^ source,
+ Func<T, bool>^ predicate,
+ Func<IEnumerable<T>^, IEnumerable<T>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Partition :
+ source : IEnumerable<'T> *
+ predicate : Func<'T, bool> *
+ resultSelector : Func<IEnumerable<'T>, IEnumerable<'T>, 'TResult> -> 'TResult var (evens, odds) =
+ Enumerable.Range(0, 10)
+ .Partition(x => x % 2 == 0, ValueTuple.Create);| ArgumentNullException | source, predicate, or + resultSelector is . + |
public static TResult Partition<TKey, TElement, TResult>(
+ this IEnumerable<IGrouping<TKey, TElement>> source,
+ TKey key,
+ IEqualityComparer<TKey>? comparer,
+ Func<IEnumerable<TElement>, IEnumerable<IGrouping<TKey, TElement>>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Partition(Of TKey, TElement, TResult) (
+ source As IEnumerable(Of IGrouping(Of TKey, TElement)),
+ key As TKey,
+ comparer As IEqualityComparer(Of TKey),
+ resultSelector As Func(Of IEnumerable(Of TElement), IEnumerable(Of IGrouping(Of TKey, TElement)), TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename TKey, typename TElement, typename TResult>
+static TResult Partition(
+ IEnumerable<IGrouping<TKey, TElement>^>^ source,
+ TKey key,
+ IEqualityComparer<TKey>^ comparer,
+ Func<IEnumerable<TElement>^, IEnumerable<IGrouping<TKey, TElement>^>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Partition :
+ source : IEnumerable<IGrouping<'TKey, 'TElement>> *
+ key : 'TKey *
+ comparer : IEqualityComparer<'TKey> *
+ resultSelector : Func<IEnumerable<'TElement>, IEnumerable<IGrouping<'TKey, 'TElement>>, 'TResult> -> 'TResult | ArgumentNullException | source or resultSelector is + . + |
public static TResult Partition<TKey, TElement, TResult>(
+ this IEnumerable<IGrouping<TKey, TElement>> source,
+ TKey key,
+ Func<IEnumerable<TElement>, IEnumerable<IGrouping<TKey, TElement>>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Partition(Of TKey, TElement, TResult) (
+ source As IEnumerable(Of IGrouping(Of TKey, TElement)),
+ key As TKey,
+ resultSelector As Func(Of IEnumerable(Of TElement), IEnumerable(Of IGrouping(Of TKey, TElement)), TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename TKey, typename TElement, typename TResult>
+static TResult Partition(
+ IEnumerable<IGrouping<TKey, TElement>^>^ source,
+ TKey key,
+ Func<IEnumerable<TElement>^, IEnumerable<IGrouping<TKey, TElement>^>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Partition :
+ source : IEnumerable<IGrouping<'TKey, 'TElement>> *
+ key : 'TKey *
+ resultSelector : Func<IEnumerable<'TElement>, IEnumerable<IGrouping<'TKey, 'TElement>>, 'TResult> -> 'TResult | ArgumentNullException | source or resultSelector is + . + |
public static TResult Partition<TKey, TElement, TResult>(
+ this IEnumerable<IGrouping<TKey, TElement>> source,
+ TKey key1,
+ TKey key2,
+ IEqualityComparer<TKey>? comparer,
+ Func<IEnumerable<TElement>, IEnumerable<TElement>, IEnumerable<IGrouping<TKey, TElement>>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Partition(Of TKey, TElement, TResult) (
+ source As IEnumerable(Of IGrouping(Of TKey, TElement)),
+ key1 As TKey,
+ key2 As TKey,
+ comparer As IEqualityComparer(Of TKey),
+ resultSelector As Func(Of IEnumerable(Of TElement), IEnumerable(Of TElement), IEnumerable(Of IGrouping(Of TKey, TElement)), TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename TKey, typename TElement, typename TResult>
+static TResult Partition(
+ IEnumerable<IGrouping<TKey, TElement>^>^ source,
+ TKey key1,
+ TKey key2,
+ IEqualityComparer<TKey>^ comparer,
+ Func<IEnumerable<TElement>^, IEnumerable<TElement>^, IEnumerable<IGrouping<TKey, TElement>^>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Partition :
+ source : IEnumerable<IGrouping<'TKey, 'TElement>> *
+ key1 : 'TKey *
+ key2 : 'TKey *
+ comparer : IEqualityComparer<'TKey> *
+ resultSelector : Func<IEnumerable<'TElement>, IEnumerable<'TElement>, IEnumerable<IGrouping<'TKey, 'TElement>>, 'TResult> -> 'TResult | ArgumentNullException | source or resultSelector is + . + |
public static TResult Partition<TKey, TElement, TResult>(
+ this IEnumerable<IGrouping<TKey, TElement>> source,
+ TKey key1,
+ TKey key2,
+ Func<IEnumerable<TElement>, IEnumerable<TElement>, IEnumerable<IGrouping<TKey, TElement>>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Partition(Of TKey, TElement, TResult) (
+ source As IEnumerable(Of IGrouping(Of TKey, TElement)),
+ key1 As TKey,
+ key2 As TKey,
+ resultSelector As Func(Of IEnumerable(Of TElement), IEnumerable(Of TElement), IEnumerable(Of IGrouping(Of TKey, TElement)), TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename TKey, typename TElement, typename TResult>
+static TResult Partition(
+ IEnumerable<IGrouping<TKey, TElement>^>^ source,
+ TKey key1,
+ TKey key2,
+ Func<IEnumerable<TElement>^, IEnumerable<TElement>^, IEnumerable<IGrouping<TKey, TElement>^>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Partition :
+ source : IEnumerable<IGrouping<'TKey, 'TElement>> *
+ key1 : 'TKey *
+ key2 : 'TKey *
+ resultSelector : Func<IEnumerable<'TElement>, IEnumerable<'TElement>, IEnumerable<IGrouping<'TKey, 'TElement>>, 'TResult> -> 'TResult | ArgumentNullException | source or resultSelector is + . + |
public static TResult Partition<TKey, TElement, TResult>(
+ this IEnumerable<IGrouping<TKey, TElement>> source,
+ TKey key1,
+ TKey key2,
+ TKey key3,
+ IEqualityComparer<TKey>? comparer,
+ Func<IEnumerable<TElement>, IEnumerable<TElement>, IEnumerable<TElement>, IEnumerable<IGrouping<TKey, TElement>>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Partition(Of TKey, TElement, TResult) (
+ source As IEnumerable(Of IGrouping(Of TKey, TElement)),
+ key1 As TKey,
+ key2 As TKey,
+ key3 As TKey,
+ comparer As IEqualityComparer(Of TKey),
+ resultSelector As Func(Of IEnumerable(Of TElement), IEnumerable(Of TElement), IEnumerable(Of TElement), IEnumerable(Of IGrouping(Of TKey, TElement)), TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename TKey, typename TElement, typename TResult>
+static TResult Partition(
+ IEnumerable<IGrouping<TKey, TElement>^>^ source,
+ TKey key1,
+ TKey key2,
+ TKey key3,
+ IEqualityComparer<TKey>^ comparer,
+ Func<IEnumerable<TElement>^, IEnumerable<TElement>^, IEnumerable<TElement>^, IEnumerable<IGrouping<TKey, TElement>^>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Partition :
+ source : IEnumerable<IGrouping<'TKey, 'TElement>> *
+ key1 : 'TKey *
+ key2 : 'TKey *
+ key3 : 'TKey *
+ comparer : IEqualityComparer<'TKey> *
+ resultSelector : Func<IEnumerable<'TElement>, IEnumerable<'TElement>, IEnumerable<'TElement>, IEnumerable<IGrouping<'TKey, 'TElement>>, 'TResult> -> 'TResult | ArgumentNullException | source or resultSelector is + . + |
public static TResult Partition<TKey, TElement, TResult>(
+ this IEnumerable<IGrouping<TKey, TElement>> source,
+ TKey key1,
+ TKey key2,
+ TKey key3,
+ Func<IEnumerable<TElement>, IEnumerable<TElement>, IEnumerable<TElement>, IEnumerable<IGrouping<TKey, TElement>>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Partition(Of TKey, TElement, TResult) (
+ source As IEnumerable(Of IGrouping(Of TKey, TElement)),
+ key1 As TKey,
+ key2 As TKey,
+ key3 As TKey,
+ resultSelector As Func(Of IEnumerable(Of TElement), IEnumerable(Of TElement), IEnumerable(Of TElement), IEnumerable(Of IGrouping(Of TKey, TElement)), TResult)
+) As TResultpublic:
+[ExtensionAttribute]
+generic<typename TKey, typename TElement, typename TResult>
+static TResult Partition(
+ IEnumerable<IGrouping<TKey, TElement>^>^ source,
+ TKey key1,
+ TKey key2,
+ TKey key3,
+ Func<IEnumerable<TElement>^, IEnumerable<TElement>^, IEnumerable<TElement>^, IEnumerable<IGrouping<TKey, TElement>^>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Partition :
+ source : IEnumerable<IGrouping<'TKey, 'TElement>> *
+ key1 : 'TKey *
+ key2 : 'TKey *
+ key3 : 'TKey *
+ resultSelector : Func<IEnumerable<'TElement>, IEnumerable<'TElement>, IEnumerable<'TElement>, IEnumerable<IGrouping<'TKey, 'TElement>>, 'TResult> -> 'TResult | ArgumentNullException | source or resultSelector is + . + |
public static IEnumerable<IList<T>> Permutations<T>(
+ this IEnumerable<T> sequence
+)
+<ExtensionAttribute>
+Public Shared Function Permutations(Of T) (
+ sequence As IEnumerable(Of T)
+) As IEnumerable(Of IList(Of T))public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<IList<T>^>^ Permutations(
+ IEnumerable<T>^ sequence
+)[<ExtensionAttribute>]
+static member Permutations :
+ sequence : IEnumerable<'T> -> IEnumerable<IList<'T>> + A permutation is a unique re-ordering of the elements of the sequence.
+ 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().
+ Be aware that the original sequence is considered one of the permutations and will be + returned as one of the results.
public static IEnumerable<T> Pipe<T>(
+ this IEnumerable<T> source,
+ Action<T> action
+)
+<ExtensionAttribute>
+Public Shared Function Pipe(Of T) (
+ source As IEnumerable(Of T),
+ action As Action(Of T)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Pipe(
+ IEnumerable<T>^ source,
+ Action<T>^ action
+)[<ExtensionAttribute>]
+static member Pipe :
+ source : IEnumerable<'T> *
+ action : Action<'T> -> IEnumerable<'T> public static IEnumerable<TSource> PreScan<TSource>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TSource, TSource> transformation,
+ TSource identity
+)
+<ExtensionAttribute>
+Public Shared Function PreScan(Of TSource) (
+ source As IEnumerable(Of TSource),
+ transformation As Func(Of TSource, TSource, TSource),
+ identity As TSource
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ PreScan(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TSource, TSource>^ transformation,
+ TSource identity
+)[<ExtensionAttribute>]
+static member PreScan :
+ source : IEnumerable<'TSource> *
+ transformation : Func<'TSource, 'TSource, 'TSource> *
+ identity : 'TSource -> IEnumerable<'TSource> 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);public static IEnumerable<TSource> Prepend<TSource>(
+ this IEnumerable<TSource> source,
+ TSource value
+)
+<ExtensionAttribute>
+Public Shared Function Prepend(Of TSource) (
+ source As IEnumerable(Of TSource),
+ value As TSource
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ Prepend(
+ IEnumerable<TSource>^ source,
+ TSource value
+)[<ExtensionAttribute>]
+static member Prepend :
+ source : IEnumerable<'TSource> *
+ value : 'TSource -> IEnumerable<'TSource> public static IEnumerable<int> Random()Public Shared Function Random As IEnumerable(Of Integer)public:
+static IEnumerable<int>^ Random()static member Random : unit -> IEnumerable<int> + The implementation internally uses a shared, thread-local instance of + Random to generate a random number on each + iteration. The actual Random instance used + therefore will depend on the thread on which a single iteration is + taking place; that is the call to + MoveNext. If the + overall iteration takes place on different threads (e.g. + via asynchronous awaits completing on different threads) then various + different Random instances will be involved + in the generation of the sequence of random numbers. Because the + Random instance is shared, if multiple sequences + are generated on the same thread, the order of enumeration affects the + resulting sequences.
+ On .NET 6 or later, System.Random.Shared is used.
public static IEnumerable<double> RandomDouble()Public Shared Function RandomDouble As IEnumerable(Of Double)public:
+static IEnumerable<double>^ RandomDouble()static member RandomDouble : unit -> IEnumerable<float> + The implementation internally uses a shared, thread-local instance of + Random to generate a random number on each + iteration. The actual Random instance used + therefore will depend on the thread on which a single iteration is + taking place; that is the call to + MoveNext. If the + overall iteration takes place on different threads (e.g. + via asynchronous awaits completing on different threads) then various + different Random instances will be involved + in the generation of the sequence of random numbers. Because the + Random instance is shared, if multiple sequences + are generated on the same thread, the order of enumeration affects the + resulting sequences.
+ On .NET 6 or later, System.Random.Shared is used.
public static IEnumerable<double> RandomDouble(
+ Random rand
+)Public Shared Function RandomDouble (
+ rand As Random
+) As IEnumerable(Of Double)public:
+static IEnumerable<double>^ RandomDouble(
+ Random^ rand
+)static member RandomDouble :
+ rand : Random -> IEnumerable<float> | ArgumentNullException | Thrown if rand is . |
public static IEnumerable<T> RandomSubset<T>(
+ this IEnumerable<T> source,
+ int subsetSize
+)
+<ExtensionAttribute>
+Public Shared Function RandomSubset(Of T) (
+ source As IEnumerable(Of T),
+ subsetSize As Integer
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ RandomSubset(
+ IEnumerable<T>^ source,
+ int subsetSize
+)[<ExtensionAttribute>]
+static member RandomSubset :
+ source : IEnumerable<'T> *
+ subsetSize : int -> IEnumerable<'T> public static IEnumerable<T> RandomSubset<T>(
+ this IEnumerable<T> source,
+ int subsetSize,
+ Random rand
+)
+<ExtensionAttribute>
+Public Shared Function RandomSubset(Of T) (
+ source As IEnumerable(Of T),
+ subsetSize As Integer,
+ rand As Random
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ RandomSubset(
+ IEnumerable<T>^ source,
+ int subsetSize,
+ Random^ rand
+)[<ExtensionAttribute>]
+static member RandomSubset :
+ source : IEnumerable<'T> *
+ subsetSize : int *
+ rand : Random -> IEnumerable<'T> public static IEnumerable<int> Random(
+ int maxValue
+)Public Shared Function Random (
+ maxValue As Integer
+) As IEnumerable(Of Integer)public:
+static IEnumerable<int>^ Random(
+ int maxValue
+)static member Random :
+ maxValue : int -> IEnumerable<int> + The implementation internally uses a shared, thread-local instance of + Random to generate a random number on each + iteration. The actual Random instance used + therefore will depend on the thread on which a single iteration is + taking place; that is the call to + MoveNext. If the + overall iteration takes place on different threads (e.g. + via asynchronous awaits completing on different threads) then various + different Random instances will be involved + in the generation of the sequence of random numbers. Because the + Random instance is shared, if multiple sequences + are generated on the same thread, the order of enumeration affects the + resulting sequences.
+ On .NET 6 or later, System.Random.Shared is used.
public static IEnumerable<int> Random(
+ int minValue,
+ int maxValue
+)Public Shared Function Random (
+ minValue As Integer,
+ maxValue As Integer
+) As IEnumerable(Of Integer)public:
+static IEnumerable<int>^ Random(
+ int minValue,
+ int maxValue
+)static member Random :
+ minValue : int *
+ maxValue : int -> IEnumerable<int> + The implementation internally uses a shared, thread-local instance of + Random to generate a random number on each + iteration. The actual Random instance used + therefore will depend on the thread on which a single iteration is + taking place; that is the call to + MoveNext. If the + overall iteration takes place on different threads (e.g. + via asynchronous awaits completing on different threads) then various + different Random instances will be involved + in the generation of the sequence of random numbers. Because the + Random instance is shared, if multiple sequences + are generated on the same thread, the order of enumeration affects the + resulting sequences.
+ On .NET 6 or later, System.Random.Shared is used.
public static IEnumerable<int> Random(
+ Random rand
+)Public Shared Function Random (
+ rand As Random
+) As IEnumerable(Of Integer)public:
+static IEnumerable<int>^ Random(
+ Random^ rand
+)static member Random :
+ rand : Random -> IEnumerable<int> | ArgumentNullException | Thrown if rand is . |
public static IEnumerable<int> Random(
+ Random rand,
+ int maxValue
+)Public Shared Function Random (
+ rand As Random,
+ maxValue As Integer
+) As IEnumerable(Of Integer)public:
+static IEnumerable<int>^ Random(
+ Random^ rand,
+ int maxValue
+)static member Random :
+ rand : Random *
+ maxValue : int -> IEnumerable<int> | ArgumentNullException | Thrown if rand is . |
public static IEnumerable<int> Random(
+ Random rand,
+ int minValue,
+ int maxValue
+)Public Shared Function Random (
+ rand As Random,
+ minValue As Integer,
+ maxValue As Integer
+) As IEnumerable(Of Integer)public:
+static IEnumerable<int>^ Random(
+ Random^ rand,
+ int minValue,
+ int maxValue
+)static member Random :
+ rand : Random *
+ minValue : int *
+ maxValue : int -> IEnumerable<int> | ArgumentNullException | Thrown if rand is . |
public static IEnumerable<int> RankBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector
+)
+<ExtensionAttribute>
+Public Shared Function RankBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey)
+) As IEnumerable(Of Integer)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<int>^ RankBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector
+)[<ExtensionAttribute>]
+static member RankBy :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> -> IEnumerable<int> public static IEnumerable<int> RankBy<TSource, TKey>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector,
+ IComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function RankBy(Of TSource, TKey) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ comparer As IComparer(Of TKey)
+) As IEnumerable(Of Integer)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey>
+static IEnumerable<int>^ RankBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector,
+ IComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member RankBy :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ comparer : IComparer<'TKey> -> IEnumerable<int> public static IEnumerable<int> Rank<TSource>(
+ this IEnumerable<TSource> source
+)
+<ExtensionAttribute>
+Public Shared Function Rank(Of TSource) (
+ source As IEnumerable(Of TSource)
+) As IEnumerable(Of Integer)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<int>^ Rank(
+ IEnumerable<TSource>^ source
+)[<ExtensionAttribute>]
+static member Rank :
+ source : IEnumerable<'TSource> -> IEnumerable<int> public static IEnumerable<int> Rank<TSource>(
+ this IEnumerable<TSource> source,
+ IComparer<TSource>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function Rank(Of TSource) (
+ source As IEnumerable(Of TSource),
+ comparer As IComparer(Of TSource)
+) As IEnumerable(Of Integer)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<int>^ Rank(
+ IEnumerable<TSource>^ source,
+ IComparer<TSource>^ comparer
+)[<ExtensionAttribute>]
+static member Rank :
+ source : IEnumerable<'TSource> *
+ comparer : IComparer<'TSource> -> IEnumerable<int> public static IEnumerable<T> Repeat<T>(
+ this IEnumerable<T> sequence
+)
+<ExtensionAttribute>
+Public Shared Function Repeat(Of T) (
+ sequence As IEnumerable(Of T)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Repeat(
+ IEnumerable<T>^ sequence
+)[<ExtensionAttribute>]
+static member Repeat :
+ sequence : IEnumerable<'T> -> IEnumerable<'T> public static IEnumerable<T> Repeat<T>(
+ this IEnumerable<T> sequence,
+ int count
+)
+<ExtensionAttribute>
+Public Shared Function Repeat(Of T) (
+ sequence As IEnumerable(Of T),
+ count As Integer
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Repeat(
+ IEnumerable<T>^ sequence,
+ int count
+)[<ExtensionAttribute>]
+static member Repeat :
+ sequence : IEnumerable<'T> *
+ count : int -> IEnumerable<'T> public static IEnumerable<T> Return<T>(
+ T item
+)
+Public Shared Function Return(Of T) (
+ item As T
+) As IEnumerable(Of T)public:
+generic<typename T>
+static IEnumerable<T>^ Return(
+ T item
+)static member Return :
+ item : 'T -> IEnumerable<'T> public static IEnumerable<TResult> RightJoin<TSource, TKey, TResult>(
+ this IEnumerable<TSource> first,
+ IEnumerable<TSource> second,
+ Func<TSource, TKey> keySelector,
+ Func<TSource, TResult> secondSelector,
+ Func<TSource, TSource, TResult> bothSelector
+)
+<ExtensionAttribute>
+Public Shared Function RightJoin(Of TSource, TKey, TResult) (
+ first As IEnumerable(Of TSource),
+ second As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ secondSelector As Func(Of TSource, TResult),
+ bothSelector As Func(Of TSource, TSource, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey, typename TResult>
+static IEnumerable<TResult>^ RightJoin(
+ IEnumerable<TSource>^ first,
+ IEnumerable<TSource>^ second,
+ Func<TSource, TKey>^ keySelector,
+ Func<TSource, TResult>^ secondSelector,
+ Func<TSource, TSource, TResult>^ bothSelector
+)[<ExtensionAttribute>]
+static member RightJoin :
+ first : IEnumerable<'TSource> *
+ second : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ secondSelector : Func<'TSource, 'TResult> *
+ bothSelector : Func<'TSource, 'TSource, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> RightJoin<TSource, TKey, TResult>(
+ this IEnumerable<TSource> first,
+ IEnumerable<TSource> second,
+ Func<TSource, TKey> keySelector,
+ Func<TSource, TResult> secondSelector,
+ Func<TSource, TSource, TResult> bothSelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function RightJoin(Of TSource, TKey, TResult) (
+ first As IEnumerable(Of TSource),
+ second As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ secondSelector As Func(Of TSource, TResult),
+ bothSelector As Func(Of TSource, TSource, TResult),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey, typename TResult>
+static IEnumerable<TResult>^ RightJoin(
+ IEnumerable<TSource>^ first,
+ IEnumerable<TSource>^ second,
+ Func<TSource, TKey>^ keySelector,
+ Func<TSource, TResult>^ secondSelector,
+ Func<TSource, TSource, TResult>^ bothSelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member RightJoin :
+ first : IEnumerable<'TSource> *
+ second : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ secondSelector : Func<'TSource, 'TResult> *
+ bothSelector : Func<'TSource, 'TSource, 'TResult> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<'TResult> public static IEnumerable<TResult> RightJoin<TFirst, TSecond, TKey, TResult>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TKey> firstKeySelector,
+ Func<TSecond, TKey> secondKeySelector,
+ Func<TSecond, TResult> secondSelector,
+ Func<TFirst, TSecond, TResult> bothSelector
+)
+<ExtensionAttribute>
+Public Shared Function RightJoin(Of TFirst, TSecond, TKey, TResult) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ firstKeySelector As Func(Of TFirst, TKey),
+ secondKeySelector As Func(Of TSecond, TKey),
+ secondSelector As Func(Of TSecond, TResult),
+ bothSelector As Func(Of TFirst, TSecond, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TKey, typename TResult>
+static IEnumerable<TResult>^ RightJoin(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TKey>^ firstKeySelector,
+ Func<TSecond, TKey>^ secondKeySelector,
+ Func<TSecond, TResult>^ secondSelector,
+ Func<TFirst, TSecond, TResult>^ bothSelector
+)[<ExtensionAttribute>]
+static member RightJoin :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ firstKeySelector : Func<'TFirst, 'TKey> *
+ secondKeySelector : Func<'TSecond, 'TKey> *
+ secondSelector : Func<'TSecond, 'TResult> *
+ bothSelector : Func<'TFirst, 'TSecond, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> RightJoin<TFirst, TSecond, TKey, TResult>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TKey> firstKeySelector,
+ Func<TSecond, TKey> secondKeySelector,
+ Func<TSecond, TResult> secondSelector,
+ Func<TFirst, TSecond, TResult> bothSelector,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function RightJoin(Of TFirst, TSecond, TKey, TResult) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ firstKeySelector As Func(Of TFirst, TKey),
+ secondKeySelector As Func(Of TSecond, TKey),
+ secondSelector As Func(Of TSecond, TResult),
+ bothSelector As Func(Of TFirst, TSecond, TResult),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TKey, typename TResult>
+static IEnumerable<TResult>^ RightJoin(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TKey>^ firstKeySelector,
+ Func<TSecond, TKey>^ secondKeySelector,
+ Func<TSecond, TResult>^ secondSelector,
+ Func<TFirst, TSecond, TResult>^ bothSelector,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member RightJoin :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ firstKeySelector : Func<'TFirst, 'TKey> *
+ secondKeySelector : Func<'TSecond, 'TKey> *
+ secondSelector : Func<'TSecond, 'TResult> *
+ bothSelector : Func<'TFirst, 'TSecond, 'TResult> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<'TResult> public static IEnumerable<KeyValuePair<T, int>> RunLengthEncode<T>(
+ this IEnumerable<T> sequence
+)
+<ExtensionAttribute>
+Public Shared Function RunLengthEncode(Of T) (
+ sequence As IEnumerable(Of T)
+) As IEnumerable(Of KeyValuePair(Of T, Integer))public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<KeyValuePair<T, int>>^ RunLengthEncode(
+ IEnumerable<T>^ sequence
+)[<ExtensionAttribute>]
+static member RunLengthEncode :
+ sequence : IEnumerable<'T> -> IEnumerable<KeyValuePair<'T, int>> public static IEnumerable<KeyValuePair<T, int>> RunLengthEncode<T>(
+ this IEnumerable<T> sequence,
+ IEqualityComparer<T>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function RunLengthEncode(Of T) (
+ sequence As IEnumerable(Of T),
+ comparer As IEqualityComparer(Of T)
+) As IEnumerable(Of KeyValuePair(Of T, Integer))public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<KeyValuePair<T, int>>^ RunLengthEncode(
+ IEnumerable<T>^ sequence,
+ IEqualityComparer<T>^ comparer
+)[<ExtensionAttribute>]
+static member RunLengthEncode :
+ sequence : IEnumerable<'T> *
+ comparer : IEqualityComparer<'T> -> IEnumerable<KeyValuePair<'T, int>> public static IEnumerable<KeyValuePair<TKey, TState>> ScanBy<TSource, TKey, TState>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector,
+ Func<TKey, TState> seedSelector,
+ Func<TState, TKey, TSource, TState> accumulator
+)
+<ExtensionAttribute>
+Public Shared Function ScanBy(Of TSource, TKey, TState) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ seedSelector As Func(Of TKey, TState),
+ accumulator As Func(Of TState, TKey, TSource, TState)
+) As IEnumerable(Of KeyValuePair(Of TKey, TState))public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey, typename TState>
+static IEnumerable<KeyValuePair<TKey, TState>>^ ScanBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector,
+ Func<TKey, TState>^ seedSelector,
+ Func<TState, TKey, TSource, TState>^ accumulator
+)[<ExtensionAttribute>]
+static member ScanBy :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ seedSelector : Func<'TKey, 'TState> *
+ accumulator : Func<'TState, 'TKey, 'TSource, 'TState> -> IEnumerable<KeyValuePair<'TKey, 'TState>> public static IEnumerable<KeyValuePair<TKey, TState>> ScanBy<TSource, TKey, TState>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TKey> keySelector,
+ Func<TKey, TState> seedSelector,
+ Func<TState, TKey, TSource, TState> accumulator,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function ScanBy(Of TSource, TKey, TState) (
+ source As IEnumerable(Of TSource),
+ keySelector As Func(Of TSource, TKey),
+ seedSelector As Func(Of TKey, TState),
+ accumulator As Func(Of TState, TKey, TSource, TState),
+ comparer As IEqualityComparer(Of TKey)
+) As IEnumerable(Of KeyValuePair(Of TKey, TState))public:
+[ExtensionAttribute]
+generic<typename TSource, typename TKey, typename TState>
+static IEnumerable<KeyValuePair<TKey, TState>>^ ScanBy(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TKey>^ keySelector,
+ Func<TKey, TState>^ seedSelector,
+ Func<TState, TKey, TSource, TState>^ accumulator,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member ScanBy :
+ source : IEnumerable<'TSource> *
+ keySelector : Func<'TSource, 'TKey> *
+ seedSelector : Func<'TKey, 'TState> *
+ accumulator : Func<'TState, 'TKey, 'TSource, 'TState> *
+ comparer : IEqualityComparer<'TKey> -> IEnumerable<KeyValuePair<'TKey, 'TState>> public static IEnumerable<TSource> ScanRight<TSource>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TSource, TSource> func
+)
+<ExtensionAttribute>
+Public Shared Function ScanRight(Of TSource) (
+ source As IEnumerable(Of TSource),
+ func As Func(Of TSource, TSource, TSource)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ ScanRight(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TSource, TSource>^ func
+)[<ExtensionAttribute>]
+static member ScanRight :
+ source : IEnumerable<'TSource> *
+ func : Func<'TSource, 'TSource, 'TSource> -> IEnumerable<'TSource> var result = Enumerable.Range(1, 5).Select(i => i.ToString()).ScanRight((a, b) => $"({a}+{b})");public static IEnumerable<TAccumulate> ScanRight<TSource, TAccumulate>(
+ this IEnumerable<TSource> source,
+ TAccumulate seed,
+ Func<TSource, TAccumulate, TAccumulate> func
+)
+<ExtensionAttribute>
+Public Shared Function ScanRight(Of TSource, TAccumulate) (
+ source As IEnumerable(Of TSource),
+ seed As TAccumulate,
+ func As Func(Of TSource, TAccumulate, TAccumulate)
+) As IEnumerable(Of TAccumulate)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TAccumulate>
+static IEnumerable<TAccumulate>^ ScanRight(
+ IEnumerable<TSource>^ source,
+ TAccumulate seed,
+ Func<TSource, TAccumulate, TAccumulate>^ func
+)[<ExtensionAttribute>]
+static member ScanRight :
+ source : IEnumerable<'TSource> *
+ seed : 'TAccumulate *
+ func : Func<'TSource, 'TAccumulate, 'TAccumulate> -> IEnumerable<'TAccumulate> var result = Enumerable.Range(1, 4).ScanRight("5", (a, b) => $"({a}+{b})");public static IEnumerable<TSource> Scan<TSource>(
+ this IEnumerable<TSource> source,
+ Func<TSource, TSource, TSource> transformation
+)
+<ExtensionAttribute>
+Public Shared Function Scan(Of TSource) (
+ source As IEnumerable(Of TSource),
+ transformation As Func(Of TSource, TSource, TSource)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ Scan(
+ IEnumerable<TSource>^ source,
+ Func<TSource, TSource, TSource>^ transformation
+)[<ExtensionAttribute>]
+static member Scan :
+ source : IEnumerable<'TSource> *
+ transformation : Func<'TSource, 'TSource, 'TSource> -> IEnumerable<'TSource> 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);public static IEnumerable<TState> Scan<TSource, TState>(
+ this IEnumerable<TSource> source,
+ TState seed,
+ Func<TState, TSource, TState> transformation
+)
+<ExtensionAttribute>
+Public Shared Function Scan(Of TSource, TState) (
+ source As IEnumerable(Of TSource),
+ seed As TState,
+ transformation As Func(Of TState, TSource, TState)
+) As IEnumerable(Of TState)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TState>
+static IEnumerable<TState>^ Scan(
+ IEnumerable<TSource>^ source,
+ TState seed,
+ Func<TState, TSource, TState>^ transformation
+)[<ExtensionAttribute>]
+static member Scan :
+ source : IEnumerable<'TSource> *
+ seed : 'TState *
+ transformation : Func<'TState, 'TSource, 'TState> -> IEnumerable<'TState> var result = Enumerable.Range(1, 5).Scan(0, (a, b) => a + b);public static IEnumerable<IEnumerable<T>> Segment<T>(
+ this IEnumerable<T> source,
+ Func<T, bool> newSegmentPredicate
+)
+<ExtensionAttribute>
+Public Shared Function Segment(Of T) (
+ source As IEnumerable(Of T),
+ newSegmentPredicate As Func(Of T, Boolean)
+) As IEnumerable(Of IEnumerable(Of T))public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<IEnumerable<T>^>^ Segment(
+ IEnumerable<T>^ source,
+ Func<T, bool>^ newSegmentPredicate
+)[<ExtensionAttribute>]
+static member Segment :
+ source : IEnumerable<'T> *
+ newSegmentPredicate : Func<'T, bool> -> IEnumerable<IEnumerable<'T>> | ArgumentNullException | + Thrown if either source or newSegmentPredicate are . + |
public static IEnumerable<IEnumerable<T>> Segment<T>(
+ this IEnumerable<T> source,
+ Func<T, int, bool> newSegmentPredicate
+)
+<ExtensionAttribute>
+Public Shared Function Segment(Of T) (
+ source As IEnumerable(Of T),
+ newSegmentPredicate As Func(Of T, Integer, Boolean)
+) As IEnumerable(Of IEnumerable(Of T))public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<IEnumerable<T>^>^ Segment(
+ IEnumerable<T>^ source,
+ Func<T, int, bool>^ newSegmentPredicate
+)[<ExtensionAttribute>]
+static member Segment :
+ source : IEnumerable<'T> *
+ newSegmentPredicate : Func<'T, int, bool> -> IEnumerable<IEnumerable<'T>> | ArgumentNullException | + Thrown if either source or newSegmentPredicate are . + |
public static IEnumerable<IEnumerable<T>> Segment<T>(
+ this IEnumerable<T> source,
+ Func<T, T, int, bool> newSegmentPredicate
+)
+<ExtensionAttribute>
+Public Shared Function Segment(Of T) (
+ source As IEnumerable(Of T),
+ newSegmentPredicate As Func(Of T, T, Integer, Boolean)
+) As IEnumerable(Of IEnumerable(Of T))public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<IEnumerable<T>^>^ Segment(
+ IEnumerable<T>^ source,
+ Func<T, T, int, bool>^ newSegmentPredicate
+)[<ExtensionAttribute>]
+static member Segment :
+ source : IEnumerable<'T> *
+ newSegmentPredicate : Func<'T, 'T, int, bool> -> IEnumerable<IEnumerable<'T>> | ArgumentNullException | + Thrown if either source or newSegmentPredicate are . + |
public static IEnumerable<int> Sequence(
+ int start,
+ int stop
+)Public Shared Function Sequence (
+ start As Integer,
+ stop As Integer
+) As IEnumerable(Of Integer)public:
+static IEnumerable<int>^ Sequence(
+ int start,
+ int stop
+)static member Sequence :
+ start : int *
+ stop : int -> IEnumerable<int> var result = MoreEnumerable.Sequence(6, 0);public static IEnumerable<int> Sequence(
+ int start,
+ int stop,
+ int step
+)Public Shared Function Sequence (
+ start As Integer,
+ stop As Integer,
+ step As Integer
+) As IEnumerable(Of Integer)public:
+static IEnumerable<int>^ Sequence(
+ int start,
+ int stop,
+ int step
+)static member Sequence :
+ start : int *
+ stop : int *
+ step : int -> IEnumerable<int> var result = MoreEnumerable.Sequence(6, 0, -2);public static IEnumerable<T> Shuffle<T>(
+ this IEnumerable<T> source
+)
+<ExtensionAttribute>
+Public Shared Function Shuffle(Of T) (
+ source As IEnumerable(Of T)
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Shuffle(
+ IEnumerable<T>^ source
+)[<ExtensionAttribute>]
+static member Shuffle :
+ source : IEnumerable<'T> -> IEnumerable<'T> public static IEnumerable<T> Shuffle<T>(
+ this IEnumerable<T> source,
+ Random rand
+)
+<ExtensionAttribute>
+Public Shared Function Shuffle(Of T) (
+ source As IEnumerable(Of T),
+ rand As Random
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Shuffle(
+ IEnumerable<T>^ source,
+ Random^ rand
+)[<ExtensionAttribute>]
+static member Shuffle :
+ source : IEnumerable<'T> *
+ rand : Random -> IEnumerable<'T> public static T SingleOrDefault<T>(
+ this IExtremaEnumerable<T> source
+)
+<ExtensionAttribute>
+Public Shared Function SingleOrDefault(Of T) (
+ source As IExtremaEnumerable(Of T)
+) As Tpublic:
+[ExtensionAttribute]
+generic<typename T>
+static T SingleOrDefault(
+ IExtremaEnumerable<T>^ source
+)[<ExtensionAttribute>]
+static member SingleOrDefault :
+ source : IExtremaEnumerable<'T> -> 'T public static T Single<T>(
+ this IExtremaEnumerable<T> source
+)
+<ExtensionAttribute>
+Public Shared Function Single(Of T) (
+ source As IExtremaEnumerable(Of T)
+) As Tpublic:
+[ExtensionAttribute]
+generic<typename T>
+static T Single(
+ IExtremaEnumerable<T>^ source
+)[<ExtensionAttribute>]
+static member Single :
+ source : IExtremaEnumerable<'T> -> 'T | InvalidOperationException | + The input sequence contains more than one element. |
public static IEnumerable<T> SkipLast<T>(
+ this IEnumerable<T> source,
+ int count
+)
+<ExtensionAttribute>
+Public Shared Function SkipLast(Of T) (
+ source As IEnumerable(Of T),
+ count As Integer
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ SkipLast(
+ IEnumerable<T>^ source,
+ int count
+)[<ExtensionAttribute>]
+static member SkipLast :
+ source : IEnumerable<'T> *
+ count : int -> IEnumerable<'T> public static IEnumerable<TSource> SkipUntil<TSource>(
+ this IEnumerable<TSource> source,
+ Func<TSource, bool> predicate
+)
+<ExtensionAttribute>
+Public Shared Function SkipUntil(Of TSource) (
+ source As IEnumerable(Of TSource),
+ predicate As Func(Of TSource, Boolean)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ SkipUntil(
+ IEnumerable<TSource>^ source,
+ Func<TSource, bool>^ predicate
+)[<ExtensionAttribute>]
+static member SkipUntil :
+ source : IEnumerable<'TSource> *
+ predicate : Func<'TSource, bool> -> IEnumerable<'TSource> + SkipUntil differs from Enumerable.SkipWhile in two respects. Firstly, the sense + of the predicate is reversed: it is expected that the predicate will return false + to start with, and then return true - for example, when trying to find a matching + item in a sequence. +
+ Secondly, SkipUntil skips the element which causes the predicate to return true. For + example, in a sequence
{ 1, 2, 3, 4, 5 }x => x == 3{ 4, 5 }+ SkipUntil is as lazy as possible: it will not iterate over the source sequence + until it has to, it won't iterate further than it has to, and it won't evaluate + the predicate until it has to. (This means that an item may be returned which would + actually cause the predicate to throw an exception if it were evaluated, so long as + it comes after the first item causing the predicate to return true.) +
| ArgumentNullException | source or predicate is null |
public static IEnumerable<T> Slice<T>(
+ this IEnumerable<T> sequence,
+ int startIndex,
+ int count
+)
+<ExtensionAttribute>
+Public Shared Function Slice(Of T) (
+ sequence As IEnumerable(Of T),
+ startIndex As Integer,
+ count As Integer
+) As IEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<T>^ Slice(
+ IEnumerable<T>^ sequence,
+ int startIndex,
+ int count
+)[<ExtensionAttribute>]
+static member Slice :
+ sequence : IEnumerable<'T> *
+ startIndex : int *
+ count : int -> IEnumerable<'T> + 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 count.
+ This method is implemented in an optimized manner for any sequence implementing IListT.
+ The result of SliceT(IEnumerableT, Int32, Int32) is identical to: + sequence.Skip(startIndex).Take(count)
public static IEnumerable<TSource> SortedMerge<TSource>(
+ this IEnumerable<TSource> source,
+ OrderByDirection direction,
+ IComparer<TSource>? comparer,
+ params IEnumerable<TSource>[] otherSequences
+)
+<ExtensionAttribute>
+Public Shared Function SortedMerge(Of TSource) (
+ source As IEnumerable(Of TSource),
+ direction As OrderByDirection,
+ comparer As IComparer(Of TSource),
+ ParamArray otherSequences As IEnumerable(Of TSource)()
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ SortedMerge(
+ IEnumerable<TSource>^ source,
+ OrderByDirection direction,
+ IComparer<TSource>^ comparer,
+ ... array<IEnumerable<TSource>^>^ otherSequences
+)[<ExtensionAttribute>]
+static member SortedMerge :
+ source : IEnumerable<'TSource> *
+ direction : OrderByDirection *
+ comparer : IComparer<'TSource> *
+ otherSequences : IEnumerable<'TSource>[] -> IEnumerable<'TSource> public static IEnumerable<TSource> SortedMerge<TSource>(
+ this IEnumerable<TSource> source,
+ OrderByDirection direction,
+ params IEnumerable<TSource>[] otherSequences
+)
+<ExtensionAttribute>
+Public Shared Function SortedMerge(Of TSource) (
+ source As IEnumerable(Of TSource),
+ direction As OrderByDirection,
+ ParamArray otherSequences As IEnumerable(Of TSource)()
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ SortedMerge(
+ IEnumerable<TSource>^ source,
+ OrderByDirection direction,
+ ... array<IEnumerable<TSource>^>^ otherSequences
+)[<ExtensionAttribute>]
+static member SortedMerge :
+ source : IEnumerable<'TSource> *
+ direction : OrderByDirection *
+ otherSequences : IEnumerable<'TSource>[] -> IEnumerable<'TSource> + Using SortedMergeTSource(IEnumerableTSource, OrderByDirection, IEnumerableTSource) + on sequences that are not ordered or are not in the same order produces undefined + results.
SortedMergeTSource(IEnumerableTSource, OrderByDirection, IEnumerableTSource) + uses performs the merge in a deferred, streaming manner.
+ Here is an example of a merge, as well as the produced result:
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 }public static IEnumerable<IEnumerable<TSource>> Split<TSource>(
+ this IEnumerable<TSource> source,
+ Func<TSource, bool> separatorFunc
+)
+<ExtensionAttribute>
+Public Shared Function Split(Of TSource) (
+ source As IEnumerable(Of TSource),
+ separatorFunc As Func(Of TSource, Boolean)
+) As IEnumerable(Of IEnumerable(Of TSource))public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<IEnumerable<TSource>^>^ Split(
+ IEnumerable<TSource>^ source,
+ Func<TSource, bool>^ separatorFunc
+)[<ExtensionAttribute>]
+static member Split :
+ source : IEnumerable<'TSource> *
+ separatorFunc : Func<'TSource, bool> -> IEnumerable<IEnumerable<'TSource>> public static IEnumerable<IEnumerable<TSource>> Split<TSource>(
+ this IEnumerable<TSource> source,
+ Func<TSource, bool> separatorFunc,
+ int count
+)
+<ExtensionAttribute>
+Public Shared Function Split(Of TSource) (
+ source As IEnumerable(Of TSource),
+ separatorFunc As Func(Of TSource, Boolean),
+ count As Integer
+) As IEnumerable(Of IEnumerable(Of TSource))public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<IEnumerable<TSource>^>^ Split(
+ IEnumerable<TSource>^ source,
+ Func<TSource, bool>^ separatorFunc,
+ int count
+)[<ExtensionAttribute>]
+static member Split :
+ source : IEnumerable<'TSource> *
+ separatorFunc : Func<'TSource, bool> *
+ count : int -> IEnumerable<IEnumerable<'TSource>> public static IEnumerable<IEnumerable<TSource>> Split<TSource>(
+ this IEnumerable<TSource> source,
+ TSource separator
+)
+<ExtensionAttribute>
+Public Shared Function Split(Of TSource) (
+ source As IEnumerable(Of TSource),
+ separator As TSource
+) As IEnumerable(Of IEnumerable(Of TSource))public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<IEnumerable<TSource>^>^ Split(
+ IEnumerable<TSource>^ source,
+ TSource separator
+)[<ExtensionAttribute>]
+static member Split :
+ source : IEnumerable<'TSource> *
+ separator : 'TSource -> IEnumerable<IEnumerable<'TSource>> public static IEnumerable<IEnumerable<TSource>> Split<TSource>(
+ this IEnumerable<TSource> source,
+ TSource separator,
+ IEqualityComparer<TSource>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function Split(Of TSource) (
+ source As IEnumerable(Of TSource),
+ separator As TSource,
+ comparer As IEqualityComparer(Of TSource)
+) As IEnumerable(Of IEnumerable(Of TSource))public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<IEnumerable<TSource>^>^ Split(
+ IEnumerable<TSource>^ source,
+ TSource separator,
+ IEqualityComparer<TSource>^ comparer
+)[<ExtensionAttribute>]
+static member Split :
+ source : IEnumerable<'TSource> *
+ separator : 'TSource *
+ comparer : IEqualityComparer<'TSource> -> IEnumerable<IEnumerable<'TSource>> public static IEnumerable<IEnumerable<TSource>> Split<TSource>(
+ this IEnumerable<TSource> source,
+ TSource separator,
+ IEqualityComparer<TSource>? comparer,
+ int count
+)
+<ExtensionAttribute>
+Public Shared Function Split(Of TSource) (
+ source As IEnumerable(Of TSource),
+ separator As TSource,
+ comparer As IEqualityComparer(Of TSource),
+ count As Integer
+) As IEnumerable(Of IEnumerable(Of TSource))public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<IEnumerable<TSource>^>^ Split(
+ IEnumerable<TSource>^ source,
+ TSource separator,
+ IEqualityComparer<TSource>^ comparer,
+ int count
+)[<ExtensionAttribute>]
+static member Split :
+ source : IEnumerable<'TSource> *
+ separator : 'TSource *
+ comparer : IEqualityComparer<'TSource> *
+ count : int -> IEnumerable<IEnumerable<'TSource>> public static IEnumerable<IEnumerable<TSource>> Split<TSource>(
+ this IEnumerable<TSource> source,
+ TSource separator,
+ int count
+)
+<ExtensionAttribute>
+Public Shared Function Split(Of TSource) (
+ source As IEnumerable(Of TSource),
+ separator As TSource,
+ count As Integer
+) As IEnumerable(Of IEnumerable(Of TSource))public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<IEnumerable<TSource>^>^ Split(
+ IEnumerable<TSource>^ source,
+ TSource separator,
+ int count
+)[<ExtensionAttribute>]
+static member Split :
+ source : IEnumerable<'TSource> *
+ separator : 'TSource *
+ count : int -> IEnumerable<IEnumerable<'TSource>> public static IEnumerable<TResult> Split<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ Func<TSource, bool> separatorFunc,
+ Func<IEnumerable<TSource>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Split(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ separatorFunc As Func(Of TSource, Boolean),
+ resultSelector As Func(Of IEnumerable(Of TSource), TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ Split(
+ IEnumerable<TSource>^ source,
+ Func<TSource, bool>^ separatorFunc,
+ Func<IEnumerable<TSource>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Split :
+ source : IEnumerable<'TSource> *
+ separatorFunc : Func<'TSource, bool> *
+ resultSelector : Func<IEnumerable<'TSource>, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> Split<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ Func<TSource, bool> separatorFunc,
+ int count,
+ Func<IEnumerable<TSource>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Split(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ separatorFunc As Func(Of TSource, Boolean),
+ count As Integer,
+ resultSelector As Func(Of IEnumerable(Of TSource), TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ Split(
+ IEnumerable<TSource>^ source,
+ Func<TSource, bool>^ separatorFunc,
+ int count,
+ Func<IEnumerable<TSource>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Split :
+ source : IEnumerable<'TSource> *
+ separatorFunc : Func<'TSource, bool> *
+ count : int *
+ resultSelector : Func<IEnumerable<'TSource>, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> Split<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ TSource separator,
+ IEqualityComparer<TSource> comparer,
+ Func<IEnumerable<TSource>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Split(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ separator As TSource,
+ comparer As IEqualityComparer(Of TSource),
+ resultSelector As Func(Of IEnumerable(Of TSource), TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ Split(
+ IEnumerable<TSource>^ source,
+ TSource separator,
+ IEqualityComparer<TSource>^ comparer,
+ Func<IEnumerable<TSource>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Split :
+ source : IEnumerable<'TSource> *
+ separator : 'TSource *
+ comparer : IEqualityComparer<'TSource> *
+ resultSelector : Func<IEnumerable<'TSource>, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> Split<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ TSource separator,
+ IEqualityComparer<TSource>? comparer,
+ int count,
+ Func<IEnumerable<TSource>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Split(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ separator As TSource,
+ comparer As IEqualityComparer(Of TSource),
+ count As Integer,
+ resultSelector As Func(Of IEnumerable(Of TSource), TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ Split(
+ IEnumerable<TSource>^ source,
+ TSource separator,
+ IEqualityComparer<TSource>^ comparer,
+ int count,
+ Func<IEnumerable<TSource>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Split :
+ source : IEnumerable<'TSource> *
+ separator : 'TSource *
+ comparer : IEqualityComparer<'TSource> *
+ count : int *
+ resultSelector : Func<IEnumerable<'TSource>, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> Split<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ TSource separator,
+ Func<IEnumerable<TSource>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Split(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ separator As TSource,
+ resultSelector As Func(Of IEnumerable(Of TSource), TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ Split(
+ IEnumerable<TSource>^ source,
+ TSource separator,
+ Func<IEnumerable<TSource>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Split :
+ source : IEnumerable<'TSource> *
+ separator : 'TSource *
+ resultSelector : Func<IEnumerable<'TSource>, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<TResult> Split<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ TSource separator,
+ int count,
+ Func<IEnumerable<TSource>, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function Split(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ separator As TSource,
+ count As Integer,
+ resultSelector As Func(Of IEnumerable(Of TSource), TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ Split(
+ IEnumerable<TSource>^ source,
+ TSource separator,
+ int count,
+ Func<IEnumerable<TSource>^, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member Split :
+ source : IEnumerable<'TSource> *
+ separator : 'TSource *
+ count : int *
+ resultSelector : Func<IEnumerable<'TSource>, 'TResult> -> IEnumerable<'TResult> public static bool StartsWith<T>(
+ this IEnumerable<T> first,
+ IEnumerable<T> second
+)
+<ExtensionAttribute>
+Public Shared Function StartsWith(Of T) (
+ first As IEnumerable(Of T),
+ second As IEnumerable(Of T)
+) As Booleanpublic:
+[ExtensionAttribute]
+generic<typename T>
+static bool StartsWith(
+ IEnumerable<T>^ first,
+ IEnumerable<T>^ second
+)[<ExtensionAttribute>]
+static member StartsWith :
+ first : IEnumerable<'T> *
+ second : IEnumerable<'T> -> bool public static bool StartsWith<T>(
+ this IEnumerable<T> first,
+ IEnumerable<T> second,
+ IEqualityComparer<T>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function StartsWith(Of T) (
+ first As IEnumerable(Of T),
+ second As IEnumerable(Of T),
+ comparer As IEqualityComparer(Of T)
+) As Booleanpublic:
+[ExtensionAttribute]
+generic<typename T>
+static bool StartsWith(
+ IEnumerable<T>^ first,
+ IEnumerable<T>^ second,
+ IEqualityComparer<T>^ comparer
+)[<ExtensionAttribute>]
+static member StartsWith :
+ first : IEnumerable<'T> *
+ second : IEnumerable<'T> *
+ comparer : IEqualityComparer<'T> -> bool public static IEnumerable<IList<T>> Subsets<T>(
+ this IEnumerable<T> sequence
+)
+<ExtensionAttribute>
+Public Shared Function Subsets(Of T) (
+ sequence As IEnumerable(Of T)
+) As IEnumerable(Of IList(Of T))public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<IList<T>^>^ Subsets(
+ IEnumerable<T>^ sequence
+)[<ExtensionAttribute>]
+static member Subsets :
+ sequence : IEnumerable<'T> -> IEnumerable<IList<'T>> + 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.
+ Subsets are produced in a deferred, streaming manner; however, each subset is returned + as a materialized list.
+ There are 2N subsets of a given sequence, where N ⇒ + sequence.Count().
| ArgumentNullException | Thrown if sequence is . |
public static IEnumerable<IList<T>> Subsets<T>(
+ this IEnumerable<T> sequence,
+ int subsetSize
+)
+<ExtensionAttribute>
+Public Shared Function Subsets(Of T) (
+ sequence As IEnumerable(Of T),
+ subsetSize As Integer
+) As IEnumerable(Of IList(Of T))public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<IList<T>^>^ Subsets(
+ IEnumerable<T>^ sequence,
+ int subsetSize
+)[<ExtensionAttribute>]
+static member Subsets :
+ sequence : IEnumerable<'T> *
+ subsetSize : int -> IEnumerable<IList<'T>> | ArgumentNullException | + Thrown if sequence is . + |
| ArgumentOutOfRangeException | + Thrown if subsetSize is less than zero. + |
public static IEnumerable<TResult> TagFirstLast<TSource, TResult>(
+ this IEnumerable<TSource> source,
+ Func<TSource, bool, bool, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function TagFirstLast(Of TSource, TResult) (
+ source As IEnumerable(Of TSource),
+ resultSelector As Func(Of TSource, Boolean, Boolean, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TSource, typename TResult>
+static IEnumerable<TResult>^ TagFirstLast(
+ IEnumerable<TSource>^ source,
+ Func<TSource, bool, bool, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member TagFirstLast :
+ source : IEnumerable<'TSource> *
+ resultSelector : Func<'TSource, bool, bool, 'TResult> -> IEnumerable<'TResult> var numbers = new[] { 123, 456, 789 };
+var result = numbers.TagFirstLast((num, fst, lst) => new
+ {
+ Number = num,
+ IsFirst = fst, IsLast = lst
+ });public static IEnumerable<TSource> TakeEvery<TSource>(
+ this IEnumerable<TSource> source,
+ int step
+)
+<ExtensionAttribute>
+Public Shared Function TakeEvery(Of TSource) (
+ source As IEnumerable(Of TSource),
+ step As Integer
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ TakeEvery(
+ IEnumerable<TSource>^ source,
+ int step
+)[<ExtensionAttribute>]
+static member TakeEvery :
+ source : IEnumerable<'TSource> *
+ step : int -> IEnumerable<'TSource> int[] numbers = { 1, 2, 3, 4, 5 };
+var result = numbers.TakeEvery(2);public static IEnumerable<TSource> TakeLast<TSource>(
+ this IEnumerable<TSource> source,
+ int count
+)
+<ExtensionAttribute>
+Public Shared Function TakeLast(Of TSource) (
+ source As IEnumerable(Of TSource),
+ count As Integer
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ TakeLast(
+ IEnumerable<TSource>^ source,
+ int count
+)[<ExtensionAttribute>]
+static member TakeLast :
+ source : IEnumerable<'TSource> *
+ count : int -> IEnumerable<'TSource> int[] numbers = { 12, 34, 56, 78 };
+var result = numbers.TakeLast(2);public static IEnumerable<TSource> TakeUntil<TSource>(
+ this IEnumerable<TSource> source,
+ Func<TSource, bool> predicate
+)
+<ExtensionAttribute>
+Public Shared Function TakeUntil(Of TSource) (
+ source As IEnumerable(Of TSource),
+ predicate As Func(Of TSource, Boolean)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ TakeUntil(
+ IEnumerable<TSource>^ source,
+ Func<TSource, bool>^ predicate
+)[<ExtensionAttribute>]
+static member TakeUntil :
+ source : IEnumerable<'TSource> *
+ predicate : Func<'TSource, bool> -> IEnumerable<'TSource> + TakeUntil differs from Enumerable.TakeWhile in two respects. Firstly, the sense + of the predicate is reversed: it is expected that the predicate will return false + to start with, and then return true - for example, when trying to find a matching + item in a sequence. +
+ Secondly, TakeUntil yields the element which causes the predicate to return true. For + example, in a sequence
{ 1, 2, 3, 4, 5 }x => x == 3{ 1, 2, 3 }+ TakeUntil is as lazy as possible: it will not iterate over the source sequence + until it has to, it won't iterate further than it has to, and it won't evaluate + the predicate until it has to. (This means that an item may be returned which would + actually cause the predicate to throw an exception if it were evaluated, so long as + no more items of data are requested.) +
| ArgumentNullException | source or predicate is null |
public static IOrderedEnumerable<T> ThenBy<T, TKey>(
+ this IOrderedEnumerable<T> source,
+ Func<T, TKey> keySelector,
+ OrderByDirection direction
+)
+<ExtensionAttribute>
+Public Shared Function ThenBy(Of T, TKey) (
+ source As IOrderedEnumerable(Of T),
+ keySelector As Func(Of T, TKey),
+ direction As OrderByDirection
+) As IOrderedEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T, typename TKey>
+static IOrderedEnumerable<T>^ ThenBy(
+ IOrderedEnumerable<T>^ source,
+ Func<T, TKey>^ keySelector,
+ OrderByDirection direction
+)[<ExtensionAttribute>]
+static member ThenBy :
+ source : IOrderedEnumerable<'T> *
+ keySelector : Func<'T, 'TKey> *
+ direction : OrderByDirection -> IOrderedEnumerable<'T> public static IOrderedEnumerable<T> ThenBy<T, TKey>(
+ this IOrderedEnumerable<T> source,
+ Func<T, TKey> keySelector,
+ IComparer<TKey>? comparer,
+ OrderByDirection direction
+)
+<ExtensionAttribute>
+Public Shared Function ThenBy(Of T, TKey) (
+ source As IOrderedEnumerable(Of T),
+ keySelector As Func(Of T, TKey),
+ comparer As IComparer(Of TKey),
+ direction As OrderByDirection
+) As IOrderedEnumerable(Of T)public:
+[ExtensionAttribute]
+generic<typename T, typename TKey>
+static IOrderedEnumerable<T>^ ThenBy(
+ IOrderedEnumerable<T>^ source,
+ Func<T, TKey>^ keySelector,
+ IComparer<TKey>^ comparer,
+ OrderByDirection direction
+)[<ExtensionAttribute>]
+static member ThenBy :
+ source : IOrderedEnumerable<'T> *
+ keySelector : Func<'T, 'TKey> *
+ comparer : IComparer<'TKey> *
+ direction : OrderByDirection -> IOrderedEnumerable<'T> public static T[] ToArrayByIndex<T>(
+ this IEnumerable<T> source,
+ Func<T, int> indexSelector
+)
+<ExtensionAttribute>
+Public Shared Function ToArrayByIndex(Of T) (
+ source As IEnumerable(Of T),
+ indexSelector As Func(Of T, Integer)
+) As T()public:
+[ExtensionAttribute]
+generic<typename T>
+static array<T>^ ToArrayByIndex(
+ IEnumerable<T>^ source,
+ Func<T, int>^ indexSelector
+)[<ExtensionAttribute>]
+static member ToArrayByIndex :
+ source : IEnumerable<'T> *
+ indexSelector : Func<'T, int> -> 'T[] public static T[] ToArrayByIndex<T>(
+ this IEnumerable<T> source,
+ int length,
+ Func<T, int> indexSelector
+)
+<ExtensionAttribute>
+Public Shared Function ToArrayByIndex(Of T) (
+ source As IEnumerable(Of T),
+ length As Integer,
+ indexSelector As Func(Of T, Integer)
+) As T()public:
+[ExtensionAttribute]
+generic<typename T>
+static array<T>^ ToArrayByIndex(
+ IEnumerable<T>^ source,
+ int length,
+ Func<T, int>^ indexSelector
+)[<ExtensionAttribute>]
+static member ToArrayByIndex :
+ source : IEnumerable<'T> *
+ length : int *
+ indexSelector : Func<'T, int> -> 'T[] public static TResult[] ToArrayByIndex<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, int> indexSelector,
+ Func<T, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function ToArrayByIndex(Of T, TResult) (
+ source As IEnumerable(Of T),
+ indexSelector As Func(Of T, Integer),
+ resultSelector As Func(Of T, TResult)
+) As TResult()public:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static array<TResult>^ ToArrayByIndex(
+ IEnumerable<T>^ source,
+ Func<T, int>^ indexSelector,
+ Func<T, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member ToArrayByIndex :
+ source : IEnumerable<'T> *
+ indexSelector : Func<'T, int> *
+ resultSelector : Func<'T, 'TResult> -> 'TResult[] public static TResult[] ToArrayByIndex<T, TResult>(
+ this IEnumerable<T> source,
+ Func<T, int> indexSelector,
+ Func<T, int, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function ToArrayByIndex(Of T, TResult) (
+ source As IEnumerable(Of T),
+ indexSelector As Func(Of T, Integer),
+ resultSelector As Func(Of T, Integer, TResult)
+) As TResult()public:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static array<TResult>^ ToArrayByIndex(
+ IEnumerable<T>^ source,
+ Func<T, int>^ indexSelector,
+ Func<T, int, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member ToArrayByIndex :
+ source : IEnumerable<'T> *
+ indexSelector : Func<'T, int> *
+ resultSelector : Func<'T, int, 'TResult> -> 'TResult[] public static TResult[] ToArrayByIndex<T, TResult>(
+ this IEnumerable<T> source,
+ int length,
+ Func<T, int> indexSelector,
+ Func<T, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function ToArrayByIndex(Of T, TResult) (
+ source As IEnumerable(Of T),
+ length As Integer,
+ indexSelector As Func(Of T, Integer),
+ resultSelector As Func(Of T, TResult)
+) As TResult()public:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static array<TResult>^ ToArrayByIndex(
+ IEnumerable<T>^ source,
+ int length,
+ Func<T, int>^ indexSelector,
+ Func<T, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member ToArrayByIndex :
+ source : IEnumerable<'T> *
+ length : int *
+ indexSelector : Func<'T, int> *
+ resultSelector : Func<'T, 'TResult> -> 'TResult[] public static TResult[] ToArrayByIndex<T, TResult>(
+ this IEnumerable<T> source,
+ int length,
+ Func<T, int> indexSelector,
+ Func<T, int, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function ToArrayByIndex(Of T, TResult) (
+ source As IEnumerable(Of T),
+ length As Integer,
+ indexSelector As Func(Of T, Integer),
+ resultSelector As Func(Of T, Integer, TResult)
+) As TResult()public:
+[ExtensionAttribute]
+generic<typename T, typename TResult>
+static array<TResult>^ ToArrayByIndex(
+ IEnumerable<T>^ source,
+ int length,
+ Func<T, int>^ indexSelector,
+ Func<T, int, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member ToArrayByIndex :
+ source : IEnumerable<'T> *
+ length : int *
+ indexSelector : Func<'T, int> *
+ resultSelector : Func<'T, int, 'TResult> -> 'TResult[] public static DataTable ToDataTable<T>(
+ this IEnumerable<T> source
+)
+<ExtensionAttribute>
+Public Shared Function ToDataTable(Of T) (
+ source As IEnumerable(Of T)
+) As DataTablepublic:
+[ExtensionAttribute]
+generic<typename T>
+static DataTable^ ToDataTable(
+ IEnumerable<T>^ source
+)[<ExtensionAttribute>]
+static member ToDataTable :
+ source : IEnumerable<'T> -> DataTable public static DataTable ToDataTable<T>(
+ this IEnumerable<T> source,
+ params Expression<Func<T, Object?>>[] expressions
+)
+<ExtensionAttribute>
+Public Shared Function ToDataTable(Of T) (
+ source As IEnumerable(Of T),
+ ParamArray expressions As Expression(Of Func(Of T, Object))()
+) As DataTablepublic:
+[ExtensionAttribute]
+generic<typename T>
+static DataTable^ ToDataTable(
+ IEnumerable<T>^ source,
+ ... array<Expression<Func<T, Object^>^>^>^ expressions
+)[<ExtensionAttribute>]
+static member ToDataTable :
+ source : IEnumerable<'T> *
+ expressions : Expression<Func<'T, Object>>[] -> DataTable public static TTable ToDataTable<T, TTable>(
+ this IEnumerable<T> source,
+ TTable table
+)
+where TTable : DataTable
+<ExtensionAttribute>
+Public Shared Function ToDataTable(Of T, TTable As DataTable) (
+ source As IEnumerable(Of T),
+ table As TTable
+) As TTablepublic:
+[ExtensionAttribute]
+generic<typename T, typename TTable>
+where TTable : DataTable
+static TTable ToDataTable(
+ IEnumerable<T>^ source,
+ TTable table
+)[<ExtensionAttribute>]
+static member ToDataTable :
+ source : IEnumerable<'T> *
+ table : 'TTable -> 'TTable when 'TTable : DataTablepublic static TTable ToDataTable<T, TTable>(
+ this IEnumerable<T> source,
+ TTable table,
+ params Expression<Func<T, Object?>>[] expressions
+)
+where TTable : DataTable
+<ExtensionAttribute>
+Public Shared Function ToDataTable(Of T, TTable As DataTable) (
+ source As IEnumerable(Of T),
+ table As TTable,
+ ParamArray expressions As Expression(Of Func(Of T, Object))()
+) As TTablepublic:
+[ExtensionAttribute]
+generic<typename T, typename TTable>
+where TTable : DataTable
+static TTable ToDataTable(
+ IEnumerable<T>^ source,
+ TTable table,
+ ... array<Expression<Func<T, Object^>^>^>^ expressions
+)[<ExtensionAttribute>]
+static member ToDataTable :
+ source : IEnumerable<'T> *
+ table : 'TTable *
+ expressions : Expression<Func<'T, Object>>[] -> 'TTable when 'TTable : DataTablepublic static string ToDelimitedString(
+ this IEnumerable<bool> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of Boolean),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<bool>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<bool> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString(
+ this IEnumerable<byte> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of Byte),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<unsigned char>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<byte> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString(
+ this IEnumerable<string> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of String),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<String^>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<string> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString(
+ this IEnumerable<ushort> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of UShort),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<unsigned short>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<uint16> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString(
+ this IEnumerable<uint> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of UInteger),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<unsigned int>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<uint32> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString(
+ this IEnumerable<ulong> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of ULong),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<unsigned long long>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<uint64> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString(
+ this IEnumerable<char> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of Char),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<wchar_t>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<char> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString(
+ this IEnumerable<decimal> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of Decimal),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<Decimal>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<decimal> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString(
+ this IEnumerable<double> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of Double),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<double>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<float> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString(
+ this IEnumerable<short> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of Short),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<short>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<int16> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString(
+ this IEnumerable<int> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of Integer),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<int>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<int> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString(
+ this IEnumerable<long> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of Long),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<long long>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<int64> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString(
+ this IEnumerable<sbyte> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of SByte),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<signed char>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<sbyte> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString(
+ this IEnumerable<float> source,
+ string delimiter
+)<ExtensionAttribute>
+Public Shared Function ToDelimitedString (
+ source As IEnumerable(Of Single),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+static String^ ToDelimitedString(
+ IEnumerable<float>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<float32> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static string ToDelimitedString<TSource>(
+ this IEnumerable<TSource> source,
+ string delimiter
+)
+<ExtensionAttribute>
+Public Shared Function ToDelimitedString(Of TSource) (
+ source As IEnumerable(Of TSource),
+ delimiter As String
+) As Stringpublic:
+[ExtensionAttribute]
+generic<typename TSource>
+static String^ ToDelimitedString(
+ IEnumerable<TSource>^ source,
+ String^ delimiter
+)[<ExtensionAttribute>]
+static member ToDelimitedString :
+ source : IEnumerable<'TSource> *
+ delimiter : string -> string | ArgumentNullException | source or delimiter is null. + |
public static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(
+ this IEnumerable<KeyValuePair<TKey, TValue>> source
+)
+<ExtensionAttribute>
+Public Shared Function ToDictionary(Of TKey, TValue) (
+ source As IEnumerable(Of KeyValuePair(Of TKey, TValue))
+) As Dictionary(Of TKey, TValue)public:
+[ExtensionAttribute]
+generic<typename TKey, typename TValue>
+static Dictionary<TKey, TValue>^ ToDictionary(
+ IEnumerable<KeyValuePair<TKey, TValue>>^ source
+)[<ExtensionAttribute>]
+static member ToDictionary :
+ source : IEnumerable<KeyValuePair<'TKey, 'TValue>> -> Dictionary<'TKey, 'TValue> public static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(
+ this IEnumerable<KeyValuePair<TKey, TValue>> source,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function ToDictionary(Of TKey, TValue) (
+ source As IEnumerable(Of KeyValuePair(Of TKey, TValue)),
+ comparer As IEqualityComparer(Of TKey)
+) As Dictionary(Of TKey, TValue)public:
+[ExtensionAttribute]
+generic<typename TKey, typename TValue>
+static Dictionary<TKey, TValue>^ ToDictionary(
+ IEnumerable<KeyValuePair<TKey, TValue>>^ source,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member ToDictionary :
+ source : IEnumerable<KeyValuePair<'TKey, 'TValue>> *
+ comparer : IEqualityComparer<'TKey> -> Dictionary<'TKey, 'TValue> public static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(
+ this IEnumerable<(TKey , TValue )> source
+)
+<ExtensionAttribute>
+Public Shared Function ToDictionary(Of TKey, TValue) (
+ source As IEnumerable(Of ( As TKey, As TValue))
+) As Dictionary(Of TKey, TValue)public:
+[ExtensionAttribute]
+generic<typename TKey, typename TValue>
+static Dictionary<TKey, TValue>^ ToDictionary(
+ IEnumerable<ValueTuple<TKey, TValue>>^ source
+)[<ExtensionAttribute>]
+static member ToDictionary :
+ source : IEnumerable<ValueTuple<'TKey, 'TValue>> -> Dictionary<'TKey, 'TValue> public static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(
+ this IEnumerable<(TKey , TValue )> source,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function ToDictionary(Of TKey, TValue) (
+ source As IEnumerable(Of ( As TKey, As TValue)),
+ comparer As IEqualityComparer(Of TKey)
+) As Dictionary(Of TKey, TValue)public:
+[ExtensionAttribute]
+generic<typename TKey, typename TValue>
+static Dictionary<TKey, TValue>^ ToDictionary(
+ IEnumerable<ValueTuple<TKey, TValue>>^ source,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member ToDictionary :
+ source : IEnumerable<ValueTuple<'TKey, 'TValue>> *
+ comparer : IEqualityComparer<'TKey> -> Dictionary<'TKey, 'TValue> public static HashSet<TSource> ToHashSet<TSource>(
+ this IEnumerable<TSource> source
+)
+<ExtensionAttribute>
+Public Shared Function ToHashSet(Of TSource) (
+ source As IEnumerable(Of TSource)
+) As HashSet(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static HashSet<TSource>^ ToHashSet(
+ IEnumerable<TSource>^ source
+)[<ExtensionAttribute>]
+static member ToHashSet :
+ source : IEnumerable<'TSource> -> HashSet<'TSource> | ArgumentNullException | source is null |
public static HashSet<TSource> ToHashSet<TSource>(
+ this IEnumerable<TSource> source,
+ IEqualityComparer<TSource>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function ToHashSet(Of TSource) (
+ source As IEnumerable(Of TSource),
+ comparer As IEqualityComparer(Of TSource)
+) As HashSet(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static HashSet<TSource>^ ToHashSet(
+ IEnumerable<TSource>^ source,
+ IEqualityComparer<TSource>^ comparer
+)[<ExtensionAttribute>]
+static member ToHashSet :
+ source : IEnumerable<'TSource> *
+ comparer : IEqualityComparer<'TSource> -> HashSet<'TSource> | ArgumentNullException | source is null |
public static ILookup<TKey, TValue> ToLookup<TKey, TValue>(
+ this IEnumerable<KeyValuePair<TKey, TValue>> source
+)
+<ExtensionAttribute>
+Public Shared Function ToLookup(Of TKey, TValue) (
+ source As IEnumerable(Of KeyValuePair(Of TKey, TValue))
+) As ILookup(Of TKey, TValue)public:
+[ExtensionAttribute]
+generic<typename TKey, typename TValue>
+static ILookup<TKey, TValue>^ ToLookup(
+ IEnumerable<KeyValuePair<TKey, TValue>>^ source
+)[<ExtensionAttribute>]
+static member ToLookup :
+ source : IEnumerable<KeyValuePair<'TKey, 'TValue>> -> ILookup<'TKey, 'TValue> public static ILookup<TKey, TValue> ToLookup<TKey, TValue>(
+ this IEnumerable<KeyValuePair<TKey, TValue>> source,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function ToLookup(Of TKey, TValue) (
+ source As IEnumerable(Of KeyValuePair(Of TKey, TValue)),
+ comparer As IEqualityComparer(Of TKey)
+) As ILookup(Of TKey, TValue)public:
+[ExtensionAttribute]
+generic<typename TKey, typename TValue>
+static ILookup<TKey, TValue>^ ToLookup(
+ IEnumerable<KeyValuePair<TKey, TValue>>^ source,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member ToLookup :
+ source : IEnumerable<KeyValuePair<'TKey, 'TValue>> *
+ comparer : IEqualityComparer<'TKey> -> ILookup<'TKey, 'TValue> public static ILookup<TKey, TValue> ToLookup<TKey, TValue>(
+ this IEnumerable<(TKey , TValue )> source
+)
+<ExtensionAttribute>
+Public Shared Function ToLookup(Of TKey, TValue) (
+ source As IEnumerable(Of ( As TKey, As TValue))
+) As ILookup(Of TKey, TValue)public:
+[ExtensionAttribute]
+generic<typename TKey, typename TValue>
+static ILookup<TKey, TValue>^ ToLookup(
+ IEnumerable<ValueTuple<TKey, TValue>>^ source
+)[<ExtensionAttribute>]
+static member ToLookup :
+ source : IEnumerable<ValueTuple<'TKey, 'TValue>> -> ILookup<'TKey, 'TValue> public static ILookup<TKey, TValue> ToLookup<TKey, TValue>(
+ this IEnumerable<(TKey , TValue )> source,
+ IEqualityComparer<TKey>? comparer
+)
+<ExtensionAttribute>
+Public Shared Function ToLookup(Of TKey, TValue) (
+ source As IEnumerable(Of ( As TKey, As TValue)),
+ comparer As IEqualityComparer(Of TKey)
+) As ILookup(Of TKey, TValue)public:
+[ExtensionAttribute]
+generic<typename TKey, typename TValue>
+static ILookup<TKey, TValue>^ ToLookup(
+ IEnumerable<ValueTuple<TKey, TValue>>^ source,
+ IEqualityComparer<TKey>^ comparer
+)[<ExtensionAttribute>]
+static member ToLookup :
+ source : IEnumerable<ValueTuple<'TKey, 'TValue>> *
+ comparer : IEqualityComparer<'TKey> -> ILookup<'TKey, 'TValue> public static IEnumerable<TSource> Trace<TSource>(
+ this IEnumerable<TSource> source
+)
+<ExtensionAttribute>
+Public Shared Function Trace(Of TSource) (
+ source As IEnumerable(Of TSource)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ Trace(
+ IEnumerable<TSource>^ source
+)[<ExtensionAttribute>]
+static member Trace :
+ source : IEnumerable<'TSource> -> IEnumerable<'TSource> public static IEnumerable<TSource> Trace<TSource>(
+ this IEnumerable<TSource> source,
+ Func<TSource, string> formatter
+)
+<ExtensionAttribute>
+Public Shared Function Trace(Of TSource) (
+ source As IEnumerable(Of TSource),
+ formatter As Func(Of TSource, String)
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ Trace(
+ IEnumerable<TSource>^ source,
+ Func<TSource, String^>^ formatter
+)[<ExtensionAttribute>]
+static member Trace :
+ source : IEnumerable<'TSource> *
+ formatter : Func<'TSource, string> -> IEnumerable<'TSource> public static IEnumerable<TSource> Trace<TSource>(
+ this IEnumerable<TSource> source,
+ string? format
+)
+<ExtensionAttribute>
+Public Shared Function Trace(Of TSource) (
+ source As IEnumerable(Of TSource),
+ format As String
+) As IEnumerable(Of TSource)public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<TSource>^ Trace(
+ IEnumerable<TSource>^ source,
+ String^ format
+)[<ExtensionAttribute>]
+static member Trace :
+ source : IEnumerable<'TSource> *
+ format : string -> IEnumerable<'TSource> public static IEnumerable<IEnumerable<T>> Transpose<T>(
+ this IEnumerable<IEnumerable<T>> source
+)
+<ExtensionAttribute>
+Public Shared Function Transpose(Of T) (
+ source As IEnumerable(Of IEnumerable(Of T))
+) As IEnumerable(Of IEnumerable(Of T))public:
+[ExtensionAttribute]
+generic<typename T>
+static IEnumerable<IEnumerable<T>^>^ Transpose(
+ IEnumerable<IEnumerable<T>^>^ source
+)[<ExtensionAttribute>]
+static member Transpose :
+ source : IEnumerable<IEnumerable<'T>> -> IEnumerable<IEnumerable<'T>> var matrix = new[]
+{
+ new[] { 10, 11 },
+ new[] { 20 },
+ new[] { 30, 31, 32 }
+};
+var result = matrix.Transpose();public static IEnumerable<T> TraverseBreadthFirst<T>(
+ T root,
+ Func<T, IEnumerable<T>> childrenSelector
+)
+Public Shared Function TraverseBreadthFirst(Of T) (
+ root As T,
+ childrenSelector As Func(Of T, IEnumerable(Of T))
+) As IEnumerable(Of T)public:
+generic<typename T>
+static IEnumerable<T>^ TraverseBreadthFirst(
+ T root,
+ Func<T, IEnumerable<T>^>^ childrenSelector
+)static member TraverseBreadthFirst :
+ root : 'T *
+ childrenSelector : Func<'T, IEnumerable<'T>> -> IEnumerable<'T> + The tree is not checked for loops. If the resulting sequence needs + to be finite then it is the responsibility of + childrenSelector to ensure that loops are not + produced.
+ This function defers traversal until needed and streams the + results.
public static IEnumerable<T> TraverseDepthFirst<T>(
+ T root,
+ Func<T, IEnumerable<T>> childrenSelector
+)
+Public Shared Function TraverseDepthFirst(Of T) (
+ root As T,
+ childrenSelector As Func(Of T, IEnumerable(Of T))
+) As IEnumerable(Of T)public:
+generic<typename T>
+static IEnumerable<T>^ TraverseDepthFirst(
+ T root,
+ Func<T, IEnumerable<T>^>^ childrenSelector
+)static member TraverseDepthFirst :
+ root : 'T *
+ childrenSelector : Func<'T, IEnumerable<'T>> -> IEnumerable<'T> + The tree is not checked for loops. If the resulting sequence needs + to be finite then it is the responsibility of + childrenSelector to ensure that loops are not + produced.
+ This function defers traversal until needed and streams the + results.
public static IEnumerable<TResult> Unfold<TState, T, TResult>(
+ TState state,
+ Func<TState, T> generator,
+ Func<T, bool> predicate,
+ Func<T, TState> stateSelector,
+ Func<T, TResult> resultSelector
+)
+Public Shared Function Unfold(Of TState, T, TResult) (
+ state As TState,
+ generator As Func(Of TState, T),
+ predicate As Func(Of T, Boolean),
+ stateSelector As Func(Of T, TState),
+ resultSelector As Func(Of T, TResult)
+) As IEnumerable(Of TResult)public:
+generic<typename TState, typename T, typename TResult>
+static IEnumerable<TResult>^ Unfold(
+ TState state,
+ Func<TState, T>^ generator,
+ Func<T, bool>^ predicate,
+ Func<T, TState>^ stateSelector,
+ Func<T, TResult>^ resultSelector
+)static member Unfold :
+ state : 'TState *
+ generator : Func<'TState, 'T> *
+ predicate : Func<'T, bool> *
+ stateSelector : Func<'T, 'TState> *
+ resultSelector : Func<'T, 'TResult> -> IEnumerable<'TResult> public static IEnumerable<IList<TSource>> WindowLeft<TSource>(
+ this IEnumerable<TSource> source,
+ int size
+)
+<ExtensionAttribute>
+Public Shared Function WindowLeft(Of TSource) (
+ source As IEnumerable(Of TSource),
+ size As Integer
+) As IEnumerable(Of IList(Of TSource))public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<IList<TSource>^>^ WindowLeft(
+ IEnumerable<TSource>^ source,
+ int size
+)[<ExtensionAttribute>]
+static member WindowLeft :
+ source : IEnumerable<'TSource> *
+ size : int -> IEnumerable<IList<'TSource>> + A window can contain fewer elements than size, + especially as it slides over the end of the sequence.
+ This operator uses deferred execution and streams its results.
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) = 5public static IEnumerable<IList<TSource>> WindowRight<TSource>(
+ this IEnumerable<TSource> source,
+ int size
+)
+<ExtensionAttribute>
+Public Shared Function WindowRight(Of TSource) (
+ source As IEnumerable(Of TSource),
+ size As Integer
+) As IEnumerable(Of IList(Of TSource))public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<IList<TSource>^>^ WindowRight(
+ IEnumerable<TSource>^ source,
+ int size
+)[<ExtensionAttribute>]
+static member WindowRight :
+ source : IEnumerable<'TSource> *
+ size : int -> IEnumerable<IList<'TSource>> + A window can contain fewer elements than size, + especially as it slides over the start of the sequence.
+ This operator uses deferred execution and streams its results.
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) = 4public static IEnumerable<IList<TSource>> Window<TSource>(
+ this IEnumerable<TSource> source,
+ int size
+)
+<ExtensionAttribute>
+Public Shared Function Window(Of TSource) (
+ source As IEnumerable(Of TSource),
+ size As Integer
+) As IEnumerable(Of IList(Of TSource))public:
+[ExtensionAttribute]
+generic<typename TSource>
+static IEnumerable<IList<TSource>^>^ Window(
+ IEnumerable<TSource>^ source,
+ int size
+)[<ExtensionAttribute>]
+static member Window :
+ source : IEnumerable<'TSource> *
+ size : int -> IEnumerable<IList<'TSource>> + The number of sequences returned is: Max(0, sequence.Count() - windowSize) + + 1
+ Returned sub-sequences are buffered, but the overall operation is streamed.
[ObsoleteAttribute("Use Window instead.")]
+public static IEnumerable<IEnumerable<TSource>> Windowed<TSource>(
+ this IEnumerable<TSource> source,
+ int size
+)
+<ExtensionAttribute>
+<ObsoleteAttribute("Use Window instead.")>
+Public Shared Function Windowed(Of TSource) (
+ source As IEnumerable(Of TSource),
+ size As Integer
+) As IEnumerable(Of IEnumerable(Of TSource))public:
+[ExtensionAttribute]
+[ObsoleteAttribute(L"Use Window instead.")]
+generic<typename TSource>
+static IEnumerable<IEnumerable<TSource>^>^ Windowed(
+ IEnumerable<TSource>^ source,
+ int size
+)[<ExtensionAttribute>]
+[<ObsoleteAttribute("Use Window instead.")>]
+static member Windowed :
+ source : IEnumerable<'TSource> *
+ size : int -> IEnumerable<IEnumerable<'TSource>> + The number of sequences returned is: Max(0, sequence.Count() - windowSize) + + 1
+ Returned sub-sequences are buffered, but the overall operation is streamed.
public static IEnumerable<TResult> ZipLongest<TFirst, TSecond, TResult>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TSecond, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function ZipLongest(Of TFirst, TSecond, TResult) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ resultSelector As Func(Of TFirst, TSecond, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TResult>
+static IEnumerable<TResult>^ ZipLongest(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TSecond, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member ZipLongest :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ resultSelector : Func<'TFirst, 'TSecond, 'TResult> -> IEnumerable<'TResult> var numbers = { 1, 2, 3 };
+var letters = { "A", "B", "C", "D" };
+var zipped = numbers.ZipLongest(letters, (n, l) => n + l);| ArgumentNullException | first, second, or resultSelector is . + |
public static IEnumerable<TResult> ZipLongest<T1, T2, T3, TResult>(
+ this IEnumerable<T1> first,
+ IEnumerable<T2> second,
+ IEnumerable<T3> third,
+ Func<T1, T2, T3, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function ZipLongest(Of T1, T2, T3, TResult) (
+ first As IEnumerable(Of T1),
+ second As IEnumerable(Of T2),
+ third As IEnumerable(Of T3),
+ resultSelector As Func(Of T1, T2, T3, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T1, typename T2, typename T3, typename TResult>
+static IEnumerable<TResult>^ ZipLongest(
+ IEnumerable<T1>^ first,
+ IEnumerable<T2>^ second,
+ IEnumerable<T3>^ third,
+ Func<T1, T2, T3, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member ZipLongest :
+ first : IEnumerable<'T1> *
+ second : IEnumerable<'T2> *
+ third : IEnumerable<'T3> *
+ resultSelector : Func<'T1, 'T2, 'T3, 'TResult> -> IEnumerable<'TResult> 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);| ArgumentNullException | first, second, third, or resultSelector is . + |
public static IEnumerable<TResult> ZipLongest<T1, T2, T3, T4, TResult>(
+ this IEnumerable<T1> first,
+ IEnumerable<T2> second,
+ IEnumerable<T3> third,
+ IEnumerable<T4> fourth,
+ Func<T1, T2, T3, T4, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function ZipLongest(Of T1, T2, T3, T4, TResult) (
+ first As IEnumerable(Of T1),
+ second As IEnumerable(Of T2),
+ third As IEnumerable(Of T3),
+ fourth As IEnumerable(Of T4),
+ resultSelector As Func(Of T1, T2, T3, T4, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T1, typename T2, typename T3, typename T4, typename TResult>
+static IEnumerable<TResult>^ ZipLongest(
+ IEnumerable<T1>^ first,
+ IEnumerable<T2>^ second,
+ IEnumerable<T3>^ third,
+ IEnumerable<T4>^ fourth,
+ Func<T1, T2, T3, T4, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member ZipLongest :
+ first : IEnumerable<'T1> *
+ second : IEnumerable<'T2> *
+ third : IEnumerable<'T3> *
+ fourth : IEnumerable<'T4> *
+ resultSelector : Func<'T1, 'T2, 'T3, 'T4, 'TResult> -> IEnumerable<'TResult> 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);| ArgumentNullException | first, second, third, fourth, or resultSelector is . + |
public static IEnumerable<TResult> ZipShortest<TFirst, TSecond, TResult>(
+ this IEnumerable<TFirst> first,
+ IEnumerable<TSecond> second,
+ Func<TFirst, TSecond, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function ZipShortest(Of TFirst, TSecond, TResult) (
+ first As IEnumerable(Of TFirst),
+ second As IEnumerable(Of TSecond),
+ resultSelector As Func(Of TFirst, TSecond, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename TFirst, typename TSecond, typename TResult>
+static IEnumerable<TResult>^ ZipShortest(
+ IEnumerable<TFirst>^ first,
+ IEnumerable<TSecond>^ second,
+ Func<TFirst, TSecond, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member ZipShortest :
+ first : IEnumerable<'TFirst> *
+ second : IEnumerable<'TSecond> *
+ resultSelector : Func<'TFirst, 'TSecond, 'TResult> -> IEnumerable<'TResult> + 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. +
+ This operator uses deferred execution and streams its results.
var numbers = new[] { 1, 2, 3 };
+var letters = new[] { "A", "B", "C", "D" };
+var zipped = numbers.ZipShortest(letters, (n, l) => n + l);public static IEnumerable<TResult> ZipShortest<T1, T2, T3, TResult>(
+ this IEnumerable<T1> first,
+ IEnumerable<T2> second,
+ IEnumerable<T3> third,
+ Func<T1, T2, T3, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function ZipShortest(Of T1, T2, T3, TResult) (
+ first As IEnumerable(Of T1),
+ second As IEnumerable(Of T2),
+ third As IEnumerable(Of T3),
+ resultSelector As Func(Of T1, T2, T3, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T1, typename T2, typename T3, typename TResult>
+static IEnumerable<TResult>^ ZipShortest(
+ IEnumerable<T1>^ first,
+ IEnumerable<T2>^ second,
+ IEnumerable<T3>^ third,
+ Func<T1, T2, T3, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member ZipShortest :
+ first : IEnumerable<'T1> *
+ second : IEnumerable<'T2> *
+ third : IEnumerable<'T3> *
+ resultSelector : Func<'T1, 'T2, 'T3, 'TResult> -> IEnumerable<'TResult> + 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. +
+ This operator uses deferred execution and streams its results.
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);| ArgumentNullException | first, second, third, or resultSelector is . + |
public static IEnumerable<TResult> ZipShortest<T1, T2, T3, T4, TResult>(
+ this IEnumerable<T1> first,
+ IEnumerable<T2> second,
+ IEnumerable<T3> third,
+ IEnumerable<T4> fourth,
+ Func<T1, T2, T3, T4, TResult> resultSelector
+)
+<ExtensionAttribute>
+Public Shared Function ZipShortest(Of T1, T2, T3, T4, TResult) (
+ first As IEnumerable(Of T1),
+ second As IEnumerable(Of T2),
+ third As IEnumerable(Of T3),
+ fourth As IEnumerable(Of T4),
+ resultSelector As Func(Of T1, T2, T3, T4, TResult)
+) As IEnumerable(Of TResult)public:
+[ExtensionAttribute]
+generic<typename T1, typename T2, typename T3, typename T4, typename TResult>
+static IEnumerable<TResult>^ ZipShortest(
+ IEnumerable<T1>^ first,
+ IEnumerable<T2>^ second,
+ IEnumerable<T3>^ third,
+ IEnumerable<T4>^ fourth,
+ Func<T1, T2, T3, T4, TResult>^ resultSelector
+)[<ExtensionAttribute>]
+static member ZipShortest :
+ first : IEnumerable<'T1> *
+ second : IEnumerable<'T2> *
+ third : IEnumerable<'T3> *
+ fourth : IEnumerable<'T4> *
+ resultSelector : Func<'T1, 'T2, 'T3, 'T4, 'TResult> -> IEnumerable<'TResult> + 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. +
+ This operator uses deferred execution and streams its results.
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);| ArgumentNullException | first, second, third, fourth, or resultSelector is . + |
public SequenceException()Public Sub Newpublic:
+SequenceException()new : unit -> SequenceExceptionprotected SequenceException(
+ SerializationInfo info,
+ StreamingContext context
+)Protected Sub New (
+ info As SerializationInfo,
+ context As StreamingContext
+)protected:
+SequenceException(
+ SerializationInfo^ info,
+ StreamingContext context
+)new :
+ info : SerializationInfo *
+ context : StreamingContext -> SequenceExceptionpublic SequenceException(
+ string? message
+)Public Sub New (
+ message As String
+)public:
+SequenceException(
+ String^ message
+)new :
+ message : string -> SequenceExceptionpublic SequenceException(
+ string? message,
+ Exception? innerException
+)Public Sub New (
+ message As String,
+ innerException As Exception
+)public:
+SequenceException(
+ String^ message,
+ Exception^ innerException
+)new :
+ message : string *
+ innerException : Exception -> SequenceException| MergeT(IEnumerableIAsyncEnumerableT) | + Concurrently merges all the elements of multiple asynchronous streams into a single + asynchronous stream. + |
| MergeT(IEnumerableIAsyncEnumerableT, Int32) | + Concurrently merges all the elements of multiple asynchronous streams into a single + asynchronous stream. An additional parameter specifies the maximum concurrent operations + that may be in flight at any give time. + |
| Equals | Determines whether the specified object is equal to the current object. (Inherited from Object) |
| GetHashCode | Serves as the default hash function. (Inherited from Object) |
| GetType | Gets the Type of the current instance. (Inherited from Object) |
| ToString | Returns a string that represents the current object. (Inherited from Object) |
| WithMaxConcurrency | + Returns new options with the given concurrency limit. + |
| WithPreserveOrder | + Returns new options with the given Boolean indicating whether or + not the results should be returned in the order of the source. + |
| WithScheduler | + Returns new options with the given scheduler. + |
| GetEnumerator | Returns an enumerator that iterates through the collection. (Inherited from IEnumerableT) |
| WithOptions | + Returns a new query that will use the given options. + |
| AggregateT, TResult1, TResult2, TResult |
+ Applies two accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TResult |
+ Applies two accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TResult |
+ Applies two accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult |
+ Applies three accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TResult |
+ Applies three accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TResult |
+ Applies three accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult |
+ Applies four accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult |
+ Applies four accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult |
+ Applies four accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult |
+ Applies five accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult |
+ Applies five accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult |
+ Applies five accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult |
+ Applies six accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult |
+ Applies six accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult |
+ Applies six accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult |
+ Applies seven accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult |
+ Applies seven accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult |
+ Applies seven accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult8, TResult |
+ Applies eight accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult |
+ Applies eight accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult |
+ Applies eight accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateRightT |
+ Applies a right-associative accumulator function over a sequence.
+ This operator is the right-associative version of the
+ AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ (Defined by MoreEnumerable) |
| AggregateRightT |
+ Applies a right-associative accumulator function over a sequence.
+ This operator is the right-associative version of the
+ AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ (Defined by AggregateRightExtension) |
| AggregateRightT, TAccumulate |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate) LINQ operator.
+ (Defined by MoreEnumerable) |
| AggregateRightT, TAccumulate |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate) LINQ operator.
+ (Defined by AggregateRightExtension) |
| AggregateRightT, TAccumulate, TResult |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value,
+ and the specified function is used to select the result value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate, FuncTAccumulate, TResult) LINQ operator.
+ (Defined by MoreEnumerable) |
| AggregateRightT, TAccumulate, TResult |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value,
+ and the specified function is used to select the result value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate, FuncTAccumulate, TResult) LINQ operator.
+ (Defined by AggregateRightExtension) |
| AppendT |
+ Returns a sequence consisting of the head elements and the given tail element.
+ (Defined by MoreEnumerable) |
| AppendT |
+ Returns a sequence consisting of the head elements and the given tail element.
+ (Defined by AppendExtension) |
| AsOrderedT |
+ Returns a query whose results evaluate asynchronously but which
+ are returned in the order of the source.
+ (Defined by ExperimentalEnumerable) |
| AsSequentialT |
+ Converts a query whose results evaluate asynchronously to use
+ sequential instead of concurrent evaluation.
+ (Defined by ExperimentalEnumerable) |
| AssertT |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ (Defined by MoreEnumerable) |
| AssertT |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ (Defined by AssertExtension) |
| AssertT |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ (Defined by MoreEnumerable) |
| AssertT |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ (Defined by AssertExtension) |
| AssertCountT |
+ Asserts that a source sequence contains a given count of elements.
+ (Defined by MoreEnumerable) |
| AssertCountT |
+ Asserts that a source sequence contains a given count of elements.
+ (Defined by AssertCountExtension) |
| AssertCountT |
+ Asserts that a source sequence contains a given count of elements.
+ A parameter specifies the exception to be thrown.
+ (Defined by MoreEnumerable) |
| AssertCountT |
+ Asserts that a source sequence contains a given count of elements.
+ A parameter specifies the exception to be thrown.
+ (Defined by AssertCountExtension) |
| AsUnorderedT |
+ Returns a query whose results evaluate asynchronously but which
+ are returned without guarantee of the source order.
+ (Defined by ExperimentalEnumerable) |
| AtLeastT |
+ Determines whether or not the number of elements in the sequence is greater than
+ or equal to the given integer.
+ (Defined by MoreEnumerable) |
| AtLeastT |
+ Determines whether or not the number of elements in the sequence is greater than
+ or equal to the given integer.
+ (Defined by AtLeastExtension) |
| AtMostT |
+ Determines whether or not the number of elements in the sequence is lesser than
+ or equal to the given integer.
+ (Defined by MoreEnumerable) |
| AtMostT |
+ Determines whether or not the number of elements in the sequence is lesser than
+ or equal to the given integer.
+ (Defined by AtMostExtension) |
| AwaitT, TResult |
+ Creates a sequence query that streams the result of each task in
+ the source sequence as it completes asynchronously. A
+ CancellationToken is passed for each asynchronous
+ evaluation to abort any asynchronous operations in flight if the
+ sequence is not fully iterated.
+ (Defined by ExperimentalEnumerable) |
| AwaitCompletionT, TTaskResult, TResult |
+ 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.
+ (Defined by ExperimentalEnumerable) |
| BacksertT |
+ 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.
+ (Defined by MoreEnumerable) |
| BacksertT |
+ 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.
+ (Defined by BacksertExtension) |
| BatchT |
+ Batches the source sequence into sized buckets.
+ (Defined by MoreEnumerable) |
| BatchT |
+ Batches the source sequence into sized buckets.
+ (Defined by BatchExtension) |
| BatchT, TResult |
+ Batches the source sequence into sized buckets and applies a projection to each bucket.
+ (Defined by MoreEnumerable) |
| BatchT, TResult |
+ Batches the source sequence into sized buckets and applies a projection to each bucket.
+ (Defined by BatchExtension) |
| BatchT, TResult |
+ Batches the source sequence into sized buckets using an array pool
+ to rent arrays to back each bucket and returns a sequence of
+ elements projected from each bucket.
+ (Defined by ExperimentalEnumerable) |
| BatchT, TBucket, TResult |
+ Batches the source sequence into sized buckets using an array pool
+ to rent arrays to back each bucket and returns a sequence of
+ elements projected from each bucket.
+ (Defined by ExperimentalEnumerable) |
| CartesianT, T2, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, T5, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, T5, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, T5, T6, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, T5, T6, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, T5, T6, T7, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, T5, T6, T7, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, T5, T6, T7, T8, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, T5, T6, T7, T8, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| ChooseT, TResult |
+ 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 true
+ as its first element and result as the second.
+ (Defined by MoreEnumerable) |
| ChooseT, TResult |
+ 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 true
+ as its first element and result as the second.
+ (Defined by ChooseExtension) |
| CompareCountT, TSecond |
+ Compares two sequences and returns an integer that indicates whether the first sequence
+ has fewer, the same or more elements than the second sequence.
+ (Defined by MoreEnumerable) |
| CompareCountT, TSecond |
+ Compares two sequences and returns an integer that indicates whether the first sequence
+ has fewer, the same or more elements than the second sequence.
+ (Defined by CompareCountExtension) |
| ConcatT |
+ Returns a sequence consisting of the head elements and the given tail element.
+ (Defined by MoreEnumerable) |
| ConsumeT |
+ Completely consumes the given sequence. This method uses immediate execution,
+ and doesn't store any data during execution.
+ (Defined by MoreEnumerable) |
| ConsumeT |
+ Completely consumes the given sequence. This method uses immediate execution,
+ and doesn't store any data during execution.
+ (Defined by ConsumeExtension) |
| CountBetweenT |
+ Determines whether or not the number of elements in the sequence is between
+ an inclusive range of minimum and maximum integers.
+ (Defined by MoreEnumerable) |
| CountBetweenT |
+ Determines whether or not the number of elements in the sequence is between
+ an inclusive range of minimum and maximum integers.
+ (Defined by CountBetweenExtension) |
| CountByT, TKey |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ (Defined by MoreEnumerable) |
| CountByT, TKey |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ (Defined by CountByExtension) |
| CountByT, TKey |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ An additional argument specifies a comparer to use for testing equivalence of keys.
+ (Defined by MoreEnumerable) |
| CountByT, TKey |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ An additional argument specifies a comparer to use for testing equivalence of keys.
+ (Defined by CountByExtension) |
| CountDownT, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CountDownT, TResult |
+ 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.
+ (Defined by CountDownExtension) |
| DistinctByT, TKey |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the default equality comparer for the projected type.
+ (Defined by MoreEnumerable) |
| DistinctByT, TKey |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the default equality comparer for the projected type.
+ (Defined by DistinctByExtension) |
| DistinctByT, TKey |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the specified comparer for the projected type.
+ (Defined by MoreEnumerable) |
| DistinctByT, TKey |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the specified comparer for the projected type.
+ (Defined by DistinctByExtension) |
| EndsWithT |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the default equality comparer.
+ (Defined by MoreEnumerable) |
| EndsWithT |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the default equality comparer.
+ (Defined by EndsWithExtension) |
| EndsWithT |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the specified element equality comparer.
+ (Defined by MoreEnumerable) |
| EndsWithT |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the specified element equality comparer.
+ (Defined by EndsWithExtension) |
| EquiZipT, TSecond, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| EquiZipT, TSecond, TResult |
+ 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.
+ (Defined by EquiZipExtension) |
| EquiZipT, T2, T3, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| EquiZipT, T2, T3, TResult |
+ 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.
+ (Defined by EquiZipExtension) |
| EquiZipT, T2, T3, T4, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| EquiZipT, T2, T3, T4, TResult |
+ 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.
+ (Defined by EquiZipExtension) |
| ExactlyT |
+ Determines whether or not the number of elements in the sequence is equals to the given integer.
+ (Defined by MoreEnumerable) |
| ExactlyT |
+ Determines whether or not the number of elements in the sequence is equals to the given integer.
+ (Defined by ExactlyExtension) |
| ExceptByT, TKey |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ (Defined by MoreEnumerable) |
| ExceptByT, TKey |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ (Defined by ExceptByExtension) |
| ExceptByT, TKey |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ (Defined by MoreEnumerable) |
| ExceptByT, TKey |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ (Defined by ExceptByExtension) |
| ExcludeT |
+ Excludes a contiguous number of elements from a sequence starting
+ at a given index.
+ (Defined by MoreEnumerable) |
| ExcludeT |
+ Excludes a contiguous number of elements from a sequence starting
+ at a given index.
+ (Defined by ExcludeExtension) |
| FallbackIfEmptyT |
+ Returns the elements of the specified sequence or the specified
+ value in a singleton collection if the sequence is empty.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence from an array of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of the specified sequence or the specified
+ value in a singleton collection if the sequence is empty.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence from an array of values.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by FallbackIfEmptyExtension) |
| FillBackwardT |
+ Returns a sequence with each null reference or value in the source
+ replaced with the following non-null reference or value in
+ that sequence.
+ (Defined by MoreEnumerable) |
| FillBackwardT |
+ Returns a sequence with each null reference or value in the source
+ replaced with the following non-null reference or value in
+ that sequence.
+ (Defined by FillBackwardExtension) |
| FillBackwardT |
+ 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.
+ (Defined by MoreEnumerable) |
| FillBackwardT |
+ 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.
+ (Defined by FillBackwardExtension) |
| FillBackwardT |
+ Returns a sequence with each missing element in the source replaced
+ with the following non-missing element in that sequence. Additional
+ parameters specify two functions, one used to determine if an
+ element is considered missing or not and another to provide the
+ replacement for the missing element.
+ (Defined by MoreEnumerable) |
| FillBackwardT |
+ Returns a sequence with each missing element in the source replaced
+ with the following non-missing element in that sequence. Additional
+ parameters specify two functions, one used to determine if an
+ element is considered missing or not and another to provide the
+ replacement for the missing element.
+ (Defined by FillBackwardExtension) |
| FillForwardT |
+ 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.
+ (Defined by MoreEnumerable) |
| FillForwardT |
+ 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.
+ (Defined by FillForwardExtension) |
| FillForwardT |
+ 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.
+ (Defined by MoreEnumerable) |
| FillForwardT |
+ 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.
+ (Defined by FillForwardExtension) |
| FillForwardT |
+ 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 specify two functions, one used to
+ determine if an element is considered missing or not and another
+ to provide the replacement for the missing element.
+ (Defined by MoreEnumerable) |
| FillForwardT |
+ 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 specify two functions, one used to
+ determine if an element is considered missing or not and another
+ to provide the replacement for the missing element.
+ (Defined by FillForwardExtension) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences.
+ (Defined by MoreEnumerable) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences.
+ (Defined by FlattenExtension) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a predicate function used to
+ determine whether a nested IEnumerable should be
+ flattened or not.
+ (Defined by MoreEnumerable) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a function that projects an inner
+ sequence via a property of an object.
+ (Defined by MoreEnumerable) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a predicate function used to
+ determine whether a nested IEnumerable should be
+ flattened or not.
+ (Defined by FlattenExtension) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a function that projects an inner
+ sequence via a property of an object.
+ (Defined by FlattenExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 9 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 9 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 10 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 10 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 11 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 11 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 12 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 12 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 13 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 13 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 14 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 14 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 15 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 15 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 16 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 16 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 1 element.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 1 element.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 2 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 2 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 3 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 3 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 4 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 4 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 5 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 5 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 6 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 6 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 7 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 7 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 8 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 8 elements.
+ (Defined by FoldExtension) |
| ForEachT |
+ Immediately executes the given action on each element in the source sequence.
+ (Defined by MoreEnumerable) |
| ForEachT |
+ Immediately executes the given action on each element in the source sequence.
+ (Defined by ForEachExtension) |
| ForEachT |
+ Immediately executes the given action on each element in the source sequence.
+ Each element's index is used in the logic of the action.
+ (Defined by MoreEnumerable) |
| ForEachT |
+ Immediately executes the given action on each element in the source sequence.
+ Each element's index is used in the logic of the action.
+ (Defined by ForEachExtension) |
| FullGroupJoinT, TSecond, TKey |
+ Performs a Full Group Join between the first and second sequences.
+ (Defined by MoreEnumerable) |
| FullGroupJoinT, TSecond, TKey |
+ Performs a Full Group Join between the first and second sequences.
+ (Defined by FullGroupJoinExtension) |
| FullGroupJoinT, TSecond, TKey |
+ Performs a Full Group Join between the first and second sequences.
+ (Defined by MoreEnumerable) |
| FullGroupJoinT, TSecond, TKey |
+ Performs a Full Group Join between the first and second sequences.
+ (Defined by FullGroupJoinExtension) |
| FullGroupJoinT, TSecond, TKey, TResult |
+ Performs a full group-join between two sequences.
+ (Defined by MoreEnumerable) |
| FullGroupJoinT, TSecond, TKey, TResult |
+ Performs a full group-join between two sequences.
+ (Defined by FullGroupJoinExtension) |
| FullGroupJoinT, TSecond, TKey, TResult |
+ Performs a full group-join between two sequences.
+ (Defined by MoreEnumerable) |
| FullGroupJoinT, TSecond, TKey, TResult |
+ Performs a full group-join between two sequences.
+ (Defined by FullGroupJoinExtension) |
| FullJoinT, TKey, TResult |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| FullJoinT, TKey, TResult |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by FullJoinExtension) |
| FullJoinT, TKey, TResult |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| FullJoinT, TKey, TResult |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by FullJoinExtension) |
| FullJoinT, TSecond, TKey, TResult |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| FullJoinT, TSecond, TKey, TResult |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by FullJoinExtension) |
| FullJoinT, TSecond, TKey, TResult |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| FullJoinT, TSecond, TKey, TResult |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by FullJoinExtension) |
| GroupAdjacentT, TKey |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and compares the keys by using a
+ specified comparer.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and compares the keys by using a
+ specified comparer.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey, TElement |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and projects the elements for
+ each group by using a specified function.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey, TResult |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey, TElement |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and projects the elements for
+ each group by using a specified function.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey, TResult |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey, TElement |
+ 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.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey, TResult |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey, TElement |
+ 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.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey, TResult |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ (Defined by GroupAdjacentExtension) |
| IndexT |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the zero-based index of the value in the source
+ sequence.
+ (Defined by MoreEnumerable) |
| IndexT |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the zero-based index of the value in the source
+ sequence.
+ (Defined by IndexExtension) |
| IndexT |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the index of the value in the source sequence.
+ An additional parameter specifies the starting index.
+ (Defined by MoreEnumerable) |
| IndexT |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the index of the value in the source sequence.
+ An additional parameter specifies the starting index.
+ (Defined by IndexExtension) |
| IndexByT, TKey |
+ 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.
+ (Defined by MoreEnumerable) |
| IndexByT, TKey |
+ 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.
+ (Defined by IndexByExtension) |
| IndexByT, TKey |
+ 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.
+ (Defined by MoreEnumerable) |
| IndexByT, TKey |
+ 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.
+ (Defined by IndexByExtension) |
| InsertT |
+ Inserts the elements of a sequence into another sequence at a
+ specified index.
+ (Defined by MoreEnumerable) |
| InsertT |
+ Inserts the elements of a sequence into another sequence at a
+ specified index.
+ (Defined by InsertExtension) |
| InterleaveT |
+ Interleaves the elements of two or more sequences into a single sequence, skipping
+ sequences as they are consumed.
+ (Defined by MoreEnumerable) |
| InterleaveT |
+ Interleaves the elements of two or more sequences into a single sequence, skipping
+ sequences as they are consumed.
+ (Defined by InterleaveExtension) |
| LagT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ negative offset.
+ (Defined by MoreEnumerable) |
| LagT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ negative offset.
+ (Defined by LagExtension) |
| LagT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ negative offset.
+ (Defined by MoreEnumerable) |
| LagT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ negative offset.
+ (Defined by LagExtension) |
| LeadT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ positive offset.
+ (Defined by MoreEnumerable) |
| LeadT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ positive offset.
+ (Defined by LeadExtension) |
| LeadT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ positive offset.
+ (Defined by MoreEnumerable) |
| LeadT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ positive offset.
+ (Defined by LeadExtension) |
| LeftJoinT, TKey, TResult |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| LeftJoinT, TKey, TResult |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by LeftJoinExtension) |
| LeftJoinT, TKey, TResult |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| LeftJoinT, TKey, TResult |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by LeftJoinExtension) |
| LeftJoinT, TSecond, TKey, TResult |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| LeftJoinT, TSecond, TKey, TResult |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by LeftJoinExtension) |
| LeftJoinT, TSecond, TKey, TResult |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| LeftJoinT, TSecond, TKey, TResult |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by LeftJoinExtension) |
| MaxByT, TKey |
+ Returns the maximal elements of the given sequence, based on
+ the given projection.
+ (Defined by MoreEnumerable) |
| MaxByT, TKey |
+ Returns the maximal elements of the given sequence, based on
+ the given projection.
+ (Defined by MaxByExtension) |
| MaxByT, TKey |
+ Returns the maximal elements of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ (Defined by MoreEnumerable) |
| MaxByT, TKey |
+ Returns the maximal elements of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ (Defined by MaxByExtension) |
| MaxConcurrencyT |
+ Returns a query whose results evaluate asynchronously to use a
+ concurrency limit.
+ (Defined by ExperimentalEnumerable) |
| MemoizeT |
+ 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.
+ (Defined by ExperimentalEnumerable) |
| MinByT, TKey |
+ Returns the minimal elements of the given sequence, based on
+ the given projection.
+ (Defined by MoreEnumerable) |
| MinByT, TKey |
+ Returns the minimal elements of the given sequence, based on
+ the given projection.
+ (Defined by MinByExtension) |
| MinByT, TKey |
+ Returns the minimal elements of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ (Defined by MoreEnumerable) |
| MinByT, TKey |
+ Returns the minimal elements of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ (Defined by MinByExtension) |
| MoveT |
+ Returns a sequence with a range of elements in the source sequence
+ moved to a new offset.
+ (Defined by MoreEnumerable) |
| MoveT |
+ Returns a sequence with a range of elements in the source sequence
+ moved to a new offset.
+ (Defined by MoveExtension) |
| OrderByT, TKey |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ (Defined by MoreEnumerable) |
| OrderByT, TKey |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ (Defined by OrderByExtension) |
| OrderByT, TKey |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ (Defined by MoreEnumerable) |
| OrderByT, TKey |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ (Defined by OrderByExtension) |
| OrderedMergeT |
+ 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.
+ (Defined by MoreEnumerable) |
| OrderedMergeT |
+ 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.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT |
+ 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.
+ (Defined by MoreEnumerable) |
| OrderedMergeT |
+ 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.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TKey |
+ Merges two ordered sequences into one with an additional
+ parameter specifying the element key by which the sequences are
+ ordered. Where the keys equal in both sequences, the
+ element from the first sequence is returned in the resulting
+ sequence.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TKey |
+ Merges two ordered sequences into one with an additional
+ parameter specifying the element key by which the sequences are
+ ordered. Where the keys equal in both sequences, the
+ element from the first sequence is returned in the resulting
+ sequence.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TKey, TResult |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first and the result when elements are found in
+ both sequences.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TKey, TResult |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first and the result when elements are found in
+ both sequences.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TKey, TResult |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first, the result when elements are found in
+ both sequences and a method for comparing keys.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TKey, TResult |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first, the result when elements are found in
+ both sequences and a method for comparing keys.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TSecond, TKey, TResult |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second and
+ the result when element is found in second sequence but not in
+ the first, the result when elements are found in both sequences.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TSecond, TKey, TResult |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second and
+ the result when element is found in second sequence but not in
+ the first, the result when elements are found in both sequences.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TSecond, TKey, TResult |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second,
+ 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.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TSecond, TKey, TResult |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second,
+ 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.
+ (Defined by OrderedMergeExtension) |
| PadT |
+ Pads a sequence with default values if it is narrower (shorter
+ in length) than a given width.
+ (Defined by MoreEnumerable) |
| PadT |
+ Pads a sequence with default values if it is narrower (shorter
+ in length) than a given width.
+ (Defined by PadExtension) |
| PadT |
+ Pads a sequence with a given filler value if it is narrower (shorter
+ in length) than a given width.
+ (Defined by MoreEnumerable) |
| PadT |
+ Pads a sequence with a dynamic filler value if it is narrower (shorter
+ in length) than a given width.
+ (Defined by MoreEnumerable) |
| PadT |
+ Pads a sequence with a given filler value if it is narrower (shorter
+ in length) than a given width.
+ (Defined by PadExtension) |
| PadT |
+ Pads a sequence with a dynamic filler value if it is narrower (shorter
+ in length) than a given width.
+ (Defined by PadExtension) |
| PadStartT |
+ Pads a sequence with default values in the beginning if it is narrower (shorter
+ in length) than a given width.
+ (Defined by MoreEnumerable) |
| PadStartT |
+ Pads a sequence with default values in the beginning if it is narrower (shorter
+ in length) than a given width.
+ (Defined by PadStartExtension) |
| PadStartT |
+ 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.
+ (Defined by MoreEnumerable) |
| PadStartT |
+ 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.
+ (Defined by MoreEnumerable) |
| PadStartT |
+ 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.
+ (Defined by PadStartExtension) |
| PadStartT |
+ 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.
+ (Defined by PadStartExtension) |
| PairwiseT, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence and its
+ predecessor, with the exception of the first element which is
+ only returned as the predecessor of the second element.
+ (Defined by MoreEnumerable) |
| PairwiseT, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence and its
+ predecessor, with the exception of the first element which is
+ only returned as the predecessor of the second element.
+ (Defined by PairwiseExtension) |
| PartialSortT |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ (Defined by MoreEnumerable) |
| PartialSortT |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ (Defined by PartialSortExtension) |
| PartialSortT |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ An additional parameter specifies the direction of the sort
+ (Defined by MoreEnumerable) |
| PartialSortT |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation. An additional parameter specifies how the
+ elements compare to each other.
+ (Defined by MoreEnumerable) |
| PartialSortT |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ An additional parameter specifies the direction of the sort
+ (Defined by PartialSortExtension) |
| PartialSortT |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation. An additional parameter specifies how the
+ elements compare to each other.
+ (Defined by PartialSortExtension) |
| PartialSortT |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ (Defined by MoreEnumerable) |
| PartialSortT |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ (Defined by PartialSortExtension) |
| PartialSortByT, TKey |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ (Defined by MoreEnumerable) |
| PartialSortByT, TKey |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ (Defined by PartialSortByExtension) |
| PartialSortByT, TKey |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies the direction of the sort
+ (Defined by MoreEnumerable) |
| PartialSortByT, TKey |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies how the keys compare to each other.
+ (Defined by MoreEnumerable) |
| PartialSortByT, TKey |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies the direction of the sort
+ (Defined by PartialSortByExtension) |
| PartialSortByT, TKey |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies how the keys compare to each other.
+ (Defined by PartialSortByExtension) |
| PartialSortByT, TKey |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ (Defined by MoreEnumerable) |
| PartialSortByT, TKey |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ (Defined by PartialSortByExtension) |
| PartitionT |
+ Partitions or splits a sequence in two using a predicate.
+ (Defined by MoreEnumerable) |
| PartitionT |
+ Partitions or splits a sequence in two using a predicate.
+ (Defined by PartitionExtension) |
| PartitionT, TResult |
+ Partitions or splits a sequence in two using a predicate and then
+ projects a result from the two.
+ (Defined by MoreEnumerable) |
| PartitionT, TResult |
+ Partitions or splits a sequence in two using a predicate and then
+ projects a result from the two.
+ (Defined by PartitionExtension) |
| PermutationsT |
+ Generates a sequence of lists that represent the permutations of the original sequence.
+ (Defined by MoreEnumerable) |
| PermutationsT |
+ Generates a sequence of lists that represent the permutations of the original sequence.
+ (Defined by PermutationsExtension) |
| PipeT |
+ Executes the given action on each element in the source sequence
+ and yields it.
+ (Defined by MoreEnumerable) |
| PipeT |
+ Executes the given action on each element in the source sequence
+ and yields it.
+ (Defined by PipeExtension) |
| PrependT |
+ Prepends a single value to a sequence.
+ (Defined by MoreEnumerable) |
| PrependT |
+ Prepends a single value to a sequence.
+ (Defined by PrependExtension) |
| PreScanT |
+ Performs a pre-scan (exclusive prefix sum) on a sequence of elements.
+ (Defined by MoreEnumerable) |
| PreScanT |
+ Performs a pre-scan (exclusive prefix sum) on a sequence of elements.
+ (Defined by PreScanExtension) |
| PreserveOrderT |
+ Returns a query whose results evaluate asynchronously and a Boolean
+ argument indicating whether the source order of the results is
+ preserved.
+ (Defined by ExperimentalEnumerable) |
| RandomSubsetT |
+ Returns a sequence of a specified size of random elements from the
+ original sequence.
+ (Defined by MoreEnumerable) |
| RandomSubsetT |
+ Returns a sequence of a specified size of random elements from the
+ original sequence.
+ (Defined by RandomSubsetExtension) |
| RandomSubsetT |
+ 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.
+ (Defined by MoreEnumerable) |
| RandomSubsetT |
+ 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.
+ (Defined by RandomSubsetExtension) |
| RankT |
+ Ranks each item in the sequence in descending ordering using a default comparer.
+ (Defined by MoreEnumerable) |
| RankT |
+ Ranks each item in the sequence in descending ordering using a default comparer.
+ (Defined by RankExtension) |
| RankT |
+ Rank each item in the sequence using a caller-supplied comparer.
+ (Defined by MoreEnumerable) |
| RankT |
+ Rank each item in the sequence using a caller-supplied comparer.
+ (Defined by RankExtension) |
| RankByT, TKey |
+ Ranks each item in the sequence in descending ordering by a specified key using a default comparer
+ (Defined by MoreEnumerable) |
| RankByT, TKey |
+ Ranks each item in the sequence in descending ordering by a specified key using a default comparer
+ (Defined by RankByExtension) |
| RankByT, TKey |
+ Ranks each item in a sequence using a specified key and a caller-supplied comparer
+ (Defined by MoreEnumerable) |
| RankByT, TKey |
+ Ranks each item in a sequence using a specified key and a caller-supplied comparer
+ (Defined by RankByExtension) |
| RepeatT |
+ Repeats the sequence forever.
+ (Defined by MoreEnumerable) |
| RepeatT |
+ Repeats the sequence forever.
+ (Defined by RepeatExtension) |
| RepeatT |
+ Repeats the sequence the specified number of times.
+ (Defined by MoreEnumerable) |
| RepeatT |
+ Repeats the sequence the specified number of times.
+ (Defined by RepeatExtension) |
| RightJoinT, TKey, TResult |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| RightJoinT, TKey, TResult |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by RightJoinExtension) |
| RightJoinT, TKey, TResult |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| RightJoinT, TKey, TResult |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by RightJoinExtension) |
| RightJoinT, TSecond, TKey, TResult |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| RightJoinT, TSecond, TKey, TResult |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by RightJoinExtension) |
| RightJoinT, TSecond, TKey, TResult |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| RightJoinT, TSecond, TKey, TResult |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by RightJoinExtension) |
| RunLengthEncodeT |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count.
+ (Defined by MoreEnumerable) |
| RunLengthEncodeT |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count.
+ (Defined by RunLengthEncodeExtension) |
| RunLengthEncodeT |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count. This overload
+ uses a custom equality comparer to identify equivalent items.
+ (Defined by MoreEnumerable) |
| RunLengthEncodeT |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count. This overload
+ uses a custom equality comparer to identify equivalent items.
+ (Defined by RunLengthEncodeExtension) |
| ScanT |
+ Performs a scan (inclusive prefix sum) on a sequence of elements.
+ (Defined by MoreEnumerable) |
| ScanT |
+ Performs a scan (inclusive prefix sum) on a sequence of elements.
+ (Defined by ScanExtension) |
| ScanT, TState |
+ Like AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) except returns
+ the sequence of intermediate results as well as the final one.
+ An additional parameter specifies a seed.
+ (Defined by MoreEnumerable) |
| ScanT, TState |
+ Like AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) except returns
+ the sequence of intermediate results as well as the final one.
+ An additional parameter specifies a seed.
+ (Defined by ScanExtension) |
| ScanByT, TKey, TState |
+ Applies an accumulator function over sequence element keys,
+ returning the keys along with intermediate accumulator states.
+ (Defined by MoreEnumerable) |
| ScanByT, TKey, TState |
+ Applies an accumulator function over sequence element keys,
+ returning the keys along with intermediate accumulator states.
+ (Defined by ScanByExtension) |
| ScanByT, TKey, TState |
+ 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.
+ (Defined by MoreEnumerable) |
| ScanByT, TKey, TState |
+ 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.
+ (Defined by ScanByExtension) |
| ScanRightT |
+ Performs a right-associative scan (inclusive prefix) on a sequence of elements.
+ This operator is the right-associative version of the
+ ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ (Defined by MoreEnumerable) |
| ScanRightT |
+ Performs a right-associative scan (inclusive prefix) on a sequence of elements.
+ This operator is the right-associative version of the
+ ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ (Defined by ScanRightExtension) |
| ScanRightT, TAccumulate |
+ Performs a right-associative scan (inclusive prefix) on a sequence of elements.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) LINQ operator.
+ (Defined by MoreEnumerable) |
| ScanRightT, TAccumulate |
+ Performs a right-associative scan (inclusive prefix) on a sequence of elements.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) LINQ operator.
+ (Defined by ScanRightExtension) |
| SchedulerT |
+ Returns a query whose results evaluate asynchronously and uses the
+ given scheduler for the workhorse task.
+ (Defined by ExperimentalEnumerable) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by MoreEnumerable) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by SegmentExtension) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by MoreEnumerable) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by SegmentExtension) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by MoreEnumerable) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by SegmentExtension) |
| ShuffleT |
+ Returns a sequence of elements in random order from the original
+ sequence.
+ (Defined by MoreEnumerable) |
| ShuffleT |
+ Returns a sequence of elements in random order from the original
+ sequence.
+ (Defined by ShuffleExtension) |
| ShuffleT |
+ 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.
+ (Defined by MoreEnumerable) |
| ShuffleT |
+ 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.
+ (Defined by ShuffleExtension) |
| SkipLastT |
+ Bypasses a specified number of elements at the end of the sequence.
+ (Defined by MoreEnumerable) |
| SkipLastT |
+ Bypasses a specified number of elements at the end of the sequence.
+ (Defined by SkipLastExtension) |
| SkipUntilT |
+ 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.
+ (Defined by MoreEnumerable) |
| SkipUntilT |
+ 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.
+ (Defined by SkipUntilExtension) |
| SliceT |
+ Extracts a contiguous count of elements from a sequence at a particular zero-based
+ starting index.
+ (Defined by MoreEnumerable) |
| SliceT |
+ Extracts a contiguous count of elements from a sequence at a particular zero-based
+ starting index.
+ (Defined by SliceExtension) |
| SortedMergeT |
+ Merges two or more sequences that are in a common order (either ascending or descending)
+ into a single sequence that preserves that order.
+ (Defined by MoreEnumerable) |
| SortedMergeT |
+ Merges two or more sequences that are in a common order (either ascending or descending)
+ into a single sequence that preserves that order.
+ (Defined by SortedMergeExtension) |
| SortedMergeT |
+ Merges two or more sequences that are in a common order (either ascending or descending)
+ into a single sequence that preserves that order.
+ (Defined by MoreEnumerable) |
| SortedMergeT |
+ Merges two or more sequences that are in a common order (either ascending or descending)
+ into a single sequence that preserves that order.
+ (Defined by SortedMergeExtension) |
| SplitT |
+ Splits the source sequence by separator elements identified by a
+ function.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by separator elements identified by a
+ function.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by a separator.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by a separator.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by separator elements identified by a
+ function, given a maximum count of splits.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by separator elements identified by a
+ function, given a maximum count of splits.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by a separator given a maximum count of splits.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by a separator and then transforms the
+ splits into results.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by a separator given a maximum count of splits.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by a separator and then transforms the
+ splits into results.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by a separator, given a maximum count
+ of splits. A parameter specifies how the separator is compared
+ for equality.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by a separator, given a maximum count
+ of splits. A parameter specifies how the separator is compared
+ for equality.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by separator elements identified by
+ a function and then transforms the splits into results.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by separator elements identified by
+ a function and then transforms the splits into results.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by a separator and then transforms
+ the splits into results.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by a separator and then transforms
+ the splits into results.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by separator elements identified by
+ a function, given a maximum count of splits, and then transforms
+ the splits into results.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by separator elements identified by
+ a function, given a maximum count of splits, and then transforms
+ the splits into results.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by a separator and then transforms the
+ splits into results. A parameter specifies how the separator is
+ compared for equality.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by a separator and then transforms the
+ splits into results. A parameter specifies how the separator is
+ compared for equality.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results. A
+ parameter specifies how the separator is compared for equality.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results. A
+ parameter specifies how the separator is compared for equality.
+ (Defined by SplitExtension) |
| StartsWithT |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the default equality
+ comparer.
+ (Defined by MoreEnumerable) |
| StartsWithT |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the default equality
+ comparer.
+ (Defined by StartsWithExtension) |
| StartsWithT |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the specified element
+ equality comparer.
+ (Defined by MoreEnumerable) |
| StartsWithT |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the specified element
+ equality comparer.
+ (Defined by StartsWithExtension) |
| SubsetsT |
+ Returns a sequence of IListT representing all of the subsets of any size
+ that are part of the original sequence. In mathematics, it is equivalent to the
+ power set of a set.
+ (Defined by MoreEnumerable) |
| SubsetsT |
+ Returns a sequence of IListT representing all of the subsets of any size
+ that are part of the original sequence. In mathematics, it is equivalent to the
+ power set of a set.
+ (Defined by SubsetsExtension) |
| SubsetsT |
+ Returns a sequence of IListT representing all subsets of a given size
+ that are part of the original sequence. In mathematics, it is equivalent to the
+ combinations or k-subsets of a set.
+ (Defined by MoreEnumerable) |
| SubsetsT |
+ Returns a sequence of IListT representing all subsets of a given size
+ that are part of the original sequence. In mathematics, it is equivalent to the
+ combinations or k-subsets of a set.
+ (Defined by SubsetsExtension) |
| TagFirstLastT, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence with additional parameters
+ indicating whether the element is the first and/or last of the
+ sequence.
+ (Defined by MoreEnumerable) |
| TagFirstLastT, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence with additional parameters
+ indicating whether the element is the first and/or last of the
+ sequence.
+ (Defined by TagFirstLastExtension) |
| TakeEveryT |
+ Returns every N-th element of a sequence.
+ (Defined by MoreEnumerable) |
| TakeEveryT |
+ Returns every N-th element of a sequence.
+ (Defined by TakeEveryExtension) |
| TakeLastT |
+ Returns a specified number of contiguous elements from the end of
+ a sequence.
+ (Defined by MoreEnumerable) |
| TakeLastT |
+ Returns a specified number of contiguous elements from the end of
+ a sequence.
+ (Defined by TakeLastExtension) |
| TakeUntilT |
+ 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.
+ (Defined by MoreEnumerable) |
| TakeUntilT |
+ 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.
+ (Defined by TakeUntilExtension) |
| ToArrayByIndexT |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT, TResult |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT, TResult |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT, TResult |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT, TResult |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT, TResult |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT, TResult |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT, TResult |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT, TResult |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ (Defined by ToArrayByIndexExtension) |
| ToDataTableT |
+ Converts a sequence to a DataTable object.
+ (Defined by MoreEnumerable) |
| ToDataTableT |
+ Converts a sequence to a DataTable object.
+ (Defined by ToDataTableExtension) |
| ToDataTableT |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ (Defined by MoreEnumerable) |
| ToDataTableT |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ (Defined by ToDataTableExtension) |
| ToDataTableT, TTable |
+ Appends elements in the sequence as rows of a given DataTable object.
+ (Defined by MoreEnumerable) |
| ToDataTableT, TTable |
+ Appends elements in the sequence as rows of a given DataTable object.
+ (Defined by ToDataTableExtension) |
| ToDataTableT, TTable |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ (Defined by MoreEnumerable) |
| ToDataTableT, TTable |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ (Defined by ToDataTableExtension) |
| ToDelimitedStringT |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ (Defined by MoreEnumerable) |
| ToDelimitedStringT |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ (Defined by ToDelimitedStringExtension) |
| ToHashSetT |
+ Returns a HashSetT of the source items using the default equality
+ comparer for the type.
+ (Defined by MoreEnumerable) |
| ToHashSetT |
+ Returns a HashSetT of the source items using the default equality
+ comparer for the type.
+ (Defined by ToHashSetExtension) |
| ToHashSetT |
+ Returns a HashSetT of the source items using the specified equality
+ comparer for the type.
+ (Defined by MoreEnumerable) |
| ToHashSetT |
+ Returns a HashSetT of the source items using the specified equality
+ comparer for the type.
+ (Defined by ToHashSetExtension) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics.
+ (Defined by MoreEnumerable) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics.
+ (Defined by TraceExtension) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics using
+ a custom formatter.
+ (Defined by MoreEnumerable) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics using
+ a custom formatter.
+ (Defined by TraceExtension) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics using
+ custom formatting.
+ (Defined by MoreEnumerable) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics using
+ custom formatting.
+ (Defined by TraceExtension) |
| TrySingleT, TCardinality |
+ Returns a tuple with the cardinality of the sequence and the
+ single element in the sequence if it contains exactly one element.
+ similar to SingleTSource(IEnumerableTSource).
+ (Defined by ExperimentalEnumerable) |
| TrySingleT, TCardinality, TResult |
+ Returns a result projected from the the cardinality of the sequence
+ and the single element in the sequence if it contains exactly one
+ element.
+ (Defined by ExperimentalEnumerable) |
| UnboundedConcurrencyT |
+ Returns a query whose results evaluate asynchronously and
+ concurrently with no defined limitation on concurrency.
+ (Defined by ExperimentalEnumerable) |
| WindowT |
+ Processes a sequence into a series of sub-sequences representing a windowed subset of
+ the original.
+ (Defined by MoreEnumerable) |
| WindowT |
+ Processes a sequence into a series of sub-sequences representing a windowed subset of
+ the original.
+ (Defined by WindowExtension) |
| WindowedT |
+ Processes a sequence into a series of sub-sequences representing a windowed subset of the original.
+ (Defined by MoreEnumerable) |
| WindowLeftT |
+ Creates a left-aligned sliding window of a given size over the
+ source sequence.
+ (Defined by MoreEnumerable) |
| WindowLeftT |
+ Creates a left-aligned sliding window of a given size over the
+ source sequence.
+ (Defined by WindowLeftExtension) |
| WindowRightT |
+ Creates a right-aligned sliding window over the source sequence
+ of a given size.
+ (Defined by MoreEnumerable) |
| WindowRightT |
+ Creates a right-aligned sliding window over the source sequence
+ of a given size.
+ (Defined by WindowRightExtension) |
| ZipLongestT, TSecond, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipLongestT, TSecond, TResult |
+ 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.
+ (Defined by ZipLongestExtension) |
| ZipLongestT, T2, T3, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipLongestT, T2, T3, TResult |
+ 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.
+ (Defined by ZipLongestExtension) |
| ZipLongestT, T2, T3, T4, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipLongestT, T2, T3, T4, TResult |
+ 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.
+ (Defined by ZipLongestExtension) |
| ZipShortestT, TSecond, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipShortestT, TSecond, TResult |
+ 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.
+ (Defined by ZipShortestExtension) |
| ZipShortestT, T2, T3, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipShortestT, T2, T3, TResult |
+ 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.
+ (Defined by ZipShortestExtension) |
| ZipShortestT, T2, T3, T4, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipShortestT, T2, T3, T4, TResult |
+ 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.
+ (Defined by ZipShortestExtension) |
| Add | Adds an item to the ICollectionT. (Inherited from ICollectionT) |
| Clear | Removes all items from the ICollectionT. (Inherited from ICollectionT) |
| Contains | Determines whether the ICollectionT contains a specific value. (Inherited from ICollectionT) |
| CopyTo | Copies the elements of the ICollectionT to an Array, starting at a particular Array index. (Inherited from ICollectionT) |
| GetEnumerator | Returns an enumerator that iterates through the collection. (Inherited from IEnumerableT) |
| IndexOf | Determines the index of a specific item in the IListT. (Inherited from IListT) |
| Insert | Inserts an item to the IListT at the specified index. (Inherited from IListT) |
| Remove | Removes the first occurrence of a specific object from the ICollectionT. (Inherited from ICollectionT) |
| RemoveAt | Removes the IListT item at the specified index. (Inherited from IListT) |
| AggregateT, TResult1, TResult2, TResult |
+ Applies two accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TResult |
+ Applies two accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TResult |
+ Applies two accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult |
+ Applies three accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TResult |
+ Applies three accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TResult |
+ Applies three accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult |
+ Applies four accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult |
+ Applies four accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult |
+ Applies four accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult |
+ Applies five accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult |
+ Applies five accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult |
+ Applies five accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult |
+ Applies six accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult |
+ Applies six accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult |
+ Applies six accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult |
+ Applies seven accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult |
+ Applies seven accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult |
+ Applies seven accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult8, TResult |
+ Applies eight accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult |
+ Applies eight accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult |
+ Applies eight accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateRightT |
+ Applies a right-associative accumulator function over a sequence.
+ This operator is the right-associative version of the
+ AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ (Defined by MoreEnumerable) |
| AggregateRightT |
+ Applies a right-associative accumulator function over a sequence.
+ This operator is the right-associative version of the
+ AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ (Defined by AggregateRightExtension) |
| AggregateRightT, TAccumulate |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate) LINQ operator.
+ (Defined by MoreEnumerable) |
| AggregateRightT, TAccumulate |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate) LINQ operator.
+ (Defined by AggregateRightExtension) |
| AggregateRightT, TAccumulate, TResult |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value,
+ and the specified function is used to select the result value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate, FuncTAccumulate, TResult) LINQ operator.
+ (Defined by MoreEnumerable) |
| AggregateRightT, TAccumulate, TResult |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value,
+ and the specified function is used to select the result value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate, FuncTAccumulate, TResult) LINQ operator.
+ (Defined by AggregateRightExtension) |
| AppendT |
+ Returns a sequence consisting of the head elements and the given tail element.
+ (Defined by MoreEnumerable) |
| AppendT |
+ Returns a sequence consisting of the head elements and the given tail element.
+ (Defined by AppendExtension) |
| AssertT |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ (Defined by MoreEnumerable) |
| AssertT |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ (Defined by AssertExtension) |
| AssertT |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ (Defined by MoreEnumerable) |
| AssertT |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ (Defined by AssertExtension) |
| AssertCountT |
+ Asserts that a source sequence contains a given count of elements.
+ (Defined by MoreEnumerable) |
| AssertCountT |
+ Asserts that a source sequence contains a given count of elements.
+ (Defined by AssertCountExtension) |
| AssertCountT |
+ Asserts that a source sequence contains a given count of elements.
+ A parameter specifies the exception to be thrown.
+ (Defined by MoreEnumerable) |
| AssertCountT |
+ Asserts that a source sequence contains a given count of elements.
+ A parameter specifies the exception to be thrown.
+ (Defined by AssertCountExtension) |
| AtLeastT |
+ Determines whether or not the number of elements in the sequence is greater than
+ or equal to the given integer.
+ (Defined by MoreEnumerable) |
| AtLeastT |
+ Determines whether or not the number of elements in the sequence is greater than
+ or equal to the given integer.
+ (Defined by AtLeastExtension) |
| AtMostT |
+ Determines whether or not the number of elements in the sequence is lesser than
+ or equal to the given integer.
+ (Defined by MoreEnumerable) |
| AtMostT |
+ Determines whether or not the number of elements in the sequence is lesser than
+ or equal to the given integer.
+ (Defined by AtMostExtension) |
| AwaitT, TResult |
+ Creates a sequence query that streams the result of each task in
+ the source sequence as it completes asynchronously. A
+ CancellationToken is passed for each asynchronous
+ evaluation to abort any asynchronous operations in flight if the
+ sequence is not fully iterated.
+ (Defined by ExperimentalEnumerable) |
| AwaitCompletionT, TTaskResult, TResult |
+ 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.
+ (Defined by ExperimentalEnumerable) |
| BacksertT |
+ 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.
+ (Defined by MoreEnumerable) |
| BacksertT |
+ 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.
+ (Defined by BacksertExtension) |
| BatchT |
+ Batches the source sequence into sized buckets.
+ (Defined by MoreEnumerable) |
| BatchT |
+ Batches the source sequence into sized buckets.
+ (Defined by BatchExtension) |
| BatchT, TResult |
+ Batches the source sequence into sized buckets and applies a projection to each bucket.
+ (Defined by MoreEnumerable) |
| BatchT, TResult |
+ Batches the source sequence into sized buckets and applies a projection to each bucket.
+ (Defined by BatchExtension) |
| BatchT, TResult |
+ Batches the source sequence into sized buckets using an array pool
+ to rent arrays to back each bucket and returns a sequence of
+ elements projected from each bucket.
+ (Defined by ExperimentalEnumerable) |
| BatchT, TBucket, TResult |
+ Batches the source sequence into sized buckets using an array pool
+ to rent arrays to back each bucket and returns a sequence of
+ elements projected from each bucket.
+ (Defined by ExperimentalEnumerable) |
| CartesianT, T2, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, T5, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, T5, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, T5, T6, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, T5, T6, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, T5, T6, T7, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, T5, T6, T7, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, T5, T6, T7, T8, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, T5, T6, T7, T8, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| ChooseT, TResult |
+ 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 true
+ as its first element and result as the second.
+ (Defined by MoreEnumerable) |
| ChooseT, TResult |
+ 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 true
+ as its first element and result as the second.
+ (Defined by ChooseExtension) |
| CompareCountT, TSecond |
+ Compares two sequences and returns an integer that indicates whether the first sequence
+ has fewer, the same or more elements than the second sequence.
+ (Defined by MoreEnumerable) |
| CompareCountT, TSecond |
+ Compares two sequences and returns an integer that indicates whether the first sequence
+ has fewer, the same or more elements than the second sequence.
+ (Defined by CompareCountExtension) |
| ConcatT |
+ Returns a sequence consisting of the head elements and the given tail element.
+ (Defined by MoreEnumerable) |
| ConsumeT |
+ Completely consumes the given sequence. This method uses immediate execution,
+ and doesn't store any data during execution.
+ (Defined by MoreEnumerable) |
| ConsumeT |
+ Completely consumes the given sequence. This method uses immediate execution,
+ and doesn't store any data during execution.
+ (Defined by ConsumeExtension) |
| CountBetweenT |
+ Determines whether or not the number of elements in the sequence is between
+ an inclusive range of minimum and maximum integers.
+ (Defined by MoreEnumerable) |
| CountBetweenT |
+ Determines whether or not the number of elements in the sequence is between
+ an inclusive range of minimum and maximum integers.
+ (Defined by CountBetweenExtension) |
| CountByT, TKey |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ (Defined by MoreEnumerable) |
| CountByT, TKey |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ (Defined by CountByExtension) |
| CountByT, TKey |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ An additional argument specifies a comparer to use for testing equivalence of keys.
+ (Defined by MoreEnumerable) |
| CountByT, TKey |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ An additional argument specifies a comparer to use for testing equivalence of keys.
+ (Defined by CountByExtension) |
| CountDownT, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CountDownT, TResult |
+ 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.
+ (Defined by CountDownExtension) |
| DistinctByT, TKey |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the default equality comparer for the projected type.
+ (Defined by MoreEnumerable) |
| DistinctByT, TKey |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the default equality comparer for the projected type.
+ (Defined by DistinctByExtension) |
| DistinctByT, TKey |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the specified comparer for the projected type.
+ (Defined by MoreEnumerable) |
| DistinctByT, TKey |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the specified comparer for the projected type.
+ (Defined by DistinctByExtension) |
| EndsWithT |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the default equality comparer.
+ (Defined by MoreEnumerable) |
| EndsWithT |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the default equality comparer.
+ (Defined by EndsWithExtension) |
| EndsWithT |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the specified element equality comparer.
+ (Defined by MoreEnumerable) |
| EndsWithT |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the specified element equality comparer.
+ (Defined by EndsWithExtension) |
| EquiZipT, TSecond, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| EquiZipT, TSecond, TResult |
+ 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.
+ (Defined by EquiZipExtension) |
| EquiZipT, T2, T3, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| EquiZipT, T2, T3, TResult |
+ 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.
+ (Defined by EquiZipExtension) |
| EquiZipT, T2, T3, T4, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| EquiZipT, T2, T3, T4, TResult |
+ 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.
+ (Defined by EquiZipExtension) |
| ExactlyT |
+ Determines whether or not the number of elements in the sequence is equals to the given integer.
+ (Defined by MoreEnumerable) |
| ExactlyT |
+ Determines whether or not the number of elements in the sequence is equals to the given integer.
+ (Defined by ExactlyExtension) |
| ExceptByT, TKey |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ (Defined by MoreEnumerable) |
| ExceptByT, TKey |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ (Defined by ExceptByExtension) |
| ExceptByT, TKey |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ (Defined by MoreEnumerable) |
| ExceptByT, TKey |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ (Defined by ExceptByExtension) |
| ExcludeT |
+ Excludes a contiguous number of elements from a sequence starting
+ at a given index.
+ (Defined by MoreEnumerable) |
| ExcludeT |
+ Excludes a contiguous number of elements from a sequence starting
+ at a given index.
+ (Defined by ExcludeExtension) |
| FallbackIfEmptyT |
+ Returns the elements of the specified sequence or the specified
+ value in a singleton collection if the sequence is empty.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence from an array of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of the specified sequence or the specified
+ value in a singleton collection if the sequence is empty.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence from an array of values.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by FallbackIfEmptyExtension) |
| FillBackwardT |
+ Returns a sequence with each null reference or value in the source
+ replaced with the following non-null reference or value in
+ that sequence.
+ (Defined by MoreEnumerable) |
| FillBackwardT |
+ Returns a sequence with each null reference or value in the source
+ replaced with the following non-null reference or value in
+ that sequence.
+ (Defined by FillBackwardExtension) |
| FillBackwardT |
+ 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.
+ (Defined by MoreEnumerable) |
| FillBackwardT |
+ 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.
+ (Defined by FillBackwardExtension) |
| FillBackwardT |
+ Returns a sequence with each missing element in the source replaced
+ with the following non-missing element in that sequence. Additional
+ parameters specify two functions, one used to determine if an
+ element is considered missing or not and another to provide the
+ replacement for the missing element.
+ (Defined by MoreEnumerable) |
| FillBackwardT |
+ Returns a sequence with each missing element in the source replaced
+ with the following non-missing element in that sequence. Additional
+ parameters specify two functions, one used to determine if an
+ element is considered missing or not and another to provide the
+ replacement for the missing element.
+ (Defined by FillBackwardExtension) |
| FillForwardT |
+ 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.
+ (Defined by MoreEnumerable) |
| FillForwardT |
+ 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.
+ (Defined by FillForwardExtension) |
| FillForwardT |
+ 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.
+ (Defined by MoreEnumerable) |
| FillForwardT |
+ 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.
+ (Defined by FillForwardExtension) |
| FillForwardT |
+ 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 specify two functions, one used to
+ determine if an element is considered missing or not and another
+ to provide the replacement for the missing element.
+ (Defined by MoreEnumerable) |
| FillForwardT |
+ 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 specify two functions, one used to
+ determine if an element is considered missing or not and another
+ to provide the replacement for the missing element.
+ (Defined by FillForwardExtension) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences.
+ (Defined by MoreEnumerable) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences.
+ (Defined by FlattenExtension) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a predicate function used to
+ determine whether a nested IEnumerable should be
+ flattened or not.
+ (Defined by MoreEnumerable) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a function that projects an inner
+ sequence via a property of an object.
+ (Defined by MoreEnumerable) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a predicate function used to
+ determine whether a nested IEnumerable should be
+ flattened or not.
+ (Defined by FlattenExtension) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a function that projects an inner
+ sequence via a property of an object.
+ (Defined by FlattenExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 9 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 9 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 10 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 10 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 11 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 11 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 12 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 12 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 13 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 13 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 14 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 14 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 15 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 15 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 16 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 16 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 1 element.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 1 element.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 2 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 2 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 3 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 3 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 4 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 4 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 5 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 5 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 6 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 6 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 7 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 7 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 8 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 8 elements.
+ (Defined by FoldExtension) |
| ForEachT |
+ Immediately executes the given action on each element in the source sequence.
+ (Defined by MoreEnumerable) |
| ForEachT |
+ Immediately executes the given action on each element in the source sequence.
+ (Defined by ForEachExtension) |
| ForEachT |
+ Immediately executes the given action on each element in the source sequence.
+ Each element's index is used in the logic of the action.
+ (Defined by MoreEnumerable) |
| ForEachT |
+ Immediately executes the given action on each element in the source sequence.
+ Each element's index is used in the logic of the action.
+ (Defined by ForEachExtension) |
| FullGroupJoinT, TSecond, TKey |
+ Performs a Full Group Join between the first and second sequences.
+ (Defined by MoreEnumerable) |
| FullGroupJoinT, TSecond, TKey |
+ Performs a Full Group Join between the first and second sequences.
+ (Defined by FullGroupJoinExtension) |
| FullGroupJoinT, TSecond, TKey |
+ Performs a Full Group Join between the first and second sequences.
+ (Defined by MoreEnumerable) |
| FullGroupJoinT, TSecond, TKey |
+ Performs a Full Group Join between the first and second sequences.
+ (Defined by FullGroupJoinExtension) |
| FullGroupJoinT, TSecond, TKey, TResult |
+ Performs a full group-join between two sequences.
+ (Defined by MoreEnumerable) |
| FullGroupJoinT, TSecond, TKey, TResult |
+ Performs a full group-join between two sequences.
+ (Defined by FullGroupJoinExtension) |
| FullGroupJoinT, TSecond, TKey, TResult |
+ Performs a full group-join between two sequences.
+ (Defined by MoreEnumerable) |
| FullGroupJoinT, TSecond, TKey, TResult |
+ Performs a full group-join between two sequences.
+ (Defined by FullGroupJoinExtension) |
| FullJoinT, TKey, TResult |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| FullJoinT, TKey, TResult |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by FullJoinExtension) |
| FullJoinT, TKey, TResult |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| FullJoinT, TKey, TResult |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by FullJoinExtension) |
| FullJoinT, TSecond, TKey, TResult |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| FullJoinT, TSecond, TKey, TResult |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by FullJoinExtension) |
| FullJoinT, TSecond, TKey, TResult |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| FullJoinT, TSecond, TKey, TResult |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by FullJoinExtension) |
| GroupAdjacentT, TKey |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and compares the keys by using a
+ specified comparer.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and compares the keys by using a
+ specified comparer.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey, TElement |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and projects the elements for
+ each group by using a specified function.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey, TResult |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey, TElement |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and projects the elements for
+ each group by using a specified function.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey, TResult |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey, TElement |
+ 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.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey, TResult |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey, TElement |
+ 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.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey, TResult |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ (Defined by GroupAdjacentExtension) |
| IndexT |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the zero-based index of the value in the source
+ sequence.
+ (Defined by MoreEnumerable) |
| IndexT |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the zero-based index of the value in the source
+ sequence.
+ (Defined by IndexExtension) |
| IndexT |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the index of the value in the source sequence.
+ An additional parameter specifies the starting index.
+ (Defined by MoreEnumerable) |
| IndexT |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the index of the value in the source sequence.
+ An additional parameter specifies the starting index.
+ (Defined by IndexExtension) |
| IndexByT, TKey |
+ 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.
+ (Defined by MoreEnumerable) |
| IndexByT, TKey |
+ 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.
+ (Defined by IndexByExtension) |
| IndexByT, TKey |
+ 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.
+ (Defined by MoreEnumerable) |
| IndexByT, TKey |
+ 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.
+ (Defined by IndexByExtension) |
| InsertT |
+ Inserts the elements of a sequence into another sequence at a
+ specified index.
+ (Defined by MoreEnumerable) |
| InsertT |
+ Inserts the elements of a sequence into another sequence at a
+ specified index.
+ (Defined by InsertExtension) |
| InterleaveT |
+ Interleaves the elements of two or more sequences into a single sequence, skipping
+ sequences as they are consumed.
+ (Defined by MoreEnumerable) |
| InterleaveT |
+ Interleaves the elements of two or more sequences into a single sequence, skipping
+ sequences as they are consumed.
+ (Defined by InterleaveExtension) |
| LagT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ negative offset.
+ (Defined by MoreEnumerable) |
| LagT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ negative offset.
+ (Defined by LagExtension) |
| LagT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ negative offset.
+ (Defined by MoreEnumerable) |
| LagT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ negative offset.
+ (Defined by LagExtension) |
| LeadT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ positive offset.
+ (Defined by MoreEnumerable) |
| LeadT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ positive offset.
+ (Defined by LeadExtension) |
| LeadT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ positive offset.
+ (Defined by MoreEnumerable) |
| LeadT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ positive offset.
+ (Defined by LeadExtension) |
| LeftJoinT, TKey, TResult |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| LeftJoinT, TKey, TResult |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by LeftJoinExtension) |
| LeftJoinT, TKey, TResult |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| LeftJoinT, TKey, TResult |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by LeftJoinExtension) |
| LeftJoinT, TSecond, TKey, TResult |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| LeftJoinT, TSecond, TKey, TResult |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by LeftJoinExtension) |
| LeftJoinT, TSecond, TKey, TResult |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| LeftJoinT, TSecond, TKey, TResult |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by LeftJoinExtension) |
| MaxByT, TKey |
+ Returns the maximal elements of the given sequence, based on
+ the given projection.
+ (Defined by MoreEnumerable) |
| MaxByT, TKey |
+ Returns the maximal elements of the given sequence, based on
+ the given projection.
+ (Defined by MaxByExtension) |
| MaxByT, TKey |
+ Returns the maximal elements of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ (Defined by MoreEnumerable) |
| MaxByT, TKey |
+ Returns the maximal elements of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ (Defined by MaxByExtension) |
| MemoizeT |
+ 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.
+ (Defined by ExperimentalEnumerable) |
| MinByT, TKey |
+ Returns the minimal elements of the given sequence, based on
+ the given projection.
+ (Defined by MoreEnumerable) |
| MinByT, TKey |
+ Returns the minimal elements of the given sequence, based on
+ the given projection.
+ (Defined by MinByExtension) |
| MinByT, TKey |
+ Returns the minimal elements of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ (Defined by MoreEnumerable) |
| MinByT, TKey |
+ Returns the minimal elements of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ (Defined by MinByExtension) |
| MoveT |
+ Returns a sequence with a range of elements in the source sequence
+ moved to a new offset.
+ (Defined by MoreEnumerable) |
| MoveT |
+ Returns a sequence with a range of elements in the source sequence
+ moved to a new offset.
+ (Defined by MoveExtension) |
| OrderByT, TKey |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ (Defined by MoreEnumerable) |
| OrderByT, TKey |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ (Defined by OrderByExtension) |
| OrderByT, TKey |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ (Defined by MoreEnumerable) |
| OrderByT, TKey |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ (Defined by OrderByExtension) |
| OrderedMergeT |
+ 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.
+ (Defined by MoreEnumerable) |
| OrderedMergeT |
+ 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.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT |
+ 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.
+ (Defined by MoreEnumerable) |
| OrderedMergeT |
+ 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.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TKey |
+ Merges two ordered sequences into one with an additional
+ parameter specifying the element key by which the sequences are
+ ordered. Where the keys equal in both sequences, the
+ element from the first sequence is returned in the resulting
+ sequence.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TKey |
+ Merges two ordered sequences into one with an additional
+ parameter specifying the element key by which the sequences are
+ ordered. Where the keys equal in both sequences, the
+ element from the first sequence is returned in the resulting
+ sequence.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TKey, TResult |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first and the result when elements are found in
+ both sequences.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TKey, TResult |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first and the result when elements are found in
+ both sequences.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TKey, TResult |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first, the result when elements are found in
+ both sequences and a method for comparing keys.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TKey, TResult |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first, the result when elements are found in
+ both sequences and a method for comparing keys.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TSecond, TKey, TResult |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second and
+ the result when element is found in second sequence but not in
+ the first, the result when elements are found in both sequences.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TSecond, TKey, TResult |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second and
+ the result when element is found in second sequence but not in
+ the first, the result when elements are found in both sequences.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TSecond, TKey, TResult |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second,
+ 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.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TSecond, TKey, TResult |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second,
+ 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.
+ (Defined by OrderedMergeExtension) |
| PadT |
+ Pads a sequence with default values if it is narrower (shorter
+ in length) than a given width.
+ (Defined by MoreEnumerable) |
| PadT |
+ Pads a sequence with default values if it is narrower (shorter
+ in length) than a given width.
+ (Defined by PadExtension) |
| PadT |
+ Pads a sequence with a given filler value if it is narrower (shorter
+ in length) than a given width.
+ (Defined by MoreEnumerable) |
| PadT |
+ Pads a sequence with a dynamic filler value if it is narrower (shorter
+ in length) than a given width.
+ (Defined by MoreEnumerable) |
| PadT |
+ Pads a sequence with a given filler value if it is narrower (shorter
+ in length) than a given width.
+ (Defined by PadExtension) |
| PadT |
+ Pads a sequence with a dynamic filler value if it is narrower (shorter
+ in length) than a given width.
+ (Defined by PadExtension) |
| PadStartT |
+ Pads a sequence with default values in the beginning if it is narrower (shorter
+ in length) than a given width.
+ (Defined by MoreEnumerable) |
| PadStartT |
+ Pads a sequence with default values in the beginning if it is narrower (shorter
+ in length) than a given width.
+ (Defined by PadStartExtension) |
| PadStartT |
+ 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.
+ (Defined by MoreEnumerable) |
| PadStartT |
+ 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.
+ (Defined by MoreEnumerable) |
| PadStartT |
+ 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.
+ (Defined by PadStartExtension) |
| PadStartT |
+ 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.
+ (Defined by PadStartExtension) |
| PairwiseT, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence and its
+ predecessor, with the exception of the first element which is
+ only returned as the predecessor of the second element.
+ (Defined by MoreEnumerable) |
| PairwiseT, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence and its
+ predecessor, with the exception of the first element which is
+ only returned as the predecessor of the second element.
+ (Defined by PairwiseExtension) |
| PartialSortT |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ (Defined by MoreEnumerable) |
| PartialSortT |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ (Defined by PartialSortExtension) |
| PartialSortT |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ An additional parameter specifies the direction of the sort
+ (Defined by MoreEnumerable) |
| PartialSortT |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation. An additional parameter specifies how the
+ elements compare to each other.
+ (Defined by MoreEnumerable) |
| PartialSortT |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ An additional parameter specifies the direction of the sort
+ (Defined by PartialSortExtension) |
| PartialSortT |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation. An additional parameter specifies how the
+ elements compare to each other.
+ (Defined by PartialSortExtension) |
| PartialSortT |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ (Defined by MoreEnumerable) |
| PartialSortT |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ (Defined by PartialSortExtension) |
| PartialSortByT, TKey |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ (Defined by MoreEnumerable) |
| PartialSortByT, TKey |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ (Defined by PartialSortByExtension) |
| PartialSortByT, TKey |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies the direction of the sort
+ (Defined by MoreEnumerable) |
| PartialSortByT, TKey |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies how the keys compare to each other.
+ (Defined by MoreEnumerable) |
| PartialSortByT, TKey |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies the direction of the sort
+ (Defined by PartialSortByExtension) |
| PartialSortByT, TKey |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies how the keys compare to each other.
+ (Defined by PartialSortByExtension) |
| PartialSortByT, TKey |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ (Defined by MoreEnumerable) |
| PartialSortByT, TKey |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ (Defined by PartialSortByExtension) |
| PartitionT |
+ Partitions or splits a sequence in two using a predicate.
+ (Defined by MoreEnumerable) |
| PartitionT |
+ Partitions or splits a sequence in two using a predicate.
+ (Defined by PartitionExtension) |
| PartitionT, TResult |
+ Partitions or splits a sequence in two using a predicate and then
+ projects a result from the two.
+ (Defined by MoreEnumerable) |
| PartitionT, TResult |
+ Partitions or splits a sequence in two using a predicate and then
+ projects a result from the two.
+ (Defined by PartitionExtension) |
| PermutationsT |
+ Generates a sequence of lists that represent the permutations of the original sequence.
+ (Defined by MoreEnumerable) |
| PermutationsT |
+ Generates a sequence of lists that represent the permutations of the original sequence.
+ (Defined by PermutationsExtension) |
| PipeT |
+ Executes the given action on each element in the source sequence
+ and yields it.
+ (Defined by MoreEnumerable) |
| PipeT |
+ Executes the given action on each element in the source sequence
+ and yields it.
+ (Defined by PipeExtension) |
| PrependT |
+ Prepends a single value to a sequence.
+ (Defined by MoreEnumerable) |
| PrependT |
+ Prepends a single value to a sequence.
+ (Defined by PrependExtension) |
| PreScanT |
+ Performs a pre-scan (exclusive prefix sum) on a sequence of elements.
+ (Defined by MoreEnumerable) |
| PreScanT |
+ Performs a pre-scan (exclusive prefix sum) on a sequence of elements.
+ (Defined by PreScanExtension) |
| RandomSubsetT |
+ Returns a sequence of a specified size of random elements from the
+ original sequence.
+ (Defined by MoreEnumerable) |
| RandomSubsetT |
+ Returns a sequence of a specified size of random elements from the
+ original sequence.
+ (Defined by RandomSubsetExtension) |
| RandomSubsetT |
+ 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.
+ (Defined by MoreEnumerable) |
| RandomSubsetT |
+ 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.
+ (Defined by RandomSubsetExtension) |
| RankT |
+ Ranks each item in the sequence in descending ordering using a default comparer.
+ (Defined by MoreEnumerable) |
| RankT |
+ Ranks each item in the sequence in descending ordering using a default comparer.
+ (Defined by RankExtension) |
| RankT |
+ Rank each item in the sequence using a caller-supplied comparer.
+ (Defined by MoreEnumerable) |
| RankT |
+ Rank each item in the sequence using a caller-supplied comparer.
+ (Defined by RankExtension) |
| RankByT, TKey |
+ Ranks each item in the sequence in descending ordering by a specified key using a default comparer
+ (Defined by MoreEnumerable) |
| RankByT, TKey |
+ Ranks each item in the sequence in descending ordering by a specified key using a default comparer
+ (Defined by RankByExtension) |
| RankByT, TKey |
+ Ranks each item in a sequence using a specified key and a caller-supplied comparer
+ (Defined by MoreEnumerable) |
| RankByT, TKey |
+ Ranks each item in a sequence using a specified key and a caller-supplied comparer
+ (Defined by RankByExtension) |
| RepeatT |
+ Repeats the sequence forever.
+ (Defined by MoreEnumerable) |
| RepeatT |
+ Repeats the sequence forever.
+ (Defined by RepeatExtension) |
| RepeatT |
+ Repeats the sequence the specified number of times.
+ (Defined by MoreEnumerable) |
| RepeatT |
+ Repeats the sequence the specified number of times.
+ (Defined by RepeatExtension) |
| RightJoinT, TKey, TResult |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| RightJoinT, TKey, TResult |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by RightJoinExtension) |
| RightJoinT, TKey, TResult |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| RightJoinT, TKey, TResult |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by RightJoinExtension) |
| RightJoinT, TSecond, TKey, TResult |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| RightJoinT, TSecond, TKey, TResult |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by RightJoinExtension) |
| RightJoinT, TSecond, TKey, TResult |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| RightJoinT, TSecond, TKey, TResult |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by RightJoinExtension) |
| RunLengthEncodeT |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count.
+ (Defined by MoreEnumerable) |
| RunLengthEncodeT |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count.
+ (Defined by RunLengthEncodeExtension) |
| RunLengthEncodeT |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count. This overload
+ uses a custom equality comparer to identify equivalent items.
+ (Defined by MoreEnumerable) |
| RunLengthEncodeT |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count. This overload
+ uses a custom equality comparer to identify equivalent items.
+ (Defined by RunLengthEncodeExtension) |
| ScanT |
+ Performs a scan (inclusive prefix sum) on a sequence of elements.
+ (Defined by MoreEnumerable) |
| ScanT |
+ Performs a scan (inclusive prefix sum) on a sequence of elements.
+ (Defined by ScanExtension) |
| ScanT, TState |
+ Like AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) except returns
+ the sequence of intermediate results as well as the final one.
+ An additional parameter specifies a seed.
+ (Defined by MoreEnumerable) |
| ScanT, TState |
+ Like AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) except returns
+ the sequence of intermediate results as well as the final one.
+ An additional parameter specifies a seed.
+ (Defined by ScanExtension) |
| ScanByT, TKey, TState |
+ Applies an accumulator function over sequence element keys,
+ returning the keys along with intermediate accumulator states.
+ (Defined by MoreEnumerable) |
| ScanByT, TKey, TState |
+ Applies an accumulator function over sequence element keys,
+ returning the keys along with intermediate accumulator states.
+ (Defined by ScanByExtension) |
| ScanByT, TKey, TState |
+ 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.
+ (Defined by MoreEnumerable) |
| ScanByT, TKey, TState |
+ 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.
+ (Defined by ScanByExtension) |
| ScanRightT |
+ Performs a right-associative scan (inclusive prefix) on a sequence of elements.
+ This operator is the right-associative version of the
+ ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ (Defined by MoreEnumerable) |
| ScanRightT |
+ Performs a right-associative scan (inclusive prefix) on a sequence of elements.
+ This operator is the right-associative version of the
+ ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ (Defined by ScanRightExtension) |
| ScanRightT, TAccumulate |
+ Performs a right-associative scan (inclusive prefix) on a sequence of elements.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) LINQ operator.
+ (Defined by MoreEnumerable) |
| ScanRightT, TAccumulate |
+ Performs a right-associative scan (inclusive prefix) on a sequence of elements.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) LINQ operator.
+ (Defined by ScanRightExtension) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by MoreEnumerable) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by SegmentExtension) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by MoreEnumerable) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by SegmentExtension) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by MoreEnumerable) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by SegmentExtension) |
| ShuffleT |
+ Returns a sequence of elements in random order from the original
+ sequence.
+ (Defined by MoreEnumerable) |
| ShuffleT |
+ Returns a sequence of elements in random order from the original
+ sequence.
+ (Defined by ShuffleExtension) |
| ShuffleT |
+ 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.
+ (Defined by MoreEnumerable) |
| ShuffleT |
+ 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.
+ (Defined by ShuffleExtension) |
| SkipLastT |
+ Bypasses a specified number of elements at the end of the sequence.
+ (Defined by MoreEnumerable) |
| SkipLastT |
+ Bypasses a specified number of elements at the end of the sequence.
+ (Defined by SkipLastExtension) |
| SkipUntilT |
+ 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.
+ (Defined by MoreEnumerable) |
| SkipUntilT |
+ 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.
+ (Defined by SkipUntilExtension) |
| SliceT |
+ Extracts a contiguous count of elements from a sequence at a particular zero-based
+ starting index.
+ (Defined by MoreEnumerable) |
| SliceT |
+ Extracts a contiguous count of elements from a sequence at a particular zero-based
+ starting index.
+ (Defined by SliceExtension) |
| SortedMergeT |
+ Merges two or more sequences that are in a common order (either ascending or descending)
+ into a single sequence that preserves that order.
+ (Defined by MoreEnumerable) |
| SortedMergeT |
+ Merges two or more sequences that are in a common order (either ascending or descending)
+ into a single sequence that preserves that order.
+ (Defined by SortedMergeExtension) |
| SortedMergeT |
+ Merges two or more sequences that are in a common order (either ascending or descending)
+ into a single sequence that preserves that order.
+ (Defined by MoreEnumerable) |
| SortedMergeT |
+ Merges two or more sequences that are in a common order (either ascending or descending)
+ into a single sequence that preserves that order.
+ (Defined by SortedMergeExtension) |
| SplitT |
+ Splits the source sequence by separator elements identified by a
+ function.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by separator elements identified by a
+ function.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by a separator.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by a separator.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by separator elements identified by a
+ function, given a maximum count of splits.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by separator elements identified by a
+ function, given a maximum count of splits.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by a separator given a maximum count of splits.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by a separator and then transforms the
+ splits into results.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by a separator given a maximum count of splits.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by a separator and then transforms the
+ splits into results.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by a separator, given a maximum count
+ of splits. A parameter specifies how the separator is compared
+ for equality.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by a separator, given a maximum count
+ of splits. A parameter specifies how the separator is compared
+ for equality.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by separator elements identified by
+ a function and then transforms the splits into results.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by separator elements identified by
+ a function and then transforms the splits into results.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by a separator and then transforms
+ the splits into results.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by a separator and then transforms
+ the splits into results.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by separator elements identified by
+ a function, given a maximum count of splits, and then transforms
+ the splits into results.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by separator elements identified by
+ a function, given a maximum count of splits, and then transforms
+ the splits into results.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by a separator and then transforms the
+ splits into results. A parameter specifies how the separator is
+ compared for equality.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by a separator and then transforms the
+ splits into results. A parameter specifies how the separator is
+ compared for equality.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results. A
+ parameter specifies how the separator is compared for equality.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results. A
+ parameter specifies how the separator is compared for equality.
+ (Defined by SplitExtension) |
| StartsWithT |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the default equality
+ comparer.
+ (Defined by MoreEnumerable) |
| StartsWithT |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the default equality
+ comparer.
+ (Defined by StartsWithExtension) |
| StartsWithT |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the specified element
+ equality comparer.
+ (Defined by MoreEnumerable) |
| StartsWithT |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the specified element
+ equality comparer.
+ (Defined by StartsWithExtension) |
| SubsetsT |
+ Returns a sequence of IListT representing all of the subsets of any size
+ that are part of the original sequence. In mathematics, it is equivalent to the
+ power set of a set.
+ (Defined by MoreEnumerable) |
| SubsetsT |
+ Returns a sequence of IListT representing all of the subsets of any size
+ that are part of the original sequence. In mathematics, it is equivalent to the
+ power set of a set.
+ (Defined by SubsetsExtension) |
| SubsetsT |
+ Returns a sequence of IListT representing all subsets of a given size
+ that are part of the original sequence. In mathematics, it is equivalent to the
+ combinations or k-subsets of a set.
+ (Defined by MoreEnumerable) |
| SubsetsT |
+ Returns a sequence of IListT representing all subsets of a given size
+ that are part of the original sequence. In mathematics, it is equivalent to the
+ combinations or k-subsets of a set.
+ (Defined by SubsetsExtension) |
| TagFirstLastT, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence with additional parameters
+ indicating whether the element is the first and/or last of the
+ sequence.
+ (Defined by MoreEnumerable) |
| TagFirstLastT, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence with additional parameters
+ indicating whether the element is the first and/or last of the
+ sequence.
+ (Defined by TagFirstLastExtension) |
| TakeEveryT |
+ Returns every N-th element of a sequence.
+ (Defined by MoreEnumerable) |
| TakeEveryT |
+ Returns every N-th element of a sequence.
+ (Defined by TakeEveryExtension) |
| TakeLastT |
+ Returns a specified number of contiguous elements from the end of
+ a sequence.
+ (Defined by MoreEnumerable) |
| TakeLastT |
+ Returns a specified number of contiguous elements from the end of
+ a sequence.
+ (Defined by TakeLastExtension) |
| TakeUntilT |
+ 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.
+ (Defined by MoreEnumerable) |
| TakeUntilT |
+ 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.
+ (Defined by TakeUntilExtension) |
| ToArrayByIndexT |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT, TResult |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT, TResult |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT, TResult |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT, TResult |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT, TResult |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT, TResult |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT, TResult |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT, TResult |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ (Defined by ToArrayByIndexExtension) |
| ToDataTableT |
+ Converts a sequence to a DataTable object.
+ (Defined by MoreEnumerable) |
| ToDataTableT |
+ Converts a sequence to a DataTable object.
+ (Defined by ToDataTableExtension) |
| ToDataTableT |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ (Defined by MoreEnumerable) |
| ToDataTableT |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ (Defined by ToDataTableExtension) |
| ToDataTableT, TTable |
+ Appends elements in the sequence as rows of a given DataTable object.
+ (Defined by MoreEnumerable) |
| ToDataTableT, TTable |
+ Appends elements in the sequence as rows of a given DataTable object.
+ (Defined by ToDataTableExtension) |
| ToDataTableT, TTable |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ (Defined by MoreEnumerable) |
| ToDataTableT, TTable |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ (Defined by ToDataTableExtension) |
| ToDelimitedStringT |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ (Defined by MoreEnumerable) |
| ToDelimitedStringT |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ (Defined by ToDelimitedStringExtension) |
| ToHashSetT |
+ Returns a HashSetT of the source items using the default equality
+ comparer for the type.
+ (Defined by MoreEnumerable) |
| ToHashSetT |
+ Returns a HashSetT of the source items using the default equality
+ comparer for the type.
+ (Defined by ToHashSetExtension) |
| ToHashSetT |
+ Returns a HashSetT of the source items using the specified equality
+ comparer for the type.
+ (Defined by MoreEnumerable) |
| ToHashSetT |
+ Returns a HashSetT of the source items using the specified equality
+ comparer for the type.
+ (Defined by ToHashSetExtension) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics.
+ (Defined by MoreEnumerable) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics.
+ (Defined by TraceExtension) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics using
+ a custom formatter.
+ (Defined by MoreEnumerable) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics using
+ a custom formatter.
+ (Defined by TraceExtension) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics using
+ custom formatting.
+ (Defined by MoreEnumerable) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics using
+ custom formatting.
+ (Defined by TraceExtension) |
| TrySingleT, TCardinality |
+ Returns a tuple with the cardinality of the sequence and the
+ single element in the sequence if it contains exactly one element.
+ similar to SingleTSource(IEnumerableTSource).
+ (Defined by ExperimentalEnumerable) |
| TrySingleT, TCardinality, TResult |
+ Returns a result projected from the the cardinality of the sequence
+ and the single element in the sequence if it contains exactly one
+ element.
+ (Defined by ExperimentalEnumerable) |
| WindowT |
+ Processes a sequence into a series of sub-sequences representing a windowed subset of
+ the original.
+ (Defined by MoreEnumerable) |
| WindowT |
+ Processes a sequence into a series of sub-sequences representing a windowed subset of
+ the original.
+ (Defined by WindowExtension) |
| WindowedT |
+ Processes a sequence into a series of sub-sequences representing a windowed subset of the original.
+ (Defined by MoreEnumerable) |
| WindowLeftT |
+ Creates a left-aligned sliding window of a given size over the
+ source sequence.
+ (Defined by MoreEnumerable) |
| WindowLeftT |
+ Creates a left-aligned sliding window of a given size over the
+ source sequence.
+ (Defined by WindowLeftExtension) |
| WindowRightT |
+ Creates a right-aligned sliding window over the source sequence
+ of a given size.
+ (Defined by MoreEnumerable) |
| WindowRightT |
+ Creates a right-aligned sliding window over the source sequence
+ of a given size.
+ (Defined by WindowRightExtension) |
| ZipLongestT, TSecond, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipLongestT, TSecond, TResult |
+ 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.
+ (Defined by ZipLongestExtension) |
| ZipLongestT, T2, T3, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipLongestT, T2, T3, TResult |
+ 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.
+ (Defined by ZipLongestExtension) |
| ZipLongestT, T2, T3, T4, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipLongestT, T2, T3, T4, TResult |
+ 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.
+ (Defined by ZipLongestExtension) |
| ZipShortestT, TSecond, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipShortestT, TSecond, TResult |
+ 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.
+ (Defined by ZipShortestExtension) |
| ZipShortestT, T2, T3, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipShortestT, T2, T3, TResult |
+ 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.
+ (Defined by ZipShortestExtension) |
| ZipShortestT, T2, T3, T4, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipShortestT, T2, T3, T4, TResult |
+ 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.
+ (Defined by ZipShortestExtension) |
| AcquireTSource | + Ensures that a source sequence of IDisposable + objects are all acquired successfully. If the acquisition of any + one IDisposable fails then those successfully + acquired till that point are disposed. + |
| AggregateRightTSource(IEnumerableTSource, FuncTSource, TSource, TSource) | + Applies a right-associative accumulator function over a sequence. + This operator is the right-associative version of the + AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator. + |
| AggregateRightTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate) | + Applies a right-associative accumulator function over a sequence. + The specified seed value is used as the initial accumulator value. + This operator is the right-associative version of the + AggregateTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate) LINQ operator. + |
| AggregateRightTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate, FuncTAccumulate, TResult) | + Applies a right-associative accumulator function over a sequence. + The specified seed value is used as the initial accumulator value, + and the specified function is used to select the result value. + This operator is the right-associative version of the + AggregateTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate, FuncTAccumulate, TResult) LINQ operator. + |
| AppendT | + Returns a sequence consisting of the head elements and the given tail element. + |
| AssertCountTSource(IEnumerableTSource, Int32) | + Asserts that a source sequence contains a given count of elements. + |
| AssertCountTSource(IEnumerableTSource, Int32, FuncInt32, Int32, Exception) | + Asserts that a source sequence contains a given count of elements. + A parameter specifies the exception to be thrown. + |
| AssertTSource(IEnumerableTSource, FuncTSource, Boolean) | + Asserts that all elements of a sequence meet a given condition + otherwise throws an Exception object. + |
| AssertTSource(IEnumerableTSource, FuncTSource, Boolean, FuncTSource, Exception) | + Asserts that all elements of a sequence meet a given condition + otherwise throws an Exception object. + |
| AtLeastT | + Determines whether or not the number of elements in the sequence is greater than + or equal to the given integer. + |
| AtMostT | + Determines whether or not the number of elements in the sequence is lesser than + or equal to the given integer. + |
| BacksertT | + 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. + |
| BatchTSource(IEnumerableTSource, Int32) | + Batches the source sequence into sized buckets. + |
| BatchTSource, TResult(IEnumerableTSource, Int32, FuncIEnumerableTSource, TResult) | + Batches the source sequence into sized buckets and applies a projection to each bucket. + |
| CartesianT1, T2, TResult(IEnumerableT1, IEnumerableT2, FuncT1, T2, TResult) | + 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. + |
| CartesianT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, T5, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, IEnumerableT5, FuncT1, T2, T3, T4, T5, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, T5, T6, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, IEnumerableT5, IEnumerableT6, FuncT1, T2, T3, T4, T5, T6, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, T5, T6, T7, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, IEnumerableT5, IEnumerableT6, IEnumerableT7, FuncT1, T2, T3, T4, T5, T6, T7, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, T5, T6, T7, T8, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, IEnumerableT5, IEnumerableT6, IEnumerableT7, IEnumerableT8, FuncT1, T2, T3, T4, T5, T6, T7, T8, TResult) | + 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. + |
| ChooseT, TResult | + 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 true + as its first element and result as the second. + |
| CompareCountTFirst, TSecond | + Compares two sequences and returns an integer that indicates whether the first sequence + has fewer, the same or more elements than the second sequence. + |
| ConsumeT | + Completely consumes the given sequence. This method uses immediate execution, + and doesn't store any data during execution. + |
| CountBetweenT | + Determines whether or not the number of elements in the sequence is between + an inclusive range of minimum and maximum integers. + |
| CountByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Applies a key-generating function to each element of a sequence and returns a sequence of + unique keys and their number of occurrences in the original sequence. + |
| CountByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + Applies a key-generating function to each element of a sequence and returns a sequence of + unique keys and their number of occurrences in the original sequence. + An additional argument specifies a comparer to use for testing equivalence of keys. + |
| CountDownT, TResult | + 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. + |
| DistinctByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Returns all distinct elements of the given source, where "distinctness" + is determined via a projection and the default equality comparer for the projected type. + |
| DistinctByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + Returns all distinct elements of the given source, where "distinctness" + is determined via a projection and the specified comparer for the projected type. + |
| EndsWithT(IEnumerableT, IEnumerableT) | + Determines whether the end of the first sequence is equivalent to + the second sequence, using the default equality comparer. + |
| EndsWithT(IEnumerableT, IEnumerableT, IEqualityComparerT) | + Determines whether the end of the first sequence is equivalent to + the second sequence, using the specified element equality comparer. + |
| EquiZipTFirst, TSecond, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. An exception is thrown + if the input sequences are of different lengths. + |
| EquiZipT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. An exception is thrown + if the input sequences are of different lengths. + |
| EquiZipT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. An exception is thrown + if the input sequences are of different lengths. + |
| EvaluateT | + Returns a sequence containing the values resulting from invoking (in order) each function in the source sequence of functions. + |
| ExactlyT | + Determines whether or not the number of elements in the sequence is equals to the given integer. + |
| ExceptByTSource, TKey(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey) | + Returns the set of elements in the first sequence which aren't + in the second sequence, according to a given key selector. + |
| ExceptByTSource, TKey(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + Returns the set of elements in the first sequence which aren't + in the second sequence, according to a given key selector. + |
| ExcludeT | + Excludes a contiguous number of elements from a sequence starting + at a given index. + |
| FallbackIfEmptyT(IEnumerableT, T) | + Returns the elements of the specified sequence or the specified + value in a singleton collection if the sequence is empty. + |
| FallbackIfEmptyT(IEnumerableT, T) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence from an array of values. + |
| FallbackIfEmptyT(IEnumerableT, IEnumerableT) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence of values. + |
| FallbackIfEmptyT(IEnumerableT, T, T) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence of values. + |
| FallbackIfEmptyT(IEnumerableT, T, T, T) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence of values. + |
| FallbackIfEmptyT(IEnumerableT, T, T, T, T) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence of values. + |
| FillBackwardT(IEnumerableT) | + Returns a sequence with each null reference or value in the source + replaced with the following non-null reference or value in + that sequence. + |
| FillBackwardT(IEnumerableT, FuncT, Boolean) | + Returns a sequence with each missing element in the source replaced + with the following non-missing element in that sequence. An + additional parameter specifies a function used to determine if an + element is considered missing or not. + |
| FillBackwardT(IEnumerableT, FuncT, Boolean, FuncT, T, T) | + Returns a sequence with each missing element in the source replaced + with the following non-missing element in that sequence. Additional + parameters specify two functions, one used to determine if an + element is considered missing or not and another to provide the + replacement for the missing element. + |
| FillForwardT(IEnumerableT) | + Returns a sequence with each null reference or value in the source + replaced with the previous non-null reference or value seen in + that sequence. + |
| FillForwardT(IEnumerableT, FuncT, Boolean) | + Returns a sequence with each missing element in the source replaced + with the previous non-missing element seen in that sequence. An + additional parameter specifies a function used to determine if an + element is considered missing or not. + |
| FillForwardT(IEnumerableT, FuncT, Boolean, FuncT, T, T) | + Returns a sequence with each missing element in the source replaced + with one based on the previous non-missing element seen in that + sequence. Additional parameters specify two functions, one used to + determine if an element is considered missing or not and another + to provide the replacement for the missing element. + |
| FirstOrDefaultT | + Returns the first element of a sequence, or a default value if the + sequence contains no elements. + |
| Flatten(IEnumerable) | + Flattens a sequence containing arbitrarily-nested sequences. + |
| Flatten(IEnumerable, FuncIEnumerable, Boolean) | + Flattens a sequence containing arbitrarily-nested sequences. An + additional parameter specifies a predicate function used to + determine whether a nested IEnumerable should be + flattened or not. + |
| Flatten(IEnumerable, FuncObject, IEnumerable) | + Flattens a sequence containing arbitrarily-nested sequences. An + additional parameter specifies a function that projects an inner + sequence via a property of an object. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 16 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 15 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 14 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 13 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 12 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 11 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 10 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 9 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 8 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 7 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 6 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 5 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 4 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, TResult) | + Returns the result of applying a function to a sequence of + 3 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, TResult) | + Returns the result of applying a function to a sequence of + 2 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, TResult) | + Returns the result of applying a function to a sequence of + 1 element. + |
| ForEachT(IEnumerableT, ActionT, Int32) | + Immediately executes the given action on each element in the source sequence. + Each element's index is used in the logic of the action. + |
| ForEachT(IEnumerableT, ActionT) | + Immediately executes the given action on each element in the source sequence. + |
| FullGroupJoinTFirst, TSecond, TKey(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey) | + Performs a Full Group Join between the first and second sequences. + |
| FullGroupJoinTFirst, TSecond, TKey(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, IEqualityComparerTKey) | + Performs a Full Group Join between the first and second sequences. + |
| FullGroupJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTKey, IEnumerableTFirst, IEnumerableTSecond, TResult) | + Performs a full group-join between two sequences. + |
| FullGroupJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTKey, IEnumerableTFirst, IEnumerableTSecond, TResult, IEqualityComparerTKey) | + Performs a full group-join between two sequences. + |
| GroupAdjacentTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Groups the adjacent elements of a sequence according to a + specified key selector function. + |
| GroupAdjacentTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + Groups the adjacent elements of a sequence according to a + specified key selector function and compares the keys by using a + specified comparer. + |
| GroupAdjacentTSource, TKey, TElement(IEnumerableTSource, FuncTSource, TKey, FuncTSource, TElement) | + Groups the adjacent elements of a sequence according to a + specified key selector function and projects the elements for + each group by using a specified function. + |
| GroupAdjacentTSource, TKey, TResult(IEnumerableTSource, FuncTSource, TKey, FuncTKey, IEnumerableTSource, TResult) | + Groups the adjacent elements of a sequence according to a + specified key selector function. The keys are compared by using + a comparer and each group's elements are projected by using a + specified function. + |
| GroupAdjacentTSource, TKey, TElement(IEnumerableTSource, FuncTSource, TKey, FuncTSource, TElement, IEqualityComparerTKey) | + Groups the adjacent elements of a sequence according to a + specified key selector function. The keys are compared by using + a comparer and each group's elements are projected by using a + specified function. + |
| GroupAdjacentTSource, TKey, TResult(IEnumerableTSource, FuncTSource, TKey, FuncTKey, IEnumerableTSource, TResult, IEqualityComparerTKey) | + Groups the adjacent elements of a sequence according to a + specified key selector function. The keys are compared by using + a comparer and each group's elements are projected by using a + specified function. + |
| IndexByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + 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. + |
| IndexByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + 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. + |
| IndexTSource(IEnumerableTSource) | + Returns a sequence of KeyValuePairTKey, TValue + where the key is the zero-based index of the value in the source + sequence. + |
| IndexTSource(IEnumerableTSource, Int32) | + Returns a sequence of KeyValuePairTKey, TValue + where the key is the index of the value in the source sequence. + An additional parameter specifies the starting index. + |
| InsertT | + Inserts the elements of a sequence into another sequence at a + specified index. + |
| InterleaveT | + Interleaves the elements of two or more sequences into a single sequence, skipping + sequences as they are consumed. + |
| LagTSource, TResult(IEnumerableTSource, Int32, FuncTSource, TSource, TResult) | + Produces a projection of a sequence by evaluating pairs of elements separated by a + negative offset. + |
| LagTSource, TResult(IEnumerableTSource, Int32, TSource, FuncTSource, TSource, TResult) | + Produces a projection of a sequence by evaluating pairs of elements separated by a + negative offset. + |
| LastOrDefaultT | + Returns the last element of a sequence, or a default value if the + sequence contains no elements. + |
| LeadTSource, TResult(IEnumerableTSource, Int32, FuncTSource, TSource, TResult) | + Produces a projection of a sequence by evaluating pairs of elements separated by a + positive offset. + |
| LeadTSource, TResult(IEnumerableTSource, Int32, TSource, FuncTSource, TSource, TResult) | + Produces a projection of a sequence by evaluating pairs of elements separated by a + positive offset. + |
| MaxByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Returns the maximal elements of the given sequence, based on + the given projection. + |
| MaxByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) | + Returns the maximal elements of the given sequence, based on + the given projection and the specified comparer for projected values. + |
| MinByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Returns the minimal elements of the given sequence, based on + the given projection. + |
| MinByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) | + Returns the minimal elements of the given sequence, based on + the given projection and the specified comparer for projected values. + |
| MoveT | + Returns a sequence with a range of elements in the source sequence + moved to a new offset. + |
| OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection) | + Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key + |
| OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection) | + Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key + |
| OrderedMergeT(IEnumerableT, IEnumerableT) | + Merges two ordered sequences into one. Where the elements equal + in both sequences, the element from the first sequence is + returned in the resulting sequence. + |
| OrderedMergeT(IEnumerableT, IEnumerableT, IComparerT) | + Merges two ordered sequences into one with an additional + parameter specifying how to compare the elements of the + sequences. Where the elements equal in both sequences, the + element from the first sequence is returned in the resulting + sequence. + |
| OrderedMergeT, TKey(IEnumerableT, IEnumerableT, FuncT, TKey) | + Merges two ordered sequences into one with an additional + parameter specifying the element key by which the sequences are + ordered. Where the keys equal in both sequences, the + element from the first sequence is returned in the resulting + sequence. + |
| OrderedMergeT, TKey, TResult(IEnumerableT, IEnumerableT, FuncT, TKey, FuncT, TResult, FuncT, TResult, FuncT, T, TResult) | + Merges two ordered sequences into one. Additional parameters + specify the element key by which the sequences are ordered, + the result when element is found in first sequence but not in + the second, the result when element is found in second sequence + but not in the first and the result when elements are found in + both sequences. + |
| OrderedMergeT, TKey, TResult(IEnumerableT, IEnumerableT, FuncT, TKey, FuncT, TResult, FuncT, TResult, FuncT, T, TResult, IComparerTKey) | + Merges two ordered sequences into one. Additional parameters + specify the element key by which the sequences are ordered, + the result when element is found in first sequence but not in + the second, the result when element is found in second sequence + but not in the first, the result when elements are found in + both sequences and a method for comparing keys. + |
| OrderedMergeTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult) | + Merges two heterogeneous sequences ordered by a common key type + into a homogeneous one. Additional parameters specify the + element key by which the sequences are ordered, the result when + element is found in first sequence but not in the second and + the result when element is found in second sequence but not in + the first, the result when elements are found in both sequences. + |
| OrderedMergeTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult, IComparerTKey) | + Merges two heterogeneous sequences ordered by a common key type + into a homogeneous one. Additional parameters specify the + element key by which the sequences are ordered, the result when + element is found in first sequence but not in the second, + the result when element is found in second sequence but not in + the first, the result when elements are found in both sequences + and a method for comparing keys. + |
| PadTSource(IEnumerableTSource, Int32) | + Pads a sequence with default values if it is narrower (shorter + in length) than a given width. + |
| PadTSource(IEnumerableTSource, Int32, TSource) | + Pads a sequence with a given filler value if it is narrower (shorter + in length) than a given width. + |
| PadTSource(IEnumerableTSource, Int32, FuncInt32, TSource) | + Pads a sequence with a dynamic filler value if it is narrower (shorter + in length) than a given width. + |
| PadStartTSource(IEnumerableTSource, Int32) | + Pads a sequence with default values in the beginning if it is narrower (shorter + in length) than a given width. + |
| PadStartTSource(IEnumerableTSource, Int32, TSource) | + Pads a sequence with a given filler value in the beginning if it is narrower (shorter + in length) than a given width. + An additional parameter specifies the value to use for padding. + |
| PadStartTSource(IEnumerableTSource, Int32, FuncInt32, TSource) | + Pads a sequence with a dynamic filler value in the beginning if it is narrower (shorter + in length) than a given width. + An additional parameter specifies the function to calculate padding. + |
| PairwiseTSource, TResult | + Returns a sequence resulting from applying a function to each + element in the source sequence and its + predecessor, with the exception of the first element which is + only returned as the predecessor of the second element. + |
| PermutationsT | + Generates a sequence of lists that represent the permutations of the original sequence. + |
| PipeT | + Executes the given action on each element in the source sequence + and yields it. + |
| PreScanTSource | + Performs a pre-scan (exclusive prefix sum) on a sequence of elements. + |
| RandomSubsetT(IEnumerableT, Int32) | + Returns a sequence of a specified size of random elements from the + original sequence. + |
| RandomSubsetT(IEnumerableT, Int32, Random) | + Returns a sequence of a specified size of random elements from the + original sequence. An additional parameter specifies a random + generator to be used for the random selection algorithm. + |
| RankByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Ranks each item in the sequence in descending ordering by a specified key using a default comparer + |
| RankByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) | + Ranks each item in a sequence using a specified key and a caller-supplied comparer + |
| RankTSource(IEnumerableTSource) | + Ranks each item in the sequence in descending ordering using a default comparer. + |
| RankTSource(IEnumerableTSource, IComparerTSource) | + Rank each item in the sequence using a caller-supplied comparer. + |
| RepeatT(IEnumerableT) | + Repeats the sequence forever. + |
| RepeatT(IEnumerableT, Int32) | + Repeats the sequence the specified number of times. + |
| RunLengthEncodeT(IEnumerableT) | + Run-length encodes a sequence by converting consecutive instances of the same element into + a KeyValuePair{T,int} representing the item and its occurrence count. + |
| RunLengthEncodeT(IEnumerableT, IEqualityComparerT) | + Run-length encodes a sequence by converting consecutive instances of the same element into + a KeyValuePair{T,int} representing the item and its occurrence count. This overload + uses a custom equality comparer to identify equivalent items. + |
| ScanByTSource, TKey, TState(IEnumerableTSource, FuncTSource, TKey, FuncTKey, TState, FuncTState, TKey, TSource, TState) | + Applies an accumulator function over sequence element keys, + returning the keys along with intermediate accumulator states. + |
| ScanByTSource, TKey, TState(IEnumerableTSource, FuncTSource, TKey, FuncTKey, TState, FuncTState, TKey, TSource, TState, IEqualityComparerTKey) | + 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. + |
| ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) | + Performs a scan (inclusive prefix sum) on a sequence of elements. + |
| ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) | + Like AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) except returns + the sequence of intermediate results as well as the final one. + An additional parameter specifies a seed. + |
| ScanRightTSource(IEnumerableTSource, FuncTSource, TSource, TSource) | + Performs a right-associative scan (inclusive prefix) on a sequence of elements. + This operator is the right-associative version of the + ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator. + |
| ScanRightTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate) | + Performs a right-associative scan (inclusive prefix) on a sequence of elements. + The specified seed value is used as the initial accumulator value. + This operator is the right-associative version of the + ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) LINQ operator. + |
| SegmentT(IEnumerableT, FuncT, T, Int32, Boolean) | + Divides a sequence into multiple sequences by using a segment detector based on the original sequence + |
| SegmentT(IEnumerableT, FuncT, Boolean) | + Divides a sequence into multiple sequences by using a segment detector based on the original sequence + |
| SegmentT(IEnumerableT, FuncT, Int32, Boolean) | + Divides a sequence into multiple sequences by using a segment detector based on the original sequence + |
| ShuffleT(IEnumerableT) | + Returns a sequence of elements in random order from the original + sequence. + |
| ShuffleT(IEnumerableT, Random) | + 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. + |
| SingleT | + Returns the only element of a sequence, and throws an exception if + there is not exactly one element in the sequence. + |
| SingleOrDefaultT | + 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. + |
| SkipLastT | + Bypasses a specified number of elements at the end of the sequence. + |
| SkipUntilTSource | + Skips items from the input sequence until the given predicate returns true + when applied to the current source item; that item will be the last skipped. + |
| SliceT | + Extracts a contiguous count of elements from a sequence at a particular zero-based + starting index. + |
| SortedMergeTSource(IEnumerableTSource, OrderByDirection, IEnumerableTSource) | + Merges two or more sequences that are in a common order (either ascending or descending) + into a single sequence that preserves that order. + |
| SortedMergeTSource(IEnumerableTSource, OrderByDirection, IComparerTSource, IEnumerableTSource) | + Merges two or more sequences that are in a common order (either ascending or descending) + into a single sequence that preserves that order. + |
| SplitTSource(IEnumerableTSource, TSource) | + Splits the source sequence by a separator. + |
| SplitTSource(IEnumerableTSource, FuncTSource, Boolean) | + Splits the source sequence by separator elements identified by a + function. + |
| SplitTSource(IEnumerableTSource, TSource, IEqualityComparerTSource) | + Splits the source sequence by a separator and then transforms the + splits into results. + |
| SplitTSource(IEnumerableTSource, TSource, Int32) | + Splits the source sequence by a separator given a maximum count of splits. + |
| SplitTSource(IEnumerableTSource, FuncTSource, Boolean, Int32) | + Splits the source sequence by separator elements identified by a + function, given a maximum count of splits. + |
| SplitTSource(IEnumerableTSource, TSource, IEqualityComparerTSource, Int32) | + Splits the source sequence by a separator, given a maximum count + of splits. A parameter specifies how the separator is compared + for equality. + |
| SplitTSource, TResult(IEnumerableTSource, TSource, FuncIEnumerableTSource, TResult) | + Splits the source sequence by a separator and then transforms + the splits into results. + |
| SplitTSource, TResult(IEnumerableTSource, FuncTSource, Boolean, FuncIEnumerableTSource, TResult) | + Splits the source sequence by separator elements identified by + a function and then transforms the splits into results. + |
| SplitTSource, TResult(IEnumerableTSource, TSource, IEqualityComparerTSource, FuncIEnumerableTSource, TResult) | + Splits the source sequence by a separator and then transforms the + splits into results. A parameter specifies how the separator is + compared for equality. + |
| SplitTSource, TResult(IEnumerableTSource, TSource, Int32, FuncIEnumerableTSource, TResult) | + Splits the source sequence by a separator, given a maximum count + of splits, and then transforms the splits into results. + |
| SplitTSource, TResult(IEnumerableTSource, FuncTSource, Boolean, Int32, FuncIEnumerableTSource, TResult) | + Splits the source sequence by separator elements identified by + a function, given a maximum count of splits, and then transforms + the splits into results. + |
| SplitTSource, TResult(IEnumerableTSource, TSource, IEqualityComparerTSource, Int32, FuncIEnumerableTSource, TResult) | + Splits the source sequence by a separator, given a maximum count + of splits, and then transforms the splits into results. A + parameter specifies how the separator is compared for equality. + |
| StartsWithT(IEnumerableT, IEnumerableT) | + Determines whether the beginning of the first sequence is + equivalent to the second sequence, using the default equality + comparer. + |
| StartsWithT(IEnumerableT, IEnumerableT, IEqualityComparerT) | + Determines whether the beginning of the first sequence is + equivalent to the second sequence, using the specified element + equality comparer. + |
| SubsetsT(IEnumerableT) | + Returns a sequence of IListT representing all of the subsets of any size + that are part of the original sequence. In mathematics, it is equivalent to the + power set of a set. + |
| SubsetsT(IEnumerableT, Int32) | + Returns a sequence of IListT representing all subsets of a given size + that are part of the original sequence. In mathematics, it is equivalent to the + combinations or k-subsets of a set. + |
| TagFirstLastTSource, TResult | + Returns a sequence resulting from applying a function to each + element in the source sequence with additional parameters + indicating whether the element is the first and/or last of the + sequence. + |
| TakeEveryTSource | + Returns every N-th element of a sequence. + |
| TakeLastTSource | + Returns a specified number of contiguous elements from the end of + a sequence. + |
| TakeUntilTSource | + Returns items from the input sequence until the given predicate returns true + when applied to the current source item; that item will be the last returned. + |
| ThenByT, TKey(IOrderedEnumerableT, FuncT, TKey, OrderByDirection) | + Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key + |
| ThenByT, TKey(IOrderedEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection) | + Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key + |
| ToArrayByIndexT(IEnumerableT, FuncT, Int32) | + Creates an array from an IEnumerableT where a + function is used to determine the index at which an element will + be placed in the array. + |
| ToArrayByIndexT(IEnumerableT, Int32, FuncT, Int32) | + Creates an array of user-specified length from an + IEnumerableT where a function is used to determine + the index at which an element will be placed in the array. + |
| ToArrayByIndexT, TResult(IEnumerableT, FuncT, Int32, FuncT, TResult) | + Creates an array from an IEnumerableT where a + function is used to determine the index at which an element will + be placed in the array. The elements are projected into the array + via an additional function. + |
| ToArrayByIndexT, TResult(IEnumerableT, FuncT, Int32, FuncT, Int32, TResult) | + Creates an array from an IEnumerableT where a + function is used to determine the index at which an element will + be placed in the array. The elements are projected into the array + via an additional function. + |
| ToArrayByIndexT, TResult(IEnumerableT, Int32, FuncT, Int32, FuncT, TResult) | + Creates an array of user-specified length from an + IEnumerableT where a function is used to determine + the index at which an element will be placed in the array. The + elements are projected into the array via an additional function. + |
| ToArrayByIndexT, TResult(IEnumerableT, Int32, FuncT, Int32, FuncT, Int32, TResult) | + Creates an array of user-specified length from an + IEnumerableT where a function is used to determine + the index at which an element will be placed in the array. The + elements are projected into the array via an additional function. + |
| ToDataTableT(IEnumerableT) | + Converts a sequence to a DataTable object. + |
| ToDataTableT(IEnumerableT, ExpressionFuncT, Object) | + Appends elements in the sequence as rows of a given DataTable + object with a set of lambda expressions specifying which members (property + or field) of each element in the sequence will supply the column values. + |
| ToDataTableT, TTable(IEnumerableT, TTable) | + Appends elements in the sequence as rows of a given DataTable object. + |
| ToDataTableT, TTable(IEnumerableT, TTable, ExpressionFuncT, Object) | + Appends elements in the sequence as rows of a given DataTable + object with a set of lambda expressions specifying which members (property + or field) of each element in the sequence will supply the column values. + |
| ToDelimitedString(IEnumerableBoolean, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableByte, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableChar, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableDecimal, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableDouble, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableInt16, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableInt32, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableInt64, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableSByte, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableSingle, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableString, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableUInt16, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableUInt32, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableUInt64, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedStringTSource(IEnumerableTSource, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDictionaryTKey, TValue(IEnumerableKeyValuePairTKey, TValue) | + Creates a DictionaryTKey, TValue from a sequence of + KeyValuePairTKey, TValue elements. + |
| ToDictionaryTKey, TValue(IEnumerableValueTupleTKey, TValue) | + Creates a DictionaryTKey, TValue from a sequence of + tuples of 2 where the first item is the key and the second the + value. + |
| ToDictionaryTKey, TValue(IEnumerableKeyValuePairTKey, TValue, IEqualityComparerTKey) | + Creates a DictionaryTKey, TValue from a sequence of + KeyValuePairTKey, TValue elements. An additional + parameter specifies a comparer for keys. + |
| ToDictionaryTKey, TValue(IEnumerableValueTupleTKey, TValue, IEqualityComparerTKey) | + Creates a DictionaryTKey, TValue from a sequence of + tuples of 2 where the first item is the key and the second the + value. An additional parameter specifies a comparer for keys. + |
| ToHashSetTSource(IEnumerableTSource) | + Returns a HashSetT of the source items using the default equality + comparer for the type. + |
| ToHashSetTSource(IEnumerableTSource, IEqualityComparerTSource) | + Returns a HashSetT of the source items using the specified equality + comparer for the type. + |
| ToLookupTKey, TValue(IEnumerableKeyValuePairTKey, TValue) | + Creates a ILookupTKey, TElement from a sequence of + KeyValuePairTKey, TValue elements. + |
| ToLookupTKey, TValue(IEnumerableValueTupleTKey, TValue) | + Creates a LookupTKey, TElement from a sequence of + tuples of 2 where the first item is the key and the second the + value. + |
| ToLookupTKey, TValue(IEnumerableKeyValuePairTKey, TValue, IEqualityComparerTKey) | + Creates a ILookupTKey, TElement from a sequence of + KeyValuePairTKey, TValue elements. An additional + parameter specifies a comparer for keys. + |
| ToLookupTKey, TValue(IEnumerableValueTupleTKey, TValue, IEqualityComparerTKey) | + Creates a LookupTKey, TElement from a sequence of + tuples of 2 where the first item is the key and the second the + value. An additional parameter specifies a comparer for keys. + |
| TraceTSource(IEnumerableTSource) | + Traces the elements of a source sequence for diagnostics. + |
| TraceTSource(IEnumerableTSource, FuncTSource, String) | + Traces the elements of a source sequence for diagnostics using + a custom formatter. + |
| TraceTSource(IEnumerableTSource, String) | + Traces the elements of a source sequence for diagnostics using + custom formatting. + |
| TransposeT | + Transposes a sequence of rows into a sequence of columns. + |
| WindowTSource | + Processes a sequence into a series of sub-sequences representing a windowed subset of + the original. + |
| WindowLeftTSource | + Creates a left-aligned sliding window of a given size over the + source sequence. + |
| WindowRightTSource | + Creates a right-aligned sliding window over the source sequence + of a given size. + |
| ZipLongestTFirst, TSecond, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. 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. + |
| ZipLongestT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. 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. + |
| ZipLongestT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. 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. + |
| ZipShortestTFirst, TSecond, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. The resulting sequence + is as short as the shortest input sequence. + |
| ZipShortestT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. The resulting sequence + is as short as the shortest input sequence. + |
| ZipShortestT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. The resulting sequence + is as short as the shortest input sequence. + |
| GetEnumerator | Returns an enumerator that iterates through the collection. (Inherited from IEnumerableT) |
| Take | + Returns a specified number of contiguous elements from the start of + the sequence. + |
| TakeLast | + Returns a specified number of contiguous elements at the end of the + sequence. + |
| AggregateT, TResult1, TResult2, TResult |
+ Applies two accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TResult |
+ Applies two accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TResult |
+ Applies two accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult |
+ Applies three accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TResult |
+ Applies three accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TResult |
+ Applies three accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult |
+ Applies four accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult |
+ Applies four accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult |
+ Applies four accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult |
+ Applies five accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult |
+ Applies five accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult |
+ Applies five accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult |
+ Applies six accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult |
+ Applies six accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult |
+ Applies six accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult |
+ Applies seven accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult |
+ Applies seven accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult |
+ Applies seven accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult8, TResult |
+ Applies eight accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult |
+ Applies eight accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult |
+ Applies eight accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateRightT |
+ Applies a right-associative accumulator function over a sequence.
+ This operator is the right-associative version of the
+ AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ (Defined by MoreEnumerable) |
| AggregateRightT |
+ Applies a right-associative accumulator function over a sequence.
+ This operator is the right-associative version of the
+ AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ (Defined by AggregateRightExtension) |
| AggregateRightT, TAccumulate |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate) LINQ operator.
+ (Defined by MoreEnumerable) |
| AggregateRightT, TAccumulate |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate) LINQ operator.
+ (Defined by AggregateRightExtension) |
| AggregateRightT, TAccumulate, TResult |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value,
+ and the specified function is used to select the result value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate, FuncTAccumulate, TResult) LINQ operator.
+ (Defined by MoreEnumerable) |
| AggregateRightT, TAccumulate, TResult |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value,
+ and the specified function is used to select the result value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate, FuncTAccumulate, TResult) LINQ operator.
+ (Defined by AggregateRightExtension) |
| AppendT |
+ Returns a sequence consisting of the head elements and the given tail element.
+ (Defined by MoreEnumerable) |
| AppendT |
+ Returns a sequence consisting of the head elements and the given tail element.
+ (Defined by AppendExtension) |
| AssertT |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ (Defined by MoreEnumerable) |
| AssertT |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ (Defined by AssertExtension) |
| AssertT |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ (Defined by MoreEnumerable) |
| AssertT |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ (Defined by AssertExtension) |
| AssertCountT |
+ Asserts that a source sequence contains a given count of elements.
+ (Defined by MoreEnumerable) |
| AssertCountT |
+ Asserts that a source sequence contains a given count of elements.
+ (Defined by AssertCountExtension) |
| AssertCountT |
+ Asserts that a source sequence contains a given count of elements.
+ A parameter specifies the exception to be thrown.
+ (Defined by MoreEnumerable) |
| AssertCountT |
+ Asserts that a source sequence contains a given count of elements.
+ A parameter specifies the exception to be thrown.
+ (Defined by AssertCountExtension) |
| AtLeastT |
+ Determines whether or not the number of elements in the sequence is greater than
+ or equal to the given integer.
+ (Defined by MoreEnumerable) |
| AtLeastT |
+ Determines whether or not the number of elements in the sequence is greater than
+ or equal to the given integer.
+ (Defined by AtLeastExtension) |
| AtMostT |
+ Determines whether or not the number of elements in the sequence is lesser than
+ or equal to the given integer.
+ (Defined by MoreEnumerable) |
| AtMostT |
+ Determines whether or not the number of elements in the sequence is lesser than
+ or equal to the given integer.
+ (Defined by AtMostExtension) |
| AwaitT, TResult |
+ Creates a sequence query that streams the result of each task in
+ the source sequence as it completes asynchronously. A
+ CancellationToken is passed for each asynchronous
+ evaluation to abort any asynchronous operations in flight if the
+ sequence is not fully iterated.
+ (Defined by ExperimentalEnumerable) |
| AwaitCompletionT, TTaskResult, TResult |
+ 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.
+ (Defined by ExperimentalEnumerable) |
| BacksertT |
+ 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.
+ (Defined by MoreEnumerable) |
| BacksertT |
+ 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.
+ (Defined by BacksertExtension) |
| BatchT |
+ Batches the source sequence into sized buckets.
+ (Defined by MoreEnumerable) |
| BatchT |
+ Batches the source sequence into sized buckets.
+ (Defined by BatchExtension) |
| BatchT, TResult |
+ Batches the source sequence into sized buckets and applies a projection to each bucket.
+ (Defined by MoreEnumerable) |
| BatchT, TResult |
+ Batches the source sequence into sized buckets and applies a projection to each bucket.
+ (Defined by BatchExtension) |
| BatchT, TResult |
+ Batches the source sequence into sized buckets using an array pool
+ to rent arrays to back each bucket and returns a sequence of
+ elements projected from each bucket.
+ (Defined by ExperimentalEnumerable) |
| BatchT, TBucket, TResult |
+ Batches the source sequence into sized buckets using an array pool
+ to rent arrays to back each bucket and returns a sequence of
+ elements projected from each bucket.
+ (Defined by ExperimentalEnumerable) |
| CartesianT, T2, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, T5, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, T5, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, T5, T6, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, T5, T6, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, T5, T6, T7, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, T5, T6, T7, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, T5, T6, T7, T8, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, T5, T6, T7, T8, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| ChooseT, TResult |
+ 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 true
+ as its first element and result as the second.
+ (Defined by MoreEnumerable) |
| ChooseT, TResult |
+ 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 true
+ as its first element and result as the second.
+ (Defined by ChooseExtension) |
| CompareCountT, TSecond |
+ Compares two sequences and returns an integer that indicates whether the first sequence
+ has fewer, the same or more elements than the second sequence.
+ (Defined by MoreEnumerable) |
| CompareCountT, TSecond |
+ Compares two sequences and returns an integer that indicates whether the first sequence
+ has fewer, the same or more elements than the second sequence.
+ (Defined by CompareCountExtension) |
| ConcatT |
+ Returns a sequence consisting of the head elements and the given tail element.
+ (Defined by MoreEnumerable) |
| ConsumeT |
+ Completely consumes the given sequence. This method uses immediate execution,
+ and doesn't store any data during execution.
+ (Defined by MoreEnumerable) |
| ConsumeT |
+ Completely consumes the given sequence. This method uses immediate execution,
+ and doesn't store any data during execution.
+ (Defined by ConsumeExtension) |
| CountBetweenT |
+ Determines whether or not the number of elements in the sequence is between
+ an inclusive range of minimum and maximum integers.
+ (Defined by MoreEnumerable) |
| CountBetweenT |
+ Determines whether or not the number of elements in the sequence is between
+ an inclusive range of minimum and maximum integers.
+ (Defined by CountBetweenExtension) |
| CountByT, TKey |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ (Defined by MoreEnumerable) |
| CountByT, TKey |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ (Defined by CountByExtension) |
| CountByT, TKey |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ An additional argument specifies a comparer to use for testing equivalence of keys.
+ (Defined by MoreEnumerable) |
| CountByT, TKey |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ An additional argument specifies a comparer to use for testing equivalence of keys.
+ (Defined by CountByExtension) |
| CountDownT, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CountDownT, TResult |
+ 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.
+ (Defined by CountDownExtension) |
| DistinctByT, TKey |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the default equality comparer for the projected type.
+ (Defined by MoreEnumerable) |
| DistinctByT, TKey |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the default equality comparer for the projected type.
+ (Defined by DistinctByExtension) |
| DistinctByT, TKey |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the specified comparer for the projected type.
+ (Defined by MoreEnumerable) |
| DistinctByT, TKey |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the specified comparer for the projected type.
+ (Defined by DistinctByExtension) |
| EndsWithT |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the default equality comparer.
+ (Defined by MoreEnumerable) |
| EndsWithT |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the default equality comparer.
+ (Defined by EndsWithExtension) |
| EndsWithT |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the specified element equality comparer.
+ (Defined by MoreEnumerable) |
| EndsWithT |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the specified element equality comparer.
+ (Defined by EndsWithExtension) |
| EquiZipT, TSecond, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| EquiZipT, TSecond, TResult |
+ 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.
+ (Defined by EquiZipExtension) |
| EquiZipT, T2, T3, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| EquiZipT, T2, T3, TResult |
+ 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.
+ (Defined by EquiZipExtension) |
| EquiZipT, T2, T3, T4, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| EquiZipT, T2, T3, T4, TResult |
+ 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.
+ (Defined by EquiZipExtension) |
| ExactlyT |
+ Determines whether or not the number of elements in the sequence is equals to the given integer.
+ (Defined by MoreEnumerable) |
| ExactlyT |
+ Determines whether or not the number of elements in the sequence is equals to the given integer.
+ (Defined by ExactlyExtension) |
| ExceptByT, TKey |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ (Defined by MoreEnumerable) |
| ExceptByT, TKey |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ (Defined by ExceptByExtension) |
| ExceptByT, TKey |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ (Defined by MoreEnumerable) |
| ExceptByT, TKey |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ (Defined by ExceptByExtension) |
| ExcludeT |
+ Excludes a contiguous number of elements from a sequence starting
+ at a given index.
+ (Defined by MoreEnumerable) |
| ExcludeT |
+ Excludes a contiguous number of elements from a sequence starting
+ at a given index.
+ (Defined by ExcludeExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of the specified sequence or the specified
+ value in a singleton collection if the sequence is empty.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence from an array of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of the specified sequence or the specified
+ value in a singleton collection if the sequence is empty.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence from an array of values.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by FallbackIfEmptyExtension) |
| FillBackwardT |
+ Returns a sequence with each null reference or value in the source
+ replaced with the following non-null reference or value in
+ that sequence.
+ (Defined by MoreEnumerable) |
| FillBackwardT |
+ Returns a sequence with each null reference or value in the source
+ replaced with the following non-null reference or value in
+ that sequence.
+ (Defined by FillBackwardExtension) |
| FillBackwardT |
+ 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.
+ (Defined by MoreEnumerable) |
| FillBackwardT |
+ 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.
+ (Defined by FillBackwardExtension) |
| FillBackwardT |
+ Returns a sequence with each missing element in the source replaced
+ with the following non-missing element in that sequence. Additional
+ parameters specify two functions, one used to determine if an
+ element is considered missing or not and another to provide the
+ replacement for the missing element.
+ (Defined by MoreEnumerable) |
| FillBackwardT |
+ Returns a sequence with each missing element in the source replaced
+ with the following non-missing element in that sequence. Additional
+ parameters specify two functions, one used to determine if an
+ element is considered missing or not and another to provide the
+ replacement for the missing element.
+ (Defined by FillBackwardExtension) |
| FillForwardT |
+ 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.
+ (Defined by MoreEnumerable) |
| FillForwardT |
+ 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.
+ (Defined by FillForwardExtension) |
| FillForwardT |
+ 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.
+ (Defined by MoreEnumerable) |
| FillForwardT |
+ 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.
+ (Defined by FillForwardExtension) |
| FillForwardT |
+ 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 specify two functions, one used to
+ determine if an element is considered missing or not and another
+ to provide the replacement for the missing element.
+ (Defined by MoreEnumerable) |
| FillForwardT |
+ 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 specify two functions, one used to
+ determine if an element is considered missing or not and another
+ to provide the replacement for the missing element.
+ (Defined by FillForwardExtension) |
| FirstT |
+ Returns the first element of a sequence.
+ (Defined by MoreEnumerable) |
| FirstT |
+ Returns the first element of a sequence.
+ (Defined by FirstExtension) |
| FirstOrDefaultT |
+ Returns the first element of a sequence, or a default value if the
+ sequence contains no elements.
+ (Defined by MoreEnumerable) |
| FirstOrDefaultT |
+ Returns the first element of a sequence, or a default value if the
+ sequence contains no elements.
+ (Defined by FirstOrDefaultExtension) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences.
+ (Defined by MoreEnumerable) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences.
+ (Defined by FlattenExtension) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a predicate function used to
+ determine whether a nested IEnumerable should be
+ flattened or not.
+ (Defined by MoreEnumerable) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a function that projects an inner
+ sequence via a property of an object.
+ (Defined by MoreEnumerable) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a predicate function used to
+ determine whether a nested IEnumerable should be
+ flattened or not.
+ (Defined by FlattenExtension) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a function that projects an inner
+ sequence via a property of an object.
+ (Defined by FlattenExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 9 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 9 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 10 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 10 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 11 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 11 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 12 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 12 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 13 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 13 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 14 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 14 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 15 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 15 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 16 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 16 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 1 element.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 1 element.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 2 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 2 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 3 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 3 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 4 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 4 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 5 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 5 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 6 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 6 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 7 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 7 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 8 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 8 elements.
+ (Defined by FoldExtension) |
| ForEachT |
+ Immediately executes the given action on each element in the source sequence.
+ (Defined by MoreEnumerable) |
| ForEachT |
+ Immediately executes the given action on each element in the source sequence.
+ (Defined by ForEachExtension) |
| ForEachT |
+ Immediately executes the given action on each element in the source sequence.
+ Each element's index is used in the logic of the action.
+ (Defined by MoreEnumerable) |
| ForEachT |
+ Immediately executes the given action on each element in the source sequence.
+ Each element's index is used in the logic of the action.
+ (Defined by ForEachExtension) |
| FullGroupJoinT, TSecond, TKey |
+ Performs a Full Group Join between the first and second sequences.
+ (Defined by MoreEnumerable) |
| FullGroupJoinT, TSecond, TKey |
+ Performs a Full Group Join between the first and second sequences.
+ (Defined by FullGroupJoinExtension) |
| FullGroupJoinT, TSecond, TKey |
+ Performs a Full Group Join between the first and second sequences.
+ (Defined by MoreEnumerable) |
| FullGroupJoinT, TSecond, TKey |
+ Performs a Full Group Join between the first and second sequences.
+ (Defined by FullGroupJoinExtension) |
| FullGroupJoinT, TSecond, TKey, TResult |
+ Performs a full group-join between two sequences.
+ (Defined by MoreEnumerable) |
| FullGroupJoinT, TSecond, TKey, TResult |
+ Performs a full group-join between two sequences.
+ (Defined by FullGroupJoinExtension) |
| FullGroupJoinT, TSecond, TKey, TResult |
+ Performs a full group-join between two sequences.
+ (Defined by MoreEnumerable) |
| FullGroupJoinT, TSecond, TKey, TResult |
+ Performs a full group-join between two sequences.
+ (Defined by FullGroupJoinExtension) |
| FullJoinT, TKey, TResult |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| FullJoinT, TKey, TResult |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by FullJoinExtension) |
| FullJoinT, TKey, TResult |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| FullJoinT, TKey, TResult |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by FullJoinExtension) |
| FullJoinT, TSecond, TKey, TResult |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| FullJoinT, TSecond, TKey, TResult |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by FullJoinExtension) |
| FullJoinT, TSecond, TKey, TResult |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| FullJoinT, TSecond, TKey, TResult |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by FullJoinExtension) |
| GroupAdjacentT, TKey |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and compares the keys by using a
+ specified comparer.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and compares the keys by using a
+ specified comparer.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey, TElement |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and projects the elements for
+ each group by using a specified function.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey, TResult |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey, TElement |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and projects the elements for
+ each group by using a specified function.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey, TResult |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey, TElement |
+ 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.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey, TResult |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey, TElement |
+ 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.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey, TResult |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ (Defined by GroupAdjacentExtension) |
| IndexT |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the zero-based index of the value in the source
+ sequence.
+ (Defined by MoreEnumerable) |
| IndexT |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the zero-based index of the value in the source
+ sequence.
+ (Defined by IndexExtension) |
| IndexT |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the index of the value in the source sequence.
+ An additional parameter specifies the starting index.
+ (Defined by MoreEnumerable) |
| IndexT |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the index of the value in the source sequence.
+ An additional parameter specifies the starting index.
+ (Defined by IndexExtension) |
| IndexByT, TKey |
+ 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.
+ (Defined by MoreEnumerable) |
| IndexByT, TKey |
+ 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.
+ (Defined by IndexByExtension) |
| IndexByT, TKey |
+ 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.
+ (Defined by MoreEnumerable) |
| IndexByT, TKey |
+ 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.
+ (Defined by IndexByExtension) |
| InsertT |
+ Inserts the elements of a sequence into another sequence at a
+ specified index.
+ (Defined by MoreEnumerable) |
| InsertT |
+ Inserts the elements of a sequence into another sequence at a
+ specified index.
+ (Defined by InsertExtension) |
| InterleaveT |
+ Interleaves the elements of two or more sequences into a single sequence, skipping
+ sequences as they are consumed.
+ (Defined by MoreEnumerable) |
| InterleaveT |
+ Interleaves the elements of two or more sequences into a single sequence, skipping
+ sequences as they are consumed.
+ (Defined by InterleaveExtension) |
| LagT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ negative offset.
+ (Defined by MoreEnumerable) |
| LagT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ negative offset.
+ (Defined by LagExtension) |
| LagT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ negative offset.
+ (Defined by MoreEnumerable) |
| LagT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ negative offset.
+ (Defined by LagExtension) |
| LastT |
+ Returns the last element of a sequence.
+ (Defined by MoreEnumerable) |
| LastT |
+ Returns the last element of a sequence.
+ (Defined by LastExtension) |
| LastOrDefaultT |
+ Returns the last element of a sequence, or a default value if the
+ sequence contains no elements.
+ (Defined by MoreEnumerable) |
| LastOrDefaultT |
+ Returns the last element of a sequence, or a default value if the
+ sequence contains no elements.
+ (Defined by LastOrDefaultExtension) |
| LeadT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ positive offset.
+ (Defined by MoreEnumerable) |
| LeadT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ positive offset.
+ (Defined by LeadExtension) |
| LeadT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ positive offset.
+ (Defined by MoreEnumerable) |
| LeadT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ positive offset.
+ (Defined by LeadExtension) |
| LeftJoinT, TKey, TResult |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| LeftJoinT, TKey, TResult |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by LeftJoinExtension) |
| LeftJoinT, TKey, TResult |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| LeftJoinT, TKey, TResult |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by LeftJoinExtension) |
| LeftJoinT, TSecond, TKey, TResult |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| LeftJoinT, TSecond, TKey, TResult |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by LeftJoinExtension) |
| LeftJoinT, TSecond, TKey, TResult |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| LeftJoinT, TSecond, TKey, TResult |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by LeftJoinExtension) |
| MaxByT, TKey |
+ Returns the maximal elements of the given sequence, based on
+ the given projection.
+ (Defined by MoreEnumerable) |
| MaxByT, TKey |
+ Returns the maximal elements of the given sequence, based on
+ the given projection.
+ (Defined by MaxByExtension) |
| MaxByT, TKey |
+ Returns the maximal elements of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ (Defined by MoreEnumerable) |
| MaxByT, TKey |
+ Returns the maximal elements of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ (Defined by MaxByExtension) |
| MemoizeT |
+ 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.
+ (Defined by ExperimentalEnumerable) |
| MinByT, TKey |
+ Returns the minimal elements of the given sequence, based on
+ the given projection.
+ (Defined by MoreEnumerable) |
| MinByT, TKey |
+ Returns the minimal elements of the given sequence, based on
+ the given projection.
+ (Defined by MinByExtension) |
| MinByT, TKey |
+ Returns the minimal elements of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ (Defined by MoreEnumerable) |
| MinByT, TKey |
+ Returns the minimal elements of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ (Defined by MinByExtension) |
| MoveT |
+ Returns a sequence with a range of elements in the source sequence
+ moved to a new offset.
+ (Defined by MoreEnumerable) |
| MoveT |
+ Returns a sequence with a range of elements in the source sequence
+ moved to a new offset.
+ (Defined by MoveExtension) |
| OrderByT, TKey |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ (Defined by MoreEnumerable) |
| OrderByT, TKey |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ (Defined by OrderByExtension) |
| OrderByT, TKey |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ (Defined by MoreEnumerable) |
| OrderByT, TKey |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ (Defined by OrderByExtension) |
| OrderedMergeT |
+ 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.
+ (Defined by MoreEnumerable) |
| OrderedMergeT |
+ 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.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT |
+ 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.
+ (Defined by MoreEnumerable) |
| OrderedMergeT |
+ 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.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TKey |
+ Merges two ordered sequences into one with an additional
+ parameter specifying the element key by which the sequences are
+ ordered. Where the keys equal in both sequences, the
+ element from the first sequence is returned in the resulting
+ sequence.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TKey |
+ Merges two ordered sequences into one with an additional
+ parameter specifying the element key by which the sequences are
+ ordered. Where the keys equal in both sequences, the
+ element from the first sequence is returned in the resulting
+ sequence.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TKey, TResult |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first and the result when elements are found in
+ both sequences.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TKey, TResult |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first and the result when elements are found in
+ both sequences.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TKey, TResult |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first, the result when elements are found in
+ both sequences and a method for comparing keys.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TKey, TResult |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first, the result when elements are found in
+ both sequences and a method for comparing keys.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TSecond, TKey, TResult |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second and
+ the result when element is found in second sequence but not in
+ the first, the result when elements are found in both sequences.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TSecond, TKey, TResult |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second and
+ the result when element is found in second sequence but not in
+ the first, the result when elements are found in both sequences.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TSecond, TKey, TResult |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second,
+ 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.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TSecond, TKey, TResult |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second,
+ 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.
+ (Defined by OrderedMergeExtension) |
| PadT |
+ Pads a sequence with default values if it is narrower (shorter
+ in length) than a given width.
+ (Defined by MoreEnumerable) |
| PadT |
+ Pads a sequence with default values if it is narrower (shorter
+ in length) than a given width.
+ (Defined by PadExtension) |
| PadT |
+ Pads a sequence with a given filler value if it is narrower (shorter
+ in length) than a given width.
+ (Defined by MoreEnumerable) |
| PadT |
+ Pads a sequence with a dynamic filler value if it is narrower (shorter
+ in length) than a given width.
+ (Defined by MoreEnumerable) |
| PadT |
+ Pads a sequence with a given filler value if it is narrower (shorter
+ in length) than a given width.
+ (Defined by PadExtension) |
| PadT |
+ Pads a sequence with a dynamic filler value if it is narrower (shorter
+ in length) than a given width.
+ (Defined by PadExtension) |
| PadStartT |
+ Pads a sequence with default values in the beginning if it is narrower (shorter
+ in length) than a given width.
+ (Defined by MoreEnumerable) |
| PadStartT |
+ Pads a sequence with default values in the beginning if it is narrower (shorter
+ in length) than a given width.
+ (Defined by PadStartExtension) |
| PadStartT |
+ 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.
+ (Defined by MoreEnumerable) |
| PadStartT |
+ 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.
+ (Defined by MoreEnumerable) |
| PadStartT |
+ 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.
+ (Defined by PadStartExtension) |
| PadStartT |
+ 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.
+ (Defined by PadStartExtension) |
| PairwiseT, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence and its
+ predecessor, with the exception of the first element which is
+ only returned as the predecessor of the second element.
+ (Defined by MoreEnumerable) |
| PairwiseT, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence and its
+ predecessor, with the exception of the first element which is
+ only returned as the predecessor of the second element.
+ (Defined by PairwiseExtension) |
| PartialSortT |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ (Defined by MoreEnumerable) |
| PartialSortT |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ (Defined by PartialSortExtension) |
| PartialSortT |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ An additional parameter specifies the direction of the sort
+ (Defined by MoreEnumerable) |
| PartialSortT |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation. An additional parameter specifies how the
+ elements compare to each other.
+ (Defined by MoreEnumerable) |
| PartialSortT |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ An additional parameter specifies the direction of the sort
+ (Defined by PartialSortExtension) |
| PartialSortT |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation. An additional parameter specifies how the
+ elements compare to each other.
+ (Defined by PartialSortExtension) |
| PartialSortT |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ (Defined by MoreEnumerable) |
| PartialSortT |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ (Defined by PartialSortExtension) |
| PartialSortByT, TKey |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ (Defined by MoreEnumerable) |
| PartialSortByT, TKey |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ (Defined by PartialSortByExtension) |
| PartialSortByT, TKey |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies the direction of the sort
+ (Defined by MoreEnumerable) |
| PartialSortByT, TKey |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies how the keys compare to each other.
+ (Defined by MoreEnumerable) |
| PartialSortByT, TKey |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies the direction of the sort
+ (Defined by PartialSortByExtension) |
| PartialSortByT, TKey |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies how the keys compare to each other.
+ (Defined by PartialSortByExtension) |
| PartialSortByT, TKey |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ (Defined by MoreEnumerable) |
| PartialSortByT, TKey |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ (Defined by PartialSortByExtension) |
| PartitionT |
+ Partitions or splits a sequence in two using a predicate.
+ (Defined by MoreEnumerable) |
| PartitionT |
+ Partitions or splits a sequence in two using a predicate.
+ (Defined by PartitionExtension) |
| PartitionT, TResult |
+ Partitions or splits a sequence in two using a predicate and then
+ projects a result from the two.
+ (Defined by MoreEnumerable) |
| PartitionT, TResult |
+ Partitions or splits a sequence in two using a predicate and then
+ projects a result from the two.
+ (Defined by PartitionExtension) |
| PermutationsT |
+ Generates a sequence of lists that represent the permutations of the original sequence.
+ (Defined by MoreEnumerable) |
| PermutationsT |
+ Generates a sequence of lists that represent the permutations of the original sequence.
+ (Defined by PermutationsExtension) |
| PipeT |
+ Executes the given action on each element in the source sequence
+ and yields it.
+ (Defined by MoreEnumerable) |
| PipeT |
+ Executes the given action on each element in the source sequence
+ and yields it.
+ (Defined by PipeExtension) |
| PrependT |
+ Prepends a single value to a sequence.
+ (Defined by MoreEnumerable) |
| PrependT |
+ Prepends a single value to a sequence.
+ (Defined by PrependExtension) |
| PreScanT |
+ Performs a pre-scan (exclusive prefix sum) on a sequence of elements.
+ (Defined by MoreEnumerable) |
| PreScanT |
+ Performs a pre-scan (exclusive prefix sum) on a sequence of elements.
+ (Defined by PreScanExtension) |
| RandomSubsetT |
+ Returns a sequence of a specified size of random elements from the
+ original sequence.
+ (Defined by MoreEnumerable) |
| RandomSubsetT |
+ Returns a sequence of a specified size of random elements from the
+ original sequence.
+ (Defined by RandomSubsetExtension) |
| RandomSubsetT |
+ 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.
+ (Defined by MoreEnumerable) |
| RandomSubsetT |
+ 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.
+ (Defined by RandomSubsetExtension) |
| RankT |
+ Ranks each item in the sequence in descending ordering using a default comparer.
+ (Defined by MoreEnumerable) |
| RankT |
+ Ranks each item in the sequence in descending ordering using a default comparer.
+ (Defined by RankExtension) |
| RankT |
+ Rank each item in the sequence using a caller-supplied comparer.
+ (Defined by MoreEnumerable) |
| RankT |
+ Rank each item in the sequence using a caller-supplied comparer.
+ (Defined by RankExtension) |
| RankByT, TKey |
+ Ranks each item in the sequence in descending ordering by a specified key using a default comparer
+ (Defined by MoreEnumerable) |
| RankByT, TKey |
+ Ranks each item in the sequence in descending ordering by a specified key using a default comparer
+ (Defined by RankByExtension) |
| RankByT, TKey |
+ Ranks each item in a sequence using a specified key and a caller-supplied comparer
+ (Defined by MoreEnumerable) |
| RankByT, TKey |
+ Ranks each item in a sequence using a specified key and a caller-supplied comparer
+ (Defined by RankByExtension) |
| RepeatT |
+ Repeats the sequence forever.
+ (Defined by MoreEnumerable) |
| RepeatT |
+ Repeats the sequence forever.
+ (Defined by RepeatExtension) |
| RepeatT |
+ Repeats the sequence the specified number of times.
+ (Defined by MoreEnumerable) |
| RepeatT |
+ Repeats the sequence the specified number of times.
+ (Defined by RepeatExtension) |
| RightJoinT, TKey, TResult |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| RightJoinT, TKey, TResult |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by RightJoinExtension) |
| RightJoinT, TKey, TResult |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| RightJoinT, TKey, TResult |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by RightJoinExtension) |
| RightJoinT, TSecond, TKey, TResult |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| RightJoinT, TSecond, TKey, TResult |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by RightJoinExtension) |
| RightJoinT, TSecond, TKey, TResult |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| RightJoinT, TSecond, TKey, TResult |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by RightJoinExtension) |
| RunLengthEncodeT |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count.
+ (Defined by MoreEnumerable) |
| RunLengthEncodeT |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count.
+ (Defined by RunLengthEncodeExtension) |
| RunLengthEncodeT |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count. This overload
+ uses a custom equality comparer to identify equivalent items.
+ (Defined by MoreEnumerable) |
| RunLengthEncodeT |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count. This overload
+ uses a custom equality comparer to identify equivalent items.
+ (Defined by RunLengthEncodeExtension) |
| ScanT |
+ Performs a scan (inclusive prefix sum) on a sequence of elements.
+ (Defined by MoreEnumerable) |
| ScanT |
+ Performs a scan (inclusive prefix sum) on a sequence of elements.
+ (Defined by ScanExtension) |
| ScanT, TState |
+ Like AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) except returns
+ the sequence of intermediate results as well as the final one.
+ An additional parameter specifies a seed.
+ (Defined by MoreEnumerable) |
| ScanT, TState |
+ Like AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) except returns
+ the sequence of intermediate results as well as the final one.
+ An additional parameter specifies a seed.
+ (Defined by ScanExtension) |
| ScanByT, TKey, TState |
+ Applies an accumulator function over sequence element keys,
+ returning the keys along with intermediate accumulator states.
+ (Defined by MoreEnumerable) |
| ScanByT, TKey, TState |
+ Applies an accumulator function over sequence element keys,
+ returning the keys along with intermediate accumulator states.
+ (Defined by ScanByExtension) |
| ScanByT, TKey, TState |
+ 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.
+ (Defined by MoreEnumerable) |
| ScanByT, TKey, TState |
+ 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.
+ (Defined by ScanByExtension) |
| ScanRightT |
+ Performs a right-associative scan (inclusive prefix) on a sequence of elements.
+ This operator is the right-associative version of the
+ ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ (Defined by MoreEnumerable) |
| ScanRightT |
+ Performs a right-associative scan (inclusive prefix) on a sequence of elements.
+ This operator is the right-associative version of the
+ ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ (Defined by ScanRightExtension) |
| ScanRightT, TAccumulate |
+ Performs a right-associative scan (inclusive prefix) on a sequence of elements.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) LINQ operator.
+ (Defined by MoreEnumerable) |
| ScanRightT, TAccumulate |
+ Performs a right-associative scan (inclusive prefix) on a sequence of elements.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) LINQ operator.
+ (Defined by ScanRightExtension) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by MoreEnumerable) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by SegmentExtension) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by MoreEnumerable) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by SegmentExtension) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by MoreEnumerable) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by SegmentExtension) |
| ShuffleT |
+ Returns a sequence of elements in random order from the original
+ sequence.
+ (Defined by MoreEnumerable) |
| ShuffleT |
+ Returns a sequence of elements in random order from the original
+ sequence.
+ (Defined by ShuffleExtension) |
| ShuffleT |
+ 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.
+ (Defined by MoreEnumerable) |
| ShuffleT |
+ 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.
+ (Defined by ShuffleExtension) |
| SingleT |
+ Returns the only element of a sequence, and throws an exception if
+ there is not exactly one element in the sequence.
+ (Defined by MoreEnumerable) |
| SingleT |
+ Returns the only element of a sequence, and throws an exception if
+ there is not exactly one element in the sequence.
+ (Defined by SingleExtension) |
| SingleOrDefaultT |
+ 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.
+ (Defined by MoreEnumerable) |
| SingleOrDefaultT |
+ 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.
+ (Defined by SingleOrDefaultExtension) |
| SkipLastT |
+ Bypasses a specified number of elements at the end of the sequence.
+ (Defined by MoreEnumerable) |
| SkipLastT |
+ Bypasses a specified number of elements at the end of the sequence.
+ (Defined by SkipLastExtension) |
| SkipUntilT |
+ 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.
+ (Defined by MoreEnumerable) |
| SkipUntilT |
+ 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.
+ (Defined by SkipUntilExtension) |
| SliceT |
+ Extracts a contiguous count of elements from a sequence at a particular zero-based
+ starting index.
+ (Defined by MoreEnumerable) |
| SliceT |
+ Extracts a contiguous count of elements from a sequence at a particular zero-based
+ starting index.
+ (Defined by SliceExtension) |
| SortedMergeT |
+ Merges two or more sequences that are in a common order (either ascending or descending)
+ into a single sequence that preserves that order.
+ (Defined by MoreEnumerable) |
| SortedMergeT |
+ Merges two or more sequences that are in a common order (either ascending or descending)
+ into a single sequence that preserves that order.
+ (Defined by SortedMergeExtension) |
| SortedMergeT |
+ Merges two or more sequences that are in a common order (either ascending or descending)
+ into a single sequence that preserves that order.
+ (Defined by MoreEnumerable) |
| SortedMergeT |
+ Merges two or more sequences that are in a common order (either ascending or descending)
+ into a single sequence that preserves that order.
+ (Defined by SortedMergeExtension) |
| SplitT |
+ Splits the source sequence by separator elements identified by a
+ function.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by separator elements identified by a
+ function.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by a separator.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by a separator.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by separator elements identified by a
+ function, given a maximum count of splits.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by separator elements identified by a
+ function, given a maximum count of splits.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by a separator given a maximum count of splits.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by a separator and then transforms the
+ splits into results.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by a separator given a maximum count of splits.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by a separator and then transforms the
+ splits into results.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by a separator, given a maximum count
+ of splits. A parameter specifies how the separator is compared
+ for equality.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by a separator, given a maximum count
+ of splits. A parameter specifies how the separator is compared
+ for equality.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by separator elements identified by
+ a function and then transforms the splits into results.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by separator elements identified by
+ a function and then transforms the splits into results.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by a separator and then transforms
+ the splits into results.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by a separator and then transforms
+ the splits into results.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by separator elements identified by
+ a function, given a maximum count of splits, and then transforms
+ the splits into results.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by separator elements identified by
+ a function, given a maximum count of splits, and then transforms
+ the splits into results.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by a separator and then transforms the
+ splits into results. A parameter specifies how the separator is
+ compared for equality.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by a separator and then transforms the
+ splits into results. A parameter specifies how the separator is
+ compared for equality.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results. A
+ parameter specifies how the separator is compared for equality.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results. A
+ parameter specifies how the separator is compared for equality.
+ (Defined by SplitExtension) |
| StartsWithT |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the default equality
+ comparer.
+ (Defined by MoreEnumerable) |
| StartsWithT |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the default equality
+ comparer.
+ (Defined by StartsWithExtension) |
| StartsWithT |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the specified element
+ equality comparer.
+ (Defined by MoreEnumerable) |
| StartsWithT |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the specified element
+ equality comparer.
+ (Defined by StartsWithExtension) |
| SubsetsT |
+ Returns a sequence of IListT representing all of the subsets of any size
+ that are part of the original sequence. In mathematics, it is equivalent to the
+ power set of a set.
+ (Defined by MoreEnumerable) |
| SubsetsT |
+ Returns a sequence of IListT representing all of the subsets of any size
+ that are part of the original sequence. In mathematics, it is equivalent to the
+ power set of a set.
+ (Defined by SubsetsExtension) |
| SubsetsT |
+ Returns a sequence of IListT representing all subsets of a given size
+ that are part of the original sequence. In mathematics, it is equivalent to the
+ combinations or k-subsets of a set.
+ (Defined by MoreEnumerable) |
| SubsetsT |
+ Returns a sequence of IListT representing all subsets of a given size
+ that are part of the original sequence. In mathematics, it is equivalent to the
+ combinations or k-subsets of a set.
+ (Defined by SubsetsExtension) |
| TagFirstLastT, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence with additional parameters
+ indicating whether the element is the first and/or last of the
+ sequence.
+ (Defined by MoreEnumerable) |
| TagFirstLastT, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence with additional parameters
+ indicating whether the element is the first and/or last of the
+ sequence.
+ (Defined by TagFirstLastExtension) |
| TakeEveryT |
+ Returns every N-th element of a sequence.
+ (Defined by MoreEnumerable) |
| TakeEveryT |
+ Returns every N-th element of a sequence.
+ (Defined by TakeEveryExtension) |
| TakeLastT |
+ Returns a specified number of contiguous elements from the end of
+ a sequence.
+ (Defined by MoreEnumerable) |
| TakeLastT |
+ Returns a specified number of contiguous elements from the end of
+ a sequence.
+ (Defined by TakeLastExtension) |
| TakeUntilT |
+ 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.
+ (Defined by MoreEnumerable) |
| TakeUntilT |
+ 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.
+ (Defined by TakeUntilExtension) |
| ToArrayByIndexT |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT, TResult |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT, TResult |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT, TResult |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT, TResult |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT, TResult |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT, TResult |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT, TResult |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT, TResult |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ (Defined by ToArrayByIndexExtension) |
| ToDataTableT |
+ Converts a sequence to a DataTable object.
+ (Defined by MoreEnumerable) |
| ToDataTableT |
+ Converts a sequence to a DataTable object.
+ (Defined by ToDataTableExtension) |
| ToDataTableT |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ (Defined by MoreEnumerable) |
| ToDataTableT |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ (Defined by ToDataTableExtension) |
| ToDataTableT, TTable |
+ Appends elements in the sequence as rows of a given DataTable object.
+ (Defined by MoreEnumerable) |
| ToDataTableT, TTable |
+ Appends elements in the sequence as rows of a given DataTable object.
+ (Defined by ToDataTableExtension) |
| ToDataTableT, TTable |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ (Defined by MoreEnumerable) |
| ToDataTableT, TTable |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ (Defined by ToDataTableExtension) |
| ToDelimitedStringT |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ (Defined by MoreEnumerable) |
| ToDelimitedStringT |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ (Defined by ToDelimitedStringExtension) |
| ToHashSetT |
+ Returns a HashSetT of the source items using the default equality
+ comparer for the type.
+ (Defined by MoreEnumerable) |
| ToHashSetT |
+ Returns a HashSetT of the source items using the default equality
+ comparer for the type.
+ (Defined by ToHashSetExtension) |
| ToHashSetT |
+ Returns a HashSetT of the source items using the specified equality
+ comparer for the type.
+ (Defined by MoreEnumerable) |
| ToHashSetT |
+ Returns a HashSetT of the source items using the specified equality
+ comparer for the type.
+ (Defined by ToHashSetExtension) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics.
+ (Defined by MoreEnumerable) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics.
+ (Defined by TraceExtension) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics using
+ a custom formatter.
+ (Defined by MoreEnumerable) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics using
+ a custom formatter.
+ (Defined by TraceExtension) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics using
+ custom formatting.
+ (Defined by MoreEnumerable) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics using
+ custom formatting.
+ (Defined by TraceExtension) |
| TrySingleT, TCardinality |
+ Returns a tuple with the cardinality of the sequence and the
+ single element in the sequence if it contains exactly one element.
+ similar to SingleTSource(IEnumerableTSource).
+ (Defined by ExperimentalEnumerable) |
| TrySingleT, TCardinality, TResult |
+ Returns a result projected from the the cardinality of the sequence
+ and the single element in the sequence if it contains exactly one
+ element.
+ (Defined by ExperimentalEnumerable) |
| WindowT |
+ Processes a sequence into a series of sub-sequences representing a windowed subset of
+ the original.
+ (Defined by MoreEnumerable) |
| WindowT |
+ Processes a sequence into a series of sub-sequences representing a windowed subset of
+ the original.
+ (Defined by WindowExtension) |
| WindowedT |
+ Processes a sequence into a series of sub-sequences representing a windowed subset of the original.
+ (Defined by MoreEnumerable) |
| WindowLeftT |
+ Creates a left-aligned sliding window of a given size over the
+ source sequence.
+ (Defined by MoreEnumerable) |
| WindowLeftT |
+ Creates a left-aligned sliding window of a given size over the
+ source sequence.
+ (Defined by WindowLeftExtension) |
| WindowRightT |
+ Creates a right-aligned sliding window over the source sequence
+ of a given size.
+ (Defined by MoreEnumerable) |
| WindowRightT |
+ Creates a right-aligned sliding window over the source sequence
+ of a given size.
+ (Defined by WindowRightExtension) |
| ZipLongestT, TSecond, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipLongestT, TSecond, TResult |
+ 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.
+ (Defined by ZipLongestExtension) |
| ZipLongestT, T2, T3, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipLongestT, T2, T3, TResult |
+ 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.
+ (Defined by ZipLongestExtension) |
| ZipLongestT, T2, T3, T4, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipLongestT, T2, T3, T4, TResult |
+ 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.
+ (Defined by ZipLongestExtension) |
| ZipShortestT, TSecond, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipShortestT, TSecond, TResult |
+ 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.
+ (Defined by ZipShortestExtension) |
| ZipShortestT, T2, T3, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipShortestT, T2, T3, TResult |
+ 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.
+ (Defined by ZipShortestExtension) |
| ZipShortestT, T2, T3, T4, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipShortestT, T2, T3, T4, TResult |
+ 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.
+ (Defined by ZipShortestExtension) |
| AcquireTSource | + Ensures that a source sequence of IDisposable + objects are all acquired successfully. If the acquisition of any + one IDisposable fails then those successfully + acquired till that point are disposed. + |
| AggregateT, TAccumulate1, TAccumulate2, TResult(IEnumerableT, TAccumulate1, FuncTAccumulate1, T, TAccumulate1, TAccumulate2, FuncTAccumulate2, T, TAccumulate2, FuncTAccumulate1, TAccumulate2, TResult) | + Applies two accumulators sequentially in a single pass over a + sequence. + |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TResult(IEnumerableT, TAccumulate1, FuncTAccumulate1, T, TAccumulate1, TAccumulate2, FuncTAccumulate2, T, TAccumulate2, TAccumulate3, FuncTAccumulate3, T, TAccumulate3, FuncTAccumulate1, TAccumulate2, TAccumulate3, TResult) | + Applies three accumulators sequentially in a single pass over a + sequence. + |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult(IEnumerableT, TAccumulate1, FuncTAccumulate1, T, TAccumulate1, TAccumulate2, FuncTAccumulate2, T, TAccumulate2, TAccumulate3, FuncTAccumulate3, T, TAccumulate3, TAccumulate4, FuncTAccumulate4, T, TAccumulate4, FuncTAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult) | + Applies four accumulators sequentially in a single pass over a + sequence. + |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult(IEnumerableT, TAccumulate1, FuncTAccumulate1, T, TAccumulate1, TAccumulate2, FuncTAccumulate2, T, TAccumulate2, TAccumulate3, FuncTAccumulate3, T, TAccumulate3, TAccumulate4, FuncTAccumulate4, T, TAccumulate4, TAccumulate5, FuncTAccumulate5, T, TAccumulate5, FuncTAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult) | + Applies five accumulators sequentially in a single pass over a + sequence. + |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult(IEnumerableT, TAccumulate1, FuncTAccumulate1, T, TAccumulate1, TAccumulate2, FuncTAccumulate2, T, TAccumulate2, TAccumulate3, FuncTAccumulate3, T, TAccumulate3, TAccumulate4, FuncTAccumulate4, T, TAccumulate4, TAccumulate5, FuncTAccumulate5, T, TAccumulate5, TAccumulate6, FuncTAccumulate6, T, TAccumulate6, FuncTAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult) | + Applies six accumulators sequentially in a single pass over a + sequence. + |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult(IEnumerableT, TAccumulate1, FuncTAccumulate1, T, TAccumulate1, TAccumulate2, FuncTAccumulate2, T, TAccumulate2, TAccumulate3, FuncTAccumulate3, T, TAccumulate3, TAccumulate4, FuncTAccumulate4, T, TAccumulate4, TAccumulate5, FuncTAccumulate5, T, TAccumulate5, TAccumulate6, FuncTAccumulate6, T, TAccumulate6, TAccumulate7, FuncTAccumulate7, T, TAccumulate7, FuncTAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult) | + Applies seven accumulators sequentially in a single pass over a + sequence. + |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult(IEnumerableT, TAccumulate1, FuncTAccumulate1, T, TAccumulate1, TAccumulate2, FuncTAccumulate2, T, TAccumulate2, TAccumulate3, FuncTAccumulate3, T, TAccumulate3, TAccumulate4, FuncTAccumulate4, T, TAccumulate4, TAccumulate5, FuncTAccumulate5, T, TAccumulate5, TAccumulate6, FuncTAccumulate6, T, TAccumulate6, TAccumulate7, FuncTAccumulate7, T, TAccumulate7, TAccumulate8, FuncTAccumulate8, T, TAccumulate8, FuncTAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult) | + Applies eight accumulators sequentially in a single pass over a + sequence. + |
| AggregateRightTSource(IEnumerableTSource, FuncTSource, TSource, TSource) | + Applies a right-associative accumulator function over a sequence. + This operator is the right-associative version of the + AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator. + |
| AggregateRightTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate) | + Applies a right-associative accumulator function over a sequence. + The specified seed value is used as the initial accumulator value. + This operator is the right-associative version of the + AggregateTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate) LINQ operator. + |
| AggregateRightTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate, FuncTAccumulate, TResult) | + Applies a right-associative accumulator function over a sequence. + The specified seed value is used as the initial accumulator value, + and the specified function is used to select the result value. + This operator is the right-associative version of the + AggregateTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate, FuncTAccumulate, TResult) LINQ operator. + |
| AppendT | + Returns a sequence consisting of the head elements and the given tail element. + |
| AssertTSource(IEnumerableTSource, FuncTSource, Boolean) | + Asserts that all elements of a sequence meet a given condition + otherwise throws an Exception object. + |
| AssertTSource(IEnumerableTSource, FuncTSource, Boolean, FuncTSource, Exception) | + Asserts that all elements of a sequence meet a given condition + otherwise throws an Exception object. + |
| AssertCountTSource(IEnumerableTSource, Int32) | + Asserts that a source sequence contains a given count of elements. + |
| AssertCountTSource(IEnumerableTSource, Int32, FuncInt32, Int32, Exception) | + Asserts that a source sequence contains a given count of elements. + A parameter specifies the exception to be thrown. + |
| AtLeastT | + Determines whether or not the number of elements in the sequence is greater than + or equal to the given integer. + |
| AtMostT | + Determines whether or not the number of elements in the sequence is lesser than + or equal to the given integer. + |
| BacksertT | + 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. + |
| BatchTSource(IEnumerableTSource, Int32) | + Batches the source sequence into sized buckets. + |
| BatchTSource, TResult(IEnumerableTSource, Int32, FuncIEnumerableTSource, TResult) | + Batches the source sequence into sized buckets and applies a projection to each bucket. + |
| CartesianT1, T2, TResult(IEnumerableT1, IEnumerableT2, FuncT1, T2, TResult) | + 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. + |
| CartesianT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, T5, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, IEnumerableT5, FuncT1, T2, T3, T4, T5, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, T5, T6, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, IEnumerableT5, IEnumerableT6, FuncT1, T2, T3, T4, T5, T6, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, T5, T6, T7, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, IEnumerableT5, IEnumerableT6, IEnumerableT7, FuncT1, T2, T3, T4, T5, T6, T7, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, T5, T6, T7, T8, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, IEnumerableT5, IEnumerableT6, IEnumerableT7, IEnumerableT8, FuncT1, T2, T3, T4, T5, T6, T7, T8, TResult) | + 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. + |
| ChooseT, TResult | + 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 true + as its first element and result as the second. + |
| CompareCountTFirst, TSecond | + Compares two sequences and returns an integer that indicates whether the first sequence + has fewer, the same or more elements than the second sequence. + |
| ConcatT |
+ Returns a sequence consisting of the head elements and the given tail element.
+ Obsolete. |
| ConsumeT | + Completely consumes the given sequence. This method uses immediate execution, + and doesn't store any data during execution. + |
| CountBetweenT | + Determines whether or not the number of elements in the sequence is between + an inclusive range of minimum and maximum integers. + |
| CountByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Applies a key-generating function to each element of a sequence and returns a sequence of + unique keys and their number of occurrences in the original sequence. + |
| CountByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + Applies a key-generating function to each element of a sequence and returns a sequence of + unique keys and their number of occurrences in the original sequence. + An additional argument specifies a comparer to use for testing equivalence of keys. + |
| CountDownT, TResult | + 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. + |
| DistinctByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Returns all distinct elements of the given source, where "distinctness" + is determined via a projection and the default equality comparer for the projected type. + |
| DistinctByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + Returns all distinct elements of the given source, where "distinctness" + is determined via a projection and the specified comparer for the projected type. + |
| EndsWithT(IEnumerableT, IEnumerableT) | + Determines whether the end of the first sequence is equivalent to + the second sequence, using the default equality comparer. + |
| EndsWithT(IEnumerableT, IEnumerableT, IEqualityComparerT) | + Determines whether the end of the first sequence is equivalent to + the second sequence, using the specified element equality comparer. + |
| EquiZipTFirst, TSecond, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. An exception is thrown + if the input sequences are of different lengths. + |
| EquiZipT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. An exception is thrown + if the input sequences are of different lengths. + |
| EquiZipT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. An exception is thrown + if the input sequences are of different lengths. + |
| EvaluateT | + Returns a sequence containing the values resulting from invoking (in order) each function in the source sequence of functions. + |
| ExactlyT | + Determines whether or not the number of elements in the sequence is equals to the given integer. + |
| ExceptByTSource, TKey(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey) | + Returns the set of elements in the first sequence which aren't + in the second sequence, according to a given key selector. + |
| ExceptByTSource, TKey(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + Returns the set of elements in the first sequence which aren't + in the second sequence, according to a given key selector. + |
| ExcludeT | + Excludes a contiguous number of elements from a sequence starting + at a given index. + |
| FallbackIfEmptyT(IEnumerableT, T) | + Returns the elements of the specified sequence or the specified + value in a singleton collection if the sequence is empty. + |
| FallbackIfEmptyT(IEnumerableT, T) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence from an array of values. + |
| FallbackIfEmptyT(IEnumerableT, IEnumerableT) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence of values. + |
| FallbackIfEmptyT(IEnumerableT, T, T) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence of values. + |
| FallbackIfEmptyT(IEnumerableT, T, T, T) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence of values. + |
| FallbackIfEmptyT(IEnumerableT, T, T, T, T) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence of values. + |
| FillBackwardT(IEnumerableT) | + Returns a sequence with each null reference or value in the source + replaced with the following non-null reference or value in + that sequence. + |
| FillBackwardT(IEnumerableT, FuncT, Boolean) | + Returns a sequence with each missing element in the source replaced + with the following non-missing element in that sequence. An + additional parameter specifies a function used to determine if an + element is considered missing or not. + |
| FillBackwardT(IEnumerableT, FuncT, Boolean, FuncT, T, T) | + Returns a sequence with each missing element in the source replaced + with the following non-missing element in that sequence. Additional + parameters specify two functions, one used to determine if an + element is considered missing or not and another to provide the + replacement for the missing element. + |
| FillForwardT(IEnumerableT) | + Returns a sequence with each null reference or value in the source + replaced with the previous non-null reference or value seen in + that sequence. + |
| FillForwardT(IEnumerableT, FuncT, Boolean) | + Returns a sequence with each missing element in the source replaced + with the previous non-missing element seen in that sequence. An + additional parameter specifies a function used to determine if an + element is considered missing or not. + |
| FillForwardT(IEnumerableT, FuncT, Boolean, FuncT, T, T) | + Returns a sequence with each missing element in the source replaced + with one based on the previous non-missing element seen in that + sequence. Additional parameters specify two functions, one used to + determine if an element is considered missing or not and another + to provide the replacement for the missing element. + |
| FirstT | + Returns the first element of a sequence. + |
| FirstOrDefaultT | + Returns the first element of a sequence, or a default value if the + sequence contains no elements. + |
| Flatten(IEnumerable) | + Flattens a sequence containing arbitrarily-nested sequences. + |
| Flatten(IEnumerable, FuncIEnumerable, Boolean) | + Flattens a sequence containing arbitrarily-nested sequences. An + additional parameter specifies a predicate function used to + determine whether a nested IEnumerable should be + flattened or not. + |
| Flatten(IEnumerable, FuncObject, IEnumerable) | + Flattens a sequence containing arbitrarily-nested sequences. An + additional parameter specifies a function that projects an inner + sequence via a property of an object. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 16 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 15 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 14 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 13 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 12 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 11 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 10 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 9 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 8 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 7 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 6 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 5 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 4 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, TResult) | + Returns the result of applying a function to a sequence of + 3 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, TResult) | + Returns the result of applying a function to a sequence of + 2 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, TResult) | + Returns the result of applying a function to a sequence of + 1 element. + |
| ForEachT(IEnumerableT, ActionT, Int32) | + Immediately executes the given action on each element in the source sequence. + Each element's index is used in the logic of the action. + |
| ForEachT(IEnumerableT, ActionT) | + Immediately executes the given action on each element in the source sequence. + |
| FromT(FuncT) | + Returns a single-element sequence containing the result of invoking the function. + |
| FromT(FuncT) | + Returns a sequence containing the values resulting from invoking (in order) each function in the source sequence of functions. + |
| FromT(FuncT, FuncT) | + Returns a sequence containing the result of invoking each parameter function in order. + |
| FromT(FuncT, FuncT, FuncT) | + Returns a sequence containing the result of invoking each parameter function in order. + |
| FullGroupJoinTFirst, TSecond, TKey(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey) | + Performs a Full Group Join between the first and second sequences. + |
| FullGroupJoinTFirst, TSecond, TKey(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, IEqualityComparerTKey) | + Performs a Full Group Join between the first and second sequences. + |
| FullGroupJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTKey, IEnumerableTFirst, IEnumerableTSecond, TResult) | + Performs a full group-join between two sequences. + |
| FullGroupJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTKey, IEnumerableTFirst, IEnumerableTSecond, TResult, IEqualityComparerTKey) | + Performs a full group-join between two sequences. + |
| FullJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TResult, FuncTSource, TSource, TResult) | + Performs a full outer join on two homogeneous sequences. + Additional arguments specify key selection functions and result + projection functions. + |
| FullJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TResult, FuncTSource, TSource, TResult, IEqualityComparerTKey) | + Performs a full outer join on two homogeneous sequences. + Additional arguments specify key selection functions, result + projection functions and a key comparer. + |
| FullJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult) | + Performs a full outer join on two heterogeneous sequences. + Additional arguments specify key selection functions and result + projection functions. + |
| FullJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult, IEqualityComparerTKey) | + Performs a full outer join on two heterogeneous sequences. + Additional arguments specify key selection functions, result + projection functions and a key comparer. + |
| GenerateTResult | + Returns a sequence of values consecutively generated by a generator function. + |
| GenerateByIndexTResult | + Returns a sequence of values based on indexes. + |
| GroupAdjacentTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Groups the adjacent elements of a sequence according to a + specified key selector function. + |
| GroupAdjacentTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + Groups the adjacent elements of a sequence according to a + specified key selector function and compares the keys by using a + specified comparer. + |
| GroupAdjacentTSource, TKey, TElement(IEnumerableTSource, FuncTSource, TKey, FuncTSource, TElement) | + Groups the adjacent elements of a sequence according to a + specified key selector function and projects the elements for + each group by using a specified function. + |
| GroupAdjacentTSource, TKey, TResult(IEnumerableTSource, FuncTSource, TKey, FuncTKey, IEnumerableTSource, TResult) | + Groups the adjacent elements of a sequence according to a + specified key selector function. The keys are compared by using + a comparer and each group's elements are projected by using a + specified function. + |
| GroupAdjacentTSource, TKey, TElement(IEnumerableTSource, FuncTSource, TKey, FuncTSource, TElement, IEqualityComparerTKey) | + Groups the adjacent elements of a sequence according to a + specified key selector function. The keys are compared by using + a comparer and each group's elements are projected by using a + specified function. + |
| GroupAdjacentTSource, TKey, TResult(IEnumerableTSource, FuncTSource, TKey, FuncTKey, IEnumerableTSource, TResult, IEqualityComparerTKey) | + Groups the adjacent elements of a sequence according to a + specified key selector function. The keys are compared by using + a comparer and each group's elements are projected by using a + specified function. + |
| IndexTSource(IEnumerableTSource) | + Returns a sequence of KeyValuePairTKey, TValue + where the key is the zero-based index of the value in the source + sequence. + |
| IndexTSource(IEnumerableTSource, Int32) | + Returns a sequence of KeyValuePairTKey, TValue + where the key is the index of the value in the source sequence. + An additional parameter specifies the starting index. + |
| IndexByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + 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. + |
| IndexByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + 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. + |
| InsertT | + Inserts the elements of a sequence into another sequence at a + specified index. + |
| InterleaveT | + Interleaves the elements of two or more sequences into a single sequence, skipping + sequences as they are consumed. + |
| LagTSource, TResult(IEnumerableTSource, Int32, FuncTSource, TSource, TResult) | + Produces a projection of a sequence by evaluating pairs of elements separated by a + negative offset. + |
| LagTSource, TResult(IEnumerableTSource, Int32, TSource, FuncTSource, TSource, TResult) | + Produces a projection of a sequence by evaluating pairs of elements separated by a + negative offset. + |
| LastT | + Returns the last element of a sequence. + |
| LastOrDefaultT | + Returns the last element of a sequence, or a default value if the + sequence contains no elements. + |
| LeadTSource, TResult(IEnumerableTSource, Int32, FuncTSource, TSource, TResult) | + Produces a projection of a sequence by evaluating pairs of elements separated by a + positive offset. + |
| LeadTSource, TResult(IEnumerableTSource, Int32, TSource, FuncTSource, TSource, TResult) | + Produces a projection of a sequence by evaluating pairs of elements separated by a + positive offset. + |
| LeftJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TSource, TResult) | + Performs a left outer join on two homogeneous sequences. + Additional arguments specify key selection functions and result + projection functions. + |
| LeftJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TSource, TResult, IEqualityComparerTKey) | + Performs a left outer join on two homogeneous sequences. + Additional arguments specify key selection functions, result + projection functions and a key comparer. + |
| LeftJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTFirst, TSecond, TResult) | + Performs a left outer join on two heterogeneous sequences. + Additional arguments specify key selection functions and result + projection functions. + |
| LeftJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTFirst, TSecond, TResult, IEqualityComparerTKey) | + Performs a left outer join on two heterogeneous sequences. + Additional arguments specify key selection functions, result + projection functions and a key comparer. + |
| MaxByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Returns the maximal elements of the given sequence, based on + the given projection. + |
| MaxByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) | + Returns the maximal elements of the given sequence, based on + the given projection and the specified comparer for projected values. + |
| MinByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Returns the minimal elements of the given sequence, based on + the given projection. + |
| MinByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) | + Returns the minimal elements of the given sequence, based on + the given projection and the specified comparer for projected values. + |
| MoveT | + Returns a sequence with a range of elements in the source sequence + moved to a new offset. + |
| OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection) | + Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key + |
| OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection) | + Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key + |
| OrderedMergeT(IEnumerableT, IEnumerableT) | + Merges two ordered sequences into one. Where the elements equal + in both sequences, the element from the first sequence is + returned in the resulting sequence. + |
| OrderedMergeT(IEnumerableT, IEnumerableT, IComparerT) | + Merges two ordered sequences into one with an additional + parameter specifying how to compare the elements of the + sequences. Where the elements equal in both sequences, the + element from the first sequence is returned in the resulting + sequence. + |
| OrderedMergeT, TKey(IEnumerableT, IEnumerableT, FuncT, TKey) | + Merges two ordered sequences into one with an additional + parameter specifying the element key by which the sequences are + ordered. Where the keys equal in both sequences, the + element from the first sequence is returned in the resulting + sequence. + |
| OrderedMergeT, TKey, TResult(IEnumerableT, IEnumerableT, FuncT, TKey, FuncT, TResult, FuncT, TResult, FuncT, T, TResult) | + Merges two ordered sequences into one. Additional parameters + specify the element key by which the sequences are ordered, + the result when element is found in first sequence but not in + the second, the result when element is found in second sequence + but not in the first and the result when elements are found in + both sequences. + |
| OrderedMergeT, TKey, TResult(IEnumerableT, IEnumerableT, FuncT, TKey, FuncT, TResult, FuncT, TResult, FuncT, T, TResult, IComparerTKey) | + Merges two ordered sequences into one. Additional parameters + specify the element key by which the sequences are ordered, + the result when element is found in first sequence but not in + the second, the result when element is found in second sequence + but not in the first, the result when elements are found in + both sequences and a method for comparing keys. + |
| OrderedMergeTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult) | + Merges two heterogeneous sequences ordered by a common key type + into a homogeneous one. Additional parameters specify the + element key by which the sequences are ordered, the result when + element is found in first sequence but not in the second and + the result when element is found in second sequence but not in + the first, the result when elements are found in both sequences. + |
| OrderedMergeTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult, IComparerTKey) | + Merges two heterogeneous sequences ordered by a common key type + into a homogeneous one. Additional parameters specify the + element key by which the sequences are ordered, the result when + element is found in first sequence but not in the second, + the result when element is found in second sequence but not in + the first, the result when elements are found in both sequences + and a method for comparing keys. + |
| PadTSource(IEnumerableTSource, Int32) | + Pads a sequence with default values if it is narrower (shorter + in length) than a given width. + |
| PadTSource(IEnumerableTSource, Int32, TSource) | + Pads a sequence with a given filler value if it is narrower (shorter + in length) than a given width. + |
| PadTSource(IEnumerableTSource, Int32, FuncInt32, TSource) | + Pads a sequence with a dynamic filler value if it is narrower (shorter + in length) than a given width. + |
| PadStartTSource(IEnumerableTSource, Int32) | + Pads a sequence with default values in the beginning if it is narrower (shorter + in length) than a given width. + |
| PadStartTSource(IEnumerableTSource, Int32, TSource) | + Pads a sequence with a given filler value in the beginning if it is narrower (shorter + in length) than a given width. + An additional parameter specifies the value to use for padding. + |
| PadStartTSource(IEnumerableTSource, Int32, FuncInt32, TSource) | + Pads a sequence with a dynamic filler value in the beginning if it is narrower (shorter + in length) than a given width. + An additional parameter specifies the function to calculate padding. + |
| PairwiseTSource, TResult | + Returns a sequence resulting from applying a function to each + element in the source sequence and its + predecessor, with the exception of the first element which is + only returned as the predecessor of the second element. + |
| PartialSortT(IEnumerableT, Int32) | + Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey), + where each element is its key, and TakeTSource(IEnumerableTSource, Int32) + in a single operation. + |
| PartialSortT(IEnumerableT, Int32, OrderByDirection) | + Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection), + where each element is its key, and TakeTSource(IEnumerableTSource, Int32) + in a single operation. + An additional parameter specifies the direction of the sort + |
| PartialSortT(IEnumerableT, Int32, IComparerT) | + Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey), + where each element is its key, and TakeTSource(IEnumerableTSource, Int32) + in a single operation. An additional parameter specifies how the + elements compare to each other. + |
| PartialSortT(IEnumerableT, Int32, IComparerT, OrderByDirection) | + Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection), + where each element is its key, and TakeTSource(IEnumerableTSource, Int32) + in a single operation. + Additional parameters specify how the elements compare to each other and + the direction of the sort. + |
| PartialSortByTSource, TKey(IEnumerableTSource, Int32, FuncTSource, TKey) | + Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey), + and TakeTSource(IEnumerableTSource, Int32) in a single operation. + |
| PartialSortByTSource, TKey(IEnumerableTSource, Int32, FuncTSource, TKey, OrderByDirection) | + Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection), + and TakeTSource(IEnumerableTSource, Int32) in a single operation. + An additional parameter specifies the direction of the sort + |
| PartialSortByTSource, TKey(IEnumerableTSource, Int32, FuncTSource, TKey, IComparerTKey) | + Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey), + and TakeTSource(IEnumerableTSource, Int32) in a single operation. + An additional parameter specifies how the keys compare to each other. + |
| PartialSortByTSource, TKey(IEnumerableTSource, Int32, FuncTSource, TKey, IComparerTKey, OrderByDirection) | + Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection), + and TakeTSource(IEnumerableTSource, Int32) in a single operation. + Additional parameters specify how the elements compare to each other and + the direction of the sort. + |
| PartitionT(IEnumerableT, FuncT, Boolean) | + Partitions or splits a sequence in two using a predicate. + |
| PartitionT, TResult(IEnumerableIGroupingBoolean, T, FuncIEnumerableT, IEnumerableT, TResult) | + Partitions a grouping by Boolean keys into a projection of true + elements and false elements, respectively. + |
| PartitionT, TResult(IEnumerableIGroupingNullableBoolean, T, FuncIEnumerableT, IEnumerableT, IEnumerableT, TResult) | + Partitions a grouping by nullable Boolean keys into a projection of + true elements, false elements and null elements, respectively. + |
| PartitionT, TResult(IEnumerableT, FuncT, Boolean, FuncIEnumerableT, IEnumerableT, TResult) | + Partitions or splits a sequence in two using a predicate and then + projects a result from the two. + |
| PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, FuncIEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) | + Partitions a grouping and projects a result from group elements + matching a key and those groups that do not. + |
| PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, TKey, FuncIEnumerableTElement, IEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) | + Partitions a grouping and projects a result from elements of + groups matching a set of two keys and those groups that do not. + |
| PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, IEqualityComparerTKey, FuncIEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) | + Partitions a grouping and projects a result from group elements + matching a key and those groups that do not. An additional parameter + specifies how to compare keys for equality. + |
| PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, TKey, TKey, FuncIEnumerableTElement, IEnumerableTElement, IEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) | + Partitions a grouping and projects a result from elements groups + matching a set of three keys and those groups that do not. + |
| PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, TKey, IEqualityComparerTKey, FuncIEnumerableTElement, IEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) | + Partitions a grouping and projects a result from elements of + groups matching a set of two keys and those groups that do not. + An additional parameter specifies how to compare keys for equality. + |
| PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, TKey, TKey, IEqualityComparerTKey, FuncIEnumerableTElement, IEnumerableTElement, IEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) | + Partitions a grouping and projects a result from elements groups + matching a set of three keys and those groups that do not. An + additional parameter specifies how to compare keys for equality. + |
| PermutationsT | + Generates a sequence of lists that represent the permutations of the original sequence. + |
| PipeT | + Executes the given action on each element in the source sequence + and yields it. + |
| PrependTSource | + Prepends a single value to a sequence. + |
| PreScanTSource | + Performs a pre-scan (exclusive prefix sum) on a sequence of elements. + |
| Random | + Returns an infinite sequence of random integers using the standard + .NET random number generator. + |
| Random(Int32) | + Returns an infinite sequence of random integers between zero and + a given maximum. + |
| Random(Random) | + Returns an infinite sequence of random integers using the supplied + random number generator. + |
| Random(Int32, Int32) | + Returns an infinite sequence of random integers between a given + minimum and a maximum. + |
| Random(Random, Int32) | + Returns an infinite sequence of random integers between zero and a + given maximum using the supplied random number generator. + |
| Random(Random, Int32, Int32) | + Returns an infinite sequence of random integers between a given + minimum and a maximum using the supplied random number generator. + |
| RandomDouble | + Returns an infinite sequence of random double values between 0.0 and 1.0 + |
| RandomDouble(Random) | + Returns an infinite sequence of random double values between 0.0 and 1.0 + using the supplied random number generator. + |
| RandomSubsetT(IEnumerableT, Int32) | + Returns a sequence of a specified size of random elements from the + original sequence. + |
| RandomSubsetT(IEnumerableT, Int32, Random) | + Returns a sequence of a specified size of random elements from the + original sequence. An additional parameter specifies a random + generator to be used for the random selection algorithm. + |
| RankTSource(IEnumerableTSource) | + Ranks each item in the sequence in descending ordering using a default comparer. + |
| RankTSource(IEnumerableTSource, IComparerTSource) | + Rank each item in the sequence using a caller-supplied comparer. + |
| RankByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Ranks each item in the sequence in descending ordering by a specified key using a default comparer + |
| RankByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) | + Ranks each item in a sequence using a specified key and a caller-supplied comparer + |
| RepeatT(IEnumerableT) | + Repeats the sequence forever. + |
| RepeatT(IEnumerableT, Int32) | + Repeats the sequence the specified number of times. + |
| ReturnT | + Returns a single-element sequence containing the item provided. + |
| RightJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TSource, TResult) | + Performs a right outer join on two homogeneous sequences. + Additional arguments specify key selection functions and result + projection functions. + |
| RightJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TSource, TResult, IEqualityComparerTKey) | + Performs a right outer join on two homogeneous sequences. + Additional arguments specify key selection functions, result + projection functions and a key comparer. + |
| RightJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTSecond, TResult, FuncTFirst, TSecond, TResult) | + Performs a right outer join on two heterogeneous sequences. + Additional arguments specify key selection functions and result + projection functions. + |
| RightJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTSecond, TResult, FuncTFirst, TSecond, TResult, IEqualityComparerTKey) | + Performs a right outer join on two heterogeneous sequences. + Additional arguments specify key selection functions, result + projection functions and a key comparer. + |
| RunLengthEncodeT(IEnumerableT) | + Run-length encodes a sequence by converting consecutive instances of the same element into + a KeyValuePair{T,int} representing the item and its occurrence count. + |
| RunLengthEncodeT(IEnumerableT, IEqualityComparerT) | + Run-length encodes a sequence by converting consecutive instances of the same element into + a KeyValuePair{T,int} representing the item and its occurrence count. This overload + uses a custom equality comparer to identify equivalent items. + |
| ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) | + Performs a scan (inclusive prefix sum) on a sequence of elements. + |
| ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) | + Like AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) except returns + the sequence of intermediate results as well as the final one. + An additional parameter specifies a seed. + |
| ScanByTSource, TKey, TState(IEnumerableTSource, FuncTSource, TKey, FuncTKey, TState, FuncTState, TKey, TSource, TState) | + Applies an accumulator function over sequence element keys, + returning the keys along with intermediate accumulator states. + |
| ScanByTSource, TKey, TState(IEnumerableTSource, FuncTSource, TKey, FuncTKey, TState, FuncTState, TKey, TSource, TState, IEqualityComparerTKey) | + 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. + |
| ScanRightTSource(IEnumerableTSource, FuncTSource, TSource, TSource) | + Performs a right-associative scan (inclusive prefix) on a sequence of elements. + This operator is the right-associative version of the + ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator. + |
| ScanRightTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate) | + Performs a right-associative scan (inclusive prefix) on a sequence of elements. + The specified seed value is used as the initial accumulator value. + This operator is the right-associative version of the + ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) LINQ operator. + |
| SegmentT(IEnumerableT, FuncT, T, Int32, Boolean) | + Divides a sequence into multiple sequences by using a segment detector based on the original sequence + |
| SegmentT(IEnumerableT, FuncT, Boolean) | + Divides a sequence into multiple sequences by using a segment detector based on the original sequence + |
| SegmentT(IEnumerableT, FuncT, Int32, Boolean) | + Divides a sequence into multiple sequences by using a segment detector based on the original sequence + |
| Sequence(Int32, Int32) | + Generates a sequence of integral numbers within the (inclusive) specified range. + If sequence is ascending the step is +1, otherwise -1. + |
| Sequence(Int32, Int32, Int32) | + Generates a sequence of integral numbers within the (inclusive) specified range. + An additional parameter specifies the steps in which the integers of the sequence increase or decrease. + |
| ShuffleT(IEnumerableT) | + Returns a sequence of elements in random order from the original + sequence. + |
| ShuffleT(IEnumerableT, Random) | + 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. + |
| SingleT | + Returns the only element of a sequence, and throws an exception if + there is not exactly one element in the sequence. + |
| SingleOrDefaultT | + 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. + |
| SkipLastT | + Bypasses a specified number of elements at the end of the sequence. + |
| SkipUntilTSource | + Skips items from the input sequence until the given predicate returns true + when applied to the current source item; that item will be the last skipped. + |
| SliceT | + Extracts a contiguous count of elements from a sequence at a particular zero-based + starting index. + |
| SortedMergeTSource(IEnumerableTSource, OrderByDirection, IEnumerableTSource) | + Merges two or more sequences that are in a common order (either ascending or descending) + into a single sequence that preserves that order. + |
| SortedMergeTSource(IEnumerableTSource, OrderByDirection, IComparerTSource, IEnumerableTSource) | + Merges two or more sequences that are in a common order (either ascending or descending) + into a single sequence that preserves that order. + |
| SplitTSource(IEnumerableTSource, TSource) | + Splits the source sequence by a separator. + |
| SplitTSource(IEnumerableTSource, FuncTSource, Boolean) | + Splits the source sequence by separator elements identified by a + function. + |
| SplitTSource(IEnumerableTSource, TSource, IEqualityComparerTSource) | + Splits the source sequence by a separator and then transforms the + splits into results. + |
| SplitTSource(IEnumerableTSource, TSource, Int32) | + Splits the source sequence by a separator given a maximum count of splits. + |
| SplitTSource(IEnumerableTSource, FuncTSource, Boolean, Int32) | + Splits the source sequence by separator elements identified by a + function, given a maximum count of splits. + |
| SplitTSource(IEnumerableTSource, TSource, IEqualityComparerTSource, Int32) | + Splits the source sequence by a separator, given a maximum count + of splits. A parameter specifies how the separator is compared + for equality. + |
| SplitTSource, TResult(IEnumerableTSource, TSource, FuncIEnumerableTSource, TResult) | + Splits the source sequence by a separator and then transforms + the splits into results. + |
| SplitTSource, TResult(IEnumerableTSource, FuncTSource, Boolean, FuncIEnumerableTSource, TResult) | + Splits the source sequence by separator elements identified by + a function and then transforms the splits into results. + |
| SplitTSource, TResult(IEnumerableTSource, TSource, IEqualityComparerTSource, FuncIEnumerableTSource, TResult) | + Splits the source sequence by a separator and then transforms the + splits into results. A parameter specifies how the separator is + compared for equality. + |
| SplitTSource, TResult(IEnumerableTSource, TSource, Int32, FuncIEnumerableTSource, TResult) | + Splits the source sequence by a separator, given a maximum count + of splits, and then transforms the splits into results. + |
| SplitTSource, TResult(IEnumerableTSource, FuncTSource, Boolean, Int32, FuncIEnumerableTSource, TResult) | + Splits the source sequence by separator elements identified by + a function, given a maximum count of splits, and then transforms + the splits into results. + |
| SplitTSource, TResult(IEnumerableTSource, TSource, IEqualityComparerTSource, Int32, FuncIEnumerableTSource, TResult) | + Splits the source sequence by a separator, given a maximum count + of splits, and then transforms the splits into results. A + parameter specifies how the separator is compared for equality. + |
| StartsWithT(IEnumerableT, IEnumerableT) | + Determines whether the beginning of the first sequence is + equivalent to the second sequence, using the default equality + comparer. + |
| StartsWithT(IEnumerableT, IEnumerableT, IEqualityComparerT) | + Determines whether the beginning of the first sequence is + equivalent to the second sequence, using the specified element + equality comparer. + |
| SubsetsT(IEnumerableT) | + Returns a sequence of IListT representing all of the subsets of any size + that are part of the original sequence. In mathematics, it is equivalent to the + power set of a set. + |
| SubsetsT(IEnumerableT, Int32) | + Returns a sequence of IListT representing all subsets of a given size + that are part of the original sequence. In mathematics, it is equivalent to the + combinations or k-subsets of a set. + |
| TagFirstLastTSource, TResult | + Returns a sequence resulting from applying a function to each + element in the source sequence with additional parameters + indicating whether the element is the first and/or last of the + sequence. + |
| TakeEveryTSource | + Returns every N-th element of a sequence. + |
| TakeLastTSource | + Returns a specified number of contiguous elements from the end of + a sequence. + |
| TakeUntilTSource | + Returns items from the input sequence until the given predicate returns true + when applied to the current source item; that item will be the last returned. + |
| ThenByT, TKey(IOrderedEnumerableT, FuncT, TKey, OrderByDirection) | + Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key + |
| ThenByT, TKey(IOrderedEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection) | + Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key + |
| ToArrayByIndexT(IEnumerableT, FuncT, Int32) | + Creates an array from an IEnumerableT where a + function is used to determine the index at which an element will + be placed in the array. + |
| ToArrayByIndexT(IEnumerableT, Int32, FuncT, Int32) | + Creates an array of user-specified length from an + IEnumerableT where a function is used to determine + the index at which an element will be placed in the array. + |
| ToArrayByIndexT, TResult(IEnumerableT, FuncT, Int32, FuncT, TResult) | + Creates an array from an IEnumerableT where a + function is used to determine the index at which an element will + be placed in the array. The elements are projected into the array + via an additional function. + |
| ToArrayByIndexT, TResult(IEnumerableT, FuncT, Int32, FuncT, Int32, TResult) | + Creates an array from an IEnumerableT where a + function is used to determine the index at which an element will + be placed in the array. The elements are projected into the array + via an additional function. + |
| ToArrayByIndexT, TResult(IEnumerableT, Int32, FuncT, Int32, FuncT, TResult) | + Creates an array of user-specified length from an + IEnumerableT where a function is used to determine + the index at which an element will be placed in the array. The + elements are projected into the array via an additional function. + |
| ToArrayByIndexT, TResult(IEnumerableT, Int32, FuncT, Int32, FuncT, Int32, TResult) | + Creates an array of user-specified length from an + IEnumerableT where a function is used to determine + the index at which an element will be placed in the array. The + elements are projected into the array via an additional function. + |
| ToDataTableT(IEnumerableT) | + Converts a sequence to a DataTable object. + |
| ToDataTableT(IEnumerableT, ExpressionFuncT, Object) | + Appends elements in the sequence as rows of a given DataTable + object with a set of lambda expressions specifying which members (property + or field) of each element in the sequence will supply the column values. + |
| ToDataTableT, TTable(IEnumerableT, TTable) | + Appends elements in the sequence as rows of a given DataTable object. + |
| ToDataTableT, TTable(IEnumerableT, TTable, ExpressionFuncT, Object) | + Appends elements in the sequence as rows of a given DataTable + object with a set of lambda expressions specifying which members (property + or field) of each element in the sequence will supply the column values. + |
| ToDelimitedString(IEnumerableBoolean, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableByte, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableChar, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableDecimal, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableDouble, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableInt16, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableInt32, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableInt64, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableSByte, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableSingle, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableString, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableUInt16, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableUInt32, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableUInt64, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedStringTSource(IEnumerableTSource, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDictionaryTKey, TValue(IEnumerableKeyValuePairTKey, TValue) | + Creates a DictionaryTKey, TValue from a sequence of + KeyValuePairTKey, TValue elements. + |
| ToDictionaryTKey, TValue(IEnumerableValueTupleTKey, TValue) | + Creates a DictionaryTKey, TValue from a sequence of + tuples of 2 where the first item is the key and the second the + value. + |
| ToDictionaryTKey, TValue(IEnumerableKeyValuePairTKey, TValue, IEqualityComparerTKey) | + Creates a DictionaryTKey, TValue from a sequence of + KeyValuePairTKey, TValue elements. An additional + parameter specifies a comparer for keys. + |
| ToDictionaryTKey, TValue(IEnumerableValueTupleTKey, TValue, IEqualityComparerTKey) | + Creates a DictionaryTKey, TValue from a sequence of + tuples of 2 where the first item is the key and the second the + value. An additional parameter specifies a comparer for keys. + |
| ToHashSetTSource(IEnumerableTSource) | + Returns a HashSetT of the source items using the default equality + comparer for the type. + |
| ToHashSetTSource(IEnumerableTSource, IEqualityComparerTSource) | + Returns a HashSetT of the source items using the specified equality + comparer for the type. + |
| ToLookupTKey, TValue(IEnumerableKeyValuePairTKey, TValue) | + Creates a ILookupTKey, TElement from a sequence of + KeyValuePairTKey, TValue elements. + |
| ToLookupTKey, TValue(IEnumerableValueTupleTKey, TValue) | + Creates a Lookup from a sequence of + tuples of 2 where the first item is the key and the second the + value. + |
| ToLookupTKey, TValue(IEnumerableKeyValuePairTKey, TValue, IEqualityComparerTKey) | + Creates a ILookupTKey, TElement from a sequence of + KeyValuePairTKey, TValue elements. An additional + parameter specifies a comparer for keys. + |
| ToLookupTKey, TValue(IEnumerableValueTupleTKey, TValue, IEqualityComparerTKey) | + Creates a Lookup from a sequence of + tuples of 2 where the first item is the key and the second the + value. An additional parameter specifies a comparer for keys. + |
| TraceTSource(IEnumerableTSource) | + Traces the elements of a source sequence for diagnostics. + |
| TraceTSource(IEnumerableTSource, FuncTSource, String) | + Traces the elements of a source sequence for diagnostics using + a custom formatter. + |
| TraceTSource(IEnumerableTSource, String) | + Traces the elements of a source sequence for diagnostics using + custom formatting. + |
| TransposeT | + Transposes a sequence of rows into a sequence of columns. + |
| TraverseBreadthFirstT | + Traverses a tree in a breadth-first fashion, starting at a root + node and using a user-defined function to get the children at each + node of the tree. + |
| TraverseDepthFirstT | + Traverses a tree in a depth-first fashion, starting at a root node + and using a user-defined function to get the children at each node + of the tree. + |
| UnfoldTState, T, TResult | + Returns a sequence generated by applying a state to the generator function, + and from its result, determines if the sequence should have a next element, its value, + and the next state in the recursive call. + |
| WindowTSource | + Processes a sequence into a series of sub-sequences representing a windowed subset of + the original. + |
| WindowedTSource |
+ Processes a sequence into a series of sub-sequences representing a windowed subset of the original.
+ Obsolete. |
| WindowLeftTSource | + Creates a left-aligned sliding window of a given size over the + source sequence. + |
| WindowRightTSource | + Creates a right-aligned sliding window over the source sequence + of a given size. + |
| ZipLongestTFirst, TSecond, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. 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. + |
| ZipLongestT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. 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. + |
| ZipLongestT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. 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. + |
| ZipShortestTFirst, TSecond, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. The resulting sequence + is as short as the shortest input sequence. + |
| ZipShortestT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. The resulting sequence + is as short as the shortest input sequence. + |
| ZipShortestT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. The resulting sequence + is as short as the shortest input sequence. + |
| Equals | Determines whether the specified object is equal to the current object. (Inherited from Object) |
| Finalize | Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection. (Inherited from Object) |
| GetBaseException | When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions. (Inherited from Exception) |
| GetHashCode | Serves as the default hash function. (Inherited from Object) |
| GetObjectData | When overridden in a derived class, sets the SerializationInfo with information about the exception. (Inherited from Exception) |
| GetType | Gets the runtime type of the current instance. (Inherited from Exception) |
| MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object) |
| ToString | Creates and returns a string representation of the current exception. (Inherited from Exception) |
| MoreEnumerable | + Provides a set of static methods for querying objects that + implement IEnumerableT. + |
| SequenceException | + The exception that is thrown for a sequence that fails a condition. + |
| IExtremaEnumerableT | + Exposes the enumerator, which supports iteration over a sequence of + some extremum property (maximum or minimum) of a specified type. + |
| OrderByDirection | + Enumeration that defines values representing valid ordering directions for a sequence. + |
| AwaitQueryOptions | + Represents options for a query whose results evaluate asynchronously. + |
| ExperimentalEnumerable | + Provides a set of static methods for querying objects that + implement IEnumerableT. 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. |
| IAwaitQueryT | + Represents a sequence whose elements or results evaluate asynchronously. + |
| ICurrentBufferT | + Represents a current buffered view of a larger result and which + is updated in-place (thus current) as it is moved through the overall + result. + |
[Missing <summary> documentation for "N:MoreLinq.Experimental.Async"]
| ExperimentalEnumerable | + Provides a set of static methods for querying objects that + implement IAsyncEnumerableT. 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. |
[Missing <summary> documentation for "N:MoreLinq.Extensions"]
| AcquireExtension | Acquire extension. |
| AggregateExtension | Aggregate extension. |
| AggregateRightExtension | AggregateRight extension. |
| AppendExtension | Append extension. |
| AssertCountExtension | AssertCount extension. |
| AssertExtension | Assert extension. |
| AtLeastExtension | AtLeast extension. |
| AtMostExtension | AtMost extension. |
| BacksertExtension | Backsert extension. |
| BatchExtension | Batch extension. |
| CartesianExtension | Cartesian extension. |
| ChooseExtension | Choose extension. |
| CompareCountExtension | CompareCount extension. |
| ConsumeExtension | Consume extension. |
| CountBetweenExtension | CountBetween extension. |
| CountByExtension | CountBy extension. |
| CountDownExtension | CountDown extension. |
| DistinctByExtension | DistinctBy extension. |
| EndsWithExtension | EndsWith extension. |
| EquiZipExtension | EquiZip extension. |
| EvaluateExtension | Evaluate extension. |
| ExactlyExtension | Exactly extension. |
| ExceptByExtension | ExceptBy extension. |
| ExcludeExtension | Exclude extension. |
| FallbackIfEmptyExtension | FallbackIfEmpty extension. |
| FillBackwardExtension | FillBackward extension. |
| FillForwardExtension | FillForward extension. |
| FirstExtension | First extension. |
| FirstOrDefaultExtension | FirstOrDefault extension. |
| FlattenExtension | Flatten extension. |
| FoldExtension | Fold extension. |
| ForEachExtension | ForEach extension. |
| FullGroupJoinExtension | FullGroupJoin extension. |
| FullJoinExtension | FullJoin extension. |
| GroupAdjacentExtension | GroupAdjacent extension. |
| IndexByExtension | IndexBy extension. |
| IndexExtension | Index extension. |
| InsertExtension | Insert extension. |
| InterleaveExtension | Interleave extension. |
| LagExtension | Lag extension. |
| LastExtension | Last extension. |
| LastOrDefaultExtension | LastOrDefault extension. |
| LeadExtension | Lead extension. |
| LeftJoinExtension | LeftJoin extension. |
| MaxByExtension | MaxBy extension. |
| MinByExtension | MinBy extension. |
| MoveExtension | Move extension. |
| OrderByExtension | OrderBy extension. |
| OrderedMergeExtension | OrderedMerge extension. |
| PadExtension | Pad extension. |
| PadStartExtension | PadStart extension. |
| PairwiseExtension | Pairwise extension. |
| PartialSortByExtension | PartialSortBy extension. |
| PartialSortExtension | PartialSort extension. |
| PartitionExtension | Partition extension. |
| PermutationsExtension | Permutations extension. |
| PipeExtension | Pipe extension. |
| PrependExtension | Prepend extension. |
| PreScanExtension | PreScan extension. |
| RandomSubsetExtension | RandomSubset extension. |
| RankByExtension | RankBy extension. |
| RankExtension | Rank extension. |
| RepeatExtension | Repeat extension. |
| RightJoinExtension | RightJoin extension. |
| RunLengthEncodeExtension | RunLengthEncode extension. |
| ScanByExtension | ScanBy extension. |
| ScanExtension | Scan extension. |
| ScanRightExtension | ScanRight extension. |
| SegmentExtension | Segment extension. |
| ShuffleExtension | Shuffle extension. |
| SingleExtension | Single extension. |
| SingleOrDefaultExtension | SingleOrDefault extension. |
| SkipLastExtension | SkipLast extension. |
| SkipUntilExtension | SkipUntil extension. |
| SliceExtension | Slice extension. |
| SortedMergeExtension | SortedMerge extension. |
| SplitExtension | Split extension. |
| StartsWithExtension | StartsWith extension. |
| SubsetsExtension | Subsets extension. |
| TagFirstLastExtension | TagFirstLast extension. |
| TakeEveryExtension | TakeEvery extension. |
| TakeLastExtension | TakeLast extension. |
| TakeUntilExtension | TakeUntil extension. |
| ThenByExtension | ThenBy extension. |
| ToArrayByIndexExtension | ToArrayByIndex extension. |
| ToDataTableExtension | ToDataTable extension. |
| ToDelimitedStringExtension | ToDelimitedString extension. |
| ToDictionaryExtension | ToDictionary extension. |
| ToHashSetExtension | ToHashSet extension. |
| ToLookupExtension | ToLookup extension. |
| TraceExtension | Trace extension. |
| TransposeExtension | Transpose extension. |
| WindowExtension | Window extension. |
| WindowLeftExtension | WindowLeft extension. |
| WindowRightExtension | WindowRight extension. |
| ZipLongestExtension | ZipLongest extension. |
| ZipShortestExtension | ZipShortest extension. |
| MergeT(IEnumerableIAsyncEnumerableT) | + Concurrently merges all the elements of multiple asynchronous streams into a single + asynchronous stream. + |
| MergeT(IEnumerableIAsyncEnumerableT, Int32) | + Concurrently merges all the elements of multiple asynchronous streams into a single + asynchronous stream. An additional parameter specifies the maximum concurrent operations + that may be in flight at any give time. + |
| AwaitT(IEnumerableTaskT) | + Creates a sequence query that streams the result of each task in + the source sequence as it completes asynchronously. + |
| AwaitT, TResult(IEnumerableT, FuncT, CancellationToken, TaskTResult) | + Creates a sequence query that streams the result of each task in + the source sequence as it completes asynchronously. A + CancellationToken is passed for each asynchronous + evaluation to abort any asynchronous operations in flight if the + sequence is not fully iterated. + |
| BatchTSource, TResult(IEnumerableTSource, Int32, ArrayPoolTSource, FuncICurrentBufferTSource, TResult) | + Batches the source sequence into sized buckets using an array pool + to rent arrays to back each bucket and returns a sequence of + elements projected from each bucket. + |
| BatchTSource, TBucket, TResult(IEnumerableTSource, Int32, ArrayPoolTSource, FuncICurrentBufferTSource, IEnumerableTBucket, FuncIEnumerableTBucket, TResult) | + Batches the source sequence into sized buckets using an array pool + to rent arrays to back each bucket and returns a sequence of + elements projected from each bucket. + |
| TrySingleT, TCardinality(IEnumerableT, TCardinality, TCardinality, TCardinality) | + Returns a tuple with the cardinality of the sequence and the + single element in the sequence if it contains exactly one element. + similar to SingleTSource(IEnumerableTSource). + |
| TrySingleT, TCardinality, TResult(IEnumerableT, TCardinality, TCardinality, TCardinality, FuncTCardinality, T, TResult) | + Returns a result projected from the the cardinality of the sequence + and the single element in the sequence if it contains exactly one + element. + |
| AggregateRightTSource(IEnumerableTSource, FuncTSource, TSource, TSource) | + Applies a right-associative accumulator function over a sequence. + This operator is the right-associative version of the + AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator. + |
| AggregateRightTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate) | + Applies a right-associative accumulator function over a sequence. + The specified seed value is used as the initial accumulator value. + This operator is the right-associative version of the + AggregateTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate) LINQ operator. + |
| AggregateRightTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate, FuncTAccumulate, TResult) | + Applies a right-associative accumulator function over a sequence. + The specified seed value is used as the initial accumulator value, + and the specified function is used to select the result value. + This operator is the right-associative version of the + AggregateTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate, FuncTAccumulate, TResult) LINQ operator. + |
| AssertCountTSource(IEnumerableTSource, Int32) | + Asserts that a source sequence contains a given count of elements. + |
| AssertCountTSource(IEnumerableTSource, Int32, FuncInt32, Int32, Exception) | + Asserts that a source sequence contains a given count of elements. + A parameter specifies the exception to be thrown. + |
| AssertTSource(IEnumerableTSource, FuncTSource, Boolean) | + Asserts that all elements of a sequence meet a given condition + otherwise throws an Exception object. + |
| AssertTSource(IEnumerableTSource, FuncTSource, Boolean, FuncTSource, Exception) | + Asserts that all elements of a sequence meet a given condition + otherwise throws an Exception object. + |
| BatchTSource(IEnumerableTSource, Int32) | + Batches the source sequence into sized buckets. + |
| BatchTSource, TResult(IEnumerableTSource, Int32, FuncIEnumerableTSource, TResult) | + Batches the source sequence into sized buckets and applies a projection to each bucket. + |
| CartesianT1, T2, TResult(IEnumerableT1, IEnumerableT2, FuncT1, T2, TResult) | + 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. + |
| CartesianT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, T5, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, IEnumerableT5, FuncT1, T2, T3, T4, T5, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, T5, T6, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, IEnumerableT5, IEnumerableT6, FuncT1, T2, T3, T4, T5, T6, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, T5, T6, T7, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, IEnumerableT5, IEnumerableT6, IEnumerableT7, FuncT1, T2, T3, T4, T5, T6, T7, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, T5, T6, T7, T8, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, IEnumerableT5, IEnumerableT6, IEnumerableT7, IEnumerableT8, FuncT1, T2, T3, T4, T5, T6, T7, T8, TResult) | + 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. + |
| CountByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Applies a key-generating function to each element of a sequence and returns a sequence of + unique keys and their number of occurrences in the original sequence. + |
| CountByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + Applies a key-generating function to each element of a sequence and returns a sequence of + unique keys and their number of occurrences in the original sequence. + An additional argument specifies a comparer to use for testing equivalence of keys. + |
| DistinctByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Returns all distinct elements of the given source, where "distinctness" + is determined via a projection and the default equality comparer for the projected type. + |
| DistinctByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + Returns all distinct elements of the given source, where "distinctness" + is determined via a projection and the specified comparer for the projected type. + |
| EndsWithT(IEnumerableT, IEnumerableT) | + Determines whether the end of the first sequence is equivalent to + the second sequence, using the default equality comparer. + |
| EndsWithT(IEnumerableT, IEnumerableT, IEqualityComparerT) | + Determines whether the end of the first sequence is equivalent to + the second sequence, using the specified element equality comparer. + |
| EquiZipTFirst, TSecond, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. An exception is thrown + if the input sequences are of different lengths. + |
| EquiZipT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. An exception is thrown + if the input sequences are of different lengths. + |
| EquiZipT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. An exception is thrown + if the input sequences are of different lengths. + |
| ExceptByTSource, TKey(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey) | + Returns the set of elements in the first sequence which aren't + in the second sequence, according to a given key selector. + |
| ExceptByTSource, TKey(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + Returns the set of elements in the first sequence which aren't + in the second sequence, according to a given key selector. + |
| FallbackIfEmptyT(IEnumerableT, T) | + Returns the elements of the specified sequence or the specified + value in a singleton collection if the sequence is empty. + |
| FallbackIfEmptyT(IEnumerableT, T) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence from an array of values. + |
| FallbackIfEmptyT(IEnumerableT, IEnumerableT) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence of values. + |
| FallbackIfEmptyT(IEnumerableT, T, T) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence of values. + |
| FallbackIfEmptyT(IEnumerableT, T, T, T) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence of values. + |
| FallbackIfEmptyT(IEnumerableT, T, T, T, T) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence of values. + |
| FillBackwardT(IEnumerableT) | + Returns a sequence with each null reference or value in the source + replaced with the following non-null reference or value in + that sequence. + |
| FillBackwardT(IEnumerableT, FuncT, Boolean) | + Returns a sequence with each missing element in the source replaced + with the following non-missing element in that sequence. An + additional parameter specifies a function used to determine if an + element is considered missing or not. + |
| FillBackwardT(IEnumerableT, FuncT, Boolean, FuncT, T, T) | + Returns a sequence with each missing element in the source replaced + with the following non-missing element in that sequence. Additional + parameters specify two functions, one used to determine if an + element is considered missing or not and another to provide the + replacement for the missing element. + |
| FillForwardT(IEnumerableT) | + Returns a sequence with each null reference or value in the source + replaced with the previous non-null reference or value seen in + that sequence. + |
| FillForwardT(IEnumerableT, FuncT, Boolean) | + Returns a sequence with each missing element in the source replaced + with the previous non-missing element seen in that sequence. An + additional parameter specifies a function used to determine if an + element is considered missing or not. + |
| FillForwardT(IEnumerableT, FuncT, Boolean, FuncT, T, T) | + Returns a sequence with each missing element in the source replaced + with one based on the previous non-missing element seen in that + sequence. Additional parameters specify two functions, one used to + determine if an element is considered missing or not and another + to provide the replacement for the missing element. + |
| Flatten(IEnumerable) | + Flattens a sequence containing arbitrarily-nested sequences. + |
| Flatten(IEnumerable, FuncIEnumerable, Boolean) | + Flattens a sequence containing arbitrarily-nested sequences. An + additional parameter specifies a predicate function used to + determine whether a nested IEnumerable should be + flattened or not. + |
| Flatten(IEnumerable, FuncObject, IEnumerable) | + Flattens a sequence containing arbitrarily-nested sequences. An + additional parameter specifies a function that projects an inner + sequence via a property of an object. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 16 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 15 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 14 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 13 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 12 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 11 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 10 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 9 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 8 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 7 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 6 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 5 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 4 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, TResult) | + Returns the result of applying a function to a sequence of + 3 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, TResult) | + Returns the result of applying a function to a sequence of + 2 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, TResult) | + Returns the result of applying a function to a sequence of + 1 element. + |
| ForEachT(IEnumerableT, ActionT, Int32) | + Immediately executes the given action on each element in the source sequence. + Each element's index is used in the logic of the action. + |
| ForEachT(IEnumerableT, ActionT) | + Immediately executes the given action on each element in the source sequence. + |
| FullGroupJoinTFirst, TSecond, TKey(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey) | + Performs a Full Group Join between the first and second sequences. + |
| FullGroupJoinTFirst, TSecond, TKey(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, IEqualityComparerTKey) | + Performs a Full Group Join between the first and second sequences. + |
| FullGroupJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTKey, IEnumerableTFirst, IEnumerableTSecond, TResult) | + Performs a full group-join between two sequences. + |
| FullGroupJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTKey, IEnumerableTFirst, IEnumerableTSecond, TResult, IEqualityComparerTKey) | + Performs a full group-join between two sequences. + |
| GroupAdjacentTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Groups the adjacent elements of a sequence according to a + specified key selector function. + |
| GroupAdjacentTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + Groups the adjacent elements of a sequence according to a + specified key selector function and compares the keys by using a + specified comparer. + |
| GroupAdjacentTSource, TKey, TElement(IEnumerableTSource, FuncTSource, TKey, FuncTSource, TElement) | + Groups the adjacent elements of a sequence according to a + specified key selector function and projects the elements for + each group by using a specified function. + |
| GroupAdjacentTSource, TKey, TResult(IEnumerableTSource, FuncTSource, TKey, FuncTKey, IEnumerableTSource, TResult) | + Groups the adjacent elements of a sequence according to a + specified key selector function. The keys are compared by using + a comparer and each group's elements are projected by using a + specified function. + |
| GroupAdjacentTSource, TKey, TElement(IEnumerableTSource, FuncTSource, TKey, FuncTSource, TElement, IEqualityComparerTKey) | + Groups the adjacent elements of a sequence according to a + specified key selector function. The keys are compared by using + a comparer and each group's elements are projected by using a + specified function. + |
| GroupAdjacentTSource, TKey, TResult(IEnumerableTSource, FuncTSource, TKey, FuncTKey, IEnumerableTSource, TResult, IEqualityComparerTKey) | + Groups the adjacent elements of a sequence according to a + specified key selector function. The keys are compared by using + a comparer and each group's elements are projected by using a + specified function. + |
| IndexByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + 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. + |
| IndexByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + 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. + |
| IndexTSource(IEnumerableTSource) | + Returns a sequence of KeyValuePairTKey, TValue + where the key is the zero-based index of the value in the source + sequence. + |
| IndexTSource(IEnumerableTSource, Int32) | + Returns a sequence of KeyValuePairTKey, TValue + where the key is the index of the value in the source sequence. + An additional parameter specifies the starting index. + |
| LagTSource, TResult(IEnumerableTSource, Int32, FuncTSource, TSource, TResult) | + Produces a projection of a sequence by evaluating pairs of elements separated by a + negative offset. + |
| LagTSource, TResult(IEnumerableTSource, Int32, TSource, FuncTSource, TSource, TResult) | + Produces a projection of a sequence by evaluating pairs of elements separated by a + negative offset. + |
| LeadTSource, TResult(IEnumerableTSource, Int32, FuncTSource, TSource, TResult) | + Produces a projection of a sequence by evaluating pairs of elements separated by a + positive offset. + |
| LeadTSource, TResult(IEnumerableTSource, Int32, TSource, FuncTSource, TSource, TResult) | + Produces a projection of a sequence by evaluating pairs of elements separated by a + positive offset. + |
| MaxByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Returns the maximal elements of the given sequence, based on + the given projection. + |
| MaxByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) | + Returns the maximal elements of the given sequence, based on + the given projection and the specified comparer for projected values. + |
| MinByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Returns the minimal elements of the given sequence, based on + the given projection. + |
| MinByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) | + Returns the minimal elements of the given sequence, based on + the given projection and the specified comparer for projected values. + |
| OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection) | + Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key + |
| OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection) | + Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key + |
| OrderedMergeT(IEnumerableT, IEnumerableT) | + Merges two ordered sequences into one. Where the elements equal + in both sequences, the element from the first sequence is + returned in the resulting sequence. + |
| OrderedMergeT(IEnumerableT, IEnumerableT, IComparerT) | + Merges two ordered sequences into one with an additional + parameter specifying how to compare the elements of the + sequences. Where the elements equal in both sequences, the + element from the first sequence is returned in the resulting + sequence. + |
| OrderedMergeT, TKey(IEnumerableT, IEnumerableT, FuncT, TKey) | + Merges two ordered sequences into one with an additional + parameter specifying the element key by which the sequences are + ordered. Where the keys equal in both sequences, the + element from the first sequence is returned in the resulting + sequence. + |
| OrderedMergeT, TKey, TResult(IEnumerableT, IEnumerableT, FuncT, TKey, FuncT, TResult, FuncT, TResult, FuncT, T, TResult) | + Merges two ordered sequences into one. Additional parameters + specify the element key by which the sequences are ordered, + the result when element is found in first sequence but not in + the second, the result when element is found in second sequence + but not in the first and the result when elements are found in + both sequences. + |
| OrderedMergeT, TKey, TResult(IEnumerableT, IEnumerableT, FuncT, TKey, FuncT, TResult, FuncT, TResult, FuncT, T, TResult, IComparerTKey) | + Merges two ordered sequences into one. Additional parameters + specify the element key by which the sequences are ordered, + the result when element is found in first sequence but not in + the second, the result when element is found in second sequence + but not in the first, the result when elements are found in + both sequences and a method for comparing keys. + |
| OrderedMergeTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult) | + Merges two heterogeneous sequences ordered by a common key type + into a homogeneous one. Additional parameters specify the + element key by which the sequences are ordered, the result when + element is found in first sequence but not in the second and + the result when element is found in second sequence but not in + the first, the result when elements are found in both sequences. + |
| OrderedMergeTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult, IComparerTKey) | + Merges two heterogeneous sequences ordered by a common key type + into a homogeneous one. Additional parameters specify the + element key by which the sequences are ordered, the result when + element is found in first sequence but not in the second, + the result when element is found in second sequence but not in + the first, the result when elements are found in both sequences + and a method for comparing keys. + |
| PadTSource(IEnumerableTSource, Int32) | + Pads a sequence with default values if it is narrower (shorter + in length) than a given width. + |
| PadTSource(IEnumerableTSource, Int32, TSource) | + Pads a sequence with a given filler value if it is narrower (shorter + in length) than a given width. + |
| PadTSource(IEnumerableTSource, Int32, FuncInt32, TSource) | + Pads a sequence with a dynamic filler value if it is narrower (shorter + in length) than a given width. + |
| PadStartTSource(IEnumerableTSource, Int32) | + Pads a sequence with default values in the beginning if it is narrower (shorter + in length) than a given width. + |
| PadStartTSource(IEnumerableTSource, Int32, TSource) | + Pads a sequence with a given filler value in the beginning if it is narrower (shorter + in length) than a given width. + An additional parameter specifies the value to use for padding. + |
| PadStartTSource(IEnumerableTSource, Int32, FuncInt32, TSource) | + Pads a sequence with a dynamic filler value in the beginning if it is narrower (shorter + in length) than a given width. + An additional parameter specifies the function to calculate padding. + |
| RandomSubsetT(IEnumerableT, Int32) | + Returns a sequence of a specified size of random elements from the + original sequence. + |
| RandomSubsetT(IEnumerableT, Int32, Random) | + Returns a sequence of a specified size of random elements from the + original sequence. An additional parameter specifies a random + generator to be used for the random selection algorithm. + |
| RankByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Ranks each item in the sequence in descending ordering by a specified key using a default comparer + |
| RankByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) | + Ranks each item in a sequence using a specified key and a caller-supplied comparer + |
| RankTSource(IEnumerableTSource) | + Ranks each item in the sequence in descending ordering using a default comparer. + |
| RankTSource(IEnumerableTSource, IComparerTSource) | + Rank each item in the sequence using a caller-supplied comparer. + |
| RepeatT(IEnumerableT) | + Repeats the sequence forever. + |
| RepeatT(IEnumerableT, Int32) | + Repeats the sequence the specified number of times. + |
| RunLengthEncodeT(IEnumerableT) | + Run-length encodes a sequence by converting consecutive instances of the same element into + a KeyValuePair{T,int} representing the item and its occurrence count. + |
| RunLengthEncodeT(IEnumerableT, IEqualityComparerT) | + Run-length encodes a sequence by converting consecutive instances of the same element into + a KeyValuePair{T,int} representing the item and its occurrence count. This overload + uses a custom equality comparer to identify equivalent items. + |
| ScanByTSource, TKey, TState(IEnumerableTSource, FuncTSource, TKey, FuncTKey, TState, FuncTState, TKey, TSource, TState) | + Applies an accumulator function over sequence element keys, + returning the keys along with intermediate accumulator states. + |
| ScanByTSource, TKey, TState(IEnumerableTSource, FuncTSource, TKey, FuncTKey, TState, FuncTState, TKey, TSource, TState, IEqualityComparerTKey) | + 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. + |
| ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) | + Performs a scan (inclusive prefix sum) on a sequence of elements. + |
| ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) | + Like AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) except returns + the sequence of intermediate results as well as the final one. + An additional parameter specifies a seed. + |
| ScanRightTSource(IEnumerableTSource, FuncTSource, TSource, TSource) | + Performs a right-associative scan (inclusive prefix) on a sequence of elements. + This operator is the right-associative version of the + ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator. + |
| ScanRightTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate) | + Performs a right-associative scan (inclusive prefix) on a sequence of elements. + The specified seed value is used as the initial accumulator value. + This operator is the right-associative version of the + ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) LINQ operator. + |
| SegmentT(IEnumerableT, FuncT, T, Int32, Boolean) | + Divides a sequence into multiple sequences by using a segment detector based on the original sequence + |
| SegmentT(IEnumerableT, FuncT, Boolean) | + Divides a sequence into multiple sequences by using a segment detector based on the original sequence + |
| SegmentT(IEnumerableT, FuncT, Int32, Boolean) | + Divides a sequence into multiple sequences by using a segment detector based on the original sequence + |
| ShuffleT(IEnumerableT) | + Returns a sequence of elements in random order from the original + sequence. + |
| ShuffleT(IEnumerableT, Random) | + 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. + |
| SortedMergeTSource(IEnumerableTSource, OrderByDirection, IEnumerableTSource) | + Merges two or more sequences that are in a common order (either ascending or descending) + into a single sequence that preserves that order. + |
| SortedMergeTSource(IEnumerableTSource, OrderByDirection, IComparerTSource, IEnumerableTSource) | + Merges two or more sequences that are in a common order (either ascending or descending) + into a single sequence that preserves that order. + |
| SplitTSource(IEnumerableTSource, TSource) | + Splits the source sequence by a separator. + |
| SplitTSource(IEnumerableTSource, FuncTSource, Boolean) | + Splits the source sequence by separator elements identified by a + function. + |
| SplitTSource(IEnumerableTSource, TSource, IEqualityComparerTSource) | + Splits the source sequence by a separator and then transforms the + splits into results. + |
| SplitTSource(IEnumerableTSource, TSource, Int32) | + Splits the source sequence by a separator given a maximum count of splits. + |
| SplitTSource(IEnumerableTSource, FuncTSource, Boolean, Int32) | + Splits the source sequence by separator elements identified by a + function, given a maximum count of splits. + |
| SplitTSource(IEnumerableTSource, TSource, IEqualityComparerTSource, Int32) | + Splits the source sequence by a separator, given a maximum count + of splits. A parameter specifies how the separator is compared + for equality. + |
| SplitTSource, TResult(IEnumerableTSource, TSource, FuncIEnumerableTSource, TResult) | + Splits the source sequence by a separator and then transforms + the splits into results. + |
| SplitTSource, TResult(IEnumerableTSource, FuncTSource, Boolean, FuncIEnumerableTSource, TResult) | + Splits the source sequence by separator elements identified by + a function and then transforms the splits into results. + |
| SplitTSource, TResult(IEnumerableTSource, TSource, IEqualityComparerTSource, FuncIEnumerableTSource, TResult) | + Splits the source sequence by a separator and then transforms the + splits into results. A parameter specifies how the separator is + compared for equality. + |
| SplitTSource, TResult(IEnumerableTSource, TSource, Int32, FuncIEnumerableTSource, TResult) | + Splits the source sequence by a separator, given a maximum count + of splits, and then transforms the splits into results. + |
| SplitTSource, TResult(IEnumerableTSource, FuncTSource, Boolean, Int32, FuncIEnumerableTSource, TResult) | + Splits the source sequence by separator elements identified by + a function, given a maximum count of splits, and then transforms + the splits into results. + |
| SplitTSource, TResult(IEnumerableTSource, TSource, IEqualityComparerTSource, Int32, FuncIEnumerableTSource, TResult) | + Splits the source sequence by a separator, given a maximum count + of splits, and then transforms the splits into results. A + parameter specifies how the separator is compared for equality. + |
| StartsWithT(IEnumerableT, IEnumerableT) | + Determines whether the beginning of the first sequence is + equivalent to the second sequence, using the default equality + comparer. + |
| StartsWithT(IEnumerableT, IEnumerableT, IEqualityComparerT) | + Determines whether the beginning of the first sequence is + equivalent to the second sequence, using the specified element + equality comparer. + |
| SubsetsT(IEnumerableT) | + Returns a sequence of IListT representing all of the subsets of any size + that are part of the original sequence. In mathematics, it is equivalent to the + power set of a set. + |
| SubsetsT(IEnumerableT, Int32) | + Returns a sequence of IListT representing all subsets of a given size + that are part of the original sequence. In mathematics, it is equivalent to the + combinations or k-subsets of a set. + |
| ThenByT, TKey(IOrderedEnumerableT, FuncT, TKey, OrderByDirection) | + Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key + |
| ThenByT, TKey(IOrderedEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection) | + Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key + |
| ToArrayByIndexT(IEnumerableT, FuncT, Int32) | + Creates an array from an IEnumerableT where a + function is used to determine the index at which an element will + be placed in the array. + |
| ToArrayByIndexT(IEnumerableT, Int32, FuncT, Int32) | + Creates an array of user-specified length from an + IEnumerableT where a function is used to determine + the index at which an element will be placed in the array. + |
| ToArrayByIndexT, TResult(IEnumerableT, FuncT, Int32, FuncT, TResult) | + Creates an array from an IEnumerableT where a + function is used to determine the index at which an element will + be placed in the array. The elements are projected into the array + via an additional function. + |
| ToArrayByIndexT, TResult(IEnumerableT, FuncT, Int32, FuncT, Int32, TResult) | + Creates an array from an IEnumerableT where a + function is used to determine the index at which an element will + be placed in the array. The elements are projected into the array + via an additional function. + |
| ToArrayByIndexT, TResult(IEnumerableT, Int32, FuncT, Int32, FuncT, TResult) | + Creates an array of user-specified length from an + IEnumerableT where a function is used to determine + the index at which an element will be placed in the array. The + elements are projected into the array via an additional function. + |
| ToArrayByIndexT, TResult(IEnumerableT, Int32, FuncT, Int32, FuncT, Int32, TResult) | + Creates an array of user-specified length from an + IEnumerableT where a function is used to determine + the index at which an element will be placed in the array. The + elements are projected into the array via an additional function. + |
| ToDataTableT(IEnumerableT) | + Converts a sequence to a DataTable object. + |
| ToDataTableT(IEnumerableT, ExpressionFuncT, Object) | + Appends elements in the sequence as rows of a given DataTable + object with a set of lambda expressions specifying which members (property + or field) of each element in the sequence will supply the column values. + |
| ToDataTableT, TTable(IEnumerableT, TTable) | + Appends elements in the sequence as rows of a given DataTable object. + |
| ToDataTableT, TTable(IEnumerableT, TTable, ExpressionFuncT, Object) | + Appends elements in the sequence as rows of a given DataTable + object with a set of lambda expressions specifying which members (property + or field) of each element in the sequence will supply the column values. + |
| ToDelimitedString(IEnumerableBoolean, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableByte, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableChar, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableDecimal, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableDouble, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableInt16, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableInt32, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableInt64, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableSByte, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableSingle, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableString, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableUInt16, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableUInt32, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableUInt64, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedStringTSource(IEnumerableTSource, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDictionaryTKey, TValue(IEnumerableKeyValuePairTKey, TValue) | + Creates a DictionaryTKey, TValue from a sequence of + KeyValuePairTKey, TValue elements. + |
| ToDictionaryTKey, TValue(IEnumerableValueTupleTKey, TValue) | + Creates a DictionaryTKey, TValue from a sequence of + tuples of 2 where the first item is the key and the second the + value. + |
| ToDictionaryTKey, TValue(IEnumerableKeyValuePairTKey, TValue, IEqualityComparerTKey) | + Creates a DictionaryTKey, TValue from a sequence of + KeyValuePairTKey, TValue elements. An additional + parameter specifies a comparer for keys. + |
| ToDictionaryTKey, TValue(IEnumerableValueTupleTKey, TValue, IEqualityComparerTKey) | + Creates a DictionaryTKey, TValue from a sequence of + tuples of 2 where the first item is the key and the second the + value. An additional parameter specifies a comparer for keys. + |
| ToHashSetTSource(IEnumerableTSource) | + Returns a HashSetT of the source items using the default equality + comparer for the type. + |
| ToHashSetTSource(IEnumerableTSource, IEqualityComparerTSource) | + Returns a HashSetT of the source items using the specified equality + comparer for the type. + |
| ToLookupTKey, TValue(IEnumerableKeyValuePairTKey, TValue) | + Creates a ILookupTKey, TElement from a sequence of + KeyValuePairTKey, TValue elements. + |
| ToLookupTKey, TValue(IEnumerableValueTupleTKey, TValue) | + Creates a LookupTKey, TElement from a sequence of + tuples of 2 where the first item is the key and the second the + value. + |
| ToLookupTKey, TValue(IEnumerableKeyValuePairTKey, TValue, IEqualityComparerTKey) | + Creates a ILookupTKey, TElement from a sequence of + KeyValuePairTKey, TValue elements. An additional + parameter specifies a comparer for keys. + |
| ToLookupTKey, TValue(IEnumerableValueTupleTKey, TValue, IEqualityComparerTKey) | + Creates a LookupTKey, TElement from a sequence of + tuples of 2 where the first item is the key and the second the + value. An additional parameter specifies a comparer for keys. + |
| TraceTSource(IEnumerableTSource) | + Traces the elements of a source sequence for diagnostics. + |
| TraceTSource(IEnumerableTSource, FuncTSource, String) | + Traces the elements of a source sequence for diagnostics using + a custom formatter. + |
| TraceTSource(IEnumerableTSource, String) | + Traces the elements of a source sequence for diagnostics using + custom formatting. + |
| ZipLongestTFirst, TSecond, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. 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. + |
| ZipLongestT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. 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. + |
| ZipLongestT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. 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. + |
| ZipShortestTFirst, TSecond, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. The resulting sequence + is as short as the shortest input sequence. + |
| ZipShortestT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. The resulting sequence + is as short as the shortest input sequence. + |
| ZipShortestT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. The resulting sequence + is as short as the shortest input sequence. + |
| AggregateRightTSource(IEnumerableTSource, FuncTSource, TSource, TSource) | + Applies a right-associative accumulator function over a sequence. + This operator is the right-associative version of the + AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator. + |
| AggregateRightTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate) | + Applies a right-associative accumulator function over a sequence. + The specified seed value is used as the initial accumulator value. + This operator is the right-associative version of the + AggregateTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate) LINQ operator. + |
| AggregateRightTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate, FuncTAccumulate, TResult) | + Applies a right-associative accumulator function over a sequence. + The specified seed value is used as the initial accumulator value, + and the specified function is used to select the result value. + This operator is the right-associative version of the + AggregateTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate, FuncTAccumulate, TResult) LINQ operator. + |
| AssertTSource(IEnumerableTSource, FuncTSource, Boolean) | + Asserts that all elements of a sequence meet a given condition + otherwise throws an Exception object. + |
| AssertTSource(IEnumerableTSource, FuncTSource, Boolean, FuncTSource, Exception) | + Asserts that all elements of a sequence meet a given condition + otherwise throws an Exception object. + |
| AssertCountTSource(IEnumerableTSource, Int32) | + Asserts that a source sequence contains a given count of elements. + |
| AssertCountTSource(IEnumerableTSource, Int32, FuncInt32, Int32, Exception) | + Asserts that a source sequence contains a given count of elements. + A parameter specifies the exception to be thrown. + |
| BatchTSource(IEnumerableTSource, Int32) | + Batches the source sequence into sized buckets. + |
| BatchTSource, TResult(IEnumerableTSource, Int32, FuncIEnumerableTSource, TResult) | + Batches the source sequence into sized buckets and applies a projection to each bucket. + |
| CartesianT1, T2, TResult(IEnumerableT1, IEnumerableT2, FuncT1, T2, TResult) | + 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. + |
| CartesianT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, T5, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, IEnumerableT5, FuncT1, T2, T3, T4, T5, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, T5, T6, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, IEnumerableT5, IEnumerableT6, FuncT1, T2, T3, T4, T5, T6, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, T5, T6, T7, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, IEnumerableT5, IEnumerableT6, IEnumerableT7, FuncT1, T2, T3, T4, T5, T6, T7, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, T5, T6, T7, T8, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, IEnumerableT5, IEnumerableT6, IEnumerableT7, IEnumerableT8, FuncT1, T2, T3, T4, T5, T6, T7, T8, TResult) | + 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. + |
| CountByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Applies a key-generating function to each element of a sequence and returns a sequence of + unique keys and their number of occurrences in the original sequence. + |
| CountByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + Applies a key-generating function to each element of a sequence and returns a sequence of + unique keys and their number of occurrences in the original sequence. + An additional argument specifies a comparer to use for testing equivalence of keys. + |
| DistinctByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Returns all distinct elements of the given source, where "distinctness" + is determined via a projection and the default equality comparer for the projected type. + |
| DistinctByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + Returns all distinct elements of the given source, where "distinctness" + is determined via a projection and the specified comparer for the projected type. + |
| EndsWithT(IEnumerableT, IEnumerableT) | + Determines whether the end of the first sequence is equivalent to + the second sequence, using the default equality comparer. + |
| EndsWithT(IEnumerableT, IEnumerableT, IEqualityComparerT) | + Determines whether the end of the first sequence is equivalent to + the second sequence, using the specified element equality comparer. + |
| EquiZipTFirst, TSecond, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. An exception is thrown + if the input sequences are of different lengths. + |
| EquiZipT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. An exception is thrown + if the input sequences are of different lengths. + |
| EquiZipT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. An exception is thrown + if the input sequences are of different lengths. + |
| ExceptByTSource, TKey(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey) | + Returns the set of elements in the first sequence which aren't + in the second sequence, according to a given key selector. + |
| ExceptByTSource, TKey(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + Returns the set of elements in the first sequence which aren't + in the second sequence, according to a given key selector. + |
| FallbackIfEmptyT(IEnumerableT, T) | + Returns the elements of the specified sequence or the specified + value in a singleton collection if the sequence is empty. + |
| FallbackIfEmptyT(IEnumerableT, T) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence from an array of values. + |
| FallbackIfEmptyT(IEnumerableT, IEnumerableT) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence of values. + |
| FallbackIfEmptyT(IEnumerableT, T, T) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence of values. + |
| FallbackIfEmptyT(IEnumerableT, T, T, T) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence of values. + |
| FallbackIfEmptyT(IEnumerableT, T, T, T, T) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence of values. + |
| FillBackwardT(IEnumerableT) | + Returns a sequence with each null reference or value in the source + replaced with the following non-null reference or value in + that sequence. + |
| FillBackwardT(IEnumerableT, FuncT, Boolean) | + Returns a sequence with each missing element in the source replaced + with the following non-missing element in that sequence. An + additional parameter specifies a function used to determine if an + element is considered missing or not. + |
| FillBackwardT(IEnumerableT, FuncT, Boolean, FuncT, T, T) | + Returns a sequence with each missing element in the source replaced + with the following non-missing element in that sequence. Additional + parameters specify two functions, one used to determine if an + element is considered missing or not and another to provide the + replacement for the missing element. + |
| FillForwardT(IEnumerableT) | + Returns a sequence with each null reference or value in the source + replaced with the previous non-null reference or value seen in + that sequence. + |
| FillForwardT(IEnumerableT, FuncT, Boolean) | + Returns a sequence with each missing element in the source replaced + with the previous non-missing element seen in that sequence. An + additional parameter specifies a function used to determine if an + element is considered missing or not. + |
| FillForwardT(IEnumerableT, FuncT, Boolean, FuncT, T, T) | + Returns a sequence with each missing element in the source replaced + with one based on the previous non-missing element seen in that + sequence. Additional parameters specify two functions, one used to + determine if an element is considered missing or not and another + to provide the replacement for the missing element. + |
| Flatten(IEnumerable) | + Flattens a sequence containing arbitrarily-nested sequences. + |
| Flatten(IEnumerable, FuncIEnumerable, Boolean) | + Flattens a sequence containing arbitrarily-nested sequences. An + additional parameter specifies a predicate function used to + determine whether a nested IEnumerable should be + flattened or not. + |
| Flatten(IEnumerable, FuncObject, IEnumerable) | + Flattens a sequence containing arbitrarily-nested sequences. An + additional parameter specifies a function that projects an inner + sequence via a property of an object. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 16 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 15 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 14 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 13 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 12 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 11 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 10 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 9 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 8 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 7 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 6 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 5 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 4 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, TResult) | + Returns the result of applying a function to a sequence of + 3 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, TResult) | + Returns the result of applying a function to a sequence of + 2 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, TResult) | + Returns the result of applying a function to a sequence of + 1 element. + |
| ForEachT(IEnumerableT, ActionT, Int32) | + Immediately executes the given action on each element in the source sequence. + Each element's index is used in the logic of the action. + |
| ForEachT(IEnumerableT, ActionT) | + Immediately executes the given action on each element in the source sequence. + |
| FromT(FuncT) | + Returns a single-element sequence containing the result of invoking the function. + |
| FromT(FuncT) | + Returns a sequence containing the values resulting from invoking (in order) each function in the source sequence of functions. + |
| FromT(FuncT, FuncT) | + Returns a sequence containing the result of invoking each parameter function in order. + |
| FromT(FuncT, FuncT, FuncT) | + Returns a sequence containing the result of invoking each parameter function in order. + |
| FullGroupJoinTFirst, TSecond, TKey(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey) | + Performs a Full Group Join between the first and second sequences. + |
| FullGroupJoinTFirst, TSecond, TKey(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, IEqualityComparerTKey) | + Performs a Full Group Join between the first and second sequences. + |
| FullGroupJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTKey, IEnumerableTFirst, IEnumerableTSecond, TResult) | + Performs a full group-join between two sequences. + |
| FullGroupJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTKey, IEnumerableTFirst, IEnumerableTSecond, TResult, IEqualityComparerTKey) | + Performs a full group-join between two sequences. + |
| GroupAdjacentTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Groups the adjacent elements of a sequence according to a + specified key selector function. + |
| GroupAdjacentTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + Groups the adjacent elements of a sequence according to a + specified key selector function and compares the keys by using a + specified comparer. + |
| GroupAdjacentTSource, TKey, TElement(IEnumerableTSource, FuncTSource, TKey, FuncTSource, TElement) | + Groups the adjacent elements of a sequence according to a + specified key selector function and projects the elements for + each group by using a specified function. + |
| GroupAdjacentTSource, TKey, TResult(IEnumerableTSource, FuncTSource, TKey, FuncTKey, IEnumerableTSource, TResult) | + Groups the adjacent elements of a sequence according to a + specified key selector function. The keys are compared by using + a comparer and each group's elements are projected by using a + specified function. + |
| GroupAdjacentTSource, TKey, TElement(IEnumerableTSource, FuncTSource, TKey, FuncTSource, TElement, IEqualityComparerTKey) | + Groups the adjacent elements of a sequence according to a + specified key selector function. The keys are compared by using + a comparer and each group's elements are projected by using a + specified function. + |
| GroupAdjacentTSource, TKey, TResult(IEnumerableTSource, FuncTSource, TKey, FuncTKey, IEnumerableTSource, TResult, IEqualityComparerTKey) | + Groups the adjacent elements of a sequence according to a + specified key selector function. The keys are compared by using + a comparer and each group's elements are projected by using a + specified function. + |
| IndexTSource(IEnumerableTSource) | + Returns a sequence of KeyValuePairTKey, TValue + where the key is the zero-based index of the value in the source + sequence. + |
| IndexTSource(IEnumerableTSource, Int32) | + Returns a sequence of KeyValuePairTKey, TValue + where the key is the index of the value in the source sequence. + An additional parameter specifies the starting index. + |
| IndexByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + 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. + |
| IndexByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + 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. + |
| LagTSource, TResult(IEnumerableTSource, Int32, FuncTSource, TSource, TResult) | + Produces a projection of a sequence by evaluating pairs of elements separated by a + negative offset. + |
| LagTSource, TResult(IEnumerableTSource, Int32, TSource, FuncTSource, TSource, TResult) | + Produces a projection of a sequence by evaluating pairs of elements separated by a + negative offset. + |
| LeadTSource, TResult(IEnumerableTSource, Int32, FuncTSource, TSource, TResult) | + Produces a projection of a sequence by evaluating pairs of elements separated by a + positive offset. + |
| LeadTSource, TResult(IEnumerableTSource, Int32, TSource, FuncTSource, TSource, TResult) | + Produces a projection of a sequence by evaluating pairs of elements separated by a + positive offset. + |
| MaxByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Returns the maximal elements of the given sequence, based on + the given projection. + |
| MaxByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) | + Returns the maximal elements of the given sequence, based on + the given projection and the specified comparer for projected values. + |
| MinByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Returns the minimal elements of the given sequence, based on + the given projection. + |
| MinByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) | + Returns the minimal elements of the given sequence, based on + the given projection and the specified comparer for projected values. + |
| OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection) | + Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key + |
| OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection) | + Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key + |
| OrderedMergeT(IEnumerableT, IEnumerableT) | + Merges two ordered sequences into one. Where the elements equal + in both sequences, the element from the first sequence is + returned in the resulting sequence. + |
| OrderedMergeT(IEnumerableT, IEnumerableT, IComparerT) | + Merges two ordered sequences into one with an additional + parameter specifying how to compare the elements of the + sequences. Where the elements equal in both sequences, the + element from the first sequence is returned in the resulting + sequence. + |
| OrderedMergeT, TKey(IEnumerableT, IEnumerableT, FuncT, TKey) | + Merges two ordered sequences into one with an additional + parameter specifying the element key by which the sequences are + ordered. Where the keys equal in both sequences, the + element from the first sequence is returned in the resulting + sequence. + |
| OrderedMergeT, TKey, TResult(IEnumerableT, IEnumerableT, FuncT, TKey, FuncT, TResult, FuncT, TResult, FuncT, T, TResult) | + Merges two ordered sequences into one. Additional parameters + specify the element key by which the sequences are ordered, + the result when element is found in first sequence but not in + the second, the result when element is found in second sequence + but not in the first and the result when elements are found in + both sequences. + |
| OrderedMergeT, TKey, TResult(IEnumerableT, IEnumerableT, FuncT, TKey, FuncT, TResult, FuncT, TResult, FuncT, T, TResult, IComparerTKey) | + Merges two ordered sequences into one. Additional parameters + specify the element key by which the sequences are ordered, + the result when element is found in first sequence but not in + the second, the result when element is found in second sequence + but not in the first, the result when elements are found in + both sequences and a method for comparing keys. + |
| OrderedMergeTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult) | + Merges two heterogeneous sequences ordered by a common key type + into a homogeneous one. Additional parameters specify the + element key by which the sequences are ordered, the result when + element is found in first sequence but not in the second and + the result when element is found in second sequence but not in + the first, the result when elements are found in both sequences. + |
| OrderedMergeTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult, IComparerTKey) | + Merges two heterogeneous sequences ordered by a common key type + into a homogeneous one. Additional parameters specify the + element key by which the sequences are ordered, the result when + element is found in first sequence but not in the second, + the result when element is found in second sequence but not in + the first, the result when elements are found in both sequences + and a method for comparing keys. + |
| PadTSource(IEnumerableTSource, Int32) | + Pads a sequence with default values if it is narrower (shorter + in length) than a given width. + |
| PadTSource(IEnumerableTSource, Int32, TSource) | + Pads a sequence with a given filler value if it is narrower (shorter + in length) than a given width. + |
| PadTSource(IEnumerableTSource, Int32, FuncInt32, TSource) | + Pads a sequence with a dynamic filler value if it is narrower (shorter + in length) than a given width. + |
| PadStartTSource(IEnumerableTSource, Int32) | + Pads a sequence with default values in the beginning if it is narrower (shorter + in length) than a given width. + |
| PadStartTSource(IEnumerableTSource, Int32, TSource) | + Pads a sequence with a given filler value in the beginning if it is narrower (shorter + in length) than a given width. + An additional parameter specifies the value to use for padding. + |
| PadStartTSource(IEnumerableTSource, Int32, FuncInt32, TSource) | + Pads a sequence with a dynamic filler value in the beginning if it is narrower (shorter + in length) than a given width. + An additional parameter specifies the function to calculate padding. + |
| Random | + Returns an infinite sequence of random integers using the standard + .NET random number generator. + |
| Random(Int32) | + Returns an infinite sequence of random integers between zero and + a given maximum. + |
| Random(Random) | + Returns an infinite sequence of random integers using the supplied + random number generator. + |
| Random(Int32, Int32) | + Returns an infinite sequence of random integers between a given + minimum and a maximum. + |
| Random(Random, Int32) | + Returns an infinite sequence of random integers between zero and a + given maximum using the supplied random number generator. + |
| Random(Random, Int32, Int32) | + Returns an infinite sequence of random integers between a given + minimum and a maximum using the supplied random number generator. + |
| RandomDouble | + Returns an infinite sequence of random double values between 0.0 and 1.0 + |
| RandomDouble(Random) | + Returns an infinite sequence of random double values between 0.0 and 1.0 + using the supplied random number generator. + |
| RandomSubsetT(IEnumerableT, Int32) | + Returns a sequence of a specified size of random elements from the + original sequence. + |
| RandomSubsetT(IEnumerableT, Int32, Random) | + Returns a sequence of a specified size of random elements from the + original sequence. An additional parameter specifies a random + generator to be used for the random selection algorithm. + |
| RankTSource(IEnumerableTSource) | + Ranks each item in the sequence in descending ordering using a default comparer. + |
| RankTSource(IEnumerableTSource, IComparerTSource) | + Rank each item in the sequence using a caller-supplied comparer. + |
| RankByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Ranks each item in the sequence in descending ordering by a specified key using a default comparer + |
| RankByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) | + Ranks each item in a sequence using a specified key and a caller-supplied comparer + |
| RepeatT(IEnumerableT) | + Repeats the sequence forever. + |
| RepeatT(IEnumerableT, Int32) | + Repeats the sequence the specified number of times. + |
| RunLengthEncodeT(IEnumerableT) | + Run-length encodes a sequence by converting consecutive instances of the same element into + a KeyValuePair{T,int} representing the item and its occurrence count. + |
| RunLengthEncodeT(IEnumerableT, IEqualityComparerT) | + Run-length encodes a sequence by converting consecutive instances of the same element into + a KeyValuePair{T,int} representing the item and its occurrence count. This overload + uses a custom equality comparer to identify equivalent items. + |
| ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) | + Performs a scan (inclusive prefix sum) on a sequence of elements. + |
| ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) | + Like AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) except returns + the sequence of intermediate results as well as the final one. + An additional parameter specifies a seed. + |
| ScanByTSource, TKey, TState(IEnumerableTSource, FuncTSource, TKey, FuncTKey, TState, FuncTState, TKey, TSource, TState) | + Applies an accumulator function over sequence element keys, + returning the keys along with intermediate accumulator states. + |
| ScanByTSource, TKey, TState(IEnumerableTSource, FuncTSource, TKey, FuncTKey, TState, FuncTState, TKey, TSource, TState, IEqualityComparerTKey) | + 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. + |
| ScanRightTSource(IEnumerableTSource, FuncTSource, TSource, TSource) | + Performs a right-associative scan (inclusive prefix) on a sequence of elements. + This operator is the right-associative version of the + ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator. + |
| ScanRightTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate) | + Performs a right-associative scan (inclusive prefix) on a sequence of elements. + The specified seed value is used as the initial accumulator value. + This operator is the right-associative version of the + ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) LINQ operator. + |
| SegmentT(IEnumerableT, FuncT, T, Int32, Boolean) | + Divides a sequence into multiple sequences by using a segment detector based on the original sequence + |
| SegmentT(IEnumerableT, FuncT, Boolean) | + Divides a sequence into multiple sequences by using a segment detector based on the original sequence + |
| SegmentT(IEnumerableT, FuncT, Int32, Boolean) | + Divides a sequence into multiple sequences by using a segment detector based on the original sequence + |
| Sequence(Int32, Int32) | + Generates a sequence of integral numbers within the (inclusive) specified range. + If sequence is ascending the step is +1, otherwise -1. + |
| Sequence(Int32, Int32, Int32) | + Generates a sequence of integral numbers within the (inclusive) specified range. + An additional parameter specifies the steps in which the integers of the sequence increase or decrease. + |
| ShuffleT(IEnumerableT) | + Returns a sequence of elements in random order from the original + sequence. + |
| ShuffleT(IEnumerableT, Random) | + 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. + |
| SortedMergeTSource(IEnumerableTSource, OrderByDirection, IEnumerableTSource) | + Merges two or more sequences that are in a common order (either ascending or descending) + into a single sequence that preserves that order. + |
| SortedMergeTSource(IEnumerableTSource, OrderByDirection, IComparerTSource, IEnumerableTSource) | + Merges two or more sequences that are in a common order (either ascending or descending) + into a single sequence that preserves that order. + |
| SplitTSource(IEnumerableTSource, TSource) | + Splits the source sequence by a separator. + |
| SplitTSource(IEnumerableTSource, FuncTSource, Boolean) | + Splits the source sequence by separator elements identified by a + function. + |
| SplitTSource(IEnumerableTSource, TSource, IEqualityComparerTSource) | + Splits the source sequence by a separator and then transforms the + splits into results. + |
| SplitTSource(IEnumerableTSource, TSource, Int32) | + Splits the source sequence by a separator given a maximum count of splits. + |
| SplitTSource(IEnumerableTSource, FuncTSource, Boolean, Int32) | + Splits the source sequence by separator elements identified by a + function, given a maximum count of splits. + |
| SplitTSource(IEnumerableTSource, TSource, IEqualityComparerTSource, Int32) | + Splits the source sequence by a separator, given a maximum count + of splits. A parameter specifies how the separator is compared + for equality. + |
| SplitTSource, TResult(IEnumerableTSource, TSource, FuncIEnumerableTSource, TResult) | + Splits the source sequence by a separator and then transforms + the splits into results. + |
| SplitTSource, TResult(IEnumerableTSource, FuncTSource, Boolean, FuncIEnumerableTSource, TResult) | + Splits the source sequence by separator elements identified by + a function and then transforms the splits into results. + |
| SplitTSource, TResult(IEnumerableTSource, TSource, IEqualityComparerTSource, FuncIEnumerableTSource, TResult) | + Splits the source sequence by a separator and then transforms the + splits into results. A parameter specifies how the separator is + compared for equality. + |
| SplitTSource, TResult(IEnumerableTSource, TSource, Int32, FuncIEnumerableTSource, TResult) | + Splits the source sequence by a separator, given a maximum count + of splits, and then transforms the splits into results. + |
| SplitTSource, TResult(IEnumerableTSource, FuncTSource, Boolean, Int32, FuncIEnumerableTSource, TResult) | + Splits the source sequence by separator elements identified by + a function, given a maximum count of splits, and then transforms + the splits into results. + |
| SplitTSource, TResult(IEnumerableTSource, TSource, IEqualityComparerTSource, Int32, FuncIEnumerableTSource, TResult) | + Splits the source sequence by a separator, given a maximum count + of splits, and then transforms the splits into results. A + parameter specifies how the separator is compared for equality. + |
| StartsWithT(IEnumerableT, IEnumerableT) | + Determines whether the beginning of the first sequence is + equivalent to the second sequence, using the default equality + comparer. + |
| StartsWithT(IEnumerableT, IEnumerableT, IEqualityComparerT) | + Determines whether the beginning of the first sequence is + equivalent to the second sequence, using the specified element + equality comparer. + |
| SubsetsT(IEnumerableT) | + Returns a sequence of IListT representing all of the subsets of any size + that are part of the original sequence. In mathematics, it is equivalent to the + power set of a set. + |
| SubsetsT(IEnumerableT, Int32) | + Returns a sequence of IListT representing all subsets of a given size + that are part of the original sequence. In mathematics, it is equivalent to the + combinations or k-subsets of a set. + |
| ThenByT, TKey(IOrderedEnumerableT, FuncT, TKey, OrderByDirection) | + Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key + |
| ThenByT, TKey(IOrderedEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection) | + Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key + |
| ToArrayByIndexT(IEnumerableT, FuncT, Int32) | + Creates an array from an IEnumerableT where a + function is used to determine the index at which an element will + be placed in the array. + |
| ToArrayByIndexT(IEnumerableT, Int32, FuncT, Int32) | + Creates an array of user-specified length from an + IEnumerableT where a function is used to determine + the index at which an element will be placed in the array. + |
| ToArrayByIndexT, TResult(IEnumerableT, FuncT, Int32, FuncT, TResult) | + Creates an array from an IEnumerableT where a + function is used to determine the index at which an element will + be placed in the array. The elements are projected into the array + via an additional function. + |
| ToArrayByIndexT, TResult(IEnumerableT, FuncT, Int32, FuncT, Int32, TResult) | + Creates an array from an IEnumerableT where a + function is used to determine the index at which an element will + be placed in the array. The elements are projected into the array + via an additional function. + |
| ToArrayByIndexT, TResult(IEnumerableT, Int32, FuncT, Int32, FuncT, TResult) | + Creates an array of user-specified length from an + IEnumerableT where a function is used to determine + the index at which an element will be placed in the array. The + elements are projected into the array via an additional function. + |
| ToArrayByIndexT, TResult(IEnumerableT, Int32, FuncT, Int32, FuncT, Int32, TResult) | + Creates an array of user-specified length from an + IEnumerableT where a function is used to determine + the index at which an element will be placed in the array. The + elements are projected into the array via an additional function. + |
| ToDataTableT(IEnumerableT) | + Converts a sequence to a DataTable object. + |
| ToDataTableT(IEnumerableT, ExpressionFuncT, Object) | + Appends elements in the sequence as rows of a given DataTable + object with a set of lambda expressions specifying which members (property + or field) of each element in the sequence will supply the column values. + |
| ToDataTableT, TTable(IEnumerableT, TTable) | + Appends elements in the sequence as rows of a given DataTable object. + |
| ToDataTableT, TTable(IEnumerableT, TTable, ExpressionFuncT, Object) | + Appends elements in the sequence as rows of a given DataTable + object with a set of lambda expressions specifying which members (property + or field) of each element in the sequence will supply the column values. + |
| ToDelimitedString(IEnumerableBoolean, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableByte, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableChar, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableDecimal, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableDouble, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableInt16, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableInt32, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableInt64, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableSByte, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableSingle, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableString, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableUInt16, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableUInt32, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableUInt64, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedStringTSource(IEnumerableTSource, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDictionaryTKey, TValue(IEnumerableKeyValuePairTKey, TValue) | + Creates a DictionaryTKey, TValue from a sequence of + KeyValuePairTKey, TValue elements. + |
| ToDictionaryTKey, TValue(IEnumerableValueTupleTKey, TValue) | + Creates a DictionaryTKey, TValue from a sequence of + tuples of 2 where the first item is the key and the second the + value. + |
| ToDictionaryTKey, TValue(IEnumerableKeyValuePairTKey, TValue, IEqualityComparerTKey) | + Creates a DictionaryTKey, TValue from a sequence of + KeyValuePairTKey, TValue elements. An additional + parameter specifies a comparer for keys. + |
| ToDictionaryTKey, TValue(IEnumerableValueTupleTKey, TValue, IEqualityComparerTKey) | + Creates a DictionaryTKey, TValue from a sequence of + tuples of 2 where the first item is the key and the second the + value. An additional parameter specifies a comparer for keys. + |
| ToHashSetTSource(IEnumerableTSource) | + Returns a HashSetT of the source items using the default equality + comparer for the type. + |
| ToHashSetTSource(IEnumerableTSource, IEqualityComparerTSource) | + Returns a HashSetT of the source items using the specified equality + comparer for the type. + |
| ToLookupTKey, TValue(IEnumerableKeyValuePairTKey, TValue) | + Creates a ILookupTKey, TElement from a sequence of + KeyValuePairTKey, TValue elements. + |
| ToLookupTKey, TValue(IEnumerableValueTupleTKey, TValue) | + Creates a Lookup from a sequence of + tuples of 2 where the first item is the key and the second the + value. + |
| ToLookupTKey, TValue(IEnumerableKeyValuePairTKey, TValue, IEqualityComparerTKey) | + Creates a ILookupTKey, TElement from a sequence of + KeyValuePairTKey, TValue elements. An additional + parameter specifies a comparer for keys. + |
| ToLookupTKey, TValue(IEnumerableValueTupleTKey, TValue, IEqualityComparerTKey) | + Creates a Lookup from a sequence of + tuples of 2 where the first item is the key and the second the + value. An additional parameter specifies a comparer for keys. + |
| TraceTSource(IEnumerableTSource) | + Traces the elements of a source sequence for diagnostics. + |
| TraceTSource(IEnumerableTSource, FuncTSource, String) | + Traces the elements of a source sequence for diagnostics using + a custom formatter. + |
| TraceTSource(IEnumerableTSource, String) | + Traces the elements of a source sequence for diagnostics using + custom formatting. + |
| ZipLongestTFirst, TSecond, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. 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. + |
| ZipLongestT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. 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. + |
| ZipLongestT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. 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. + |
| ZipShortestTFirst, TSecond, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. The resulting sequence + is as short as the shortest input sequence. + |
| ZipShortestT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. The resulting sequence + is as short as the shortest input sequence. + |
| ZipShortestT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. The resulting sequence + is as short as the shortest input sequence. + |
| SequenceException | + Initializes a new instance of the SequenceException class. + |
| SequenceException(String) | + Initializes a new instance of the SequenceException class + with a given error message. + |
| SequenceException(SerializationInfo, StreamingContext) | + Initializes a new instance of the SequenceException class + with serialized data. + |
| SequenceException(String, Exception) | + Initializes a new instance of the SequenceException class + with a given error message and a reference to the inner exception + that is the cause of the exception. + |
public int? MaxConcurrency { get; }Public ReadOnly Property MaxConcurrency As Integer?
+ Getpublic:
+property Nullable<int> MaxConcurrency {
+ Nullable<int> get ();
+}member MaxConcurrency : Nullable<int> with getpublic bool PreserveOrder { get; }Public ReadOnly Property PreserveOrder As Boolean
+ Getpublic:
+property bool PreserveOrder {
+ bool get ();
+}member PreserveOrder : bool with getpublic TaskScheduler Scheduler { get; }Public ReadOnly Property Scheduler As TaskScheduler
+ Getpublic:
+property TaskScheduler^ Scheduler {
+ TaskScheduler^ get ();
+}member Scheduler : TaskScheduler with getAwaitQueryOptions Options { get; }ReadOnly Property Options As AwaitQueryOptions
+ Getproperty AwaitQueryOptions^ Options {
+ AwaitQueryOptions^ get ();
+}abstract Options : AwaitQueryOptions with get| MaxConcurrency | + Gets a positive (non-zero) integer that specifies the maximum + number of asynchronous operations to have in-flight concurrently + or null to mean unlimited concurrency. + |
| PreserveOrder | + Get a Boolean that determines whether results should be ordered + the same as the source. + |
| Scheduler | + Get the scheduler to be used for any workhorse task. + |
| Options | + The options that determine how the sequence evaluation behaves when + it is iterated. + |
| Count | Gets the number of elements contained in the ICollectionT. (Inherited from ICollectionT) |
| IsReadOnly | Gets a value indicating whether the ICollectionT is read-only. (Inherited from ICollectionT) |
| Item | Gets or sets the element at the specified index. (Inherited from IListT) |
| Data | Gets a collection of key/value pairs that provide additional user-defined information about the exception. (Inherited from Exception) |
| HelpLink | Gets or sets a link to the help file associated with this exception. (Inherited from Exception) |
| HResult | Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception. (Inherited from Exception) |
| InnerException | Gets the Exception instance that caused the current exception. (Inherited from Exception) |
| Message | Gets a message that describes the current exception. (Inherited from Exception) |
| Source | Gets or sets the name of the application or the object that causes the error. (Inherited from Exception) |
| StackTrace | Gets a string representation of the immediate frames on the call stack. (Inherited from Exception) |
| TargetSite | Gets the method that throws the current exception. (Inherited from Exception) |
+ Provides a set of static methods for querying objects that + implement IAsyncEnumerableT.
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.
public static class ExperimentalEnumerable<ExtensionAttribute>
+Public NotInheritable Class ExperimentalEnumerable[ExtensionAttribute]
+public ref class ExperimentalEnumerable abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type ExperimentalEnumerable = class end| MergeT(IEnumerableIAsyncEnumerableT) | + Concurrently merges all the elements of multiple asynchronous streams into a single + asynchronous stream. + |
| MergeT(IEnumerableIAsyncEnumerableT, Int32) | + Concurrently merges all the elements of multiple asynchronous streams into a single + asynchronous stream. An additional parameter specifies the maximum concurrent operations + that may be in flight at any give time. + |
public sealed class AwaitQueryOptionsPublic NotInheritable Class AwaitQueryOptionspublic ref class AwaitQueryOptions sealed[<SealedAttribute>]
+type AwaitQueryOptions = class end| MaxConcurrency | + Gets a positive (non-zero) integer that specifies the maximum + number of asynchronous operations to have in-flight concurrently + or null to mean unlimited concurrency. + |
| PreserveOrder | + Get a Boolean that determines whether results should be ordered + the same as the source. + |
| Scheduler | + Get the scheduler to be used for any workhorse task. + |
| Equals | Determines whether the specified object is equal to the current object. (Inherited from Object) |
| GetHashCode | Serves as the default hash function. (Inherited from Object) |
| GetType | Gets the Type of the current instance. (Inherited from Object) |
| ToString | Returns a string that represents the current object. (Inherited from Object) |
| WithMaxConcurrency | + Returns new options with the given concurrency limit. + |
| WithPreserveOrder | + Returns new options with the given Boolean indicating whether or + not the results should be returned in the order of the source. + |
| WithScheduler | + Returns new options with the given scheduler. + |
| Default | + The default options used for a query whose results evaluate + asynchronously. + |
+ Provides a set of static methods for querying objects that + implement IEnumerableT.
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.
public static class ExperimentalEnumerable<ExtensionAttribute>
+Public NotInheritable Class ExperimentalEnumerable[ExtensionAttribute]
+public ref class ExperimentalEnumerable abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type ExperimentalEnumerable = class endpublic interface IAwaitQuery<out T> : IEnumerable<T>,
+ IEnumerable
+Public Interface IAwaitQuery(Of Out T)
+ Inherits IEnumerable(Of T), IEnumerablegeneric<typename T>
+public interface class IAwaitQuery : IEnumerable<T>,
+ IEnumerabletype IAwaitQuery<'T> =
+ interface
+ interface IEnumerable<'T>
+ interface IEnumerable
+ end| Options | + The options that determine how the sequence evaluation behaves when + it is iterated. + |
| GetEnumerator | Returns an enumerator that iterates through the collection. (Inherited from IEnumerableT) |
| WithOptions | + Returns a new query that will use the given options. + |
| AggregateT, TResult1, TResult2, TResult |
+ Applies two accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TResult |
+ Applies two accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TResult |
+ Applies two accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult |
+ Applies three accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TResult |
+ Applies three accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TResult |
+ Applies three accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult |
+ Applies four accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult |
+ Applies four accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult |
+ Applies four accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult |
+ Applies five accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult |
+ Applies five accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult |
+ Applies five accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult |
+ Applies six accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult |
+ Applies six accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult |
+ Applies six accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult |
+ Applies seven accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult |
+ Applies seven accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult |
+ Applies seven accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult8, TResult |
+ Applies eight accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult |
+ Applies eight accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult |
+ Applies eight accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateRightT |
+ Applies a right-associative accumulator function over a sequence.
+ This operator is the right-associative version of the
+ AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ (Defined by MoreEnumerable) |
| AggregateRightT |
+ Applies a right-associative accumulator function over a sequence.
+ This operator is the right-associative version of the
+ AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ (Defined by AggregateRightExtension) |
| AggregateRightT, TAccumulate |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate) LINQ operator.
+ (Defined by MoreEnumerable) |
| AggregateRightT, TAccumulate |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate) LINQ operator.
+ (Defined by AggregateRightExtension) |
| AggregateRightT, TAccumulate, TResult |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value,
+ and the specified function is used to select the result value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate, FuncTAccumulate, TResult) LINQ operator.
+ (Defined by MoreEnumerable) |
| AggregateRightT, TAccumulate, TResult |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value,
+ and the specified function is used to select the result value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate, FuncTAccumulate, TResult) LINQ operator.
+ (Defined by AggregateRightExtension) |
| AppendT |
+ Returns a sequence consisting of the head elements and the given tail element.
+ (Defined by MoreEnumerable) |
| AppendT |
+ Returns a sequence consisting of the head elements and the given tail element.
+ (Defined by AppendExtension) |
| AsOrderedT |
+ Returns a query whose results evaluate asynchronously but which
+ are returned in the order of the source.
+ (Defined by ExperimentalEnumerable) |
| AsSequentialT |
+ Converts a query whose results evaluate asynchronously to use
+ sequential instead of concurrent evaluation.
+ (Defined by ExperimentalEnumerable) |
| AssertT |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ (Defined by MoreEnumerable) |
| AssertT |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ (Defined by AssertExtension) |
| AssertT |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ (Defined by MoreEnumerable) |
| AssertT |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ (Defined by AssertExtension) |
| AssertCountT |
+ Asserts that a source sequence contains a given count of elements.
+ (Defined by MoreEnumerable) |
| AssertCountT |
+ Asserts that a source sequence contains a given count of elements.
+ (Defined by AssertCountExtension) |
| AssertCountT |
+ Asserts that a source sequence contains a given count of elements.
+ A parameter specifies the exception to be thrown.
+ (Defined by MoreEnumerable) |
| AssertCountT |
+ Asserts that a source sequence contains a given count of elements.
+ A parameter specifies the exception to be thrown.
+ (Defined by AssertCountExtension) |
| AsUnorderedT |
+ Returns a query whose results evaluate asynchronously but which
+ are returned without guarantee of the source order.
+ (Defined by ExperimentalEnumerable) |
| AtLeastT |
+ Determines whether or not the number of elements in the sequence is greater than
+ or equal to the given integer.
+ (Defined by MoreEnumerable) |
| AtLeastT |
+ Determines whether or not the number of elements in the sequence is greater than
+ or equal to the given integer.
+ (Defined by AtLeastExtension) |
| AtMostT |
+ Determines whether or not the number of elements in the sequence is lesser than
+ or equal to the given integer.
+ (Defined by MoreEnumerable) |
| AtMostT |
+ Determines whether or not the number of elements in the sequence is lesser than
+ or equal to the given integer.
+ (Defined by AtMostExtension) |
| AwaitT, TResult |
+ Creates a sequence query that streams the result of each task in
+ the source sequence as it completes asynchronously. A
+ CancellationToken is passed for each asynchronous
+ evaluation to abort any asynchronous operations in flight if the
+ sequence is not fully iterated.
+ (Defined by ExperimentalEnumerable) |
| AwaitCompletionT, TTaskResult, TResult |
+ 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.
+ (Defined by ExperimentalEnumerable) |
| BacksertT |
+ 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.
+ (Defined by MoreEnumerable) |
| BacksertT |
+ 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.
+ (Defined by BacksertExtension) |
| BatchT |
+ Batches the source sequence into sized buckets.
+ (Defined by MoreEnumerable) |
| BatchT |
+ Batches the source sequence into sized buckets.
+ (Defined by BatchExtension) |
| BatchT, TResult |
+ Batches the source sequence into sized buckets and applies a projection to each bucket.
+ (Defined by MoreEnumerable) |
| BatchT, TResult |
+ Batches the source sequence into sized buckets and applies a projection to each bucket.
+ (Defined by BatchExtension) |
| BatchT, TResult |
+ Batches the source sequence into sized buckets using an array pool
+ to rent arrays to back each bucket and returns a sequence of
+ elements projected from each bucket.
+ (Defined by ExperimentalEnumerable) |
| BatchT, TBucket, TResult |
+ Batches the source sequence into sized buckets using an array pool
+ to rent arrays to back each bucket and returns a sequence of
+ elements projected from each bucket.
+ (Defined by ExperimentalEnumerable) |
| CartesianT, T2, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, T5, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, T5, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, T5, T6, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, T5, T6, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, T5, T6, T7, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, T5, T6, T7, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, T5, T6, T7, T8, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, T5, T6, T7, T8, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| ChooseT, TResult |
+ 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 true
+ as its first element and result as the second.
+ (Defined by MoreEnumerable) |
| ChooseT, TResult |
+ 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 true
+ as its first element and result as the second.
+ (Defined by ChooseExtension) |
| CompareCountT, TSecond |
+ Compares two sequences and returns an integer that indicates whether the first sequence
+ has fewer, the same or more elements than the second sequence.
+ (Defined by MoreEnumerable) |
| CompareCountT, TSecond |
+ Compares two sequences and returns an integer that indicates whether the first sequence
+ has fewer, the same or more elements than the second sequence.
+ (Defined by CompareCountExtension) |
| ConcatT |
+ Returns a sequence consisting of the head elements and the given tail element.
+ (Defined by MoreEnumerable) |
| ConsumeT |
+ Completely consumes the given sequence. This method uses immediate execution,
+ and doesn't store any data during execution.
+ (Defined by MoreEnumerable) |
| ConsumeT |
+ Completely consumes the given sequence. This method uses immediate execution,
+ and doesn't store any data during execution.
+ (Defined by ConsumeExtension) |
| CountBetweenT |
+ Determines whether or not the number of elements in the sequence is between
+ an inclusive range of minimum and maximum integers.
+ (Defined by MoreEnumerable) |
| CountBetweenT |
+ Determines whether or not the number of elements in the sequence is between
+ an inclusive range of minimum and maximum integers.
+ (Defined by CountBetweenExtension) |
| CountByT, TKey |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ (Defined by MoreEnumerable) |
| CountByT, TKey |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ (Defined by CountByExtension) |
| CountByT, TKey |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ An additional argument specifies a comparer to use for testing equivalence of keys.
+ (Defined by MoreEnumerable) |
| CountByT, TKey |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ An additional argument specifies a comparer to use for testing equivalence of keys.
+ (Defined by CountByExtension) |
| CountDownT, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CountDownT, TResult |
+ 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.
+ (Defined by CountDownExtension) |
| DistinctByT, TKey |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the default equality comparer for the projected type.
+ (Defined by MoreEnumerable) |
| DistinctByT, TKey |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the default equality comparer for the projected type.
+ (Defined by DistinctByExtension) |
| DistinctByT, TKey |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the specified comparer for the projected type.
+ (Defined by MoreEnumerable) |
| DistinctByT, TKey |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the specified comparer for the projected type.
+ (Defined by DistinctByExtension) |
| EndsWithT |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the default equality comparer.
+ (Defined by MoreEnumerable) |
| EndsWithT |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the default equality comparer.
+ (Defined by EndsWithExtension) |
| EndsWithT |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the specified element equality comparer.
+ (Defined by MoreEnumerable) |
| EndsWithT |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the specified element equality comparer.
+ (Defined by EndsWithExtension) |
| EquiZipT, TSecond, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| EquiZipT, TSecond, TResult |
+ 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.
+ (Defined by EquiZipExtension) |
| EquiZipT, T2, T3, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| EquiZipT, T2, T3, TResult |
+ 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.
+ (Defined by EquiZipExtension) |
| EquiZipT, T2, T3, T4, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| EquiZipT, T2, T3, T4, TResult |
+ 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.
+ (Defined by EquiZipExtension) |
| ExactlyT |
+ Determines whether or not the number of elements in the sequence is equals to the given integer.
+ (Defined by MoreEnumerable) |
| ExactlyT |
+ Determines whether or not the number of elements in the sequence is equals to the given integer.
+ (Defined by ExactlyExtension) |
| ExceptByT, TKey |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ (Defined by MoreEnumerable) |
| ExceptByT, TKey |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ (Defined by ExceptByExtension) |
| ExceptByT, TKey |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ (Defined by MoreEnumerable) |
| ExceptByT, TKey |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ (Defined by ExceptByExtension) |
| ExcludeT |
+ Excludes a contiguous number of elements from a sequence starting
+ at a given index.
+ (Defined by MoreEnumerable) |
| ExcludeT |
+ Excludes a contiguous number of elements from a sequence starting
+ at a given index.
+ (Defined by ExcludeExtension) |
| FallbackIfEmptyT |
+ Returns the elements of the specified sequence or the specified
+ value in a singleton collection if the sequence is empty.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence from an array of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of the specified sequence or the specified
+ value in a singleton collection if the sequence is empty.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence from an array of values.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by FallbackIfEmptyExtension) |
| FillBackwardT |
+ Returns a sequence with each null reference or value in the source
+ replaced with the following non-null reference or value in
+ that sequence.
+ (Defined by MoreEnumerable) |
| FillBackwardT |
+ Returns a sequence with each null reference or value in the source
+ replaced with the following non-null reference or value in
+ that sequence.
+ (Defined by FillBackwardExtension) |
| FillBackwardT |
+ 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.
+ (Defined by MoreEnumerable) |
| FillBackwardT |
+ 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.
+ (Defined by FillBackwardExtension) |
| FillBackwardT |
+ Returns a sequence with each missing element in the source replaced
+ with the following non-missing element in that sequence. Additional
+ parameters specify two functions, one used to determine if an
+ element is considered missing or not and another to provide the
+ replacement for the missing element.
+ (Defined by MoreEnumerable) |
| FillBackwardT |
+ Returns a sequence with each missing element in the source replaced
+ with the following non-missing element in that sequence. Additional
+ parameters specify two functions, one used to determine if an
+ element is considered missing or not and another to provide the
+ replacement for the missing element.
+ (Defined by FillBackwardExtension) |
| FillForwardT |
+ 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.
+ (Defined by MoreEnumerable) |
| FillForwardT |
+ 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.
+ (Defined by FillForwardExtension) |
| FillForwardT |
+ 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.
+ (Defined by MoreEnumerable) |
| FillForwardT |
+ 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.
+ (Defined by FillForwardExtension) |
| FillForwardT |
+ 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 specify two functions, one used to
+ determine if an element is considered missing or not and another
+ to provide the replacement for the missing element.
+ (Defined by MoreEnumerable) |
| FillForwardT |
+ 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 specify two functions, one used to
+ determine if an element is considered missing or not and another
+ to provide the replacement for the missing element.
+ (Defined by FillForwardExtension) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences.
+ (Defined by MoreEnumerable) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences.
+ (Defined by FlattenExtension) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a predicate function used to
+ determine whether a nested IEnumerable should be
+ flattened or not.
+ (Defined by MoreEnumerable) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a function that projects an inner
+ sequence via a property of an object.
+ (Defined by MoreEnumerable) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a predicate function used to
+ determine whether a nested IEnumerable should be
+ flattened or not.
+ (Defined by FlattenExtension) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a function that projects an inner
+ sequence via a property of an object.
+ (Defined by FlattenExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 9 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 9 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 10 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 10 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 11 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 11 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 12 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 12 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 13 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 13 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 14 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 14 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 15 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 15 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 16 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 16 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 1 element.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 1 element.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 2 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 2 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 3 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 3 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 4 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 4 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 5 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 5 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 6 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 6 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 7 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 7 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 8 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 8 elements.
+ (Defined by FoldExtension) |
| ForEachT |
+ Immediately executes the given action on each element in the source sequence.
+ (Defined by MoreEnumerable) |
| ForEachT |
+ Immediately executes the given action on each element in the source sequence.
+ (Defined by ForEachExtension) |
| ForEachT |
+ Immediately executes the given action on each element in the source sequence.
+ Each element's index is used in the logic of the action.
+ (Defined by MoreEnumerable) |
| ForEachT |
+ Immediately executes the given action on each element in the source sequence.
+ Each element's index is used in the logic of the action.
+ (Defined by ForEachExtension) |
| FullGroupJoinT, TSecond, TKey |
+ Performs a Full Group Join between the first and second sequences.
+ (Defined by MoreEnumerable) |
| FullGroupJoinT, TSecond, TKey |
+ Performs a Full Group Join between the first and second sequences.
+ (Defined by FullGroupJoinExtension) |
| FullGroupJoinT, TSecond, TKey |
+ Performs a Full Group Join between the first and second sequences.
+ (Defined by MoreEnumerable) |
| FullGroupJoinT, TSecond, TKey |
+ Performs a Full Group Join between the first and second sequences.
+ (Defined by FullGroupJoinExtension) |
| FullGroupJoinT, TSecond, TKey, TResult |
+ Performs a full group-join between two sequences.
+ (Defined by MoreEnumerable) |
| FullGroupJoinT, TSecond, TKey, TResult |
+ Performs a full group-join between two sequences.
+ (Defined by FullGroupJoinExtension) |
| FullGroupJoinT, TSecond, TKey, TResult |
+ Performs a full group-join between two sequences.
+ (Defined by MoreEnumerable) |
| FullGroupJoinT, TSecond, TKey, TResult |
+ Performs a full group-join between two sequences.
+ (Defined by FullGroupJoinExtension) |
| FullJoinT, TKey, TResult |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| FullJoinT, TKey, TResult |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by FullJoinExtension) |
| FullJoinT, TKey, TResult |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| FullJoinT, TKey, TResult |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by FullJoinExtension) |
| FullJoinT, TSecond, TKey, TResult |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| FullJoinT, TSecond, TKey, TResult |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by FullJoinExtension) |
| FullJoinT, TSecond, TKey, TResult |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| FullJoinT, TSecond, TKey, TResult |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by FullJoinExtension) |
| GroupAdjacentT, TKey |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and compares the keys by using a
+ specified comparer.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and compares the keys by using a
+ specified comparer.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey, TElement |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and projects the elements for
+ each group by using a specified function.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey, TResult |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey, TElement |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and projects the elements for
+ each group by using a specified function.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey, TResult |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey, TElement |
+ 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.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey, TResult |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey, TElement |
+ 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.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey, TResult |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ (Defined by GroupAdjacentExtension) |
| IndexT |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the zero-based index of the value in the source
+ sequence.
+ (Defined by MoreEnumerable) |
| IndexT |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the zero-based index of the value in the source
+ sequence.
+ (Defined by IndexExtension) |
| IndexT |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the index of the value in the source sequence.
+ An additional parameter specifies the starting index.
+ (Defined by MoreEnumerable) |
| IndexT |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the index of the value in the source sequence.
+ An additional parameter specifies the starting index.
+ (Defined by IndexExtension) |
| IndexByT, TKey |
+ 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.
+ (Defined by MoreEnumerable) |
| IndexByT, TKey |
+ 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.
+ (Defined by IndexByExtension) |
| IndexByT, TKey |
+ 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.
+ (Defined by MoreEnumerable) |
| IndexByT, TKey |
+ 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.
+ (Defined by IndexByExtension) |
| InsertT |
+ Inserts the elements of a sequence into another sequence at a
+ specified index.
+ (Defined by MoreEnumerable) |
| InsertT |
+ Inserts the elements of a sequence into another sequence at a
+ specified index.
+ (Defined by InsertExtension) |
| InterleaveT |
+ Interleaves the elements of two or more sequences into a single sequence, skipping
+ sequences as they are consumed.
+ (Defined by MoreEnumerable) |
| InterleaveT |
+ Interleaves the elements of two or more sequences into a single sequence, skipping
+ sequences as they are consumed.
+ (Defined by InterleaveExtension) |
| LagT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ negative offset.
+ (Defined by MoreEnumerable) |
| LagT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ negative offset.
+ (Defined by LagExtension) |
| LagT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ negative offset.
+ (Defined by MoreEnumerable) |
| LagT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ negative offset.
+ (Defined by LagExtension) |
| LeadT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ positive offset.
+ (Defined by MoreEnumerable) |
| LeadT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ positive offset.
+ (Defined by LeadExtension) |
| LeadT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ positive offset.
+ (Defined by MoreEnumerable) |
| LeadT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ positive offset.
+ (Defined by LeadExtension) |
| LeftJoinT, TKey, TResult |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| LeftJoinT, TKey, TResult |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by LeftJoinExtension) |
| LeftJoinT, TKey, TResult |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| LeftJoinT, TKey, TResult |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by LeftJoinExtension) |
| LeftJoinT, TSecond, TKey, TResult |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| LeftJoinT, TSecond, TKey, TResult |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by LeftJoinExtension) |
| LeftJoinT, TSecond, TKey, TResult |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| LeftJoinT, TSecond, TKey, TResult |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by LeftJoinExtension) |
| MaxByT, TKey |
+ Returns the maximal elements of the given sequence, based on
+ the given projection.
+ (Defined by MoreEnumerable) |
| MaxByT, TKey |
+ Returns the maximal elements of the given sequence, based on
+ the given projection.
+ (Defined by MaxByExtension) |
| MaxByT, TKey |
+ Returns the maximal elements of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ (Defined by MoreEnumerable) |
| MaxByT, TKey |
+ Returns the maximal elements of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ (Defined by MaxByExtension) |
| MaxConcurrencyT |
+ Returns a query whose results evaluate asynchronously to use a
+ concurrency limit.
+ (Defined by ExperimentalEnumerable) |
| MemoizeT |
+ 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.
+ (Defined by ExperimentalEnumerable) |
| MinByT, TKey |
+ Returns the minimal elements of the given sequence, based on
+ the given projection.
+ (Defined by MoreEnumerable) |
| MinByT, TKey |
+ Returns the minimal elements of the given sequence, based on
+ the given projection.
+ (Defined by MinByExtension) |
| MinByT, TKey |
+ Returns the minimal elements of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ (Defined by MoreEnumerable) |
| MinByT, TKey |
+ Returns the minimal elements of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ (Defined by MinByExtension) |
| MoveT |
+ Returns a sequence with a range of elements in the source sequence
+ moved to a new offset.
+ (Defined by MoreEnumerable) |
| MoveT |
+ Returns a sequence with a range of elements in the source sequence
+ moved to a new offset.
+ (Defined by MoveExtension) |
| OrderByT, TKey |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ (Defined by MoreEnumerable) |
| OrderByT, TKey |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ (Defined by OrderByExtension) |
| OrderByT, TKey |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ (Defined by MoreEnumerable) |
| OrderByT, TKey |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ (Defined by OrderByExtension) |
| OrderedMergeT |
+ 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.
+ (Defined by MoreEnumerable) |
| OrderedMergeT |
+ 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.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT |
+ 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.
+ (Defined by MoreEnumerable) |
| OrderedMergeT |
+ 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.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TKey |
+ Merges two ordered sequences into one with an additional
+ parameter specifying the element key by which the sequences are
+ ordered. Where the keys equal in both sequences, the
+ element from the first sequence is returned in the resulting
+ sequence.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TKey |
+ Merges two ordered sequences into one with an additional
+ parameter specifying the element key by which the sequences are
+ ordered. Where the keys equal in both sequences, the
+ element from the first sequence is returned in the resulting
+ sequence.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TKey, TResult |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first and the result when elements are found in
+ both sequences.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TKey, TResult |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first and the result when elements are found in
+ both sequences.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TKey, TResult |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first, the result when elements are found in
+ both sequences and a method for comparing keys.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TKey, TResult |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first, the result when elements are found in
+ both sequences and a method for comparing keys.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TSecond, TKey, TResult |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second and
+ the result when element is found in second sequence but not in
+ the first, the result when elements are found in both sequences.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TSecond, TKey, TResult |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second and
+ the result when element is found in second sequence but not in
+ the first, the result when elements are found in both sequences.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TSecond, TKey, TResult |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second,
+ 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.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TSecond, TKey, TResult |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second,
+ 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.
+ (Defined by OrderedMergeExtension) |
| PadT |
+ Pads a sequence with default values if it is narrower (shorter
+ in length) than a given width.
+ (Defined by MoreEnumerable) |
| PadT |
+ Pads a sequence with default values if it is narrower (shorter
+ in length) than a given width.
+ (Defined by PadExtension) |
| PadT |
+ Pads a sequence with a given filler value if it is narrower (shorter
+ in length) than a given width.
+ (Defined by MoreEnumerable) |
| PadT |
+ Pads a sequence with a dynamic filler value if it is narrower (shorter
+ in length) than a given width.
+ (Defined by MoreEnumerable) |
| PadT |
+ Pads a sequence with a given filler value if it is narrower (shorter
+ in length) than a given width.
+ (Defined by PadExtension) |
| PadT |
+ Pads a sequence with a dynamic filler value if it is narrower (shorter
+ in length) than a given width.
+ (Defined by PadExtension) |
| PadStartT |
+ Pads a sequence with default values in the beginning if it is narrower (shorter
+ in length) than a given width.
+ (Defined by MoreEnumerable) |
| PadStartT |
+ Pads a sequence with default values in the beginning if it is narrower (shorter
+ in length) than a given width.
+ (Defined by PadStartExtension) |
| PadStartT |
+ 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.
+ (Defined by MoreEnumerable) |
| PadStartT |
+ 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.
+ (Defined by MoreEnumerable) |
| PadStartT |
+ 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.
+ (Defined by PadStartExtension) |
| PadStartT |
+ 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.
+ (Defined by PadStartExtension) |
| PairwiseT, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence and its
+ predecessor, with the exception of the first element which is
+ only returned as the predecessor of the second element.
+ (Defined by MoreEnumerable) |
| PairwiseT, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence and its
+ predecessor, with the exception of the first element which is
+ only returned as the predecessor of the second element.
+ (Defined by PairwiseExtension) |
| PartialSortT |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ (Defined by MoreEnumerable) |
| PartialSortT |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ (Defined by PartialSortExtension) |
| PartialSortT |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ An additional parameter specifies the direction of the sort
+ (Defined by MoreEnumerable) |
| PartialSortT |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation. An additional parameter specifies how the
+ elements compare to each other.
+ (Defined by MoreEnumerable) |
| PartialSortT |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ An additional parameter specifies the direction of the sort
+ (Defined by PartialSortExtension) |
| PartialSortT |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation. An additional parameter specifies how the
+ elements compare to each other.
+ (Defined by PartialSortExtension) |
| PartialSortT |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ (Defined by MoreEnumerable) |
| PartialSortT |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ (Defined by PartialSortExtension) |
| PartialSortByT, TKey |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ (Defined by MoreEnumerable) |
| PartialSortByT, TKey |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ (Defined by PartialSortByExtension) |
| PartialSortByT, TKey |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies the direction of the sort
+ (Defined by MoreEnumerable) |
| PartialSortByT, TKey |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies how the keys compare to each other.
+ (Defined by MoreEnumerable) |
| PartialSortByT, TKey |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies the direction of the sort
+ (Defined by PartialSortByExtension) |
| PartialSortByT, TKey |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies how the keys compare to each other.
+ (Defined by PartialSortByExtension) |
| PartialSortByT, TKey |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ (Defined by MoreEnumerable) |
| PartialSortByT, TKey |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ (Defined by PartialSortByExtension) |
| PartitionT |
+ Partitions or splits a sequence in two using a predicate.
+ (Defined by MoreEnumerable) |
| PartitionT |
+ Partitions or splits a sequence in two using a predicate.
+ (Defined by PartitionExtension) |
| PartitionT, TResult |
+ Partitions or splits a sequence in two using a predicate and then
+ projects a result from the two.
+ (Defined by MoreEnumerable) |
| PartitionT, TResult |
+ Partitions or splits a sequence in two using a predicate and then
+ projects a result from the two.
+ (Defined by PartitionExtension) |
| PermutationsT |
+ Generates a sequence of lists that represent the permutations of the original sequence.
+ (Defined by MoreEnumerable) |
| PermutationsT |
+ Generates a sequence of lists that represent the permutations of the original sequence.
+ (Defined by PermutationsExtension) |
| PipeT |
+ Executes the given action on each element in the source sequence
+ and yields it.
+ (Defined by MoreEnumerable) |
| PipeT |
+ Executes the given action on each element in the source sequence
+ and yields it.
+ (Defined by PipeExtension) |
| PrependT |
+ Prepends a single value to a sequence.
+ (Defined by MoreEnumerable) |
| PrependT |
+ Prepends a single value to a sequence.
+ (Defined by PrependExtension) |
| PreScanT |
+ Performs a pre-scan (exclusive prefix sum) on a sequence of elements.
+ (Defined by MoreEnumerable) |
| PreScanT |
+ Performs a pre-scan (exclusive prefix sum) on a sequence of elements.
+ (Defined by PreScanExtension) |
| PreserveOrderT |
+ Returns a query whose results evaluate asynchronously and a Boolean
+ argument indicating whether the source order of the results is
+ preserved.
+ (Defined by ExperimentalEnumerable) |
| RandomSubsetT |
+ Returns a sequence of a specified size of random elements from the
+ original sequence.
+ (Defined by MoreEnumerable) |
| RandomSubsetT |
+ Returns a sequence of a specified size of random elements from the
+ original sequence.
+ (Defined by RandomSubsetExtension) |
| RandomSubsetT |
+ 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.
+ (Defined by MoreEnumerable) |
| RandomSubsetT |
+ 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.
+ (Defined by RandomSubsetExtension) |
| RankT |
+ Ranks each item in the sequence in descending ordering using a default comparer.
+ (Defined by MoreEnumerable) |
| RankT |
+ Ranks each item in the sequence in descending ordering using a default comparer.
+ (Defined by RankExtension) |
| RankT |
+ Rank each item in the sequence using a caller-supplied comparer.
+ (Defined by MoreEnumerable) |
| RankT |
+ Rank each item in the sequence using a caller-supplied comparer.
+ (Defined by RankExtension) |
| RankByT, TKey |
+ Ranks each item in the sequence in descending ordering by a specified key using a default comparer
+ (Defined by MoreEnumerable) |
| RankByT, TKey |
+ Ranks each item in the sequence in descending ordering by a specified key using a default comparer
+ (Defined by RankByExtension) |
| RankByT, TKey |
+ Ranks each item in a sequence using a specified key and a caller-supplied comparer
+ (Defined by MoreEnumerable) |
| RankByT, TKey |
+ Ranks each item in a sequence using a specified key and a caller-supplied comparer
+ (Defined by RankByExtension) |
| RepeatT |
+ Repeats the sequence forever.
+ (Defined by MoreEnumerable) |
| RepeatT |
+ Repeats the sequence forever.
+ (Defined by RepeatExtension) |
| RepeatT |
+ Repeats the sequence the specified number of times.
+ (Defined by MoreEnumerable) |
| RepeatT |
+ Repeats the sequence the specified number of times.
+ (Defined by RepeatExtension) |
| RightJoinT, TKey, TResult |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| RightJoinT, TKey, TResult |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by RightJoinExtension) |
| RightJoinT, TKey, TResult |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| RightJoinT, TKey, TResult |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by RightJoinExtension) |
| RightJoinT, TSecond, TKey, TResult |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| RightJoinT, TSecond, TKey, TResult |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by RightJoinExtension) |
| RightJoinT, TSecond, TKey, TResult |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| RightJoinT, TSecond, TKey, TResult |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by RightJoinExtension) |
| RunLengthEncodeT |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count.
+ (Defined by MoreEnumerable) |
| RunLengthEncodeT |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count.
+ (Defined by RunLengthEncodeExtension) |
| RunLengthEncodeT |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count. This overload
+ uses a custom equality comparer to identify equivalent items.
+ (Defined by MoreEnumerable) |
| RunLengthEncodeT |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count. This overload
+ uses a custom equality comparer to identify equivalent items.
+ (Defined by RunLengthEncodeExtension) |
| ScanT |
+ Performs a scan (inclusive prefix sum) on a sequence of elements.
+ (Defined by MoreEnumerable) |
| ScanT |
+ Performs a scan (inclusive prefix sum) on a sequence of elements.
+ (Defined by ScanExtension) |
| ScanT, TState |
+ Like AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) except returns
+ the sequence of intermediate results as well as the final one.
+ An additional parameter specifies a seed.
+ (Defined by MoreEnumerable) |
| ScanT, TState |
+ Like AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) except returns
+ the sequence of intermediate results as well as the final one.
+ An additional parameter specifies a seed.
+ (Defined by ScanExtension) |
| ScanByT, TKey, TState |
+ Applies an accumulator function over sequence element keys,
+ returning the keys along with intermediate accumulator states.
+ (Defined by MoreEnumerable) |
| ScanByT, TKey, TState |
+ Applies an accumulator function over sequence element keys,
+ returning the keys along with intermediate accumulator states.
+ (Defined by ScanByExtension) |
| ScanByT, TKey, TState |
+ 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.
+ (Defined by MoreEnumerable) |
| ScanByT, TKey, TState |
+ 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.
+ (Defined by ScanByExtension) |
| ScanRightT |
+ Performs a right-associative scan (inclusive prefix) on a sequence of elements.
+ This operator is the right-associative version of the
+ ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ (Defined by MoreEnumerable) |
| ScanRightT |
+ Performs a right-associative scan (inclusive prefix) on a sequence of elements.
+ This operator is the right-associative version of the
+ ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ (Defined by ScanRightExtension) |
| ScanRightT, TAccumulate |
+ Performs a right-associative scan (inclusive prefix) on a sequence of elements.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) LINQ operator.
+ (Defined by MoreEnumerable) |
| ScanRightT, TAccumulate |
+ Performs a right-associative scan (inclusive prefix) on a sequence of elements.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) LINQ operator.
+ (Defined by ScanRightExtension) |
| SchedulerT |
+ Returns a query whose results evaluate asynchronously and uses the
+ given scheduler for the workhorse task.
+ (Defined by ExperimentalEnumerable) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by MoreEnumerable) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by SegmentExtension) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by MoreEnumerable) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by SegmentExtension) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by MoreEnumerable) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by SegmentExtension) |
| ShuffleT |
+ Returns a sequence of elements in random order from the original
+ sequence.
+ (Defined by MoreEnumerable) |
| ShuffleT |
+ Returns a sequence of elements in random order from the original
+ sequence.
+ (Defined by ShuffleExtension) |
| ShuffleT |
+ 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.
+ (Defined by MoreEnumerable) |
| ShuffleT |
+ 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.
+ (Defined by ShuffleExtension) |
| SkipLastT |
+ Bypasses a specified number of elements at the end of the sequence.
+ (Defined by MoreEnumerable) |
| SkipLastT |
+ Bypasses a specified number of elements at the end of the sequence.
+ (Defined by SkipLastExtension) |
| SkipUntilT |
+ 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.
+ (Defined by MoreEnumerable) |
| SkipUntilT |
+ 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.
+ (Defined by SkipUntilExtension) |
| SliceT |
+ Extracts a contiguous count of elements from a sequence at a particular zero-based
+ starting index.
+ (Defined by MoreEnumerable) |
| SliceT |
+ Extracts a contiguous count of elements from a sequence at a particular zero-based
+ starting index.
+ (Defined by SliceExtension) |
| SortedMergeT |
+ Merges two or more sequences that are in a common order (either ascending or descending)
+ into a single sequence that preserves that order.
+ (Defined by MoreEnumerable) |
| SortedMergeT |
+ Merges two or more sequences that are in a common order (either ascending or descending)
+ into a single sequence that preserves that order.
+ (Defined by SortedMergeExtension) |
| SortedMergeT |
+ Merges two or more sequences that are in a common order (either ascending or descending)
+ into a single sequence that preserves that order.
+ (Defined by MoreEnumerable) |
| SortedMergeT |
+ Merges two or more sequences that are in a common order (either ascending or descending)
+ into a single sequence that preserves that order.
+ (Defined by SortedMergeExtension) |
| SplitT |
+ Splits the source sequence by separator elements identified by a
+ function.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by separator elements identified by a
+ function.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by a separator.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by a separator.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by separator elements identified by a
+ function, given a maximum count of splits.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by separator elements identified by a
+ function, given a maximum count of splits.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by a separator given a maximum count of splits.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by a separator and then transforms the
+ splits into results.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by a separator given a maximum count of splits.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by a separator and then transforms the
+ splits into results.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by a separator, given a maximum count
+ of splits. A parameter specifies how the separator is compared
+ for equality.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by a separator, given a maximum count
+ of splits. A parameter specifies how the separator is compared
+ for equality.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by separator elements identified by
+ a function and then transforms the splits into results.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by separator elements identified by
+ a function and then transforms the splits into results.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by a separator and then transforms
+ the splits into results.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by a separator and then transforms
+ the splits into results.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by separator elements identified by
+ a function, given a maximum count of splits, and then transforms
+ the splits into results.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by separator elements identified by
+ a function, given a maximum count of splits, and then transforms
+ the splits into results.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by a separator and then transforms the
+ splits into results. A parameter specifies how the separator is
+ compared for equality.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by a separator and then transforms the
+ splits into results. A parameter specifies how the separator is
+ compared for equality.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results. A
+ parameter specifies how the separator is compared for equality.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results. A
+ parameter specifies how the separator is compared for equality.
+ (Defined by SplitExtension) |
| StartsWithT |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the default equality
+ comparer.
+ (Defined by MoreEnumerable) |
| StartsWithT |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the default equality
+ comparer.
+ (Defined by StartsWithExtension) |
| StartsWithT |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the specified element
+ equality comparer.
+ (Defined by MoreEnumerable) |
| StartsWithT |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the specified element
+ equality comparer.
+ (Defined by StartsWithExtension) |
| SubsetsT |
+ Returns a sequence of IListT representing all of the subsets of any size
+ that are part of the original sequence. In mathematics, it is equivalent to the
+ power set of a set.
+ (Defined by MoreEnumerable) |
| SubsetsT |
+ Returns a sequence of IListT representing all of the subsets of any size
+ that are part of the original sequence. In mathematics, it is equivalent to the
+ power set of a set.
+ (Defined by SubsetsExtension) |
| SubsetsT |
+ Returns a sequence of IListT representing all subsets of a given size
+ that are part of the original sequence. In mathematics, it is equivalent to the
+ combinations or k-subsets of a set.
+ (Defined by MoreEnumerable) |
| SubsetsT |
+ Returns a sequence of IListT representing all subsets of a given size
+ that are part of the original sequence. In mathematics, it is equivalent to the
+ combinations or k-subsets of a set.
+ (Defined by SubsetsExtension) |
| TagFirstLastT, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence with additional parameters
+ indicating whether the element is the first and/or last of the
+ sequence.
+ (Defined by MoreEnumerable) |
| TagFirstLastT, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence with additional parameters
+ indicating whether the element is the first and/or last of the
+ sequence.
+ (Defined by TagFirstLastExtension) |
| TakeEveryT |
+ Returns every N-th element of a sequence.
+ (Defined by MoreEnumerable) |
| TakeEveryT |
+ Returns every N-th element of a sequence.
+ (Defined by TakeEveryExtension) |
| TakeLastT |
+ Returns a specified number of contiguous elements from the end of
+ a sequence.
+ (Defined by MoreEnumerable) |
| TakeLastT |
+ Returns a specified number of contiguous elements from the end of
+ a sequence.
+ (Defined by TakeLastExtension) |
| TakeUntilT |
+ 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.
+ (Defined by MoreEnumerable) |
| TakeUntilT |
+ 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.
+ (Defined by TakeUntilExtension) |
| ToArrayByIndexT |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT, TResult |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT, TResult |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT, TResult |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT, TResult |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT, TResult |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT, TResult |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT, TResult |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT, TResult |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ (Defined by ToArrayByIndexExtension) |
| ToDataTableT |
+ Converts a sequence to a DataTable object.
+ (Defined by MoreEnumerable) |
| ToDataTableT |
+ Converts a sequence to a DataTable object.
+ (Defined by ToDataTableExtension) |
| ToDataTableT |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ (Defined by MoreEnumerable) |
| ToDataTableT |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ (Defined by ToDataTableExtension) |
| ToDataTableT, TTable |
+ Appends elements in the sequence as rows of a given DataTable object.
+ (Defined by MoreEnumerable) |
| ToDataTableT, TTable |
+ Appends elements in the sequence as rows of a given DataTable object.
+ (Defined by ToDataTableExtension) |
| ToDataTableT, TTable |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ (Defined by MoreEnumerable) |
| ToDataTableT, TTable |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ (Defined by ToDataTableExtension) |
| ToDelimitedStringT |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ (Defined by MoreEnumerable) |
| ToDelimitedStringT |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ (Defined by ToDelimitedStringExtension) |
| ToHashSetT |
+ Returns a HashSetT of the source items using the default equality
+ comparer for the type.
+ (Defined by MoreEnumerable) |
| ToHashSetT |
+ Returns a HashSetT of the source items using the default equality
+ comparer for the type.
+ (Defined by ToHashSetExtension) |
| ToHashSetT |
+ Returns a HashSetT of the source items using the specified equality
+ comparer for the type.
+ (Defined by MoreEnumerable) |
| ToHashSetT |
+ Returns a HashSetT of the source items using the specified equality
+ comparer for the type.
+ (Defined by ToHashSetExtension) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics.
+ (Defined by MoreEnumerable) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics.
+ (Defined by TraceExtension) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics using
+ a custom formatter.
+ (Defined by MoreEnumerable) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics using
+ a custom formatter.
+ (Defined by TraceExtension) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics using
+ custom formatting.
+ (Defined by MoreEnumerable) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics using
+ custom formatting.
+ (Defined by TraceExtension) |
| TrySingleT, TCardinality |
+ Returns a tuple with the cardinality of the sequence and the
+ single element in the sequence if it contains exactly one element.
+ similar to SingleTSource(IEnumerableTSource).
+ (Defined by ExperimentalEnumerable) |
| TrySingleT, TCardinality, TResult |
+ Returns a result projected from the the cardinality of the sequence
+ and the single element in the sequence if it contains exactly one
+ element.
+ (Defined by ExperimentalEnumerable) |
| UnboundedConcurrencyT |
+ Returns a query whose results evaluate asynchronously and
+ concurrently with no defined limitation on concurrency.
+ (Defined by ExperimentalEnumerable) |
| WindowT |
+ Processes a sequence into a series of sub-sequences representing a windowed subset of
+ the original.
+ (Defined by MoreEnumerable) |
| WindowT |
+ Processes a sequence into a series of sub-sequences representing a windowed subset of
+ the original.
+ (Defined by WindowExtension) |
| WindowedT |
+ Processes a sequence into a series of sub-sequences representing a windowed subset of the original.
+ (Defined by MoreEnumerable) |
| WindowLeftT |
+ Creates a left-aligned sliding window of a given size over the
+ source sequence.
+ (Defined by MoreEnumerable) |
| WindowLeftT |
+ Creates a left-aligned sliding window of a given size over the
+ source sequence.
+ (Defined by WindowLeftExtension) |
| WindowRightT |
+ Creates a right-aligned sliding window over the source sequence
+ of a given size.
+ (Defined by MoreEnumerable) |
| WindowRightT |
+ Creates a right-aligned sliding window over the source sequence
+ of a given size.
+ (Defined by WindowRightExtension) |
| ZipLongestT, TSecond, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipLongestT, TSecond, TResult |
+ 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.
+ (Defined by ZipLongestExtension) |
| ZipLongestT, T2, T3, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipLongestT, T2, T3, TResult |
+ 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.
+ (Defined by ZipLongestExtension) |
| ZipLongestT, T2, T3, T4, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipLongestT, T2, T3, T4, TResult |
+ 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.
+ (Defined by ZipLongestExtension) |
| ZipShortestT, TSecond, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipShortestT, TSecond, TResult |
+ 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.
+ (Defined by ZipShortestExtension) |
| ZipShortestT, T2, T3, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipShortestT, T2, T3, TResult |
+ 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.
+ (Defined by ZipShortestExtension) |
| ZipShortestT, T2, T3, T4, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipShortestT, T2, T3, T4, TResult |
+ 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.
+ (Defined by ZipShortestExtension) |
public interface ICurrentBuffer<T> : IList<T>,
+ ICollection<T>, IEnumerable<T>, IEnumerable
+Public Interface ICurrentBuffer(Of T)
+ Inherits IList(Of T), ICollection(Of T), IEnumerable(Of T),
+ IEnumerablegeneric<typename T>
+public interface class ICurrentBuffer : IList<T>,
+ ICollection<T>, IEnumerable<T>, IEnumerabletype ICurrentBuffer<'T> =
+ interface
+ interface IList<'T>
+ interface ICollection<'T>
+ interface IEnumerable<'T>
+ interface IEnumerable
+ end| Count | Gets the number of elements contained in the ICollectionT. (Inherited from ICollectionT) |
| IsReadOnly | Gets a value indicating whether the ICollectionT is read-only. (Inherited from ICollectionT) |
| Item | Gets or sets the element at the specified index. (Inherited from IListT) |
| Add | Adds an item to the ICollectionT. (Inherited from ICollectionT) |
| Clear | Removes all items from the ICollectionT. (Inherited from ICollectionT) |
| Contains | Determines whether the ICollectionT contains a specific value. (Inherited from ICollectionT) |
| CopyTo | Copies the elements of the ICollectionT to an Array, starting at a particular Array index. (Inherited from ICollectionT) |
| GetEnumerator | Returns an enumerator that iterates through the collection. (Inherited from IEnumerableT) |
| IndexOf | Determines the index of a specific item in the IListT. (Inherited from IListT) |
| Insert | Inserts an item to the IListT at the specified index. (Inherited from IListT) |
| Remove | Removes the first occurrence of a specific object from the ICollectionT. (Inherited from ICollectionT) |
| RemoveAt | Removes the IListT item at the specified index. (Inherited from IListT) |
| AggregateT, TResult1, TResult2, TResult |
+ Applies two accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TResult |
+ Applies two accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TResult |
+ Applies two accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult |
+ Applies three accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TResult |
+ Applies three accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TResult |
+ Applies three accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult |
+ Applies four accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult |
+ Applies four accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult |
+ Applies four accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult |
+ Applies five accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult |
+ Applies five accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult |
+ Applies five accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult |
+ Applies six accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult |
+ Applies six accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult |
+ Applies six accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult |
+ Applies seven accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult |
+ Applies seven accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult |
+ Applies seven accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult8, TResult |
+ Applies eight accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult |
+ Applies eight accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult |
+ Applies eight accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateRightT |
+ Applies a right-associative accumulator function over a sequence.
+ This operator is the right-associative version of the
+ AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ (Defined by MoreEnumerable) |
| AggregateRightT |
+ Applies a right-associative accumulator function over a sequence.
+ This operator is the right-associative version of the
+ AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ (Defined by AggregateRightExtension) |
| AggregateRightT, TAccumulate |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate) LINQ operator.
+ (Defined by MoreEnumerable) |
| AggregateRightT, TAccumulate |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate) LINQ operator.
+ (Defined by AggregateRightExtension) |
| AggregateRightT, TAccumulate, TResult |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value,
+ and the specified function is used to select the result value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate, FuncTAccumulate, TResult) LINQ operator.
+ (Defined by MoreEnumerable) |
| AggregateRightT, TAccumulate, TResult |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value,
+ and the specified function is used to select the result value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate, FuncTAccumulate, TResult) LINQ operator.
+ (Defined by AggregateRightExtension) |
| AppendT |
+ Returns a sequence consisting of the head elements and the given tail element.
+ (Defined by MoreEnumerable) |
| AppendT |
+ Returns a sequence consisting of the head elements and the given tail element.
+ (Defined by AppendExtension) |
| AssertT |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ (Defined by MoreEnumerable) |
| AssertT |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ (Defined by AssertExtension) |
| AssertT |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ (Defined by MoreEnumerable) |
| AssertT |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ (Defined by AssertExtension) |
| AssertCountT |
+ Asserts that a source sequence contains a given count of elements.
+ (Defined by MoreEnumerable) |
| AssertCountT |
+ Asserts that a source sequence contains a given count of elements.
+ (Defined by AssertCountExtension) |
| AssertCountT |
+ Asserts that a source sequence contains a given count of elements.
+ A parameter specifies the exception to be thrown.
+ (Defined by MoreEnumerable) |
| AssertCountT |
+ Asserts that a source sequence contains a given count of elements.
+ A parameter specifies the exception to be thrown.
+ (Defined by AssertCountExtension) |
| AtLeastT |
+ Determines whether or not the number of elements in the sequence is greater than
+ or equal to the given integer.
+ (Defined by MoreEnumerable) |
| AtLeastT |
+ Determines whether or not the number of elements in the sequence is greater than
+ or equal to the given integer.
+ (Defined by AtLeastExtension) |
| AtMostT |
+ Determines whether or not the number of elements in the sequence is lesser than
+ or equal to the given integer.
+ (Defined by MoreEnumerable) |
| AtMostT |
+ Determines whether or not the number of elements in the sequence is lesser than
+ or equal to the given integer.
+ (Defined by AtMostExtension) |
| AwaitT, TResult |
+ Creates a sequence query that streams the result of each task in
+ the source sequence as it completes asynchronously. A
+ CancellationToken is passed for each asynchronous
+ evaluation to abort any asynchronous operations in flight if the
+ sequence is not fully iterated.
+ (Defined by ExperimentalEnumerable) |
| AwaitCompletionT, TTaskResult, TResult |
+ 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.
+ (Defined by ExperimentalEnumerable) |
| BacksertT |
+ 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.
+ (Defined by MoreEnumerable) |
| BacksertT |
+ 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.
+ (Defined by BacksertExtension) |
| BatchT |
+ Batches the source sequence into sized buckets.
+ (Defined by MoreEnumerable) |
| BatchT |
+ Batches the source sequence into sized buckets.
+ (Defined by BatchExtension) |
| BatchT, TResult |
+ Batches the source sequence into sized buckets and applies a projection to each bucket.
+ (Defined by MoreEnumerable) |
| BatchT, TResult |
+ Batches the source sequence into sized buckets and applies a projection to each bucket.
+ (Defined by BatchExtension) |
| BatchT, TResult |
+ Batches the source sequence into sized buckets using an array pool
+ to rent arrays to back each bucket and returns a sequence of
+ elements projected from each bucket.
+ (Defined by ExperimentalEnumerable) |
| BatchT, TBucket, TResult |
+ Batches the source sequence into sized buckets using an array pool
+ to rent arrays to back each bucket and returns a sequence of
+ elements projected from each bucket.
+ (Defined by ExperimentalEnumerable) |
| CartesianT, T2, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, T5, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, T5, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, T5, T6, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, T5, T6, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, T5, T6, T7, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, T5, T6, T7, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, T5, T6, T7, T8, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, T5, T6, T7, T8, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| ChooseT, TResult |
+ 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 true
+ as its first element and result as the second.
+ (Defined by MoreEnumerable) |
| ChooseT, TResult |
+ 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 true
+ as its first element and result as the second.
+ (Defined by ChooseExtension) |
| CompareCountT, TSecond |
+ Compares two sequences and returns an integer that indicates whether the first sequence
+ has fewer, the same or more elements than the second sequence.
+ (Defined by MoreEnumerable) |
| CompareCountT, TSecond |
+ Compares two sequences and returns an integer that indicates whether the first sequence
+ has fewer, the same or more elements than the second sequence.
+ (Defined by CompareCountExtension) |
| ConcatT |
+ Returns a sequence consisting of the head elements and the given tail element.
+ (Defined by MoreEnumerable) |
| ConsumeT |
+ Completely consumes the given sequence. This method uses immediate execution,
+ and doesn't store any data during execution.
+ (Defined by MoreEnumerable) |
| ConsumeT |
+ Completely consumes the given sequence. This method uses immediate execution,
+ and doesn't store any data during execution.
+ (Defined by ConsumeExtension) |
| CountBetweenT |
+ Determines whether or not the number of elements in the sequence is between
+ an inclusive range of minimum and maximum integers.
+ (Defined by MoreEnumerable) |
| CountBetweenT |
+ Determines whether or not the number of elements in the sequence is between
+ an inclusive range of minimum and maximum integers.
+ (Defined by CountBetweenExtension) |
| CountByT, TKey |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ (Defined by MoreEnumerable) |
| CountByT, TKey |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ (Defined by CountByExtension) |
| CountByT, TKey |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ An additional argument specifies a comparer to use for testing equivalence of keys.
+ (Defined by MoreEnumerable) |
| CountByT, TKey |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ An additional argument specifies a comparer to use for testing equivalence of keys.
+ (Defined by CountByExtension) |
| CountDownT, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CountDownT, TResult |
+ 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.
+ (Defined by CountDownExtension) |
| DistinctByT, TKey |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the default equality comparer for the projected type.
+ (Defined by MoreEnumerable) |
| DistinctByT, TKey |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the default equality comparer for the projected type.
+ (Defined by DistinctByExtension) |
| DistinctByT, TKey |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the specified comparer for the projected type.
+ (Defined by MoreEnumerable) |
| DistinctByT, TKey |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the specified comparer for the projected type.
+ (Defined by DistinctByExtension) |
| EndsWithT |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the default equality comparer.
+ (Defined by MoreEnumerable) |
| EndsWithT |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the default equality comparer.
+ (Defined by EndsWithExtension) |
| EndsWithT |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the specified element equality comparer.
+ (Defined by MoreEnumerable) |
| EndsWithT |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the specified element equality comparer.
+ (Defined by EndsWithExtension) |
| EquiZipT, TSecond, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| EquiZipT, TSecond, TResult |
+ 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.
+ (Defined by EquiZipExtension) |
| EquiZipT, T2, T3, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| EquiZipT, T2, T3, TResult |
+ 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.
+ (Defined by EquiZipExtension) |
| EquiZipT, T2, T3, T4, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| EquiZipT, T2, T3, T4, TResult |
+ 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.
+ (Defined by EquiZipExtension) |
| ExactlyT |
+ Determines whether or not the number of elements in the sequence is equals to the given integer.
+ (Defined by MoreEnumerable) |
| ExactlyT |
+ Determines whether or not the number of elements in the sequence is equals to the given integer.
+ (Defined by ExactlyExtension) |
| ExceptByT, TKey |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ (Defined by MoreEnumerable) |
| ExceptByT, TKey |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ (Defined by ExceptByExtension) |
| ExceptByT, TKey |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ (Defined by MoreEnumerable) |
| ExceptByT, TKey |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ (Defined by ExceptByExtension) |
| ExcludeT |
+ Excludes a contiguous number of elements from a sequence starting
+ at a given index.
+ (Defined by MoreEnumerable) |
| ExcludeT |
+ Excludes a contiguous number of elements from a sequence starting
+ at a given index.
+ (Defined by ExcludeExtension) |
| FallbackIfEmptyT |
+ Returns the elements of the specified sequence or the specified
+ value in a singleton collection if the sequence is empty.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence from an array of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of the specified sequence or the specified
+ value in a singleton collection if the sequence is empty.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence from an array of values.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by FallbackIfEmptyExtension) |
| FillBackwardT |
+ Returns a sequence with each null reference or value in the source
+ replaced with the following non-null reference or value in
+ that sequence.
+ (Defined by MoreEnumerable) |
| FillBackwardT |
+ Returns a sequence with each null reference or value in the source
+ replaced with the following non-null reference or value in
+ that sequence.
+ (Defined by FillBackwardExtension) |
| FillBackwardT |
+ 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.
+ (Defined by MoreEnumerable) |
| FillBackwardT |
+ 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.
+ (Defined by FillBackwardExtension) |
| FillBackwardT |
+ Returns a sequence with each missing element in the source replaced
+ with the following non-missing element in that sequence. Additional
+ parameters specify two functions, one used to determine if an
+ element is considered missing or not and another to provide the
+ replacement for the missing element.
+ (Defined by MoreEnumerable) |
| FillBackwardT |
+ Returns a sequence with each missing element in the source replaced
+ with the following non-missing element in that sequence. Additional
+ parameters specify two functions, one used to determine if an
+ element is considered missing or not and another to provide the
+ replacement for the missing element.
+ (Defined by FillBackwardExtension) |
| FillForwardT |
+ 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.
+ (Defined by MoreEnumerable) |
| FillForwardT |
+ 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.
+ (Defined by FillForwardExtension) |
| FillForwardT |
+ 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.
+ (Defined by MoreEnumerable) |
| FillForwardT |
+ 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.
+ (Defined by FillForwardExtension) |
| FillForwardT |
+ 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 specify two functions, one used to
+ determine if an element is considered missing or not and another
+ to provide the replacement for the missing element.
+ (Defined by MoreEnumerable) |
| FillForwardT |
+ 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 specify two functions, one used to
+ determine if an element is considered missing or not and another
+ to provide the replacement for the missing element.
+ (Defined by FillForwardExtension) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences.
+ (Defined by MoreEnumerable) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences.
+ (Defined by FlattenExtension) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a predicate function used to
+ determine whether a nested IEnumerable should be
+ flattened or not.
+ (Defined by MoreEnumerable) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a function that projects an inner
+ sequence via a property of an object.
+ (Defined by MoreEnumerable) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a predicate function used to
+ determine whether a nested IEnumerable should be
+ flattened or not.
+ (Defined by FlattenExtension) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a function that projects an inner
+ sequence via a property of an object.
+ (Defined by FlattenExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 9 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 9 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 10 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 10 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 11 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 11 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 12 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 12 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 13 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 13 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 14 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 14 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 15 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 15 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 16 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 16 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 1 element.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 1 element.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 2 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 2 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 3 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 3 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 4 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 4 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 5 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 5 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 6 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 6 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 7 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 7 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 8 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 8 elements.
+ (Defined by FoldExtension) |
| ForEachT |
+ Immediately executes the given action on each element in the source sequence.
+ (Defined by MoreEnumerable) |
| ForEachT |
+ Immediately executes the given action on each element in the source sequence.
+ (Defined by ForEachExtension) |
| ForEachT |
+ Immediately executes the given action on each element in the source sequence.
+ Each element's index is used in the logic of the action.
+ (Defined by MoreEnumerable) |
| ForEachT |
+ Immediately executes the given action on each element in the source sequence.
+ Each element's index is used in the logic of the action.
+ (Defined by ForEachExtension) |
| FullGroupJoinT, TSecond, TKey |
+ Performs a Full Group Join between the first and second sequences.
+ (Defined by MoreEnumerable) |
| FullGroupJoinT, TSecond, TKey |
+ Performs a Full Group Join between the first and second sequences.
+ (Defined by FullGroupJoinExtension) |
| FullGroupJoinT, TSecond, TKey |
+ Performs a Full Group Join between the first and second sequences.
+ (Defined by MoreEnumerable) |
| FullGroupJoinT, TSecond, TKey |
+ Performs a Full Group Join between the first and second sequences.
+ (Defined by FullGroupJoinExtension) |
| FullGroupJoinT, TSecond, TKey, TResult |
+ Performs a full group-join between two sequences.
+ (Defined by MoreEnumerable) |
| FullGroupJoinT, TSecond, TKey, TResult |
+ Performs a full group-join between two sequences.
+ (Defined by FullGroupJoinExtension) |
| FullGroupJoinT, TSecond, TKey, TResult |
+ Performs a full group-join between two sequences.
+ (Defined by MoreEnumerable) |
| FullGroupJoinT, TSecond, TKey, TResult |
+ Performs a full group-join between two sequences.
+ (Defined by FullGroupJoinExtension) |
| FullJoinT, TKey, TResult |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| FullJoinT, TKey, TResult |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by FullJoinExtension) |
| FullJoinT, TKey, TResult |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| FullJoinT, TKey, TResult |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by FullJoinExtension) |
| FullJoinT, TSecond, TKey, TResult |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| FullJoinT, TSecond, TKey, TResult |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by FullJoinExtension) |
| FullJoinT, TSecond, TKey, TResult |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| FullJoinT, TSecond, TKey, TResult |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by FullJoinExtension) |
| GroupAdjacentT, TKey |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and compares the keys by using a
+ specified comparer.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and compares the keys by using a
+ specified comparer.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey, TElement |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and projects the elements for
+ each group by using a specified function.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey, TResult |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey, TElement |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and projects the elements for
+ each group by using a specified function.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey, TResult |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey, TElement |
+ 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.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey, TResult |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey, TElement |
+ 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.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey, TResult |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ (Defined by GroupAdjacentExtension) |
| IndexT |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the zero-based index of the value in the source
+ sequence.
+ (Defined by MoreEnumerable) |
| IndexT |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the zero-based index of the value in the source
+ sequence.
+ (Defined by IndexExtension) |
| IndexT |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the index of the value in the source sequence.
+ An additional parameter specifies the starting index.
+ (Defined by MoreEnumerable) |
| IndexT |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the index of the value in the source sequence.
+ An additional parameter specifies the starting index.
+ (Defined by IndexExtension) |
| IndexByT, TKey |
+ 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.
+ (Defined by MoreEnumerable) |
| IndexByT, TKey |
+ 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.
+ (Defined by IndexByExtension) |
| IndexByT, TKey |
+ 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.
+ (Defined by MoreEnumerable) |
| IndexByT, TKey |
+ 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.
+ (Defined by IndexByExtension) |
| InsertT |
+ Inserts the elements of a sequence into another sequence at a
+ specified index.
+ (Defined by MoreEnumerable) |
| InsertT |
+ Inserts the elements of a sequence into another sequence at a
+ specified index.
+ (Defined by InsertExtension) |
| InterleaveT |
+ Interleaves the elements of two or more sequences into a single sequence, skipping
+ sequences as they are consumed.
+ (Defined by MoreEnumerable) |
| InterleaveT |
+ Interleaves the elements of two or more sequences into a single sequence, skipping
+ sequences as they are consumed.
+ (Defined by InterleaveExtension) |
| LagT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ negative offset.
+ (Defined by MoreEnumerable) |
| LagT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ negative offset.
+ (Defined by LagExtension) |
| LagT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ negative offset.
+ (Defined by MoreEnumerable) |
| LagT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ negative offset.
+ (Defined by LagExtension) |
| LeadT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ positive offset.
+ (Defined by MoreEnumerable) |
| LeadT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ positive offset.
+ (Defined by LeadExtension) |
| LeadT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ positive offset.
+ (Defined by MoreEnumerable) |
| LeadT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ positive offset.
+ (Defined by LeadExtension) |
| LeftJoinT, TKey, TResult |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| LeftJoinT, TKey, TResult |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by LeftJoinExtension) |
| LeftJoinT, TKey, TResult |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| LeftJoinT, TKey, TResult |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by LeftJoinExtension) |
| LeftJoinT, TSecond, TKey, TResult |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| LeftJoinT, TSecond, TKey, TResult |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by LeftJoinExtension) |
| LeftJoinT, TSecond, TKey, TResult |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| LeftJoinT, TSecond, TKey, TResult |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by LeftJoinExtension) |
| MaxByT, TKey |
+ Returns the maximal elements of the given sequence, based on
+ the given projection.
+ (Defined by MoreEnumerable) |
| MaxByT, TKey |
+ Returns the maximal elements of the given sequence, based on
+ the given projection.
+ (Defined by MaxByExtension) |
| MaxByT, TKey |
+ Returns the maximal elements of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ (Defined by MoreEnumerable) |
| MaxByT, TKey |
+ Returns the maximal elements of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ (Defined by MaxByExtension) |
| MemoizeT |
+ 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.
+ (Defined by ExperimentalEnumerable) |
| MinByT, TKey |
+ Returns the minimal elements of the given sequence, based on
+ the given projection.
+ (Defined by MoreEnumerable) |
| MinByT, TKey |
+ Returns the minimal elements of the given sequence, based on
+ the given projection.
+ (Defined by MinByExtension) |
| MinByT, TKey |
+ Returns the minimal elements of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ (Defined by MoreEnumerable) |
| MinByT, TKey |
+ Returns the minimal elements of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ (Defined by MinByExtension) |
| MoveT |
+ Returns a sequence with a range of elements in the source sequence
+ moved to a new offset.
+ (Defined by MoreEnumerable) |
| MoveT |
+ Returns a sequence with a range of elements in the source sequence
+ moved to a new offset.
+ (Defined by MoveExtension) |
| OrderByT, TKey |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ (Defined by MoreEnumerable) |
| OrderByT, TKey |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ (Defined by OrderByExtension) |
| OrderByT, TKey |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ (Defined by MoreEnumerable) |
| OrderByT, TKey |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ (Defined by OrderByExtension) |
| OrderedMergeT |
+ 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.
+ (Defined by MoreEnumerable) |
| OrderedMergeT |
+ 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.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT |
+ 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.
+ (Defined by MoreEnumerable) |
| OrderedMergeT |
+ 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.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TKey |
+ Merges two ordered sequences into one with an additional
+ parameter specifying the element key by which the sequences are
+ ordered. Where the keys equal in both sequences, the
+ element from the first sequence is returned in the resulting
+ sequence.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TKey |
+ Merges two ordered sequences into one with an additional
+ parameter specifying the element key by which the sequences are
+ ordered. Where the keys equal in both sequences, the
+ element from the first sequence is returned in the resulting
+ sequence.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TKey, TResult |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first and the result when elements are found in
+ both sequences.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TKey, TResult |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first and the result when elements are found in
+ both sequences.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TKey, TResult |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first, the result when elements are found in
+ both sequences and a method for comparing keys.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TKey, TResult |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first, the result when elements are found in
+ both sequences and a method for comparing keys.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TSecond, TKey, TResult |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second and
+ the result when element is found in second sequence but not in
+ the first, the result when elements are found in both sequences.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TSecond, TKey, TResult |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second and
+ the result when element is found in second sequence but not in
+ the first, the result when elements are found in both sequences.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TSecond, TKey, TResult |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second,
+ 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.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TSecond, TKey, TResult |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second,
+ 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.
+ (Defined by OrderedMergeExtension) |
| PadT |
+ Pads a sequence with default values if it is narrower (shorter
+ in length) than a given width.
+ (Defined by MoreEnumerable) |
| PadT |
+ Pads a sequence with default values if it is narrower (shorter
+ in length) than a given width.
+ (Defined by PadExtension) |
| PadT |
+ Pads a sequence with a given filler value if it is narrower (shorter
+ in length) than a given width.
+ (Defined by MoreEnumerable) |
| PadT |
+ Pads a sequence with a dynamic filler value if it is narrower (shorter
+ in length) than a given width.
+ (Defined by MoreEnumerable) |
| PadT |
+ Pads a sequence with a given filler value if it is narrower (shorter
+ in length) than a given width.
+ (Defined by PadExtension) |
| PadT |
+ Pads a sequence with a dynamic filler value if it is narrower (shorter
+ in length) than a given width.
+ (Defined by PadExtension) |
| PadStartT |
+ Pads a sequence with default values in the beginning if it is narrower (shorter
+ in length) than a given width.
+ (Defined by MoreEnumerable) |
| PadStartT |
+ Pads a sequence with default values in the beginning if it is narrower (shorter
+ in length) than a given width.
+ (Defined by PadStartExtension) |
| PadStartT |
+ 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.
+ (Defined by MoreEnumerable) |
| PadStartT |
+ 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.
+ (Defined by MoreEnumerable) |
| PadStartT |
+ 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.
+ (Defined by PadStartExtension) |
| PadStartT |
+ 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.
+ (Defined by PadStartExtension) |
| PairwiseT, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence and its
+ predecessor, with the exception of the first element which is
+ only returned as the predecessor of the second element.
+ (Defined by MoreEnumerable) |
| PairwiseT, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence and its
+ predecessor, with the exception of the first element which is
+ only returned as the predecessor of the second element.
+ (Defined by PairwiseExtension) |
| PartialSortT |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ (Defined by MoreEnumerable) |
| PartialSortT |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ (Defined by PartialSortExtension) |
| PartialSortT |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ An additional parameter specifies the direction of the sort
+ (Defined by MoreEnumerable) |
| PartialSortT |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation. An additional parameter specifies how the
+ elements compare to each other.
+ (Defined by MoreEnumerable) |
| PartialSortT |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ An additional parameter specifies the direction of the sort
+ (Defined by PartialSortExtension) |
| PartialSortT |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation. An additional parameter specifies how the
+ elements compare to each other.
+ (Defined by PartialSortExtension) |
| PartialSortT |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ (Defined by MoreEnumerable) |
| PartialSortT |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ (Defined by PartialSortExtension) |
| PartialSortByT, TKey |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ (Defined by MoreEnumerable) |
| PartialSortByT, TKey |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ (Defined by PartialSortByExtension) |
| PartialSortByT, TKey |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies the direction of the sort
+ (Defined by MoreEnumerable) |
| PartialSortByT, TKey |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies how the keys compare to each other.
+ (Defined by MoreEnumerable) |
| PartialSortByT, TKey |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies the direction of the sort
+ (Defined by PartialSortByExtension) |
| PartialSortByT, TKey |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies how the keys compare to each other.
+ (Defined by PartialSortByExtension) |
| PartialSortByT, TKey |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ (Defined by MoreEnumerable) |
| PartialSortByT, TKey |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ (Defined by PartialSortByExtension) |
| PartitionT |
+ Partitions or splits a sequence in two using a predicate.
+ (Defined by MoreEnumerable) |
| PartitionT |
+ Partitions or splits a sequence in two using a predicate.
+ (Defined by PartitionExtension) |
| PartitionT, TResult |
+ Partitions or splits a sequence in two using a predicate and then
+ projects a result from the two.
+ (Defined by MoreEnumerable) |
| PartitionT, TResult |
+ Partitions or splits a sequence in two using a predicate and then
+ projects a result from the two.
+ (Defined by PartitionExtension) |
| PermutationsT |
+ Generates a sequence of lists that represent the permutations of the original sequence.
+ (Defined by MoreEnumerable) |
| PermutationsT |
+ Generates a sequence of lists that represent the permutations of the original sequence.
+ (Defined by PermutationsExtension) |
| PipeT |
+ Executes the given action on each element in the source sequence
+ and yields it.
+ (Defined by MoreEnumerable) |
| PipeT |
+ Executes the given action on each element in the source sequence
+ and yields it.
+ (Defined by PipeExtension) |
| PrependT |
+ Prepends a single value to a sequence.
+ (Defined by MoreEnumerable) |
| PrependT |
+ Prepends a single value to a sequence.
+ (Defined by PrependExtension) |
| PreScanT |
+ Performs a pre-scan (exclusive prefix sum) on a sequence of elements.
+ (Defined by MoreEnumerable) |
| PreScanT |
+ Performs a pre-scan (exclusive prefix sum) on a sequence of elements.
+ (Defined by PreScanExtension) |
| RandomSubsetT |
+ Returns a sequence of a specified size of random elements from the
+ original sequence.
+ (Defined by MoreEnumerable) |
| RandomSubsetT |
+ Returns a sequence of a specified size of random elements from the
+ original sequence.
+ (Defined by RandomSubsetExtension) |
| RandomSubsetT |
+ 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.
+ (Defined by MoreEnumerable) |
| RandomSubsetT |
+ 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.
+ (Defined by RandomSubsetExtension) |
| RankT |
+ Ranks each item in the sequence in descending ordering using a default comparer.
+ (Defined by MoreEnumerable) |
| RankT |
+ Ranks each item in the sequence in descending ordering using a default comparer.
+ (Defined by RankExtension) |
| RankT |
+ Rank each item in the sequence using a caller-supplied comparer.
+ (Defined by MoreEnumerable) |
| RankT |
+ Rank each item in the sequence using a caller-supplied comparer.
+ (Defined by RankExtension) |
| RankByT, TKey |
+ Ranks each item in the sequence in descending ordering by a specified key using a default comparer
+ (Defined by MoreEnumerable) |
| RankByT, TKey |
+ Ranks each item in the sequence in descending ordering by a specified key using a default comparer
+ (Defined by RankByExtension) |
| RankByT, TKey |
+ Ranks each item in a sequence using a specified key and a caller-supplied comparer
+ (Defined by MoreEnumerable) |
| RankByT, TKey |
+ Ranks each item in a sequence using a specified key and a caller-supplied comparer
+ (Defined by RankByExtension) |
| RepeatT |
+ Repeats the sequence forever.
+ (Defined by MoreEnumerable) |
| RepeatT |
+ Repeats the sequence forever.
+ (Defined by RepeatExtension) |
| RepeatT |
+ Repeats the sequence the specified number of times.
+ (Defined by MoreEnumerable) |
| RepeatT |
+ Repeats the sequence the specified number of times.
+ (Defined by RepeatExtension) |
| RightJoinT, TKey, TResult |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| RightJoinT, TKey, TResult |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by RightJoinExtension) |
| RightJoinT, TKey, TResult |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| RightJoinT, TKey, TResult |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by RightJoinExtension) |
| RightJoinT, TSecond, TKey, TResult |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| RightJoinT, TSecond, TKey, TResult |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by RightJoinExtension) |
| RightJoinT, TSecond, TKey, TResult |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| RightJoinT, TSecond, TKey, TResult |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by RightJoinExtension) |
| RunLengthEncodeT |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count.
+ (Defined by MoreEnumerable) |
| RunLengthEncodeT |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count.
+ (Defined by RunLengthEncodeExtension) |
| RunLengthEncodeT |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count. This overload
+ uses a custom equality comparer to identify equivalent items.
+ (Defined by MoreEnumerable) |
| RunLengthEncodeT |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count. This overload
+ uses a custom equality comparer to identify equivalent items.
+ (Defined by RunLengthEncodeExtension) |
| ScanT |
+ Performs a scan (inclusive prefix sum) on a sequence of elements.
+ (Defined by MoreEnumerable) |
| ScanT |
+ Performs a scan (inclusive prefix sum) on a sequence of elements.
+ (Defined by ScanExtension) |
| ScanT, TState |
+ Like AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) except returns
+ the sequence of intermediate results as well as the final one.
+ An additional parameter specifies a seed.
+ (Defined by MoreEnumerable) |
| ScanT, TState |
+ Like AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) except returns
+ the sequence of intermediate results as well as the final one.
+ An additional parameter specifies a seed.
+ (Defined by ScanExtension) |
| ScanByT, TKey, TState |
+ Applies an accumulator function over sequence element keys,
+ returning the keys along with intermediate accumulator states.
+ (Defined by MoreEnumerable) |
| ScanByT, TKey, TState |
+ Applies an accumulator function over sequence element keys,
+ returning the keys along with intermediate accumulator states.
+ (Defined by ScanByExtension) |
| ScanByT, TKey, TState |
+ 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.
+ (Defined by MoreEnumerable) |
| ScanByT, TKey, TState |
+ 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.
+ (Defined by ScanByExtension) |
| ScanRightT |
+ Performs a right-associative scan (inclusive prefix) on a sequence of elements.
+ This operator is the right-associative version of the
+ ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ (Defined by MoreEnumerable) |
| ScanRightT |
+ Performs a right-associative scan (inclusive prefix) on a sequence of elements.
+ This operator is the right-associative version of the
+ ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ (Defined by ScanRightExtension) |
| ScanRightT, TAccumulate |
+ Performs a right-associative scan (inclusive prefix) on a sequence of elements.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) LINQ operator.
+ (Defined by MoreEnumerable) |
| ScanRightT, TAccumulate |
+ Performs a right-associative scan (inclusive prefix) on a sequence of elements.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) LINQ operator.
+ (Defined by ScanRightExtension) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by MoreEnumerable) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by SegmentExtension) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by MoreEnumerable) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by SegmentExtension) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by MoreEnumerable) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by SegmentExtension) |
| ShuffleT |
+ Returns a sequence of elements in random order from the original
+ sequence.
+ (Defined by MoreEnumerable) |
| ShuffleT |
+ Returns a sequence of elements in random order from the original
+ sequence.
+ (Defined by ShuffleExtension) |
| ShuffleT |
+ 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.
+ (Defined by MoreEnumerable) |
| ShuffleT |
+ 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.
+ (Defined by ShuffleExtension) |
| SkipLastT |
+ Bypasses a specified number of elements at the end of the sequence.
+ (Defined by MoreEnumerable) |
| SkipLastT |
+ Bypasses a specified number of elements at the end of the sequence.
+ (Defined by SkipLastExtension) |
| SkipUntilT |
+ 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.
+ (Defined by MoreEnumerable) |
| SkipUntilT |
+ 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.
+ (Defined by SkipUntilExtension) |
| SliceT |
+ Extracts a contiguous count of elements from a sequence at a particular zero-based
+ starting index.
+ (Defined by MoreEnumerable) |
| SliceT |
+ Extracts a contiguous count of elements from a sequence at a particular zero-based
+ starting index.
+ (Defined by SliceExtension) |
| SortedMergeT |
+ Merges two or more sequences that are in a common order (either ascending or descending)
+ into a single sequence that preserves that order.
+ (Defined by MoreEnumerable) |
| SortedMergeT |
+ Merges two or more sequences that are in a common order (either ascending or descending)
+ into a single sequence that preserves that order.
+ (Defined by SortedMergeExtension) |
| SortedMergeT |
+ Merges two or more sequences that are in a common order (either ascending or descending)
+ into a single sequence that preserves that order.
+ (Defined by MoreEnumerable) |
| SortedMergeT |
+ Merges two or more sequences that are in a common order (either ascending or descending)
+ into a single sequence that preserves that order.
+ (Defined by SortedMergeExtension) |
| SplitT |
+ Splits the source sequence by separator elements identified by a
+ function.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by separator elements identified by a
+ function.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by a separator.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by a separator.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by separator elements identified by a
+ function, given a maximum count of splits.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by separator elements identified by a
+ function, given a maximum count of splits.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by a separator given a maximum count of splits.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by a separator and then transforms the
+ splits into results.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by a separator given a maximum count of splits.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by a separator and then transforms the
+ splits into results.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by a separator, given a maximum count
+ of splits. A parameter specifies how the separator is compared
+ for equality.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by a separator, given a maximum count
+ of splits. A parameter specifies how the separator is compared
+ for equality.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by separator elements identified by
+ a function and then transforms the splits into results.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by separator elements identified by
+ a function and then transforms the splits into results.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by a separator and then transforms
+ the splits into results.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by a separator and then transforms
+ the splits into results.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by separator elements identified by
+ a function, given a maximum count of splits, and then transforms
+ the splits into results.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by separator elements identified by
+ a function, given a maximum count of splits, and then transforms
+ the splits into results.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by a separator and then transforms the
+ splits into results. A parameter specifies how the separator is
+ compared for equality.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by a separator and then transforms the
+ splits into results. A parameter specifies how the separator is
+ compared for equality.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results. A
+ parameter specifies how the separator is compared for equality.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results. A
+ parameter specifies how the separator is compared for equality.
+ (Defined by SplitExtension) |
| StartsWithT |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the default equality
+ comparer.
+ (Defined by MoreEnumerable) |
| StartsWithT |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the default equality
+ comparer.
+ (Defined by StartsWithExtension) |
| StartsWithT |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the specified element
+ equality comparer.
+ (Defined by MoreEnumerable) |
| StartsWithT |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the specified element
+ equality comparer.
+ (Defined by StartsWithExtension) |
| SubsetsT |
+ Returns a sequence of IListT representing all of the subsets of any size
+ that are part of the original sequence. In mathematics, it is equivalent to the
+ power set of a set.
+ (Defined by MoreEnumerable) |
| SubsetsT |
+ Returns a sequence of IListT representing all of the subsets of any size
+ that are part of the original sequence. In mathematics, it is equivalent to the
+ power set of a set.
+ (Defined by SubsetsExtension) |
| SubsetsT |
+ Returns a sequence of IListT representing all subsets of a given size
+ that are part of the original sequence. In mathematics, it is equivalent to the
+ combinations or k-subsets of a set.
+ (Defined by MoreEnumerable) |
| SubsetsT |
+ Returns a sequence of IListT representing all subsets of a given size
+ that are part of the original sequence. In mathematics, it is equivalent to the
+ combinations or k-subsets of a set.
+ (Defined by SubsetsExtension) |
| TagFirstLastT, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence with additional parameters
+ indicating whether the element is the first and/or last of the
+ sequence.
+ (Defined by MoreEnumerable) |
| TagFirstLastT, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence with additional parameters
+ indicating whether the element is the first and/or last of the
+ sequence.
+ (Defined by TagFirstLastExtension) |
| TakeEveryT |
+ Returns every N-th element of a sequence.
+ (Defined by MoreEnumerable) |
| TakeEveryT |
+ Returns every N-th element of a sequence.
+ (Defined by TakeEveryExtension) |
| TakeLastT |
+ Returns a specified number of contiguous elements from the end of
+ a sequence.
+ (Defined by MoreEnumerable) |
| TakeLastT |
+ Returns a specified number of contiguous elements from the end of
+ a sequence.
+ (Defined by TakeLastExtension) |
| TakeUntilT |
+ 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.
+ (Defined by MoreEnumerable) |
| TakeUntilT |
+ 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.
+ (Defined by TakeUntilExtension) |
| ToArrayByIndexT |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT, TResult |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT, TResult |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT, TResult |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT, TResult |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT, TResult |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT, TResult |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT, TResult |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT, TResult |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ (Defined by ToArrayByIndexExtension) |
| ToDataTableT |
+ Converts a sequence to a DataTable object.
+ (Defined by MoreEnumerable) |
| ToDataTableT |
+ Converts a sequence to a DataTable object.
+ (Defined by ToDataTableExtension) |
| ToDataTableT |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ (Defined by MoreEnumerable) |
| ToDataTableT |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ (Defined by ToDataTableExtension) |
| ToDataTableT, TTable |
+ Appends elements in the sequence as rows of a given DataTable object.
+ (Defined by MoreEnumerable) |
| ToDataTableT, TTable |
+ Appends elements in the sequence as rows of a given DataTable object.
+ (Defined by ToDataTableExtension) |
| ToDataTableT, TTable |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ (Defined by MoreEnumerable) |
| ToDataTableT, TTable |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ (Defined by ToDataTableExtension) |
| ToDelimitedStringT |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ (Defined by MoreEnumerable) |
| ToDelimitedStringT |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ (Defined by ToDelimitedStringExtension) |
| ToHashSetT |
+ Returns a HashSetT of the source items using the default equality
+ comparer for the type.
+ (Defined by MoreEnumerable) |
| ToHashSetT |
+ Returns a HashSetT of the source items using the default equality
+ comparer for the type.
+ (Defined by ToHashSetExtension) |
| ToHashSetT |
+ Returns a HashSetT of the source items using the specified equality
+ comparer for the type.
+ (Defined by MoreEnumerable) |
| ToHashSetT |
+ Returns a HashSetT of the source items using the specified equality
+ comparer for the type.
+ (Defined by ToHashSetExtension) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics.
+ (Defined by MoreEnumerable) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics.
+ (Defined by TraceExtension) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics using
+ a custom formatter.
+ (Defined by MoreEnumerable) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics using
+ a custom formatter.
+ (Defined by TraceExtension) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics using
+ custom formatting.
+ (Defined by MoreEnumerable) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics using
+ custom formatting.
+ (Defined by TraceExtension) |
| TrySingleT, TCardinality |
+ Returns a tuple with the cardinality of the sequence and the
+ single element in the sequence if it contains exactly one element.
+ similar to SingleTSource(IEnumerableTSource).
+ (Defined by ExperimentalEnumerable) |
| TrySingleT, TCardinality, TResult |
+ Returns a result projected from the the cardinality of the sequence
+ and the single element in the sequence if it contains exactly one
+ element.
+ (Defined by ExperimentalEnumerable) |
| WindowT |
+ Processes a sequence into a series of sub-sequences representing a windowed subset of
+ the original.
+ (Defined by MoreEnumerable) |
| WindowT |
+ Processes a sequence into a series of sub-sequences representing a windowed subset of
+ the original.
+ (Defined by WindowExtension) |
| WindowedT |
+ Processes a sequence into a series of sub-sequences representing a windowed subset of the original.
+ (Defined by MoreEnumerable) |
| WindowLeftT |
+ Creates a left-aligned sliding window of a given size over the
+ source sequence.
+ (Defined by MoreEnumerable) |
| WindowLeftT |
+ Creates a left-aligned sliding window of a given size over the
+ source sequence.
+ (Defined by WindowLeftExtension) |
| WindowRightT |
+ Creates a right-aligned sliding window over the source sequence
+ of a given size.
+ (Defined by MoreEnumerable) |
| WindowRightT |
+ Creates a right-aligned sliding window over the source sequence
+ of a given size.
+ (Defined by WindowRightExtension) |
| ZipLongestT, TSecond, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipLongestT, TSecond, TResult |
+ 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.
+ (Defined by ZipLongestExtension) |
| ZipLongestT, T2, T3, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipLongestT, T2, T3, TResult |
+ 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.
+ (Defined by ZipLongestExtension) |
| ZipLongestT, T2, T3, T4, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipLongestT, T2, T3, T4, TResult |
+ 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.
+ (Defined by ZipLongestExtension) |
| ZipShortestT, TSecond, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipShortestT, TSecond, TResult |
+ 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.
+ (Defined by ZipShortestExtension) |
| ZipShortestT, T2, T3, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipShortestT, T2, T3, TResult |
+ 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.
+ (Defined by ZipShortestExtension) |
| ZipShortestT, T2, T3, T4, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipShortestT, T2, T3, T4, TResult |
+ 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.
+ (Defined by ZipShortestExtension) |
public static class AcquireExtension<ExtensionAttribute>
+Public NotInheritable Class AcquireExtension[ExtensionAttribute]
+public ref class AcquireExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type AcquireExtension = class end| AcquireTSource | + Ensures that a source sequence of IDisposable + objects are all acquired successfully. If the acquisition of any + one IDisposable fails then those successfully + acquired till that point are disposed. + |
public static class AggregateExtension<ExtensionAttribute>
+Public NotInheritable Class AggregateExtension[ExtensionAttribute]
+public ref class AggregateExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type AggregateExtension = class endpublic static class AggregateRightExtension<ExtensionAttribute>
+Public NotInheritable Class AggregateRightExtension[ExtensionAttribute]
+public ref class AggregateRightExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type AggregateRightExtension = class end| AggregateRightTSource(IEnumerableTSource, FuncTSource, TSource, TSource) | + Applies a right-associative accumulator function over a sequence. + This operator is the right-associative version of the + AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator. + |
| AggregateRightTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate) | + Applies a right-associative accumulator function over a sequence. + The specified seed value is used as the initial accumulator value. + This operator is the right-associative version of the + AggregateTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate) LINQ operator. + |
| AggregateRightTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate, FuncTAccumulate, TResult) | + Applies a right-associative accumulator function over a sequence. + The specified seed value is used as the initial accumulator value, + and the specified function is used to select the result value. + This operator is the right-associative version of the + AggregateTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate, FuncTAccumulate, TResult) LINQ operator. + |
public static class AppendExtension<ExtensionAttribute>
+Public NotInheritable Class AppendExtension[ExtensionAttribute]
+public ref class AppendExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type AppendExtension = class end| AppendT | + Returns a sequence consisting of the head elements and the given tail element. + |
public static class AssertCountExtension<ExtensionAttribute>
+Public NotInheritable Class AssertCountExtension[ExtensionAttribute]
+public ref class AssertCountExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type AssertCountExtension = class end| AssertCountTSource(IEnumerableTSource, Int32) | + Asserts that a source sequence contains a given count of elements. + |
| AssertCountTSource(IEnumerableTSource, Int32, FuncInt32, Int32, Exception) | + Asserts that a source sequence contains a given count of elements. + A parameter specifies the exception to be thrown. + |
public static class AssertExtension<ExtensionAttribute>
+Public NotInheritable Class AssertExtension[ExtensionAttribute]
+public ref class AssertExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type AssertExtension = class end| AssertTSource(IEnumerableTSource, FuncTSource, Boolean) | + Asserts that all elements of a sequence meet a given condition + otherwise throws an Exception object. + |
| AssertTSource(IEnumerableTSource, FuncTSource, Boolean, FuncTSource, Exception) | + Asserts that all elements of a sequence meet a given condition + otherwise throws an Exception object. + |
public static class AtLeastExtension<ExtensionAttribute>
+Public NotInheritable Class AtLeastExtension[ExtensionAttribute]
+public ref class AtLeastExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type AtLeastExtension = class end| AtLeastT | + Determines whether or not the number of elements in the sequence is greater than + or equal to the given integer. + |
public static class AtMostExtension<ExtensionAttribute>
+Public NotInheritable Class AtMostExtension[ExtensionAttribute]
+public ref class AtMostExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type AtMostExtension = class end| AtMostT | + Determines whether or not the number of elements in the sequence is lesser than + or equal to the given integer. + |
public static class BacksertExtension<ExtensionAttribute>
+Public NotInheritable Class BacksertExtension[ExtensionAttribute]
+public ref class BacksertExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type BacksertExtension = class end| BacksertT | + 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. + |
public static class BatchExtension<ExtensionAttribute>
+Public NotInheritable Class BatchExtension[ExtensionAttribute]
+public ref class BatchExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type BatchExtension = class end| BatchTSource(IEnumerableTSource, Int32) | + Batches the source sequence into sized buckets. + |
| BatchTSource, TResult(IEnumerableTSource, Int32, FuncIEnumerableTSource, TResult) | + Batches the source sequence into sized buckets and applies a projection to each bucket. + |
public static class CartesianExtension<ExtensionAttribute>
+Public NotInheritable Class CartesianExtension[ExtensionAttribute]
+public ref class CartesianExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type CartesianExtension = class end| CartesianT1, T2, TResult(IEnumerableT1, IEnumerableT2, FuncT1, T2, TResult) | + 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. + |
| CartesianT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, T5, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, IEnumerableT5, FuncT1, T2, T3, T4, T5, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, T5, T6, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, IEnumerableT5, IEnumerableT6, FuncT1, T2, T3, T4, T5, T6, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, T5, T6, T7, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, IEnumerableT5, IEnumerableT6, IEnumerableT7, FuncT1, T2, T3, T4, T5, T6, T7, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, T5, T6, T7, T8, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, IEnumerableT5, IEnumerableT6, IEnumerableT7, IEnumerableT8, FuncT1, T2, T3, T4, T5, T6, T7, T8, TResult) | + 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. + |
public static class ChooseExtension<ExtensionAttribute>
+Public NotInheritable Class ChooseExtension[ExtensionAttribute]
+public ref class ChooseExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type ChooseExtension = class end| ChooseT, TResult | + 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 true + as its first element and result as the second. + |
public static class CompareCountExtension<ExtensionAttribute>
+Public NotInheritable Class CompareCountExtension[ExtensionAttribute]
+public ref class CompareCountExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type CompareCountExtension = class end| CompareCountTFirst, TSecond | + Compares two sequences and returns an integer that indicates whether the first sequence + has fewer, the same or more elements than the second sequence. + |
public static class ConsumeExtension<ExtensionAttribute>
+Public NotInheritable Class ConsumeExtension[ExtensionAttribute]
+public ref class ConsumeExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type ConsumeExtension = class end| ConsumeT | + Completely consumes the given sequence. This method uses immediate execution, + and doesn't store any data during execution. + |
public static class CountBetweenExtension<ExtensionAttribute>
+Public NotInheritable Class CountBetweenExtension[ExtensionAttribute]
+public ref class CountBetweenExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type CountBetweenExtension = class end| CountBetweenT | + Determines whether or not the number of elements in the sequence is between + an inclusive range of minimum and maximum integers. + |
public static class CountByExtension<ExtensionAttribute>
+Public NotInheritable Class CountByExtension[ExtensionAttribute]
+public ref class CountByExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type CountByExtension = class end| CountByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Applies a key-generating function to each element of a sequence and returns a sequence of + unique keys and their number of occurrences in the original sequence. + |
| CountByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + Applies a key-generating function to each element of a sequence and returns a sequence of + unique keys and their number of occurrences in the original sequence. + An additional argument specifies a comparer to use for testing equivalence of keys. + |
public static class CountDownExtension<ExtensionAttribute>
+Public NotInheritable Class CountDownExtension[ExtensionAttribute]
+public ref class CountDownExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type CountDownExtension = class end| CountDownT, TResult | + 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. + |
public static class DistinctByExtension<ExtensionAttribute>
+Public NotInheritable Class DistinctByExtension[ExtensionAttribute]
+public ref class DistinctByExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type DistinctByExtension = class end| DistinctByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Returns all distinct elements of the given source, where "distinctness" + is determined via a projection and the default equality comparer for the projected type. + |
| DistinctByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + Returns all distinct elements of the given source, where "distinctness" + is determined via a projection and the specified comparer for the projected type. + |
public static class EndsWithExtension<ExtensionAttribute>
+Public NotInheritable Class EndsWithExtension[ExtensionAttribute]
+public ref class EndsWithExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type EndsWithExtension = class end| EndsWithT(IEnumerableT, IEnumerableT) | + Determines whether the end of the first sequence is equivalent to + the second sequence, using the default equality comparer. + |
| EndsWithT(IEnumerableT, IEnumerableT, IEqualityComparerT) | + Determines whether the end of the first sequence is equivalent to + the second sequence, using the specified element equality comparer. + |
public static class EquiZipExtension<ExtensionAttribute>
+Public NotInheritable Class EquiZipExtension[ExtensionAttribute]
+public ref class EquiZipExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type EquiZipExtension = class end| EquiZipTFirst, TSecond, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. An exception is thrown + if the input sequences are of different lengths. + |
| EquiZipT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. An exception is thrown + if the input sequences are of different lengths. + |
| EquiZipT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. An exception is thrown + if the input sequences are of different lengths. + |
public static class EvaluateExtension<ExtensionAttribute>
+Public NotInheritable Class EvaluateExtension[ExtensionAttribute]
+public ref class EvaluateExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type EvaluateExtension = class end| EvaluateT | + Returns a sequence containing the values resulting from invoking (in order) each function in the source sequence of functions. + |
public static class ExactlyExtension<ExtensionAttribute>
+Public NotInheritable Class ExactlyExtension[ExtensionAttribute]
+public ref class ExactlyExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type ExactlyExtension = class end| ExactlyT | + Determines whether or not the number of elements in the sequence is equals to the given integer. + |
public static class ExceptByExtension<ExtensionAttribute>
+Public NotInheritable Class ExceptByExtension[ExtensionAttribute]
+public ref class ExceptByExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type ExceptByExtension = class end| ExceptByTSource, TKey(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey) | + Returns the set of elements in the first sequence which aren't + in the second sequence, according to a given key selector. + |
| ExceptByTSource, TKey(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + Returns the set of elements in the first sequence which aren't + in the second sequence, according to a given key selector. + |
public static class ExcludeExtension<ExtensionAttribute>
+Public NotInheritable Class ExcludeExtension[ExtensionAttribute]
+public ref class ExcludeExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type ExcludeExtension = class end| ExcludeT | + Excludes a contiguous number of elements from a sequence starting + at a given index. + |
public static class FallbackIfEmptyExtension<ExtensionAttribute>
+Public NotInheritable Class FallbackIfEmptyExtension[ExtensionAttribute]
+public ref class FallbackIfEmptyExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type FallbackIfEmptyExtension = class end| FallbackIfEmptyT(IEnumerableT, T) | + Returns the elements of the specified sequence or the specified + value in a singleton collection if the sequence is empty. + |
| FallbackIfEmptyT(IEnumerableT, T) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence from an array of values. + |
| FallbackIfEmptyT(IEnumerableT, IEnumerableT) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence of values. + |
| FallbackIfEmptyT(IEnumerableT, T, T) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence of values. + |
| FallbackIfEmptyT(IEnumerableT, T, T, T) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence of values. + |
| FallbackIfEmptyT(IEnumerableT, T, T, T, T) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence of values. + |
public static class FillBackwardExtension<ExtensionAttribute>
+Public NotInheritable Class FillBackwardExtension[ExtensionAttribute]
+public ref class FillBackwardExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type FillBackwardExtension = class end| FillBackwardT(IEnumerableT) | + Returns a sequence with each null reference or value in the source + replaced with the following non-null reference or value in + that sequence. + |
| FillBackwardT(IEnumerableT, FuncT, Boolean) | + Returns a sequence with each missing element in the source replaced + with the following non-missing element in that sequence. An + additional parameter specifies a function used to determine if an + element is considered missing or not. + |
| FillBackwardT(IEnumerableT, FuncT, Boolean, FuncT, T, T) | + Returns a sequence with each missing element in the source replaced + with the following non-missing element in that sequence. Additional + parameters specify two functions, one used to determine if an + element is considered missing or not and another to provide the + replacement for the missing element. + |
public static class FillForwardExtension<ExtensionAttribute>
+Public NotInheritable Class FillForwardExtension[ExtensionAttribute]
+public ref class FillForwardExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type FillForwardExtension = class end| FillForwardT(IEnumerableT) | + Returns a sequence with each null reference or value in the source + replaced with the previous non-null reference or value seen in + that sequence. + |
| FillForwardT(IEnumerableT, FuncT, Boolean) | + Returns a sequence with each missing element in the source replaced + with the previous non-missing element seen in that sequence. An + additional parameter specifies a function used to determine if an + element is considered missing or not. + |
| FillForwardT(IEnumerableT, FuncT, Boolean, FuncT, T, T) | + Returns a sequence with each missing element in the source replaced + with one based on the previous non-missing element seen in that + sequence. Additional parameters specify two functions, one used to + determine if an element is considered missing or not and another + to provide the replacement for the missing element. + |
public static class FirstExtension<ExtensionAttribute>
+Public NotInheritable Class FirstExtension[ExtensionAttribute]
+public ref class FirstExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type FirstExtension = class end| FirstT | + Returns the first element of a sequence. + |
public static class FirstOrDefaultExtension<ExtensionAttribute>
+Public NotInheritable Class FirstOrDefaultExtension[ExtensionAttribute]
+public ref class FirstOrDefaultExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type FirstOrDefaultExtension = class end| FirstOrDefaultT | + Returns the first element of a sequence, or a default value if the + sequence contains no elements. + |
public static class FlattenExtension<ExtensionAttribute>
+Public NotInheritable Class FlattenExtension[ExtensionAttribute]
+public ref class FlattenExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type FlattenExtension = class end| Flatten(IEnumerable) | + Flattens a sequence containing arbitrarily-nested sequences. + |
| Flatten(IEnumerable, FuncIEnumerable, Boolean) | + Flattens a sequence containing arbitrarily-nested sequences. An + additional parameter specifies a predicate function used to + determine whether a nested IEnumerable should be + flattened or not. + |
| Flatten(IEnumerable, FuncObject, IEnumerable) | + Flattens a sequence containing arbitrarily-nested sequences. An + additional parameter specifies a function that projects an inner + sequence via a property of an object. + |
public static class FoldExtension<ExtensionAttribute>
+Public NotInheritable Class FoldExtension[ExtensionAttribute]
+public ref class FoldExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type FoldExtension = class end| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 16 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 15 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 14 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 13 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 12 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 11 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 10 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 9 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 8 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 7 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 6 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 5 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 4 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, TResult) | + Returns the result of applying a function to a sequence of + 3 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, TResult) | + Returns the result of applying a function to a sequence of + 2 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, TResult) | + Returns the result of applying a function to a sequence of + 1 element. + |
public static class ForEachExtension<ExtensionAttribute>
+Public NotInheritable Class ForEachExtension[ExtensionAttribute]
+public ref class ForEachExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type ForEachExtension = class end| ForEachT(IEnumerableT, ActionT, Int32) | + Immediately executes the given action on each element in the source sequence. + Each element's index is used in the logic of the action. + |
| ForEachT(IEnumerableT, ActionT) | + Immediately executes the given action on each element in the source sequence. + |
public static class FullGroupJoinExtension<ExtensionAttribute>
+Public NotInheritable Class FullGroupJoinExtension[ExtensionAttribute]
+public ref class FullGroupJoinExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type FullGroupJoinExtension = class end| FullGroupJoinTFirst, TSecond, TKey(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey) | + Performs a Full Group Join between the first and second sequences. + |
| FullGroupJoinTFirst, TSecond, TKey(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, IEqualityComparerTKey) | + Performs a Full Group Join between the first and second sequences. + |
| FullGroupJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTKey, IEnumerableTFirst, IEnumerableTSecond, TResult) | + Performs a full group-join between two sequences. + |
| FullGroupJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTKey, IEnumerableTFirst, IEnumerableTSecond, TResult, IEqualityComparerTKey) | + Performs a full group-join between two sequences. + |
public static class FullJoinExtension<ExtensionAttribute>
+Public NotInheritable Class FullJoinExtension[ExtensionAttribute]
+public ref class FullJoinExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type FullJoinExtension = class endpublic static class GroupAdjacentExtension<ExtensionAttribute>
+Public NotInheritable Class GroupAdjacentExtension[ExtensionAttribute]
+public ref class GroupAdjacentExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type GroupAdjacentExtension = class end| GroupAdjacentTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Groups the adjacent elements of a sequence according to a + specified key selector function. + |
| GroupAdjacentTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + Groups the adjacent elements of a sequence according to a + specified key selector function and compares the keys by using a + specified comparer. + |
| GroupAdjacentTSource, TKey, TElement(IEnumerableTSource, FuncTSource, TKey, FuncTSource, TElement) | + Groups the adjacent elements of a sequence according to a + specified key selector function and projects the elements for + each group by using a specified function. + |
| GroupAdjacentTSource, TKey, TResult(IEnumerableTSource, FuncTSource, TKey, FuncTKey, IEnumerableTSource, TResult) | + Groups the adjacent elements of a sequence according to a + specified key selector function. The keys are compared by using + a comparer and each group's elements are projected by using a + specified function. + |
| GroupAdjacentTSource, TKey, TElement(IEnumerableTSource, FuncTSource, TKey, FuncTSource, TElement, IEqualityComparerTKey) | + Groups the adjacent elements of a sequence according to a + specified key selector function. The keys are compared by using + a comparer and each group's elements are projected by using a + specified function. + |
| GroupAdjacentTSource, TKey, TResult(IEnumerableTSource, FuncTSource, TKey, FuncTKey, IEnumerableTSource, TResult, IEqualityComparerTKey) | + Groups the adjacent elements of a sequence according to a + specified key selector function. The keys are compared by using + a comparer and each group's elements are projected by using a + specified function. + |
public static class IndexByExtension<ExtensionAttribute>
+Public NotInheritable Class IndexByExtension[ExtensionAttribute]
+public ref class IndexByExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type IndexByExtension = class end| IndexByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + 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. + |
| IndexByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + 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. + |
public static class IndexExtension<ExtensionAttribute>
+Public NotInheritable Class IndexExtension[ExtensionAttribute]
+public ref class IndexExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type IndexExtension = class end| IndexTSource(IEnumerableTSource) | + Returns a sequence of KeyValuePairTKey, TValue + where the key is the zero-based index of the value in the source + sequence. + |
| IndexTSource(IEnumerableTSource, Int32) | + Returns a sequence of KeyValuePairTKey, TValue + where the key is the index of the value in the source sequence. + An additional parameter specifies the starting index. + |
public static class InsertExtension<ExtensionAttribute>
+Public NotInheritable Class InsertExtension[ExtensionAttribute]
+public ref class InsertExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type InsertExtension = class end| InsertT | + Inserts the elements of a sequence into another sequence at a + specified index. + |
public static class InterleaveExtension<ExtensionAttribute>
+Public NotInheritable Class InterleaveExtension[ExtensionAttribute]
+public ref class InterleaveExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type InterleaveExtension = class end| InterleaveT | + Interleaves the elements of two or more sequences into a single sequence, skipping + sequences as they are consumed. + |
public static class LagExtension<ExtensionAttribute>
+Public NotInheritable Class LagExtension[ExtensionAttribute]
+public ref class LagExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type LagExtension = class end| LagTSource, TResult(IEnumerableTSource, Int32, FuncTSource, TSource, TResult) | + Produces a projection of a sequence by evaluating pairs of elements separated by a + negative offset. + |
| LagTSource, TResult(IEnumerableTSource, Int32, TSource, FuncTSource, TSource, TResult) | + Produces a projection of a sequence by evaluating pairs of elements separated by a + negative offset. + |
public static class LastExtension<ExtensionAttribute>
+Public NotInheritable Class LastExtension[ExtensionAttribute]
+public ref class LastExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type LastExtension = class end| LastT | + Returns the last element of a sequence. + |
public static class LastOrDefaultExtension<ExtensionAttribute>
+Public NotInheritable Class LastOrDefaultExtension[ExtensionAttribute]
+public ref class LastOrDefaultExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type LastOrDefaultExtension = class end| LastOrDefaultT | + Returns the last element of a sequence, or a default value if the + sequence contains no elements. + |
public static class LeadExtension<ExtensionAttribute>
+Public NotInheritable Class LeadExtension[ExtensionAttribute]
+public ref class LeadExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type LeadExtension = class end| LeadTSource, TResult(IEnumerableTSource, Int32, FuncTSource, TSource, TResult) | + Produces a projection of a sequence by evaluating pairs of elements separated by a + positive offset. + |
| LeadTSource, TResult(IEnumerableTSource, Int32, TSource, FuncTSource, TSource, TResult) | + Produces a projection of a sequence by evaluating pairs of elements separated by a + positive offset. + |
public static class LeftJoinExtension<ExtensionAttribute>
+Public NotInheritable Class LeftJoinExtension[ExtensionAttribute]
+public ref class LeftJoinExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type LeftJoinExtension = class endpublic static class MaxByExtension<ExtensionAttribute>
+Public NotInheritable Class MaxByExtension[ExtensionAttribute]
+public ref class MaxByExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type MaxByExtension = class end| MaxByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Returns the maximal elements of the given sequence, based on + the given projection. + |
| MaxByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) | + Returns the maximal elements of the given sequence, based on + the given projection and the specified comparer for projected values. + |
public static class MinByExtension<ExtensionAttribute>
+Public NotInheritable Class MinByExtension[ExtensionAttribute]
+public ref class MinByExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type MinByExtension = class end| MinByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Returns the minimal elements of the given sequence, based on + the given projection. + |
| MinByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) | + Returns the minimal elements of the given sequence, based on + the given projection and the specified comparer for projected values. + |
public static class MoveExtension<ExtensionAttribute>
+Public NotInheritable Class MoveExtension[ExtensionAttribute]
+public ref class MoveExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type MoveExtension = class end| MoveT | + Returns a sequence with a range of elements in the source sequence + moved to a new offset. + |
public static class OrderByExtension<ExtensionAttribute>
+Public NotInheritable Class OrderByExtension[ExtensionAttribute]
+public ref class OrderByExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type OrderByExtension = class end| OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection) | + Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key + |
| OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection) | + Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key + |
public static class OrderedMergeExtension<ExtensionAttribute>
+Public NotInheritable Class OrderedMergeExtension[ExtensionAttribute]
+public ref class OrderedMergeExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type OrderedMergeExtension = class end| OrderedMergeT(IEnumerableT, IEnumerableT) | + Merges two ordered sequences into one. Where the elements equal + in both sequences, the element from the first sequence is + returned in the resulting sequence. + |
| OrderedMergeT(IEnumerableT, IEnumerableT, IComparerT) | + Merges two ordered sequences into one with an additional + parameter specifying how to compare the elements of the + sequences. Where the elements equal in both sequences, the + element from the first sequence is returned in the resulting + sequence. + |
| OrderedMergeT, TKey(IEnumerableT, IEnumerableT, FuncT, TKey) | + Merges two ordered sequences into one with an additional + parameter specifying the element key by which the sequences are + ordered. Where the keys equal in both sequences, the + element from the first sequence is returned in the resulting + sequence. + |
| OrderedMergeT, TKey, TResult(IEnumerableT, IEnumerableT, FuncT, TKey, FuncT, TResult, FuncT, TResult, FuncT, T, TResult) | + Merges two ordered sequences into one. Additional parameters + specify the element key by which the sequences are ordered, + the result when element is found in first sequence but not in + the second, the result when element is found in second sequence + but not in the first and the result when elements are found in + both sequences. + |
| OrderedMergeT, TKey, TResult(IEnumerableT, IEnumerableT, FuncT, TKey, FuncT, TResult, FuncT, TResult, FuncT, T, TResult, IComparerTKey) | + Merges two ordered sequences into one. Additional parameters + specify the element key by which the sequences are ordered, + the result when element is found in first sequence but not in + the second, the result when element is found in second sequence + but not in the first, the result when elements are found in + both sequences and a method for comparing keys. + |
| OrderedMergeTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult) | + Merges two heterogeneous sequences ordered by a common key type + into a homogeneous one. Additional parameters specify the + element key by which the sequences are ordered, the result when + element is found in first sequence but not in the second and + the result when element is found in second sequence but not in + the first, the result when elements are found in both sequences. + |
| OrderedMergeTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult, IComparerTKey) | + Merges two heterogeneous sequences ordered by a common key type + into a homogeneous one. Additional parameters specify the + element key by which the sequences are ordered, the result when + element is found in first sequence but not in the second, + the result when element is found in second sequence but not in + the first, the result when elements are found in both sequences + and a method for comparing keys. + |
public static class PadExtension<ExtensionAttribute>
+Public NotInheritable Class PadExtension[ExtensionAttribute]
+public ref class PadExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type PadExtension = class end| PadTSource(IEnumerableTSource, Int32) | + Pads a sequence with default values if it is narrower (shorter + in length) than a given width. + |
| PadTSource(IEnumerableTSource, Int32, TSource) | + Pads a sequence with a given filler value if it is narrower (shorter + in length) than a given width. + |
| PadTSource(IEnumerableTSource, Int32, FuncInt32, TSource) | + Pads a sequence with a dynamic filler value if it is narrower (shorter + in length) than a given width. + |
public static class PadStartExtension<ExtensionAttribute>
+Public NotInheritable Class PadStartExtension[ExtensionAttribute]
+public ref class PadStartExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type PadStartExtension = class end| PadStartTSource(IEnumerableTSource, Int32) | + Pads a sequence with default values in the beginning if it is narrower (shorter + in length) than a given width. + |
| PadStartTSource(IEnumerableTSource, Int32, TSource) | + Pads a sequence with a given filler value in the beginning if it is narrower (shorter + in length) than a given width. + An additional parameter specifies the value to use for padding. + |
| PadStartTSource(IEnumerableTSource, Int32, FuncInt32, TSource) | + Pads a sequence with a dynamic filler value in the beginning if it is narrower (shorter + in length) than a given width. + An additional parameter specifies the function to calculate padding. + |
public static class PairwiseExtension<ExtensionAttribute>
+Public NotInheritable Class PairwiseExtension[ExtensionAttribute]
+public ref class PairwiseExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type PairwiseExtension = class end| PairwiseTSource, TResult | + Returns a sequence resulting from applying a function to each + element in the source sequence and its + predecessor, with the exception of the first element which is + only returned as the predecessor of the second element. + |
public static class PartialSortByExtension<ExtensionAttribute>
+Public NotInheritable Class PartialSortByExtension[ExtensionAttribute]
+public ref class PartialSortByExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type PartialSortByExtension = class endpublic static class PartialSortExtension<ExtensionAttribute>
+Public NotInheritable Class PartialSortExtension[ExtensionAttribute]
+public ref class PartialSortExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type PartialSortExtension = class endpublic static class PartitionExtension<ExtensionAttribute>
+Public NotInheritable Class PartitionExtension[ExtensionAttribute]
+public ref class PartitionExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type PartitionExtension = class endpublic static class PermutationsExtension<ExtensionAttribute>
+Public NotInheritable Class PermutationsExtension[ExtensionAttribute]
+public ref class PermutationsExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type PermutationsExtension = class end| PermutationsT | + Generates a sequence of lists that represent the permutations of the original sequence. + |
public static class PipeExtension<ExtensionAttribute>
+Public NotInheritable Class PipeExtension[ExtensionAttribute]
+public ref class PipeExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type PipeExtension = class end| PipeT | + Executes the given action on each element in the source sequence + and yields it. + |
public static class PreScanExtension<ExtensionAttribute>
+Public NotInheritable Class PreScanExtension[ExtensionAttribute]
+public ref class PreScanExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type PreScanExtension = class end| PreScanTSource | + Performs a pre-scan (exclusive prefix sum) on a sequence of elements. + |
public static class PrependExtension<ExtensionAttribute>
+Public NotInheritable Class PrependExtension[ExtensionAttribute]
+public ref class PrependExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type PrependExtension = class end| PrependTSource | + Prepends a single value to a sequence. + |
public static class RandomSubsetExtension<ExtensionAttribute>
+Public NotInheritable Class RandomSubsetExtension[ExtensionAttribute]
+public ref class RandomSubsetExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type RandomSubsetExtension = class end| RandomSubsetT(IEnumerableT, Int32) | + Returns a sequence of a specified size of random elements from the + original sequence. + |
| RandomSubsetT(IEnumerableT, Int32, Random) | + Returns a sequence of a specified size of random elements from the + original sequence. An additional parameter specifies a random + generator to be used for the random selection algorithm. + |
public static class RankByExtension<ExtensionAttribute>
+Public NotInheritable Class RankByExtension[ExtensionAttribute]
+public ref class RankByExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type RankByExtension = class end| RankByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Ranks each item in the sequence in descending ordering by a specified key using a default comparer + |
| RankByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) | + Ranks each item in a sequence using a specified key and a caller-supplied comparer + |
public static class RankExtension<ExtensionAttribute>
+Public NotInheritable Class RankExtension[ExtensionAttribute]
+public ref class RankExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type RankExtension = class end| RankTSource(IEnumerableTSource) | + Ranks each item in the sequence in descending ordering using a default comparer. + |
| RankTSource(IEnumerableTSource, IComparerTSource) | + Rank each item in the sequence using a caller-supplied comparer. + |
public static class RepeatExtension<ExtensionAttribute>
+Public NotInheritable Class RepeatExtension[ExtensionAttribute]
+public ref class RepeatExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type RepeatExtension = class end| RepeatT(IEnumerableT) | + Repeats the sequence forever. + |
| RepeatT(IEnumerableT, Int32) | + Repeats the sequence the specified number of times. + |
public static class RightJoinExtension<ExtensionAttribute>
+Public NotInheritable Class RightJoinExtension[ExtensionAttribute]
+public ref class RightJoinExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type RightJoinExtension = class endpublic static class RunLengthEncodeExtension<ExtensionAttribute>
+Public NotInheritable Class RunLengthEncodeExtension[ExtensionAttribute]
+public ref class RunLengthEncodeExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type RunLengthEncodeExtension = class end| RunLengthEncodeT(IEnumerableT) | + Run-length encodes a sequence by converting consecutive instances of the same element into + a KeyValuePair{T,int} representing the item and its occurrence count. + |
| RunLengthEncodeT(IEnumerableT, IEqualityComparerT) | + Run-length encodes a sequence by converting consecutive instances of the same element into + a KeyValuePair{T,int} representing the item and its occurrence count. This overload + uses a custom equality comparer to identify equivalent items. + |
public static class ScanByExtension<ExtensionAttribute>
+Public NotInheritable Class ScanByExtension[ExtensionAttribute]
+public ref class ScanByExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type ScanByExtension = class end| ScanByTSource, TKey, TState(IEnumerableTSource, FuncTSource, TKey, FuncTKey, TState, FuncTState, TKey, TSource, TState) | + Applies an accumulator function over sequence element keys, + returning the keys along with intermediate accumulator states. + |
| ScanByTSource, TKey, TState(IEnumerableTSource, FuncTSource, TKey, FuncTKey, TState, FuncTState, TKey, TSource, TState, IEqualityComparerTKey) | + 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. + |
public static class ScanExtension<ExtensionAttribute>
+Public NotInheritable Class ScanExtension[ExtensionAttribute]
+public ref class ScanExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type ScanExtension = class end| ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) | + Performs a scan (inclusive prefix sum) on a sequence of elements. + |
| ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) | + Like AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) except returns + the sequence of intermediate results as well as the final one. + An additional parameter specifies a seed. + |
public static class ScanRightExtension<ExtensionAttribute>
+Public NotInheritable Class ScanRightExtension[ExtensionAttribute]
+public ref class ScanRightExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type ScanRightExtension = class end| ScanRightTSource(IEnumerableTSource, FuncTSource, TSource, TSource) | + Performs a right-associative scan (inclusive prefix) on a sequence of elements. + This operator is the right-associative version of the + ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator. + |
| ScanRightTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate) | + Performs a right-associative scan (inclusive prefix) on a sequence of elements. + The specified seed value is used as the initial accumulator value. + This operator is the right-associative version of the + ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) LINQ operator. + |
public static class SegmentExtension<ExtensionAttribute>
+Public NotInheritable Class SegmentExtension[ExtensionAttribute]
+public ref class SegmentExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type SegmentExtension = class end| SegmentT(IEnumerableT, FuncT, T, Int32, Boolean) | + Divides a sequence into multiple sequences by using a segment detector based on the original sequence + |
| SegmentT(IEnumerableT, FuncT, Boolean) | + Divides a sequence into multiple sequences by using a segment detector based on the original sequence + |
| SegmentT(IEnumerableT, FuncT, Int32, Boolean) | + Divides a sequence into multiple sequences by using a segment detector based on the original sequence + |
public static class ShuffleExtension<ExtensionAttribute>
+Public NotInheritable Class ShuffleExtension[ExtensionAttribute]
+public ref class ShuffleExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type ShuffleExtension = class end| ShuffleT(IEnumerableT) | + Returns a sequence of elements in random order from the original + sequence. + |
| ShuffleT(IEnumerableT, Random) | + 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. + |
public static class SingleExtension<ExtensionAttribute>
+Public NotInheritable Class SingleExtension[ExtensionAttribute]
+public ref class SingleExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type SingleExtension = class end| SingleT | + Returns the only element of a sequence, and throws an exception if + there is not exactly one element in the sequence. + |
public static class SingleOrDefaultExtension<ExtensionAttribute>
+Public NotInheritable Class SingleOrDefaultExtension[ExtensionAttribute]
+public ref class SingleOrDefaultExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type SingleOrDefaultExtension = class end| SingleOrDefaultT | + 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. + |
public static class SkipLastExtension<ExtensionAttribute>
+Public NotInheritable Class SkipLastExtension[ExtensionAttribute]
+public ref class SkipLastExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type SkipLastExtension = class end| SkipLastT | + Bypasses a specified number of elements at the end of the sequence. + |
public static class SkipUntilExtension<ExtensionAttribute>
+Public NotInheritable Class SkipUntilExtension[ExtensionAttribute]
+public ref class SkipUntilExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type SkipUntilExtension = class end| SkipUntilTSource | + Skips items from the input sequence until the given predicate returns true + when applied to the current source item; that item will be the last skipped. + |
public static class SliceExtension<ExtensionAttribute>
+Public NotInheritable Class SliceExtension[ExtensionAttribute]
+public ref class SliceExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type SliceExtension = class end| SliceT | + Extracts a contiguous count of elements from a sequence at a particular zero-based + starting index. + |
public static class SortedMergeExtension<ExtensionAttribute>
+Public NotInheritable Class SortedMergeExtension[ExtensionAttribute]
+public ref class SortedMergeExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type SortedMergeExtension = class end| SortedMergeTSource(IEnumerableTSource, OrderByDirection, IEnumerableTSource) | + Merges two or more sequences that are in a common order (either ascending or descending) + into a single sequence that preserves that order. + |
| SortedMergeTSource(IEnumerableTSource, OrderByDirection, IComparerTSource, IEnumerableTSource) | + Merges two or more sequences that are in a common order (either ascending or descending) + into a single sequence that preserves that order. + |
public static class SplitExtension<ExtensionAttribute>
+Public NotInheritable Class SplitExtension[ExtensionAttribute]
+public ref class SplitExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type SplitExtension = class end| SplitTSource(IEnumerableTSource, TSource) | + Splits the source sequence by a separator. + |
| SplitTSource(IEnumerableTSource, FuncTSource, Boolean) | + Splits the source sequence by separator elements identified by a + function. + |
| SplitTSource(IEnumerableTSource, TSource, IEqualityComparerTSource) | + Splits the source sequence by a separator and then transforms the + splits into results. + |
| SplitTSource(IEnumerableTSource, TSource, Int32) | + Splits the source sequence by a separator given a maximum count of splits. + |
| SplitTSource(IEnumerableTSource, FuncTSource, Boolean, Int32) | + Splits the source sequence by separator elements identified by a + function, given a maximum count of splits. + |
| SplitTSource(IEnumerableTSource, TSource, IEqualityComparerTSource, Int32) | + Splits the source sequence by a separator, given a maximum count + of splits. A parameter specifies how the separator is compared + for equality. + |
| SplitTSource, TResult(IEnumerableTSource, TSource, FuncIEnumerableTSource, TResult) | + Splits the source sequence by a separator and then transforms + the splits into results. + |
| SplitTSource, TResult(IEnumerableTSource, FuncTSource, Boolean, FuncIEnumerableTSource, TResult) | + Splits the source sequence by separator elements identified by + a function and then transforms the splits into results. + |
| SplitTSource, TResult(IEnumerableTSource, TSource, IEqualityComparerTSource, FuncIEnumerableTSource, TResult) | + Splits the source sequence by a separator and then transforms the + splits into results. A parameter specifies how the separator is + compared for equality. + |
| SplitTSource, TResult(IEnumerableTSource, TSource, Int32, FuncIEnumerableTSource, TResult) | + Splits the source sequence by a separator, given a maximum count + of splits, and then transforms the splits into results. + |
| SplitTSource, TResult(IEnumerableTSource, FuncTSource, Boolean, Int32, FuncIEnumerableTSource, TResult) | + Splits the source sequence by separator elements identified by + a function, given a maximum count of splits, and then transforms + the splits into results. + |
| SplitTSource, TResult(IEnumerableTSource, TSource, IEqualityComparerTSource, Int32, FuncIEnumerableTSource, TResult) | + Splits the source sequence by a separator, given a maximum count + of splits, and then transforms the splits into results. A + parameter specifies how the separator is compared for equality. + |
public static class StartsWithExtension<ExtensionAttribute>
+Public NotInheritable Class StartsWithExtension[ExtensionAttribute]
+public ref class StartsWithExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type StartsWithExtension = class end| StartsWithT(IEnumerableT, IEnumerableT) | + Determines whether the beginning of the first sequence is + equivalent to the second sequence, using the default equality + comparer. + |
| StartsWithT(IEnumerableT, IEnumerableT, IEqualityComparerT) | + Determines whether the beginning of the first sequence is + equivalent to the second sequence, using the specified element + equality comparer. + |
public static class SubsetsExtension<ExtensionAttribute>
+Public NotInheritable Class SubsetsExtension[ExtensionAttribute]
+public ref class SubsetsExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type SubsetsExtension = class end| SubsetsT(IEnumerableT) | + Returns a sequence of IListT representing all of the subsets of any size + that are part of the original sequence. In mathematics, it is equivalent to the + power set of a set. + |
| SubsetsT(IEnumerableT, Int32) | + Returns a sequence of IListT representing all subsets of a given size + that are part of the original sequence. In mathematics, it is equivalent to the + combinations or k-subsets of a set. + |
public static class TagFirstLastExtension<ExtensionAttribute>
+Public NotInheritable Class TagFirstLastExtension[ExtensionAttribute]
+public ref class TagFirstLastExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type TagFirstLastExtension = class end| TagFirstLastTSource, TResult | + Returns a sequence resulting from applying a function to each + element in the source sequence with additional parameters + indicating whether the element is the first and/or last of the + sequence. + |
public static class TakeEveryExtension<ExtensionAttribute>
+Public NotInheritable Class TakeEveryExtension[ExtensionAttribute]
+public ref class TakeEveryExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type TakeEveryExtension = class end| TakeEveryTSource | + Returns every N-th element of a sequence. + |
public static class TakeLastExtension<ExtensionAttribute>
+Public NotInheritable Class TakeLastExtension[ExtensionAttribute]
+public ref class TakeLastExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type TakeLastExtension = class end| TakeLastTSource | + Returns a specified number of contiguous elements from the end of + a sequence. + |
public static class TakeUntilExtension<ExtensionAttribute>
+Public NotInheritable Class TakeUntilExtension[ExtensionAttribute]
+public ref class TakeUntilExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type TakeUntilExtension = class end| TakeUntilTSource | + Returns items from the input sequence until the given predicate returns true + when applied to the current source item; that item will be the last returned. + |
public static class ThenByExtension<ExtensionAttribute>
+Public NotInheritable Class ThenByExtension[ExtensionAttribute]
+public ref class ThenByExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type ThenByExtension = class end| ThenByT, TKey(IOrderedEnumerableT, FuncT, TKey, OrderByDirection) | + Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key + |
| ThenByT, TKey(IOrderedEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection) | + Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key + |
public static class ToArrayByIndexExtension<ExtensionAttribute>
+Public NotInheritable Class ToArrayByIndexExtension[ExtensionAttribute]
+public ref class ToArrayByIndexExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type ToArrayByIndexExtension = class end| ToArrayByIndexT(IEnumerableT, FuncT, Int32) | + Creates an array from an IEnumerableT where a + function is used to determine the index at which an element will + be placed in the array. + |
| ToArrayByIndexT(IEnumerableT, Int32, FuncT, Int32) | + Creates an array of user-specified length from an + IEnumerableT where a function is used to determine + the index at which an element will be placed in the array. + |
| ToArrayByIndexT, TResult(IEnumerableT, FuncT, Int32, FuncT, TResult) | + Creates an array from an IEnumerableT where a + function is used to determine the index at which an element will + be placed in the array. The elements are projected into the array + via an additional function. + |
| ToArrayByIndexT, TResult(IEnumerableT, FuncT, Int32, FuncT, Int32, TResult) | + Creates an array from an IEnumerableT where a + function is used to determine the index at which an element will + be placed in the array. The elements are projected into the array + via an additional function. + |
| ToArrayByIndexT, TResult(IEnumerableT, Int32, FuncT, Int32, FuncT, TResult) | + Creates an array of user-specified length from an + IEnumerableT where a function is used to determine + the index at which an element will be placed in the array. The + elements are projected into the array via an additional function. + |
| ToArrayByIndexT, TResult(IEnumerableT, Int32, FuncT, Int32, FuncT, Int32, TResult) | + Creates an array of user-specified length from an + IEnumerableT where a function is used to determine + the index at which an element will be placed in the array. The + elements are projected into the array via an additional function. + |
public static class ToDataTableExtension<ExtensionAttribute>
+Public NotInheritable Class ToDataTableExtension[ExtensionAttribute]
+public ref class ToDataTableExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type ToDataTableExtension = class end| ToDataTableT(IEnumerableT) | + Converts a sequence to a DataTable object. + |
| ToDataTableT(IEnumerableT, ExpressionFuncT, Object) | + Appends elements in the sequence as rows of a given DataTable + object with a set of lambda expressions specifying which members (property + or field) of each element in the sequence will supply the column values. + |
| ToDataTableT, TTable(IEnumerableT, TTable) | + Appends elements in the sequence as rows of a given DataTable object. + |
| ToDataTableT, TTable(IEnumerableT, TTable, ExpressionFuncT, Object) | + Appends elements in the sequence as rows of a given DataTable + object with a set of lambda expressions specifying which members (property + or field) of each element in the sequence will supply the column values. + |
public static class ToDelimitedStringExtension<ExtensionAttribute>
+Public NotInheritable Class ToDelimitedStringExtension[ExtensionAttribute]
+public ref class ToDelimitedStringExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type ToDelimitedStringExtension = class end| ToDelimitedString(IEnumerableBoolean, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableByte, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableChar, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableDecimal, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableDouble, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableInt16, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableInt32, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableInt64, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableSByte, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableSingle, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableString, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableUInt16, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableUInt32, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableUInt64, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedStringTSource(IEnumerableTSource, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
public static class ToDictionaryExtension<ExtensionAttribute>
+Public NotInheritable Class ToDictionaryExtension[ExtensionAttribute]
+public ref class ToDictionaryExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type ToDictionaryExtension = class end| ToDictionaryTKey, TValue(IEnumerableKeyValuePairTKey, TValue) | + Creates a DictionaryTKey, TValue from a sequence of + KeyValuePairTKey, TValue elements. + |
| ToDictionaryTKey, TValue(IEnumerableValueTupleTKey, TValue) | + Creates a DictionaryTKey, TValue from a sequence of + tuples of 2 where the first item is the key and the second the + value. + |
| ToDictionaryTKey, TValue(IEnumerableKeyValuePairTKey, TValue, IEqualityComparerTKey) | + Creates a DictionaryTKey, TValue from a sequence of + KeyValuePairTKey, TValue elements. An additional + parameter specifies a comparer for keys. + |
| ToDictionaryTKey, TValue(IEnumerableValueTupleTKey, TValue, IEqualityComparerTKey) | + Creates a DictionaryTKey, TValue from a sequence of + tuples of 2 where the first item is the key and the second the + value. An additional parameter specifies a comparer for keys. + |
public static class ToHashSetExtension<ExtensionAttribute>
+Public NotInheritable Class ToHashSetExtension[ExtensionAttribute]
+public ref class ToHashSetExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type ToHashSetExtension = class end| ToHashSetTSource(IEnumerableTSource) | + Returns a HashSetT of the source items using the default equality + comparer for the type. + |
| ToHashSetTSource(IEnumerableTSource, IEqualityComparerTSource) | + Returns a HashSetT of the source items using the specified equality + comparer for the type. + |
public static class ToLookupExtension<ExtensionAttribute>
+Public NotInheritable Class ToLookupExtension[ExtensionAttribute]
+public ref class ToLookupExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type ToLookupExtension = class end| ToLookupTKey, TValue(IEnumerableKeyValuePairTKey, TValue) | + Creates a ILookupTKey, TElement from a sequence of + KeyValuePairTKey, TValue elements. + |
| ToLookupTKey, TValue(IEnumerableValueTupleTKey, TValue) | + Creates a LookupTKey, TElement from a sequence of + tuples of 2 where the first item is the key and the second the + value. + |
| ToLookupTKey, TValue(IEnumerableKeyValuePairTKey, TValue, IEqualityComparerTKey) | + Creates a ILookupTKey, TElement from a sequence of + KeyValuePairTKey, TValue elements. An additional + parameter specifies a comparer for keys. + |
| ToLookupTKey, TValue(IEnumerableValueTupleTKey, TValue, IEqualityComparerTKey) | + Creates a LookupTKey, TElement 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. + |
public static class TraceExtension<ExtensionAttribute>
+Public NotInheritable Class TraceExtension[ExtensionAttribute]
+public ref class TraceExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type TraceExtension = class end| TraceTSource(IEnumerableTSource) | + Traces the elements of a source sequence for diagnostics. + |
| TraceTSource(IEnumerableTSource, FuncTSource, String) | + Traces the elements of a source sequence for diagnostics using + a custom formatter. + |
| TraceTSource(IEnumerableTSource, String) | + Traces the elements of a source sequence for diagnostics using + custom formatting. + |
public static class TransposeExtension<ExtensionAttribute>
+Public NotInheritable Class TransposeExtension[ExtensionAttribute]
+public ref class TransposeExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type TransposeExtension = class end| TransposeT | + Transposes a sequence of rows into a sequence of columns. + |
public static class WindowExtension<ExtensionAttribute>
+Public NotInheritable Class WindowExtension[ExtensionAttribute]
+public ref class WindowExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type WindowExtension = class end| WindowTSource | + Processes a sequence into a series of sub-sequences representing a windowed subset of + the original. + |
public static class WindowLeftExtension<ExtensionAttribute>
+Public NotInheritable Class WindowLeftExtension[ExtensionAttribute]
+public ref class WindowLeftExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type WindowLeftExtension = class end| WindowLeftTSource | + Creates a left-aligned sliding window of a given size over the + source sequence. + |
public static class WindowRightExtension<ExtensionAttribute>
+Public NotInheritable Class WindowRightExtension[ExtensionAttribute]
+public ref class WindowRightExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type WindowRightExtension = class end| WindowRightTSource | + Creates a right-aligned sliding window over the source sequence + of a given size. + |
public static class ZipLongestExtension<ExtensionAttribute>
+Public NotInheritable Class ZipLongestExtension[ExtensionAttribute]
+public ref class ZipLongestExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type ZipLongestExtension = class end| ZipLongestTFirst, TSecond, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. 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. + |
| ZipLongestT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. 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. + |
| ZipLongestT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. 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. + |
public static class ZipShortestExtension<ExtensionAttribute>
+Public NotInheritable Class ZipShortestExtension[ExtensionAttribute]
+public ref class ZipShortestExtension abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type ZipShortestExtension = class end| ZipShortestTFirst, TSecond, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. The resulting sequence + is as short as the shortest input sequence. + |
| ZipShortestT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. The resulting sequence + is as short as the shortest input sequence. + |
| ZipShortestT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. The resulting sequence + is as short as the shortest input sequence. + |
public interface IExtremaEnumerable<out T> : IEnumerable<T>,
+ IEnumerable
+Public Interface IExtremaEnumerable(Of Out T)
+ Inherits IEnumerable(Of T), IEnumerablegeneric<typename T>
+public interface class IExtremaEnumerable : IEnumerable<T>,
+ IEnumerabletype IExtremaEnumerable<'T> =
+ interface
+ interface IEnumerable<'T>
+ interface IEnumerable
+ end| GetEnumerator | Returns an enumerator that iterates through the collection. (Inherited from IEnumerableT) |
| Take | + Returns a specified number of contiguous elements from the start of + the sequence. + |
| TakeLast | + Returns a specified number of contiguous elements at the end of the + sequence. + |
| AggregateT, TResult1, TResult2, TResult |
+ Applies two accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TResult |
+ Applies two accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TResult |
+ Applies two accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult |
+ Applies three accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TResult |
+ Applies three accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TResult |
+ Applies three accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult |
+ Applies four accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult |
+ Applies four accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult |
+ Applies four accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult |
+ Applies five accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult |
+ Applies five accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult |
+ Applies five accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult |
+ Applies six accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult |
+ Applies six accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult |
+ Applies six accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult |
+ Applies seven accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult |
+ Applies seven accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult |
+ Applies seven accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult8, TResult |
+ Applies eight accumulator queries sequentially in a single
+ pass over a sequence.
+ (Defined by ExperimentalEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult |
+ Applies eight accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by MoreEnumerable) |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult |
+ Applies eight accumulators sequentially in a single pass over a
+ sequence.
+ (Defined by AggregateExtension) |
| AggregateRightT |
+ Applies a right-associative accumulator function over a sequence.
+ This operator is the right-associative version of the
+ AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ (Defined by MoreEnumerable) |
| AggregateRightT |
+ Applies a right-associative accumulator function over a sequence.
+ This operator is the right-associative version of the
+ AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ (Defined by AggregateRightExtension) |
| AggregateRightT, TAccumulate |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate) LINQ operator.
+ (Defined by MoreEnumerable) |
| AggregateRightT, TAccumulate |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate) LINQ operator.
+ (Defined by AggregateRightExtension) |
| AggregateRightT, TAccumulate, TResult |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value,
+ and the specified function is used to select the result value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate, FuncTAccumulate, TResult) LINQ operator.
+ (Defined by MoreEnumerable) |
| AggregateRightT, TAccumulate, TResult |
+ Applies a right-associative accumulator function over a sequence.
+ The specified seed value is used as the initial accumulator value,
+ and the specified function is used to select the result value.
+ This operator is the right-associative version of the
+ AggregateTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate, FuncTAccumulate, TResult) LINQ operator.
+ (Defined by AggregateRightExtension) |
| AppendT |
+ Returns a sequence consisting of the head elements and the given tail element.
+ (Defined by MoreEnumerable) |
| AppendT |
+ Returns a sequence consisting of the head elements and the given tail element.
+ (Defined by AppendExtension) |
| AssertT |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ (Defined by MoreEnumerable) |
| AssertT |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ (Defined by AssertExtension) |
| AssertT |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ (Defined by MoreEnumerable) |
| AssertT |
+ Asserts that all elements of a sequence meet a given condition
+ otherwise throws an Exception object.
+ (Defined by AssertExtension) |
| AssertCountT |
+ Asserts that a source sequence contains a given count of elements.
+ (Defined by MoreEnumerable) |
| AssertCountT |
+ Asserts that a source sequence contains a given count of elements.
+ (Defined by AssertCountExtension) |
| AssertCountT |
+ Asserts that a source sequence contains a given count of elements.
+ A parameter specifies the exception to be thrown.
+ (Defined by MoreEnumerable) |
| AssertCountT |
+ Asserts that a source sequence contains a given count of elements.
+ A parameter specifies the exception to be thrown.
+ (Defined by AssertCountExtension) |
| AtLeastT |
+ Determines whether or not the number of elements in the sequence is greater than
+ or equal to the given integer.
+ (Defined by MoreEnumerable) |
| AtLeastT |
+ Determines whether or not the number of elements in the sequence is greater than
+ or equal to the given integer.
+ (Defined by AtLeastExtension) |
| AtMostT |
+ Determines whether or not the number of elements in the sequence is lesser than
+ or equal to the given integer.
+ (Defined by MoreEnumerable) |
| AtMostT |
+ Determines whether or not the number of elements in the sequence is lesser than
+ or equal to the given integer.
+ (Defined by AtMostExtension) |
| AwaitT, TResult |
+ Creates a sequence query that streams the result of each task in
+ the source sequence as it completes asynchronously. A
+ CancellationToken is passed for each asynchronous
+ evaluation to abort any asynchronous operations in flight if the
+ sequence is not fully iterated.
+ (Defined by ExperimentalEnumerable) |
| AwaitCompletionT, TTaskResult, TResult |
+ 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.
+ (Defined by ExperimentalEnumerable) |
| BacksertT |
+ 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.
+ (Defined by MoreEnumerable) |
| BacksertT |
+ 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.
+ (Defined by BacksertExtension) |
| BatchT |
+ Batches the source sequence into sized buckets.
+ (Defined by MoreEnumerable) |
| BatchT |
+ Batches the source sequence into sized buckets.
+ (Defined by BatchExtension) |
| BatchT, TResult |
+ Batches the source sequence into sized buckets and applies a projection to each bucket.
+ (Defined by MoreEnumerable) |
| BatchT, TResult |
+ Batches the source sequence into sized buckets and applies a projection to each bucket.
+ (Defined by BatchExtension) |
| BatchT, TResult |
+ Batches the source sequence into sized buckets using an array pool
+ to rent arrays to back each bucket and returns a sequence of
+ elements projected from each bucket.
+ (Defined by ExperimentalEnumerable) |
| BatchT, TBucket, TResult |
+ Batches the source sequence into sized buckets using an array pool
+ to rent arrays to back each bucket and returns a sequence of
+ elements projected from each bucket.
+ (Defined by ExperimentalEnumerable) |
| CartesianT, T2, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, T5, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, T5, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, T5, T6, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, T5, T6, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, T5, T6, T7, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, T5, T6, T7, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| CartesianT, T2, T3, T4, T5, T6, T7, T8, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CartesianT, T2, T3, T4, T5, T6, T7, T8, TResult |
+ 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.
+ (Defined by CartesianExtension) |
| ChooseT, TResult |
+ 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 true
+ as its first element and result as the second.
+ (Defined by MoreEnumerable) |
| ChooseT, TResult |
+ 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 true
+ as its first element and result as the second.
+ (Defined by ChooseExtension) |
| CompareCountT, TSecond |
+ Compares two sequences and returns an integer that indicates whether the first sequence
+ has fewer, the same or more elements than the second sequence.
+ (Defined by MoreEnumerable) |
| CompareCountT, TSecond |
+ Compares two sequences and returns an integer that indicates whether the first sequence
+ has fewer, the same or more elements than the second sequence.
+ (Defined by CompareCountExtension) |
| ConcatT |
+ Returns a sequence consisting of the head elements and the given tail element.
+ (Defined by MoreEnumerable) |
| ConsumeT |
+ Completely consumes the given sequence. This method uses immediate execution,
+ and doesn't store any data during execution.
+ (Defined by MoreEnumerable) |
| ConsumeT |
+ Completely consumes the given sequence. This method uses immediate execution,
+ and doesn't store any data during execution.
+ (Defined by ConsumeExtension) |
| CountBetweenT |
+ Determines whether or not the number of elements in the sequence is between
+ an inclusive range of minimum and maximum integers.
+ (Defined by MoreEnumerable) |
| CountBetweenT |
+ Determines whether or not the number of elements in the sequence is between
+ an inclusive range of minimum and maximum integers.
+ (Defined by CountBetweenExtension) |
| CountByT, TKey |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ (Defined by MoreEnumerable) |
| CountByT, TKey |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ (Defined by CountByExtension) |
| CountByT, TKey |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ An additional argument specifies a comparer to use for testing equivalence of keys.
+ (Defined by MoreEnumerable) |
| CountByT, TKey |
+ Applies a key-generating function to each element of a sequence and returns a sequence of
+ unique keys and their number of occurrences in the original sequence.
+ An additional argument specifies a comparer to use for testing equivalence of keys.
+ (Defined by CountByExtension) |
| CountDownT, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| CountDownT, TResult |
+ 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.
+ (Defined by CountDownExtension) |
| DistinctByT, TKey |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the default equality comparer for the projected type.
+ (Defined by MoreEnumerable) |
| DistinctByT, TKey |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the default equality comparer for the projected type.
+ (Defined by DistinctByExtension) |
| DistinctByT, TKey |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the specified comparer for the projected type.
+ (Defined by MoreEnumerable) |
| DistinctByT, TKey |
+ Returns all distinct elements of the given source, where "distinctness"
+ is determined via a projection and the specified comparer for the projected type.
+ (Defined by DistinctByExtension) |
| EndsWithT |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the default equality comparer.
+ (Defined by MoreEnumerable) |
| EndsWithT |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the default equality comparer.
+ (Defined by EndsWithExtension) |
| EndsWithT |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the specified element equality comparer.
+ (Defined by MoreEnumerable) |
| EndsWithT |
+ Determines whether the end of the first sequence is equivalent to
+ the second sequence, using the specified element equality comparer.
+ (Defined by EndsWithExtension) |
| EquiZipT, TSecond, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| EquiZipT, TSecond, TResult |
+ 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.
+ (Defined by EquiZipExtension) |
| EquiZipT, T2, T3, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| EquiZipT, T2, T3, TResult |
+ 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.
+ (Defined by EquiZipExtension) |
| EquiZipT, T2, T3, T4, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| EquiZipT, T2, T3, T4, TResult |
+ 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.
+ (Defined by EquiZipExtension) |
| ExactlyT |
+ Determines whether or not the number of elements in the sequence is equals to the given integer.
+ (Defined by MoreEnumerable) |
| ExactlyT |
+ Determines whether or not the number of elements in the sequence is equals to the given integer.
+ (Defined by ExactlyExtension) |
| ExceptByT, TKey |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ (Defined by MoreEnumerable) |
| ExceptByT, TKey |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ (Defined by ExceptByExtension) |
| ExceptByT, TKey |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ (Defined by MoreEnumerable) |
| ExceptByT, TKey |
+ Returns the set of elements in the first sequence which aren't
+ in the second sequence, according to a given key selector.
+ (Defined by ExceptByExtension) |
| ExcludeT |
+ Excludes a contiguous number of elements from a sequence starting
+ at a given index.
+ (Defined by MoreEnumerable) |
| ExcludeT |
+ Excludes a contiguous number of elements from a sequence starting
+ at a given index.
+ (Defined by ExcludeExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of the specified sequence or the specified
+ value in a singleton collection if the sequence is empty.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence from an array of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of the specified sequence or the specified
+ value in a singleton collection if the sequence is empty.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence from an array of values.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by FallbackIfEmptyExtension) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by MoreEnumerable) |
| FallbackIfEmptyT |
+ Returns the elements of a sequence, but if it is empty then
+ returns an alternate sequence of values.
+ (Defined by FallbackIfEmptyExtension) |
| FillBackwardT |
+ Returns a sequence with each null reference or value in the source
+ replaced with the following non-null reference or value in
+ that sequence.
+ (Defined by MoreEnumerable) |
| FillBackwardT |
+ Returns a sequence with each null reference or value in the source
+ replaced with the following non-null reference or value in
+ that sequence.
+ (Defined by FillBackwardExtension) |
| FillBackwardT |
+ 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.
+ (Defined by MoreEnumerable) |
| FillBackwardT |
+ 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.
+ (Defined by FillBackwardExtension) |
| FillBackwardT |
+ Returns a sequence with each missing element in the source replaced
+ with the following non-missing element in that sequence. Additional
+ parameters specify two functions, one used to determine if an
+ element is considered missing or not and another to provide the
+ replacement for the missing element.
+ (Defined by MoreEnumerable) |
| FillBackwardT |
+ Returns a sequence with each missing element in the source replaced
+ with the following non-missing element in that sequence. Additional
+ parameters specify two functions, one used to determine if an
+ element is considered missing or not and another to provide the
+ replacement for the missing element.
+ (Defined by FillBackwardExtension) |
| FillForwardT |
+ 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.
+ (Defined by MoreEnumerable) |
| FillForwardT |
+ 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.
+ (Defined by FillForwardExtension) |
| FillForwardT |
+ 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.
+ (Defined by MoreEnumerable) |
| FillForwardT |
+ 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.
+ (Defined by FillForwardExtension) |
| FillForwardT |
+ 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 specify two functions, one used to
+ determine if an element is considered missing or not and another
+ to provide the replacement for the missing element.
+ (Defined by MoreEnumerable) |
| FillForwardT |
+ 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 specify two functions, one used to
+ determine if an element is considered missing or not and another
+ to provide the replacement for the missing element.
+ (Defined by FillForwardExtension) |
| FirstT |
+ Returns the first element of a sequence.
+ (Defined by MoreEnumerable) |
| FirstT |
+ Returns the first element of a sequence.
+ (Defined by FirstExtension) |
| FirstOrDefaultT |
+ Returns the first element of a sequence, or a default value if the
+ sequence contains no elements.
+ (Defined by MoreEnumerable) |
| FirstOrDefaultT |
+ Returns the first element of a sequence, or a default value if the
+ sequence contains no elements.
+ (Defined by FirstOrDefaultExtension) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences.
+ (Defined by MoreEnumerable) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences.
+ (Defined by FlattenExtension) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a predicate function used to
+ determine whether a nested IEnumerable should be
+ flattened or not.
+ (Defined by MoreEnumerable) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a function that projects an inner
+ sequence via a property of an object.
+ (Defined by MoreEnumerable) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a predicate function used to
+ determine whether a nested IEnumerable should be
+ flattened or not.
+ (Defined by FlattenExtension) |
| Flatten |
+ Flattens a sequence containing arbitrarily-nested sequences. An
+ additional parameter specifies a function that projects an inner
+ sequence via a property of an object.
+ (Defined by FlattenExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 9 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 9 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 10 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 10 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 11 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 11 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 12 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 12 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 13 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 13 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 14 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 14 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 15 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 15 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 16 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 16 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 1 element.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 1 element.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 2 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 2 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 3 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 3 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 4 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 4 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 5 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 5 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 6 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 6 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 7 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 7 elements.
+ (Defined by FoldExtension) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 8 elements.
+ (Defined by MoreEnumerable) |
| FoldT, TResult |
+ Returns the result of applying a function to a sequence of
+ 8 elements.
+ (Defined by FoldExtension) |
| ForEachT |
+ Immediately executes the given action on each element in the source sequence.
+ (Defined by MoreEnumerable) |
| ForEachT |
+ Immediately executes the given action on each element in the source sequence.
+ (Defined by ForEachExtension) |
| ForEachT |
+ Immediately executes the given action on each element in the source sequence.
+ Each element's index is used in the logic of the action.
+ (Defined by MoreEnumerable) |
| ForEachT |
+ Immediately executes the given action on each element in the source sequence.
+ Each element's index is used in the logic of the action.
+ (Defined by ForEachExtension) |
| FullGroupJoinT, TSecond, TKey |
+ Performs a Full Group Join between the first and second sequences.
+ (Defined by MoreEnumerable) |
| FullGroupJoinT, TSecond, TKey |
+ Performs a Full Group Join between the first and second sequences.
+ (Defined by FullGroupJoinExtension) |
| FullGroupJoinT, TSecond, TKey |
+ Performs a Full Group Join between the first and second sequences.
+ (Defined by MoreEnumerable) |
| FullGroupJoinT, TSecond, TKey |
+ Performs a Full Group Join between the first and second sequences.
+ (Defined by FullGroupJoinExtension) |
| FullGroupJoinT, TSecond, TKey, TResult |
+ Performs a full group-join between two sequences.
+ (Defined by MoreEnumerable) |
| FullGroupJoinT, TSecond, TKey, TResult |
+ Performs a full group-join between two sequences.
+ (Defined by FullGroupJoinExtension) |
| FullGroupJoinT, TSecond, TKey, TResult |
+ Performs a full group-join between two sequences.
+ (Defined by MoreEnumerable) |
| FullGroupJoinT, TSecond, TKey, TResult |
+ Performs a full group-join between two sequences.
+ (Defined by FullGroupJoinExtension) |
| FullJoinT, TKey, TResult |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| FullJoinT, TKey, TResult |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by FullJoinExtension) |
| FullJoinT, TKey, TResult |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| FullJoinT, TKey, TResult |
+ Performs a full outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by FullJoinExtension) |
| FullJoinT, TSecond, TKey, TResult |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| FullJoinT, TSecond, TKey, TResult |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by FullJoinExtension) |
| FullJoinT, TSecond, TKey, TResult |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| FullJoinT, TSecond, TKey, TResult |
+ Performs a full outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by FullJoinExtension) |
| GroupAdjacentT, TKey |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and compares the keys by using a
+ specified comparer.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and compares the keys by using a
+ specified comparer.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey, TElement |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and projects the elements for
+ each group by using a specified function.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey, TResult |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey, TElement |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function and projects the elements for
+ each group by using a specified function.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey, TResult |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey, TElement |
+ 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.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey, TResult |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ (Defined by MoreEnumerable) |
| GroupAdjacentT, TKey, TElement |
+ 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.
+ (Defined by GroupAdjacentExtension) |
| GroupAdjacentT, TKey, TResult |
+ Groups the adjacent elements of a sequence according to a
+ specified key selector function. The keys are compared by using
+ a comparer and each group's elements are projected by using a
+ specified function.
+ (Defined by GroupAdjacentExtension) |
| IndexT |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the zero-based index of the value in the source
+ sequence.
+ (Defined by MoreEnumerable) |
| IndexT |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the zero-based index of the value in the source
+ sequence.
+ (Defined by IndexExtension) |
| IndexT |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the index of the value in the source sequence.
+ An additional parameter specifies the starting index.
+ (Defined by MoreEnumerable) |
| IndexT |
+ Returns a sequence of KeyValuePairTKey, TValue
+ where the key is the index of the value in the source sequence.
+ An additional parameter specifies the starting index.
+ (Defined by IndexExtension) |
| IndexByT, TKey |
+ 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.
+ (Defined by MoreEnumerable) |
| IndexByT, TKey |
+ 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.
+ (Defined by IndexByExtension) |
| IndexByT, TKey |
+ 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.
+ (Defined by MoreEnumerable) |
| IndexByT, TKey |
+ 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.
+ (Defined by IndexByExtension) |
| InsertT |
+ Inserts the elements of a sequence into another sequence at a
+ specified index.
+ (Defined by MoreEnumerable) |
| InsertT |
+ Inserts the elements of a sequence into another sequence at a
+ specified index.
+ (Defined by InsertExtension) |
| InterleaveT |
+ Interleaves the elements of two or more sequences into a single sequence, skipping
+ sequences as they are consumed.
+ (Defined by MoreEnumerable) |
| InterleaveT |
+ Interleaves the elements of two or more sequences into a single sequence, skipping
+ sequences as they are consumed.
+ (Defined by InterleaveExtension) |
| LagT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ negative offset.
+ (Defined by MoreEnumerable) |
| LagT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ negative offset.
+ (Defined by LagExtension) |
| LagT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ negative offset.
+ (Defined by MoreEnumerable) |
| LagT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ negative offset.
+ (Defined by LagExtension) |
| LastT |
+ Returns the last element of a sequence.
+ (Defined by MoreEnumerable) |
| LastT |
+ Returns the last element of a sequence.
+ (Defined by LastExtension) |
| LastOrDefaultT |
+ Returns the last element of a sequence, or a default value if the
+ sequence contains no elements.
+ (Defined by MoreEnumerable) |
| LastOrDefaultT |
+ Returns the last element of a sequence, or a default value if the
+ sequence contains no elements.
+ (Defined by LastOrDefaultExtension) |
| LeadT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ positive offset.
+ (Defined by MoreEnumerable) |
| LeadT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ positive offset.
+ (Defined by LeadExtension) |
| LeadT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ positive offset.
+ (Defined by MoreEnumerable) |
| LeadT, TResult |
+ Produces a projection of a sequence by evaluating pairs of elements separated by a
+ positive offset.
+ (Defined by LeadExtension) |
| LeftJoinT, TKey, TResult |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| LeftJoinT, TKey, TResult |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by LeftJoinExtension) |
| LeftJoinT, TKey, TResult |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| LeftJoinT, TKey, TResult |
+ Performs a left outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by LeftJoinExtension) |
| LeftJoinT, TSecond, TKey, TResult |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| LeftJoinT, TSecond, TKey, TResult |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by LeftJoinExtension) |
| LeftJoinT, TSecond, TKey, TResult |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| LeftJoinT, TSecond, TKey, TResult |
+ Performs a left outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by LeftJoinExtension) |
| MaxByT, TKey |
+ Returns the maximal elements of the given sequence, based on
+ the given projection.
+ (Defined by MoreEnumerable) |
| MaxByT, TKey |
+ Returns the maximal elements of the given sequence, based on
+ the given projection.
+ (Defined by MaxByExtension) |
| MaxByT, TKey |
+ Returns the maximal elements of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ (Defined by MoreEnumerable) |
| MaxByT, TKey |
+ Returns the maximal elements of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ (Defined by MaxByExtension) |
| MemoizeT |
+ 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.
+ (Defined by ExperimentalEnumerable) |
| MinByT, TKey |
+ Returns the minimal elements of the given sequence, based on
+ the given projection.
+ (Defined by MoreEnumerable) |
| MinByT, TKey |
+ Returns the minimal elements of the given sequence, based on
+ the given projection.
+ (Defined by MinByExtension) |
| MinByT, TKey |
+ Returns the minimal elements of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ (Defined by MoreEnumerable) |
| MinByT, TKey |
+ Returns the minimal elements of the given sequence, based on
+ the given projection and the specified comparer for projected values.
+ (Defined by MinByExtension) |
| MoveT |
+ Returns a sequence with a range of elements in the source sequence
+ moved to a new offset.
+ (Defined by MoreEnumerable) |
| MoveT |
+ Returns a sequence with a range of elements in the source sequence
+ moved to a new offset.
+ (Defined by MoveExtension) |
| OrderByT, TKey |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ (Defined by MoreEnumerable) |
| OrderByT, TKey |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ (Defined by OrderByExtension) |
| OrderByT, TKey |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ (Defined by MoreEnumerable) |
| OrderByT, TKey |
+ Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
+ (Defined by OrderByExtension) |
| OrderedMergeT |
+ 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.
+ (Defined by MoreEnumerable) |
| OrderedMergeT |
+ 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.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT |
+ 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.
+ (Defined by MoreEnumerable) |
| OrderedMergeT |
+ 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.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TKey |
+ Merges two ordered sequences into one with an additional
+ parameter specifying the element key by which the sequences are
+ ordered. Where the keys equal in both sequences, the
+ element from the first sequence is returned in the resulting
+ sequence.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TKey |
+ Merges two ordered sequences into one with an additional
+ parameter specifying the element key by which the sequences are
+ ordered. Where the keys equal in both sequences, the
+ element from the first sequence is returned in the resulting
+ sequence.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TKey, TResult |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first and the result when elements are found in
+ both sequences.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TKey, TResult |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first and the result when elements are found in
+ both sequences.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TKey, TResult |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first, the result when elements are found in
+ both sequences and a method for comparing keys.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TKey, TResult |
+ Merges two ordered sequences into one. Additional parameters
+ specify the element key by which the sequences are ordered,
+ the result when element is found in first sequence but not in
+ the second, the result when element is found in second sequence
+ but not in the first, the result when elements are found in
+ both sequences and a method for comparing keys.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TSecond, TKey, TResult |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second and
+ the result when element is found in second sequence but not in
+ the first, the result when elements are found in both sequences.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TSecond, TKey, TResult |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second and
+ the result when element is found in second sequence but not in
+ the first, the result when elements are found in both sequences.
+ (Defined by OrderedMergeExtension) |
| OrderedMergeT, TSecond, TKey, TResult |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second,
+ 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.
+ (Defined by MoreEnumerable) |
| OrderedMergeT, TSecond, TKey, TResult |
+ Merges two heterogeneous sequences ordered by a common key type
+ into a homogeneous one. Additional parameters specify the
+ element key by which the sequences are ordered, the result when
+ element is found in first sequence but not in the second,
+ 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.
+ (Defined by OrderedMergeExtension) |
| PadT |
+ Pads a sequence with default values if it is narrower (shorter
+ in length) than a given width.
+ (Defined by MoreEnumerable) |
| PadT |
+ Pads a sequence with default values if it is narrower (shorter
+ in length) than a given width.
+ (Defined by PadExtension) |
| PadT |
+ Pads a sequence with a given filler value if it is narrower (shorter
+ in length) than a given width.
+ (Defined by MoreEnumerable) |
| PadT |
+ Pads a sequence with a dynamic filler value if it is narrower (shorter
+ in length) than a given width.
+ (Defined by MoreEnumerable) |
| PadT |
+ Pads a sequence with a given filler value if it is narrower (shorter
+ in length) than a given width.
+ (Defined by PadExtension) |
| PadT |
+ Pads a sequence with a dynamic filler value if it is narrower (shorter
+ in length) than a given width.
+ (Defined by PadExtension) |
| PadStartT |
+ Pads a sequence with default values in the beginning if it is narrower (shorter
+ in length) than a given width.
+ (Defined by MoreEnumerable) |
| PadStartT |
+ Pads a sequence with default values in the beginning if it is narrower (shorter
+ in length) than a given width.
+ (Defined by PadStartExtension) |
| PadStartT |
+ 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.
+ (Defined by MoreEnumerable) |
| PadStartT |
+ 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.
+ (Defined by MoreEnumerable) |
| PadStartT |
+ 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.
+ (Defined by PadStartExtension) |
| PadStartT |
+ 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.
+ (Defined by PadStartExtension) |
| PairwiseT, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence and its
+ predecessor, with the exception of the first element which is
+ only returned as the predecessor of the second element.
+ (Defined by MoreEnumerable) |
| PairwiseT, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence and its
+ predecessor, with the exception of the first element which is
+ only returned as the predecessor of the second element.
+ (Defined by PairwiseExtension) |
| PartialSortT |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ (Defined by MoreEnumerable) |
| PartialSortT |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ (Defined by PartialSortExtension) |
| PartialSortT |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ An additional parameter specifies the direction of the sort
+ (Defined by MoreEnumerable) |
| PartialSortT |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation. An additional parameter specifies how the
+ elements compare to each other.
+ (Defined by MoreEnumerable) |
| PartialSortT |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ An additional parameter specifies the direction of the sort
+ (Defined by PartialSortExtension) |
| PartialSortT |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation. An additional parameter specifies how the
+ elements compare to each other.
+ (Defined by PartialSortExtension) |
| PartialSortT |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ (Defined by MoreEnumerable) |
| PartialSortT |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
+ where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
+ in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ (Defined by PartialSortExtension) |
| PartialSortByT, TKey |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ (Defined by MoreEnumerable) |
| PartialSortByT, TKey |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ (Defined by PartialSortByExtension) |
| PartialSortByT, TKey |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies the direction of the sort
+ (Defined by MoreEnumerable) |
| PartialSortByT, TKey |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies how the keys compare to each other.
+ (Defined by MoreEnumerable) |
| PartialSortByT, TKey |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies the direction of the sort
+ (Defined by PartialSortByExtension) |
| PartialSortByT, TKey |
+ Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ An additional parameter specifies how the keys compare to each other.
+ (Defined by PartialSortByExtension) |
| PartialSortByT, TKey |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ (Defined by MoreEnumerable) |
| PartialSortByT, TKey |
+ Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
+ and TakeTSource(IEnumerableTSource, Int32) in a single operation.
+ Additional parameters specify how the elements compare to each other and
+ the direction of the sort.
+ (Defined by PartialSortByExtension) |
| PartitionT |
+ Partitions or splits a sequence in two using a predicate.
+ (Defined by MoreEnumerable) |
| PartitionT |
+ Partitions or splits a sequence in two using a predicate.
+ (Defined by PartitionExtension) |
| PartitionT, TResult |
+ Partitions or splits a sequence in two using a predicate and then
+ projects a result from the two.
+ (Defined by MoreEnumerable) |
| PartitionT, TResult |
+ Partitions or splits a sequence in two using a predicate and then
+ projects a result from the two.
+ (Defined by PartitionExtension) |
| PermutationsT |
+ Generates a sequence of lists that represent the permutations of the original sequence.
+ (Defined by MoreEnumerable) |
| PermutationsT |
+ Generates a sequence of lists that represent the permutations of the original sequence.
+ (Defined by PermutationsExtension) |
| PipeT |
+ Executes the given action on each element in the source sequence
+ and yields it.
+ (Defined by MoreEnumerable) |
| PipeT |
+ Executes the given action on each element in the source sequence
+ and yields it.
+ (Defined by PipeExtension) |
| PrependT |
+ Prepends a single value to a sequence.
+ (Defined by MoreEnumerable) |
| PrependT |
+ Prepends a single value to a sequence.
+ (Defined by PrependExtension) |
| PreScanT |
+ Performs a pre-scan (exclusive prefix sum) on a sequence of elements.
+ (Defined by MoreEnumerable) |
| PreScanT |
+ Performs a pre-scan (exclusive prefix sum) on a sequence of elements.
+ (Defined by PreScanExtension) |
| RandomSubsetT |
+ Returns a sequence of a specified size of random elements from the
+ original sequence.
+ (Defined by MoreEnumerable) |
| RandomSubsetT |
+ Returns a sequence of a specified size of random elements from the
+ original sequence.
+ (Defined by RandomSubsetExtension) |
| RandomSubsetT |
+ 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.
+ (Defined by MoreEnumerable) |
| RandomSubsetT |
+ 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.
+ (Defined by RandomSubsetExtension) |
| RankT |
+ Ranks each item in the sequence in descending ordering using a default comparer.
+ (Defined by MoreEnumerable) |
| RankT |
+ Ranks each item in the sequence in descending ordering using a default comparer.
+ (Defined by RankExtension) |
| RankT |
+ Rank each item in the sequence using a caller-supplied comparer.
+ (Defined by MoreEnumerable) |
| RankT |
+ Rank each item in the sequence using a caller-supplied comparer.
+ (Defined by RankExtension) |
| RankByT, TKey |
+ Ranks each item in the sequence in descending ordering by a specified key using a default comparer
+ (Defined by MoreEnumerable) |
| RankByT, TKey |
+ Ranks each item in the sequence in descending ordering by a specified key using a default comparer
+ (Defined by RankByExtension) |
| RankByT, TKey |
+ Ranks each item in a sequence using a specified key and a caller-supplied comparer
+ (Defined by MoreEnumerable) |
| RankByT, TKey |
+ Ranks each item in a sequence using a specified key and a caller-supplied comparer
+ (Defined by RankByExtension) |
| RepeatT |
+ Repeats the sequence forever.
+ (Defined by MoreEnumerable) |
| RepeatT |
+ Repeats the sequence forever.
+ (Defined by RepeatExtension) |
| RepeatT |
+ Repeats the sequence the specified number of times.
+ (Defined by MoreEnumerable) |
| RepeatT |
+ Repeats the sequence the specified number of times.
+ (Defined by RepeatExtension) |
| RightJoinT, TKey, TResult |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| RightJoinT, TKey, TResult |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by RightJoinExtension) |
| RightJoinT, TKey, TResult |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| RightJoinT, TKey, TResult |
+ Performs a right outer join on two homogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by RightJoinExtension) |
| RightJoinT, TSecond, TKey, TResult |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by MoreEnumerable) |
| RightJoinT, TSecond, TKey, TResult |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions and result
+ projection functions.
+ (Defined by RightJoinExtension) |
| RightJoinT, TSecond, TKey, TResult |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by MoreEnumerable) |
| RightJoinT, TSecond, TKey, TResult |
+ Performs a right outer join on two heterogeneous sequences.
+ Additional arguments specify key selection functions, result
+ projection functions and a key comparer.
+ (Defined by RightJoinExtension) |
| RunLengthEncodeT |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count.
+ (Defined by MoreEnumerable) |
| RunLengthEncodeT |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count.
+ (Defined by RunLengthEncodeExtension) |
| RunLengthEncodeT |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count. This overload
+ uses a custom equality comparer to identify equivalent items.
+ (Defined by MoreEnumerable) |
| RunLengthEncodeT |
+ Run-length encodes a sequence by converting consecutive instances of the same element into
+ a KeyValuePair{T,int} representing the item and its occurrence count. This overload
+ uses a custom equality comparer to identify equivalent items.
+ (Defined by RunLengthEncodeExtension) |
| ScanT |
+ Performs a scan (inclusive prefix sum) on a sequence of elements.
+ (Defined by MoreEnumerable) |
| ScanT |
+ Performs a scan (inclusive prefix sum) on a sequence of elements.
+ (Defined by ScanExtension) |
| ScanT, TState |
+ Like AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) except returns
+ the sequence of intermediate results as well as the final one.
+ An additional parameter specifies a seed.
+ (Defined by MoreEnumerable) |
| ScanT, TState |
+ Like AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) except returns
+ the sequence of intermediate results as well as the final one.
+ An additional parameter specifies a seed.
+ (Defined by ScanExtension) |
| ScanByT, TKey, TState |
+ Applies an accumulator function over sequence element keys,
+ returning the keys along with intermediate accumulator states.
+ (Defined by MoreEnumerable) |
| ScanByT, TKey, TState |
+ Applies an accumulator function over sequence element keys,
+ returning the keys along with intermediate accumulator states.
+ (Defined by ScanByExtension) |
| ScanByT, TKey, TState |
+ 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.
+ (Defined by MoreEnumerable) |
| ScanByT, TKey, TState |
+ 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.
+ (Defined by ScanByExtension) |
| ScanRightT |
+ Performs a right-associative scan (inclusive prefix) on a sequence of elements.
+ This operator is the right-associative version of the
+ ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ (Defined by MoreEnumerable) |
| ScanRightT |
+ Performs a right-associative scan (inclusive prefix) on a sequence of elements.
+ This operator is the right-associative version of the
+ ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
+ (Defined by ScanRightExtension) |
| ScanRightT, TAccumulate |
+ Performs a right-associative scan (inclusive prefix) on a sequence of elements.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) LINQ operator.
+ (Defined by MoreEnumerable) |
| ScanRightT, TAccumulate |
+ Performs a right-associative scan (inclusive prefix) on a sequence of elements.
+ The specified seed value is used as the initial accumulator value.
+ This operator is the right-associative version of the
+ ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) LINQ operator.
+ (Defined by ScanRightExtension) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by MoreEnumerable) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by SegmentExtension) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by MoreEnumerable) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by SegmentExtension) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by MoreEnumerable) |
| SegmentT |
+ Divides a sequence into multiple sequences by using a segment detector based on the original sequence
+ (Defined by SegmentExtension) |
| ShuffleT |
+ Returns a sequence of elements in random order from the original
+ sequence.
+ (Defined by MoreEnumerable) |
| ShuffleT |
+ Returns a sequence of elements in random order from the original
+ sequence.
+ (Defined by ShuffleExtension) |
| ShuffleT |
+ 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.
+ (Defined by MoreEnumerable) |
| ShuffleT |
+ 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.
+ (Defined by ShuffleExtension) |
| SingleT |
+ Returns the only element of a sequence, and throws an exception if
+ there is not exactly one element in the sequence.
+ (Defined by MoreEnumerable) |
| SingleT |
+ Returns the only element of a sequence, and throws an exception if
+ there is not exactly one element in the sequence.
+ (Defined by SingleExtension) |
| SingleOrDefaultT |
+ 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.
+ (Defined by MoreEnumerable) |
| SingleOrDefaultT |
+ 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.
+ (Defined by SingleOrDefaultExtension) |
| SkipLastT |
+ Bypasses a specified number of elements at the end of the sequence.
+ (Defined by MoreEnumerable) |
| SkipLastT |
+ Bypasses a specified number of elements at the end of the sequence.
+ (Defined by SkipLastExtension) |
| SkipUntilT |
+ 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.
+ (Defined by MoreEnumerable) |
| SkipUntilT |
+ 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.
+ (Defined by SkipUntilExtension) |
| SliceT |
+ Extracts a contiguous count of elements from a sequence at a particular zero-based
+ starting index.
+ (Defined by MoreEnumerable) |
| SliceT |
+ Extracts a contiguous count of elements from a sequence at a particular zero-based
+ starting index.
+ (Defined by SliceExtension) |
| SortedMergeT |
+ Merges two or more sequences that are in a common order (either ascending or descending)
+ into a single sequence that preserves that order.
+ (Defined by MoreEnumerable) |
| SortedMergeT |
+ Merges two or more sequences that are in a common order (either ascending or descending)
+ into a single sequence that preserves that order.
+ (Defined by SortedMergeExtension) |
| SortedMergeT |
+ Merges two or more sequences that are in a common order (either ascending or descending)
+ into a single sequence that preserves that order.
+ (Defined by MoreEnumerable) |
| SortedMergeT |
+ Merges two or more sequences that are in a common order (either ascending or descending)
+ into a single sequence that preserves that order.
+ (Defined by SortedMergeExtension) |
| SplitT |
+ Splits the source sequence by separator elements identified by a
+ function.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by separator elements identified by a
+ function.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by a separator.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by a separator.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by separator elements identified by a
+ function, given a maximum count of splits.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by separator elements identified by a
+ function, given a maximum count of splits.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by a separator given a maximum count of splits.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by a separator and then transforms the
+ splits into results.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by a separator given a maximum count of splits.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by a separator and then transforms the
+ splits into results.
+ (Defined by SplitExtension) |
| SplitT |
+ Splits the source sequence by a separator, given a maximum count
+ of splits. A parameter specifies how the separator is compared
+ for equality.
+ (Defined by MoreEnumerable) |
| SplitT |
+ Splits the source sequence by a separator, given a maximum count
+ of splits. A parameter specifies how the separator is compared
+ for equality.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by separator elements identified by
+ a function and then transforms the splits into results.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by separator elements identified by
+ a function and then transforms the splits into results.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by a separator and then transforms
+ the splits into results.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by a separator and then transforms
+ the splits into results.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by separator elements identified by
+ a function, given a maximum count of splits, and then transforms
+ the splits into results.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by separator elements identified by
+ a function, given a maximum count of splits, and then transforms
+ the splits into results.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by a separator and then transforms the
+ splits into results. A parameter specifies how the separator is
+ compared for equality.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by a separator and then transforms the
+ splits into results. A parameter specifies how the separator is
+ compared for equality.
+ (Defined by SplitExtension) |
| SplitT, TResult |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results. A
+ parameter specifies how the separator is compared for equality.
+ (Defined by MoreEnumerable) |
| SplitT, TResult |
+ Splits the source sequence by a separator, given a maximum count
+ of splits, and then transforms the splits into results. A
+ parameter specifies how the separator is compared for equality.
+ (Defined by SplitExtension) |
| StartsWithT |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the default equality
+ comparer.
+ (Defined by MoreEnumerable) |
| StartsWithT |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the default equality
+ comparer.
+ (Defined by StartsWithExtension) |
| StartsWithT |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the specified element
+ equality comparer.
+ (Defined by MoreEnumerable) |
| StartsWithT |
+ Determines whether the beginning of the first sequence is
+ equivalent to the second sequence, using the specified element
+ equality comparer.
+ (Defined by StartsWithExtension) |
| SubsetsT |
+ Returns a sequence of IListT representing all of the subsets of any size
+ that are part of the original sequence. In mathematics, it is equivalent to the
+ power set of a set.
+ (Defined by MoreEnumerable) |
| SubsetsT |
+ Returns a sequence of IListT representing all of the subsets of any size
+ that are part of the original sequence. In mathematics, it is equivalent to the
+ power set of a set.
+ (Defined by SubsetsExtension) |
| SubsetsT |
+ Returns a sequence of IListT representing all subsets of a given size
+ that are part of the original sequence. In mathematics, it is equivalent to the
+ combinations or k-subsets of a set.
+ (Defined by MoreEnumerable) |
| SubsetsT |
+ Returns a sequence of IListT representing all subsets of a given size
+ that are part of the original sequence. In mathematics, it is equivalent to the
+ combinations or k-subsets of a set.
+ (Defined by SubsetsExtension) |
| TagFirstLastT, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence with additional parameters
+ indicating whether the element is the first and/or last of the
+ sequence.
+ (Defined by MoreEnumerable) |
| TagFirstLastT, TResult |
+ Returns a sequence resulting from applying a function to each
+ element in the source sequence with additional parameters
+ indicating whether the element is the first and/or last of the
+ sequence.
+ (Defined by TagFirstLastExtension) |
| TakeEveryT |
+ Returns every N-th element of a sequence.
+ (Defined by MoreEnumerable) |
| TakeEveryT |
+ Returns every N-th element of a sequence.
+ (Defined by TakeEveryExtension) |
| TakeLastT |
+ Returns a specified number of contiguous elements from the end of
+ a sequence.
+ (Defined by MoreEnumerable) |
| TakeLastT |
+ Returns a specified number of contiguous elements from the end of
+ a sequence.
+ (Defined by TakeLastExtension) |
| TakeUntilT |
+ 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.
+ (Defined by MoreEnumerable) |
| TakeUntilT |
+ 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.
+ (Defined by TakeUntilExtension) |
| ToArrayByIndexT |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT, TResult |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT, TResult |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT, TResult |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT, TResult |
+ Creates an array from an IEnumerableT where a
+ function is used to determine the index at which an element will
+ be placed in the array. The elements are projected into the array
+ via an additional function.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT, TResult |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT, TResult |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ (Defined by MoreEnumerable) |
| ToArrayByIndexT, TResult |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ (Defined by ToArrayByIndexExtension) |
| ToArrayByIndexT, TResult |
+ Creates an array of user-specified length from an
+ IEnumerableT where a function is used to determine
+ the index at which an element will be placed in the array. The
+ elements are projected into the array via an additional function.
+ (Defined by ToArrayByIndexExtension) |
| ToDataTableT |
+ Converts a sequence to a DataTable object.
+ (Defined by MoreEnumerable) |
| ToDataTableT |
+ Converts a sequence to a DataTable object.
+ (Defined by ToDataTableExtension) |
| ToDataTableT |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ (Defined by MoreEnumerable) |
| ToDataTableT |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ (Defined by ToDataTableExtension) |
| ToDataTableT, TTable |
+ Appends elements in the sequence as rows of a given DataTable object.
+ (Defined by MoreEnumerable) |
| ToDataTableT, TTable |
+ Appends elements in the sequence as rows of a given DataTable object.
+ (Defined by ToDataTableExtension) |
| ToDataTableT, TTable |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ (Defined by MoreEnumerable) |
| ToDataTableT, TTable |
+ Appends elements in the sequence as rows of a given DataTable
+ object with a set of lambda expressions specifying which members (property
+ or field) of each element in the sequence will supply the column values.
+ (Defined by ToDataTableExtension) |
| ToDelimitedStringT |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ (Defined by MoreEnumerable) |
| ToDelimitedStringT |
+ Creates a delimited string from a sequence of values and
+ a given delimiter.
+ (Defined by ToDelimitedStringExtension) |
| ToHashSetT |
+ Returns a HashSetT of the source items using the default equality
+ comparer for the type.
+ (Defined by MoreEnumerable) |
| ToHashSetT |
+ Returns a HashSetT of the source items using the default equality
+ comparer for the type.
+ (Defined by ToHashSetExtension) |
| ToHashSetT |
+ Returns a HashSetT of the source items using the specified equality
+ comparer for the type.
+ (Defined by MoreEnumerable) |
| ToHashSetT |
+ Returns a HashSetT of the source items using the specified equality
+ comparer for the type.
+ (Defined by ToHashSetExtension) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics.
+ (Defined by MoreEnumerable) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics.
+ (Defined by TraceExtension) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics using
+ a custom formatter.
+ (Defined by MoreEnumerable) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics using
+ a custom formatter.
+ (Defined by TraceExtension) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics using
+ custom formatting.
+ (Defined by MoreEnumerable) |
| TraceT |
+ Traces the elements of a source sequence for diagnostics using
+ custom formatting.
+ (Defined by TraceExtension) |
| TrySingleT, TCardinality |
+ Returns a tuple with the cardinality of the sequence and the
+ single element in the sequence if it contains exactly one element.
+ similar to SingleTSource(IEnumerableTSource).
+ (Defined by ExperimentalEnumerable) |
| TrySingleT, TCardinality, TResult |
+ Returns a result projected from the the cardinality of the sequence
+ and the single element in the sequence if it contains exactly one
+ element.
+ (Defined by ExperimentalEnumerable) |
| WindowT |
+ Processes a sequence into a series of sub-sequences representing a windowed subset of
+ the original.
+ (Defined by MoreEnumerable) |
| WindowT |
+ Processes a sequence into a series of sub-sequences representing a windowed subset of
+ the original.
+ (Defined by WindowExtension) |
| WindowedT |
+ Processes a sequence into a series of sub-sequences representing a windowed subset of the original.
+ (Defined by MoreEnumerable) |
| WindowLeftT |
+ Creates a left-aligned sliding window of a given size over the
+ source sequence.
+ (Defined by MoreEnumerable) |
| WindowLeftT |
+ Creates a left-aligned sliding window of a given size over the
+ source sequence.
+ (Defined by WindowLeftExtension) |
| WindowRightT |
+ Creates a right-aligned sliding window over the source sequence
+ of a given size.
+ (Defined by MoreEnumerable) |
| WindowRightT |
+ Creates a right-aligned sliding window over the source sequence
+ of a given size.
+ (Defined by WindowRightExtension) |
| ZipLongestT, TSecond, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipLongestT, TSecond, TResult |
+ 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.
+ (Defined by ZipLongestExtension) |
| ZipLongestT, T2, T3, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipLongestT, T2, T3, TResult |
+ 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.
+ (Defined by ZipLongestExtension) |
| ZipLongestT, T2, T3, T4, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipLongestT, T2, T3, T4, TResult |
+ 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.
+ (Defined by ZipLongestExtension) |
| ZipShortestT, TSecond, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipShortestT, TSecond, TResult |
+ 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.
+ (Defined by ZipShortestExtension) |
| ZipShortestT, T2, T3, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipShortestT, T2, T3, TResult |
+ 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.
+ (Defined by ZipShortestExtension) |
| ZipShortestT, T2, T3, T4, TResult |
+ 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.
+ (Defined by MoreEnumerable) |
| ZipShortestT, T2, T3, T4, TResult |
+ 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.
+ (Defined by ZipShortestExtension) |
public static class MoreEnumerable<ExtensionAttribute>
+Public NotInheritable Class MoreEnumerable[ExtensionAttribute]
+public ref class MoreEnumerable abstract sealed[<AbstractClassAttribute>]
+[<SealedAttribute>]
+[<ExtensionAttribute>]
+type MoreEnumerable = class end| AcquireTSource | + Ensures that a source sequence of IDisposable + objects are all acquired successfully. If the acquisition of any + one IDisposable fails then those successfully + acquired till that point are disposed. + |
| AggregateT, TAccumulate1, TAccumulate2, TResult(IEnumerableT, TAccumulate1, FuncTAccumulate1, T, TAccumulate1, TAccumulate2, FuncTAccumulate2, T, TAccumulate2, FuncTAccumulate1, TAccumulate2, TResult) | + Applies two accumulators sequentially in a single pass over a + sequence. + |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TResult(IEnumerableT, TAccumulate1, FuncTAccumulate1, T, TAccumulate1, TAccumulate2, FuncTAccumulate2, T, TAccumulate2, TAccumulate3, FuncTAccumulate3, T, TAccumulate3, FuncTAccumulate1, TAccumulate2, TAccumulate3, TResult) | + Applies three accumulators sequentially in a single pass over a + sequence. + |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult(IEnumerableT, TAccumulate1, FuncTAccumulate1, T, TAccumulate1, TAccumulate2, FuncTAccumulate2, T, TAccumulate2, TAccumulate3, FuncTAccumulate3, T, TAccumulate3, TAccumulate4, FuncTAccumulate4, T, TAccumulate4, FuncTAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult) | + Applies four accumulators sequentially in a single pass over a + sequence. + |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult(IEnumerableT, TAccumulate1, FuncTAccumulate1, T, TAccumulate1, TAccumulate2, FuncTAccumulate2, T, TAccumulate2, TAccumulate3, FuncTAccumulate3, T, TAccumulate3, TAccumulate4, FuncTAccumulate4, T, TAccumulate4, TAccumulate5, FuncTAccumulate5, T, TAccumulate5, FuncTAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult) | + Applies five accumulators sequentially in a single pass over a + sequence. + |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult(IEnumerableT, TAccumulate1, FuncTAccumulate1, T, TAccumulate1, TAccumulate2, FuncTAccumulate2, T, TAccumulate2, TAccumulate3, FuncTAccumulate3, T, TAccumulate3, TAccumulate4, FuncTAccumulate4, T, TAccumulate4, TAccumulate5, FuncTAccumulate5, T, TAccumulate5, TAccumulate6, FuncTAccumulate6, T, TAccumulate6, FuncTAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult) | + Applies six accumulators sequentially in a single pass over a + sequence. + |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult(IEnumerableT, TAccumulate1, FuncTAccumulate1, T, TAccumulate1, TAccumulate2, FuncTAccumulate2, T, TAccumulate2, TAccumulate3, FuncTAccumulate3, T, TAccumulate3, TAccumulate4, FuncTAccumulate4, T, TAccumulate4, TAccumulate5, FuncTAccumulate5, T, TAccumulate5, TAccumulate6, FuncTAccumulate6, T, TAccumulate6, TAccumulate7, FuncTAccumulate7, T, TAccumulate7, FuncTAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult) | + Applies seven accumulators sequentially in a single pass over a + sequence. + |
| AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult(IEnumerableT, TAccumulate1, FuncTAccumulate1, T, TAccumulate1, TAccumulate2, FuncTAccumulate2, T, TAccumulate2, TAccumulate3, FuncTAccumulate3, T, TAccumulate3, TAccumulate4, FuncTAccumulate4, T, TAccumulate4, TAccumulate5, FuncTAccumulate5, T, TAccumulate5, TAccumulate6, FuncTAccumulate6, T, TAccumulate6, TAccumulate7, FuncTAccumulate7, T, TAccumulate7, TAccumulate8, FuncTAccumulate8, T, TAccumulate8, FuncTAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult) | + Applies eight accumulators sequentially in a single pass over a + sequence. + |
| AggregateRightTSource(IEnumerableTSource, FuncTSource, TSource, TSource) | + Applies a right-associative accumulator function over a sequence. + This operator is the right-associative version of the + AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator. + |
| AggregateRightTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate) | + Applies a right-associative accumulator function over a sequence. + The specified seed value is used as the initial accumulator value. + This operator is the right-associative version of the + AggregateTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate) LINQ operator. + |
| AggregateRightTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate, FuncTAccumulate, TResult) | + Applies a right-associative accumulator function over a sequence. + The specified seed value is used as the initial accumulator value, + and the specified function is used to select the result value. + This operator is the right-associative version of the + AggregateTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate, FuncTAccumulate, TResult) LINQ operator. + |
| AppendT | + Returns a sequence consisting of the head elements and the given tail element. + |
| AssertTSource(IEnumerableTSource, FuncTSource, Boolean) | + Asserts that all elements of a sequence meet a given condition + otherwise throws an Exception object. + |
| AssertTSource(IEnumerableTSource, FuncTSource, Boolean, FuncTSource, Exception) | + Asserts that all elements of a sequence meet a given condition + otherwise throws an Exception object. + |
| AssertCountTSource(IEnumerableTSource, Int32) | + Asserts that a source sequence contains a given count of elements. + |
| AssertCountTSource(IEnumerableTSource, Int32, FuncInt32, Int32, Exception) | + Asserts that a source sequence contains a given count of elements. + A parameter specifies the exception to be thrown. + |
| AtLeastT | + Determines whether or not the number of elements in the sequence is greater than + or equal to the given integer. + |
| AtMostT | + Determines whether or not the number of elements in the sequence is lesser than + or equal to the given integer. + |
| BacksertT | + 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. + |
| BatchTSource(IEnumerableTSource, Int32) | + Batches the source sequence into sized buckets. + |
| BatchTSource, TResult(IEnumerableTSource, Int32, FuncIEnumerableTSource, TResult) | + Batches the source sequence into sized buckets and applies a projection to each bucket. + |
| CartesianT1, T2, TResult(IEnumerableT1, IEnumerableT2, FuncT1, T2, TResult) | + 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. + |
| CartesianT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, T5, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, IEnumerableT5, FuncT1, T2, T3, T4, T5, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, T5, T6, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, IEnumerableT5, IEnumerableT6, FuncT1, T2, T3, T4, T5, T6, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, T5, T6, T7, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, IEnumerableT5, IEnumerableT6, IEnumerableT7, FuncT1, T2, T3, T4, T5, T6, T7, TResult) | + 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. + |
| CartesianT1, T2, T3, T4, T5, T6, T7, T8, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, IEnumerableT5, IEnumerableT6, IEnumerableT7, IEnumerableT8, FuncT1, T2, T3, T4, T5, T6, T7, T8, TResult) | + 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. + |
| ChooseT, TResult | + 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 true + as its first element and result as the second. + |
| CompareCountTFirst, TSecond | + Compares two sequences and returns an integer that indicates whether the first sequence + has fewer, the same or more elements than the second sequence. + |
| ConcatT |
+ Returns a sequence consisting of the head elements and the given tail element.
+ Obsolete. |
| ConsumeT | + Completely consumes the given sequence. This method uses immediate execution, + and doesn't store any data during execution. + |
| CountBetweenT | + Determines whether or not the number of elements in the sequence is between + an inclusive range of minimum and maximum integers. + |
| CountByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Applies a key-generating function to each element of a sequence and returns a sequence of + unique keys and their number of occurrences in the original sequence. + |
| CountByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + Applies a key-generating function to each element of a sequence and returns a sequence of + unique keys and their number of occurrences in the original sequence. + An additional argument specifies a comparer to use for testing equivalence of keys. + |
| CountDownT, TResult | + 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. + |
| DistinctByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Returns all distinct elements of the given source, where "distinctness" + is determined via a projection and the default equality comparer for the projected type. + |
| DistinctByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + Returns all distinct elements of the given source, where "distinctness" + is determined via a projection and the specified comparer for the projected type. + |
| EndsWithT(IEnumerableT, IEnumerableT) | + Determines whether the end of the first sequence is equivalent to + the second sequence, using the default equality comparer. + |
| EndsWithT(IEnumerableT, IEnumerableT, IEqualityComparerT) | + Determines whether the end of the first sequence is equivalent to + the second sequence, using the specified element equality comparer. + |
| EquiZipTFirst, TSecond, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. An exception is thrown + if the input sequences are of different lengths. + |
| EquiZipT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. An exception is thrown + if the input sequences are of different lengths. + |
| EquiZipT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. An exception is thrown + if the input sequences are of different lengths. + |
| EvaluateT | + Returns a sequence containing the values resulting from invoking (in order) each function in the source sequence of functions. + |
| ExactlyT | + Determines whether or not the number of elements in the sequence is equals to the given integer. + |
| ExceptByTSource, TKey(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey) | + Returns the set of elements in the first sequence which aren't + in the second sequence, according to a given key selector. + |
| ExceptByTSource, TKey(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + Returns the set of elements in the first sequence which aren't + in the second sequence, according to a given key selector. + |
| ExcludeT | + Excludes a contiguous number of elements from a sequence starting + at a given index. + |
| FallbackIfEmptyT(IEnumerableT, T) | + Returns the elements of the specified sequence or the specified + value in a singleton collection if the sequence is empty. + |
| FallbackIfEmptyT(IEnumerableT, T) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence from an array of values. + |
| FallbackIfEmptyT(IEnumerableT, IEnumerableT) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence of values. + |
| FallbackIfEmptyT(IEnumerableT, T, T) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence of values. + |
| FallbackIfEmptyT(IEnumerableT, T, T, T) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence of values. + |
| FallbackIfEmptyT(IEnumerableT, T, T, T, T) | + Returns the elements of a sequence, but if it is empty then + returns an alternate sequence of values. + |
| FillBackwardT(IEnumerableT) | + Returns a sequence with each null reference or value in the source + replaced with the following non-null reference or value in + that sequence. + |
| FillBackwardT(IEnumerableT, FuncT, Boolean) | + Returns a sequence with each missing element in the source replaced + with the following non-missing element in that sequence. An + additional parameter specifies a function used to determine if an + element is considered missing or not. + |
| FillBackwardT(IEnumerableT, FuncT, Boolean, FuncT, T, T) | + Returns a sequence with each missing element in the source replaced + with the following non-missing element in that sequence. Additional + parameters specify two functions, one used to determine if an + element is considered missing or not and another to provide the + replacement for the missing element. + |
| FillForwardT(IEnumerableT) | + Returns a sequence with each null reference or value in the source + replaced with the previous non-null reference or value seen in + that sequence. + |
| FillForwardT(IEnumerableT, FuncT, Boolean) | + Returns a sequence with each missing element in the source replaced + with the previous non-missing element seen in that sequence. An + additional parameter specifies a function used to determine if an + element is considered missing or not. + |
| FillForwardT(IEnumerableT, FuncT, Boolean, FuncT, T, T) | + Returns a sequence with each missing element in the source replaced + with one based on the previous non-missing element seen in that + sequence. Additional parameters specify two functions, one used to + determine if an element is considered missing or not and another + to provide the replacement for the missing element. + |
| FirstT | + Returns the first element of a sequence. + |
| FirstOrDefaultT | + Returns the first element of a sequence, or a default value if the + sequence contains no elements. + |
| Flatten(IEnumerable) | + Flattens a sequence containing arbitrarily-nested sequences. + |
| Flatten(IEnumerable, FuncIEnumerable, Boolean) | + Flattens a sequence containing arbitrarily-nested sequences. An + additional parameter specifies a predicate function used to + determine whether a nested IEnumerable should be + flattened or not. + |
| Flatten(IEnumerable, FuncObject, IEnumerable) | + Flattens a sequence containing arbitrarily-nested sequences. An + additional parameter specifies a function that projects an inner + sequence via a property of an object. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 16 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 15 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 14 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 13 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 12 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 11 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 10 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 9 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 8 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 7 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 6 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 5 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, T, TResult) | + Returns the result of applying a function to a sequence of + 4 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, T, TResult) | + Returns the result of applying a function to a sequence of + 3 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, T, TResult) | + Returns the result of applying a function to a sequence of + 2 elements. + |
| FoldT, TResult(IEnumerableT, FuncT, TResult) | + Returns the result of applying a function to a sequence of + 1 element. + |
| ForEachT(IEnumerableT, ActionT, Int32) | + Immediately executes the given action on each element in the source sequence. + Each element's index is used in the logic of the action. + |
| ForEachT(IEnumerableT, ActionT) | + Immediately executes the given action on each element in the source sequence. + |
| FromT(FuncT) | + Returns a single-element sequence containing the result of invoking the function. + |
| FromT(FuncT) | + Returns a sequence containing the values resulting from invoking (in order) each function in the source sequence of functions. + |
| FromT(FuncT, FuncT) | + Returns a sequence containing the result of invoking each parameter function in order. + |
| FromT(FuncT, FuncT, FuncT) | + Returns a sequence containing the result of invoking each parameter function in order. + |
| FullGroupJoinTFirst, TSecond, TKey(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey) | + Performs a Full Group Join between the first and second sequences. + |
| FullGroupJoinTFirst, TSecond, TKey(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, IEqualityComparerTKey) | + Performs a Full Group Join between the first and second sequences. + |
| FullGroupJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTKey, IEnumerableTFirst, IEnumerableTSecond, TResult) | + Performs a full group-join between two sequences. + |
| FullGroupJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTKey, IEnumerableTFirst, IEnumerableTSecond, TResult, IEqualityComparerTKey) | + Performs a full group-join between two sequences. + |
| FullJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TResult, FuncTSource, TSource, TResult) | + Performs a full outer join on two homogeneous sequences. + Additional arguments specify key selection functions and result + projection functions. + |
| FullJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TResult, FuncTSource, TSource, TResult, IEqualityComparerTKey) | + Performs a full outer join on two homogeneous sequences. + Additional arguments specify key selection functions, result + projection functions and a key comparer. + |
| FullJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult) | + Performs a full outer join on two heterogeneous sequences. + Additional arguments specify key selection functions and result + projection functions. + |
| FullJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult, IEqualityComparerTKey) | + Performs a full outer join on two heterogeneous sequences. + Additional arguments specify key selection functions, result + projection functions and a key comparer. + |
| GenerateTResult | + Returns a sequence of values consecutively generated by a generator function. + |
| GenerateByIndexTResult | + Returns a sequence of values based on indexes. + |
| GroupAdjacentTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Groups the adjacent elements of a sequence according to a + specified key selector function. + |
| GroupAdjacentTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + Groups the adjacent elements of a sequence according to a + specified key selector function and compares the keys by using a + specified comparer. + |
| GroupAdjacentTSource, TKey, TElement(IEnumerableTSource, FuncTSource, TKey, FuncTSource, TElement) | + Groups the adjacent elements of a sequence according to a + specified key selector function and projects the elements for + each group by using a specified function. + |
| GroupAdjacentTSource, TKey, TResult(IEnumerableTSource, FuncTSource, TKey, FuncTKey, IEnumerableTSource, TResult) | + Groups the adjacent elements of a sequence according to a + specified key selector function. The keys are compared by using + a comparer and each group's elements are projected by using a + specified function. + |
| GroupAdjacentTSource, TKey, TElement(IEnumerableTSource, FuncTSource, TKey, FuncTSource, TElement, IEqualityComparerTKey) | + Groups the adjacent elements of a sequence according to a + specified key selector function. The keys are compared by using + a comparer and each group's elements are projected by using a + specified function. + |
| GroupAdjacentTSource, TKey, TResult(IEnumerableTSource, FuncTSource, TKey, FuncTKey, IEnumerableTSource, TResult, IEqualityComparerTKey) | + Groups the adjacent elements of a sequence according to a + specified key selector function. The keys are compared by using + a comparer and each group's elements are projected by using a + specified function. + |
| IndexTSource(IEnumerableTSource) | + Returns a sequence of KeyValuePairTKey, TValue + where the key is the zero-based index of the value in the source + sequence. + |
| IndexTSource(IEnumerableTSource, Int32) | + Returns a sequence of KeyValuePairTKey, TValue + where the key is the index of the value in the source sequence. + An additional parameter specifies the starting index. + |
| IndexByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + 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. + |
| IndexByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) | + 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. + |
| InsertT | + Inserts the elements of a sequence into another sequence at a + specified index. + |
| InterleaveT | + Interleaves the elements of two or more sequences into a single sequence, skipping + sequences as they are consumed. + |
| LagTSource, TResult(IEnumerableTSource, Int32, FuncTSource, TSource, TResult) | + Produces a projection of a sequence by evaluating pairs of elements separated by a + negative offset. + |
| LagTSource, TResult(IEnumerableTSource, Int32, TSource, FuncTSource, TSource, TResult) | + Produces a projection of a sequence by evaluating pairs of elements separated by a + negative offset. + |
| LastT | + Returns the last element of a sequence. + |
| LastOrDefaultT | + Returns the last element of a sequence, or a default value if the + sequence contains no elements. + |
| LeadTSource, TResult(IEnumerableTSource, Int32, FuncTSource, TSource, TResult) | + Produces a projection of a sequence by evaluating pairs of elements separated by a + positive offset. + |
| LeadTSource, TResult(IEnumerableTSource, Int32, TSource, FuncTSource, TSource, TResult) | + Produces a projection of a sequence by evaluating pairs of elements separated by a + positive offset. + |
| LeftJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TSource, TResult) | + Performs a left outer join on two homogeneous sequences. + Additional arguments specify key selection functions and result + projection functions. + |
| LeftJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TSource, TResult, IEqualityComparerTKey) | + Performs a left outer join on two homogeneous sequences. + Additional arguments specify key selection functions, result + projection functions and a key comparer. + |
| LeftJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTFirst, TSecond, TResult) | + Performs a left outer join on two heterogeneous sequences. + Additional arguments specify key selection functions and result + projection functions. + |
| LeftJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTFirst, TSecond, TResult, IEqualityComparerTKey) | + Performs a left outer join on two heterogeneous sequences. + Additional arguments specify key selection functions, result + projection functions and a key comparer. + |
| MaxByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Returns the maximal elements of the given sequence, based on + the given projection. + |
| MaxByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) | + Returns the maximal elements of the given sequence, based on + the given projection and the specified comparer for projected values. + |
| MinByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Returns the minimal elements of the given sequence, based on + the given projection. + |
| MinByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) | + Returns the minimal elements of the given sequence, based on + the given projection and the specified comparer for projected values. + |
| MoveT | + Returns a sequence with a range of elements in the source sequence + moved to a new offset. + |
| OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection) | + Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key + |
| OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection) | + Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key + |
| OrderedMergeT(IEnumerableT, IEnumerableT) | + Merges two ordered sequences into one. Where the elements equal + in both sequences, the element from the first sequence is + returned in the resulting sequence. + |
| OrderedMergeT(IEnumerableT, IEnumerableT, IComparerT) | + Merges two ordered sequences into one with an additional + parameter specifying how to compare the elements of the + sequences. Where the elements equal in both sequences, the + element from the first sequence is returned in the resulting + sequence. + |
| OrderedMergeT, TKey(IEnumerableT, IEnumerableT, FuncT, TKey) | + Merges two ordered sequences into one with an additional + parameter specifying the element key by which the sequences are + ordered. Where the keys equal in both sequences, the + element from the first sequence is returned in the resulting + sequence. + |
| OrderedMergeT, TKey, TResult(IEnumerableT, IEnumerableT, FuncT, TKey, FuncT, TResult, FuncT, TResult, FuncT, T, TResult) | + Merges two ordered sequences into one. Additional parameters + specify the element key by which the sequences are ordered, + the result when element is found in first sequence but not in + the second, the result when element is found in second sequence + but not in the first and the result when elements are found in + both sequences. + |
| OrderedMergeT, TKey, TResult(IEnumerableT, IEnumerableT, FuncT, TKey, FuncT, TResult, FuncT, TResult, FuncT, T, TResult, IComparerTKey) | + Merges two ordered sequences into one. Additional parameters + specify the element key by which the sequences are ordered, + the result when element is found in first sequence but not in + the second, the result when element is found in second sequence + but not in the first, the result when elements are found in + both sequences and a method for comparing keys. + |
| OrderedMergeTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult) | + Merges two heterogeneous sequences ordered by a common key type + into a homogeneous one. Additional parameters specify the + element key by which the sequences are ordered, the result when + element is found in first sequence but not in the second and + the result when element is found in second sequence but not in + the first, the result when elements are found in both sequences. + |
| OrderedMergeTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult, IComparerTKey) | + Merges two heterogeneous sequences ordered by a common key type + into a homogeneous one. Additional parameters specify the + element key by which the sequences are ordered, the result when + element is found in first sequence but not in the second, + the result when element is found in second sequence but not in + the first, the result when elements are found in both sequences + and a method for comparing keys. + |
| PadTSource(IEnumerableTSource, Int32) | + Pads a sequence with default values if it is narrower (shorter + in length) than a given width. + |
| PadTSource(IEnumerableTSource, Int32, TSource) | + Pads a sequence with a given filler value if it is narrower (shorter + in length) than a given width. + |
| PadTSource(IEnumerableTSource, Int32, FuncInt32, TSource) | + Pads a sequence with a dynamic filler value if it is narrower (shorter + in length) than a given width. + |
| PadStartTSource(IEnumerableTSource, Int32) | + Pads a sequence with default values in the beginning if it is narrower (shorter + in length) than a given width. + |
| PadStartTSource(IEnumerableTSource, Int32, TSource) | + Pads a sequence with a given filler value in the beginning if it is narrower (shorter + in length) than a given width. + An additional parameter specifies the value to use for padding. + |
| PadStartTSource(IEnumerableTSource, Int32, FuncInt32, TSource) | + Pads a sequence with a dynamic filler value in the beginning if it is narrower (shorter + in length) than a given width. + An additional parameter specifies the function to calculate padding. + |
| PairwiseTSource, TResult | + Returns a sequence resulting from applying a function to each + element in the source sequence and its + predecessor, with the exception of the first element which is + only returned as the predecessor of the second element. + |
| PartialSortT(IEnumerableT, Int32) | + Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey), + where each element is its key, and TakeTSource(IEnumerableTSource, Int32) + in a single operation. + |
| PartialSortT(IEnumerableT, Int32, OrderByDirection) | + Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection), + where each element is its key, and TakeTSource(IEnumerableTSource, Int32) + in a single operation. + An additional parameter specifies the direction of the sort + |
| PartialSortT(IEnumerableT, Int32, IComparerT) | + Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey), + where each element is its key, and TakeTSource(IEnumerableTSource, Int32) + in a single operation. An additional parameter specifies how the + elements compare to each other. + |
| PartialSortT(IEnumerableT, Int32, IComparerT, OrderByDirection) | + Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection), + where each element is its key, and TakeTSource(IEnumerableTSource, Int32) + in a single operation. + Additional parameters specify how the elements compare to each other and + the direction of the sort. + |
| PartialSortByTSource, TKey(IEnumerableTSource, Int32, FuncTSource, TKey) | + Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey), + and TakeTSource(IEnumerableTSource, Int32) in a single operation. + |
| PartialSortByTSource, TKey(IEnumerableTSource, Int32, FuncTSource, TKey, OrderByDirection) | + Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection), + and TakeTSource(IEnumerableTSource, Int32) in a single operation. + An additional parameter specifies the direction of the sort + |
| PartialSortByTSource, TKey(IEnumerableTSource, Int32, FuncTSource, TKey, IComparerTKey) | + Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey), + and TakeTSource(IEnumerableTSource, Int32) in a single operation. + An additional parameter specifies how the keys compare to each other. + |
| PartialSortByTSource, TKey(IEnumerableTSource, Int32, FuncTSource, TKey, IComparerTKey, OrderByDirection) | + Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection), + and TakeTSource(IEnumerableTSource, Int32) in a single operation. + Additional parameters specify how the elements compare to each other and + the direction of the sort. + |
| PartitionT(IEnumerableT, FuncT, Boolean) | + Partitions or splits a sequence in two using a predicate. + |
| PartitionT, TResult(IEnumerableIGroupingBoolean, T, FuncIEnumerableT, IEnumerableT, TResult) | + Partitions a grouping by Boolean keys into a projection of true + elements and false elements, respectively. + |
| PartitionT, TResult(IEnumerableIGroupingNullableBoolean, T, FuncIEnumerableT, IEnumerableT, IEnumerableT, TResult) | + Partitions a grouping by nullable Boolean keys into a projection of + true elements, false elements and null elements, respectively. + |
| PartitionT, TResult(IEnumerableT, FuncT, Boolean, FuncIEnumerableT, IEnumerableT, TResult) | + Partitions or splits a sequence in two using a predicate and then + projects a result from the two. + |
| PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, FuncIEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) | + Partitions a grouping and projects a result from group elements + matching a key and those groups that do not. + |
| PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, TKey, FuncIEnumerableTElement, IEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) | + Partitions a grouping and projects a result from elements of + groups matching a set of two keys and those groups that do not. + |
| PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, IEqualityComparerTKey, FuncIEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) | + Partitions a grouping and projects a result from group elements + matching a key and those groups that do not. An additional parameter + specifies how to compare keys for equality. + |
| PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, TKey, TKey, FuncIEnumerableTElement, IEnumerableTElement, IEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) | + Partitions a grouping and projects a result from elements groups + matching a set of three keys and those groups that do not. + |
| PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, TKey, IEqualityComparerTKey, FuncIEnumerableTElement, IEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) | + Partitions a grouping and projects a result from elements of + groups matching a set of two keys and those groups that do not. + An additional parameter specifies how to compare keys for equality. + |
| PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, TKey, TKey, IEqualityComparerTKey, FuncIEnumerableTElement, IEnumerableTElement, IEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) | + Partitions a grouping and projects a result from elements groups + matching a set of three keys and those groups that do not. An + additional parameter specifies how to compare keys for equality. + |
| PermutationsT | + Generates a sequence of lists that represent the permutations of the original sequence. + |
| PipeT | + Executes the given action on each element in the source sequence + and yields it. + |
| PrependTSource | + Prepends a single value to a sequence. + |
| PreScanTSource | + Performs a pre-scan (exclusive prefix sum) on a sequence of elements. + |
| Random | + Returns an infinite sequence of random integers using the standard + .NET random number generator. + |
| Random(Int32) | + Returns an infinite sequence of random integers between zero and + a given maximum. + |
| Random(Random) | + Returns an infinite sequence of random integers using the supplied + random number generator. + |
| Random(Int32, Int32) | + Returns an infinite sequence of random integers between a given + minimum and a maximum. + |
| Random(Random, Int32) | + Returns an infinite sequence of random integers between zero and a + given maximum using the supplied random number generator. + |
| Random(Random, Int32, Int32) | + Returns an infinite sequence of random integers between a given + minimum and a maximum using the supplied random number generator. + |
| RandomDouble | + Returns an infinite sequence of random double values between 0.0 and 1.0 + |
| RandomDouble(Random) | + Returns an infinite sequence of random double values between 0.0 and 1.0 + using the supplied random number generator. + |
| RandomSubsetT(IEnumerableT, Int32) | + Returns a sequence of a specified size of random elements from the + original sequence. + |
| RandomSubsetT(IEnumerableT, Int32, Random) | + Returns a sequence of a specified size of random elements from the + original sequence. An additional parameter specifies a random + generator to be used for the random selection algorithm. + |
| RankTSource(IEnumerableTSource) | + Ranks each item in the sequence in descending ordering using a default comparer. + |
| RankTSource(IEnumerableTSource, IComparerTSource) | + Rank each item in the sequence using a caller-supplied comparer. + |
| RankByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) | + Ranks each item in the sequence in descending ordering by a specified key using a default comparer + |
| RankByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) | + Ranks each item in a sequence using a specified key and a caller-supplied comparer + |
| RepeatT(IEnumerableT) | + Repeats the sequence forever. + |
| RepeatT(IEnumerableT, Int32) | + Repeats the sequence the specified number of times. + |
| ReturnT | + Returns a single-element sequence containing the item provided. + |
| RightJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TSource, TResult) | + Performs a right outer join on two homogeneous sequences. + Additional arguments specify key selection functions and result + projection functions. + |
| RightJoinTSource, TKey, TResult(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, FuncTSource, TResult, FuncTSource, TSource, TResult, IEqualityComparerTKey) | + Performs a right outer join on two homogeneous sequences. + Additional arguments specify key selection functions, result + projection functions and a key comparer. + |
| RightJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTSecond, TResult, FuncTFirst, TSecond, TResult) | + Performs a right outer join on two heterogeneous sequences. + Additional arguments specify key selection functions and result + projection functions. + |
| RightJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTSecond, TResult, FuncTFirst, TSecond, TResult, IEqualityComparerTKey) | + Performs a right outer join on two heterogeneous sequences. + Additional arguments specify key selection functions, result + projection functions and a key comparer. + |
| RunLengthEncodeT(IEnumerableT) | + Run-length encodes a sequence by converting consecutive instances of the same element into + a KeyValuePair{T,int} representing the item and its occurrence count. + |
| RunLengthEncodeT(IEnumerableT, IEqualityComparerT) | + Run-length encodes a sequence by converting consecutive instances of the same element into + a KeyValuePair{T,int} representing the item and its occurrence count. This overload + uses a custom equality comparer to identify equivalent items. + |
| ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) | + Performs a scan (inclusive prefix sum) on a sequence of elements. + |
| ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) | + Like AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) except returns + the sequence of intermediate results as well as the final one. + An additional parameter specifies a seed. + |
| ScanByTSource, TKey, TState(IEnumerableTSource, FuncTSource, TKey, FuncTKey, TState, FuncTState, TKey, TSource, TState) | + Applies an accumulator function over sequence element keys, + returning the keys along with intermediate accumulator states. + |
| ScanByTSource, TKey, TState(IEnumerableTSource, FuncTSource, TKey, FuncTKey, TState, FuncTState, TKey, TSource, TState, IEqualityComparerTKey) | + 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. + |
| ScanRightTSource(IEnumerableTSource, FuncTSource, TSource, TSource) | + Performs a right-associative scan (inclusive prefix) on a sequence of elements. + This operator is the right-associative version of the + ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator. + |
| ScanRightTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate) | + Performs a right-associative scan (inclusive prefix) on a sequence of elements. + The specified seed value is used as the initial accumulator value. + This operator is the right-associative version of the + ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) LINQ operator. + |
| SegmentT(IEnumerableT, FuncT, T, Int32, Boolean) | + Divides a sequence into multiple sequences by using a segment detector based on the original sequence + |
| SegmentT(IEnumerableT, FuncT, Boolean) | + Divides a sequence into multiple sequences by using a segment detector based on the original sequence + |
| SegmentT(IEnumerableT, FuncT, Int32, Boolean) | + Divides a sequence into multiple sequences by using a segment detector based on the original sequence + |
| Sequence(Int32, Int32) | + Generates a sequence of integral numbers within the (inclusive) specified range. + If sequence is ascending the step is +1, otherwise -1. + |
| Sequence(Int32, Int32, Int32) | + Generates a sequence of integral numbers within the (inclusive) specified range. + An additional parameter specifies the steps in which the integers of the sequence increase or decrease. + |
| ShuffleT(IEnumerableT) | + Returns a sequence of elements in random order from the original + sequence. + |
| ShuffleT(IEnumerableT, Random) | + 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. + |
| SingleT | + Returns the only element of a sequence, and throws an exception if + there is not exactly one element in the sequence. + |
| SingleOrDefaultT | + 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. + |
| SkipLastT | + Bypasses a specified number of elements at the end of the sequence. + |
| SkipUntilTSource | + Skips items from the input sequence until the given predicate returns true + when applied to the current source item; that item will be the last skipped. + |
| SliceT | + Extracts a contiguous count of elements from a sequence at a particular zero-based + starting index. + |
| SortedMergeTSource(IEnumerableTSource, OrderByDirection, IEnumerableTSource) | + Merges two or more sequences that are in a common order (either ascending or descending) + into a single sequence that preserves that order. + |
| SortedMergeTSource(IEnumerableTSource, OrderByDirection, IComparerTSource, IEnumerableTSource) | + Merges two or more sequences that are in a common order (either ascending or descending) + into a single sequence that preserves that order. + |
| SplitTSource(IEnumerableTSource, TSource) | + Splits the source sequence by a separator. + |
| SplitTSource(IEnumerableTSource, FuncTSource, Boolean) | + Splits the source sequence by separator elements identified by a + function. + |
| SplitTSource(IEnumerableTSource, TSource, IEqualityComparerTSource) | + Splits the source sequence by a separator and then transforms the + splits into results. + |
| SplitTSource(IEnumerableTSource, TSource, Int32) | + Splits the source sequence by a separator given a maximum count of splits. + |
| SplitTSource(IEnumerableTSource, FuncTSource, Boolean, Int32) | + Splits the source sequence by separator elements identified by a + function, given a maximum count of splits. + |
| SplitTSource(IEnumerableTSource, TSource, IEqualityComparerTSource, Int32) | + Splits the source sequence by a separator, given a maximum count + of splits. A parameter specifies how the separator is compared + for equality. + |
| SplitTSource, TResult(IEnumerableTSource, TSource, FuncIEnumerableTSource, TResult) | + Splits the source sequence by a separator and then transforms + the splits into results. + |
| SplitTSource, TResult(IEnumerableTSource, FuncTSource, Boolean, FuncIEnumerableTSource, TResult) | + Splits the source sequence by separator elements identified by + a function and then transforms the splits into results. + |
| SplitTSource, TResult(IEnumerableTSource, TSource, IEqualityComparerTSource, FuncIEnumerableTSource, TResult) | + Splits the source sequence by a separator and then transforms the + splits into results. A parameter specifies how the separator is + compared for equality. + |
| SplitTSource, TResult(IEnumerableTSource, TSource, Int32, FuncIEnumerableTSource, TResult) | + Splits the source sequence by a separator, given a maximum count + of splits, and then transforms the splits into results. + |
| SplitTSource, TResult(IEnumerableTSource, FuncTSource, Boolean, Int32, FuncIEnumerableTSource, TResult) | + Splits the source sequence by separator elements identified by + a function, given a maximum count of splits, and then transforms + the splits into results. + |
| SplitTSource, TResult(IEnumerableTSource, TSource, IEqualityComparerTSource, Int32, FuncIEnumerableTSource, TResult) | + Splits the source sequence by a separator, given a maximum count + of splits, and then transforms the splits into results. A + parameter specifies how the separator is compared for equality. + |
| StartsWithT(IEnumerableT, IEnumerableT) | + Determines whether the beginning of the first sequence is + equivalent to the second sequence, using the default equality + comparer. + |
| StartsWithT(IEnumerableT, IEnumerableT, IEqualityComparerT) | + Determines whether the beginning of the first sequence is + equivalent to the second sequence, using the specified element + equality comparer. + |
| SubsetsT(IEnumerableT) | + Returns a sequence of IListT representing all of the subsets of any size + that are part of the original sequence. In mathematics, it is equivalent to the + power set of a set. + |
| SubsetsT(IEnumerableT, Int32) | + Returns a sequence of IListT representing all subsets of a given size + that are part of the original sequence. In mathematics, it is equivalent to the + combinations or k-subsets of a set. + |
| TagFirstLastTSource, TResult | + Returns a sequence resulting from applying a function to each + element in the source sequence with additional parameters + indicating whether the element is the first and/or last of the + sequence. + |
| TakeEveryTSource | + Returns every N-th element of a sequence. + |
| TakeLastTSource | + Returns a specified number of contiguous elements from the end of + a sequence. + |
| TakeUntilTSource | + Returns items from the input sequence until the given predicate returns true + when applied to the current source item; that item will be the last returned. + |
| ThenByT, TKey(IOrderedEnumerableT, FuncT, TKey, OrderByDirection) | + Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key + |
| ThenByT, TKey(IOrderedEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection) | + Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key + |
| ToArrayByIndexT(IEnumerableT, FuncT, Int32) | + Creates an array from an IEnumerableT where a + function is used to determine the index at which an element will + be placed in the array. + |
| ToArrayByIndexT(IEnumerableT, Int32, FuncT, Int32) | + Creates an array of user-specified length from an + IEnumerableT where a function is used to determine + the index at which an element will be placed in the array. + |
| ToArrayByIndexT, TResult(IEnumerableT, FuncT, Int32, FuncT, TResult) | + Creates an array from an IEnumerableT where a + function is used to determine the index at which an element will + be placed in the array. The elements are projected into the array + via an additional function. + |
| ToArrayByIndexT, TResult(IEnumerableT, FuncT, Int32, FuncT, Int32, TResult) | + Creates an array from an IEnumerableT where a + function is used to determine the index at which an element will + be placed in the array. The elements are projected into the array + via an additional function. + |
| ToArrayByIndexT, TResult(IEnumerableT, Int32, FuncT, Int32, FuncT, TResult) | + Creates an array of user-specified length from an + IEnumerableT where a function is used to determine + the index at which an element will be placed in the array. The + elements are projected into the array via an additional function. + |
| ToArrayByIndexT, TResult(IEnumerableT, Int32, FuncT, Int32, FuncT, Int32, TResult) | + Creates an array of user-specified length from an + IEnumerableT where a function is used to determine + the index at which an element will be placed in the array. The + elements are projected into the array via an additional function. + |
| ToDataTableT(IEnumerableT) | + Converts a sequence to a DataTable object. + |
| ToDataTableT(IEnumerableT, ExpressionFuncT, Object) | + Appends elements in the sequence as rows of a given DataTable + object with a set of lambda expressions specifying which members (property + or field) of each element in the sequence will supply the column values. + |
| ToDataTableT, TTable(IEnumerableT, TTable) | + Appends elements in the sequence as rows of a given DataTable object. + |
| ToDataTableT, TTable(IEnumerableT, TTable, ExpressionFuncT, Object) | + Appends elements in the sequence as rows of a given DataTable + object with a set of lambda expressions specifying which members (property + or field) of each element in the sequence will supply the column values. + |
| ToDelimitedString(IEnumerableBoolean, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableByte, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableChar, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableDecimal, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableDouble, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableInt16, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableInt32, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableInt64, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableSByte, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableSingle, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableString, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableUInt16, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableUInt32, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedString(IEnumerableUInt64, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDelimitedStringTSource(IEnumerableTSource, String) | + Creates a delimited string from a sequence of values and + a given delimiter. + |
| ToDictionaryTKey, TValue(IEnumerableKeyValuePairTKey, TValue) | + Creates a DictionaryTKey, TValue from a sequence of + KeyValuePairTKey, TValue elements. + |
| ToDictionaryTKey, TValue(IEnumerableValueTupleTKey, TValue) | + Creates a DictionaryTKey, TValue from a sequence of + tuples of 2 where the first item is the key and the second the + value. + |
| ToDictionaryTKey, TValue(IEnumerableKeyValuePairTKey, TValue, IEqualityComparerTKey) | + Creates a DictionaryTKey, TValue from a sequence of + KeyValuePairTKey, TValue elements. An additional + parameter specifies a comparer for keys. + |
| ToDictionaryTKey, TValue(IEnumerableValueTupleTKey, TValue, IEqualityComparerTKey) | + Creates a DictionaryTKey, TValue from a sequence of + tuples of 2 where the first item is the key and the second the + value. An additional parameter specifies a comparer for keys. + |
| ToHashSetTSource(IEnumerableTSource) | + Returns a HashSetT of the source items using the default equality + comparer for the type. + |
| ToHashSetTSource(IEnumerableTSource, IEqualityComparerTSource) | + Returns a HashSetT of the source items using the specified equality + comparer for the type. + |
| ToLookupTKey, TValue(IEnumerableKeyValuePairTKey, TValue) | + Creates a ILookupTKey, TElement from a sequence of + KeyValuePairTKey, TValue elements. + |
| ToLookupTKey, TValue(IEnumerableValueTupleTKey, TValue) | + Creates a Lookup from a sequence of + tuples of 2 where the first item is the key and the second the + value. + |
| ToLookupTKey, TValue(IEnumerableKeyValuePairTKey, TValue, IEqualityComparerTKey) | + Creates a ILookupTKey, TElement from a sequence of + KeyValuePairTKey, TValue elements. An additional + parameter specifies a comparer for keys. + |
| ToLookupTKey, TValue(IEnumerableValueTupleTKey, TValue, IEqualityComparerTKey) | + Creates a Lookup from a sequence of + tuples of 2 where the first item is the key and the second the + value. An additional parameter specifies a comparer for keys. + |
| TraceTSource(IEnumerableTSource) | + Traces the elements of a source sequence for diagnostics. + |
| TraceTSource(IEnumerableTSource, FuncTSource, String) | + Traces the elements of a source sequence for diagnostics using + a custom formatter. + |
| TraceTSource(IEnumerableTSource, String) | + Traces the elements of a source sequence for diagnostics using + custom formatting. + |
| TransposeT | + Transposes a sequence of rows into a sequence of columns. + |
| TraverseBreadthFirstT | + Traverses a tree in a breadth-first fashion, starting at a root + node and using a user-defined function to get the children at each + node of the tree. + |
| TraverseDepthFirstT | + Traverses a tree in a depth-first fashion, starting at a root node + and using a user-defined function to get the children at each node + of the tree. + |
| UnfoldTState, T, TResult | + Returns a sequence generated by applying a state to the generator function, + and from its result, determines if the sequence should have a next element, its value, + and the next state in the recursive call. + |
| WindowTSource | + Processes a sequence into a series of sub-sequences representing a windowed subset of + the original. + |
| WindowedTSource |
+ Processes a sequence into a series of sub-sequences representing a windowed subset of the original.
+ Obsolete. |
| WindowLeftTSource | + Creates a left-aligned sliding window of a given size over the + source sequence. + |
| WindowRightTSource | + Creates a right-aligned sliding window over the source sequence + of a given size. + |
| ZipLongestTFirst, TSecond, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. 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. + |
| ZipLongestT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. 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. + |
| ZipLongestT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. 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. + |
| ZipShortestTFirst, TSecond, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. The resulting sequence + is as short as the shortest input sequence. + |
| ZipShortestT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. The resulting sequence + is as short as the shortest input sequence. + |
| ZipShortestT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) | + Returns a projection of tuples, where each tuple contains the N-th + element from each of the argument sequences. The resulting sequence + is as short as the shortest input sequence. + |
public enum OrderByDirectionPublic Enumeration OrderByDirectionpublic enum class OrderByDirectiontype OrderByDirection| Ascending | 0 | + Elements are ordered by increasing value + |
| Descending | 1 | + Elements are ordered by decreasing value + |
[SerializableAttribute]
+public class SequenceException : Exception<SerializableAttribute>
+Public Class SequenceException
+ Inherits Exception[SerializableAttribute]
+public ref class SequenceException : public Exception[<SerializableAttribute>]
+type SequenceException =
+ class
+ inherit Exception
+ end| SequenceException | + Initializes a new instance of the SequenceException class. + |
| SequenceException(String) | + Initializes a new instance of the SequenceException class + with a given error message. + |
| SequenceException(SerializationInfo, StreamingContext) | + Initializes a new instance of the SequenceException class + with serialized data. + |
| SequenceException(String, Exception) | + Initializes a new instance of the SequenceException class + with a given error message and a reference to the inner exception + that is the cause of the exception. + |
| Data | Gets a collection of key/value pairs that provide additional user-defined information about the exception. (Inherited from Exception) |
| HelpLink | Gets or sets a link to the help file associated with this exception. (Inherited from Exception) |
| HResult | Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception. (Inherited from Exception) |
| InnerException | Gets the Exception instance that caused the current exception. (Inherited from Exception) |
| Message | Gets a message that describes the current exception. (Inherited from Exception) |
| Source | Gets or sets the name of the application or the object that causes the error. (Inherited from Exception) |
| StackTrace | Gets a string representation of the immediate frames on the call stack. (Inherited from Exception) |
| TargetSite | Gets the method that throws the current exception. (Inherited from Exception) |
| Equals | Determines whether the specified object is equal to the current object. (Inherited from Object) |
| Finalize | Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection. (Inherited from Object) |
| GetBaseException | When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions. (Inherited from Exception) |
| GetHashCode | Serves as the default hash function. (Inherited from Object) |
| GetObjectData | When overridden in a derived class, sets the SerializationInfo with information about the exception. (Inherited from Exception) |
| GetType | Gets the runtime type of the current instance. (Inherited from Exception) |
| MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object) |
| ToString | Creates and returns a string representation of the current exception. (Inherited from Exception) |
| SerializeObjectState | Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception. (Inherited from Exception) Obsolete. |
If you are not redirected automatically, follow this link to the default topic.
+ + diff --git a/3.4/ref/api/scripts/clipboard.min.js b/3.4/ref/api/scripts/clipboard.min.js new file mode 100644 index 0000000..41c6a0f --- /dev/null +++ b/3.4/ref/api/scripts/clipboard.min.js @@ -0,0 +1,7 @@ +/*! + * clipboard.js v2.0.10 + * https://clipboardjs.com/ + * + * Licensed MIT © Zeno Rocha + */ +!function(t,e){"object"==typeof exports&&"object"==typeof module?module.exports=e():"function"==typeof define&&define.amd?define([],e):"object"==typeof exports?exports.ClipboardJS=e():t.ClipboardJS=e()}(this,function(){return n={686:function(t,e,n){"use strict";n.d(e,{default:function(){return o}});var e=n(279),i=n.n(e),e=n(370),u=n.n(e),e=n(817),c=n.n(e);function a(t){try{return document.execCommand(t)}catch(t){return}}var f=function(t){t=c()(t);return a("cut"),t};var l=function(t){var e,n,o,r=1" + topicTitle + "
Omitted " + (matchingFileIndices.length - rankings.length) + " more results
"; + + return content; +} diff --git a/3.4/ref/api/search.html b/3.4/ref/api/search.html new file mode 100644 index 0000000..2d68bca --- /dev/null +++ b/3.4/ref/api/search.html @@ -0,0 +1,68 @@ + + + + + + + + + + + ++ Back +
+