Generate sequence in Linq

Question

I want to generate a sequence using Linq that goes from 10 to 100 with a step size of 10. The sequence also must contain a custom value (in the correct order).

This is what I have now, and I'm wondering if there is a smarter way of doing it using Linq expressions.

var pageSize = 25; //number that must be in sequnce if not already, can be anything.
var items = Enumerable.Range(10, 100)     //Generate range           
           .Where(x => x % 10 == 0)       //Take every 10th item
           .Concat(new[] { pageSize })    //Add the custom number
           .Distinct()                    //If the custom number was already in there, remove it
           .OrderBy(x => x);              //Sort the sequence

Result:

10 
20 
25 
30 
40 
50 
60 
70 
80 
90 
100 

Answer 1

Know your library

.Distinct() should immediately make you think of a Set.
.OrderBy(...) should make you think of a sorted collection.

I give you: the SortedSet<T>, part of .NET since version 4.0.

When LINQ is not enough, extend it

LINQ uses extension methods, so if it doesn't have what you need, add your own:

private static IEnumerable<T> ToSelectionWith<T>(this IEnumerable<T> sequence, params T[] items)
{
    return new SortedSet<T>(sequence.Concat(items));
}

Usage

This allows you to call it as though it were a part of LINQ itself:

var pageSize = 25;
var items = Enumerable.Range(1, 10).Select(x => x*10).ToSelectionWith(pageSize);

Benefits

1. It's concise — a one-liner. You could even skip the extension method and use the SortedSet directly.
2. It's readable — by wrapping it in the extension method, the intent of using the SortedSet is clarified.
3. It performs well — in my crude Stopwatch testing, it beat your and Sandeep's versions for both small and large input sequences. (Specifically, the SortedSet based approach runs twice as fast as Sandeep's version for your original input, and at least three times as fast for very large input sizes).

Answer 2

Size of initial list in the following code is less:

var x = Enumerable.Range(1, 10)
                  .Select(x_ => x_ * 10)
                  .Concat(new[] {25})
                  .Distinct()
                  .OrderBy(x_ => x_)
                  .ToList();

Otherwise your original code is perfect.

Answer 3

Just include the custom value in the condition, then you don't need to concatentat it, remove duplicates or sort. To get the range from 10 to 100 you should use 91 as count in the Range method, Range(10, 100) creates numbers from 10 to 109.

var pageSize = 25;

var items =
  Enumerable.Range(10, 91)           
  .Where(x => x % 10 == 0 || x == pageSize);

Note: This naturally only works if the custom value is inside the range.

Answer 4

Although there isn't much left to add to the actual use case OP mentioned, considering the general problem of inserting a value in the correct order in an ordered sequence, a more time and space efficient solution exists.

public static IEnumerable<T> InsertPreservingOrder<T> (this IEnumerable<T> sortedSequence, T value)
    where T : IComparable<T>
{
    return sortedSequence.TakeWhile(x => x.CompareTo(value) < 0)
             .Append(value)
             .Concat(sortedSequence.SkipWhile(x => x.CompareTo(value) <= 0));
}

where Append is syntactic sugar for .Concat(new{...}) as per @codesparkle's answer:

public static IEnumerable<T> Append<T>(this IEnumerable<T> sequence, params T[] items)
{
    return sequence.Concat(items);
}

This operation is of constant (O(1)) space, linear (O(n)) time and lazy. Especially useful in situations like this :

var customValue = 15;
var defaultValues = Enumerable.Range(1, 10000000).Select(x_ => x_ * 10);
var items = defaultValues.InsertPreservingOrder(customValue);
// then later
items.Take(10).ToList().ForEach(Console.WriteLine);

I also think this method is a clear improvement in capturing programmer's intent w.r.t. the original version, regardless of asymptotic complexity. It reifies an idea; therefore can be reused, whenever the current value of a variable would be added in a collection of default options. Its name makes clear both the precondition that first parameter is assumed to be already sorted, and the postcondition that the return value is also sorted. However it leaves the distinctness condition opaque.

Though I'd still prefer a simple defaultValues.Append(customValue).ToSortedSet()