DotnetMinorNotes

• Al bekende architecturen
  • Monolith
  • 3-tier
    • Voordelen
    • Nadelen
  • Onion architecture
    • Lagen
      • Logica laag
      • Domain services
      • Application services
      • Buitenste schil
    • Dependencies
    • Domain logic laag
      • Domain service laag
      • API Interface laag
  • Wanneer kies je wat?
    • Monolith
    • 3-Tier
    • Onion

Architectuur patterns

Disclaimer: Dit zijn notities van de .Net minor die gevolgd is in het tweede semester van 2017. Deze minor is gegeven door Marco Pil van Info Support.

Monolith

Een applicatie die gebruik maakt van 1 laag waarin alles gedaan wordt

3-tier

Voordelen

• Makkelijk verantwoordelijkheden scheiden
• Dingen zijn snel terug vinden
• Simpel aan te passen
• Overzichtelijk
• Lagen kunnen in verschillende DLL’s ondergebracht worden
  • Er kunnen geen circulaire referenties gelegd worden, dus referenties gaan 1 kant op

Nadelen

Wanneer de logica complex wordt, wordt de logica laag heel groot. Daarnaast ben je afhankelijk van de laag eronder

Onion architecture

Wanneer de taal dichter bij het domein gaat liggen heb je het niet meer over data access e.d.

Lagen

Logica laag

• Tekenen als een circeltje in plaats van een stapeltje
  • Dit noemen we ‘Domein logica’
  • Dit is ook meteen het domein model
  • Logica in het domein pushen
    • Klant kan zichzelf verhuizen
      • Wijzigt eigen adres
      • Doet validaties
      • Poef! hij is verhuisd
  • Focussen op wat het moeilijkste is: Planning genereren

Domain services

• In de taal van de klant
• Object overstijgende dingen
  • IKlantRepository
  • Klant vinden of klant aanmaken kan de klant niet zelf doen

Application services

Services die niet tot het domein behoren, maar technische toepassingen hebben

• Util dingen als GetDayOfWeek(…)

Buitenste schil

1. (API/User) Interface
   • Web API
   • Website
   • Of een andere manier waarop je de interface van je applicatie ontsluit
2. Infrastructuur
   • Contact maken met een database
   • Contact maken met een event bus
   • Contact maken met het internet
   • Contact maken met Outlook
3. Testen
   • Applicatie testen
   • Integratie testen
   • Unit testen

Dependencies

• De dependencies gaan naar het midden toe
  • Complexe domein logica moet niet nog complexer worden doordat het nog afhankelijk is van andere dingen
• Elke laag kan in een eigen DLL staan
  • Dan weet je zeker dat de richting goed is, omdat er geen circulaire referenties gelegd kunnen worden

Domain logic laag

Domain objects, die voorheen POCO’s waren, bevatten nu ook logica

public class Klant
{
    public long Id { get; set; }
    public string Naam { get; set; }
    public string Adres { get; set; }

    public void Verhuis(...) { ... }
}

Domain service laag

KlantService met daarin een Execute methode voor het afhandelen van commands

public class KlantService
{
    // Constructor die private members zet

    private readonly IKlantRepository _klantRepository;
    private readonly IEventPublished _eventPublisher;

    public void Execute(VerhuisKlantCommand command)
    {
        Klant klant = _klantRepository.FindKlant(command.KlantId);
        klant.Verhuis(command.NiewAdres);
        _klantRepository.SaveKlant(klant);
        _eventPublisher.Publish(new KlantVerhuisdEvent(...));
    }
}

API Interface laag

Een API controller met daarin een Verhuis methode die de service aanroept

public class KlantController : Controller
{
    // Constructor die private member zet

    private readonly KlantService _klantService;

    [HttpPatch]
    public IActionResult Verhuis([FromBody]VerhuisKlantCommand command)
    {
        try
        {
            _klantService.Execute(command);

            return Ok();
        }
        catch (Exception)
        {
            return BadRequest(...);
        }
    }
}

Wanneer kies je wat?

Monolith

Voor kleine simpele applicaties

3-Tier

Voor niet te complexe domeinen en niet te grote applicaties

Onion

Wanneer domain logica complex wordt