如果在 LINQ 中找到，如何在最后一条记录上应用包含并删除？

Question

我有一个字符串列表，例如

AAPL,28/03/2012,88.34,88.778,87.187,88.231,163682382
AAPL,29/03/2012,87.54,88.08,86.747,87.123,151551216
FB,30/03/2012,86.967,87.223,85.42,85.65,182255227

现在我只想使用 LINQ 删除不包含 AAPL（符号名称）的最后一条记录。

下面我写了包含多行的代码，但我想把它变成单行代码，

fileLines = System.IO.File.ReadAllLines(fileName).AsParallel().Skip(1).ToList();
var lastLine = fileLines.Last();
if (!lastLine.Contains(item.sym))
{
    fileLines.RemoveAt(fileLines.Count - 1);
}

那么如何在单行 linq 查询中完成所有操作？

Answer 1

您可以使用三元运算符来决定要连接的尾部，如下所示。

fileLines
    = fileLines.Take(fileLines.Count())
               .Concat(fileLines.Last().Contains(item.sym) ? Enumerable.Empty
                                                           : new string[]{ item.sym });

您可以将其表述得更简洁，如下所示。

fileLines
    = System.IO.File.ReadAllLines(fileName)
                    .AsParallel()
                    .Skip(1)
                    .Take(fileLines.Count())
                    .Concat(fileLines.Last().Contains(item.sym) ? Enumerable.Empty
                                                                : new string[]{ item.sym });
                    .ToList();

话虽这么说，但这种努力值得商榷。懒惰评估的Linq扩展方法的积累很难调试。

Answer 2

我知道你需要简化过滤操作，而且，从我在你的案例中看到的情况来看，你只缺少一条信息（即当前项目是否是枚举集合中的最后一个）这将帮助您定义谓词。我现在要写的可能看起来不像"a simple single line"；然而，它将是一个可重用的扩展，它将提供这条信息（以及更多）而无需执行额外和不必要的循环或迭代。

最终产品将是：

IEnumerable<string> fileLines = System.IO.File.ReadLines(fileName).RichWhere((item, originalIndex, countedIndex, hasMoreItems) => hasMoreItems || item.StartsWith("AAPL"));

我受微软Enumerable at ReferenceSource启发编写的类似LINQ的扩展：

public delegate bool RichPredicate<T>(T item, int originalIndex, int countedIndex, bool hasMoreItems);
public static class EnumerableExtensions
{
    /// <remarks>
    /// This was contributed by Aly El-Haddad as an answer to this whosebug.com question:
    /// 
    /// </remarks>
    public static IEnumerable<T> RichWhere<T>(this IEnumerable<T> source, RichPredicate<T> predicate)
    {
        return new RichWhereIterator<T>(source, predicate);
    }
    private class RichWhereIterator<T> : IEnumerable<T>, IEnumerator<T>
    {
        private readonly int threadId;
        private readonly IEnumerable<T> source;
        private readonly RichPredicate<T> predicate;
        private IEnumerator<T> enumerator;
        private int state;
        private int countedIndex = -1;
        private int originalIndex = -1;
        private bool hasMoreItems;

        public RichWhereIterator(IEnumerable<T> source, RichPredicate<T> predicate)
        {
            threadId = Thread.CurrentThread.ManagedThreadId;
            this.source = source ?? throw new ArgumentNullException(nameof(source));
            this.predicate = predicate ?? ((item, originalIndex, countedIndex, hasMoreItems) => true);
        }
        public T Current { get; private set; }

        object IEnumerator.Current => Current;

        public void Dispose()
        {
            if (enumerator is IDisposable disposable)
                disposable.Dispose();
            enumerator = null;
            originalIndex = -1;
            countedIndex = -1;
            hasMoreItems = false;
            Current = default(T);
            state = -1;
        }

        public bool MoveNext()
        {
            switch (state)
            {
                case 1:
                    enumerator = source.GetEnumerator();
                    if (!(hasMoreItems = enumerator.MoveNext()))
                    {
                        Dispose();
                        break;
                    }
                    ++originalIndex;
                    state = 2;
                    goto case 2;
                case 2:
                    if (!hasMoreItems) //last predicate returned true and that was the last item
                    {
                        Dispose();
                        break;
                    }
                    T current = enumerator.Current;
                    hasMoreItems = enumerator.MoveNext();
                    ++originalIndex;
                    if (predicate(current, originalIndex - 1, countedIndex + 1, hasMoreItems))
                    {
                        ++countedIndex;
                        Current = current;
                        return true;
                    }
                    else if (hasMoreItems)
                    { goto case 2; }

                    //predicate returned false and there're no more items
                    Dispose();
                    break;
            }
            return false;
        }

        public void Reset()
        {
            Current = default(T);
            hasMoreItems = false;
            originalIndex = -1;
            countedIndex = -1;
            state = 1;
        }

        public IEnumerator<T> GetEnumerator()
        {
            if (threadId == Thread.CurrentThread.ManagedThreadId && state == 0)
            {
                state = 1;
                return this;
            }
            return new RichWhereIterator<T>(source, predicate) { state = 1 };
        }
        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
    }
}

RichPredicate<T>，可以认为是 Func<T, int, int, bool, bool> 提供有关每个项目的信息：

item: 要评估的项目。
originalIndex：该项目在其原始 IEnumerable<T> 源中的索引（直接传递给 RichWhere 的那个）。
countedIndex：该项目的索引IF 谓词的计算结果为真。
hasMoreItems：判断这是否是原始 IEnumerable<T> 源中的最后一项。

如果在 LINQ 中找到，如何在最后一条记录上应用包含并删除？

How to apply contain on last record and delete if found in LINQ?

c#

linq

filestream