Windows 8 Programlama makale serisine, Async Desteği ile devam ediyoruz.

Asenkron programlama ölçeklendirilebilir ve yanıt veren (donmayan) uygulama geliştirmek için uzun yıllardır bilinen bir teknik. Uzun yıllardır bilinmesine rağmen, uygulama geliştiriciler olarak asenkron programlama bize hep zor gelmiştir.

.Net 4.5 ile birlikte asenkron programlama Async Framework sayesinde kolay programlanabilir hale getirildi ve Task Parallel Library‘nin (TPL) içerisine entegre edildi.

Asenkron programlama ile ilgili daha detaylı bilgiye, MSDN‘in Visual Studio Asynchronous Programming sayfasından ulaşabilirsiniz.

Bu makalede basit bir örnek ile async ve await anahtar kelimelerinin kullanımını inceleyeceğiz.

Yapacağımız örnek bir web sitesinin içeriğini okuyacak ve web adreslerini toplayacak. İlk olarak standart programlama yöntemlerini kullanarak uygulamamızı geliştireceğiz, daha sonra async ve await anahtar kelimeleri ile asenkron programlama öğelerini uygulamamıza dahil edeceğiz.

Hemen yeni bir Visual Studio 2011 açarak geliştirmeye başlayalım;

Yeni Proje oluşturma dialog kutusunda Windows Metro Style grubunda yer alan Application proje şablonunu seçelim ve projemize bir isim verelim (bu örnekte benim kullandığım isim, AsyncOrnek)

Proje oluşturulduğunda MainPage.xaml dosyasının içeriği;

<UserControl x:Class="Windows8ApplicationBar.MainPage"
	xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
	xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
	xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
	xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
	mc:Ignorable="d"
	d:DesignHeight="768" d:DesignWidth="1366">

	<Grid x:Name="LayoutRoot" Background="#FF0C0C0C">
	</Grid>

</UserControl>

İlk önce uygulamamıza bir TextBox, bir Button ve bir ListBox nesnesi ekliyoruz;

<Grid x:Name="LayoutRoot" Background="#FF0C0C0C">

	<TextBox x:Name="txtKaynakHtml" Width="600" Height="700" HorizontalAlignment="Left" />
	<ListBox x:Name="lbUrlList" Width="600" Height="700" HorizontalAlignment="Right" />
	<Button x:Name="btnTara" Content="Tara" HorizontalAlignment="Center" />

</Grid>

Böylece uygulama ekranımız şu şekilde gözüküyor;

TextBox kontrolünün Text özelliğine web sitesinin kaynak html’ini atayacağımız için, çok satır gösterebilir olması lazım (MultiLine)

WPF TextBox kontrolünün MultiLine olabilmesi için, TextBox element’ine şu özellikleri ekliyoruz;

TextWrapping="Wrap" AcceptsReturn="True" ScrollViewer.VerticalScrollBarVisibility="Visible"

Button kontrolüne basıldığında tarama işlemini başlatmak için, Button element’inde Click olayını yakalıyoruz;

Click="btnTara_Click"

Böylece uygulamamızın XAML kod’u aşağıdaki hale gelmiş oluyor;

<UserControl x:Class="AsyncOrnek.MainPage"
	xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
	xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
	xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
	xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
	mc:Ignorable="d"
	d:DesignHeight="768" d:DesignWidth="1366">

	<Grid x:Name="LayoutRoot" Background="#FF0C0C0C">

		<TextBox x:Name="txtKaynakHtml" Width="600" Height="700" HorizontalAlignment="Left" TextWrapping="Wrap" AcceptsReturn="True" ScrollViewer.VerticalScrollBarVisibility="Visible" />
		<ListBox x:Name="lbUrlList" Width="600" Height="700" HorizontalAlignment="Right" />
		<Button x:Name="btnTara" Content="Tara" HorizontalAlignment="Center" Click="btnTara_Click" />

	</Grid>

</UserControl>

MainPage.xaml.cs dosyasında btnTara_Click method’unu yazıyoruz;

private void btnTara_Click(object sender, RoutedEventArgs e)
{
}

Öncelikle, taradığımız sitede bulacağımız url’leri saklayacağımız string dizisini oluşturalım;

List<string> UrlList = new List<string>();

HttpClient sınıfından yeni bir instance oluşturup, Get() method’una, tarayacağımız sitenin adresini yazalım.

Get() method’undan dönen HttpResponseMessage tipindeki cevabı bir değişkene atayalım;

var HttpCagri = new HttpClient().Get("http://www.enginpolat.com");

HttpClient sınıfı System.Net.Http namespace‘inde yer aldığı için, MainPage.xaml.cs dosyasının using kısmına

using System.Net.Http;

satırını ekleyelim.

HttpCagri değişkeninin sitenin kaynak html’ini okuyabildiğinden emin olmak için, EnsureSuccessStatusCode() method’unu çağıralım.

Böylece HttpContent tipindeki Content özelliğine erişebilir olacağız. Content özelliğinin ReadAsString() method’u kaynak html’ini döndürecek, biz de bir değişken aracılığıyla bu html’i saklayacağız.

var KaynakHtml = HttpCagri.EnsureSuccessStatusCode().Content.ReadAsString();

Elimizdeki bu html verisini, arayüzdeki txtKaynakHtml TextBox‘ında göstermek için;

txtKaynakHtml.Text = KaynakHtml;

Şimdi yapmamız gereken, KaynakHtml değişkenindeki url‘leri bulmak. Bunun için Regex sınıfından faydalanacağız ve yazacağımız Regular Expression‘a uyan url’leri UrlList değişkeninde biriktireceğiz.

Regex sınıfı System.Text.RegularExpressions namespace’inde olduğu için, MainPage.xaml.cs dosyasının using kısmına

using System.Text.RegularExpressions;

satırını ekleyelim.

Öncelikle Regex sınıfının static Matches method’una KaynakHtml değişkenini, Regular Expression metnini ve arama yaparken büyük/küçük harf ayrımı yapmaması için RegexOptions.IgnoreCase değerini parametre olarak veriyoruz.

RegexOptions parametresine verebileceğimiz diğer değerler;

• RegexOptions.None
• RegexOptions.IgnoreCase
• RegexOptions.Multiline
• RegexOptions.ExplicitCapture
• RegexOptions.Compiled
• RegexOptions.Singleline
• RegexOptions.IgnorePatternWhitespace
• RegexOptions.RightToLeft
• RegexOptions.ECMAScript
• RegexOptions.CultureInvariant

Method’dan dönen MatchCollection tipindeki cevabı bir değişkende saklıyoruz;

var mc = Regex.Matches(KaynakHtml, "href\\s*=\\s*(?:\"(?<1>http://[^\"]*)\")", RegexOptions.IgnoreCase);

Bir foreach döngüsü ile MatchCollection‘daki her Match‘i UrlList‘e ekliyoruz;

foreach (Match m in mc)
{
	UrlList.Add(m.Groups[1].Value);
}

Son olarak arayüzdeki lbUrlList ListBox‘ında bu listeyi gösteriyoruz;

lbUrlList.ItemsSource = UrlList;

İlk çalıştırma aşamasına geldik. Projeyi çalıştırıp Tara butonuna bastığımızda garip bir hata alıyoruz;

Cannot write more bytes to the buffer than the configured maximum buffer size: 65536

Bu hataya, kaynak html’ini aldığımız siteden dönen cevabın 65536 karakterden büyük olması yol açıyor. Çözüm aslında basit;

HttpClient tipindeki değişkenin MaxResponseContentBufferSize özelliğine sitenin kaynak html’inin karakter sayısı kadar büyük bir değer vermemiz lazım.

Bu örnek için ben verilebilecek en büyük değer olan int.MaxValue değerini seçtim, HttpCagri değişkenini tanımladığımız satırı şöyle güncelliyoruz;

var HttpCagri = new HttpClient() { MaxResponseContentBufferSize = int.MaxValue }.Get("http://www.enginpolat.com");

Artık projemizi çalıştırabiliriz;

Buraya kadar uygulamayı çalıştırmaya odaklanmıştık, uygulamayı çalıştırdıktan sonra kullanıyoruz ve farkediyoruz ki, Tara butonuna bastıktan sonra liste dolana kadar uygulama kullanıcıya yanıt vermiyor.

Kullanıcı dostu bir uygulamanın her zaman kullanıcıya yanıt vermesi beklenir. Biz de Tara butonunun yaptığı işi asenkron yapmasını sağlayarak oluşan donmaların önüne geçebiliriz.

Asenkron çalışma yeteneğini eklemek için öncelikle btnTara_Click method’una async anahtar kelimesini ekleyeceğiz;

private async void btnTara_Click(object sender, RoutedEventArgs e)

Uygulamanın donmasına sebep olan en uzun iş, internet sitesinin cevabının alındığı HttpClient sınıfının Get() method’u. Bu yüzden Get() method’unu asenkron özellikte olan GetAsync() method’u ile değiştiriyoruz.

HttpCagri değişkenine değer atamadan önce await anahtar kelimesi ile asenkron yaptığımız çağrının sonuçlanmasını beklemeliyiz. İlgili satırı aşağıdaki şekilde güncelleyelim;

var HttpCagri = await new HttpClient() { MaxResponseContentBufferSize = int.MaxValue }.GetAsync("http://www.enginpolat.com");

Böylece uygulamamıza asenkron çalışabilme yeteneğini kazandırmış olduk. Projenin kodlarının tamamı;

<UserControl x:Class="AsyncOrnek.MainPage"
	xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
	xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
	xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
	xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
	mc:Ignorable="d"
	d:DesignHeight="768" d:DesignWidth="1366">

	<Grid x:Name="LayoutRoot" Background="#FF0C0C0C">

		<TextBox x:Name="txtKaynakHtml" Width="600" Height="700" HorizontalAlignment="Left" TextWrapping="Wrap" AcceptsReturn="True" ScrollViewer.VerticalScrollBarVisibility="Visible" />
		<ListBox x:Name="lbUrlList" Width="600" Height="700" HorizontalAlignment="Right" />
		<Button x:Name="btnTara" Content="Tara" HorizontalAlignment="Center" Click="btnTara_Click" />

	</Grid>

</UserControl>

private async void btnTara_Click(object sender, RoutedEventArgs e)
{
	List<string> UrlList = new List<string>();

	var HttpCagri = await new HttpClient() { MaxResponseContentBufferSize = int.MaxValue }.GetAsync("http://www.enginpolat.com");
	var KaynakHtml = HttpCagri.EnsureSuccessStatusCode().Content.ReadAsString();

	txtKaynakHtml.Text = KaynakHtml;

	var mc = Regex.Matches(KaynakHtml, "href\\s*=\\s*(?:\"(?<1>http://[^\"]*)\")", RegexOptions.IgnoreCase);

	foreach (Match m in mc)
	{
		UrlList.Add(m.Groups[1].Value);
	}

	lbUrlList.ItemsSource = UrlList;
}

Projelerimizde dosya sistemi üzerinde geçici olarak dosya oluşturma ve işimiz bittiğinde silme ihtiyacı hissedebiliriz.

Bu yazıyı okumadan önce Hem benzersiz hem de geçici dosya oluşturmanın en kolay yolu ve C# ile Geçici Dosya Oluşturmak başlıklı yazılarımı okumanızı öneririm.

Bu linkte bulduğum yöntemi çok kullanışlı buldum ve sizler (aynı zamanda kendim) için türkçeleştirdim;

public class TempFile : IDisposable
{
	public TempFile() : this(string.Empty)
	{ }

	private readonly string _tmpfile;

	public TempFile(string extension)
	{
		_tmpfile = Path.GetTempFileName();

		if (!string.IsNullOrEmpty(extension))
		{
			string newTmpFile = _tmpfile + extension;

			/// Yeni bir geçici dosya oluşturulur
			File.Create(newTmpFile, 0);
			/// Eski geçici dosya silinmediyse, silinir.
			File.Delete(_tmpfile);

			/// Yeni oluşturulan geçici dosya kullanıma hazır!
			_tmpfile = newTmpFile;
		}
	}

	public string FullPath
	{
		get { return _tmpfile; }
	}

	void IDisposable.Dispose()
	{
		if (!string.IsNullOrEmpty(_tmpfile) && File.Exists(_tmpfile))
		{
			File.Delete(_tmpfile);
		}
	}
}

Kullanımına örnek;

using(TempFile tmp = new TempFile(".dat")) /// dat uzantılı bir geçici dosya oluşturuluyor
{
	/// FullPath özelliğinden geçici dosyanın yolu ve dosya adı alınabilir;
	string filename = tmp.FullPath;
}

C# 4.0 ile hayatımıza giren dynamic ve C# 1.0‘dan beri varolan object arasında ne fark var?

Önce eski dostumuz object ile başlayalım;

object anahtar kelimesi aslında System.Object sınıfının bir kısaltmasından başka birşey değildir (ki kendisi C# sınıf hiyerarşisinin en temelinde yer almaktadır)

Not : Birçoğumuzun bildiği gibi, aslında herşey object sınıfından türememektedir. bknz: Eric Lippert’in MSDN Blog yazısı

object tipinde bir değişkene, hemen hemen istediğimiz her değeri atayabiliriz. Birkaç örnek;

object Rakam = 10;
Console.WriteLine(Rakam.GetType());
/// System.Int32

Rakam = Rakam + 10;
/// Derleme zamanı hatası. Çünkü derleme anında Rakam değişkeni System.Object tipinde

Rakam = (int)Rakam + 10;
/// Hatasız atama için, unboxing yapmamız gerekiyor

Örnekte gördüğümüz gibi, Rakam değişkeninde rakamsal bir değer tutuyor olmamıza rağmen, derleyici, değişken üzerinde matematiksel işlem yapmamıza izin vermedi.

Değişken’in değerine erişebilmek için unboxing yapmak zorunda kaldık ve tip güvenliği olmadığı için çalışma zamanı hataları oluşturabilecek, zayıf bir kod ortaya çıktı.

Bir de C# 4.0 ile birlikte gelen dynamic inceleyelim;

dynamic Rakam = 10;
Console.WriteLine(Rakam.GetType());
/// object için aldığımız sonucun aynısını alıyoruz
/// System.Int32

Rakam = Rakam + 10;
/// Derleme zamanı hatası almayız, çünkü derleyici tipi çözümlemek için uğraşmaz.

Bu, object ile dynamic arasındaki en temel farktır. dynamic ile, derleyici‘ye (compiler), nesnenin tipinin sadece çalışma zamanında bilinebileceğini söylemiş oluyoruz.

Sonuçta aslında derleme zamanı için daha az kod yazıyoruz.

Fakat bu dynamic anahtar kelimesini daha az tehlikeli veya daha tehlikeli duruma getirmez.

Genelde bir sonraki soru; “dynamic ile herhangi bir method’a uygun olmayan tipte parametre gönderip, hata oluşmasını sağlayabilir miyim?” oluyor.

Basit bir örnek ile bu soruyu test edelim;

public static void AdSoyadYaz(string Ad, string Soyad)
{
    Console.WriteLine(Ad + " " + Soyad);
}

Bu method’umuzu dynamic tipindeki bir değişken ile çağıralım;

dynamic Ad = 10;
dynamic Soyad = 20;

/// Çalışma zamanı hatası almanız lazım.
AdSoyadYaz(Ad, Soyad);

Yukarıdaki kod ile, çalışma zamanında RuntimeBinderException tipinde bir hata almalısınız. Hatanın Message property’sinde; “The best overloaded method match for ‘AdSoyadYaz(string, string)’ has some invalid arguments” yazıyor olmalı.

dynamic Ad = "Engin";
dynamic Soyad = "Polat";

AdSoyadYaz(Ad, Soyad);

Gördüğünüz gibi, method’un çalıştırılması için parametre tipleri çalışma zamanında kontrol edilir, ve uygunsuz ise, RuntimeBinderException tipinde bir hata fırlatılır.

object anahtar kelimesinde ise, bu süreç derleme zamanında kontrol edilir.

object Ad = 10;
object Soyad = 20;

/// Derleme zamanı hatası almanız lazım.
AdSoyadYaz(Ad, Soyad);

object Ad = "Engin";
object Soyad = "Polat";

AdSoyadYaz((string)Ad, (string)Soyad);

SortedSet sınıfı, .Net Framework 4.0 ile birlikte gelen en yeni sınıflardan biridir ve listesine eklenen elemanları sıralı bir şekilde tutar.

Bir örnek ile göstermek gerekirse;

public static void Main(string[] args)
{
	var SiraliListe = new SortedSet<string>();

	SiraliListe.Add("Engin");
	SiraliListe.Add("Ahmet");
	SiraliListe.Add("Mehmet");
	SiraliListe.Add("Ayşe");
	SiraliListe.Add("Fatma");

	foreach (string s in SiraliListe)
	{
		Console.WriteLine(s);
	}

	Console.ReadLine();
}

kodunun çıktısı aşağıdaki gibi olacaktır;

Ahmet
Ayşe
Engin
Fatma
Mehmet

public static void Main(string[] args)
{
	var SiraliListe = new SortedSet<int>() { 2, 5, 4, 6, 9, 3, 2, 8, 10, 7, 1 };

	foreach (int Sayi in SiraliListe)
	{
		Console.WriteLine(Sayi);
	}

	Console.ReadLine();
}

Çıktı : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

Tüm koleksiyonlara uygulayabildiğimiz Reverse() methodu SortedSet sınıfında da kullanılabiliyor;

public static void Main(string[] args)
{
	var SiraliListe = new SortedSet<int>() { 2, 5, 4, 6, 9, 3, 2, 8, 10, 7, 1 };

	foreach (int Sayi in SiraliListe.Reverse())
	{
		Console.WriteLine(Sayi);
	}

	Console.ReadLine();
}

Çıktı : 10, 9, 8, 7, 6, 5, 4, 3, 2, 1

Clear() methodu, tüm elemanları silmeye yarıyor;

public static void Main(string[] args)
{
	var SiraliListe = new SortedSet() { 2, 5, 4, 6, 9, 3, 2, 8, 10, 7, 1 };

	SiraliListe.Clear();

	Console.ReadLine();
}

Min ve Max özellikleri sayesinde listedeki en küçük ve en büyük değerli elemanlara ulaşabiliriz;

public static void Main(string[] args)
{
	var SiraliListe = new SortedSet<int>() { 2, 5, 4, 6, 9, 3, 2, 8, 10, 7, 1 };

	Console.WriteLine("Min : {0}, Max : {1}", SiraliListe.Min, SiraliListe.Max);

	Console.ReadLine();
}

Çıktı : Min : 1, Max : 10

.Net string sınıfı uygulamalarımızda sıklıkla kullandığımız sınıflardan biridir.

.Net 1.1 versiyonundan itibaren gelişme göstermesine rağmen, hala bazı fonksiyonlarının eksik olduğunu veya tam anlamıyla kullanılmadığını düşünüyoum.

Bu makalemde, string sınıfının çok bilinmeyen veya çok kullanılmayan özelliklerine ve methodlarına değinmeye çalışacağım.

String değişkeni tekrar eden karakterler ile doldurmak

String değişkeni tekrar eden karakterler ile doldurmak için, String sınıfının constructor’ını kullanmak gerekir.

Örneğin, bir string değişkeni 50 adet nokta (.) karakteri ile doldurmak istiyorsak;

string degisken = new string('.', 50);

String değişkenin boş olduğunu kontrol etmek

String değişkenin değer içerip içermediğini belirlemek için string.Empty ve boş tırnaklar (“”) ile karşılaştırmamız gerekir.

if (degisken != null && degisken != "")
{
}

Alternatif olarak bu iki karşılaştırmayı yapmak yerine, .Net 2.0 ile gelen string.IsNullOrEmpty static fonksiyonunu kullanabiliriz;

if (!string.IsNullOrEmpty(degisken))
{
}

String.Empty ve boş tırnaklar (“”) arasındaki fark

İnternette çeşitli sitelerde, string.Empty ve boş tırnaklar (“”) arasında seçim yapmak için yazılmış makalelere rastlayabilirsiniz.

Aslında yapılan onlarca test gösteriyor ki, performans açısından bakıldığında string.Empty ve boş tırnaklar (“”) arasında önemsenmeyecek kadar küçük bir fark vardır.

Yapılan testler milyarlarca string değişken üzerinde yapılmasına rağmen ortaya çıkan fark göz ardı edilebilecek kadar düşük seviyededir.

String değişkenin içeriğini ters çevirmek

Bir string değişkenin içeriğini ters çevirmek için çeşitli algoritmalara internet üzerinden ulaşabilir veya kendi algoritmanızı geliştirebilirsiniz.

Kodun temizliği, hız, Unicode karakter setleri ile sorunsuz çalışabilmesi açısından benim en çok kullandığım yöntem şudur;

public static string Reverse(this string s)
{
	char[] charArray = s.ToCharArray();
	Array.Reverse(charArray);
	return new string(charArray);
}

String karşılaştırma

String değişkenin değeri null olabileceği için, karşılaştırma operatörünü (==) kullanmaktan kaçınmamız gerekir.

Bunun yerine String sınıfının static Compare method’unu kullanmamız daha doğrudur.

Static Compare method’u sayesinde null referans’ları doğru şekilde karşılaştırabilir, büyük-küçük harf duyarlılığını yoksayabilir, farklı Culture’daki değerleri karşılaştırabiliriz.

if (String.Compare(degisken1, degisken2, true) == 0)
{
}

Büyük-Küçük harf duyarlılığı olmayan IndexOf

String sınıfının IndexOf method’u büyük-küçük harf duyarlıdır. Büyük-Küçük harf duyarlılığı olmadan IndexOf method’unu kullanmak istiyorsak, System.Globalization namespace’inde yeralan CompareInfo sınıfı’nın IndexOf method’unu kullanabiliriz;

using System.Globalization;

string degisken1 = "Uygulamalarımızın olmazsa olmaz unsurları değişkenlerdir";
string degisken2 = "OLMAZ";

CompareInfo karsilastirma = CultureInfo.InvariantCulture.CompareInfo;
int i = karsilastirma.IndexOf(degisken1, degisken2, CompareOptions.IgnoreCase);

string ve String farkı

MSDN’deki String sınıfı ile alakalı bir sayfadan alıntı;

“The keyword string is simply an alias for the predefined class System.String.” – C# Language Specification 4.2.3

Türkçesi;

“string anahtar kelimesi basitçe, System.String sınıfının takma adıdır.” – C# Language Specification 4.2.3

Aşağıdaki kodu çalıştırdığımızda Console’a “Bir”, “İki”, “Üç” yazdığını görüyoruz.

Sizce neden “Dört” elemanı yazılmıyor?

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BuKoddaNeYanlisVar
{
    class Program
    {
        private List<string> _items = new List<string>();

        public List<string> Items
        {
            get { return _items.ToList(); }
            set { _items = value; }
        }
        static void Main(string[] args)
        {
            Program program = new Program();
            program.Items = new List<string> { "Bir", "İki", "Üç" };
            program.Items.Add("Dört");
            foreach (var item in program.Items)
                Console.WriteLine(item);
            Console.ReadLine();
        }
    }
}

Sadece bir method içerisinde kullanacağınız basit class‘lara kaç defa ihtiyaç duydunuz? Böyle bir class’a her ihtiyaç duyduğunuzda yapmanız gereken, yeni bir class oluşturup, bütün tanımlama kodlarını (private alanlar, public alanlar, vs.) yazmaktır.

C# dili, İsimsiz Tip (Anonymous Type) tanımlamaya izin veriyor. Üstelik, private ve public öğelerin oluşturulmasını ve yönetilmesini C# dilinin kendisi üstleniyor.

public class HataLogla()
{
	var Hata = new { Mesaj = "Hata Mesajının Kendisi", Tarih = DateTime.Now, Yer = "XClass.YMethod" };
	var Kullanici = new { Id = 42, AdSoyad = "Engin Polat", Yonetici = "Ali Veli" };

	string Loglanacak = string.Format("Hata Mesajı: {0}\nTarih: {1} {2}\nHatanın Oluştuğu Yer: {3}\n\nKullanıcıId: {4}\nKullanıcı Adı: {5}\nYöneticisi: {6}", Hata.Mesaj, Hata.ToShortDateString(), Hata.Tarih.ToLongTimeString(), Hata.Yer, Kullanici.Id, Kullanici.AdSoyad, Kullanici.Yonetici);

	File.WriteAllText(Loglanacak, @"C:\Log\Log.txt");

	MessageBox.Show(Hata.Mesaj, Hata.Tarih);
}

Yukarıdaki kodda yer alan Hata ve Kullanici değişkenlerinin tipleri, derleme zamanında derleyici tarafından otomatik oluşturulur. Eğer method‘un içerisine aşağıdaki kodları eklersek;

MessageBox.Show("Hata değişkeninin tipi : " + Hata.GetType().ToString());
MessageBox.Show("Kullanici değişkeninin tipi : " + Kullanici.GetType().ToString());

Mesaj kutularında şu değerleri görürüz;

Hata değişkeninin tipi : <>f_AnonymousType0’3[System.String,System.DateTime,System.String]
Kullanici değişkeninin tipi : <>f_AnonymousType0’3[System.Int32,System.String,System.String]

Farkettiğiniz gibi, böyle bir tip oluşturmaya çalışırsak, derleme zamanında hata alırız, ama C# derleyicisi bizim için bu tipleri oluşturuyor.

Değişkenin tipini veremeyeceğimiz için, C# diline var anahtar kelimesi eklenmiştir.

var anahtar kelimesi sayesinde, değişkenin tipi atandığı değerden otomatik olarak çözümleniyor.

İsimsiz Tipler (Anonymous Types) IDisposable interface’ini uygulamadığı için, Disposable olamazlar.

Eğer yukarıdaki örneği geleneksel kodlama teknikleri ile yazacak olsaydık;

public class HataBilgi
{
	private string _Mesaj = string.Empty;
	private DateTime _Tarih = DateTime.Now;
	private string _Yer = string.Empty;

	public string Mesaj
	{
		get
		{
			return _Mesaj;
		}
		set
		{
			_Mesaj = value;
		}
	}

	public DateTime Tarih
	{
		get
		{
			return _Tarih;
		}
		set
		{
			_Tarih = value;
		}
	}

	public string Yer
	{
		get
		{
			return _Yer;
		}
		set
		{
			_Yer = value;
		}
	}

	public HataBilgi(string Mesaj, DateTime Tarih, string Yer)
	{
		this.Mesaj = Mesaj;
		this.Tarih = Tarih;
		this.Yer = Yer;
	}
}

public class KullaniciBilgi
{
	private int _Id = 0;
	private string _AdSoyad = string.Empty;
	private string _Yonetici = string.Empty;

	public int Id
	{
		get
		{
			return _Id;
		}
		set
		{
			_Id = value;
		}
	}

	public string AdSoyad
	{
		get
		{
			return _AdSoyad;
		}
		set
		{
			_AdSoyad = value;
		}
	}

	public string Yonetici
	{
		get
		{
			return _Yonetici;
		}
		set
		{
			_Yonetici = value;
		}
	}

	public KullaniciBilgi(int Id, string AdSoyad, string Yonetici)
	{
		this.Id = Id;
		this.AdSoyad = AdSoyad;
		this.Yonetici = Yonetici;
	}
}

public class HataLoglama
{
	HataBilgi Hata = new HataBilgi("Hata Mesajının Kendisi", DateTime.Now, "XClass.YMethod");
	KullaniciBilgi Kullanici = new KullaniciBilgi(42, "Engin Polat", "Ali Veli");

	string Loglanacak = string.Format("Hata Mesajı: {0}\nTarih: {1} {2}\nHatanın Oluştuğu Yer: {3}\n\nKullanıcıId: {4}\nKullanıcı Adı: {5}\nYöneticisi: {6}", Hata.Mesaj, Hata.ToShortDateString(), Hata.Tarih.ToLongTimeString(), Hata.Yer, Kullanici.Id, Kullanici.AdSoyad, Kullanici.Yonetici);

	File.WriteAllText(Loglanacak, @"C:\Log\Log.txt");

	MessageBox.Show(Hata.Mesaj, Hata.Tarih);
}

İsimsiz Tip yeteneklerini kullanarak yazdığımızda ise;

public class HataLogla()
{
	var Hata = new { Mesaj = "Hata Mesajının Kendisi", Tarih = DateTime.Now, Yer = "XClass.YMethod" };
	var Kullanici = new { Id = 42, AdSoyad = "Engin Polat", Yonetici = "Ali Veli" };

	string Loglanacak = string.Format("Hata Mesajı: {0}\nTarih: {1} {2}\nHatanın Oluştuğu Yer: {3}\n\nKullanıcıId: {4}\nKullanıcı Adı: {5}\nYöneticisi: {6}", Hata.Mesaj, Hata.ToShortDateString(), Hata.Tarih.ToLongTimeString(), Hata.Yer, Kullanici.Id, Kullanici.AdSoyad, Kullanici.Yonetici);

	File.WriteAllText(Loglanacak, @"C:\Log\Log.txt");

	MessageBox.Show(Hata.Mesaj, Hata.Tarih);
}

Aradaki fark açıkça ortada!

C# dilinin bazı yetenekleri, aslında uygulama geliştiricilerin göremedikleri method’lardan gelmektedir.

Eğer geliştirdiğiniz uygulamanın assembly’lerini ILDASM tool’u ile açıp incelerseniz, bu method çağrılarını görebilirsiniz.

Eğer bilerek veya yanlışlıkla bu method’lardan birisi ile aynı isme sahip method oluşturmaya çalışırsanız, derleme anında (compile-time) hata alırsınız.

Bu rezerve method isimlerini inceleyelim;

Özellikler (Properties) için Rezerve Methodlar;

Class veya Struct‘larınıza eklediğiniz özellikler, derleme zamanında

T add_{OzellikAdi}
void set_{OzellikAdi}(T value)

şablonunda iki method’a dönüştürülür. Class veya Struct‘ınıza bu şablona uyan method ekleyemezsiniz.

Indexer’lar için Rezerve Methodlar;

Indexer’larınız derleme zamanında

T get_Item(Parametre)
void set_Item(Parametre, T value)

şablonunda iki method’a dönüştürülür.

Yıkıcılar (Destructors) için Rezerve Methodlar;

Class veya Struct‘ınıza eklediğiniz Destructor kodu derleme zamanında

void Finalize()

method’una dönüştürülür. Class veya Struct‘ınıza Finalize() method’u eklemeye çalıştığınızda derleme zamanında uyarı alırsınız.

Olaylar (Events) için Rezerve Methodlar;

Olaylarınız için derleme zamanında kodunuza

void add_{EventAdi}(T callback)
void remove_{EventAdi}(T callback)

methodları eklenir.

Uygulamalarımızı geliştirirken birçok class veya struct yazmamız gerekir.

Bu class veya struct‘ların hemen hepsinde özelliklere (properties) ihtiyaç duyarız.

Çünkü, local değişkenlerin public değil, private olmasını isteriz. Bu durumda yapmamız gereken public olmasını istediğimiz local değişkenlere birer tane özellik (property) yazmaktır.

Örnek Personel Class‘ı aşağıdaki gibi olacaktır;

public class Personel
{
	private int PersonelId;
	private string AdSoyad;
}

public class Personel
{
	private int _PersonelId;
	private string _AdSoyad;

	public int PersonelId
	{
		get { return _PersonelId; }
		set { _PersonelId = value; }
	}

	public string AdSoyad
	{
		get { return _AdSoyad; }
		set { _AdSoyad = value; }
	}
}

Sadece okuma/yazma yapan iki özellik için ne faz kod yazdık, değil mi?

Eğer get/set blokları arasına özel iş yapan kod yazmamız gerekiyorsa, yukarıdaki gibi yapmaya devam etmeliyiz.

Fakat sadece okuma/yazma yapan özellikleri C# 3.0‘dan itibaren daha kısa yazabiliyoruz;

public class Personel
{
	public int PersonelId { get; set; }

	public string AdSoyad { get; set; }
}

Gördüğünüz gibi local değişkenlerin oluşturulması ve yönetilmesi işini yapmakla uğraşmıyoruz.

Eğer local değişkenlerin nasıl oluşturulduğunu merak ediyorsanız, projenizi compile ettikten sonra, ortaya çıkan exe/dll dosyasını ILDASM (Intermediate Language Disassembler) tool’u ile açıp bakabilirsiniz.

PersonelId özelliği için <>k__AutomaticallyGeneratedPropertyField0 isimli bir değişkenin oluşturulduğu ve tipininde int olduğunu göreceksiniz.

Otomatik oluşturulan değişken’in ismini herhangi bir kod parçasında kullanmaya çalışırsak, derleme (compile) zamanında yazım hatası (syntax error) alırız, yani local değişkenleri kullanamayız.

Eski stil kodlamada sadece okunabilir (readonly) veya sadece yazılabilir (writeonly) property tanımlayabiliyorduk. Bunu yeni stil kodlamada da yapabilir miyiz?

Cevap Evet, aşağıdaki kodu inceleyin;

public class Personel
{
	public int PersonelId { get; private set; }
	public string AdSoyad { private get; set; }
}