GeneticAlgorithms.GeneticSolver.GetBest C# (CSharp) Method

        public string GetBest(int length,
                              string geneSet,
                              Func<string, int> getFitness,
                              Action<int, int, string> displayChild)
        {
            int maxIndividualsInPool = geneSet.Length * 3;
            int generationCount = 1;
            var uniqueIndividuals = new HashSet<string>();
            var parents = GenerateParents(length, geneSet)
                .Where(x => uniqueIndividuals.Add(x.Genes))
                .Take(maxIndividualsInPool)
                .ToList();
            foreach (var individual in parents)
            {
                individual.Fitness = getFitness(individual.Genes);
            }
            parents = parents.OrderBy(x => x.Fitness).ToList();

            displayChild(generationCount, parents.Last().Fitness, parents.Last().Genes);

            int worstParentFitness = parents.Last().Fitness;
            var children = GenerateChildren(parents, Crossover, geneSet);
            do
            {
                var improved = new List<Individual>();
                foreach (var child in children.Where(x => uniqueIndividuals.Add(x.Genes)))
                {
                    child.Fitness = getFitness(child.Genes);
                    if (worstParentFitness >= child.Fitness)
                    {
                        improved.Add(child);
                        if (worstParentFitness > child.Fitness)
                        {
                            displayChild(generationCount, child.Fitness, child.Genes);
                            worstParentFitness = child.Fitness;
                        }
                    }
                }
                generationCount++;
                if (improved.Any())
                {
                    parents = parents
                        .Concat(improved)
                        .OrderBy(x => x.Fitness)
                        .Take(maxIndividualsInPool)
                        .ToList();
                    children = GenerateChildren(parents, Crossover, geneSet);
                }
                else
                {
                    children = GenerateChildren(parents, Mutate, geneSet);
                }
            } while (parents[0].Fitness > 0);
            return parents[0].Genes;
        }

        public string Duplicate(string toMatch)
        {
            var solver = new GeneticSolver
                {
                    MaxSecondsWithoutImprovement = 1
                };
            int geneCount = toMatch.Length;
            Func<string, int> getFitness = child =>
            {
                int matches = Enumerable.Range(0, geneCount)
                    .Count(x => child[x] != toMatch[x]);
                return matches;
            };
            string geneSet = new String(toMatch.Distinct().ToArray());
            var stopwatch = new Stopwatch();
            stopwatch.Start();
            Action<int, int, string, string> displayCurrentBest =
                (generation, fitness, genes, strategy) =>
                    Console.WriteLine("generation\t{0} fitness\t{1} {2}\telapsed: {3}",
                                  generation.ToString().PadLeft(5, ' '),
                                  fitness.ToString().PadLeft(TotalWidth(toMatch), ' '),
                                  genes,
                                  stopwatch.Elapsed);

            string result = solver.GetBest(toMatch.Length,
                                           geneSet,
                                           getFitness,
                                           displayCurrentBest);
            Console.WriteLine(result);
            return result;
        }