标签: linq-to-objects

是否有可能编写一个查询,我们从任何给定的字符串中获取所有可以解析为int的字符？

例如,我们有一个字符串,如: "$%^DDFG 6 7 23 1"

结果必须是 "67231"

甚至更轻微一点:我们只能获得前三个数字吗？

我有一个包含两个不同类型泛型列表,例如着想,让他们打电话Products和Employees.我正在尝试找到与员工位于同一位置的产品,即在哪里product.SiteId == emp.SiteId

List<Product> lstProds;
List<Employees> lstEmps;

我的(老skool)大脑告诉我使用forEach循环找到匹配但我怀疑有一个('更好'/更快/更快？)的方式来使用Linq.任何人都可以照亮我吗？我在网上找到的所有例子都涉及原语列表(字符串/整数),并没有特别有用.

考虑到List已知的边界,是否.Last()列举了集合？

我问这个,因为文件说,这是定义Enumerable(在这种情况下,将需要枚举集)

如果它不枚举集合,然后我可以通过索引只需访问最后一个元素(如我们知道.Count的List<T>),但它似乎愚蠢不得不这样做....

以下问题:
我应该在LINQ查询中使用两个"where"子句或"&&"吗？
可以或者我应该在LINQ查询中将两个Where子句连接在一起吗？
linq样式,链接where子句vs和运营商
Jon Skeet:博客文章

大多数答案都表示,Linq To Objects在单个lambda表达式中链接where子句vs && 的性能可以忽略不计,因此可以根据您的编码风格决定使用哪一个.

我从查看IL程序集开始,你可以肯定地看到chaining where子句将导致Where扩展被调用2次而第二次调用的输入是第一次调用的结果.

var numbers = new List<int>() { 1, 2 ,3,4,5,6,7,8,9,10};
IEnumerable<int> query = numbers.Where(x=> x>2).Where(x => x<5);

// IL

IL_005B:  ldloc.0     // numbers
IL_005C:  ldsfld      UserQuery.CS$<>9__CachedAnonymousMethodDelegate3
IL_0061:  brtrue.s    IL_0076
IL_0063:  ldnull      
IL_0064:  ldftn       b__1
IL_006A:  newobj      System.Func<System.Int32,System.Boolean>..ctor
IL_006F:  stsfld      UserQuery.CS$<>9__CachedAnonymousMethodDelegate3
IL_0074:  br.s        IL_0076
IL_0076:  ldsfld      UserQuery.CS$<>9__CachedAnonymousMethodDelegate3
IL_007B:  call        System.Linq.Enumerable.Where <-----------First Call
IL_0080:  ldsfld      UserQuery.CS$<>9__CachedAnonymousMethodDelegate4
IL_0085:  brtrue.s    IL_009A
IL_0087:  ldnull      
IL_0088:  ldftn       b__2
IL_008E:  newobj      System.Func<System.Int32,System.Boolean>..ctor
IL_0093: …

我期望Enumerable.Empty()的实现就是这样:

public static IEnumerable<TResult> Empty<TResult>()
{
    yield break;
}

但实现是这样的:

public static IEnumerable<TResult> Empty<TResult>()
{
    return EmptyEnumerable<TResult>.Instance;
}

internal class EmptyEnumerable<TElement>
{
    private static volatile TElement[] instance;

    public static IEnumerable<TElement> Instance
    {
        get
        {
            if (EmptyEnumerable<TElement>.instance == null)
                EmptyEnumerable<TElement>.instance = new TElement[0];
            return (IEnumerable<TElement>)EmptyEnumerable<TElement>.instance;
        }
    }
}

为什么实现比一行代码更复杂？返回缓存数组是否有优势而不是(yield)不返回任何元素？

注意:我永远不会依赖方法的实现细节,但我只是好奇.

我正在为我编写的局域网方网站构建一个插件,允许使用Round Robin锦标赛.

一切进展顺利,但我有一些关于排名超过两个标准的最有效方法的问题.

基本上,我想要以下排名布局:

         Rank  Wins  TotalScore
PersonE  1     5     50
PersonD  2     3.5   37
PersonA  2     3.5   37
PersonC  4     2.5   26
PersonB  5     2.5   24
PersonF  6     0     12

在SQL服务器中,我会使用:

SELECT
    [Person],
    RANK() OVER (ORDER BY Wins DESC, TotalScore DESC) [Rank],
    [Wins],
    [TotalScore]

现在,我只有List,Dictionary等可以使用

特别:

Dictionary<TournamentTeam, double> wins = new Dictionary<TournamentTeam, double>();
Dictionary<TournamentTeam, double> score = new Dictionary<TournamentTeam, double>();

有没有办法用LINQ做这种排名风格？

如果没有,是否有一种可扩展的方式可以让我以后考虑Win-Loss-Draw而不仅仅是胜利,如果我选择的话？

编辑:

我改编了TheSoftwareJedi的答案:

private class RRWinRecord : IComparable
{
    public int Wins { get; set; } …

在为LINQ编写方法链时,我可以用两种方式之一做Where语句:

var blackOldCats = cats.Where(cat => cat.Age > 7 && cat.Colour == "noir" )

要么

var blackOldCats = cats.Where(cat => cat.Age > 7).Where(cat => cat.Colour == "noir" )

一个人比另一个人有什么好处吗？

不要过多担心这个例子中的数据类型,但是如果数据类型存在问题,那么也应该知道.

显而易见的一点是该对象已被引用,因此在应用程序中同时出现两个属性更容易,对吧？

我衷心想要了解如何在c#中使用和不使用lambda表达式构建(简单和复杂)查询.我搜索了很多,但也许我可能会错过一些要检查的链接.有些人可以告诉我在哪里可以学习Linq的基本知识,它的所有功能,编写查询等等吗？请指导我!

我有一个我必须使用的场景.选择LINQ中的位置.以下是我的查询.

List<DTFlight> testList = _ctrFlightList.Select(i => new DTFlight() { AirLineName = i.AirLineName,ArrivalDate = i.ArrivalDate }).ToList();

我希望在这个查询中使用where(添加条件).

请帮忙......谢谢.

我们在使用LINQ的代码段中遇到了轻微的性能问题,并且提出了一个关于LINQ如何在查找方面工作的问题

我的问题是这个(请注意我已经更改了所有代码,因此这是代码的指示性示例,而不是真实场景):

特定

public class Person {
 int ID;
 string Name;
 DateTime Birthday; 
 int OrganisationID;
}

如果我有一个说100k Person对象的列表,然后是一个日期列表,比如1000,我运行了这段代码:

var personBirthdays = from Person p in personList
    where p.OrganisationID = 123
    select p.Birthday;

foreach (DateTime d in dateList)
{
    if (personBirthdays.Contains(d))
        Console.WriteLine(string.Format("Date: {0} has a Birthday", d.ToShortDateString()));
}

结果代码将是以下迭代:

100k(用于查找具有organisationID 123的用户需要完成的循环)
乘以
1000(列表中的日期数量)
乘以
x(具有要检查的组织ID 123的用户数量的日期) )

这是很多迭代!

如果我将personBirthdays的代码更改为:

List<DateTime> personBirthdays = 
        (from Person p in personList
        where p.OrganisationID = 123
        select p.Birthday).ToList();

这应该删除100k作为倍数,并只执行一次？

所以你会有100k +(1000*x)而不是(100k*1000*x).

问题是,这似乎太容易了,我确信LINQ在某个地方做了一些聪明的事情应该意味着这不会发生.

如果没有人回答,我会进行一些测试并报告.

清晰度更新: 我们不考虑数据库查找,该personList …