Uses of Interface
sharin.unlinq.Enumerable

Packages that use Enumerable
sharin.unlinq   
 

Uses of Enumerable in sharin.unlinq
 

Subinterfaces of Enumerable in sharin.unlinq
 interface Dictionary<K,V>
           
 interface EnumerableList<E>
           
 interface Grouping<K,E>
           
 interface Lookup<K,V>
           
 interface OrderedEnumerable<T>
           
 

Classes in sharin.unlinq that implement Enumerable
 class BasicDictionary<TKey,TValue>
           
 class BasicEnumerable<T>
           
 class BasicEnumerableList<T>
           
 class BasicGrouping<K,E>
           
 class BasicLookup<TKey,TValue>
           
 class BasicOrderedEnumerable<T>
           
 

Methods in sharin.unlinq that return Enumerable
<R> Enumerable<R>
Enumerable.cast(Class<R> resultClass)
           
<R> Enumerable<R>
BasicOrderedEnumerable.cast(Class<R> resultClass)
           
<R> Enumerable<R>
BasicLookup.cast(Class<R> resultClass)
           
<R> Enumerable<R>
BasicEnumerableList.cast(Class<R> resultClass)
           
<R> Enumerable<R>
BasicEnumerable.cast(Class<R> resultClass)
           
<R> Enumerable<R>
BasicDictionary.cast(Class<R> resultClass)
           
 Enumerable<Grouping<TKey,TValue>> BasicLookup.concat(Enumerable<Grouping<TKey,TValue>> second)
           
 Enumerable<Map.Entry<TKey,TValue>> BasicDictionary.concat(Enumerable<Map.Entry<TKey,TValue>> second)
           
 Enumerable<T> Enumerable.concat(Enumerable<T> second)
           
 Enumerable<T> BasicOrderedEnumerable.concat(Enumerable<T> second)
           
 Enumerable<T> BasicEnumerableList.concat(Enumerable<T> second)
           
 Enumerable<T> BasicEnumerable.concat(Enumerable<T> second)
           
 Enumerable<T> Enumerable.defaultIfEmpty()
           
 Enumerable<T> BasicOrderedEnumerable.defaultIfEmpty()
           
 Enumerable<Grouping<TKey,TValue>> BasicLookup.defaultIfEmpty()
           
 Enumerable<T> BasicEnumerableList.defaultIfEmpty()
           
 Enumerable<T> BasicEnumerable.defaultIfEmpty()
           
 Enumerable<Map.Entry<TKey,TValue>> BasicDictionary.defaultIfEmpty()
           
 Enumerable<Grouping<TKey,TValue>> BasicLookup.defaultIfEmpty(Grouping<TKey,TValue> defaultValue)
           
 Enumerable<Map.Entry<TKey,TValue>> BasicDictionary.defaultIfEmpty(Map.Entry<TKey,TValue> defaultValue)
           
 Enumerable<T> Enumerable.defaultIfEmpty(T defaultValue)
           
 Enumerable<T> BasicOrderedEnumerable.defaultIfEmpty(T defaultValue)
           
 Enumerable<T> BasicEnumerableList.defaultIfEmpty(T defaultValue)
           
 Enumerable<T> BasicEnumerable.defaultIfEmpty(T defaultValue)
           
 Enumerable<T> Enumerable.distinct()
           
 Enumerable<T> BasicOrderedEnumerable.distinct()
           
 Enumerable<Grouping<TKey,TValue>> BasicLookup.distinct()
           
 Enumerable<T> BasicEnumerableList.distinct()
           
 Enumerable<T> BasicEnumerable.distinct()
           
 Enumerable<Map.Entry<TKey,TValue>> BasicDictionary.distinct()
           
static
<R> Enumerable<R>
BasicEnumerable.empty()
           
 Enumerable<Grouping<TKey,TValue>> BasicLookup.except(Enumerable<Grouping<TKey,TValue>> second)
           
 Enumerable<Map.Entry<TKey,TValue>> BasicDictionary.except(Enumerable<Map.Entry<TKey,TValue>> second)
           
 Enumerable<T> Enumerable.except(Enumerable<T> second)
           
 Enumerable<T> BasicOrderedEnumerable.except(Enumerable<T> second)
           
 Enumerable<T> BasicEnumerableList.except(Enumerable<T> second)
           
 Enumerable<T> BasicEnumerable.except(Enumerable<T> second)
           
static
<E> Enumerable<E>
BasicEnumerable.from(E... objects)
           
static Enumerable<Integer> BasicEnumerable.from(int... values)
           
static
<E> Enumerable<E>
BasicEnumerable.from(Iterable<E> iterable)
           
static Enumerable<Boolean> BasicEnumerable.fromBoolean(boolean... values)
           
static Enumerable<Byte> BasicEnumerable.fromByte(byte... values)
           
static Enumerable<Character> BasicEnumerable.fromChar(char... values)
           
static Enumerable<Double> BasicEnumerable.fromDouble(double... values)
           
static Enumerable<Float> BasicEnumerable.fromFloat(float... values)
           
static Enumerable<Long> BasicEnumerable.fromLong(long... values)
           
static Enumerable<Short> BasicEnumerable.fromShort(short... values)
           
<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,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,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>>
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>>
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>
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>
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>
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>
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>
BasicEnumerable.groupJoin(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,Enumerable<I>,R> resultSelector)
           
 Enumerable<Grouping<TKey,TValue>> BasicLookup.intersect(Enumerable<Grouping<TKey,TValue>> second)
           
 Enumerable<Map.Entry<TKey,TValue>> BasicDictionary.intersect(Enumerable<Map.Entry<TKey,TValue>> second)
           
 Enumerable<T> Enumerable.intersect(Enumerable<T> second)
           
 Enumerable<T> BasicOrderedEnumerable.intersect(Enumerable<T> second)
           
 Enumerable<T> BasicEnumerableList.intersect(Enumerable<T> second)
           
 Enumerable<T> BasicEnumerable.intersect(Enumerable<T> second)
           
<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>
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>
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)
           
<R> Enumerable<R>
Enumerable.ofType(Class<R> resultClass)
           
<R> Enumerable<R>
BasicOrderedEnumerable.ofType(Class<R> resultClass)
           
<R> Enumerable<R>
BasicLookup.ofType(Class<R> resultClass)
           
<R> Enumerable<R>
BasicEnumerableList.ofType(Class<R> resultClass)
           
<R> Enumerable<R>
BasicEnumerable.ofType(Class<R> resultClass)
           
<R> Enumerable<R>
BasicDictionary.ofType(Class<R> resultClass)
           
static Enumerable<Integer> BasicEnumerable.range(int start, int count)
           
static
<R> Enumerable<R>
BasicEnumerable.repeat(R element, int count)
           
 Enumerable<T> Enumerable.reverse()
           
 Enumerable<T> BasicOrderedEnumerable.reverse()
           
 Enumerable<Grouping<TKey,TValue>> BasicLookup.reverse()
           
 Enumerable<T> BasicEnumerableList.reverse()
           
 Enumerable<T> BasicEnumerable.reverse()
           
 Enumerable<Map.Entry<TKey,TValue>> BasicDictionary.reverse()
           
<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)
           
<R> Enumerable<R>
BasicLookup.select(Func2<Grouping<TKey,TValue>,Integer,R> selector)
           
<R> Enumerable<R>
BasicDictionary.select(Func2<Map.Entry<TKey,TValue>,Integer,R> selector)
           
<R> Enumerable<R>
Enumerable.select(Func2<T,Integer,R> selector)
           
<R> Enumerable<R>
BasicOrderedEnumerable.select(Func2<T,Integer,R> selector)
           
<R> Enumerable<R>
BasicEnumerableList.select(Func2<T,Integer,R> selector)
           
<R> Enumerable<R>
BasicEnumerable.select(Func2<T,Integer,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)
           
<C,R> Enumerable<R>
BasicLookup.selectMany(Func2<Grouping<TKey,TValue>,Integer,Enumerable<C>> collectionSelector, Func2<Grouping<TKey,TValue>,C,R> resultSelector)
           
<R> Enumerable<R>
BasicLookup.selectMany(Func2<Grouping<TKey,TValue>,Integer,Enumerable<R>> selector)
           
<C,R> Enumerable<R>
BasicDictionary.selectMany(Func2<Map.Entry<TKey,TValue>,Integer,Enumerable<C>> collectionSelector, Func2<Map.Entry<TKey,TValue>,C,R> resultSelector)
           
<R> Enumerable<R>
BasicDictionary.selectMany(Func2<Map.Entry<TKey,TValue>,Integer,Enumerable<R>> selector)
           
<C,R> Enumerable<R>
Enumerable.selectMany(Func2<T,Integer,Enumerable<C>> collectionSelector, Func2<T,C,R> resultSelector)
           
<C,R> Enumerable<R>
BasicOrderedEnumerable.selectMany(Func2<T,Integer,Enumerable<C>> collectionSelector, Func2<T,C,R> resultSelector)
           
<C,R> Enumerable<R>
BasicEnumerableList.selectMany(Func2<T,Integer,Enumerable<C>> collectionSelector, Func2<T,C,R> resultSelector)
           
<C,R> Enumerable<R>
BasicEnumerable.selectMany(Func2<T,Integer,Enumerable<C>> collectionSelector, Func2<T,C,R> resultSelector)
           
<R> Enumerable<R>
Enumerable.selectMany(Func2<T,Integer,Enumerable<R>> selector)
           
<R> Enumerable<R>
BasicOrderedEnumerable.selectMany(Func2<T,Integer,Enumerable<R>> selector)
           
<R> Enumerable<R>
BasicEnumerableList.selectMany(Func2<T,Integer,Enumerable<R>> selector)
           
<R> Enumerable<R>
BasicEnumerable.selectMany(Func2<T,Integer,Enumerable<R>> selector)
           
 Enumerable<T> Enumerable.skip(int count)
           
 Enumerable<T> BasicOrderedEnumerable.skip(int count)
           
 Enumerable<Grouping<TKey,TValue>> BasicLookup.skip(int count)
           
 Enumerable<T> BasicEnumerableList.skip(int count)
           
 Enumerable<T> BasicEnumerable.skip(int count)
           
 Enumerable<Map.Entry<TKey,TValue>> BasicDictionary.skip(int count)
           
 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)
           
 Enumerable<Grouping<TKey,TValue>> BasicLookup.skipWhile(Func2<Grouping<TKey,TValue>,Integer,Boolean> predicate)
           
 Enumerable<Map.Entry<TKey,TValue>> BasicDictionary.skipWhile(Func2<Map.Entry<TKey,TValue>,Integer,Boolean> predicate)
           
 Enumerable<T> Enumerable.skipWhile(Func2<T,Integer,Boolean> predicate)
           
 Enumerable<T> BasicOrderedEnumerable.skipWhile(Func2<T,Integer,Boolean> predicate)
           
 Enumerable<T> BasicEnumerableList.skipWhile(Func2<T,Integer,Boolean> predicate)
           
 Enumerable<T> BasicEnumerable.skipWhile(Func2<T,Integer,Boolean> predicate)
           
 Enumerable<T> Enumerable.take(int count)
           
 Enumerable<T> BasicOrderedEnumerable.take(int count)
           
 Enumerable<Grouping<TKey,TValue>> BasicLookup.take(int count)
           
 Enumerable<T> BasicEnumerableList.take(int count)
           
 Enumerable<T> BasicEnumerable.take(int count)
           
 Enumerable<Map.Entry<TKey,TValue>> BasicDictionary.take(int count)
           
 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)
           
 Enumerable<Grouping<TKey,TValue>> BasicLookup.takeWhile(Func2<Grouping<TKey,TValue>,Integer,Boolean> predicate)
           
 Enumerable<Map.Entry<TKey,TValue>> BasicDictionary.takeWhile(Func2<Map.Entry<TKey,TValue>,Integer,Boolean> predicate)
           
 Enumerable<T> Enumerable.takeWhile(Func2<T,Integer,Boolean> predicate)
           
 Enumerable<T> BasicOrderedEnumerable.takeWhile(Func2<T,Integer,Boolean> predicate)
           
 Enumerable<T> BasicEnumerableList.takeWhile(Func2<T,Integer,Boolean> predicate)
           
 Enumerable<T> BasicEnumerable.takeWhile(Func2<T,Integer,Boolean> predicate)
           
 Enumerable<Grouping<TKey,TValue>> BasicLookup.union(Enumerable<Grouping<TKey,TValue>> second)
           
 Enumerable<Map.Entry<TKey,TValue>> BasicDictionary.union(Enumerable<Map.Entry<TKey,TValue>> second)
           
 Enumerable<T> Enumerable.union(Enumerable<T> second)
           
 Enumerable<T> BasicOrderedEnumerable.union(Enumerable<T> second)
           
 Enumerable<T> BasicEnumerableList.union(Enumerable<T> second)
           
 Enumerable<T> BasicEnumerable.union(Enumerable<T> second)
           
 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)
           
 Enumerable<Grouping<TKey,TValue>> BasicLookup.where(Func2<Grouping<TKey,TValue>,Integer,Boolean> predicate)
           
 Enumerable<Map.Entry<TKey,TValue>> BasicDictionary.where(Func2<Map.Entry<TKey,TValue>,Integer,Boolean> predicate)
           
 Enumerable<T> Enumerable.where(Func2<T,Integer,Boolean> predicate)
           
 Enumerable<T> BasicOrderedEnumerable.where(Func2<T,Integer,Boolean> predicate)
           
 Enumerable<T> BasicEnumerableList.where(Func2<T,Integer,Boolean> predicate)
           
 Enumerable<T> BasicEnumerable.where(Func2<T,Integer,Boolean> predicate)
           
 

Methods in sharin.unlinq with parameters of type Enumerable
 Enumerable<Grouping<TKey,TValue>> BasicLookup.concat(Enumerable<Grouping<TKey,TValue>> second)
           
 Enumerable<Map.Entry<TKey,TValue>> BasicDictionary.concat(Enumerable<Map.Entry<TKey,TValue>> second)
           
 Enumerable<T> Enumerable.concat(Enumerable<T> second)
           
 Enumerable<T> BasicOrderedEnumerable.concat(Enumerable<T> second)
           
 Enumerable<T> BasicEnumerableList.concat(Enumerable<T> second)
           
 Enumerable<T> BasicEnumerable.concat(Enumerable<T> second)
           
 Enumerable<Grouping<TKey,TValue>> BasicLookup.except(Enumerable<Grouping<TKey,TValue>> second)
           
 Enumerable<Map.Entry<TKey,TValue>> BasicDictionary.except(Enumerable<Map.Entry<TKey,TValue>> second)
           
 Enumerable<T> Enumerable.except(Enumerable<T> second)
           
 Enumerable<T> BasicOrderedEnumerable.except(Enumerable<T> second)
           
 Enumerable<T> BasicEnumerableList.except(Enumerable<T> second)
           
 Enumerable<T> BasicEnumerable.except(Enumerable<T> second)
           
<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>
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>
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)
           
 Enumerable<Grouping<TKey,TValue>> BasicLookup.intersect(Enumerable<Grouping<TKey,TValue>> second)
           
 Enumerable<Map.Entry<TKey,TValue>> BasicDictionary.intersect(Enumerable<Map.Entry<TKey,TValue>> second)
           
 Enumerable<T> Enumerable.intersect(Enumerable<T> second)
           
 Enumerable<T> BasicOrderedEnumerable.intersect(Enumerable<T> second)
           
 Enumerable<T> BasicEnumerableList.intersect(Enumerable<T> second)
           
 Enumerable<T> BasicEnumerable.intersect(Enumerable<T> second)
           
<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>
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>
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)
           
 Boolean BasicLookup.sequenceEqual(Enumerable<Grouping<TKey,TValue>> second)
           
 Boolean BasicDictionary.sequenceEqual(Enumerable<Map.Entry<TKey,TValue>> second)
           
 Boolean Enumerable.sequenceEqual(Enumerable<T> second)
           
 Boolean BasicOrderedEnumerable.sequenceEqual(Enumerable<T> second)
           
 Boolean BasicEnumerableList.sequenceEqual(Enumerable<T> second)
           
 Boolean BasicEnumerable.sequenceEqual(Enumerable<T> second)
           
 Enumerable<Grouping<TKey,TValue>> BasicLookup.union(Enumerable<Grouping<TKey,TValue>> second)
           
 Enumerable<Map.Entry<TKey,TValue>> BasicDictionary.union(Enumerable<Map.Entry<TKey,TValue>> second)
           
 Enumerable<T> Enumerable.union(Enumerable<T> second)
           
 Enumerable<T> BasicOrderedEnumerable.union(Enumerable<T> second)
           
 Enumerable<T> BasicEnumerableList.union(Enumerable<T> second)
           
 Enumerable<T> BasicEnumerable.union(Enumerable<T> second)
           
 

Method parameters in sharin.unlinq with type arguments of type Enumerable
<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,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,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>
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,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>
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>
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>
BasicEnumerable.groupJoin(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,Enumerable<I>,R> resultSelector)
           
<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)
           
<C,R> Enumerable<R>
BasicLookup.selectMany(Func2<Grouping<TKey,TValue>,Integer,Enumerable<C>> collectionSelector, Func2<Grouping<TKey,TValue>,C,R> resultSelector)
           
<R> Enumerable<R>
BasicLookup.selectMany(Func2<Grouping<TKey,TValue>,Integer,Enumerable<R>> selector)
           
<C,R> Enumerable<R>
BasicDictionary.selectMany(Func2<Map.Entry<TKey,TValue>,Integer,Enumerable<C>> collectionSelector, Func2<Map.Entry<TKey,TValue>,C,R> resultSelector)
           
<R> Enumerable<R>
BasicDictionary.selectMany(Func2<Map.Entry<TKey,TValue>,Integer,Enumerable<R>> selector)
           
<C,R> Enumerable<R>
Enumerable.selectMany(Func2<T,Integer,Enumerable<C>> collectionSelector, Func2<T,C,R> resultSelector)
           
<C,R> Enumerable<R>
BasicOrderedEnumerable.selectMany(Func2<T,Integer,Enumerable<C>> collectionSelector, Func2<T,C,R> resultSelector)
           
<C,R> Enumerable<R>
BasicEnumerableList.selectMany(Func2<T,Integer,Enumerable<C>> collectionSelector, Func2<T,C,R> resultSelector)
           
<C,R> Enumerable<R>
BasicEnumerable.selectMany(Func2<T,Integer,Enumerable<C>> collectionSelector, Func2<T,C,R> resultSelector)
           
<R> Enumerable<R>
Enumerable.selectMany(Func2<T,Integer,Enumerable<R>> selector)
           
<R> Enumerable<R>
BasicOrderedEnumerable.selectMany(Func2<T,Integer,Enumerable<R>> selector)
           
<R> Enumerable<R>
BasicEnumerableList.selectMany(Func2<T,Integer,Enumerable<R>> selector)
           
<R> Enumerable<R>
BasicEnumerable.selectMany(Func2<T,Integer,Enumerable<R>> selector)
           
 

Constructors in sharin.unlinq with parameters of type Enumerable
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.