Linq To Sql惊人地快速检索数据.它比ADO快10倍,这正常吗

本文关键字:ADO 它比 10倍 常吗 数据 检索 Sql To Linq | 更新日期: 2023-09-27 18:24:58

我目前正在学习从Linq到Sql,我对选择数据的性能感到非常惊讶。我正在从几个表中检索联接的数据。我选择了大约40k行。使用ADO将这些数据映射到对象的时间约为35秒,使用NHbiernate的时间约130秒,使用Linq to Sql的可疑时间仅为3秒5。此外,我想写的是,我正在使用立即加载,看起来像:

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到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到SQL部分是否一切都好,因为我认为在NHibernat中一切都很好,毕竟比令人困惑的ADO部分慢得多。

谢谢你们的回复。

Linq To Sql惊人地快速检索数据.它比ADO快10倍,这正常吗

LINQ to SQL消耗ADO.NET并有额外的开销,所以不:除非它不做同样的工作,否则它不会更快。有人提到通过序数和名字访问,但坦率地说,这影响的是微秒,而不是秒。它无法解释数量级的变化。

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

dbContext.Log = Console.Out;

它将把TSQL执行写入控制台。有两种选择:

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

一旦您有了TSQL进行比较,就可以并排测试,这样您就可以测试相同的工作。如果你想在没有开销的情况下获得便利,我会选择"dapper"——它省去了将读者映射到对象的枯燥乏味的工作,但非常优化。

根据以上备注重写ADO.NET代码,这应该会快得多。您仍然可以通过使用序数值而不是列名以及按照与查询中完全相同的顺序读取字段来进行改进,但这些都是微观优化。

我还删除了几个重复项。您可能还想检查如何提高类型转换和转换的性能,因为Parse(ToString)路由效率非常低,并且在使用不同语言运行的系统时可能会导致非常奇怪的问题。当涉及小数、浮点或双精度时,在进行这些转换时也有可能发生数据丢失,因为并非所有的值都能正确地转换为字符串(或无法往返)。

public static List<NumericFormulaDO> SelectAllNumericFormulas()
{
    var nFormulas = new Dictionary<int, 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))
    {  
        connection.Open();
        using (var command = new SqlCommand(queryString, connection));
        using (var reader = command.ExecuteReader())
        {
            while (reader.Read())
            {
                var det = new RPNDetailsDO();
                det.RPNDetails_Id = (int) reader.GetValue("RPNDetails_Id");
                det.RPN_Id = (int) reader.GetValue("RPN_Id");
                det.Identifier = (string) reader.GetValue("Identifier");
                det.Parameter.Architecture = (string)reader.GetValue("Architecture");
                det.Parameter.Code = (string)reader.GetValue("Code");
                det.Parameter.Description = (string)reader.GetValue("Description");
                det.Parameter.Parameter_Id = (int) reader.GetValue("Parameter_Id");
                det.Parameter.ParameterType = (string)reader.GetValue("ParameterType");
                det.Parameter.QualityDeviationLevel = (string)reader.GetValue("QualityDeviationLevel");
                NumericFormulaDO parent = null;
                if (!nFormulas.TryGetValue((int)reader.GetValue("RPN_Id"), out parent)
                {
                    parent = CreatingNumericFormulaDO(reader, det);
                    nFormulas.Add(parent.RPN.RPNID, parent);
                }
                else
                {
                    parent.RPN.RPNDetails.Add(det);
                }
            }
        }
    }
    return nFormulas.Values.ToList();
}
相关文章: