使 using 语句可用于多个一次性对象

Question

我在一个文件夹中有一堆文本文件，它们都应该有相同的标题。换句话说，所有文件的前 100 行应该是相同的。所以我写了一个函数来检查这个条件：

private static bool CheckHeaders(string folderPath, int headersCount)
{
    var enumerators = Directory.EnumerateFiles(folderPath)
        .Select(f => File.ReadLines(f).GetEnumerator())
        .ToArray();
    //using (enumerators)
    //{
        for (int i = 0; i < headersCount; i++)
        {
            foreach (var e in enumerators)
            {
                if (!e.MoveNext()) return false;
            }
            var values = enumerators.Select(e => e.Current);
            if (values.Distinct().Count() > 1) return false;
        }
        return true;
    //}
}

我使用枚举器的原因是内存效率。我不是将所有文件内容加载到内存中，而是逐行同时枚举文件，直到发现不匹配，或者检查了所有标题。

注释的代码行很明显我的问题。我想使用using 块来安全地处理所有枚举器，但不幸的是using (enumerators) 无法编译。显然using 只能处理一个一次性对象。我知道我可以手动处理枚举数，方法是将整个事物包装在 try-finally 块中，并最终在内部循环中运行处理逻辑，但这似乎很尴尬。在这种情况下，我是否可以采用任何机制使 using 语句成为可行的选择？

---

更新

我刚刚意识到我的函数有一个严重的缺陷。枚举器的构造并不稳健。锁定的文件可能会导致异常，而一些枚举器已经创建。这些枚举器将不会被释放。这是我想要解决的问题。我正在考虑这样的事情：

var enumerators = Directory.EnumerateFiles(folderPath)
    .ToDisposables(f => File.ReadLines(f).GetEnumerator());

扩展方法ToDisposables 应确保在发生异常时不会留下任何一次性物品。

Answer 1

您可以在 enumerators 上创建一次性包装器：

class DisposableEnumerable : IDisposable
{
    private IEnumerable<IDisposable> items;

    public event UnhandledExceptionEventHandler DisposalFailed;

    public DisposableEnumerable(IEnumerable<IDisposable> items) => this.items = items;

    public void Dispose()
    {
        foreach (var item in items)
        {
            try
            {
                item.Dispose();
            }
            catch (Exception e)
            {
                var tmp = DisposalFailed;
                tmp?.Invoke(this, new UnhandledExceptionEventArgs(e, false));
            }
        }
    }
}

并以对代码影响最小的方式使用它：

private static bool CheckHeaders(string folderPath, int headersCount)
{
    var enumerators = Directory.EnumerateFiles(folderPath)
        .Select(f => File.ReadLines(f).GetEnumerator())
        .ToArray();

    using (var disposable = new DisposableEnumerable(enumerators))
    {
        for (int i = 0; i < headersCount; i++)
        {
            foreach (var e in enumerators)
            {
                if (!e.MoveNext()) return false;
            }
            var values = enumerators.Select(e => e.Current);
            if (values.Distinct().Count() > 1) return false;
        }
        return true;
    }
}

问题是你必须一个一个地单独处理这些对象。但这取决于您在哪里封装该逻辑。而且我建议的代码没有手册try-finally,)

Answer 2

到问题的第二部分。如果我猜对了，这就足够了：

static class DisposableHelper
{
    public static IEnumerable<TResult> ToDisposable<TSource, TResult>(this IEnumerable<TSource> source,
        Func<TSource, TResult> selector) where TResult : IDisposable
    {
        var exceptions = new List<Exception>();
        var result = new List<TResult>();
        foreach (var i in source)
        {
            try { result.Add(selector(i)); }
            catch (Exception e) { exceptions.Add(e); }
        }

        if (exceptions.Count == 0)
            return result;

        foreach (var i in result)
        {
            try { i.Dispose(); }
            catch (Exception e) { exceptions.Add(e); }
        }

        throw new AggregateException(exceptions);
    }
}

用法：

private static bool CheckHeaders(string folderPath, int headersCount)
{
    var enumerators = Directory.EnumerateFiles(folderPath)
                               .ToDisposable(f => File.ReadLines(f).GetEnumerator())
                               .ToArray();

    using (new DisposableEnumerable(enumerators))
    {
        for (int i = 0; i < headersCount; i++)
        {
            foreach (var e in enumerators)
            {
                if (!e.MoveNext()) return false;
            }
            var values = enumerators.Select(e => e.Current);
            if (values.Distinct().Count() > 1) return false;
        }
        return true;
    }
}

和

try
{
    CheckHeaders(folderPath, headersCount);
}
catch(AggregateException e)
{
    // Prompt to fix errors and try again
}

Answer 3

我将建议一种方法，该方法使用对Zip 的递归调用来允许并行枚举普通IEnumerable<string> 而无需诉诸使用IEnumerator<string>。

bool Zipper(IEnumerable<IEnumerable<string>> sources, int take)
{
    IEnumerable<string> ZipperImpl(IEnumerable<IEnumerable<string>> ss)
        => (!ss.Skip(1).Any())
            ? ss.First().Take(take)
            : ss.First().Take(take).Zip(
                ZipperImpl(ss.Skip(1)),
                (x, y) => (x == null || y == null || x != y) ? null : x);

    var matching_lines = ZipperImpl(sources).TakeWhile(x => x != null).ToArray();
    return matching_lines.Length == take;
}

现在建立你的enumerables：

IEnumerable<string>[] enumerables =
    Directory
        .EnumerateFiles(folderPath)
        .Select(f => File.ReadLines(f))
        .ToArray();

现在调用很简单：

bool headers_match = Zipper(enumerables, 100);

以下是针对三个超过 4 行的文件运行此代码的跟踪：

本·彼得林 5:28 PM ACST 本·彼得林 5:28 PM ACST 本·彼得林 5:28 PM ACST 在 2019-05-23 的电话中，James 提到他希望能够通过管理员编辑当前的运费规则（例如在 shipping_rules.xml 中）。 在 2019-05-23 的电话中，James 提到他希望能够通过管理员编辑当前的运费规则（例如在 shipping_rules.xml 中）。 在 2019-05-23 的电话中，James 提到他希望能够通过管理员编辑当前的运费规则（例如在 shipping_rules.xml 中）。 他还提到他希望能够为给定的时间窗口设置不同的运费规则，例如1 月 1 日至 1 月 30 日。 他还提到他希望能够为给定的时间窗口设置不同的运费规则，例如1 月 1 日至 1 月 30 日。 他还提到他希望能够为给定的时间窗口设置不同的运费规则，例如1 月 1 日至 1 月 30 日。 在选择要使用的适当模块时，应考虑这些故事情节。 在选择要使用的适当模块时应考虑这些故事。X 在选择要使用的适当模块时，应考虑这些故事情节。

请注意，枚举在第二个文件的第 4 行遇到不匹配的标头时停止。然后所有枚举都停止了。

Answer 4

按照@Alex 的建议创建IDisposable 包装器是正确的。如果其中一些文件被锁定，它只需要一个逻辑来处理已经打开的文件，并且可能需要一些错误状态的逻辑。可能是这样的（错误状态逻辑很简单）：

public class HeaderChecker : IDisposable
{
    private readonly string _folderPath;
    private readonly int _headersCount;
    private string _lockedFile;
    private readonly List<IEnumerator<string>> _files = new List<IEnumerator<string>>();

    public HeaderChecker(string folderPath, int headersCount)
    {
        _folderPath = folderPath;
        _headersCount = headersCount;
    }

    public string LockedFile => _lockedFile;

    public bool CheckFiles()
    {
        _lockedFile = null;
        if (!TryOpenFiles())
        {
            return false;
        }
        if (_files.Count == 0)
        {
            return true; // Not sure what to return here.
        }

        for (int i = 0; i < _headersCount; i++)
        {
            if (!_files[0].MoveNext()) return false;
            string currentLine = _files[0].Current;

            for (int fileIndex = 1; fileIndex < _files.Count; fileIndex++)
            {
                if (!_files[fileIndex].MoveNext()) return false;
                if (_files[fileIndex].Current != currentLine) return false;
            }
        }
        return true;
    }

    private bool TryOpenFiles()
    {
        bool result = true;
        foreach (string file in Directory.EnumerateFiles(_folderPath))
        {
            try
            {
                _files.Add(File.ReadLines(file).GetEnumerator());
            }
            catch
            {
                _lockedFile = file;
                result = false;
                break;
            }
        }
        if (!result)
        {
            DisposeCore(); // Close already opened files.
        }
        return result;
    }

    private void DisposeCore()
    {
        foreach (var item in _files)
        {
            try
            {
                item.Dispose();
            }
            catch
            {
            }
        }
        _files.Clear();
    }

    public void Dispose()
    {
        DisposeCore();
    }
}

// Usage
using (var checker = new HeaderChecker(folderPath, headersCount))
{
    if (!checker.CheckFiles())
    {
        if (checker.LockedFile is null)
        {
            // Error while opening files.
        }
        else
        {
            // Headers do not match.
        }
    }
}

在检查线路时，我还删除了 .Select() 和 .Distinct()。第一个只是迭代 enumerators 数组 - 与上面的 foreach 相同，因此您将枚举此数组两次。然后创建一个新的行列表，.Distinct() 对其进行枚举。