public void Cycle3()
        {
            // A→B
              // ↑ ↓
              // └─C

              var graph = new[]
                  {
                    new
                    {
                      Value = "A",
                      DependsOn = "B"
                    },
                    new
                    {
                      Value = "B",
                      DependsOn = "C"
                    },
                    new
                    {
                      Value = "C",
                      DependsOn = "A"
                    },
                  };

              var byValue = graph.ToLookup(k => k.Value);
              var components = graph.DetectCycles(s => byValue[s.DependsOn]);

              Assert.AreEqual(1, components.Count);
              Assert.AreEqual(0, components.IndependentComponents().Count());
              Assert.AreEqual(1, components.Cycles().Count());
              Assert.AreEqual(3, components.Single().Count);
        }
示例#2
0
        public void TestReferenceType_ReferenceKey_NullComparer()
        {
            string[] strings = new [] {"0", "1", "2", "3", "4", "5", "6"};

            ILookup<string, string> lookup = strings.ToLookup (keySelector: it => it, comparer: null);

            Assert.That (lookup.Count, Is.EqualTo (strings.Length));
            foreach (string element in strings) {
                IEnumerable<string> enumerable = lookup [element];
                Assert.That (enumerable.Count (), Is.EqualTo (1));
                Assert.That (enumerable.ElementAt (0), Is.EqualTo (element));
            }
        }
        public void Cycle2()
        {
            var graph = new[]
                  {
                    TestValue.Create(1, 2),
                    TestValue.Create(2, 1),
                  };
              var byValue = graph.ToLookup(t => t.Value);
              var components = graph.DetectCycles(s => s.DependsOn.SelectMany(d => byValue[d]));

              Assert.AreEqual(1, components.Count);
              Assert.AreEqual(0, components.IndependentComponents().Count());
              Assert.AreEqual(1, components.Cycles().Count());
              Assert.AreEqual(2, components.First().Count());
        }
        public void ToLookup_ComplexSourceElementSelectorAndComparer_returnCorrectLookup()
        {
            var source = new[]
            {
                new { First = "Jan", Last = "Jansen" },
                new { First = "Klaas", Last = "Willemsen" },
                new { First = "Sjaakie", Last = (string)null },
                new { First ="Miep", Last = "JANSEN"},
            };

            var lookup = source.ToLookup(x => x.Last, x => x.First, StringComparer.OrdinalIgnoreCase);
            Assert.Equal(new string[] { "Sjaakie" }, lookup[null]);
            Assert.Equal(new string[] { "Jan", "Miep" }, lookup["Jansen"]);
            Assert.Equal(new string[] { "Klaas" }, lookup["Willemsen"]);
            Assert.Empty(lookup["Klaassen"]);
        }
示例#5
0
        public void TestReferenceType_NullArgumentExceptions()
        {
            string[] strings = new [] {"0", "1", "2", "3", "4", "5", "6"};
            IEqualityComparer<string> comparer = EqualityComparer<string>.Default;
            Func<string, string> func = it => it;

            Assert.Throws<ArgumentNullException> (() => strings.ToLookup<string, string> (keySelector: null));
            Assert.Throws<ArgumentNullException> (() => strings.ToLookup<string, string> (keySelector: null, comparer: comparer));

            Assert.Throws<ArgumentNullException> (() => strings.ToLookup<string, string, string> (keySelector: null, elementSelector: func));
            Assert.Throws<ArgumentNullException> (() => strings.ToLookup<string, string, string> (keySelector: null, elementSelector: func, comparer: comparer));

            Assert.Throws<ArgumentNullException> (() => strings.ToLookup<string, string, string> (keySelector: func, elementSelector: null));
            Assert.Throws<ArgumentNullException> (() => strings.ToLookup<string, string, string> (keySelector: func, elementSelector: null, comparer: comparer));

            Assert.Throws<ArgumentNullException> (() => strings.ToLookup<string, string, string> (keySelector: null, elementSelector: null));
            Assert.Throws<ArgumentNullException> (() => strings.ToLookup<string, string, string> (keySelector: null, elementSelector: null, comparer: comparer));
        }
        public void Cycle3WithStub()
        {
            TestValue<string> vD;
              var graph = new[]
                  {
                    TestValue.Create("A", "B"),
                    TestValue.Create("B", "C"),
                    TestValue.Create("C", "A", "D"),
                    vD = TestValue.Create("D"),
                  };
              var byValue = graph.ToLookup(t => t.Value);
              var components = graph.DetectCycles(s => s.DependsOn.SelectMany(d => byValue[d]));

              Assert.AreEqual(2, components.Count);
              Assert.AreEqual(1, components.IndependentComponents().Count());
              Assert.AreEqual(1, components.Cycles().Count());
              Assert.AreEqual(1, components.Count(c => c.Count == 3));
              Assert.AreEqual(1, components.Count(c => c.Count == 1));
              Assert.IsTrue(components.Single(c => c.Count == 1).Single() == vD);
        }
        public void LookupWithComparareAndElementSelector()
        {
            var people = new[] {
                new { First = "Jon", Last = "Skeet" },
                new { First = "Tom", Last = "SKEET" }, // Note upper-cased name
                new { First = "Juni", Last = "Cortez" },
                new { First = "Holly", Last = "Skeet" },
                new { First = "Abbey", Last = "Bartlet" },
                new { First = "Carmen", Last = "Cortez" },
                new { First = "Jed", Last = "Bartlet" }
            };

            var lookup = people.ToLookup(p => p.Last, p => p.First, StringComparer.OrdinalIgnoreCase);

            lookup["Skeet"].AssertSequenceEqual("Jon", "Tom", "Holly");
            lookup["Cortez"].AssertSequenceEqual("Juni", "Carmen");
            // The key comparer is used for lookups too
            lookup["BARTLET"].AssertSequenceEqual("Abbey", "Jed");

            lookup.Select(x => x.Key).AssertSequenceEqual("Skeet", "Cortez", "Bartlet");
        }
        public void TwoIsolated3Cycles()
        {
            var graph = new[]
                  {
                    TestValue.Create(1, 2),
                    TestValue.Create(2, 3),
                    TestValue.Create(3, 1),
                    TestValue.Create(4, 5),
                    TestValue.Create(5, 6),
                    TestValue.Create(6, 4),
                  };
              var byValue = graph.ToLookup(t => t.Value);
              var components = graph.DetectCycles(s => s.DependsOn.SelectMany(d => byValue[d]));

              Assert.AreEqual(2, components.Count);
              Assert.AreEqual(0, components.IndependentComponents().Count());
              Assert.AreEqual(2, components.Cycles().Count());
              Assert.IsTrue(components.All(c => c.Count == 3));
        }
示例#9
0
        public void TestReferenceType_ValueKey_ValueElement_NullComparer()
        {
            string[] strings = new [] {"0", "1", "2", "3", "4", "5", "6"};

            ILookup<int, int> lookup = strings.ToLookup (keySelector: it => int.Parse (it), elementSelector: it => int.Parse (it), comparer: null);

            Assert.That (lookup.Count, Is.EqualTo (strings.Length));
            foreach (string element in strings) {
                int key = int.Parse (element);
                int value = int.Parse (element);
                IEnumerable<int> enumerable = lookup [key];
                Assert.That (enumerable.Count (), Is.EqualTo (1));
                Assert.That (enumerable.ElementAt (0), Is.EqualTo (value));
            }
        }
        public void CycleWithDuplicates()
        {
            var testValues = new
                       {
                         A = TestValue.Create("a ", "e"),
                         B = TestValue.Create(" B", " c "),
                         A2 = TestValue.Create("A ", "C"),
                         C = TestValue.Create("C", "A", "D"),
                         D = TestValue.Create("d"),
                         E = TestValue.Create("E"),
                       };

              var graph = new[]
                  {
                    testValues.A,
                    testValues.B,
                    testValues.C,
                    testValues.D,
                    testValues.E,
                    testValues.A2,
                  };

              var ignoreCase = DerivedComparer.Create(StringComparer.OrdinalIgnoreCase, (string t) => t.Trim());
              var equalityComparer = TestValue.CreateComparer(ignoreCase);
              var vertexValueComparer = new VertexValueComparer<TestValue<string>>(equalityComparer);

              var byValue = graph.ToLookup(t => t.Value, ignoreCase);

              var vertices = VertexBuilder.BuildVertices(graph, s => s.DependsOn.SelectMany(d => byValue[d]), equalityComparer).ToList();
              Assert.AreEqual(6, vertices.Count, "every source element should yield a vertex");
              Assert.AreEqual(5, vertices.Distinct().Count(), "'A' and 'a ' should yield the exact same vertex");

              var finder = new StronglyConnectedComponentFinder<TestValue<string>>();

              var simpleComponents = finder.DetectCycle(vertices, vertexValueComparer);

              var components = simpleComponents.ExtractCycles(equalityComparer);

              Assert.AreEqual(4, components.Count, "It should be only 4 components");
              Assert.AreEqual(3, components.IndependentComponents().Count(), "B, D & E are acylic");
              Assert.AreEqual(1, components.Cycles().Count(), "Only 1 cycle should be found");

              Assert.AreEqual
            (2,
             components.Take(2)
                   .SelectMany(t => t)
                   .Intersect(new[] { testValues.D, testValues.E })
                   .Count(),
             "D & E should be the first components.");

              var component3 = components.Skip(2).First();
              var component4 = components.Skip(3).First();
              Assert.AreEqual(component3.Count, 2, "3rd component should be a cycle of 2");
              Assert.AreEqual
            (component3.Intersect(new[] { testValues.A, testValues.C }).Count(),
             2,
             "3rd component should be a cycle of A & C");

              Assert.AreEqual(testValues.B, component4.Single()); // 4th one has to be B (uses A)
        }
示例#11
0
        public void TestValueType_NullArgumentExceptions()
        {
            int[] ints = new [] {0, 1, 2, 3, 4, 5, 6};
            IEqualityComparer<int> comparer = EqualityComparer<int>.Default;
            Func<int, int> func = it => it;

            Assert.Throws<ArgumentNullException> (() => ints.ToLookup<int, int> (keySelector: null));
            Assert.Throws<ArgumentNullException> (() => ints.ToLookup<int, int> (keySelector: null, comparer: comparer));

            Assert.Throws<ArgumentNullException> (() => ints.ToLookup<int, int, int> (keySelector: null, elementSelector: func));
            Assert.Throws<ArgumentNullException> (() => ints.ToLookup<int, int, int> (keySelector: null, elementSelector: func, comparer: comparer));

            Assert.Throws<ArgumentNullException> (() => ints.ToLookup<int, int, int> (keySelector: func, elementSelector: null));
            Assert.Throws<ArgumentNullException> (() => ints.ToLookup<int, int, int> (keySelector: func, elementSelector: null, comparer: comparer));

            Assert.Throws<ArgumentNullException> (() => ints.ToLookup<int, int, int> (keySelector: null, elementSelector: null));
            Assert.Throws<ArgumentNullException> (() => ints.ToLookup<int, int, int> (keySelector: null, elementSelector: null, comparer: comparer));
        }
示例#12
0
 public void TestToLookupElement() {
     Func<bool> f = () => {
         var a = new[] { 1, 2, 3, 5 };
         var l = a.ToLookup(x => x & 1, x => x + 1);
         var l0 = l[0].ToArray();
         var l1 = l[1].ToArray();
         return l0.Length == 1 && l0[0] == 3 && l1.Length == 3;
     };
     this.Test(f, true);
 }
        public void Cycle4WithStubIgnoreCaseAndTrim()
        {
            var testValues = new
                       {
                         A = TestValue.Create("a ", "B"),
                         B = TestValue.Create(" B", " c "),
                         C = TestValue.Create("C", "A", "D"),
                         D = TestValue.Create("d"),
                         E = TestValue.Create("e", "b"),
                         A2 = TestValue.Create("A ", "B"),
                       };

              var graph = new[]
                  {
                    testValues.A,
                    testValues.B,
                    testValues.C,
                    testValues.D,
                    testValues.E,
                    testValues.A2,
                  };

              var ignoreCase = DerivedComparer.Create(StringComparer.OrdinalIgnoreCase, (string t) => t.Trim());

              var byValue = graph.ToLookup(t => t.Value, ignoreCase);
              var components = graph.DetectCycles(s => s.DependsOn.SelectMany(d => byValue[d]), TestValue.CreateComparer(ignoreCase));

              Assert.AreEqual(3, components.Count);
              Assert.AreEqual(2, components.IndependentComponents().Count()); // D & E are acyclic
              Assert.AreEqual(1, components.Cycles().Count());
              Assert.AreEqual(1, components.Count(c => c.Count == 3));
              Assert.AreEqual(2, components.Count(c => c.Count == 1));

              var component1 = components.First();

              Assert.IsTrue(component1.Single() == testValues.D); // first component has to be D (used by C which is in a cycle)

              var component2 = components.Skip(1).First().ToList();

              var component3 = components.Skip(2).First();

              Assert.IsTrue(component3.Single() == testValues.E); // 3rd component has to be E (requires B which is in a cycle)

              Assert.IsTrue(component2[0] == testValues.C); // first one has to be C (used by A & B)
              Assert.IsTrue(component2[1] == testValues.B); // first one has to be B (used by A)
              Assert.IsTrue(component2[2] == testValues.A); // first one has to be A (used by C, but was in the list )
        }
示例#14
0
        public void TestReferenceType_ValueKey_ReferenceElement_Comparer()
        {
            IEqualityComparer<int> comparer = EqualityComparer<int>.Default;
            string[] strings = new [] {"0", "1", "2", "3", "4", "5", "6"};

            ILookup<int, string> lookup = strings.ToLookup (keySelector: it => int.Parse (it), elementSelector: it => it, comparer: comparer);

            Assert.That (lookup.Count, Is.EqualTo (strings.Length));
            foreach (string element in strings) {
                int key = int.Parse (element);
                IEnumerable<string> enumerable = lookup [key];
                Assert.That (enumerable.Count (), Is.EqualTo (1));
                Assert.That (enumerable.ElementAt (0), Is.EqualTo (element));
            }
        }
示例#15
0
        public OperationHandler(ILightNodeOptions options, Type classType, MethodInfo methodInfo)
        {
            this.ClassName = classType.Name;
            this.MethodName = methodInfo.Name;
            this.Arguments = methodInfo.GetParameters()
                .Select(x => new ParameterInfoSlim(x))
                .ToArray();
            this.ParameterNames = Arguments.Select(x => x.Name).ToList().AsReadOnly();
            this.ReturnType = methodInfo.ReturnType;

            this.filters = options.Filters
                .Concat(classType.GetCustomAttributes<LightNodeFilterAttribute>(true))
                .Concat(methodInfo.GetCustomAttributes<LightNodeFilterAttribute>(true))
                .OrderBy(x => x.Order)
                .ToArray();

            var operationOption = methodInfo.GetCustomAttributes<OperationOptionAttribute>(true).FirstOrDefault()
                               ?? classType.GetCustomAttributes<OperationOptionAttribute>(true).FirstOrDefault();
            this.AcceptVerb = (operationOption != null && operationOption.AcceptVerbs != null)
                ? operationOption.AcceptVerbs.Value
                : options.DefaultAcceptVerb;

            var verbSpecifiedAttr = methodInfo.GetCustomAttributes<HttpVerbAttribtue>(true);
            if (verbSpecifiedAttr.Any())
            {
                this.AcceptVerb = verbSpecifiedAttr.Aggregate((AcceptVerbs)0, (x, y) => x | y.AcceptVerbs);
            }

            this.ForceUseFormatter = (operationOption != null && operationOption.ContentFormatter != null)
                ? operationOption.ContentFormatter
                : null;
            var formatterChoiceBase = new[] { options.DefaultFormatter }.Concat(options.SpecifiedFormatters).Where(x => x != null).ToArray();
            this.optionFormatters = formatterChoiceBase;
            this.formatterByExt = formatterChoiceBase.SelectMany(x => (x.Ext ?? "").Split('|'), (fmt, ext) => new { fmt, ext }).ToLookup(x => x.ext, x => x.fmt, StringComparer.OrdinalIgnoreCase);
            this.formatterByMediaType = formatterChoiceBase.ToLookup(x => x.MediaType, StringComparer.OrdinalIgnoreCase);
            this.formatterByContentEncoding = formatterChoiceBase.ToLookup(x => x.ContentEncoding, StringComparer.OrdinalIgnoreCase);

            this.AttributeLookup = classType.GetCustomAttributes(true)
                .Concat(methodInfo.GetCustomAttributes(true))
                .Cast<Attribute>()
                .ToLookup(x => x.GetType());

            foreach (var argument in this.Arguments)
            {
                if (!TypeBinder.IsAllowType(argument.ParameterType))
                {
                    throw new InvalidOperationException(string.Format("parameter is not allowed, class:{0} method:{1} paramName:{2} paramType:{3}",
                        classType.Name, methodInfo.Name, argument.Name, argument.ParameterType.FullName));
                }
            }

            // prepare lambda parameters
            var envArg = Expression.Parameter(typeof(IDictionary<string, object>), "environment");
            var envBind = Expression.Bind(typeof(LightNodeContract).GetProperty("Environment"), envArg);
            var args = Expression.Parameter(typeof(object[]), "args");
            var parameters = methodInfo.GetParameters()
                .Select((x, i) => Expression.Convert(Expression.ArrayIndex(args, Expression.Constant(i)), x.ParameterType))
                .ToArray();

            // Task or Task<T>
            if (typeof(Task).IsAssignableFrom(this.ReturnType))
            {
                // (object[] args) => new X().M((T1)args[0], (T2)args[1])...
                var lambda = Expression.Lambda<Func<IDictionary<string, object>, object[], Task>>(
                    Expression.Call(
                        Expression.MemberInit(Expression.New(classType), envBind),
                        methodInfo,
                        parameters),
                    envArg, args);

                if (this.ReturnType.IsGenericType && this.ReturnType.GetGenericTypeDefinition() == typeof(Task<>))
                {
                    this.handlerBodyType = HandlerBodyType.AsyncFunc;
                    this.methodAsyncFuncBody = lambda.Compile();

                    lock (taskResultExtractors)
                    {
                        if (!taskResultExtractors.ContainsKey(this.ReturnType))
                        {
                            // (object task) => (object)((Task<>).Result)
                            var taskParameter = Expression.Parameter(typeof(object), "task");
                            var resultLambda = Expression.Lambda<Func<object, object>>(
                                Expression.Convert(
                                    Expression.Property(
                                        Expression.Convert(taskParameter, this.ReturnType),
                                        "Result"),
                                    typeof(object)),
                                taskParameter);

                            var compiledResultLambda = resultLambda.Compile();

                            taskResultExtractors[this.ReturnType] = compiledResultLambda;
                        }
                    }
                }
                else
                {
                    this.handlerBodyType = HandlerBodyType.AsyncAction;
                    this.methodAsyncActionBody = lambda.Compile();
                }
            }
            else if (this.ReturnType == typeof(void)) // of course void
            {
                // (object[] args) => { new X().M((T1)args[0], (T2)args[1])... }
                var lambda = Expression.Lambda<Action<IDictionary<string, object>, object[]>>(
                    Expression.Call(
                        Expression.MemberInit(Expression.New(classType), envBind),
                        methodInfo,
                        parameters),
                    envArg, args);

                this.handlerBodyType = HandlerBodyType.Action;
                this.methodActionBody = lambda.Compile();
            }
            else // return T
            {
                // (object[] args) => (object)new X().M((T1)args[0], (T2)args[1])...
                var lambda = Expression.Lambda<Func<IDictionary<string, object>, object[], object>>(
                    Expression.Convert(
                        Expression.Call(
                            Expression.MemberInit(Expression.New(classType), envBind),
                            methodInfo,
                            parameters)
                    , typeof(object)),
                    envArg, args);

                this.handlerBodyType = HandlerBodyType.Func;
                this.methodFuncBody = lambda.Compile();
            }
        }
示例#16
0
        static void Main(string[] args)
        {
            List<int> list1 = new List<int>() { 1, 2, 3, 4, 5, 6 };
            List<int> list2 = new List<int>() { 6, 4, 2, 7, 9, 0 };

            // select many with list2.
            var query = list1.SelectMany(o => list2);

            foreach (var q in query)
                Console.Write("{0} ", q);

            // LINQ statement of SelectMany
            var query1 = from item1 in list1
                         from item2 in list2
                         select new { a = item1, b = item2 };

            foreach (var q in query1)
                Console.WriteLine("{0} ", q);

            // select many with list2
            var query2 = list1.SelectMany(o => list2, (a, b) => new { a, b });

            foreach (var q in query2)
                Console.WriteLine("{0} ", q);

            // join is equivalent to LINQ statement.
            //var query = from item1 in list1
            //            join item2 in list2 on item1 equals item2
            //            select item2;

            var query3 = list1.Join(
                list2,
                item1 => item1,
                item2 => item2,
                (item1, item2) => item2);

            foreach (var q in query3)
                Console.WriteLine("{0} ", q);

            // LINQ statement with group join
            var query4 = from item1 in list1
                         join item2 in list2 on item1 equals item2 into g
                         from item in g
                         select new { v = item1, c = item };

            foreach (var q in query4)
                Console.WriteLine("{0} count: {1} ", q.v, q.c);

            // LINQ method call equivalent to LINQ statement.            
            var query5 = list1.GroupJoin(
                list2,
                item1 => item1,
                item2 => item2,
                (item1, item2) => new { v = item1, c = item2.Count() });

            foreach (var q in query5)
                Console.WriteLine("{0} count: {1} ", q.v, q.c);

            //List<int> sequences = new List<int>() { 1, 2, 4, 3, 2, 4, 6, 4, 2, 4, 5, 6, 5, 2, 2, 6, 3, 5, 7, 5 };

            //var group = sequences.GroupBy(o => o);

            //foreach (var g in group)
            //    Console.WriteLine("{0} count: {1}", g.Key, g.Count());

            //var group2 = sequences.GroupBy(
            //    o => (o % 2 == 0) ? "Odd Number" : "Even Numbder",
            //    o2 => (o2 % 2 == 0) ? "Odd" : "Even");

            //foreach (var g in group2)
            //    Console.WriteLine(g.ToString());

            // ToLookup() demo
            var nameValuesGroup = new[]
            {
                new { name = "Allen", value = 65, group = "A" },
                new { name = "Abbey", value = 120, group = "A" },
                new { name = "Slong", value = 330, group = "B" },
                new { name = "George", value = 213, group = "C" },
                new { name = "Meller", value = 329, group = "C" },
                new { name = "Mary", value = 192, group = "B" },
                new { name = "Sue", value = 200, group = "C" }
            };
            var lookupValues = nameValuesGroup.ToLookup(c => c.group);
            foreach (var g in lookupValues)
            {
                Console.WriteLine("=== Group : {0} ===", g.Key);
                foreach (var item in g)
                    Console.WriteLine("name: {0}, value: {1}", item.name, item.value);
            }

            // order list.
            var nameValues = new[]
            {
                new { name = "Allen", value = 65 },
                new { name = "Abbey", value = 120 },
                new { name = "Slong", value = 330 },
                new { name = "George", value = 213 },
                new { name = "Meller", value = 329 },
                new { name = "Mary", value = 192 },
                new { name = "Sue", value = 200 }
            };

            // single sort
            var sortedNames = nameValues.OrderBy(c => c.name);
            var sortedValues = nameValues.OrderBy(c => c.value);
            Console.WriteLine("== OrderBy() demo: sortedNames ==");
            foreach (var q in sortedNames)
                Console.WriteLine("name: {0} value: {1} ", q.name, q.value);
            Console.WriteLine("== OrderBy() demo: sortedValues ==");
            foreach (var q in sortedValues)
                Console.WriteLine("name: {0} value: {1} ", q.name, q.value);

            // multiple sort conditions.
            var sortedByNameValues = nameValues.OrderBy(c => c.name).ThenBy(c =>
            c.value);
            var sortedByValueNames = nameValues.OrderBy(c => c.value).ThenBy(c => c.name);
            Console.WriteLine("== OrderBy() + ThenBy() demo: sortedByNameValues ==");
            foreach (var q in sortedByNameValues)
                Console.WriteLine("name: {0} value: {1} ", q.name, q.value);
            Console.WriteLine("== OrderBy() + ThenBy() demo: sortedByValueNames ==");
            foreach (var q in sortedByValueNames)
                Console.WriteLine("name: {0} value: {1} ", q.name, q.value);

            // Union/Intersect/Except
            int[] numbersA = { 0, 2, 4, 5, 6, 8, 9 };
            int[] numbersB = { 1, 3, 5, 7, 8 };

            var unionResults = numbersA.Union(numbersB);
            var intersectResults = numbersA.Intersect(numbersB);
            var exceptResults = numbersA.Except(numbersB);

            Console.WriteLine("== Union ==");

            foreach (var q in unionResults)
                Console.Write(q + " ");

            Console.WriteLine();
            Console.WriteLine("== Intersect ==");

            foreach (var q in intersectResults)
                Console.Write(q + " ");

            Console.WriteLine();
            Console.WriteLine("== Except ==");

            foreach (var q in exceptResults)
                Console.Write(q + " ");

            Console.WriteLine();

            // distinct
            int[] numberSeries = { 2, 2, 3, 5, 5 };

            var distinctValues = numberSeries.Distinct();

            Console.WriteLine("Distinct values from numberSeries");

            foreach (var q in distinctValues)
                Console.Write(q + " ");

            Console.WriteLine();

            var firstLastItems = new[] { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" };

            // First()/Last()
            string firstContainsO = firstLastItems.First(s => s.Contains('o'));
            string lastContainsO = firstLastItems.Last(s => s.Contains('o'));

            Console.WriteLine("First string starting with 'o': {0}", firstContainsO);
            Console.WriteLine("Last string starting with 'o': {0}", lastContainsO);
            
            // ElementAt()
            string itemAtThree = firstLastItems.ElementAt(2);
            string itemAtSix = firstLastItems.ElementAt(5);

            Console.WriteLine("3rd string in list : {0}", itemAtThree);
            Console.WriteLine("6th string in list : {0}", itemAtSix);

            // 存款
            double myBalance = 100.0;
            // 提款的額度
            int[] withdrawItems = { 20, 10, 40, 50, 10, 70, 30 };
            double balance = withdrawItems.Aggregate(myBalance,
            (originbalance, nextWithdrawal) =>
            {
                Console.WriteLine("originbalance: {0}, nextWithdrawal: {1}",
                originbalance, nextWithdrawal);
                Console.WriteLine("Withdrawal status: {0}", (nextWithdrawal <=
                originbalance) ? "OK" : "FAILED");
                // 若存款餘額不夠時,不會扣除,否則扣除提款額度。
                return ((nextWithdrawal <= originbalance) ? (originbalance -
                nextWithdrawal) : originbalance);
            });
            // 顯示最終的存款數
            Console.WriteLine("Ending balance: {0}", balance);

            var balanceStatus = withdrawItems.Aggregate(myBalance,
                (originbalance, nextWithdrawal) =>
                {
                    return ((nextWithdrawal <= originbalance) ? (originbalance -
                    nextWithdrawal) : originbalance);
                },
                (finalbalance) =>
                {
                    return (finalbalance >= 1000) ? "Normal" : "Lower";
                });

            Console.WriteLine("Balance status: {0}", balanceStatus);


            Console.ReadLine();
        }
示例#17
0
        public void TestValueType_ReferenceKey()
        {
            int[] ints = new [] {0, 1, 2, 3, 4, 5, 6};

            ILookup<string, int> lookup = ints.ToLookup (keySelector: it => it.ToString ());

            Assert.That (lookup.Count, Is.EqualTo (ints.Length));
            foreach (int element in ints) {
                string key = element.ToString ();
                IEnumerable<int> enumerable = lookup [key];
                Assert.That (enumerable.Count (), Is.EqualTo (1));
                Assert.That (enumerable.ElementAt (0), Is.EqualTo (element));
            }
        }
示例#18
0
        public void TestValueType_ReferenceKey_ValueElement_Comparer()
        {
            IEqualityComparer<string> comparer = EqualityComparer<string>.Default;
            int[] ints = new [] {0, 1, 2, 3, 4, 5, 6};

            ILookup<string, int> lookup = ints.ToLookup (keySelector: it => it.ToString (), elementSelector: it => it, comparer: comparer);

            Assert.That (lookup.Count, Is.EqualTo (ints.Length));
            foreach (int element in ints) {
                string key = element.ToString ();
                IEnumerable<int> enumerable = lookup [key];
                Assert.That (enumerable.Count (), Is.EqualTo (1));
                Assert.That (enumerable.ElementAt (0), Is.EqualTo (element));
            }
        }
示例#19
0
        public void TestValueType_ValueKey_ValueElement_NullComparer()
        {
            int[] ints = new [] {0, 1, 2, 3, 4, 5, 6};

            ILookup<int, int> lookup = ints.ToLookup (keySelector: it => it, elementSelector: it => it, comparer: null);

            Assert.That (lookup.Count, Is.EqualTo (ints.Length));
            foreach (int element in ints) {
                IEnumerable<int> enumerable = lookup [element];
                Assert.That (enumerable.Count (), Is.EqualTo (1));
                Assert.That (enumerable.ElementAt (0), Is.EqualTo (element));
            }
        }
示例#20
0
        public void TestValueType_ValueKey_ReferenceElement_NullComparer()
        {
            int[] ints = new [] {0, 1, 2, 3, 4, 5, 6};

            ILookup<int, string> lookup = ints.ToLookup (keySelector: it => it, elementSelector: it => it.ToString (), comparer: null);

            Assert.That (lookup.Count, Is.EqualTo (ints.Length));
            foreach (int element in ints) {
                string value = element.ToString ();
                IEnumerable<string> enumerable = lookup [element];
                Assert.That (enumerable.Count (), Is.EqualTo (1));
                Assert.That (enumerable.ElementAt (0), Is.EqualTo (value));
            }
        }
示例#21
0
        public void ToLookup()
        {
            var items = new[]
            {
                new KeyValueClass { Key = "a", Value = 2 },
                new KeyValueClass { Key = "a", Value = 1 },
                new KeyValueClass { Key = "b", Value = 1 },
                new KeyValueClass { Key = "c", Value = 3 },
                new KeyValueClass { Key = "c", Value = 4 },
                new KeyValueClass { Key = "c", Value = 1 },
            };

            var groups = items.ToLookup(x => x.Key);
            var a = groups["a"].Select(x => x.Value).ToArray();
            var b = groups["b"].Select(x => x.Value).ToArray();
            var c = groups["c"].Select(x => x.Value).ToArray();
            AssertEquals(a[0], 2);
            AssertEquals(a[1], 1);
            AssertEquals(b[0], 1);
            AssertEquals(c[0], 3);
            AssertEquals(c[1], 4);
            AssertEquals(c[2], 1);
        }
        public void ScriptTest()
        {
            var values = new[]
            {
                Tuple.Create("item1","path1"),
                Tuple.Create("item2","path2"),
                Tuple.Create("item1","path3")
            };

            var lookup = values.ToLookup(s => s.Item1, s => s.Item2);
            var config = Substitute.For<IContentDeliveryNetworkConfiguration>();
            config.Scripts.Returns(lookup);

            ContentDeliveryNetworkExtensions.Configuration = config;

            foreach (var value in values)
            {
                VerifyContentLinks(_myHtmlHelper.Script(value.Item1), value.Item1, ContentLinkType.Javascript, lookup);
            }
        }