How do I assign a property on only a subrange of items in a list?

Question

I want to create a list of custom objects using AutoFixture . I want the first N objects to have a property set to one value, and the remainder to have it set to another value (or to simply be set by the Fixture 's default strategy).

I am aware that I can use Fixture.CreateMany<T>.With , but this applies a function to all members of the list.

In NBuilder there are methods named TheFirst and TheNext (among others) which provide this functionality. An example of their use:

Given a class Foo :

class Foo
{
    public string Bar {get; set;}
    public int Blub {get; set;}
}

one can instantiate a bunch of Foo s like so:

class TestSomethingUsingFoo
{
    /// ... set up etc.

    [Test]
    public static void TestTheFooUser()
    {
        var foosToSupplyToTheSUT = Builder<Foo>.CreateListOfSize(10)
            .TheFirst(5)
                .With(foo => foo.Bar = "Baz")
            .TheNext(3)
                .With(foo => foo.Bar = "Qux")
            .All()
                .With(foo => foo.Blub = 11)
            .Build();

        /// ... perform the test on the SUT 
    }
}

This gives a list of objects of type Foo with the following properties:

[Object]    Foo.Bar    Foo.Blub
--------------------------------
0           Baz        10
1           Baz        10
2           Baz        10
3           Baz        10
4           Baz        10
5           Qux        10
6           Qux        10
7           Qux        10
8           Bar9       10
9           Bar10      10

(The Bar9 and Bar10 values represent NBuilder 's default naming scheme)

Is there a 'built-in' way to achieve this using AutoFixture ? Or an idiomatic way to set up a fixture to behave like this?

Answer 1

By far the easiest way to do that would be like this:

var foos = fixture.CreateMany<Foo>(10).ToList();
foos.Take(5).ToList().ForEach(f => f.Bar = "Baz");
foos.Skip(5).Take(3).ToList().ForEach(f => f.Bar = "Qux");
foos.ForEach(f => f.Blub = 11);

Assigning values to properties is already built-in to C#, so instead of providing a restrictive API that can't possibly enable you to do everything you'd want to do, the AutoFixture philosophy is to use the language constructs already available .

The next philosophical step is that if you often need to do something like that, the SUT could probably benefit from a redesign.