ADO.NET

ADO.NET (ActiveX Data Objects for .NET), Microsoft’un .NET Framework’ünün bir parçası olarak sunulan veritabanı işlemlerini gerçekleştirmek için kullanılan bir teknolojidir.

Temel ADO.NET Kavramları

Connection (Bağlantı): Veritabanına Bağlantı Kurma İşlemleri

ADO.NET’in temel kavramlarından biri “Connection” veya bağlantıdır. Bağlantı, veritabanına erişim sağlayan bir nesnedir ve veritabanı işlemleri yapabilmek için bağlanmanız gereken ilk adımdır.

Bağlantı Dizesi (Connection String): Bağlantı kurabilmek için bir bağlantı dizesi gerekir. Bu dize, veritabanı sunucusunun türünü, sunucu adını, veritabanı adını, kimlik bilgilerini ve diğer bağlantı parametrelerini içerir.

Data Source=ServerName;Initial Catalog=DatabaseName;User ID=UserName;Password=Password;

Data Source: Veritabanı sunucusunun adı veya IP adresi.
Initial Catalog: Bağlanılacak veritabanının adı.
User ID ve Password: Veritabanına erişim için kullanıcı kimliği ve şifre.

SqlConnection Sınıfı: Bağlantıyı temsil etmek için SqlConnection sınıfı kullanılır. Bu sınıf, bağlantı açma, kapatma ve diğer bağlantı işlemlerini gerçekleştirmenizi sağlar.

using System.Data.SqlClient;
// ...
SqlConnection connection = new SqlConnection(connectionString); // Bağlantı dizesi ile bir SqlConnection nesnesi oluşturulur.
connection.Open(); // Bağlantıyı açma
// ...
connection.Close(); // Bağlantıyı kapatma

Bağlantı Yönetimi: Bağlantılar, açıldığında kaynakları kullanır ve gereksiz kaynak sızıntılarını önlemek için kapatılmalıdır. Bağlantıları “using” blokları içinde kullanarak veya açıldıktan sonra kapatmayı unutmadan kullanmanız önemlidir. Bağlantıların otomatik olarak kapatılması, kodunuzu daha güvenli ve temiz hale getirir.

using (SqlConnection connection = new SqlConnection(connectionString))
{ 
connection.Open(); // Veritabanı işlemleri burada yapılır
} // Bağlantı otomatik olarak kapatılır

Bağlantı Durumu (Connection State): Bağlantının şu anki durumunu öğrenmek için State özelliğini kullanabilirsiniz. Bağlantı açıksa veya kapalıysa bu özellik size bilgi verir.

if (connection.State == ConnectionState.Open)
{ 
// Bağlantı açıktır.
}

ADO.NET bağlantıları, veritabanı ile etkileşimde bulunmanın temelini oluşturur. Bağlantı dizesi ile bir SqlConnection nesnesi oluşturarak, bu bağlantıyı açarak veritabanına erişim sağlar ve işlem tamamlandığında kapatılarak kaynakların serbest bırakılmasını sağlar. Bu temel bağlantı kavramları, ADO.NET ile veritabanı işlemlerine başlamak için bilinmesi gereken önemli konulardır.

Command (Komut): SQL Sorgularını Veritabanına İleten İşlemler.

ADO.NET’in temel kavramlarından biri “Command” veya komuttur. Command, SQL sorgularını veritabanına ileten işlemleri temsil eder. Ayrıca, parametrelerin eklenmesi ve sorguların çalıştırılması gibi görevleri de üstlenir.

SqlCommand Sınıfı: SQL sorgularını veritabanına iletmek için SqlCommand sınıfını kullanırız. Bu sınıf, bir bağlantıya bağlı olarak çalışır ve sorguları yürütmek için gereken yöntemlere sahiptir.

- `using System.Data.SqlClient;
// ...
SqlCommand command = new SqlCommand(sqlQuery, connection);`
    - `sqlQuery`: Çalıştırılacak SQL sorgusunu içeren bir dize.
    - `connection`: SqlCommand'ın çalıştırılacağı SqlConnection nesnesi.

SQL Sorgusu: SqlCommand oluştururken, sorgunun kendisini bir dize olarak iletilir. Örnek SQL sorgusu:

string sqlQuery = "SELECT * FROM Customers WHERE Country = @Country";
command.Parameters.AddWithValue("@Country", "USA");

Parametreler: SqlCommand ile çalışırken, kullanıcı girdilerini veya başka dinamik verileri güvenli bir şekilde sorgulara dahil etmek için parametreler kullanılır. Parametreler, SQL sorgusunda özel işaretleme (genellikle @ParamName şeklinde) kullanılarak belirtilir.

command.Parameters.AddWithValue("@Country", "USA");

Parametreler, sorguları SQL enjeksiyon saldırılarına karşı koruma sağlar ve verilerin tür uyumsuzluğunu önler.

Sorgu Çalıştırma: SqlCommand nesnesini kullanarak sorguları çalıştırmak için bir dizi yöntem vardır. Bunlar arasında ExecuteReader, ExecuteNonQuery, ve ExecuteScalar bulunur.

ExecuteReader: SELECT sorguları için kullanılır ve bir SqlDataReader nesnesini döndürür. Veritabanından veri okumak için kullanılır.
ExecuteNonQuery: INSERT, UPDATE veya DELETE gibi etkilenen satır sayısını döndüren sorgular için kullanılır.
ExecuteScalar: Tek bir değeri döndüren sorgular için kullanılır.

SqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{ 
// Verileri işle
}
reader.Close();

Transaction (İşlem) İşlemleri: Birden fazla sorgunun bir işlem (transaction) içinde işlenmesi gerektiğinde, SqlTransaction nesnesi kullanılabilir. Bu, bir dizi sorgunun başarılı bir şekilde tamamlanması veya geri alınması gereken durumlarda önemlidir.

SqlTransaction transaction = connection.BeginTransaction();
command.Transaction = transaction;
try
{ 
// Birden fazla sorgu çalıştırma transaction.Commit(); // İşlemi onaylama
transaction.Commit();
}
catch (Exception ex)
{ 
transaction.Rollback(); // İşlemi geri alma
}

ADO.NET Command, SQL sorgularının veritabanına iletilmesi ve sonuçların işlenmesi için önemli bir araçtır. Parametrelerin kullanımı ve sorguların güvenli bir şekilde yürütülmesi, güvenlik ve performans açısından önemlidir. Bu kavramları anladığınızda, veritabanı işlemlerini daha iyi kontrol edebilir ve güvenli bir şekilde gerçekleştirebilirsiniz.

DataReader: Veritabanından Veri Okuma İşlemleri

ADO.NET’in temel kavramlarından biri olan DataReader, veritabanından veri okuma işlemlerini gerçekleştirmek için kullanılan bir sınıftır. DataReader, veritabanından okunan verilere tek yönlü (forward-only) bir erişim sağlar ve verileri satır satır okur.

SqlDataReader Sınıfı: DataReader işlemleri için kullanılan temel sınıf SqlDataReader’dır. Bu sınıf, bir SqlCommand nesnesi aracılığıyla veritabanından okunan verilere erişim sağlar.

using System.Data.SqlClient;
// ...
SqlDataReader reader = command.ExecuteReader();

command: Veritabanından veri okuma işlemi için kullanılan SqlCommand nesnesi.

İleri Okuma (Forward-Only): DataReader, veritabanından veri okurken ileri yönlü (forward-only) bir yapıya sahiptir, yani verilere sadece ileri doğru tek seferde erişim sağlar. Geriye veya rastgele hareket etmek mümkün değildir.

Veri Okuma İşlemi: SqlDataReader ile veri okuma işlemi Read yöntemi kullanılarak gerçekleştirilir. Bu yöntem, bir sonraki satıra geçer ve sıradaki satırın okunup okunmadığını kontrol eder.

while (reader.Read())
{ 
// Verileri işle
}

Veri Erişimi: SqlDataReader ile verilere erişmek için sütun adı veya indeks kullanılabilir. Örneğin, bir sorgu sonucunda dönen sütunları GetString, GetInt32, GetDateTime, vb. gibi yöntemlerle okuyabilirsiniz.

string name = reader.GetString(0); // İlk sütunu string olarak alır
int age = reader.GetInt32(1); // İkinci sütunu integer olarak alır

Null Değerler: SqlDataReader ile veri okurken null değerlere dikkat etmelisiniz. Veritabanından null değerler okunduğunda, bu durumu kontrol etmek için IsDBNull yöntemini kullanabilirsiniz.

if (!reader.IsDBNull(2))
{ 
  string description = reader.GetString(2);
}

Bağlantı İle İlişkilendirme: SqlDataReader, verileri okurken bir SqlConnection bağlantısına ihtiyaç duyar. Veri okuma işlemi sırasında bağlantı açık olmalıdır. Okuma işlemi tamamlandığında bağlantıyı kapatmayı unutmamalısınız.

using (SqlConnection connection = new SqlConnection(connectionString))
{ 
	connection.Open(); 
  	using (SqlCommand command = new SqlCommand(sqlQuery, connection)) 
    	using (SqlDataReader reader = command.ExecuteReader()) 
    	{ 
      	while (reader.Read()) 
      	{ 
      			// Verileri işle 
      	} 
    }
}

DataReader, büyük veri kümesini veritabanından etkili bir şekilde okumak için ideal bir seçenektir, çünkü bellekte sınırlı bir kaynak kullanır ve verileri tek seferde alır. Ancak, ileri yönlü (forward-only) doğası, geriye dönük işlemler veya rastgele erişim gerektiren senaryolar için uygun değildir.

Data Access İşlemleri

Veritabanına Bağlantı Oluşturma

ADO.NET’de veritabanına bağlantı oluşturmak, temel bir işlemdir. Bağlantı oluşturma işlemi, veritabanı sunucusuna erişim sağlar ve veri okuma, yazma, güncelleme veya silme işlemlerini gerçekleştirmenizi sağlar.

Bağlantı Dizesi (Connection String): Bağlantı oluşturmak için bir bağlantı dizesine ihtiyaç vardır. Bağlantı dizesi, veritabanı sunucusunun türünü, sunucu adını, veritabanı adını, kimlik bilgilerini ve diğer bağlantı parametrelerini içerir. Örnek bir bağlantı dizesi şu şekildedir:

• Data Source=ServerName;Initial Catalog=DatabaseName;User ID=UserName;Password=Password;
    ◦ Data Source: Veritabanı sunucusunun adı veya IP adresi.
    ◦ Initial Catalog: Bağlanılacak veritabanının adı.
    ◦ User ID ve Password: Veritabanına erişim için kullanıcı kimliği ve şifre.

SqlConnection Sınıfı: Bağlantı oluşturmak için SqlConnection sınıfını kullanırız. Bu sınıf, bağlantı yönetimi için gerekli yöntemleri ve özellikleri sağlar.

using System.Data.SqlClient;
// ...
string connectionString = "Data Source=ServerName;Initial Catalog=DatabaseName;User ID=UserName;Password=Password;";
SqlConnection connection = new SqlConnection(connectionString);

Bağlantı Açma ve Kapatma: SqlConnection nesnesi oluşturulduktan sonra, bağlantı açılmalı ve işlem tamamlandığında kapatılmalıdır. Bağlantının açılması, veritabanı sunucusuyla iletişim kurmayı başlatır ve bağlantının kapatılması, kaynakların serbest bırakılmasını sağlar.

connection.Open(); // Bağlantıyı açma
// Veritabanı işlemleri burada yapılır
connection.Close(); // Bağlantıyı kapatma

Bağlantıları “using” blokları içinde kullanarak açmak ve otomatik olarak kapatmak da iyi bir uygulama yöntemidir.

using (SqlConnection connection = new SqlConnection(connectionString))
{ 
connection.Open(); // Veritabanı işlemleri burada yapılır
} // Bağlantı otomatik olarak kapatılır

Bağlantı Durumu (Connection State): Bağlantının şu anki durumunu öğrenmek için State özelliğini kullanabilirsiniz. Bağlantı açıksa veya kapalıysa bu özellik size bilgi verir.

if (connection.State == ConnectionState.Open)
{ 
	// Bağlantı açıktır.
}

Bağlantı oluşturma işlemi, ADO.NET ile veritabanına erişimin temel adımıdır. Bağlantı dizesi ile bir SqlConnection nesnesi oluşturarak, bu bağlantıyı açarak veritabanına erişim sağlar ve işlem tamamlandığında kapatılarak kaynakların serbest bırakılmasını sağlar. Bu temel bağlantı kavramları, ADO.NET ile veritabanı işlemlerine başlamak için bilinmesi gereken önemli konulardır.

SQL Sorguları Oluşturma ve Çalıştırma

ADO.NET ile SQL sorguları oluşturma ve çalıştırma, veritabanı işlemlerinin temelini oluşturur. SQL sorguları, veritabanından veri almak, veri eklemek, güncellemek veya silmek için kullanılır.

SqlCommand Sınıfı: SQL sorgularını oluşturmak ve çalıştırmak için SqlCommand sınıfını kullanırız. Bu sınıf, SqlConnection nesnesi aracılığıyla veritabanına erişim sağlar.

using System.Data.SqlClient;
// ...
SqlConnection connection = new SqlConnection(connectionString);
connection.Open(); // Bağlantıyı açma
SqlCommand command = new SqlCommand();
command.Connection = connection;

SQL Sorgusu Oluşturma: SqlCommand nesnesi üzerinden SQL sorgusu oluşturulur. SQL sorgusu bir dize içinde tanımlanır ve SqlCommand nesnesine atanır.

string sqlQuery = "SELECT * FROM Customers WHERE Country = 'USA'";
command.CommandText = sqlQuery;

SQL sorgularında parametreler kullanarak güvenli sorgular oluşturmak önemlidir. Parametreler, SQL enjeksiyon saldırılarına karşı koruma sağlar. Örneğin:

string country = "USA";
string sqlQuery = "SELECT * FROM Customers WHERE Country = @Country";
command.Parameters.AddWithValue("@Country", country);

Sorguyu Çalıştırma: SqlCommand nesnesi ile oluşturulan sorguyu çalıştırmak için ExecuteReader, ExecuteNonQuery veya ExecuteScalar gibi yöntemleri kullanabilirsiniz.

ExecuteReader: SELECT sorguları için kullanılır ve bir SqlDataReader nesnesini döndürür. Bu nesneyi kullanarak verileri okuyabilirsiniz.

SqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{ 
// Verileri işle
}
reader.Close();

ExecuteNonQuery: INSERT, UPDATE veya DELETE gibi etkilenen satır sayısını döndüren sorgular için kullanılır.

int rowsAffected = command.ExecuteNonQuery();

ExecuteScalar: Tek bir değeri döndüren sorgular için kullanılır.

object result = command.ExecuteScalar();

Transaction (İşlem) İşlemleri: Birden fazla sorguyu bir işlem (transaction) içinde çalıştırmak gerektiğinde, bir SqlTransaction nesnesi kullanılır. Bu, bir dizi sorgunun başarılı bir şekilde tamamlanması veya geri alınması gerektiği durumlarda önemlidir.

SqlTransaction transaction = connection.BeginTransaction();
command.Transaction = transaction;
try
{ 
// Birden fazla sorgu çalıştırma transaction.Commit(); // İşlemi onaylama
}
catch (Exception ex)
{ 
transaction.Rollback(); // İşlemi geri alma
}

ADO.NET ile SQL sorguları oluşturmak ve çalıştırmak, veritabanı işlemlerini gerçekleştirmek için temel bir beceridir. SQL sorgularını doğru bir şekilde oluşturmak, güvenliğinizi artırırken, sorguları çalıştırarak verilere erişim sağlamanızı sağlar. SQL sorgularını parametrelerle kullanmak, SQL enjeksiyon saldırılarına karşı koruma sağlar.

Veri Okuma, Yazma, Güncelleme ve Silme İşlemleri

ADO.NET kullanarak temel veri erişim işlemleri olan veri okuma, yazma, güncelleme ve silme işlemlerini derinlemesine anlayalım. Bu işlemler, veritabanı işlemlerinin temel taşlarıdır:

Veri Okuma (Select):
- Veri okuma işlemi, SELECT SQL sorgusu kullanılarak gerçekleştirilir.
- SqlCommand ile SQL sorgusu oluşturulur ve ExecuteReader metodu kullanılarak sorgu çalıştırılır.
- SqlDataReader nesnesi veri okuma işlemi için kullanılır.
- SqlDataReader ile veriler satır satır okunur ve işlenir.
- Okunan verilere sütun adı veya indeks kullanarak erişilir.

using System;
using System.Data.SqlClient;

class Program
{
    static void Main()
    {
        string connectionString = "your_connection_string_here";

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

            string sqlQuery = "SELECT FirstName, LastName FROM Customers";

            using (SqlCommand command = new SqlCommand(sqlQuery, connection))
            using (SqlDataReader reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    string firstName = reader.GetString(0);
                    string lastName = reader.GetString(1);

                    Console.WriteLine($"{firstName} {lastName}");
                }
            }
        }
    }
}

Veri Yazma (Insert):
- Veri yazma işlemi, INSERT SQL sorgusu kullanılarak gerçekleştirilir.
- SqlCommand ile SQL sorgusu oluşturulur ve ExecuteNonQuery metodu kullanılarak sorgu çalıştırılır.
- ExecuteNonQuery sonucu, etkilenen satır sayısını döndürür.
Örnek:

using System;
using System.Data.SqlClient;

class Program
{
    static void Main()
    {
        string connectionString = "your_connection_string_here";

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

            string firstName = "John";
            string lastName = "Doe";

            string sqlQuery = $"INSERT INTO Customers (FirstName, LastName) VALUES ('{firstName}', '{lastName}')";

            using (SqlCommand command = new SqlCommand(sqlQuery, connection))
            {
                int rowsAffected = command.ExecuteNonQuery();
                Console.WriteLine($"{rowsAffected} satır eklendi.");
            }
        }
    }
}

Veri Güncelleme (Update):
- Veri güncelleme işlemi, UPDATE SQL sorgusu kullanılarak gerçekleştirilir.
- SqlCommand ile SQL sorgusu oluşturulur ve ExecuteNonQuery metodu kullanılarak sorgu çalıştırılır.
- ExecuteNonQuery sonucu, etkilenen satır sayısını döndürür.
Örnek:

using System;
using System.Data.SqlClient;

class Program
{
    static void Main()
    {
        string connectionString = "your_connection_string_here";

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

            string newFirstName = "Jane";
            string lastNameToUpdate = "Doe";

            string sqlQuery = $"UPDATE Customers SET FirstName = '{newFirstName}' WHERE LastName = '{lastNameToUpdate}'";

            using (SqlCommand command = new SqlCommand(sqlQuery, connection))
            {
                int rowsAffected = command.ExecuteNonQuery();
                Console.WriteLine($"{rowsAffected} satır güncellendi.");
            }
        }
    }
}

Veri Silme (Delete):
- Veri silme işlemi, DELETE SQL sorgusu kullanılarak gerçekleştirilir.
- SqlCommand ile SQL sorgusu oluşturulur ve ExecuteNonQuery metodu kullanılarak sorgu çalıştırılır.
- ExecuteNonQuery sonucu, etkilenen satır sayısını döndürür.
Örnek:

using System;
using System.Data.SqlClient;

class Program
{
    static void Main()
    {
        string connectionString = "your_connection_string_here";

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

            string lastNameToDelete = "Doe";

            string sqlQuery = $"DELETE FROM Customers WHERE LastName = '{lastNameToDelete}'";

            using (SqlCommand command = new SqlCommand(sqlQuery, connection))
            {
                int rowsAffected = command.ExecuteNonQuery();
                Console.WriteLine($"{rowsAffected} satır silindi.");
            }
        }
    }
}

Veri okuma, yazma, güncelleme ve silme işlemleri, ADO.NET kullanarak veritabanı işlemlerini yönetmek için temel adımlardır. SQL sorgularını doğru bir şekilde oluşturmak ve parametrelerle kullanmak, veri bütünlüğünü ve güvenliği sağlar. İşlemlerin sonucunu takip etmek için ExecuteNonQuery sonucunu kontrol edebilirsiniz. İşlem sırasında hataların ele alınmasına dikkat etmek önemlidir.

Parametre Kullanımı

ADO.NET’de parametreler, SQL sorgularını güvenli bir şekilde oluşturmanızı ve çalıştırmanızı sağlar. Parametreler, kullanıcı girdilerini veya diğer dinamik verileri sorgulara dahil etmek için kullanılır ve SQL enjeksiyon saldırılarına karşı koruma sağlar.

Parametre Türleri:ADO.NET parametrelerini kullanırken farklı türlerde parametreler oluşturabilirsiniz. En yaygın kullanılan parametre türleri şunlardır:

SqlParameter: Bu, SQL sorgularında kullanılan ve adı belirtilen parametre türüdür. Değeri veya türü belirtilebilir. Örneğin, bir kullanıcının adını almak için SqlParameter kullanabilirsiniz.
SqlDbType: Veritabanına veri türünü belirtmek için kullanılır. Örneğin, bir tarih parametresi için SqlDbType.DateTime kullanabilirsiniz.
Size: Varyanslı (nvarchar, nvarchar) türler için karakter sayısını belirtmek için kullanılır.
Direction: Parametrenin giriş (Input), çıkış (Output) veya her ikisi (InputOutput) olup olmadığını belirtir.

Parametre Oluşturma: Parametre oluştururken, parametrenin adı, veri türü ve diğer özellikleri belirtilir. Parametre adı, SQL sorgusunda kullanılacak olan adıdır ve sorguda @ işareti ile başlar. Parametrelerin türü ve adı, SqlParameter nesnesi ile belirtilir.

string parameterName = "@FirstName";
SqlParameter parameter = new SqlParameter(parameterName, SqlDbType.NVarChar, 50);
parameter.Value = "John";

Parametre Eklemek: Parametreleri SqlCommand nesnesine eklemek, sorgunun içinde kullanılmalarını sağlar. Parametre eklerken, parametrenin adını ve değerini belirtmelisiniz.

command.Parameters.Add(parameter);

veya

command.Parameters.AddWithValue(parameterName, "John");

Sorgu Oluşturma ve Parametre Kullanımı: SQL sorgusu oluştururken parametreleri kullanmak için sorgunun içinde parametre adını kullanmalısınız. Parametre adı, sorguda @ işareti ile başlar.

string sqlQuery = "SELECT * FROM Customers WHERE FirstName = @FirstName";
SqlCommand command = new SqlCommand(sqlQuery, connection);
command.Parameters.AddWithValue(parameterName, "John");

Sorguyu Çalıştırma: Parametrelerle oluşturulan SqlCommand nesnesini çalıştırmak, sorgunun veritabanında çalıştırılmasını sağlar.

using (SqlDataReader reader = command.ExecuteReader())
{ 
  while (reader.Read()) { 
  // Verileri işle 
  }
}

Parametre kullanımı, veritabanı işlemlerini daha güvenli hale getirir ve SQL enjeksiyon saldırılarına karşı koruma sağlar. Ayrıca, parametrelerin veri türleri otomatik olarak tür uyumsuzluklarını önler. Bu, güvenlik ve performans açısından önemlidir. Veri tabanından veri okuma, yazma, güncelleme veya silme işlemlerini gerçekleştirirken parametreleri doğru bir şekilde kullanarak verilerinizi koruyabilir ve veritabanı işlemlerinizi daha güvenli hale getirebilirsiniz.

Connection String

ADO.NET ile veritabanına bağlanmak için gerekli olan bağlantı dizesi (connection string) oluşturmak ve kullanmak, veritabanı işlemlerine başlamanın önemli bir adımıdır. Bağlantı dizesi, veritabanı sunucusuyla iletişim kurmanızı sağlar ve bağlantı bilgilerini içerir. İşte bu konuyu derinlemesine anlatan önemli bilgiler:

Bağlantı Dizesi (Connection String) Nedir?

Bağlantı dizesi, veritabanına erişim için gerekli olan bilgileri içeren bir metin dizisidir.
Veritabanı sunucusunun türünü, sunucu adresini veya adını, veritabanı adını, kullanıcı adını ve şifresini içerebilir.
Bağlantı dizesi, veritabanı sunucusuyla iletişim kurmanızı sağlar ve bu bilgilerin güvenli bir şekilde saklanması önemlidir.

Bağlantı Dizesi Yapısı:

Bağlantı dizesi, belirli bir veritabanı sunucusu ve sürücüsüne göre farklılık gösterir.
Örnek bir SQL Server bağlantı dizesi şu şekildedir:

Data Source=ServerName;Initial Catalog=DatabaseName;User ID=UserName;Password=Password;
Data Source: Veritabanı sunucusunun adı veya IP adresi.
Initial Catalog: Bağlanılacak veritabanının adı.
User ID ve Password: Veritabanına erişim için kullanıcı kimliği ve şifre.

Bağlantı Dizesi Güvenliği:

Bağlantı dizesi, içeriği hassas bilgiler içerdiği için güvende tutulmalıdır.
Bağlantı dizesinin açıkça kod içinde bulunmaması önerilir. Web.config veya appsettings.json gibi yapılandırma dosyalarında saklanabilir.
Bağlantı dizesi güvenli bir şekilde saklandığında, kodunuzu değiştirmeden farklı ortamlarda kullanabilirsiniz.

Bağlantı Dizesi Oluşturma ve Kullanma:

SqlConnection nesnesi oluşturmadan önce bağlantı dizesini oluşturmanız gerekmektedir.
Bağlantı dizesi oluşturulur ve bir SqlConnection nesnesine atanır.

using System;
using System.Data.SqlClient;

class Program
{
    static void Main()
    {
        // Bağlantı dizesi
        string connectionString = "Data Source=ServerName;Initial Catalog=DatabaseName;User ID=UserName;Password=Password;";

        // SqlConnection nesnesini oluştur
        SqlConnection connection = new SqlConnection(connectionString);

        try
        {
            // Bağlantıyı aç
            connection.Open();

            // Bağlantı üzerinde işlemler yapabilirsiniz.

            Console.WriteLine("Bağlantı başarıyla açıldı.");
        }
        catch (Exception ex)
        {
            // Hata durumunda mesajı yazdır
            Console.WriteLine("Bağlantı hatası: " + ex.Message);
        }
        finally
        {
            // Bağlantıyı kapat
            if (connection.State == System.Data.ConnectionState.Open)
            {
                connection.Close();
            }
        }
    }
}

Bağlantıyı Açma ve Kapatma:
- SqlConnection nesnesi oluşturulduktan sonra, bağlantı açılmalıdır. Bağlantı, veritabanı sunucusuyla iletişim kurmayı başlatır.
- İşlem tamamlandığında bağlantı kapatılmalıdır. Bağlantının kapatılması, kaynakların serbest bırakılmasını sağlar.

connection.Open(); // Bağlantıyı açma
// Veritabanı işlemleri burada yapılır
connection.Close(); // Bağlantıyı kapatma

Bağlantıları “using” blokları içinde kullanarak açmak ve otomatik olarak kapatmak da iyi bir uygulama yöntemidir.

using System;
using System.Data.SqlClient;

class Program
{
    static void Main()
    {
        // Bağlantı dizesi
        string connectionString = "Data Source=ServerName;Initial Catalog=DatabaseName;User ID=UserName;Password=Password;";

        // SqlConnection nesnesini using ifadesi ile oluştur ve aç
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            try
            {
                // Bağlantıyı aç
                connection.Open();

                // Bağlantı üzerinde işlemler yapabilirsiniz.
                
                Console.WriteLine("Bağlantı başarıyla açıldı.");
            }
            catch (Exception ex)
            {
                // Hata durumunda mesajı yazdır
                Console.WriteLine("Bağlantı hatası: " + ex.Message);
            }
            // using bloğunun sonunda bağlantı otomatik olarak kapatılır.
        }
    }
}

Bağlantı dizesi oluşturma ve kullanma, veritabanı işlemlerinin başlangıç adımıdır. Bağlantı dizesi, veritabanı sunucusu ile iletişim kurmanıza olanak tanır ve hassas bilgileri güvende tutmak önemlidir. SqlConnection nesnesi ile bu bağlantı dizesini kullanarak veritabanı işlemlerini gerçekleştirebilirsiniz.

Veri Okuma

SqlDataReader Kullanarak Veri Okuma İşlemleri

SqlDataReader, C# ADO.NET kütüphanesi kullanılarak veritabanından veri okuma işlemlerini gerçekleştirmek için kullanılan bir sınıftır. Bu sınıf, bir SQL sorgusu veya saklı yordam (stored procedure) sonucunda dönen verileri okumak için kullanılır. SqlDataReader nesnesi, verileri veritabanından tek satır tek satır okur, bu da büyük veri kümelerini etkili bir şekilde işlememizi sağlar.

Bağlantı Oluşturma: SqlDataReader kullanmadan önce, veritabanına bir bağlantı oluşturmalısınız. SqlConnection sınıfını kullanarak bir veritabanı bağlantısı oluşturabilirsiniz. Bağlantı bilgilerini belirtmelisiniz (sunucu adı, veritabanı adı, kullanıcı adı, şifre vb.).

using System;
using System.Data.SqlClient;

class Program
{
    static void Main()
    {
        // Bağlantı dizesi
        string connectionString = "Data Source=serverName;Initial Catalog=databaseName;User ID=username;Password=password";

        // SqlConnection nesnesini using ifadesi ile oluştur ve aç
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            try
            {
                // Bağlantıyı aç
                connection.Open();

                // Bağlantı üzerinde işlemler yapabilirsiniz.
                
                Console.WriteLine("Bağlantı başarıyla açıldı.");
            }
            catch (Exception ex)
            {
                // Hata durumunda mesajı yazdır
                Console.WriteLine("Bağlantı hatası: " + ex.Message);
            }
            // using bloğunun sonunda bağlantı otomatik olarak kapatılır.
        }
    }
}

Komut Oluşturma: Verileri almak için bir SqlCommand nesnesi oluşturmalısınız. Bu nesne, SQL sorgusunu veya saklı yordamı temsil eder.

string query = "SELECT * FROM TableName";
SqlCommand command = new SqlCommand(query, connection);

Verileri Okuma: SqlDataReader nesnesi kullanarak verileri okuma işlemi gerçekleştirilir. SqlDataReader, veritabanından gelen verileri satır satır okur ve bu verileri işlemenize olanak tanır.

SqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{ 
// Verileri okuma işlemleri burada yapılır. 
int id = reader.GetInt32(0); 
// Örnek: İlk sütunun (0. sütun) değerini al 
string name = reader.GetString(1); 
// Örnek: İkinci sütunun (1. sütun) değerini al 
// Diğer sütunları okuma işlemleri
}
reader.Close();

Bağlantı Kapatma: Veri okuma işlemi tamamlandığında, SqlConnection nesnesi ile olan bağlantıyı kapatmayı unutmayın. Bu, kaynakların serbest bırakılmasını sağlar.

connection.Close();

Hata İşleme: Veri okuma sırasında oluşabilecek hataları ele almak önemlidir. try-catch blokları kullanarak hata işleme eklemelisiniz.

try
{
   // Veri okuma işlemleri
}
catch (Exception ex)
{ 
  // Hata işleme kodu
}
finally
{ 
  connection.Close();
}

Bu, SqlDataReader kullanarak veri okuma işlemlerini derinlemesine anlatan temel adımları içerir. Veritabanı bağlantısı oluşturma, komut oluşturma, veri okuma, bağlantı kapatma ve hata işleme bu işlem sürecinin önemli bileşenleridir. SqlDataReader, veritabanından verileri etkili bir şekilde okumak için kullanışlı bir araçtır.

Okunan Verileri Kullanma ve İşleme

C# ADO.NET ile veritabanından okunan verileri kullanma ve işleme konusu oldukça önemlidir. Veritabanından çekilen verileri işlemek için SqlDataReader, DataTable veya DataReader nesneleri kullanılabilir.

SqlDataReader ile Verileri Kullanma ve İşleme: SqlDataReader nesnesi, verileri tek satır tek satır okur ve bu verileri işlemenize olanak tanır. Okunan verileri kullanmak için aşağıdaki yöntemleri kullanabilirsiniz:

SqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{ 
// Verileri okuma işlemleri burada yapılır. 
int id = reader.GetInt32(0); 
// Örnek: İlk sütunun (0. sütun) değerini al 
string name = reader.GetString(1); 
// Örnek: İkinci sütunun (1. sütun) değerini al 
// Diğer sütunları okuma işlemleri
}
reader.Close();

Okunan verileri kullanırken dikkat etmeniz gereken bazı önemli noktalar şunlardır:

Veri tiplerini doğru bir şekilde dönüştürmek: SqlDataReader, verileri birinci sütundan başlayarak sırayla döndürür. Veri tiplerini doğru bir şekilde dönüştürmek için, GetInt32, GetString, GetBoolean, GetDecimal vb. gibi veri türüne özgü metotları kullanmalısınız.
NULL değerleri ele alma: Okunan verilerin bazı sütunları NULL değere sahip olabilir. Bu durumu kontrol etmek için IsDBNull yöntemini kullanabilirsiniz.

DataTable ile Verileri Kullanma ve İşleme: SqlDataReader yerine verileri bir DataTable nesnesine aktarmak da yaygın bir yaklaşımdır. DataTable, verileri bir tablo gibi saklar ve daha sonra kolayca işlem yapmanızı sağlar.

using System.Data;
DataTable table = new DataTable();
SqlDataReader reader = command.ExecuteReader();
table.Load(reader);
foreach (DataRow row in table.Rows)
{ 
int id = (int)row["ID"]; 
string name = (string)row["Name"]; 
// Diğer sütunları okuma işlemleri
}

DataTable kullanmanın avantajları, verileri daha kolay filtreleme, sıralama ve gruplama yeteneği sunmasıdır.

DataReader ve DataTable Performans Karşılaştırması: SqlDataReader, verileri veritabanından tek satır tek satır okuduğu için genellikle daha hızlıdır. DataTable ise verileri bellekte saklayarak daha fazla işleme olanak tanır ancak daha fazla bellek tüketebilir. Performans gereksinimlerinize göre hangi yöntemi kullanmanız gerektiğini dikkate almalısınız.

Hata İşleme: Veritabanından veri okurken hataların oluşma olasılığı vardır. Bu nedenle try-catch blokları kullanarak hata işleme eklemelisiniz. Özellikle verileri okurken herhangi bir hata durumunda gerekli işlemi yapmalısınız.

try
{ 
SqlDataReader reader = command.ExecuteReader(); 
while (reader.Read()) { 
  // Verileri okuma işlemleri 
} 
reader.Close();
}
catch (Exception ex)
{ 
  // Hata işleme kodu
}
finally
{ 
  connection.Close();
}

Bu, C# ADO.NET ile veritabanından verileri okuma ve işleme konusunu derinlemesine anlatan temel bilgileri içerir. Veritabanı ile iletişim kurarken verilerin doğru bir şekilde okunması ve işlenmesi, uygulamanızın temel bir bileşenidir.

DataSet ve DataTable

DataSet ve DataTable Nesnelerini Kullanarak Veri Saklama ve İşleme

C# ADO.NET‘te DataSet ve DataTable nesneleri, verilerin bellekte saklanması ve işlenmesi için oldukça güçlü araçlardır. DataSet ve DataTable, veritabanı sorgularından dönen sonuçları saklamak, filtrelemek, sıralamak ve ilişkilendirmek için kullanılır. İşte DataSet ve DataTable nesnelerini kullanarak veri saklama ve işleme konusunu derinlemesine anlatan bir rehber:

DataTable ve DataSet Nedir?

DataTable: DataTable, bir tabloyu temsil eden bir nesnedir. Her bir DataRow, DataTable içindeki bir kaydı temsil eder ve DataColumn nesneleri, her sütunun veri yapısını tanımlar.
DataSet: DataSet, bir veya birden fazla DataTable ve ilişkilendirilmiş verileri içeren bir nesnedir. Veritabanı sorgularından dönen sonuçları içinde saklayabilir. DataSet, genellikle çoklu tablo içeren veri kümesini temsil etmek için kullanılır.

DataTable Oluşturma ve Kullanma:

DataTable table = new DataTable("Customers");

// Sütunları tanımlama
table.Columns.Add("CustomerID", typeof(string));
table.Columns.Add("CustomerName", typeof(string));
table.Columns.Add("City", typeof(string));

// Yeni bir kayıt eklemek
DataRow row = table.NewRow();
row["CustomerID"] = "C001";
row["CustomerName"] = "Company A";
row["City"] = "New York";
table.Rows.Add(row);

// Verilere erişim
foreach (DataRow dataRow in table.Rows)
{
    string customerId = (string)dataRow["CustomerID"];
    string customerName = (string)dataRow["CustomerName"];
    string city = (string)dataRow["City"];
}

DataSet Oluşturma ve Kullanma:

DataSet dataset = new DataSet("MyDataSet");

// DataTable oluşturma
DataTable customersTable = new DataTable("Customers");
customersTable.Columns.Add("CustomerID", typeof(string));
customersTable.Columns.Add("CustomerName", typeof(string));
customersTable.Columns.Add("City", typeof(string));

// DataTable'ı DataSet'e ekleme
dataset.Tables.Add(customersTable);

// Yeni bir kayıt ekleme
DataRow newRow = customersTable.NewRow();
newRow["CustomerID"] = "C002";
newRow["CustomerName"] = "Company B";
newRow["City"] = "Los Angeles";
customersTable.Rows.Add(newRow);

// Verilere erişim
foreach (DataRow row in customersTable.Rows)
{
    string customerId = (string)row["CustomerID"];
    string customerName = (string)row["CustomerName"];
    string city = (string)row["City"];
}

DataSet ile İlişkilendirme:

DataSet, birden fazla DataTable’ı içerebilir ve bu tablolar arasında ilişkiler kurabilirsiniz. İlişkilendirmek için DataRelation kullanabilirsiniz.

DataRelation relation = new DataRelation("CustomerOrders", customersTable.Columns["CustomerID"], ordersTable.Columns["CustomerID"]);
dataset.Relations.Add(relation);

Veri Saklama ve İşleme:

DataSet ve DataTable, verileri filtreleme, sıralama, gruplama ve veri değişikliklerini izleme gibi çeşitli işlemleri destekler. Ayrıca, DataGridView veya diğer veri bağlama kontrolleri ile verileri görüntülemek için kullanılabilirler.

Verileri Veritabanından Alma ve Güncelleme:

DataSet ve DataTable, SqlDataAdapter sınıfı ile veritabanından veri almak ve güncellemek için kullanılabilir. SqlDataAdapter, SqlCommand nesnesi ile veritabanı işlemlerini gerçekleştirir.

SqlDataAdapter adapter = new SqlDataAdapter("SELECT * FROM Customers", connection);
adapter.Fill(dataset, "Customers"); // Verileri DataTable'a doldurur
adapter.Update(dataset, "Customers"); // Değişiklikleri veritabanına kaydeder

Bu rehber, C# ADO.NET’te DataSet ve DataTable nesnelerini kullanarak veri saklama ve işleme konusunu derinlemesine anlatır. DataSet ve DataTable, verileri uygulamanızda etkili bir şekilde işlemek için güçlü ve esnek araçlar sunar.

DataTable Oluşturma ve Veri Eklemesi

ADO.NET, C# programlama dilinde veri tabanı işlemleri için kullanılan bir teknolojidir. DataTable, bellekte bir tabloyu temsil eden bir sınıftır. DataTable kullanarak verileri tablo biçiminde tutabilir, işleyebilir ve bu verileri veri tabanına ekleyebilirsiniz.

DataTable Oluşturma: DataTable oluşturmak için DataTable sınıfını kullanabilirsiniz. İlk olarak, System.Data isim alanını ekleyin.

using System;
using System.Data;

class Program
{
    static void Main()
    {
        // DataTable oluşturma
        DataTable dataTable = new DataTable("Person");

        // DataTable sütunlarını tanımlama
        DataColumn columnID = new DataColumn("ID", typeof(int));
        DataColumn columnName = new DataColumn("Name", typeof(string));
        DataColumn columnAge = new DataColumn("Age", typeof(int));

        // Sütunları DataTable'a ekleme
        dataTable.Columns.Add(columnID);
        dataTable.Columns.Add(columnName);
        dataTable.Columns.Add(columnAge);

        // DataTable'ı ekrana yazdırma
        Console.WriteLine("DataTable Structure:");
        foreach (DataColumn column in dataTable.Columns)
        {
            Console.WriteLine($"{column.ColumnName,-10} {column.DataType}");
        }
    }
}

Yukarıdaki örnekte, Person adında bir DataTable oluşturuldu ve bu tablonun sütunları belirlendi.

Veri Ekleme: Oluşturulan DataTable’a veri eklemek için DataRow kullanılır. DataRow, DataTable’daki her bir kaydı temsil eder.

class Program
{
    static void Main()
    {
        // Önceki kodlar...

        // Veri eklemek için DataRow oluşturma
        DataRow row1 = dataTable.NewRow();
        row1["ID"] = 1;
        row1["Name"] = "John Doe";
        row1["Age"] = 30;

        // DataRow'ı DataTable'a ekleme
        dataTable.Rows.Add(row1);

        // Bir başka yöntemle doğrudan ekleme
        dataTale.Rows.Add(2, "Jane Doe", 25);

        // DataTable'ı ekrana yazdırma
        Console.WriteLine("\nDataTable Content:");
        foreach (DataRow row in dataTable.Rows)
        {
            Console.WriteLine($"{row["ID"],-5} {row["Name"],-15} {row["Age"]}");
        }
    }
}

Bu örnekte, NewRow metoduyla yeni bir satır oluşturuldu, veriler atanıp ardından Rows.Add metoduyla DataTable’a eklendi.

Bu örneklerde veri tabanına kaydetme işlemi yapılmamıştır. Eğer bir veri tabanına kaydetme işlemi gerçekleştirmek istiyorsanız, genellikle ADO.NET ile bir bağlantı (SqlConnection), bir komut (SqlCommand), ve gerekirse bir bağlantı yöneticisi (SqlDataAdapter veya SqlDataReader) kullanmanız gerekir. Bu örnekte sadece DataTable kullanımı ve veri eklemesi üzerine odaklanılmıştır.

Veri İlişkilendirmesi (Relationships)

ADO.NET’te veri ilişkilendirmesi (relationships) genellikle DataSet sınıfı üzerinde gerçekleşir. DataSet, bellekteki verileri tutabilen ve bu veriler arasında ilişkilendirme yapabilen bir sınıftır. Veri tabanından gelen verilerin tutulması, işlenmesi ve ilişkilendirilmesi için kullanılır.

Aşağıda C# ADO.NET’te veri ilişkilendirmesi yapmak için adım adım bir örnek bulunmaktadır. Bu örnekte iki tablo arasında bir ilişki kurulacak.

using System;
using System.Data;

class Program
{
    static void Main()
    {
        // İki tablo oluşturma
        DataTable parentTable = new DataTable("Customers");
        DataTable childTable = new DataTable("Orders");

        // Customers tablosunun sütunlarını tanımlama
        DataColumn parentColumn = new DataColumn("CustomerID", typeof(int));
        parentColumn.Unique = true;
        parentTable.Columns.Add(parentColumn);
        parentTable.Columns.Add(new DataColumn("CustomerName", typeof(string)));

        // Orders tablosunun sütunlarını tanımlama
        DataColumn childColumn = new DataColumn("OrderID", typeof(int));
        childColumn.Unique = true;
        childTable.Columns.Add(childColumn);
        childTable.Columns.Add(new DataColumn("CustomerID", typeof(int)));
        childTable.Columns.Add(new DataColumn("OrderDate", typeof(DateTime)));

        // DataSet oluşturma ve tabloları ekleme
        DataSet dataSet = new DataSet();
        dataSet.Tables.Add(parentTable);
        dataSet.Tables.Add(childTable);

        // İki tablo arasında ilişki oluşturma
        DataRelation relation = new DataRelation("CustomerOrderRelation",
                                                parentTable.Columns["CustomerID"],
                                                childTable.Columns["CustomerID"]);
        dataSet.Relations.Add(relation);

        // Veri eklemek için DataRow oluşturma
        DataRow parentRow = parentTable.NewRow();
        parentRow["CustomerID"] = 1;
        parentRow["CustomerName"] = "John Doe";

        DataRow childRow1 = childTable.NewRow();
        childRow1["OrderID"] = 101;
        childRow1["CustomerID"] = 1;
        childRow1["OrderDate"] = DateTime.Now;

        DataRow childRow2 = childTable.NewRow();
        childRow2["OrderID"] = 102;
        childRow2["CustomerID"] = 1;
        childRow2["OrderDate"] = DateTime.Now.AddDays(1);

        // DataRow'ları tablolara ekleme
        parentTable.Rows.Add(parentRow);
        childTable.Rows.Add(childRow1);
        childTable.Rows.Add(childRow2);

        // İlişkilendirilmiş verileri ekrana yazdırma
        Console.WriteLine("Customer and Orders Data:");

        foreach (DataRow customerRow in parentTable.Rows)
        {
            Console.WriteLine($"Customer ID: {customerRow["CustomerID"]}, Customer Name: {customerRow["CustomerName"]}");

            foreach (DataRow orderRow in customerRow.GetChildRows(relation))
            {
                Console.WriteLine($"   Order ID: {orderRow["OrderID"]}, Order Date: {orderRow["OrderDate"]}");
            }

            Console.WriteLine();
        }
    }
}

Veri Bağlama (Data Binding)

Veri Kontrolleri (DataGridView, ListBox, ComboBox, vb.) İle Veri Bağlama

ADO.NET ile veri kontrolleri (Data Controls) kullanılarak, kullanıcı arayüzündeki kontroller (DataGridView, ListBox, ComboBox gibi) ile veritabanı arasında bağlantı kurabilir ve verileri görüntüleyebilirsiniz. Bu, genellikle veritabanındaki verileri kullanıcıya daha anlamlı ve düzenli bir şekilde sunmak için kullanılır.

using System;
using System.Data;
using System.Data.SqlClient;
using System.Windows.Forms;

class Program
{
    static void Main()
    {
        // Veritabanı bağlantı dizesi
        string connectionString = "Data Source=(localdb)\\MSSQLLocalDB;Initial Catalog=SampleDB;Integrated Security=True";

        // Veritabanı bağlantısı oluşturma
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            // SQL sorgusu
            string query = "SELECT CustomerID, CustomerName FROM Customers";

            // SqlDataAdapter ve DataTable oluşturma
            SqlDataAdapter adapter = new SqlDataAdapter(query, connection);
            DataTable dataTable = new DataTable();

            // Verileri veritabanından çekme ve DataTable'a doldurma
            adapter.Fill(dataTable);

            // DataGridView ile veri bağlama
            DataGridView dataGridView = new DataGridView();
            dataGridView.DataSource = dataTable;

            // ListBox ile veri bağlama
            ListBox listBox = new ListBox();
            listBox.DataSource = dataTable;
            listBox.DisplayMember = "CustomerName"; // Gösterilecek sütun adı

            // ComboBox ile veri bağlama
            ComboBox comboBox = new ComboBox();
            comboBox.DataSource = dataTable;
            comboBox.DisplayMember = "CustomerName"; // Gösterilecek sütun adı
            comboBox.ValueMember = "CustomerID"; // Seçilen öğe değeri

            // Form oluşturma ve kontrolleri ekleyerek gösterme
            Form form = new Form();
            form.Controls.Add(dataGridView);
            form.Controls.Add(listBox);
            form.Controls.Add(comboBox);

            Application.Run(form);
        }
    }
}

Bu örnekte:

Bir SqlConnection nesnesi ile veritabanına bağlanılır.
Bir SqlDataAdapter nesnesi ile SQL sorgusu çalıştırılır ve elde edilen veri bir DataTable nesnesine yüklenir.
DataGridView, ListBox ve ComboBox gibi kontroller kullanılarak bu DataTable‘a bağlama yapılır.
Oluşturulan kontroller bir Form nesnesine eklenir ve uygulama çalıştırılır.

Bu sayede, veritabanındaki verileri kullanıcı arayüzünde görüntüleyebilir ve çeşitli kontroller ile etkileşimde bulunabilirsiniz. DataGridView tabloyu, ListBox liste elemanlarını, ve ComboBox açılır listeyi gösterir. DisplayMember özelliği ile hangi sütunun görüntüleneceğini belirleyebilir, ValueMember ile seçilen öğenin değerini alabilirsiniz.

CRUD İşlemleri (Create, Read, Update, Delete) İle Veri Güncelleme

ADO.NET kullanarak C# programında CRUD (Create, Read, Update, Delete) işlemleri gerçekleştirmek için, genellikle SqlConnection, SqlCommand, SqlDataAdapter ve DataSet gibi sınıfları kullanırız. Aşağıda, her bir CRUD işlemi için örneklerle birlikte adım adım bir açıklama bulunmaktadır.

Veri Okuma (Read):

using System;
using System.Data;
using System.Data.SqlClient;

class Program
{
    static void Main()
    {
        // Veritabanı bağlantı dizesi
        string connectionString = "Data Source=(localdb)\\MSSQLLocalDB;Initial Catalog=SampleDB;Integrated Security=True";

        // Veritabanı bağlantısı oluşturma
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            // SQL sorgusu
            string query = "SELECT * FROM Customers";

            // SqlDataAdapter ve DataTable oluşturma
            SqlDataAdapter adapter = new SqlDataAdapter(query, connection);
            DataTable dataTable = new DataTable();

            // Verileri veritabanından çekme ve DataTable'a doldurma
            adapter.Fill(dataTable);

            // Okunan verileri ekrana yazdırma
            foreach (DataRow row in dataTable.Rows)
            {
                Console.WriteLine($"Customer ID: {row["CustomerID"]}, Customer Name: {row["CustomerName"]}");
            }
        }
    }
}

Veri Ekleme (Create):

using System;
using System.Data;
using System.Data.SqlClient;

class Program
{
    static void Main()
    {
        // Veritabanı bağlantı dizesi
        string connectionString = "Data Source=(localdb)\\MSSQLLocalDB;Initial Catalog=SampleDB;Integrated Security=True";

        // Veritabanı bağlantısı oluşturma
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            // SQL sorgusu
            string query = "INSERT INTO Customers (CustomerName) VALUES (@CustomerName)";

            // SqlCommand ve SqlParameter oluşturma
            using (SqlCommand command = new SqlCommand(query, connection))
            {
                // Parametre ekleme
                command.Parameters.AddWithValue("@CustomerName", "New Customer");

                // Bağlantı açma
                connection.Open();

                // Sorguyu çalıştırma
                int rowsAffected = command.ExecuteNonQuery();

                Console.WriteLine($"Rows Affected: {rowsAffected}");
            }
        }
    }
}

Veri Güncelleme (Update):

using System;
using System.Data;
using System.Data.SqlClient;

class Program
{
    static void Main()
    {
        // Veritabanı bağlantı dizesi
        string connectionString = "Data Source=(localdb)\\MSSQLLocalDB;Initial Catalog=SampleDB;Integrated Security=True";

        // Veritabanı bağlantısı oluşturma
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            // SQL sorgusu
            string query = "UPDATE Customers SET CustomerName = @NewName WHERE CustomerID = @CustomerID";

            // SqlCommand ve SqlParameter oluşturma
            using (SqlCommand command = new SqlCommand(query, connection))
            {
                // Parametre ekleme
                command.Parameters.AddWithValue("@NewName", "Updated Customer");
                command.Parameters.AddWithValue("@CustomerID", 1);

                // Bağlantı açma
                connection.Open();

                // Sorguyu çalıştırma
                int rowsAffected = command.ExecuteNonQuery();

                Console.WriteLine($"Rows Affected: {rowsAffected}");
            }
        }
    }
}

Veri Silme (Delete):

using System;
using System.Data;
using System.Data.SqlClient;

class Program
{
    static void Main()
    {
        // Veritabanı bağlantı dizesi
        string connectionString = "Data Source=(localdb)\\MSSQLLocalDB;Initial Catalog=SampleDB;Integrated Security=True";

        // Veritabanı bağlantısı oluşturma
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            // SQL sorgusu
            string query = "DELETE FROM Customers WHERE CustomerID = @CustomerID";

            // SqlCommand ve SqlParameter oluşturma
            using (SqlCommand command = new SqlCommand(query, connection))
            {
                // Parametre ekleme
                command.Parameters.AddWithValue("@CustomerID", 1);

                // Bağlantı açma
                connection.Open();

                // Sorguyu çalıştırma
                int rowsAffected = command.ExecuteNonQuery();

                Console.WriteLine($"Rows Affected: {rowsAffected}");
            }
        }
    }
}

Bu örneklerde, SqlConnection, SqlCommand, SqlDataAdapter, ve DataTable gibi sınıflar kullanılarak veri okuma ve yazma işlemleri gerçekleştirilmiştir. Parametreler kullanılarak SQL sorgularına dinamik değerler eklenmiştir. Bu yöntem SQL enjeksi saldırılarına karşı daha güvenli bir yaklaşım sunar.

DataAdapter

DataAdapter Kullanarak Verileri Veritabanına Geri Yazma İşlemleri

ADO.NET’te SqlDataAdapter kullanarak verileri veritabanına geri yazma işlemleri, genellikle bir DataSet üzerinden gerçekleştirilir. DataSet, bellekteki veri tabanını temsil eden bir koleksiyondur ve DataAdapter sınıfı, bu DataSet ile veri tabanı arasında veri eşleştirmeyi sağlar. Aşağıda, C# ADO.NET’te SqlDataAdapter kullanarak veritabanına geri yazma işlemleri için adım adım bir açıklama bulunmaktadır:

Verileri Okuma ve DataSet Oluşturma:

using System;
using System.Data;
using System.Data.SqlClient;

class Program
{
    static void Main()
    {
        // Veritabanı bağlantı dizesi
        string connectionString = "Data Source=(localdb)\\MSSQLLocalDB;Initial Catalog=SampleDB;Integrated Security=True";

        // Veritabanı bağlantısı oluşturma
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            // SQL sorgusu
            string query = "SELECT * FROM Customers";

            // SqlDataAdapter ve DataSet oluşturma
            SqlDataAdapter adapter = new SqlDataAdapter(query, connection);
            DataSet dataSet = new DataSet();

            // Verileri veritabanından çekme ve DataSet'e doldurma
            adapter.Fill(dataSet, "Customers");
        }
    }
}

Verileri Güncelleme ve Veritabanına Yazma:

using System;
using System.Data;
using System.Data.SqlClient;

class Program
{
    static void Main()
    {
        // Veritabanı bağlantı dizesi
        string connectionString = "Data Source=(localdb)\\MSSQLLocalDB;Initial Catalog=SampleDB;Integrated Security=True";

        // Veritabanı bağlantısı oluşturma
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            // SQL sorgusu
            string selectQuery = "SELECT * FROM Customers";
            string updateQuery = "UPDATE Customers SET CustomerName = @CustomerName WHERE CustomerID = @CustomerID";

            // SqlDataAdapter ve DataSet oluşturma
            SqlDataAdapter adapter = new SqlDataAdapter(selectQuery, connection);
            DataSet dataSet = new DataSet();

            // Verileri veritabanından çekme ve DataSet'e doldurma
            adapter.Fill(dataSet, "Customers");

            // SqlCommandBuilder kullanarak otomatik olarak güncelleme sorgularını oluşturma
            SqlCommandBuilder commandBuilder = new SqlCommandBuilder(adapter);

            // Veri değişiklikleri yapma
            DataRow rowToUpdate = dataSet.Tables["Customers"].Rows[0];
            rowToUpdate["CustomerName"] = "Updated Customer";

            // Veritabanına güncel veriyi yazma
            adapter.Update(dataSet, "Customers");

            Console.WriteLine("Data Updated Successfully!");
        }
    }
}

Veri Değişikliklerini İzleme ve Yönetme

ADO.NET, veri değişikliklerini izlemek ve yönetmek için bir dizi özellik ve sınıf sunar. Bu, genellikle bir DataSet kullanarak gerçekleştirilir.

DataSet ve DataTable Kullanımı:

using System;
using System.Data;
using System.Data.SqlClient;

class Program
{
    static void Main()
    {
        // Veritabanı bağlantı dizesi
        string connectionString = "Data Source=(localdb)\\MSSQLLocalDB;Initial Catalog=SampleDB;Integrated Security=True";

        // Veritabanı bağlantısı oluşturma
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            // SQL sorgusu
            string query = "SELECT * FROM Customers";

            // SqlDataAdapter ve DataSet oluşturma
            SqlDataAdapter adapter = new SqlDataAdapter(query, connection);
            DataSet dataSet = new DataSet();

            // Verileri veritabanından çekme ve DataSet'e doldurma
            adapter.Fill(dataSet, "Customers");

            // DataTable referansı alma
            DataTable dataTable = dataSet.Tables["Customers"];
        }
    }
}

Veri Değişikliklerini İzleme:

// Yeni bir satır ekleniyor
DataRow newRow = dataTable.NewRow();
newRow["CustomerName"] = "New Customer";
dataTable.Rows.Add(newRow);

// Varolan bir satır güncelleniyor
DataRow rowToUpdate = dataTable.Rows[0];
rowToUpdate["CustomerName"] = "Updated Customer";

// Bir satır siliniyor
DataRow rowToDelete = dataTable.Rows[1];
rowToDelete.Delete();

// Değişiklikleri onaylama
adapter.Update(dataSet, "Customers");

Yeni bir satır eklenir, varolan bir satır güncellenir ve bir satır silinir. adapter.Update çağrısı ile bu değişiklikler veritabanına uygulanır.

Veri Değişikliklerini Geri Alma:

// Veri değişikliklerini geri alma
dataSet.RejectChanges();

RejectChanges metodunu kullanarak tüm değişiklikleri geri alabilirsiniz. Bu, veri setini orijinal durumuna döndürür.

Özel İzin Verme ve Denetleme:

// Veri değişikliklerini izleme etkinleştirme
dataTable.RowChanged += (sender, e) =>
{
    Console.WriteLine($"Row changed: {e.Row["CustomerName"]}");
};

// Veri silme işlemi sırasında özel kontrol ekleme
dataTable.RowDeleting += (sender, e) =>
{
    if (e.Row["CustomerName"].ToString() == "Protected Customer")
    {
        Console.WriteLine("Deleting a protected row is not allowed.");
        e.Cancel = true; // Silme işlemi iptal ediliyor
    }
};

RowChanged ve RowDeleting olayları ile veri değişikliklerini izleyebilir ve özel kontrol ekleyebilirsiniz. RowDeleting olayında e.Cancel = true kullanarak bir satırın silinmesini engelleyebilirsiniz.

Bu örnekler, veri değişikliklerini nasıl izleyebileceğinizi ve yönetebileceğinizi göstermektedir. DataSet ve DataTable sınıfları, bu tür senaryolar için çeşitli olaylar (events) ve metotlar sağlar. Bu, uygulamanızda veri güncelleme işlemleri sırasında esneklik sağlar.

Transaction (İşlem)

İşlem Kullanarak Birden Fazla Veri İşlem Adımını Birleştirme ve İşlemi ya Tamamlama ya da Geri Alma

ADO.NET’te işlemler (transactions) kullanarak birden fazla veri işlem adımını birleştirmek, bu adımları ya tamamlamak ya da geri almak mümkündür. İşlemler, bir dizi veri tabanı işlemini gruplandırır ve bu işlemleri birleştirmek, bir işlemin tamamını başarıyla tamamlamaktan emin olmayı sağlar veya bir hatanın olması durumunda tüm işlemi geri alabilir.

using System;
using System.Data;
using System.Data.SqlClient;

class Program
{
    static void Main()
    {
        // Veritabanı bağlantı dizesi
        string connectionString = "Data Source=(localdb)\\MSSQLLocalDB;Initial Catalog=SampleDB;Integrated Security=True";

        // Veritabanı bağlantısı oluşturma
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            connection.Open();

            // İşlem başlatma
            SqlTransaction transaction = connection.BeginTransaction();

            try
            {
                // İlk işlem adımı: Veri ekleme
                string insertQuery = "INSERT INTO Customers (CustomerName) VALUES (@CustomerName)";
                using (SqlCommand insertCommand = new SqlCommand(insertQuery, connection, transaction))
                {
                    insertCommand.Parameters.AddWithValue("@CustomerName", "New Customer");

                    int rowsAffected = insertCommand.ExecuteNonQuery();

                    Console.WriteLine($"Rows Affected by Insert: {rowsAffected}");
                }

                // İkinci işlem adımı: Veri güncelleme
                string updateQuery = "UPDATE Customers SET CustomerName = @NewName WHERE CustomerID = @CustomerID";
                using (SqlCommand updateCommand = new SqlCommand(updateQuery, connection, transaction))
                {
                    updateCommand.Parameters.AddWithValue("@NewName", "Updated Customer");
                    updateCommand.Parameters.AddWithValue("@CustomerID", 1);

                    int rowsAffected = updateCommand.ExecuteNonQuery();

                    Console.WriteLine($"Rows Affected by Update: {rowsAffected}");
                }

                // İşlemi tamamla
                transaction.Commit();

                Console.WriteLine("Transaction committed successfully!");
            }
            catch (Exception ex)
            {
                // İşlem sırasında bir hata olması durumunda işlemi geri al
                Console.WriteLine($"Transaction failed. Rolling back. Error: {ex.Message}");
                transaction.Rollback();
            }
        }
    }
}

Bu örnekte, SqlConnection üzerinden bir işlem başlatılır (BeginTransaction). Ardından, bir dizi SQL sorgusu çalıştırılır. Eğer herhangi bir sorguda bir hata olursa (try-catch bloğu içindeki catch bloğu), işlem geri alınır (Rollback). Eğer hiçbir hata olmazsa, işlem tamamlanır (Commit). Bu, tüm işlemlerin başarıyla tamamlanması durumunda veritabanındaki değişikliklerin uygulandığı bir güvenliğidir.

Error Handling (Hata Yönetimi)

ADO.NET kullanılırken veritabanı işlemlerinde hata yönetimi oldukça önemlidir. Hataların düzgün bir şekilde ele alınması, uygulamanın güvenilirliğini artırır ve sorunların hızlı bir şekilde tanımlanmasını sağlar.

Try-Catch Blokları Kullanma:

using System;
using System.Data.SqlClient;

class Program
{
    static void Main()
    {
        try
        {
            // Veritabanı bağlantısı oluşturma
            using (SqlConnection connection = new SqlConnection("ConnectionString"))
            {
                // Bağlantı açma
                connection.Open();

                // Veritabanı işlemleri burada gerçekleştirilir
            }
        }
        catch (SqlException ex)
        {
            // SQL hataları
            Console.WriteLine($"SQL Error: {ex.Message}");
        }
        catch (Exception ex)
        {
            // Diğer hatalar
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
}

try-catch blokları kullanarak genel hataları ve SQL hatalarını yakalayabilirsiniz.

Transaction ve Rollback İşlemleri ile Hata Yönetimi:

using System;
using System.Data;
using System.Data.SqlClient;

class Program
{
    static void Main()
    {
        using (SqlConnection connection = new SqlConnection("ConnectionString"))
        {
            connection.Open();

            SqlTransaction transaction = connection.BeginTransaction();

            try
            {
                // İşlemler burada gerçekleştirilir

                // İşlemi tamamla
                transaction.Commit();
            }
            catch (Exception ex)
            {
                // İşlem sırasında bir hata olması durumunda işlemi geri al
                Console.WriteLine($"Transaction failed. Rolling back. Error: {ex.Message}");
                transaction.Rollback();
            }
        }
    }
}

İşlemleri bir işlem (transaction) içinde gruplandırarak, işlem sırasında bir hata durumunda tüm işlemi geri alabilirsiniz.

Hata Kodları ve Mesajları İnceleme:

try
{
    // Veritabanı işlemleri burada gerçekleştirilir
}
catch (SqlException ex)
{
    foreach (SqlError error in ex.Errors)
    {
        Console.WriteLine($"SQL Error {error.Number}: {error.Message}");
    }
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}

SqlException sınıfının Errors özelliği ile bir SQL hatasının tüm detaylarını inceleyebilirsiniz.

Hata Kaydını Loglama:

try
{
    // Veritabanı işlemleri burada gerçekleştirilir
}
catch (Exception ex)
{
    // Hata kaydını loglama
    LogError(ex);
}

void LogError(Exception ex)
{
    // Hata kaydını loglama işlemleri burada yapılır
}

Bu örnekler, temel hata yönetimi tekniklerini göstermektedir. Gerçek bir uygulamada, daha ayrıntılı ve özelleştirilmiş hata yönetimi stratejileri kullanılabilir.

ADO.NET’te hata yönetimi, Exception sınıflarını kullanarak gerçekleştirilir. Exception sınıfları, bir hata durumunda oluşan istisnai durumları temsil eder ve bu durumların ele alınması programlama yapısının bir parçasıdır.

Temel Exception Sınıfı:

Exception sınıfı, tüm istisnai durumların temel sınıfıdır. Bu sınıf, genel hata durumlarını temsil eder ve diğer spesifik istisnai durum sınıfları bu sınıftan türetilir. Aşağıda, Exception sınıfının temel kullanımı bulunmaktadır:

try
{
    // ADO.NET kodları burada yer alır
}
catch (Exception ex)
{
    // Genel hata durumu
    Console.WriteLine($"Hata: {ex.Message}");
}

SqlException Sınıfı:

SqlException sınıfı, SQL Server veritabanlarından kaynaklanan hataları temsil eder. Bu sınıf, Number özelliği aracılığıyla spesifik hata kodlarına ve Errors koleksiyonu aracılığıyla ayrıntılı hata bilgilerine erişim sağlar.

SqlException Sınıfı:

try
{
    // ADO.NET kodları burada yer alır
}
catch (SqlException ex)
{
    foreach (SqlError error in ex.Errors)
    {
        Console.WriteLine($"SQL Hatası ({error.Number}): {error.Message}");
    }
}

Özel Exception Sınıfları Kullanma:

Özel durumları temsil etmek ve özelleştirilmiş hata işleme stratejileri uygulamak için kendi istisnai durum sınıflarınızı oluşturabilirsiniz. Örneğin, aşağıda özel bir CustomDatabaseException sınıfı bulunmaktadır:

public class CustomDatabaseException : Exception
{
    public CustomDatabaseException(string message) : base(message)
    {
    }
}

try
{
    // ADO.NET kodları burada yer alır
}
catch (CustomDatabaseException ex)
{
    Console.WriteLine($"Özel Hata: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"Genel Hata: {ex.Message}");
}

Finally Bloğu:

finally bloğu, try ve catch bloklarının ardından her durumda çalıştırılacak kodları içerir. Veritabanı bağlantılarını kapatmak veya kaynakları serbest bırakmak gibi temizleme işlemleri için kullanışlıdır.

try
{
    // ADO.NET kodları burada yer alır
}
catch (Exception ex)
{
    Console.WriteLine($"Hata: {ex.Message}");
}
finally
{
    // Her durumda çalışacak kodlar burada yer alır
}

Bu örnekler, C# ADO.NET’te Exception sınıflarını kullanarak temel hata yönetimi konseptlerini göstermektedir. Özel hata sınıfları oluşturarak ve finally bloğunu kullanarak daha özelleştirilmiş ve güvenli bir hata yönetimi stratejisi uygulayabilirsiniz.

Connection Pooling

ADO.NET, bağlantı havuzunu kullanarak veritabanı bağlantılarını etkili bir şekilde yönetme imkanı sunar. Bağlantı havuzu, bir uygulama tarafından kullanılan bağlantıları saklayan ve bu bağlantıları daha sonra tekrar kullanıma sunan bir mekanizmadır. Bu, bağlantıların sürekli olarak açılıp kapatılmasını önler ve uygulamanın performansını artırır.

Bağlantı Havuzunu Etkinleştirme: Bağlantı havuzunu etkinleştirmek için, bağlantı dizesinde Pooling=true ifadesini kullanmanız yeterlidir. Bu, bağlantı havuzunun otomatik olarak etkinleştirilmesini sağlar.

string connectionString = "Data Source=(localdb)\\MSSQLLocalDB;Initial Catalog=SampleDB;Integrated Security=True;Pooling=true";

Bağlantı Nesnelerini Yönetme: Bağlantı havuzunu kullanırken, bağlantı nesnelerini açtığınızda aslında bir bağlantı havuzundan bir bağlantı alırsınız. Bağlantıyı kapatmak, gerçekte bağlantıyı havuza geri bırakır.

using (SqlConnection connection = new SqlConnection(connectionString))
{
    connection.Open();
    // Veritabanı işlemleri burada gerçekleştirilir
}
// Bağlantı otomatik olarak havuza geri bırakılır

Bağlantı Havuzu Ayarları: Bağlantı havuzu, bir dizi özelliği özelleştirmenize izin verir. Örneğin, Min Pool Size ve Max Pool Size özellikleri ile havuzun başlangıç ve maksimum boyutlarını ayarlayabilirsiniz.

string connectionString = "Data Source=(localdb)\\MSSQLLocalDB;Initial Catalog=SampleDB;Integrated Security=True;Pooling=true;Min Pool Size=5;Max Pool Size=20";

Bu örnekte, havuz en az 5 bağlantı içerecek ve en fazla 20 bağlantıya kadar genişleyebilecektir.

Bağlantı Havuzu İzleme: Bağlantı havuzunu izlemek için SqlConnection sınıfının StatisticsEnabled özelliğini kullanabilirsiniz. Bu özellik, bağlantı havuzu istatistiklerini almanıza olanak tanır.

using (SqlConnection connection = new SqlConnection(connectionString))
{
    connection.StatisticsEnabled = true;
    connection.Open();
    // Veritabanı işlemleri burada gerçekleştirilir
    Console.WriteLine($"Bağlantı Sayısı: {connection.Statistics.NumberOfPooledConnections}");

Bu örnekte, bağlantı havuzundaki bağlantı sayısını öğrenmek için NumberOfPooledConnections istatistik özelliğini kullanıyoruz.

Bağlantı havuzu, veritabanı bağlantılarını daha etkili bir şekilde yönetmek ve performansı artırmak için güçlü bir araçtır. Özellikle çok sayıda veritabanı işlemi gerçekleştirilen uygulamalarda, bağlantı havuzunu kullanmak önemlidir.

Temel ADO.NET Kavramları

Connection (Bağlantı): Veritabanına Bağlantı Kurma İşlemleri

Command (Komut): SQL Sorgularını Veritabanına İleten İşlemler.

DataReader: Veritabanından Veri Okuma İşlemleri

Data Access İşlemleri

Veritabanına Bağlantı Oluşturma

SQL Sorguları Oluşturma ve Çalıştırma

Veri Okuma, Yazma, Güncelleme ve Silme İşlemleri

Parametre Kullanımı

Connection String

Veri Okuma

SqlDataReader Kullanarak Veri Okuma İşlemleri

Okunan Verileri Kullanma ve İşleme

DataSet ve DataTable

DataSet ve DataTable Nesnelerini Kullanarak Veri Saklama ve İşleme

DataTable Oluşturma ve Veri Eklemesi

Veri İlişkilendirmesi (Relationships)

Veri Bağlama (Data Binding)

Veri Kontrolleri (DataGridView, ListBox, ComboBox, vb.) İle Veri Bağlama

CRUD İşlemleri (Create, Read, Update, Delete) İle Veri Güncelleme

DataAdapter

DataAdapter Kullanarak Verileri Veritabanına Geri Yazma İşlemleri

Veri Değişikliklerini İzleme ve Yönetme

DataSet ve DataTable Kullanımı:

Transaction (İşlem)

İşlem Kullanarak Birden Fazla Veri İşlem Adımını Birleştirme ve İşlemi ya Tamamlama ya da Geri Alma

Error Handling (Hata Yönetimi)

Connection Pooling

Leave a ReplyCancel Reply

MinIO

Modern Yazılım Geliştirme: Mimari, Tasarım ve Uygulama Prensipleri

Firebase Firestore

Temel ADO.NET Kavramları

Connection (Bağlantı): Veritabanına Bağlantı Kurma İşlemleri

Command (Komut): SQL Sorgularını Veritabanına İleten İşlemler.

DataReader: Veritabanından Veri Okuma İşlemleri

Data Access İşlemleri

Veritabanına Bağlantı Oluşturma

SQL Sorguları Oluşturma ve Çalıştırma

Veri Okuma, Yazma, Güncelleme ve Silme İşlemleri

Parametre Kullanımı

Connection String

Veri Okuma

SqlDataReader Kullanarak Veri Okuma İşlemleri

Okunan Verileri Kullanma ve İşleme

DataSet ve DataTable

DataSet ve DataTable Nesnelerini Kullanarak Veri Saklama ve İşleme

DataTable Oluşturma ve Veri Eklemesi

Veri İlişkilendirmesi (Relationships)

Veri Bağlama (Data Binding)

Veri Kontrolleri (DataGridView, ListBox, ComboBox, vb.) İle Veri Bağlama

CRUD İşlemleri (Create, Read, Update, Delete) İle Veri Güncelleme

DataAdapter

DataAdapter Kullanarak Verileri Veritabanına Geri Yazma İşlemleri

Veri Değişikliklerini İzleme ve Yönetme

DataSet ve DataTable Kullanımı:

Transaction (İşlem)

İşlem Kullanarak Birden Fazla Veri İşlem Adımını Birleştirme ve İşlemi ya Tamamlama ya da Geri Alma

Error Handling (Hata Yönetimi)

Connection Pooling

Leave a ReplyCancel Reply

Trending now

MinIO

Modern Yazılım Geliştirme: Mimari, Tasarım ve Uygulama Prensipleri

Firebase Firestore