chapter 1-6 minor update

Author: tibitoth

docs/seminar/01-csharp1/chapter1.md

@@ -340,3 +340,26 @@ Nem kell az `Add` függvényhívást és a lista referenciát kiírni, egyértel
     Ez a forma is ugyanolyan `Add` függvényhívásokra fordul, mint az eredeti változatban.
 
 Próbáljuk ki az alkalmazást! Láthatjuk, hogy a konstruktoron keresztül teljesen inicializálható `Person` példányok esetében a kiírás teljes, viszont vannak olyan `Student` példányok, ahol a kiírás üres értékeket talál. Ezzel a jelenséggel a következő gyakorlatokon tovább foglalkozunk.
+
+C# új verziójában megjelent a Collection Expression szintaxis is, amivel a kollekció inicializálás még egyszerűbbé válik, aminek a szintaxisa a `[]` között megadott elemekből áll. Itt nem kell megadni a típust sem, a fordító automatikusan kitalálja azt a bal oldalból, és működik a legtöbb kollekció típussal és tömbbel is.
+
+```csharp hl_lines="1-2 12"
+List<Person> people =
+[
+    new Person("Horváth Aladár", new DateTime(1991, 06, 10)),
+    new Person("Kovács István", new DateTime(1994, 04, 22)),
+    new Person("Kovács Géza", new DateTime(1998, 03, 16)),
+    new Student("Fel Elek", new DateTime(2002, 06, 10))
+    {
+        Neptun = "ABC123",
+        Major="Info BSc"
+    },
+    new Student("Hiány Áron", new DateTime(2000, 02, 13))
+];
+```
+
+Továbbá van lehetőség kollekciók összefűzésére is a `..` operátorral.
+
+```csharp
+List<Person> people2 = [ .. people, new Person("Kovács Béla", new DateTime(1995, 01, 01)) ];
+```

docs/seminar/02-csharp2/chapter2.md

@@ -47,7 +47,7 @@ dotnet <projektnév.dll>
 ```
 
 !!! tip "Parancssor aktuális mappája"
-    A dotnet parancshoz a dll könyvtárában kell lennünk. Ehhez a legegyszerűbb, ha a Windows fájlkezelőben a megfelelő könyvtárban állva az elérési útvonal mezőt átírjuk a `cmd` szövegre, majd kbd:\[ENTER\]-t nyomunk.
+    A dotnet parancshoz a dll könyvtárában kell lennünk. Ehhez a legegyszerűbb, ha a Windows fájlkezelőben a megfelelő könyvtárban állva az elérési útvonal mezőt átírjuk a `cmd` szövegre, majd ++enter++-t nyomunk.
 
 Adjunk a létrejövő projekthez egy `Dog` osztályt *Dog.cs* néven, ez lesz az adatmodellünk:
 
@@ -87,7 +87,7 @@ Ebben az esetben a típus egyértelműen `Dog`.
 Ha csak deklarálni szeretnénk egy változót (nem adunk értékül a változónak semmit), akkor nem használhatjuk a `var` kulcsszót, ugyanis nem következik a kódból a változó típusa.
 Ekkor explicit meg kell adnunk a típust.
 
-``` csharp hl_lines="5-10"
+``` csharp hl_lines="6-11"
 Dog banan = new Dog
 {
    Name = "Banán",
@@ -97,15 +97,15 @@ var watson = new Dog { Name = "Watson" };
 
 var unnamed = new Dog { DateOfBirth = new DateTime(2017, 02, 10) };
 var unknown = new Dog { };
-//watson = 3; // 
-//var error;  // 
+//watson = 3; // (1)
+//var error;  // (2)
 
 Console.WriteLine(banan);
 Console.ReadLine();
 ```
 
-* Fordítási hiba: a `watson` deklarációjakor eldőlt, hogy ő `Dog` típus, utólag nem lehet megváltoztatni és például számértéket értékül adni. Ez nem JavaScript.
-* Fordítási hiba: implicit típust csak úgy lehet deklarálni, ha egyúttal inicializáljuk is. Az inicializációs kifejezés alapján dől el (implicit) a példány típusa.
+1. Fordítási hiba: a `watson` deklarációjakor eldőlt, hogy ő `Dog` típus, utólag nem lehet megváltoztatni és például számértéket értékül adni. Ez nem JavaScript.
+2. Fordítási hiba: implicit típust csak úgy lehet deklarálni, ha egyúttal inicializáljuk is. Az inicializációs kifejezés alapján dől el (implicit) a példány típusa.
 
 Próbáljuk ki a nem forduló sorokat, nézzük meg a fordító hibaüzeneteit!
 
@@ -180,8 +180,8 @@ public class Dog
     public Dictionary<string, object>  Metadata { get; } = new();
     public object this[string key]
     {
-        get { return Metadata[key]; }
-        set { Metadata[key] = value; }
+        get => Metadata[key];
+        set => Metadata[key] = value;
     }
 }
 ```
@@ -217,7 +217,9 @@ var dogs = new Dictionary<string, Dog>
 };
 
 foreach (var dog in dogs)
+{
     Console.WriteLine($"{dog.Key} - {dog.Value}");
+}
 ```
 
 Próbáljuk ki - minden név-kutya párt ki kell írnia a szótárból.
@@ -236,7 +238,9 @@ var dogs = new Dictionary<string, Dog>
 //ArgumentNullException!
 ```
 
-Ez azonban kivételt okoz, amikor a kutya neve nincs kitöltve, azaz `null` értékű. Esetünkben elég lenne az adott változó neve szövegként. Erre jó a `nameof` operátor.
+Ez azonban kivételt okoz, amikor a kutya neve nincs kitöltve, azaz `null` értékű.
+Esetünkben elég lenne az adott változó neve szövegként.
+Erre jó a `nameof` operátor.
 
 ``` csharp
 var dogs = new Dictionary<string, Dog>
@@ -253,7 +257,8 @@ Ez a változat már nem fog kivételt okozni.
 
 A `nameof` operátor sokfajta nyelvi elemet támogat, vissza tudja adni egy változó, egy típus, egy property vagy egy függvény nevét is.
 
-A szótár feltöltését megírhatjuk kollekció inicializációval is. Ehhez kihasználjuk, hogy a szótár típus rendelkezik egy `Add` metódussal, amelyik egyszerűen egy kulcsot és egy hozzátartozó értéket vár:
+A szótár feltöltését megírhatjuk kollekció inicializációval is.
+Ehhez kihasználjuk, hogy a szótár típus rendelkezik egy `Add` metódussal, amelyik egyszerűen egy kulcsot és egy hozzátartozó értéket vár:
 
 ``` csharp
 var dogs = new Dictionary<string, Dog>

docs/seminar/03-linq/chapter3.md

@@ -53,14 +53,14 @@ static List<Dog> ListDogsByNamePrefix(IEnumerable<Dog> dogs, string prefix)
 
 Próbáljuk ki!
 
-A kód működik, viszont nem újrahasznosítható. 
+A kód működik, viszont nem újrahasznosítható.
 Ha bármi más alapján szeretnénk keresni a kutyák között (pl. a neve tartalmaz-e egy adott szövegrészt), mindig egy új segédfüggvényt kell készítenünk, ami rontja a kód újrahasznosíthatóságát.
 
 Oldjuk meg úgy, hogy az általános problémát is megoldjuk!
 Ehhez az szükséges, hogy a kollekciónk egyes elemein kiértékelhessünk egy, a hívó által megadott predikátumot.
 Készítsük el az általánosabb változatot, ehhez felhasználhatjuk a `ListDogsByNamePrefix` kódját.
 
-``` csharp hl_lines="1 6"
+``` csharp hl_lines="2 7"
 static List<Dog> ListDogsByPredicate(
     IEnumerable<Dog> dogs, Predicate<Dog> predicate)
 {
@@ -182,7 +182,7 @@ namespace HelloLinq.Extensions.Enumerable;
 
 public static class EnumerableExtensions
 {
-    public static int Sum<T> (IEnumerable<T>  source, Func<T, int>  sumSelector)
+    public static int Sum<T>(IEnumerable<T>  source, Func<T, int>  sumSelector)
     {
         var result = 0;
         foreach (var elem in source)
@@ -450,9 +450,13 @@ A fát kóddá fordíthatjuk a `Compile` metódus segítségével, mely a leford
 Console.WriteLine(e.Compile()(5));
 ```
 
-Bár az `Expression<>` emiatt okosabb választásnak tűnik, ám a LINQ-to-Objects alapinterfészének (ami a lekérdezőfüggvényeket biztosítja) függvényei `Func<>` / `Action<>` delegátokat várnak. Ami nem csoda, hiszen memóriabeli listákat általában sima programkóddal dolgozunk fel, nincs értelme felépíteni kifejezésfát csak azért, hogy utána egyből kóddá fordítsuk. Emellett más, memóriabeli adatokon dolgozó LINQ technológia is létezik, pl. LINQ-to-XML saját API-val (nem `IEnumerable<>` alaptípussal).
+Bár az `Expression<>` emiatt okosabb választásnak tűnik, ám a LINQ-to-Objects alapinterfészének (ami a lekérdezőfüggvényeket biztosítja) függvényei `Func<>` / `Action<>` delegátokat várnak.
+Ami nem csoda, hiszen memóriabeli listákat általában sima programkóddal dolgozunk fel, nincs értelme felépíteni kifejezésfát csak azért, hogy utána egyből kóddá fordítsuk.
+Emellett más, memóriabeli adatokon dolgozó LINQ technológia is létezik, pl. LINQ-to-XML saját API-val (nem `IEnumerable<>` alaptípussal).
 
-A nem memóriabeli adatokon, hanem például külső adatbázisból dolgozó LINQ provider-ek viszont `IQueryable<>`-t valósítanak meg. Az `IQueryable<>` az `IEnumerable<>`-ból származik, így neki is vannak `Func<>` / `Action<>`-ös függvényei, de emellett `Expression<>`-ösek is. Ez utóbbiak teszik lehetővé, hogy ne csak .NET kódot generáljanak a lambda kifejezésekből, hanem helyette pl. SQL kifejezést - hiszen egy relációs adatbázis adatfeldolgozó nyelve nem .NET, hanem valamilyen SQL dialektus.
+A nem memóriabeli adatokon, hanem például külső adatbázisból dolgozó LINQ provider-ek viszont `IQueryable<>`-t valósítanak meg.
+Az `IQueryable<>` az `IEnumerable<>`-ból származik, így neki is vannak `Func<>` / `Action<>`-ös függvényei, de emellett `Expression<>`-ösek is.
+Ez utóbbiak teszik lehetővé, hogy ne csak .NET kódot generáljanak a lambda kifejezésekből, hanem helyette pl. SQL kifejezést - hiszen egy relációs adatbázis adatfeldolgozó nyelve nem .NET, hanem valamilyen SQL dialektus.
 
 ### A LINQ providerek általános működése
 
@@ -462,4 +466,4 @@ Kimenetük: az adatforrásnak megfelelő nyelvű, a query-t végrehajtó kód (.
 
 LINQ-to-Objects esetén nincs valódi LINQ provider (a provider az `IQueryable.Provider`-en keresztül érhető el, de a `List<>` nem `IQueryable`!), hiszen nincs feladata: kódot kap bemenetül, ugyanazt kellene kimenetül adnia. A *LINQ-to-XML* is hasonló elven működik.
 
-Valódi LINQ providert valósít meg például az *Entity Framework*, de ezt a technológiát később tárgyaljuk.
+Valódi LINQ providert valósít meg például az *Entity Framework Core*, de ezt a technológiát később tárgyaljuk.