CSharpx.EnumerableExtensions Class Reference

Classes
class	MaterializedEnumerable

Static Public Member Functions
static IEnumerable< TResult >	Cartesian< TFirst, TSecond, TResult > (this IEnumerable< TFirst > first, IEnumerable< TSecond > second, Func< TFirst, TSecond, TResult > resultSelector)
	Returns the Cartesian product of two sequences by combining each element of the first set with each in the second and applying the user=define projection to the pair.
static IEnumerable< TSource >	Prepend< TSource > (this IEnumerable< TSource > source, TSource value)
	Prepends a single value to a sequence.
static IEnumerable< T >	Concat< T > (this T head, IEnumerable< T > tail)
	Returns a sequence consisting of the head element and the given tail elements.
static IEnumerable< T >	Concat< T > (this IEnumerable< T > head, T tail)
	Returns a sequence consisting of the head elements and the given tail element.
static IEnumerable< T >	Exclude< T > (this IEnumerable< T > sequence, int startIndex, int count)
	Excludes count elements from a sequence starting at a given index.
static IEnumerable< KeyValuePair< int, TSource > >	Index< TSource > (this IEnumerable< TSource > source)
	Returns a sequence of KeyValuePair<TKey,TValue> where the key is the zero-based index of the value in the source sequence.
static IEnumerable< KeyValuePair< int, TSource > >	Index< TSource > (this IEnumerable< TSource > source, int startIndex)
	Returns a sequence of KeyValuePair<TKey,TValue> where the key is the index of the value in the source sequence. An additional parameter specifies the starting index.
static TResult	Fold< T, TResult > (this IEnumerable< T > source, Func< T, TResult > folder)
	Returns the result of applying a function to a sequence of 1 element.
static TResult	Fold< T, TResult > (this IEnumerable< T > source, Func< T, T, TResult > folder)
	Returns the result of applying a function to a sequence of 2 elements.
static TResult	Fold< T, TResult > (this IEnumerable< T > source, Func< T, T, T, TResult > folder)
	Returns the result of applying a function to a sequence of 3 elements.
static TResult	Fold< T, TResult > (this IEnumerable< T > source, Func< T, T, T, T, TResult > folder)
	Returns the result of applying a function to a sequence of 4 elements.
static void	ForEach< T > (this IEnumerable< T > source, Action< T > action)
	Immediately executes the given action on each element in the source sequence.
static IEnumerable< TResult >	Pairwise< TSource, TResult > (this IEnumerable< TSource > source, Func< TSource, TSource, TResult > resultSelector)
	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.
static string	ToDelimitedString< TSource > (this IEnumerable< TSource > source)
	Creates a delimited string from a sequence of values. The delimiter used depends on the current culture of the executing thread.
static string	ToDelimitedString< TSource > (this IEnumerable< TSource > source, string delimiter)
	Creates a delimited string from a sequence of values and a given delimiter.
static IEnumerable< T >	Tail< T > (this IEnumerable< T > source)
	Return everything except first element and throws exception if empty.
static IEnumerable< T >	TailNoFail< T > (this IEnumerable< T > source)
	Return everything except first element without throwing exception if empty.
static IEnumerable< T >	Memoize< T > (this IEnumerable< T > source)
	Captures current state of a sequence.
static IEnumerable< T >	Materialize< T > (this IEnumerable< T > source)
	Creates an immutable copy of a sequence.
static T	Choice< T > (this IEnumerable< T > source)
	Selects a random element.
static IEnumerable< T >	Intersperse< T > (this IEnumerable< T > source, T element)
	Takes an element and a sequence and ‘intersperses’ that element between its elements.
static IEnumerable< T >	FlattenOnce< T > (this IEnumerable< IEnumerable< T > > source)
	Flattens a sequence by one level.
static IEnumerable< string >	FlattenOnce (this IEnumerable< string > source)
	Reduces a sequence of strings to a sequence of parts, splitted by space, of each original string.
static Maybe< T >	TryHead< T > (this IEnumerable< T > source)
	Safe function that returns Just(first element) or None.
static Maybe< IEnumerable< T > >	ToMaybe< T > (this IEnumerable< T > source)
	Turns an empty sequence to Nothing, otherwise Just(sequence).

Static Private Member Functions
static IEnumerable< TSource >	AssertCountImpl< TSource > (IEnumerable< TSource > source, int count, Func< int, int, Exception > errorSelector)
static IEnumerable< TSource >	ExpectingCountYieldingImpl< TSource > (IEnumerable< TSource > source, int count, Func< int, int, Exception > errorSelector)
static IEnumerable< T >	ExcludeImpl< T > (IEnumerable< T > sequence, int startIndex, int count)
static TResult	FoldImpl< T, TResult > (IEnumerable< T > source, int count, Func< T, TResult > folder1, Func< T, T, TResult > folder2, Func< T, T, T, TResult > folder3, Func< T, T, T, T, TResult > folder4)
static Exception	OnFolderSourceSizeError (int cmp, int count)
static IEnumerable< TResult >	PairwiseImpl< TSource, TResult > (this IEnumerable< TSource > source, Func< TSource, TSource, TResult > resultSelector)
static string	ToDelimitedStringImpl< T > (IEnumerable< T > source, string delimiter, Func< StringBuilder, T, StringBuilder > append)

Static Private Attributes
static readonly Func< int, int, Exception >	OnFolderSourceSizeErrorSelector = OnFolderSourceSizeError

Detailed Description

Definition at line 20 of file EnumerableExtensions.cs.

Member Function Documentation

AssertCountImpl< TSource >()

static IEnumerable< TSource > CSharpx.EnumerableExtensions.AssertCountImpl< TSource > ( IEnumerable< TSource >  source, int  count, Func< int, int, Exception >  errorSelector  )

staticprivate

Definition at line 24 of file EnumerableExtensions.cs.

        {
            ICollection<TSource> collection = source as ICollection<TSource>; // Optimization for collections
 
            if (collection != null)
            {
                if (collection.Count != count)
                {
                    throw errorSelector(collection.Count.CompareTo(count), count);
                }
 
                return source;
            }
 
            return ExpectingCountYieldingImpl(source, count, errorSelector);
        }

Cartesian< TFirst, TSecond, TResult >()

static IEnumerable< TResult > CSharpx.EnumerableExtensions.Cartesian< TFirst, TSecond, TResult > ( this IEnumerable< TFirst >  first, IEnumerable< TSecond >  second, Func< TFirst, TSecond, TResult >  resultSelector  )

static

Returns the Cartesian product of two sequences by combining each element of the first set with each in the second and applying the user=define projection to the pair.

Definition at line 71 of file EnumerableExtensions.cs.

        {
            if (first == null)
            {
                throw new ArgumentNullException(nameof(first));
            }
 
            if (second == null)
            {
                throw new ArgumentNullException(nameof(second));
            }
 
            if (resultSelector == null)
            {
                throw new ArgumentNullException(nameof(resultSelector));
            }
 
            return from element1 in first
                   from element2 in second // TODO buffer to avoid multiple enumerations
                   select resultSelector(element1, element2);
        }

Choice< T >()

static T CSharpx.EnumerableExtensions.Choice< T > ( this IEnumerable< T >  source )

static

Selects a random element.

Definition at line 478 of file EnumerableExtensions.cs.

        {
#if CSX_REM_CRYPTORAND
            int index = new Random().Next(source.Count() - 1);
#else
            var index = new CryptoRandom().Next(source.Count() - 1);
#endif
            return source.ElementAt(index);
        }

Concat< T >() [1/2]

static IEnumerable< T > CSharpx.EnumerableExtensions.Concat< T > ( this IEnumerable< T >  head, T  tail  )

static

Returns a sequence consisting of the head elements and the given tail element.

Definition at line 126 of file EnumerableExtensions.cs.

        {
            if (head == null)
            {
                throw new ArgumentNullException(nameof(head));
            }
 
            return head.Concat(LinqEnumerable.Repeat(tail, 1));
        }

Concat< T >() [2/2]

static IEnumerable< T > CSharpx.EnumerableExtensions.Concat< T > ( this T  head, IEnumerable< T >  tail  )

static

Returns a sequence consisting of the head element and the given tail elements.

Definition at line 113 of file EnumerableExtensions.cs.

        {
            if (tail == null)
            {
                throw new ArgumentNullException(nameof(tail));
            }
 
            return tail.Prepend(head);
        }

Exclude< T >()

static IEnumerable< T > CSharpx.EnumerableExtensions.Exclude< T > ( this IEnumerable< T >  sequence, int  startIndex, int  count  )

static

Excludes count elements from a sequence starting at a given index.

Template Parameters

T	The type of the elements of the sequence

Definition at line 140 of file EnumerableExtensions.cs.

        {
            if (sequence == null)
            {
                throw new ArgumentNullException(nameof(sequence));
            }
 
            if (startIndex < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(startIndex));
            }
 
            if (count < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(count));
            }
 
            return ExcludeImpl(sequence, startIndex, count);
        }

ExcludeImpl< T >()

static IEnumerable< T > CSharpx.EnumerableExtensions.ExcludeImpl< T > ( IEnumerable< T >  sequence, int  startIndex, int  count  )

staticprivate

Definition at line 160 of file EnumerableExtensions.cs.

        {
            int index = -1;
            int endIndex = startIndex + count;
 
            using (IEnumerator<T> iter = sequence.GetEnumerator())
            {
                // yield the first part of the sequence
                while (iter.MoveNext() && ++index < startIndex)
                {
                    yield return iter.Current;
                }
 
                // skip the next part (up to count elements)
                while (++index < endIndex && iter.MoveNext()) { }
 
                // yield the remainder of the sequence
                while (iter.MoveNext())
                {
                    yield return iter.Current;
                }
            }
        }

ExpectingCountYieldingImpl< TSource >()

static IEnumerable< TSource > CSharpx.EnumerableExtensions.ExpectingCountYieldingImpl< TSource > ( IEnumerable< TSource >  source, int  count, Func< int, int, Exception >  errorSelector  )

staticprivate

Definition at line 43 of file EnumerableExtensions.cs.

        {
            int iterations = 0;
 
            foreach (TSource element in source)
            {
                iterations++;
 
                if (iterations > count)
                {
                    throw errorSelector(1, count);
                }
 
                yield return element;
            }
 
            if (iterations != count)
            {
                throw errorSelector(-1, count);
            }
        }

FlattenOnce()

static IEnumerable< string > CSharpx.EnumerableExtensions.FlattenOnce ( this IEnumerable< string >  source )

static

Reduces a sequence of strings to a sequence of parts, splitted by space, of each original string.

Definition at line 530 of file EnumerableExtensions.cs.

        {
            foreach (string element in source)
            {
                string[] parts = element.Split();
 
                foreach (string part in parts)
                {
                    yield return part;
                }
            }
        }

FlattenOnce< T >()

static IEnumerable< T > CSharpx.EnumerableExtensions.FlattenOnce< T > ( this IEnumerable< IEnumerable< T > >  source )

static

Flattens a sequence by one level.

Definition at line 515 of file EnumerableExtensions.cs.

        {
            foreach (IEnumerable<T> element in source)
            {
                foreach (T subelement in element)
                {
                    yield return subelement;
                }
            }
        }

Fold< T, TResult >() [1/4]

static TResult CSharpx.EnumerableExtensions.Fold< T, TResult > ( this IEnumerable< T >  source, Func< T, T, T, T, TResult >  folder  )

static

Returns the result of applying a function to a sequence of 4 elements.

Definition at line 237 of file EnumerableExtensions.cs.

        {
            return FoldImpl(source, 4, null, null, null, folder);
        }

Fold< T, TResult >() [2/4]

static TResult CSharpx.EnumerableExtensions.Fold< T, TResult > ( this IEnumerable< T >  source, Func< T, T, T, TResult >  folder  )

static

Returns the result of applying a function to a sequence of 3 elements.

Definition at line 228 of file EnumerableExtensions.cs.

        {
            return FoldImpl(source, 3, null, null, folder, null);
        }

Fold< T, TResult >() [3/4]

static TResult CSharpx.EnumerableExtensions.Fold< T, TResult > ( this IEnumerable< T >  source, Func< T, T, TResult >  folder  )

static

Returns the result of applying a function to a sequence of 2 elements.

Definition at line 219 of file EnumerableExtensions.cs.

        {
            return FoldImpl(source, 2, null, folder, null, null);
        }

Fold< T, TResult >() [4/4]

static TResult CSharpx.EnumerableExtensions.Fold< T, TResult > ( this IEnumerable< T >  source, Func< T, TResult >  folder  )

static

Returns the result of applying a function to a sequence of 1 element.

Definition at line 210 of file EnumerableExtensions.cs.

        {
            return FoldImpl(source, 1, folder, null, null, null);
        }

FoldImpl< T, TResult >()

static TResult CSharpx.EnumerableExtensions.FoldImpl< T, TResult > ( IEnumerable< T >  source, int  count, Func< T, TResult >  folder1, Func< T, T, TResult >  folder2, Func< T, T, T, TResult >  folder3, Func< T, T, T, T, TResult >  folder4  )

staticprivate

Definition at line 242 of file EnumerableExtensions.cs.

        {
            if (source == null)
            {
                throw new ArgumentNullException(nameof(source));
            }
 
            if ((count == 1 && folder1 == null) ||
                (count == 2 && folder2 == null) ||
                (count == 3 && folder3 == null) ||
                (count == 4 && folder4 == null))
            {
                // ReSharper disable NotResolvedInText
                throw new ArgumentNullException("folder"); // ReSharper restore NotResolvedInText
            }
 
            T[] elements = new T[count];
 
            foreach (KeyValuePair<int, T> e in AssertCountImpl(source.Index(),
                                                               count,
                                                               OnFolderSourceSizeErrorSelector
                                                              ))
            {
                elements[e.Key] = e.Value;
            }
 
            switch (count)
            {
                case 1:
                    return folder1(elements[0]);
                case 2:
                    return folder2(elements[0], elements[1]);
                case 3:
                    return folder3(elements[0], elements[1], elements[2]);
                case 4:
                    return folder4(elements[0], elements[1], elements[2], elements[3]);
                default:
                    throw new NotSupportedException();
            }
        }

ForEach< T >()

static void CSharpx.EnumerableExtensions.ForEach< T > ( this IEnumerable< T >  source, Action< T >  action  )

static

Immediately executes the given action on each element in the source sequence.

Definition at line 300 of file EnumerableExtensions.cs.

        {
            if (source == null)
            {
                throw new ArgumentNullException(nameof(source));
            }
 
            if (action == null)
            {
                throw new ArgumentNullException(nameof(action));
            }
 
            foreach (T element in source)
            {
                action(element);
            }
        }

Index< TSource >() [1/2]

static IEnumerable< KeyValuePair< int, TSource > > CSharpx.EnumerableExtensions.Index< TSource > ( this IEnumerable< TSource >  source )

static

Returns a sequence of KeyValuePair<TKey,TValue> where the key is the zero-based index of the value in the source sequence.

Definition at line 189 of file EnumerableExtensions.cs.

        {
            return source.Index(0);
        }

Index< TSource >() [2/2]

static IEnumerable< KeyValuePair< int, TSource > > CSharpx.EnumerableExtensions.Index< TSource > ( this IEnumerable< TSource >  source, int  startIndex  )

static

Returns a sequence of KeyValuePair<TKey,TValue> where the key is the index of the value in the source sequence. An additional parameter specifies the starting index.

Definition at line 199 of file EnumerableExtensions.cs.

        {
            return source.Select((element, index) => new KeyValuePair<int, TSource>(startIndex + index, element));
        }

Intersperse< T >()

static IEnumerable< T > CSharpx.EnumerableExtensions.Intersperse< T > ( this IEnumerable< T >  source, T  element  )

static

Takes an element and a sequence and ‘intersperses’ that element between its elements.

Definition at line 491 of file EnumerableExtensions.cs.

        {
            if (element == null)
            {
                throw new ArgumentNullException(nameof(element));
            }
 
            int count = source.Count();
            int last = count - 1;
 
            for (int i = 0; i < count; i++)
            {
                yield return source.ElementAt(i);
 
                if (i != last)
                {
                    yield return element;
                }
            }
        }

Materialize< T >()

static IEnumerable< T > CSharpx.EnumerableExtensions.Materialize< T > ( this IEnumerable< T >  source )

static

Creates an immutable copy of a sequence.

Definition at line 463 of file EnumerableExtensions.cs.

        {
            if (source is MaterializedEnumerable<T> ||
                source.GetType()
                      .IsArray)
            {
                return source;
            }
 
            return new MaterializedEnumerable<T>(source);
        }

Memoize< T >()

static IEnumerable< T > CSharpx.EnumerableExtensions.Memoize< T > ( this IEnumerable< T >  source )

static

Captures current state of a sequence.

Definition at line 452 of file EnumerableExtensions.cs.

        {
            return source.GetType()
                         .IsArray
                       ? source
                       : source.ToArray();
        }

OnFolderSourceSizeError()

static Exception CSharpx.EnumerableExtensions.OnFolderSourceSizeError ( int  cmp, int  count  )

staticprivate

Definition at line 288 of file EnumerableExtensions.cs.

        {
            string message = cmp < 0
                                 ? "Sequence contains too few elements when exactly {0} {1} expected"
                                 : "Sequence contains too many elements when exactly {0} {1} expected";
 
            return new Exception(string.Format(message, count.ToString("N0"), count == 1 ? "was" : "were"));
        }

Pairwise< TSource, TResult >()

static IEnumerable< TResult > CSharpx.EnumerableExtensions.Pairwise< TSource, TResult > ( this IEnumerable< TSource >  source, Func< TSource, TSource, TResult >  resultSelector  )

static

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.

Definition at line 324 of file EnumerableExtensions.cs.

        {
            if (source == null)
            {
                throw new ArgumentNullException(nameof(source));
            }
 
            if (resultSelector == null)
            {
                throw new ArgumentNullException(nameof(resultSelector));
            }
 
            return PairwiseImpl(source, resultSelector);
        }

PairwiseImpl< TSource, TResult >()

static IEnumerable< TResult > CSharpx.EnumerableExtensions.PairwiseImpl< TSource, TResult > ( this IEnumerable< TSource >  source, Func< TSource, TSource, TResult >  resultSelector  )

staticprivate

Definition at line 340 of file EnumerableExtensions.cs.

        {
            Debug.Assert(source != null);
            Debug.Assert(resultSelector != null);
 
            using (IEnumerator<TSource> e = source.GetEnumerator())
            {
                if (!e.MoveNext())
                {
                    yield break;
                }
 
                TSource previous = e.Current;
 
                while (e.MoveNext())
                {
                    yield return resultSelector(previous, e.Current);
                    previous = e.Current;
                }
            }
        }

Prepend< TSource >()

static IEnumerable< TSource > CSharpx.EnumerableExtensions.Prepend< TSource > ( this IEnumerable< TSource >  source, TSource  value  )

static

Prepends a single value to a sequence.

Definition at line 99 of file EnumerableExtensions.cs.

        {
            if (source == null)
            {
                throw new ArgumentNullException(nameof(source));
            }
 
            return LinqEnumerable.Repeat(value, 1)
                                 .Concat(source);
        }

Tail< T >()

static IEnumerable< T > CSharpx.EnumerableExtensions.Tail< T > ( this IEnumerable< T >  source )

static

Return everything except first element and throws exception if empty.

Definition at line 414 of file EnumerableExtensions.cs.

        {
            using (IEnumerator<T> e = source.GetEnumerator())
            {
                if (e.MoveNext())
                {
                    while (e.MoveNext())
                    {
                        yield return e.Current;
                    }
                }
                else
                {
                    throw new ArgumentException("Source sequence cannot be empty", nameof(source));
                }
            }
        }

TailNoFail< T >()

static IEnumerable< T > CSharpx.EnumerableExtensions.TailNoFail< T > ( this IEnumerable< T >  source )

static

Return everything except first element without throwing exception if empty.

Definition at line 435 of file EnumerableExtensions.cs.

        {
            using (IEnumerator<T> e = source.GetEnumerator())
            {
                if (e.MoveNext())
                {
                    while (e.MoveNext())
                    {
                        yield return e.Current;
                    }
                }
            }
        }

ToDelimitedString< TSource >() [1/2]

static string CSharpx.EnumerableExtensions.ToDelimitedString< TSource > ( this IEnumerable< TSource >  source )

static

Creates a delimited string from a sequence of values. The delimiter used depends on the current culture of the executing thread.

Definition at line 368 of file EnumerableExtensions.cs.

        {
            return ToDelimitedString(source, null);
        }

ToDelimitedString< TSource >() [2/2]

static string CSharpx.EnumerableExtensions.ToDelimitedString< TSource > ( this IEnumerable< TSource >  source, string  delimiter  )

static

Creates a delimited string from a sequence of values and a given delimiter.

Definition at line 377 of file EnumerableExtensions.cs.

        {
            if (source == null)
            {
                throw new ArgumentNullException(nameof(source));
            }
 
            return ToDelimitedStringImpl(source, delimiter, (sb, e) => sb.Append(e));
        }

ToDelimitedStringImpl< T >()

static string CSharpx.EnumerableExtensions.ToDelimitedStringImpl< T > ( IEnumerable< T >  source, string  delimiter, Func< StringBuilder, T, StringBuilder >  append  )

staticprivate

Definition at line 387 of file EnumerableExtensions.cs.

        {
            Debug.Assert(source != null);
            Debug.Assert(append != null);
 
            delimiter = delimiter ?? CultureInfo.CurrentCulture.TextInfo.ListSeparator;
            StringBuilder sb = new StringBuilder();
            int i = 0;
 
            foreach (T value in source)
            {
                if (i++ > 0)
                {
                    sb.Append(delimiter);
                }
 
                append(sb, value);
            }
 
            return sb.ToString();
        }

ToMaybe< T >()

static Maybe< IEnumerable< T > > CSharpx.EnumerableExtensions.ToMaybe< T > ( this IEnumerable< T >  source )

static

Turns an empty sequence to Nothing, otherwise Just(sequence).

Definition at line 588 of file EnumerableExtensions.cs.

        {
            using (IEnumerator<T> e = source.GetEnumerator())
            {
                return e.MoveNext()
                           ? Maybe.Just(source)
                           : Maybe.Nothing<IEnumerable<T>>();
            }
        }

TryHead< T >()

static Maybe< T > CSharpx.EnumerableExtensions.TryHead< T > ( this IEnumerable< T >  source )

static

Safe function that returns Just(first element) or None.

Definition at line 575 of file EnumerableExtensions.cs.

        {
            using (IEnumerator<T> e = source.GetEnumerator())
            {
                return e.MoveNext()
                           ? Maybe.Just(e.Current)
                           : Maybe.Nothing<T>();
            }
        }

Member Data Documentation

OnFolderSourceSizeErrorSelector

readonly Func<int, int, Exception> CSharpx.EnumerableExtensions.OnFolderSourceSizeErrorSelector = OnFolderSourceSizeError

staticprivate

Definition at line 22 of file EnumerableExtensions.cs.

---

The documentation for this class was generated from the following file:

• deps/commandlineparser/src/CommandLine/Infrastructure/CSharpx/EnumerableExtensions.cs