/// <summary> /// Prepends a single value to a sequence. /// </summary> /// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam> /// <param name="source">The sequence to prepend to.</param> /// <param name="value">The value to prepend.</param> /// <returns> /// Returns a sequence where a value is prepended to it. /// </returns> /// <remarks> /// This operator uses deferred execution and streams its results. /// </remarks> /// <code> /// int[] numbers = { 1, 2, 3 }; /// IEnumerable<int> result = numbers.Prepend(0); /// </code> /// The /// <c>result</c> /// variable, when iterated over, will yield /// 0, 1, 2 and 3, in turn. public static IEnumerable <TSource> Prepend <TSource>(this IEnumerable <TSource> source, TSource value) { if (source == null) { throw new ArgumentNullException("source"); } return(LinqEnumerable.Concat(LinqEnumerable.Repeat(value, 1), source)); }
/// <summary> /// Returns a sequence consisting of the head elements and the given tail element. /// </summary> /// <typeparam name="T">Type of sequence</typeparam> /// <param name="head">All elements of the head. Must not be null.</param> /// <param name="tail">Tail element of the new sequence.</param> /// <returns>A sequence consisting of the head elements and the given tail element.</returns> /// <remarks>This operator uses deferred execution and streams its results.</remarks> public static IEnumerable <T> Concat <T>(this IEnumerable <T> head, T tail) { if (head == null) { throw new ArgumentNullException(nameof(head)); } return(LinqEnumerable.Concat(head, LinqEnumerable.Repeat(tail, 1))); }
public ReturnShortModelAttribute(Type model, params Type[] models) { if (models != null && models.Any()) { Models = Enumerable.ToArray(Enumerable.Concat(models, new[] { model, })); } else { Models = new[] { model, }; } }
public override IEnumerator <TSource> GetEnumerator() { return(SL.Concat(source, source2).GetEnumerator()); }
/// <summary> /// Prepends a single value to a sequence. /// </summary> /// <typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam> /// <param name="source">The sequence to prepend to.</param> /// <param name="value">The value to prepend.</param> /// <returns> /// Returns a sequence where a value is prepended to it. /// </returns> /// <remarks> /// This operator uses deferred execution and streams its results. /// </remarks> /// <code> /// int[] numbers = { 1, 2, 3 }; /// IEnumerable<int> result = numbers.Prepend(0); /// </code> /// The <c>result</c> variable, when iterated over, will yield /// 0, 1, 2 and 3, in turn. public static IEnumerable <TSource> Prepend <TSource> (this IEnumerable <TSource> source, TSource value) { source.ThrowIfNull("source"); return(LinqEnumerable.Concat(LinqEnumerable.Repeat(value, 1), source)); }
/// <summary> /// Returns a sequence consisting of the head elements and the given tail element. /// </summary> /// <typeparam name="T">Type of sequence</typeparam> /// <param name="head">All elements of the head. Must not be null.</param> /// <param name="tail">Tail element of the new sequence.</param> /// <returns>A sequence consisting of the head elements and the given tail element.</returns> /// <remarks>This operator uses deferred execution and streams its results.</remarks> public static IEnumerable <T> Concat <T> (this IEnumerable <T> head, T tail) { head.ThrowIfNull("head"); return(LinqEnumerable.Concat(head, LinqEnumerable.Repeat(tail, 1))); }