在 LINQ 中使用 TryGetValue() 吗？

Question

此代码可以工作，但效率低下，因为它会双重查找 ignored 字典。如何在 LINQ 语句中使用字典 TryGetValue() 方法来提高效率？

IDictionary<int, DateTime> records = ...

IDictionary<int, ISet<DateTime>> ignored = ...

var result = from r in records
             where !ignored.ContainsKey(r.Key) ||
             !ignored[r.Key].Contains(r.Value)
             select r;

问题是我不确定如何在 LINQ 语句中声明用于 out 参数的变量。

Answer 1

（我的回答涉及使用 TrySomething( TInput input, out TOutput value ) 方法的一般情况（例如 IDictionary.TryGetValue( TKey, out TValue ) 和 Int32。 TryParse( String, out Int32 ) 因此它不会直接用OP自己的exmaple代码回答OP的问题，我在这里发布这个答案是因为这个QA目前是“linq trygetvalue”的Google最高结果。 2019 年 3 月）。

使用扩展方法语法时，至少有以下两种方法：

使用 C# 值元组、System.Tuple 或匿名类型：

调用 TrySomething<。首先在 Select 调用中使用 /code> 方法，并将结果存储在 C# 7.0 中的值元组中（或旧版本 C# 中的匿名类型，请注意，应首选值元组，因为它们的开销较低）：

使用 C# 7.0 值元组（推荐）：

// Task: Find and parse only the integers in this input:
IEnumerable<String> input = new[] { "a", "123", "b", "456", ... };

List<Int32> integersInInput = input
    .Select( text => Int32.TryParse( text, out Int32 value ) ? ( ok: true, value ) : ( ok: false, default(Int32) ) )
    .Where( t => t.ok )
    .Select( t => t.value )
    .ToList();

实际上可以通过利用另一个巧妙的技巧来简化，其中 value 变量在整个 .Select 的范围内 lambda，因此三元表达式变得不必要，如下所示：

// Task: Find and parse only the integers in this input:
IEnumerable<String> input = new[] { "a", "123", "b", "456", ... };

List<Int32> integersInInput = input
    .Select( text => ( ok: Int32.TryParse( text, out Int32 value ), value ) ) // much simpler!
    .Where( t => t.ok )
    .Select( t => t.value )
    .ToList();

使用 C# 3.0 匿名类型：

// Task: Find and parse only the integers in this input:
IEnumerable<String> input = new[] { "a", "123", "b", "456", ... };

List<Int32> integersInInput = input
    .Select( text => Int32.TryParse( text, out Int32 value ) ? new { ok = true, value } : new { ok = false, default(Int32) } )
    .Where( t => t.ok )
    .Select( t => t.value )
    .ToList();

使用 .NET Framework 4.0 Tuple:

// Task: Find and parse only the integers in this input:
IEnumerable<String> input = new[] { "a", "123", "b", "456", ... };

List<Int32> integersInInput = input
    .Select( text => Int32.TryParse( text, out Int32 value ) ? Tuple.Create( true, value ) : Tuple.Create( false, default(Int32) ) )
    .Where( t => t.Item1 )
    .Select( t => t.Item2 )
    .ToList();

扩展方法

2. 使用我编写的 自己的扩展方法：SelectWhere 将其减少为单个调用。它在运行时应该更快，尽管这并不重要。

它的工作原理是为具有第二个 out 参数的方法声明自己的 delegate 类型。 Linq 默认情况下不支持这些，因为 System.Func 不接受 out 参数。但是，由于委托在 C# 中的工作方式，您可以将 TryFunc 与任何与其匹配的方法一起使用，包括 Int32.TryParse、Double .TryParse、Dictionary.TryGetValue 等...

要支持其他具有更多参数的 Try... 方法，只需定义一个新的委托类型并为调用者提供一种指定更多值的方法。

public delegate Boolean TryFunc<T,TOut>( T input, out TOut value );

public static IEnumerable<TOut> SelectWhere<T,TOut>( this IEnumerable<T> source, TryFunc<T,TOut> tryFunc )
{
    foreach( T item in source )
    {
        if( tryFunc( item, out TOut value ) )
        {
            yield return value;
        }
    }
}

用法：

// Task: Find and parse only the integers in this input:
IEnumerable<String> input = new[] { "a", "123", "b", "456", ... };

List<Int32> integersInInput = input
    .SelectWhere( Int32.TryParse ) // The parse method is passed by-name instead of in a lambda
    .ToList();

如果您仍想使用 lambda，则可以使用替代定义使用值元组作为返回类型（需要 C# 7.0 或更高版本）：

public static IEnumerable<TOut> SelectWhere<T,TOut>( this IEnumerable<T> source, Func<T,(Boolean,TOut)> func )
{
    foreach( T item in source )
    {
        (Boolean ok, TOut output) = func( item );

        if( ok ) yield return output;
    }
}

用法：

// Task: Find and parse only the integers in this input:
IEnumerable<String> input = new[] { "a", "123", "b", "456", ... };

List<Int32> integersInInput = input
    .SelectWhere( text => ( Int32.TryParse( text, out Int32 value ), value ) )
    .ToList();

这有效，因为 C# 7.0 允许在 out 类型名称< 中声明变量/code> 用于其他元组值的表达式。

Answer 2

您需要在查询之前声明 out 变量：

ISet<DateTime> s = null;
var result = from r in records
             where !ignored.TryGetValue(r.Key, out s)
                || !s.Contains(r.Value)
             select r;

不过，如果稍后才评估查询，请注意副作用...

Answer 3

使用外部变量，您无需担心它超出范围，因为 LINQ 表达式是一个可以使其保持活动状态的闭包。但是，为了避免任何冲突，您可以将变量和表达式放在一个函数中：

public IEnumerable GetRecordQuery() {
    ISet<DateTime> s = null;
    return from r in records
           ... 
}

...

var results = GetRecordQuery();

这样，只有查询才能访问 s 变量，而任何其他查询（从单独调用 返回） GetRecordQuery) 每个都有自己的变量实例。