ReactiveX 学习笔记（11）对 LINQ 的扩展
Interactive Extensions（Ix）
本文的主题为 Ix 库，对 LINQ 的扩展。
Buffer
Ix.NET Buffer
Ix.NET BufferTest
Buffer 方法将源序列按照起始位置和元素个数分成若干组，形成序列的序列。
var rng = Enumerable.Range(0, 10);
var res = rng.Buffer(3).ToList();
// res.Count == 4
// res[0] == { 0, 1, 2 }
// res[1] == { 3, 4, 5 }
// res[2] == { 6, 7, 8 }
// res[3] == { 9 }
var rng = Enumerable.Range(0, 10);
var res = rng.Buffer(5).ToList();
// res.Count == 2
// res[0] == { 0, 1, 2, 3, 4 }
// res[1] == { 5, 6, 7, 8, 9 }
var rng = Enumerable.Empty<int>();
var res = rng.Buffer(5).ToList();
// res.Count == 0
var rng = Enumerable.Range(0, 10);
var res = rng.Buffer(3, 2).ToList();
// res.Count == 5
// res[0] == { 0, 1, 2 }
// res[1] == { 2, 3, 4 }
// res[2] == { 4, 5, 6 }
// res[3] == { 6, 7, 8 }
// res[4] == { 8, 9 }
var rng = Enumerable.Range(0, 10);
var res = rng.Buffer(3, 4).ToList();
// res.Count == 3
// res[0] == { 0, 1, 2 }
// res[1] == { 4, 5, 6 }
// res[2] == { 8, 9 }
Case
Case 方法根据回调函数的结果选择并返回 Dictionary 参数中的序列。
var x = 1;
var d = 'd';
var res = EnumerableEx.Case<int, char>(() => x, new Dictionary<int, IEnumerable<char>>
{
{ 0, new[] { 'a' } },
{ 1, new[] { 'b' } },
{ 2, new[] { 'c' } },
{ 3, EnumerableEx.Defer(() => new[] { d }) },
});
// res.Single() == 'b'
// res.Single() == 'b'
x = 0;
// res.Single() == 'a'
x = 2;
// res.Single() == 'c'
x = 3;
// res.Single() == 'd'
d = 'e';
// res.Single() == 'e'
x = 4;
Assert.True(res.IsEmpty());
var x = 1;
var d = 'd';
var res = EnumerableEx.Case<int, char>(() => x, new Dictionary<int, IEnumerable<char>>
{
{ 0, new[] { 'a' } },
{ 1, new[] { 'b' } },
{ 2, new[] { 'c' } },
{ 3, EnumerableEx.Defer(() => new[] { d }) },
}, new[] { 'z' });
// res.Single() == 'b'
// res.Single() == 'b'
x = 0;
// res.Single() == 'a'
x = 2;
// res.Single() == 'c'
x = 3;
// res.Single() == 'd'
d = 'e';
// res.Single() == 'e'
x = 4;
// res.Single() == 'z'
Catch
var ex = new MyException();
var res = EnumerableEx.Throw<int>(ex).Catch<int, MyException>(e => { Assert.Same(ex, e); return new[] { 42 }; }).Single();
// res == 42
var ex = new MyException();
var res = EnumerableEx.Throw<int>(ex).Catch<int, Exception>(e => { Assert.Same(ex, e); return new[] { 42 }; }).Single();
// res == 42
var ex = new MyException();
AssertThrows<MyException>(() =>
{
EnumerableEx.Throw<int>(ex).Catch<int, InvalidOperationException>(e => { Assert.True(false); return new[] { 42 }; }).Single();
});
var xs = Enumerable.Range(0, 10);
var res = xs.Catch<int, MyException>(e => { Assert.True(false); return new[] { 42 }; });
// res == xs
var xss = new[] { Enumerable.Range(0, 5), Enumerable.Range(5, 5) };
var res = EnumerableEx.Catch(xss);
// res == Enumerable.Range(0, 5)
var xss = new[] { Enumerable.Range(0, 5), Enumerable.Range(5, 5) };
var res = xss.Catch();
// res == Enumerable.Range(0, 5)
var xss = new[] { Enumerable.Range(0, 5), Enumerable.Range(5, 5) };
var res = xss[0].Catch(xss[1]);
// res == Enumerable.Range(0, 5)
var xss = new[] { Enumerable.Range(0, 5).Concat(EnumerableEx.Throw<int>(new MyException())), Enumerable.Range(5, 5) };
var res = EnumerableEx.Catch(xss);
// res == Enumerable.Range(0, 10)
var xss = new[] { Enumerable.Range(0, 5).Concat(EnumerableEx.Throw<int>(new MyException())), Enumerable.Range(5, 5) };
var res = xss.Catch();
// res == Enumerable.Range(0, 10)
var xss = new[] { Enumerable.Range(0, 5).Concat(EnumerableEx.Throw<int>(new MyException())), Enumerable.Range(5, 5) };
var res = xss[0].Catch(xss[1]);
// res == Enumerable.Range(0, 10)
var e1 = new MyException();
var ex1 = EnumerableEx.Throw<int>(e1);
var e2 = new MyException();
var ex2 = EnumerableEx.Throw<int>(e2);
var e3 = new MyException();
var ex3 = EnumerableEx.Throw<int>(e3);
var xss = new[] { Enumerable.Range(0, 2).Concat(ex1), Enumerable.Range(2, 2).Concat(ex2), ex3 };
var res = xss.Catch();
var e = res.GetEnumerator();
HasNext(e, 0);
HasNext(e, 1);
HasNext(e, 2);
HasNext(e, 3);
AssertThrows<MyException>(() => e.MoveNext(), ex => ex == e3);
var xs = new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
var res = xs.Catch<int, MyException>(e => { Assert.False(true); return new[] { 42 }; });
// res == xs
var xss = new[] { new[] { 0, 1, 2, 3, 4 }, new[] { 5, 6, 7, 8, 9 } };
var res = EnumerableEx.Catch(xss);
// res == Enumerable.Range(0, 5)));
var xss = new[] { new[] { 0, 1, 2, 3, 4 }, new[] { 5, 6, 7, 8, 9 } };
var res = xss.Catch();
// res == Enumerable.Range(0, 5)));
var xss = new[] { new[] { 0, 1, 2, 3, 4 }, new[] { 5, 6, 7, 8, 9 } };
var res = xss[0].Catch(xss[1]);
// res == Enumerable.Range(0, 5)));
var xss = new[] { new[] { 0, 1, 2, 3, 4 }.Concat(EnumerableEx.Throw<int>(new MyException())), new[] { 5, 6, 7, 8, 9 } };
var res = EnumerableEx.Catch(xss);
// res == Enumerable.Range(0, 10)));
var xss = new[] { new[] { 0, 1, 2, 3, 4 }.Concat(EnumerableEx.Throw<int>(new MyException())), new[] { 5, 6, 7, 8, 9 } };
var res = xss.Catch();
// res == Enumerable.Range(0, 10)));
var xss = new[] { new[] { 0, 1, 2, 3, 4 }.Concat(EnumerableEx.Throw<int>(new MyException())), new[] { 5, 6, 7, 8, 9 } };
var res = xss[0].Catch(xss[1]);
// res == Enumerable.Range(0, 10)));
var e1 = new MyException();
var ex1 = EnumerableEx.Throw<int>(e1);
var e2 = new MyException();
var ex2 = EnumerableEx.Throw<int>(e2);
var e3 = new MyException();
var ex3 = EnumerableEx.Throw<int>(e3);
var xss = new[] { new[] { 0, 1 }.Concat(ex1), new[] { 2, 3 }.Concat(ex2), ex3 };
var res = xss.Catch();
var e = res.GetEnumerator();
HasNext(e, 0);
HasNext(e, 1);
HasNext(e, 2);
HasNext(e, 3);
AssertThrows<MyException>(() => e.MoveNext(), ex => ex == e3);
Concat
Ix.NET Concat
Ix.NET ConcatTest
Concat 方法将若干序列连接起来。
var res = new[]
{
new[] { 1, 2, 3 },
new[] { 4, 5 }
}.Concat();
// res == { 1, 2, 3, 4, 5 }
var i = 0;
var xss = Enumerable.Range(0, 3).Select(x => Enumerable.Range(0, x + 1)).Do(_ => ++i);
var res = xss.Concat().Select(x => i + " - " + x).ToList();
/*
res == {
"1 - 0",
"2 - 0",
"2 - 1",
"3 - 0",
"3 - 1",
"3 - 2",
}
*/
var res = EnumerableEx.Concat(
new[] { 1, 2, 3 },
new[] { 4, 5 }
);
// res == { 1, 2, 3, 4, 5 }
Create
Ix.NET Create
Ix.NET CreateTest
Create 方法使用协程创建序列。
private static IEnumerator<int> MyEnumerator()
{
yield return 1;
yield return 2;
}
var hot = false;
var res = EnumerableEx.Create<int>(() =>
{
hot = true;
return MyEnumerator();
});
// hot == false
var e = res.GetEnumerator();
// hot == true
HasNext(e, 1);
HasNext(e, 2);
NoNext(e);
hot = false;
var f = ((IEnumerable)res).GetEnumerator();
// hot == true
var xs = EnumerableEx.Create<int>(async yield =>
{
var i = 0;
while (i < 10)
{
await yield.Return(i++);
}
});
var j = 0;
foreach (var elem in xs)
{
// elem == j
j++;
}
// j == 10
var xs = EnumerableEx.Create<int>(async yield =>
{
var i = 0;
while (true)
{
if (i == 10)
{
await yield.Break();
return;
}
await yield.Return(i++);
}
});
var j = 0;
foreach (var elem in xs)
{
// elem == j
j++;
}
// j == 10
Defer
Defer 方法使用返回序列的回调函数创建序列。
var i = 0;
var n = 5;
var xs = EnumerableEx.Defer(() =>
{
i++;
return Enumerable.Range(0, n);
});
// i == 0
// xs.ToList() == Enumerable.Range(0, n)
// i == 1
n = 3;
// xs.ToList() == Enumerable.Range(0, n)
// i == 2
Distinct / DistinctUntilChanged
Ix.NET Distinct / DistinctUntilChanged
Ix.NET DistinctTest
Ix.NET DistinctUntilChangedTest
Distinct 方法去除序列中的重复元素。
DistinctUntilChanged 方法去除序列中邻近的重复元素。
var res = Enumerable.Range(0, 10).Distinct(x => x % 5).ToList();
// res == Enumerable.Range(0, 5)
private class MyEqualityComparer : IEqualityComparer<int>
{
public bool Equals(int x, int y)
{
return x % 2 == y % 2;
}
public int GetHashCode(int obj)
{
return EqualityComparer<int>.Default.GetHashCode(obj % 2);
}
}
var res = Enumerable.Range(0, 10).Distinct(x => x % 5, new MyEqualityComparer()).ToList();
// res =={ 0, 1 }
var res = new[] { 1, 2, 2, 3, 3, 3, 2, 2, 1 }.DistinctUntilChanged().ToList();
// res == { 1, 2, 3, 2, 1 }
var res = new[] { 1, 1, 2, 3, 4, 5, 5, 6, 7 }.DistinctUntilChanged(x => x / 2).ToList();
// res == { 1, 2, 4, 6 }
Do / DoWhile
Ix.NET Do / DoWhile
Ix.NET DoTest
Ix.NET DoWhileTest
Do 方法让序列在枚举元素时执行指定的函数。
DoWhile 方法通过模拟 do ... while 语句生成新的序列：无限次重复源序列中的所有元素直到指定条件不再满足为止。
var n = 0;
Enumerable.Range(0, 10).Do(x => n += x).ForEach(_ => { });
// n == 45
var n = 0;
Enumerable.Range(0, 10).Do(x => n += x, () => n *= 2).ForEach(_ => { });
// n == 90
var ex = new MyException();
var ok = false;
AssertThrows<MyException>(() =>
EnumerableEx.Throw<int>(ex).Do(x => { Assert.True(false); }, e => { Assert.Equal(ex, e); ok = true; }).ForEach(_ => { })
);
// ok == true
var obs = new MyObserver();
Enumerable.Range(0, 10).Do(obs).ForEach(_ => { });
// obs.Done == true
// obs.Sum == 45
private class MyObserver : IObserver<int>
{
public int Sum;
public bool Done;
public void OnCompleted()
{
Done = true;
}
public void OnError(Exception error)
{
throw new NotImplementedException();
}
public void OnNext(int value)
{
Sum += value;
}
}
var sum = 0;
var done = false;
Enumerable.Range(0, 10).Do(x => sum += x, ex => { throw ex; }, () => done = true).ForEach(_ => { });
// done == true
// sum == 45
var x = 5;
var res = EnumerableEx.DoWhile(EnumerableEx.Defer(() => new[] { x }).Do(_ => x--), () => x > 0).ToList();
// res == { 5, 4, 3, 2, 1 }
var x = 0;
var res = EnumerableEx.DoWhile(EnumerableEx.Defer(() => new[] { x }).Do(_ => x--), () => x > 0).ToList();
// res == { 0 }
Expand
Ix.NET Expand
Ix.NET ExpandTest
Expand 方法执行以下操作
- 对源序列中的元素依次调用指定函数，将所生成的多个序列平坦化形成序列1（即执行 SelectMany 方法），将源序列与序列1相连接形成新序列1。
- 对序列1中的元素依次调用指定函数，将所生成的多个序列平坦化形成序列2（即执行 SelectMany 方法），将新序列1与序列2相连接形成新序列2。
- 重复以上步骤，直至某个序列n为空时返回最终所形成的新序列。
var res = new[] { 0 }.Expand(x => new[] { x + 1 }).Take(10).ToList();
// res == Enumerable.Range(0, 10)
var res = new[] { 3 }.Expand(x => Enumerable.Range(0, x)).ToList();
var exp = new[] {
3,
0, 1, 2,
0,
0, 1,
0
};
// res == exp
Finally
Ix.NET Finally
Ix.NET FinallyTest
var done = false;
var xs = Enumerable.Range(0, 2).Finally(() => done = true);
// done == false
var e = xs.GetEnumerator();
// done == false
HasNext(e, 0);
// done == false
HasNext(e, 1);
// done == false
NoNext(e);
// done == true
var done = false;
var xs = Enumerable.Range(0, 2).Finally(() => done = true);
// done == false
var e = xs.GetEnumerator();
// done == false
HasNext(e, 0);
// done == false
e.Dispose();
// done == true
var done = false;
var ex = new MyException();
var xs = EnumerableEx.Throw<int>(ex).Finally(() => done = true);
// done == false
var e = xs.GetEnumerator();
// done == false
try
{
HasNext(e, 0);
Assert.True(false);
}
catch (MyException ex_)
{
Assert.Same(ex, ex_);
}
// done == true
ForEach
Ix.NET ForEach
Ix.NET ForEachTest
ForEach 方法枚举序列，为每一个元素调用指定函数，有不带下标和带下标两个版本。
var n = 0;
Enumerable.Range(5, 3).ForEach(x => n += x);
// n == 5 + 6 + 7
var n = 0;
Enumerable.Range(5, 3).ForEach((x, i) => n += x * i);
// n == 5 * 0 + 6 * 1 + 7 * 2
For
For 方法枚举源序列，将每一个元素都映射为一个序列，然后连接这些序列。
var res = EnumerableEx.For(new[] { 1, 2, 3 }, x => Enumerable.Range(0, x)).ToList();
// res == { 0, 0, 1, 0, 1, 2 }
Generate
Ix.NET Generate
Ix.NET GenerateTest
Generate 方法通过模拟 for 循环来生成序列。
var res = EnumerableEx.Generate(0, x => x < 5, x => x + 1, x => x * x).ToList();
// res == { 0, 1, 4, 9, 16 }
Hide
Hide 方法隐藏序列的真实类型。
var xs = new List<int> { 1, 2, 3 };
var ys = xs.Hide();
// ys is not List<int>
// xs == ys
If
If 方法根据给定条件（谓词函数）的结果
- 在两个给定序列中选择其中之一。
- 在给定序列和空序列中选择其中之一。
var x = 5;
var res = EnumerableEx.If(() => x > 0, new[] { +1 }, new[] { -1 });
// res.Single() == +1
x = -x;
// res.Single() == -1
var x = 5;
var res = EnumerableEx.If(() => x > 0, new[] { +1 });
// res.Single() == +1
x = -x;
// res.IsEmpty() == true
IgnoreElements
Ix.NET IgnoreElements
Ix.NET IgnoreElementsTest
IgnoreElements 方法将源序列转换为空序列。
var n = 0;
Enumerable.Range(0, 10).Do(_ => n++).IgnoreElements().Take(5).ForEach(_ => { });
// n == 10
IsEmpty
Ix.NET IsEmpty
Ix.NET IsEmptyTest
IsEmpty 方法判断序列是否为空。
// Enumerable.Empty<int>().IsEmpty() == true
// new[] { 1 }.IsEmpty() == false
Max / MaxBy
Ix.NET Max / MaxBy
Ix.NET MaxTest
Ix.NET MaxByTest
Max / MaxBy 方法返回序列中的最大值。
Max 带有一个用于比较序列中元素的 comparer 参数（IComparer 接口的实例）。
MaxBy 带有一个用于转换序列中元素的 keySelector 参数（回调函数）。
private class Mod7Comparer : IComparer<int>
{
public int Compare(int x, int y)
{
return Comparer<int>.Default.Compare(x % 7, y % 7);
}
}
// new[] { 2, 5, 3, 7 }.Max(new Mod7Comparer()) == 5
var res = new[] { 2, 5, 0, 7, 4, 3, 6, 2, 1 }.MaxBy(x => x % 3);
// res == { 2, 5, 2 }
Memoize
Ix.NET Memoize
Ix.NET MemoizeTest
Min / MinBy
Ix.NET Min / MinBy
Ix.NET MinTest
Ix.NET MinByTest
Min / MinBy 方法返回序列中的最小值。
Min 带有一个用于比较序列中元素的 comparer 参数（IComparer 接口的实例）。
MinBy 带有一个用于转换序列中元素的 keySelector 参数（回调函数）。
private class Mod3Comparer : IComparer<int>
{
public int Compare(int x, int y)
{
return Comparer<int>.Default.Compare(x % 3, y % 3);
}
}
// new[] { 5, 3, 7 }.Min(new Mod3Comparer()) == 3
var res = new[] { 2, 5, 0, 7, 4, 3, 6, 2, 1 }.MinBy(x => x % 3);
// res == { 0, 3, 6 }
OnErrorResumeNext
Ix.NET OnErrorResumeNext
Ix.NET OnErrorResumeNextTest
OnErrorResumeNext 方法将若干序列连接起来，忽略序列中抛出的异常。
var xs = new[] { 1, 2 };
var ys = new[] { 3, 4 };
var res = xs.OnErrorResumeNext(ys);
// res == { 1, 2, 3, 4 }
var xs = new[] { 1, 2 }.Concat(EnumerableEx.Throw<int>(new MyException()));
var ys = new[] { 3, 4 };
var res = xs.OnErrorResumeNext(ys);
// res == { 1, 2, 3, 4 }
var xs = new[] { 1, 2 };
var ys = new[] { 3, 4 };
var zs = new[] { 5, 6 };
var res = EnumerableEx.OnErrorResumeNext(xs, ys, zs);
// res == { 1, 2, 3, 4, 5, 6 }
var xs = new[] { 1, 2 }.Concat(EnumerableEx.Throw<int>(new MyException()));
var ys = new[] { 3, 4 };
var zs = new[] { 5, 6 };
var res = EnumerableEx.OnErrorResumeNext(xs, ys, zs);
// res == { 1, 2, 3, 4, 5, 6 }
var xs = new[] { 1, 2 };
var ys = new[] { 3, 4 };
var res = new[] { xs, ys }.OnErrorResumeNext();
// res == { 1, 2, 3, 4 }
var xs = new[] { 1, 2 }.Concat(EnumerableEx.Throw<int>(new MyException()));
var ys = new[] { 3, 4 };
var res = new[] { xs, ys }.OnErrorResumeNext();
// res == { 1, 2, 3, 4 }
Publish
Ix.NET Publish
Ix.NET PublishTest
Repeat
Ix.NET Repeat
Ix.NET RepeatTest
EnumerableEx.Repeat(n) 返回由元素 n 组成的无限序列。
x.Repeat() 返回由序列 x 中的所有元素无限次重复而生成的序列。
x.Repeat(n) 返回由序列 x 中的所有元素经过 n 次重复生成的序列。
var xs = EnumerableEx.Repeat(42).Take(1000);
// xs.All(x => x == 42) == true
// xs.Count() == 1000
var i = 0;
var xs = new[] { 1, 2 }.Do(_ => i++).Repeat();
var res = xs.Take(10).ToList();
// res.Count == 10
// res.Buffer(2).Select(b => b.Sum()).All(x => x == 3) == true
// i == 10
var i = 0;
var xs = new[] { 1, 2 }.Do(_ => i++).Repeat(5);
var res = xs.ToList();
// res.Count == 10
// res.Buffer(2).Select(b => b.Sum()).All(x => x == 3) == true
// i == 10
Retry
var xs = Enumerable.Range(0, 10);
var res = xs.Retry();
// res == xs
var xs = Enumerable.Range(0, 10);
var res = xs.Retry(2);
// res == xs
var ex = new MyException();
var xs = Enumerable.Range(0, 2).Concat(EnumerableEx.Throw<int>(ex));
var res = xs.Retry(2);
var e = res.GetEnumerator();
HasNext(e, 0);
HasNext(e, 1);
HasNext(e, 0);
HasNext(e, 1);
AssertThrows<MyException>(() => e.MoveNext(), ex_ => ex == ex_);
Return
Ix.NET Return
Ix.NET ReturnTest
Return 方法返回由一个元素组成的序列。
// EnumerableEx.Return(42).Single() == 42
Scan
Scan 方法转换序列：
- Scan 带有一个有返回值的二元函数和一个可选的初值。
- 结果序列的第 1 项没有初值时等于将二元函数应用到源序列的第 1 项和第 2 项后所得到的结果，有初值时等于将二元函数应用到初值和源序列的第 1 项后所得到的结果。
- 结果序列的第 n + 1 项等于将二元函数应用到结果序列的第 n 项和源序列的第 n + 1 项后所得到的结果。
var res = Enumerable.Range(0, 5).Scan((n, x) => n + x).ToList();
// res == { 1, 3, 6, 10 }
var res = Enumerable.Range(0, 5).Scan(10, (n, x) => n - x).ToList();
// res == { 10, 9, 7, 4, 0 }
SelectMany
Ix.NET SelectMany
Ix.NET SelectManyTest
SelectMany 方法将源序列中的所有元素都映射成指定序列，然后连接这些序列。
var res = new[] { 1, 2 }.SelectMany(new[] { 'a', 'b', 'c' }).ToList();
// res == { 'a', 'b', 'c', 'a', 'b', 'c' }
Share
SkipLast
Ix.NET SkipLast
Ix.NET SkipLastTest
SkipLast 方法略过序列尾部的 n 个元素，返回其余元素组成的序列。
var e = Enumerable.Range(0, 5);
var r = e.SkipLast(3).ToList();
// r == e.Take(2)
StartWith
Ix.NET StartWith
Ix.NET StartWithTest
StartWith 方法在序列之前插入指定的（1 个或多个）元素。
var e = Enumerable.Range(1, 5);
var r = e.StartWith(0).ToList();
// r == Enumerable.Range(0, 6)
TakeLast
Ix.NET TakeLast
Ix.NET TakeLastTest
TakeLast 方法返回由序列尾部的 n 个元素组成的序列。
var e = Enumerable.Range(0, 5);
var r = e.TakeLast(3).ToList();
// r == e.Skip(2)
Throw
Using
While
While 方法通过模拟 while 语句生成新的序列：只要指定条件满足就无限次重复源序列中的所有元素。
var x = 5;
var res = EnumerableEx.While(() => x > 0, EnumerableEx.Defer(() => new[] { x }).Do(_ => x--)).ToList();
// res == { 5, 4, 3, 2, 1 }
var x = 0;
var res = EnumerableEx.While(() => x > 0, EnumerableEx.Defer(() => new[] { x }).Do(_ => x--)).ToList();
// res == { }
