Seeking a quick and dirty way to populate a list of entities for testing purposes Here's what I have at the moment. Any ideas for improving on this?

public static Snapshot[] GetSnapshots()
{
    var arrayedSnapshot = new
    {
        Id = Enumerable.Range(1, 9),
        ScenarioTimeInSeconds = new[] { 0, 0, 0, 60, 60, 60, 120, 120, 120 },
        BearingInDegrees = new[] { 0, 120, 220, 0, 120, 220, 0, 120, 220},
        RangeInNauticalMiles = new[] { 0, 1, 1, 0, 1, 1, 0, 1, 1 },
        CourseInDegrees = new[] { 90, 90, 90, 90, 90, 180, 90, 90, 90 },
        SpeedInKnots = Enumerable.Repeat(7, 9),
        XCoordinate = new[] { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
        YCoordinate = new[] { 0, 0, 0, 0, 0, 0, 0, 0, 0 }
    };
    return arrayedSnapshot.Id
        .Select((td, index) =&gt;
            new Snapshot
            {
                Id = arrayedSnapshot.Id ElementAt(index),
                ScenarioTimeInSeconds = arrayedSnapshot.ScenarioTimeInSeconds.ElementAt(index),
                BearingInDegrees = arrayedSnapshot.BearingInDegrees.ElementAt(index),
                RangeInNauticalMiles = arrayedSnapshot.RangeInNauticalMiles.ElementAt(index),
                CourseInDegrees = arrayedSnapshot.CourseInDegrees.ElementAt(index),
                SpeedInKnots = arrayedSnapshot.SpeedInKnots.ElementAt(index),
                XCoordinate = arrayedSnapshot.XCoordinate.ElementAt(index),
                YCoordinate = arrayedSnapshot.YCoordinate.ElementAt(index),
            })
        .ToArray();
}


Edit

Here is a new version based on Anton Golov's answer:

public static IEnumerable&lt;Snapshot&gt; GetSnapshots()
{
    for (var i = 0; i &lt; 9; i++)
    {
        yield return new Snapshot
        {
            Id = i + 1,
            ScenarioTimeInSeconds = new[] { 0, 0, 0, 60, 60, 60, 120, 120, 120 }[i],
            BearingInDegrees = new[] { 0, 120, 220, 0, 120, 220, 0, 120, 220 }[i],
            RangeInNauticalMiles = new[] { 0, 1, 1, 0, 1, 1, 0, 1, 1 }[i],
            CourseInDegrees = new[] { 90, 90, 90, 90, 90, 180, 90, 90, 90 }[i],
            SpeedInKnots = new[] { 7, 7, 7, 7, 7, 7, 7, 7, 7 }[i],
            XCoordinate = new[] { 0, 0, 0, 0, 0, 0, 0, 0, 0 }[i],
            YCoordinate = new[] { 0, 0, 0, 0, 0, 0, 0, 0, 0 }[i]
        };
    }
}


This seems a lot more elegant than my original.
As far as I can see, most of your data is fairly predictable.  What about:

for (int i = 0; i &lt; 9; ++i)
{
   int scenarioTimeInSeconds = 60*(i/3); // Intentional loss of fractional part
   int bearingInDegrees = (i % 3) * 120; // It's now 0, 120, 240
   int rangeInNauticalMiles = (i % 3 == 0) ? 0 : 1;
   int courseInDegrees = (i == 5) ? 180 : 90;
   yield return new Snapshot
       {
           Id = i + 1,
           ScenarioTimeInSeconds = scenarioTimeInSeconds,
           BearingInDegrees = bearingInDegrees,
           RangeInNauticalMiles = rangeInNauticalMiles,
           CourseInDegrees = courseInDegrees,
           SpeedInKnots = 7,
           XCoordinate = 0,
           YCoordinate = 0,
      };
}


This already seems more readable to me.  Now you can split the logic that makes the values for the various local ints off into separate functions and document each one.  In order to do it this way, you do have to have GetSnapshots return an IEnumerable&lt;Snapshot&gt;, but that makes sense anyway -- and if you really want them as an array, just call ToArray() on it outside the function (i.e. GetSnapshots().ToArray()).

Even if you'd rather not do that, you should still change numbers that are used multiple times (in your case: 60, 90, 120, 180, 220) into named constants, unless they're entirely unrelated.