Dapper ORM

Dapper Kurulumu

Adım 1: Projenize Dapper’ı Eklemek Dapper’ı projenize eklemek için, genellikle NuGet Paket Yöneticisi’ni kullanırsınız. Aşağıdaki adımları izleyin:

1.1. Visual Studio’da projenizi açın.

1.2. Projeye sağ tıklayın ve “Yönet NuGet Paketleri” seçeneğini seçin.

1.3. “NuGet Paket Yöneticisi” penceresi açılacak. Sağ üst köşede “Göz at” sekmesini seçin.

1.4. “Dapper” aramasını yapın ve Dapper paketini bulun.

1.5. “Yüklemek için” butonuna tıklayarak Dapper’ı projenize ekleyin.

1.6. NuGet Paket Yöneticisi, Dapper ve bağımlılıklarını projenize ekleyecektir.

Adım 2: Gereksinimleri Karşılamak Dapper’ı projenize eklediğinizde, aşağıdaki gereksinimleri karşıladığınızdan emin olmanız gerekebilir:

2.1. Veritabanı Bağlantısı: Dapper, bir veritabanına bağlanmak için bir bağlantı dizesi ve veritabanı türüne ihtiyaç duyar. Veritabanınızın türüne uygun bir .NET veritabanı sürücüsüne (örneğin, SQL Server için System.Data.SqlClient, PostgreSQL için Npgsql, MySQL için MySql.Data, vb.) sahip olmalısınız.

2.2. Veri Sınıfları: Dapper, veritabanı tablolarını temsil eden veri sınıflarına (POCO – Plain Old CLR Object) ihtiyaç duyar. Veri sınıfları, veritabanı tablolarıyla uyumlu şekilde alanları (properties) tanımlar.

Adım 3: Dapper’ı Kullanmaya Başlamak Dapper’ı projenize ekledikten sonra, Dapper’ı kullanmaya başlamak için aşağıdaki temel adımları izleyebilirsiniz:

3.1. Veritabanı Bağlantısı: Dapper ile bir veritabanına bağlanın ve bağlantıyı yapılandırın.

3.2. SQL Sorguları: Dapper ile SQL sorgularını hazırlayın ve parametreleri kullanarak sorguları güvence altına alın.

3.3. Sorgu Yürütme: Dapper ile sorguları yürütün ve sonuçları işleyin.

3.4. Veri Sınıfları: Veritabanı tablolarını temsil eden veri sınıflarını kullanarak sonuçları nesne haline getirin.

Dapper ile ilgili daha fazla bilgi edinmek için resmi Dapper belgelerini incelemek ve örnek projeleri incelemek faydalı olacaktır. Bu şekilde Dapper’ı projenizde etkili bir şekilde kullanabilirsiniz.

Bağlantı Ayarları

Bağlantı Dizesi (Connection String): Bağlantı dizesi, projenizin hangi veritabanına, hangi sunucuya ve hangi kimlik doğrulama yöntemini kullanarak bağlanacağını belirleyen metin tabanlı bir yapıdır. Bağlantı dizesi, veritabanı türüne ve sunucu konfigürasyonuna göre değişiklik gösterir. Örnek olarak, SQL Server veritabanına bağlanmak için kullanılan bir bağlantı dizesi şu şekilde görünebilir:

string connectionString = "Server=myServer;Database=myDatabase;User Id=myUsername;Password=myPassword;";

Bu bağlantı dizesi aşağıdaki önemli unsurları içerir:

• Server: Veritabanı sunucusunun adı veya IP adresi.
• Database: Bağlanılacak veritabanının adı.
• User Id ve Password: Veritabanına bağlanmak için kullanılan kimlik bilgileri.

Her veritabanı sistemi (SQL Server, PostgreSQL, MySQL, vb.) için bağlantı dizesi farklılık gösterebilir. Resmi veritabanı belgeleri ve kütüphane dokümantasyonları, doğru bağlantı dizesi formatını öğrenmenize yardımcı olacaktır.

Bağlantı Ayarları: Bağlantı ayarları, veritabanı bağlantısı sırasında davranışı özelleştiren veya yapılandıran değerleri içerir. Bu ayarlar, bağlantı açma zaman aşımı, bağlantı havuzlama, karakter kodlaması, oturum değişkenleri ve daha fazlasını içerebilir. Ayarlar, projenizin ihtiyaçlarına ve veritabanınıza özgü gereksinimlere bağlı olarak değişebilir.

Bağlantı ayarları, veritabanı sunucunuzun ve kullandığınız veritabanı erişim kütüphanesinin belirttiği belgelere göre yapılandırılmalıdır. Örneğin, SQL Server bağlantıları için SqlConnection sınıfı kullanılıyorsa, bu sınıfın özelliklerini kullanarak bağlantı ayarları yapabilirsiniz.

using System.Data.SqlClient;

string connectionString = "Server=myServer;Database=myDatabase;User Id=myUsername;Password=myPassword;";
using (SqlConnection connection = new SqlConnection(connectionString))
{
    connection.Open();
    // Bağlantı açık ve kullanıma hazır.
    // SQL sorgularını bu bağlantı üzerinden yürütebilirsiniz.
}

Özellikle, bağlantı havuzlamayı (connection pooling) yapılandırma, bağlantıların veritabanına nasıl geri döneceğini ve yeniden kullanılacağını belirler. Bağlantı havuzlaması, veritabanı erişimi performansını artırabilir.

Bağlantı ayarlarını ve bağlantı dizesini projenizin gereksinimlerine göre düzenlemek, veritabanı ile güvenilir bir şekilde iletişim kurmanızı sağlar. Bu ayarları projenizin veritabanı erişim kütüphanesi ve veritabanı türüne uygun şekilde yapılandırmak, veritabanı bağlantısı ile ilgili sorunları önlemeye yardımcı olur.

SQL Sorguları

C# projelerinde Dapper kullanarak SQL sorguları oluşturmak ve parametreleri eklemek oldukça basit ve veritabanı işlemlerini daha güvenli hale getirmenize yardımcı olur. İşte Dapper kullanarak SQL sorguları oluşturmayı ve parametreleri nasıl eklemeyi öğrenebileceğiniz derinlemesine bir anlatım:

1. SQL Sorgusu Oluşturmak: Dapper ile SQL sorgularını oluşturmak için, genellikle sorguyu bir metin dizesi olarak belirlersiniz. Sorgunun parametrelerini belirlemek için özel işaretler kullanabilirsiniz. Örnek olarak, bir basit “SELECT” sorgusu oluşturmak için:

string sql = "SELECT * FROM Customers WHERE Country = @Country";

Bu örnekte, @Country parametresi, sorgunun bir parametresini temsil eder.

2. Parametre Eklemek: Parametreler, SQL sorgularına değerlerin güvenli bir şekilde eklenmesini sağlar ve SQL enjeksiyonlarını önler. Dapper ile parametre eklemek için, parametreleri bir anonim tip içinde belirleyebilirsiniz. Örnek olarak:

string country = "USA"; // Parametre değeri

string sql = "SELECT * FROM Customers WHERE Country = @Country";

var results = connection.Query<Customer>(sql, new { Country = country });

Yukarıdaki örnekte, @Country parametresi new { Country = country } ifadesi ile tanımlandı. Dapper, bu parametre değerini SQL sorgusu içine yerleştirir ve güvenli bir şekilde çalıştırır.

3. Parametre Türleri: Dapper, parametre türlerini otomatik olarak algılar ve veritabanıyla uygun bir şekilde eşleştirir. Ancak bazen parametre türünü belirtmek isteyebilirsiniz. Örneğin, bir tarih parametresini belirlemek için:

DateTime startDate = new DateTime(2023, 1, 1);

string sql = "SELECT * FROM Orders WHERE OrderDate >= @StartDate";

var results = connection.Query<Order>(sql, new { StartDate = startDate }, commandType: CommandType.Text);

Yukarıdaki örnekte, commandType parametresi kullanılarak sorgu türü belirtildi (burada metin olarak belirtilmiştir).

4. Birden Çok Parametre: Birden çok parametre eklemek için, aynı mantıkla ekleyebilirsiniz. Örnek olarak:

string country = "USA";
int totalOrders = 100;

string sql = "SELECT * FROM Customers WHERE Country = @Country AND TotalOrders >= @TotalOrders";

var results = connection.Query<Customer>(sql, new { Country = country, TotalOrders = totalOrders });

Bu, birden çok parametreyi aynı sorguda kullanmanın basit bir örneğidir.

Dapper, SQL sorgularını oluşturmayı ve parametreleri güvenli bir şekilde eklemeyi kolaylaştırır. Ayrıca, bu yöntem SQL sorgularının okunabilirliğini artırır ve kodu daha temiz hale getirir.

Dapper’da Sorgu Yürütme

1. Sorguları Yürütmek: Dapper kullanarak SQL sorgularını yürütmek için, öncelikle bir veritabanı bağlantısı oluşturmanız gerekir. Ardından Query veya Execute yöntemlerini kullanarak sorguları yürütebilirsiniz.

string sql = "SELECT * FROM Customers WHERE Country = @Country";

using (IDbConnection connection = new SqlConnection(connectionString))
{
    // Sorguyu yürütme ve sonuçları almak
    var results = connection.Query<Customer>(sql, new { Country = "USA" });
}

Yukarıdaki örnekte, connection.Query yöntemi kullanılarak bir “SELECT” sorgusu yürütüldü ve sonuçları almak için bir tür belirtildi (Customer).

2. Birden Fazla Sonuç Alma: Eğer birden fazla sonuç almanız gerekiyorsa, QueryMultiple yöntemini kullanabilirsiniz. Örneğin, iki farklı sorgu çalıştırma ve sonuçları almak için:

string sql = "SELECT * FROM Customers; SELECT * FROM Orders";

using (IDbConnection connection = new SqlConnection(connectionString))
{
    // Birden fazla sorgu çalıştırma
    using (var multi = connection.QueryMultiple(sql))
    {
        var customers = multi.Read<Customer>().ToList();
        var orders = multi.Read<Order>().ToList();
    }
}

3. Sorgu Türlerini Belirtme: Dapper, sonuçların nasıl dönüşeceğini anlamak için bir tür belirlemenizi gerektirir. Sorgunun sonuçlarını bir sınıf veya anonim tip ile eşleştirebilirsiniz. Ayrıca, sonuçların bir liste olarak veya tek bir öğe olarak dönmesini belirleyebilirsiniz.

4. Parametrelerle Çalışma: SQL sorgularını yürütürken parametrelerin nasıl kullanılacağını önceki cevapta açıkladık. Parametreleri sorgunuzda @ParametreAdı şeklinde belirleyebilirsiniz ve parametre değerlerini bir anonim nesne içinde sağlayabilirsiniz.

5. Dönen Sonuçlar: Dapper, sorgulardan dönen sonuçları otomatik olarak eşleştirir. Sonuçları nesne veya nesneler listesi olarak alabilirsiniz. Ayrıca, sonuçları dinamik nesneler olarak da alabilirsiniz. Veri türlerine göre sonuçları işleyebilirsiniz.

6. Hata Yönetimi: Dapper, sorguları yürütürken oluşabilecek hataları yönetmeye yardımcı olur. Exception’larını işleyerek hata durumlarını ele alabilirsiniz.

Dapper, SQL sorgularını çalıştırmak ve sonuçları almak için veritabanı işlemlerini basitleştiren güçlü bir araçtır. Veritabanı türüne ve projenizin ihtiyaçlarına bağlı olarak, bu temel yöntemleri ve Dapper’ın sunduğu diğer özellikleri kullanarak veritabanı erişimi sağlayabilirsiniz.

Veri Sınıfları

1. Veritabanı Tablosunu Anlama: Önce, temsil edeceğiniz veritabanı tablosunu ve bu tablonun şemasını anlayın. Bu, tablodaki sütunların adları, veri türleri ve ilişkileri hakkında bilgi sahibi olmanız gerektiği anlamına gelir. Veritabanı yönetim sistemi veya araçlarını kullanarak tabloyu inceleyebilirsiniz.

2. Veri Sınıfı Oluşturma: Şimdi, veritabanı tablosunu temsil edecek bir veri sınıfı (POCO) oluşturabilirsiniz. Sınıfı oluştururken aşağıdaki önemli unsurları düşünmelisiniz:

• Sınıf Adı: Sınıfın adı genellikle veritabanı tablosunun adını yansıtmalıdır. Örneğin, eğer tablo “Customers” ise, sınıf adı “Customer” olabilir.
• Property’ler: Her sütunu bir sınıf özelliği (property) olarak temsil etmelisiniz. Property isimleri ve veri türleri, veritabanı tablosundaki sütunların adları ve veri tipleri ile aynı olmalıdır. Örneğin, bir “Customers” tablosunun “FirstName” ve “LastName” sütunlarına sahipse, sınıf şu şekilde olabilir:

public class Customer
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

3. İlişkileri Düşünme: Eğer veritabanınızda tablolar arasında ilişkiler bulunuyorsa, bu ilişkileri veri sınıflarınıza yansıtmalısınız. Örneğin, bir “Orders” tablosu ve her siparişin bir müşteriye ait olduğunu düşünelim. Bu durumda “Customer” sınıfı ile “Order” sınıfı arasında bir ilişki kurmalısınız. Bu, Dapper’ı kullanarak veritabanı sorgularını daha kolay ve etkili bir şekilde yürütmenizi sağlar.

public class Order
{
    public int OrderId { get; set; }
    public int CustomerId { get; set; }
    // Diğer özellikler
}

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

4. Veri Sınıfını Veritabanı ile Eşleştirme: Veri sınıfınızı veritabanı tablosuyla eşleştirmek için, Dapper’ı kullanarak sorguları yürütürken sınıfınızı ve veritabanı tablonuzu ilişkilendirmeniz gerekecektir. Bu, verileri veritabanından çekerken veya veritabanına gönderirken çok önemlidir.

string sql = "SELECT * FROM Customers WHERE Country = @Country";
var results = connection.Query<Customer>(sql, new { Country = "USA" });

Dapper, veritabanı tablosunu ve veri sınıfını otomatik olarak eşleştirecektir.

Veritabanı tablolarını temsil eden veri sınıflarını oluşturarak, C# projelerinizde veritabanı işlemlerini daha kolay ve okunabilir bir hale getirebilirsiniz. Bu veri sınıfları aynı zamanda veritabanı işlemlerinin güvenli ve düzenli bir şekilde yapılmasını sağlar.

İlişkili Veri Çekme

1. Veri Sınıflarını Tasarlama: İlişkili tablolar arasında veri çekmek için önce veri sınıflarını doğru bir şekilde tasarlamalısınız. Her tabloyu temsil eden bir veri sınıfı (POCO) oluşturmalısınız. Ayrıca, tablolar arasındaki ilişkileri temsil etmek için uygun özellikleri (property) eklemelisiniz. İşte örnek bir senaryo:

Varsayalım ki iki tablonuz var: “Customers” ve “Orders”. Her müşterinin birden fazla siparişi olabilir. İlişkiyi temsil etmek için “Customers” ve “Orders” sınıflarını aşağıdaki gibi tasarlayabilirsiniz:

public class Customer
{
    public int CustomerId { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public List<Order> Orders { get; set; }
}

public class Order
{
    public int OrderId { get; set; }
    public int CustomerId { get; set; }
    public decimal TotalAmount { get; set; }
}

2. SQL Sorgusu Oluşturma: İlişkili verileri çekmek için uygun SQL sorgularını oluşturmanız gerekir. Örneğin, müşterileri ve onların siparişlerini birlikte almak için bir SQL sorgusu oluşturmalısınız.

string sql = "SELECT c.*, o.* FROM Customers c LEFT JOIN Orders o ON c.CustomerId = o.CustomerId";

Bu sorgu, “Customers” ve “Orders” tablolarını birleştirir ve müşteri bilgileri ile ilişkili siparişleri içerir.

3. Dapper Kullanarak Veri Çekme: Veritabanı sorgusunu Dapper kullanarak yürütebilirsiniz. Sorgunun sonucunu veri sınıflarına eşlemek için Dapper’ın Query veya QueryMultiple yöntemlerini kullanabilirsiniz.

using (IDbConnection connection = new SqlConnection(connectionString))
{
    var customers = connection.Query<Customer, Order, Customer>(
        sql,
        (customer, order) =>
        {
            customer.Orders = customer.Orders ?? new List<Order>();
            customer.Orders.Add(order);
            return customer;
        },
        splitOn: "CustomerId"
    ).Distinct().ToList();
}

Yukarıdaki örnek, müşteri ve sipariş bilgilerini çeker ve ilişkiyi kurar. splitOn parametresi, sorgudan dönen sonuçları nasıl böleceğinizi belirtir.

4. Sonuçları İşleme: Elde edilen sonuçları işlerken, müşterilerin ve siparişlerin ilişkisini görmelisiniz. İşte örnek bir döngü kullanımı:

foreach (var customer in customers)
{
    Console.WriteLine($"Customer: {customer.FirstName} {customer.LastName}");
    foreach (var order in customer.Orders)
    {
        Console.WriteLine($"Order: {order.OrderId}, Amount: {order.TotalAmount}");
    }
}

İlişkili tablolar arasında veri çekme ve ilişkileri kurma süreci, veritabanı tablolarının tasarımına, SQL sorgularının oluşturulmasına ve Dapper gibi ORM araçlarının kullanılmasına dayanır. İhtiyacınıza ve projenizin gereksinimlerine göre, bu süreci uyarlamanız gerekebilir.

Transaction Yönetimi

1. Transaction Oluşturma: Transaction kullanarak birden fazla veritabanı işlemini gruplamak için bir transaction nesnesi oluşturmanız gerekir. Transaction nesnesi, işlemleri başlatmak, işlem sırasında hataları işlemek ve işlemleri tamamlamak için kullanılır. C# projelerinde, System.Data.SqlClient veya diğer veritabanı sürücülerinin transaction sınıfını kullanabilirsiniz.

using (SqlConnection connection = new SqlConnection(connectionString))
{
    connection.Open();
    using (SqlTransaction transaction = connection.BeginTransaction())
    {
        try
        {
            // İşlemleri burada tanımlayın

            // Commit ile işlemleri onaylama
            transaction.Commit();
        }
        catch (Exception)
        {
            // Hata durumunda işlemleri geri alma
            transaction.Rollback();
            throw; // Hatanın üst seviyelere iletileceği yer
        }
    }
}

2. İşlemleri Tanımlama: Transaction içinde gerçekleştirilecek işlemleri tanımlayın. İşlemler, SQL sorgularını kullanarak veritabanı işlemlerini içerebilir. Örnek işlemler aşağıda gösterilmiştir:

using (SqlConnection connection = new SqlConnection(connectionString))
{
    connection.Open();
    using (SqlTransaction transaction = connection.BeginTransaction())
    {
        try
        {
            // İlk işlem
            string sql1 = "INSERT INTO Products (Name, Price) VALUES ('Product A', 100)";
            connection.Execute(sql1, transaction: transaction);

            // İkinci işlem
            string sql2 = "UPDATE Customers SET Balance = Balance - 100 WHERE CustomerId = 1";
            connection.Execute(sql2, transaction: transaction);

            // Commit ile işlemleri onaylama
            transaction.Commit();
        }
        catch (Exception)
        {
            // Hata durumunda işlemleri geri alma
            transaction.Rollback();
            throw;
        }
    }
}

3. Transaction’ların Atomik Olması: Transaction’lar atomik işlemlerdir, yani bir işlem başarısız olursa, diğer işlemler geri alınır. Bu, veritabanı işlemlerinin bir bütün olarak işlemesini sağlar. Eğer bir işlem başarısız olursa, transaction içindeki tüm işlemler geri alınır (rollback).

4. Hata İşleme: İşlemlerde hata meydana geldiğinde, hataları işleyin ve transaction’ı geri alın (Rollback). Hata durumunda bir exception fırlatmak, daha yüksek seviyeli kodun hatayı ele almasına yardımcı olur.

5. Transaction Kapsamı: Transaction’ları, belirli bir işlemi gruplamak için kullanabileceğiniz gibi, bir işlem veya servis çağrısının başlangıcından bitişine kadar kullanabilirsiniz. Böylece tüm işlemler bir transaction içinde otomatik olarak işlenir.

Transaction’lar, veritabanı işlemlerini koordine etmek ve işlemleri atomik hale getirmek için güçlü bir araçtır. Bu sayede veritabanı bütünlüğü ve tutarlılığı sağlayabilir ve hata durumlarında geri alma işlemi yapabilirsiniz.

Stored Procedure Kullanımı

Dapper’ı Projeye Ekleyin: İlk adım olarak, Dapper’ı projenize eklemeniz gerekiyor. NuGet Paket Yöneticisi’ni veya Package Manager Console’ı kullanarak Dapper paketini projenize ekleyebilirsiniz.

Install-Package Dapper

Veritabanı Bağlantısını Oluşturun: Dapper’ı kullanmadan önce bir veritabanı bağlantısı oluşturmalısınız. Bu, IDbConnection arayüzünü uygulayan bir sınıf olabilir. Genellikle SqlConnection sınıfını kullanırız. Örnek bir bağlantı oluşturma kodu:

using System.Data;
using System.Data.SqlClient;
string connectionString = "your_connection_string_here";
IDbConnection dbConnection = new SqlConnection(connectionString);

Stored Procedure’ı Çağırma: Dapper ile stored procedure’ı çağırmak için aşağıdaki yöntemleri kullanabilirsiniz:

Tek Satır Sonucu Dönen Stored Procedure: Tek bir değer veya tek bir satır sonucu dönen stored procedure’ları çağırmak için Query veya QueryFirstOrDefault yöntemlerini kullanabilirsiniz. Örnek:

string procedureName = "YourStoredProcedureName";
var parameters = new { Param1 = value1, Param2 = value2 };
var result = dbConnection.Query<YourResultType>(procedureName, parameters, commandType: CommandType.StoredProcedure).FirstOrDefault();

Birden Fazla Satır Sonucu Dönen Stored Procedure: Birden fazla satır sonucu dönen stored procedure’ları çağırmak için Query yöntemini kullanabilirsiniz. Örnek:

string procedureName = "YourStoredProcedureName";
var parameters = new { Param1 = value1, Param2 = value2 };
var results = dbConnection.Query<YourResultType>(procedureName, parameters, commandType: CommandType.StoredProcedure).ToList();

Veritabanına Veri Eklemek İçin Stored Procedure: Veritabanına veri eklemek için stored procedure kullanmak için Execute yöntemini kullanabilirsiniz. Örnek:

string procedureName = "InsertDataProcedure";
var parameters = new { Param1 = value1, Param2 = value2 };
int affectedRows = dbConnection.Execute(procedureName, parameters, commandType: CommandType.StoredProcedure);

Parametreleri Kullanma: Stored procedure’lara parametreler göndermek için, bir anonim nesne (anonymous object) kullanabilirsiniz. Bu anonim nesne, stored procedure’daki parametrelerle aynı isimlere sahip olmalıdır.

var parameters = new { Param1 = value1, Param2 = value2 };

Son olarak, işlem tamamlandığında veritabanı bağlantısını kapatmayı unutmayın:

dbConnection.Close();

Dapper’ın Performans İncelikleri

1. Sorgu Sonuçlarını Önbelleğe Almayın: Dapper, her sorguyu veritabanına gönderir ve sonuçları geri alır. Sık sık kullanılan sorguları veya sonuçları önbelleğe almak yerine, veritabanı sunucusunun kendi önbelleğini kullanmasına izin verin.
2. Lazy Loading’i Kullanmayın: Dapper, nesneleri ilişkili nesnelerle bir araya getirme işlemi sırasında tembel yükleme (lazy loading) özelliğini destekler. Ancak, bu özellik performans sorunlarına yol açabilir. İlişkili verileri gerektiği zaman getiren “eager loading” veya JOIN ifadelerini kullanmayı tercih edin.
3. Özelleştirilmiş Sorgular Kullanın: Dapper’ın otomatik nesne-mapping özelliğini kullanarak bir sorgu oluşturmak yerine, sorgularınızı elle yazın ve optimize edin. Veritabanı tarafında indeksler ve doğru sorgular kullanarak performansı artırabilirsiniz.
4. Dapper’in Query ve Execute Yöntemlerini Veritabanı Bağlantısı Üzerinden Kullanın: Dapper’in Query ve Execute yöntemlerini bir veritabanı bağlantısı üzerinden kullanmak, her sorgu için ayrı bir bağlantı oluşturmak yerine aynı bağlantıyı kullanmanıza olanak tanır. Bu bağlantıların yönetimi, işlem başına açılması ve kapatılması gereken bağlantıların sayısını azaltmanıza yardımcı olur.
5. Parametreleri Doğru Şekilde Kullanın: Dapper ile çalışırken parametreleri doğru şekilde kullanmak önemlidir. Özellikle, SQL Injection saldırılarından kaçınmak için parametreleri güvenli bir şekilde kullanmalısınız. Ayrıca, parametrelerin türlerini ve sıralarını doğru bir şekilde belirttiğinizden emin olun.
6. Bulk İşlemleri İçin Dapper.Contrib veya Dapper-Plus Kütüphanelerini Kullanın: Dapper.Contrib veya Dapper-Plus gibi üçüncü taraf kütüphaneler, toplu işlemler için Dapper’ı optimize eder. Bu kütüphaneler, büyük miktarda veri eklemek veya güncellemek gibi işlemlerde performansı artırabilir.
7. Veritabanı Sunucusunu ve İşletim Sistemini Optimize Edin: Dapper’ın performansı, kullanılan veritabanı sunucusu ve işletim sistemi ile de ilişkilidir. Veritabanı sunucusunun performansını artırmak için indeksler, önbellekler ve sorgu optimizasyonları gibi veritabanı düzeyinde yapılandırmaları gözden geçirin.
8. Asenkron İşlemleri Kullanın: Dapper, asenkron işlemleri destekler. Uzun süren veritabanı işlemlerini asenkron olarak yapmak, uygulamanızın yanıt verme süresini artırabilir.
9. SQL Profili Kullanın: Dapper sorgularınızın performansını izlemek ve hata ayıklamak için SQL Profil kullanabilirsiniz. Bu, sorgularınızın gerçek çalışma sürelerini ve isteğe bağlı olarak indeks kullanımını incelemenize yardımcı olur.

Dapper ile Uyumlu Veritabanları

C# Dapper, birçok farklı veritabanı türünü destekler ve bu veritabanlarına bağlanmanın çeşitli yollarını sağlar. İşte Dapper tarafından desteklenen bazı popüler veritabanı türleri ve bunlara nasıl bağlanılacağınız hakkında derinlemesine bilgi:

SQL Server: Dapper, SQL Server’a bağlanmanın basit bir yolunu sunar. SQL Server’a bağlanmak için SqlConnection sınıfını kullanabilirsiniz.

using System.Data;
using System.Data.SqlClient;
string connectionString = "Server=myServerAddress;Database=myDatabase;User Id=myUsername;Password=myPassword;";
IDbConnection dbConnection = new SqlConnection(connectionString);

Daha sonra dbConnection nesnesini Dapper sorgularınız için kullanabilirsiniz.

PostgreSQL: Dapper, PostgreSQL veritabanına da bağlanmanıza olanak tanır. PostgreSQL’e bağlanmak için NpgsqlConnection kullanabilirsiniz.

using System.Data;
using Npgsql;
string connectionString = "Host=myHost;Port=myPort;Database=myDatabase;Username=myUsername;Password=myPassword;";
IDbConnection dbConnection = new NpgsqlConnection(connectionString);

MySQL: MySQL veritabanına Dapper ile bağlanmak için MySqlConnection kullanabilirsiniz.

using System.Data;
using MySql.Data.MySqlClient;
string connectionString = "Server=myServer;Database=myDatabase;Uid=myUsername;Pwd=myPassword;";
IDbConnection dbConnection = new MySqlConnection(connectionString);

Oracle: Oracle veritabanlarına Dapper ile bağlanmak için OracleConnection kullanabilirsiniz. İşte bir örnek:

using System.Data;
using Oracle.ManagedDataAccess.Client;
string connectionString = "User Id=myUsername;Password=myPassword;Data Source=myDataSource;";
IDbConnection dbConnection = new OracleConnection(connectionString);

SQLite: SQLite veritabanına bağlanmak için Dapper ile SQLiteConnection kullanabilirsiniz.

using System.Data;
using System.Data.SQLite;
string connectionString = "Data Source=myDatabase.db;Version=3;";
IDbConnection dbConnection = new SQLiteConnection(connectionString);

Diğer Veritabanları: Dapper, daha pek çok veritabanı türünü destekler. Bu veritabanlarının her biri için bağlantı dizesi ve bağlantı nesnesi oluşturma konusunda belirli sürücüleri kullanmanız gerekebilir. Bağlantı dizesi ve sürücü seçimi, her veritabanı için farklıdır ve veritabanı belgelerine başvurmanız gerekebilir.

İleri Düzey Kullanım Senaryoları

Birden Fazla Sorgu Çalıştırma: Dapper, birden fazla sorguyu çalıştırmak için çoklu sonuç kümelerini döndürebilir. Örneğin, bir stored procedure birinci sonuç kümesinde bir liste ve ikinci sonuç kümesinde bir başka liste döndürüyorsa, aşağıdaki gibi kullanabilirsiniz:

using (var multi = dbConnection.QueryMultiple("YourStoredProcedure", parameters, commandType: CommandType.StoredProcedure))
{ 
var firstResult = multi.Read<YourFirstResultType>().ToList(); 
var secondResult = multi.Read<YourSecondResultType>().ToList();
}

Transaction Kullanma: Dapper ile bir işlem içinde birden fazla sorguyu bir işlem olarak gruplamak için IDbTransaction kullanabilirsiniz. Bu, veritabanı işleminizin atomik olmasını sağlar.

using (var transaction = dbConnection.BeginTransaction())
{ try { 
// İşlem 1 
dbConnection.Execute("YourFirstQuery", transaction: transaction); 
// İşlem 2 
dbConnection.Execute("YourSecondQuery", transaction: transaction); 
// İşlem tamamlandıysa işlemi onaylayın 
transaction.Commit(); 
}catch { 
// Hata durumunda işlemi geri alın 
transaction.Rollback(); }
}

Performans İyileştirmeleri: Dapper ile performansı artırmak için aşağıdaki yöntemleri kullanabilirsiniz:

• Parametre Kullanımı: Sorgularda parametreleri kullanarak SQL Injection saldırılarından korunabilir ve sorguların daha hızlı çalışmasını sağlayabilirsiniz.
• Bulk İşlemleri: Dapper.Contrib veya Dapper-Plus gibi üçüncü taraf kütüphanelerle toplu ekleme, güncelleme veya silme işlemlerini optimize edebilirsiniz.
• Asenkron İşlemler: Dapper, asenkron işlemleri destekler. Uzun süren veritabanı işlemlerini asenkron olarak yaparak uygulamanızın yanıt verme süresini artırabilirsiniz.
• Sorgu Optimizasyonları: Sorgularınızı optimize etmek için veritabanı tarafında indeksler, görünümler ve saklı sorgular gibi özellikleri kullanabilirsiniz.

Dinamik Sorgular: Dapper, sorguları dinamik olarak oluşturmanıza ve çalıştırmanıza olanak tanır. Özellikle filtreleme veya sıralama gereksinimleri olan dinamik sorgular için kullanışlıdır. Örnek:

string sql = "SELECT * FROM YourTable WHERE Column1 = @Value1";
var result = dbConnection.Query<YourResultType>(sql, new { Value1 = filterValue });

Dapper’ı karmaşık senaryolarda kullanırken, sorguları ve işlemleri mantıklı bir şekilde gruplandırmak ve performansı optimize etmek önemlidir. Dapper, veritabanı işlemlerini basit ve etkili bir şekilde yönetmenize yardımcı olur ve karmaşık senaryolara uygun birçok esneklik sunar.

Hata Yönetimi

Hata Yönetimi:

İstisna Yakalama: Dapper’da hatalar genellikle istisna (exception) şeklinde işlenir. Dapper’dan olası hataları yakalamak ve işlemek için try-catch blokları kullanabilirsiniz. Özellikle veritabanı işlemleri sırasında, bağlantı hatası gibi hataların yakalanması önemlidir.

try
{ // Dapper sorgusu veya işlemi burada
}
catch (SqlException ex)
{ // SQL Server ile ilgili hatalar Console.WriteLine($"SQL Hatası: {ex.Message}");
}
catch (Exception ex)
{ // Diğer genel hatalar Console.WriteLine($"Hata: {ex.Message}");
}

Hata İşleme ve Geri Bildirim: Yakalanan hataları işlerken, kullanıcıya veya geliştiriciye hata bilgilerini dönmek için uygun bir mekanizma kullanmalısınız. Bu, hata ayıklamayı ve sorunları daha kolay tanımlamanızı sağlar. Örneğin, hataları günlüğe kaydetmek veya kullanıcıya hata mesajları göstermek gibi işlemler yapılabilir.

Hata Ayıklama: a. Sorgu İzleme: Dapper ile sorguların hata ayıklanması için Dapper.SqlMapper.Print veya Dapper.SqlMapper.Log yöntemlerini kullanabilirsiniz. Bu yöntemler, Dapper tarafından çalıştırılan SQL sorgularını konsola yazdırır. Bu, sorguların doğru şekilde oluşturulduğunu ve hataların tespit edilmesine yardımcı olur.

Dapper.SqlMapper.Log = Console.Write; // Sorgu çıktılarını konsola yazdırır

Hata Ayıklama Araçları: Visual Studio ve diğer geliştirme ortamları, hata ayıklamayı kolaylaştırmak için hata ayıklama araçları sunar. Bir hata durumunda kodunuzu adım adım izlemek, değişkenleri gözlemlemek ve hata kaynağını tespit etmek için bu araçları kullanabilirsiniz.

Stack Trace İzleme: Hata ayıklama sırasında hata izini (stack trace) incelemek, hata kaynağını tespit etmek ve hatayı düzeltmek için yardımcı olur. Hata izini kullanarak, hangi kod parçasının hata verdiğini ve hangi satırda olduğunu belirleyebilirsiniz.

Üçüncü Taraf Araçlar: Dapper ile hata ayıklama konusunda işinizi kolaylaştıracak üçüncü taraf araçlar mevcuttur. Örneğin, MiniProfiler gibi birçok hata ayıklama ve performans analizi aracı Dapper ile uyumludur.

Hata yönetimi ve hata ayıklama, Dapper ile geliştirme yaparken büyük öneme sahiptir. Hataları etkili bir şekilde yönetmek ve ayıklamak, uygulamanızın daha güvenilir ve sorunsuz çalışmasını sağlar. Bu nedenle Dapper kullanırken bu konulara özellikle dikkat etmelisiniz.

Dapper ile İlişkili Kütüphaneler

Dapper.Contrib: Dapper.Contrib, Dapper’ın temel işlevselliğini genişleten bir eklentidir. Bu eklenti, CRUD (Create, Read, Update, Delete) işlemlerini kolaylaştırır ve Dapper nesnelerini veritabanına ekleme, güncelleme ve silme işlemlerini basitleştirir. Ayrıca Dapper.Contrib, ilişkisel verileri daha kolay yönetmenize yardımcı olabilir.

Dapper-Extensions: Dapper-Extensions, Dapper’ı CRUD işlemlerini daha kolay bir şekilde gerçekleştirmek için geliştiren bir başka eklentidir. Bu eklenti, işlem sırasında temel operasyonları basitleştirmenize olanak tanır ve otomatik kimlik sütunlarıyla çalışmanıza yardımcı olabilir.

Dapper.FluentMap: Dapper.FluentMap, nesne ilişkilendirmelerini kolayca tanımlamanıza olanak tanır. Bu, nesnelerin veritabanı tabloları ile nasıl eşleştiğini belirlemenizi sağlar. Dapper.FluentMap, karmaşık veri modellemelerini daha basit hale getirir ve nesne ilişkilendirmelerini daha okunaklı bir şekilde tanımlamanıza yardımcı olur.

Dapper-Async: Dapper, asenkron işlemleri destekler, ancak Dapper-Async, asenkron işlemleri daha basit ve açık bir şekilde kullanmanızı sağlar. Bu eklenti, async/await anahtar kelimeleriyle Dapper’ı kullanmayı kolaylaştırır.

Dapper.SimpleCRUD: Dapper.SimpleCRUD, temel CRUD işlemlerini daha basit hale getirir ve Dapper ile çalışmayı kolaylaştırır. Bu eklenti, Dapper’a daha yüksek düzeyde bir API sağlar.

Dapper.SqlBuilder: Dapper.SqlBuilder, SQL sorgularını dinamik olarak oluşturmanıza olanak tanır. Bu, filtreleme, sıralama ve dinamik sorgular oluşturmak için kullanışlıdır. Dapper.SqlBuilder, karmaşık sorguları basit bir şekilde oluşturmanıza yardımcı olabilir.

Dapper.Rainbow: Dapper.Rainbow, sorgu oluşturmayı ve filtrelemeyi kolaylaştırır. Bu eklenti, karmaşık sorgular oluştururken kodu daha temiz ve okunaklı hale getirir.

Dapper-FluentMap.AutoMap: Dapper-FluentMap.AutoMap, nesne ve veritabanı tablosu eşlemelerini otomatik olarak yapar. Bu, Dapper kullanırken nesneleri ve veritabanı tablolarını hızlı bir şekilde eşleştirmenize yardımcı olur.

Dapper.GraphQL: Dapper.GraphQL, GraphQL sorgularını Dapper ile kullanmanıza olanak tanır. Bu, GraphQL tabanlı API’lar oluşturmak için Dapper’ı kullanmayı kolaylaştırır.

Dapper.Sugar: Dapper.Sugar, sorgu oluşturmayı ve filtrelemeyi kolaylaştırır. Bu, SQL sorgularını yazarken Dapper’ı daha etkili bir şekilde kullanmanıza yardımcı olabilir.

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