linq 查询中未处理的项目

Question

我有 Select 的 linq，其中创建了 IDisposable 对象。之后有一个过滤器Where，这会导致一些对象永远不会被释放。

这是一个再现：

class Program
{
    static void Main(string[] args)
    {
        var results = "1234567890"
            .Select(o => new Test(o))
            .Where(o => o.Value > '3' && o.Value < '7')
            .ToList();

        // do something with results
        // ...

        // dispose
        foreach (var result in results)
            result.Dispose();
    }
}

class Test : IDisposable
{
    public char Value { get; }
    public Test(char value)
    {
        Value = value;
        Console.WriteLine($"{Value}");
    }
    public void Dispose() => Console.WriteLine($"{Value} disposed");
}

输出：

1
2
3
4
5
6
7
8
9
0
4 disposed
5 disposed
6 disposed

问题：

如您所见，有1、2、3、7、8、9、0，它们是被创建但从未被释放的。

我的解决方案：

我可以在Select 中移动Where 条件，但是我需要应用丑陋的“返回null + Where 而不是null”解决方法：

var results = "1234567890".Select(o =>
{
    if (o > '3' && o < '7')
        return new Test(o);
    return null;
}).Where(o => o != null).ToList();

输出：

4
5
6
4 disposed
5 disposed
6 disposed

有没有更好（更优雅）的方式？

如果Select 在某个返回IEnumerable<T> 的库方法中，我的解决方法除了丑陋之外还有一个问题，我无法更改。如何申请Where不漏？

Answer 1

如您所见，创建了 1, 2, 3, 7, 8, 9, 0 从未丢弃

这是因为Where 需要为每个Select 调用创建Test 实例以根据条件测试结果。

过滤后，results 包含已创建对象的子集 => 您的代码仅处理此子集项。

有没有更好（更优雅）的方式？

唯一的LINQ方法是将初始可枚举物化为List<Test>（或数组）在过滤之前，并处理列表项：

        var results = "1234567890"
            .Select(o => new Test(o))
            .ToList();

        var filteredResults = results
            .Where(o => o.Value > '3' && o.Value < '7')
            .ToList();

        // do something with FILTERED results
        // ...

        // dispose
        foreach (var result in results)
            result.Dispose();

但是如果有一些原因尽快Dispose 不必要的结果，并且你不能修改代码，那会产生可枚举的，只是不要使用LINQ。写一个普通的foreach：

        var enumerable = "1234567890"
            .Select(o => new Test(o));

        var results = new List<Test>();

        foreach (var item in enumerable)
        {
            if (!(item.Value > '3' && item.Value < '7'))
            {
                item.Dispose();
            }
            else
            {
                results.Add(item);
            }
        }

        // do something with results
        // ...

        // dispose
        foreach (var result in results)
            result.Dispose();

Answer 2

您可以先使用char 过滤您的string，然后选择所需的类型：

var results = "1234567890".Where(ch => ch > '3' && ch < '7').Select(s => new Test(s)).ToList();

foreach (var item in results)
{
    item.Dispose();
}

Answer 3

你需要记住所有项目：

var allItems= "1234567890"
        .Select(o => new Test(o)).ToArray();
var result = allItems.Where(o => o.Value > '3' && o.Value < '7')
        .ToList();

比处置所有物品：

foreach (var result in allItems)
        result.Dispose();

Answer 4

从库中获取项目后，您可以将它们存储在数组中。您可以过滤数组，对相关项目做一些事情并使用数组来处理所有项目：

var items = GetItemsFromLibrary().ToArray();
try
{
  var relevantItems = items.Where(o => o.Value > '3' && o.Value < '7');
  // Do something with relevant items
  // ...
}
finally
{
  // Dispose all items
  foreach (var item in items)
    item.Dispose();
}

ToArray 将项目存储在一个数组中，以便您在处置它们时再次处理相同的项目，而不是再次查询库，这可能会导致返回新项目。

如果您担心内存不足，可以使用以下（丑陋的）方法尽早丢弃不必要的项目。这可能是一个优势，但与使用ToArray 存储所有项目相比，我怀疑这不是一个很大的优势。

var items = GetItemsFromLibrary()
  .Where(o => {
           if (o.Value > '3' && o.Value < '7')
             return true;
           // Object not relevant in this case
           o.Dispose()
           return false;
         })
  .ToArray();
try
{
  // Do something with relevant items
  // ...
}
finally
{
  // Dispose all items
  foreach (var item in items)
    item.Dispose();
}

即使在 Where 子句中处理不必要的项目时，该对象也已在库中实例化。因此，您最好的选择是将库更改为仅返回相关项目。

Answer 5

正如其他人已经说过的，您正在创建对象，然后丢弃对它们的引用，这意味着无法调用 Dispose()。

这些对象最终会在未来的某个时间被 GC 收集，但 GC 确实不会自动为您调用 Dispose() 而无需任何帮助。

如果这是您真正需要的模式，您可以在一次性对象上实现终结器，以便在 GC 启动时为您调用 Dispose()。

class Program
{
    static void Main(string[] args)
    {
        var results = "1234567890"
                      .Select(o => new Test(o))
                      .Where(o => o.Value > '3' && o.Value < '7')
                      .ToList();

        // do something with results
        // ...

        // dispose
        foreach (var result in results)
            result.Dispose();

        // Force GC to prove dispose called...
        GC.Collect();

        Console.ReadLine();
    }
}
class Test : IDisposable
{
    public char Value { get; }
    public Test(char value)
    {
        Value = value;
        Console.WriteLine($"{Value}");
    }
    public void Dispose() => Console.WriteLine($"{Value} disposed");

    ~Test()
    {
        Dispose();
    }
}