将序列中某个数字的连续出现替换为该数字的单个出现

试试这个:

var intList = new List<int>() { 1, 1, 2, 2, 3, 3, 4, 1, 1, 5, 6, 7, 1, 1 };
var intObsrvr = intList.ToObservable();

var query =
    intObsrvr
        .Scan(
            new { skip = false, value = int.MinValue },
            (a, x) =>  new { skip = (a.value == 1) && (x == 1) , value = x })
        .Where(x => !x.skip)
        .Select(x => x.value);

我觉得 .Scan 被低估了。

你也可以使用 .Publish / Zip / SelectMany :

var query =
    intObsrvr.Publish(
        xs => xs
            .StartWith(int.MinValue)
            .Zip(xs, (z, x) => z == 1 & x == 1 ? new int[] { } : new [] { x })
            .SelectMany(x => x));

你挑吧。

var query =
    intObsrvr.Publish(
        xs => xs
            .StartWith(int.MinValue)
            .Zip(xs, (z, x) => z == 1 & x == 1
                ? Observable.Empty<int>()
                : Observable.Return(x))
            .SelectMany(x => x));

更多选择。

另一个 Zip 不带变量 SelectMany :

var observable = new List<int> { 1, 1, 2, 2, 3, 3, 4, 1, 1, 5, 6, 7, 1, 1 }
    .ToObservable();

observable.StartWith(int.MinValue).Zip(observable, (previous, current) => (previous, current))
    .Where(t => t.current != 1 || t.current != t.previous)
    .Select(t => t.current);

如果内置的方法与您的要求不匹配,则始终可以创建自己的方法。

一个 DistinctUntilChanged 满足您的需求非常简单:

public static IEnumerable<T> DistinctUntilChanged<T>(
    this IEnumerable<T> source) 
{
    using (var e = source.GetEnumerator())
    {
        if (!e.MoveNext())
            yield break;

        yield return e.Current;
        var previous = e.Current;

        while (e.MoveNext())
        {
            if (!e.Current.Equals(previous))
            {
                yield return e.Current;
                previous = e.Current;
            }
        }
    }
}