Introdução

Em grande parte de nosso sistema, muitas telas precisam contém apenas uma lógica de CRUD básica (

CrudAppService e AsyncCrudAppService Classes

Se você precisa criar um serviço de aplicação que terá uma operação de CRUD (acrônimo de Create, Read, Update e Delete) para uma entidade especifica, .

Visando uma maior produtividade o TNF contém duas classes para agilizar esses processo: CrudAppService e AsyncCrudAppService.

Como essas classes são facilitadores, neste modelo não possui nenhuma implementação na camada de domínio. As validações são geradas em cima dos objetos que fazem o mapeamento com o banco de dados (Country) e DTOs (CountryDto).

classes que agilizam essa criação de serviços de forma automática.

Para utilizar essas funcionalidades instale via nuget o pacote Tnf disponível em nosso package source: https://www.myget.org/F/tnf/api/v3/index.json

Definindo um Serviço de CRUD

Primeiro vamos criar nossa interface para o serviço definindo sua herança para a interface IAsyncCrudAppService<CountryDto> informando qual o Dto que será usado para o mapeamento da entidadeA entidade abaixo realiza o mapeamento da tabela Countries para o Entity Framework Core:

[AutoMap(typeof(CountryDto))]
[Table("Countries")]
public classinterface CountryICountryAppService : EntityIAsyncCrudAppService<CountryDto>
{
    public const int MaxNameLength = 256;
    [Required]
    [MaxLength(MaxNameLength)]}

Adicionando Validações ao DTO

No exemplo acima criamos um serviço para trabalhar com o objeto CountryDto representando a entidade persistida com Entity Framework Core.

public class CountryDto : CustomValidate
{
    public string Name { get; set; }


    public override Country(void AddValidationErrors(CustomValidationContext context)
    {
    }

    public Country(int id, string name)
if (string.IsNullOrWhiteSpace(Name))
       {
        Id  = id;
    context.Results.Add(new ValidationResult("Name is required"));
     Name = name;}
    }
}

Abaixo Acima temos a definição do de nosso DTO usando a herança de uma validação customizadaclasse chamada CustomValidate. Essa classe realiza a validação do objeto DTO ao criar o serviço automático. Nela podem ser adicionadas regras de validação personalizadas.

Criando a Entidade do Entity Framework Core

Para a tabela "Countries" temos a seguinte definição:

[AutoMap(typeof(CountryDto))]
[Table("Countries")]
public class CountryDtoCountry : CustomValidateEntity
{
    public const int MaxNameLength = 256;
    [Required]
    [MaxLength(MaxNameLength)]
    public string Name { get; set; }

    public override void AddValidationErrors(CustomValidationContext contextCountry()
    {
    }

   if public Country(string.IsNullOrWhiteSpace(Name)int id, string name)
       {
        Id =  context.Results.Add(new ValidationResult("Name is required"));
id;
        Name = name;
 }
   }
}

Definição da interface do serviço de aplicação:

public interface ICountryAppService : IAsyncCrudAppService<CountryDto>
{
}

Até este ponto temos nossa definição de serviço (interface), DTO criado e Entidade no Entity Framework Core representada.

Note o atributo AutoMap esta sendo usado na entidade.

Essa especificação garante que ao utilizar o serviço de CRUD irá usar o Mapper automático das propriedades pra classe de infraestrutura e DTO.

Para utilizar o AutoMapper consulte o tópico de Mapeamento Automático de Entidades.

Implementando o Serviço de CRUD

Agora vamos implementar a nossa classe de serviçoImplementação do serviço de aplicação informando qual a entidade, DTO e realizando a herança da classe AsyncCrudAppService que irá definir que este serviço contem as funcionalidades de CRUD presentes no TNF:

public class CountryAppService : AsyncCrudAppService<Country, CountryDto>, ICountryAppService
{
    public CountryAppService(IRepository<Country> repository)
        : base(repository)
    {
    }
}

Note que o serviço recebe como parâmetro um repositório de dados para a entidade Country. Quem define a implementação para a interface IRepository neste exemplo é um nuget package do TNF que contém uma implementação de repositório para o Entity Framework Core chamado: "Tnf.App.EntityFrameworkCore".

O repositório padrão realiza o mapeamento da entidade automaticamente para o seu respectivo DTO através de outros pacotes chamados: Tnf.AutoMapper e Tnf.Dto.

a definição do serviço se da pela herança da classe AsyncCrudAppService< Entity, Dto> onde é passado a entidade do Entity Framework Core e a sua classe de DTO criada.

Como parâmetro em seu construtor o serviço recebe um tipo IRepository<Entity> definindo o repositório que será usado pelo serviço automático na hora de realizar as operações.

Após a definição acima o serviço pode ser usado normalmente em sua aplicação.

A herança da classe AsyncCrudAppService< Entity, Dto> expõe o CRUD no formato assíncrono.

Também existe a versão síncrona do serviço de CRUD usando a herança CrudAppService< Entity, Dto>Ambos os pacotes podem ser obtidos através de nosso feed de pacotes: https://www.myget.org/F/tnf/api/v3/index.json