Uses of Interface
sharin.unlinq.Func

Packages that use Func
sharin.unlinq   
 

Uses of Func in sharin.unlinq
 

Methods in sharin.unlinq with parameters of type Func
<A,R> R
BasicLookup.aggregate(A seed, Func2<A,Grouping<TKey,TValue>,A> func, Func<A,R> resultSelector)
           
<A,R> R
BasicDictionary.aggregate(A seed, Func2<A,Map.Entry<TKey,TValue>,A> func, Func<A,R> resultSelector)
           
<A,R> R
Enumerable.aggregate(A seed, Func2<A,T,A> func, Func<A,R> resultSelector)
           
<A,R> R
BasicOrderedEnumerable.aggregate(A seed, Func2<A,T,A> func, Func<A,R> resultSelector)
           
<A,R> R
BasicEnumerableList.aggregate(A seed, Func2<A,T,A> func, Func<A,R> resultSelector)
           
<A,R> R
BasicEnumerable.aggregate(A seed, Func2<A,T,A> func, Func<A,R> resultSelector)
           
 Boolean BasicLookup.all(Func<Grouping<TKey,TValue>,Boolean> predicate)
           
 Boolean BasicDictionary.all(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
           
 Boolean Enumerable.all(Func<T,Boolean> predicate)
           
 Boolean BasicOrderedEnumerable.all(Func<T,Boolean> predicate)
           
 Boolean BasicEnumerableList.all(Func<T,Boolean> predicate)
           
 Boolean BasicEnumerable.all(Func<T,Boolean> predicate)
           
 Boolean BasicLookup.any(Func<Grouping<TKey,TValue>,Boolean> predicate)
           
 Boolean BasicDictionary.any(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
           
 Boolean Enumerable.any(Func<T,Boolean> predicate)
           
 Boolean BasicOrderedEnumerable.any(Func<T,Boolean> predicate)
           
 Boolean BasicEnumerableList.any(Func<T,Boolean> predicate)
           
 Boolean BasicEnumerable.any(Func<T,Boolean> predicate)
           
 double BasicLookup.average(Func<Grouping<TKey,TValue>,Integer> selector)
           
 double BasicDictionary.average(Func<Map.Entry<TKey,TValue>,Integer> selector)
           
 double Enumerable.average(Func<T,Integer> selector)
           
 double BasicOrderedEnumerable.average(Func<T,Integer> selector)
           
 double BasicEnumerableList.average(Func<T,Integer> selector)
           
 double BasicEnumerable.average(Func<T,Integer> selector)
           
 double BasicLookup.averageDouble(Func<Grouping<TKey,TValue>,Double> selector)
           
 double BasicDictionary.averageDouble(Func<Map.Entry<TKey,TValue>,Double> selector)
           
 double Enumerable.averageDouble(Func<T,Double> selector)
           
 double BasicOrderedEnumerable.averageDouble(Func<T,Double> selector)
           
 double BasicEnumerableList.averageDouble(Func<T,Double> selector)
           
 double BasicEnumerable.averageDouble(Func<T,Double> selector)
           
 float BasicLookup.averageFloat(Func<Grouping<TKey,TValue>,Float> selector)
           
 float BasicDictionary.averageFloat(Func<Map.Entry<TKey,TValue>,Float> selector)
           
 float Enumerable.averageFloat(Func<T,Float> selector)
           
 float BasicOrderedEnumerable.averageFloat(Func<T,Float> selector)
           
 float BasicEnumerableList.averageFloat(Func<T,Float> selector)
           
 float BasicEnumerable.averageFloat(Func<T,Float> selector)
           
 double BasicLookup.averageLong(Func<Grouping<TKey,TValue>,Long> selector)
           
 double BasicDictionary.averageLong(Func<Map.Entry<TKey,TValue>,Long> selector)
           
 double Enumerable.averageLong(Func<T,Long> selector)
           
 double BasicOrderedEnumerable.averageLong(Func<T,Long> selector)
           
 double BasicEnumerableList.averageLong(Func<T,Long> selector)
           
 double BasicEnumerable.averageLong(Func<T,Long> selector)
           
 int BasicLookup.count(Func<Grouping<TKey,TValue>,Boolean> predicate)
           
 int BasicDictionary.count(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
           
 int Enumerable.count(Func<T,Boolean> predicate)
           
 int BasicOrderedEnumerable.count(Func<T,Boolean> predicate)
           
 int BasicEnumerableList.count(Func<T,Boolean> predicate)
           
 int BasicEnumerable.count(Func<T,Boolean> predicate)
           
 Grouping<TKey,TValue> BasicLookup.first(Func<Grouping<TKey,TValue>,Boolean> predicate)
           
 Map.Entry<TKey,TValue> BasicDictionary.first(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
           
 T Enumerable.first(Func<T,Boolean> predicate)
           
 T BasicOrderedEnumerable.first(Func<T,Boolean> predicate)
           
 T BasicEnumerableList.first(Func<T,Boolean> predicate)
           
 T BasicEnumerable.first(Func<T,Boolean> predicate)
           
 Grouping<TKey,TValue> BasicLookup.firstOrDefault(Func<Grouping<TKey,TValue>,Boolean> predicate)
           
 Grouping<TKey,TValue> BasicLookup.firstOrDefault(Func<Grouping<TKey,TValue>,Boolean> predicate, Grouping<TKey,TValue> defaultValue)
           
 Map.Entry<TKey,TValue> BasicDictionary.firstOrDefault(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
           
 Map.Entry<TKey,TValue> BasicDictionary.firstOrDefault(Func<Map.Entry<TKey,TValue>,Boolean> predicate, Map.Entry<TKey,TValue> defaultValue)
           
 T Enumerable.firstOrDefault(Func<T,Boolean> predicate)
           
 T BasicOrderedEnumerable.firstOrDefault(Func<T,Boolean> predicate)
           
 T BasicEnumerableList.firstOrDefault(Func<T,Boolean> predicate)
           
 T BasicEnumerable.firstOrDefault(Func<T,Boolean> predicate)
           
 T Enumerable.firstOrDefault(Func<T,Boolean> predicate, T defaultValue)
           
 T BasicOrderedEnumerable.firstOrDefault(Func<T,Boolean> predicate, T defaultValue)
           
 T BasicEnumerableList.firstOrDefault(Func<T,Boolean> predicate, T defaultValue)
           
 T BasicEnumerable.firstOrDefault(Func<T,Boolean> predicate, T defaultValue)
           
<K> Enumerable<Grouping<K,Grouping<TKey,TValue>>>
BasicLookup.groupBy(Func<Grouping<TKey,TValue>,K> keySelector)
           
<K,E> Enumerable<Grouping<K,E>>
BasicLookup.groupBy(Func<Grouping<TKey,TValue>,K> keySelector, Func<Grouping<TKey,TValue>,E> elementSelector)
           
<K,E> Enumerable<Grouping<K,E>>
BasicLookup.groupBy(Func<Grouping<TKey,TValue>,K> keySelector, Func<Grouping<TKey,TValue>,E> elementSelector)
           
<K,E,R> Enumerable<R>
BasicLookup.groupBy(Func<Grouping<TKey,TValue>,K> keySelector, Func<Grouping<TKey,TValue>,E> elementSelector, Func2<K,Enumerable<E>,R> resultSelector)
           
<K,E,R> Enumerable<R>
BasicLookup.groupBy(Func<Grouping<TKey,TValue>,K> keySelector, Func<Grouping<TKey,TValue>,E> elementSelector, Func2<K,Enumerable<E>,R> resultSelector)
           
<K,R> Enumerable<R>
BasicLookup.groupBy(Func<Grouping<TKey,TValue>,K> keySelector, Func2<K,Enumerable<Grouping<TKey,TValue>>,R> resultSelector)
           
<K> Enumerable<Grouping<K,Map.Entry<TKey,TValue>>>
BasicDictionary.groupBy(Func<Map.Entry<TKey,TValue>,K> keySelector)
           
<K,E> Enumerable<Grouping<K,E>>
BasicDictionary.groupBy(Func<Map.Entry<TKey,TValue>,K> keySelector, Func<Map.Entry<TKey,TValue>,E> elementSelector)
           
<K,E> Enumerable<Grouping<K,E>>
BasicDictionary.groupBy(Func<Map.Entry<TKey,TValue>,K> keySelector, Func<Map.Entry<TKey,TValue>,E> elementSelector)
           
<K,E,R> Enumerable<R>
BasicDictionary.groupBy(Func<Map.Entry<TKey,TValue>,K> keySelector, Func<Map.Entry<TKey,TValue>,E> elementSelector, Func2<K,Enumerable<E>,R> resultSelector)
           
<K,E,R> Enumerable<R>
BasicDictionary.groupBy(Func<Map.Entry<TKey,TValue>,K> keySelector, Func<Map.Entry<TKey,TValue>,E> elementSelector, Func2<K,Enumerable<E>,R> resultSelector)
           
<K,R> Enumerable<R>
BasicDictionary.groupBy(Func<Map.Entry<TKey,TValue>,K> keySelector, Func2<K,Enumerable<Map.Entry<TKey,TValue>>,R> resultSelector)
           
<K> Enumerable<Grouping<K,T>>
Enumerable.groupBy(Func<T,K> keySelector)
           
<K> Enumerable<Grouping<K,T>>
BasicOrderedEnumerable.groupBy(Func<T,K> keySelector)
           
<K> Enumerable<Grouping<K,T>>
BasicEnumerableList.groupBy(Func<T,K> keySelector)
           
<K> Enumerable<Grouping<K,T>>
BasicEnumerable.groupBy(Func<T,K> keySelector)
           
<K,E> Enumerable<Grouping<K,E>>
Enumerable.groupBy(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Enumerable<Grouping<K,E>>
Enumerable.groupBy(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Enumerable<Grouping<K,E>>
BasicOrderedEnumerable.groupBy(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Enumerable<Grouping<K,E>>
BasicOrderedEnumerable.groupBy(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Enumerable<Grouping<K,E>>
BasicEnumerableList.groupBy(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Enumerable<Grouping<K,E>>
BasicEnumerableList.groupBy(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Enumerable<Grouping<K,E>>
BasicEnumerable.groupBy(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Enumerable<Grouping<K,E>>
BasicEnumerable.groupBy(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E,R> Enumerable<R>
Enumerable.groupBy(Func<T,K> keySelector, Func<T,E> elementSelector, Func2<K,Enumerable<E>,R> resultSelector)
           
<K,E,R> Enumerable<R>
Enumerable.groupBy(Func<T,K> keySelector, Func<T,E> elementSelector, Func2<K,Enumerable<E>,R> resultSelector)
           
<K,E,R> Enumerable<R>
BasicOrderedEnumerable.groupBy(Func<T,K> keySelector, Func<T,E> elementSelector, Func2<K,Enumerable<E>,R> resultSelector)
           
<K,E,R> Enumerable<R>
BasicOrderedEnumerable.groupBy(Func<T,K> keySelector, Func<T,E> elementSelector, Func2<K,Enumerable<E>,R> resultSelector)
           
<K,E,R> Enumerable<R>
BasicEnumerableList.groupBy(Func<T,K> keySelector, Func<T,E> elementSelector, Func2<K,Enumerable<E>,R> resultSelector)
           
<K,E,R> Enumerable<R>
BasicEnumerableList.groupBy(Func<T,K> keySelector, Func<T,E> elementSelector, Func2<K,Enumerable<E>,R> resultSelector)
           
<K,E,R> Enumerable<R>
BasicEnumerable.groupBy(Func<T,K> keySelector, Func<T,E> elementSelector, Func2<K,Enumerable<E>,R> resultSelector)
           
<K,E,R> Enumerable<R>
BasicEnumerable.groupBy(Func<T,K> keySelector, Func<T,E> elementSelector, Func2<K,Enumerable<E>,R> resultSelector)
           
<K,R> Enumerable<R>
Enumerable.groupBy(Func<T,K> keySelector, Func2<K,Enumerable<T>,R> resultSelector)
           
<K,R> Enumerable<R>
BasicOrderedEnumerable.groupBy(Func<T,K> keySelector, Func2<K,Enumerable<T>,R> resultSelector)
           
<K,R> Enumerable<R>
BasicEnumerableList.groupBy(Func<T,K> keySelector, Func2<K,Enumerable<T>,R> resultSelector)
           
<K,R> Enumerable<R>
BasicEnumerable.groupBy(Func<T,K> keySelector, Func2<K,Enumerable<T>,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicLookup.groupJoin(Enumerable<I> inner, Func<Grouping<TKey,TValue>,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<Grouping<TKey,TValue>,Enumerable<I>,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicLookup.groupJoin(Enumerable<I> inner, Func<Grouping<TKey,TValue>,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<Grouping<TKey,TValue>,Enumerable<I>,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicDictionary.groupJoin(Enumerable<I> inner, Func<Map.Entry<TKey,TValue>,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<Map.Entry<TKey,TValue>,Enumerable<I>,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicDictionary.groupJoin(Enumerable<I> inner, Func<Map.Entry<TKey,TValue>,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<Map.Entry<TKey,TValue>,Enumerable<I>,R> resultSelector)
           
<I,K,R> Enumerable<R>
Enumerable.groupJoin(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,Enumerable<I>,R> resultSelector)
           
<I,K,R> Enumerable<R>
Enumerable.groupJoin(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,Enumerable<I>,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicOrderedEnumerable.groupJoin(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,Enumerable<I>,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicOrderedEnumerable.groupJoin(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,Enumerable<I>,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicEnumerableList.groupJoin(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,Enumerable<I>,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicEnumerableList.groupJoin(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,Enumerable<I>,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicEnumerable.groupJoin(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,Enumerable<I>,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicEnumerable.groupJoin(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,Enumerable<I>,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicLookup.join(Enumerable<I> inner, Func<Grouping<TKey,TValue>,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<Grouping<TKey,TValue>,I,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicLookup.join(Enumerable<I> inner, Func<Grouping<TKey,TValue>,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<Grouping<TKey,TValue>,I,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicDictionary.join(Enumerable<I> inner, Func<Map.Entry<TKey,TValue>,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<Map.Entry<TKey,TValue>,I,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicDictionary.join(Enumerable<I> inner, Func<Map.Entry<TKey,TValue>,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<Map.Entry<TKey,TValue>,I,R> resultSelector)
           
<I,K,R> Enumerable<R>
Enumerable.join(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,I,R> resultSelector)
           
<I,K,R> Enumerable<R>
Enumerable.join(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,I,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicOrderedEnumerable.join(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,I,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicOrderedEnumerable.join(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,I,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicEnumerableList.join(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,I,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicEnumerableList.join(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,I,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicEnumerable.join(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,I,R> resultSelector)
           
<I,K,R> Enumerable<R>
BasicEnumerable.join(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,I,R> resultSelector)
           
 Grouping<TKey,TValue> BasicLookup.last(Func<Grouping<TKey,TValue>,Boolean> predicate)
           
 Map.Entry<TKey,TValue> BasicDictionary.last(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
           
 T Enumerable.last(Func<T,Boolean> predicate)
           
 T BasicOrderedEnumerable.last(Func<T,Boolean> predicate)
           
 T BasicEnumerableList.last(Func<T,Boolean> predicate)
           
 T BasicEnumerable.last(Func<T,Boolean> predicate)
           
 Grouping<TKey,TValue> BasicLookup.lastOrDefault(Func<Grouping<TKey,TValue>,Boolean> predicate)
           
 Grouping<TKey,TValue> BasicLookup.lastOrDefault(Func<Grouping<TKey,TValue>,Boolean> predicate, Grouping<TKey,TValue> defaultValue)
           
 Map.Entry<TKey,TValue> BasicDictionary.lastOrDefault(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
           
 Map.Entry<TKey,TValue> BasicDictionary.lastOrDefault(Func<Map.Entry<TKey,TValue>,Boolean> predicate, Map.Entry<TKey,TValue> defaultValue)
           
 T Enumerable.lastOrDefault(Func<T,Boolean> predicate)
           
 T BasicOrderedEnumerable.lastOrDefault(Func<T,Boolean> predicate)
           
 T BasicEnumerableList.lastOrDefault(Func<T,Boolean> predicate)
           
 T BasicEnumerable.lastOrDefault(Func<T,Boolean> predicate)
           
 T Enumerable.lastOrDefault(Func<T,Boolean> predicate, T defaultValue)
           
 T BasicOrderedEnumerable.lastOrDefault(Func<T,Boolean> predicate, T defaultValue)
           
 T BasicEnumerableList.lastOrDefault(Func<T,Boolean> predicate, T defaultValue)
           
 T BasicEnumerable.lastOrDefault(Func<T,Boolean> predicate, T defaultValue)
           
 long BasicLookup.longCount(Func<Grouping<TKey,TValue>,Boolean> predicate)
           
 long BasicDictionary.longCount(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
           
 long Enumerable.longCount(Func<T,Boolean> predicate)
           
 long BasicOrderedEnumerable.longCount(Func<T,Boolean> predicate)
           
 long BasicEnumerableList.longCount(Func<T,Boolean> predicate)
           
 long BasicEnumerable.longCount(Func<T,Boolean> predicate)
           
<R extends Comparable<R>>
R
BasicLookup.max(Func<Grouping<TKey,TValue>,R> selector)
           
<R extends Comparable<R>>
R
BasicDictionary.max(Func<Map.Entry<TKey,TValue>,R> selector)
           
<R extends Comparable<R>>
R
Enumerable.max(Func<T,R> selector)
           
<R extends Comparable<R>>
R
BasicOrderedEnumerable.max(Func<T,R> selector)
           
<R extends Comparable<R>>
R
BasicEnumerableList.max(Func<T,R> selector)
           
<R extends Comparable<R>>
R
BasicEnumerable.max(Func<T,R> selector)
           
<R extends Comparable<R>>
R
BasicLookup.min(Func<Grouping<TKey,TValue>,R> selector)
           
<R extends Comparable<R>>
R
BasicDictionary.min(Func<Map.Entry<TKey,TValue>,R> selector)
           
<R extends Comparable<R>>
R
Enumerable.min(Func<T,R> selector)
           
<R extends Comparable<R>>
R
BasicOrderedEnumerable.min(Func<T,R> selector)
           
<R extends Comparable<R>>
R
BasicEnumerableList.min(Func<T,R> selector)
           
<R extends Comparable<R>>
R
BasicEnumerable.min(Func<T,R> selector)
           
<K> OrderedEnumerable<Grouping<TKey,TValue>>
BasicLookup.orderBy(Func<Grouping<TKey,TValue>,K> keySelector)
           
<K> OrderedEnumerable<Grouping<TKey,TValue>>
BasicLookup.orderBy(Func<Grouping<TKey,TValue>,K> keySelector, Comparator<K> comparator)
           
<K> OrderedEnumerable<Map.Entry<TKey,TValue>>
BasicDictionary.orderBy(Func<Map.Entry<TKey,TValue>,K> keySelector)
           
<K> OrderedEnumerable<Map.Entry<TKey,TValue>>
BasicDictionary.orderBy(Func<Map.Entry<TKey,TValue>,K> keySelector, Comparator<K> comparator)
           
<K> OrderedEnumerable<T>
Enumerable.orderBy(Func<T,K> keySelector)
           
<K> OrderedEnumerable<T>
BasicOrderedEnumerable.orderBy(Func<T,K> keySelector)
           
<K> OrderedEnumerable<T>
BasicEnumerableList.orderBy(Func<T,K> keySelector)
           
<K> OrderedEnumerable<T>
BasicEnumerable.orderBy(Func<T,K> keySelector)
           
<K> OrderedEnumerable<T>
Enumerable.orderBy(Func<T,K> keySelector, Comparator<K> comparator)
           
<K> OrderedEnumerable<T>
BasicOrderedEnumerable.orderBy(Func<T,K> keySelector, Comparator<K> comparator)
           
<K> OrderedEnumerable<T>
BasicEnumerableList.orderBy(Func<T,K> keySelector, Comparator<K> comparator)
           
<K> OrderedEnumerable<T>
BasicEnumerable.orderBy(Func<T,K> keySelector, Comparator<K> comparator)
           
<K> OrderedEnumerable<Grouping<TKey,TValue>>
BasicLookup.orderByDescending(Func<Grouping<TKey,TValue>,K> keySelector)
           
<K> OrderedEnumerable<Grouping<TKey,TValue>>
BasicLookup.orderByDescending(Func<Grouping<TKey,TValue>,K> keySelector, Comparator<K> comparator)
           
<K> OrderedEnumerable<Map.Entry<TKey,TValue>>
BasicDictionary.orderByDescending(Func<Map.Entry<TKey,TValue>,K> keySelector)
           
<K> OrderedEnumerable<Map.Entry<TKey,TValue>>
BasicDictionary.orderByDescending(Func<Map.Entry<TKey,TValue>,K> keySelector, Comparator<K> comparator)
           
<K> OrderedEnumerable<T>
Enumerable.orderByDescending(Func<T,K> keySelector)
           
<K> OrderedEnumerable<T>
BasicOrderedEnumerable.orderByDescending(Func<T,K> keySelector)
           
<K> OrderedEnumerable<T>
BasicEnumerableList.orderByDescending(Func<T,K> keySelector)
           
<K> OrderedEnumerable<T>
BasicEnumerable.orderByDescending(Func<T,K> keySelector)
           
<K> OrderedEnumerable<T>
Enumerable.orderByDescending(Func<T,K> keySelector, Comparator<K> comparator)
           
<K> OrderedEnumerable<T>
BasicOrderedEnumerable.orderByDescending(Func<T,K> keySelector, Comparator<K> comparator)
           
<K> OrderedEnumerable<T>
BasicEnumerableList.orderByDescending(Func<T,K> keySelector, Comparator<K> comparator)
           
<K> OrderedEnumerable<T>
BasicEnumerable.orderByDescending(Func<T,K> keySelector, Comparator<K> comparator)
           
<R> Enumerable<R>
BasicLookup.select(Func<Grouping<TKey,TValue>,R> selector)
           
<R> Enumerable<R>
BasicDictionary.select(Func<Map.Entry<TKey,TValue>,R> selector)
           
<R> Enumerable<R>
Enumerable.select(Func<T,R> selector)
           
<R> Enumerable<R>
BasicOrderedEnumerable.select(Func<T,R> selector)
           
<R> Enumerable<R>
BasicEnumerableList.select(Func<T,R> selector)
           
<R> Enumerable<R>
BasicEnumerable.select(Func<T,R> selector)
           
<C,R> Enumerable<R>
BasicLookup.selectMany(Func<Grouping<TKey,TValue>,Enumerable<C>> collectionSelector, Func2<Grouping<TKey,TValue>,C,R> resultSelector)
           
<R> Enumerable<R>
BasicLookup.selectMany(Func<Grouping<TKey,TValue>,Enumerable<R>> selector)
           
<C,R> Enumerable<R>
BasicDictionary.selectMany(Func<Map.Entry<TKey,TValue>,Enumerable<C>> collectionSelector, Func2<Map.Entry<TKey,TValue>,C,R> resultSelector)
           
<R> Enumerable<R>
BasicDictionary.selectMany(Func<Map.Entry<TKey,TValue>,Enumerable<R>> selector)
           
<C,R> Enumerable<R>
Enumerable.selectMany(Func<T,Enumerable<C>> collectionSelector, Func2<T,C,R> resultSelector)
           
<C,R> Enumerable<R>
BasicOrderedEnumerable.selectMany(Func<T,Enumerable<C>> collectionSelector, Func2<T,C,R> resultSelector)
           
<C,R> Enumerable<R>
BasicEnumerableList.selectMany(Func<T,Enumerable<C>> collectionSelector, Func2<T,C,R> resultSelector)
           
<C,R> Enumerable<R>
BasicEnumerable.selectMany(Func<T,Enumerable<C>> collectionSelector, Func2<T,C,R> resultSelector)
           
<R> Enumerable<R>
Enumerable.selectMany(Func<T,Enumerable<R>> selector)
           
<R> Enumerable<R>
BasicOrderedEnumerable.selectMany(Func<T,Enumerable<R>> selector)
           
<R> Enumerable<R>
BasicEnumerableList.selectMany(Func<T,Enumerable<R>> selector)
           
<R> Enumerable<R>
BasicEnumerable.selectMany(Func<T,Enumerable<R>> selector)
           
 Grouping<TKey,TValue> BasicLookup.single(Func<Grouping<TKey,TValue>,Boolean> predicate)
           
 Map.Entry<TKey,TValue> BasicDictionary.single(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
           
 T Enumerable.single(Func<T,Boolean> predicate)
           
 T BasicOrderedEnumerable.single(Func<T,Boolean> predicate)
           
 T BasicEnumerableList.single(Func<T,Boolean> predicate)
           
 T BasicEnumerable.single(Func<T,Boolean> predicate)
           
 Grouping<TKey,TValue> BasicLookup.singleOrDefault(Func<Grouping<TKey,TValue>,Boolean> predicate)
           
 Grouping<TKey,TValue> BasicLookup.singleOrDefault(Func<Grouping<TKey,TValue>,Boolean> predicate, Grouping<TKey,TValue> defaultValue)
           
 Map.Entry<TKey,TValue> BasicDictionary.singleOrDefault(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
           
 Map.Entry<TKey,TValue> BasicDictionary.singleOrDefault(Func<Map.Entry<TKey,TValue>,Boolean> predicate, Map.Entry<TKey,TValue> defaultValue)
           
 T Enumerable.singleOrDefault(Func<T,Boolean> predicate)
           
 T BasicOrderedEnumerable.singleOrDefault(Func<T,Boolean> predicate)
           
 T BasicEnumerableList.singleOrDefault(Func<T,Boolean> predicate)
           
 T BasicEnumerable.singleOrDefault(Func<T,Boolean> predicate)
           
 T Enumerable.singleOrDefault(Func<T,Boolean> predicate, T defaultValue)
           
 T BasicOrderedEnumerable.singleOrDefault(Func<T,Boolean> predicate, T defaultValue)
           
 T BasicEnumerableList.singleOrDefault(Func<T,Boolean> predicate, T defaultValue)
           
 T BasicEnumerable.singleOrDefault(Func<T,Boolean> predicate, T defaultValue)
           
 Enumerable<Grouping<TKey,TValue>> BasicLookup.skipWhile(Func<Grouping<TKey,TValue>,Boolean> predicate)
           
 Enumerable<Map.Entry<TKey,TValue>> BasicDictionary.skipWhile(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
           
 Enumerable<T> Enumerable.skipWhile(Func<T,Boolean> predicate)
           
 Enumerable<T> BasicOrderedEnumerable.skipWhile(Func<T,Boolean> predicate)
           
 Enumerable<T> BasicEnumerableList.skipWhile(Func<T,Boolean> predicate)
           
 Enumerable<T> BasicEnumerable.skipWhile(Func<T,Boolean> predicate)
           
 int BasicLookup.sum(Func<Grouping<TKey,TValue>,Integer> selector)
           
 int BasicDictionary.sum(Func<Map.Entry<TKey,TValue>,Integer> selector)
           
 int Enumerable.sum(Func<T,Integer> selector)
           
 int BasicOrderedEnumerable.sum(Func<T,Integer> selector)
           
 int BasicEnumerableList.sum(Func<T,Integer> selector)
           
 int BasicEnumerable.sum(Func<T,Integer> selector)
           
 double BasicLookup.sumDouble(Func<Grouping<TKey,TValue>,Double> selector)
           
 double BasicDictionary.sumDouble(Func<Map.Entry<TKey,TValue>,Double> selector)
           
 double Enumerable.sumDouble(Func<T,Double> selector)
           
 double BasicOrderedEnumerable.sumDouble(Func<T,Double> selector)
           
 double BasicEnumerableList.sumDouble(Func<T,Double> selector)
           
 double BasicEnumerable.sumDouble(Func<T,Double> selector)
           
 float BasicLookup.sumFloat(Func<Grouping<TKey,TValue>,Float> selector)
           
 float BasicDictionary.sumFloat(Func<Map.Entry<TKey,TValue>,Float> selector)
           
 float Enumerable.sumFloat(Func<T,Float> selector)
           
 float BasicOrderedEnumerable.sumFloat(Func<T,Float> selector)
           
 float BasicEnumerableList.sumFloat(Func<T,Float> selector)
           
 float BasicEnumerable.sumFloat(Func<T,Float> selector)
           
 long BasicLookup.sumLong(Func<Grouping<TKey,TValue>,Long> selector)
           
 long BasicDictionary.sumLong(Func<Map.Entry<TKey,TValue>,Long> selector)
           
 long Enumerable.sumLong(Func<T,Long> selector)
           
 long BasicOrderedEnumerable.sumLong(Func<T,Long> selector)
           
 long BasicEnumerableList.sumLong(Func<T,Long> selector)
           
 long BasicEnumerable.sumLong(Func<T,Long> selector)
           
 Enumerable<Grouping<TKey,TValue>> BasicLookup.takeWhile(Func<Grouping<TKey,TValue>,Boolean> predicate)
           
 Enumerable<Map.Entry<TKey,TValue>> BasicDictionary.takeWhile(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
           
 Enumerable<T> Enumerable.takeWhile(Func<T,Boolean> predicate)
           
 Enumerable<T> BasicOrderedEnumerable.takeWhile(Func<T,Boolean> predicate)
           
 Enumerable<T> BasicEnumerableList.takeWhile(Func<T,Boolean> predicate)
           
 Enumerable<T> BasicEnumerable.takeWhile(Func<T,Boolean> predicate)
           
<K> OrderedEnumerable<T>
OrderedEnumerable.thenBy(Func<T,K> keySelector)
           
<K> OrderedEnumerable<T>
BasicOrderedEnumerable.thenBy(Func<T,K> keySelector)
           
<K> OrderedEnumerable<T>
OrderedEnumerable.thenBy(Func<T,K> keySelector, Comparator<K> comparator)
           
<K> OrderedEnumerable<T>
BasicOrderedEnumerable.thenBy(Func<T,K> keySelector, Comparator<K> comparator)
           
<K> OrderedEnumerable<T>
OrderedEnumerable.thenByDescending(Func<T,K> keySelector)
           
<K> OrderedEnumerable<T>
BasicOrderedEnumerable.thenByDescending(Func<T,K> keySelector)
           
<K> OrderedEnumerable<T>
OrderedEnumerable.thenByDescending(Func<T,K> keySelector, Comparator<K> comparator)
           
<K> OrderedEnumerable<T>
BasicOrderedEnumerable.thenByDescending(Func<T,K> keySelector, Comparator<K> comparator)
           
<K> Dictionary<K,Grouping<TKey,TValue>>
BasicLookup.toDictionary(Func<Grouping<TKey,TValue>,K> keySelector)
           
<K,E> Dictionary<K,E>
BasicLookup.toDictionary(Func<Grouping<TKey,TValue>,K> keySelector, Func<Grouping<TKey,TValue>,E> elementSelector)
           
<K,E> Dictionary<K,E>
BasicLookup.toDictionary(Func<Grouping<TKey,TValue>,K> keySelector, Func<Grouping<TKey,TValue>,E> elementSelector)
           
<K> Dictionary<K,Map.Entry<TKey,TValue>>
BasicDictionary.toDictionary(Func<Map.Entry<TKey,TValue>,K> keySelector)
           
<K,E> Dictionary<K,E>
BasicDictionary.toDictionary(Func<Map.Entry<TKey,TValue>,K> keySelector, Func<Map.Entry<TKey,TValue>,E> elementSelector)
           
<K,E> Dictionary<K,E>
BasicDictionary.toDictionary(Func<Map.Entry<TKey,TValue>,K> keySelector, Func<Map.Entry<TKey,TValue>,E> elementSelector)
           
<K> Dictionary<K,T>
Enumerable.toDictionary(Func<T,K> keySelector)
           
<K> Dictionary<K,T>
BasicOrderedEnumerable.toDictionary(Func<T,K> keySelector)
           
<K> Dictionary<K,T>
BasicEnumerableList.toDictionary(Func<T,K> keySelector)
           
<K> Dictionary<K,T>
BasicEnumerable.toDictionary(Func<T,K> keySelector)
           
<K,E> Dictionary<K,E>
Enumerable.toDictionary(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Dictionary<K,E>
Enumerable.toDictionary(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Dictionary<K,E>
BasicOrderedEnumerable.toDictionary(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Dictionary<K,E>
BasicOrderedEnumerable.toDictionary(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Dictionary<K,E>
BasicEnumerableList.toDictionary(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Dictionary<K,E>
BasicEnumerableList.toDictionary(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Dictionary<K,E>
BasicEnumerable.toDictionary(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Dictionary<K,E>
BasicEnumerable.toDictionary(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K> Map<K,List<Grouping<TKey,TValue>>>
BasicLookup.toListMap(Func<Grouping<TKey,TValue>,K> keySelector)
           
<K,E> Map<K,List<E>>
BasicLookup.toListMap(Func<Grouping<TKey,TValue>,K> keySelector, Func<Grouping<TKey,TValue>,E> elementSelector)
           
<K,E> Map<K,List<E>>
BasicLookup.toListMap(Func<Grouping<TKey,TValue>,K> keySelector, Func<Grouping<TKey,TValue>,E> elementSelector)
           
<K> Map<K,List<Map.Entry<TKey,TValue>>>
BasicDictionary.toListMap(Func<Map.Entry<TKey,TValue>,K> keySelector)
           
<K,E> Map<K,List<E>>
BasicDictionary.toListMap(Func<Map.Entry<TKey,TValue>,K> keySelector, Func<Map.Entry<TKey,TValue>,E> elementSelector)
           
<K,E> Map<K,List<E>>
BasicDictionary.toListMap(Func<Map.Entry<TKey,TValue>,K> keySelector, Func<Map.Entry<TKey,TValue>,E> elementSelector)
           
<K> Map<K,List<T>>
Enumerable.toListMap(Func<T,K> keySelector)
           
<K> Map<K,List<T>>
BasicOrderedEnumerable.toListMap(Func<T,K> keySelector)
           
<K> Map<K,List<T>>
BasicEnumerableList.toListMap(Func<T,K> keySelector)
           
<K> Map<K,List<T>>
BasicEnumerable.toListMap(Func<T,K> keySelector)
           
<K,E> Map<K,List<E>>
Enumerable.toListMap(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Map<K,List<E>>
Enumerable.toListMap(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Map<K,List<E>>
BasicOrderedEnumerable.toListMap(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Map<K,List<E>>
BasicOrderedEnumerable.toListMap(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Map<K,List<E>>
BasicEnumerableList.toListMap(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Map<K,List<E>>
BasicEnumerableList.toListMap(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Map<K,List<E>>
BasicEnumerable.toListMap(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Map<K,List<E>>
BasicEnumerable.toListMap(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K> Lookup<K,Grouping<TKey,TValue>>
BasicLookup.toLookup(Func<Grouping<TKey,TValue>,K> keySelector)
           
<K,E> Lookup<K,E>
BasicLookup.toLookup(Func<Grouping<TKey,TValue>,K> keySelector, Func<Grouping<TKey,TValue>,E> elementSelector)
           
<K,E> Lookup<K,E>
BasicLookup.toLookup(Func<Grouping<TKey,TValue>,K> keySelector, Func<Grouping<TKey,TValue>,E> elementSelector)
           
<K> Lookup<K,Map.Entry<TKey,TValue>>
BasicDictionary.toLookup(Func<Map.Entry<TKey,TValue>,K> keySelector)
           
<K,E> Lookup<K,E>
BasicDictionary.toLookup(Func<Map.Entry<TKey,TValue>,K> keySelector, Func<Map.Entry<TKey,TValue>,E> elementSelector)
           
<K,E> Lookup<K,E>
BasicDictionary.toLookup(Func<Map.Entry<TKey,TValue>,K> keySelector, Func<Map.Entry<TKey,TValue>,E> elementSelector)
           
<K> Lookup<K,T>
Enumerable.toLookup(Func<T,K> keySelector)
           
<K> Lookup<K,T>
BasicOrderedEnumerable.toLookup(Func<T,K> keySelector)
           
<K> Lookup<K,T>
BasicEnumerableList.toLookup(Func<T,K> keySelector)
           
<K> Lookup<K,T>
BasicEnumerable.toLookup(Func<T,K> keySelector)
           
<K,E> Lookup<K,E>
Enumerable.toLookup(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Lookup<K,E>
Enumerable.toLookup(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Lookup<K,E>
BasicOrderedEnumerable.toLookup(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Lookup<K,E>
BasicOrderedEnumerable.toLookup(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Lookup<K,E>
BasicEnumerableList.toLookup(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Lookup<K,E>
BasicEnumerableList.toLookup(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Lookup<K,E>
BasicEnumerable.toLookup(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Lookup<K,E>
BasicEnumerable.toLookup(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K> Map<K,Grouping<TKey,TValue>>
BasicLookup.toMap(Func<Grouping<TKey,TValue>,K> keySelector)
           
<K,E> Map<K,E>
BasicLookup.toMap(Func<Grouping<TKey,TValue>,K> keySelector, Func<Grouping<TKey,TValue>,E> elementSelector)
           
<K,E> Map<K,E>
BasicLookup.toMap(Func<Grouping<TKey,TValue>,K> keySelector, Func<Grouping<TKey,TValue>,E> elementSelector)
           
<K> Map<K,Map.Entry<TKey,TValue>>
BasicDictionary.toMap(Func<Map.Entry<TKey,TValue>,K> keySelector)
           
<K,E> Map<K,E>
BasicDictionary.toMap(Func<Map.Entry<TKey,TValue>,K> keySelector, Func<Map.Entry<TKey,TValue>,E> elementSelector)
           
<K,E> Map<K,E>
BasicDictionary.toMap(Func<Map.Entry<TKey,TValue>,K> keySelector, Func<Map.Entry<TKey,TValue>,E> elementSelector)
           
<K> Map<K,T>
Enumerable.toMap(Func<T,K> keySelector)
           
<K> Map<K,T>
BasicOrderedEnumerable.toMap(Func<T,K> keySelector)
           
<K> Map<K,T>
BasicEnumerableList.toMap(Func<T,K> keySelector)
           
<K> Map<K,T>
BasicEnumerable.toMap(Func<T,K> keySelector)
           
<K,E> Map<K,E>
Enumerable.toMap(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Map<K,E>
Enumerable.toMap(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Map<K,E>
BasicOrderedEnumerable.toMap(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Map<K,E>
BasicOrderedEnumerable.toMap(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Map<K,E>
BasicEnumerableList.toMap(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Map<K,E>
BasicEnumerableList.toMap(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Map<K,E>
BasicEnumerable.toMap(Func<T,K> keySelector, Func<T,E> elementSelector)
           
<K,E> Map<K,E>
BasicEnumerable.toMap(Func<T,K> keySelector, Func<T,E> elementSelector)
           
 Enumerable<Grouping<TKey,TValue>> BasicLookup.where(Func<Grouping<TKey,TValue>,Boolean> predicate)
           
 Enumerable<Map.Entry<TKey,TValue>> BasicDictionary.where(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
           
 Enumerable<T> Enumerable.where(Func<T,Boolean> predicate)
           
 Enumerable<T> BasicOrderedEnumerable.where(Func<T,Boolean> predicate)
           
 Enumerable<T> BasicEnumerableList.where(Func<T,Boolean> predicate)
           
 Enumerable<T> BasicEnumerable.where(Func<T,Boolean> predicate)
           
 

Constructors in sharin.unlinq with parameters of type Func
BasicOrderedEnumerable(Enumerable<T> enumerable, Func<T,K> keySelector, boolean descending)
           
BasicOrderedEnumerable(Enumerable<T> enumerable, Func<T,K> keySelector, boolean descending, Comparator<K> comparator)
           
 



Copyright © 2009 SHU. All Rights Reserved.