我在字符串中有“按属性排序”的名称。我需要使用Lambda/Linq对对象列表进行排序。

Ex:

public class Employee
{
  public string FirstName {set; get;}
  public string LastName {set; get;}
  public DateTime DOB {set; get;}
}


public void Sort(ref List<Employee> list, string sortBy, string sortDirection)
{
  //Example data:
  //sortBy = "FirstName"
  //sortDirection = "ASC" or "DESC"

  if (sortBy == "FirstName")
  {
    list = list.OrderBy(x => x.FirstName).toList();    
  }

}

与其使用一堆if来检查字段名(sortBy)，还有一种更干净的排序方式吗 排序是否知道数据类型?

我需要做一个LINQ2DataSet查询，对多个字段(如

var result = from x in entity
join y in entity2 
       on x.field1 = y.field1 
and 
          x.field2 = y.field2

我还没有找到一个合适的解决方案(我可以在where子句中添加额外的约束，但这远远不是一个合适的解决方案，或者使用这个解决方案，但这假设了一个等价连接)。

在LINQ中是否可以在一个连接中连接多个字段?

EDIT

var result = from x in entity
             join y in entity2
             on new { x.field1, x.field2 } equals new { y.field1, y.field2 }

是我在上面假设等联时引用的解决方案。

进一步的编辑

为了回答批评，我原来的例子是一个等量连接，我承认，我目前的要求是一个等量连接，我已经采用了我上面提到的解决方案。

然而，我正在尝试了解我已经/应该使用LINQ的可能性和最佳实践。我将需要做一个日期范围查询连接与表ID很快，只是先发制人的问题，看起来我必须在where子句中添加日期范围。

一如既往，感谢所有的建议和意见

我有以下代码:

public double CalculateDailyProjectPullForceMax(DateTime date, string start = null, string end = null)
{
    Log("Calculating Daily Pull Force Max...");

    var pullForceList = start == null
                             ? _pullForce.Where((t, i) => _date[i] == date).ToList() // implicitly captured closure: end, start
                             : _pullForce.Where(
                                 (t, i) => _date[i] == date && DateTime.Compare(_time[i], DateTime.Parse(start)) > 0 && 
                                           DateTime.Compare(_time[i], DateTime.Parse(end)) < 0).ToList();

    _pullForceDailyMax = Math.Round(pullForceList.Max(), 2, MidpointRounding.AwayFromZero);

    return _pullForceDailyMax;
}

现在，我在这一行添加了一个注释，ReSharper建议进行更改。它是什么意思，或者为什么它需要改变?隐式捕获闭包:end, start

我经常想检查提供的值是否与列表中的值匹配(例如在验证时):

if (!acceptedValues.Any(v => v == someValue))
{
    // exception logic
}

最近，我注意到ReSharper要求我将这些查询简化为:

if (acceptedValues.All(v => v != someValue))
{
    // exception logic
}

显然，这在逻辑上是相同的，也许可读性稍强(如果您做了大量的数学运算)，我的问题是:这会导致性能下降吗?

感觉它应该(即. any()听起来像短路，而. all()听起来像没有)，但我没有任何证据来证实这一点。有没有人有更深层次的知识，是否查询将解决相同的，或者ReSharper是否引导我误入歧途?

比较两个庞大(>50.000项)的最快(和最少资源密集型)的方法是什么，从而得到如下所示的两个列表:

在第一个列表中出现但在第二个列表中没有出现的项目 出现在第二个列表中但不在第一个列表中的项目

目前，我正在使用列表或IReadOnlyCollection，并在linq查询中解决这个问题:

var list1 = list.Where(i => !list2.Contains(i)).ToList();
var list2 = list2.Where(i => !list.Contains(i)).ToList();

但这并不像我想的那样好。 有什么想法使这更快和更少的资源密集，因为我需要处理很多列表?

我有两个表达式的类型表达式<Func<T, bool>>和我想采取或，与或不是这些，并获得一个相同类型的新表达式

Expression<Func<T, bool>> expr1;
Expression<Func<T, bool>> expr2;

...

//how to do this (the code below will obviously not work)
Expression<Func<T, bool>> andExpression = expr AND expr2

我需要修改一个现有的程序，它包含以下代码:

var inputs = events.Select(async ev => await ProcessEventAsync(ev))
                   .Select(t => t.Result)
                   .Where(i => i != null)
                   .ToList();

但这对我来说很奇怪，首先使用async和await select。根据Stephen Cleary的回答，我应该可以放弃这些。

然后是第二个Select，它选择结果。这是否意味着任务根本不是异步的，而是同步执行的(如此多的努力是徒劳的)，或者任务将异步执行，当它完成时，执行查询的其余部分?

根据Stephen Cleary的另一个回答，我应该像下面这样写上面的代码吗?

var tasks = await Task.WhenAll(events.Select(ev => ProcessEventAsync(ev)));
var inputs = tasks.Where(result => result != null).ToList();

这是完全一样的吗?

var inputs = (await Task.WhenAll(events.Select(ev => ProcessEventAsync(ev))))
                                       .Where(result => result != null).ToList();

当我在这个项目上工作时，我想改变第一个代码示例，但我不太热衷于改变(显然工作)异步代码。也许我只是担心什么，所有3个代码样本做完全相同的事情?

processevensasync看起来像这样:

async Task<InputResult> ProcessEventAsync(InputEvent ev) {...}

我有一个字符串形式的整数数组:

var arr = new string[] { "1", "2", "3", "4" };

我需要一个'实'整数数组来进一步推动它:

void Foo(int[] arr) { .. }

我尝试转换int，当然失败了:

Foo(arr.Cast<int>.ToArray());

接下来我可以做:

var list = new List<int>(arr.Length);
arr.ForEach(i => list.Add(Int32.Parse(i))); // maybe Convert.ToInt32() is better?
Foo(list.ToArray());

or

var list = new List<int>(arr.Length);
arr.ForEach(i =>
{
   int j;
   if (Int32.TryParse(i, out j)) // TryParse is faster, yeah
   {
      list.Add(j);
   }
 }
 Foo(list.ToArray());

但两者看起来都很丑。

还有其他方法来完成这个任务吗?

我正在使用实体框架，偶尔我会得到这个错误。

EntityCommandExecutionException
{"There is already an open DataReader associated with this Command which must be closed first."}
   at System.Data.EntityClient.EntityCommandDefinition.ExecuteStoreCommands...

即使我没有做任何手动连接管理。

此错误间歇性地发生。

触发错误的代码(为方便阅读而缩短):

        if (critera.FromDate > x) {
            t= _tEntitites.T.Where(predicate).ToList();
        }
        else {
            t= new List<T>(_tEntitites.TA.Where(historicPredicate).ToList());
        }

使用Dispose模式以便每次都打开新的连接。

using (_tEntitites = new TEntities(GetEntityConnection())) {

    if (critera.FromDate > x) {
        t= _tEntitites.T.Where(predicate).ToList();
    }
    else {
        t= new List<T>(_tEntitites.TA.Where(historicPredicate).ToList());
    }

}

仍然有问题

为什么EF不重用一个连接，如果它已经打开。

给定一个集合，有没有办法得到该集合的最后N个元素?如果框架中没有方法，那么编写一个扩展方法来实现这个目的的最佳方式是什么?