Yazılım Öğren

WinAPI Fonksiyonlarının C#’ta Kullanımı

xqm26 — Fri, 10 Apr 2009 13:22:30 +0000

C# ve dotNET ile birlikte yazılım geliştirmeye yeni bir soluk gelmiş olsada C# ile eskiden yazılmış COM komponentlerine erişebilmek mümkündür. Daha önceki iki makalede .NET ve COM ilişkisini detaylı bir şekilde incelemiştik. Bu makalede .NET’in Win 32 API ile nasıl entegre edildiği anlatılacaktır. .NET ve C#’ın yeni imkanlarının yanısıra eski bir teknoloji olan COM ve yönetilmeyen(unmanaged) kodlarla uyumlu bir şekilde çalışması belkide C# ve .NET’i diğer yazılım geliştirme platformlarından ayıran en önemli özelliktir.

Bildiğiniz gibi C#’ta gösterici kullanımı tamamen serbesttir. Bu yüzden eskiden(.NET öncesi) yazılmış ve parametre olarak gösterici alan COM komponentleri ve Windows API fonksiyonları C# ile sorunsuz bir şekilde çalıştırılabilmektedir. Bu yazıda Win API fonksiyonlarının .NET ortamında ne şekilde ele alındığı incelenecektir.

Win32 sistem fonksiyonları kullanıldığında, kod CLR tarafından yönetilmekten çıkar. .NET ortamında geliştirilen bir uygulamada yönetilmeyen kod segmenti ile kaşılaşılırsa ilgi kod segmenti CLR tarafından yönetilmekten çıkar. Dolayısıyla “garbage collection” mekanizması ve .NET’e özgü diğer servisler kullanım dışı olur.

CLR tarafından yönetilmeyen kodlara erişebilmek için C#’ta System.Runtime.InteropServices isim alanında bulunan ve DllImprtAttribute sınıfını temsil eden DllImport niteliği kullanılmaktadır. DllImport niteliği ile harici bir kaynakta bulunan metoda referans vermek için external anahtar sözcüğü kullanılır. Bir sınıf bildiriminin en başında external anahtar sözcüğü ve DllImport niteliği kullanılarak CLR tarafından yönetilmeyen bir metot bildirimi yapılır. Tabi metodun gövdesi harici bir kaynakta zaten var olduğu için bizim metodun gövdesini yazmamızın bir anlamı yoktur. Ardından bu metot sınıfın istenildiği yerinde kullanılabilir. İsterseniz basit bir örnekle DllImport niteliğinin kullanımını gösterelim.

Win API windows sistemlerinin programlanabilir arayüzünü içermektedir. Windows uygulamarının tamamı bu arayüzdeki fonksiyonları ve diğer yapıları kullanmaktadır. Aşağıdaki programda Win32 sistemlerinde bulunan MessageBox() fonksiyonunun kullanımına bir örnek verilmiştir.

Not : Bu yazıda C#’ta niteliklerin(Attributes) nasıl kullanıldığını bildiğiniz varsayılmıştır.

using System;
using System.Runtime.InteropServices;

class Class1
{
[DllImport("user32.dll")]
public static extern int MessageBox(int tip,string mesaj,string baslik,int secenek);

    static void Main()
    {
        MessageBox(0,”Mesaj”,”Win API MessageBox”,2);
    }
}

DllImportAttribute sınıfının bir tane yapıcı metodu bulunmaktadır. Bu metot parametre olarak harici kaynağın adı belirtmektedir. Yukarıdaki kaynak kodda MessageBox fonksiyonunun bulunduğu “user32.dll” isimli dosya DllImport niteliğine parametre olarak verilmiştir. Bu örnekte dikkat edilmesi gereken diğer nokta ise extern anahtar sözcüğünün kullanımıdır. Bu anahtar sözcük ile bildirimi yapılan metodun harici bir dosyada olduğu belirtilmektedir. Dolayısıyla C# derleyicisi metodun gövdesini kaynak kodda aramayacaktır.

Programın çalışma şeklini açıklamadan önce ekran çıktısına bakalım :

Yukurıdaki çıktıdan ve kaynak koddan da görüldüğü üzere Win API deki bir fonksiyonun çağrımı klasik metot çağrımından farklı değildir. Değişen tek şey metodun bildirim şeklidir.

Not : Gösterilen mesaj kutusunun farklı formlarını görmek için MessageBox metodunun parametreleri ile oynayın.

Şimdi kısaca yukarıdaki programın çalışma zamanındaki durumunu inceleyelim. Program çalıştırıldığında, CLR tarafından yönetilmeyen bir metot çağrımı yapıldığında ilgili kaynaktan metot belleğe yüklenir ve belleğe yüklenen metodun başlangıç adresi saklanır. Ardından bizim parametre olarak geçtiğimiz değişkenler DLL’ deki fonksiyona uyumlu hale getirilir ve parametre olarak geçirilir. Eğer bir geri dönüş değeri bekleniyorsa yönetilmeyen kod bölümünden gelen değer uygun .NET türüne dönüştürülerek işlemlere devam edilir. Bu işlemler tamamen .NET’in alt yapısını ilgilendirmektedir. Dolayısıyla programcının yapacağı iş sadece metodun bildirimini doğru bir şekilde gerçekleştirmektir.

DllImportAttribute sınıfının bir kaç önemli özelliği daha vardır. Bunlardan en önemlisi harici kaynaktaki bir fonksiyona takma isim verebilmemizi sağlayan string türünde olan EntryPoint özelliğidir. EntryPoint özelliğini kullanarak MessagBox fonksiyonuna takma isim verebiliriz. Fonksiyon çağrımı bu takma isim ile gerçekleştirilebilmektedir. Örneğin MessageBox fonksiyonuna TebrikMesajiVer şeklinde bir takma isim vermek için aşağıdaki gibi bir bildirim yapılmalıdır.

using System;
using System.Runtime.InteropServices;

class Class1
{
[DllImport("user32.dll",EntryPoint = "MessageBox")]
public static extern int TebrikMesajiVer(int tip,string mesaj,string baslik,int secenek);

    static void Main()
    {
        TebrikMesajiVer(0,”Tebrikler”,”Takma İsim Verme”,0);
    }
}

Şimdi de DllImport niteliği ile ilgili diğer özelliklere ve önemli noktalara bakalım.

1 – DllImport niteliği yalnızca metotlara uygulanabilir.

2 – DllImport niteliği ile işaretlenmiş metotlar mutlaka extern anahtar sözcüğü ile bildirilmelidir.

3 – DllImport niteliğinin EntryPoint’in haricinde 4 tane isimli parametresi(named parameter) daha vardır. Bunlar : CallingConvention, CharSet, ExactSpelling, PreserveSig ve SetLastError parametreleridir. Bu parametrelerden önemli olanlar aşağıda açıklanmıştır.

4 – CallingConvention : Bu paramtre CallingConvention numaralandırması türündendir. Bu parametre ile harici metodun ne şekilde çağrılacağı ile ilgili bilgi verilir. CallingConvention numaralandırması 5 tane sembol içerir. Varsayılan olarak bu sembol Winapi olacak şekilde ayarlanmıştır. Yani CallingConvention parametresini DllImport ile kullanmıyorsak varsayılan olarak bu Winapi’dir. Diğer semboller ise Cdecl, FastCall, ThisCall, StdCall şeklindedir. En çok Winapi sembolu kullanıldığı için diğer sembollerin ne anlama geldiği anlatılmayacaktır. Diğer sembollerin ne anlama geldiklerini MSDN kütüphanesinden detaylı bir şekilde öğrenebilirsiniz.

5 - CharSet : Harici fonksiyonun çağrımında kullanılacak karekter setini belirler. Bu parametre CharSet numaralandırması ile belirtilir. Varsayılan olarak CharSet.Auto şeklindedir. CharSet numaralandırmasının diğer sembolleri Ansi, Unicode ve None şeklindedir.

6 - ExactSpelling : EntryPoint ile belirtilen ismin ilgili fonksiyon ismine yazım biçimi bakımından tam uyumlu olup olmayacağını belirtir. Bu özellik bool türündendir ve varsayılan olarak false değerdir.

DllImport metodunun varsayılan çağrım biçimi olan Winapi sadece Windows sistemlerine özgün olduğu için sistemler arası taşınabilirliğin yüksek olması gereken projelerde bu niteliğin kullanımından kaçınmak gerekir. Bu yüzden DllImport özelliğini kullanmadan önce ilgili fonksiyonun .NET Framework içinde olup olmadığını kontrol etmek gerekir. Örneğin MessageBox fonksiyonu zaten System.Windows.Forms isim alanında bulunduğu için API kullanarak bu fonksiyondan yararlanmak mantıklı değildir. Zira ileride programınızın Linux ortamında yada diğer farklı ortamlarda da çalışmasını istiyorsanız programınızı değiştirip yeniden derlemeniz gerekecektir. Oysa .NET Framework içinde bulunan standart sınıfları ve onların metotlarını kullanırsanız böyle bir derdiniz olmayacaktır.

C# ile Sıra (Queue) Sınıfı ve kullanımı

xqm26 — Fri, 10 Apr 2009 13:17:28 +0000

Şimdi, diğer önemli veri yapısı olan sıra (queue) veri yapısını inceleyeceğiz.

Queue veri tipi ve .NET’in sınıf kütüphanesinde bulunan Queue sınıfı, yığın (stack) sınıfına çok benziyor. Bu veri tipleri çalışma mantığı olarak tam tersi gibi görünmelerine rağmen bir çok metodları ve özellikleri birebir örtüşüyor. Bu durumda birazdan okayacağınız makalenin formatı yığın makalemizdekine çok benzediğini göreceksiniz.

1. Queue(sıra) veri Yapısının Çalışma Şekli

Sıralar (queue) İlk Giren İlk Çıkar (FIFO) prensibi ile çalışan veri yapısı şekinde bilinirler. Bir sıraya ilk giren eleman ilk olarak çıkar. Sıralara örnek olarak bir markette alışverişini yapan müşterilerin, aldıkları ürünlerin ücretlerini ödemek için kasada sıraya geçmeleri verilebilir. Marketteki sırada sıraya ilk giren müşterinin işi ilk önce biter. Daha sonra ikinci ve üçüncü müşterilerin işleri yapılır.

Sıralar bilgisayar programlamada sık sık başvurulan veri yapılarıdır. Mesela, işletim sisteminde yapılması gereken işleri bir sıra veri yapısı ile tutarız. Herhangi bir anda yeni bir iş geldiği zaman bu iş sıraya (Queue) girer. Sırası gelen iş yapılır ve sonraki işe geçilir gibi. Queue veri yapıları ayrıca simulasyonlarda da sık sık kullanılır.

2. .NET Sınıf Kütüphanesi Sıra Sınıfı (Queue)

.NET sınıf kütüphanesinde sıra veri yapısını kullanmak için Queue sınıfını kullanırız. NET’in yığın (Stack) sınıfını kullanmak için pogram kodunun baş tarafına using System.Collections; eklememiz gerekir. Yani sıra sınıfı System.Collections isim alanında bulunuyor.

C# veya herhangi bir dilde yazılan yığın veri yapılarında Enqueue(), Dequeue, Peek(), Clear() fonksiyonları ve Count, özelliği vadır. Bunların yanında Clone(), CopyTo(), ToArray(), Contains() ve Equals() metodları .NET’in yığın sınıfında yeralır.

Sıra sınıfının Enqueue() metodu sıraya yeni bir eleman ekler. Dequeue() metodu ile yığının en öndeki elemanı sıradan siler ve silinen elemanı geriye dönderir. Eğer sıranın tepesindeki elemanı öğrenmek istersek Peek() medotunu işimize yarar. Bu metod sıranın başındaki nesneyi dödürür ama bu nesneyi sıradan silmez.

using System;
using System.Collections; // Queue sınıfı bu isim alanı içinde bulunur.

class Sira_Ornek1
{

public static void Main()
{

// Queue sınıfından bir nesne oluşturalım:
Queue sira = new Queue();

      // Nesnemize Enqueue metodu ile değerler girelim:
      sira.Enqueue(”Ahmet”);
      sira.Enqueue(”Ferit”);
      sira.Enqueue(”Hasan”);
      sira.Enqueue(”Hüseyin”);

// sira isimli nesnemizin eleman sayısı:
Console.WriteLine( “\n sira nesmemizin eleman sayısı: ” + sira.Count);

      // sira isimli nesnemizin elemanları:
      Console.WriteLine( “\n sıra nesmemizin elemanları: ” );
      DegerleriYaz( sira );

      //sira isimli nesmemizden bir eleman alalım:
      string eleman= (string)sira.Dequeue();
      Console.WriteLine(” \n Sıramizin başından şunu aldık: ” + eleman);

      //şimdi ise siranin en başındaki nesneyi öğrenelim.
      // Ama onu ıiradan çıkartmayacağız:
      eleman= (string)sira.Peek();
      Console.WriteLine(” \n Sıramızın başındaki eleman ” + eleman);

}

   public static void DegerleriYaz( IEnumerable kolleksiyon )
   {
      System.Collections.IEnumerator Enum = kolleksiyon.GetEnumerator();

while ( Enum.MoveNext() )
Console.Write( “\t{0}”, Enum.Current );

Console.WriteLine();
}
}

Yukarıdaki örnek programda önce Queue sınıfından sıra isimli bir nesne oluşturuyoruz. Sonraki altı satırda sıramıza “Ahmet”, “Ferit”, “Hasan”, ve “Hüseyin” değerlerini Enqueue metodu ile ekliyoruz. Degerleri() ismini verdiğimiz static fonksiyonumuz ile sıramızdaki eleman sayısını ve elemanları ekrana yazdırıyoruz. Daha sonra sıramızdan bir tane elemanı Deuque() metodu yardımıyla alıyor ekrana yazdırıyoruz. Programın son kısmında ise Peek() metodunu kullanrak sıranın en üstündeki elemanın ne olduğunu öğreniyoruz ve bu eleman sırada kalıyor.

Sıra sınıflarında bulunan diğer iki temel fonksiyonlar olan Count özelliği ve Clear() metodlarıdır. Bunlardan Count, sıra nesnesinde bulunan elemanların sayısını geriye dönderen bir özelliktir. Özellikler C# dilinde sınıflarda bulunan üye değişkenlerin değerlerini öğrenmemize ve onların değerlerini değiştirmemize yarayan bir tür fonksiyonlardır. Count özelliği eleman sayısını int tipinde dönderir ve sadece okunabilen (readonly) yapıdadır. Özellikler program içinde çağrılırken parantezleri kullanmayız. Eğer sırayı boşaltmak/temizlemek istersek Clean() metodu işimizi yarayacaktır. Clean() metodu hiçbir parametre almaz ve hiçbirşey döndermez. Herhangi bir sıra nesnesinin içinde bir elemanın olup olmadığını anlamak için Contains() metodu kullanılır. Bu metod aranacak nesneyi alır ve geriye true veya false değerlerini dönderir. İsterseniz aşağıdaki programda Contains() ve Clear() metodları ile Count özelliklerini nasıl kullanabileceğimizi görelim:

using System;
using System.Collections; // Queue sınıfı bu isim alanı içinde bulunur.

class Sira_Ornek2
{

public static void Main()
{

// Queue sınıfından bir nesne oluşturalım:
Queue sira = new Queue();

      // Nesnemize Enqueue metodu ile değerler girelim:
      sira.Enqueue(12);
      sira.Enqueue(3);
      sira.Enqueue(18);
      sira.Enqueue(7);
      sira.Enqueue(20);

// sıra isimli nesnemizin eleman sayısı:
Console.WriteLine( “\n sira nesmemizin eleman sayısı: ” + sira.Count);

      // sira isimli nesnemizin elemanları:
      Console.WriteLine( “\n sıra nesmemizin elemanları: ” );
      DegerleriYaz( sira );

//Contains metodunun kullanımı:
int sayi=7;

      if(sira.Contains(7))
         Console.WriteLine(”Sıramızda ” + sayi + ” var.”);
      else
         Console.WriteLine(”Sıramızda ” + sayi + ” yok.”);

// sıramızın içindeki elemanları silelim:
sira.Clear();

      // Sıramızı temizledikten sonra kaç tane
      //eleman bulunduğunu bulup yazalım.
      int elemanSayisi= sira.Count;

Console.WriteLine(”\n Sıramizda şu anda {0} tane eleman vardır.”, elemanSayisi);

}

   public static void DegerleriYaz( IEnumerable kolleksiyon )
   {
      System.Collections.IEnumerator Enum = kolleksiyon.GetEnumerator();

while ( Enum.MoveNext() )
Console.Write( “\t{0}”, Enum.Current );

Console.WriteLine();
}
}

Yığında makalemiz Clone(), ToArray() ve Equals() metodlarının aynıları Queue sınıfı içinde bulabiliriz. Sizlerin yığın makalesindeki en son örneğini sıra veri tipi için de yazıp kendinizi denemenizi tavsiye ederim. Herkese iyi çalışmalar.

Visual C# ile Basit Bir Not Defteri Uygulaması

xqm26 — Fri, 10 Apr 2009 13:14:28 +0000

Eğer bu yazıyı sonuna kadar okursanız ve kodları sizde yazarsanız, yazının sonuna geldiğiniz Basit Not Defteri adında bir uygulamanız olacak. Önce bu programdan biraz bahsedelim. Adı üstünde bir Not Defteri uygulaması ancak basit hem de çok basit. Yapabildiği şeyler: Yeni dosya yaratmak, var olan dosyaları açmak, dosya kaydetmek… Böyle bir program yapmamın sebebi tabi ki metin editörleri konusunda alternatif oluşturma isteği falan değil, tek sebep benim ilk başlarda çok zorlandığım SaveFileDialog, OpenFileDialog gibi kontroller konusunda örneklemeler yapmak..

Lafı daha fazla uzatmadan artık uygulamaya geçelim. Önce aşağıdaki programı Visual Studio .Net’in Designer’ında oluşturun…

Ben bu resime kullandığım kontrollerin isimlerini de yazdım ki kodları incelerken zorluk çıkmasın. Yalnız burada görünmeyen 2 kontrol daha var. Biri SaveFileDialog (objSave), diğeri OpenFileDialog (objOpen). Bu kontrolleri de ekleyip adlarını parantez içlerindeki gibi yaparsanız sorun çıkmaz…

Şimdi kodlarımıza geçebiliriz. Bu bölümde adım adım ilerleyeceğiz. Menülerdeki tüm başlıkların olaylarını yazacağız.

1)Genel değişkenimizi tanımlama
Bu programda Degisim adında, “bool” yani sadece true ve false değerleri alabilen bir değişken tanımladım. Bu değişken sayesinde kullanıcıyı metinin değişip değişmediği konusunda uyaracağız, böylece isterse değişen metni kayıt imkanı vereceğiz…

private bool Degisim;

2)Form1’in onLoad Olayı
Bu olay programımızın açılışında yürütülen olaydır. Burada objSave ve objOpen için bazı ayarlar yapıyoruz ve göstermesini istediğimiz dosyaların uzantılarını giriyoruz.

      private void Form1_Load(object sender, System.EventArgs e)
      {
         objOpen.Filter = “Text Dosyaları(*.txt)|*.txt|Tüm Dosylar(*.*)|*.*” ;
         objOpen.FilterIndex = 1 ;
         objSave.Filter = “Text Dosyaları(*.txt)|*.txt|Tüm Dosyalar(*.*)|*.*” ;
         objSave.FilterIndex = 1 ;
      }

3)Kullanılacak metotların tanımlanması…
Ben bu programda sadece 2 tane metot tanımladım. Bunlardan birincisi KayitMekanizmasi, diğeri DegisimUyari . KayitMekanizmasi adı üstünde yazdıklarımızı kaydedecek olan mekanizma, DegisimUyari ise objText içindeki metnin değişimi durumda programı kapatırken falan bize haber verecek olan kod.

      public void KayitMekanizmasi(string strVeri)
      {
         if (objSave.ShowDialog() == DialogResult.OK)
         {
            StreamWriter Kayitci = new StreamWriter(Environment.GetEnvironmentVariable(”mydocuments”)+objSave.FileName.ToString(),false,System.Text.Encoding.Unicode);
            Kayitci.Write(strVeri);
            Kayitci.Close();
            Degisim = false;
         }
      }

Önce yukarıdaki kodu biraz inceleyelim. Burada önce bi if kontrolü görüyorsunuz. Bu kontrolün amacı, Kayıt ekranı açıldığı zaman kullanıcı “OK” düğmesine tıklayıp tıklamadığını kontrol etmek. Eğer “OK”e tıkladı ise programımız bir adet StreamWriter oluşturuyor. Kayitci adındaki bu Writer Environment.GetEnvironmentVariable(”mydocuments”) bu kod ile ayarlı olan Belgelerim klasörüne gidiyor otomatik olarak. objSave.FileName ise bizim Kayıt Ekranın da dosyaya verdiğimiz ismi bize döndürüyor. Son olarak ise bu satırda Unicode bir kodlama yaptığımız gösteriyoruz. Bunu yazmazsanız Türkçe karakterlerinizin yerinde yeller estiğini görürsünüz.

Kayitci.Write(strVeri) satırı ile gelen veriyi kaydediyor ve StreamWriter nesnesini kapatıyor. Degisim değerini ise true olarak atıyor. Bunun nedeni değişim oldu ve ben bunu gördüm demek. Kullanıcıya haber vermeye gerek yok anlamına gelecek.

Şimdi devam edelim.

      public bool DegisimUyari()
      {
         if (MessageBox.Show(”Dosyanızda bir değişiklik oldu kaydetmek ister misiniz?”,”Değişiklik Var”,MessageBoxButtons.YesNo,MessageBoxIcon.Exclamation) == DialogResult.Yes)
         {
            return true;
         }
         else

         {
            Degisim = false;
            return false;
         }

      }

Yukarıdaki kodda ise tipik bir MessageBox kullanımı görüyorsunuz. Buradaki metodumuz birde değer döndürüyor.Bir bool değeri döndürüyor. Bu dönen değer ile biz az sonra kullanıcının çıkan mesaj kutusunda dosyayı kaydetmek isteyip istemediğini anlayacağız.

MessageBox.Show(”Dosyanızda bir değişiklik oldu kaydetmek ister misiniz?”,”Değişiklik Var”,MessageBoxButtons.YesNo,MessageBoxIcon.Exclamation) == DialogResult.Yes)

Bu satırı biraz incelemek lazım. Burada ilk overload (Overload metodlara parantezler içinde yollanan veri demek.) mesaj kutusunda görünecek olan yazı, ikinicisi bu mesaj kutusunun başlığı, üçüncüsü mesaj kutusu üzerinde ki “Evet”, “Hayır” düğmeleri ve son olarak mesaj kutusundaki simge. Ancak kodlara bakmaya devam ettiğimizde bir karşılaştırma görüyoruz (“==” ifadesi) DialogResult.Yes , aslında açıklamaya bile gerek yok. Eğer kullanıcı “Evet”e tıkladı ise demek. Asıl kodlarda bu durumda bir “true” ifadesi döndürüldüğünü görebilirsiniz. Biz daha sonra bunu kontrol ederek KayitMekanizmasi metodumuzu çağıracağız.

4) Yeni düğmesi
Menümüzdeki “Yeni” düğmesine tıkladığımızda olacak olayları gireceğiz. Bunun için bu düğmeye Designer’dan çift tıklayınız.

private void menuItem2_Click(object sender, System.EventArgs e)
      {
         if (Degisim == false)
         {
            objText.Clear();

         }
         else
         {
            if (DegisimUyari())
            {
               KayitMekanizmasi(objText.Text);
               objText.Clear();
               Degisim = false;
            }
            else
            {
               objText.Clear();
               Degisim = false;
            }
         }
      }

Burada önce Degisim değerini kontrol ediyoruz. Eğer değer “false” ise yani değişim yoksa ya bu dosya önceden kaydedilmiştir ya da yeni açılmıştır. O zaman içeriğinin temizlenmesinde bir sorun yok.

Eğer değer “true” ise biraz karışıyor ortalık. Önce kullanıcıyı uyarmak için DegisimUyari() çalıştırılıyor. Eğer kullanıcı kayıt etmek istiyorsa, KayitMekanizmasi() çalıştırılıyor, ekran temizleniyor ve Degisim değeri false oluyor.Eğer kullanıcı kayıt etmek istemiyorsa içerik temizleniyor ve Degisim değeri yine false oluyor. Böylece yeni bir dosya açma işlemlerini hallettik.

5) Varolan dosyayı açma

Metin editörünüz ile daha önce var olan bir dosyayı açmak istersiniz diye böyle bir özellik ekledik birde. Menümüzde “Aç”a çift tıklayın ve tıklama olayına aşağıdaki kodları girin.

private void menuItem3_Click(object sender, System.EventArgs e)
{
           if (Degisim == true)
         {
            if (DegisimUyari())
            {
               KayitMekanizmasi(objText.Text);
            }
         }
         if (objOpen.ShowDialog() == DialogResult.OK)
         {

            FileInfo strKaynak = new FileInfo(Environment.GetEnvironmentVariable(”mydocuments”)+objOpen.FileName.ToString());
            StreamReader Okuyucu = strKaynak.OpenText();

            objText.Text = Okuyucu.ReadToEnd();
            Degisim = false;
            Okuyucu.Close();
         }
}

Bu kodlarda da önce değişim var mı diye bakıyoruz. Yani amacımız kullanıcının yazdığı metni yanlışlıkla bastığı bir düğme yüzünden kaybetmesini engellemek. Eğer değişim varsa ve uyarıdan “true” değeri dönerse kaydediyoruz, aksi halde herhangi bir şey yapmıyoruz.

Bundan sonra yukarıda SaveFileDialog için yaptığımız benzer şeyleri yapıyoruz. Yani .ShowDialog() metodunu çağırıyoruz. Kullanıcı OK’e tıklayınca kodlarımız devam ediyor. Ancak burada yukarıdakinden farklı kodlar var. Dosya okumak için çok farklı yöntemler var. Yazmak içinde tabi ki. Mesela StreamWriter’ın StreamReader’ı da var ve ben burada bunu kullandım. Eğer kodları incelerseniz biraz farklı olduğunu göreceksiniz. Çünkü burada FileInfo diye de bir şey var. FileInfo bu tür dosya işlemcilerine yardımcı olur. strKaynak değişkenine atadığımız nesnemizde StreamWriter daki gibi path gösterip dosyamızı açıyoruz. Burada objOpen.FileName’den gelen veri, kullanıcının açmak istediği dosya.

StreamReader nesnesini de oluşturup strKaynak.OpenText() ile metin dosyamızı açıyoruz. Yalnız burada bir noktaya dikkat çekmek istiyorum. Ben burada açılacak dosyanın bir .txt dosyası olduğunu bildiğim için .OpenText’i kullandım. Yoksa başka versiyonları da mevcut. Bu nesneyi de oluşturduktan sonra objText’e Okuyucu.ReadToEnd ile baştan sonra tüm veriyi okuyup aktarıyoruz. Değişimden haberimiz olduğunu programa bildirip, nesnelerimizi kapatıyoruz…

6) Kaydet düğmesi

Kullanıcı çalışmasını kaydetmek istediği zaman bu düğmeye tıklayabilir. Çok kısa bir kodu var. Zaten asıl işi yapan KayitMekanizmasi(), biz sadece onu çağıracağız şimdi.

private void menuItem4_Click(object sender, System.EventArgs e)
{
KayitMekanizmasi(objText.Text);
Degisim = false;
}

Burada açıklanacak bir kod yok. Gördüğünüz gibi …

7) Kapat Düğmesi

Kullanıcı programı kapatmak isteyebilir ve bunun için Dosya menüsündeki Kapat düğmesini kullanabilir. O zaman bu düğmeye de bir olay atamamız lazım. Şimdi çift tıklayın ve aşağıdaki kodları yazın.

private void menuItem6_Click(object sender, System.EventArgs e)
{
Close();
}

Bu kod çok basit. Sadece Close() metodunu çağırıyor. Bu özel tanımlı bir metodur ve o form penceresinin kapanmasını sağlar. Şimdi aklınıza gelebilir ya içeride kaydedilmemiş veri varsa hiç kontrol etmedik. O zaman biraz sabır, ona da bakacağız…

8) Kapanmadan önce kontrol
Kullanıcımız programı çok farklı şekillerde kapatabilir. Alt + F4 kombinasyonu, köşedeki X ile kapatabilir ya da Kapat düğmemize tıklar;ancak az önce de dediğimiz gibi ya içeride veri varsa. O zaman bu veri için bi kontrol yapmamız lazım. Form’ların “Closing” adında olayları vardır. Bu form kapatılmadan hemen önce yapılacakları belirler. Biz buna bazı olaylar atıyoruz şimdi.

   private void Form1_Closing(object sender, System.ComponentModel.CancelEventArgs e)
      {
         if (Degisim == true)
         {
            if (DegisimUyari())
            {
               KayitMekanizmasi(objText.Text);
               Close();

            }
         }
         else
         {
            Close();
         }
      }

Burada yapılanlardan farklı olan hiç bir şey yok. Degisim değerini kontrol ediyoruz ve ona göre işlem yapıyoruz..

9) Son bir metod…

Asıl en önemli şeyi yapmadık sanıyorum. Örneğin kullanıcı programa bir veri girdiğinde yani herhangi bi yazı yazdığında Degisim değeri değişmedi. O zaman bunu halledelim. objText’in TextChanged adında bir olayı var. Şimdi o olay kodları içine aşağıdaki tek satırlık kodu yazıyoruz.

   private void objText_TextChanged(object sender, System.EventArgs e)
   {
       Degisim = true;
   }

Evet, böylece olayın iş yapan kısmı bitti..

Ancak menülerimiz arasında hiç ilgilenmediğimiz bir düğme var. Hakkında. Bu aslında en gereksiz şey belki ama bir programcının en çok önemsediği bölüm . Bunun için basit bir form yaratınız. Ben aşağıdaki formu oluşturdum ve adını “hakkinda” yaptım.

Burada altta iki tane de link var. Biri MaxiASP.Com ‘a biri MaxiASP.Net’e yönlenmiş durumda. Bunlara tıklandığında tarayıcımızın açılıp sitelere gitmemizi sağlayacak kodlarda aşağıda.

private void linkLabel1_LinkClicked(object sender, System.Windows.Forms.LinkLabelLinkClickedEventArgs e)
{
System.Diagnostics.Process.Start(”http://www.maxiasp.com”);
}

private void linkLabel2_LinkClicked(object sender, System.Windows.Forms.LinkLabelLinkClickedEventArgs e)
{
System.Diagnostics.Process.Start(”http://www.maxiasp.net”);

}

Gerçekten çok uzun bir yazı oldu. Eğer her şey yolunda gitti ise şu an canavar gibi çalışan bir “Basit Not Defteriniz” var. <

C#’da Kaynak Kodunuzu XML ile Süsleyin

xqm26 — Fri, 10 Apr 2009 13:06:24 +0000

Büyük yazılım projelerinde en önemli aktivitelerden birisi proje bazında iyi bir dökümantasyon yapmaktır; proje analiz sürecindeki dökümantasyon genellikle standart olan UML diyagramları ile yapılmaktadır, tabi işin bir de geliştiriciye bakan tarafı vardır. Projenin en nihayi sonu kod yazmak olduğuna göre kodların dökümantasyonu da en az analiz sürecindeki dökümantasyon kadar önemlidir. Bu yazıda .NET ile birlikte ön plana çıkan XML yorum formatı ile kodlarımızı nasıl dökümante edebileceğimizi inceleyeceğiz.

Bildiğiniz gibi kodlarımıza yorum satırı koymamızdaki en büyük amaç kodların başkası tarafından kolaylıkla anlaşılabilir hale gelmesini sağlamaktır. Bazen bu işlemi kendimiz içinde yapmak durumunda kalabiliriz, zira bir çok karmaşık uygulamada yazdığımız kaynak koda yıllar sonra belkide aylar sonra baktığımızda vakt-i zamanında neler düşündüğümüz hemen aklımıza gelmeyebilir. Bu durumda en büyük yardımcımız o zamanlar tembellik etmeden yazdığımız yorum satırları olacaktır. Eğer kendinize yorum satırı ekleme alışkanlığını kazandırırsanız bunun getirisini ileride mutlaka göreceksiniz. Peki ne kadar yorum satırı gereklidir? Bu sorunun cevabı size ve yazdığınız kodların karmaşıklığına göre değişir. Eğer şiir gibi kod yazıyorum diyorsanız belkide bir cümlelik yorum satırı işinizi görebilir, yok arap saçı gibi kod yazıyorum diyorsanız belkide yazdığınız kod satırı sayısından daha fazla yorum yazmak zorunda kalabilirsiniz.

.NET bir çok meselede olduğu gibi yorum ekleme mekanizmasını da estetik bir şekilde çözmüştür. Çok değil daha bir kaç yıl öncesine kadar kaynak kodlarımızdaki yorum satırları // ve /* */karekterleri ile belirtiliyordu. .NET bu eski yorum yazma şeklini desteklemekle birlikte XML formatındaki yorum ekleme mekanizmasıyla ön plana çıkmaktadır. XML sayesinde artık kodlarımızdaki yorumlar standart hale getirilmiştir. Böylece bir XML yorumunda belirli bir etiketi gördüğümüzde o etiketin içindeki açıklamanın neyi ifade ettiğini anlarız. Aynı zamanda VS.NET kodlarımızdaki XML yorumlarını ayrıştırarak saf bir XML dosyası da üretebilmektedir. Bu sayede XML formatındaki yorum dosyasını istediğimiz sistem ile rahatlıkla entegre edebilirz, söz gelimi proje yöneticisine XML dosyasındaki yorum bilgilerini HTML formatında sunabiliriz.

XML Yorum Satırları

C#’ta XML yorum satırları ” /// (3 adet slash karakteri) ” ile başlayan satırlarda yazılır. Önceden belirlenmiş bir takım standart XML etiketleri vardır, öyleki bu etiketler aynı zamanda ECMA tarafından da standart olarak kabul edilmiştir. Ancak XML etiketlerini programcı istediği şekilde şirketin ihtiyaçlarına yada kendi ihtiyaçlarına göre genişletebilir. XML yorum yazmadaki belkide tek kısıt XML sözdizimine uyma şartıdır. XML sözdizimine göre açılan bütün etiketler kapanmalıdır.

En çok kullanılan önceden tanımlı XML etiketleri , ,

ve etiketleridir. Bu etiketlerin bazıları intellisense ve “Object Browser” programı tarafından kullanılmaktadır. Örneğin VS.NET editöründe bir nesne yaratıldığında nesne türüne ait yapıcı metottaki parametrelerin kısa açıklaması editör penceresinde gösterilir. Aynı şekilde kendi yazdığımız sınıflar içinde bu açıklamaların çıkmasını istiyorsak XML yorum etiketlerini kullanmamız gerekir.

XML yorum etiketleri tür bazında, metot bazında ve parametre bazında olabilir. Tür bazında yorum ekleme işlemi sınıflar, temcilciler, indeksleyiciler, olaylar, numaralandırmalar(enums) ve yapılar(struct) için uygulanabilir. Metot bazındaki yorumlar herhangi bir metodun bildiriminden önce yapılır. Parametre bazındaki yorumlar ise bir metodun parametreleri ve geri dönüş değerleri ile ilgilidir.

Açıklayıcı olması açısından örnek bir sınıf üzerinde XML yorumlarını ve VS.NET gibi akıllı editörlerde bu yorumların ne gibi etkilerinin olduğunu inceleyelim.

Şimdi yeni bir “Class Library” projesi açıp aşağıdaki sınıf bildirimini yazın.

using System;

namespace XMLYorum
{
///

      /// Cebir sinifi bazi özel matematiksel islemleri
      /// yapmak için çesitli statik metotlar sunar.
      ///

      public class Cebir
      {
            ///
            /// Mutlak Deger Alma Islemi
            ///
            ///

            /// Parametre olarak gelen sayinin
            /// Mutlak Degerini alir.
            ///

            ///Mutlak Degeri alinacak sayi.
            ///Paremetre olarak gelen sayinin mutlak degeri.
            public static int MutlakDeger(int Deger)
            {
                  if(Deger < 0)
                        return -Deger;
                  else
                        return Deger;
            }

            ///
            /// Kare Alma Islemi
            ///
            ///

            /// Parametre olarak gelen sayinin
            /// karesini almak için kullanilir.
            ///

            ///Karesi alinacak sayi.
            ///Parametre olarak gelen sayinin karesi.
            public static double KareAl(double Deger)
            {
                  return Deger * Deger;
            }
      }
}

Yukarıdaki örnek koddan görüldüğü üzere sınıf ve metot bildirimlerinden önce /// ile başlayan satırlarda XML formatında yorumlar yazılmıştır.VS.NET kod editörü /// karakterinden sonra

, ve etiketlerini otomatik oluşturdu. etiketini ise kendimiz yazmalıyız. XML yorum etiketleri de intellisense özelliklerinden faydalanır. Otomatik tamamlama işlemi etiketler içinde geçerlidir.

Yukarıdaki örnekte etiketi ile sınıf yada metod ile ilgili kısa bir açıklama yapılır.

etiketi içinde daha ayrıntılı bilgi verilir. Gerekirse çeşitli teknik bilgiler de bu etiket içinde belirtilir.

Şimdi C# derleyicisinin XML formatındaki yorumları kaynak koddan ne şekilde ayırdığını görmek için projeyi derleyelim. Projeyi derlemeden önce eğer VS.NET kulllanıyorsanız Proje özellikleri(Solutin Explorer’a sağ tıklayarak görebilirsiniz) penceresinden “Configuration Properties/Build” sekmesinin altındaki “XML Documentation File” kutusuna oluşturulacak XML dosyasının ismini aşağıdaki gibi yazmalısınız. Tabi VS.NET editörünün intellisense özelliklerinden faydalanmak istiyorsak XML dosyasının ismini oluşturulacak DLL ismiyle aynı verilmeliyiz.

Eğer VS.NET gibi akıllı bir editörünüz yoksa .NET Framework ile birlikte ücretsiz olarak dağıtılan ve komut satırından çalıştırılabilen C# derleyicisini kullanarak ta XML yorum dosyalarını oluşturabilirsiniz. Bunun için yapmanız gereken csc derleyicisini komut satırından aşağıdaki gibi çalıştırmaktır.

csc /t:library /doc:XmlYorum.xml XmlYorum.cs

VS.NET yada C# komut satırı ile oluşturulan XML dosyasının yapısı aşağıdaki gibidir.

Şimdi birde oluşturduğumuz Cebir isimli bir sınıfa farklı bir projeden referans verip metotlarını kullanalım. Yeni bir Console uygulaması açın ve oluşturduğumuz Cebir sınıfına ait assembly dosyasına referans verin. Eğer komut satırı derleyicisi ile çalışıyorsanız ” /r:Cebir.dll ” parametresini ekleyin. Tabi bu durumda XML yorumlarının etkisini göremeyeceksiniz. Çünkü XML yorumlarını göstermek VS.NET teki akıllı editörün bir yeteneğidir. Notepad’in yada başka text editörlerinden bu tür imkanlar beklememek lazım!

Cebir sınıfının KareAl() metodunu kullanmak istediğimizde VS.NET’teki kod editörü bize KareAl() metoduna ilişkin XML formatındaki açıklamayı sarı kutucuk içinde aşağıdaki gibi gösterecektir. Böylece kullanacağımız metodun veya sınıfın bildirimine bakmamıza gerek kalmamıştır.

Aynı durum parametreler içinde geçerlidir. Örneğin KareAl() metodunun çağrım parantezini yazdığımız anda aktif parametre ile ilgili XML açıklaması aşağıdaki gibi gösterilir.

Aynı XML yorumları VS.NET ile entegre çalışan “Object Browser” arayüzü ile de aşağıdaki gibi gösterilmektedir.

Not : “Object Browser” penceresine erişmek için (Ctrl + Alt + J) tuş kombinasyonunu kullanabilirsiniz.

Diğer XML Yorum Etiketleri

XML yorum etiketleri yukarıda anlatılanlar ile sınırlı değildir. Aşağıda kullanılabilecek standart etiketler alfabetik sıraya göre toplu bir şekilde tablo halinde açıklamalarıyla birlikte verilmiştir.

	Açıklama içindeki bir bölümün “kod fontu” şeklinde olduğunu vurgulmak için kullanılır. Örnek : /// /// Bu sınıf Stream sınıfından türemiştir. /// public class YeniSınıf { … }
	XML açıklaması içinde uzun bir kod bloğu örneği verilecekse diğer yazılardan ayırmak için kod bloğu bu etiket arasında yazılır. Örnek : /// /// Bu metod iki Kompleks türeden sayıyı toplar. Örneğin /// `/// Kompleks sayi1 = new Kompleks(5,6); /// Kompleks sayi2 = new Kompleks(0,1); /// /// Kompleks sayi3 = sayi1 + sayi2; ///` /// public Kompleks operator+(Kompleks sayi1, Kompleks sayi2) { … }
	Bir metodun yada sınıfın ne şekilde kullanılacağını açıklayan blok bu etiket içinde yazılır. `etiketinin kullanımı ile hemen hemen eşdeğerdedir. etiketini verilen örneğin aynısı etiketi içinde geçerli olduğu ayrıca bir örnek vermeye gerek yoktur.`
	Bir metodun fırlatabileceği istisnai durumlarla ilgili bilgi vermek için kullanılır. etiketi “cref” niteliği ile birlikte kullanılır. “cref” niteliği ile fırlatılacak istisnai durum(exception) sınfının türü belirtilir. Örnek : /// /// Bu metod iki Kompleks türeden sayıyı toplar. Örneğin /// /// /// /// /// /// public Kompleks operator+(Kompleks sayi1, Kompleks sayi2) { … }
	HTML kodlarındaki etiketine benzer bir amacı vardır. Liste şeklinde bir yapı oluşması gerektiği bildirilir. listedeki başlık bilgisini, listedeki her elemanı, her elemandaki terimi ve bu eleman hakkındaki detaylı bilgiyi bildirir. Örnek : /// Bu bir liste örneğidir. /// /// /// /// /// /// term 1 /// Açıklama 1 /// /// /// /// /// term 2 /// Açıklama 2 /// /// /// /// term 3 /// Açıklama 3 /// /// /// /// public class YeniSınıf { … } Not : Liste tipi() “number” olabileceği gibi “bullet” ve “table” da olabilir.
	gibi uzun açıklama bloklarında bir paragrafı belirtmek için kullanılır. Örnek : /// /// Bu sınıf Stream sınıfından türemiştir. /// /// Bu sınıf aynı zamanda IDisposable arayüzünü uygulamıştır. /// /// public class YeniSınıf { … }
	Bir metodun parametreleri ile ilgili bilgi vermek için kullanılır. Örnek : ///Toplanacak birinci sayı ///Toplanacak ikinci sayı public static double Topla(int Sayi1, int Sayi2) { return Sayi1 + Sayi2; }
	etiketleri içerisine alınan yerde aslında metodun ilgili parametresinin olduğu bildirilir. Böylece oluşacak XML yorum dosyasınıdaki bu etiketi farklı bir biçimde yorumlama şansına sahip oluruz. Örnek : /// /// Bu sınıfın , ve /// ve biçiminde iki parametresi vardır. /// public static double Topla(int Sayi1, int Sayi2) { return Sayi1 + Sayi2; }
	Üye elemanla ilgili güvenlik bilgisi vermektedir. Örneğin bir metoda yada sınıfa kimlerin erişeceği ve ne şekilde erişeceği bu etiket kullanılarak belirtilebilir. Örnek : ///Herkes bu metoda erişebilir. /// public static double Topla(int Sayi1, int Sayi2) { return Sayi1 + Sayi2; }
	Bir tür hakkında kısa bir açıklama vermek için kullanılır. Örnek : /// /// Özel cebirsel işlemleri tanımlar. /// public class Cebir { …. }
	Bir metodun geri dönüş değeri ilgili bilgi vermek için kullanılır. Örnek : /// /// Kare Alma Islemi /// /// /// Parametre olarak gelen sayinin /// karesini almak için kullanilir. /// ///Karesi alinacak sayi. ///Parametre olarak gelen sayinin karesi. public static double KareAl(double Deger) { return Deger * Deger; }
	Yazı içinde bir bağlantının(link) olacağını belirtir. “cref” niteliği ile birlikte kullanılır. “cref” niteliği bağlantının olacağı üye elemanı simgeler. Örnek : /// /// Bu metod iki Kompleks türeden sayıyı toplar. Örneğin /// /// /// public Kompleks operator+(Kompleks sayi1, Kompleks sayi2) { … }
	Yazı içinde ilgili elemanla yakından ilişkili olan diğer elemanlara bağlantı vermek için kullanılır. Kullanımı etiketi ile aynıdır. Örnek : /// /// Bu metod iki Kompleks türeden sayıyı toplar. Örneğin /// /// /// /// /// public Kompleks operator+(Kompleks sayi1, Kompleks sayi2) { … }
	Üye elemanla ilgili geniş açıklama yazmak için kullanılan bir etikettir. Örnek : /// /// Cebir sinifi bazi özel matematiksel islemleri /// yapmak için çesitli statik metotlar sunar. /// public class Cebir { … }
	Sınıfın bir üye elemanı olan özellikler (Property) hakkında bilgi vermek için kullanılır. Örnek : /// /// Kontrolün rengini belirtir. /// public int Renk { get { return a;} set { a = value;} }

Kodlarınızı XML yorumları ile süslemiyi unutmayın !…

Visual C# ile Windows Kontrolü Hazırlama

xqm26 — Fri, 10 Apr 2009 12:58:59 +0000

Simdi sizlere Visual C# NET’te bir Windows Control nasıl yapılır ve bu Windows Control’ü programlarımızda nasıl kullanırız onu göstereceğiz. Göstereceğim örneği çok basit seçtim, bunun nedeni de yaratıcılığı siz arkadaslarıma bırakmayı uygun görmemdir. Şimdi örneğimizi adım adım inceleyelim.

I. Visual Studio .NET’te yeni bir proje açalım ve Windows Control Library’yi seçelim ve adını değiştirelim(Ben burada NewControls adını verdim siz istediğiniz adı verebilirsiniz.)

II. Daha sonra Anlamlı bir isim olması için UserControl1’in adını MyTextBox olarak değiştirelim.

III. Bu değişiklikleri yaptıktan sonra MyTextBox’ın üzerine bir TextBox yerleştirelim ve onun adını da değiştirelim. Ben burada adını myTBox olarak değiştirdim.

IV. Evet şimdi MyTextBox’ın kodunu açalım ve bir TextBox’ın yapması gerektiğini düşündüğümüz özellikleri de eklemek için istediğimiz metodu buraya yazalım. Burada örnek olarak myTBox üzerindeki bilginin integer olup olmadığını control eden bir metod yazalım ve metodun dönüş değeri eğer integer değilse 0 (sıfır) olsun. Eğer dönüş değeri 1 olursa integer olsun.

V. Kod yazımını tamamladıktan sonra derleyin, eğer derlemek yerine direk çalıştırırsanız(run) asagıdaki uyarıyı alırsınız(Kısaca verdiği uyarı : “Bu Windows Control tek basına çalışamaz. Bunu baska projelerde kullanmalısınız.”) Ama sorun değil çünkü yaptıgımız Windows control’ü zaten diğer projelerde kullanmak üzere tasarladık.

Şimdi sorabilirsiniz bu Windows Control’ü projelerimizde nasıl kullanacağız? Yine adım adım anlatalım.

I. Yeni bir proje açın veya önceden var olan bir projeyi açın. Ben burada Deneme adında yeni bir proje açtım.

II. Daha sonra .Net’in Ana Proje Penceresindeki MenuBar’dan Tools’I tıklayın açılan menuItem’lardan Add/Remove ToolBoxItems’ı tıklayın.

III. Daha sonra açılan pencereden .NET Framework Components’in seçili olmasına dikkat edin. Eğer seçili değilse onu seçin. Ve Browse diyerek daha önce kaydetmiş oldugumuz NewControls projesinin içine girilelim oradan bin’e oradan da Debug’ın içine girelim. Daha sonra karşımıza çıkan NewControls.dll adlı dosyayı seçip OK tuşuna basalım. Daha sonra tekrar NET Framework Components’in seçili oldugu pencerede OK tuşuna basalım.

IV. Şimdi ToolBox’a bakalım. İste karşımızda MyTextBox’ımızın yazılı olduğu bir ToolBox’ımız oldu. Artık MyTextBox’ımızı diğer Tool’ları kullandığımız gibi kullanabiliriz.

C#’ta Inheritance(Miras) Kavramı

xqm26 — Fri, 10 Apr 2009 12:46:50 +0000

Bu yazıda inheritance’ın programlamada ne anlama geldiğinden bahsedeceğim. Inheritance aslında Oject Oriented Programming in (Nesne Yönelimli Programlama) üç prensibinden bir tanesidir. Diğer iki prensip ise encapsulation ve polymorphism’dir. Tabii ki diğer iki prensibe bu yazıda değinmeyeceğim. En sade şekliyle: inheritance sayesinde bir sınıfın metodlarını kullanan başka sınıflar türetilebilmesine yarar diyebiliriz. Ancak ayrıntılarına birazdan ineceğim. Eğer daha önce nesne tabanlı bir programlama dili kullandıysanız, (Java ve C++ gibi) C#’ta inheritance’a çok çabuk adapte olursunuz. Aslında şu ana kadar bahsettiklerim genel kültürden ibaretti ve eminim çoğunuz da bunları biliyordunuz. (Nesne Tabanlı Programlama geçmişi olmayanları da düşünerek böyle bir giriş yaptım.)

Evet şimdi ana kısma yani programın nasıl yazılacağına geliyoruz. Bunun için basit bir örnek vereceğim. Düşünün ki student adında bir sınıfımız(class) olsun. Ayrıca bir de teacher adında bir sınıfıımız olsun. Bunların ortak özellikleri nedir? Tabii ki insan olmaları diyeceksiniz ve ana sınıfımıza yani person sınıfına ulaşmış olacaksınız. Şimdi basitçe özetlersek person sınıf’ından teacher ve student adında iki sınıf türetmiş olduk. Sırada bunun kodunu nasıl yazacağımız var. Alışkanlıklara devam edip adım adım kodu yazalım. (Bunu program yazarken de ilke edinirseniz faydalı olacağına inanıyorum. Önce ne yapacağınızı adım adım belirleyin sonra belirlediklerinizi adım adım uygulamaya geçirin.)

I. İlk önce person sınıfını yazalım.

using System;

using System.Windows.Forms;

namespace Miras

{

public abstract class Person

     //sınıfın sadece türetileceğini
     //belirtmek için sınıfı abstaract keyword’ünü kullanarak soyutladık
     //Ancak burada abstaract keyword’ünün kullanılmasındaki temel

//faktör bu sınıfın abstract metod içermesidir.

{

//Türetilen sınıflarda kullanılmak üzere 3 tane değişken tanımladık.

protected string Name;

protected int Age;

protected string Gender;

//Türetilen sınıflarda metodun içi doldurulması için

//abstract olarak makeAction metodu tanımladık

public abstract void makeAction();

public Person()

{

}

}
}

II. Şimdi de Student sınıfını yazalım.

using System;

using System.Windows.Forms;

namespace Miras

{

//Student class’ı Person class’ından miras aldığını belirtiyoruz.

public class Student:Person

{

//Person sınıfında tanımlanan abstract metodu override ederek

//metodun içini istediğimiz gibi doldurduk.

public override void makeAction()

{

MessageBox.Show(”Ben bir öğrenciyim”);

}

public Student(string name,int age,string gender)

{

this.Name=name;

this.Age = age;

this.Gender=gender;

}

III. Sıra Teacher sınıfını yazmaya geldi.

using System;

using System.Windows.Forms;

namespace Miras

{

public class Teacher:Person //Teacher class’ı Person class’ından

// miras alıyor

{

private string Unvan; //Teacher sınıfında kullanılmak üzere

//Unvan adında bir değişken tanımladık.

//Person sınıfında tanımlanan abstract metodu override ederek

//metodun içini istediğimiz gibi doldurduk.

public override void makeAction()

{

MessageBox.Show(”Ben bir öğretmenim”);

}

public Teacher(string name,int age,string gender,string unvan)

{

this.Name=name;

this.Age = age;

this.Gender=gender;

this.Unvan=unvan;

}

}// teacher sınıfının sonu

}// Miras isim uzayının sonu

Şimdi dikkat edilmesi gereken noktaları sıralayalım:

I. Abstaract (soyut) sınıftan yeni bir sınıf türetilemez. Örneğimizde person sınıfı abstract sınıftır ve new anahtar sözcüğü kullanılarak yeni nesne oluşturulmaz.

II. Abstract metodların mutlaka içleri boş olarak yaratılır ve türetildikleri sınıflarda (en az bir sınıf türetilmek zorunda) mutlaka içleri override anahtar sözcüğü kullanılarak doldurulur.

III. Bir sınıftan miras yolu ile başka bir sınıf türetileceği zaman temel sınıf(base class) illa ki abstract anahtar sözcüğü ile tanımlanmak zorunda değildir. (Eğer abstract metod içermiyorsa.)

C# ‘ta Kapsülleme, Erişim Belirteçleri ve Polymorphism

xqm26 — Fri, 10 Apr 2009 12:44:20 +0000

Türkçe karşılığına gelirsek kapsülleme demek. Ancak bilgisayar terimi olarak biraz açarsak kapsülleme, yönettiği kod ve veriyi birbirine bağlayan ve bu ikisini dış kaynaklı karıştırma ve yanlış kullanımdan koruyan bir mekanızmadır. Bu sayede veriyi dış ortamdan koruyan bir ambalaj vazifesi gördüğünü de söyleyebiliriz. Şimdi kapsüllemeyi biliyoruz da C#’ta yada .Net Framework’ünde ne gibi farklılıklar var diyeceksiniz? Öncelikle .Net Framework’ünde gelen yeniliklerden bahsedelim.

I. Erişim belirteçlerinin(Access Modifiers) varlığı kapsüllemeyi çok daha rahat yapabilmemize olanak sağlar. Bu sayede bir metod veya bir değişken anahtar sözcükler(keywords) aracılığıyla sadece önceden belirlenen sınırlar dahilinde kullanılabilir. Yada bunlara belirlenen sınırlar içinden ulaşılabilir. Burada bahsedilen keyword’leri birazdan açıklayacağım. (Tabii ki C#’ta kullanılan keywordleri açıklayacağım. Ve kullanımlarını basitçe anlatacağım.)

II. Özellik(Property) Sahalarının kullanımı (Bunun yapımını ilerde C# kodu ile göstereceğim.) Bu sayede .Net Framework kapsüllemeyi destekler.

III. Soyut sınıf(abstract class) ve soyut metodların(abstract methods) kullanımı. Aslında kalıtım(inheritance) konusunu anlatırken taban sınıfımız(base class) soyut sınıf idi. Onun için bu kısmı sadece açıklayacağım. Örnek vermeyeceğim. Örneği görmek isteyenler miras(inheritance) konusunu anlattığım yazıdaki örneği incelerlerse istedikleri bilgiye ulaşabilirler.

Evet bu kadarlık giriş yeter. Şimdi yukarıda anlattığım 3 maddeyi enine boyuna tartışalım.

I. Erişim belirteçlerinin ne işe yaradıklarından yukarıda bahsettiğim için burada direkt erişim belirteçlerinin neler olduklarını yazalım ve erişim sınırlarını çizelim. Erişim sınırları geniş olandan dar olana doğru bir sıralama yaparsak.

public: Bütün her yerden erişilmek istenen veriler public anahtar sözcüğü ile birlikte kullanılır. Sadece aynı proje içerisinden değil diğer projeler içerisinden de erişilebilir.
internal: Aynı assembly içindeki tüm sınıflar erişebilir. Yani public anahtar sözcüğünün sadece aynı proje içinden erişilebileni. (VB .Net’te ise Friend anahtar sözcüğüne karşılık gelir.)
protected: Protected anahtar sözcüğü ile birlikte kullanılan verilere ise sadece bir alt sınıfa kadar erişilebilir.
private: Bu ise sadece tanımlandığı sınıfta geçerli olan veriler için kullanılır.

Ancak kontrollerde(controller) yaygın olan kullanım şekli kontrollerin dışarıdan erişilmesi istenen metodlarının(aynı anda diyelim ki 3 tane kontrol’ün belli metodlarının çalışması gerekli olabilir.) public anahtar sözcüğü kullanılan bir metod içinde tanımlanmasıdır. Şimdi bu durumun nasıl yapıldığını gösteren mini bir örnek kod yazalım. Kodda belirtilen kontrollerin daha önceden tanımlanmış olduğunu düşünelim.

public void ChangeColor(Color color)
{
    this.groupBoxLine.BackColor = color;
    this.groupBoxOutCity.BackColor = color;
    this.groupBoxExternalPriceDetails.BackColor = color;
    this.groupBoxInternalPriceDetails.BackColor = color;
    this.groupBoxUser.BackColor = color;
    this.groupBox1.BackColor = color;
    this.btnAddNewLine.BackColor = color;
    this.btnAddNewUser.BackColor = color;
    this.btnCentralReport.BackColor = color;
    this.btnChangePassword.BackColor = color;
    this.btnDeleteExternalLine.BackColor = color;
    this.btnDeleteInternalLine.BackColor = color;
    this.btnDeleteUser.BackColor = color;
    this.btnExit.BackColor = color;
}

Yukarıdaki metod bir renk parametresi gönderilerek çağrıldığı zaman yukarıda yazan bütün (daha öncede private anahtar sözcüğü ile tanımlanmış olduklarını kabul etmiştik.) kontrollerin rengini gönderilen renge değiştirmeye yarıyor. Bu sayede yukarıdaki kontrollerin hepsinin BackColor dışındaki metodları dış dünyadan soyutlanmış oluyor.

Aslında yaptığımız metod public anahtar sözcüğü ile tanımlanmayıp internal anahtar sözcüğü ile de tanımlanabilir. Bu bizim metodun içindeki kontrollere ait BackColor metodlarının dış dünyadan ne kadar soyutlanmasını istediğimiza bağlıdır.

II. Özellik sahaları sınıflara ait özel(private) değişkenlerin aynı metodlar gibi dış dünyaya açılmalarını sağlıyor. Sadece okuma amaçlı dışa açılım yapılabildiği gibi hem okuma-hem yazma amaçlı bir açılım da yapılabilir. Teorik olarak sadece yazma amaçlı da bir açılım olsa da ne kadar mantıklı olur bilmem!!!! Şimdi örneklerimize geçelim.

private int currentExNumber = -1;
private int loginStatus = 0;

public int CurrentExNumber //Sadece okuma amaçlı özellik
{
    get
    {
        return currentExNumber;
    }
}

public int LoginStatus //Hem okuma hem yazma amaçlı özellik
{
    get
    {
        return loginStatus;
    }
    set
    {
        loginStatus = value;
    }
}

Şimdi yukarıdaki özellikleri kullanırken nesneadi.LoginStatus ve nesneadi.CurrentExNumber şeklinde kullanabiliriz. Yalnız dikkat etmemiz gereken CurrentExNumber kullanılacağı zaman sadece eşit işaretinin(=) sol tarafında kullanılabilecek olması. Çünkü başta da belirttiğimiz gibi sadece okuma yapabildiğimiz için get metodu var. Zaten bir değer atamaya kalkarsak hata verecektir.(Derleme esnasında özelliğin sadece okuma amaçlı olduğuna dair debug penceresinden mesaj verir.) Bu sayede de değiştirilmesini istemediğimiz ama kullanmak zorunda olduğumuz verilerin dış ortamdan hem soyutlanmasına hem de bunların dış ortama belirli izinler dahilinde açılımına izin vermiş olduk.

III. Aslında soyut sınıf ve soyut metod’dan daha önce az da olsa miras konusunu anlatırken bahsetmiştim. Ancak şimdi biraz polymorphism’den bahsederek bu kavramları biraz daha açacağım. Polymorphism kapsülleme ve miras’dan ayrı düşünülemez. Polymorphism Yunancada “çok formluluk” anlamına gelmektedir. Polymorphism ile soyut sınıf arasındaki ilşkiden bahsetmeden önce soyut sınıf ve soyut metodlarla ilgili bir iki ayrıntı daha verelim. Soyut sınıf sadece taban sınıflarında kullanılır ve yeni nesne yaratılmasında kesinlikle kullanılamaz. (Yani new anahtar sözcüğü kullanılamaz.)

Soyut metodlara gelince bunların ise soyut sınıflarda kullanılacağından bahsetmiştik. Bunun bize sağladığı avantaj bu metodların türetilen sınıflarda nasıl gerçekleştirildiğini bilmek zorunda olmamamızdır. Aslında bunu söyleyerek polymorphism’in yararından bahsetmiş olduk. Yani polymorphism veri soyutlaması yaparak sadece ilgilenmemiz gereken olaylar ve verilerle ilgilenmemize olanak sağlıyor. Bu sayede taban sınıfından türetilen ve aynı metodu farklı gerçekleştirimlerle(implementation) kullanan birden fazla sınıfa sahip olabiliyoruz. En basit örnek üçgen bir çokgen, kare de bir çokgen ve her ikisinin de bir alanı mevcut. Hemen basitçe bir taslak çıkarırsak çokgen sınıfı soyut taban sınıfı ve alan adında soyut bir metoda sahip. Üçgen ve kare sınıfları ise türetilen sınıflar ve alan metodunu istedikleri biçimde gerçekleştiriyorlar. (Bu işlemlerin nasıl yapıldığı miras konusunu anlattığım yazıda mevcuttur.)

Bir de soyut özellikler(abstract property) var. Bunların kullanımı ise soyut metodlar ile özelliklerin birlikte kullanımı ile ortaya çıkmakta. Buna bir örnek kod verirsem anlaşılması daha kolay olacaktır. Ancak bunların kullanımına çok sık rastlamadığımı belirtmem gerekir.

Sanırım aşağıdaki örnek kod parçası soyut özelliklerin kullanımını daha da netleştirmiştir.

abstract class Taban // Soyut sınıf
{
protected int CurrentExNumber = -1;

    public abstract int GetCurrentExNumber// Soyut özellik
    {
        get;
    }
}

class Turet: Taban //Turet adlı bir sınıf türetiliyor
{

    public override int GetCurrentExNumber// overriding property
    {
        get
        {
            return CurrentExNumber+1;
        }
    }
}

Polymorphism’den bahsettik. Şimdi ise yalancı polymorphism’den bahsedelim. Aslında bir örnekle biraz daha açarsam daha net olur. Diyelim ki bir karşılaştırma metodunuz var ve hem integer hem de string veri tiplerini karşılaştırmak istiyorsunuz. Yalancı polymorphism sayesinde aynı isimde iki metod yazarak bu isteğinizi gerçekleştirebilirsiniz. Bunun için mini bir örnek kod yazalım isterseniz.

Aşağıda yazacağım metodların aynı sınıf içinde yazıldığını düşünelim. Şimdi bu metodları kullanırken metodların içinde yer aldığı sınıftan üretilen nesneninadi.karsilastir( yazdığımız anda kod tamamlayıcısı bize iki seçenek sunar biri bu metodun iki tane integer veri tipi ile çalıştığı, ikincisi ise bu metodun iki tane string veri tipi ile çalıştığıdır. Bu sayede bir arabirim ile birden fazla metod gerçekleştirilmiş olur.

Aslında bir metodun birden fazla gerçekleştirime sahip olması olayına overloading denir.

Dikkat edilmesi gereken nokta overloading ile overriding’in birbirine karıştırılmamasıdır. Unutmayın overloading’te bütün işlemler aynı sınıf içerisinde oluyor. Overriding’te ise tek bir sınıf yerine taban sınıfı ile bu sınıftan türetilen sınıflar işin içine giriyor.

public void karsilastir(int sayi1, int sayi2)
{
//Metodun iç implementasyonunu sizlere bıraktım.
}

public void karsilastir(string data1, string data2)
{
Metodun iç implementasyonunu sizlere bıraktım.
}

C# ‘da MD5 ile Veri Şifreleme

xqm26 — Fri, 10 Apr 2009 12:39:30 +0000

Bu makalemizde herhangi bir string ifadenin nasıl MD5 ile şifreleneceğini öğreneceğiz. Bu sırada web.config, Panel Nesnesi, Stored Procedure gibi konulara da değineceğiz.

Aşağıda verdiğim örnek, çoğu zaman kullandığımız Kayıt Formu ile Login Formundan oluşuyor. Kayıt olurken, email adresi ve parola bilgileri soruluyor. Bunun sonrasında parola bilgisi MD5 algoritması ile şifrelenip veritabanına veriler yazılıyor.

Login Formumuzda ise, aynı veriler istenerek, yine parolamız MD5 algoritması ile veritabanına gönderiliyor. Yani SQL’deki “Select” cümlesi aracılığı ile kontrolümüzü yapıyoruz.

Örneğimize geçmeden önce örneğimiz içerisinde kullandığımız Panel nesnemizin bazı özelliklerini inceleyelim.

Height = Panelimizin yüksekliği (pixel cinsinden)
Width = Panelimizin genişliği (pixel cinsinden)
BackColor = Panelimizin arkafon rengi
BackImageUrl = Panelimizin arkasında resim göstermek istiyorsak
BorderColor = Panelimizin sınır çizgisinin rengi
BorderWidth = Panelimizin sınır çizgisinin genişliği (pixel cinsinden)
Font = Panelimizin içerisinde gösterilecek metinlerin Font adı
Visible = Panelimizin görüntülenme ayarı (true/false değerleri alır)

Şimdi de veritabanına bağlanmak amaçlı kullandığımız bağlantı satırımızı nasıl kullandığımıza bakalım.

Klasik ASP içerisinde veritabanına bağlanmak istediğimizde bunu çoğu zaman asp dosyamızın içerisine yazıyorduk. Veya başka bir sayfaya yazıp, onu kullanacağımız sayfaya dahil ediyorduk. Hatırlarsanız bu yönteme “Include File” yöntemi deniyordu. Bu durum güvenlik açısından birçok açık ortaya çıkartmak ile beraber, yetersiz de kalıyordu.

.Net’te ise bu sıkıntılar atlatıldı. Şimdi projemiz ile ilgili birçok veriyi saklayabileceğimiz, güvenli bir dosyaya kavuştuk. İşte bu dosyanın adı web.config

Web.config dosyasının ayrıntılarını burada işleyemeyeceğim. Sadece veritabanı bağlantı satırımızı nasıl web.config sayfamıza yazmamız gerektiğini ve aspx dosyamızdan nasıl çağırıldığını göstereceğim.

Örneğin web.config dosyamızın içeriği:

Gelelim aspx dosyamızdan nasıl çağırabileceğimize:

string dbConnStr = ConfigurationSettings.AppSettings["strConn"];

Sanırım artık konumuza dönebiliriz. İlgili tüm açıklamaları kod satırları arasında anlatmağa çalıştım. Ayrıca CodeBehind yönetimi kullanarak kodladım. Bu yöntemden de kısaca bahsetmek gerekirse, CodeBehind yöntemi ile kodumuz ile görselliğimizi tamamen ayırıyoruz. Böylelikle tasarım değişikliği gibi durumlarda hiçbir sıkıntı çekmiyoruz. Örneği incelediğinizde durumu da farkedeceksiniz.

Fakat öncelikle, veritabanamızın yapısını, stored procedure ve web.config dosyamızın ilgili kodlarını verelim.

Tablomuz:

registerUser

user_id int (IDENTITY)

user_email varchar 255

user_password binary 16

Stored Procedure:

sp_ins_regUser

 CREATE PROCEDURE sp_ins_regUser

@user_email varchar(255),

@user_password binary(16)

AS

INSERT INTO

            registerUser

            (user_email, user_password)

VALUES

            (@user_email, @user_password)

GO

sp_sel_loginCheck

CREATE PROCEDURE sp_sel_loginCheck

@uemail varchar(255),

@upwd binary(16)

AS

SELECT

            user_id

FROM

            registerUser

WHERE

            user_email = @uemail AND

            user_password = @upwd

GO

Web.config

İlk önce görsel arayüzümün bulunduğu, kişinin kayıt olduğu sayfa olan:

register.aspx

<%@ Page Language="c#" Inherits="registerForm.regForm" Src="register.aspx.cs"%>

                    
                        
            
            
                        
                        
            
            
                        
                        
            
            
                        
            
            


Kayıt Formu


E-posta Adresiniz



Parolanız



"2">

Bu sayfanın kodlarını işleyen:

register.aspx.cs

 using System;

using System.IO;

using System.Web.UI; //web textbox larına ulaşabilmemiz için gereken class

using System.Security.Cryptography; //md5 için gerekli class

using System.Text; //UTF fonksiyonu için gerekli class

using System.Data; //veritabanı işlemleri için gerekli class

using System.Data.SqlClient; //veritabanı işlemleri için gerekli class

using System.Configuration; //web.config dosyamızdan veri okuyabilmek amaçlı class

namespace registerForm

            public class regForm : System.Web.UI.Page

                        //kodlamada kullanacağımız nesnelerimizi tanımlıyoruz.

                        protected System.Web.UI.WebControls.TextBox emailAdr;

                        protected System.Web.UI.WebControls.TextBox parola;

                        protected System.Web.UI.WebControls.Panel register;

                        protected System.Web.UI.WebControls.Panel registerStatus;

                        protected System.Web.UI.WebControls.Label lblInfo;

                        public void Page_Load(Object Src, EventArgs E)

                                     //sayfa yüklendiğinde panellerimizin görüntülenme ayarlarını yapıyoruz.

                                     //form ekranı ilk olarak görüntülenecek.

                                     register.Visible = true;

                                    registerStatus.Visible = false;

                                     lblInfo.Text = "";

                        //Formu Gönder butonuna tıklandığında çalışan fonksiyonumuz

                        protected void doRegister(object sender, System.EventArgs e)

                                     //girilen verileri alıyoruz.

                                     string txtEmailAdr = emailAdr.Text;

                                     string txtParola = parola.Text;

                                     //işlem sonucu göstermek amaçlı ikinci panelimizi görünür kılıyoruz.

                                     register.Visible = false;

                                     registerStatus.Visible = true;

try

                                                 //parolanız şifrelenmesi için fonksiyona gönderiyoruz.

                                                 //şifrelenmiş verimiz byte haline geleceği için değişkenimizi

                                                 //byte olarak tanımlıyoruz.

                                                 byte[] encyrptedPassword = md5Password(txtParola);

                                                 //veritabanına Email adresini ve şifrelenmiş Parolayı kayıt ediyoruz.

                                                 SqlConnection conn = new SqlConnection(ConfigurationSettings.AppSettings["strConn"]);

                                                 conn.Open();

                                                 SqlCommand sc = new SqlCommand ();

                                                 sc.Connection = conn;

                                                 sc.CommandType = CommandType.StoredProcedure;

                                                 sc.CommandText = "sp_ins_regUser";

                                                 sc.Parameters.Add("@user_email", SqlDbType.VarChar, 255, "user_email");

                                                 sc.Parameters["@user_email"].Value = txtEmailAdr;

                                                 sc.Parameters.Add("@user_password", SqlDbType.Binary, 16, "user_password");

                                                 sc.Parameters["@user_password"].Value = encyrptedPassword;

                                                 sc.ExecuteNonQuery();

                                                 conn.Close();

                                                 //try-catch bloğuna soktuğumuz işlemimizde bir sorun çıkmadı ise

                                                 //ziyaretçimizi bilgilendiriyoruz.

                                                 lblInfo.Text = "Kayıt işleminiz başarı ile gerçekleştirilmiştir";

                                     catch

                                                 //veritabanında bir hata oluştuysa ziyaretçimizi bilgilendiriyoruz.

                                                 lblInfo.Text = "Kayıt işleminiz sırasında bir hata oluştu. Lütfen tekrar deneyiniz.";

                        byte[] md5Password(string pass)

                                     //md5 şifrelenmesi için verimizin byte haline gelmesi gerekli.

                                     //veri 8-bit şeklinde dönüştürülmesi için ilk önce UTF fonksiyonuna gönderiliyor.

                                     UTF8Encoding encoder = new UTF8Encoding();

                                     //md5 şifrelemesi için nesnemizi oluşturuyoruz.

                                     MD5 md5 = new MD5CryptoServiceProvider();

                                     //verimizi md5 ile çalıştırıyoruz.

                       //dikkat ederseniz UTF fonksiyonundan dönen değeri GetBytes ile alabildik.

                                     byte[] donenDeger = md5.ComputeHash(encoder.GetBytes(pass));

                                     //şifrelenmiş değerimizi geri gönderiyoruz.

                                     return donenDeger;

Kullanıcı adı, parola verilerinin girildiği görsel sayfa olan:

login.aspx

<%@ Page Language="c#" Inherits="loginForm.Login" Src="login.aspx.cs"%>

                                       
                                     
                        
                        
                                     
                                     
                        
                        
                                     
                                     
                        
                        
                                     
                        
                        


Siteye Giriş


E-posta Adresiniz



Parolanız



lspan="2">

login.aspx.cs

using System;

using System.IO;

using System.Web.UI; //web textbox larına ulaşabilmemiz için gereken class

using System.Security.Cryptography; //md5 için gerekli class

using System.Text; //UTF fonksiyonu için gerekli class

using System.Data; //veritabanı işlemleri için gerekli class

using System.Data.SqlClient; //veritabanı işlemleri için gerekli class

using System.Configuration; //web.config dosyamızdan veri okuyabilmek amaçlı class

namespace loginForm

            public class Login : System.Web.UI.Page

                        //kodlamada kullanacağımız nesnelerimizi tanımlıyoruz.

                        protected System.Web.UI.WebControls.TextBox emailAdr;

                        protected System.Web.UI.WebControls.TextBox parola;

                        protected System.Web.UI.WebControls.Panel pnlLogin;

                        protected System.Web.UI.WebControls.Panel loginStatus;

                        protected System.Web.UI.WebControls.Label lblInfo;

                        public void Page_Load(object sender, System.EventArgs e)

                                     //sayfa yüklendiğinde panellerimizin görüntülenme ayarlarını yapıyoruz.

                       //form ekranı ilk olarak görüntülenecek.

                                     pnlLogin.Visible = true;

                                     loginStatus.Visible = false;

                                     lblInfo.Text = "";

                        //Formu Gönder butonuna tıklandığında çalışan fonksiyonumuz

                        protected void doLogin(object sender, System.EventArgs e)

                                     //girilen verileri alıyoruz.

                                     string uid = emailAdr.Text;

                                     string pwd = parola.Text;

                                     //işlem sonucu göstermek amaçlı ikinci panelimizi görünür kılıyoruz.

                                     pnlLogin.Visible = false;

                                     loginStatus.Visible = true;

                                     //parolanız şifrelenmesi için fonksiyona gönderiyoruz.

                                     //şifrelenmiş verimiz byte haline geleceği için değişkenimizi

                                     //byte olarak tanımlıyoruz.

                                     byte[] encyrptedPwd = md5Password(pwd);

                                     //veritabanına ilgili verileri göndererek kontrolümüzü yaparız.

                                     SqlConnection conn = new SqlConnection(ConfigurationSettings.AppSettings["strConn"]);

                                     conn.Open();

                                     SqlCommand sc = new SqlCommand ();

                                     sc.Connection = conn;

                                     sc.CommandType = CommandType.StoredProcedure;

                                     sc.CommandText = "sp_sel_loginCheck";

                                     sc.Parameters.Add("@uemail", SqlDbType.VarChar, 255, "uemail");

                                     sc.Parameters["@uemail"].Value = uid;

                                     sc.Parameters.Add("@upwd", SqlDbType.Binary, 16, "upwd");

                                     sc.Parameters["@upwd"].Value = encyrptedPwd;

try

                                                 //Elimizdeki verilerle çalıştırdığımız SP'mizden geri bir kolon, bir satır döndüğü

                                                 //için SqlCommand nesnesinin ExecuteScalar() metodunu kullanıyoruz.

                                                 //user_id şuanda bizim işimize yaramıyor, fakat nasıl çekildiğini göstermek amacı ile

                                                 //bu satırı da kodumuza ekledim.

                                                 string user_id = sc.ExecuteScalar().ToString();

                                                 //Email ve parola doğru ise bilgilendiriyoruz.

                                                 lblInfo.Text = "Hoşgeldiniz ";

                                     catch

                                                 //Email ve parola yanlışsa tekrar girmesini istiyoruz.

                                                 lblInfo.Text = "Yanlış E-posta Adresi/Parola. Lütfen bilgilerinizi kontrol edip tekrar deneyiniz.";

                                     conn.Close();

                        byte[] md5Password(string pass)

                                     //md5 şifrelenmesi için verimizin byte haline gelmesi gerekli.

                                     //veri 8-bit şeklinde dönüştürülmesi için ilk önce UTF fonksiyonuna gönderiliyor.

                                     UTF8Encoding encoder = new UTF8Encoding();

                                     //md5 şifrelemesi için nesnemizi oluşturuyoruz.

                                     MD5 md5 = new MD5CryptoServiceProvider();

                                     //verimizi md5 ile çalıştırıyoruz.

                                     //dikkat ederseniz UTF fonksiyonundan dönen değeri GetBytes ile alabildik.

                                     byte[] donenDeger = md5.ComputeHash(encoder.GetBytes(pass));

                                     //şifrelenmiş değerimizi geri gönderiyoruz.

                                     return donenDeger;

C# ile Yazıcı Çıktısı Alma İşlemleri

xqm26 — Fri, 10 Apr 2009 12:23:46 +0000

C# ile Windows iş uygulaması geliştiriyorsanız programınızın mutlaka yazıcı çıktısı alma bölümü olacaktır. Bu makalede C# ile nasıl yazıcı çıktısı alınabileceğinin temelleri üzerinde duracağım.

.NET sınıf kütüphanesi her alanda olduğu gibi yazıcı çıktısı alma ile ilgili bir takım sınıflar sağlamıştır. PrintDocument sınıfı yazı çıktısı alma ile ilgili en temel sınıftır. Bu yazıda bu sınıfın özelliklerini, olaylarını ve metotlarını ayrıntılı bir şekilde inceleyip tek sayfalı yada çok sayfalı yazıcı çıktısının nasıl alınabileceğini göstereceğim. Ayrıca yazıcı çıktısı alma ile çok yakından ilgili olan PrintPreview, PageSetupDialog ve PrintDialog gibi sınıflarıda inceleyeceğiz.

PrintDocument Sınıfı

Bu sınıf programlarımıza yazıcı çıktısı alma desteğini eklemek için kullanabileceğimiz en temel yapıdır. Bu sınıf türünden bir nesne yaratıldığında çıktı alma ile ilgili hemen her tür bilgiye erişmemiz mümkündür.

PrintDocument YaziciCiktisi = new PrintDocument();

şeklinde bir tanımlama yaptığımızda varsayılan yazıcı(default printer) ile çalışılmaktadır. Bir dökümanı yazıcıya göndermek için PrintDocument sınıfının Print() metodu kullanılır. Print() metodu çağrıldığı anda PrintPage olayı meydana gelir. Bu olayı yakalayan kontrol yazıcıya gönderilecek döküman üzerinde işlemler yaparak çıktının şeklini belirlemelidir. Her bir sayfa için ayrıca PrintPage olayı meydana geleceği için her bir olay içinde doğru sayfaları yazıcıya göndermek için bir takım işlemler yapmak gerekecektir. Aksi halde her defasında birinci sayfayı yazıcıya gönderme ihtimalimiz vardır. Kısacası PrintPage olayı olmadan yazıcıya çıktı bilgilerini gönderemeyiz. Bu yüzden ilk olarak PrintPage olayını ve bu olaya ait argümanları içeren PrintPageEventArgs sınıfını inceleyelim.

Önce PrintPage olayının argümanlarını içeren PrintPageEventArgs sınıfının üye elemanlarını inceleyelim, ardında bir konsol uygulamasından yazıcıya nasıl bir döküman göndereceğimizi göstereceğim.

PrintPageEventArgs sınıfnın üye elemanları :

Graphics : Yazıcıya gönderilecek döküman bilgilerini belirleyen grafik nesnesidir. Yazıcya gönderilecek bilgilerin tamamı bu nesne içerisinde belirtilecektir. Not : Graphics sınıf GDI+ kütüphanesinin en önemli sınıfıdr.

Cancel : Çıktı alma işleminin iptal edilip edilemeyeceği ile ilgili bilgi veren bool türünden bir elemandır. Eğer değeri true ise çıktı alma işlemi iptal edilecektir.

HasMorePages : Yazıcıya gönderilecek çıktının birden fazla sayfa kapladığı durumlarda PrintPage olayına ilişkin metotta bu özelliğin true olarak değiştirilmesi gerekir. Böylece bundan sonraki PrintPage olaylarında bu değişken kontrol edilerek diğer sayfaların çıktıya gönderilmesi ile ilgili işlemler yapılır.

MarginBounds : Yazıcıya gönderilen çıktı dökümanının en ve boyutlarını temsil eden Rectangle türünden bir özelliktir. Rectangle sınıfıda GDI+ kütüphanesinin bir parçasıdır. Bu özellikte yazıcıya gönderilecek çıktının sadece üzerine çizim yapılabilen kısmı belirtilir.

PageBounds : Yazıcıya gönderilen dökümanın tamamının en ve boy değerlerini tutan yine Rectangle sınıfı türünden bir elemandır.

PageSettings: İlgili dökümana ait sayfa ayarlarını tutan ve PageSettings sınıfı türünden bir elemandır. PageSettings sınıfının Color, Landscape, Margins, PaperSize, PaperSource, PrinterResolution gibi sayfa ile ilgili bilgi tutan üye özellikleri bulunmaktadır.

Şimdi basit bir örnekle yazıcıya çıktı gönderelim. Örneğimizde varsayılan yazıcınıza, sol üst köşesi (20,20) koordinatlarında eni ve boyu 100 olan bir dörtgen içeren sayfayı göndereceğiz. Gönderilecek sayfadaki dörtgeni çizmek için tahmin edeceğiniz üzere Graphics nesnesini kullanacağız.

using System;
using System.Drawing.Printing;
using System.Drawing;

class Printer
{
    static void Main()
    {
        PrintDocument PD = new PrintDocument();
        PD.PrintPage += new PrintPageEventHandler(OnPrintDocument);

         try
        {
            PD.Print();
        }
         catch
        {
            Console.WriteLine(”Yazıcı çıktısı alınamıyor…”);
        }
         finally
        {
            PD.Dispose();
        }
    }

    private static void OnPrintDocument(object sender, PrintPageEventArgs e)
    {
        e.Graphics.DrawRectangle(Pens.Red,20,20,100,100);
    }
}

Yukarıdaki programı derleyip çalıştırdığınızda hiç bir uyarı eğer verilmeden sisteminize bir yazıcı bağlı OnPrintDocument() metodunda hazırlanan içerik yazıcıya gönderilecektir. Eğer sisteminize bağlı bir yazıcı yoksa doğal olarak catch bloğundaki kod çalışacaktır.

Çizilen dörtgen nesnesinin kağıdın neresine basılacağını biz belirliyoruz. MarginBounds özelliğini kullanarak çizilecek içeriğin doğru noktaya çizilmesini sağlayabiliriz. Bu özellik sizin yazıcı ayarlarınız ile ilgili olduğu için programlama yolu ile kod içerisinden değiştirilemez. Yani bu özellik “read only” bir özelliktir. Dikkat edilmesi gereken diğer bir noktada yazıcıya gönderilecek içeriğin PageBounds özelliği ile belirtilen dörtgenin dışına taşmamasıdır. Bu yüzden çizimleri yapılırken bu özellik baz alınmalıdır.

Yukarıda yazdığımız basit programda eksiklik bulunmaktadır. Bu eksiklik çizilecek dörtgenin tek bir sayfaya sığmadığı durumlarda görülür. Söz gelimi eğer dörtgenin yüksekliğini 2000 yaparsak yazıcıdan sadece ilk kağıda sığan bölümü çıkacaktır. Birden fazla sayfası olan çıktıları yazıcıya göndermek için PrintPageEventArgs sınıfnın HasMorePages özelliği kullanılır. Bu özellik OnPrintDocument() metodu içerisinde true değerine çekilerek çıktı alma işleminin devam ettiği belirtilmelidir. Ayrıca her bir sayfanın içeriğide metot her çağrıldığında farklı bir biçimde oluşturulacağı için programcının bu ayrımı da kodlaması gerekmektedir. Örneğin yüksekliği 2000 pixel olan bir dikdörtgeni tek sayfada bastıramayacağımız için ilk sayfaya sığmayan diğer bölümleri parçalayarak her bir sayfaya sığacak şekilde ayarlamalıyız. Bu işlem için PrintPageEventArgs sınıfnın HasMorePages değişkenini kullanacağız.

Hemen diğer bölümlere geçmeden önce birden fazla sayfalı yazıcı çıktısı alma işlemine örnek verelim. Bu örnekte bir text dosyasının içeriğini yazıcıya nasıl gönderebileceğimizi inceleyeceğiz. Tabi burda yazının birden fazla sayfada olup olmadığının kontrolünü yapmamız gerekir. Yazıları yazıcı çıktısına göndermek için Graphics sınıfnın DrawString metodunu kullanacağız. Bu metot grafik arayüzüne belirli bir fontta ve font büyüklüğünde yazı yazmamızı sağlar. Önce örneği inceleyelim ardından örnek üzerinde biraz konuşacağız.

using System;
using System.IO;
using System.Drawing;
using System.Windows.Forms;
using System.Drawing.Printing;

class Printer
{
private static StreamReader dosyaAkimi;

    static void Main(string[] args)
    {
        dosyaAkimi = new System.IO.StreamReader(”C:\\Print.txt”);

PrintDocument PD = new PrintDocument();
PD.PrintPage += new PrintPageEventHandler(OnPrintDocument);

        try
        {
            PD.Print();
        }
        catch
        {
            Console.WriteLine(”Yazici çiktisi alinamiyor…”);
        }
        finally
        {
            PD.Dispose();
        }
    }

    public static void OnPrintDocument(object sender,PrintPageEventArgs e)
    {
        Font font = new Font(”Verdana”, 11) ;
        float yPozisyon = 0 ; int LineCount = 0 ;
        float leftMargin = e.MarginBounds.Left;
        float topMargin = e.MarginBounds.Top;

string line=null;

float SayfaBasinaDusenSatir = e.MarginBounds.Height / font.GetHeight() ;

        while (((line=dosyaAkimi.ReadLine()) != null) && LineCount < SayfaBasinaDusenSatir)
        {
            yPozisyon = topMargin + (LineCount * font.GetHeight(e.Graphics));
            e.Graphics.DrawString (line, font, Brushes.Red, leftMargin,yPozisyon);

LineCount++;
}

        if (line = = null)
            e.HasMorePages = false ;
        else
            e.HasMorePages = true ;

}
}

Yukarıdaki program herhangi bir text formatındaki dosyayı yazıcıya gönderek çıktı almanızı sağlayacaktır. Dosyanın içeriğini yazıcıya gönderirken çıktının ne şekilde olacağı tamamen programlama yolu ile bizim tarafımızdan yapılmaktadır. Örneğin çıktının yazı fontunu GDI+ kütüphanesinin bir sınıfı olan Font ile yazı renginide yine GDI+ kütüphanesinin Brushes sınıfının üye elemanları ile rahatlıkla değiştirebiliriz.

Yukarıdaki örnek uygulamada en önemli kısım dosya içeriğinin yazıcıyı gönderilmesi sırasında görülür. Dosya içeriğinin birden fazla sayıda sayfa içermesi durumunda dosya akımından bir sayfaya sığacak kadar satır okunmalıdır. Eğer dosya akımının sonuna gelinmediyse HasMorePages özelliği true yapılarak OnPrintDocument metodunun yeniden çağrılması gerekir. Kaynak koddanda gördüğünüz üzere dosya akımından okunan satır null değereeşit olduğunda yani dosyanın sonuna gelindiğinde HasMorePages özeliiği false yapılarak Print() metodunun icrası sonlandırılmıştır.

Bir diğer önemli nokta ise yazıcıya gönderilecek her bir sayfada kaç satırın bulunacağının belirlenmesidir. Sayfa başına düşen satır sayısı, sayfanın yazıcıya gönderilecek bölümünün yüksekliğinin yani e.MarginBounds.Height ‘in çıktıya gönderilecek yazıya ait fontun yüksekliğine bölümü ile elde edilir. Sayfa başına üşen satır sayısı elde edildikten sonra herbir sayfanın içeriği while döngüsü yardımı ile hazırlanır. Okunan satır sayısı null değere eşit olmayana kadar ve okunan satır sayısı sayfa başına düşen satır sayısı olana kadar döngüye devam edilir. Döngü içerisinde PrintPageEventArgs olay argümanlarını içeren sınıfın Graphics nesnesine DrawString() metodu yardımıyla dosya akımından okunan satır yazılır. Bir sonraki satırın çıktı ekranının neresinden başlayacağını tutmak için ise her bir satır okunduğunda yPozisyon’u kullanılan font’un yüksekliği kadar artırılır. Bütün bu işlemleri yaptıktan sonra HasMorePages özelliği ayarlanır ki sonraki sayfalar çıktıya gönderilsin. Eğer dosya sonuna gelinmişse artık basılacak sayfa yok demektir ve HasMorePages özelliği false olarak belirlenir.

Not : Dosya akımının neden OnPrintDocument() metodunun içinde tanımlanmadığını merak ediyor olabilirsiniz. Bunun sebebi OnPrintDocument() metodunun her bir sayfa için yeniden çağrılmasıdır. Eğer dosya akımını bahsi geçen metotta tanımlamış olsaydık her defasında dosya akımı baştan okunacağı için hiç bir zaman dosya akımının sonuna gelemeyecektik ve her defasında sonsuza dek ilk sayfayı çıktıya göndermiş olacaktık. Bu yüzden dosya akımını global düzey diyebileceğimiz bir noktada yani ana sınıfımın bir üye elamanı olacak şekilde tanımladık.

Aklınıza takılmış olabilecek diğer bir nokta ise yazıcının renk ayarlarıdır. Eğer yazcınız renkli çıktı almayı desteklemiyorsa DrawString() metoduna parametre olarak geçtiğimiz Brushes.Red parametresinin bir önemi olmayacaktır. Bu yüzden dökümanları yazıcya göndermeden yazcının renkli baskıyı desteleyip desteklemediğini kontrol etmek en akıllıca yöntemdir. Bu şekildeki bri kontrol için PrintDocument sınıfının PrinterSettings özelliği kullanılabilir. Bu özellik varsayılan yazcınız ile ilgili bir takım ayarları yapısında barındıran özelliklere sahiptir. Örneğin varsayılan yazıcınızın renkli bakıyı destekleyip desteklemediğini kontrol etmek için SupportsColor özelliğini aşağıdaki gibi kullanabilirsiniz. Not : SupportsColor özelliği bool türündendir.

using System;
using System.Drawing.Printing;
using System.Drawing;

class Printer
{
    static void Main()
    {
        PrintDocument PD = new PrintDocument();
        PD.PrintPage += new PrintPageEventHandler(OnPrintDocument);

         if ( PD.PrinterSettings.SupportsColor )
         {
              //renkli baskı ayarları
         }
         else
         {
              //renksiz baskı ayarları
         }

}

    private static void OnPrintDocument(object sender, PrintPageEventArgs e)
    {
        ….
    }
}

PrinterSettings yolu ile elde edebileceğimiz diğer önemli özellikler aşağıda listelenmiştir.

CanDuplex : bool türünden olan bu değişken yazıcının arkalı önlü çıktı almayı destekleyip desteklemediğini belirtir.

Copies: short türünden olan bu değişken yazıcıya gönderilecek dökümanın kaç kopya çıkarılacğını belirtir. Eğer 10 sayfalık bir döküman için bu özelliği 5 olarak girerseniz 50 adet kağıdınızı yazıcıya yerleştirmeyi unutmayın.

CanDuplex : bool türünden olan bu değişken yazıcının arkalı önlü çıktı almayı destekleyip desteklemediğini belirtir.

Duplex : Duplex enum sabiti türünden olan bu değişken arkalı önlü baskı özelliğini belirler. Duplex numaralandırması Default,Sizmplex,Horizontal ve Vertical olmak üzere dört tane üyesi vardır.

IsDefaultPrinter : PrinterName ile belirtilen yazıcının bilgisayarınızdaki varsayılan yazıcı(default printer) olup olmadığını belirtir.

IsValid : PrinterName ile belirtilenin gerçekten sisteminize ait bir yazıcı olup olmadığını belirtir.

PaperSizes : Yazıcı tarafından desteklenen sayfa ebatlarının PaperSizeCollection türünden bir koleksiyon nesnesi ile geri döner. Bu koleksiyondaki her bir eleman System.Drawing isim alanında bulunan PaperSize türündendir. PaperSize sınıfnın Width(sayfa eni), Height(sayfa boyu),Kind(sayfa türü) gibi özellikleri bulunmaktadır.

PaperSources : Yazıcı tarafından desteklenen sayfa kağıt alma kaynaklarını PaperSourceCollection türünden bir koleksiyon nesnesi ile geri döner. Bu koleksiyondaki her bir eleman System.Drawing isim alanında bulunan PaperSource türündendir. PaperSource sınıfnın Kind özelliği PaperSourceKind numaralandırması türünden bir nesne olup kağıt kaynağının tipini belirtir.Bu numaralandırmanın bazı semboleri şunlardır : Envelope, Cassette, Custom, Manuel, TractorFeed.

PrintToFile : Çıktının herhangi port yerine bir dosyaya yazdırılıp yazdırılmayacağını tutan bool türünden bir değişken. Bu değişken daha çok birazdan göreceğimiz PrintDialog ekranının görüntülenmesi sırasında değiştirilip kullanılır.

Çıktı Ön-İzleme Penceresi

Profesyonel uygulamaların tamamında yazıcıya çıktı göndermeden önce kullanıcıya ön izleme imkanı sağlanır. .NEt ortamında program geliştiriyorsanız Windows’un standart ön izleme penceresini programlama yolu ile görüntülemeniz son derece kolaydır. Bu ekranın görüntülenmesi için System.Drawing isim alanında bulunan PrintPreviewDialog sınıfı kullanılır. Bu sınıf ile ilişkilendirilmiş PrintDocument nesnesinin PrintPage olayına ilişkin metot çalıştırılarak ön-izleme penceresindeki içerik elde edilir.

Bir PrintPreviewDialog nesnesi oluşturulduktan sonra nesnenin Document özelliğine PrintDocument türünden bir nesne atanır. Ve ardından PrintPreviewControl türünden olan nesne üzerinden Show() yada ShowDialog() metotları kullanılarak ön izleme ekranı gösterilir.

Ön izleme çıktısnın görüntülendiği pencereyi elbette PrintDocument sınıfnın Print() metodunu çağırmadan önce göstermeliyiz. Daha önce yaptığımız ve dosya içeriğini yazıcıya gönderen uygulmanın Main() metodunu aşağıdaki gibi değiştirerek ön izleme ekranından çıktıya gönderilecek içeriği görüntüleyelim.

static void Main(string[] args)
{
dosyaAkimi = new System.IO.StreamReader(”C:\\Print.txt”);

PrintDocument PD = new PrintDocument();
PD.PrintPage += new PrintPageEventHandler(OnPrintDocument);

         PrintPreviewDialog pdlg = new PrintPreviewDialog();
         pdlg.Document = PD;
         pdlg.ShowDialog();

Programı yeni haliyle derleyip çalıştırdığımızda ilk önce öıktı ön izleme ekranı aşağıdaki gibi gösterilecektir. Not : Çıktıya gönderilecek dosyanın yolu örneğimiz için “C:\Print.txt” şeklinde olmalıdır.

Sayfa Düzenleme Ekranı (PageSetupDialog Sınıfı)

Dökümanı çıktıya göndermeden önce gönderme işleminin hangi yazıcı ayarları ile yapılacağını belirlemek için genellikle sayfa düzenleme ekranı gösterilir. Bu ekranda kağıt tipinden, yazcının kağıt kaynağına kadar bir çok özelliği değiştirmeniz mümkündür. Bu ekranda yapılan bütün değişiklikler PrintDocument sınıfının PrinterSettings özelliğine aktarılır. Sayfa düzenleme ekrana System.Drawing isim alanında bulunan PrintSetupDialog sınıfı ile gerçekleştirilir. Bu sınıfının kullanımı PrintPreviewDialog sınıfının kullanımı ile nerdeyse aynıdır. Bu yüzden ayrıca açıklmaya gerek duymuyorum.

Son olarak yazıcı ön izleme ekranından önce sayfa düzenleme ekranının gösterilmesini sağlamak için uygulamamaızın Main() metodunu aşağıdaki gibi değiştirin ve çalıştırın.

static void Main(string[] args)
{
dosyaAkimi = new System.IO.StreamReader(”C:\\Print.txt”);

PrintDocument PD = new PrintDocument();
PD.PrintPage += new PrintPageEventHandler(OnPrintDocument);

         PrintDialog pdiyalog = new PrintDialog();
         pdiyalog.Document = PD;
         pdiyalog.ShowDialog();

        PrintPreviewDialog pdlg = new PrintPreviewDialog();
        pdlg.Document = PD;
        pdlg.ShowDialog();

Programı derleyip çalıştırdığınızda karşınıza ilk çıkacak görüntü aşağıdaki ekran olacaktır.

Bu örnekle birlikte yazıcı çıktısı alma ile ilgili temel işlemlerin anlatıldığı yazımızın sonuna geldik. .NET teki yazıcı çıktısı alma işlemleri bu anlattıklarımla sınırlı değildir. Ancak bu yazıda anlatılanlar bu konuya çok hızlı bir giriş yapmanızı sağlamıştır. İlerleyen yazılarda görüşmek dileğiyle.

Kaynaklar :

MSDN Yardım Dökümanları

C# Düzenli İfadeler(Regular Expressions) Nedir?

xqm26 — Fri, 10 Apr 2009 12:01:56 +0000

Regular expression bir metni düzenlemek yada metin içerisinden belli kurallara uyan alt metinler elde etmek için kullandığımız bir dildir. Bir regular expression, string tipindeki karakter topluluğuna uygulanır. Sonuç olarak substringler oluşur yada orjinal metnin bir kısmını içeren değiştirilmiş yeni metinler elde edilir.

Regular Expression’larda Kullanılan Özel Karakterler ve Etkileri

Regular expression desenleri tanımlamada kullanılan özel karakterleri örnekleri ile anlatırsak sanırım regular expressionlar daha tanıdı ve kolay gelebilir.

1.) “.” Karakteri

Tek bir karakteri temsil eder(yeni satır karakteri hariç).
“CSharp.edir” şeklindeki bir desen CSharpnedir, CSharpNedir, CSharpSedir, CSharp3edir gibi stringleri döndürebilir.

2.) “[]” Karakterleri

Bir arrayi yada aralığı temsil eder.
“CSharp[SNY]edir” deseni, CSharpSedir, CSharpNedir ve CSharpYedir stringlerini döndürür.
“CSharp[a-z]edir” şeklindeki kullanım aralık belirtmeye yarar.
“CSharp[0-9]edir” şeklindeki kılanlım ise sayısal aralık belirtmeye yarar.

3.) “?” Karakteri

Kendinden önceki karakterin stringte olması yada olmamasını sağlar.
“CSharpn?edir” deseni CSharpedir yada CSharpnedir döndürür.

4.) “\” Karakteri

Kendinden sonraki özel karakterin stringe dahil edilmesini sağlar.
“CSharpnedir\?” deseni CSharpnedir? Stringini döndürür. (Eğer “\” karakterini kullanmamış olsaydık CSharpnedi yada CSharpnedir dönerdi.)

5.) “*” Karakteri

Kendinden önceki karakterin yada stringin hiç olmaması yada istediği sayıda olmasını sağlar.
“CSharpnedir*” deseni, CSharpnedi, CSharpnedir, CSharpnedirr, CSharpnedirrr, … döndürür. “CSharp(nedir)*” deseni ise CSharp, CSharpnedir, CSharpnedirnedir, … döndürür.

6.) “{}” Karakterleri

Kendinden önce gelen karakterin belirtilen sayıda tekrar etmesini sağlar.
“C{4}Sharpnedir” deseni, CCCCSharpnedir stringini döndürür.

7.) “^” Karakteri

Satır başını ifade eder.
“^CSharpnedir” deseni, satır başında “CSharpnedir” stringi varsa bunu döndürür.

8.) “$” Karakteri

Satır sonunu ifade eder.
“CSharpnedir$” deseni, satır sonunda “CSharpnedir” stringi varsa bunu döndürür.

Basit Bir Tarih Deseni Yapalım

Şimdi işin pratiğine gelelim ve adım adım tarih deseni oluşturalım. Daha sonra ise oluşturduğumuz bu tarih desenini bir konsol programında kullanalım.

Tarih desenimiz bir string içerisindeki, GG/AA/YYYY formatlarındaki tarihleri yakalayacak yapıda olsun.

Önce desenimizin GG yani tarihin gün belirtilen kısmını tanımlayalım :

“(0?[1-9])”
// 1, 2, .., 9, 01, 02, …, 09 gibi yazılmış günleri tanımlar.

“([12][0-9])”
// 10, 11, …, 29 gibi yazılmış günleri tanımlar.

“(3[01])”
// 30, 31 günlerini tanımlar.

// Bu üç tanımı OR (|) işlemiyle
// birleştirirsek gün tanımını elde ederiz.

// Gün tanımı :
“((0?[1-9])|([12][0-9])|(3[01]))”

Şimdi desenimizin AA yani tarihin ay belirtilen kısmını tanımlayalım :

“(0?[1-9])”
// 1, 2, .., 9, 01, 02, .., 09 gibi yazılmış ayları tanımlar.

“(1[0-2])”
// 10, 11, 12 aylarını tanımlar.

// Bu iki tanımı OR işlemiyle
// birleştirirsek ay tanımını elde ederiz.

// Ay Tanımı :
“((0?[1-9])|(1[0-2]))”

Şimdi desenimizin YYYY yani tarihin yıl belirtilen kısmını tanımlayalım :

“([12][0-9][0-9][0-9])”
//1000 ile 2999 yılları arasındaki tüm yılları içerir.

Ve son olarak tanımladığımız gün, ay ve yıl desenlerini “/” ile birleştirelim :

“((0?[1-9])|([12][0-9])|(3[01]))(/)(0?[1-9]|1[0-2])(/)([12][0-9][0-9][0-9]))”

Basit Bir Test Programı Yazalım

Şimdi elde ettiğimiz tarih desenini test edebileceğimiz basit bir konsol programı yazalım. Ek bilgi olarak “?” şeklindeki bir ifadeyi desenin önüne ilave ederseniz, bir desen grubu ifade etmiş olursunuz ve birkaç deseni aynı anda kontrol edebilirsiniz.

using System;

using System.Text.RegularExpressions;

class Test

{

public static void Main()

{

// Regular Expression için bir desen (pattern) tanımlıyoruz :

string tarihDeseni=@”(?((0?[1-9])|([12][0-9])|(3[01]))(/)(0?[1-9]|1[0-2])(/)([12][0-9][0-9][0-9]))”;

// Regular Expression’umuzu tanımlıyoruz :

Regex benimRegex=new Regex(tarihDeseni);

// Kullanıcıdan tarih içeren metni talep ediyoruz :

Console.WriteLine(”Lütfen içinde tarih olan bir metin giriniz :”);

// Tarih arayacağımız metni konsoldan alıyoruz :

string metin=Console.ReadLine();

// Metin içerisindeki tarihleri (birden fazla olabilir) Collection nesnesine atıyoruz :

MatchCollection benimMatchCollection=benimRegex.Matches(metin);

// Metin içindeki herbir tarihi ekrana yazdırıyoruz :

foreach(Match benimMatch in benimMatchCollection)

{

Console.WriteLine(benimMatch.Groups["tarih"]);

}

Console.Read();

}