.Net 6'da Mapster Kullanımı

Üzeyir AYDIN

10 Apr

Paylaş :

Modern mimari onları katmanlar arasında nesneden nesneye eşlemeye zorladığı için, günümüzde geliştiriciler kitaplıkları haritalamaya her zamankinden daha fazla önem veriyorlar. Örneğin, geçmişte github'da temiz mimari için bir depo hazırlamıştım , bu yüzden görsel stüdyo için bir şablon, onu görebilir ve modern mimari katmanları hakkında daha fazla bilgi alabilirsiniz.

Ancak, bildiklerime dayanarak, çoğu geliştirici eşlemeyi aşağıdaki gibi birçok kod satırı yazarak yapar:

public IActionResult Post(ProductDto dto)
{
Product product = new()
{
Name = dto.Name,
Brand = dto.Brand,
...
...
...
Size = dto.Size,
Weight = dto.Weight,
...
...
ColorId = dto.ColorId
};
...
return Ok();
}

Bazı programcıların neden haritalama için bu yolu seçtiğini bilmiyorum! ama biliyorum, bunu sevmiyorum çünkü gerçekten sıkıcı ve zaman alıcı ve AutoMapper ve Mapster gibi Mapping kitaplıklarını kullanmayı tercih ediyorum.
Basit ve hızlı oldukları için. “Mapster”a ek olarak eğlenceli ve yüksek performansa sahip! deposunu github içinde görebilirsiniz .

O halde başlayalım!

1. Yeni bir ASP.NET Core Web API Projesi oluşturun

2. Varlık Modelleri Ekle

“ Entities ” adında bir klasör oluşturun ve Product.cs , Color.cs sınıflarını ekleyin. Aşağıdaki gibi olmalıdır:

public classProduct 

{

    public int Id { get; set; }

    public string Name { get; set; }

    public string Brand { get; set; }

    public string WeightWithUnit { get; set; }

    public string Size { get; set; }

    public int ColorId { get; set; }

    public Color Color { get; set; }

}

public class Color
{
    public intId { get; set; }
    public string Name { get; set; }

    public List<Product> Products { get; set; }
}

3. Mapster Nuget paketini kurun

Mapster Nuget paketini ekleyin:

PM> Install-Package Mapster

İlk önce temel kullanıma bakın:

Yeni bir nesneye eşleme

var destObject = sourceObject.Adapt<Destination>();

Mevcut bir nesneye eşleme

sourceObject.Adapt(destObject);

Sorgulanabilir Uzantılar

var destinations = context.Sources.ProjectToType<Destination>().ToList();

Bu, Mapster'ın temel kullanımıydı, ancak aşağıda özelleştirilmiş konfigürasyonla farklı bir kullanım gösteriyoruz.

4. “BaseDto” Soyut sınıfını ekleyin

“ Dtos ” adlı bir klasör oluşturun ve BaseDto.cs , ProductDto.cs sınıflarını ekleyin.
Aslında “Dto” sınıflarımız BaseDto sınıfını uygular .


	public abstract class BaseDto<TDto, TEntity> : IRegister where TDto : class, new()
	where TEntity : class, new()
	{

	public TEntity ToEntity()
	{
	return this.Adapt<TEntity>();
	}

	public TEntity ToEntity(TEntity entity)
	{
	return (this as TDto).Adapt(entity);
	}

	public static TDto FromEntity(TEntity entity)
	{
	return entity.Adapt<TDto>();
	}


	private TypeAdapterConfig Config { get; set; }

	public virtual void AddCustomMappings() { }


	protected TypeAdapterSetter<TDto, TEntity> SetCustomMappings()
	=> Config.ForType<TDto, TEntity>();

	protected TypeAdapterSetter<TEntity, TDto> SetCustomMappingsInverse()
	=> Config.ForType<TEntity, TDto>();

	public void Register(TypeAdapterConfig config)
	{
	Config = config;
	AddCustomMappings();
	}
	}

IRegister, Mapster kitaplığındaki bir arabirimdir, bu nedenle derlemeleri tararken ve yer eşlemeleri Register yöntemindeyken eşlemelerin bulunmasına izin vermek için uygulanır.
Ardından, daha kolay haritalama için bazı yardımcı yöntemler ekledik:
ToEntity()
ToEntity(TEntity entity)
FromEntity(TEntity entity)
- Ayrıca eşlemelerin konfigürasyonunu özelleştirmek için üç yöntem ekledik :
- AddCustomMappings()
  SetCustomMappings()
  SetCustomMappingsInverse()
Sonraki adımlarda bu yöntemlerin nasıl kullanılacağını göstereceğiz…
5. ÜrünDto'ya Ekle
ProductDto sınıfını oluşturun ve BaseDto sınıfını uygulayın . Ardından AddCustomMappings() yöntemini geçersiz kılın ve özelleştirme eşlemelerini ekleyin:


	public class ProductDto : BaseDto<ProductDto,Product> {
	public string Name { get; set; }
	public string Brand { get; set; }
	public string FullName { get; set; }

	public int Weight { get; set; }
	public string WeightUnit { get; set; }
	public string Size { get; set; }

	public int ColorId { get; set; }
	public string ColorName { get; set; }


	public override void AddCustomMappings()
	{
	SetCustomMappings()
	.Map(dest => dest.WeightWithUnit,
	src => src.Weight.ToString() + " " + src.WeightUnit);


	SetCustomMappingsInverse()
	.Map(dest => dest.FullName, src => $"{src.Name} ({src.Brand})")
	.Map(dest => dest.ColorName, src => src.Color.Name)
	.Map(dest => dest.Weight,
	src => Convert.ToInt32(src.WeightWithUnit.Split(" ",StringSplitOptions.None)[0]))
	.Map(dest => dest.WeightUnit,
	src => src.WeightWithUnit.Split(" ", StringSplitOptions.None)[1]);
	}
	}

6. Program Sınıfında Mapster Konfigürasyonu Ekleme

İlk olarak “ Webframework ” adında bir klasör oluşturun ve MapsterConfiguration.cs dosyasını ekleyin.
Bu nedenle, IRegister.cs arabirimini uygulayan tarama sınıflarına derlemeyi ekleyin.


	public static class MapsterConfiguration {
	public static void AddMapster(this IServiceCollection services)
	{
	var typeAdapterConfig = TypeAdapterConfig.GlobalSettings;
	Assembly applicationAssembly = typeof(BaseDto<,>).Assembly;
	typeAdapterConfig.Scan(applicationAssembly);
	}
	}

Ardından program.cs sınıfında AddMapster() extensions yöntemini çağırın:


	var builder = WebApplication.CreateBuilder(args); // Add services to the container.

	builder.Services.AddMapster(); // <========<<

	builder.Services.AddControllers();

	...
	...
	...

7. API Denetleyicisi ekleyin ve eşlemeleri test edin

ProductsControllerEşlemeleri test etmek için “ ” adında yeni bir api denetleyici sınıfı oluşturun . Aşağıda uygulama detayları yer almaktadır:


	[ApiController] [Route("[controller]")]
	public class ProductsController : ControllerBase
	{
	private readonly ApplicationDbContext _context;

	public ProductsController(ApplicationDbContext context)
	{
	_context = context;
	}

	[HttpPost]
	public async Task<IActionResult> Post(ProductDto dto)
	{
	Product product = dto.ToEntity();

	_context.Add(product);

	await _context.SaveChangesAsync();

	return Ok(product);
	}


	[HttpGet]
	public async Task<IActionResult> Get(int productId)
	{
	ProductDto productDto = await _context
	.Products
	.Where(p => p.Id == productId)
	.ProjectToType<ProductDto>()
	.FirstOrDefaultAsync();

	return Ok(productDto);
	}


	[HttpGet]
	[Route("[controller]/[action]")]
	public async Task<IActionResult> GetAll()
	{
	var result = await _context
	.Products
	.ProjectToType<ProductDto>()
	.ToListAsync();

	return Ok(result);
	}
	}

8. Son nokta: eşleme yapılandırması için statik yöntem nasıl oluşturulur

Örneğin , ProductDto.cs'ye " HasFavoriteColor " özelliğini ekledikten sonra " GetMapsterConfig " statik yöntemini ekliyoruz:


	public class ProductDto : BaseDto<ProductDto,Product> {
	public string Name { get; set; }
	public string Brand { get; set; }
	public string FullName { get; set; }

	public int Weight { get; set; }
	public string WeightUnit { get; set; }
	public string Size { get; set; }

	public int ColorId { get; set; }
	public string ColorName { get; set; }


	public bool HasFavoriteColor { get; set; }

	public static TypeAdapterConfig GetMapsterConfig(int userFavoriteColorId)
	{
	return new TypeAdapterConfig()
	.NewConfig<Product, ProductDto>()
	.Map(dest => dest.FullName, src => $"{src.Name} ({src.Brand})")
	.Map(dest => dest.ColorName, src => src.Color.Name)
	.Map(dest => dest.HasFavoriteColor, src => src.ColorId == userFavoriteColorId) //<======<<
	.Config;
	}

	...
	...
	}

Artık eşlemeyi denetleyicide şu şekilde kullanabiliriz:


	[HttpGet] [Route("[controller]/[action]")]
	public async Task<IActionResult> Products(int userFavoriteColorId)
	{
	var result = await _context
	.Products
	.ProjectToType<ProductDto>(ProductDto.GetMapsterConfig(userFavoriteColorId)) //<======<<
	.ToListAsync();

	return Ok(result);
	}

Hesabınızı yönetmek için giriş yapın