C# Labeled类代码示例

        public static void ILookup_MembersBehaveCorrectly(Labeled<ParallelQuery<int>> labeled, int count)
        {
            int NonExistentKey = count * 2;
            ILookup<int, int> lookup = labeled.Item.ToLookup(x => x);

            // Count
            Assert.Equal(count, lookup.Count);

            // Contains
            Assert.All(lookup, group => lookup.Contains(group.Key));
            Assert.False(lookup.Contains(NonExistentKey));

            // Indexer
            Assert.All(lookup, group => Assert.Equal(group, lookup[group.Key]));
            Assert.Equal(Enumerable.Empty<int>(), lookup[NonExistentKey]);

            // GetEnumerator
            IEnumerator e1 = ((IEnumerable)lookup).GetEnumerator();
            IEnumerator<IGrouping<int, int>> e2 = lookup.GetEnumerator();
            while (e1.MoveNext())
            {
                e2.MoveNext();
                Assert.Equal(((IGrouping<int,int>)e1.Current).Key, e2.Current.Key);
            }
            Assert.False(e2.MoveNext());
        }

        public static void AsSequential_LinqBinding(Labeled<ParallelQuery<int>> labeled, int count)
        {
            IEnumerable<int> seq = labeled.Item.AsSequential();

            // The LINQ Cast<T>() retains origin type for ParallelEnumerable  and Partitioner when unordered,
            // (and for all sources when ordered, due to the extra wrapper)
            // although aliased as IEnumerable<T>, so further LINQ calls work as expected.
            // If this test starts failing, update this test, and maybe mention it in release notes.
            Assert.IsNotType<ParallelQuery<int>>(seq.Cast<int>());
            Assert.True(seq.Cast<int>() is ParallelQuery<int>);

            Assert.False(seq.Concat(Enumerable.Range(0, count)) is ParallelQuery<int>);
            Assert.False(seq.DefaultIfEmpty() is ParallelQuery<int>);
            Assert.False(seq.Distinct() is ParallelQuery<int>);
            Assert.False(seq.Except(Enumerable.Range(0, count)) is ParallelQuery<int>);
            Assert.False(seq.GroupBy(x => x) is ParallelQuery<int>);
            Assert.False(seq.GroupJoin(Enumerable.Range(0, count), x => x, y => y, (x, g) => x) is ParallelQuery<int>);
            Assert.False(seq.Intersect(Enumerable.Range(0, count)) is ParallelQuery<int>);
            Assert.False(seq.Join(Enumerable.Range(0, count), x => x, y => y, (x, y) => x) is ParallelQuery<int>);
            Assert.False(seq.OfType<int>() is ParallelQuery<int>);
            Assert.False(seq.OrderBy(x => x) is ParallelQuery<int>);
            Assert.False(seq.OrderByDescending(x => x) is ParallelQuery<int>);
            Assert.False(seq.Reverse() is ParallelQuery<int>);
            Assert.False(seq.Select(x => x) is ParallelQuery<int>);
            Assert.False(seq.SelectMany(x => new[] { x }) is ParallelQuery<int>);
            Assert.False(seq.Skip(count / 2) is ParallelQuery<int>);
            Assert.False(seq.SkipWhile(x => true) is ParallelQuery<int>);
            Assert.False(seq.Take(count / 2) is ParallelQuery<int>);
            Assert.False(seq.TakeWhile(x => true) is ParallelQuery<int>);
            Assert.False(seq.Union(Enumerable.Range(0, count)) is ParallelQuery<int>);
            Assert.False(seq.Where(x => true) is ParallelQuery<int>);
            Assert.False(seq.Zip(Enumerable.Range(0, count), (x, y) => x) is ParallelQuery<int>);
        }

 public static void Any_AllFalse(Labeled<ParallelQuery<int>> labeled, int count)
 {
     ParallelQuery<int> query = labeled.Item;
     IntegerRangeSet seen = new IntegerRangeSet(0, count);
     Assert.False(query.Any(x => !seen.Add(x)));
     seen.AssertComplete();
 }

 public static void ToList(Labeled<ParallelQuery<int>> labeled, int count)
 {
     ParallelQuery<int> query = labeled.Item;
     int seen = 0;
     Assert.All(query.ToList(), x => Assert.Equal(seen++, x));
     Assert.Equal(count, seen);
 }

 public static void Distinct_Unordered_NotPipelined(Labeled<ParallelQuery<int>> labeled, int count)
 {
     ParallelQuery<int> query = labeled.Item;
     IntegerRangeSet seen = new IntegerRangeSet(0, count);
     Assert.All(query.Distinct(new ModularCongruenceComparer(count)).ToList(), x => seen.Add(x % count));
     seen.AssertComplete();
 }

 public static void Where_NotPipelined(Labeled<ParallelQuery<int>> labeled, int count)
 {
     ParallelQuery<int> query = labeled.Item;
     int seen = -2;
     Assert.All(query.Where(x => x % 2 == 0).ToList(), x => Assert.Equal(seen += 2, x));
     Assert.Equal(count - (count - 1) % 2 - 1, seen);
 }

 public static void ForAll(Labeled<ParallelQuery<int>> labeled, int count)
 {
     ParallelQuery<int> query = labeled.Item;
     IntegerRangeSet seen = new IntegerRangeSet(0, count);
     query.ForAll<int>(x => seen.Add(x));
     seen.AssertComplete();
 }

 public static void Cast_Unordered_Valid_NotPipelined(Labeled<ParallelQuery<int>> labeled, int count)
 {
     ParallelQuery<int> query = labeled.Item;
     IntegerRangeSet seen = new IntegerRangeSet(0, count);
     Assert.All(query.Select(x => (object)x).Cast<int>().ToList(), x => seen.Add(x));
     seen.AssertComplete();
 }

 public static void Single_NoMatch(Labeled<ParallelQuery<int>> labeled, int count, int element)
 {
     ParallelQuery<int> query = labeled.Item;
     IntegerRangeSet seen = new IntegerRangeSet(0, count);
     Assert.Throws<InvalidOperationException>(() => query.Single(x => !seen.Add(x)));
     seen.AssertComplete();
 }

 public static void SingleOrDefault_NoMatch(Labeled<ParallelQuery<int>> labeled, int count, int element)
 {
     ParallelQuery<int> query = labeled.Item;
     IntegerRangeSet seen = new IntegerRangeSet(0, count);
     Assert.Equal(default(int), query.SingleOrDefault(x => !seen.Add(x)));
     seen.AssertComplete();
 }

 public static void Sum_Int_Overflow(Labeled<ParallelQuery<int>> labeled, int count)
 {
     Functions.AssertThrowsWrapped<OverflowException>(() => labeled.Item.Select(x => x == 0 ? int.MaxValue : x).Sum());
     Functions.AssertThrowsWrapped<OverflowException>(() => labeled.Item.Select(x => x == 0 ? int.MaxValue : (int?)x).Sum());
     Functions.AssertThrowsWrapped<OverflowException>(() => labeled.Item.Sum(x => x == 0 ? int.MinValue : -x));
     Functions.AssertThrowsWrapped<OverflowException>(() => labeled.Item.Sum(x => x == 0 ? int.MinValue : -(int?)x));
 }

        public static void ToList_OperationCanceledException_PreCanceled(Labeled<ParallelQuery<int>> labeled, int count)
        {
            CancellationTokenSource cs = new CancellationTokenSource();
            cs.Cancel();

            Functions.AssertIsCanceled(cs, () => labeled.Item.WithCancellation(cs.Token).ToList());
        }

 public static void ToArray_Unordered(Labeled<ParallelQuery<int>> labeled, int count)
 {
     ParallelQuery<int> query = labeled.Item;
     IntegerRangeSet seen = new IntegerRangeSet(0, count);
     Assert.All(query.ToArray(), x => seen.Add(x));
     seen.AssertComplete();
 }

 public static void AsEnumerable(Labeled<ParallelQuery<int>> labeled, int count)
 {
     int seen = 0;
     IEnumerable<int> enumerable = labeled.Item.AsEnumerable();
     Assert.All(enumerable, x => Assert.Equal(seen++, x));
     Assert.Equal(count, seen);
 }

        public static void GetEnumerator_Unordered(Labeled<ParallelQuery<int>> labeled, int count)
        {
            IntegerRangeSet seen = new IntegerRangeSet(0, count);
            IEnumerator<int> enumerator = labeled.Item.GetEnumerator();
            if (count == 0 && labeled.ToString().Contains("Array"))
            {
                Assert.Same(enumerator, labeled.Item.GetEnumerator());
            }
            else
            {
                Assert.NotSame(enumerator, labeled.Item.GetEnumerator());
            }
            while (enumerator.MoveNext())
            {
                int current = enumerator.Current;
                seen.Add(current);
                Assert.Equal(current, enumerator.Current);
            }
            seen.AssertComplete();

            if (labeled.ToString().StartsWith("Enumerable.Range") || labeled.ToString().StartsWith("Partitioner"))
            {
                Assert.Throws<NotSupportedException>(() => enumerator.Reset());
            }
            else
            {
                enumerator.Reset();
                seen = new IntegerRangeSet(0, count);
                while (enumerator.MoveNext())
                {
                    Assert.True(seen.Add(enumerator.Current));
                }
                seen.AssertComplete();
            }
        }