IEnumerable<T> Extension

method Any<T>(aBlock: not nullable Func<not nullable T, Boolean>): Boolean

Boolean Any<T>(Func<not nullable T, Boolean>! aBlock)

func Any<T>(_ aBlock: Func<not nullable T, Boolean>) -> Boolean

Boolean Any<T>(Func2<T, Boolean> aBlock)

Function Any<T>(aBlock As Func (Of T, Boolean)) As Boolean

method Any<T>: Boolean

Boolean Any<T>()

func Any<T>() -> Boolean

Boolean Any<T>()

Function Any<T>() As Boolean

method array<T>: not nullable NSArray<T>

NSArray<T>! array<T>()

func array<T>() -> NSArray<T>

NSArray<T> array<T>()

Function array<T>() As NSArray<T>

method Cast<U,T>: IEnumerable<U>

IEnumerable<U> Cast<U,T>()

func Cast<U,T>() -> IEnumerable<U>

IEnumerable<U> Cast<U,T>()

Function Cast<U,T>() As IEnumerable<U>

method Concat<T>(aSecond: not nullable IEnumerable<T>): IEnumerable<T>

IEnumerable<T> Concat<T>(IEnumerable<T>! aSecond)

func Concat<T>(_ aSecond: IEnumerable<T>) -> IEnumerable<T>

IEnumerable<T> Concat<T>(IEnumerable<T> aSecond)

Function Concat<T>(aSecond As IEnumerable<T>) As IEnumerable<T>

method Contains<T>(aItem: T): Boolean

Boolean Contains<T>(T aItem)

func Contains<T>(_ aItem: T) -> Boolean

Boolean Contains<T>(T aItem)

Function Contains<T>(aItem As T) As Boolean

method Count<T>: Int32

Int32 Count<T>()

func Count<T>() -> Int32

Int32 Count<T>()

Function Count<T>() As Int32

method Count<T>(aCondition: not nullable Func<not nullable T, Boolean>): Int32

Int32 Count<T>(Func<not nullable T, Boolean>! aCondition)

func Count<T>(_ aCondition: Func<not nullable T, Boolean>) -> Int32

Int32 Count<T>(Func2<T, Boolean> aCondition)

Function Count<T>(aCondition As Func (Of T, Boolean)) As Int32

method Distinct<T>(aComparator: Func<T,T,RemObjects.Elements.System.Int32>): IEnumerable<T>

IEnumerable<T> Distinct<T>(Func<T,T,RemObjects.Elements.System.Int32> aComparator)

func Distinct<T>(_ aComparator: Func<T,T,RemObjects.Elements.System.Int32>) -> IEnumerable<T>

IEnumerable<T> Distinct<T>(Func<T,T,RemObjects.Elements.System.Int32> aComparator)

Function Distinct<T>(aComparator As Func<T,T,RemObjects.Elements.System.Int32>) As IEnumerable<T>

method EqualsTo<T>(collection: IEnumerable<T>): Boolean

Boolean EqualsTo<T>(IEnumerable<T> collection)

func EqualsTo<T>(_ collection: IEnumerable<T>) -> Boolean

Boolean EqualsTo<T>(IEnumerable<T> collection)

Function EqualsTo<T>(collection As IEnumerable<T>) As Boolean

method Except<T>(aSecond: not nullable IEnumerable<T>; aComparator: Func<T,T,RemObjects.Elements.System.Int32>): IEnumerable<T>

IEnumerable<T> Except<T>(IEnumerable<T>! aSecond, Func<T,T,RemObjects.Elements.System.Int32> aComparator)

func Except<T>(_ aSecond: IEnumerable<T>, _ aComparator: Func<T,T,RemObjects.Elements.System.Int32>) -> IEnumerable<T>

IEnumerable<T> Except<T>(IEnumerable<T> aSecond, Func<T,T,RemObjects.Elements.System.Int32> aComparator)

Function Except<T>(aSecond As IEnumerable<T>, aComparator As Func<T,T,RemObjects.Elements.System.Int32>) As IEnumerable<T>

method First<T>: T

T First<T>()

func First<T>() -> T

T First<T>()

Function First<T>() As T

method First<T>(aBlock: not nullable Func<not nullable T, Boolean>): T

T First<T>(Func<not nullable T, Boolean>! aBlock)

func First<T>(_ aBlock: Func<not nullable T, Boolean>) -> T

T First<T>(Func2<T, Boolean> aBlock)

Function First<T>(aBlock As Func (Of T, Boolean)) As T

method FirstOrDefault<T>: nullable T

T? FirstOrDefault<T>()

func FirstOrDefault<T>() -> T?

T FirstOrDefault<T>()

Function FirstOrDefault<T>() As T?

method FirstOrDefault<T>(aBlock: not nullable Func<not nullable T, Boolean>): nullable T

T? FirstOrDefault<T>(Func<not nullable T, Boolean>! aBlock)

func FirstOrDefault<T>(_ aBlock: Func<not nullable T, Boolean>) -> T?

T FirstOrDefault<T>(Func2<T, Boolean> aBlock)

Function FirstOrDefault<T>(aBlock As Func (Of T, Boolean)) As T?

method GroupBy<TKey,T>(aKeySelector: not nullable Func<T, TKey>; aComparer: IEqualityComparer<TKey>): IEnumerable<IGroupingSequence<TKey, T>>

IEnumerable<IGroupingSequence<TKey, T>> GroupBy<TKey,T>(Func<T, TKey>! aKeySelector, IEqualityComparer<TKey> aComparer)

func GroupBy<TKey,T>(_ aKeySelector: Func<T, TKey>, _ aComparer: IEqualityComparer<TKey>) -> IEnumerable<IGroupingSequence<TKey, T>>

IEnumerable<IGroupingSequence<TKey, T>> GroupBy<TKey,T>(Func2<T, TKey> aKeySelector, IEqualityComparer<TKey> aComparer)

Function GroupBy<TKey,T>(aKeySelector As Func (Of T, TKey), aComparer As IEqualityComparer<TKey>) As IEnumerable<IGroupingSequence<TKey, T>>

method GroupBy<TKey,TValue,T>(aKeySelector: not nullable Func<T, TKey>; aValueSelector: not nullable Func<T, TValue>; aComparer: IEqualityComparer<TKey>): IEnumerable<IGroupingSequence<TKey, TValue>>

IEnumerable<IGroupingSequence<TKey, TValue>> GroupBy<TKey,TValue,T>(Func<T, TKey>! aKeySelector, Func<T, TValue>! aValueSelector, IEqualityComparer<TKey> aComparer)

func GroupBy<TKey,TValue,T>(_ aKeySelector: Func<T, TKey>, _ aValueSelector: Func<T, TValue>, _ aComparer: IEqualityComparer<TKey>) -> IEnumerable<IGroupingSequence<TKey, TValue>>

IEnumerable<IGroupingSequence<TKey, TValue>> GroupBy<TKey,TValue,T>(Func2<T, TKey> aKeySelector, Func2<T, TValue> aValueSelector, IEqualityComparer<TKey> aComparer)

Function GroupBy<TKey,TValue,T>(aKeySelector As Func (Of T, TKey), aValueSelector As Func (Of T, TValue), aComparer As IEqualityComparer<TKey>) As IEnumerable<IGroupingSequence<TKey, TValue>>

method Intersect<T>(aSecond: not nullable IEnumerable<T>; aComparator: Func<T,T,RemObjects.Elements.System.Int32>): IEnumerable<T>

IEnumerable<T> Intersect<T>(IEnumerable<T>! aSecond, Func<T,T,RemObjects.Elements.System.Int32> aComparator)

func Intersect<T>(_ aSecond: IEnumerable<T>, _ aComparator: Func<T,T,RemObjects.Elements.System.Int32>) -> IEnumerable<T>

IEnumerable<T> Intersect<T>(IEnumerable<T> aSecond, Func<T,T,RemObjects.Elements.System.Int32> aComparator)

Function Intersect<T>(aSecond As IEnumerable<T>, aComparator As Func<T,T,RemObjects.Elements.System.Int32>) As IEnumerable<T>

method Max<T,U>(aBlock: not nullable Func<not nullable T, U>): nullable U

U? Max<T,U>(Func<not nullable T, U>! aBlock)

func Max<T,U>(_ aBlock: Func<not nullable T, U>) -> U?

U Max<T,U>(Func2<T, U> aBlock)

Function Max<T,U>(aBlock As Func (Of T, U)) As U?

method Max<T>: nullable T

T? Max<T>()

func Max<T>() -> T?

T Max<T>()

Function Max<T>() As T?

method Min<T,U>(aBlock: not nullable Func<not nullable T, U>): nullable U

U? Min<T,U>(Func<not nullable T, U>! aBlock)

func Min<T,U>(_ aBlock: Func<not nullable T, U>) -> U?

U Min<T,U>(Func2<T, U> aBlock)

Function Min<T,U>(aBlock As Func (Of T, U)) As U?

method Min<T>: nullable T

T? Min<T>()

func Min<T>() -> T?

T Min<T>()

Function Min<T>() As T?

method OrderBy<C,T>(aBlock: not nullable Func<not nullable T, C>): IOrderedSequence<T>

IOrderedSequence<T> OrderBy<C,T>(Func<not nullable T, C>! aBlock)

func OrderBy<C,T>(_ aBlock: Func<not nullable T, C>) -> IOrderedSequence<T>

IOrderedSequence<T> OrderBy<C,T>(Func2<T, C> aBlock)

Function OrderBy<C,T>(aBlock As Func (Of T, C)) As IOrderedSequence<T>

method OrderByDescending<C,T>(aBlock: not nullable Func<not nullable T, C>): IEnumerable<T>

IEnumerable<T> OrderByDescending<C,T>(Func<not nullable T, C>! aBlock)

func OrderByDescending<C,T>(_ aBlock: Func<not nullable T, C>) -> IEnumerable<T>

IEnumerable<T> OrderByDescending<C,T>(Func2<T, C> aBlock)

Function OrderByDescending<C,T>(aBlock As Func (Of T, C)) As IEnumerable<T>

method Reverse<T>: IEnumerable<T>

IEnumerable<T> Reverse<T>()

func Reverse<T>() -> IEnumerable<T>

IEnumerable<T> Reverse<T>()

Function Reverse<T>() As IEnumerable<T>

method Select<T,U>(aBlock: not nullable Func<not nullable T, U>): IEnumerable<U>

IEnumerable<U> Select<T,U>(Func<not nullable T, U>! aBlock)

func Select<T,U>(_ aBlock: Func<not nullable T, U>) -> IEnumerable<U>

IEnumerable<U> Select<T,U>(Func2<T, U> aBlock)

Function Select<T,U>(aBlock As Func (Of T, U)) As IEnumerable<U>

method SelectMany<T,U,TRes>(aBlock: not nullable Func<not nullable T, wrapped nullable IEnumerable<U>>; aSelector: not nullable Func<not nullable T, U, TRes>): IEnumerable<TRes>

IEnumerable<TRes> SelectMany<T,U,TRes>(Func<not nullable T, wrapped nullable IEnumerable<U>>! aBlock, Func<not nullable T, U, TRes>! aSelector)

func SelectMany<T,U,TRes>(_ aBlock: Func<not nullable T, wrapped nullable IEnumerable<U>>, _ aSelector: Func<not nullable T, U, TRes>) -> IEnumerable<TRes>

IEnumerable<TRes> SelectMany<T,U,TRes>(Func2<T, IEnumerable<U>> aBlock, Func3<T, U, TRes> aSelector)

Function SelectMany<T,U,TRes>(aBlock As Func (Of T, IEnumerable<U>?), aSelector As Func (Of T, U, TRes)) As IEnumerable<TRes>

method SelectMany<T,U>(aBlock: not nullable Func<not nullable T, wrapped nullable IEnumerable<U>>): IEnumerable<U>

IEnumerable<U> SelectMany<T,U>(Func<not nullable T, wrapped nullable IEnumerable<U>>! aBlock)

func SelectMany<T,U>(_ aBlock: Func<not nullable T, wrapped nullable IEnumerable<U>>) -> IEnumerable<U>

IEnumerable<U> SelectMany<T,U>(Func2<T, IEnumerable<U>> aBlock)

Function SelectMany<T,U>(aBlock As Func (Of T, IEnumerable<U>?)) As IEnumerable<U>

method Skip<T>(aCount: Int32): IEnumerable<T>

IEnumerable<T> Skip<T>(Int32 aCount)

func Skip<T>(_ aCount: Int32) -> IEnumerable<T>

IEnumerable<T> Skip<T>(Int32 aCount)

Function Skip<T>(aCount As Int32) As IEnumerable<T>

method SkipWhile<T>(aBlock: not nullable Func<not nullable T, Boolean>): IEnumerable<T>

IEnumerable<T> SkipWhile<T>(Func<not nullable T, Boolean>! aBlock)

func SkipWhile<T>(_ aBlock: Func<not nullable T, Boolean>) -> IEnumerable<T>

IEnumerable<T> SkipWhile<T>(Func2<T, Boolean> aBlock)

Function SkipWhile<T>(aBlock As Func (Of T, Boolean)) As IEnumerable<T>

method Take<T>(aCount: Int32): IEnumerable<T>

IEnumerable<T> Take<T>(Int32 aCount)

func Take<T>(_ aCount: Int32) -> IEnumerable<T>

IEnumerable<T> Take<T>(Int32 aCount)

Function Take<T>(aCount As Int32) As IEnumerable<T>

method TakeWhile<T>(aBlock: not nullable Func<not nullable T, Boolean>): IEnumerable<T>

IEnumerable<T> TakeWhile<T>(Func<not nullable T, Boolean>! aBlock)

func TakeWhile<T>(_ aBlock: Func<not nullable T, Boolean>) -> IEnumerable<T>

IEnumerable<T> TakeWhile<T>(Func2<T, Boolean> aBlock)

Function TakeWhile<T>(aBlock As Func (Of T, Boolean)) As IEnumerable<T>

method ToArray<T>: not nullable array of T

T[]! ToArray<T>()

func ToArray<T>() -> T...

T[] ToArray<T>()

Function ToArray<T>() As T()

method ToDictionary<TKey,TValue,T>(aKeySelector: not nullable Func<T, TKey>; aValueSelector: not nullable Func<T, TValue>): not nullable Dictionary<TKey, TValue>

Dictionary<TKey, TValue>! ToDictionary<TKey,TValue,T>(Func<T, TKey>! aKeySelector, Func<T, TValue>! aValueSelector)

func ToDictionary<TKey,TValue,T>(_ aKeySelector: Func<T, TKey>, _ aValueSelector: Func<T, TValue>) -> Dictionary<TKey, TValue>

Dictionary<TKey, TValue> ToDictionary<TKey,TValue,T>(Func2<T, TKey> aKeySelector, Func2<T, TValue> aValueSelector)

Function ToDictionary<TKey,TValue,T>(aKeySelector As Func (Of T, TKey), aValueSelector As Func (Of T, TValue)) As Dictionary<TKey, TValue>

method ToDictionary<TKey,TValue,T>(aKeySelector: not nullable Func<T, TKey>; aValueSelector: not nullable Func<T, TValue>; aComparer: nullable IEqualityComparer<TKey>): not nullable Dictionary<TKey, TValue>

Dictionary<TKey, TValue>! ToDictionary<TKey,TValue,T>(Func<T, TKey>! aKeySelector, Func<T, TValue>! aValueSelector, IEqualityComparer<TKey>? aComparer)

func ToDictionary<TKey,TValue,T>(_ aKeySelector: Func<T, TKey>, _ aValueSelector: Func<T, TValue>, _ aComparer: IEqualityComparer<TKey>?) -> Dictionary<TKey, TValue>

Dictionary<TKey, TValue> ToDictionary<TKey,TValue,T>(Func2<T, TKey> aKeySelector, Func2<T, TValue> aValueSelector, IEqualityComparer<TKey> aComparer)

Function ToDictionary<TKey,TValue,T>(aKeySelector As Func (Of T, TKey), aValueSelector As Func (Of T, TValue), aComparer As IEqualityComparer<TKey>?) As Dictionary<TKey, TValue>

method ToImmutableList<T>: not nullable RemObjects.Elements.System.ImmutableList<T>

RemObjects.Elements.System.ImmutableList<T>! ToImmutableList<T>()

func ToImmutableList<T>() -> RemObjects.Elements.System.ImmutableList<T>

RemObjects.Elements.System.ImmutableList<T> ToImmutableList<T>()

Function ToImmutableList<T>() As RemObjects.Elements.System.ImmutableList<T>

method ToList<T>: not nullable RemObjects.Elements.System.List<T>

RemObjects.Elements.System.List<T>! ToList<T>()

func ToList<T>() -> RemObjects.Elements.System.List<T>

RemObjects.Elements.System.List<T> ToList<T>()

Function ToList<T>() As RemObjects.Elements.System.List<T>

method ToLookup<TKey,T>(aKeySelector: not nullable Func<T, TKey>; aComparer: IEqualityComparer<TKey>): ILookup<TKey, T>

ILookup<TKey, T> ToLookup<TKey,T>(Func<T, TKey>! aKeySelector, IEqualityComparer<TKey> aComparer)

func ToLookup<TKey,T>(_ aKeySelector: Func<T, TKey>, _ aComparer: IEqualityComparer<TKey>) -> ILookup<TKey, T>

ILookup<TKey, T> ToLookup<TKey,T>(Func2<T, TKey> aKeySelector, IEqualityComparer<TKey> aComparer)

Function ToLookup<TKey,T>(aKeySelector As Func (Of T, TKey), aComparer As IEqualityComparer<TKey>) As ILookup<TKey, T>

method ToLookup<TKey,TValue,T>(aKeySelector: not nullable Func<T, TKey>; aValueSelector: not nullable Func<T, TValue>; aComparer: IEqualityComparer<TKey>): ILookup<TKey, TValue>

ILookup<TKey, TValue> ToLookup<TKey,TValue,T>(Func<T, TKey>! aKeySelector, Func<T, TValue>! aValueSelector, IEqualityComparer<TKey> aComparer)

func ToLookup<TKey,TValue,T>(_ aKeySelector: Func<T, TKey>, _ aValueSelector: Func<T, TValue>, _ aComparer: IEqualityComparer<TKey>) -> ILookup<TKey, TValue>

ILookup<TKey, TValue> ToLookup<TKey,TValue,T>(Func2<T, TKey> aKeySelector, Func2<T, TValue> aValueSelector, IEqualityComparer<TKey> aComparer)

Function ToLookup<TKey,TValue,T>(aKeySelector As Func (Of T, TKey), aValueSelector As Func (Of T, TValue), aComparer As IEqualityComparer<TKey>) As ILookup<TKey, TValue>

method ToNSArray<T>: not nullable NSArray<T>

NSArray<T>! ToNSArray<T>()

func ToNSArray<T>() -> NSArray<T>

NSArray<T> ToNSArray<T>()

Function ToNSArray<T>() As NSArray<T>

method ToNSMutableArray<T>: not nullable NSMutableArray<T>

NSMutableArray<T>! ToNSMutableArray<T>()

func ToNSMutableArray<T>() -> NSMutableArray<T>

NSMutableArray<T> ToNSMutableArray<T>()

Function ToNSMutableArray<T>() As NSMutableArray<T>

method Where<T>(aBlock: not nullable Func<not nullable T, Boolean>): IEnumerable<T>

IEnumerable<T> Where<T>(Func<not nullable T, Boolean>! aBlock)

func Where<T>(_ aBlock: Func<not nullable T, Boolean>) -> IEnumerable<T>

IEnumerable<T> Where<T>(Func2<T, Boolean> aBlock)

Function Where<T>(aBlock As Func (Of T, Boolean)) As IEnumerable<T>