主页 / 问题 / 954657
Accepted
Vadim Prokopchuk
Asked:2020-03-10 20:13:53 +0000 UTC2020-03-10 20:13:53 +0000 UTC

什么时候不应该使用迭代器？

  • 772

什么时候使用迭代器模式是合适的，什么时候是不可取的？

模式隐藏了哪些陷阱？

例如，我有一个从文件中读取行的类：

public class FormattedFileReader{
    private readonly string _path;

    // ...     

    public static IEnumerable<string> ReadFromFile(){

        foreach (var line in File.ReadLines(_path)){
            yield return GetFormattedValue(line);
        }
    }

    private string GetFormattedValue(string initial){
        // ...
    }
}
c#

1 个回答

  1. Best Answer

    他们在 MSDN 上写的关于迭代器的内容

    我将告诉你我对使用迭代器的看法。

    每当我使用：

    • 如果您需要性能，即使用索引器快速遍历某些集合，因此不会使用foreach
    • 如果在方法内部使用了迭代器IEnumerator<T> GetEnumerator() yield return，同时我们最好不要保持连接打开，例如与数据库长时间保持连接，因为我们绝对不能确定在调用循环内部foreach我们会绕过在合理的时间内关闭整个集合并关闭连接，否则有人会绕过它，而不知道我们快速遍历集合的计划。

    我认为使用迭代器非常合适的示例：

    遍历集合的一部分

    /// <summary>
/// Класс-итератор для прохода по части исходной коллекции, реализующей <see cref="IReadOnlyList{T}"/>.
/// </summary>
/// <typeparam name="T"> Тип элементов коллекции. </typeparam>
public struct SubListIterator<T> : IEnumerable<T>
{
    private readonly IReadOnlyList<T> _original;
    private readonly int _start;

    public SubListIterator(IReadOnlyList<T> original, int start, int length)
    {
        if (original == null)
        {
            throw new ArgumentNullException(nameof(original));
        }

        if (start < 0)
        {
            throw new ArgumentOutOfRangeException(nameof(start));
        }

        if (length < 0)
        {
            throw new ArgumentOutOfRangeException(nameof(length));
        }

        if (start + length > original.Count)
        {
            throw new Exception(
                "The range exceeds the size of the original IReadOnlyList " +
                $"({nameof(start)} + {nameof(length)} = {(start + length).ToString()}, size of IReadOnlyList = {original.Count}).");
        }

        Length = length;
        _original = original;
        _start = start;
    }

    public T this[int index]
    {
        get
        {
            if (index < 0 || index >= Length)
            {
                throw new IndexOutOfRangeException();
            }

            return _original[_start + index];
        }
    }

    public int Length { get; }

    public IEnumerator<T> GetEnumerator()
    {
        for (int i = 0; i < Length; i++)
        {
            yield return _original[_start + i];
        }
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

    迭代器扩展方法

    public static class IReadOnlyListExtensions
{
    public static IEnumerable<SubListIterator<T>> GetPart<T>(this IReadOnlyList<T> list, int partSize)
    {
        int newPartSize;
        for (int i = 0; i < list.Count; i += newPartSize)
        {
            newPartSize = partSize + i > list.Count ? list.Count - i : partSize;
            yield return new SubListIterator<T>(list, i, newPartSize);
        }
    }
}

    从文件中读取，如果对我们来说快速关闭这个文件并不重要

    /// <summary>
/// Класс для чтения из файла данных по частям.
/// </summary>
public class TextFileIterator : IEnumerable<IReadOnlyList<string>>
{
    private readonly string _pathToFile;
    private readonly int _maxLines;
    private readonly CancellationToken _cancellationToken;
    private readonly Encoding _encoding;

    public TextFileIterator(string pathToFile, int maxLines, CancellationToken cancellationToken, Encoding encoding = null)
    {
        Debug.Assert(maxLines > 0);
        Debug.Assert(pathToFile != null);
        Debug.Assert(cancellationToken != null);

        _pathToFile = pathToFile;
        _maxLines = maxLines;
        _cancellationToken = cancellationToken;

        if (encoding == null)
        {
            encoding = Encoding.UTF8;
        }
        _encoding = encoding;
    }

    public IEnumerator<IReadOnlyList<string>> GetEnumerator()
    {
        using (var file = new StreamReader(_pathToFile, _encoding))
        {
            var lines = new List<string>(_maxLines);

            do
            {
                lines.Clear();
                string line = null;
                for (int i = 0; i < _maxLines; i++)
                {
                    if ((line = file.ReadLine()) == null)
                    {
                        break;
                    }

                    if (_cancellationToken.IsCancellationRequested)
                    {
                        yield break;
                    }

                    lines.Add(line);
                }

                if (lines.Count > 0)
                {
                    yield return lines.ToArray();
                }

                if (line == null)
                {
                    break;
                }

            } while (!_cancellationToken.IsCancellationRequested);
        }
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}
    • 3

相关问题