feat/update: ORM and Covariance/Contravariance explained and Explicit Loading

Author: RedIsGaming

notes_wpfw/.obsidian/workspace.json

@@ -13,7 +13,7 @@
             "state": {
               "type": "markdown",
               "state": {
-                "file": "csharp/wpfw_deel1/week1/csharp.md",
+                "file": "csharp/wpfw_deel1/week4/orm_en_linq.md",
                 "mode": "source",
                 "source": false
               }
@@ -85,7 +85,7 @@
             "state": {
               "type": "backlink",
               "state": {
-                "file": "csharp/wpfw_deel1/week1/csharp.md",
+                "file": "csharp/wpfw_deel1/week4/orm_en_linq.md",
                 "collapseAll": false,
                 "extraContext": false,
                 "sortOrder": "alphabetical",
@@ -102,7 +102,7 @@
             "state": {
               "type": "outgoing-link",
               "state": {
-                "file": "csharp/wpfw_deel1/week1/csharp.md",
+                "file": "csharp/wpfw_deel1/week4/orm_en_linq.md",
                 "linksCollapsed": false,
                 "unlinkedCollapsed": true
               }
@@ -125,7 +125,7 @@
             "state": {
               "type": "outline",
               "state": {
-                "file": "csharp/wpfw_deel1/week1/csharp.md"
+                "file": "csharp/wpfw_deel1/week4/orm_en_linq.md"
               }
             }
           }
@@ -148,13 +148,14 @@
   },
   "active": "9f997fb097ca76a3",
   "lastOpenFiles": [
+    "csharp/wpfw_deel1/week7/specflow.md",
     "csharp/wpfw_deel1/week2/testen_mocks.md",
     "csharp/wpfw_deel1/week3/async_(en_functioneel)_programmeren.md",
     "csharp/wpfw_deel1/week4/orm_en_linq.md",
     "csharp/wpfw_deel1/week1/csharp.md",
-    "csharp/wpfw_deel1/week7/specflow.md",
-    "csharp/wpfw_deel1/week6/api.md",
+    "primaryconstructor_dependency.png",
     "csharp/wpfw_deel1/week5/internet.md",
+    "csharp/wpfw_deel1/week6/api.md",
     "Pasted image 20231210153422.png",
     "mock_result.png",
     "Pasted image 20231209171503.png",

notes_wpfw/csharp/wpfw_deel1/week1/csharp.md

@@ -157,7 +157,9 @@ public class Program
 > The current levels have the following difficulties: Easy. 
 > Just fucking easy!!! and Hard.
 
-## Contra- and Covariance
+## #Contravariance and #Covariance
+
+### #Contravariance and #Covariance Example 1
 
 ```C#
 //namespace ConsoleApp1  
@@ -184,14 +186,20 @@ class Consumer<T> : IConsumer<T> //Contravariance, no return, args.
     Console.WriteLine($"This contravariance returns: {obj}.\n");  
   }  
 }  
-  
-public class Variance {} //This class won't be used for this part.
 
 //Add this classes/interfaces in a seperate file or place it somewhere you like.
 
 ```
 
-Hier komt later wat uitleg.
+Hierboven is de layout voor #contravariantie en #covariantie. Schrik niet. Ik zal precies uitleggen wat het nou eigenlijk is. We maken 2 #interface en #class aan. In IProducer passen we #covariantie toe. Dit geven we expliciet met het keyword #out. Je kunt het zien als argument is uit de method en als return type. #T heeft een return type met waarde #T.
+
+Daarna laten we #class Producer inheriten van IProducer. Beide hebben de #generics waarde van #T. Voor #T returnen we #default. Dit zet alle waardes op #null of de absolute 0 waarde wanneer dit van toepassing is. Dan hebben we een #interface IConsumer. Hier passen we #contravariantie toe. Met het keyword #in maak je #T expliciet #contravariant.
+
+Je ziet dat we geen return type hebben. Wel hebben we een obj argument van type #T. #in is als argument in de method. Dit is van laag naar hoog, #contravariantie is van hoog naar laag. Vervolgens hebben we een #class Consumer met type #T als #generics type. Daarna implementeren we de method met argument obj van type #T. We zetten hier onze #code.
+
+> We zetten daar het volgende in: #Console.WriteLine($"This contravariance returns: {obj}.\n");
+
+### #Contravariance and #Covariance Result
 
 ```C#
 namespace ConsoleApp1;
@@ -214,7 +222,116 @@ public class Program
 
 ```
 
-> Het volgende resultaat is: This contravariance returns: h.
+We roepen het programma aan met de #interface en maken twee objecten aan. Hierboven zie je #Covariance en #Contravariance in actie. Het is duidelijk wat het resultaat is van deze code.
+
+> Het volgende resultaat is: This #contravariance returns: h.
+
+### #Contravariance and #Covariance Example 2
+
+We maken een super simpel programma. 2 #class met eentje genaamd: Base en de andere genaamd: Derived. Deze inherited van Base. Beide #class hebben hun eigen method, die iets uitprinten in de #Console . In Program hebben we ook 2 methods die we gebruiken voor de #Action. In de uitleg in de #code kun je precies zien hoe dit nou eigenlijk te werk gaat.
+
+```C#
+namespace ConsoleApp1; 
+
+public class Base 
+{ 
+  public void PrintBase() 
+  { 
+    Console.WriteLine("Base"); 
+  } 
+} 
+
+public class Derived : Base 
+{ 
+  public void PrintDerived() 
+  { 
+    Console.WriteLine("Derived"); 
+  } 
+} 
+
+public class Program 
+{ 
+  private static void PrintActionBase(Base b) 
+  { 
+    Console.WriteLine("Action Base"); 
+  } 
+  
+  private static void PrintActionDerived(Derived d) 
+  { 
+    Console.WriteLine("Action Derive"); 
+  } 
+  
+  public static void Main() 
+  { 
+    var base1 = new Base(); //Invariant met implicit typing 
+    Derived derived1 = new(); //Invariant met new() object
+    
+    object Base base2 = new Derived(); //Covariant, hoog naar laag 
+    Derived derived2 = new Base(); //Contravariant, laag naar hoog
+      
+    List<Base> base3 = new List<Derived>(); //Covariant, hoog naar laag 
+    List<Derived> derived3 = new List<Base>(); //Contravariant, laag naar hoog
+      
+	IEnumerable<Base> base4 = new List<Derived>(); //Covariant, werkt met een type dat hoger is. //In dit geval de IEnumerable. Interfaces kunnen alleen voor de eerste komen te staan. 
+	IEnumerable<Derived> derived4 = new List<Base>(); //Contravariant, werkt niet met een type dat lager is, je krijgt //hierop een error. Type 'Base' doesn't match expected type 'Derived'. 
+	  
+	Action<Base> base5 = new Action<Derived>(PrintActionDerived); //Covariant, werkt niet met een type dat hoger is. Je krijgt hierop een error.
+	Action<Derived> derived5 = new Action<Base>(PrintActionBase); //Contravariant, werkt met eem type dat lager is. In dit geval de Action. Interfaces kunnen alleen voor de eerste komen te staan.
+  } 
+}
+
+```
+
+> Hierboven staat in het Nederlands uitgelegd, wat #covariantie en #contravariantie nou doen.
+
+### #Contravariance and #Covariance Example 3
+
+Hier zullen we de boven genoemde voorbeelden nog verder verduidelijken. We maken 2 #interface en #class aan en doen daar iets mee. IGalaxy en Planet zijn #covariant. IPlanet en Orbit zijn #contravariant. We zullen met #object en #string werken. Let goed op de keywords: #out en #in. In de #code staat in het Nederlands beschreven hoe dit allemaal te werk gaat.
+
+```C#
+namespace ConsoleApp1;  
+  
+public interface IGalaxy<out T> //Covariance, keyword => out, want type T is uit de argument list.  
+{  
+  public T? Covariance(); //Return type T  
+}  
+  
+public class Planet : IGalaxy<string> //Verander dit van string naar object en het return type ook, wat merk je op?  
+{  
+  public string Covariance() => "Planet"; //Return type  
+}  
+  
+public interface IPlanet<in T> //Contravariance, keyword => in, want type T is in de argument list.  
+{  
+  public void Contravariance(T obj); //Argument type T  
+}  
+  
+public class Orbit : IPlanet<object> //Verander dit van object naar string en het argument type ook, wat merk je op?  
+{  
+  public void Contravariance(object obj) => Console.WriteLine(obj); //Argument type  
+}  
+  
+public class Program  
+{  
+  public static void Main()  
+  {  
+    //Allemaal high to low, maar:
+     
+    IGalaxy<object> galaxy = new Planet(); //Het is covariant, kijk naar de type tussen <>. Ik kan object erin stoppen en  
+    //vervangen met string. Dit werkt, want object is een collectie die de string in zich heeft. Dit werkt.    
+    IGalaxy<string> extraGalaxy = new Planet(); //Invariant type werkt ook.  
+    //IGalaxy<string> g = new Planet(); //Contravariant werkt niet hierop. string kan niet naar object. Zie regel 8/10.    
+    
+    IPlanet<string> planet = new Orbit(); //Het is Contravariant, kijk naar de type tussen <>. Ik kan string erin stoppen  
+    //en vervangen met object. Dit werkt, want string behoort tot een collectie die vanuit object komt. Dit werkt.    
+    IPlanet<object> extraplanet = new Orbit(); //Invariant type werkt ook.  
+    //IPlanet<object> p = new Orbit(); //Covariant werkt niet hierop. object kan niet naar string. Zie regel 18/20.  
+  }
+}
+
+```
+
+> Hierboven staat in het Nederlands uitgelegd, wat #covariantie en #contravariantie nou doen.
 
 ## Generics and Generic Type Constraints
 

notes_wpfw/csharp/wpfw_deel1/week2/testen_mocks.md

@@ -50,6 +50,12 @@ We maken een #interface ICalculator met een #generics met type #T. Daaraan geven
 
 Nadat we de Mock hebben, maken we een #class / #struct met de daadwerkelijke implementatie. We maken een Calculator en in de #Primary-Constructor geven we de #interface mee met iCalculator argument. Dit is #Dependency-Injection . Je implementeert niet de #interface, maar geeft dit als waarde mee.
 
+> Hier is hoe #Primary-Constructor werkt met #Dependency-Injection :
+
+![[primaryconstructor_dependency.png]]
+
+> url: https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/tutorials/primary-constructors
+
 De MockCalculator die de #interface implementeert is #Dependency-Inversion. Terug naar Calculator. De argument die meegegeven is een #interface-Injection en de #Property een #setter-Injection. Die is #readonly en #private. We willen niet de Mock implementatie aanroepen. Je ziet ook een #generics constraint met where #T : #INumber #T.
 
 Nu is het alleen mogelijk om arithmatic getallen eraan mee te geven. Als laatste hebben we de twee methods die we in de test gaan gebruiken. De implementatie lijkt bijna hetzelfde als de #interface , maar we kunnen de namen van die method voor de => aanpassen. Voor het gemak laten we het zoals het is. #generics types zijn optioneel. Het is geen requirement voor een Mock.

notes_wpfw/csharp/wpfw_deel1/week4/orm_en_linq.md

@@ -347,23 +347,88 @@ public class Program
 
 ```
 
-## ORM
+## #ORM
 
-Dit wordt later beschreven.
+#ORM staat voor Object Relational Mapping en zorgt ervoor dat je data kan aansturen van en naar Databases. Het maakt de vertaalslag naar queries, zodat je niet dit zelf hoeft te schrijven. Terwijl je focust op de datastructuren, doet het #ORM de rest voor je. Hieronder staat een goeie uitleg van #ChatGPT die in het Engels is geschreven. 
+
+> Het gaat over wat een #ORM precies oplost en tegen welke problemen je kan aanlopen.
+
+**ChatGPT**
+**Object-Relational Mapping (ORM)** is a programming technique that allows data to be seamlessly transferred between an object-oriented system and a relational database system. The main problems that #ORM aims to solve are related to the impedance mismatch between the object-oriented programming paradigm and the relational database model.
+
+### Problems #ORM Solves:
+
+1. **Impedance Mismatch:**
+    
+    - **Problem:** Object-oriented languages (like Java or C#) represent data using objects, while relational databases store data in tables. The differences between these models create an impedance mismatch.
+    - **Solution:** #ORM provides a way to map objects to database tables and vice versa, helping to bridge the gap between the object-oriented and relational worlds.
+2. **Boilerplate Code:**
+    
+    - **Problem:** Manually writing SQL queries and mapping database results to objects can be tedious and error-prone, leading to a lot of boilerplate code.
+    - **Solution:** #ORM tools automate the process of #CRUD (Create, Read, Update, Delete) operations, reducing the amount of boilerplate #code and improving developer productivity.
+3. **Database Abstraction:**
+    
+    - **Problem:** Without #ORM, developers need to write code specific to the database they are using. Switching databases can be challenging.
+    - **Solution:** #ORM abstracts away the underlying database details, making it easier to switch between different database systems without major code changes.
+4. **Maintainability:**
+    
+    - **Problem:** When the data model changes, manual updates to SQL queries and #object mappings are required, making maintenance challenging.
+    - **Solution:** #ORM tools often provide automated schema generation and migration tools, making it easier to adapt to changes in the data model.
+
+### Problems Encountered with #ORM:
+
+1. **Performance Overhead:**
+    
+    - **Issue:** #ORM tools may introduce performance overhead compared to hand-tuned SQL queries, especially for complex or performance-critical applications.
+    - **Mitigation:** #ORM tools often provide ways to optimize queries, and developers can choose to use native SQL queries when necessary.
+2. **Learning Curve:**
+    
+    - **Issue:** There can be a learning curve associated with understanding and effectively using an #ORM, especially for developers new to the tool.
+    - **Mitigation:** Training, documentation, and experience can help developers become proficient with the #ORM tool.
+3. **Customization Limitations:**
+    
+    - **Issue:** Some #ORMs might limit the flexibility to perform highly customized or optimized database operations.
+    - **Mitigation:** Some #ORM tools provide ways to write custom queries or use native SQL when needed, but it depends on the specific #ORM.
+4. **Mapping Complex Relationships:**
+    
+    - **Issue:** Mapping complex relationships between objects and database tables can be challenging and may require additional configuration.
+    - **Mitigation:** #ORMs often provide features and annotations to handle complex relationships, but developers need to be aware of and properly configure these.
+
+While #ORM tools can greatly simplify database interaction in many scenarios, it's important to be aware of their limitations and potential issues. The choice to use an #ORM should be based on the specific requirements and constraints of the project.
 
 ## Explicit, Eager and Lazy #Loading
 
-#Loading is een proces dat geldt voor de Entity Framework (EF) en de omliggende data in het ORM. Welke #Loading je moet gebruiken en welke sneller is aan de #usecase en wat je ermee wilt bereiken. Hieronder zullen alle verschillende #Loading worden beschreven. Omdat dit een best uitgebreid stuk kan zijn, zullen we de #code uit de docs gebruiken en niet zelf aanmaken.
+#Loading is een proces dat geldt voor de Entity Framework (EF) en de omliggende data in het #ORM. Welke #Loading je moet gebruiken en welke sneller is aan de #usecase en wat je ermee wilt bereiken. Hieronder zullen alle verschillende #Loading worden beschreven. Omdat dit een best uitgebreid stuk kan zijn, zullen we de #code uit de docs gebruiken en niet zelf aanmaken.
 
 > Url behorend tot de #code voorbeelden: https://blog.jetbrains.com/dotnet/2023/09/21/eager-lazy-and-explicit-loading-with-entity-framework-core/ en https://dzone.com/articles/working-with-lazy-loading-and-eager-loading-in-ent
 
 ### Explicit #Loading
 
-Explicit #Loading is het proces.
+Explicit #Loading is het proces waar de gegevens worden geladen wanneer je dit specifiek doet. De data wordt alleen opgehaald wanneer dit nodig is. Doe je dit niet? Dan krijg je een lege #collection . Het wordt duidelijk waar de #code voor de query wordt aangeroepen, maar je hebt nog steeds het resultaat + 1 probleem. Hieronder is een voorbeeld van Explicit #Loading .
+
+```C#
+var invoices = db.Invoices
+  .ToList();
+
+// All invoices are already loaded...
+foreach (var invoice in invoices)
+{
+  // ...but you'll have to explicitly load invoice lines when they are needed
+  db.Entry(invoice).Collection(p => p.InvoiceLines).Load();
+
+  foreach (var invoiceLine in invoice.InvoiceLines)
+  {
+    // ...
+  }
+}
+
+```
+
+> Om Explicit #Loading toe te passen, gebruik je het keyword #Load. Zie het voorbeeld hier.
 
 ## Eager #Loading 
 
-Eager #Loading is het proces waarop je op een query aanroept en daarboven op de gerelateerde gegevens en die ermee laad. Dit kun je doen met de #Include keyword. Eager #Loading is het tegenovergestelde van Lazy #Loading , want je laad meteen alle gegevens in. Dit kan voor een grote overhead zorgen. Hieronder is een voorbeeld hoe je #Loading kunt toepassen.
+Eager #Loading is het proces waarop je op een query iets aanroept en daarboven op de gerelateerde gegevens ermee laad. Dit kun je doen met de #Include keyword. Eager #Loading is het niet het tegenovergestelde van Lazy #Loading ,  je laad wel meteen alle gegevens in. Dit kan voor een overhead zorgen. Hieronder is een voorbeeld hoe je #Loading kunt toepassen.
 
 ```C#
 var invoices = db.Invoices
@@ -397,7 +462,7 @@ using (var context = new AdventureWorksContext())
 
 ## Lazy #Loading 
 
-Lazy #Loading is het proces waarbij de query automatisch worden geladen wanneer dit nodig is. Alleen de nodige gegevens die je verwacht worden geladen. In tegenstelling tot Eager #Loading is Lazy #Loading veel sneller. Dit komt, omdat je niet expliciet aangeeft dat je hierop ook een call wilt doen. 
+Lazy #Loading is het proces waarbij de query automatisch worden geladen wanneer dit nodig is. Alleen de nodige gegevens die je verwacht worden geladen. In tegenstelling tot Eager #Loading is Lazy #Loading niet perse veel sneller. Je krijgt het volledige resultaat + 1. In het meeste gevallen is het niet aan te raden om dit te gebruiken. Kijk naar de benaming: Lazy.
 
 ```C#
 var invoices = db.Invoices
@@ -438,3 +503,7 @@ public sealed class NorthwindModelOptimized: NorthwindModel
 }
 
 ```
+
+### Explicit, Eager and Lazy #Loading Video
+
+> Hier een video: https://www.youtube.com/watch?v=T9fTFynqvCw