相关疑难解决方法(0)

LINQ使用延迟执行模型,这意味着在调用Linq运算符时不返回结果序列,而是这些运算符返回一个对象,该对象只有在枚举此对象时才会生成序列的元素.

虽然我理解延迟查询是如何工作的,但我在理解延迟执行的好处时遇到了一些麻烦:

1)我已经读过只有在你真正需要结果时执行的延迟查询才会有很大的好处.那么这个好处是什么？

2)延迟查询的其他优点是,如果您定义一次查询,那么每次枚举结果时,如果数据发生更改,您将得到不同的结果.

a)但是从下面的代码中可以看出,我们能够实现相同的效果(因此,每次枚举资源时,如果数据发生变化,我们会得到不同的结果),即使不使用延迟查询:

List<string> sList = new List<string>( new[]{ "A","B" });

foreach (string item in sList)
    Console.WriteLine(item); // Q1 outputs AB

sList.Add("C");

foreach (string item in sList)
    Console.WriteLine(item); // Q2 outputs ABC

3)延期执行是否还有其他好处？

我做了快速测试应用程序,将LINQ排序与我的自定义对象上的Array.Sort进行比较.Array.Sort似乎非常慢!

我创建了这样的自定义类:

class Person : IComparable<Person>
{
    public int Age { get; set; }
    public string Name { get; set; }

    public int CompareTo(Person obj)
    {
        return this.Age.CompareTo(obj.Age);
    }

    public Person()
    { }

}

然后我在main()中做了我的测试人员:

string name = "Mr. Tomek";

Random r = new Random();
int size = 10000000;

DateTime start, end;
Person[] people1 = new Person[size];
Person[] people2 = new Person[size];

for (int i = 0; i < size; i++)
{
     people1[i] = new Person();
     people1[i].Age = r.Next(0, 10000); …

这是对C#Sort和OrderBy这个优秀问题的跟进比较.我将使用相同的示例:

List<Person> persons = new List<Person>();
persons.Add(new Person("P005", "Janson"));
persons.Add(new Person("P002", "Aravind"));
persons.Add(new Person("P007", "Kazhal"));

争论的方法是:

persons.Sort((p1, p2) => string.Compare(p1.Name, p2.Name, true));
//and
persons.OrderBy(n => n.Name);

首先让我说,我理解没有任何重大的性能差异需要担心.但我很想知道为什么OrderBy表现得比这更好Sort.我正在使用@phoog在原始问题中发布的答案.

private void button1_Click(object sender, EventArgs e)
{
    IEnumerable<Person> people;

    BenchMark(persons => persons.Sort((p1, p2) => string.Compare(p1.Name, p2.Name, true)));

    BenchMark(persons => people = persons.OrderBy(n => n.Name));
}

private static Random randomSeed = new Random();
public static string RandomString(int size, bool lowerCase)
{
    var sb = new StringBuilder(size); …

为了简洁起见,在我的代码中,我希望能够执行以下操作:拥有一个集合,找到匹配lambda表达式的第一个元素; 如果存在,则返回属性或函数的值.如果它不存在,则返回null.

更新的例子w.类

我们有一些东西

class Stuff
{
    public int Id { get; set; }
    public string Value { get; set; }
    public DateTime? ExecutionTime { get; set; }
}

我的目标是在调用它时很好地返回

var list = new Stuff[] { new Stuff() { Id = 1, Value = "label", ExecutionTime = DateTime.Now } };

// would return the value of ExecutionTime for the element in the list
var ExistingTime = list.FirstOrDefault(s => s.Value.Contains("ab")).ExecutionTime;

// would return null
var NotExistingTime = list.FirstOrDefault(s => s.Value.Contains("zzz")).ExecutionTime; 

是否可以使用一些linq-syntax-fu或者我必须在继续之前明确检查返回值？ …

我的List记忆力很大,来自一个大约20岁的班级properties.

我想基于一个过滤此列表property,对于特定任务,我只需要一个列表property.所以我的查询是这样的:

data.Select(x => x.field).Where(x => x == "desired value").ToList()

哪一个让我有更好的表现,Select先使用或使用Where？

data.Where(x => x.field == "desired value").Select(x => x.field).ToList()

如果这与data type我将数据保存在内存或字段类型中有关,请告诉我.请注意,我也需要这些对象用于其他任务,因此我无法在首先过滤它们并将它们加载到内存之前.

假设我有一些字符串:

string[] strings = { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" };

有什么区别:

string startsWithO = strings.First(s => s[0] == 'o');

和:

string startsWithO = strings.Where(s => s[0] == 'o').First();

由于Where()被推迟,它不应该减慢执行速度,对吗？

Linq是.NET的一个很棒的补充,我发现它在很多情况下都很好用,即使我刚开始学习如何使用Linq.

然而,在我对Linq所做的阅读中,我发现开发人员需要注意一些微妙的事情,这可能会导致麻烦.

我已经提到了一个明确的警告,我发现这是延迟执行的结果.

所以我想知道,对于Linq来说,Linq的新手应该知道哪些其他注意事项？

可能重复:
LINQ扩展方法 - Any()vs. Where()vs. Exists()

给定内存中的对象列表,我运行了以下两个表达式:

myList.where(x => x.Name == "bla").Any() 

VS

myList.Any(x => x.Name == "bla")

后者总是最快的,我相信这是由于Where枚举所有项目.但是当没有匹配时也会发生这种情况.

我不确定为什么.是否存在这种观察到的性能差异的情况,例如是否在查询Nhib？

干杯.

我需要编写一个查询,从用户为任何给定数据集定义的列中提取不同的值.可能有数百万行,因此语句必须尽可能高效.以下是我的代码.

这个LINQ查询的顺序是什么？有更有效的方法吗？

var MyValues = from r in MyDataTable.AsEnumerable()
               orderby r.Field<double>(_varName)
               select r.Field<double>(_varName); 

IEnumerable result= MyValues.Distinct();

我有一个List<String> myList.

我想把这个列表中的前10个项目与某些标准相匹配(.Contains("a")例如,让我们说).

我有:

Var results = myList.Where(o=>o.Contains("a")).Take(10);

哪个工作正常,但LINQ执行了Where检索满足此条件的所有项目,然后只采取了前10个？或者这将以整个LINQ语句被考虑的方式编译(即它将执行Where但只到达到10项)？