Net Anlatım .Net Geliştirme

ASP.NET’te Rol Tabanlı(Rol-Based) Güvenlik

jaja — Sat, 05 Jan 2008 12:56:49 +0000

Rol tabanlı güvenliğin ASPNET’te nasıl uygulandığına geçmeden önce rolün ne olduğu ve uygulamalar içerisinde nasıl bir önem taşıdığı incelenmelidir. Bu tür bir inceleme için bir forum sitesi iyi bir örnek olarak verilebilir. Bir forum sitesini kullanan kullanıcıların aşağıdaki gibi rolleri olabilmektedir.

1) Sistem Yöneticisi, ekleme, silme güncelleme gibi işlemlerin hepsini yapabilen en yetkili kullanıcıdır.

2) �Moderator�, sadece gelen mesajları onaylayabilir

3) �Abone�, yeni mesaj yaratabilir, mesajları okuyabilir, yönetici özelliklerini barındırmaz.

4) Diğer (genel Internet kullanıcıları), sadece mesajları okuyabilirler.

ASP ile geliştirilen uygulamalarda genel yaklaşım kullanıcıyı diğerlerinden ayırt eden kimlik bilgisinin (�userid�) �Session� nesnesinde saklanması ve ilgili kullanıcının yetki bilgisinin veritabanından sorgu ile alınmasıdır.

int currentUserID = Session(”UserID”)

string userType = myDatabaseLookupFunction( currentUserID )

//Sadece System Administrator’ları ve Moderatörlerine izin var.

switch(userType)
{
case “1″:
case “2″ :
// Geçerli kullanıcı
case Else :
// Yetkisiz Kullancı
}

Bu tarz kod parçaları yetki kontrolünün yapılmasını gerektiren her sayfada yer almakta ve her defasında veritabanına bir sorgu gönderip sonuç almaya sebep olmaktadır.

ASP.NET teknolojisi ile bu yaklaşım değişmektedir.

Temeller (�Principals�), Roller ve Kimlikler

�Windows� işletim sistemlerinde kullanıcılar ve kullanıcıların bağlı bulunduğu grup tanımlamaları bulunmaktadır. Örneğin, güvenli bir ağa erişmek isteyen istemci, bir kullanıcı adı ile bu kullanıcı adının bağlı bulunduğu bir yada daha fazla grup bilgisine ihtiyaç duymaktadır. .NET terminolojisinde, kullanıcı adı ve grup kavramları kimlik ve rol olarak isimlendirilmektedir. Kodsal açıdan bakılırsa, kimlik ve rol bilgileri �Principal� isimli nesne içerisinde saklanmaktadır. Rol tabanlı güvenliğin nasıl sağlandığının daha iyi anlaşılabilmesi için, öncelikle bu üç kavramın birbirleri ile olan ilişkileri incelenmelidir. Kodlama örnekleri ilerleyen başlıklar altında verilecektir.

Kimlikler

Kimlikler kullanıcıları temsil etmektedirler. �System.Security.Principal� isim alanı altında bulunan, kullanıcı özelliklerinin tanımlanmasını sağlayan �WindowsIdentity� ve �GenericIdentity� sınıflarının yardımı ile gerekli kodlamalar yapılabilmektedir.

Roller

Kodlamada en basit şekilde metin dizini olarak yaratılıp �Principal� nesnesine eklenirler.

string[] roleString = {”manager”, “cleaner”}

�Principals�

Bir �Principal� nesnesi anlık kullanıcının kimlik ve rol bilgilerini taşımaktadır. Bu nesne �System.Security.Principal� �namespace� i altında yer alan �WindowsPrincipal� ve �GenericPrincipal� sınıfları kullanılarak yaratılmaktadır.

.NET ortamında çalışma zamanında, yetki kontrolünün gerektiği durumlarda, kullanıcı kimlik ve rol bilgilerini taşıyan �Principal� nesnesine ihtiyaç duyulmaktadır. Bu sebepten dolayı �authentication� işlemi sırasında gerçekliği doğrulanmış olan kullanıcı ve onun rol bilgileri �Principal� nesnesine atanmalıdır.

Kod Örneği

Aşağıdaki kod global.asax dosyası içerisine yazılmalıdır;

public void Application_AuthenticateRequest(object sender, EventArgs e)
{

System.Web.Security.FormsIdentity id;

id = HttpContext.Current.User.Identity;

string[] MyRoles = new string[2];

MyRoles[0] = “Manager”;

MyRoles[1] = “Admin”;

HttpContext.Current.User = new System.Security.Principal.GenericPrincipal(id,MyRoles)
}

Yukarıdaki kod parçasında, önceden belirlenmiş rol tanımları ve kimlik bilgileri �authentication� işlemini gerçekleştiren kullanıcı için �Principal� nesnesine atanmaktadır.

�FormsAuthentication� nesnesinin çalışma mantığı hatırlanırsa, bir kullanıcının gerçekliği kanıtlanmakta (�authentication�) ve bir cookie yaratılmaktadır. �Application_AuthenticateRequest� metoduda bu sırada sistem tarafından çağırılmaktadır. Bu yüzden, kullanıcıya dinamik olarak rol ataması için bu metot uygun bir yerdir.

Özet

1) Kullanıcı adı ve şifresi kontrol edilir,

2) Kullanıcı için tanımlı olan roller çekilir,(VB.NET Kodu)

        Dim strRoles() As String

        Dim arrRoles As New ArrayList()

        ‘ do some database call that returns a reader

        While reader.Read()

                arrRoles.Add(reader(”role”))

        End While

        strRoles = arrRoles.ToArray(GetType(String), String())

3) Kimlik ve rol bilgileri �Principal� nesnesine atanır,

Dim objPrincipal As GenericPrincipal = New GenericPrincipal(objIdentity, strRoles)

4) HttpContext.Current.User= objPrincipal

Kullanıcı Rolü Kontrolleri

Uygulama içerisinde �Principal� nesnesinin içeriğine erişmek için dört ayrı yöntem bulunmaktadır. Bu yöntemler �Configuratively�, �Programmatically�, �Imperatively� ve �Declaratively� olarak isimlendirilmektedir. Burada ilk iki yöntem anlatılmaktadır.

Konfigürasyon Yöntemi(Configuratively)

Gerekli yetki kontrolü web.config dosyasında tanımlanmaktadır. Örneğin geliştirilen bir uygulamada, yönetim ile ilgili sayfalara sadece yönetici ve �moderator� tanımlı kullanıcıların erişmesi gerekmektedir. Bu durumu geçerli kılmak için aşağıda gösterildiği gibi bir kodlama yapılabilmektedir.

Bu yöntemin klasik ASP güvenlik yaklaşımı ile kıyaslandığında, yazılım geliştirenin işini kolaylaştırdığı görülmektedir. ASP teknolojisinde, güvenlik kontrolünün gerektiği her sayfaya ilgili kontrol kodları eklenmektedir.

Programsal Olarak(Programmatically)

Kod içerisinden yetki kontrolü yapmakta mümkündür. Örneğin, bir forum sitesinde genel Internet kullanıcılarının yazılanları okuması ancak yeni bir konu yaratamaması istenmektedir. Dolayısıyla yeni konu isimli köprü bu tip kullanıcılara gösterilmeyecektir.

if(!User.IsInRole(”public”))

    // göster

else

   // gösterme

Connection (Bağlantı) Kavramı ve OleDbConnection Sınıfı

jaja — Sat, 05 Jan 2008 12:56:05 +0000

Bu makalemizde, ADONET mimarisinde temel yapı taşı olan Connection (Bağlantı) kavramına kısaca değinecek ve OleDbConnection sınıfını incelemeye çalışacağız. ADO.NET mimarisinde, pek çok sınıfın veri kaynakları ile olan iletişiminde Connection (Bağlantı) nesnelerini kullanırız. Örneğin, bir veri kayağındaki tablolara ait verileri, DataSet sınıfından bir nesne örneğine taşımak istediğimizi düşünelim. Bu dataSet nesnesini dolduracak olan DataAdapter sınıfına, sahip olduğu sql sorgusunun veya komutunun işleyeceği bir hattı belirtmemiz gerekir. İşte burada devreye Connection (Bağlantı) nesnelerimiz girer. Yada bir Command sınıfı nesnesi yardımıyla veritabanı üzerindeki bir saklı yordamı (stored procedure) çalıştırmak istediğimizi düşünelim. Bu durumda komutun çalıştırılabileceği bir hattı veri kaynağımız ile Command nesnesi arasında sağlamamız gerekir. İşte Connection (Bağlantı) nesnemizi kullanmamız için bir sebep daha.

Verdiğimiz bu basit örneklerdende anlaşıldığı gibi, Connection(bağlantı) sınıfları, veri kaynağına bir hat çekerek, ADO.NET nesnelerinin bu hat yardımıyla işlemlerini gerçekleştirmelerine imkan sağlarlar. Ancak sahip olunan veri kaynağının türüne göre, ADO.NET içerisine değişik Connection sınıfları eklenmiştir. DotNet’in ilk sürümünde OleDbConnection ve SqlConnection nesneleri ile bu hatlar temin edilirken, .NET Framework 1.1 sürümü ile birlikte, OdbcConnection ve OracleConnection sınıflarıda ADO.NET kütüphanelerine dahil edilerek Odbc ve Oracle veri kaynaklarına bağlantılar sağlanması imkanı kazandırılmıştır.

OleDbConnection sınıfı ile, bir OleDb Data Provider (veri sağlayıcısı) üzerinden, ole db destekli veri kaynaklarına erişim sağlayabiliriz. SqlConnection sınıfı Sql Sunucularına doğrudan bağlantı sağlar. Aynı şekilde OracleConnection sınıfıda Oracle veri kaynaklarına doğrudan erişim sağlar. OdbcConnection sınıfı ise odbc destekli veri kaynaklarına erişim için kullanılır. Bu makalemizde bu bağlantı sınıflarından OleDbConnection sınıfını inceleyeceğiz. OleDbConnection sınıfı, ADO.NET sınıflarının , Ole Db desteği olan veri kaynaklarına erişebilmesi amacıyla kullanılır. Veri kaynağının tipi tam olarak bilinmediği için, arada bu işlevi ayırt etmeye yarayan bir COM+ nesnesi yer almaktadır. OleDbConnection sınıfına ait bir nesne iletişim kurmak istediği veri kaynağına ait ole db veri sağlayıcısını belirtmek durumundadır. Bunu daha iyi kavramak için aşağıdaki şekle bakalım.

Şekil 1. OleDbConnection ile Veri Kaynaklarına Bağlantı.

Görüldüğü gibi bir OleDbConnection nesnesi öncelikle bir Ole Db Data Provider ( Ole Db Veri Sağlayıcısı) ile iletişim kurar. Ardından bu veri sağlayıcı istenen veri kaynağına erişerek, gerekli hattı tesis etmiş olur. Peki bu işlemi nasıl gerçekleştireceğiz. İşte tüm Connection nesnelerinin en önemli özelliği olan ConnectionString özelliği bu noktada devreye girmektedir. Kısaca ConnectionString özelliği ile, veri kaynağı ile sağlanacak olan iletişim hattının kurulum bilgileri belirlenir. OleDbConnection sınıfı için ConnectionString özelliği aşağıdaki prototipe sahiptir.

public virtual string ConnectionString {get; set;}

ConnectionString özelliği belirlenmiş bir OleDbConnection sınıfı nesne örneğini açtığımızda, yani veri kaynağına olan hattı kullanılabilir hale getirdiğimizde, bu özellik yanlız-okunabilir (read-only) hale gelir. Dolayısıyla açık bir OleDbConnection nesnesinin ConnectionString özelliğini değiştiremezsiniz. Bunun için bu bağlantıyı tekrardan kapatmanız gerekecektir. ConnectionString özelliği, bir takım anahtar-değer çiftlerinin noktalı virgül ile ayırlmasından oluşturulan string bir bilgi topluluğudur. ConnectionString özelliği içinde kullanabileceğimiz bu anahtar-değer çiftlerinin en önemlisi Provider anahtarıdır. Bu anahtara vereceğimiz değer, hangi tip ole db veri sağlayıcısını kullanmak istediğimizi belirtmektedir.

Örneğin Sql sunucusuna, Sql Ole Db Provider ile bağlanmak istersek, Provider anahtarına, SQLOLEDB değerini atarız. Provider anahtarı mutlaka belirtilir. Daha sonraki anahtar-değer çiftleri ise bu Provider seçimine bağlı olarak değişiklik gösterecektir. Veri kaynağına hangi tip Ole Db Veri Sağlayıcısından bağlandığımızı seçtikten sonra, bağlanmak istediğimiz veri kaynağıda belli olmuş olucaktır. Sırada bu veri kaynağının adını veya adresine belirteceğimiz anahtar-değer çiftlerinin belirlenmesi vardır. Örneğin bir Sql Sunucusuna bağlanıyorsak, sunucu adınıda Ole Db Data Provider( Veri Sağlyacısı) ‘na bildirmemiz gerekir. Bunun için Data Source anahtarını kullanırız. Bununla birlikte bağlandığımız veri kaynağı, sql yada oracle gibi bir veritabanı yönetim sistemi değilde, Access gibi bir tablolama sistemi ise, Data Source anahtarı, tablonun fiziki adresini alır. Sql ve Oracle gibi sunuculara yapılacak bağlantılarda Provider ve Data Source seçiminin yanında hangi veritabanına bağlanılacağınıda Initial Catalog anahtarı yada Database anahtarı ile belirleriz. Bunların dışında veri kaynağına yapılacak olan bağlantının güvenlik ayarlarınıda belirtiriz. Çoğunlukla Integrated Security gibi bir anahtara True değerinin atandığını görürüz. Bu anahtar, veri kaynağına bağlanmak istenen uygulama için, makinenin windows authentication ayarlarına bakıldığını belirtir. Dolayısıyla sql sunucusuna bağlanma yetkisi olan her windows kullanıcısı bu bağlantıyı sağlayabilir. Ancak istersek belli bir kullanıcı adı veya şifresi ilede bir veritabanına bağlantı açılmasını sağlayabiliriz. Bunun için ise, User ID ve Password anahtarlarını kullanırız.

Buraya kadar bahsettiklerimiz kavramsal açıklamalardır. Dilerseniz basit örnekler ile konuyu daha iyi açıklamaya çalışalım. Örneklerimizi Console uygulamaları şeklinde gerçekleştireceğiz. İlk örneğimizde, Sql Sunucusundaki veritabanı için, bir bağlantı hattı oluşturup açacağız.

using System;

using System.Data.OleDb; /* OleDbConnection sınıfı, Data.OleDb isim uzayında yer almaktadır. */

namespace OleDbCon1

{

class Class1

{

static void Main(string[] args)

{

OleDbConnection conFriends=new OleDbConnection(); /* OleDbConnection nesnemiz oluşturuluyor. */

/* ConnectionString özelliği belirleniyor. Provider (Sağlayıcımız) SQLOLEDB. Bu bir sql sunucusuna bağlanmak istediğimizi belirtir. Data Source anahtarına localhost değerini atayarak, sunucunun yerel makinede olduğunu belirtiyoruz. Ancak buraya başka bir adreste girilebilir. Sunucunuz nerede ise oranın adresi. Database ile, bağlantı hattının açılacağı veritabanını belirliyoruz. Burada sql sunucumuzda yer alan Friends veritabanına bağlantı hattı açıyoruz. Son olarak Integrated Security=SSPI anahtar-değer çifti sayesinde Windows Doğrulaması ile sunucuya bağlanabileceğimizi belirtiyoruz. Yani sql sunucusuna bağlanma yetkisi olan her windows kullanıcısı bu hattı tesis edebilecek.*/

conFriends.ConnectionString=”Provider=SQLOLEDB;Data Source=localhost;Database=Friends;Integrated Security=SSPI”;

try

{

conFriends.Open(); /* Open metodu ile oluşturduğumuz iletişim hattını kullanıma açıyoruz. */

Console.WriteLine(”Bağlantı açıldı…”);

conFriends.Close(); /* Close metodu ilede oluşturulan iletişim hattını kapatıyoruz. */

Console.WriteLine(”Bağlantı kapatıldı…”);

}

catch(Exception hata)

{

Console.WriteLine(hata.Message.ToString());

}

Şekil 2. Uygulamanın Çalışmasının Sonucu.

Aynı örnekte bu kez belli bir kullanıcı ile bağlanmak istediğimizi düşünelim. Bu durumda ConnectionString’imizi aşağıdaki şekilde değiştirmemiz gerekir. Bu durumda User ID ve Password anahtarlarına gerekli kullanıcı değerlerini atarız.

conFriends.ConnectionString=”Provider=SQLOLEDB;Data Source=localhost;Database=Friends;User Id=sa;Password=CucP??80.”;

Şimdide bir Access tablosuna nasıl bağlanabileceğimizi görelim. Bunun için ConnectionString özelliğimizi aşağıdaki gibi yazarız.

OleDbConnection conYazarlar=new OleDbConnection(”Provider=Microsoft.Jet.OLEDB.4.0;data source=c:\\Authors.mdb”);

try

{

conYazarlar.Open();

Console.WriteLine(”Yazarlar Access veritabanına bağlantı açıldı…”);

conYazarlar.Close();

Console.WriteLine(”Yazarlar Access veritabanına olan bağlantı kapatıldı…”);

}

catch(Exception hata)

{

Console.WriteLine(hata.Message.ToString());

}

Şekil 3. Access Veritabanına Bağlatı.

Bu örnekte dikkat ederseniz ConnectionString özelliğini, OleDbConnection nesnemizin diğer yapıcı metodu içerisinde parametre olarak belirledik. Ayıraca, Provider olarak bu kez Microsoft.Jet.OLEDB.4.0 ‘ı seçerek, bir Access veritabanına bağlanmak istediğimizi bu Ole Db Provider’a bildirmiş olduk. Daha sonra bu veri sağlayıcı componenti, Data Source anahtarındaki değere bakarak, ilgili adresteki veritabanına bir hat çekti.

Başka bir ConnectionString anahtarıda File Name dir. Bu anahtara bir udl uzantılı dosya adresi vererek, bağlantı hattının bu dosyadaki ayarlar üzerinden gerçekleştirilmesini sağlayabiliriz. Bir udl dosyası Data Link Properties ( veri linki özellikleri) özelliklerini belirler. Böyle bir dosya oluşturmak son derece basittir. Bir text editor ile boş bir dosya açın ve onu udl uzantısı ile kaydedin. Bu durumda dosyamızın görünümü şu şekilde olucaktır.

Şekil 4. Bir udl dosyasının görüntüsü.

Bu dosyayı açtığımızda hepimizin aşina olduğu veritabanı bağlantı seçenekleri ile karşılaşırız.

Şekil 5. Connection ayarları.

Bu penceredeki adımları takip ederek bir ConnectionString’i bir udl dosyasına kaydedebilir ve OleDbConnection nesnemiz için sadece File Name anahtarına bu değeri vererek ilgili bağlantının, bu udl dosyasındaki ayarlar üzerinden gerçekleştirilmesini sağlayabiliriz. İlk yapmamız gereken ConnectionString özelliğinde olduğu gibi , Provider (Sağlayıcı) seçimidir.

Şekil 6. Provider Seçimi.

Burada örnek olarak Sql Server Provider’ımızı seçelim. Sonraki adımda ise sırasıyla sunucu adımızı (Server Name), sunucuya hangi kimlik doğrulaması ile bağlanacağımızı ve veritabanımızın adını seçeriz. Son olarakta bu dosyamızı kaydedelim.

Şekil 7. Connection Özelliklerinin belirlenmesi.

Şimdi uygulamızı buna göre değiştirelim.

OleDbConnection con=new OleDbConnection();

con.ConnectionString=”File Name=C:\\baglanti.udl”;

try

{

con.Open();

Console.WriteLine(”Bağlantı açıldı…”);

con.Close();

Console.WriteLine(”Bağlantı kapatıldı…”);

}

catch(Exception hata)

{

Console.WriteLine(hata.Message.ToString());

}

Şekil 8. Udl dosyası üzerinden bağlantı açmak ve kapatmak.

Tabiki burada Visual Studio.Net’in bağlantı sağlamak için bize sunduğu görsel nimetlerden sözetmedende geçemeyiz. Visual Studio.NET ortamında, OleDbConnection oluşturmak için kullanabileceğimiz Server Explorer sekmesi yer almaktadır.

Şekil 9. Server Explorer

Burada servers sekmesinde Sql sunucularına erişebiliriz. Buradan tablolara, görünümlere, saklı yordamlara hatta tabloa alanlarına ulaşabiliriz. Server Explorer’ın sağladığı pek çok işlevsellik vardır. Örneğin bu pencereden, bir sql tablosu yaratabilirsiniz veya bir saklı yordam oluşturabilirsiniz. Hatta bir tabloyu formunuza sürüklüyerek, gerekli olan tüm ADO.NET nesnelerinin otomatik olarak oluşturulmasınıda sağlayabilirsiniz. Bu makalemizde OleDbConnection nesnesini incelediğimiz için bu tip bir bağlantıyı Server Explorer yardımıyla nasıl gerçekleştireceğimizi inceleyeceğiz. Bunun için (Connect To Database) aracını kullanacağız. Bu butona bastığımızda karşımıza tanıdık Data Link Properties penceresi gelecektir. Süratli bir şekilde burada gerekli bağlantı ayarlarını yaptıktan sonra, Server Explorer aşağıdaki görünümü alıcaktır. Burada örnek olarak bir Access veritabanına bağlantı sağlanmıştır.

Şekil 10. Bağlantı oluşturuldu.

Dikkat ederseniz bağlantımız üzerinden, veri kaynağındaki tablolara ve alanlarına ulaşabiliyoruz. Şimdi bu bağlantıyı, bir windows uygulamasında veya bir asp.net uygulamasında forma sürüklediğimizde bir OleDbConnection nesnesinin otomatik olarak oluşturulduğunu göreceksiniz. İşte bu kadar basit. Artık bu connection nesnesini kullanabilirsiniz. Diğer yandan Server Explorer’da oluşturulan bu bağlantıyı başka uygulamalarda da hazır olarak görebilirsiniz. Data Connection sekmesi uygulamalarda kullanacağımız veri bağlantılarını hazır olarak bulundurmak için ideal bir yerdir.

Şekil 11. OleDbConnection1 nesnesinin Server Explorer yarıdımıyla oluşturulması.

Gelelim OleDbConnection nesnesinin diğer kullanışlı üyelerine. Buraya kadar bir bağlantı hattını oluşturmak için ConnectionString özelliğinin nasıl kullanıldığını inceledik. Bununla birlikte var olan bir bağlantı hattını açmak için Open metodunu, bu bağlantı hattını kapatmak içinde Close metodunun kullanıldığını gördük. OleDbConnection nesnesinin diğer bir özelliğide ConnectionTimeout değeridir. ConnectionTimeout özelliği, bir bağlantının sağlanması için gerekli süreyi belirtir. Bu süre boyunca bağlantı sağlanamaması bir istisnanın fırlatılmasına neden olucaktır. Bu özellik yanlız-okunabilir (read-only) bir özellik olduğundan, değerini doğrudan değiştiremeyiz. Bunun için, bu özelliği ConnectionString içerisinde belirlememiz gerekir. Örneğin aşağıdaki kodlarda, Sql sunucusuna bağlanabilmek için gerekli süre 10 saniye olarak belirlenmiştir. Şimdi ben Sql Server servisimizi durduracağım ve uygulamayı çalıştıracağım. Bakalım 10 saniye sonunda ne olucak.

OleDbConnection conFriends=new OleDbConnection();

conFriends.ConnectionString=”Provider=SQLOLEDB;Data Source=localhost;Database=Friends;User Id=sa;Password=CucP??80.;Connect Timeout=10″;

try

{

conFriends.Open();

Console.WriteLine(”Baglanti açildi…”);

conFriends.Close();

Console.WriteLine(”Baglanti kapatildi…”);

}

catch(Exception hata)

{

Console.WriteLine(hata.Message.ToString());

}

Bu durumda aşağıdaki hata mesajını alırız.

Şekil 12. Sql sunucusunun olmadığını gösteren istisna.

OleDbConnection sınıfının Open ve Close metodları dışındada faydalı metodları vardır. Örneğin ChangeDatabase metodu. Bu metod ile açık olan bir bağlantı üzerinden, veri kaynağındaki seçili veritabanını değiştirmemiz sağlanır. Yani hattın ucu başka bir veritabanına yönlendirilebilir. Bu tabiki Oracle ve Sql gibi veritabanı sistemlerinde özellikle işe yarar. Örneğin, Friends veritabanına bağlıyken, açık olan bağlantımız üzerinden hattımızı, pubs veritabanına yönlendirelim.

OleDbConnection conFr=new OleDbConnection(); /* OleDbConnection nesnemiz oluşturuluyor. */

conFr.ConnectionString=”Provider=SQLOLEDB;Data Source=localhost;Database=Friends;Integrate/d Security=SSPI”; /* Bağlantı hattımız için gerekli bilgiler giriliyor. Sql sunucumuzda yer alan Friends isimli veritabanına bağlandık. */

conFr.Open(); /* Bağlantımız açılıyor. */

Console.WriteLine(”Veritabanı “+conFr.Database.ToString()); /* Şuandaki bağlantının hangi veritabanına yapıldığını OleDbConnection sınıfının Database özelliği ile öğreniyoruz. */

conFr.ChangeDatabase(”pubs”); /* ChangeDatabase metodu ile bağlantı hattımızı yönlendirmek istediğimiz veritabanının adını giriyoruz. */

Console.WriteLine(”Şimdiki veritabanı “+conFr.Database.ToString()); /* Bağlantı hattının şu an yönlendirilmiş olduğu veritabanının adını Database özelliği ile elde ediyoruz.*/

conFr.Close(); /* Bağlantımızı kapatıyoruz. */

Şekil 13. ChangeDatabase metodunun çalışmasının sonucu.

Diğer yararlı bir metod ise GetOleDbSchemaTable metodudur ki bunu bir önceki makalemizde incelemiştik. Bunun dışında bir OleDbCommand nesnesini oluşturmaya yarayan CreateCommand metodu, bir Transaction’ın başlatılması için kullanılan BeginTransaction metodu, OleDbConnection’a ait kaynakları serbest bırakan Dispose metodu’da faydalı diğer metodlar olarak sayılabilir. Bu metodlardan ilerliyen makalelerde yeri geldikçe bahsedeceğiz. OleDbConnection nesnesinin sadece 3 adet olayı vardır. Bunlar, StateChange, Disposed ve InfoMessage olaylarıdır. Bunlardan en çok, StateChange olayını kullanırız. Bu olay, OleDbConnection nesnesinin bağlantı durumunda bir değişiklik olduğunda oluşur. Bu olayın prototipi aşağıdaki şekildedir.

public event StateChangeEventHandler StateChange;

Bu olay StateChangeEventArgs tipinden bir argüman almaktadır. Bu argüman iki özelliğe sahiptir. Bunlar CurrentState ve OriginalState özellikleridir. CurrentState bağlantının o anki drumunu belirtir. OriginalState ise son değişiklikten önceki halini gösterir. Her iki özellikde ConnectionState numaralandırıcısı türünden değerlere işaret ederler. Bu değerler şunlardır.

ConnectionState Değeri	Açıklaması
ConnectionState.Open	Bağlantı açık ise bu değer geçerlidir.
ConnectionState.Closed	Bağlantı kapandığında bu değer geçerlidir.
ConnectionState.Connecting	Bağlantı hattı iletişime açılırken bu değer geçerlidir.
ConnectionState.Broken	Bağlantı hattı açıkken herhangibir nedenle bir kopma meydana gelmesi ve hattın işlevselliğini kaybetmesi durumunda oluşur.
ConnectionState.Executing	Bağlantı nesnemiz bir komut çalıştırırken oluşur.
ConnectionState.Fetching	Bağlantı hattı üzerinden veriler alınırken bur değer geçerlidir.

Tablo 1. ConnectionState numaralandırıcısının değerleri.

ConnectionState numaralandırıcısı aynı zamanda, State özelliği içinde kullanılabilir. State özelliği, OleDbConnection nesnesinin o anki durumunu, ConnectionState numaralandırıcısı tipinde saklar. State özelliğini uygulamalarımızda, var olan bağlantının durumun kontrol ederek hareket etmek için kullanabiliriz. Örneğin bir bağlantı nesnesini uygulamamızın bir yerinde tekrardan açmak istediğimizi varsayalım. Bu bağlantı nesnesinin durumu zaten Open ise yani açık ise, tekrardan açma işlemi uygulamamız gerekmez. Dilerseniz makalemizin sonunda StateChange olayına ilişkin bir örnek geliştirelim.

OleDbConnection con; /* OleDbConnection nesnemiz tanımlanıyor.*/

private void Form1_Load(object sender, System.EventArgs e)

{

lstDurum.Items.Clear();

con=new OleDbConnection(”Provider=SQLOLEDB;Data source=localhost;initial catalog=Friends;Integrated Security=sspi”); /* Bağlantı hattımız oluşturuluyor. */

con.StateChange+=new StateChangeEventHandler(con_DurumDegisti); /* OleDbConnection nesnemiz için StateChange olayımız ekleniyor. Olay meydana geldiğinde con_DurumDegisti isimli metod çalıştırılıcak.*/

}

private void btnAc_Click(object sender, System.EventArgs e)

{

if(con.State==ConnectionState.Closed) /* Kullanıcı açık olan bir bağlantı üzerinden tekrar bu butona basarak bir bağlantı açmak isterse bunun önüne geçmek için ilgili OleDbConnection nesnesinin durumuna bakıyoruz. Eğer con nesnesi kapalı ise, açılabilmesini sağlıyoruz.*/

{

con.Open(); /* Bağlantımız açılıyor. İşte bu anda StateChange olayı çalıştırılır.*/

}

private void btnKapat_Click(object sender, System.EventArgs e)

{

if(con.State==ConnectionState.Open) /* Eğer açık bir bağlantı varsa kapatma işlemini uyguluyoruz.*/

{

con.Close(); /* Bağlantı kapanıyor. StateChange olayı bir kez daha çalışır. */

}

private void con_DurumDegisti(object sender,StateChangeEventArgs e)

{

lstDurum.Items.Add(”Bağlantı durumu “+e.OriginalState.ToString()+” idi.”); /* Bağlantımızın hangi halde olduğunu alıyoruz.*/

lstDurum.Items.Add(”Artık bağlantı durumu “+e.CurrentState.ToString()); /* Ve bağlantımızın yeni halini alıyoruz.*/

}

Şekil 14. StateChange olayı.

GetOleDbSchemaTable Metodu İle Veritabanı Nesnelerini Elde Etme

jaja — Sat, 05 Jan 2008 12:55:06 +0000

Bu makalemizde, OleDbConnection sınıfına ati olan GetOleDbSchemaTable metodu sayesinde, Sql Veritabanımızdaki varlıklara ait şema bilgilerini nasıl temin edebileceğimizi incelemeye çalışacağız. Çoğu zaman programlarımızda, bağlandığımız veritabanında yer alan tabloların (Tables), görünümlerin (Views), saklı yordamların (Stored Procedures) ve daha pek çok veritabanı nesnesinin bir listesine sahip olmak isteriz. ADO.NET’te yer alan OleDbConnection nesnesine ait GetOleDbSchemaTable metodunu kullanarak bu istediğimiz sonuca varabiliriz.GetOleDbSchema metodu aşağıdaki prototipe sahiptir.

public DataTable GetOleDbSchemaTable(Guid schema,object[] restrictions);

Dikkat edecek olursanız metodun geri dönüş değeri DataTable tipindedir. Metodun isminde Table kullanılmasının nedenide zaten budur. Yani dönen şema bilgileri bir DataTable nesnesine aktarılacaktır. Metod iki önemli parametreye sahiptir. İlk parametremiz, OleDbSchemaGuid sınıfı türünden bir numaralandırıcı değeri almaktadır. Bu parametreye vereceğimiz değer ile, veritabanından elde etmek istediğimiz şema tipini belirleriz. Örneğin veritabanında yer alan tabloları elde etmek için, OleDbSchemaGuid.Tables değerini veririz. Bunun yanında bu parametreye verebileceğimiz başka önemli değerlerde şunlardır.

OleDbSchemaGuid Özelliği	Açıklaması
OleDbSchemaGuid .Columns	Tablo veya tablolara ait sütun yapısını sağlar.
OleDbSchemaGuid .Procedures	OleDbConnection nesnesinin bağlı olduğu veritabanında yer alan saklı yordamların listesini sağlar.
OleDbSchemaGuid .Views	OleDbConnection nesnesinin bağlı olduğu veritabanında yer alan görünümlerin listesini sağlar.
OleDbSchemaGuid .Indexes	Belirtilen Catalog’da yer alan indexlerin listesini sağlar.
OleDbSchemaGuid .Primary_Keys	Belirtilen tablo veya tablolardaki birincil anahtarların listesini verir.

Tablo 1. OleDbSchemaGuid Üyelerinin Bir Kısmı

OleDbSchemaGuid sınıfı yukarıdaki örnek üyelerinin yanısıra pek çok üyeye sahiptir. Bu üyeler ile ilgili daha geniş bilgi için MSDN kaynaklarından faydalanmanızı tavsiye ederim. GetOleDbSchemaTable metodumuz ikinci bir parametre daha almaktadır. Bu parametre ile şema bilgisi üzerindeki sınırlamaları belirleriz. Bu sayede, ilk parametrede istediğimiz schema bilgilerinin sadece belirli bir tablo içinmi, yada veritabanının tamamı içinmi oluşturulacağına dair sonuçları elde etmiş oluruz. Örneklerimizi incelediğimizde bu parametrelerin ne işe yaradıklarını daha iyi anlayacağınızı düşünüyorum. Şimdi ilk örneğimizi geliştirelim. Basit bir Console uygulaması olarak geliştireceğimiz bu örnekte, Sql sunucumuzda yer alan, Friends isimli veritabanındaki tüm tabloların bir listesini elde edeceğiz. İşte program kodlarımız.

using System;

/* OleDb isim uzayını ve Data isim uzayını ekliyoruz. */

using System.Data;

using System.Data.OleDb;

namespace GetOleDbSchemaTables1

{

class Class1

{

static void Main(string[] args)

{

/* OleDbConnection nesnemizi oluşturuyoruz. SQLOLEDB provider’ını kullanarak, Sql sunucumuzda yer alan Friends isimli veritabanına bir bağlantı nesnesi tanımlıyoruz. */

OleDbConnection con=new OleDbConnection(”provider=SQLOLEDB;data source=localhost;initial catalog=Friends;Integrated Security=sspi”);

con.Open(); /* Bağlantımızı açıyoruz. */

DataTable tblTabloListesi; /* GetOleDbSchemaTable metodunun sonucunu tutacak DataTable nesnemizi tanımlıyoruz.*/

tblTabloListesi=con.GetOleDbSchemaTable(OleDbSchemaGuid.Tables,null); /* OleDbConnection nesnemizin, GetOleDbSchemaTable metodunu çalıştırıyoruz ve elde edilen şema bilgisini (ki bu örnekte Friends isimli veritabanındaki tüm tabloların listesini alıyor.) alıyoruz ve DataTable nesnemizin bellete referans ettiği alana aktarıyoruz.*/

foreach(DataRow dr in tblTabloListesi.Rows) /* DataTable’ımız içindeki satırlarda gezinebileceğimiz bir döngü oluşturuyoruz ve bu döngü içinde her bir satırın TABLE_NAME alanının değerini, dolayısıyla Friends veritabanındaki tablo adlarını ekrana yazdırıyoruz. */

{

Console.WriteLine(dr[”TABLE_NAME”]);

}

Şimdi uygulamamızı çalıştırdığımızda Friends isimli veritabanında yer alan tüm tabloların ekrana yazıldığını görürsünüz.

Şekil 1. Friends veritabanındaki tabloların listesi.

Şimdi kodlarımızdaki blTabloListesi=con.GetOleDbSchemaTable(OleDbSchemaGuid.Tables,null); satırını daha yakından incelemeye çalışalım. İlk parametremiz OleDbSchemaGuid.Tables, con isimli OleDbConnection nesnemizin bağlandığı Sql sunucusundaki Friends veritabanından sadece tablo bilgilerini elde etmek istediğimizi göstermektedir. Sınırlandırıcı özelliğe sahip olan ikinci parametremize null değerini vererek tüm tabloların şemaya dahil edilmesini ve DataTable nesnesine aktarılmasını sağlamış olduk. Bu noktada bu iki parametrenin birbirleri ile ilişkil olduklarını söyleyebiliriz. Çünkü, OleDbSchemaGuid parametresinin vereceği tabloların şema yapısı, ikinci parametreye bağlıdır. Şöyleki;

Sınırlama Alanı	Açıklaması
TABLE_CATALOG	Katalog adı. Eğer provider’ımız katalogları desteklemiyorsa null değeri verilir.
TABLE_SCHEMA	Şema adı. Yine provider’ımız şemaları desteklemiyorsa null değeri verilir.
TABLE_NAME	Belirli bir tabloya ait şema bilgileri kullanılacaksa, örneğin bu tabloya ait sütun bilgileri alınıcaksa kullanılır.
TABLE_TYPE	Veritabanından hangi tipteki tabloları alacağımızı belirtmek için kullanılır.

Tablo 2. OleDbSchemaGuid.Tables İçin Sınırlama Parametresi Elemanları

Ancak farzedelimki sadece kullanıcı tanımlı taboların listesine ihtiyacımız var. İşte bu durumda sınırlandırıcı parametremiz devreye girecek. Bunun için, sınırlandırıcı parametremizin son elemanının değerini belirlememiz yeterli olucak. O halde bu işlemi nasıl gerçekleştirebiliriz? Bunun için uygulamamızın kodlarını aşağıdaki şekilde değiştirmemiz yeterlidir.

object[] objSinirlama;

objSinirlama=new object[]{null,null,null,”TABLE”};

tblTabloListesi=con.GetOleDbSchemaTable(OleDbSchemaGuid.Tables, objSinirlama);

Şekil 2. Sadece Kullanıcı Tanımlı Tabloların Listesi

Burada sınırlandırıcı nesnemizin nasıl tanımlandığına dikkat edin. Bu tanımlama biraz karışık gelebilir. Ancak OleDbSchemaGuid özelliğinin aldığı değere göre şema bilgileri üzerinde bir sınırlama koymak istiyorsak, bu üyenin kullanabileceği değerleri bilmemiz gerekir. Burada object dizimizin son elemanın TABLE değeri atanmıştır. TABLE değeri şema bilgisine sadece kullanıcı tarafından tanımlanmış taboların alınacağını belirtir. Diğer yandan bu dördüncü elemana, ALIAS, SYSTEM TABLE, VIEW, SYSTEM VIEW, SYNONYM, TEMPORARY, LOCAL TEMPORARY değerlerinide verebiliriz. Hepsi, OleDbSchemaGuid.Tables parametresi sonucunda oluşturulacak tablo şema bilgilerinin yapısınıda değiştirecektir. Örneğin, SYSTEM TABLE değerini vermemiz halinde, Friends tablosundaki system tablolarının listesini elde etmiş oluruz. Yada VIEW değerini verdiğimizde kullanıcı tanımlı görünüm nesnelerinin listesini elde etmiş olurduk.

Yukarıdaki örneğimizde, veritabanımızda yer alan tablolara ait schema bilgilerini aldık. Şimdi ise belirli bir tablonun sütun bilgilerini almak istediğimizi farzedelim. Burada sütun bilgileri için, OleDbSchemaGuid.Columns parametresini kullanmamız gerekiyor. Bu durumda sınırlandırıcımızıda bu parametreye göre değiştirmek durumundayız. Eğer ilk örneğimizdeki gibi null değerini verirsek veritabanındaki tüm tabloların kolonlarına ait şema bilgilerini elde etmiş oluruz. Oysaki belirli bir tabloya ait alanlar için şema bilgisi alıcaksak,OleDbSchemaGuid.Columns parametresinin sınırlandırıcı koşullarını değiştirmemiz gerekecektir. İşte bu noktada sınırlandırıcı değişkenimizin üçüncü elemanı olan TABLE_NAME elemanını kullanırız. Bu amaçla kodlarımızı aşağıdaki şekilde değiştirmemiz yeterli olucaktır.

object[] objSinirlama;

objSinirlama=new object[]{null,null,”Kitap”,null};

tblTabloListesi=con.GetOleDbSchemaTable(OleDbSchemaGuid.Columns, objSinirlama); /* OleDbConnection nesnemizin, GetOleDbSchemaTable metodunu çalıştırıyoruz. Bu kez, Columns değeri sayesinde, sınırlama nesnemizin üçüncü elemanında belirttiğimiz tablo adına ait alanların listesini elde ediyoruz. */

foreach(DataRow dr in tblTabloListesi.Rows)

{

Console.WriteLine(dr[”COLUMN_NAME”]);

}

Şekil 3. Tablomuza ait alanların adları.

Böylece Kitap isimli tablomuzun alanlarına ait schema bilgilerini elde etmiş olduk. Bu örnekte ve bir önceki örnekte dikkat ederseniz, DataTable nesnesindeki belirli bir alanın değerini ekrana yazdırdık. Bu örnekte, COLUMN_NAME, önceki örnekte ise, TABLE_NAME. Elbette elde ettiğimiz şema bilgilerinde sadece bu alanlar yer almıyor. Örneğin Friends veritabanındaki kullanıcı tanımlı tablolara ait başka ne tür bilgilerin şemaya alındığına bir bakalım. Bu amaçla, DataTable nesnemize aktarılan şema bilgilerine ait satırlardaki tüm alanları bir döngü ile gezmemiz yeterli olucaktır. Bunu aşağıdaki kodlar ile gerçekleştirebiliriz.

object[] objSinirlama;

objSinirlama=new object[]{null,null,null,”TABLE”};

tblTabloListesi=con.GetOleDbSchemaTable(OleDbSchemaGuid.Tables, objSinirlama);

foreach(DataRow dr in tblTabloListesi.Rows)

{

for(int i=0;i<=tblTabloListesi.Rows.Count;++i)

{

Console.Write(dr[i]);

Console.Write(”—”);

}

Console.WriteLine(”");

}

Şekil 4. Şemadaki diğer bilgiler.

Data Form Wizard Yardımıyla İlişkili Tablo Uygulamalarının Hazırlanması

jaja — Sat, 05 Jan 2008 12:51:17 +0000

Bu makalemizde, Visual StudioNET ortamında, Data Form Wizard yardımıyla, veritabanı uygulamalarının ne kadar kolay bir şekilde oluşturulabileceğini inceleyeceğiz. Pek çok programcı, uygulamalarını geliştirirken sihirbazları kullanmaktan açıkça kaçınır. Bunun bir nedeni, sihirbazların işlemleri çok fazla kolaylaştırması ve programcıyı tembelliğe itmesidir. Gerçektende, bir Data Form Wizard yardımıyla uzun sürede programlayacağınız bir veritabanı uygulamsını inanılmaz kısa sürede tamamlayabilirisiniz. Diğer yandan, bir programcı için bir uygulamayı geliştirmekteki en önemli unsur belkide şu kelimenin arkasında gizlidir; Kontrol.

Kontrol bir programcı için, uygulamanın her yerinde hakim olmak demektir. Yazılabilecek her kodun programcı tarafından yazılması, olabilecek tüm hataların düzeltilmesi, mantıksal bütünlüklerin sağlanması ve kullanıcının ihtiyaçlarına en üst düzeyde cevap verilebilmesi, programcının kontrolünü güçlendiren unsurlar arasında yer alır. Gerçektende ben size, gerçek hayatta sihirbazları çok fazla kullanmamanızı tavsiye ederim. Herşeyden önce, sihirbazlar tek düzelik sağlarlar ve sürekli aynı adımları atarlar. Bu bir süre sonra hem sizi tembelleştirecek hemde gerçek bir programcı gibi düşünmekten örneğin oluşabilecek programatik hataların önceden sezilebilmesi yetenğinden mahrum bırakacaktır.

Ancak tüm bu olumsuzlukların yanında, bir Data Form Wizard aracını kullanaraktan, .NET ortamında veritabanı programlamasını öğrenmeye çalışan bir programcı için, neler yapılabileceği? , bunların hangi temel adımlarla gerçekleştirildiği? , hatta Visual Studio.NET tarafından otomatik olarak oluşturulan kodların nerelerde devreye girdiği? gibi sorunların anlaşılmasıda oldukça kolay olucaktır. Diğer yandan profesyonel programcılarda zaman zaman, sadece kendileri için bir takım verileri kolayca izleyebilmek amacıyla yada ani müdahalelerde bulunmak amacıyla oluşturacakları uygulamalarda aynı kodları tekrardan yazmak yerine sihirbazları kullanmayı tercih edebilirler. Dolayısıyla zaman zaman sihirbazları kullanmak oldukça işe yarayabilir ama bunu alışkanlık halinede getirmemek gerekir. İşte bu makalemizde, bir Ado.Net uygulamasının, ilişkili iki tablo için nasıl kolayca oluşturulabileceğini incelyeceğiz. Uygulamamız sona erdiğinde, tabloları izleyebilecek, ilişkili kayıtları inceleyebilecek, yeni kayıtlar ekleyebilecek, var olanları düzenleyip silebilecek ve kayıtlar arasında gezinebileceğiz. Ayrıca sihirbazımız, programatik olarak oluşturulan Ado.Net uygulamalarında da hangi adımları takip edeceğimiz hakkında bize kılavuzluk etmiş olucak. Şimdi dilerseniz uygulamamızı yazmaya başlayalım. Öncelikle Visual Studio ortamında bir C# Windows Uygulaması açalım. Daha sonra veritabanı uygulamamızı taşıyacak formu eklemek için, Solution sekmesinde, projemize sağ tuş ile tıklayalım ve Add New Item öğesini seçelim.

Şekil 1. Add New Item.

Bu durumda karşımıza aşağıdaki pencere gelecektir. Bu pencerede Data Form Wizard aracını seçelim. Data Form Wizard aracı tüm adımları bitirildikten sonra, projemize cs uzantılı bir sınıf ve bu sınıfı kullanan bir Form ekleyecektir. Veritabanına bağlanılması, tabloların dolduruluması, satırlar arasında gezinme gibi pek çok işlevi yerine getiren metodlar, özellikler ve nesneler, Data Form Wizard ile oluşturulan bu sınıf içerisine yazılacaktır. Burada Form dosyanıza anlamlı bir isim vermenizi öneririm.

Şekil 2. Data Form Wizard

Bundan sonra, artık uygulamayı oluşturacağımız adımlara geçmiş oluruz.

Şekil 3. Adımlara başlıyoruz.

İlk adımımız DataSet nesnemizin isimlendirilmesi. Bir DataSet, veritabanından bağımsız olarak uygulamanın çalıştığı sistemin belleğinde oluşturulan bir alana referans eden kuvvetli bir nesnedir. Bir DataSet içersine, tablolar, tablolar arası ilişkiler vb. ekleyebiliriz. Bir DataSet ile, veritabanındanki gerekli veriler DataSet nesnesinin bellekte temsil ettiği bölgeye yüklendikten sonra bu veritabanına bağlı olmaksızın çalışabiliriz. Dahada önemlisi, veritabanına bağlı olmaksızın, veriler ekleyebilir, verileri düzenleyebilir, silebilir, yeni tablolara, görünümler, ilişkiler oluşturabiliriz. DataSet, ADO.NET ‘in en önemli yeniliklerinden birisi olmakla birlikte, bağlantısız katman dediğimiz kısımın bir parçasıdır. DataSet’i ilerleyen makalelerimizde daha detaylı olarak da inceleyeceğiz. Şu an için bilmeniz gereken, oluşturacağımız DataSet’in Sql sunucumuzda (veya başka bir databasede) yer alan ilişkili tablolarımızı ve aralarındaki ilişkiyi içerecek olan bağlantısız ( ADO’ daki RecordSet gibi, Veritabanına sürekli bir bağlantıyı gerektirmeyen ) bir nesne oluşudur. Şimdi burada uygulamaya önceden eklediğimiz bir DataSet nesnesini seçebileceğimiz gibi yeni bir tanede oluşturabiliriz. Biz yeni bir DataSet oluşturacağımızdan, Creat a new database named alanına, DataSet’imizin adını giriyoruz.

Şekil 4. İlk adımımız DataSet nesnemizi belirleyeceğimiz ad ile oluşturmak.

Sıradaki adım, veritabanına olan bağlantımızı gerçekleştirecek nesnemizi tanımlayacak. Herşeyden önce DataSet nesnemize bir veritabanından veriler yükleyeceksek, bir veri sağlayıcısı üzerinden bu verileri çekmemiz gerekecektir. İşte bu amaçla, pek çok ADO.NET nesnesi için gerekli olan ve belirtilen veri sağlayıcısı üzerinden ilgili veri kaynağına bir bağlantı açmamıza yarayan bir bağlantı ( Connection ) nesnesi kullanacağız. Burada uygulamamızda Sql Sunucumuzda yer alan veritabanına OleDb üzerinden erişmek istediğimiz için, sihirbazımız bize bir OleDbConnection nesnesi örneği oluşturacaktır. Veri sağlayıcısının tipine göre, OleDbConnection, SqlConnection, OracleConnection, OdbcConnection bağlantı nesnelerini oluşturabiliriz. New Connection seçeneğini seçerek yeni bir bağlantı oluşturmamızı sağlayacak diğer bir sihirbaza geçiş yapıyoruz.

Şekil 5. Connection nesnemizi oluşturmaya başlıyoruz.

Şimdi karşımızda Data Link Properties penceresi yer almakta. Burada, Provider kısmında Microsoft OLE DB Provider For Sql Server seçeneği seçili olmalıdır.

Şekil 6. Provider.

Connection sekmesinde ise öncelikle bağlanmak istediğimiz sql sunucusunun adını girmeliyiz. Sql sunucumuz bu uygulamada, istemci bilgisayar üzerinde kurulu olduğundan buraya localhost yazabiliriz. 2nci seçenekte, sql sunucusuna log in olmamız için gerekli bilgileri veriyoruz. Eğer sql sunucumuz windows authentication’ı kullanıyorsa, Use Windows Integrated Security seçeneğini seçebiliriz. Bu durumda sql sunucusuna bağlanmak için windows kullanıcı bilgileri kontrol edilecektir. Bunun sonucu olarak username ve password kutucukları geçersiz kılınıcakatır. Diğer yandan sql sunucusuna, burada oluşturulmuş bir sql kullanıcı hesabı ilede erişebiliriz. Ben uygulamamda sa kullanıcısını kullandım. Bildiğiniz gibi sa sql kullanıcısı admin yetkilerine sahip bir kullanıcı olarak sql sunucusunun kurulması ile birlikte sisteme default olarak yüklenir. Ancak ilk yüklemede herhangibir şifresi yoktur. Güvenlik amacıyla bu kullanıcıya mutlaka bir şifre verin.(Bunu sql ortamında gerçekleştireceksiniz.) Allow Saving Password seçeneğini işaretlemediğimiz takdirde, uygulamayı kim kullanıyor ise, uygulama başlatıldığında sql sunucusuna bağlanabilmek için kendisinden bu kulllanıcı adına istinaden şifre sorulacaktır. Eğer bu seçeneği işaretlersek, program çalıştırıldığında buraya girilen şifre sorulmayacaktır. Şimdi 3nci seçeneğe geçersek ve combo box kontrolünü açarsak sql sunucusunda yer alan veritabanlarının tümünü görebiliriz. Buradan kullanacağımız veritabanını seçeceğiz.

Şekil 7. Connection bilgileri giriliyor.

Dilersek Test Connection butonuna tıklayarak, sql sunucusuna bağlanıp bağlanamadığımızı kontrolde edebiliriz. Şimdi OK diyelim ve Data Link Properties penceresini kapatalım. Bu durumda karşımıza bir Login penceresi çıkacaktır. Bu az önce Allow Saving Password seçeneğini işaretlemediğimiz için karşımıza gelmiştir. Şifremizi tekrardan girerek bu adımı geçiyoruz. Bu durumda, sql sunucumuz için gerekli bağlantıyı sağlıyacak connection nesnemizde oluşturulmuş olur.

Şekil 8. Login penceresi.

Sıradaki adımımızda ise, uygulamamızda kullanacağımız tabloları seçeceğiz. Bu adımda, bağlandığımız veritabanında yer alan tablolar ve görünümler yer almaktadır. Biz hemen ekleyeceğimiz iki tabloyu seçip pencerenin sağ tarafında yer alan Seleceted Item(s) kısmına aktarıyoruz. Bu tabloların her biri birer DataTable nesnesi olucak şekilde DataSet nesnemize eklenir. DataTable nesneleri tablolara ait bilgilerinin ve verilerinin bellekte yüklendiği belli bir alanı referans ederler. Bir DataSet nesnesi birden fazla DataTable içerebilir. Böylece veritabanı ortamını DataSet nesnesi ile uygulamanın çalıştığı sistem belleğinde simule etmiş oluruz.

Şekil 9. Tablolar seçiliyor.

Bu iki tablomuz hakkında yeri gelmişken kısaca bilgi verelim. Sepetler tablosunda alışveriş sepetlerine ait bilgiler yer alıyor. Siparsler tablosu ise bu belirli sepetin içinde yer alan ürünlerin listesini tutuyor. Yani Sepetler tablosundan Siparisler tablosuna doğru bire-çok ilişki söz konusu. Bu adımıda tamamladıktan sonra, veri kaynağına log in olmamız için tekrar bir şifre ekranı ile karşılacağız. Burayıda geçtikten sonra sıra, iki tablo arasındaki ilişkiyi kuracağımız adıma geldi. Burada aralarında ilişki oluşturmak istediğimiz tabloları ve ilgili kolonları seçerek ilişkimiz için bir isim belirleyeceğiz. Bunun sonucu olarak sihirbazımız bir DataRelation nesnesi oluşturacak ve bu nesneyi DataSet’e ekliyecek. Böylece veritabanından bağımsız olarak çalışırken, DataSet kümemiz bu DataRelation nesnesini kullanarak tablolar arasındaki bütünlüğüde sağlamış olucak. Öncelikle bu ilişki için anlmalı bir ad belirleyin. Çoğunlukla ilişkinin hangi taboladan hangi tabloya doğru olduğuna bağlı olunarak bir isimlendirme yapılır. Daha sonra Parent(Master) tablo ve Primary Key seçilir. Ardından Foreign Key alanını içeren tabloda, Child(Detail) tablo olarak seçilir. Uyulamamızda Sepetler tablosu ile Siparisler tablosu SepetID alanları ile birbirlerine ilişkilendirilmiştir.

Şekil 10. DataRelation nesnesi oluşturuluyor.

Bir sonraki adımımızda tabloların hangi alanlarının Form üzerinde görüntüleneceğini belirleriz. Başlangıç için bütün alanlar seçili haldedir. Bizde bunu uygulamamızda bu halde bırakacağız.

Şekil 11. Görüntülenecek Alanların Seçilmesi.

Son adım ise, Formun tasarımının nasıl olacağıdır. İstersek master tabloyu DataGrid kontrolü içinde gösterebiliriz. Ya da Master tabloya ait verileri bağlanmış kontollerlede gösterebiliriz. Bunun için Single record in individual controls seçeneğini seçelim. Diğer seçenekleride olduğu gibi bırakalım.

Şekil 12. Son Adım. Formun görüntüsünün ayarlanması.

Böylece Data Form Wizard yardımıyla veritabanı uygulamamız için gerekli formu oluşturmuş olduk. Karşımıza aşağıdaki gibi bir Form çıkacaktır.

Şekil 13. Formun son hali.

Görüldüğü gibi tüm kontrolleri ile birlikte uygulamamız oluşturulmuştur. Sql sunucumuza Ole Db veri sağlayıcısı üzerinden erişmemizi sağlıyan OleDbConnection nesnemiz, tablolardaki verileri DataSet nesnesine yüklemek (Fill) ve bu tablolardaki değişiklikleri, veritabanına yansıtmak (update) için kullanılan OleDbDataAdapter nesneleri, tabloları ve tablolar arası ilişkiyi bellekte sakayıp veritabanından bağımsız olarak çalışmamızı sağlayan DataSet nesnemiz ve diğerleri… Hepsi sihirbazımız sayesinde kolayca oluşturulmuştur. Gelelim bu form ile neler yapabileceğimize.

Her şeyden önce uygulamamızı çalıştırdığımızda hiç bir kontrolde verilerin görünmediğine şahit olucaksınız. Önce, veritabanından ilgili tablolara ait verilerin DataSet üzerinden DataTable nesnelerine yüklenmesi gerekir. Bu Fill olarak tanımlanan bir işlemdir. Load butonu bu işlemi gerçekleştirir. Load başlıklı butonun koduna bakarasak;

private void btnLoad_Click(object sender, System.EventArgs e)

{

try

{

// Attempt to load the dataset.

this.LoadDataSet();

}

catch (System.Exception eLoad)

{

// Add your error handling code here.

// Display error message, if any.

System.Windows.Forms.MessageBox.Show(eLoad.Message);

}

this.objdsSatislar_PositionChanged();

}

Görüldüğü gibi kod LoadDataSet adlı bir procedure’e yönlendirilir.

public void LoadDataSet()

{

// Create a new dataset to hold the records returned from the call to FillDataSet.

// A temporary dataset is used because filling the existing dataset would

// require the databindings to be rebound.

Wizard.dsSatislar objDataSetTemp;

objDataSetTemp = new Wizard.dsSatislar();

try

{

// Attempt to fill the temporary dataset.

this.FillDataSet(objDataSetTemp);

}

catch (System.Exception eFillDataSet)

{

// Add your error handling code here.

throw eFillDataSet;

}

try

{

grdSiparisler.DataSource = null;

// Empty the old records from the dataset.

objdsSatislar.Clear();

// Merge the records into the main dataset.

objdsSatislar.Merge(objDataSetTemp);

grdSiparisler.SetDataBinding(objdsSatislar, “Sepetler.drSepetlerToSiparisler”);

}

catch (System.Exception eLoadMerge)

{

// Add your error handling code here.

throw eLoadMerge;

}

Bu metodda da yükleme işlemi için bir DataSet nesnesi oluşturulur veFillDataSet procedure’ü bu DataSet’i parametre alarak çağırılır. Bu kodlarda ise OleDbDataAdapter nesnelerinin Fill metodlarıa tablolara ait verileri, veritabanından alarak DataTable nesnelerine yüklerler. Bunu yaparken OleDbDataAdapter nesneleri Select sorgularını kullanır. Bu sorgular, program içinde oluşturulmuş SqlCommand nesnelerinde saklanmaktadır. Her bir tablo için bir OleDbDataAdapter, bu tabodaki verileri almak için çalıştıracağı bir Sql sorgusunu, bir SqlCommand nesnesinden alır.

public void FillDataSet(Wizard.dsSatislar dataSet)

{

// Turn off constraint checking before the dataset is filled.

// This allows the adapters to fill the dataset without concern

// for dependencies between the tables.

dataSet.EnforceConstraints = false;

try

{

// Open the connection.

this.oleDbConnection1.Open();

// Attempt to fill the dataset through the OleDbDataAdapter1.

this.oleDbDataAdapter1.Fill(dataSet);

this.oleDbDataAdapter2.Fill(dataSet);

}

catch (System.Exception fillException)

{

// Add your error handling code here.

throw fillException;

}

finally

{

// Turn constraint checking back on.

dataSet.EnforceConstraints = true;

// Close the connection whether or not the exception was thrown.

this.oleDbConnection1.Close();

}

Uygulamanın diğer butonlarına ilişkin kodlarıda incelediğinizde herşeyin otomatik olarak sihirbaz tarafından uygulandığını göreceksiniz. Uygulamanın tüm kodlarını ekteki DataForm1.cs dosyası içinden inceleyebilirsiniz. Şimdi uygulamamızı çalıştıralım ve görelim. Uygulamayı çalıştırdığınızda Form1′in ekrana geldiğini ve DataForm1 in görünmediğini göreceksiniz. Bu durumu düzeltmek için, projenin başlangıç formunu değiştirmemiz gerekiyor.Bunun için, Form1′in Main Procedure’ünün kodunu aşağıdaki gibi değiştirmemiz yeterlidir.

static void Main()

{

Application.Run( new DataForm1());

}

Şimdi uygulamamızı çalıştırabiliriz. Load başlıklı button kontrolüne tıkladığımızda tablo verilerinin ekrana geldiğini ve kontrollere yüklendiğini göreceksiniz. Yön kontrolleri ile Sepetler tablosunda gezinirken DataGrid kontrolündeki verilerinde değiştiğine dikkatinizi çekmek isterim.

Şekil 14.Uygulamanın çalışmasının sonucu.

Dilerseniz veriler üzerinde değişiklikler yapabilirsiniz. Ancak yaptığınız bu değişiklilker bellekteki DataSet kümesi üzerinde gerçekleşecektir. Bu değişiklikleri eğer, veritabanınada yazmak isterseniz Update başlıklı button kontrolüne tıklamanız gerekir. Bu durumda temel olarak, OleDbDataAdapter nesnesi, DataSet üzerindeki tüm değişiklikleri alıcak ve veritabanını Update metodu ile güncelleyecektir. Bu işlem için OleDbDataAdapter nesnesinin Update metodu, UpdateCommand özelliğine bakar. UpdateCommand özelliği, Update sorgusu içeren bir SqlCommand nesnesini işaret eder. Böylece güncelleme işlemi bu komut vasıtasıyla gerçekleşir. Bu işlemler yanında yeni satırlar ekleyebilir, var olanlarını silebilirsiniz. Görüldüğü gibi komple bir veritabanı uygulaması oldu. Bunun dışında uygulamamızın güçlü yönleride vardır. Örneğin yeni bir Siparis girin. Ancak Siparis numarasını aşağıdaki gibi var olmayan bir SepetID olarak belirleyin.

Şekil 15. Var olmayan bir ForeignKey girdik.

Bu durumda aşağıdaki uyarıyı alırsınız.

Şekil 16. ForeignKeyConstraint durumu.

Bu durumda Yes derseniz buradaki değer otomatik olarak 1000 yapılır. İşte bu olay DataRelation nesnemizin becerisidir. Değerli okurlarım uzun ama bir okadarda faydalı olduğuna inandığım bir makalemizin daha sonuna geldik. Hepinize mutlu günler dilerim.

Strongly Typed DataSet - 2 (Kuvvetle Türlendirilmiş Veri Kümeleri)

jaja — Sat, 05 Jan 2008 12:50:14 +0000

Bir önceki makalemizde, Kuvvetle Türlendirilmiş Veri Kümelerinin ne olduğunu ve nasıl oluşturulduğunu incelemiştik. Bu makalemizde ise, bir türlendirilmiş veri kümesi yardımıyla satır ekleme, arama, düzenleme ve silme gibi işlemlerin nasıl yapılacağını inceleyeceğiz. Bu amaçla işe basit bir windows uygulaması ile başlıyoruz. Bu uygulamamızda kolaylık olması açısından Kuvvetle Türlendirilmiş Veri Kümemizi, Visual Studio.NET ortamında oluşturdum. Uygulamamızda, Makale isimli sql tablomuzu kullanacağız. Uygulamamızın formu izleyen şekildeki gibi olucak.

Şekil 1. Form Tasarımımız.

Kullanıcı, Ekle başlıklı butona tıkladığında, textBox kontrollerine girmiş olduğu değerlerden oluşan yeni satırımız, dataTable’ımıza eklenmiş olucak. Bu işlemi gerçekleştiren kodlar aşağıda verilmiştir.

private void btnEkle_Click(object sender, System.EventArgs e) {

dsMakale.MakaleRow dr; /* Yeni bir satır tanımlanıyor. MakaleRow bir DataRow tipidir ve bizim dsMakale isimli Kuvvetle Türlendirilmiş Veri Kümesi sınıfımızda yer almaktadır.*/

dr=mk.Makale.NewMakaleRow(); /* MakalNewRow ile dr isimli MakaleRow nesnemizin, Makale isimli DataTable’ımızda yeni ve boş bir satıra referans etmesi sağlanıyor. */

dr.Konu=txtKonu.Text; /* Veriler yeni satırımızın ilgili alanlarına yerleştiriliyor. */

dr.Tarih=Convert.ToDateTime(txtTarih.Text);

dr.Adres=txtAdres.Text;

mk.Makale.AddMakaleRow(dr); /* Son olarak AddMakaleRow metodu ile oluşturulan yeni satır dataTable’ımıza ekleniyor.*/

}

Bu teknikte dikkat edicek olursanız Kuvvetle Türlendirilmiş Veri Kümemize ait metodlar ve nesneler kullanılmıştır. Örneğin, bir DataTable nesnesi ile referans edilen bellek bölgesindeki tabloya, yeni bir satır eklemek için öncelikle yeni bir DataRow nesnesi tanımlarız. Sonra bu DataRow nesnesini boş bir satır olacak şekilde DataTable nesnemiz için oluştururuz. Daha sonra bu DataRow nesnesinde her bir alan için yeni verileri ekleriz. Son olarakta bu oluşturulan yeni DataRow nesnesini DataTable’ımıza ekleriz. Böylece, DataTable nesnemizin işaret ettiği tabloya yeni bir satır eklemiş oluruz. Bu teknik klasik olarak Türlendirilmemiş Veri Kümelerini kullandığımız örneklerde aşağıdaki kodlar ile gerçekleştirimektedir.

DataRow drKlasik;

drKlasik=ds.Tables[0].NewRow();

drKlasik[1]=txtKonu.Text;

drKlasik[2]=Convert.ToDateTime(txtTarih.Text);

drKlasik[3]=txtAdres.Text;

ds.Tables[0].Rows.Add(drKlasik);

Gördüğünüz gibi teknik olarak iki yaklaşımda aynıdır. Ancak, aralarındaki farkı anlamak için kullanılan ifadelere yakından bakmamız yeterlidir. Herşeyden önce Kuvvetle Türlendirilmiş Veri Kümelerini kullanmak, kod yazarken programcıya daha anlaşılır gelmektedir. Dilerseniz, bu iki tekniği aşağıdaki tablo ile karşılaştıralım.

UnTyped Dataset Tekniği	Typed DataSet Tekniği
Yeni Bir Satır Tanımlamak
DataRow drKlasik;	dsMakale.MakaleRow dr; Görüldüğü gibi intelliSense özelliği sayesinde, dsMakale dataSet’inden sonra yeni bir DataRow nesnesi oluşturmak için gerekli söz dizimini bulmak ve anlamak son derece kolay.
Tanımlanan Yeni Satırı Oluşturmak
drKlasik=ds.Tables[0].NewRow();	dr=mk.Makale.NewMakaleRow(); Görüldüğü gibi, Typed DataSet sınıfımız yardımıyla tanımlanan yeni satırı oluşturmak için kullanacağımız söz dizimi çok daha okunaklı ve anlamlı.
Alanlara Verileri Aktarmak
drKlasik[1]=txtKonu.Text; drKlasik[2]=Convert.ToDateTime(txtTarih.Text); drKlasik[3]=txtAdres.Text;	dr.Konu=txtKonu.Text; dr.Tarih=Convert.ToDateTime(txtTarih.Text); dr.Adres=txtAdres.Text; Bir Type DataSet üzerinden oluşturduğumuz DataRow nesnesinin alanlarına veri aktarırken hangi alanların olduğunu kolayca gözlemleyebiliriz. Üstelik bu biçim, kodumuza daha kolay okunurluk ve anlam kazandırır.
Oluşturulan Satırın Tabloya Eklenmesi
ds.Tables[0].Rows.Add(drKlasik);	mk.Makale.AddMakaleRow(dr); NewMakaleRow metoduna ulaşmak gördüğünüz gibi daha kolaydır.

Tablo 1. Türlendirilmiş (Typed) ve Türlendirilmemiş (UnTyped) Veri Kümelerinde Satır Ekleme İşlemlerinin Karşılaştırılması.

Her iki teknik arasında kavramsal olarak fark bulunmamasına rağmen, uygulanabilirlik ve kolaylık açısından farklar olduğunu görüyoruz. Bu durum verileri ararken, düzenlerken veya silerkende karşımıza çıkmaktadır. Şimdi uygulamamızda belli bir satırı nasıl bulacağımızı inceleyelim. Kullanıcı Bul başlıklı butona tıkladığında txtMakaleID textBox kontrolüne girdiği değerdeki satır bulunacak ve bulunan satıra ait alan verileri, formumuzdaki diğer textBox kontrollerine yüklencek. Arama işleminin PrimaryKey üzerinden yapıldığınıda belirtelim. Şimdi kodlarımızı yazalım.

private void btnBul_Click(object sender, System.EventArgs e) {

dsMakale.MakaleRow drBulunan; /* Arama sonucu bulunan satırı tutacak DataRow nesnemiz tanımlanıyor. */

drBulunan=mk.Makale.FindByID(Convert.ToInt32(txtMakaleID.Text)); /* FindByID metodu, Türlendirilimiş Veri Kümemizdeki tablomuzun Primary Key alanı üzerinden arama yapıyor ve sonucu drBulunan DataRow(MakaleRow) nesnemize atıyor. */

if(drBulunan!=null) /* Eğer aranan satır bulunursa drBulunan değeri null olmayacaktır. */

{

txtKonu.Text=drBulunan.Konu; /* Bulunan satıra ait alan verileri ilgili kontrollere atanıyor. */

txtTarih.Text=drBulunan.Tarih.ToString();

txtAdres.Text=drBulunan.Adres;

}

else

{

MessageBox.Show(”Aranan Makale Bulunamadı”);

}

Bu arama tekniğinin, türlendirilmemiş veri kümelerindeki arama tekniğine göre çok farklı bir özelliği vardır. Klasik yöntemde bir DataTable üzerinden arama yaparken Find metodunu kullanırız.

Şekil 3. Klasik Find metodu.

Görüldüğü gibi Find metodu, PrimaryKey değerini alır ve bu değeri kullanarak, tablonun PrimaryKey alanı üzeriden arama yapar. Oysa örneğimizde kullandığımız Türlendirilmiş Veri Kümesine ait Makale DataTable nesnesinin Find metodu isim değişikliğine uğrayrak FindByID haline dönüşmüştür. Nitekim, bu yeni DataTable nesnesi hangi alanın PrimaryKey olduğunu bilir ve metodun ismini buna göre değiştirerek arama kodunu yazmamızı son derece kolaylaştırır.

Şekil 4. FindByID metodu;

Diğer yandan, Klasik Find metodumuz, key parametresini object türünden alırken, FindByID metodumuz PrimaryKey alanının değeri ne ise, parametreyi o tipten alır. Buda FindByID metodunun, klasik Find metodundanki object türünden dolayı, daha performanslı çalışmasına neden olur.

Şekil 5. FindByID metodunda parametre tipi.

Diğer yandan aynı işi yapan bu metodlar arasındaki fark birden fazla Primary Key alanına sahip olan tablolarda daha çok belirginleşir. Söz gelimi, Sql sunucusunda yer alan Northwind veri tabanındaki, Order Details tablosunun hem OrderID alanı hemde ProductID alanı Primary Key’dir. Dolayısıyla bu iki alan üzerinden arama yapmak istediğimizde klasik Find metodunu aşağıdaki haliyle kullanırız.

DataRow drBulunan;

drBulunan = dt.Find(new objcet[]{10756,9);

Oysaki bu tabloyu Türlendirilmiş Veri Kümesi üzerinden kullanırsak kod satırları aşağıdakine dönüşür.

drBulunan=ds.SiparisDetay.FindByOrderIDProductID(10756,9);

Gelelim verilerin düzenlenmesi işlemine. Şimdi uygulamamızda bulduğumuz satıra ait verileri textBox kontrollerine aktarıldıktan sonra, üzerlerinde değişiklik yaptığımızda bu değişikliklerin DataTable’ımıza nasıl yansıtacağımıza bakalım. Normal şartlarda, Türlendirilmemiş Veri Kümesi üzerindeki bir DataTable’a ait herhangibir satırda yapılan değşiklikler için, güncel DataRow nesnesine ait BeginEdit ve EndEdit metodları kullanılmaktadır. Oysaki Türlendirilmiş Veri Kümelerindenki satırlara ait alanlar birer özellik olarak tutulduklarından, sadece bu özelliklere yeni değerlerini atamamız yeterli olmaktadır. Bu veri kümesinin bir sınıf şeklinde tutuluyor olmasının sağlamış olduğu güçtür. Bu nedenle Türlendirilmiş Veri Kümeleri Strongly takısını haketmektedir. Dilerseniz uygulamamızda arama sonucu elde ettiğimiz bir satıra ait alan değerlerini güncelleyeceğimiz kod satırlarını yazalım.

private void btnDegistir_Click(object sender, System.EventArgs e) {

drBulunan.Konu=txtKonu.Text;

drBulunan.Adres=txtAdres.Text;

drBulunan.Tarih=Convert.ToDateTime(txtTarih.Text);

}

Şimdi uygulamamızı çalıştıralım. ID değeri 6 olan satırı bulalım. Daha sonra bu satırdaki bazı veileri değiştirelim ve Degistir başlıklı butona tıklayalım. Değişikliklerin hemen gerçekleştiğini ve DataGrid kontrolünede yansıdığını görürüz.

Şekil 6. ID=6 olan satır bulunuyor.

Şekil 7. Güncel Satır Verileri Değiştiriliyor.

Son olarak satır silme işlemini inceleyelim. Bu amaçla RemoveMakaleRow metodunu kullanacağız. Elbette bu metod, örneğimizde oluşturduğumuz Kuvvetle Türlendirilmiş Veri Kümemizin sınıfı içinde yeniden yazılmış bir metoddur ve sınıfımız içindeki prototipide şu şekildedir.

public void RemoveMakaleRow(MakaleRow row) {

this.Rows.Remove(row);

}

Açıkçası yaptığı işlem sınıfın Rows koleksiyonundan row parameteresi ile gelen satırı çıkartmaktır. Uygulamamızda ise bu metodu aşağıdaki şekilde kullanırız.

private void btnSil_Click(object sender, System.EventArgs e) {

mk.Makale.RemoveMakaleRow(drBulunan);

}

Bu metod parametre olarak aldığı satırı tablodan çıkartır.

Strongly Typed DataSet - 1 (Kuvvetle Türlendirilmiş Veri Kümeleri)

jaja — Sat, 05 Jan 2008 12:49:01 +0000

Bugünkü makalemizde kuvvetle türlendirilmiş veri kümelerinin ne olduğunu ve nasıl oluşturulduklarını incelemeye çalışacağız. Kuvvetle türlendirilmiş veri kümelerini tanımlamadan önce, aşağıdaki kod satırının incelemekle işe başlayalım.

textBox1.Text=dsMakale1.Tables[”Makale”].Rows[3][”Konu”].ToString();

Bu satır ile, dsMakale isimli dataSet nesnemizin bellekte işaret ettiği veri bölgesinde yer alan DataTable’lardan Makale tablosuna işaret edenin, 4ncü satırındaki Konu alanının değeri alınarak, TextBox kontrolümüzün text özelliğine atanmaktadır. Şimdide aşağıdaki kod satırını ele alalım.

textBox1.Text=rsMakale.Fields(”Konu”).Value

Bu ifade eski dostumuz ADO daki rsMakale isimli recordSet’i kullanarak, Konu isimli alanın değerine ulaşmıştır. Dikkat edicek olursanız bu iki ifade arasında uzunluk açısından belirgin bir fark vardır. İkinci yazım daha kolaydır. Zaten bu nedenle, ADO.NET’i öğrenen programcıların ilk başta en çok karşılaştıkları zorluk, bu kod yazımının uzunluğu olmuştur. Bununla birlikte, ADO.NET’ in XML tabanlı bir mimariye sahip olması, karşımıza Kuvvetle Türlendirilmiş Veri Kümelerini çıkarmaktadır. Microsfot.NET mimarları, programlarımızda aşağıdakine benzer daha kısa ifadelerin kullanılabilmesi amacıyla, Kuvvetle Güçlendirilmiş Veri Kümeleri kavramını ADO.NET’e yerleştirmiştir.

textBox1.Text=dsTypedMakale.Makale[3].Konu.ToString();

Bu ifade ilk yazdığımız ifadeye göre çok daha kısadır. Peki bu nasıl sağlanmıştır. dsTypedMakale isimli DataSet nesnemiz aslında Kuvvetle Türlendirilmiş Veri Kümemizin ta kendisidir. Bu noktada Kuvvetle Türlendirilmiş Veri Kümesi’nin ne olduğunu tanımlayabiliriz.

Bir Strongly Typed DataSet ( Kuvvetle Türlendirilmiş Veri Kümesi ), DataSet sınıfından türetilmiş, programcı tarafından belirtilen bir xml schema sınıfını baz alan, veri bağlantılarının özelleştirilip yukarıdaki gibi kısa yazımlar ile erişimlere imkan sağlayan, özelleştirilmiş bir DataSet sınıfıdır.

Bu geniş kavramı anlamak için elbette en kolay yol örneklendirmek olucak. Ancak bundan önce Kuvvetle Türlendirilmiş Veri Kümemizin nasıl oluşturacağımızı görelim. Bunun için elimizde iki yol var. Yollardan birisi, komut satırından XSD.exe XML Schema Defination Tool’unu kullanmak. Bu yol biraz daha zahmetli olmakla birlikte Visual Studio.NET’e olan gereksinimi kaldırdığı için zaman zaman tercih edilir. Diğer yolumuz ise Kuvvetle Türlendirilmiş Veri Kümemizi Visual Studio.NET ortamında oluşturmak. Yollardan hangisini seçersek seçelim, Kuvvetle Türlendirilmiş Veri Kümemizin oluşturulması için bize mutlaka bir xml schema dosyası (xsd uzantılı) gerekiyor. Çünkü Kuvvetle Türlendirilmiş Veri Kümemiz, bir xml schema dosyası baz alınarak oluşturulmaktadır. Şimdi dilerseniz komut satırı yardımıyla bir Kuvvetle Türlendirilmiş Veri Kümesinin nasıl oluşturulacağını inceleyelim. Bunun için öncelikle biraz kod yazmamız gerekecek. İzleyen kodlar ile, bir DataSet’i gerekli tablo bilgileri ile yükleyecek ve daha sonra bu DataSet’e ait xml schema bilgilerini, DataSet sınıfına ait WriteXmlSchema metodu ile bir xsd dosyasına aktaracağız. Örneğin basit olması amacıyla bir console uygulaması oluşturalım.

using System;

using System.Data;

using System.Data.SqlClient;

namespace TypeDataSet2

{

class Class1

{

static void Main(string[] args)

{

SqlConnection conFriends=new SqlConnection(”data source=localhost;initial catalog=Friends;integrated security=sspi”);

SqlDataAdapter da=new SqlDataAdapter(”Select * From Makale”,conFriends);

DataSet dsMakale=new DataSet(”Makaleler”);

conFriends.Open();

da.FillSchema(dsMakale,SchemaType.Source,”Makale”);

conFriends.Close();

dsMakale.WriteXmlSchema(”Makaleler.xsd”);

}

Yukarıdaki kodları kısaca açıklayalım. Burada Sql sunucumuzda yer alan Friends isimli veritabanına bağlanıyor ve Makale isimli tabloya ait schema bilgilerini DataSet nesnemize yüklüyoruz. Daha sonra ise, DataSet nesnemizin WriteXmlSchema metodu ile, DataSet’in yapısını xml tabanlı schema dosyası olarak ( Makaleler.xsd ) sisteme kaydediyoruz. İşte Kuvvetle Türlendirişmiş Veri Kümemizi bu xsd uzantılı schema dosyası yardımıyla oluşturacağız. Sistemizde uygulamamızı oluşturduğumuz yerdeki Debug klasörüne baktığımızda, aşağıdaki görüntüyü elde ederiz.

Şekil 1. XML Schema Dosyamız.

Şimdi .NET Framework’ün XSD.exe aracını kullanarak, bu schema dosyasından Kuvvetle Türlendirilmiş Veri Kümemizi temsil edicek sınıfı oluşturalım. Bunun için, komut satırında aşağıdaki satırı yazarız.

Şekil 2. Kuvvetle Türlendirilmiş Veri Kümesi sınıfının oluşturulması.

Burada görüldüğü gibi, xsd schema dosyamızdan, Kuvvetle Türlendirilmiş Veri Kümesi sınıfımız (Makaleler.cs) oluşturulmuştur. xsd aracındaki /d parametresi, sınıfımızın DataSet sınıfından türetileceğini belirtmektedir. Şimdi Debug klasörümüze tekrar bakıcak olursak, Kuvvetle Türlendirilmiş Veri Kümesi sınıfımızın oluşturulmuş olduğunu görürüz.

Şekil 3. Kuvvetle Türlendirilmiş Veri Kümesi Sınıfımız.

Peki bu oluşturduğumuz Kuvvetle Türlendirilmiş Veri Kümesi sınıfını uygulamamızda nasıl kullanacağız. Bu oldukça basit. Yeni DataSet nesnemizi, Makaleler.cs sınıfından türeteceğiz. Aşağıdaki kodu inceleyelim.

using System; using System.Data;

using System.Data.SqlClient;

namespace TypeDataSet2

{

class Class1

{

static void Main(string[] args)

{

SqlConnection conFriends=new SqlConnection(”data source=localhost;initial catalog=Friends;integrated security=sspi”);

SqlDataAdapter da=new SqlDataAdapter(”Select * From Makale”,conFriends);

conFriends.Open();

Makaleler dsTypedMakale=new Makaleler(); /* Kuvvetle Türlendirilmiş Veri Kümesi sınıfımızdan bir DataSet nesnesi türetiyoruz.*/

da.Fill(dsTypedMakale.Makale); /* SqlDataAdapter nesnemiz yardımıyla, yeni dataSet’imizdeki Makale isimli tablomuzu Sql sunucumuzda yer alan Makale isimli tablonun verileri ile yüklüyoruz. */

Console.WriteLine(dsTypedMakale.Makale[3].Konu.ToString()); /* Yeni DataSet nesnemizdeki Makale tablosunun 4ncü satırındaki Konu alanının değerine erişiyoruz. */

conFriends.Close();

}

Uygulamamızı çalıştırdığımızda aşağıdaki sonu elde ederiz.

Şekil 4. Uygulamanın sonucu.

Görüldüğü gibi bir Kuvvetle Türlendirilmiş Veri Kümesi oluşturmak ve kullanmak son derece basit. Dilerseniz xsd aracı ile oluşturduğumuz Makaleler.cs isimli Kuvvetle Türlendirilmiş Veri Kümesi sınıfımızı ele alalım. Bu sınıfı oluşturduğunuzda mutlaka incelemenizi tavsiye ederim. Çok uzun bir dosya olduğunundan tüm kod satırlarına burada yer vermiyorum. Ancak dikkatimizi çekicek bir kaç üyeyi göstereceğim. Öncelikle sınıf tanımımıza bir göz atalım.

public class Makaleler : DataSet {

…

}

Daha öncedende söylediğimiz gibi Kuvvetle Türlendirilmiş Veri Kümesi sınıfları DataSet sınıfından türetilmektedir. Yeni dataSet sınıfımız, içereceği tablo, alan, kısıtlama, ilişki gibi bilgileri bir xsd dosyasından almaktaydı. Biz xsd dosyasını oluştururken, DataSet’e Makale isimli tablonun yapısını yüklemiştik. Bu durumda, Kuvvetle Türlendirilmiş Veri Kümesi sınıfımız içinde, Makale isimli tablomuzu belirten yeni bir DataTable üyesi kullanılır.

private MakaleDataTable tableMakale;

Burada MakaleDataTable, DataTable sınfının özelleştirilmiş bir haline sunar.

protected Makaleler(SerializationInfo info, StreamingContext context) {

string strSchema = ((string)(info.GetValue(”XmlSchema”, typeof(string))));

if ((strSchema != null))

{

DataSet ds = new DataSet();

ds.ReadXmlSchema(new XmlTextReader(new System.IO.StringReader(strSchema)));

if ((ds.Tables[”Makale”] != null))

{

this.Tables.Add(new MakaleDataTable(ds.Tables[”Makale”]));

}

…

}

…

public MakaleDataTable Makale

{

get

{

return this.tableMakale;

}

…

Görüldüğü gibi MakaleDataTable isminde yeni bir sınıfımız vardır. Bu sınıf Makale isimli tabloyu tüm elemanları ile tanımlar. Bunun için, bu sınıf DataTable sınıfından türetilir. Makale tablosundaki her bir alan bu sınıf içerisinde birer özellik haline gelir. Bununla birlikte bu yeni DataTable sınıfı, alan ekleme, alan silme gibi metodlar ve pek çok olayıda tanımlar. Diğer yandan pek çok DataTable metoduda bu sınıf içinde override edilir.

public class MakaleDataTable : DataTable, System.Collections.IEnumerable {

private DataColumn columnID;

private DataColumn columnKonu;

private DataColumn columnTarih;

private DataColumn columnAdres;

…

public int Count

{

get

{

return this.Rows.Count;

}

internal DataColumn IDColumn

{

get

{

return this.columnID;

}

public MakaleRow this[int index]

{

get

{

return ((MakaleRow)(this.Rows[index]));

}

public event MakaleRowChangeEventHandler MakaleRowChanged;

…

public void AddMakaleRow(MakaleRow row)

{

this.Rows.Add(row);

}

public MakaleRow AddMakaleRow(string Konu, System.DateTime Tarih, string Adres)

{

MakaleRow rowMakaleRow = ((MakaleRow)(this.NewRow()));

rowMakaleRow.ItemArray = new object[] {null,Konu,Tarih,Adres};

this.Rows.Add(rowMakaleRow);

return rowMakaleRow;

}

…

}

Buraya kadar , komut satırı yardımıyla ve kod yazarak bir Kuvvetle Türlendirilmiş Veri Kümesinin nasıl oluşturulacağını gördük. Bu teknikteki adımları gözden geçirmek gerekirse izlememiz gereken yol şöyle olucaktır.

Şekil 5. Kuvvetle Türlendirilmiş Veri Kümesi Oluşturulma Aşamaları

Şimdide, Kuvvetle Türlendirilmiş Veri Kümesi sınıfını, Visual Studio.NET ortamında nasıl geliştireceğimizi görelim. Bu daha kolay bir yoldur. Öncelikle Visual Studio.Net ortamında bir Windows Uygulaması açalım. Daha sonra, Server Explorer penceresinden Makale isimli tablomuzu Formumuza sürükleyelim.

Şekil 6. Server Explorer ile Makale Tablosunun Forma Alınması

Bu durumda formumuzda otomatik olarak SqlConnection ve SqlDataAdapter nesnelerimiz oluşur.

Şekil 7. SqlConnection ve SqlDataAdapter otomatik olarak oluşturulur.

Şimdi SqlDataAdapter nesnemizin özelliklerinden Generate DataSet’e tıkladığımızda karşımıza aşağıdaki pencere çıkacaktır.

Şekil 8. DataSet oluşturuluyor.

Burada DataSet nesnemiz otomatik olarak oluşturulacaktır. DataSet’imize dsMakale adını verelim ve OK başlıklı butona basalım. Şimdi Solution Explorer’da Show All Files seçeneğine tıklarsak, Kuvvetle Türlendirilmiş Veri Kümesi sınıfımızın oluşturulduğunu görürüz.

Şekil 9. Kuvvetle Türlendirilmiş Veri Kümesi

Artık uygulamamızda bu sınıfı kullanabiliriz. İşte örnek kod satırlarımız.

private void Form1_Load(object sender, System.EventArgs e) {

dsMakale mk=new dsMakale();

sqlDataAdapter1.Fill(mk.Makale);

textBox1.Text=mk.Makale[3].Konu.ToString();

}

Uygulamamızı çalıştırdığımızda aşağıdaki sonucu elde ederiz.

Şekil 10. Uygulamanın Sonucu.

Temsilci(Delegate) Kavramına Giriş

jaja — Sat, 05 Jan 2008 12:47:47 +0000

Bugünkü makalemizde, C# programlama dilinde ileri seviye kavramlardan biri olan Temsilcileri(delegates) incelemeye başlayacağız. Temsilciler ileri seviye bir kavram olmasına rağmen, her seviyden C# programcısının bilmesi gereken unsurlardandır. Uygulamalarımızı temsilciler olmadan da geliştirebiliriz. Ancak bu durumda, yapamıyacaklarımız, yapabileceklerimizin önüne geçecektir. Diğer yandan temsilcilerin kullanımını gördükçe bize getireceği avantajları daha iyi anlayacağımız kanısındayım. Bu makalemizde temsilcileri en basit haliyle anlamaya çalışıcağız.

Temsilci (delegate), program içerisinde bir veya daha fazla metodu gösteren(işaret eden), referans türünden bir nesnedir. Programlarımızda temsilciler kullanmak istediğimizde, öncelikle bu temsilcinin tanımını yaparız. Temsilci tanımları, arayüzlerdeki metod tanımlamaları ile neredeyse aynıdır. Tek fark delegate anahtar sözcüğünün yer almasıdır. Bununla birlikte, bir temsilci tanımlandığında, aslında işaret edebileceği metod(ların) imzalarınıda belirlemiş olur. Dolayısıyla, bir temsilciyi sadece tanımladığı metod imzasına uygun metodlar için kullanabiliceğimizi söyleyebiliriz. Temsilci tanımları tasarım zamanında yapılır. Bir temsilciyi, bir metodu işaret etmesi için kullanmak istediğimizde ise, çalışma zamanında onu new yapılandırıcısı ile oluşturur ve işaret etmesini istediğimiz metodu ona parametre olarak veririz. Bir temsilci tanımı genel haliyle, aşağıdaki şekildeki gibidir.

Şekil 1. Temsilci tanımlaması.

Şekildende görüldüğü gibi, temsilciler aslında bir metod tanımlarlar fakat bunu uygulamazlar. İşte bu özellikleri ile arayüzlerdeki metod tanılamalarına benzerler. Uygulamalarımızda, temsilci nesneleri ile göstermek yani işaret etmek istediğimiz metodlar bu imzaya sahip olmalıdır. Bildiğiniz gibi metod imzaları, metodun geri dönüş tipi ve aldığı parametreler ile belirlenmektedir.

Bir temsilcinin tanımlanması, onu kullanmak için yeterli değildir elbette. Herşeyden önce bir amacımız olmalıdır. Bir temsilciyi çalışma zamanında oluşturabiliriz ve kullanabiliriz. Bir temsilci sadece bir tek metodu işaret edebileceği gibi, birden fazla metod için tanımlanmış ve oluşturulmuş temsilcileride kullanabiliriz. Diğer yandan, tek bir temsilcide birden fazla temsilciyi toplayarak bu temsilcilerin işaret ettiği, tüm metodları tek bir seferde çalıştırma lüksünede sahibizdir. Ancak temsilciler gerçek anlamda iki amaçla kullanılırlar. Bunlardan birincisi olaylardır(events). Diğer yandan, bugünkü makalemizde işleyeceğimiz gibi, bir metodun çalışma zamanında, hangi metodların çalıştırılacağına karar vermesi gerektiği durumlarda kullanırız. Elbette bahsetmiş olduğumuz bu amacı, herhangibir temsilye ihtiyaç duymadan da gerçekleştirebiliriz. Ancak temsilcileri kullanmadığımızda, bize sağladığı üstün programlama tekniği, kullanım kolaylığı ve artan verimliliğide göz ardı etmiş oluruz.

Şimdi dilerseniz bahsetmiş olduğumuz bu amaçla ilgili bir örnek verelim ve konuyu daha iyi kavramaya çalışalım. Örneğin, personelimizin yapmış olduğu satış tutarlarına göre, prim hesabı yapan ve ilgili yerlere bu değişiklikleri yazan bir projemiz olsun. Burada primlerin hesaplanması için değişik katsayılar, yapılan satışın tutarına göre belirlenmiş olabilir. Örneğin bu oranlar düşük, orta ve yüksek olarak tanımlanmış olsun. Personel hangi gruba giriyorsa, metodumuz ona uygun metodu çağırsın. İşte bu durumda karar verici metodumuz, çalıştırabileceği metodları temsil eden temsilci nesnelerini parametre olarak alır. Yani, çalışma zamanında ilgili metodlar için temsilci nesneleri oluşturulur ve karar verici metoda , hangi metod çalıştırılacak ise onun temsilcisi gönderilir. Böylece uygulamamız çalıştığında, tek yapmamız gereken hangi metodun çalıştırılması isteniyorsa, bu metoda ilişkin temsilcinin, karar verici metoda gönderilmesi olacaktır.

Oldukça karışık görünüyor. Ancak örnekleri yazdıkça daha iyi kavrayacağınıza inanıyorum. Şimdiki örneğimizde, temsilcilerin tasarım zamanında nasıl tanımlandığını, çalışma zamanında nasıl oluşturulduklarını ve karar verici bir metod için temsilcilerin nasıl kullanılacağını incelemeye çalışacağız.

using System;

namespace Delegates1
{
public class Calistir
{
public static int a;
public delegate void temcilci(int deger); /* Temsilci tanımlamamızı yapıyoruz. Aynı zamanda temsilcimiz , değer döndürmeyen ve integer tipte tek bir parametre alan bir metod tanımlıyor. Temsilcimizin adı ise temsilci.*/ * Şimdi bu temsilciyi kullacanak bir metod yazıyoruz. İşte karar verici metodumuz budur. Dikkat ederseniz metodumuz parametre olarak, temsilci nesnemiz tipinden bir temsilci(Delegate) alıyor. Daha sonra metod bloğu içinde, parametre olarak geçirilen bu temsilcinin işaret ettiği metod çağırılıyor ve bu metoda parametre olarak integer tipte bir değer geçiriliyor. Kısaca, metod içinden, temsilcinin işaret ettiği metod çağırılıyor. Burada, temsilci tanımına uygun olan metodun çağırılması garanti altına alınmıştır. Yani, programın çalışması sırasında, new yapılandırıcısı kulllanarak oluşturacağımız bir temsilci(delegate), kendi metod tanımı ile uyuşmayan bir metod için yaratılmaya çalışıldığında bir derleyici hatası alacağızdır. Dolayısıyla bu, temsilcilerin yüksek güvenlikli işaretçiler olmasını sağlar. Bu , temsilcileri, C++ dilindeki benzeri olan işaretçilerden ayıran en önemli özelliktir. */

public void Metod1(Calistir.temcilci t)
{
t(a);
}
}

class Class1
{

/* IkıKat ve UcKat isimli metodlarımız, temsilcimizin programın çalışması sırasında işaret etmesini istediğimiz metodlar. Bu nedenle imzaları, temsilci tanımımızdaki metod imzası ile aynıdır. */

public static void IkiKat(int sayi)
{
sayi=sayi*2;
Console.WriteLine(”IkiKat isimli metodun temsilcisi tarafindan çagirildi.”+sayi.ToString());
}

public static void UcKat(int sayi)
{
sayi=sayi*3;
Console.WriteLine(”UcKat isimli metodun temsilcisi tarafindan çagirildi.”+sayi.ToString());
}

static void Main(string[] args)
{

/* Temsilci nesnelerimiz ilgili metodlar için oluşturuluyor. Burada, new yapılandırıcısı ile oluşturulan temsilci nesneleri parametre olarak, işaret edecekleri metodun ismini alıyorlar. Bu noktadan itibaren t1 isimli delegate nesnemiz IkiKat isimli metodu, t2 isimli delegate nesnemizde UcKat isimli metodu işaret ediceklerdir. */

Calistir.temcilci t1=new Delegates1.Calistir.temcilci(IkiKat);

Calistir.temcilci t2=new Delegates1.Calistir.temcilci(UcKat);

Console.WriteLine(”1 ile 20 arası değer girin”);

Calistir.a=System.Convert.ToInt32(Console.ReadLine());

Calistir c= new Calistir();

/* Kullanıcının Console penceresinden girdiği değer göre, Calistir sınıfının a isimli integer tipteki değerini 10 ile karşılaştırılıyor. 10 dan büyükse, karar verici metodumuza t1 temsilcisi gönderiliyor. Bu durumda Metod1 isimli karar verici metodumuz, kendi kod bloğu içinde t1 delegate nesnesinin temsil ettiği IkıKat metodunu, Calistir.a değişkeni ile çağırıyor. Aynı işlem tarzı t2 delegate nesnesi içinde geçerli.*/

if(Calistir.a>=10)
{
c.Metod1(t1);
}
else
{
c.Metod1(t2);
}
}
}
s}

Uygulamamızı çalıştıralım ve bir değer girelim.

Şekil 2. Programın çalışmasının sonucu.

Bu basit örnek ile umarım temsilciler hakkında biraz olsun bilgi sahibi olmuşsunuzdur. Şimdi temsilciler ile ilgili kavramlarımıza devam edelim. Yukarıdaki örneğimiz ışığında temsilcileri programlarımızda temel olarak nasıl kullandığımızı aşağıdaki şekil ile daha kolay anlayabileceğimizi sanıyorum.

Şekil 3. Temsilcilerin Karar Verici metodlar ile kullanımı.

Yukarıdaki örneğimizde, her bir metod için tek bir temsilci tanımladık ve temsilcileri teker teker çağırdık. Bu Single-Cast olarak adlandırılmaktadır. Ancak programlarımız da bazen, tek bir temsilciye birden fazla temsilci ekleyerek, birden fazla metodu tek bir temsilci ile çalıştırmak isteyebiliriz. Bu durumda Multi-Cast temsilciler tanımlarız. Şimdi multi-cast temsilciler ile ilgili bir örnek yapalım. Bu örneğimizde t1 isimli temsilcimiz, multi-cast temsilcimiz olucak.

using System;
namespace Delegates2
{
public class temsilciler
{
public delegate void dgTemsilci(); /* Temsilcimiz tanımlanıyor. Geri dönüş değeri olmayan ve parametre almayan metodları temsil edebilir. */

/* Metod1, Metod2 ve Metod3 temsilcilerimizin işaret etmesini istediğimiz metodlar olucaktır.*/
public static void Metod1()
{
Console.WriteLine(”Metod 1 çalıştırıldı.”);
}

public static void Metod2()
{
Console.WriteLine(”PI değeri 3.14 alınsın”);
}

public static void Metod3()
{
Console.WriteLine(”Mail gönderildi…”);
}

/* Temsilcilerimizi çalıştıran metodumuz. Parametre olarak gönderilen temsilciyi, dolayısıyla bu temsilcinin işaret ettiği metodu alıyor. */

public static void TemsilciCalistir(temsilciler.dgTemsilci dt)
{
dt(); /* Temsilcinin işaret ettiği metod çalıştırılıyor.*
}
}

class Class1
{
static void Main(string[] args)
{
/* Üç metodumuz içinde temsilci nesnelerimiz oluşturuluyor .*/

temsilciler.dgTemsilci t1=new Delegates2.temsilciler.dgTemsilci(temsilciler.Metod1);

temsilciler.dgTemsilci t2=new Delegates2.temsilciler.dgTemsilci(temsilciler.Metod2);

temsilciler.dgTemsilci t3=new Delegates2.temsilciler.dgTemsilci(temsilciler.Metod3);

Console.WriteLine(”sadece t1″);

temsilciler.TemsilciCalistir(t1);

Console.WriteLine(”—”);

/* Burada t1 temsilcimize, t2 temsilcisi ekleniyor. Bu durumda, t1 temsilcimiz hem kendi metodunu hemde, t2 temsilcisinin işaret ettiği metodu işaret etmeye başlıyor. Bu halde iken TemsilciCalistir metodumuza t1 temsilcisini göndermemiz her iki temsilcinin işaret ettiği metodların çalıştırılmasına neden oluyor.*/

t1+=t2;

Console.WriteLine(”t1 ve t2″);

temsilciler.TemsilciCalistir(t1);

Console.WriteLine(”—”);

t1+=t3; /* Şimdi t1 temsilcimiz hem t1, hem t2, hem de t3 temsilcilerinin işaret ettiği metodları işaret etmiş olucak.*/

Console.WriteLine(”t1,t2 ve t3″);

temsilciler.TemsilciCalistir(t1);

Console.WriteLine(”—”);

t1-=t2; /* Burada ise t2 metodunu t1 temsilcimizden çıkartıyoruz. Böylece, t1 temsilcimiz sadece t1 ve t3 temsilcilerini içeriyor. */
Console.WriteLine(”t1 ve t3″);

temsilciler.TemsilciCalistir(t1);

Console.WriteLine(”—”);
}
}
}

Uygulamamızı çalıştırdığımızda aşağıdaki sonucu elde ederiz.

Şekil 4. Multi-Cast temsilciler.

Web Servisleri ile Dosya Transferi Yapmak

jaja — Sat, 05 Jan 2008 12:46:59 +0000

Bu yazımda sizlere Xml Web Servisleri ve ASPdotNET ile basit bir dosya transfer uygulamasi yapmaya çalışacağız. İşe veritabanımızı oluşturmayla başlayalım :

1- ) SQL server da CsharpNedir adinda yeni bir veritabani olusturalim.
2- ) Olusturdugumuz bu veritabaninda ;

Yukardaki şekilde bir tablo oluşturduktan sonra Kayıt etme işlemi için aşağıdaki Stored Procedure’umuzu yazalım

3-)

CREATE Procedure sp_DosyaYukle
(
@Adi nvarchar(100),
@Turu nvarchar(50),
@Boyut int,
@Dosya image
)
AS
INSERT INTO tbl_Dosya(Adi,Turu,Boyut,Dosya)
VALUES (@Adi,@Turu,@Boyut,@Dosya)
GO

Yukardaki saklı yordamda ikkat ettiyseniz Tarih alanını yazmadım çünkü zaten kayit eklendiğinde mevcut bir tarih girilceği için yani her kayıtta bunu tabloyu olustururken varsayilan(default) değer olarak getdate() fonksiyonunu yazdim. Böylece program içinde ikinci bir defa kayıt etme işlemi ile uğraşmak zorunda kalmayacağım.

Yukardaki şekilde veritabanımız oluşturduktan sonra sıra web servisimizi yazmaya geldi. VS.NET editörümüzde C# dili ile bir web servisi projesi açalım. Projemizin adini CsharpNedir olarak verelim;

Daha sonra sql server sunucusuna erişim yapabilmek için web.config dosyasında tanımladığımız baglantı cümlesi anahtar kelimesine erişim yapabilmek için.

using System.Configuration

isimuzayını(namespace) ve sql server üzerine islem yapabilmek için ise

using System.Data.SqlClient

isimuzayını(namespace) ini referans olarak belirleyelim.

Şimdi veritabanina kayit eklemek için kullanacağımız metodumuzu yazalım.

[WebMethod(Description=”Veritabanina dosya yükleme yapabileceğiniz metod.”)]
public string DosyaYukle(string Adi,string Turu,int Boyut,byte[] Dosya)
{
string IslemSonucu = string.Empty;
SqlConnection baglanti = new SqlConnection(strCon);
SqlCommand komut = new SqlCommand();
komut.CommandText = “sp_DosyaYukle”;
komut.CommandType = CommandType.StoredProcedure;
komut.Connection = baglanti;

baglanti.Open();

#region sqlparametre lerin doldurulmasi

komut.Parameters.Add(new SqlParameter(”@Adi” ,SqlDbType.NVarChar,100
ParameterDirection.Input,false,0,0,”",DataRowVersion.Proposed,Adi));

komut.Parameters.Add(new SqlParameter(”@Turu” ,SqlDbType.NVarChar,50
ParameterDirection.Input,false,0,0,”",DataRowVersion.Proposed,Turu));

komut.Parameters.Add(new SqlParameter(”@Boyut” ,SqlDbType.Int,4
ParameterDirection.Input,false,0,0,”",DataRowVersion.Proposed,Boyut));

komut.Parameters.Add(new SqlParameter(”@Dosya” ,SqlDbType.Image,16
ParameterDirection.Input,false,0,0,”",DataRowVersion.Proposed,Dosya));

#endregion

try
{
komut.ExecuteNonQuery();
baglanti.Close();

return IslemSonucu = “Kayit yapilmistir”;
}
catch(Exception ex)
{
return IslemSonucu = “Hata olustur : ” + ex.Message;
}
}

Yukaridaki fonksiyon ile veritabanına kayıt yapıldı veya yapılmadıysa olusan hatayı string olarak göndürebilmesi için string türünde tanımladım. Niçin string olarak tanımladığımı konumuzun ilerleyen bölümünde açıklayacağım. Simdi metodumuzu inceleyelim. Veritabanımıza yükleyecegimiz dosyamızın adını, türünü, boyutunu ve dosyamızı kayıt edebilceğimiz parametrelerimizi yazdık. Daha sonra fonksiyon içinde sqlconnection sınıfından bir baglantı nesnesi kurduk daha sonra sqlcommand ile veritabanımızda belirttiğimiz bir storedprocedure’u işlem yapabilmek için

komut.CommandText = “sp_DosyaYukle”;
komut.CommandType = CommandType.StoredProcedure;
komut.Connection = baglanti;

Yukarıdaki SqlCommand nesnemizden türettigimiz komut nesnemizin CommandText özelliğine kullanmak istediğimiz stored procedure’umuzun adını, CommandType özelligine ise StoredProcedure, Text veya TableDirect türünü belirtiyoruz. Biz StoredProcedure kullandığımiz için StoredProcedure seçeneğini kullandık.

Ve kayıt işlemlerimizi yapmak için komut nesnemize parametre olarak alanlarımızı ve değerlerimizi yazıyoruz. Kayıt etme fonksiyonumuz bittikten sonra bilgileri görmek için geriye dataset döndürecek bir fonksiyon daha yazıyoruz.

[WebMethod(Description = “Kaydettiginizi veritabanina eklediginiz verileri dataset olarak islem yapabilirsiniz”)]
public DataSet DosyaGoster()
{
SqlConnection baglanti = new SqlConnection(strCon);
baglanti.Open();
SqlDataAdapter dataadapter = new SqlDataAdapter(”SELECT Adi,Boyut,Tarih FROM tbl_Dosya”,baglanti);
DataSet dset = new DataSet(”tbl_Dosya”);
dataadapter.Fill(dset,”tbl_Dosya”);
baglanti.Close();
return dset;
}

Şekil � 1

Yukarıdaki metod ile tbl_Dosya tablosundaki tüm kayitlari dset dataset nesnemize yüklüyoruz. Bu şekilde servisimiz bittikten sonra(Sekil - 1) projemize bir adet asp.net projesi ekleyelim. Projemizin adını CsharpNedirWebUI olarak belirleyelim.

Sayfa üzerinde kullanacağımız kontroller;

1 � 1 adet Label nesnesi
2 � 1 adet HtmlFile nesnesi
3 � 1 adet Buton nesnesi

4 � 1 adet Datagrid nesnesi (Sekil � 2 )

Şekil � 2

Yukarıdaki gibi nesnelerimizi form üzerine yerleştiriyoruz. Daha sonra projemize Solution explorer penceresinden Add WebReferance diyerek web servisimizi referans veriyoruz. (Şekil � 3)

Şekil � 3

Yukaridaki şekilde işaretlemiş oldugum yerlerde ilk önce CsharpNedirWebUI projemize Add WebReferance veriyoruz ben CsharpNedirWebServisi oalrak verdim daha sonra 2. seçenek te ise bu servisi proje içinde kullanabilmek için projemin adi �.� Referans verdiğim servisin adı şeklinde referans veriyorum yani

using CsharpNedirWebUI.CsharpNedirWebServisi;

şeklinde verdikten sonra;

proje içinde Servise erişim yapabilmek için

private DosyaTransferServisi servisim = null ;

şeklinde sayfa içinde her yerde kullanılabilir türde servisim nesnesini tanımlıyoruz.

Sayfa içinde kullanılacak Alert metodu için ;

public void Alert(string text)
{
AddStartupScript(”OnClick”, “alert(\”" + text + “\”);”);
}

private void AddStartupScript(string name, string script)
{
script = ““;
this.Page.RegisterStartupScript(name, script);
}

Servisimizde kayıt ekleme fonksiyonunu string olarak tanımlamamdaki sebep proje içinde bu servisi kullanırken bir alert ile veya messagebox ile geriye sonucu uyarı seklinde göstermesini saglamaktı.

Şimdi kaydet butonuna tıkladığımızda yazacağımız servisimize gidecek parametrelerimizi yazalım;

private void btnKaydet_Click(object sender, System.EventArgs e)
{
servisim = new DosyaTransferServisi();

if(flDosya.PostedFile != null)
{
HttpPostedFile dosyalar = flDosya.PostedFile;

string dosyaAdi = dosyalar.FileName;
string turu = dosyalar.ContentType;
int boyut = dosyalar.ContentLength;
byte[] dosya =new byte[boyut];

dosyalar.InputStream.Read(dosya,0,boyut);

string sonuc = servisim.DosyaYukle(System.IO.Path.GetFileName(dosyaAdi),turu,boyut,dosya);

Alert(sonuc);
}
}

Yukarıdaki metodumuzu yazdığımızda servisim.DosyaYukle fonksiyonuna flDosya nesnesinden seçtigimiz dosyanın, Adi,Tipi,Boyutu ve Dosya olarak belirttiğim değişkenlere atayarak bunu servis fonksiyonuna gönderiyorum. Gönderme işlemi sırasında servis işleniyor ve geriye dönebilecek iki sonuç string olarak tanımladığım değişkenime geliyor. Daha sonra bu sonuç değişkenini Alert metodunda kullanarak “kayıt edildi” veya “kayıt edilmedi” şeklinde bir uyarı alıyorum.

Yazım burada bitmiştir. Kısaca ne yaptığımızı açıklayacak olursak;

1- ) Web servislerini her yerde kullanabilirsiniz.

2- ) Web servislerine windows uygulamalarından erişim yaparken varsayılan olarak httpGet ve httpPost metodları kapalı olarak gelir. Bunu aşmanın yolu web.config dosyasında

tanımlamasını yapmamız gerekiyor ama microsoft bunu tavsiye etmiyor.

.NET Veri Sağlayıcıları (Data Providers)

jaja — Sat, 05 Jan 2008 12:46:10 +0000

Bugünkü makalemiz ile, ADONET ‘ te yer alan veri sağlayıcılarını inceleyeceğiz. Bildiğiniz gibi hepimiz uygulamalarımızda yoğun bir şekilde veri kaynaklarını kullanmaktayız. Normalde sistemimizde, bu veri kaynaklarına erişmek için kullanılan sistem sürücüleri vardır. Bu sürücüler, sistemimize dll kütüphaneleri olarak yüklenirler ve kendilerini sisteme kayıt ederler(register). Bu noktadan itibaren bu veri sürücülerinin içerdiği fonksiyonları kullanarak veritabanları üzerinde istediğimiz işlemleri gerçekleştirebiliriz. Kısaca, bu veri sürücüleri uygulamalarımız ile, veritabanı arasındaki iletişimi sağlarlar. Sistemizide yüklü olan programlara göre pek çok veri sürücüsüne sahip olabiliriz. Örneğin ODBC sürücüleri, SQL sürücüleri, Ole Db Jet sürücüleri ve bazıları.

ADO.NET ile veritabanı uygulamaları geliştirirken, bu sürücüler üzerinden veritabanlarına erişim sağlarız. Bu sebeple .Net Framework ‘te her bir veri sürücüsü için geliştirilmiş veri sağlayıcıları (data providers) vardır. Bu veri sağlayıcılarının görevi, uygulamalarımız ile veri sürücülerini bağlamak ve veri sürücülerindeki ilgili kütüphane fonksiyonlarını çalıştırarak veriler üzerinde işlem yapabilmemizi sağlamaktır. .Net Framework’ ün 1.1 sürümü aşağıdaki listede yer alan veri sağlayıcıları ile birlikte gelmektedir. .Net Framework’ün ilk sürümlerinde sadece Sql ve Ole Db veri sağlayıcıları varsayılan olarak yer almaktadır. Ancak 1.1 sürümü ile birlikte bu veri sağlayıcılarına, Oracle ve ODBC veri sağlayıcılarıda eklenmiştir.

.Net Framework Veri Sağlayıcıları

Data Provider For SQL Server

Data Provider For OLE DB

Data Provider For ODBC

Data Provider For Oracle

Tablo 1: .NET Veri Sağlayıcıları

Şimdi dilerseniz, bu veri sağlayıcıları kısaca incelemeye çalışalım.

SQL veri sağlayıcısına ait tüm üyeler, System.Data.SQLClient isim uzayında yer almaktadır. SQL veri sağlayıcısının en önemli özelliği, sql motoruna direkt sql api’si üzerinden erişim sağlayabilmesidir. Bu özellik ona diğer veri sağlayıcılarına göre daha yüksek performans kazandırır. Nitekim sql veri sağlayıcısı, sql server’a doğrudan ulaşmak için kendi iletişim protokolü olan TDS(Tabular Data Stream)’yi kullanmaktadır. Elbette bu özelliği ile, örneğin SqlDataReader nesnesinin kullanıldığı veri okuma yöntemlerinde, ole db veri kaynağına göre çok daha hızlı ve verimlidir. Nitekim aynı sql veri kaynaklarına ole db veri sağlayıcısı ilede erişmemiz mümkündür. Ama belirttiğimiz gibi performans ve verimlilik bu iki veri kaynağı için oldukça farklıdır.

Şekil 1. Sql Veri Sağlayıcımız.

Sql veri sağlayıcısı, Sql Server’ın 7 ve daha üstü versiyonlarını desteklemektedir. Bu nedenle 6.5 versiyonu ve daha öncesi için, Ole Db veri sağlayıcısını kullanmak zorundayız. Diğer yandan Sql veri sağlayıcısı MDAC(Microsoft Data Access Component)’ın 2.6 veya üstü sürümünün sistemimizde kurulu olmasını gerektirmektedir. Sql veri sağlayıcısı, sql server’ın 7.0 ve sonraki sürümlerinde özellikle çok katlı uygulamalarda yüksek verim ve performans sağlar.

Ole Db veri sağlayıcısı, Ole Db desteği veren tüm veri sürücüleri ile ilişki kurabilmektedir. Bunu yaparken, Ole Db Com nesnelerini kullanır. Aşağıdaki şekilde görüldüğü gibi, uygulamamızda ole db veri sağlayıcısı kullanarak, bir oledb veri kaynağına erişmek oldukça maliyetlidir. Bunun yanında ole db’yi destekleyen çok çeşitli veri kaynağı sürücülerinin olması ole db nin ürün yelpazesini genişliğini gösterir.

Şekil 2 . Ole Db Veri Sağlayıcısı

Ole Db veri sağlayıcısı Ole Db desteği veren her türlü veri sürücüsü ile çalışabilir. Aşağıda ole db veri sağlayıcısı ile kullanılabilen örnek Ole Db veri sürücüleri listelenmiştir.

Ole Db veri sağlayıcısının .net framework üyeleri, System.Data.OleDb isim uzayında yer alır. Çoğunlulkla bu veri sağlayıcısını Access tablolarına erişmek için uygulamalarımızda kullanmaktayız. Bununla bilrikte Paradox, dBASE, Excel, FoxPro,Oracle 7.3,Oracle8 gibi veri tablolarınada erişebiliriz. Diğer yandan Oracle sürücülerine ve ODBC sürücülerinede erişebiliriz. Ancak elbetteki, çok katlı uygulamalarda, sql veri sağlayıcısını veya oracle veri sağlayıcısını tercih etmemiz daha doğru olucaktır. Diğer yandan ole db veri sağlayıcısı, com servsileri ile veri sürücülerine eriştiği için, özellikle sql veri sağlayıcısına göre çok daha düşük bir performans sergiler. Ole Db veri kaynakları ile çalışan ole db veri sağlayıcısının , özellikle sql server’ın 6.5 ve önceki sürümlerinin kullanıldığı tek katlı ve çok katlı uygulamalarda kullanılması tercih edilir. Bununla birlikte, access tabloları ile çalışırken, çok katlı mimarilerin, bu veri tabloları üzerinden ole db sağlayıcıları ile oluşturulması microsoft otoriterlerince tavsiye edilmemektedir.

ODBC veri sağlayıcısı, Ole Db veri sağlayıcısı gibi, ODBC desteği veren sürücüler ile, ODBC Servis Component’lerini kullanarak iletişim kurar.

Şekil 3 . ODBC Veri Sağlayıcısı

ODBC veri sağlayıcısı ile ilgili üyeler, .net framework içinde, System.Data.Odbc isim uzayında yer almaktadır. Aslında bu veri sağlayıcı, .net framework’ün 1.0 versiyounda yer almamaktaydı. Ancak 1.1 verisyonu ile birlikte ADO.NET ‘ teki yerini almıştır. ODBC sürücüsü yardımıyla,sql server’a, access tablolarına ve odbc’yi destekleyen veri srücülerine erişebiliriz. ODBC veri sağlayıcısı, odbc veri kaynakları üzerinden yapılan tek katlı (single-tier) ve orta katlı(middle-tier) mimarilerinde kullanılabilir.

Oracle servis sağlayıcısı, .net framework’ün System.Data.OracleClient isim uzayında yer alan üyelerden oluşur. Oracle servis sağlayıcısı, oracle veri kaynaklarına erişebilmek için, sql veri sağlayıcısı gibi kendi iletişim protokünü içeren Oracle Client Connectivity’yi kullanır. Oracle veri sağlayıcısının .net’e yerleştirilmesindeki temel amaç, oracle veri tabanlarına ole db veri sağlayıcısı ile ole db üzerinden değil, doğrudan erişilebilmesini sağlamaktır. Bu sayede oracle veri kaynağı ile oluşturulan etkileşimde en iyi performansın elde edilmesi sağlanmıştır. Zaten bu yönü ilede oracle veri sağlayıcısı, sql veri sağlayıcısına benzer bir yapıdadır. Doğal olarak, oracle veri kaynakları üzerinde gerçekleştirilen, çok katlı ve tek katlı mimarilerde yüksek performans sergilemektedir.

Bu makalemizde .net veri sağlayıcılarına kısaca değinmeye çalıştık. İlerliyen makalelerimiz ile birlikte ado.net’in tüm kavramlarını inclemeye çalışacağım. Bir sonraki makalemde ole db veri sağlayıcısı üyelerinden olan, OleDbConnection nesnesini incelemeye çalışacağım. Hepinize mutlu günler ve iyi çalışmalar dilerim.

Arayüz(Interface) Kullanımına Giriş

jaja — Sat, 05 Jan 2008 12:45:03 +0000

Bugünkü makalemizde, nesneye dayalı programlamanın önemli kavramlarından birisi olan arayüzleri incelemeye çalışacağız. Öncelikle, arayüz’ün tanımını yapalım.

Bir arayüz, başka sınıflar için bir rehberdir. Bu kısa tanımın arkasında, deryalar gibi bir kavram denizi olduğunu söylemekte yarar buluyorum. Arayüzün ne olduğunu tam olarak anlayabilmek için belkide asıl kullanım amacına bakmamız gerekmektedir.

C++ programlama dilinde, sınıflar arasında çok kalıtımlılık söz konusu idi. Yani bir sınıf, kalıtımsal olarak, birden fazla sınıftan türetilebiliyordu . Ancak bu teknik bir süre sonra kodların dahada karmaşıklaşmasına ve anlaşılabilirliğin azalmasına neden oluyordu. Bu sebeten ötürü değerli Microsoft mimarları, C# dilinde, bir sınıfın sadece tek bir sınıfı kalıtımsal olarak alabileceği kısıtlmasını getirdiler. Çok kalıtımlık görevini ise anlaşılması daha kolay arayüzlere bıraktılar. İşte arayüzleri kullanmamızın en büyük nedenlerinden birisi budur.

Diğer yandan, uygulamalarımızın geleceği açısından da arayüzlerin çok kullanışlı olabileceğini söylememiz gerekiyor. Düşününkü, bir ekip tarafından yazılan ve geliştirilen bir uygulamada görevlisiniz. Kullandığınız nesnelerin, türetildiği sınıflar zaman içerisinde, gelişen yeniliklere adapte olabilmek amacıyla, sayısız yeni metoda, özelliğe vb.. sahip olduklarını farzedin. Bir süre sonra, nesnelerin türetildiği sınıflar içerisinde yer alan kavram kargaşısını, “bu neyi yapıyordu?, kime yapıyordu? , ne için yapıyordu?” gibi soruların ne kadar çok sorulduğunu düşünün. Oysa uygulamanızdaki sınıfların izleyeceği yolu gösteren rehber(ler) olsa fena mı olurdu? İşte size arayüzler. Bir arayüz oluşturun ve bu arayüzü uygulayan sınıfların hangi metodları, özellikleri vb kullanması gerektiğine karar verin. Programın gelişmesimi gerekiyor? Yeni niteliklere mi ihtiyacın var? İster kullanılan arayüzleri, birbirlerinden kalıtımsal olarak türetin, ister yeni arayüzler tasarlayın. Tek yapacağınız sınıfların hangi arayüzlerini kullanacağını belirtmek olucaktır.

Bu açıklamalar ışığında bir arayüz nasıl tanımlanır ve hangi üyelere sahiptir bundan bahsedelim.Bir arayüz tanımlanması aşağıdaki gibi yapılır. Yazılan kod bloğunun bir arayüz olduğunu Interface anahtar sözcüğü belirtmektedir. Arayüz isminin başında I harfi kullanıldığına dikkat edin. Bu kullanılan sınıfın bir arayüz olduğunu anlamamıza yarayan bir isim kullanma tekniğidir. Bu sayede, sınıfların kalıtımsal olarak aldığı elemanların arayüz olup olmadığını daha kolayca anlayabiliriz.

public inteface IArayuz
{

}

Tanımlama görüldüğü gibi son derece basit. Şimdi arayüzlerin üyelerine bir göz atalım. Arayüzler, sadece aşağıdaki üyelere sahip olabilirler:

Arayüz Üyeleri

A. Özellikler (properties)

B. Metodlar (methods)

C. Olaylar (events)

D. İndeksleyiciler (indexers)

Tablo 1. Arayüzlerin sahip olabileceği üyeler Diğer yandan, arayüzler içerisinde aşağıdaki üyeler kesinlikle kullanılamazlar:

Arayüzlerde Kullanılamayan Üyeler

i. Yapıcılar (constructors)

ii. Yokediciler (destructors)

iii. Alanlar (fields)

Tablo 2. Arayüzlerde kullanılamayan üyeler. Arayüzler Tablo1 deki üyelere sahip olabilirler. Peki bu üyeler nasıl tanımlanır. Herşeyden önce arayüzler ile ilgili en önemli kural onun bir rehber olmasıdır. Yani arayüzler sadece, kendisini rehber alan sınıfların kullanacağı üyeleri tanımlarlar. Herhangi bir kod satırı içermezler. Sadece özelliğin, metodun, olayın veya indeksleyicinin tanımı vardır. Onların kolay okunabilir olmalarını sağlayan ve çoklu kalıtım için tercih edilmelerine neden olan sebepte budur. Örneğin;

public interface IArayuz
{
/* double tipte bir özellik tanımı. get ve set anahtar sözcüklerinin herhangibir blok {} içermediğine dikkat edin. */ double isim
{
get;
set;
}

/* Yanlız okunabilir (ReadOnly) string tipte bir özellik tanımı. */
string soyisim
{
get ;
}

/* integer değer döndüren ve ili integer parametre alan bir metod tanımı. Metod tanımlarındada metodun dönüş tipi, parametreleri, ismi dışında herhangibir kod satırı olmadığına dikkat edin. */

int topla(int a, int b);

/* Dönüş değeri olmayan ve herhangibir parametre almayan bir metod tanımı. */

void yaz();

/* Bir indeksleyici tanımı */
string this [ int index]
{
get;
set;
}
}

Görüldüğü gibi sadece tanımlamalar mevcut. Herhangibir kod satırı mevcut değil. Bir arayüz tasarlarken uymamız gereken bir takım önemli kurallar vardır. Bu kurallar aşağıdaki tabloda kısaca listelenmiştir.

1	Bir arayüz’ün tüm üyeleri public kabul edilir. Private, Protected gibi belirtiçler kullanamayız. Bunu yaptığımız takdirde örneğin bir elemanı private tanımladığımız takdirde, derleme zamanında şu hatayı alırız. *“The modifier ‘private’ is not valid for this item”*
2	Diğer yandan bir metodu public olarakta tanımlayamayız. Çünkü zaten varsayılan olarak bütün üyeler public tanımlanmış kabul edilir. Bir metodu public tanımladığımızda yine derleme zamanında şu hatayı alırız. *“The modifier ‘public’ is not valid for this item”*
3	Bir arayüz, bir yapı(struct)’dan veya bir sınıf(class)’tan kalıtımla türetilemez. Ancak, bir arayüzü başka bir arayüzden veya arayüzlerden kalıtımsal olarak türetebiliriz.
4	Arayüz elemanlarını static olarak tanımlayamayız.
5	Arayüzlerin uygulandığı sınıflar, arayüzde tanımlanan bütün üyeleri kullanmak zorundadır.

Tablo 3. Uyulması gereken kurallar. Şimdi bu kadar açıklamadan sonra konuyu daha iyi anlayabilmek için basit ve açıklayıcı bir örnek geliştirelim. Önce arayüzümüzü tasarlayalım:

public interface IArayuz
{
void EkranaYaz();
int Yas
{
get;
set;
} string isim
{
get;
set;
}
}

Şimdide bu arayüzü kullanacak sınıfımızı tasarlayalım.

public class Kisiler:IArayuz
{ }

Şimdi bu anda uygulamayı derlersek, IArayuz’ündeki elemanları sınıfımız içinde kullanmadığımızdan dolayı aşağıdaki derleme zamanı hatalarını alırız.

Interfaces1.Kisiler’ does not implement interface member ‘Interfaces1.IArayuz.EkranaYaz()’

Interfaces1.Kisiler’ does not implement interface member ‘Interfaces1.IArayuz.isim’

Interfaces1.Kisiler’ does not implement interface member ‘Interfaces1.IArayuz.Yas’

Görüldüğü gibi kullanmadığımız tüm arayüz üyeleri için bir hata mesajı oluştu. Bu noktada şunu tekrar hatırlatmak istiyorum,

Arayüzlerin uygulandığı sınıflar, arayüzde(lerde) tanımlanan tüm üyeleri kullanmak, yani kodlamak zorundadır.

Şimdi sınıfımızı düzgün bir şekilde geliştirelim:

public class Kisiler:IArayuz /* Sınıfın kullanacağı arayüz burada belirtiliyor.*/
{ private int y;
private string i;

/* Bir sınıfa bir arayüz uygulamamız, bu sınıfa başka üyeler eklememizi engellemez. Burada örneğin sınıfın yapıcı metodlarınıda düzenledik. */

public Kisiler()
{
y=18;
i=”Yok”;
}

/* Dikkat ederseniz özelliğin herşeyi, arayüzdeki ile aynı olmalıdır. Veri tipi, ismi vb… Bu tüm diğer arayüz üyelerinin, sınıf içerisinde uygulanmasında da geçerlidir. */

public Kisiler(string ad,int yas)
{

y=yas;
i=ad;
}

public int Yas
{
get
{
return y;
}

set
{
y=value;
}
}

public string Isim
{
get
{
return i;
}

set
{
i=value;
}
}

public void EkranaYaz()
{
Console.WriteLine(”Adım:”+i);
Console.WriteLine(”Yaşım:”+y);
}
}

Şimdi oluşturduğumuz bu sınıfı nasıl kullanacağımıza bakalım.

class Arayuz_Deneme
{
{
Kisiler kisi=new Kisiler(”Burak”,27);
Console.WriteLine(”Yaşım “+kisi.Yas.ToString());
Console.WriteLine(”Adım “+kisi.Isim);
Console.WriteLine(”———–”);
kisi.EkranaYaz();
}
}

Uygulamamızı çalıştırdığımızda aşağıdaki sonucu elde ederiz.

Şekil 1. Uygulamanın Çalışması Sonucu.