Linq To Sql令人惊讶的快速撤退数据.它是否比ADO快10倍是正常的吗？

Question

我正在学习Linq to Sql,我对选择数据的性能非常惊讶.我正在从几张桌子上撤回加入的数据.我选择了大约40k的行.使用大约35秒的ADO时间将此数据映射到对象,使用大约130秒的NHbiernate时间以及使用Linq To Sql只有3,5s的可疑内容.此外,我想写我正在使用立即加载看起来像:

THESIS th = new THESIS(connectionString);
DataLoadOptions dlo = new DataLoadOptions();
dlo.LoadWith<NumericFormula>(x => x.RPN);
dlo.LoadWith<RPN>(x => x.RPNDetails);
dlo.LoadWith<RPNDetail>(x => x.Parameter);
th.LoadOptions = dlo;
th.Log = Console.Out;

在我迭代时查看日志我看不到Linq To Sql对数据库生成一些额外的查询.

我对性能的巨大差异感到非常惊讶,我想也许我不明白.

有人可以解释一下为什么它的工作如此之快？测量时间我正在使用秒表课程.

ADO.NET代码:

public static List<NumericFormulaDO> SelectAllNumericFormulas()
{
    var nFormulas = new List<NumericFormulaDO>();

    string queryString = @"
        SELECT *
        FROM    NumericFormula nf 
                Left Join Unit u on u.Unit_Id = nf.Unit_Id 
                Left Join UnitType ut on ut.UnitType_Id = u.UnitType_Id 
                Join RPN r on r.RPN_Id = nf.RPN_Id 
                Join RPNDetails rd on rd.RPN_Id = r.RPN_Id 
                Join Parameter par on par.Parameter_Id = rd.Parameter_Id where nf.NumericFormula_Id<=10000";

    using (var connection = new SqlConnection(connectionString))
    {
        var command = new SqlCommand(queryString, connection);
        connection.Open();
        using (var reader = command.ExecuteReader())
        {
            while (reader.Read())
            {
                var det = new RPNDetailsDO();
                det.RPNDetails_Id = Int32.Parse(reader["RPNDetails_Id"].ToString());
                det.RPN_Id = Int32.Parse(reader["RPN_Id"].ToString());
                det.Identifier = reader["Identifier"].ToString();
                det.Parameter.Architecture = reader["Architecture"].ToString();
                det.Parameter.Code = reader["Code"].ToString();
                det.Parameter.Description = reader["Description"].ToString();
                det.Parameter.Parameter_Id = Int32.Parse(reader["Parameter_Id"].ToString());
                det.Parameter.ParameterType = reader["ParameterType"].ToString();
                det.Parameter.QualityDeviationLevel = reader["QualityDeviationLevel"].ToString();

                if (nFormulas.Count > 0)
                {
                     if (nFormulas.Any(x => x.RPN.RPN_Id == Int32.Parse(reader["RPN_Id"].ToString())))
                     {
                         nFormulas.First(x=>x.RPN.RPN_Id == Int32.Parse(reader["RPN_Id"].ToString())).RPN.RPNDetails.Add(det);
                     }
                     else
                     {
                         NumericFormulaDO nFormula = CreatingNumericFormulaDO(reader, det);
                         nFormulas.Add(nFormula);
                         //System.Diagnostics.Trace.WriteLine(nFormulas.Count.ToString());
                     }
                }
                else
                {
                     NumericFormulaDO nFormula = CreatingNumericFormulaDO(reader, det);
                     nFormulas.Add(nFormula);
                     //System.Diagnostics.Trace.WriteLine(nFormulas.Count.ToString());
                }
            }
        }
    }

    return nFormulas;
}

private static NumericFormulaDO CreatingNumericFormulaDO(SqlDataReader reader, RPNDetailsDO det)
{
    var nFormula = new NumericFormulaDO();
    nFormula.CalculateDuringLoad = Boolean.Parse(reader["CalculateDuringLoad"].ToString());
    nFormula.NumericFormula_Id = Int32.Parse(reader["NumericFormula_Id"].ToString());
    nFormula.RPN.RPN_Id = Int32.Parse(reader["RPN_Id"].ToString());
    nFormula.RPN.Formula = reader["Formula"].ToString();
    nFormula.Unit.Name = reader["Name"].ToString();

    if (reader["Unit_Id"] != DBNull.Value)
    {
        nFormula.Unit.Unit_Id = Int32.Parse(reader["Unit_Id"].ToString());
        nFormula.Unit.UnitType.Type = reader["Type"].ToString();
        nFormula.Unit.UnitType.UnitType_Id = Int32.Parse(reader["UnitType_Id"].ToString());
    }
    nFormula.RPN.RPNDetails.Add(det);
    return nFormula;
}

---

LINQ to SQL代码:

THESIS th = new THESIS(connectionString);
DataLoadOptions dlo = new DataLoadOptions();
dlo.LoadWith<NumericFormula>(x => x.RPN);
dlo.LoadWith<RPN>(x => x.RPNDetails);
dlo.LoadWith<RPNDetail>(x => x.Parameter);
th.LoadOptions = dlo;
th.Log = Console.Out;
var nFormulas = 
    th.NumericFormulas.ToList<NumericFormula>();

---

NHibernate代码:

IQueryable<NumericFormulaDO> nFormulas =
    session.Query<NumericFormulaDO>()
        .Where(x=>x.NumericFormula_Id <=10000);

List<NumericFormulaDO> nForList =
    new List<NumericFormulaDO>();

nForList = nFormulas.ToList<NumericFormulaDO>();

与您的评论相关,您可以看到在ADO我正在使用SqlReader,在LINQ中我尝试使用立即执行.

当然,我在ADO中的映射"算法"可能不是很好但是NHibernate比ADO慢得多(慢4倍),所以我想知道在LINQ to SQL部分是否一切都好,因为我认为在NHibernate中是一切都很好,毕竟比ADO部分的混乱要慢得多.

谢谢大家的回复.

Answer 1

LINQ-to-SQL消耗ADO.NET并且有额外的开销,所以没有:它不应该更快,除非它没有做同样的工作.通过序数和名称提到了访问权限,但坦率地说这会影响微秒,而不是秒.它不会解释一个数量级的变化.

回答这个问题的唯一方法是跟踪LINQ-to-SQL正在做什么.幸运的是,这很简单 - 您可以这样做:

dbContext.Log = Console.Out;

将编写TSQL执行到控制台.那么有两种选择:

1. 你发现TSQL没有做同样的事情(也许它不是急于加载)
2. 你发现TSQL是有效的(=做同样的事情),但有一个更好的计划 - 在这种情况下......"借"它:p

一旦你的TSQL比较,测试的是并排的一面,所以你正在测试同样的工作.如果你想要没有开销的便利,我会看看"小巧玲珑" - 带走将阅读器映射到对象的枯燥乏味的工作,但是非常优化.