Question

我想构建一个流利的api，以便在我过滤值的数组上进行迭代，并继续处理其余（而不是过滤后的）值。像这样的伪代码：

int[] input = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };

from a in Take(3) // a = {5,4,1}
from b in Skip(4) // b = null
from c in TakeWhile(x=> x != 0) // c = {7, 2}
select new Stuff(a, b, c)

我不知道从哪里开始寻找东西，这样的基础是什么。所以我想寻求帮助。

系统不应限于int数。.另一个示例：

string[] input = { "how", "are", "you", "doing", "?" };

from a in OneOf("how", "what", "where") // a = "how"
from b in Match("are") // b = "are"
from c in TakeWhile(x=> x != "?") // c = { "you", "doing" }
select new Stuff(a, b, c)

Answer 1

以下代码将允许您执行input.FirstTake(3).ThenSkip(4).ThenTakeWhile(x => x != 0);以获取序列5、4、1、7、2。主要思想是，您需要跟踪要进行的拍摄和跳过您可以在迭代时应用它们。这类似于OrderBy和ThenBy的工作方式。请注意，您不能在两者之间进行其他Linq操作。这样会建立一个连续跳过和执行的枚举，然后该序列将通过您执行的任何Linq操作进行馈送。

public interface ITakeAndSkip<out T> : IEnumerable<T>
{
    ITakeAndSkip<T> ThenSkip(int number);
    ITakeAndSkip<T> ThenTake(int number);
    ITakeAndSkip<T> ThenTakeWhile(Func<T, bool> predicate);
    ITakeAndSkip<T> ThenSkipWhile(Func<T, bool> predicate);
}

public class TakeAndSkip<T> : ITakeAndSkip<T>
{
    private readonly IEnumerable<T> _source;

    private class TakeOrSkipOperation
    {
        public bool IsSkip { get; private set; }
        public Func<T, bool> Predicate { get; private set; }
        public int Number { get; private set; }

        private TakeOrSkipOperation()
        {
        }

        public static TakeOrSkipOperation Skip(int number)
        {
            return new TakeOrSkipOperation
            {
                IsSkip = true,
                Number = number
            };
        }

        public static TakeOrSkipOperation Take(int number)
        {
            return new TakeOrSkipOperation
            {
                Number = number
            };
        }


        public static TakeOrSkipOperation SkipWhile(Func<T, bool> predicate)
        {
            return new TakeOrSkipOperation
            {
                IsSkip = true,
                Predicate = predicate
            };
        }

        public static TakeOrSkipOperation TakeWhile(Func<T, bool> predicate)
        {
            return new TakeOrSkipOperation
            {
                Predicate = predicate
            };
        }
    }

    private readonly List<TakeOrSkipOperation> _operations = new List<TakeOrSkipOperation>();

    public TakeAndSkip(IEnumerable<T> source)
    {
        _source = source;
    }

    public IEnumerator<T> GetEnumerator()
    {
        using (var enumerator = _source.GetEnumerator())
        {
            // move to the first item and if there are none just return
            if (!enumerator.MoveNext()) yield break;

            // Then apply all the skip and take operations
            foreach (var operation in _operations)
            {
                int n = operation.Number;
                // If we are not dealing with a while then make the predicate count
                // down the number to zero.
                var predicate = operation.Predicate ?? (x => n-- > 0);

                // Iterate the items until there are no more or the predicate is false
                bool more = true;
                while (more && predicate(enumerator.Current))
                {
                    // If this is a Take then yield the current item.
                    if (!operation.IsSkip) yield return enumerator.Current;
                    more = enumerator.MoveNext();
                }

                // If there are no more items return
                if (!more) yield break;
            }

            // Now we need to decide what to do with the rest of the items. 
            // If there are no operations or the last one was a skip then
            // return the remaining items
            if (_operations.Count == 0 || _operations.Last().IsSkip)
            {
                do
                {
                    yield return enumerator.Current;
                } while (enumerator.MoveNext());
            }

            // Otherwise the last operation was a take and we're done.
        }
    }

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

    public ITakeAndSkip<T> ThenSkip(int number)
    {
        _operations.Add(TakeOrSkipOperation.Skip(number));
        return this;
    }

    public ITakeAndSkip<T> ThenSkipWhile(Func<T, bool> predicate)
    {
        _operations.Add(TakeOrSkipOperation.SkipWhile(predicate));
        return this;
    }

    public ITakeAndSkip<T> ThenTake(int number)
    {
        _operations.Add(TakeOrSkipOperation.Take(number));
        return this;
    }

    public ITakeAndSkip<T> ThenTakeWhile(Func<T, bool> predicate)
    {
        _operations.Add(TakeOrSkipOperation.TakeWhile(predicate));
        return this;
    }
}

public static class TakeAndSkipExtensions
{
    public static ITakeAndSkip<T> FirstTake<T>(this IEnumerable<T> source, int number)
    {
        return new TakeAndSkip<T>(source).ThenTake(number);
    }

    public static ITakeAndSkip<T> FirstSkip<T>(this IEnumerable<T> source, int number)
    {
        return new TakeAndSkip<T>(source).ThenSkip(number);
    }

    public static ITakeAndSkip<T> FirstTakeWhile<T>(this IEnumerable<T> source, Func<T, bool> predicate)
    {
        return new TakeAndSkip<T>(source).ThenTakeWhile(predicate);
    }

    public static ITakeAndSkip<T> FirstSkipWhile<T>(this IEnumerable<T> source, Func<T, bool> predicate)
    {
        return new TakeAndSkip<T>(source).ThenSkipWhile(predicate);
    }
}

将类似LINQ的流畅查询链接在一起

1 个答案: