标签: linq-query-syntax

如果有时间使用标准linq关键字或linq扩展方法与lambda表达式,我正试图处理.他们似乎做同样的事情,只是写得不一样.这纯粹是风格问题吗？

var query = from p in Products
    where p.Name.Contains("foo")
    orderby c.Name
    select p;

// or with extension methods:
var query = Products
    .Where(p => p.Name.Contains("foo"))
    .OrderBy(p => p.Name);

他们非常相似,第二个例子更简洁,但如果你不知道=>在做什么,可能会表现得更差.

除了编写简洁的代码之外,使用扩展方法而不是LINQ语法还有其他优点吗？

当选择在其中一个LINQ扩展方法中使用LINQ查询语法或Lambda表达式时,是否有人遵守任何规则(或者您是否被迫遵守雇主的任何规则？)？这适用于任何实体,SQL,对象,任何东西.

在我们的工作场所,我的老板根本不喜欢lambda,他会使用查询语法来处理任何事情,在某些情况下,我发现它的可读性较差.

var names = collection.Select(item => item.Name);

var names = from item in collection
            select item.Name;

也许在添加一个条件时,我发现的Lambda有点乱,在哪里

var names = collection.Where(item => item.Name == "Fred")
                      .Select(item => item.Name);

var names = from item in collection
            where item.Name == "Fred"
            select item.Name;

只是出于兴趣:编译器如何处理这个？有谁知道上面的LINQ查询将如何编译成lambda？是否会Name为每个元素调用该属性？我们可以这样做,并可能提高性能吗？这是否意味着lambda在性能方面稍微可控？

var names = collection.Select(item => item.Name)
                      .Where(name => name == "Fred");

当然,当我们开始使用越来越多的表达式时,lambda变得混乱,我开始在这里使用查询语法.

var names = collection.Where(item => item.Name == "Fred")
                      .OrderBy(item => item.Age)
                      .Select(item => item.Name);

var names = from item in collection
            where item.Name …

鉴于这样的类:

public class Stock
{
    public Stock() {}
    public Guid StockID { get; set; }
    public string Description { get; set; }
}

让我们说我现在有一个List<Stock>.如果我想检索所有StockID的列表并将其填充到IEnumerable或IList中.显然我可以做到这一点.

List<Stock> stockItems = new List<Stock>();
List<Guid> ids = new List<Guid>();

foreach (Stock itm in stockItems) 
{
    ids.Add(itm.StockID);
}

但是有什么方法可以使用Linq来实现相同的结果吗？我想Distinct()可能会这样做,但无法弄清楚如何达到预期的效果.

考虑使用查询表示法编写的LINQ表达式:

 List<Person> pr = (from p in db.Persons
                     join e in db.PersonExceptions
                     on p.ID equals e.PersonID
                     where e.CreatedOn >= fromDate
                     orderby e.CreatedOn descending
                     select p)
                   .ToList();

问题:如何使用点表示法编写此LINQ表达式？

如果我使用扩展方法语法,以下查询将如何显示？

var query = from c in checks
group c by string.Format("{0} - {1}", c.CustomerId, c.CustomerName) 
into customerGroups
select new { Customer = customerGroups.Key, Payments = customerGroups }

是否有工具,流程或解决方案将以下LINQ查询语法转换为使用Lambdas的方法语法(点表示法)？我希望解决方案将以下查询语法转换为方法语法,例如this.

var filteredEmployees = 
    from employee in allEmployees
    where employee.DepartmentID < 4 && employee.EmployeeID < 10
    orderby employee.DepartmentID descending,
            employee.LastName descending
    select employee;

以下

var filteredEmployees2 = allEmployees.Where(employee => ((employee.DepartmentID < 4) && (employee.EmployeeID < 10)))
        .OrderByDescending(employee => employee.DepartmentID)
        .ThenByDescending(employee => employee.LastName);

我想用它来更好地学习方法语法.

我正在Roslyn中实现C#规范7.16.2"查询表达式转换".但是,我在7.16.2.5"选择子句"中遇到了问题.

它读

表单的查询表达式

from x in e select v

Run Code Online (Sandbox Code Playgroud)

被翻译成

( e ) . Select ( x => v )

Run Code Online (Sandbox Code Playgroud)

除非v是标识符x,否则翻译很简单

( e )

Run Code Online (Sandbox Code Playgroud)

例如

from c in customers.Where(c => c.City == "London")
select c

Run Code Online (Sandbox Code Playgroud)

简单地翻译成

customers.Where(c => c.City == "London")

Run Code Online (Sandbox Code Playgroud)

我的代码不会产生与示例匹配的结果,因为(根据"除非"行),我将其翻译from x in e select x成( e ),而不仅仅是e.因此,我的代码将示例翻译成

( customers.Where(c => c.City == "London") )

规范中的示例是错误的,还是我需要进行处理以识别是否需要括起括号？如果是这样,这是在规范的某个地方吗？

同样,7.16.2.6(Groupby条款)说

表单的查询表达式

from x in e group v by k

Run Code Online (Sandbox Code Playgroud)

被翻译成

( e ) . GroupBy ( …

Run Code Online (Sandbox Code Playgroud)

将LINQ字符串解析为查询的最佳实践方法是什么？

换句话说,转换最有意义的方法是:

 string query = @"from element in source
                  where element.Property = ""param""
                  select element";

成

 IEnumerable<Element> = from element in source 
                        where element.Property = "param"
                        select element;

假设source指的是IEnumerable<Element>或IQueryable<Element>在本地范围内.

我正在使用DataTable并注意到Resharper建议我可以将循环转换为LINQ表达式.我这样做了,它在查询表达式语法(简化)中重写:

var test1 = from DataRow row in dt.Rows select row;

就个人而言,我更喜欢方法语法,所以重写它:

var test2 = dt.Rows.Select(row => row);

它打破了.

'System.Data.DataRowCollection'不包含'Select'的定义,也没有扩展方法'Select'接受类型为'System.Data.DataRowCollection'的第一个参数'(你是否缺少using指令或程序集引用) ？)

由于查询表达式被转换为方法调用,为什么第一个工作但不是第二个？我希望两者都可以或者两者都不工作,这显然不是这样.

我试图编写一个方法,尽可能简单地返回给定枚举的排列.代码:

using System.Collections.Generic;

public static partial class Permutable {
    static IEnumerable<IEnumerable<T>> PermuteIterator<T>(
        IEnumerable<T> source, int offset) {
        var count=0;

        foreach(var dummy in source)
            if(++count>offset)
                foreach(
                    var sequence in
                        Permutable.PermuteIterator(
                            source.Exchange(offset, count-1), 1+offset)
                    )
                    yield return sequence;

        if(offset==count-1)
            yield return source;
    }

    public static IEnumerable<IEnumerable<T>> AsPermutable<T>(
        this IEnumerable<T> source) {
        return Permutable.PermuteIterator(source, 0);
    }

    public static IEnumerable<T> Exchange<T>(
        this IEnumerable<T> source, int index1, int index2) {
        // exchange elements at index1 and index2
    }
}

由于代码在迭代器块中简化了,我试图使它只是LINQ的单个查询表达式.

在foreach这个代码的嵌套中有一个递归,甚至另一个可能在...之外产生foreach; …