litedb embedded database -> document database objecten kunnen direct in db gezet worden

coordinator context -> entity relation -> object omzetten naar relationele db items

system.reactive -> observables -> één grote observable stream

dependency injection (Dependency injection - .NET | Microsoft Learn) Design Patterns Explained – Dependency Injection with Code Examples (stackify.com)
geregistreerd in lokale container
IServiceCollection registreert alle componenten in een systeem
dependencies in constructor zijn altijd verplicht

Dependency injection is a programming technique that makes a class independent of its dependencies. It achieves that by decoupling the usage of an object from its creation. You can introduce interfaces to break the dependencies between higher and lower level classes. If you do that, both classes depend on the interface and no longer on each other. link](https://stackify.com/dependency-injection/#:~:text=Dependency%20injection%20is%20a%20programming,inversion%20and%20single%20responsibility%20principles.)).

Dependency inversion SOLID Design Principles Explained: Dependency Inversion Principle with Code Examples (stackify.com)
High-level modules, which provide complex logic, should be easily reusable and unaffected by changes in low-level modules, which provide utility features.

1. High-level modules should not depend on low-level modules. Both should depend on abstractions.
2. Abstractions should not depend on details. Details should depend on abstractions.

extension methods Extension Methods - C# Programming Guide - C# | Microsoft Learn Shared -> alle onderdelen die andere modules gebruiken
transient -> elke keer een nieuwe als je hem opnieuw aanroept (in een web app voor iedere user opnieuw, voor de aparte users als singleton)
te herkennen door this
interfaces kunnen daarmee uitgebreid worden
Functionaliteit van klassen kan uitgebreid worden
Kan alleen als static methods in een static class
An extension method will never be called if it has the same signature as a method defined in the type.
When to use:

- when the original source isn't under your control
    - derived object is inappropriate or impossible
    - functionality shouldn't be expoed beyond its applicable scope
    

Hosted services .NET Hosted Service: Run a background service and task (uses .NET Core) (youtube.com)

• Hosted services worden toegevoegd aan de DI container met een singleton lifetime

  • Hierdoor kunnen alleen singleton of transient services toegevoegd worden
  • scoped kan door een service provider te injecteren en dan in de task de CreateScope hiervan aan te roepen om zo zelf een scope te maken:

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
        while (!stoppingToken.IsCancellationRequested)
        {
        using (var scope = _serviceProvider.CreateScope())
          {
          var scopedService = scope.ServiceProvider.GetRequiredService<IMyScopedService>();
          // other task code...
          }
        }
        }
        

    Verschil tussen HostedService en BackgroundService: BackgroundService implementeert de IHostedService interface, heeft alleen een ExecuteAsync methode waarbij de task gerund wordt. Bij de IHostedService moet je zelf de StartAsync(CancellationToken cancellationToken) en StopAsync(CancellationToken cancellationToken) implementeren.

• Scoped services: (What is a Scoped .NET Dependency, and Why You Should Use Them (youtube.com), Use scoped services within a BackgroundService - .NET | Microsoft Learn)
  Wordt gebruikt als je iets voor een bepaalde scope wil gebruiken
  Je kan ze toevoegen aan een background service
  No scope is created for a hosted service by default
  Wordt gebruikt voor een nieuwe request

  
  

Open/Closed principle (link](https://stackify.com/solid-design-open-closed-principle/)))

“Software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification. A class is closed, since it may be compiled, stored in a library, baselined, and used by client classes. But it is also open, since any new class may use it as parent, adding new features. When a descendant class is defined, there is no need to change the original or to disturb its clients”

Alles met repository is database code

Dependencies automatisch toegepast mits ze in Startup.cs zijn geregistreerd

communicatie met CM api is in Shared gedefinieerd

asynchroon is heel gebruikelijk in C#
Task<subtype>
cancellation token: een async operatie kan netjes afgesloten worden
Mediator
soort event bus maar dan op hoger niveau

ServiceHostProcess om windows service snel op te laten starten host het dotnet proces restart het dotnet proces als het crasht

[Theory]
[InlineData(13,5,8)]
[InlineData(0,3,-3)]
[InlineData(100,45,55)]
[InlineData(0,0,0)]
public void addTwoNumbers(int expected, int first, int second)
{
	Assert.Equal(expected, first + second);
}

using Xunit;

[assembly: CollectionBehavior(DisableTestParallelization = true)]
          

[CollectionDefinition("name of collection")]
pulic class ClassDefinition : ICollectionFixture<ClassUnderTest>
{
	// all classes under this definition will use the same context
}

[Collection("name of collection")]
public class TestOne {}