标签: linq-to-objects

我有一个像这样的数据列表:

ID AddressPurpose Address ...
1  L
1  P
2  L
2  P
3  P
3  L
4  P
4  L
5  P
6  L

我希望能够过滤数据,以便对于每个唯一的数字,如果有一个P行,则返回它,否则返回L行.所以数据看起来像这样:

ID AddressPurpose Address ...
1  P
2  P
3  P
4  P
5  P
6  L

目前我有这个查询工作正常:

var query = from c in list
            orderby c.AddressPurpose descending
            group c by c.ID
            into g
                select g;

var finalList = new List<Company>();
foreach (var list in query)
{
    finalList.Add(list.First());
}
return finalList;

没有使用额外的foreach,有没有更好的方法来做到这一点？

我有这个问题困扰着我; 它被封装为一个新的查询运算符,我制作了两个版本,试图看看哪个更好.两者表现得非常糟糕.

第一次尝试; 陈述式

public static IEnumerable<IEnumerable<?>> Section<?>(this IEnumerable<?> source, int length)
{
    return source.Any()
        ? source.Take(length).Cons(source.Skip(length).Section(length))
        : Enumerable.Empty<IEnumerable<?>>();
}

第二次尝试:势在必行的"收益率回报"风格

public static IEnumerable<IEnumerable<?>> Section<?>(this IEnumerable<?> source, int length)
{
    var fst = source.Take(length);
    var rst = source.Skip(length);

    yield return fst;

    if (rst.Any())
        foreach (var section in rst.Section(length))
            yield return section;
}

事实上,第二次尝试在可读性,组合性和速度方面都更糟糕.

关于如何优化这个的任何线索？

另请参见LINQ to Objects和LINQ to SQL查询之间的差异

我们在数据库和内存对象中使用了一些查询.

与linq-to-sql相比,使用不敏感字符串的最佳方法是什么？

• 它在SQL Server上运行得很快
• 相同的查询表达式可以与linq-to-objects一起使用以获得相同的结果

运用

a.ToLowerInvariant() == b.ToLowerInvariant()

至少得到相同的结果,但据我所知,它不会在SQL服务器上处理,所以可能会慢得多

a == b

我的职业生涯始于一个核心功能范式开发人员(LISP),现在我是一个核心的.net/C#开发人员.当然我很迷恋LINQ.但是,我也相信(1)使用正确的工具和(2)保留KISS原则:在我工作的60多名工程师中,可能只有20%有LINQ /功能范例经验,5%有6到12个月的这种经历.简而言之,我觉得有必要远离LINQ,除非我在没有它的情况下实现目标受到阻碍(其中用一行LINQ替换3行OO代码不是"目标").

但现在,拥有12个月LINQ /功能范例经验的工程师之一,正在生产代码中的每个可想到的位置使用LINQ到对象,或者至少使用lambda表达式.我对KISS原则的各种呼吁没有产生任何结果.因此...

我接下来可以申请哪些已发表的研究？什么"编码标准"指南有其他人炮制成功？我可以指出是否发布了LINQ性能问题？简而言之,我试图通过间接说服来实现我的第一个目标 - KISS.

当然,这个问题可以扩展到无数其他领域(例如过度使用扩展方法).也许有一个"超级"指南,备受推崇(例如已发表的研究等),在这方面需要更广泛的考虑.什么？

编辑编辑:哇!我受过教育!我同意我会以完全错误的方式来到这里.但作为澄清,请看下面我实际看到的示例代码.最初它编译和工作,但它的目的现在无关紧要.只要顺其自然的"感觉".现在我半年后再次访问这个样本,我对实际上困扰我的情况有了不同的看法.但是我希望有更好的眼睛比我的评论更好.

//This looks like it was meant to become an extension method...
public class ExtensionOfThreadPool
{
    public static bool QueueUserWorkItem(Action callback)
    {
        return ThreadPool.QueueUserWorkItem((o) => callback());
    }
}

public class LoadBalancer
{
    //other methods and state variables have been stripped...

    void ThreadWorker()
    {
        // The following callbacks give us an easy way to control whether
        // we add additional headers around outbound WCF calls.
        Action<Action> WorkRunner = null;

        // This …

我正在查询视图并使用名为status的列过滤结果.我想查询它,以便我可以通过使用IN运算符来搜索具有不同状态的行,就像我在SQL中所做的那样.

如此:

SELECT*FROM VIEW WHERE状态('....','.....')

我怎样才能做到这一点？

这是一个普遍的问题,但这是我正在寻找解决方案的具体案例:

我有一个Dictionary<int, List<string>>我想应用各种谓词.我想要一个可以处理多个LINQ查询的方法,例如:

from x in Dictionary
where x.Value.Contains("Test")
select x.Key

from x in Dictionary
where x.Value.Contains("Test2")
select x.Key

所以我正在寻找一个像这样的方法:

public int GetResult(**WhatGoesHere** filter)
{
    return from x in Dictionary.Where(filter)
           select x.Key;
}

要像这样使用:

int result;

result = GetResult(x => x.Value.Contains("Test"));
result = GetResult(x => x.Value.Contains("Test2"));

WhatGoesHere的正确语法是什么？

我有一个匿名类的集合,我想返回一个空列表.

什么是最好的可读表达式？

我虽然如下,但我认为它们不够可读:

var result = MyCollection.Take(0).ToList();

var result = MyCollection.Where(p => false).ToList();

注意:我不想清空集合本身.

任何建议!

使用linq到对象(不是linq到sql)进行条件查询的最佳方法是什么.

目前我正在使用http://www.albahari.com/nutshell/predicatebuilder.aspx中的Predicate构建器 ,并将已编译的谓词传递给IEnumerable.Where,它似乎工作得很好.

我要解决的示例代码:

我有这个

 string keyword1 = "Test1";
 string keyword2 = "Test3";

        IEnumerable<TestObject> tests = new List<TestObject>()
                                     {
                                         new TestObject() {Name1 = "Test1", Name2 = "Test1"},
                                         new TestObject() {Name1 = "Test2", Name2 = "Test2"},
                                         new TestObject() {Name1 = "Test3", Name2 = "Test3"},

                                     };

        if (!String.IsNullOrEmpty(keyword1) && String.IsNullOrEmpty(keyword2))
            tests = tests.Where(e => e.Name1.Contains(keyword1));
        else if (!String.IsNullOrEmpty(keyword2) && !String.IsNullOrEmpty(keyword1))
            tests = tests.Where(e => e.Name2.Contains(keyword2) || e.Name1.Contains(keyword1));

        return tests.ToList();

如果我想执行.Where(...)或.Max(...)等操作,我需要确保列表不为空并且计数大于零.每次我想使用列表时,除了执行以下操作之外:

if(mylist != null && mylist.Count > 0)
{...}

我可以使用更内联或lambda技术吗？还是另一种压缩技术？

如何使用linq-to-objects基于派生类型过滤掉对象？

我正在寻找性能最佳的解决方案.

使用的类:

abstract class Animal { }
class Dog : Animal { }
class Cat : Animal { }
class Duck : Animal { }
class MadDuck : Duck { }

我知道三种方法:使用is关键字,使用Except方法,并使用该OfType方法.

List<Animal> animals = new List<Animal>
{
    new Cat(),
    new Dog(),
    new Duck(),
    new MadDuck(),
};

// Get all animals except ducks (and or their derived types)
var a = animals.Where(animal => (animal is Duck == false));
var b = animals.Except((IEnumerable<Animal>)animals.OfType<Duck>());

// …