C# Repository Design Pattern

Repository Tasarım Deseni Nedir?

• Repository deseni nedir?
• Repository deseninin amacı nedir?
• Generic Repository nedir?

Repository tasarım deseni, yazılım geliştirme süreçlerinde veritabanı işlemlerini ve veri erişimini soyutlamak ve daha kolay yönetilebilir hale getirmek için kullanılan bir tasarım desenidir. Bu desen, özellikle veri tabanı işlemlerini daha az bağımlı ve test edilebilir hale getirmek amacıyla kullanılır. C# gibi nesne yönelimli programlama dillerinde sıkça kullanılan bir tasarım desenidir.

Repository tasarım deseni aşağıdaki temel bileşenlerden oluşur:

1. Repository (Depo) Sınıfı: Bu sınıf, veritabanı işlemlerini gerçekleştiren temel sınıftır. CRUD (Create, Read, Update, Delete) işlemlerini içerir. Örneğin, verileri ekleme, okuma, güncelleme ve silme işlemleri bu sınıf üzerinden yapılır.
2. Entity (Varlık) Sınıfları: Bu sınıflar, veritabanındaki tablolara karşılık gelir. Her bir varlık sınıfı, veritabanı tablosunun bir kaydını temsil eder. C# sınıfları olarak tanımlanırlar.
3. UnitOfWork (İş Birimi): Bu sınıf, işlemleri bir araya getirir ve bu işlemleri tek bir işlem olarak işlememizi sağlar. İş birimi, birden çok repository’nin işlemlerini tek bir işlem içinde birleştirir ve her işlem başarılıysa veritabanına kaydetme işlemi yapar veya herhangi bir hata durumunda geri alır.

Repository tasarım deseni, yazılımın daha modüler, test edilebilir ve veri tabanı bağlantılarını daha iyi soyutlayarak değişikliklere karşı daha esnek hale gelmesini sağlar. Bu, yazılım geliştirme sürecini daha etkili hale getirebilir ve kodun daha iyi bakımını ve geliştirilmesini kolaylaştırabilir.

// Entity sınıfı
public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
    // Diğer özellikler
}

// Repository sınıfı
public class CustomerRepository
{
    public Customer GetById(int id)
    {
        // Veritabanından müşteriyi almak için gerekli kod
    }

    public void Add(Customer customer)
    {
        // Müşteriyi eklemek için gerekli kod
    }

    public void Update(Customer customer)
    {
        // Müşteriyi güncellemek için gerekli kod
    }

    public void Delete(int id)
    {
        // Müşteriyi silmek için gerekli kod
    }
}

// UnitOfWork sınıfı
public class UnitOfWork
{
    private CustomerRepository customerRepository;

    public CustomerRepository Customers => customerRepository ??= new CustomerRepository();
    
    public void SaveChanges()
    {
        // Değişiklikleri veritabanına kaydet
    }
}

2. Generic Repository Tasarım Deseni Kavramları
   • Entity Framework veya ADO.NET gibi veritabanı erişim teknolojileriyle nasıl kullanılır?

C# Generic Repository tasarım desenini Entity Framework veya ADO.NET gibi veritabanı erişim teknolojileriyle nasıl kullanacağınızı derinlemesine anlatmak için örnek bir uygulama oluşturacağım. Bu örnekte Entity Framework kullanarak Generic Repository tasarım desenini uygulayacağız.

Proje Hazırlığı: İlk adım, bir C# projesi oluşturmak ve Entity Framework’ü projenize eklemektir. Entity Framework’ün yüklü olduğundan ve bir DbContext sınıfı tanımlandığından emin olun. Ayrıca, projenizin başka gereksinimlerine göre diğer paketleri eklemek gerekebilir.

Varlık (Entity) Sınıfı Oluşturma: Öncelikle veritabanı tablosuna karşılık gelen bir varlık sınıfı oluşturun. Örnek olarak, “Customer” adında bir sınıf oluşturabilirsiniz:

public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
    // Diğer özellikler
}

DbContext Oluşturma: DbContext sınıfınızı tanımlayın ve varlık sınıfını DbSet ile ilişkilendirin:

public class MyDbContext : DbContext
{
    public DbSet<Customer> Customers { get; set; }
}

Generic Repository Sınıfı Oluşturma: Generic Repository tasarım desenini uygulayan bir sınıf oluşturun. Bu sınıf, Entity Framework ile etkileşimde bulunacak ve CRUD işlemlerini gerçekleştirecektir.

public class Repository<T> where T : class
{
    private readonly MyDbContext context;

    public Repository(MyDbContext dbContext)
    {
        context = dbContext;
    }

    public T GetById(int id)
    {
        return context.Set<T>().Find(id);
    }

    public void Add(T entity)
    {
        context.Set<T>().Add(entity);
    }

    public void Update(T entity)
    {
        context.Entry(entity).State = EntityState.Modified;
    }

    public void Delete(T entity)
    {
        context.Set<T>().Remove(entity);
    }

    public IEnumerable<T> GetAll()
    {
        return context.Set<T>().ToList();
    }
}

UnitOfWork Sınıfı Oluşturma: Bir iş birimi sınıfı oluşturarak, tüm repository işlemlerini birleştirin ve SaveChanges() yöntemi ile değişiklikleri kaydedin:

public class UnitOfWork
{
    private readonly MyDbContext context;

    public UnitOfWork(MyDbContext dbContext)
    {
        context = dbContext;
        Customers = new Repository<Customer>(context);
    }

    public Repository<Customer> Customers { get; }

    public void SaveChanges()
    {
        context.SaveChanges();
    }
}

Kullanım: Şimdi Generic Repository ve UnitOfWork sınıflarını kullanarak veritabanı işlemlerini gerçekleştirebilirsiniz. Örnek kullanım:

using (var dbContext = new MyDbContext())
{
    using (var unitOfWork = new UnitOfWork(dbContext))
    {
        // Müşteri eklemek
        var newCustomer = new Customer { Name = "John Doe" };
        unitOfWork.Customers.Add(newCustomer);
        unitOfWork.SaveChanges();

        // Bir müşteriyi güncellemek
        var existingCustomer = unitOfWork.Customers.GetById(1);
        existingCustomer.Name = "Updated Name";
        unitOfWork.Customers.Update(existingCustomer);
        unitOfWork.SaveChanges();

        // Bir müşteriyi silmek
        var customerToDelete = unitOfWork.Customers.GetById(2);
        unitOfWork.Customers.Delete(customerToDelete);
        unitOfWork.SaveChanges();

        // Tüm müşterileri getirmek
        var allCustomers = unitOfWork.Customers.GetAll();
        foreach (var customer in allCustomers)
        {
            Console.WriteLine($"Customer Id: {customer.Id}, Name: {customer.Name}");
        }
    }
}

Bu örnek, Entity Framework ile Generic Repository tasarım deseninin kullanımını gösterir. Bu desen, veritabanı işlemlerini soyutlar ve kodun daha modüler ve yönetilebilir olmasını sağlar. Ayrıca, iş birimi (UnitOfWork) ile tüm işlemleri bir araya getirerek, veritabanı işlemlerini tek bir işlem içinde birleştirir ve hata durumlarında geri alma işlemini kolaylaştırır.

CRUD (Create, Read, Update, Delete) işlemlerini nasıl gerçekleştirir?

C# Generic Repository tasarım deseni, CRUD (Create, Read, Update, Delete) işlemlerini genelleştirilmiş bir şekilde ele alır ve farklı varlık türleri için yeniden kullanılabilir işlevler sunar. Aşağıda, Generic Repository tasarım deseni kullanarak her bir CRUD işlemini derinlemesine açıklayan bir örnek verilecektir.

Örneğimizde bir “Customer” varlık sınıfını kullanarak CRUD işlemlerini yapacağımızı varsayalım.

Create (Ekleme) İşlemi: Generic Repository ile yeni bir müşteri eklemek için aşağıdaki adımları izleyebilirsiniz:

using (var unitOfWork = new UnitOfWork(new MyDbContext()))
{
    var newCustomer = new Customer
    {
        Name = "John Doe",
        // Diğer özellikler
    };
    unitOfWork.Customers.Add(newCustomer);
    unitOfWork.SaveChanges();
}

Bu işlem, yeni bir müşteri nesnesini oluşturur, Add metodu ile Repository’ye ekler ve değişiklikleri SaveChanges ile kaydeder.

Read (Okuma) İşlemi: Generic Repository ile müşteri bilgilerini okumak için şu şekilde kullanabilirsiniz:

using (var unitOfWork = new UnitOfWork(new MyDbContext()))
{
    var customer = unitOfWork.Customers.GetById(1); // Id 1'e sahip müşteriyi getir
    if (customer != null)
    {
        Console.WriteLine($"Customer Id: {customer.Id}, Name: {customer.Name}");
    }
}

GetById metodu ile müşteriyi Id’ye göre getirebilirsiniz. İstenirse, GetAll metodu ile tüm müşterileri de getirebilirsiniz.

Update (Güncelleme) İşlemi: Müşteri bilgilerini güncellemek için aşağıdaki şekilde kullanabilirsiniz:

using (var unitOfWork = new UnitOfWork(new MyDbContext()))
{
    var customer = unitOfWork.Customers.GetById(1); // Güncellenmesi gereken müşteriyi getir
    if (customer != null)
    {
        customer.Name = "Updated Name";
        // Diğer güncellenecek özellikler
        unitOfWork.Customers.Update(customer);
        unitOfWork.SaveChanges();
    }
}

İlgili müşteriyi GetById ile getirip, güncellemeleri yaparak ve ardından Update ve SaveChanges ile değişiklikleri kaydedebilirsiniz.

Delete (Silme) İşlemi: Müşteriyi silmek için aşağıdaki şekilde kullanabilirsiniz:

using (var unitOfWork = new UnitOfWork(new MyDbContext()))
{
    var customerToDelete = unitOfWork.Customers.GetById(2); // Silinmesi gereken müşteriyi getir
    if (customerToDelete != null)
    {
        unitOfWork.Customers.Delete(customerToDelete);
        unitOfWork.SaveChanges();
    }
}

Silinmesi gereken müşteriyi GetById ile getirip, Delete ve SaveChanges ile silme işlemini gerçekleştirebilirsiniz.

Generic Repository tasarım deseni sayesinde, CRUD işlemleri farklı varlık türleri için aynı yapıda çalışır ve veritabanı işlemleri soyutlanır. Bu, yazılımınızı daha modüler hale getirir ve aynı işlemleri tekrar tekrar yazmaktan kaçınmanıza yardımcı olur. Bu tasarım deseni, veri tabanı işlemlerini daha verimli ve yeniden kullanılabilir bir şekilde yönetmenizi sağlar.

Birden fazla varlık (entity) türünü nasıl destekler?

C# Generic Repository tasarım deseni, birden fazla varlık (entity) türünü desteklemek için tür parametresi ile genelleştirilmiş bir yapı sunar. Bu sayede farklı varlık türleri için aynı CRUD (Create, Read, Update, Delete) işlemlerini yeniden kullanabilirsiniz. Aşağıda bu konuyu daha derinlemesine anlatan bir örnek verilecektir.

Varsayalım ki projenizde “Customer” ve “Product” adında iki farklı varlık türü bulunuyor ve her ikisini de Generic Repository ile desteklemek istiyorsunuz.

Varlık (Entity) Sınıfları Oluşturma: İlk adım, her bir varlık türü için ayrı C# sınıfları oluşturmaktır. Örnek olarak, “Customer” ve “Product” sınıflarını oluşturalım:

public class Customer
{
    public int CustomerId { get; set; }
    public string CustomerName { get; set; }
    // Diğer özellikler
}

public class Product
{
    public int ProductId { get; set; }
    public string ProductName { get; set; }
    // Diğer özellikler
}

DbContext Oluşturma: DbContext sınıfınızı tanımlayın ve her iki varlık türünü de DbSet ile ilişkilendirin:

public class MyDbContext : DbContext
{
    public DbSet<Customer> Customers { get; set; }
    public DbSet<Product> Products { get; set; }
}

Generic Repository Sınıfı Oluşturma: Generic Repository sınıfınızı her iki varlık türü için genel olarak kullanacak şekilde oluşturun. Bu sınıf, tür parametresi ile genelleştirilmiş ve veritabanı işlemlerini gerçekleştirecektir.

public class Repository<T> where T : class
{
    private readonly MyDbContext context;

    public Repository(MyDbContext dbContext)
    {
        context = dbContext;
    }

    public T GetById(int id)
    {
        return context.Set<T>().Find(id);
    }

    public void Add(T entity)
    {
        context.Set<T>().Add(entity);
    }

    public void Update(T entity)
    {
        context.Entry(entity).State = EntityState.Modified;
    }

    public void Delete(T entity)
    {
        context.Set<T>().Remove(entity);
    }

    public IEnumerable<T> GetAll()
    {
        return context.Set<T>().ToList();
    }
}

UnitOfWork Sınıfı Oluşturma: Bir iş birimi sınıfı oluşturarak, her iki repository için işlemleri birleştirin:

public class UnitOfWork
{
    private readonly MyDbContext context;

    public UnitOfWork(MyDbContext dbContext)
    {
        context = dbContext;
        Customers = new Repository<Customer>(context);
        Products = new Repository<Product>(context);
    }

    public Repository<Customer> Customers { get; }
    public Repository<Product> Products { get; }

    public void SaveChanges()
    {
        context.SaveChanges();
    }
}

Kullanım: Artık hem “Customer” hem de “Product” varlık türleri için CRUD işlemlerini yapabilirsiniz:

using (var unitOfWork = new UnitOfWork(new MyDbContext()))
{
    // Customer ekleme
    var newCustomer = new Customer { CustomerName = "John Doe" };
    unitOfWork.Customers.Add(newCustomer);

    // Product ekleme
    var newProduct = new Product { ProductName = "Sample Product" };
    unitOfWork.Products.Add(newProduct);

    unitOfWork.SaveChanges();
}

CRUD işlemlerini aynı Generic Repository ve UnitOfWork sınıfları ile hem “Customer” hem de “Product” varlık türleri için kullanabilirsiniz.

Bu yaklaşım, farklı varlık türlerini desteklemek için Generic Repository tasarım desenini kullanmanın örneklerinden sadece biridir. Bu sayede kod tekrarı önlenir, veritabanı işlemleri soyutlanır ve yazılımınız daha modüler ve bakımı daha kolay hale gelir.

Generic Repository Arayüzü (Interface)

C# Generic Repository tasarım deseni için bir arayüz (interface) oluşturmak, bu tasarım desenin esnekliğini artırabilir ve çeşitli veritabanı işlemlerini daha genelleştirilmiş bir şekilde ele almanıza yardımcı olabilir. Bu sayede projenizde farklı varlık türleri için kullanılan Generic Repository’ler için bir standart belirleyebilirsiniz.

Aşağıda C# Generic Repository tasarım deseni için bir arayüz oluşturmanın ve kullanmanın adımlarını derinlemesine açıklayan bir örnek verilecektir.

IGenericRepository Arayüzü Oluşturma: İlk adım, Generic Repository tasarım deseni için bir arayüz (interface) oluşturmaktır. Bu arayüz, CRUD işlemlerini tanımlar ve daha sonra farklı varlık türleri için kullanılacak Generic Repository’ler için bir şablondur.

public interface IGenericRepository<T> where T : class
{
    T GetById(int id);
    void Add(T entity);
    void Update(T entity);
    void Delete(T entity);
    IEnumerable<T> GetAll();
}

Bu arayüz, tür parametresi ile genelleştirilir ve CRUD işlemlerini içerir.

Generic Repository Sınıfı Oluşturma: Daha sonra, Generic Repository tasarım desenini uygulayan bir sınıf oluşturun. Bu sınıf, IGenericRepository arayüzünü uygular ve tüm CRUD işlemlerini gerçekleştirir.

public class GenericRepository<T> : IGenericRepository<T> where T : class
{
    private readonly MyDbContext context;

    public GenericRepository(MyDbContext dbContext)
    {
        context = dbContext;
    }

    public T GetById(int id)
    {
        return context.Set<T>().Find(id);
    }

   

    public void Update(T entity)
    {
        context.Entry(entity).State = EntityState.Modified;
    }

    public void Delete(T entity)
    {
        context.Set<T>().Remove(entity);
    }

    public IEnumerable<T> GetAll()
    {
        return context.Set<T>().ToList();
    }
}

Generic Repository sınıfı, IGenericRepository arayüzünü uygular ve tür parametresi ile genelleştirilmiştir.

UnitOfWork Sınıfını Güncelleme: UnitOfWork sınıfınıza, yeni Generic Repository sınıfınızı eklemelisiniz. Örneğin:

public class UnitOfWork
{
    private readonly MyDbContext context;

    public UnitOfWork(MyDbContext dbContext)
    {
        context = dbContext;
        Customers = new GenericRepository<Customer>(context);
        Products = new GenericRepository<Product>(context);
    }

    public IGenericRepository<Customer> Customers { get; }
    public IGenericRepository<Product> Products { get; }

    public void SaveChanges()
    {
        context.SaveChanges();
    }
}

Burada, IGenericRepository<Customer> ve IGenericRepository<Product> arayüzlerini kullanarak Generic Repository sınıflarını oluşturuyoruz.

Kullanım: Artık Generic Repository tasarım desenini kullanarak CRUD işlemlerini farklı varlık türleri için yapabilirsiniz:

using (var unitOfWork = new UnitOfWork(new MyDbContext()))
{
    // Customer için CRUD işlemleri
    var newCustomer = new Customer { /* müşteri özellikleri */ };
    unitOfWork.Customers.Add(newCustomer);
    var existingCustomer = unitOfWork.Customers.GetById(1);
    existingCustomer.Name = "Updated Name";
    unitOfWork.Customers.Update(existingCustomer);
    unitOfWork.Customers.Delete(existingCustomer);
    // ...

    // Product için CRUD işlemleri
    var newProduct = new Product { /* ürün özellikleri */ };
    unitOfWork.Products.Add(newProduct);
    var existingProduct = unitOfWork.Products.GetById(1);
    existingProduct.Name = "Updated Name";
    unitOfWork.Products.Update(existingProduct);
    unitOfWork.Products.Delete(existingProduct);
    // ...

    unitOfWork.SaveChanges();
}

Bu yaklaşım, projenizde farklı varlık türleri için Generic Repository kullanmanın bir yolunu sağlar ve aynı CRUD işlemlerini tekrar tekrar yazmaktan kaçınmanıza yardımcı olur. Ayrıca, IGenericRepository arayüzü, Generic Repository sınıfınıza bir standart belirlemenize yardımcı olur. Bu tasarım deseni, yazılımınızı daha modüler ve bakımı daha kolay hale getirir.

IRepository<T> arayüzü nasıl tasarlanır?

C# Generic Repository tasarım desenini uygulamak için IRepository<T> arayüzünü oluşturmak, farklı varlık (entity) türleri için yeniden kullanılabilir bir arayüz sağlar. Bu arayüz, CRUD (Create, Read, Update, Delete) işlemlerini tanımlar ve Generic Repository sınıfları için bir şablon olarak kullanılır. Aşağıda, IRepository<T> arayüzünün nasıl tasarlanacağını ve kullanılacağını detaylı bir şekilde anlatan bir örnek verilecektir.

IRepository<T> Arayüzü Oluşturma: İlk adım, Generic Repository tasarım desenini uygulamak için bir arayüz oluşturmaktır. Bu arayüz, CRUD işlemlerini belirtmelidir. Örnek olarak:

public interface IRepository<T> where T : class
{
    T GetById(int id);
    IEnumerable<T> GetAll();
    void Add(T entity);
    void Update(T entity);
    void Delete(T entity);
}

Bu arayüz, T türünde genelleştirilmiştir ve CRUD işlemlerini içerir.

Generic Repository Sınıfını Oluşturma: Daha sonra, Generic Repository tasarım desenini uygulayan bir sınıf oluşturun. Bu sınıf, IRepository<T> arayüzünü uygular ve belirtilen CRUD işlemlerini gerçekleştirir.

public class GenericRepository<T> : IRepository<T> where T : class
{
    private readonly DbContext context;

    public GenericRepository(DbContext dbContext)
    {
        context = dbContext;
    }

    public T GetById(int id)
    {
        return context.Set<T>().Find(id);
    }

    public IEnumerable<T> GetAll()
    {
        return context.Set<T>().ToList();
    }

    public void Add(T entity)
    {
        context.Set<T>().Add(entity);
    }

    public void Update(T entity)
    {
        context.Entry(entity).State = EntityState.Modified;
    }

    public void Delete(T entity)
    {
        context.Set<T>().Remove(entity);
    }
}

Generic Repository sınıfı, IRepository<T> arayüzünü uygular ve tür parametresi ile genelleştirilir.

Kullanım: Şimdi Generic Repository tasarım desenini kullanarak CRUD işlemlerini farklı varlık türleri için yapabilirsiniz:

using (var dbContext = new MyDbContext())
{
    var customerRepository = new GenericRepository<Customer>(dbContext);
    var productRepository = new GenericRepository<Product>(dbContext);

    // Customer için CRUD işlemleri
    var newCustomer = new Customer { /* müşteri özellikleri */ };
    customerRepository.Add(newCustomer);
    var existingCustomer = customerRepository.GetById(1);
    existingCustomer.Name = "Updated Name";
    customerRepository.Update(existingCustomer);
    customerRepository.Delete(existingCustomer);
    // ...

    // Product için CRUD işlemleri
    var newProduct = new Product { /* ürün özellikleri */ };
    productRepository.Add(newProduct);
    var existingProduct = productRepository.GetById(1);
    existingProduct.Name = "Updated Name";
    productRepository.Update(existingProduct);
    productRepository.Delete(existingProduct);
    // ...
}

Bu yaklaşım, farklı varlık türleri için Generic Repository kullanmanın bir yolunu sağlar ve aynı CRUD işlemlerini tekrar tekrar yazmaktan kaçınmanıza yardımcı olur. IRepository<T> arayüzü, Generic Repository sınıfınıza bir standart belirlemenize yardımcı olur. Bu tasarım deseni, yazılımınızı daha modüler ve bakımı daha kolay hale getirir.

CRUD işlemleri için hangi yöntemler tanımlanır?

C# Generic Repository tasarım deseninde CRUD (Create, Read, Update, Delete) işlemlerini gerçekleştirmek için beş temel yöntem tanımlanır. Bu yöntemler, bir varlık (entity) türünün veritabanı işlemlerini gerçekleştirmek için kullanılır. İşte bu beş temel yöntemin her birinin detaylı açıklamaları:

GetById(int id): Bu yöntem, veritabanından belirtilen kimlik (id) değerine sahip bir varlığı almak için kullanılır. Kimlik, genellikle varlık türünün birincil anahtar (primary key) özelliği ile eşleştirilir. İşte bir örnek:

public T GetById(int id)
{
    return context.Set<T>().Find(id);
}

GetAll(): Bu yöntem, tüm varlıkları bir koleksiyon olarak veritabanından getirir. Genellikle bir varlık türünün tüm kayıtlarını almak için kullanılır. İşte bir örnek:

public IEnumerable<T> GetAll()
{
    return context.Set<T>().ToList();
}

Add(T entity): Bu yöntem, yeni bir varlığı veritabanına eklemek için kullanılır. Yeni bir varlık oluşturulur ve bu yöntem aracılığıyla veritabanına eklenir. İşte bir örnek:

public void Add(T entity)
{
    context.Set<T>().Add(entity);
}

Update(T entity): Bu yöntem, mevcut bir varlığı güncellemek için kullanılır. Varlık nesnesi alınır, değişiklikler yapılır ve bu yöntemle veritabanına güncelleme işlemi uygulanır. İşte bir örnek:

public void Update(T entity)
{
    context.Entry(entity).State = EntityState.Modified;
}

Delete(T entity): Bu yöntem, bir varlığı veritabanından silmek için kullanılır. Belirtilen varlık nesnesi alınır ve veritabanından kaldırılır. İşte bir örnek:

public void Delete(T entity)
{
    context.Set<T>().Remove(entity);
}

Bu beş temel yöntem, Generic Repository tasarım deseninde her varlık türü için aynıdır. Bu tasarım deseni, tekrar tekrar aynı CRUD işlemlerini yazmaktan kaçınmanıza yardımcı olur ve kodunuzu daha modüler hale getirir. Her bir yöntem, genellikle bir veritabanı işlemi gerçekleştiren LINQ ifadeleri veya Entity Framework gibi ORM (Object-Relational Mapping) araçları kullanır. Bu sayede veritabanı işlemleri soyutlanır ve kodun daha okunabilir ve bakımı daha kolay hale gelir.

Birden fazla varlık türünü desteklemek için arayüz nasıl genelleştirilir?

Generic Repository Uygulaması

• Generic Repository’nin somut uygulaması nasıl yapılır?

C# Generic Repository tasarım deseni, veritabanı işlemlerini yönetmek için genelleştirilmiş bir yapı sağlar ve farklı varlık (entity) türleri için CRUD (Create, Read, Update, Delete) işlemlerini somutlaştırmak için kullanılır. Aşağıda, Generic Repository’nin somut bir uygulamasını nasıl yapacağınızı adım adım anlatan bir örnek bulunmaktadır.

Örnek olarak, bir öğrenci nesnesi için Generic Repository tasarım desenini uygulayacağımızı düşünelim.

Varlık (Entity) Sınıfı Oluşturma: İlk adım, veritabanınızda temsil edilecek öğrenci nesnesini temsil eden bir sınıf oluşturmak:

public class Student
{
    public int StudentId { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public DateTime BirthDate { get; set; }
}

DbContext Sınıfını Oluşturma: Ardından, Entity Framework veya benzeri bir ORM kullanarak DbContext sınıfınızı oluşturun:

public class MyDbContext : DbContext
{
    public DbSet<Student> Students { get; set; }
}

IArachnidRepository Arayüzünü Oluşturma: Generic Repository tasarım desenini somutlaştırmak için bir arayüz (interface) oluşturun:

public interface IGenericRepository<T> where T : class
{
    T GetById(int id);
    IEnumerable<T> GetAll();
    void Add(T entity);
    void Update(T entity);
    void Delete(T entity);
}

Generic Repository Sınıfını Oluşturma: Generic Repository sınıfını oluşturun ve IGenericRepository<T> arayüzünü uygulayın:

public class GenericRepository<T> : IGenericRepository<T> where T : class
{
    private readonly MyDbContext context;

    public GenericRepository(MyDbContext dbContext)
    {
        context = dbContext;
    }

    public T GetById(int id)
    {
        return context.Set<T>().Find(id);
    }

    public IEnumerable<T> GetAll()
    {
        return context.Set<T>().ToList();
    }

    public void Add(T entity)
    {
        context.Set<T>().Add(entity);
    }

    public void Update(T entity)
    {
        context.Entry(entity).State = EntityState.Modified;
    }

    public void Delete(T entity)
    {
        context.Set<T>().Remove(entity);
    }
}

Kullanım: Generic Repository’yi kullanarak CRUD işlemlerini gerçekleştirin:

using (var dbContext = new MyDbContext())
{
    var studentRepository = new GenericRepository<Student>(dbContext);

    // Öğrenci ekleme
    var newStudent = new Student
    {
        FirstName = "John",
        LastName = "Doe",
        BirthDate = new DateTime(2000, 1, 1)
    };
    studentRepository.Add(newStudent);
    dbContext.SaveChanges();

    // Öğrenci güncelleme
    var existingStudent = studentRepository.GetById(1);
    existingStudent.FirstName = "Updated";
    studentRepository.Update(existingStudent);
    dbContext.SaveChanges();

    // Öğrenci silme
    var studentToDelete = studentRepository.GetById(2);
    studentRepository.Delete(studentToDelete);
    dbContext.SaveChanges();
}

Bu örnek, Generic Repository tasarım desenini somutlaştırmanın bir yolunu göstermektedir. Generic Repository’nin kullanılması, kodunuzu daha temiz ve tekrar kullanılabilir hale getirir. Ayrıca, farklı varlık türleri için aynı CRUD işlemlerini tekrar tekrar yazmak zorunda kalmadan veritabanı işlemlerini yönetmenize olanak tanır.

Entity Framework veya ADO.NET kullanarak Generic Repository nasıl uygulanır?

C# Generic Repository tasarım deseni, Entity Framework veya ADO.NET gibi veritabanı erişim teknolojileriyle kullanılarak genelleştirilmiş bir yapı sağlar. Bu tasarım deseni, farklı varlık (entity) türleri için aynı CRUD (Create, Read, Update, Delete) işlemlerini yeniden kullanmanıza yardımcı olur. Aşağıda, Entity Framework ile C# Generic Repository tasarım desenini nasıl uygulayabileceğinizi ve ayrıca Entity Framework olmadan ADO.NET kullanarak nasıl uygulayabileceğinizi detaylı bir şekilde anlatacağım.

Varlık (Entity) Sınıfı Oluşturma: İlk adım, veritabanınızdaki bir tabloyu temsil eden bir varlık sınıfı oluşturmaktır. Örneğin, bir “Student” sınıfı oluşturabilirsiniz:

public class Student
{
    public int StudentId { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

DbContext Sınıfını Oluşturma: Entity Framework kullanarak DbContext sınıfınızı oluşturun ve varlık türünüzü DbSet ile ilişkilendirin:

public class MyDbContext : DbContext
{
    public DbSet<Student> Students { get; set; }
}

IGenericRepository Arayüzü Oluşturma: Generic Repository tasarım desenini uygulamak için bir arayüz oluşturun:

public interface IGenericRepository<T> where T : class
{
    T GetById(int id);
    IEnumerable<T> GetAll();
    void Add(T entity);
    void Update(T entity);
    void Delete(T entity);
}

Generic Repository Sınıfını Oluşturma: Generic Repository sınıfını oluşturun ve IGenericRepository<T> arayüzünü uygulayın. Entity Framework ile veritabanı işlemlerini gerçekleştirin:

public class GenericRepository<T> : IGenericRepository<T> where T : class
{
    private readonly MyDbContext context;

    public GenericRepository(MyDbContext dbContext)
    {
        context = dbContext;
    }

    public T GetById(int id)
    {
        return context.Set<T>().Find(id);
    }

    public IEnumerable<T> GetAll()
    {
        return context.Set<T>().ToList();
    }

    public void Add(T entity)
    {
        context.Set<T>().Add(entity);
    }

    public void Update(T entity)
    {
        context.Entry(entity).State = EntityState.Modified;
    }

    public void Delete(T entity)
    {
        context.Set<T>().Remove(entity);
    }
}

Kullanım: Generic Repository’yi kullanarak CRUD işlemlerini gerçekleştirin:

using (var dbContext = new MyDbContext())
{
    var studentRepository = new GenericRepository<Student>(dbContext);

    // Öğrenci ekleme
    var newStudent = new Student { FirstName = "John", LastName = "Doe" };
    studentRepository.Add(newStudent);
    dbContext.SaveChanges();

    // Öğrenci güncelleme
    var existingStudent = studentRepository.GetById(1);
    existingStudent.FirstName = "Updated";
    studentRepository.Update(existingStudent);
    dbContext.SaveChanges();

    // Öğrenci silme
    var studentToDelete = studentRepository.GetById(2);
    studentRepository.Delete(studentToDelete);
    dbContext.SaveChanges();
}

LINQ sorgularıyla nasıl birleştirilir?

C# Generic Repository tasarım deseni, LINQ (Language Integrated Query) sorgularıyla birleştirilerek veritabanı işlemleri için güçlü ve esnek bir yöntem sunar. LINQ, C# dilinde, nesne koleksiyonları üzerinde sorgular oluşturmanızı sağlayan bir dil özelliğidir ve Entity Framework gibi ORM (Object-Relational Mapping) araçlarıyla veritabanı işlemlerini kolaylaştırır. LINQ’i Generic Repository tasarım deseniyle birleştirmek için aşağıdaki adımları takip edebilirsiniz:

LINQ Sorguları İle Generic Repository’nin Uygulanması: Generic Repository’nin CRUD (Create, Read, Update, Delete) işlemleri, LINQ sorguları ile birleştirilerek veritabanına erişim sağlar. Örnek olarak, aşağıdaki öğrenci varlık (entity) ve bir Generic Repository kullanımını ele alalım:

// Varlık (Entity) Sınıfı
public class Student
{
    public int StudentId { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

// IGenericRepository Arayüzü
public interface IGenericRepository<T> where T : class
{
    T GetById(int id);
    IEnumerable<T> GetAll();
    void Add(T entity);
    void Update(T entity);
    void Delete(T entity);
}

// Generic Repository Sınıfı
public class GenericRepository<T> : IGenericRepository<T> where T : class
{
    private readonly MyDbContext context;

    public GenericRepository(MyDbContext dbContext)
    {
        context = dbContext;
    }

    public T GetById(int id)
    {
        return context.Set<T>().Find(id);
    }

    public IEnumerable<T> GetAll()
    {
        return context.Set<T>().ToList();
    }

    public void Add(T entity)
    {
        context.Set<T>().Add(entity);
    }

    public void Update(T entity)
    {
        context.Entry(entity).State = EntityState.Modified;
    }

    public void Delete(T entity)
    {
        context.Set<T>().Remove(entity);
    }
}

LINQ Sorgularını Kullanma: LINQ sorguları, Generic Repository ile entegre edilerek özel sorgular oluşturmanıza olanak tanır. Örneğin, tüm öğrencilerin listesini almak için LINQ kullanabilirsiniz:

using (var dbContext = new MyDbContext())
{
    var studentRepository = new GenericRepository<Student>(dbContext);

    // Tüm öğrencileri LINQ ile alma
    var students = studentRepository.GetAll();

    foreach (var student in students)
    {
        Console.WriteLine($"{student.FirstName} {student.LastName}");
    }
}

Özel LINQ Sorguları Oluşturma: LINQ sorgularını kullanarak özel sorgular oluşturabilirsiniz. Örneğin, belirli bir öğrenci adına göre öğrencileri filtrelemek için LINQ kullanabilirsiniz:

using (var dbContext = new MyDbContext())
{
    var studentRepository = new GenericRepository<Student>(dbContext);

    // LINQ ile öğrencileri filtreleme
    var studentsWithFirstNameJohn = studentRepository.GetAll()
        .Where(s => s.FirstName == "John")
        .ToList();

    foreach (var student in studentsWithFirstNameJohn)
    {
        Console.WriteLine($"{student.FirstName} {student.LastName}");
    }
}

LINQ, Generic Repository tasarım deseniyle birleştirildiğinde, veritabanı işlemleri için daha yüksek seviyede ve daha okunabilir kod yazmanıza yardımcı olur. LINQ, sorguları nesne koleksiyonları gibi ele almanıza olanak tanır ve Entity Framework gibi ORM araçları, LINQ sorgularını veritabanı işlemlerine çevirmek için kullanılır. Bu, veritabanı işlemlerini basit ve özgün bir şekilde yönetmenizi sağlar.

Unit of Work deseni ile Repository deseni nasıl birleştirilir?

C# Generic Repository tasarım deseni ve Unit of Work deseni, birlikte kullanılarak daha karmaşık veritabanı işlemleri için bir çözüm sunar. Bu iki tasarım deseni, veritabanı işlemlerini soyutlayarak, birleştirerek ve işlemleri gruplayarak kodun daha düzenli, daha bakımı kolay ve daha güvenilir hale gelmesini sağlar. İşte bu iki tasarım desenini nasıl birleştireceğinizi detaylı bir şekilde açıklayan bir örnek:

Varlık (Entity) Sınıfı ve Generic Repository Oluşturma: İlk adım, Generic Repository tasarım desenini kullanarak veritabanı işlemlerini soyutlamaktır. Aşağıda bir öğrenci varlık sınıfı ve Generic Repository’nin nasıl oluşturulacağına dair örnek bir kod bulunmaktadır:

public class Student
{
    public int StudentId { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

public interface IGenericRepository<T> where T : class
{
    T GetById(int id);
    IEnumerable<T> GetAll();
    void Add(T entity);
    void Update(T entity);
    void Delete(T entity);
}

public class GenericRepository<T> : IGenericRepository<T> where T : class
{
    private readonly MyDbContext context;

    public GenericRepository(MyDbContext dbContext)
    {
        context = dbContext;
    }

    // CRUD işlemleri burada tanımlanır
}

Unit of Work Sınıfı Oluşturma: Unit of Work tasarım desenini uygulamak için bir sınıf oluşturmanız gereklidir. Bu sınıf, Generic Repository’leri içerecek ve işlemleri gruplayarak yönetecektir:

public class UnitOfWork : IUnitOfWork
{
    private readonly MyDbContext context;

    public IGenericRepository<Student> StudentRepository { get; private set; }

    public UnitOfWork(MyDbContext dbContext)
    {
        context = dbContext;
        StudentRepository = new GenericRepository<Student>(context);
    }

    public void Save()
    {
        context.SaveChanges();
    }
}

IGenericRepository ve IUnitOfWork Arayüzlerini Oluşturma: Hem Generic Repository hem de Unit of Work sınıflarının arayüzlerini oluşturun:

public interface IGenericRepository<T> where T : class
{
    T GetById(int id);
    IEnumerable<T> GetAll();
    void Add(T entity);
    void Update(T entity);
    void Delete(T entity);
}

public interface IUnitOfWork : IDisposable
{
    IGenericRepository<Student> StudentRepository { get; }
    void Save();
}

Kullanım: Artık Unit of Work ve Generic Repository’yi kullanarak veritabanı işlemlerini gruplayabilir ve tek bir Save çağrısı ile tüm işlemleri kaydedebilirsiniz. Örnek kullanım şu şekilde olabilir:

using (var unitOfWork = new UnitOfWork(new MyDbContext()))
{
    var studentRepository = unitOfWork.StudentRepository;

    var newStudent = new Student { FirstName = "John", LastName = "Doe" };
    studentRepository.Add(newStudent);

    unitOfWork.Save();
}

Bu yaklaşım, veritabanı işlemlerini daha yüksek seviyede ve daha düzenli bir şekilde yönetmenize olanak tanır. Unit of Work, birden fazla işlemi tek bir Save çağrısıyla gruplamak ve herhangi bir hata durumunda işlemleri geri almak için kullanılır. Generic Repository, işlemlerin nasıl yapılacağını soyutlayarak ve tekrar kullanılabilir bir arayüz sunarak kodun daha temiz ve bakımı daha kolay hale gelmesini sağlar. Birlikte kullanıldığında, bu iki tasarım deseni veritabanı işlemlerini daha etkili bir şekilde yönetmenize yardımcı olur.

Transaction yönetimi nasıl yapılır?

C# Generic Repository tasarım deseni ile işlemlerinizin veritabanında bir bütün olarak ele alınmasını ve gerektiğinde geri alınabilmesini istiyorsanız, işlemi yönetmek ve işlemin sonucunu bir Transaction (işlem) içinde izlemek önemlidir. İşte C# Generic Repository tasarım deseni ile Transaction yönetimi hakkında detaylı bir açıklama:

Transaction Kavramı Nedir?: Bir işlem (Transaction), birden fazla veritabanı işlemini bir bütün olarak ele alan ve işlemin tamamının başarılı bir şekilde tamamlanmasını veya başarısız olduğunda geri alınmasını sağlayan bir mekanizmadır. İşlem başladığında, işlemin tüm adımları tamamlandığında veritabanı kalıcı değişiklikleri kabul eder. Ancak bir hata oluşursa veya işlem iptal edilirse, tüm değişiklikler geri alınır.

Transaction Oluşturma: C# ile Transaction oluşturmak için .NET Framework’ün System.Data.SqlClient adlı kütüphanesini kullanabilirsiniz. Aşağıdaki gibi bir örnek ile bir SqlConnection üzerinde bir Transaction oluşturabilirsiniz:

using (var connection = new SqlConnection(connectionString))
{
    connection.Open();

    using (var transaction = connection.BeginTransaction())
    {
        try
        {
            // Transaction içinde yapılacak işlemler buraya eklenir
            // Örnek: Insert, Update, Delete işlemleri

            transaction.Commit(); // İşlem başarılı ise işlemi onayla
        }
        catch (Exception)
        {
            transaction.Rollback(); // İşlem hata verirse işlemi geri al
            throw; // Hata durumunu yukarıya iletebilirsiniz
        }
    }
}

Generic Repository ile Transaction Kullanımı: Generic Repository tasarım deseni ile Transaction kullanmak istiyorsanız, Unit of Work deseni ile birlikte kullanabilirsiniz. Unit of Work, Generic Repository’leri ve Transaction’ı yönetmek için ideal bir yerdir. İşte bir örnek:

using (var unitOfWork = new UnitOfWork(new MyDbContext()))
{
    var studentRepository = unitOfWork.StudentRepository;

    using (var transaction = unitOfWork.BeginTransaction())
    {
        try
        {
            var newStudent = new Student { FirstName = "John", LastName = "Doe" };
            studentRepository.Add(newStudent);

            // Diğer işlemler buraya eklenir

            unitOfWork.Save();
            transaction.Commit(); // İşlem başarılı ise işlemi onayla
        }
        catch (Exception)
        {
            transaction.Rollback(); // İşlem hata verirse işlemi geri al
            throw; // Hata durumunu yukarıya iletebilirsiniz
        }
    }
}

Bu örnekte, Generic Repository tasarım deseni ile Transaction kullanarak işlemlerinizi gruplandık ve hata durumunda işlemi geri alabilirsiniz. İşlemler başarılı olduğunda işlemi onaylayarak (Commit), hata durumunda ise işlemi geri alarak (Rollback) veritabanınızın tutarlılığını koruyabilirsiniz. Bu, özellikle çoklu işlem adımlarını içeren işlemler için önemlidir.

Generic Repository ve Unit of Work desenlerini nasıl enjekte edersiniz?

Dependency Injection (Bağımlılık Enjeksiyonu), Generic Repository ve Unit of Work desenlerini projenize enjekte etmek, kodunuzu daha düzenli ve test edilebilir hale getirmenizi sağlar. Bağımlılıkları enjekte etmek için bir DI konteyneri kullanılır. Aşağıda bu üç kavramın nasıl bir araya getirileceğini detaylı bir şekilde anlatacağım:

Bağımlılıkları Enjekte Etme (Dependency Injection): Dependency Injection, bağımlılıkların (servisler, arayüzler, sınıflar vb.) bir sınıfın dışarıdan enjekte edilmesi anlamına gelir. Bu, sınıfların kendi bağımlılıklarını oluşturmak yerine dışarıdan almasını sağlar. Bu, kodun daha esnek, test edilebilir ve bakımı daha kolay hale gelmesini sağlar.

Generic Repository ve Unit of Work Sınıflarını Enjekte Etme: Generic Repository ve Unit of Work sınıflarını bağımlılıklar olarak projenize eklemek için aşağıdaki adımları izleyebilirsiniz:

a. İlgili arayüzleri (IGenericRepository, IUnitOfWork) ve sınıfları (GenericRepository, UnitOfWork) tanımlayın. Örneğin:

public interface IGenericRepository<T> where T : class
{
    // CRUD işlemleri burada tanımlanır
}

public class GenericRepository<T> : IGenericRepository<T> where T : class
{
    // CRUD işlemleri burada uygulanır
}

public interface IUnitOfWork : IDisposable
{
    // Unit of Work işlemleri burada tanımlanır
}

public class UnitOfWork : IUnitOfWork
{
    // Unit of Work işlemleri burada uygulanır
}

b. Bağımlılıklarınızı, projenizin DI konteynerine ekleyin. DI konteyneri projenize bağlı olarak değişebilir. Örneğin, ASP.NET Core projelerinde Startup.cs dosyasında servislerin eklenmesi gibi:

public void ConfigureServices(IServiceCollection services)
{
    services.AddScoped(typeof(IGenericRepository<>), typeof(GenericRepository<>));
    services.AddScoped<IUnitOfWork, UnitOfWork>();
}

c. Bağımlılıkları enjekte edeceğiniz sınıfları yazarken, bağımlılıkları sınıfın yapıcı (constructor) metoduna enjekte edin:

public class MyService
{
    private readonly IGenericRepository<Student> studentRepository;
    private readonly IUnitOfWork unitOfWork;

    public MyService(IGenericRepository<Student> studentRepository, IUnitOfWork unitOfWork)
    {
        this.studentRepository = studentRepository;
        this.unitOfWork = unitOfWork;
    }

    public void DoSomething()
    {
        // studentRepository ve unitOfWork kullanarak işlemler gerçekleştirin
    }
}

Bu, bağımlılıkların sınıfın yapıcısına enjekte edilerek, DI konteyneri tarafından otomatik olarak sağlanmasını sağlar.

Dependency Injection Kullanma: Bağımlılıkları enjekte etmek ve kullanmak için sınıfınızı ve bağımlılıklarınızı DI konteynerinden alabilirsiniz. Aşağıda bir örnek:

public class Program
{
    public static void Main(string[] args)
    {
        // DI konteyneri oluşturulur
        var serviceProvider = new ServiceCollection()
            .AddScoped<MyService>()
            .AddScoped(typeof(IGenericRepository<>), typeof(GenericRepository<>))
            .AddScoped<IUnitOfWork, UnitOfWork>()
            .BuildServiceProvider();

        // MyService sınıfı ve bağımlılıkları alınır
        var myService = serviceProvider.GetRequiredService<MyService>();

        // MyService ile işlem yapılır
        myService.DoSomething();
    }
}

Bu örnekte, MyService sınıfı, DI konteynerinden alınarak bağımlılıkları ile birlikte kullanılır.

Dependency Injection ile Generic Repository ve Unit of Work tasarım desenlerini birleştirerek, kodunuzun daha düzenli ve test edilebilir olmasını sağlayabilirsiniz. Ayrıca, bağımlılıkların DI konteyneri tarafından yönetilmesi, farklı bağımlılıkları kolayca değiştirmenize ve test etmenize olanak tanır.

IoC (Inversion of Control) konteynerlerinin kullanımı.

Dependency Injection (Bağımlılık Enjeksiyonu) ve IoC (Inversion of Control – Konteynerler) kavramları, yazılım geliştirme süreçlerini düzenli, esnek ve test edilebilir hale getirmenin önemli unsurlarıdır. IoC konteynerleri, bağımlılıkların (servisler, sınıflar vb.) oluşturulmasını ve yönetilmesini kolaylaştıran bir yazılım bileşeni sağlar. İşte IoC konteynerlerinin kullanımını detaylı bir şekilde anlatan bir rehber:

IoC Konteyneri (Container) Kavramı: IoC konteyneri, bir uygulama içindeki nesnelerin oluşturulmasını, bağımlılıkların yönetilmesini ve enjeksiyonun gerçekleştirilmesini sağlayan bir bileşen veya kütüphane olarak hizmet verir. Bu konteynerler, tasarım desenlerini kullanarak ve konfigürasyon dosyaları ile bağımlılıkların nasıl oluşturulacağını ve enjekte edileceğini belirlemenize olanak tanır.

IoC Konteyneri Seçimi: .NET ekosistemi içinde birçok IoC konteyneri bulunmaktadır. Örneğin, ASP.NET Core projelerinde built-in bir IoC konteyneri vardır. Bu konteyneri kullanabilirsiniz veya daha fazla özelleştirme gereksinimi varsa popüler IoC konteynerlerinden birini seçebilirsiniz. Örnek IoC konteynerleri şunlardır:

• ASP.NET Core Dependency Injection (Built-in): ASP.NET Core projelerinde varsayılan olarak bulunur.
• Autofac: Geniş özelleştirme seçenekleri sunan popüler bir IoC konteyneridir.
• Unity: Microsoft tarafından geliştirilen bir IoC konteyneridir.
• Ninject: Hafif ve kolay kullanılabilen bir IoC konteyneridir.
• StructureMap: Büyük ve karmaşık projeler için uygundur.

IoC Konteyneri ile Bağımlılıkları Yönetme: Bağımlılıkları IoC konteyneri aracılığıyla yönetmek için aşağıdaki adımları takip edebilirsiniz: a. Konteyneri projenize ekleyin. Örnek olarak, NuGet paketi olarak Autofac veya Unity’i projenize ekleyebilirsiniz. b. Bağımlılıkları kaydedin: Konteyneri kullanarak projenizde kullanılacak bağımlılıkları kaydedin. Bu kayıt işlemi genellikle projenizin başlangıcında gerçekleştirilir. c. Bağımlılıkları enjekte edin: Bağımlılıkları kullanmak istediğiniz sınıflara enjekte edin. Bu işlem, IoC konteyneri tarafından otomatik olarak yapılır.

Örnek Bir IoC Konteyneri Kullanımı: Autofac IoC konteynerini kullanarak örnek bir bağımlılık enjeksiyonu işlemi şu şekilde olabilir:

var builder = new ContainerBuilder();

// Bağımlılıkları kaydetme
builder.RegisterType<StudentService>().As<IStudentService>();
builder.RegisterType<CourseService>().As<ICourseService>();
builder.RegisterType<UnitOfWork>().As<IUnitOfWork>();
builder.RegisterType<MyDbContext>().AsSelf();

var container = builder.Build();

// Bağımlılıkları enjekte etme
using (var scope = container.BeginLifetimeScope())
{
    var studentService = scope.Resolve<IStudentService>();
    var courseService = scope.Resolve<ICourseService>();
    var unitOfWork = scope.Resolve<IUnitOfWork>();

    // Bağımlılıkları kullanma
    studentService.DoSomething();
    courseService.DoSomething();
}

Generic Repository tasarım deseninin test edilebilirliği nasıl artırılır?

Generic Repository tasarım deseni ile test edilebilirlik (testability) artırılabilir ve yazılım projenizin daha güvenilir hale gelmesini sağlayabilirsiniz. Test edilebilirlik, yazılım geliştirme sürecinde hata ayıklamayı, bakımı ve kod kalitesini geliştirmenize yardımcı olur. İşte Generic Repository tasarım deseninin test edilebilirliğini artırmak için yapabileceğiniz bazı önemli adımlar:

Bağımlılıkların Enjekte Edilmesi (Dependency Injection): Generic Repository sınıfını kullanırken bağımlılıkların (veritabanı bağlantısı, DbContext vb.) enjekte edilmesini sağlamak önemlidir. Bu, test edilebilirlik açısından büyük bir avantajdır. Özellikle veritabanı işlemleri için kullanılan DbContext, mock veya sahte (fake) bir DbContext ile değiştirilebilir. Bağımlılıkların enjekte edilmesi, testlerin sırf veritabanı işlemlerini test etmesine gerek kalmadan çalışmasını sağlar.

Mocking Kütüphanelerini Kullanma: Testler sırasında veritabanı işlemlerini taklit etmek için mock veya sahte nesneler kullanmak faydalı olabilir. Örneğin, Entity Framework için Moq, NSubstitute veya Entity Framework in-memory database kullanabilirsiniz. Bu, testlerin hızlı ve tekrarlanabilir olmasını sağlar.

Repository Arayüzleri ve Soydutlamaları Kullanma: Generic Repository tasarım desenini kullanırken, repository arayüzleri ve somut sınıfları kullanmak test edilebilirlik açısından önemlidir. Repository arayüzleri sayesinde mock veya sahte repository sınıfları oluşturarak veritabanı işlemlerini taklit edebilirsiniz. Örnek:

public interface IStudentRepository
{
    Student GetById(int id);
    IEnumerable<Student> GetAll();
    void Add(Student student);
    void Update(Student student);
    void Delete(Student student);
}

public class StudentRepository : IStudentRepository
{
    private readonly MyDbContext context;

    public StudentRepository(MyDbContext dbContext)
    {
        context = dbContext;
    }

    // CRUD işlemleri burada uygulanır
}

Unit of Work Deseni Kullanma: Unit of Work deseni ile tüm veritabanı işlemleri tek bir işlem içinde gruplanabilir. Bu, testlerin daha kolay ve yönetilebilir hale gelmesini sağlar. Her testin başında veritabanı işlemleri geri alınabilir ve her testin sonunda işlemler onaylanabilir.

Data Seeding Kullanma: Test verilerini doldurmak için data seeding (veri ekleme) yöntemlerini kullanabilirsiniz. Özellikle in-memory veritabanları veya test veritabanları kullanırken, her test öncesi ve sonrası test verilerini doldurup temizlemek testlerin daha temiz ve tekrarlanabilir olmasını sağlar.

Integration Test ve Unit Test Ayrımı: Veritabanı işlemleri içeren testler ile iş mantığına odaklanan testleri ayrı tutun. Veritabanı işlemlerini içeren testleri “integration test” olarak adlandırın ve iş mantığına odaklanan testleri “unit test” olarak adlandırın. Bu sayede her iki tür testi daha iyi yönetebilirsiniz.

Test edilebilirlik, yazılımın kalitesini artırmanın önemli bir yoludur ve Generic Repository tasarım desenini kullanırken bu ilkelere dikkat etmek, projenizin test edilebilirliğini artırır ve hataları daha erken tespit etmenize yardımcı olur.

Moq veya diğer mocking araçları ile nasıl test edilir?

Moq gibi mocking araçları, bağımlılıkları (örneğin veritabanı erişimi) taklit etmek ve test edebilmek için oldukça kullanışlıdır. Bu araçları kullanarak, bir sınıfın bağımlılıklarını taklit edebilir ve sınıfın işlevselliğini test edebilirsiniz. İşte Moq kullanarak nasıl test yapabileceğinize dair genel bir rehber:

Mock Nesnelerin Oluşturulması: İlk olarak, Moq veya diğer mocking kütüphanelerini projenize eklemelisiniz. Moq, popüler bir mocking kütüphanesidir. Örneğin, NuGet Package Manager’ı kullanarak Moq’u projenize ekleyebilirsiniz.

Install-Package Moq

Mock Nesnelerin Oluşturulması: Mock nesneleri oluşturmak için Moq’u kullanabilirsiniz. Aşağıda bir örnek:

using Moq;

// Interface veya sınıfı temsil eden bir mock oluşturun
var studentRepositoryMock = new Mock<IStudentRepository>();

Mock Nesnelerin Davranışlarının Ayarlanması: Mock nesnelerin davranışlarını belirlemek için Setup yöntemini kullanabilirsiniz. Örneğin, bir metodu çağırıldığında ne tür bir değer döndürmesi gerektiğini veya hangi davranışı sergilemesi gerektiğini ayarlayabilirsiniz.

// Örnek: GetAll metodu çağrıldığında sahte bir liste döndürme
studentRepositoryMock.Setup(repo => repo.GetAll()).Returns(new List<Student>());

Test İşlemlerinin Gerçekleştirilmesi: Şimdi test edilecek sınıfınızı veya servisinizi oluşturun ve mock nesneleri bu sınıfa enjekte edin.

var myService = new MyService(studentRepositoryMock.Object);

Testin Yürütülmesi: Şimdi sınıfınızı veya servisinizi test edebilirsiniz. Çağrılan metodlar, mock nesneler üzerinden taklit edilen davranışları sergileyecektir.

var result = myService.DoSomething();
// Test sonuçlarını kontrol edin ve doğrulayın

Verilerin ve Davranışların Doğrulanması: Test sonuçlarını kontrol etmek ve beklenen davranışların gerçekleşip gerçekleşmediğini doğrulamak için Assert ifadelerini kullanabilirsiniz.

Assert.IsNotNull(result);
studentRepositoryMock.Verify(repo => repo.GetAll(), Times.Once);

Temizlik: Testlerin sonunda mock nesneleri temizlemeyi unutmayın. Mock nesneleri ayrıca MockBehavior ile davranışlarını özelleştirebilirsiniz. Örneğin, Strict davranış ile bir metot çağrılmadığında hata alabilirsiniz.

Moq ve diğer mocking kütüphaneleri, bağımlılıkları taklit ederek sınıflarınızı test etmenizi kolaylaştırır. Bu şekilde, kodunuzu daha güvenilir hale getirebilir ve hataları daha erken tespit edebilirsiniz. Mocking, test otomasyonunun önemli bir parçasıdır ve yazılım projelerinizin kalitesini artırmanıza yardımcı olur.

Bir sonraki yazıda görüşmek dileğiyle!”