C# List.Aggregate方法代码示例

        public BackPackIndividual BruteForce(BackPackEnvironment environment)
        {
            var possibleIndividuals = new List<BackPackIndividual>();

            int genomeSize = environment.ComputeGenomeSize();

            var chromosome = new int[genomeSize];
            var posssibilitiesPerInt = environment.AvailableItems.Count > 31 ?
                uint.MaxValue :
                (uint)1 << environment.AvailableItems.Count; // 2^n
            
            for (uint i = 0; i < posssibilitiesPerInt; i++)
            {
                for (int j = 0; j < genomeSize; j++)
                {
                    chromosome[j] = (int)i;
                    var individual = new BackPackIndividual(environment);
                    individual.Genome.Chromosome = (int[])chromosome.Clone();

                    if (environment.Validate(individual))
                    {
                        possibleIndividuals.Add(individual);
                    }
                }
            }

            return possibleIndividuals.Aggregate((a, b) => environment.RateFitness(a) > environment.RateFitness(b) ? a : b);
        }

        public void WhenADeckIsFlipped_TheCardsAreInExactlyTheReverseOrder()
        {
            var deck = new Deck();
            var expectedCardString = string.Empty;

            // Add Cards to Deck
            for (var i = 1; i <= 9; i++)
            {
                var card = deck.Push(new Cards.Number(i, CardColour.Blue));
                expectedCardString += string.Format("{0}{1}{2}", card.GetType(), card.Colour, card.Value);
            }

            // Flip the Deck
            deck.Flip();

            // Remove Cards from Deck
            var cards = new List<ICard>();
            while (deck.NumberOfCardsInDeck > 0)
            {
                cards.Add(deck.Pop());
            }

            // Build Compare Strings in reverse order because the Deck is a Stack (LIFO).  (I understand due to the way shuffling occurs that in theory the decks could be identical in some universe)
            var actualCardString = cards.Aggregate(string.Empty,
                                                   (current, t) =>
                                                   current + string.Format("{0}{1}{2}", t.GetType(), t.Colour, t.Value));

            Assert.AreEqual(actualCardString, expectedCardString);
        }

        public void GetBatchMessage()
        {
            var messages = new List<string> { "1", "2" };
            string batchMessages = messages.Aggregate("", (current, message) => current + (message + ","));

            Request request = new Request(ExtensionMessageEndPoint + "/" + batchMessages);
            Response response = RingCentralClient.GetPlatform().Get(request);
            Assert.IsTrue(response.IsMultiPartResponse());
            List<string> multiPartResult = response.GetMultiPartResponses();

            //We're interested in the response statuses and making sure the result was ok for each of the message id's sent.
            JToken responseStatuses = JObject.Parse(multiPartResult[0]);
            for (int i = 0; i < messages.Count; i++)
            {
                var status = (string)responseStatuses.SelectToken("response")[i].SelectToken("status");
                Assert.AreEqual(status, "200");
            }

            foreach (string res in multiPartResult.Skip(1))
            {
                JToken token = JObject.Parse(res);
                var id = (string)token.SelectToken("id");
                Assert.IsNotNull(id);
            }

        }

 public void TestSumAggregate()
 {
     List<int?> l = new List<int?>
     {
         0,
         3,
         null,
         4,
         5
     };
     int? sum = l.Sum();
     int? agg = l.Aggregate((int?)0, (s, x) => s + x);
     Assert.IsFalse(sum == null);
     Assert.IsTrue(agg == null);
 }

        public void FluentSearchOfDifferentFieldsInAListSerializesCorrectly()
        {
            var fieldsAndValues = new List<Tuple<string, string>>
            {
                Tuple.Create("field1", "value1"),
                Tuple.Create("field2", "value2"),
                Tuple.Create("field3", "value3"),
                Tuple.Create("field4", "value4"),
                Tuple.Create("field5", "value5"),
            };

            var s = fieldsAndValues.Aggregate((Term)null,
                (a, t) => a == null ? new RiakFluentSearch("bucket", t.Item1).Search(t.Item2) : a.And(t.Item1, t.Item2))
                .Build();

            var q = s.ToString();
            Assert.AreEqual("field1:value1 AND field2:value2 AND field3:value3 AND field4:value4 AND field5:value5", q);
        }

        public void Should_return_an_empty_list()
        {
            var SearchTags = new List<string> { "test" };
            using (var mongo = new Mongo())
            {
                mongo.Connect();
                var db = mongo.GetDatabase("posts");
                var posts = db.GetCollection<Post>();
                posts.Remove(x => true);
                posts.Insert(new Post() { Tags = new List<string> { "test", "funny" } });

                var result = SearchTags
                    .Aggregate(posts.Linq(), (current, tag) => current.Where(x => x.Tags.Contains(tag)))
                    .OrderByDescending(x => x.LastAccess)
                    .ToList();

                Assert.AreEqual(1, result.Count);
            }
        }

        private static int CalculatePrice(List<string> cart)
        {
            cart.Sort();

            List<List<string>> resultSet = new List<List<string>>();

            // TODO NEXT TIME
            // create permutations --> and calcPrice on those
            // find cheapest
            //  OR
            // calc price for each potential set?

            while (cart.Count > 0)
            {
                List<string> currentSet = GetSetThatDoesntHaveTheBook(cart[0], resultSet);

                if (currentSet == null)
                {
                    currentSet = new List<string>();
                    resultSet.Add(currentSet);

                }
                else
                {
                    currentSet.Add(cart[0]);
                    cart.RemoveAt(0);
                }

            }

            //Assert.That(resultSet.Count, Is.EqualTo(2));

            int calculatePrice =
                resultSet.Aggregate(
                0,
                (total, set) => total + CalculateSetPrice(set));

            //Assert.That(resultSet[0].Count, Is.EqualTo(2));
            //Assert.That(resultSet[1].Count, Is.EqualTo(1));

            //Assert.That(price1, Is.EqualTo(1520));
            //Assert.That(price2, Is.EqualTo(800));

            return calculatePrice;
        }

        public void TwoSameBooks_Costs1600C()
        {
            List<string> cart = new List<string>();

            cart.Add("Harry1");
            cart.Add("Harry1");

            double price = 0;

            price =
            cart.Aggregate(
                0,
                (total, title) => total + 800);

            Assert.That(price, Is.EqualTo(1600));
        }

 private static Expr BuildExpr(Expr[] vars, bool[] truthTable) {
     var vLen = vars.Length;
     var e = truthTable
         .Select((x, i) => new { x, i })
         .Where(x => x.x)
         .Select(x => x.i)
         .Aggregate((Expr)ctx.Literal(false), (acc, b) => {
             var ands = new List<Expr>();
             for (int i = 0, mask = 1; i < vLen; i++, mask <<= 1) {
                 if ((b & mask) != 0) {
                     // true
                     ands.Add(vars[i]);
                 } else {
                     // false
                     ands.Add(ctx.ExprGen.Not(vars[i]));
                 }
             }
             return ctx.ExprGen.Or(acc, ands.Aggregate((x, y) => ctx.ExprGen.And(x, y)));
         });
     return e;
 }

		public void PropertyChanges()
		{
			var task = new Task("A", new List<string> {"+fixsink", "+writenovel"},
			                    new List<string> {"@home", "@work"},
			                    "Write a chapter about fixing the sink");

			task.DueDate = DateTime.Now.AddDays(3).ToString();

			bool fired = false;

			List<String> changedProperties = new List<string>();

			task.PropertyChanged += (sender, e) =>
				{
					fired = true;
					changedProperties.Add(e.PropertyName);
				};

			// Setting task values to their current value shouldn't fire PropertyChanged
			task.Priority = task.Priority;
			task.DueDate = task.DueDate;
			task.Body = task.Body;

			Debug.WriteLine(changedProperties.Aggregate(String.Empty, (l, v) => l + " " + v));

			Assert.False(fired);

			// Setting them to new values should fire PropertyChanged
			task.Priority = "B";
			Debug.WriteLine(changedProperties.Aggregate(String.Empty, (l, v) => l + " " + v));
			Assert.True(fired);
			fired = false;

			task.DueDate = DateTime.Now.AddDays(4).ToString();
			Debug.WriteLine(changedProperties.Aggregate(String.Empty, (l, v) => l + " " + v));
			Assert.True(fired);
			fired = false;

			task.Body = "Delete chapter about the sink";
			Debug.WriteLine(changedProperties.Aggregate(String.Empty, (l, v) => l + " " + v));
			Assert.True(fired);
		}

        public void FluentSearchOfSameFieldsInAListSerializesCorrectly()
        {
            var fieldsAndValues = new List<string>
            {
                "value1",
                "value2",
                "value3",
                "value4",
                "value5"
            };

            var s = fieldsAndValues.Aggregate((Term)null,
                (a, v) => a == null ? new RiakFluentSearch("bucket", "field").Search(v) : a.And(v))
                .Build();

            var q = s.ToString();
            Assert.AreEqual("field:value1 AND field:value2 AND field:value3 AND field:value4 AND field:value5", q);
        }

            public void SaveVehicle()
            {
                var results = new List<string>();
                var success = true;
                using (var session = NHibernateSession.Current)
                using (var trans = session.BeginTransaction())
                {
                    var vehicle = GetValidVehicle();
                    session.Save(vehicle);
                    if (vehicle.Id == 0)
                    {
                        results.Add("Failed to save vehicle");
                        success = false;
                    }
                    if (success)
                    {
                        results.Add("Success");
                    }
                    trans.Rollback();
                }

                Assert.IsTrue(success, results.Aggregate((i, j) => i + j));
            }

        protected void Run(Action whatToRun, string testNameSuffix = "", Action before = null, Action after = null)
        {
            before = before ?? new Action(() => {});
            after = after ?? new Action(() => {});
            var success = false;
            var tries = 1;
            var fails = new List<string>();

            while(!success)
            {
                results = new List<double>();
                for(var i = 0; i < WarmUpRounds; i++)
                {
                    before();
                    whatToRun();
                    after();
                }

                while(true)
                {
                    before();
                    Measure(whatToRun);
                    after();

                    if(results.Count >= MinimalNumberOfRuns)
                    {
                        var currentAverage = results.Average();
                        var currentStdDev = results.StandardDeviation();
                        results.RemoveAll(x => Math.Abs(x - currentAverage) > 3*currentStdDev);
                        currentStdDev = results.StandardDeviation();
                        currentAverage = results.Average();
                        if(currentStdDev/currentAverage <= MinimalRequiredStandardDeviation)
                        {
                            success = true;
                            break;
                        }
                    }
                    if(results.Count > MaximalNumberOfRuns)
                    {
                        fails.Add(string.Format("Maximal number of runs {0} was exceeded, with standard deviation {1:0.00} > {2:0.00}. (Try {3}).", MaximalNumberOfRuns,
                                               results.StandardDeviation()/results.Average(), MinimalRequiredStandardDeviation, tries));
                        break;
                    }
                }
                if(tries++ >= MaximalRetriesCount)
                {
                    Assert.Fail(fails.Aggregate((x, y) => x + Environment.NewLine + y));
                }
            }
            var average = results.Average();
            var stdDev = results.StandardDeviation();
            var testName = string.Format("{0}:{1}", TestContext.CurrentContext.Test.Name, testNameSuffix);
            resultsDb.Append(new Result(testName, average, stdDev, SetUp.TestDate));
            File.AppendAllLines(SetUp.TestLogFileName, new [] { string.Format("{0}\t{1}s\t{2:0.00}", testName, average.NormalizeDecimal(), stdDev/average) } );
        }