LINQ i lambda — wybieranie danych krótkim zapisem

// 1. kto ma co najmniej 40 punktow
List<Uczestnik> zaliczyli = new List<Uczestnik>();
foreach (Uczestnik u in turniej)
{
    if (u.Punkty >= 40)
    {
        zaliczyli.Add(u);
    }
}

// 2. suma punktow
int suma = 0;
foreach (Uczestnik u in turniej)
{
    suma += u.Punkty;
}

// 3. srednia
double srednia = (double)suma / turniej.Count;

// 4. najlepszy wynik
int najlepszy = turniej[0].Punkty;
foreach (Uczestnik u in turniej)
{
    if (u.Punkty > najlepszy)
    {
        najlepszy = u.Punkty;
    }
}

List<Uczestnik> zaliczyli = turniej.Where(x => x.Punkty >= 40).ToList();
int suma       = turniej.Sum(x => x.Punkty);
double srednia = turniej.Average(x => x.Punkty);
int najlepszy  = turniej.Max(x => x.Punkty);

Func<Uczestnik, bool> warunek = x => x.Punkty >= 40;

//                                  ^   ^  ^
//                                  |   |  wynik (warunek do sprawdzenia)
//                                  |   strzalka - czytaj "daje"
//                                  parametr (jeden uczestnik)

IEnumerable<Uczestnik> mocni = turniej.Where(x => x.Punkty >= 40);
IEnumerable<Uczestnik> z3TP  = turniej.Where(x => x.Klasa == "3TP");
IEnumerable<Uczestnik> oboje = turniej.Where(x => x.Punkty >= 40 && x.Klasa == "3TP");

foreach (Uczestnik u in mocni)
{
    Console.WriteLine(u.Imie);
}

IEnumerable<string> imiona = turniej.Select(x => x.Imie);
IEnumerable<int> punkty       = turniej.Select(x => x.Punkty);
IEnumerable<string> wiersze   = turniej.Select(x => $"{x.Imie} - {x.Punkty} pkt");

Console.WriteLine(string.Join(", ", imiona));

// rosnaco po punktach
var a = turniej.OrderBy(x => x.Punkty);

// malejaco po punktach
var b = turniej.OrderByDescending(x => x.Punkty);

// malejaco po punktach, a przy remisie - krotszy czas wyzej
var c = turniej.OrderByDescending(x => x.Punkty).ThenBy(x => x.Czas);

// po klasie, a w klasie alfabetycznie
var d = turniej.OrderBy(x => x.Klasa).ThenBy(x => x.Imie);

int ilu        = turniej.Count();                       // wszyscy
int iluMocnych = turniej.Count(x => x.Punkty >= 40);    // z warunkiem
int suma       = turniej.Sum(x => x.Punkty);
double srednia = turniej.Average(x => x.Punkty);
int najwiecej  = turniej.Max(x => x.Punkty);
double najkrotszy = turniej.Min(x => x.Czas);

Console.WriteLine($"{ilu} osob, {iluMocnych} z wynikiem 40+, srednia {srednia:F2}");

bool ktokolwiek = turniej.Any();                          // czy cokolwiek jest
bool jestMistrz = turniej.Any(x => x.Punkty > 50);        // czy ktos przekroczyl 50
bool wszyscyZdali = turniej.All(x => x.Punkty >= 30);     // czy KAZDY ma 30+

Console.WriteLine($"{jestMistrz} / {wszyscyZdali}");

Uczestnik pierwszy = turniej.First();                        // pierwszy z listy
Uczestnik pierwszyZ2TP = turniej.First(x => x.Klasa == "2TP");

Uczestnik? moze = turniej.FirstOrDefault(x => x.Punkty > 100);
if (moze == null)
{
    Console.WriteLine("nikt nie przekroczyl 100 punktow");
}

// Uczestnik brak = turniej.First(x => x.Punkty > 100);   // WYJATEK!

var podium = turniej.OrderByDescending(x => x.Punkty).Take(3);
var poza   = turniej.OrderByDescending(x => x.Punkty).Skip(3);

// strona 2 listy po 10 pozycji:
var strona2 = turniej.OrderBy(x => x.Imie).Skip(10).Take(10);

var wynik = turniej
    .Where(x => x.Klasa.StartsWith("3"))        // 1. wybierz klasy trzecie
    .OrderByDescending(x => x.Punkty)           // 2. uloz od najlepszego
    .Take(3)                                    // 3. wez trzy pierwsze
    .Select(x => x.Imie);                       // 4. zostaw same imiona

Console.WriteLine(string.Join(", ", wynik));

// DOBRZE: najpierw odsiej, potem sortuj mniejszy zbior
turniej.Where(x => x.Punkty >= 40).OrderBy(x => x.Imie);

// DZIALA, ale sortuje wszystko po to, zeby wiekszosc wyrzucic
turniej.OrderBy(x => x.Imie).Where(x => x.Punkty >= 40);

// ZLE: Take przed OrderBy bierze trzy PRZYPADKOWE osoby i je sortuje
turniej.Take(3).OrderByDescending(x => x.Punkty);

// DOBRZE: najpierw uloz, potem wez trzy najlepsze
turniej.OrderByDescending(x => x.Punkty).Take(3);

List<Uczestnik> lista  = turniej.Where(x => x.Punkty >= 40).ToList();
Uczestnik[] tablica    = turniej.OrderBy(x => x.Imie).ToArray();

Dictionary<string, int> punktyPoImieniu =
    turniej.ToDictionary(x => x.Imie, x => x.Punkty);

Console.WriteLine(punktyPoImieniu["Kasia Nowak"]);

foreach (IGrouping<string, Uczestnik> grupa in turniej.GroupBy(x => x.Klasa))
{
    Console.WriteLine($"{grupa.Key}: {grupa.Count()} osob");

    foreach (Uczestnik u in grupa)
    {
        Console.WriteLine($"    {u.Imie} - {u.Punkty} pkt");
    }
}

var zestawienie = turniej
    .GroupBy(x => x.Klasa)
    .OrderByDescending(g => g.Sum(y => y.Punkty));

foreach (IGrouping<string, Uczestnik> g in zestawienie)
{
    Console.WriteLine($"{g.Key,-5} osob {g.Count()}  suma {g.Sum(y => y.Punkty),3}  srednia {g.Average(y => y.Punkty):F1}  najlepszy {g.Max(y => y.Punkty)}");
}

List<int> liczby = new List<int> { 1, 2, 3 };

var duze = liczby.Where(x => x > 1);        // tu jeszcze NIC sie nie policzylo

liczby.Add(10);                             // zmiana zrodla PO napisaniu zapytania

Console.WriteLine(string.Join(", ", duze)); // dopiero tu zapytanie sie wykonuje

var mocni = turniej.Where(x => { Console.WriteLine("sprawdzam"); return x.Punkty >= 40; });

Console.WriteLine(mocni.Count());     // przeglada cala liste
Console.WriteLine(mocni.Count());     // przeglada JESZCZE RAZ

List<Uczestnik> mocni = turniej.Where(x => x.Punkty >= 40).ToList();

Console.WriteLine(mocni.Count);       // gotowa lista, zero pracy
Console.WriteLine(mocni.Count);

// skladnia metod (ta, ktora uzywamy w calej lekcji)
var a = turniej
    .Where(x => x.Punkty >= 40)
    .OrderByDescending(x => x.Punkty)
    .Select(x => x.Imie);

// skladnia zapytania - dokladnie to samo
var b = from x in turniej
        where x.Punkty >= 40
        orderby x.Punkty descending
        select x.Imie;

// Program.cs - pelny plik
List<Uczestnik> turniej = new List<Uczestnik>
{
    new Uczestnik("Kasia Nowak", "3TP", 51, 62.5),
    new Uczestnik("Marek Lis",   "2TP", 34, 71.0),
    new Uczestnik("Ala Wrona",   "3TP", 42, 58.2),
    new Uczestnik("Piotr Dab",   "1TP", 51, 55.9),
    new Uczestnik("Ewa Sosna",   "2TP", 28, 80.4),
    new Uczestnik("Jan Klon",    "3TP", 45, 66.1)
};

Console.WriteLine("=== 1. kto zaliczyl (40 pkt i wiecej) ===");
foreach (Uczestnik u in turniej.Where(z => z.Punkty >= 40))
{
    Console.WriteLine($"  {u}");
}

Console.WriteLine();
Console.WriteLine("=== 2. klasyfikacja koncowa ===");
int miejsce = 1;
foreach (Uczestnik u in turniej.OrderByDescending(z => z.Punkty).ThenBy(z => z.Czas))
{
    Console.WriteLine($"  {miejsce}. {u}");
    miejsce++;
}

Console.WriteLine();
Console.WriteLine("=== 3. podium (same imiona) ===");
var podium = turniej
    .OrderByDescending(z => z.Punkty)
    .ThenBy(z => z.Czas)
    .Take(3)
    .Select(z => z.Imie);

Console.WriteLine("  " + string.Join(" | ", podium));

Console.WriteLine();
Console.WriteLine("=== 4. liczby ===");
Console.WriteLine($"  uczestnikow:      {turniej.Count()}");
Console.WriteLine($"  z wynikiem 40+:   {turniej.Count(z => z.Punkty >= 40)}");
Console.WriteLine($"  suma punktow:     {turniej.Sum(z => z.Punkty)}");
Console.WriteLine($"  srednia punktow:  {turniej.Average(z => z.Punkty):F2}");
Console.WriteLine($"  najlepszy wynik:  {turniej.Max(z => z.Punkty)}");
Console.WriteLine($"  najkrotszy czas:  {turniej.Min(z => z.Czas):F1} s");
Console.WriteLine($"  sredni czas:      {turniej.Average(z => z.Czas):F2} s");

Console.WriteLine();
Console.WriteLine("=== 5. sprawdzenia ===");
Console.WriteLine($"  ktos przekroczyl 50 pkt: {turniej.Any(z => z.Punkty > 50)}");
Console.WriteLine($"  kazdy ma co najmniej 30: {turniej.All(z => z.Punkty >= 30)}");
Console.WriteLine($"  ktos z klasy 4TP:        {turniej.Any(z => z.Klasa == "4TP")}");

Console.WriteLine();
Console.WriteLine("=== 6. szukanie jednego ===");
Uczestnik pierwszyZ2TP = turniej.First(z => z.Klasa == "2TP");
Console.WriteLine($"  pierwszy z 2TP: {pierwszyZ2TP.Imie}");

Uczestnik? rekordzista = turniej.FirstOrDefault(z => z.Punkty > 100);
if (rekordzista == null)
{
    Console.WriteLine("  nikt nie przekroczyl 100 punktow");
}

Console.WriteLine();
Console.WriteLine("=== 7. zestawienie po klasach ===");
var poKlasach = turniej
    .GroupBy(z => z.Klasa)
    .OrderByDescending(g => g.Sum(y => y.Punkty));

foreach (IGrouping<string, Uczestnik> g in poKlasach)
{
    Console.WriteLine($"  {g.Key,-5} osob {g.Count()}  suma {g.Sum(y => y.Punkty),3}  srednia {g.Average(y => y.Punkty),5:F1}");

    foreach (Uczestnik u in g.OrderByDescending(y => y.Punkty))
    {
        Console.WriteLine($"          {u.Imie,-14} {u.Punkty,3} pkt");
    }
}

Console.WriteLine();
Console.WriteLine("=== 8. leniwe kontra policzone ===");
List<Uczestnik> kopia = new List<Uczestnik>(turniej);

var leniwe = kopia.Where(z => z.Punkty >= 40);
List<Uczestnik> policzone = kopia.Where(z => z.Punkty >= 40).ToList();

kopia.Add(new Uczestnik("Zosia Buk", "1TP", 99, 50.0));

Console.WriteLine($"  zapytanie leniwe:   {leniwe.Count()} osob");
Console.WriteLine($"  lista policzona:    {policzone.Count} osob");

Console.WriteLine();
Console.WriteLine("=== 9. slownik imie -> punkty ===");
Dictionary<string, int> slownik = turniej.ToDictionary(z => z.Imie, z => z.Punkty);
Console.WriteLine($"  Ala Wrona ma {slownik["Ala Wrona"]} pkt");


class Uczestnik
{
    public string Imie { get; }
    public string Klasa { get; }
    public int Punkty { get; }
    public double Czas { get; }

    public Uczestnik(string imie, string klasa, int punkty, double czas)
    {
        Imie = imie;
        Klasa = klasa;
        Punkty = punkty;
        Czas = czas;
    }

    public override string ToString()
    {
        return $"{Imie,-14} {Klasa,-5} {Punkty,3} pkt   {Czas,5:F1} s";
    }
}