如何使用扩展方法使集合成为“n”元素？

Question

So, here is my issue, I have a given object which is an IEnumerable and I have been guaranteed that said collection will always have at most 4 elements. Now, for a reason that is not important, I'd like to be able to, in some elegant way, "force" the collection to contain 4 elements if it has any less.

I've already done some research and the most convincig candidate is Zip, but it stops zipping after it reaches the shortest collection's end.

Is there any way of doing this without making my own extension method? To better explain myself:

var list1 = new List<Dog> {
    new Dog { Name = "Puppy" }
}
var list2 = new List<Dog> {
    new Dog { Name = "Puppy1" },
    new Dog { Name = "Puppy2" },
    new Dog { Name = "Puppy3" },
    new Dog { Name = "Puppy4" },
}

var other1 = list1.ExtendToNElements(4).ToList();
//Now other1's first element is an instance of Dog with Name = "Puppy"
//And the following 3 elements are null, or have a Dog with no name
//I don't really care about that

var other2 = list2.ExtendToNElements(4).ToList();
//other2 is the same as list2, nothing got added.

Thanks in advance!

Answer 1

Quick one-liner (which should count as "doable without an extension method"):

public static IEnumerable<TItem> Extend<TItem>(
            this IEnumerable<TItem> source, 
            int n)
{
    return source.Concat(Enumerable.Repeat(default(TItem), n))
                 .Take(n);
}

Since Repeat takes an explicit count, passing in n gives a reasonable upper bound. The elements are generated on-demand anyway. Using source.Count() would force execution of source which isn't ideal.

Slightly more overengineered and flexible version:

public static IEnumerable<TItem> Extend<TItem>(
            this IEnumerable<TItem> source, 
            int n, 
            Func<TItem> with) 
{
    return source.Concat(
        from i in Enumerable.Range(0, n) select with()
    ).Take(n);
}

public static IEnumerable<TItem> Extend<TItem>(
            this IEnumerable<TItem> source, 
            int n, 
            TItem with = default(TItem)) 
{
    return source.Extend(n, with: () => with);
}

Answer 2

You can use MoreLinq's Pad method: http://code.google.com/p/morelinq/ (NuGet: http://www.nuget.org/packages/morelinq )

This will append the default value for the type ( null in this case):

var other1 = list1.Pad(4).ToList();

Or if you want to supply a default value:

var other1 = list1.Pad(4, "Puppy_null").ToList();

Or if you want to have those numbered puppies:

var other1 = list.Pad(4, (count) => "Puppy" + count).ToList();

The Pad method will not add additional entries if its length is already equal to or greater than your pad size.

Here's the Pad implementation specifically if you want to incorporate/adapt it without bringing in the entire project: http://code.google.com/p/morelinq/source/browse/MoreLinq/Pad.cs

Answer 3

    class Program
    {
        static void Main(string[] args)
        {
            List<string> list = new List<string>();
            list.Capacity = 4;
            var items = list.TakeOrDefault(4);


        }
    }

    public static class EnumerableExtensions
    {
        public static IEnumerable<T> TakeOrDefault<T>(this IEnumerable<T> enumerable, int length)
        {
            int count = 0;
            foreach (T element in enumerable)
            {
                if (count == length)
                    yield break;

                yield return element;
                count++;
            }
            while (count != length)
            {
                yield return default(T);
                count++;
            }
        }
    }