Exemplo com a Arquitetura em Camadas (Layered Architecture)

Modelo

public class Artista
{
    public int Id { get; set; }
    public string Nome { get; set; }
    public string Bio { get; set; }
    public string FotoPerfil { get; set; }
}

Repositório

public interface IArtistaRepository
{
    IEnumerable<Artista> GetAll();
    Artista GetById(int id);
    void Add(Artista artista);
    void Update(Artista artista);
    void Delete(int id);
}

public class ArtistaRepository : IArtistaRepository
{
    private readonly ScreenSoundContext _context;

    public ArtistaRepository(ScreenSoundContext context)
    {
        _context = context;
    }

    public IEnumerable<Artista> GetAll()
    {
        return _context.Artistas.ToList();
    }

    public Artista GetById(int id)
    {
        return _context.Artistas.Find(id);
    }

    public void Add(Artista artista)
    {
        _context.Artistas.Add(artista);
        _context.SaveChanges();
    }

    public void Update(Artista artista)
    {
        _context.Artistas.Update(artista);
        _context.SaveChanges();
    }

    public void Delete(int id)
    {
        var artista = _context.Artistas.Find(id);
        if (artista != null)
        {
            _context.Artistas.Remove(artista);
            _context.SaveChanges();
        }
    }
}

Serviço

public class ArtistaService
{
    private readonly IArtistaRepository _repository;

    public ArtistaService(IArtistaRepository repository)
    {
        _repository = repository;
    }

    public IEnumerable<Artista> GetAllArtistas()
    {
        return _repository.GetAll();
    }

    public Artista GetArtistaById(int id)
    {
        return _repository.GetById(id);
    }

    public void CreateArtista(Artista artista)
    {
        // Lógica de negócios, validações, etc.
        _repository.Add(artista);
    }

    public void UpdateArtista(Artista artista)
    {
        // Lógica de negócios, validações, etc.
        _repository.Update(artista);
    }

    public void DeleteArtista(int id)
    {
        // Lógica de negócios, validações, etc.
        _repository.Delete(id);
    }
}

Controlador

[ApiController]
[Route("[controller]")]
public class ArtistaController : ControllerBase
{
    private readonly ArtistaService _service;

    public ArtistaController(ArtistaService service)
    {
        _service = service;
    }

    [HttpGet]
    public IActionResult Get()
    {
        var artistas = _service.GetAllArtistas();
        return Ok(artistas);
    }

    [HttpGet("{id}")]
    public IActionResult Get(int id)
    {
        var artista = _service.GetArtistaById(id);
        if (artista == null)
        {
            return NotFound();
        }
        return Ok(artista);
    }

    [HttpPost]
    public IActionResult Post([FromBody] Artista artista)
    {
        _service.CreateArtista(artista);
        return CreatedAtAction(nameof(Get), new { id = artista.Id }, artista);
    }

    [HttpPut]
    public IActionResult Put([FromBody] Artista artista)
    {
        _service.UpdateArtista(artista);
        return NoContent();
    }

    [HttpDelete("{id}")]
    public IActionResult Delete(int id)
    {
        _service.DeleteArtista(id);
        return NoContent();
    }
}

Resumo

1. Modelo (Artista): Representa a entidade de dados.
2. Repositório (ArtistaRepository): Manipula a persistência e recuperação dos dados.
3. Serviço (ArtistaService): Encapsula a lógica de negócios e coordena a manipulação dos dados através do repositório.
4. Controlador (ArtistaController): Recebe as requisições HTTP e utiliza o serviço para realizar as operações necessárias.