Question

我修改了一个Github项目，以测试更多与实体框架相关的查询方式。

型号：

[Table("Player")]
public partial class Player
{
    public int Id { get; set; }

    [Required]
    [StringLength(200)]
    public string FirstName { get; set; }

    [Required]
    [StringLength(200)]
    public string LastName { get; set; }

    public DateTime DateOfBirth { get; set; }

    public int TeamId { get; set; }

    public virtual Team Team { get; set; }
}

[Table("Team")]
public partial class Team
{
    public Team()
    {
        Players = new HashSet<Player>();
    }

    public int Id { get; set; }

    [Required]
    [StringLength(200)]
    public string Name { get; set; }

    public DateTime FoundingDate { get; set; }

    public int SportId { get; set; }

    public virtual ICollection<Player> Players { get; set; }

    public virtual Sport Sport { get; set; }
}

[Table("Sport")]
public partial class Sport
{
    public Sport()
    {
        Teams = new HashSet<Team>();
    }

    public int Id { get; set; }

    [StringLength(100)]
    public string Name { get; set; }

    public virtual ICollection<Team> Teams { get; set; }
}

我正在测试的是这些东西：

EF＆＃34;同步＆＃34; - FirstOrDefault（）和ToList（）

context.Players.FirstOrDefault(x => x.Id == id);

context.Players.AsNoTracking().Where(x => x.TeamId == teamId).ToList();

context.Teams.AsNoTracking().Include(x => x.Players).Where(x => x.SportId == sportId).ToList();

EF＆＃34; Async＆＃34; - FirstOrDefaultAsync（）和ToListAsync（）

await context.Players.FirstOrDefaultAsync(x => x.Id == id);

await context.Players.AsNoTracking().Where(x => x.TeamId == teamId).ToListAsync();

await context.Teams.AsNoTracking().Include(x => x.Players).Where(x => x.SportId == sportId).ToListAsync();

EF＆＃34;同步＆＃34;选择进入DTO对象

context.Players.Select(p => new PlayerDTO()
                {
                    Id = p.Id,
                    FirstName = p.FirstName,
                    DateOfBirth = p.DateOfBirth,
                    LastName = p.LastName,
                    TeamId = p.TeamId

                }).FirstOrDefault(x => x.Id == id);

context.Players.Where(x => x.TeamId == teamId).Select(p => new PlayerDTO()
                {
                    Id = p.Id,
                    FirstName = p.FirstName,
                    DateOfBirth = p.DateOfBirth,
                    LastName = p.LastName,
                    TeamId = p.TeamId
                }).ToList();

context.Teams.Where(x => x.SportId == sportId).Select(t => new TeamDTO()
                    {
                        Id = t.Id,
                        FoundingDate = t.FoundingDate,
                        Name = t.Name,
                        SportId = t.SportId,
                        Players = t.Players.Select(p => new PlayerDTO()
                        {
                            Id = p.Id,
                            FirstName = p.FirstName,
                            DateOfBirth = p.DateOfBirth,
                            LastName = p.LastName,
                            TeamId = p.TeamId
                        }).ToList()
                    }).ToList();

EF＆＃34; Async＆＃34;选择进入DTO对象

await context.Players.Select(p => new PlayerDTO()
                {
                    Id = p.Id,
                    FirstName = p.FirstName,
                    DateOfBirth = p.DateOfBirth,
                    LastName = p.LastName,
                    TeamId = p.TeamId

                }).FirstOrDefaultAsync(x => x.Id == id);

 await context.Players.Where(x => x.TeamId == teamId).Select(p => new PlayerDTO()
                {
                    Id = p.Id,
                    FirstName = p.FirstName,
                    DateOfBirth = p.DateOfBirth,
                    LastName = p.LastName,
                    TeamId = p.TeamId
                }).ToListAsync();

await context.Teams.Where(x => x.SportId == sportId).Select(t => new TeamDTO()
                {
                    Id = t.Id,
                    FoundingDate = t.FoundingDate,
                    Name = t.Name,
                    SportId = t.SportId,
                    Players = t.Players.Select(p => new PlayerDTO()
                    {
                        Id = p.Id,
                        FirstName = p.FirstName,
                        DateOfBirth = p.DateOfBirth,
                        LastName = p.LastName,
                        TeamId = p.TeamId
                    }).ToList()
                }).ToListAsync();

我觉得我的结果很麻烦。主要是因为MS正在推广EF的异步部分。

我的结果:(以毫秒为单位）

运动数量：8，球队数量：30，球员数量：100

EntityFrameworkAsyncDTO Results
Run #   Player by ID            Players per Team                Teams per Sport
0               1,46                    3,47                    35,88
1               1,04                    3                       33
2               1,02                    3,3                     33,75
3               1,03                    3                       31,75
4               1,1                     3,27                    31,38
EntityFrameworkAsync Results
Run #   Player by ID            Players per Team                Teams per Sport
0               1,17                    3,53                    57
1               1,01                    3                       48,62
2               0,99                    3,03                    47,88
3               1,02                    3,07                    51
4               1                       3,03                    48,88
EntityFrameworkDTO Results
Run #   Player by ID            Players per Team                Teams per Sport
0               0,02                    3                       13,25
1               0,01                    2,8                     13,12
2               0,15                    2,97                    13,25
3               0,02                    2,9                     13,25
4               0,05                    2,8                     13,12
EntityFramework Results
Run #   Player by ID            Players per Team                Teams per Sport
0               0,01                    2,27                    28,38
1               0,01                    2,4                     28,25
2               0                       2,13                    28,5
3               0,01                    2,17                    27,5
4               0,01                    2,13                    29
ADONET Results
Run #   Player by ID            Players per Team                Teams per Sport
0               0                       2,03                    11,75
1               0                       2                       12,62
2               0                       2                       11,38
3               0                       2                       12,38
4               0                       2                       11,25

/编辑我已将ADO.NET时间添加到结果列表中作为参考。

我的问题是：我的查询出错了，因为加载时间差别很大？

在我运行的真实世界系统中，我已将所有异步数据库调用更改为同步调用，并且在我的统计数据中可以看到系统正在看到数据库调用速度提高约50％。这是一个通过SignalR连接100-120个当前用户的系统，它非常重DB。

Answer 1

我认为this article详细解释了它。

异步并不快，并且在正常的“同步”代码之上增加了大量开销。但是当你浪费时间等待时（例如网络连接上的高延迟等），它允许更好地使用资源

Answer 2

异步方法意味着需要更多的IL代码，从而解释了一次调用的区别。

如果您在方法中进行其他异步调用，则可以从异步方法中受益。

另一篇有趣的文章：https://www.thereformedprogrammer.net/analysis-of-entity-framework-6-async-performance/

Answer 3

如果您按如下方式运行异步测试，则我同意其他贡献者的观点：

var tskPlayers = context.Players.FirstOrDefaultAsync(x => x.Id == id);

var tskPlayersNt = context.Players.AsNoTracking().Where(x => x.TeamId == teamId).ToListAsync();

var tskTeamsNt = context.Teams.AsNoTracking().Include(x => x.Players).Where(x => x.SportId == sportId).ToListAsync();

Task.WhenAll(tskPlayers, tskPlayersNt, tskTeamsNt);

您会看到更好的结果。

实体框架6异步方法与同步方法的性能

3 个答案: