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); }
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"]); }
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)); }
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) }
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)); }
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 ) }
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)); } }
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(); } }
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(); }
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)); } }
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)); } }
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)); } }
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)); } }
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); } }