Linq Ve Transactionlar İle Conflictlerin Çözülmesi

2023-05-08

Veritabanları ile çalışırken, eşzamanlı transactionların doğru bir şekilde yönetilmesi ve veri bütünlüğünün korunması büyük önem taşır. LINQ (Language Integrated Query) ile veritabanı işlemlerinde transactionlar (transactions) kullanarak çakışmaların nasıl çözüleceği konusunda örnekler ve ve öneriler gösterilecektir.

Transactionlar (Transactions) Nedir?

Transactionlar, veritabanı üzerinde gerçekleştirilen bir dizi işlemi gruplayan ve bu işlemlerin tamamının başarılı bir şekilde tamamlanmasını veya hiçbirinin gerçekleştirilmemesini sağlayan bir yöntemdir. Transactionlar, veri bütünlüğünü korumak ve eşzamanlı işlemlerde çakışmaları çözmek için kullanılır.

LINQ ve Entity Framework ile Transactionlar Kullanarak Çakışmaların Çözülmesi

LINQ ve Entity Framework kullanarak, transactionlarla çakışmaları çözmek için aşağıdaki adımları takip edebiliriz:

  1. Veritabanı bağlantısı oluşturun.
  2. Transaction başlatın.
  3. Transactionları gerçekleştirin.
  4. Transactionı tamamlayın veya geri alın.

Örnek: Banka Hesaplarında Para Transferi

Bu örnekte, iki banka hesabı arasında para transferi gerçekleştiren bir uygulama için transactionlarla çakışmaların nasıl çözüleceğini göreceğiz.

Öncelikle, Entity Framework’te kullanılacak olan veritabanı nesnesini tanımlayalım:

public class BankDbContext : DbContext
{
    public DbSet<BankAccount> BankAccounts { get; set; }
}

public class BankAccount
{
    public int Id { get; set; }
    public string Owner { get; set; }
    public decimal Balance { get; set; }
}

Ardından, iki banka hesabı arasında para transferi gerçekleştiren bir işlemi yönetelim:

public void TransferFunds(int sourceAccountId, int targetAccountId, decimal amount)
{
    using (var context = new BankDbContext())
    {
        // İşlemi başlat
        using (var transaction = context.Database.BeginTransaction())
        {
            try
            {
                // Kaynak hesabı al
                var sourceAccount = context.BankAccounts.Find(sourceAccountId);
                if (sourceAccount == null)
                {
                    throw new InvalidOperationException("Kaynak hesap bulunamadı.");
                }

                // Hedef hesabı al
                var targetAccount = context.BankAccounts.Find(targetAccountId);
                if (targetAccount == null)
                {
                    throw new InvalidOperationException("Hedef hesap bulunamadı.");
                }

                // Para transferini gerçekleştir
               
                sourceAccount.Balance -= amount;
                targetAccount.Balance += amount;

                // Değişiklikleri kaydet
                context.SaveChanges();

                // İşlemi tamamla
                transaction.Commit();
            }
            catch (Exception ex)
            {
                // İşlemi geri al
                transaction.Rollback();
                throw new InvalidOperationException("Para transferi gerçekleştirilemedi.", ex);
            }
        }
    }
}

Bu örnekte, TransferFunds fonksiyonu, iki banka hesabı arasında para transferini gerçekleştirmek için bir transaction başlatır. İşlemin başarıyla tamamlanması durumunda, işlem Commit ile tamamlanır ve değişiklikler veritabanına kaydedilir. Eğer işlem sırasında bir hata oluşursa, transaction Rollback ile geri alınır ve veritabanındaki tutarlar önceki durumlarına döner.

Öneriler

Transactionlarla çakışmaları çözerken dikkate almanız gereken bazı noktalar şunlardır:

  1. Transactionları mümkün olduğunca kısa tutun: İşlem süresi ne kadar uzun olursa, eşzamanlı transactionlar arasındaki çakışma olasılığı o kadar artar. Transactionları kısa tutarak, veritabanı kaynaklarının daha verimli kullanılmasını sağlayabilirsiniz.

  2. Transactionlar sırasında hataları yönetin: Transactionlar sırasında meydana gelen hataların doğru şekilde yönetilmesi, veri bütünlüğünü korumak için önemlidir. Hataları işlem geri alınarak ve uygun hata mesajlarıyla yönetin.

  3. Transactionları gerekli durumlarda kullanın: Transactionlar, veri bütünlüğünü korumak için gereklidir, ancak her işlem için işlem kullanmak performansı olumsuz yönde etkileyebilir. Transactionları, birden fazla işlemin başarılı bir şekilde tamamlanmasını veya hiçbirinin gerçekleştirilmemesini sağlamak için gereken durumlarda kullanın.



More posts like this

The SemaphoreSlim Class: Multitask-Based Programming in C#

2023-06-11 | #net #semaphoreslim

Overview The SemaphoreSlim class is a structure used in C# to control one or more threads using a specific resource or operation concurrently. SemaphoreSlim limits the number of threads that can access the resource at the same time. The use of SemaphoreSlim is often used to prevent deadlock situations in multi-threaded applications and to ensure that a specific resource is used by only one or more threads at the same time.

Continue reading 


LINQ and Optimistic Concurrency: Methods for Ensuring Data Integrity

2023-06-11 | #linq #net #optimistic-concurrency

When working with databases, it is of great importance to properly manage concurrent operations and ensure data integrity. Concurrency control is used to manage multiple users or processes accessing the same data concurrently. In this article, we will explore how to ensure data integrity using LINQ (Language Integrated Query) with optimistic concurrency. What is Optimistic Concurrency? Optimistic concurrency is a method where resources are not locked when a transaction begins, but changes are checked before the transaction is completed.

Continue reading 


LINQ and Pessimistic Concurrency: Methods for Ensuring Data Integrity

2023-06-11 | #linq #net #pessimistic-concurrency

When working with databases, managing concurrent operations and ensuring data integrity are of great importance. Concurrency control is used to manage multiple users or processes accessing the same data concurrently. In this article, we will explore how to use LINQ (Language Integrated Query) with pessimistic concurrency to maintain data integrity. What is Pessimistic Concurrency? Pessimistic concurrency is based on the principle of locking the relevant data when a transaction begins and maintaining the lock until the transaction is completed.

Continue reading 