API Controller logica naar een service verplaatsen

[timmie1]

Ik ben momenteel bezig met het opzetten van een REST API in een ASP.NET C# project in Visual Studio. De API maakt contact met een externe PostgrueSQL database met behulp van npgsql EntityFramework. Dit lijkt te werken, want de initial migration is uitgevoerd en er is op de database server een database geïnitialiseerd zoals ik het model gedefinieerd hebt. Voor de CRUD operaties heb ik een API controller met actions laten genereren, waarvan ik de logica naar een nieuw op te zetten Service dien te verplaatsen. De controller dient daarna tevens de IService te implementeren.

Mijn vragen:
Hoe stel ik vast welke logica ik moet verplaatsen?
Wat is business logic in dit geval?
Op welke manier verplaats ik de logica dan?

Voorbeeld:

code:

// GET: api/Album
        [HttpGet]
        public async Task<ActionResult<IEnumerable<Album.Api.Models.Album>>> GetAlbums()
        {

          //return _albumService.GetAlbums();
          if (_context.Albums == null)
          {
              return NotFound();
          }
            return await _context.Albums.ToListAsync();
        }

Dien ik in dit geval de logica hieruit in de gelijknamige method in de service te plakken, de context daarbij mee te geven, in de Controller een instantie van de Service aan te maken en dan de gelijknamige method met de geplakte logica in de Service aan te roepen? Of denk ik nu verkeerd?
Dus bijvoorbeeld dit:


Relevante software en hardware die ik gebruik
Visual Studio
ASP.NET project in C#

Wat ik al gevonden of geprobeerd heb
Ik heb een nieuwe folder aangemaakt, Service genaamd. Hierin heb ik een nieuwe Service class aangemaakt en methods aangemaakt die gelijknamig zijn aan de CRUD-methods in de Controller. Vervolgens heb ik in dezelfde folder een IService interface aangemaakt en dezeflde method signatures geplakt.

[ Voor 10% gewijzigd door timmie1 op 10-07-2023 11:23 ]

[RobIII]

De service heeft geen weet waar (in welke context) deze gebruikt wordt (of althans: dat zou zo moeten zijn). Dus het returnen van een ActionResult als een "NotFound" is niet aan de service maar aan de controller. Je service zou (bijv.) een Task<IEnumerable<Album>> moeten returnen. Dit is één van de SOLID principes (in dit geval de S). En daarmee kun je, als het goed is, al je vragen beantwoorden.

[ Voor 9% gewijzigd door RobIII op 10-07-2023 11:28 ]

[timmie1]

RobIII schreef op maandag 10 juli 2023 @ 11:25:
De service heeft geen weet waar (in welke context) deze gebruikt wordt (of althans: dat zou zo moeten zijn). Dus het returnen van een ActionResult als een "NotFound" is niet aan de service maar aan de controller. Je service zou (bijv.) een Task<IEnumerable<Album>> moeten returnen. Dit is één van de SOLID principes (in dit geval de S). En daarmee kun je, als het goed is, al je vragen beantwoorden.

Dank voor het antwoord.

De S van SOLID betekent als ik het goed begrijp dus dat taakgroepen gescheiden in aparte klassen horen.
Betekent dit in dit geval dat de AlbumService de interactie met de AlbumContext volledig moet gaan overnemen van de AlbumController, zoals bijvoorbeeld in dit stuk code hieronder? :

code:

    //Service class
    public class AlbumService
    {
        private readonly AlbumContext context;

        public AlbumService(AlbumContext _context) 
        {
            context = _context;
        }

        public ActionResult<Album.Api.Models.Album> GetAlbums()
        {
            return context.Albums()
        }
        //Other methods
//---------------------------------------------------------------------------------------------------------     
    //Controller class
        
    public class AlbumController : ControllerBase, IAlbumService
    {
        private AlbumService _albumService;

        public AlbumController(AlbumContext context)
        {
            _albumService = new AlbumService(context);
        }

        // GET: api/Album
        [HttpGet]
        public async Task<ActionResult<IEnumerable<Album.Api.Models.Album>>> GetAlbums()
        {
          IEnumerable<Album.Api.Models.Album> albums = _albumService.GetAlbums();
          if (albums == null)
          {
              return NotFound();
          }
            return await albums.ToListAsync();
        }
        //Other methods

[Haan]

Dat komt in de buurt, maar als je het helemaal goed wilt doen, lees dan ook over dependency injection (voor de I van SOLID ). https://learn.microsoft.c...ction?view=aspnetcore-7.0
Kort gezegd is het niet de bedoeling dat je in de constructor een service aanmaakt, maar dat deze geïnjecteerd wordt via de constructor. En meestal kies je dan voor een interface (IAlbumService) om unit testen eenvoudiger te maken.

[Diumelia]

Haan schreef op maandag 10 juli 2023 @ 12:48:
Dat komt in de buurt, maar als je het helemaal goed wilt doen, lees dan ook over dependency injection (voor de I van SOLID ). https://learn.microsoft.c...ction?view=aspnetcore-7.0
Kort gezegd is het niet de bedoeling dat je in de constructor een service aanmaakt, maar dat deze geïnjecteerd wordt via de constructor. En meestal kies je dan voor een interface (IAlbumService) om unit testen eenvoudiger te maken.

Correctie: Voor de D van SOLID (Dependency Inversion). De I staat voor Interface segregation.

[Haan]

Stom ja Ik zat met Inversion of control in m'n hoofd..