.Net Core AutoMapper Kullanımı

Merhaba Arkadaşlar, bu yazımda sizlere .Net Core AutoMapper Kullanımı konusundan bahsedeceğim.

Yazımıza başlarken AutoMapper nedir kısaca ondan bahsetmek istiyorum. AutoMapper kütüphanesi, farklı tipte olan nesneleri otomatik olarak birbirine dönüştürmemizi sağlayan kütüphanedir.

Örnek vermek gerekirse, veri tabanımızdan verilerimizi çektiğimizi düşünelim. Bu verileri çekerken Category nesnemiz bulunuyor. Fakat direkt olarak veri tabanı nesneleri ile işlem yapmak istemiyoruz. Çünkü içerisinde diğer bilgilerimiz de bulunabilir. Farklı bir nesne oluşturarak sadece gerekli alanların görünmesi için property’lerimizi ekleyerek gösterim sağlamak istiyoruz. Bunun için de CategoryDto nesnemiz var diyelim. Category nesnemizi CategoryDto nesnemize atama yaparak gösterim sağlamak istiyoruz. Bu işlemi sağlayabilmek için ilgili nesnenin property’lerine atama işlemi yapmamız gerekiyor. Bu işlem de kod tarafında hem yorucu hem de kod fazlalığı ve kirliliğine sebep oluyor. Haliyle bizi bu işten kurtaran bir şey varsa neden kullanmayalım 🙂

Artık örneğimize geçebiliriz.

Öncelikle projemizi .Net Core 6 ile Web Projesi oluşturuyorum. Daha sonra da Nuget Package Manager ile gerekli kütüphaneleri yükleyeceğiz. Yüklememiz gereken kütüphaneler aşağıdaki gibidir.

• AutoMapper
• AutoMapper.Extensions.Microsoft.DependencyInjection

İlgili paketlerimizi yükledikten sonra da gerekli ayarlamaları yapmamız gerekiyor. Öncelikle bu ayarları yapmalıyız ki AutoMapper kütüphanesi de bu dönüştürme işlemini gerçekleştirebilsin.

Bir class oluşturmamız gerekiyor ve bu class‘ın da Profile sınıfından miras alması gerekiyor. Profile sınıfı AutoMapper kütüphanesinden gelmektedir. Using kısmına bu paketin eklemesini sağladıktan sonra kullanabiliriz.

 public class MappingProfile : Profile
 {
        public MappingProfile()
        {
            CreateMap<Category, CategoryDto>().ReverseMap();
        }
 }

Yukarıda görüldüğü üzere MappingProfile isminde bir class oluşturuyorum ve Profile sınıfından miras almaktadır. Daha sonra da Constructor‘ını oluşturarak içerisinde CreateMap metodumuzu kullanıyoruz. CreateMap metodumuz ile Category‘nin CategoryDto nesnesine çevrilmesi gerektiğini belirtiyoruz. ReverseMap ile de CategoryDto nesnesinin Category nesnesine çevrilmesi gerektiğini belirtmiş oluyoruz.

MappingProfile sınıfımızı oluşturduktan sonra da Program.cs sınıfımıza gidiyoruz. Burada AutoMapper eklemesini gerçekleştireceğiz. Program sınıfımıza giderek aşağıdaki kod(AddAutoMapper) ile eklemeyi gerçekleştiriyoruz. Parametre olarak da GetAssemblies() tanımını yaparak MappingProfile sınıfımızı görmesi gerektiğini belirtmiş oluyoruz.

builder.Services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies());

 AutoMapper eklemesini gerçekleştirdikten sonra Category nesnelerimizi oluşturuyoruz.

public class Category
{
        public int Id { get; set; }
        public string Name { get; set; }
        public bool IsDeleted { get; set; }
        public bool IsActive { get; set; }
}

public class CategoryDto
{
        public int Id { get; set; }
        public string Name { get; set; }
}

Category ve CategoryDto nesnelerimizi oluşturduk. Category nesnemizde IsDeleted ve IsActive property’leri bulunmakta ve CategoryDto nesnemizde bu property’ler bulunmamaktadır. Çünkü bu property’lerin gösterimini sağlamak istemiyoruz. Bu nesneleri oluşturduktan sonra da Category listemiz ile ilgili işlemleri sağlamak için bir interface ve bir class oluşturuyoruz. ICategoryService isminde bir Interface nesnesi oluşturuyoruz ve bunu kullanabilmek için de CategoryService nesnemizi oluşturup içerisinde de örnek listemizi tanımlıyoruz.

public interface ICategoryService
{
    List<Category> GetCategories();
    Category GetCategory(int id);
}

public class CategoryService : ICategoryService
{
    List<Category> _categories;
    public CategoryService()
    {
        _categories = new List<Category>();
        _categories.Add(new Category { Id = 1, Name="Category 1" });
        _categories.Add(new Category { Id = 2, Name="Category 2" });
        _categories.Add(new Category { Id = 3, Name="Category 3" });
    }
    public List<Category> GetCategories()
    {
        return _categories;
    }

    public Category GetCategory(int id)
    {
        return _categories.Find(c => c.Id == id);
    }
}

Yukarıdaki ICategoryService nesnemizi kullanmak için Program.cs dosyası içerisinde tanımlamayı da yapmalıyız.

builder.Services.AddScoped<ICategoryService, CategoryService>();

Daha sonra da Controller tarafında bu dönüştürme işlemini sağlıyoruz.

public class HomeController : Controller
{
    private readonly IMapper _mapper;
    private readonly ICategoryService _categoryService;
    public HomeController(IMapper mapper, ICategoryService categoryService)
    {
        _mapper = mapper;
        _categoryService = categoryService;
    }

    public IActionResult AutoMapperTest()
    {
        var categories = _categoryService.GetAll();

        var result = _mapper.Map<List<CategoryDto>>(categories);

        return View(result);
    }
}

Dependency Injection yöntemi ile IMapper tanımını gerçekleştiriyoruz. Action’da da _mapper.Map metodumuzu kullanarak hangi nesneye çevrilmesi gerektiğini belirtiyoruz. Burada Category nesnesini CategoryDto nesnesine çevirme işlemi gerçekleştirdik. Bunu da bir liste olarak belirttik. AutoMapper bizim için dönüştürme işlemini gerçekleştirecektir.

Umarım faydalı olur.

Bir sonraki yazıda görüşmek üzere…