Car[] (array) 和 IEnumerable 有区别吗<Car>什么时候使用 AutoMapper？

Question

In several projects I am using the mapping functions of AutoMapper. I will use the object Car as an example through the full question.

First my set-up :

I define my maps with profiles:

public class CarProfile : Profile
{
    public CarProfile()
    {
        CreateMap<Car, CarResponse>();
    }
}

I initialize AutoMapper in ASP.NET Core Web API with:

services.AddAutoMapper();

Using the NuGet packages AutoMapper and AutoMapper.Extensions.Microsoft.DependencyInjection

The mapper is automically injected in the constructor and set as a private field _mapper .

Eventually I map a collection with the following piece of code:

_mapper.Map<IEnumerable<Car>, IEnumerable<CarResponse>>(_context.Cars);

It's also worth to mention that _context.Cars is in this case an DbSet<T> .

Now my actual question is: would it be different if I would use an array instead of a IEnumerable .

Example given :

_mapper.Map<Car[], CarResponse[]>(_context.Cars);

Please consider performance, clean code and behavioural differences.

Answer 1

Behavioural differences

I generated the execution plan and I can conclude that there at least is a difference. See this link for my comparison: https://www.diffnow.com/?report=elujt . Analyzing the C# code makes clear that there happens more when using an array.

Performance

Since this still does not give any insights in performance, I measured that using Stopwatch .

        var watchienumerable = Stopwatch.StartNew();
        var ienumerable = _mapper.Map<IEnumerable<Car>, IEnumerable<CarResponse>>(contextDevices);
        watchienumerable.Stop();

Measuring IEnumerable first:

• IEnumerable: 21 milliseconds;
• Array: 7 milliseconds;

Measuring Array first:

• IEnumerable: 7 milliseconds;
• Array: 21 milliseconds;

These results are not representative, because the mapper still needs to be warmed up.

Mapping a collection related to this object first (to warm up the mapping, initialize caching etc.)

• IEnumerable: 57704 ticks;
• Array: 122014 ticks;

I can conclude that mapping to an IEnumerable from (something that is not an array) is faster than mapping to an array. With hindsight, it sounds quite obvious.

When the input is an array:

• IEnumerable: 18642 ticks;
• Array: 1392 ticks;

It's also worth to mention that if use the actual type of _context.Cars which is DbSet<Car> . It is exactly as fast as when I use IEnumerable<Car> .

Word of advice: I would use the type that is closest to the input and still matches your desired output. In my case, I will stick to using IEnumerable.

Clean code

This part of my answer is highly opiniated and very open to comments. But I think Car[] reads better than IEnumerable<Car> .

However since there are behavioural and performance differences I don't think it's clean to use an array here. It also changes the intent. So using IEnumerable<T> would be better.