10

是否可以动态限制从 LINQ to SQL 查询返回的列数？

我有一个超过 50 列的数据库 SQL 视图。我的应用程序有一个具有 50 多个属性的域对象，每列一个。在我的 winforms 项目中，我将域对象列表绑定到网格。默认情况下，只有少数列是可见的，但是用户可以打开/关闭任何列。

用户抱怨网格加载时间过长。我捕获了 LINQ 生成的 SQL 查询，然后在 SQL Server Management Studio 中执行它并验证了它的缓慢性。如果我更改 SQL 语句，删除所有不可见的列，它几乎会立即运行。性能与查询中的列数直接相关。

我想知道是否可以动态更改从 LINQ 生成的 SQL 查询返回的列数？例如，这是我的代码当前的样子：

public List<Entity> GetEntities()
{
    using (var context = new CensusEntities())
    {
        return (from e in context.Entities
            select e).ToList();
    }
}

context.Entities 对象是从包含超过 50 列的 SQL 视图生成的，因此当执行上述操作时，它会生成类似“SELECT Col1, Col2, Col3, ... Col50 FROM Entity INNER JOIN ...”的 SQL。我想将方法​​签名更改为如下所示：

public List<Entity> GetEntities(string[] visibleColumns)
{
    using (var context = new CensusEntities())
    {
        return (from e in context.Entities
            select e).ToList();
    }
}

我不确定如何更改此方法的主体以将生成的 SQL 语句更改为仅返回我关心的列值，其他所有值都可以为 NULL。

4

3 回答 3

4

像这样的东西应该工作：

 List<string> columns = new List<string>();
 columns.Add("EmployeeID");
 columns.Add("HireDate");
 columns.Add("City");

将列添加到您的列表 ^。

var result = Class.ReturnList(columns);

将列表传递给方法 ^。

public static List<Entity> ReturnList(List<string> VisibleColumns)
        {
            StringBuilder SqlStatement = new StringBuilder();
            SqlStatement.Append("Select ");
            for (int i = 0; i < VisibleColumns.Count; i++)
            {
                if (i == VisibleColumns.Count - 1)
                {
                    SqlStatement.Append(VisibleColumns[i]);
                }
                else
                {
                    SqlStatement.Append(VisibleColumns[i]);
                    SqlStatement.Append(",");
                }
            }
            SqlStatement.Append(" FROM Entity");
            using (var ctx = new DataClasses1DataContext())
            {
                var result = ctx.ExecuteQuery<Entity>(SqlStatement.ToString());
                return result.ToList();
            }

        }

这基本上只是对SELECT您在列表中传递的所有字段进行声明VisibleColumns。

在这种情况下，列表中的字符串将生成的 SQL 语句VisibleColumns为：

Select EmployeeID, HireDate, City From Employee

（注意：我使用 Northwind 数据库进行了尝试，因此使用了 EmployeeID 等列名。显然，您应该将它们替换为您自己的。）

于 2012-10-09T21:04:17.293 回答
0

尝试这样的事情

using (var context = new CensusEntities())
{
    var q = from e in context.Entities
        select e.myfield1,e.myfield2;
    return q.Tolist();
}

生成的查询应该更轻，并且所有的数据转换都在下面。

但是如果你真的需要构建动态输入，我认为应该涉及一些动态sql。所以

  1. 构建动态SQL并获取数据表
  2. 使用数据表到动态对象的转换，如此处所示 如何将数据表转换为动态对象？

BTW 辛苦了，我认为你应该考虑使用第一块代码。

于 2012-10-09T20:21:26.017 回答
0

动态执行此操作并非易事，但如果您想要检索的列组合有限，则可以执行如下显式选择：

public List<Entity> GetEntities()
{
    using (var context = new CensusEntities())
    {
        return (from e in context.Entities
            select new
            {
                col1 = e.col1,
                col4 = e.col4,
                col5 = e.col5,
            }
        ).ToList()
        .Select(x=>new Entity{col1 = x.col1, col4 = x.col4, col5 = x.col5}).ToList();
    }
}

额外的选择步骤是必要的，因为 LINQ2SQL 不会为您创建部分实体。

为用户想要检索的每个常见的列组合（尤其是初始列）创建一个方法。

但是，为了使这种动态化，您可以使用存储为匿名类中的属性的实体构建查询，并在同一匿名类的第二个属性中收集另一个匿名类中的结果属性。最后，您从收集的对象中选择您的实体到正确类型的对象中。

public List<Entity> GetEntities()
{
    using (var context = new CensusEntities())
    {
        var combinedResult = (from e in context.Entities
            select new {
                Entity = e,
                CollectedValues = new
                                  {
                                      // Insert default values of the correct type as placeholders
                                      col1 = 0, // or "" for string or false for bool
                                      col2 = 0, // or "" for string or false for bool
                                      // ...
                                      col49 = 0, // or "" for string or false for bool
                                      col50 = 0, // or "" for string or false for bool
                                  }
        );

        // Then copy each requested property

        // col1
        if (useCol1)
        {
            var combinedResult = (from e in combinedResult
                select new {
                    Entity = e,
                    CollectedValues = new
                                      {
                                          col1 = e.Enitity.col1, // <-- here we update with the real value
                                          col2 = e.CollectedValues.col2, // <-- here we just use any previous value
                                          // ...
                                          col49 = e.CollectedValues.col49, // <-- here we just use any previous value
                                          col50 = e.CollectedValues.col50, // <-- here we just use any previous value                                          }
            );
        }

        // col2
        if (useCol2)
        {
         // same as last time
                                          col1 = e.CollectedValues.col1, // <-- here we just use any previous value
                                          col2 = e.Enitity.col2, // <-- here we update with the real value
                                          // ...
        }

        // repeat for all columns, update the column you want to fetch

        // Just get the collected objects, discard the temporary
        // Entity property. When the query is executed here only
        // The properties we actually have used from the Entity object
        // will be fetched from the database and mapped.
        return combinedResult.Select(x => x.CollectedValues).ToList()
        .Select(x=>new Entity{col1 = x.col1, col2 = x.col2, ... col50 = x.col50}).ToList();
    }
}

会有很多代码，维护起来很痛苦，但它应该可以工作。
如果你要走这条路，我建议你构建一个代码生成器，用你的 LINQ 上下文的反射来构建这个代码。

于 2012-10-09T19:55:22.077 回答