Visual C# ile Programlamaya Giriş || C#

htt://www.csharpnedir.com adresinden alıntıdır.

Visual C#, Visual
Studio ailesinin yeni üyesidir, bu yeni dil c ve c++ temelleri üzerine kurulmasına
rağmen komponent temelli programlama tekniğini geliştirmek için birtakım yeni
özellikler eklenmiştir. C# dilinin sentaksı C ve C++ programcılarına çok tanıdık
gelecektir. Bundan şüpheniz olmasın.

Genel Açıklamalar

Bu yazıda göreceğimiz
basit uygulamada QuickSort algoritmasını kullanarak nasıl basit bir C# projesinin
oluşturulduğunu göreceğiz. Bu uygulamada bir c# programında en sık kullanılan
yapılardan olan dosyaya ve console ekranına okuma/yazma, fonksiyon oluşturma ve
basit dizilerin kullanımı açıklanacaktır.



Bu yazı kesinlikle C# dilinin tüm özelliklerinin anlatıldığı yazı değildir. Bu
yazı C# dilini öğrenmek için sizlere bir başlangıç noktası sunar.

Önerilen Kaynaklar

Visual Studio.NET
(Beta 2 veya sonrası) örnek kaynak kodu derlemeniz için gereklidir. C/C++ bilgisi
size bu yazıyı anlamanızda yardımcı olabilir ama gerekli değildir.

Adım
1. Projeye Başlama

Visual Studio ile
program geliştirme organizasyonu solution(çözüm) çalışma alanları üzerindendir. Solution
dediğimiz ortam bir veya daha fazla projeyi içerebilir. Bu makale için tek bir
C# projesi içeren bir solution oluşturacağız.

Yeni bir proje
oluşturmak

1. Visual Studio.NET
   ortamından, class=command>File | New | Project menülerini
   seçin.
   

   
   

   
   
2. Soldan(Project
   Types) Visual C#, sağdan(Templates) ise Console
   Application butonlarını seçin.
   

   
   

   
   
3. Projenizin
   adını belirleyin ve projenizin hangi klasörde saklanacağını belirleyin.Bu
   klasör Visual Studio tarafından otomatik oluşturulur.Proje adı olarak ben
   quicksort yazıyorum.Siz istediğiniz adı verebilirsiniz.
   

   
   

   
   
4. OK tuşuna basalım
   ve yola koyulalım.

"Visual C#
Solution" ortamımız

Visual Studio.NET
içinde bir Visual C# projesi bulunan bir solution oluşturdu. Proje assemblyinfo.cs
ve class1.cs adlı iki tane dosya içermektedir.

Bundan sonraki
adımlarda projemizi nasıl derleyeceğimizi ve bu iki dosya hakkında detaylı bilgiyi
öğreneceğiz.

Adım
2. Hello, World!

Kusura
bakmayın ama geleneği
bozmadan ilk defa C programlama dili ile yazılmış olan "Hello, World!" programını
c# ile yazacağız. Bu bir gelenektir ve her yeni bir dili öğrenmeye başladığınızda
bunu siz de göreceksiniz.

Kaynak Kodu Değiştirme

1. Solution Explorer
   'da bulunan 'class1.cs'dosyasına çift tıklayın. Solution Explorer 'ı göremiyorsanız,
   view menüsünü kullanarak görünür hale getirebilirsiniz.
   
2. Şablonla oluşturulmuş
   koda aşağıda kırmızı ile yazılmış kısmı ekleyin (class1.cs).
   

   using
   System;
   
   
   
   namespace quicksort
   
   {
   
       ///

   
   
       /// Summary description for Class1.
       ///
   
   
       class Class1
   
       {
   
           static void Main(string[]
   args)
   
           {
   
               //
   
               // TODO: Add code to start application
   here
   
               //
   
               Console.WriteLine
   ("Hello, C#.NET World!");
   
           }
   
       }
   
   }
   
   
   
3. Dikkat edin
   siz kodunuzu yazdıkça Visual Studio size sınıflar ve fonksiyon adları hakkında
   bilgi verir, çünkü .NET Framework tip bilgisini yayınlamaktadır.
   
   
   

   
   
   

   
   

   
   

Uygulamamızı Derleyelim

1. Programımızda
   değişiklik yaptığımıza göre artık Build menüsünden Build 'ı seçerek programımızı
   derleyebiliriz.
   

   
   

   
   
2. Hata ve mesajlar
   en altta bulunan "Output Window" denilen pencerede görünür. Eğer
   herhangi bir hata yoksa uygulamamızı Debug menüsü altında bulunan 'Start
   without Debugging' menüsüne tıklayarak çalıştırabiliriz.
   
   
   

   
   

   
   

Programımızın
Çıktısı

Aşağıda programımızın
Visual C# içinden çalıştırılarak oluşturulmuş çıktısının ekran görüntüsü mevcuttur.

Değişiklikleri
Anlamak

class=keyword>System.Console sınıfına ait WriteLine()
fonksiyonu
kendisine argüman olarak gönderilen dizgeyi sonuna satır sonu karakteri de
ekleyerek ekrana yazar.
Bu
fonksiyon integer ve floating-point gibi diğer veri tiplerini de argüman olarak
alabilir.



Program belleğe
yüklendiğinde programın kontrolu Main() fonksiyonuna gelir. class=keyword>WriteLine() fonksiyonunu oraya yazmamızın
sebebi budur.

Adım
3. Programın Yapısı

Şimdi basit bir Hello World
uygulaması geliştirmiş olduk, şimdi de bir Visual C# uygulamasının basit
componentlerini inceleyelim.

Kaynak Kod Yorumları

// karakterlerinden
sonra gelen ve satırın sonuna kadar olan sözcükler yorum satırlarıdır ve C# derleyicisi
tarafından görünmezler. Aynı zamanda birden fazla satıra yorum eklemek istiyorsak
/* */ karakterleri arasına yorum yazarız.

// Bu satır derleyici
tarafından görülmez

/* Aynı zamanda bu blok da

derleyici tarafından görünmez*/

Using Komutu

.NET Framework geliştiricilere
yüzlerce yararlı sınıflar sunar. Mesela, Console sınıfı, console ekranına ait
girdi ve çıktıları işler. Bu sınıflar hiyerarşik bir ağaç içinde organize edilmiştir.
Aslında Console sınıfının tam ismi System.Console ' dur. Diğer sınıflar ise System.IO.FileStream
ve System.Collections.Queue. içindedirler.

using komutu bize
sınıfın ismini namespace(isim alanı) kullanmadan kullanabilmemizi sağlar.

Aşağıda kırmızı ile yazılan yazılar using komutunun uygulamasının sonucudur.

using
System;

class Class1

{

    static void Main(string[]
args)

    {

        System.Console.WriteLine ("Hello, C#.NET World!");

        Console.WriteLine
("Hello, C#.NET World!");

    }

}

Sınıf Bildirimi

C++ ve Visual Basic
'den farklı olarak C# 'da bütün fonksiyonlar bir sınıf içerisinde olmalıdır. C#
'da bir sınıf tanımlamak için class anahtar sözcüğü kullanılır.Bu durumda bizim
uygulamamızda, Class1 sınıfı Main() adında bir fonksiyon içerir. Eğer sınıf bildirimini
bir isim alanı blokları içine alırsak sınıflarımızı CSharp.QuickSortApp şeklinde
bir hiyerarşi içine alabiliriz.



Sınıflar hakkında çok derin bir bilgi vermeyi düşünmüyorum.Fakat bizim örneğimizin
neden bir parçası olduğunu açıklamakta fayda gördüm.

Main() Fonksiyonu

Program belleğe yüklendiğinde
Main() fonksiyonu programın kontrolünü eline alır, bu yüzden başlangıç kodlarımızı
daima Main() fonksiyonu içinde yazmalıyız. Komut satırı argümanları ise bir string
dizisi olan args dizisine aktarılır.(mesela: delete x ) Burada programımızın adı
delete ise x bir komut satırı argümanıdır.

Adım
4. Console Girişi

Şimdi işlemlerimize
bir QuickSrot uygulaması geliştirerek devam edelim. İlk yapmamız gereken kullanıcya
hedef ve kaynak dosyasının isimlerini sormak olacaktır.

Source Code Modifications

1. class1.cs dosyasına
   aşağıda kırmızı ile yazılanları yazın. Burada sınıf ismi ve isimalanı ismi
   bizim için çok önemli değildir.
   

   // namespaces
   ekleme
   
   using System;
   
   
   
   // namespace tanımlama
   
   namespace MsdnAA
   
   {
   
       // uygulama sınıfı tanımlama
   
       class QuickSortApp
   
       {
   
           // uygulama oluşturma
   
           static void Main (string[] szArgs)
   
           {
   
               // Programın
   hakkında
   
               Console.WriteLine ("QuickSort
   C#.NET Sample Application\n");
   
   
   
               // kullanıcıdan bilgi alma
   
               Console.Write
   ("Source: ");
   
               string szSrcFile = Console.ReadLine
   ();
   
               Console.Write ("Output: ");
   
               string szDestFile = Console.ReadLine
   ();
   
           }
   
       }
   
   }
   
   

   
   

Console'dan Okuma

class=keyword>Console sınıfının ReadLine() metodu
kullanıcıya bir giriş ekranı sunar ve geriye kullanıcının girdiği dizgeyi(string)
geri döndürür.Bu metod bellek tahsisatını otomatik olarak kendi içinde yapmaktadır
ve .NET garbage collector mekanizması sayesinde iade etmeniz gereken herhangi
bir alan yoktur.

Program Çıktısı

Programı Debug
| Start Without Debugging menülerini kullanarak çalıştırın.

Aşağıda programımızın son halinin çıktısını görüyorsunuz.

Adım
5. Dizilerin Kullanımı



Programımız
sıralama yapmadan önce girişten satırları alarak bir dizi içinde saklaması gerekir.
Şimdi .NET temel sınıflarından olan ArrayList sınıfını inceleyeceğiz.

Kaynak Kod Değişikliği

1. class1.cs dosyası
   içinde aşağıda kırmızı ile gösterilen yerleri ekleyin.
   

   // isim alanı
   ekleme
   
   using System;
   
   using System.Collections;
   
   
   
   // isimalanı tanımlama
   
   namespace c#nedircom
   
   {
   
       // uygulama sınıfı tanımlama
   
       class QuickSortApp
   
       {
   
           // uygulama başlangıcı
   
           static void Main (string[] szArgs)
   
           {
   
              
   
               Console.WriteLine ("QuickSort
   C#.NET Sample Application\n");
   
   
   
               // Dosya isimlerini almak için
   komut yaz
   
               Console.Write ("Source: ");
   
               string szSrcFile = Console.ReadLine
   ();
   
               Console.Write ("Output: ");
   
               string szDestFile = Console.ReadLine
   ();
   
   
   
            
     // TODO: Read contents of source file
   
               ArrayList szContents = new ArrayList
   ();
   
           }
   
       }
   
   }
   

   
   

ArrayList sınıfının
kullanımı

ArrayList sınıfına
direkt ulaşabilmek için System.Collections isimalanını projemize using komutuyla
ekliyoruz. Bu sınıf dinamik olarak büyüyüp küçülebilen nesne dizileri için kullanılır.
Yeni bir eleman eklemek için basit bir şekilde Add() metodunu kullanabilirsiniz.
Bu diziye eklenen yeni eleman orijinal nesne için referans olarak kullanılır, ve
garbage collector alan iadesi için hazır olacaktır.

string szElement
= "insert-me";

ArrayList szArray = new ArrayList ();

szArray.Add (szElement);

Dizinin var olan bir
elemanına ulaşabilmek için, diziye ait Item() metoduna ulaşmak istediğimiz elemanın
sıra(index) numarasını geçebiliriz.Kısaca [] operatörlerini kullanarak da
istediğimiz elemana Item() metodunu kullanmadan da ulaşabiliriz.

Console.WriteLine
(szArray[2]);

Console.WriteLine (szArray.Item (2));

ArrayList
sınıfının daha birçok metodu vardır, ancak biz bu uygulamada sadece ekleme ve okuma yapacağız.
ArrayList sınıfına ait tüm metod ve özellikleri öğrenmek için MSDN kitaplığına
başvurabilirsiniz.

Adım
6. File Girdi/Çıktı(Input/Output)

Şimdi isterseniz dosyadan
okuma ve dosyaya yazma işlemlerini gerçekleştirelim. Dosyadaki her satırı okuyup,
bir string dizisinin her elemanını bir satır gelecek şekilde ekleyeceğiz.Sonraki
aşamada ise QuickSort algoritmasını kullanarak diziyi sıralı bir şekilde yazacağız.

Kaynak Kod Değişikliği

1. class1.cs dosyasına
   aşağıda kırmızı ile yazılanları yazın. Burada sınıf ismi ve isimalanı ismi
   bizim için çok önemli değildir.
   

   // isimalanı
   ekleme
   
   using System;
   
   using System.Collections;
   
   class=newcode>using System.IO;
   
   
   
   
   
   namespace MsdnAA
   
   {
   
   
   
       class QuickSortApp
   
       {
   
   
   
           static void Main (string[] szArgs)
   
           {
   
            
     string szSrcLine;
   
               ArrayList szContents = new ArrayList
   ();
   
               FileStream fsInput = new FileStream
   (szSrcFile, FileMode.Open,FileAccess.Read);
   
               StreamReader srInput = new StreamReader
   (fsInput);
   
               while ((szSrcLine = srInput.ReadLine
   ()) != null)
   
               {
   
                   // dizinin sonuna
   ekleme 
                   szContents.Add (szSrcLine);
   
               }
   
               srInput.Close ();
   
               fsInput.Close ();
   
   
   
               // TODO: Buraya QuickSort fonksiyonu
   gelecek
   
   
   
               // sıraları satırları yazma
   
               FileStream fsOutput = new FileStream
   (szDestFile,FileMode.Create, FileAccess.Write);
   
               StreamWriter srOutput = new StreamWriter
   (fsOutput);
   
               for (int nIndex = 0; nIndex <
   szContents.Count; nIndex++)
   
               {
   
                   // hedef dosyaya
   satır yazma
   
                   srOutput.WriteLine
   (szContents[nIndex]);
   
               }
   
               srOutput.Close ();
   
               fsOutput.Close ();
   
   
   
               // başarıyı kullanıcıya bildirme
   
               Console.WriteLine ("\nThe sorted
   lines have been written.\n\n");
   
           }
   
       }
   
   }
   

   
   

Kaynak Dosyadan
Okuma

Kaynak dosyayı açmak
için FileStream sınıfını ve StreamReader sınıfını kullanarak ReadLine() metodu
ile dosyayı okuyoruz. ReadLine() metodunu dosyanın sonunu ifade eden NULL değerine
geri dönene kadar çağırıyoruz.Döngü içinde okunan satırları dizinin içine ekliyoruz
ve sonrada tüm nesneleri kapatıyoruz.

Hedef Dosyaya
Yazma

Dosyaya yazarken dizinin
sıralanmış olduğunu varsaydık ve öyle devam ettik. Aynı şeklide FileStream nesnesini
ve StreamWriter sınıfını kullanarak hedef dosyaya yazma işlemini yaptık.

Adım
7. Fonksiyon Yaratma

Son aşamada diziyi
QuickSort algoritması ile sıralayan fonksiyonu yazmaya geldi. Bu fonksiyonu uygulamamızın
ana sınıfının içine koyacağız.

Kaynak Kod Değişikliği

1. class1.cs dosyasına
   aşağıda kırmızı ile yazılanları yazın. Burada sınıf ismi ve isimalanı ismi
   bizim için çok önemli değildir.
   

   // isim alanı
   ekleme
   
   using System;
   
   using System.Collections;
   
   using System.IO;
   
   
   
   
   
   namespace c#nedircom
   
   {
   
   
   
       class QuickSortApp
   
       {
   
   
   
           static void Main (string[] szArgs)
   
           {
   
               ... ... ...
   
   
   
            
     // QuickSort fonksiyonuna parametrelerin geçişi
   
               QuickSort (szContents, 0, szContents.Count
   - 1);
   
   
   
               ... ... ...
   
           }
   
   
   
           //
   QuickSort fonksiyonu
   
           static void QuickSort (ArrayList szArray, int
   nLower, int nUpper)
   
           {
   
   
   
               if (nLower < nUpper)
   
               {
   
                   // Ayırma ve sıralama
   işlemi
   
                   int nSplit = Partition
   (szArray, nLower, nUpper);
   
                   QuickSort (szArray,
   nLower, nSplit - 1);
   
                   QuickSort (szArray,
   nSplit + 1, nUpper);
   
               }
   
           }
   
   
   
           // QuickSort bölmelere ayırma
   
           static int Partition (ArrayList szArray, int
   nLower, int nUpper)
   
           {
   
               // İlk elemanı bulma
   
               int nLeft = nLower + 1;
   
               string szPivot = (string) szArray[nLower];
   
               int nRight = nUpper;
   
   
   
               // Dizi elemanlarını bölme
   
               string szSwap;
   
               while (nLeft <= nRight)
   
               {
   
                  
   
                   while (nLeft <=
   nRight)
   
                   {
   
                       if
   (((string) szArray[nLeft]).CompareTo (szPivot) > 0)
   
                        
     break;
   
                       nLeft
   = nLeft + 1;
   
                   }
   
                   while (nLeft <=
   nRight)
   
                   {
   
                       if
   (((string) szArray[nRight]).CompareTo (szPivot) <= 0)
   
                        
     break;
   
                       nRight
   = nRight - 1;
   
                   }
   
   
   
                   // Eğer uygunsa
   yer değiştirme işlemi yap
   
                   if (nLeft < nRight)
   
                   {
   
                       szSwap
   = (string) szArray[nLeft];
   
                       szArray[nLeft]
   = szArray[nRight];
   
                       szArray[nRight]
   = szSwap;
   
                       nLeft
   = nLeft + 1;
   
                       nRight
   = nRight - 1;
   
                   }
   
               }
   
   
   
               szSwap = (string) szArray[nLower];
   
               szArray[nLower] = szArray[nRight];
   
               szArray[nRight] = szSwap;
   
               return nRight;
   
           }
   
       }
   
   }
   

   
   

QuickSort() Fonksiyonu

Bu fonksiyon alt sınır,
üst sınır ve bir dizi olmak üzere 3 tane parametre almaktadır. QuickSort fonksiyonu
Partition() fonksiyonunu çağırarak diziyi iki parçaya ayırır. Bu parçaların birinde
belirlenen bir diziden önceki ,diğer parçasında ise sonraki elemanlar bulunur.
Sonra fonksiyon tekrar kendini çağırarak bu iki parçanın sıralanmasını sağlar.

Yukarıdaki kodlarda
yeni gördüğümüz metod CompareTo() metodudur. Bu metod iki string ifadesini karşılaştırır.

QuickSort Uygulamasını
Çalıştırma

Bu adım uygulamamızın
son adımı olacaktır.Şimdi programımızı derleyip çalıştırabiliriz. Programımızın
çalışması için bir text dosyası oluşturmamız sıralama yapabilmek için gerekecek.
Exe dosyasının bulunduğu dizini text dosyasını oluşturup programı çalıştıralım.

Programın Çıktısı

Aşağıda programımızı
çalıştırdıktan sonraki ekran çıktısı mevcuttur. Yukarıdaki ekranda ise output.txt
dosyasında meydana gelen değişiklikleri görebilirsiniz.

Adım
8. Debugger Kullanmak

Debugger aracı programımızın
problemlerini çözmek için önemli ve gerekli bir araçtır. İyi bir başlangıç yaptığımıza
göre son aşamada programımız içinde nasıl dolaşacağımıza ve QuickWatch' ı nasıl
kullanacağımıza bakalım.

Breakpoint' leri
Ayarlama

Program Debugger içinde
çalışırken eğer breakpoint olan bir noktaya gelinirse program sonlandırılır ve
debugger control 'ü bizim elimize geçer. Herhangi bir satıra breakpoint koymak
için ilgili satıra sağ tıklayıp aşağıdaki gibi Insert BreakPoint menüsüne tıklayın.

BreakPoint bulunan
satırlar kırmızı ile gösterilir. BreakPoint ' i kaldırmak için ilgili satıra
sağ tıklayıp Remove BreakPoint menüsünü seçin.

Program içinde
Adım Adım ilerlemek

Aşağıdaki şekilde
görüldüğü gibi bir breakpoint oluşturduktan sonra debugger ile programımızı çalıştıralım.
Debug menüsünden daha önceden de yaptığımızı gibi class=command>Start Without Debugging yerine Start
menüsüne tıklayın. Bu şekilde programı çalıştırdığımızda program debugger ile
çalışmaya başlayacaktır, ve breakpoint 'ler aktif olmaya başlayacaktır.



Program breakpoint 'in olduğu noktaya geldiğinde, debugger programın kontrolünü
alır. Aşağıdaki şekilde görüldüğü gibi sarı okla programın geldiği nokta gösterilir.

Kod içinde adım
adım ilerlemek için menü çubuğundan Debug | Step Over ' ı seçerek sarı okun
hareketini izleyin. class=command>Debug | Step Into komutu gitmek istediğimiz
fonksiyona gitmemizi sağlar. Aşağıda iki defa Step Over menüsünü seçtikten sonra
kaynak kodumuzun görüntüsü mevcuttur.

Eğer programımızın
diğer bir sonlandırıcı nedene (yeni bir breakpoint, exception , exit, debug)
gelene kadar devam etmesini istiyorsanız Debug | Continue menülerini seçin.

Değişken Değerlerini
Takip Etme

Debugger 'ın kontrolü
bizde iken farenin imlecini kaynak kodda istediğimiz değişken üzerine götürerek
değişkenin o anki değerini öğrenebiliriz.

Aynı zamanda bir
değişkene sağ tıklayarak QuickWatch menüsünü açabilirsiniz. QuickWatch ile değişken
hakkında daha detaylı bilgiler elde edebilirsiniz. Mesela diziler hakkında aşağıdaki
şekilde görüldüğü gibi bilgiler elde edilebilir.

Diğer Debugger
Araçları

Visual Studio yukarıda
bahsettiğimiz araçları dışında farklı araçlarda barındırır. Mesela Call Stack
Wiever aracı ile o an hangi fonksiyonun çağrıldığı ile ilgili bilgiyi elde edebilirsiniz.
Bellekteki değerleri ve bir prosesteki thread 'leri de aynı anda görebileceğimiz
araçlar mevcuttur.

Son Söz &
Sonuç

Bu yazının amacı sizlere
Visual Studio ile nasıl basit bir uygulamanın yapılacağını adım adım göstermekti.
Diğer .NET ve C# kaynaklarını araştırmak için sizi cesaretlendirebildiysek ne
mutlu bize. Bu yazıyı buraya kadar okuduğunuza göre en azından şu aşamada çalışan
bir projeniz var, istediğiniz gibi üzerinde değişiklikler yapıp sonucu görebilirsiniz.

Bu yazı "Microsoft MSDN Magazine" 'den Türkçeye
tercüme edilmiştir.

Göstericiler(Pointers) Kullanmak || C#

Göstericiler(Pointer) alt seviye programlama için olmazsa olmaz yapılardır. Göstericiler nesnelerin bellekte tutuldukları adresleri saklayan veri yapılarıdır. Bu makalede C#'ta kullanımı çok fazla gerekli olmayan göstericilerin nasıl kulanıldıklarını inceleyeceğiz. Bu yazı göstericiler hakkında temel bilgilere sahip olduğunuzu varsaymaktadır.

.NET' in altyapısında gösterici kavramı sıklıkla kullanılırken göstericilerin açıkca kullanımı programcılar için gizlenmitir. Bunun nedeni gösterici kullanımının programlardaki görülemeyen hatalara sıkça yol açabilmesidir. Özellikle dili yeni öğrenenler için gösterici hataları içinden çıkılmaz bir hale gelebilmektedir. C#'ta göstericiler yerine referans değişkenleri mevcuttur. Referanslar heap bellek bölgesindeki nesnelerin başlangıç adresini tutar. Ancak bu adresin değerine kesinlikle ulaşamayız. Oysa C ve C++ dillerinde stack bölgesindeki değişkenlerin de adreslerine erişbilmemiz mümkündür. Üstelik değişkenlerin adreslerini örneğin 0x965474 şeklinde elde etmemiz bile mümkündür. C ve C++ programcılarına pek yabancı gelmeyecektir bunlar, ancak programlama dünyasına C# ile giren biri için göstericilere neden ihtiyaç duyabileceğimiz pek anlamlı gelmeyebilir. Şunu da söyeleyelim ki çok istisnai durumlar dışında göstericilere ihtiyacımız olmayacak, peki bu istisna durumlar nelerdir?

* Geriye Uyumluluk(Backward Compatibility) : COM ve WinAPI'deki fonksiyonlar gibi sık sık gösterici kullanan fonksiyonları C# ile programlarımızdan çağırabilmek için parametre olarak gösterici alan fonksiyonlara gösterici göndermemiz gerekebilir. Eğer C# ta gösterici kullanımına izin verilmemiş olsaydı tür uyumsuzluğu yüzünden gösterici kullanan eski COM ve DLL'lere erişebilmemiz mümkün olamazdı.

* Performans : C ve C++ dillerinin günümüze kadar çok popüler olmasının altında yatan nedenlerden biri de belleğe direkt erişimi sağladığı içinperformansın inanılmaz derecede yükselmesidir. Bizim için performansın çok önemli olduğu yerlerde gösterici kullanmamızdan daha doğal birşey olamaz.

* Alt Seviye İşlemler : Donanım arayüzleri ile direkt bir ilişki içerisinde olacak programlarda göstericilerin kullanımı mecburi gibidir. Bazen de belleğe kullanıcıların direkt erişebilmesi gereken programlar olabilir. Bu durumlarda da göstericilerden faydalanabiliriz.

Bütün bunların yanında gösterici kullanmanın bir çok sıkıntıyıda beraberinde getireceği kesindir. Öncelikle kullanımının zor olması ve kestirilmesi zor olan hatalara yol açabilmesi bu sıkıntıların en başında gelenidir. Zaten C#'ta gösterici kullanacağımız zaman kodu unsafe(güvensiz) anahtar sözcüğü ile işaretlememiz gerekir. Aksi halde program derlenemeyecektir. Normal bir metot içinde gösterici kullanımı yasaklanmıştır.

Şimdi de unsafe anahtar sözcüğünün kullanımına örnekler verelim.

1-) unsafe olarak işaretlenen sınıfların bütün metotlarında gösterici kullanabiliriz.

unsafe class Sınıf
{

}

2-) Normal bir metot içinde herhangi bir bloğu unsafe olarak aşağıdaki gibi işaretleyip dilediğimiz gibi gösterici kullanabiliriz. unsafe bloklarının dışında ise gösterici kullanamayız.

int NormalMetot(int a, string str)
{
unsafe
{

}
}

3-) Normal bir metodu unsafe olarak işaretleyip sadece o metodun içinde de gösterici kullanabiliriz.

unsafe int NormalMetot(int a, string str)
{

}

4-) Bir sınıfın üye değişkenlerinden biri unsafe olarak işaretlenip gösterici olarak bildirilebilir. Ancak bir metot içerisinde yerel bir gösterici tanımlanamaz. Yerel bir gösterici tanımlamak için unsafe olarak işaretlenmiş metod yada blok kullanılır.

class Sınıf
{
unsafe char *ptr;
}

Gösterici Tanımlama ve Gösterici Operatörleri

Göstericiler aşağıdaki gibi tanımlanabilir.

char* ptr1, ptr2;
int* ptr3;

ptr1 ve ptr2 char türden bir gösterici iken ptr3 int türden bir göstericdir. Bir göstericide iki bileşen vardır. Bu bileşenlerden birincisi adres bileşenidir. Adres bileşeni nesnenin bellekte bulunduğu başlangıç adresidir. İkinci bileşen ise tür bileşenidir. Bu bileşen ise ilgili adresteki nesneye ulaşmak istediğimizde bellekten ne kadarlık bilgili okunacağını sağlar. Örneğin int türden bir adresteki bilgiyi okumak istediğimizde 4 byte'lık bir bilgi okunacaktır, aynı şekilde char türden bir gösterici ise 2 byte'lık bir bilgi okunacaktır.

& operatörü

Adres operatörü olarak bilinen bu operatör değişkenlerin veya nesnelerin bellekte bulundukları adresleri elde etmek için kullanılır. Bu operatör hangi tür değişkenle kullunılırsa o türden bir gösterici üretilir.

* operatörü

İçerik operatörü olan *, bir adresteki bilgileri elde etmek için kullanılır. Aşağıdaki programda bu iki operatörün kullanımına bir örnek verilmiştir.

using System;

class Class1
{
unsafe static void Main()
{
int* ptr1;
char* ptr2;

int a = 50;
ptr1 = &a;
int Adres = (int)ptr1;
Console.WriteLine("{0:X}",Adres);

char ch = 'A';
ptr2 = &ch;
*ptr2 = 'B';
Console.WriteLine(ch);
}
}

Bu programı derleyebilmek için komut satırı derleyicisene programın içinde unsafe bloğunun olduğunu belirtmemiz gerekir. Bunun için komut satırına

csc /unsafe KaynakKod.cs

yada

csc -unsafe KaynakKod.cs

yazarak programı derleyebilirsiniz. Eğer Visual Studio.NET kullanıyorsanız projeye sağ tıklayıp proje özelliklerine gelip Build kısmından "Allow unsafe code blocks" kısmını true olacak şekilde değiştirin.

Programı çalıştırdığınızda ekrana a değişkeninin adresi ve B karekteri yazılacaktır. Adres bilgisini ekrana yazdırmadan önce göstericide tutulan adresi normal bir türe nasıl dönüştürdüğümüze dikkat edin. Bunu yapmamızın sebebi Consol.WriteLine() metodunun gösterici parametres alan versiyonunun olmamasıdır.

C#'ta tür güvenliğinin ne kadar önemli olduğunu vurgulamak için aşağıdaki deyimleri örnek verebiliriz.

int* ptr1;
*ptr1 = 50;

Bu deyimleri içeren bir program derlenemeyecektir. Çünkü ptr1 göstericisinde hangi adresin tutulduğu belli değildir. Bu yüzden adresi belli olmayan bellek bölgesine bir değer yerleştirmek imkansızdır. C ve C++ dillerinde bu kullanım tamamen geçerlidir. Ama gelin bir de bunun sakıncasına bir göz atalım. ptr1 göstericisi tanımlandığında ptr1 de rastgele bir adres değeri bulunmaktadır. Bu adreste rastgele bir adres olduğu için o an bellekte çalışan kendi programımızdaki bir değişkenin adresi bile olabilir. Yada sistemde çalışan başka bir prosesteki elemanların adresleri olabilir. Kaynağını bilmediğimiz bir adresteki değeri * operatörü ile değiştirdiğimizde hiç tahmin edemeyeceğimiz çalışma zamanı hataları alabiliriz. İşin kötüsü adresler rastgele olduğu için programımızın test aşamasında bu hatalar oluşmayabilir. Adresler nasıl rastgele ise hataların oluşması da rastgeledir. Programımız piyasada iken böyle bir hatanın farkına varılması iş maliyetlerini ne kadar artırdığını siz tahmin edin artık. Bütün bu dezavantajlar göstericilerin asla gereksiz olduğu anlamına gelmemelidir. Sadece göstericileri kullanırken daha dikkatli davranmamız gerektiğinin göstergesidir.

Göstericiler arasında tür dönüşümleri mümkündür. Örneğin int türden bir gösterici char türden bir göstericiye aşağıdaki gibi dönüştürülebilir.

char* ptr1
int* ptr2;

ptr1 = (char*)ptr2

Aynı şekilde bir gösterici de tamsayı türlerine dönüştürülebilir. Adresler tam sayı türünden birer sayı oldukları için bunu yapabilmemiz son derece normal bir durumdur. Bir önceki çalışan programda da Console.WriteLine() metodu ile ekrana yazmak istediğimiz nesnenin adresini tamsayı türlerinden birini çevirdiğimizi hatırlayın. Örneğin aşağıdaki deyimleri içeren bir program derlenemeyecektir.

char* ptr1
char ch = 'A';
ptr1 = ch;

Console.WriteLine(ptr1)


Göstericilerle ilgili diğer önemli yapı ise void göstericilerdir. void olan göstericilerde tür bilgisi saklanmamaktadır. void göstericilere herhangi bir türden gösterici atanabilir. void göstericiler daha çok eskiden yazılmış API fonksiyonlarında void parametre alan fonksiyoları programlarımız içerisinden çağırmak için kullanılır. void göstericilerin kullanımına aşağıda bir örnek verilmiştir.

int* ptr1;
void * x;
x = ptr1;

sizeof operatörü

sizeof operatörü temel türlerin ve yapıların bellekte ne kadar alan kapladıklarını verir. Örneğin sizeof(int) = 4, sizeof(char) = 2 ' dir. sizeof operatörünü sınıflar için kullanamayız ancak tanımlayacağımız yapılar için kullanabiliriz.

Bu yazının sonuna geldik. Bir sonraki yazımızda yapı göstericileri tanımlamayı sınıflar ile göstericiler arasındaki ilişkiyi, gösterici aritmetiğini inceleyip örnek bir gösterici uygulaması yapacağız.

Web Servisleri ile GDI+ Kullanımı || C#

GDI+, .NET Framework altyapısının grafik işlemlerini yapmak için sunduğu bir kütüphanedir, windows uygulamalarındaki bir çok kontrol bu arayüzdeki metotların ve sınıfların kullanılmasıyla yaplır, zaten "User Control" dediğimiz kullanıcı tanımlı kontrollerde de sıklıkla GDI+ kütüphanesi kullanılmaktadır. Bu yazıda GDI+ ve Web Servislerini birleştirip grafik uygulaması örneği yapacağız. Peki nasıl? Öncelikle bir web servisimiz olacak. Bu web servisi kendisine gönderilen bir takım veriler dahilinde işlemler yapıp bize bilgilerin grafiğine ilişkin resmin verilerini gönderecek. Bu veriler çok çeşitli biçimlerde olabilir. Bizim uygulamamızda resim bilgisi byte dizisi şeklinde olacaktır. Web servisine bağlanan client, aldığı resim verilerini istediği şekilde kullanabilir. Bu yazıdaki uygulamada web servisine bağlanan bir ASP.NET sayfası olacak. ASP.NET web sayfası, web servisinden aldığı resim bilgisini bir dosyaya kaydedip yapısındaki bir "Picture" kontrolünde görüntülenmesini sağlayacak.

Web Servisinin Oluşturulması

Yeni bir web servisi projesi başlatın ve adını GDIPasta olarak verin. Çünkü bu web servisinden beklentimiz kendisine gönderilen bilgilere ait pasta şeklindeki grafiğin resim bilgilerini göndermektir. GDI+ kütüphanesindeki System.Drawing ve System.Drawing.Imaging isim alanlarını using ile kaynak kodun başına ekleyin. Muhtemelen bu işlemi yapmadan önce "Add Reference" menüsünden System.Drawing.dll Assembly'sine referans vermeniz gerekecektir.

Web servisimize yeni bir metot ekleyelim ve adını GrafikPasta olarak verelim. Bu metot parametre olarak integer türden bir dizi alacaktır. Metodun geri dönüş değeri ise byte türden dizi olacaktır. Parametre olan integer türden dizi grafiği çizilecek vwerileri temsil etmektedir. Geri dönüş değeri ise web servisinin oluşturduğu resmin byte dizisi şeklindeki temsilidir.Neden resmin kendisini oluşturup resmin URL'sini göndermiyoruz da resmin kendisini gönderiyoruz? Bu şekilde yapmamızın özel bir nedeni yok, sizin geliştireceğiniz uygulamanın ihtiyacına göre bu durum değişebilir. Burada önemli olan gelen verilere göre resmi nasıl çizeceğimizdir.

DipNot : Eklediğiniz metodu WebMethod niteliği ile bildirmeyi unutmayın.

Pasta şeklindeki grafikler çizmek için Graphics sınıfın FillPie() ve DrawPie() metotları kullanılmaktadır. Bu iki metodunda parametrik yapısı benzerdir. Tek fark FillPie() metodunun ilk parametresi Brush DrawPie() metodunun ki ise Pen türünden olmasıdır. Bu iki metodun diğer parametreleri ise çizilecek pasta diliminin açısı, pasta diliminin hangi açıdan itibaren çizileceği, dilimin çizileceği grafik nesnesi üzerinde nerden itiabaren çizileceği gibi verilerdir. Bu iki metodun parametreik yapısı ile ilgili ayrıntılı bilgiyi MSDN kütühanesinden öğrenebilirsiniz.

Web metodunu yazmadan önce metodun genel işleyişi hakkında bilgi vermek istiyorum. Metoda parametre olarak gelen her bir sayının toplam sayılar üzerindeki yüzdesi hesaplanır ve bu yüzdelere karşılık düşen açılar hesaplanır. Her bir dilimi çizmeden önce bir önceki dilimin açısı toplam açıya eklenir ve böylece bir sonraki dilimin hangi açıdan itibaren çizileceği belirlenmiş olur.

Çizilen pasta grafiğiniz resim olarak geri döndürmek için Bitmap, Graphics ve MemoryStream(System.IO) sınıfları kullanılacaktır. Teorik olarak yeni bir Bitmap nesnesi oluşturulur. Bu resime ilişkin Graphics nesnesi Graphics.FromImage() metodu ile elde edilir. Graphics nesnesinin metotları(FillPie,DrawPie) kullanılarak Bitmap nesnesi hazırlanır ve ardından Bitmap.Save() metodu ile resim bilgisi MemoryStream nesnesine aktarılır. Son olarak MemoryStrem.ToArray() metodu ile resim bilgisi byte dizisne çevrilir ve geri döndürülür.

Bütün bu bilgiler ışığında web metodu aşağıdaki şekilde yazılmıştır.

[WebMethod]
public byte[] GrafikPasta(int[] Dizi)
{
MemoryStream PastaStream = new MemoryStream();

int Width,Height,Margin;
Height = Width =300;

Margin = 20;

int [] Bilgiler = Dizi;

int YariCap = (Width - Margin)/2;

int Cap = Width - Margin;

int UsttenBaslangic = (Height/2) - YariCap;

int SoldanBaslangic = (Width/2) - YariCap;

int Toplam = 0;

for(int i=0; i< Bilgiler.Length; i++)
Toplam += Bilgiler[i];

SolidBrush[] renkler = {
new SolidBrush(Color.Red),
new SolidBrush(Color.Blue),
new SolidBrush(Color.Yellow),
new SolidBrush(Color.HotPink),
new SolidBrush(Color.Green),
new SolidBrush(Color.Magenta)
};

Bitmap resim = new Bitmap(Width,Height);

Graphics g = Graphics.FromImage(resim);

g.FillRectangle(Brushes.White,0,0,resim.Width,resim.Height);

float pastaAci = 0, toplamAci = 0;

Pen p = new Pen(Color.Red,8);

int fircaNo;

for(int i=0; i< Bilgiler.Length; i++)
{
pastaAci = (Convert.ToSingle(Bilgiler[i]) / Toplam) * 360;

fircaNo =i % renkler.Length;

g.DrawPie(p,SoldanBaslangic,UsttenBaslangic,Cap,Cap,toplamAci,pastaAci);

g.FillPie(renkler[fircaNo],SoldanBaslangic,UsttenBaslangic,Cap,Cap,toplamAci,pastaAci);

toplamAci += pastaAci;
}

resim.Save(PastaStream,ImageFormat.Jpeg);

return PastaStream.ToArray();
}

Dikkat ettiyseniz resim.Save() metodu ile resmin hangi formatta saklanacağı belirtilmiştir. Ben Jpeg formatını seçtim, sizler isterseniz diğer formatları seçebilirsiniz. Tabi istemci uygulamamız bir web sayfası olduğu için web sayfasında görüntüleyebileceğimiz bir resim formatı seçmeniz doğru olacaktır.

Şimdi sıra web servisine bağlanacak olan istemciyi yazmaya geldi. Öncelikle var olan bir projeye yeni bir ASP.NET projesi ekleyin. Ardından bu eklediğiniz projede web servisine referans vermek için "Add Web Reference" menüsünü seçin ve web servisinin URL'sini girin. Web servislerinin kullanımı ile ilgili eksikleriniz varsa daha önce yazmış olduğum web servisleri makalelerini okumanızı tavsiye ederim.

ASP.NET sayfasında yapmamız gerekenler şunlardır : Web servisine gönderilecek bilgilerin elde edilmesi ve web servisinden dönecek byte disinin resime çevrilerek bir resim kontrolü üzerinde gösterilmesi. Web servisine gönderilecek bilgileri elde etmek için sayfa bir TextBox ve Button ekleyin. TextBox'tan girilen sayı değerleri resim bilgisini oluşturacak değerler olsun. Bu sayılar boşluk karakteri ve '-' karakteri ile ayrılacaktır. Web servisinden dönecek resim bilgisini göstermek içinde sayfa bir Image kontrolü ekleyin. Sayfamızın altyapısı bu şekilde hazır olduğuna göre byte dizisinin nasıl resme çevireceğimiz üzerinde konuşalım : Tabii ki yine GDI+ kütüphanesinden faydalanacağız. Bu yüzden System.Drawing ve System.Drawing.Imaging isim alanlarını eklemeyi unutmayın. Kullanacağımız sınıf Bitmap ve System.IO da bulunan MemoryStrem' dir. Öncelikle TextBox'tan sayılar ayıklanır ve int türden bir diziye aktarılır. Bu dizi web metodunun GrafikPasta() isimli metoduna geçirilir. Web metodundan dönen byte dizisi kullanılarak yeni bir MemoryStream nesnesi oluşturuluır. Oluşturulan bu MemoryStream nesnesi ile yeni bir Bitmap nesnesi oluşturulur ve Bitmap.Save() metodu ile resim istenilen formatta diske kaydedilir. Ve ardından diske kaydedilen resim Image kontrolünün ImageUrl özelliğine atanır.

Yukarıda anlatılan bütün işlemler aşağıdaki gibi Button kontrolünün Click metodu içinde yapılacaktır.

private void Button1_Click(object sender, System.EventArgs e)
{
byte[] bytes;

System.IO.MemoryStream PastaGrafik;

char[] sep = {' ','-'};

string[] str = TextBox1.Text.Split(sep,100) ;

int[] Dizi = new int[str.Length];

for(int i=0; i< Dizi.Length;i++)
{
Dizi[i] = Convert.ToInt32(str[i]);
}

Service1 ws = new Service1();
bytes = ws.GrafikPasta(Dizi);

PastaGrafik = new System.IO.MemoryStream(bytes);

Bitmap Resim = new Bitmap(PastaGrafik);

string url = @"C:/PastaGrafik.jpeg";

Resim.Save(url,ImageFormat.Jpeg);

Image1.Width = Resim.Width;
Image1.Height = Resim.Height;
Image1.ImageUrl = url;
Image1.Visible = true;

Resim.Dispose();
}

Bir dizin içindeki dosyaların bulunması || C#

Merhaba bu yazımızda günümüz işletim sistemlerinin temeli olan dosya bulma kavramını göreceğiz.Özellikle Windows ve Linux türevi işletim sistemlerinde özel bir dosya türü vardır. Bu dosya türü genellikle klasör olarak bilinir.Klasör dışındaki diğer dosyalar klasörler içinde saklanabilir. Bir dosyanın işletim sistemi modülü içinde bulunabilmesi için dosyanın dereceli yol bilgisine ihtiyacımız vardır. Mesela "C" sürücüsünün altında "xxx.dat" dosyasının dosya yolu bilgisi yani path bilgisi şöyle ifade edilir : "c:\\xxx.dat" . Burdan yola çıkarak bizim bu yazı çerçevesi içerisinde yapacağımız şey kullanıcıdan aldığımız bir veri yolu bilgisi içindeki dosyaları bulmak ve ekrana yazdırmaktır.

Basit programımızı geliştirmeye başlamadan önce biraz ön bilgi konuyu kavrayabilmemiz için iyi olacaktır. Bildiğiniz gibi bir sıra içindeki dosyaların elde edilmesi sistem programlamada ve uygulamada büyük öneme sahiptir.Örneğin; bir dosyanın dizin ağacında aranması, dosyalara toplu işlemlerin yapılması ya da dizinin sıralı bir şekilde gösterilmesi gibi uygulamalar az sonra öğreneceğimiz basit algoritma ile gerçekleştirilir.

Sıra yapıları ve dosyalama organizasyonu işletim sistemine özgü olduğu için her fakrlı işletim sisteminde dosya bulma işlemini yerine getiren farklı fonksiyonlar vardır. Bu tür işletim sistemine özgü olan fonksiyonlara genel olarak "sistem fonksiyonları" denir. Zaten bizde bu yazımızda Windows işletim sistemine ait sistem fonksiyonlarını kullanacağız.

Şimdi DOS altında dizin içinde dosya arama yapan findfirst ve findnext fonksiyonlarını tanıyalım:

findfirst fonksiyonu

findfirst fonksiyonunun prototip bilgisi başlık dosyası içinde bulunur.Bu fonksiyonun prototipi aşağıdaki gibidir;

int findfirst(const char *dosy_yolu,struct ffblk * ffblk,int attrib)

Örnek:

findfirst("c:\\windows\\sefer.dat" , &ffblk , 0);

İlk parametre dosyaların aranacağı ’path’ bilgisinin saklanacağı karekter dizisidir.İkinci parametre çeşitli dosya bilgilerinin saklandığı 6 elamanlı ve dir.h başlık dosyası içinde tanımlanmış bir yapı nesnesi türünden bir adrestir. struct ffblk türünün yapısı şu şekildedir.

struct ffblk{
char ff_reserved[21];
char ff_attrib;
int ff_ftime;
int ff_fdate;
long ff_fsize;
char ff_name[13];
}


Yapı elemanlarının adından da anlaşılacağı gibi, struct ffblk yapısı dosya adı, tarih, tür ve büyüklük gibi bilgileri tutar.Şimdilik bizim bilmemiz gerekn ff_name ve attrib özelliğidir.ff_name elemanı dosyanın adını, ff_atrib ise dosyanın türünü (arşiv,hidden,directory,system) tutar.

findfirst fonksiyonunun 3. parametresi ise hangi tür doyaların aranacağını gösterir.3. parametre olarak sıfır değeri verdiğimizde findfirst fonksiyonu normal dosyalar dediğimiz "read only ve archive" dosyalarını arar. Bu konu hakkında daha detaylı bilgiyi sonraki makalelerimizde bulabilirsiniz. Biz şimdilik 3 parametre olarak "0" gireceğiz.

findfirst fonksiyonunun geri dönüş değeri ise bize fonksiyonun başarılı olup olmadığı hakkında bilgi verir.Fonksiyon başarılıysa "0", başarısızsa "1" değerine geri döner.

Dosya ismi olarak dosyanın tam adını girebildiğimiz gibi "*" ve "?" gibi joker karekterleri de girebiliriz.Bu durumuda findfirst fonksiyonu bu koşulu sağlayan ilk fonksiyonu bulur.

findnext fonksiyonu

findfirst fonksiyonu ile birden fazla dosya bulunması olası ise ilk bulunan dosya dışındaki dosyalar findnext fonksiyonu ile bulunur. İşletim sistemleri dosyaları diskte kendilerine özgü bir şekilde sıraladıkları için bu organizasyonu bizim bilmemiz zordur.findnext fonksiyonu paremetre olarak bir dosya bilgisi alır ve bu dosya bilgisine bakarak bir sonraki dosyanın bilgisi ile yer değiştirir.(Unutmayın dosya bilgisinde kastımız "struct ffblk" yapısıdır.)

findnext fonksiyonununda prototipi başlık dosyasındadır, ve parametrik yapısı aşağıdaki gibidir.

int findnext(struct ffblk *finfo);

Geri dönüş değeri aynı şekilde fonksiyonun başarılı olup olmadığını gösterir.

Şimdi bu öğrendiğimiz fonksiyonlarla klasik bir dizin listeleme programı yazalım.



#inlude
#include //neden oldugunu biliyoruz değilmi?

int main()

{
struct ffblk dosyamiz; /* bu yapı nesnesi dosya bilgilerimizi saklayacak.*/
int sonuc; /* fonksiyonlarımızın başarılı olup olmadığını kontrol edeceğiz.*/
char dosya_yolu[80]; /*kullanıcıdan alacağımız patyh bilgisini sakalayacağımız dizi.*/
printf("Lütfen bir yol giriniz:");
gets(dosya_yolu); /*kullanıcıdan alkdığımız yolu diziye yerleştirdik.*/

sonuc=findfirst(dosya_yolu,&dosyamiz,0); /* dosya_yolundaki ilk dosyamızı bulduk.
şimdi bir döngü içinde dosya bilgilerini findnext fonksiyonuna gönderip fonksiyon başarısız olana kadar devam edeceğiz.böylece dosya bulma işlemi bitmiş olacak.sonrada istediğimiz formatta dosya ismini ve istediğimiz dosya bilgilerini ekrana yazdırabiliriz.*/

while (!sonuc){ // işlem başarısız olana kadar devam et
printf("%-20s--%-ld\n",dosyamiz.ff_name,dosyamiz.ff_size); /*dosya adını ve büyüklüğünü alt alta yazdık */
sonuc = findnext(&dosyamiz); /*bir sonraki dosyanın bilgilerini istiyoruz ve dosyamiz’in içine saklıyoruz*/
}

}


Ve ilk dosya arayan programımızı yazdık.Bundan sonraki yazılarımızda daha ileri uygulamalarda görüşmek üzere.

ilk C# Programımız | C#

C# dili ortaya çıkalı daha hiç birşey yapmayan varsa ya da birşeyler yapıp da ne yaptığından emin olmayan varsa işte bu yazı tam size göre. Bu yazımızda Dünya programımızı yazacağız.Ama programımızı yazarken her şeyi Öğreneceğiz. O halde aşağıdaki programı iyice inceleyin önce, şöyle bir göz atın programa yukarıdan aşağıya,.

//dosya adı : MerhabaDunya.cs

using System;

namespace MerhabaDunya

{
class Sınıf1
{
static void Main(string args[])
{
Console.WriteLine("Merhaba Dünya");
}
}
}

Yukarıdaki ilk programımızı incelediğinize göre açıklamalarımıza geçebiliriz. Eğer önceden C++ ve Java ile ilgilenmiş arkadaşlar varsa yukarıdaki kodlar tanıdık gelebilir. Nitekim, her ne kadar Microsoft firması ilk başlarda bunu kabul etmese de C# dili Java ve C++ dillerinin harmanlanmasından oluşmuş bir dildir. Bugün bunu kabul etmeyen yoktur sanırım.

Yukarıdaki ilk programımızın kodunu ben Notepad ile yazdım. Ama kodu derleyip çalıştırmak için bir C# derleyicisine ihtiyacımız olacak. C# derleyicisi Visual Studio.NET ile kurulabileceği gibi www.microsoft.com web sitesinden .NET Framework yazılımını indirerek de kurulabilir. Eğer Visual Studio ortamında çalışıyorsanız yukarıdaki kodları Visual Studio .NET ' in sunduğu hazır proje şablonlarından rahatlıkla oluşturabilirsiniz. Visual Studio programını çalıştırdıktan sonra Project->New menüsünden dil olarak Visual C# ve proje şablonu olarak da "Console Application" seçerseniz, main işlevi içindeki kodlar dışındaki yapı otomatikmen oluşturulacaktır.Eğer .NET Framework yapısını kurduysanız Console Ekranından C# derleyicisini çalıştırmalısınız. Komut ekranını yazarak kaynak kodumuzu derleyebilirsiniz.

Şimdi kodlarımızı inceleyelim. İlk satırdaki ifadesi System adlı bir isim alanının kullanılacağını belirtiyor.Peki nedir bu isim alanı(Namespace). İsimalanı kavramı son yıllarda program modüllerinin çok sayıda artmasından dolayı popüler hale gelmiştir. Kolay ve hızlı programlama yapmamızı sağlayan bir takım hazır kütüphaneler her ne kadar işimizi kolaylaştırsa da eğer isimalanları olmasaydı kullanacağımız her kütüphane bizim için işin içinden çıkılmaz bir hale gelebilirdi. Düşünün ki iki ayrı firma iki ayrı sınıf kütüphaneleri oluşturdu ve bu kütüphanelerin içinde aynı isimli birden çok sınıf yapısı var. Eğer biz programcı olarak iki firmanın da kütüphanesini kullanmak istiyorsak her ikisini aynı kod içinde kullanamayız. Çünkü aynı isimli sınıflar derleme aşamasında hata verecektir. Bu durumda yapılması gereken tek şey ya da en etkili yöntem isimalanlarını kullanmaktır. Yani bir sınıfa(class) ulaşabilmek için onun isim alanıyla çağırmak. İsim alanları hiyerarşik yapıda olabilir. Mesela System isim alanının altında başka bir isim alanı onun altında başkaları vs. İşte .NET isimalanı(namespace) hiyerarşisinin en tepesinde bulunan isim alanı System adlı isimalanıdır. En temel işlemlerimiz için bile bu isim alanını kullanmalıyız. Aksi halde programımız çalışmayacaktır. İsimalanlarını kullanmak için isimalanının başına using sözcüğü getirilir.

Soru: System isim alanının içinde Data isimalanında bulunan bir cs adlı sınıfı kullanabilmek için kaynak kodumuza ne eklememiz gerekir.

Cevap : Kaynak kodumuzun en başına aşağıdaki ifadeyi yazmamız gerekir.

using System.Data;

Bildiğiniz gibi C# dili %100 nesne tabanlı bir dildir. Yaptığımız herşey bir sınıf nesnesidir C# dilinde. Nesne olmayan hiçbirşey yoktur. C++ dilindeki main işlevini hatırlarsınız çoğunuz. Programımız c++ dilinde main işlevinden başlar ama main işlevi hiç bir zaman bir sınıf içinde olmamıştır.C# dilinde herşey sınıflarla temsil edildiği için main işlevi de bizim belirlediğimiz bir sınıfın işlevi olmak zorundadır. Yukarıdaki programımızda ifadesi ile programımızda bir sınıf nesnesi oluşturuyoruz. Sınıf1 sınıfının bir işlevi olan main'in elbette eskiden de olduğu gibi özel bir anlamı vardır. Biliyorsunuz ki derleyiciler programın nerden çalışacağını bilmek isterler, aksi halde derleme işleminden sonra "programınız için başlama noktası bulunamadı" hatası alırız. Bu yüzden main işlevi bizim için eskiden de olduğu gibi programımızın başlangıç noktasıdır. Yani biz programda yapmak istediklerimizi main işlevi içinde gerçekleştireceğiz. Sınıf tanımlamalarımızı ise istediğimiz noktada yapabiliriz. Daha öncede dediğimiz gibi isimalanları birçok sınıfın veya tek bir sınıfın oluşturduğu kümedir. Bizim ana programımız da bir sınıf olduğuna göre Class1 sınıfını istediğimiz isimli bir isimalanına sokabiliriz. Yukarıda yazarak isimalanını başlatıyoruz.

Şimdi main işlevinin içine bakalım, System isimalanında bulunan Console sınıfının bir metodu olan WriteLine() ile ekrana bir string ifadesi yazdırıyoruz. Biz burda iki tırnak ifadesi içinde yazımızı belirtmemize rağmen fonksiyonun kullanmı bununla sınırlı değildir. C# dilindeki fonksiyon aşırı yükleme (function overloading)kullanılarak fonksiyonu birçok parametrik yapıda kullanabilmemiz sağlanmıştır. Fonksiyon aşırı yükleme konusuna bundan sonraki yazılarımızda değineceğimizi belirtelim. WriteLine() işlevinin adından da anlaşılacağı gibi ekrana basmak istediğimiz yazıdan sonra satır atlama işlemi yapar.Bunu test etmek için bir tane "Merhaba Dünya" da siz yazdırın. Göreceksiniz ki siz belirtmemenize rağmen alt alta iki tane "Merhaba Dünya" yazısı çıkacak.

Eğer bu programı yazıp derlediyeseniz ne mutlu size ki C# dünyasına güzel bir adım attınız.