J'ai une liste de date de naissance. Je veux le convertir par tranche d'âge. c'est-à-dire: groupe 1: 0 à 15 ans, groupe 2: 15 à 20 ans etc.

Si vous souhaitez utiliser la méthode groupby, vous pouvez utiliser l'approche suivante mais c'est un peu compliqué et compliqué dans votre cas. Mais cela peut être suivi dans certains cas.

private static (List<Person> OlderPersons, List<Person> YoungerPersons) GroupByAgeV2(List<Person> people, DateTime refDate)
{
  var peopleHasBirtDate = people.Where(x => x.DateOfBirth.HasValue).ToList();

  var olderPersons = peopleHasBirtDate.Where(p => p.DateOfBirth >= refDate).ToList();
  var youngerPersons = peopleHasBirtDate.Where(p => p.DateOfBirth < refDate).ToList();

  return (OlderPersons: olderPersons, YoungerPersons: youngerPersons);

}

Cette approche semble meilleure et plus facile à lire dans votre cas

private static (List<Person> OlderPersons, List<Person> YoungerPersons) GroupByAgeV1(List<Person> people, DateTime refDate)
{
  var groupedDates = people.Where(x => x.DateOfBirth.HasValue).GroupBy(p => p.DateOfBirth >= refDate).ToList();

  var olderPersons = groupedDates.Where(g => g.Key == false)
                      .Select(g => g.ToList())
                      .ToList()
                        .FirstOrDefault();
  var youngerPersons = groupedDates.Where(g => g.Key == false)
                    .Select(g => g.ToList())
                    .ToList()
                      .FirstOrDefault();

  return (OlderPersons: olderPersons, YoungerPersons: youngerPersons);

}

Ajoutez une propriété (lecture seule) à votre classe, ou écrivez une extension pour calculer la tranche d'âge:

Dictionary<int, List<Person>> byAgeGroup = people
    .GroupBy(x => x.AgeGroup)
    .ToDictionary(x => x.Key, x => x.ToList());

Ensuite, obtenez un dictionnaire qui a l'ID de tranche d'âge (1, 2,3) comme clé et une liste de vos instances de classe appartenant à cette tranche d'âge comme valeur, comme suit:

public int AgeGroup
{
    get
    {
        if (!DateOfBirth.HasValue)
        {
            return 0;
        }
        int year = DateTime.Now.Year;
        int age = DateTime.Now.Year - DateOfBirth.Value.Year;
        return
            age <= 15 ? 1 :
            age <= 20 ? 2 :
            age <= 35 ? 3 :
            age <= 60 ? 4 : 5;
    }
}

Voici une application console simple qui adopte une approche similaire à celle décrite par @Oguz Ozgul:

var peopleGroupedByAge = people
    .GroupBy(p => p.AgeGroup)
    .OrderBy(g => g.Key);

Les éléments les plus importants sont Age et Propriétés calculées AgeGroup ajoutées à l'objet Person . Parcourez le code dans un débogueur et inspectez-y les valeurs - vous verrez qu'elles encapsulent la logique du calcul de la tranche d'âge dans laquelle une personne appartient.

Enfin, nous devons regrouper notre Personne code > les objets en groupes en fonction de leur tranche d'âge. Nous pouvons y parvenir par la méthode GroupBy :

using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApp3
{
    internal class Person
    {
        public string Name { get; set; }
        public DateTime DateOfBirth { get; set; }

        public int Age
            => (int) Math.Floor((DateTimeOffset.UtcNow - DateOfBirth).TotalDays / 365);

        public int AgeGroup
        {
            get
            {
                if (Age < 15) // [0,14]
                    return 1;
                if (Age < 20) // [15,19]
                    return 2;
                if (Age < 30) // [20,29]
                    return 3;
                if (Age < 40) // [30,39]
                    return 4;
                if (Age < 60) // [40, 59]
                    return 5;
                return 6; // 60+
            }
        }
    }

    internal class Program
    {
        private static readonly Dictionary<int, string> _ageGroupRanges
            = new Dictionary<int, string>
            {
                {1, "0 to 14"},
                {2, "15 to 19"},
                {3, "20 to 29"},
                {4, "30 to 39"},
                {5, "40 to 59"},
                {6, "60+"}
            };

        private static void Main(string[] args)
        {
            var people = new List<Person>
            {
                new Person {Name = "Joe", DateOfBirth = new DateTime(1980, 01, 01)},
                new Person {Name = "Dan", DateOfBirth = new DateTime(1982, 01, 01)},
                new Person {Name = "Laura", DateOfBirth = new DateTime(2010, 01, 01)},
                new Person {Name = "Beth", DateOfBirth = new DateTime(2020, 01, 01)}
            };
            var peopleGroupedByAge = people
                .GroupBy(p => p.AgeGroup)
                .OrderBy(g => g.Key);

            foreach (var group in peopleGroupedByAge)
            {
                var ageGroup = group.Key;
                var ageGroupRange = _ageGroupRanges[ageGroup];
                var namesOfPeopleInGroup = string.Join(", ", group.Select(p => p.Name));
                Console.WriteLine($"Age group {ageGroup} ({ageGroupRange}): {namesOfPeopleInGroup}");
            }

            Console.ReadKey(true);
        }
    }
}