Şafak Ünel (Matematik Mühendisi)

C# Command-Line Argumanlarına Erişme

2011-02-19T14:20:00.001+02:00

Biliyoruz ki defalarca yazdığımız ve kullanıdığımız Main() metodu args adında bir string dizisini parametre olarak almaktadır. Öncelikle bu argumanlara nasıl ulaşır ve müdahale edebiliriz ona bir bakalım:

Main Metodu :

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace SimpleCSharpApp

{

class Program

{

static int Main(string[] args)

{

}

1. Metod :

for (int i = 0; i < args.Length; i++)

Console.WriteLine("Arg: {0}", args[i]);

2. Metod :

string[] theArgs = Environment.GetCommandLineArgs();

foreach (string arg in theArgs)

Console.WriteLine("Arg: {0}", arg);

Program çıktısı :

Peki biz kendi argumanlarımızı projemize nasıl ekleriz? Bunun için projemize sağ tıklayıp Properties – > Debug içerisindeki Start Options –> Command line arguments içerisine istediğimiz arguman isimlerini başlarında “-” veya “/” olacak şekilde yazarak ekleyebiliriz.

Peki bu bizim nasıl işimize yarar? Mesela bir oyun yazdığımızı düşünelim ve bu projemizin argumanlarına örnekte olduğu gibi –godmode diye bir arguman tanımlarız. Eğer bir kişi bu argumanla bu programı çalıştırırsa bu kişinin hile yapan oyuncu olduğunu anlarız gibi çok basit bir örnek verebiliriz.

C# Main() Metodu ile ERRORLEVEL

2011-02-19T13:18:00.001+02:00

Main metodunu C# ile yazdığımız tüm console, windows desktop ve windows servislerinde bulunması gerektiğiniz biliyoruz. Zaten bu programlardan herhangi birini yazmak için Visual Studio içinde yeni proje oluştruduğumuzda Visual Studio main metodu yazılmış şekilde projeyi oluşturmaktadır. Ve bu metod static bir metod olup void tipinde tanımlanmış olarak gelmektedir.

Fakat biz istersek bu metodun tipini değiştirebiliriz. Peki bu bizim ne işimize yarıyacak? Mesela bir örnek olarak ERRORLEVEL değişkenini batch dosyasıyla okuyarak programımızın döndürdüğü değeri izleyebiliriz. Windows üzerinde bir program çalıştırdığımızda Main() metodunun döndürdüğü değer ERRORLEVEL denilen çevresel değişken üzerinde tutulur. Genelde Main() metodunun döndürdüğü 0 programın sorunsuz çalıştığını –1 ise program çalışırken hata oluştuğunu göstermektedir. Yani kısacası Main() metodumuzun tipini void tipinden int tipine çevirerek programımızın doğru çalışıp çalışmadığını çevresel değişken olaran ERRORLEVEL’I kullanarak öğrenmek mümkün. Şimdi bu anlattıklarımızı bir program üzerinde inceleyelim.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace MainReturnValTest

{

class Program

{

static void Main(string[] args)

{

Console.WriteLine("C# Main() Metodu ile ERRORLEVEL");

Console.ReadLine();

}

Yukarıda yazdığımız program default olarak gelen static void tipli Main() metodumuz ile yazdığımız program bu programı Main() metodunu int tipine çevirip yazarsak :

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace MainReturnValTest

{

class Program

{

static int Main()

{

Console.WriteLine("C# Main() Metodu ile ERRORLEVEL");

Console.ReadLine();

return 0;

}

Görüldüğü gibi artık Main metodu bir değer döndürüyor. Böylelikle artık çevresel değişken ERRORLEVEL’i kullanarak artık programımızın çalışmasını izleyebiliriz. Bunun için biz txt dosyası açarak aşagıdaki kodu içerisine kopyalayıp dosyayı test.bat şeklinde kaydedip projemizin olduğu klasöre kopyalamamız gerekli. Bundan sonra yapmamız gereken Visual Studio Commant prompt ile bat uzantılı dosyamızı bulup çalıştırmak.

rem test.bat
@echo off
MainReturnValTest
@if "%ERRORLEVEL%" == "0" goto good

:fail
echo Execution Failed
echo return value = %ERRORLEVEL%
goto end

:good
echo Execution succeeded
echo Return value = %ERRORLEVEL%
goto end

:end
echo All Done.

Çalışma sonucu :

C# Reflector Kullanımı

2011-02-05T13:52:00.001+02:00

Daha önceki yazımızda bir programı derlediğimizde oluşan dll veya exe dosyasının CIL, metadata ve manifest bilgilerini içerdiğini ve bu bilgilere Visual Studio’nun bir tool’u olan idasm ile ulaşabileceğimizden bahsetmiştik. Bu yazıya buradan ulaşılabilir.

Reflector ise bu dll veya exe’yi kullanarak yazdığımız kodları göstermeye yarar. Yani elimizde bir dll veya exe var ise biz bu dll veya exe’nin oluşması için yazılan kodları görebiliriz. Şimdi bunu nasış yaptığını bir örnek ile inceleyelim

Not : Reflector Visual Studio içerisinde bulunan bir tool değildir. Buradan indirebilirsiniz.

Daha önce C# CIL, Metadata, Manifest Kavramları ve “ildasm.exe” yazımızda kullandığımız şu örnek üzerinden gidelim :

// Calc.cs

using System;

namespace CalculatorExample

{

// This class contains the app's entry point.

class Program

{

static void Main()

{

Calc c = new Calc();

int ans = c.Add(10, 84);

Console.WriteLine("10 + 84 is {0}.", ans);

// Wait for user to press the Enter key before shutting down.

Console.ReadLine();

}

// The C# calculator.

class Calc

{

public int Add(int x, int y)

{ return x + y; }

}

Burada bir Program bide Calc sınıfımız var ve örnek olarak Calc sınıfımızın içerisine Add metodu eklemişiz. Bakalım bu programı derlememiz sonucu oluşan exe’yi Reflector’le açarak bu Add metodunun içeriğine ulaşabilecek miyiz? Bunun için önce yukarıda linkini verdiğim yerden Reflector’u bilgisayarınıza indirmeniz gerekmektedir. Program kurulum gerektirmemektedir. Zip dosyasını açıp içerisindeki “Reflector.exe”’yi çalıştırmanız yeterlidir. İlk çalışmada hangi Freamwork versiyonu ile çalıştığınızı soracaktır. Siz içeriğini açmak istediğiniz dll veya exe hangi versiyonda yazılmış ise onu seçerek programı başlatabilirsiniz. Benim yazdığım yukarıdaki program .NET 4.0’da derlendiği için ben 4.0’ı seçip çalıştırdım. Ardından File –> Open sekmelerini tıklayıp yazdığım programın derlenmesi sonucu oluşan Calc.exe’yi bularak açtım.

sonucunda gördüğünüz gibi Calc sınıfımın içerisine tanımladığım Add metodunun içeriğine ulaştım. Bu birlikte çalışılan projelerde eğer diğer takım arkadaşınız sizin yaptığınız değişikliği ezdiyse ve siz ne yaptığınızı hatırlamıyorsanız onu geri almak için mükemmel bir program oluyor. Yani hayat kurtarıyor. Bunun dışında elinizde bir dll veya exe var onun içeriğini merak ediyorsanız yine tam size göre bir program.

Ayrıca yazılan kodları sadece C# olarak getirmiyor. Aşağıdaki listeden seçtiğiniz programlama diline göre assembly içeriği getirtmek mümkün.

Örneğin Calc.exe’yi açarken C# değilde Visual Basic seçseydim sonuç şu şekilde olacaktı :

Yani Reflector için okuyacağı assembly’in hangi dilde yazıldığı önemli değil. Çünkü daha öncede dediğimiz gibi bu okuduğu assembly CIL bilgisi içeriyor. Yani platforma bağlı olmayan evrensel bir bilgi .NET tabanlı her dilin derlenmesi sonucu oluşan bir bilgi. Bu yüzden Reflector’da ona okuması için verdiğiniz assembly’in bu CIL bilgisini derlemenin tersine bir işlem yaparak size vermektedir. Derlenince yazdığımız kodlar nasıl CIL’e dönüşüyorsa Reflector ile de CIL yazılan koda dönüşüyor. Böyle bir program yaptıkları için Reflector yazıcılarına teşekkür etmek lazım sanırım.

C# CIL, Metadata, Manifest Kavramları ve “ildasm.exe”

2011-01-29T17:12:00.002+02:00

CIL ( Common Intermediate Language ) daha önce yazdığım C# CLR, CLS, MSIL Nedir? yazımda bahsettiğim MSIL ( Microsoft Intermediate Langugage ) kavramının aynısıdır. Sadece bu kavramın ismi değişmiştir. CIL ve MSIL hakkında daha geniş bilgiye yukarıda belirttiğim yazıdan yine ulaşabilirsiniz.

CIL yazdığımız programı derlememiz sonucunda oluşan işlemciden bağımsız komut setidir. İşlemciden bağımsız olması CIL’in platform bağımsız olduğunu gösterir. Hangi platformda derlenirse derlensin sonucunda oluşan CIL hep ayni olacaktır. Bu CIL çalıştırılabilir bir kod değildir. En basit anlatımla JIT ile JIT’in çalıştırıldığı platforma göre yorumlanarak çalıştırılabilir bir hale gelecektir.

CIL ve diğer kavramları incelemek için önce C# ile örnek bir program yazalım:

// Calc.cs

using System;

namespace CalculatorExample

{

// This class contains the app's entry point.

class Program

{

static void Main()

{

Calc c = new Calc();

int ans = c.Add(10, 84);

Console.WriteLine("10 + 84 is {0}.", ans);

// Wait for user to press the Enter key before shutting down.

Console.ReadLine();

}

// The C# calculator.

class Calc

{

public int Add(int x, int y)

{ return x + y; }

}

Bu program derlendikten sonra oluşan eğer bir kütüphane ise *.dll dosyası veya console application ise *.exe dosyaları CIL, metadata ve manifest içerir.

Şekil – 1 : mscoree.dll ile derlenen kod şeması

Şimdi bu kavramları derlediğimiz örnek program üzerinden giderek açıklayalım. Bir dll veya exe dosyasının içinde bulunan CIL, metadata ve manifest Visual Studio’nun bir tool’u olan “ildasm” ile görüntülenebilir. Bu tool’a ulşamak için Visual Studio Command Prompt’a “ildasm” yazıp Enter’a basmanız yeterlidir. Bu tool üzerinden File –> Open diyerek yukarıda yazdığımız programın çalışması sonucu oluşan “Calc.exe” dosyasını açarsak bu dosyanın içerisinde bulunan yukarıda bahsettiğimiz CIL, metadata ve manifest kavramlarını görebiliriz.

Şekil – 2 : ildasm programının ekran görüntüsü

CIL Kodu Görüntüleme

Çalıştırdığımız ildasm.exe içerisinde bulunan Main : void() metoduna çift tıkladığımızda o Calc.exe dosyamızın içerisinde bulunan CIL kodunu görüntüleyebiliriz.

Şekil – 3 : CIL Kodu

Type Metadata Kavramı ve Type Metadata Görüntüleme

Önce programımızın Type Metadatasına nasıl ulaşabiliriz ona bakalım ardından da bu kodun programımız için ne ifade ettiğine bakalım. İlk işlem olan Type Metadata görüntülemesi için ildasm.exe üzerindeyken Ctrl + M tuşlarına basmamız yeterlidir. Bu bize Calc.exe programımızın içerisindeki Type Metadata bilgisini gösteren bir pencere açaçaktır.

Şekil – 4 : Type Metadata

Peki bu Type Metadata programımız için ne ifade ediyor şimdi bu soruya gelelim. Bu konuyla ilgili daha geniş bir bilgiyi ileride paylaşacağım ama şimdilik en basit anlamıyla. Metadata program içerisinde tanımladığımız tüm değişken bilgilerini içerir. Örneğin biz bu programda bir CalculatorExample class’ı tanımladık. Bu class tanımı Type Metadata’da tutulmaktadır. Bunun gibi class, structure, enumaration v.b. gibi tanımlamalar ve bunların içerisinde tanımlanan property’ler, event’lar, metotların hepsinin bilgisi Type Metadata içerisinde bulunmaktadır. Örneğin Visual Studio’nun en büyük avantajlarından saydığımız IntelliSense’de bu metadata bilgisini kullanmaktadır. Ayni zamanda debug ederken, compile ederken v.s. gibi önemli işler hep Type Metadata’dan yararlanmaktadır.

Manifest ( Assembly Metadata ) Kavramı ve Görüntüleme

Son olarak exe’mizin içerisindeki Manifest bilgisini görüntülemek için yine ildasm tool’unu kullanmamız yeterlidir. Bu tool ile bir exe açtığımızda karşımıza çıkan ekrandaki MANIFEST yazan sekmeye çift tıkladığımızda exe’mizin manifest dosyasına ulaşmış oluruz.

Şekil – 5 : Manifest

Kısaca Manifest’in görevi assembly versiyon numarası, copyright bilgisi gibi özelliklerini tutar. Yine Manifest hakkında daha detaylı bilgiyi ileride yazacağım için bunuda kısaca geçiyorum.

Sonuç olarak bir program derlendikten sonra oluşan eğer bir kütüphane ise *.dll dosyası veya console application ise *.exe dosyaları CIL, metadata ve manifest içerir. Bu kavramların her birinin ayrı bir görevi vardır ve bunların görevlerini ve derlediğimiz programlarda bunlara nasıl ulaşabileceğimizi yukarıda kısaca işledik.

Kaynaklar : Apress Yayınları : Pro C# 2010 and the .NET 2010 Platform

Vigideo - video izlemenin yeni şekli.

2010-10-31T14:55:00.001+02:00

Vigideo Hakkinda

Vigideo en iyi video sitelerini tek adreste toplayarak aradiginiz tüm videolari ayni adreste izleyebilmenizi saglayan bir sistemdir.Diger bir deyisle Türkiye'nin en kapsamli video arama motorudur. Sagladigi tüm bu olanaklar ile size hizli ve kolay video izlemenizi amaçlamaktadir.

Neden Vigideo?

Vigideo'nun video siteleri içerisinde gittikçe artan büyük sitelerin embeded kodlarini kullanarak olusturulan video sitelerinden farki kullaniciyi reklam ile bogan bir yaklasimi yoktur. Video izlemeden önce 15 sn reklami bekleyin gibi kullaniciyi bezdiren bir yaklasimi yoktur çünkü Vigideo'nun amaci video izlemeyi zorlastirmak degil kolaylastirmaktir. Ayrica bu siteler sadece kendi ekledikleri videolari kullaniciya sunmaktadir. Vigideo ise bunun aksine en iyi video sitelerini tarayarak sonuç döndürmektedir.

Videolari Nasil Izleyebilirim?

Vigideo'da video izlemenin 2 yöntemi vardir. Öncelikle sol üst kösede bulunan arama kutusuna izlemek istediginiz kelimeyi girip hemen bu arama kutusunun yaninda bulunan butona basmaniz gerekmektedir. Bu kelime ne olabilir mesela canimiz Duman grubundan bir sarki dinlemek istedi. Bu durumda "Duman" yazip arama yapmamiz yeterlidir.

Sadece arama kutusuna izlemek istediginiz videoyu yazmaniz yeterli.

Arama kutusuna izlemek istediginiz videoyu yazip hemen yanindaki vigi! butonuna basarak arama yaptiktiginizda asagidaki gibi sonuçlarin döndügünü göreceksiniz.

Bundan sonra artik videonuzu nasil izlemek istediginiz size kalmis olacak ister videonun isminin veya resminin üzerine tiklayarak Vigideo üzerinden videonuzu izleyebilirsiniz. Isterseniz de sagda tarih bölümünün altinda bulunan saglayici resminin üzerine tiklayarak videoyu orjinal sitesinde izleyebilirsiniz. Asagida sitemiz üzerinden izlenen bir videonun screenshot'i yer almaktadir.

Yine arama sonuçlarinin içerisinde bulunan paylasim linkleri ile sevdiginiz, begendiginiz videolari en popüler paylasim ortamlarina ekleyerek arkadaslarinizla paylasabilirsiniz. Iste video izlemeyi bu kadar basit yaptik.

Kendi Playlist'inizi Olusturun

Sevdiginiz videolari ardi ardina izlemek istemez misiniz? Vigideo ile bu artik çok kolay. Izlemek istediginiz videolari "Listeye Ekle" butonu ile playlistinize ekliyorsunuz.

Ve size özel olusturdugunuz listeden seçtiginiz videolari dilediginizde izleyebiliyorsunuz. Ayrica Vigideo sevdiginiz videolari onu bir daha ki ziyaretinize kadar aklinda tutuyor.

En Çok ve En Son Izlenen Videolar

Bu bölüm sayesinde diger kullanicilarin su an ne izlediklerini en çok neleri izlediklerini görerek en popüler videolari buradan izleyebileceksiniz.

Dünyadan Futbol

Futbol keyfini evinize getirdik. Içerisinde Türkiye, Ispanya, Ingiltere gibi büyük liglerin bulundugu 5 ligin maçlarinin ayni zamanda Avrupa Ligi maçlarininda yer aldigi bu bölümümüz sayesinde maçin bitiminin hemen ardindan bu maçlarin genis özetlerini sitemiz üzerinden yüksek kalitede izleyebileceksiniz.

Önemli Not:

Sitemizde izlemis olduguz videolar kesinlikle bizim tarafimizdan eklenmemistir. Sonuçlarin sag tarafinda bulunan saglayici tarafindan videolar izlenmektedir. Vigideo sadece bir video arama motoru oldugu için bu videolarla ilgili herhangi bir sorumluluk tasimamaktadir. Her türlü soru, öneri ve isteklerinizi admin@vigideo.com mail adresine yazarak bize iletebilirsiniz.

Tüm bu özelliklere erişmek için : Vigideo - video izlemenin yeni şekli.

Referandum 2010 Canlı Sonuçları

2010-09-12T19:34:00.001+03:00

C# IClonable ile Referans Tiplerini Klonlamak

2010-08-22T14:40:00.000+03:00

Bilindiği üzere referans tipleri belleğin heap bölgesinde tutulmaktadır. Bu durumun sonucu olarak iki referans tipi arasında bir atama işlemi söz konusu olduğunda, aslında bu referans tiplerinin heap bellek bölgesinde yer alan adresleri eşitlenmektedir. Böyle olunca da referans tiplerinin her hangibirisinde yapılan değişiklik diğerinide otomatikman etkileyecektir. Bu referans tiplerinin değer tiplerinden farklı olduğu bi yönüdür. Çünkü değer tiplerinde bir eşitleme söz konusu olduğunda nesnenin yenisi yaratılmaktadır.

Referans tiplerinde de biz değer tiplerinde olduğu gibi eşitleme yaptığımızda bu referansların birbirlerini etkilememelerini isteyebiliriz. Bu durumda IClonable arayüzünü uygulayarak referans tipinin klonlanmasını sağlayabiliriz. Bunun nasıl yapıldığına geçmeden önce iki referans tipinin birbirine eşitlenmesi sonucu nasıl adreslerinin eşitlendiğine bir örnek verelim.

public class Araba

{

public string Marka { get; set; }

public int Model { get; set; }

public Araba()

{

this.Marka = "Opel";

this.Model = 2010;

}

public Araba(string marka, int model)

{

this.Marka = marka;

this.Model = model;

}

public override string ToString()

{

string arabaBilgisi = "Marka: " + Marka.ToString() + " Model: " + Model.ToString();

return arabaBilgisi;

}

static void Main(string[] args)

{

Araba araba1 = new Araba();

Console.WriteLine(araba1.ToString()); // araba1 nesnesinin özelliklerini yazdırıyoruz.

Araba araba2;

araba2 = araba1;

Console.WriteLine(araba2.ToString()); // araba2 nesnesinin özelliklerini yazdırıyoruz.

araba2.Marka = "Fiat";

araba2.Model = 2009;

Console.WriteLine(araba2.ToString());

Console.WriteLine(araba1.ToString());

Console.ReadLine();

}

Program Çıktısı :

Bu örneğimizde olduğu gibi araba1 nesnesi önce yaratılmış daha sonra araba2 = araba1 denerek araba2 nesnesine atanmıştır. Bu durumda araba2 nesnesine yapılan değişiklik doğrudan araba1 nesnesini etkilemiştir. Bu durumun nedeni atama yapılırken yukarıda anlattığımız şekilde referans tiplerinin heap bellek bölgesinde yer alan adresleri eşitlenmesidir.

Gelin şimdi de IClonable arayüzünü kullanarak bu durumu nasıl çözeceğimize bakalım.

public class Araba:ICloneable

{

public string Marka { get; set; }

public int Model { get; set; }

public Araba()

{

this.Marka = "Opel";

this.Model = 2010;

}

public Araba(string marka, int model)

{

this.Marka = marka;

this.Model = model;

}

public override string ToString()

{

string arabaBilgisi = "Marka: " + Marka.ToString() + " Model: " + Model.ToString();

return arabaBilgisi;

}

#region ICloneable

public object Clone()

{

return new Araba(this.Marka,this.Model);

}

//NOT: Bu şekilde de Klonlama yapılabilmektedir. Fakat bu yöntemde eğer clasın içinde başka bir reference type varsa o kopyalanmaz.

//public object Clone()

//{

// return this.MemberwiseClone();

//}

#endregion

}

static void Main(string[] args)

{

Araba araba1 = new Araba();

Console.WriteLine("araba1: " + araba1.ToString()); // araba1 nesnesinin özelliklerini yazdırıyoruz.

Araba araba2;

araba2 = araba1;

//araba2 = (Araba)araba1.Clone();

Console.WriteLine("araba2: " + araba2.ToString()); // araba2 nesnesinin özelliklerini yazdırıyoruz.

araba2.Marka = "Fiat";

araba2.Model = 2009;

Console.WriteLine("araba2: " + araba2.ToString());

Console.WriteLine("araba1: " + araba1.ToString());

Console.ReadLine();

}

Programın Çıktısı :

İkinci örneğimizde IClonable arayüzü implement edilerek bu arayüzün Clone metodu kullanılmıştır. Ve bu sayede atama yapılırken Clone metodu kullanılarak yeni bir araba nesnesi ve adresi oluşturulması sağlanmıştır. Programın çıktısından açıkça görüldüğü gibi bu sefer araba2 nesnesine yapılan değişiklikler araba1 nesnesini etkilememiştir.

Burada kod içerisinde commentli olarak yazılmış önemli bir nokta var.

//NOT: Bu şekilde de Klonlama yapılabilmektedir. Fakat bu yöntemde eğer clasın içinde başka bir reference type varsa o kopyalanmaz.

public object Clone()

{

return this.MemberwiseClone();

}

Klonlama bu şekilde de yapılabilir fakat Araba nesnesi içerisinde bir referans tipi tanımlı ise bu metod bu referans tipini klonlamaz yani ataması yapılan nesnenin içerisindeki referans tipinin adresi aynen kopyalanır. Bu yüzden bu metodu eğer sınıfınızda referans tipi tanımlamadıysanız kullanmanız gerekmektedir.

C# Static Kullanımı

2010-08-21T19:06:00.000+03:00

Static'in kullanıldığı yerler:

• Bir sınıf(class) içerisinde bulunan metodlar(methods).
• Bir sınıf(class) içerisinde bulunan alanlar (fields)
• Bir sınıfa ait static bir yapıcı metod (constructors)
• Değişmezler (constants) implicit olarak static tanımlama.
• Readonly referanslar.

Bir sınıf(class) içerisinde bulunan metodlar(methods).

Static olarak tanımlanan bir metodun kullanılabilmesi için tanımlanmış olduğu tipin nesne örneğini oluşturmaya gerek yoktur. Bu durum çoğunlukla bir tipin asıl iş yapan fonksiyonelliklerin kullanılabilmesi için, tüm nesneyi örneklemenin gereksiz olduğu durumlarda ele alınır. Instance oluşturup bir statik metodu çağaramayız.

public class Dikdortgen

{

//Dikdortgen sınıfı ile ilgili diğer kodlar.

public static int AlanHesapla(int aKenari, int bKenari)

{

return aKenari * bKenari;

}

class Program

{

static void Main(string[] args)

{

int alan = Dikdortgen.AlanHesapla(3,5);

}

Görüldüğü gibi Dikdörtgen sınıfı içerisinde static olarak tanımalanan AlanHesapla metdodu Dikdörtgen sınıfının instance'ı oluşturulmadan sadece sınıf ismi ardından nokta denerek kullanılmıştır. Bu buze yuraıda yazdığımız gibi nesneyi boşuna yaratmadan Dikdörgen sınıfı içerisindeki metodu çağırmamızı sağlamıştır. Örneğin Console uygulamalarını geliştirirken çok sık kullandığımız Console sınıfına ait WriteLine, ReadLine vb metodlar static olarak tanımlanmışlardır. Hatta bir console uygulaması geliştirdiğimizde, programın giriş noktası olan Main metodunun static olarak tanımlandığını farketmişizdir.

Static metodların kullanılması sırasında dikkat edilmesi gereken bazı durumlar vardır. Öncelikli olarak, static olarak tanımlanmış sınıf metodlarına static olmayan sınıf üyeleride erişebilir. Örneğin:

public class Dikdortgen

{

//Dikdortgen sınıfı ile ilgili diğer kodlar.

public static int AlanHesapla(int aKenari, int bKenari)

{

return aKenari * bKenari;

}

public bool AlanKontorlu(int aKenari, int bKenari,int kontrolAlani)

{

if (kontrolAlani > AlanHesapla(aKenari, bKenari))

return true;

else

return false;

}

Bu kod parçasında görüldüğü gibi static olarak tanımlanan AlanHesapla metodu static olmayan AlanKontrolu metodu içerisinde çağırılabilmiştir. Fakat bu durumun tam tersi mümkün değildir yani static üyeler sadece static üyelere erişebilir.

Bir sınıf(class) içerisinde bulunan alanlar (fields)

Static metodlar gibi, bir sınıf içerisinde kullanılabilecek static alanlarda tanımlayabiliriz. Bir örnekle bunu inceleyecek olursak :

public class Dikdortgen

{

//Dikdortgen sınıfı ile ilgili diğer kodlar.

public static int kontrolAlani = 20;

public static int AlanHesapla(int aKenari, int bKenari)

{

return aKenari * bKenari;

}

public bool AlanKontorlu(int aKenari, int bKenari,int kontrolAlani)

{

if (kontrolAlani > AlanHesapla(aKenari, bKenari))

return true;

else

return false;

}

class Program

{

static void Main(string[] args)

{

Dikdortgen dikdortgen1 = new Dikdortgen();

Console.WriteLine(Dikdortgen.kontrolAlani);

Dikdortgen dikdortgen2 = new Dikdortgen();

Console.WriteLine(Dikdortgen.kontrolAlani);

Dikdortgen dikdortgen3 = new Dikdortgen();

Console.WriteLine(Dikdortgen.kontrolAlani);

Console.ReadLine();

}

Bu kod parçacığında görüldüğü gibi int tipinde static kontrolAlani adında bir değişken tanımlanmıştır ve Dikdörtgen nesnesinin 3 defa instance'ı oluşturulup bu değişkenin değerlerine bakılmıştır. Bu program parçacığının çalışması sonucunda şu şekilde olacaktır:

Burada görüldüğü gibi Dikdörtgen sınıfına ait 3 nesne örneğinin oluşturulmasına ve kullanılmasına rağmen kontrolAlani değerinin hiç bir şekilde değişmediğidir. İşte bu etkinin nedeni kontrolAlani değerinin static olarak tanımlanmış oluşudur. Dolayısıyla Dikdörtgen nesnelerinden kaç tane oluşturulursa oluşturulsun hepsi aynı kontrolAlani değerine işaret etmektedir. Fakat bir static alanın değeri çalışma zamanında değiştirilebilir. Bu duruma şöyle bir örnek verilebilir :

public class Dikdortgen

{

//Dikdortgen sınıfı ile ilgili diğer kodlar.

public static int kontrolAlani = 20;

public void KontrolAlaniDegistir(int yeniKontrolAlani)

{

kontrolAlani = yeniKontrolAlani;

}

public static int AlanHesapla(int aKenari, int bKenari)

{

return aKenari * bKenari;

}

public bool AlanKontorlu(int aKenari, int bKenari,int kontrolAlani)

{

if (kontrolAlani > AlanHesapla(aKenari, bKenari))

return true;

else

return false;

}

class Program

{

static void Main(string[] args)

{

Dikdortgen dikdortgen1 = new Dikdortgen();

Console.WriteLine(Dikdortgen.kontrolAlani);

dikdortgen1.KontrolAlaniDegistir(30);

Dikdortgen dikdortgen2 = new Dikdortgen();

Console.WriteLine(Dikdortgen.kontrolAlani);

Dikdortgen dikdortgen3 = new Dikdortgen();

Console.WriteLine(Dikdortgen.kontrolAlani);

Console.ReadLine();

}

Görüldüğü gibi Dikdortgen sınıfının içerisine kontrolAlaniDegistir adında bir metod tanımlanarak static bir değişken olan kontrolAlani'ni çalışma anında değiştirme amaçlanmıştır. Bu programın çıktısı şu şekilde olacaktır:

Fakat burada contructer işin içene girince durum farklı bir boyut alacaktır. Bu örneğin bir farklı versiyonunun contructer'lı yazılmış hanina bakarsak :

public class Dikdortgen

{

//Dikdortgen sınıfı ile ilgili diğer kodlar.

public static int kontrolAlani = 20;

public Dikdortgen()

{

kontrolAlani = 25;

}

public void KontrolAlaniDegistir()

{

kontrolAlani = 40;

}

public static int AlanHesapla(int aKenari, int bKenari)

{

return aKenari * bKenari;

}

public bool AlanKontorlu(int aKenari, int bKenari,int kontrolAlani)

{

if (kontrolAlani > AlanHesapla(aKenari, bKenari))

return true;

else

return false;

}

class Program

{

static void Main(string[] args)

{

Dikdortgen dikdortgen1 = new Dikdortgen();

Console.WriteLine(Dikdortgen.kontrolAlani);

dikdortgen1.KontrolAlaniDegistir();

Dikdortgen dikdortgen2 = new Dikdortgen();

Console.WriteLine(Dikdortgen.kontrolAlani);

Dikdortgen dikdortgen3 = new Dikdortgen();

Console.WriteLine(Dikdortgen.kontrolAlani);

Console.ReadLine();

}

}

Bu örneğin çıktısı şu şekilde olacaktır:

Görüldüğü gibi bu durumda KontrolAlaniDegistir metodu işe yaramamıştır. Çünkü her yeni nesne örneği oluşturulduğunda kontrolAlani değişkenine 25 değeri atanmıştır. Bu durumdan kurtulmanın yolu bir sonraki başlıkta açıklanacaktır.

Bir sınıfa ait static bir yapıcı metod (constructors)

Static yapıcı metodu çoğunlukla bir sınıfın static değişkenlerine ilk nesne örneği oluşturulduğunda bir kereliğine değer atmak için kullanabiliriz. Bu bilgiler ışığında Dikdortegen sınıfımızı aşağıdaki gibi değiştirelim ve static yapıcı metodumuz içerisinde static kontrolAlani değişkeninin değerini belirleyelim.

public class Dikdortgen

{

//Dikdortgen sınıfı ile ilgili diğer kodlar.

public static int kontrolAlani = 20;

//public Dikdortgen()

//{

// kontrolAlani = 25;

//}

//Bu sefer statik constructer kullandık.

static Dikdortgen()

{

kontrolAlani = 35;

}

static void KontrolAlaniDegistir()

{

kontrolAlani = 40;

}

public static int AlanHesapla(int aKenari, int bKenari)

{

return aKenari * bKenari;

}

public bool AlanKontorlu(int aKenari, int bKenari,int kontrolAlani)

{

if (kontrolAlani > AlanHesapla(aKenari, bKenari))

return true;

else

return false;

}

Bu durumda program çıktısı :

bu şekilde farklı bir sonuç elde etmemizin nedeni static yapıcılar(constructor)sadece ilk nesne örneği oluşturulduğunda çalışır. Aynı tipe ait sonraki nesne örneklemelerinde çalışmazlar.

Değişmezler (constants) implicit olarak static tanımlama.

Constant lar uygulamanın çalışması boyunca değişmeyecek değerleri saklamak için kullandığımız bir değişken çeşididir. Basit olarak değer türünden (value types) sabit bir değişkeni aşağıdaki gibi tanımlayabiliriz.

public const double PI = 3.14;;

Çağırırkende şu şekile çağırılabilir :

double pi = Derived.PI;

yani yazılmamış olsa bile cons değişkenler static değişkenlerdir bu yüzden bir const değişken tanımlarken static kelimesini eklersek tanımlamaya hata alırız.

Readonly referanslar.

Constant lar derleme zamanında (compile time) tanımlanan değişkenler için geçerlidir. Bu nedenlede sadece değer türlerine (value types) uygulanabilirler. Oysaki bazı durumlarda sabit olarak tanımladığımız değişkenlerin değerleri çalışma zamanında belirlenebilir. Bu nedenle referans tiplerini sabit olarak kullanılabilmek için readonly tanımlarız. Bununla ilgilide örneğimizi şu şekilde genişletebiliriz :

public class Dikdortgen

{

//Dikdortgen sınıfı ile ilgili diğer kodlar.

public static int kontrolAlani = 20;

//public Dikdortgen()

//{

// kontrolAlani = 25;

//}

//Bu sefer statik constructer kullandık.

static Dikdortgen()

{

kontrolAlani = 35;

}

public void KontrolAlaniDegistir()

{

kontrolAlani = 30;

}

public static int AlanHesapla(int aKenari, int bKenari)

{

return aKenari * bKenari;

}

public bool AlanKontorlu(int aKenari, int bKenari,int kontrolAlani)

{

if (kontrolAlani > AlanHesapla(aKenari, bKenari))

return true;

else

return false;

}

public class Sekiller

{

public static readonly Dikdortgen dikdortgen;

static Sekiller()

{

dikdortgen = new Dikdortgen();

}

class Program

{

static void Main(string[] args)

{

Dikdortgen dikdortgen1 = new Dikdortgen();

Console.WriteLine(Dikdortgen.kontrolAlani);

dikdortgen1.KontrolAlaniDegistir();

Dikdortgen dikdortgen2 = new Dikdortgen();

Console.WriteLine(Dikdortgen.kontrolAlani);

Dikdortgen dikdortgen3 = new Dikdortgen();

Console.WriteLine(Dikdortgen.kontrolAlani);

Dikdortgen dikdortgen4 = Sekiller.dikdortgen;

Console.ReadLine();

}

C# Volatile Anahtar Sözcüğü

2010-08-15T21:55:00.002+03:00

Derleyiciler kodunuzun daha hızlı çalışabilmesi için çoğu zaman kodunuza mudahalede bulunurlar. Bu müdehaleler kod optimizasyonu olarak bilinir. Ne gibi optimizasyonlar yapılır derseniz. Mesela bir değişken tanımladınız ve hiç çağırmadınız. Bu durumda derleyici bu değişkeni derlenecek kodun içerisine almayarak derlenecek kod boyutunu küçültür. Ayni şekilde yanlışlıkla hiç bir şekilde içine girilmiyecek bir if yazdınız bu sefer derleyici bu if içerisinde yaptığınız işlemleri derlenecek koda eklemeyecektir. İşte tüm bunlar bize performans olarak geri döner. İkinci bir optimizasyon ise microişlemci düzeyinde optimizasyondur. Bu derleyicinin değişkenlerin elde edilmesinde yada tekrar yazılmasında belleğin yada işlemcinin tercih edilmesi ile ilgilidir. Değerin mikroişlemci tarafından belleğe(ram) yazılması ile mikroişlemcideki register bölgesine yazılması arasında büyük fark vardır. Bu fark elbette hız faktörüdür. İşte tam bu noktada ikinci tip optimizasyon kuralını tanımlayabiliriz. Derleyici öyle bloklara rastlayabilir ki, bu bloklar içinde bulunan bir değişkenin değerini her defasında bellekten okuyacağına bu değişkenin değerini bir defaya mahsus olmak üzere mikroişlemcinin ilgili register bölgesine bölgesine kaydeder ve sonraki okumalarda işlemci bellek yerine bu register bölgesini kullanır. Böylece kodunuzun çalışma süresinde önemli sayılabilecek bir azalma görülür.

Bildiğiniz üzere uygulamalar genellikle çoklu iş parçacıklarından(multi thread) ve proseslerden oluşur. Her bir proses diğer bir proses teki değişkene işletim sisteminin izin verdiği ölçüde erişip üzerinde işlemler yapabilir. Aynı şekilde bir iş parçacığıda diğer bir iş parçacığında bulunan değişkene erişip üzerinde çeşitli işlemler yapabilir. Peki bunun bizim optimizasyon kurllarımızla bağlantısı ne? Şöyle ki : derleyici bir değişkenin değerinin farklı bir iş parçacağı tarafından yada farklı bir proses tarafından işleneceği üzerinde durmaz. Bu tamamen işletim sisteminin yönetimindedir. Hal böyleyken bizim yukarıda bahsettiğimiz ikinci optimizasyon tipi bazı durumlarda yarar getireceğiniz zarar getirebilir. Zira optimizasyon adına bir değişkenin değerini her defasında bellekten okuma yerine mikroişlemcideki ilgili register dan okurken o anda farklı bir iş parçacağı yada farklı bir proses hatta ve hatta işletim sistemi sizin erişmeye çalıştığınız değişkenin değerini sizin uygulamanızın mantığına göre değiştirebilir. Bu durumda siz o değişkenin son halini kullanmamış olursunuz. Dolayısıyla programınızda farklı thread lar yada prosesler arasında paylaşılan veya işletim sistemi tarafından değiştirilmesi muhtemel olan değişkenlerinizi optimizasyon kuralına tabi tutmamanız gerekir. Bu durumda volatile anahtar sözcüğü burada imdadımıza yetişiyor. Bir değişkeni volatile anahtar sözcüğü ile bildirdiğiniz takdirde derleyicinizin optimizasyon ile ilgili parametresini açık tutsanız bile ilgili değişken yukarıda bahsi geçen tehlikeli optimizasyon kurallarına tabi tutulmayacaktır. Yani volatile ile bildirilen değişkenlere programın akışı sırasında her ihtiyaç duyulduğunda değişkenin gerçek yeri olan belleğe başvurulur.

Volatile aşağıdaki değişken tipleri ile birlikte kullanılabilir.

Herhangi bir referans tipindeki değişken ile

byte, sbyte, short, ushort, int, uint, char, float yada bool. türünden olan değişkenler ile

byte, sbyte, short, ushort, int, yada uint türünden semboller içeren numaralandırmalar(enums) ile

unsafe modda iken herhangi bir gösterici türü ile

Bu konuyla ilgili MSDN'de bulunan aşağıdaki örneği inceleyerek konuyu daha iyi anlayabiliriz.

using System;
using System.Threading;

class Test
{
    public static int result;
    public static volatile bool finished;

    static void Thread2()
    {
        result = 143;
        finished = true;
    }

    static void Main()
    {
        finished = false;
        new Thread(new ThreadStart(Thread2)).Start();

        for (; ; )
        {
            if (finished)
            {
                Console.WriteLine("result = {0}", result);
                return;
            }
        }
    }
}

Yukarıda görüldüğü gibi boolean bir değer olan finish değişkeni volatile olarak tanımlanmıştır. Bu programdaki püf nokta finished isimli değişkenin ana thread ve ana thread içinde başlatılan yeni thread tarafından ortak kullanılan bir değişken olmasıdır. Eğer finished değişkeni volatile olarak bildirilmemiş olsaydı, akış thread2 metoduna gelmiş olmasına rağmen Main metodu içindeki if bloğu çalıştırılmayabilirdi. Çünkü derleyici ana thread içinden finished değişkeninine tampolanmış bir bölgeden(register) erişebilir. Bu durumda finished değişkeninin gerçek değeri true olmasına rağmen ana thread de finished değişkeni halen false olarak ele alınır. Bu yüzden finished değişkeninin her durumda son versiyonunu elde etmek için bu değişken volatile anahtar sözcüğü ile bildirilmiştir.

Kaynak : CSharpNedir.com

C# Const ve Readonly Farkı

2010-08-15T21:19:00.001+03:00

Bir uygulama yazdık ve bir değişkenin değerinin değişmemesini istiyoruz. Bu durumda bu değişkeni const veya readonly tanımlarız. Peki const ve readonly tanımlanan değişkenler arasında nasıl bir fark var?

const : Türkçe’ye Sabit olarak çevrilebilir. Class seviyesinde tanımlanır ve tanımlanma anında değeri verilmek zorundadır. Sonradan değeri değiştirilemez.

readonly : Sadece-Okunabilir anlamına gelir. Class seviyesinde tanımlanır. Tanımlandığı anda değeri verilebilir veya Class Constructor’ında değeri verilebilir. Sonradan değeri değiştirilemez. Const'tan en büyük farkı budur. İkincisi ise Readonly değişkenlere nesne referansı ile ulaşabiliriz. Const da ise sınıfın kendisi ile ulaşabiliriz.

namespace CONST
    {
        class ConstReadonlyVeri
        {

public ConstReadonlyVeri()

{

pi = 22 / 7;

}

            public const string sonbahar = "Autumn";
            public readonly float pi = 3.14f;
        }
    }

    namespace CONST
    {
        class Program
        {

            const string mat= "matematik";
            static void Main(string[] args)
            {
                //Aşağıdakini yaparak elemanlara ulaşamayız.
                //SabitVeri s = new SabitVeri();
                Console.WriteLine(ConstRadonlyVeri.sonbahar);
                Console.WriteLine(mat);
                // Değiştirmeyi denersek
                // ConstReadonlyVeri.sonbahar = "ilkbahar";
                // Expected alırız.
            }
        }
    }

C# Namespace Hakkında

2010-08-15T17:13:00.003+03:00

Namespace'ler .NET Framework sınıf kütüphanesindeki veri türlerini ve sınıfları kullanabilmemiz için C# dilinde using anahtar sözcüğü ile birlikte kullanılır ve derleyiciye bildirilir.

using System;

public class Hello
{
    public static void Main()
    {
        Console.WriteLine("Merhaba Dünya!");
    }
}

burada görüldüğü gibi System namespace'inin projemize using keywordu ile eklemiş olduk. System'i using ile kodumuza eklememiş olsak Console clasını direk yazamaz bunun yerine System.Console... şeklinde yazmamız gerekirdi. Buda kodumuzun okunurluğunu düşürürdü. İç içe namespace'ler mümkündür(System.Forms gibi). Bunun dışında bizde kendi namespace'lerimizi oluşturup projelerimizde kullanabiliriz.

Namespace import edip kullanırken şöyle bir sorunun çıkması olasıdır :

namespace Turkce
{
    public class Harf
    {
       …
    }
}
namespace Ingilizce
{
    public class Harf
    {
       …
    }
}

Yukarıda iki namespace tanımı var. Biz projemize bu iki namespace'i tanımlarsak ikisinde de ortak olan Harf sınıfına erişimde hata alacağız.

using System;
using Turkce;
using Ingilizce;

public class Dil
{
    public static void Main()
    {
        Harf harfler = new Harf();
    }
}

bu kod parçası hata vercektir çünkü instance'ı yaratılan Harf sınıfının Turkce mi yoksa Ingilizce mi namespace'ınden geldiğini çözemeyecektir. Bu durumdan kurtulmanın 2 yöntemi vardır. Birinci Yöntem :

using System;
using Turkce;
using Ingilizce;

public class Dil
{
    public static void Main()
    {
        Turkce.Harf() turkceHarf= new Turkce.Harf();
        Ingilizce.Harf() ingilizceHarf= new Ingilizce.Harf();
    }
}

Fakat bu çözüm okunurluğu azalttığı için tavsiye edebileceğim bir çözüm değil bunun yerine :

using System;
using Turkce;
using Ingilizce;

public class Dil
{
    using TurkceHarf= Turkce.Harf;
    using IngilizceHarf= Ingilizce.Harf;
    public static void Main()
    {
        TurkceHarf turkceHarf= new TurkceHarf();
        IngilizceHarf ingilizceHarf= new IngilizceHarf();
    }
}

Takma isim verme yöntemi olan bu yöntem daha kullanışlıdır. Takma isimler ancak ve ancak tanımlanadıkları blok içinde geçerlidir. Başka bloklarda takma adları kullanmak derleme zamanında hataya yol açar.

C# as ve is Operatörlerinin Kullanımı

2010-08-15T16:04:00.002+03:00

is Operatörünün Kullanımı

Boxing ve Unboxing işlemleri yapılırken veya sıradan bir tip dönümüşümü yaparken is operatörünü kullanarak programımızın dönüştürme hatası vermemesini kontrol edebiliriz. Bir değişkenin tipinini dönüşüm yapmak istediğimiz tiple is ile karşılaştırarak çevrimin doğru olup olmuyacağını karşılaştırabiliriz. Yani is ile boolean bir değer elde edilir. is Anahtar sözcüğünün örnek kullanımı:

static void Main(string[] args)

{

String derivedObj = "Dummy";

Object baseObj1 = new Object();

Object baseObj2 = derivedObj;

Console.WriteLine("baseObj2 {0} String",

baseObj2 is String ? "is" : "isnot");

Console.WriteLine("baseObj1 {0} String",

baseObj1 is String ? "is" : "isnot");

Console.WriteLine("derivedObj {0} Object",

derivedObj is Object ? "is" : "isnot");

int j = 123;

object boxed = j;

object obj = new Object();

Console.WriteLine("boxed {0} int",

boxed is int ? "is" : "isnot");

Console.WriteLine("obj {0} int",

obj is int ? "is" : "isnot");

Console.WriteLine("boxed {0} System.ValueType",

boxed is ValueType ? "is" : "isnot");

}

bu programın çıktısı :

baseObj2 is String
baseObj1 isnot String
derivedObj is Object
boxed is int
obj isnot int
boxed is System.ValueType

görüldüğü gibi is anahtar sözcüğü değişkenin tipinin karşılaştırma tipine bakarak bize o mu değil mi bilgisini vererek tip dönüşümlerinde fayda sağlamaktadır. is sadece tanımlı tipler üzerinde çalışır. Yani biz bir class tanımladıysak ve bunun tipi hakkında bilgi almak istiyorsak is bize bu konuda yardımcı olamayacaktır.

As Operatörünün Kullanımı

Daha önce is sadece tanımlı tipler üzerinde çalıştığını. Yani biz bir class tanımladıysak ve bunun tipi hakkında bilgi almak istiyorsak is bize bu konuda yardımcı olamayacağını söylemiştik. Bu durumda devreye as anahtar kelimesi devreye girer. is operotoruyle çok benzerdi fakat is operatoru boolean bir değer döndürürken as operatoru hedef tipin referansını döndürür. Eğer dönüşüm imkansız ise null değeri döndürür. As operatorunun örnek kullanımına bakarsak :

using System;

public class BaseType { }

public class DerivedType : BaseType { }

public class EntryPoint
{

    static void Main()
    {

        DerivedType derivedObj = new DerivedType();

        BaseType baseObj1 = new BaseType();

        BaseType baseObj2 = derivedObj;

        DerivedType derivedObj2 = baseObj2 as DerivedType;

        if (derivedObj2 != null)
        {

            Console.WriteLine("Conversion Succeeded");

        }
        else
        {

            Console.WriteLine("Conversion Failed");

        }

        derivedObj2 = baseObj1 as DerivedType;

        if (derivedObj2 != null)
        {

            Console.WriteLine("Conversion Succeeded");

        }
        else
        {

            Console.WriteLine("Conversion Failed");

        }

        BaseType baseObj3 = derivedObj as BaseType;

        if (baseObj3 != null)
        {

            Console.WriteLine("Conversion Succeeded");

        }
        else
        {

            Console.WriteLine("Conversion Failed");

        }

    }

}

Bu programın çıktısı :

Conversion Succeeded
Conversion Failed
Conversion Succeeded

C# 3.0 : Implicitly Typed Local Variable Kullanımı

2010-08-15T15:15:00.001+03:00

Implicitly Typed Local Variable C# 3.0 ile birlikte gelen özelliklerden biri. Bu makalemizde bu özelliğe değineceğiz. Kısaca bu özellik ile artık değişkenlerimizi "var" kelimesi ile tanımlayabiliyoruz. Bu ne demek oluyor şöyle ki biz bir değişken tanımlarken bunun tipinin int, string vaya daha başka herhangi bir tip olduğunu söylemek zorunda kalmıyoruz. Compiler hangi tipte bir değişken olduğunu belirlemek için tanımlamanın sağ tarafına bakıyor. Kullanımı built-in type, anonymous type, user-defined type veya .NET Framework kütüphanesinden bir class olabilir. Görüldüğü gibi tip tanımlaması yapmakla bir farkı yok tip yerine var kelimesini koyuluyor sadece. Peki o zaman bu bize ne kolaylık sağlıyor neden kullanalım ki derseniz anonymous type'lar sadece var ile gösterilebilir ve bunu linq deyimlerinde kullanacağız. Ayrıca "var" daha az kod yazmanızı sağlıyor. Uzun ve karmaşık tiplerde kolaylık sağlıyor.

int value= 7; // explicitly
var value= 7; // implicitly

List liste = new List(); // explicitly
var liste = new List(); // implicitly

Kullanım Kuralları:

- Değişkeni tanımlarken ilk değerini kendisine eşitlememiz gerekiyor ki compiler hangi türde yaratabileceğini bilsin.
- Bir değişken önce int daha sonra string olarak tanımlanamaz.
- Sadece local olarak kullanılabilir.

C# Ref ve Out Anahtar Sözcüklerinin Kullanımı

2010-08-15T13:19:00.003+03:00

Ref Anahtar Sözcüğü

Değer tipleri(int, double, byte vs.) metotlara kopyalanarak geçirilirler yani değişkenin birebir yeni bir kopyası oluşturulur. Ancak bazı durumlarda değer tiplerini de referansları ile metotlara geçirmek isteyebiliriz. Bu durumda ref anahtar sözcüğünü kullanarak bunu gerçekleştirebiliriz. ref anahtar sözcüğü değer türlerinin metotlara referans yolu ile geçirilmesini sağlar. Referans türleri zaten referans yolu ile geçirildiği için bu türler için ref anahtar sözcüğünü kullanmak gereksizdir. Ancak kullanımı tamamen geçerli kılınmıştır.Burada dikkat edilmesi gereken nokta ref ile tanımlanan metodu çağırırken yine ref çözçüğü kullanılması gerekmektedir. ref sözcüğünün kullanımı ile ilgili diğer bir önemli nokta ise ref ile kullanılacak değişkenlere mutlaka değer atanmış olma zorunluluğudur. Herhangi bir değer verilmemiş değişkeni ref ile de olsa kullanamayız. Şimdi bir örnekle ref kullanımına bakalım :

public struct Coordinate //Value Type
{

    public int x;
    public int y;
}
public class EntryPoint //Reference Type
{
    public static void AttemptToModifyCoord(Coordinate coord)
    {
        coord.x = 1;
        coord.y = 3;
    }
    public static void ModifyCoord(ref Coordinate coord)
    {
        coord.x = 10;
        coord.y = 10;
    }
    static void Main()
    {
        Coordinate location;
        location.x = 50;
        location.y = 50;
        AttemptToModifyCoord(location);
        System.Console.WriteLine("( {0}, {1} )", location.x, location.y);
        ModifyCoord(ref location);
        System.Console.WriteLine("( {0}, {1} )", location.x, location.y);
    }
}

bu programın çıktısı şu şekilde olacaktır :

( 50,50 )
( 10,10 )

buradanda anlaşıldığı gibi ilk metodumuz olan AttemptToModifyCoord metoduna gönderilen ve değer tipi olan location struct'ının bir kopyası oluşturulup gönderildiği için main metodunun içinde tanımlanan location'una bir etkisi olmamıştır. Ama bu değer tipini ref ile ModifyCoord metoduna gönderdiğimizde ise bunun bir kopyasını değil nesnenin adresine giderek kendisini referans almıştır. Bu durumda ModifyCoord metodunun yaptığı değişiklik main metodunun içerisindeki location değer tipini etkilemiş ve x,y'nin değerini 10 yapmıştır. Yani kısacası ref değer tiplerini referans yolu ile aktarır.

Out Anahtar Sözcüğü

Out anahtar sözcüğünün kullanımının ref anahtar sözcüğünün kullanımından bir farkı yoktur. Out'ta değer tipini referans yolu ile aktarır tek farkı ref kullanımında olduğu gibi ilk değer atamasının yapılması zorunluluğunun olmamasıdır. Yukarıdaki örneği aynen out'la yazabiliriz. Sadece bu sefer main metodu içerisinde yaptığımız ilk değer atamasına bu durumda gerek kalmayacaktır.

C# CLR, CLS, MSIL Nedir?

2010-07-25T20:47:00.003+03:00

Merhaba bu yazımda CLR, CLS, MSIL olgularının ne anlama geldiğini en basit şekilde anlatacağım. Zaten C# veya Java yazıyorsanız programlamaya ilginiz varsa bu olguları biliyorsunuzdur bu durumda yeniden bir hatırlamış olursunuz bilmiyorsanızda yeni bir şey öğrenmiş olursunuz..

CLR ( Common Language Runtime )

C# ile üretilmiş kodların sistem üzerinde çalıştırılmasını sağlayan mekanizmadır. Bir C# kodu yazıp derlediğimizde bu kod Microsoft Intermediate Language ( MSIL ) 'a dönüştürülür. Bu kod çalıştırılabilir bir kod değildir. Bu kod " sözde kod " ( pseudocode ) içeren bir dosyadır. Bu kod anca bulunduğu sistemde bir ara program ile çalıştırılır. Bu program MSIL'i, sistem üzerinde çalıştırır. İşte C# ta bu CLR 'dir. Yani CLR 'nin olduğu her ortamda ( işletim sistemi ve işlemci farketmeksizin ) C# da derlenmiş kodlar daha doğrusu MSIL çalışacaktır.

Program çalışacağı zaman C# ile derlenen kodlar yani MSIL kodlar; bir JIT ( Just-In-Time - Tam zamanında ) derleyici tarafından kullanılarak çalıştırılabilir koda dönüştürülürler. C# ( veya .NET ) kodları çalıştırıldığı zaman CLR, bu JIT derleyiciyi çalıştırır. JIT derleyici programınızın ihtiyaçlarına göre MSIL 'i yerel dile çevirir. Yani MSIL olarak ürettiğiniz her kod CLR 'nin olduğu her ortamda o sisteme uygun bir dile çevrilir ve yürütülür. Bu kodun içinde yeralan metadata olarak tanımlanan çıktı bulunur. Bu çıktı sayesinde programınızın diğer kodlarla etkileşimi sağlanır.

CLR ,programlarımızı değişik şekilde derleyebilir. Varsayılan derleme türü JIT(Just IN TIME- çalışam anında derleme) 'dır. Program çalışırken daha önce derlenmemiş bir parçasına gelince hemen o kısmı da derler ve bunu hafızda chach'e koyar. Tekrar aynı program parçasını çalıştırmak gerekirse burayı hafızadan çalıştırır. Eğer RAM 'imizi yeteri kadar büyükse, programın tamamı derlenmiş ve hafızada depolanmış durumda olabilir. Bu durumda programımız çok hızlı çalışır.

Hafızamızın yeteri kadar büyük olmadığı durumlarda EconoJIT (Ekonomik JIT) derleyicisini kullanabiliriz. Bu derleyici ile programın derlenmiş kısımları hafızada depolanmaz ve her seferinde aynı program parçası derlenir. Tabi ki bu derleyici normal JIT'e göre programlarımızı daha yavaş çalıştırır. Ama RAM 'imizi çok daha az kullanır.

CLR ile gelen üçüncü derleyicimiz PreJIT(ön JIT derleyicisi) ise derleme işini program çalışmadan önce yapar ve tüm makine kodlarını bir yerde saklar. Çalışma anında çok hızlı olan programımız diğer JIT derleyicileriyle derlenmiş olanlara nazaran çok hızlı çalışır.

Kısaca C# kodumuz iki defa derleme aşamasından geçer program kodu MSIL'ye, MSIL ise makine koduna çevrilir.

CLS ( Common Language Specification - Ortak Dil Spesifikasyonu )

Common Language Specification(CLS) bünyesinde barındırdığı birtakım yapıları ve kısıtları ile kütüphane(library) ve derleyici(compiler) yazabilmek için rehberlik yapmaktadır. CLS yazılan bir kütüphanenin CLS'yi destekleyen diğer programlama dilleri ile entegre şekilde çalışabilmesini ve bu diller tarafından da kullanılabilmesini sağlamaktadır. CLS CTS'nin bir altkümesidir. CLS uygulama geliştiriciler için büyük önem arzetmektedir. Öyle ki bir uygulama geliştirici yazdığı kodun diğer kod geliştiriciler tarafından da kullanılabilir olmasını gözönünde bulundurmalıdır. CLS'nin kriterleri ve kuralları gözönünde bulundurularak yazılan bir API(Application Program Interface) diğer programlama dilleri içerisinden kullanılabilmekte Common Language Runtime tarafından da işletilebilmektedir.

.NET uyumlu programlama dili oluştururken belirli standartlara uyulması gerekir. Bu standartlar CLS (Common Language Specifications - Dillerin ortak özellikleri) ile belirlenmiştir.

Kaynaklar : C#Nedir.com, Ceviz.com

C# Generic Kolleksiyon Sınıfları

2010-03-24T22:42:00.002+02:00

Bu yazımızda C# 2.0 ile birlikte C# diline eklenen Generic yapıları kullanılarak geliştirilmiş olan bazı koleksiyon tabanlı nesneleri ve generic yapıların avantajlarına bakacağız.

ArrayList liste = new ArrayList();
liste.Add(5);
liste.Add("generic");

Örneğimizde System.Collection isim alanından türeyen ArrayList sınıfını kullanarak liste adında bir kolleksiyon tanımladık ve bu kolleksiyona int tipinde 5 ve string tipinde "generic" değerlerini ekledik. Görüldüğü gibi iki farklı tür olmasına rağmen ArrayList'e bu iki değeri atayabildik. Çünkü ArrayList değerleri obje tipinde depo eder bu yüzden istediğimiz kadar farklı türü Add metodu ile ekleyebiliriz.

int a = (int)liste[0];
string b = (string)liste[1];

Ama kolleksiyondan bu değerleri çekip bir değişkene atamak istiyorsak bir casting işlemi yapmak gerekmektedir. Yani obje veri türünü int veri türüne çevirmemiz gerekmektedir. Buna C#'ta boxing işlemi denmektedir. Referans tipi olan obje ile değer tipi olan int belleğin farklı bölümlerinde bulunmaktadır. Bu yüzden bu işlem bizim için büyük bir performans kaybıdır. Generic kolleksiyon sınıfları bu soruna yanıt getirmiştir.

List<string> liste = new List<string>();
liste.Add("safak");
liste.Add("unel");

Örneğimizde yine liste tipinde bir koleksiyon tanımladık ama bu sefer bu koleksiyon System.Collections.Generic isim alanı altından tanımlandı. Yani generic bir koleksiyondur. Kolayca görüleceği gibi generic koleksiyonların farkı tanımladığımızda hangi tür nesneler içereceğini vermemizdir. Örneğimizdeki liste koleksiyonu string tipinde nesneler tutan bir koleksiyondur çünkü koleksiyonumuzu tanımlarken büyük küçük işaretleri arasına yazdığımız string bize bu koleksiyonun sadece string tipinde nesneler tutacağını belirtir. Şimdi bu koleksiyondan çektiğimiz bir nesneyi nasıl bir değişkene atıyoruz ona bakalım.

Resimde görüldüğü gibi string tipindeki a değişkenine listenin herhangi bir değerini atamak istediğimizde karşımıza çıkan ToolTip bize listenin string tipinde bir değer döndürdüğünü söylüyor. Bu durumda artık bizim ilk örneğimizdeki ArrayList'te olduğu gibi bir casting yapmamıza gerek yok. Yani:

string a = liste[0];

dememiz bizim liste koleksiyonumuzun 0. indeksindeki değeri a değişkenine atamamız için yeterli. Casting'e gerek yok çünkü liste koleksiyonumuzun string tipinde bir değer döndüreceğiniz biliyoruz. Bu şekilde unboxing yapmadığımız yani objeyi stringe çevirmeye çalışmadığımız için herhangi bir performans kaybıda yaşamayız. Generic kolleksiyonların hayatımızı kolaylarştıran en önemli özelliğide budur..

Dictionary Kollesiyonunun Kullanımı:

C# Koleksiyonlar(System.Collection) yazımda bahsettiğim HashTable'ın generic halidir. Örnek bir HashTable tanımı yaparsak:

Hashtable hashTable= new Hashtable();
hashTable.Add("5", "unel");
hashTable.Add("4", "blog");
hashTable.Add("1", true);
hashTable.Add("3", "safak");
hashTable.Add("2", "2");
hashTable.Add("6", 123);

Görüldüğü gibi HashTable kollesiyonu hem string hem boolean hemde int türünden nesneleri ayni anda tutmaktadır. Çünkü generic olmadığı için tüm bu nesneleri obje olarak saklamaktadır. Dictionary kollesiyonuda ayni HashTable gibi key/value ikili matığıyla çalışmaktadır fakat generic olduğu için key ve value parametrelerinin hangi değer tipi olcağı tanımlama yapılırken verilmektedir. Bir örnek verecek olursak :

görüldüğü gibi tanımlamaların ardından artık yeni bir değer eklerken ToolTip bize key değerinin int tipinde , value değerinin ise string tipinde olacağını söylemektedir. Tanımlama :

            Dictionary<int, string> genericDictionary = new Dictionary<int, string>();
            genericDictionary.Add(0, "safak");
            genericDictionary.Add(1, "unel");

genericDictionary isminde tanımladığımız Dictionary kolleksiyonumuza tanımlama esnasında key değerinin int, value değerinin ise string tipinde olacağını büyük küçük işaretleri arasına yazarak belirtmiş olduk. Yani bundan sonra genericDictionary'a yeni bir değer eklerken key değerini int, value değerini ise string tipinde vermek zorundayız. Bu şekilde genericDictionary'dan bir değer çekersek dönecek value değerinin string tipinde olacağını biliriz ve casting işlemi yapmadan yani herhangi bir performans kaybına uğramadan bu koleksiyon üzerinden istediğimiz herhangi bir değeri string tipinde bir değişkene atayabiliriz.

Kısaca Generic kolleksiyon yapılarının özellikleri ve yararları bunlar umarım generic kolleksiyonlar bize ne kadar yararlı olduysa bu yazıda size o kadar yararlı olmuştur. Hoşçakalın..

C# Code Snippets

2010-03-24T15:21:00.001+02:00

Devamlı kullandığımız if döngüsü olsun, for,foreach yapıları olsun bunları yazmak devamlı yazmış olsak bile zaman alan bir işlemdir. Visual Studio bunları yazarken bize kolaylık olsun diye IntelliSense'in yanından snippets kavramını ortaya çıkarmıştır. Bu snippets yapısı bize devamlı kullanıdığımız kod parçacıklarını kolayca yazmamızı sağlar. Visual Studio ile gelen hazır snippetlar olduğu gibi kendimizde snippet oluşturup bunu projemizi yazarken kullanabiliriz.

Peki hazır olan if,foreach,for gibi snippetları kullanmak için neler yapmalıyız? Bunun için kod yazarken "foreach" yazıp TAB tuşuna iki kere basmak yeterlidir.

Fotograflardaki örneklerde görüldüğü gibi "foreach" yazıp TAB TAB yapınca VS bize foreach yapısının örnek bir kullanımını oluşturdu bize kalan sadece bu yapıyı kendi programımıza göre değiştirip kullanmak. Böyle devamlı kullandığımız şeyleri snippet ile kullanmak bize çok büyük bir zaman kazandıracaktır. Peki diyelim ki MessageBox kontrolünü çok kullanıyosunuz ve bunun snippeti yok bu durumda ne yapacaksınız? Bunun için VS bize kendi snippet'larımızı oluşturup kullanma olanağı sağlıyor.

Snippet Oluşturmak :

Bunun için ilk yapmamız gereken bir xml dosyası açıp uzantısını .snippet olarak değiştirmek. Ardından aşağıda örneğini gördüğünüz kod gibi bir xml formatlı snippet tanımı hazırlamak.

Buradaki xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet" snippet için xml şemamızdır bunu eklememiz bize hangi snippet dosyası oluştururken hangi tabların olduğunu gösteren IntelliSense'ı yükleyeceği için önemlidir.

Bu örnek ile artık kodumuz içerisine uzun uzun MessageBox kodu yazmak yerine ShortCut olarak verdigimiz mb stringini kullanarak Default olarak vediğimiz "Hello World" stringini içeren MessageBox kontrolu mb yazıp TAB TAB dersek çıkacaktır. MessageBox.Show(); içerisindeki $message$ ID olarak verdiğimiz "message"ın Default'u "Hello World"ü parametre olarak alır.

Fakat bu kodu yazmak bizim snippet'ımızın çalışacağı anlamına gelmez bunun için bu snippeti yüklememiz gerekmektedir. Bunun için yapılması gereken Tools -> Code Snippets Manager diyip snippets dosyamızı import etmemizdir.

Dosyamızı bulup import işlemini yapmamızın ardından artık snippets dosyamız içerisinde tanımladığımız snippetları kullanmaya başlayabiliriz.

C# Configuration File (App.config,Web.Config,..) Dinamik Olarak Yazmak

2010-03-18T23:57:00.006+02:00

Uygulamalarımızın konfugrasyon bilgilerini yani connection stringlerini, hostname gibi application settinglerini ve benzerlerini kaydettiğimiz web.config, app.config, machine.config gibi configuration dosyaları vardır. Uygulamamız çalışmadan önce bir çok ayarı bu dosyalara kaydederiz. Bu dosyaların en büyük yararı program içerisinde bir çok yerde kullanacağımız bilgileri bu dosyalara kaydedip istediğimiz zaman cağırabiliyor olmamızdır. Bunun bize en büyük artısı mesela connection stringimizi buraya değilde hard-code olarak programımıza yazdık. Bir çok yerde vertabanı bağlantısı yapacağımız için connection stringte herhangi bir değişiklik yapacaksak teker teker kod içinde nerelere yazdığımızı bulmamız gerekecekti. Fakat configuration dosyaları sayesinde sadece burda değiştirisek her yerde değiştirmiş olacağız.

Configuration dosyalarına kısa bir giriş yaptıktan sonra asıl konumuza gelelim. Bu configuration dosyalarını uygulamamızın çalışması esnasında değiştirmek istersek ne yapmalıyız? Uygulamamızın bir web uygulaması olduğunu düşünerek anlatacağım. Web uygulamalarında configuration dosyası olarak web.config dosyası bulunmaktadır. Ama uygulamanın çalışması esnasında bu dosyada bir değişiklik yaparsak uygulamamızın restart edilmesi gerekmektedir. Bu yüzden dinamik olarak configuration dosyasında değişiklik yapmak istiyosak direk olarak web.config üzerinde değişiklik yapamayız bu durumda projemize yeni bir configuration dosyası eklememiz gerekmektedir. Bunun için Item -> New Item ile kolayca yapabiliriz.

Yukardaki resimde görüldüğü gibi mysettings.config adında yeni bir configuration dosyası eklemiş olduk. Öncelikle bu mysettings.config dosyasını web.config dosyası içinde tanımlamamız gerekmektedir.

<appsettings configsource="mysettings.config"/>

web.config dosyası

bu tanımlamayı yaptıktan sonra mesela mysettings.config dosyasına hostname'imizi kaydetmiş olalım.

<appSettings>

<add key="hostName" value="http://safakunel.blogspot.com"/>

<appSettings>

mysettings.config dosyası

Şimdi bu tanımladığımız hostName'imizi programda dinamik olarak değiştirelim:

   Configuration c = WebConfigurationManager.OpenWebConfiguration("~");

    AppSettingsSection s = (AppSettins)c.GetSection("appSettings");

    s.Settings["hostName"].value = "http://www.safakunel.com";

    c.Save();

buradaki OpenWebConfigration içindeki "~" karakteri o dizindeki configuration dosyası anlamına geliyor. Daha sonra appSettings içindeki hostName'e ulaşıp "http://safakunel.blogspot.com" olan hostName'i "http://www.safakunel.com" olarak dinamik bir şekilde programın çalışma esnasında değiştiriyoruz. Son olarak bu işlemleri yapabilmemiz için System.Web.Configuration namespace'ini kullanmalıyız bunu unutmayalım. Bu şekilde C# bize dinamik bir şekilde configuration dosyalarına müdahale şansı tanıyor. Hoşçakalın..

C# Localization (Çok Dillilik)

2010-03-18T21:48:00.000+02:00

Uygulamalarımızı eskiden çok dilli şekilde yazmak istediğimizde bunun çok zor bir işlem olduğunu bir önceki yazımda bahsetmiştim. Şimdi bunu resource dosyalarını kullanarak nasıl kolay bir şekilde yapabiliriz ona bir göz atacağız.

Bunun için resource C# Resource Kullanımı yazımda bahsettiğim gibi projemize iki resource dosyası ekleyelim. Bunların isimlerine

Localization.resx (Localization.tr-TR.resx default olarak Türkçe kullandığımız için bu şekilde yazmamıza gerek yoktur ama yazabilirizde)
Localization.fr-FR.resx

verelim. Ardından bu Localization.resx dosyamıza key olarak Title değer olarakta "Merhaba" değerini verip kaydedelim. Daha sonra Localization.fr-FR.resx dosyamıza geçerek yine Title'ı key olarak verip değer olarakta "Bonjour" değerini verelim.

Lokalization.resx Dosyasının Görünümü

Lokalization.fr-FR.resx Dosyasının Görünümü

Bunu yaptıktan sonra artık programımızda bununları kullanalım :

Localization.Culture = new CultureInfo("fr-FR");
string frTitle = Localization.Title;
Localization.Culture = new CultureInfo("tr-TR");
string trTitle = Localization.Title;

kod parçacığını incelersek Localization.Culture = new CultureInfo("fr-FR"); diyerek dili Fransızcaya set etmiş oluyoruz ve bundan sonra resx dosyamızın ismi olan Localization diyip bunun içine Title keyi ile kaydettiğimiz değeri çağırırsak otomatik olarak dili fransızcaya set ettiğimiz için Lokalization.fr-FR.resx dosyasına bakarak frTitle stringine "Bonjour" değerini atıyor. Yani bundan sonra resource dosyamızdan ne çağırırsak çağıralım dili Fransızcaya set ettiğimiz için uygulamamız Lokalization.fr-FR.resx dosyasına bakacaktır.Daha sonra Localization.Culture = new CultureInfo("tr-TR"); diyerek dili yeniden Türkçeye set ediyoruz. Bu durumda da artık Lokalization.fr-FR.resx dosyasına değil Lokalization.resx dosyasına bakıyor ve trTitle stringine "Merhaba" değerini atıyor.

Bu şekilde iki veya kaç dil desteği vermek istiyorsanız o sayıda resx dosyası oluşturup ayni parametrelerle çevirilerini yaparsanız çok dilli bir program çok kolay bir şekilde yazmış olursunuz. Hoşçakalın..

100. Yazımın Şerefine..CHEARS!

2010-03-18T19:29:00.002+02:00

3 Kasım 2008'de ilk yazımı yazmıştım o günden bu güne 1.5 yıla yakın bir süre geçmiş ve bugün 100. yazımı yazdım. Bundan önce defalarca neden blog yazdığımı söylemiştim ama yazdıklarımı düşününce kendim için not alıyorum diyebilirim sanırım. Biraz bencilce oluyor ama doğrusu bu. Fakat bunu yaparken evde duran boş bir kağıda not almak yerine buraya alıyorum. Mesela programlama çalışıyorum bitince bir daha geri dönmek için öğrendiklerimi buraya yazıyorum, şiir yazmak istiyor canım buraya karalıyorum bla bla bla.. Bunun artısı benim için bir hatırlatma aracı olan bu blog buraya gelenler için öğrenme aracı oluyor. Bu bloğu açtığımdam bu güne 10.209 kez okunmuş. Okuyan herkese teşekkürler..Umarım yardımcı olabilmişimdir veya okuduklarını beğenmişlerdir.

Yakında safakunel.com olarak yayına devam edecek bloğumu okuyan herkese bir kez daha teşekkürler hoşçakalın..

Şsfak ÜNEL

C# Localization (Yerelleştirme - Dil ve Kültür Desteği) Kullanımı

2010-03-18T18:49:00.003+02:00

Önceleri bir programı farklı dillerde yazmak çok zordu. Programlar farklı diller için farklı şekillerde ayrı ayrı yazılırlardı. Yani 2 dil desteği veren Türkçe ve İngilizce destekli bir program yazacağınızı düşünün ayni kodları iki kez yazmanız gerekecekti. Localization sadece çeviri olarak düşünülmemesi gerekir. Çünkü farklı dillerde mesela en basitinden nokta ve virgülün anlamı farklı olabilir veya saatin gösterimi, tarihin gösterimi farklı olabilir. Localization bize tüm bu değişiklikleri yapma imkanı vermektedir.

Bir uygulamanın dil desteği ve kültür desteği vermesi için ise, framework içinde yer alan System.Globalization isim alanındaki sınıflardan ve resource files dediğimiz kaynak dosyalarından yararlanılır. Bir başka deyişle, bir uygulamanın yerelleştirilmesi yani dil desteği ve kültürel desteğin sağlaması için, uygulama kodları ile destek birimleri birbirinden ayrı tutulmuştur. Böylece, bir uygulamayı çok sayıda kültür için yerelleştirmek mümkün olmaktadır.

IETF tarafından belirlenmiş RFC 1766 standartlarına göre kültürler doğal (neutral) ve alt (specific) kültür olmak üzere iki parametreyle isimlendirirler. Fransa örneğine bakarsak :

fr - FR : Fransa
fr - BE : Belçika

bu örneklerde RFC 1766 standartlarına göre Fransızca okunaşan iki ülke olan Fransa ve Belçika'nın nasıl isimlendirildiğini görüyoruz. İlk sıradaki fr doğal (neutral) FR ve BE ise alt (specific) kültürleri gösterir.

Kültürel Bilgilerin Listelenmesi:

CultureInfo[] kulturBilgiListesi=CultureInfo.GetCultures(CultureTypes.AllCultures);

AllCultures: Tüm kültürleri listeler.
InstalledWin32Cultures: Windows sistemlerinde kullanılan kültürleri listeler.
NeutralCultures: Sadece dille ilişkilendirilmiş doğal kültürleri listeler.
SpecificCultures: Alt kültürleri listeler.

Peki bu kültürler ile programımızı nasıl yerelleştirecez? Bunun için:

Thread.CurrentThread.CurrentCulture=guncelKultur;

Bu kod satırı ile, çalışan thread için kültür değeri, seçilen kültüre göre ayarlanmıştır. Dolayısıyla bu kod satırını izleyen satırlardaki sayısal değer, tarih ve zaman formatları, seçilen kültüre göre ekrana gelecektir. İşte bu şekilde programımızı basit bir şekilde yerelleştirmiş olduk. Bundan sonraki yazımda resources dosyalarıyla uygulamalarımıza nasıl çoklu dil desteği verebiliriz bunu öğrenip yazmaya çalışacağım. Umarım bu yazı şuan okuyan kişiye yardımcı olmuştur. Hoşçakalın..

Kaynak : Burak Selim Şenyurt : Localization (Yerelleştirme) - 1

C# Resources Kullanımı

2010-03-17T22:26:00.002+02:00

Bir uygulamada kullanıdığımız kaynakları düşünürsek bunlar resimler,sesler ve yazılar(string) olabilir. Bu kaynakları bir pathden okutmak resource kullanmadan programımızı yazarken yapabileceğiz bir yaklaşımdır. Fakat en basitinden programımızın logosunu bir path içine attık oradan okuyoruz diyelim bu programı başka bir bilgisayara kurduğumuzda ayni pathi oraya taşımak zorunda olacağımızı gösterir veya taşıdık diyelim yalnışlıkla silinme tehlikesi vardır. Bununla birlikte derlenmiş programımızın farklı dillerdeki versiyonları olabilir. Bu durumda her dil için bir string kaynak dosyası(resource file) hazırlamamız yetecektir.

Kısacası resource yönetimi bize istediğimiz kaynakları exe içerisine gömmemize olanak sağlar. Resource dosyaları *.resx ve *.resource uzantılıdır. Şimdi bunları nası projemize ekleriz ve kullanırız onu bir görelim.

Resx uzantılı dosya Xml tabanlı bir dosyadır. Kaynak değerleri anahtar-değer çiftleri şeklinde saklar. Xml tabanlı oluğu için programcılar tarafından kolayca okunabilir. Assembly içerisine doğrudan eklenmezler.

Assembly içerisine doğrudan eklenen dosya kaynakları binary formatta tutan resource uzantılı dosyadır.

Aslında System.Resource altında bulunan ResourceWriter sınıfı ile kod ile bu kaynakları projemize ekleyebiliriz ama tabiki Visual Studio IDE'miz ile bu çok daha kolay bir şekilde yapılabilmektedir. Şimdi gelin buna bir bakalım :

Bunun için öncelikle projemize sağ tıklayıp Add -> New Item diyerek yeni öğe ekleme ekranına gelmeliyiz.

Ardından açılan öğe ekleme ekranından Resources File seçerek programımıza *.resx uzantılı dosya ekleriz.

*.resx dosyasını ekledikten sonra bize sadece istediğimiz kaynakları bu dosyaya eklemek kalıyor. Bunun için oluşturduğumuz resx dosyasını çift tıklayıp açmamız ve Add Resource tabını kullanabiliriz.

Görüldüğü gibi Add Resource tabıyla resource dosyamıza istediğimiz kaynakları ekleyebiliriz. Bu kaynakları eklediğimizde Solution Explorer’ da Resources isimli bir klasör açıldığı göreceksiniz. Kaynak olarak eklediğimiz tüm dosyalar bu klasör altına otomatik olarak taşınacaktır.

Peki Resources klasörümüz burda, resx uzantılı dosyamız burda peki kaynakları binary formatında saklayan resources uzantılı dosyamız nerede? Bu dosya obj klasörü altındaki debug klasörüne otomatik olarak atılmaktadır. Bu resources dosyamız Projemizinismi. + resx dosyamıza verdiğimiz isim + .resources şeklinde isimlendirilir. Mesala bizim örneğimizde yaratılan resources dosyasının ismi WindowsApplication2.Resource2.resources olmuştur. Bu işlemleri doğru bir şekilde yaptıysak şu anda resoruce dosyamız içerisinde yer alan kaynaklar exe uzantılı assembly içerisine dahil edilmiştir. Buda, uygulamamızın exe dosyasını alıp başka bir adreste (örneğin başka bir makinede) çalıştıracak olursak, assembly içerisine gömülen kaynakların kullanılabileceği anlamına gelmektedir.

ResourceManager

Assembly içerisine gömülen kaynak dosyalarına ulaşabilmek için ResourceManager sınıfından yararlanırız. Mesela örneğimizde deneme.gif dosyasını eklemiştik şimdi bu resim dosyasına nasıl ulaşıp ele alabiliriz onu bir görelim :

ResourceManager resManager = new ResourceManager("WindowsApplication2.Resource2", Assembly.GetExecutingAssembly());
pbImage.Image=(Bitmap)resManager.GetObject("deneme");
resManager.ReleaseAllResources();

Burada deneme bir resim dosyası olduğu için resources dosyası içinde binary şekilde yer olur o yüzden örneğimizde bu resmi bir PictureBox içerisine atamak için Bitmap'e çevirmemiz gerekmektedir. Resources içerisinden bir string çekmek istiyorsak böyle bir şeye ihtiyaç duymayacaktık.

Bir yazımızında daha sonuna geldik. Bu yazımızda Resources kullanımıyla ilgili bir giriş yaptık. Bir sonraki yazım yine Resource kullanımı ile ilgili olacak bu sefer resources dosyalarını kullanarak nasıl Localization işlemleri yapılır bunu öğrenip anlatmaya çalışacağım. Bu yazı bloğumdaki 100. yazı olmasından dolayı önemli bir yazıydı benim için ayni zamanda da hem benim için hem sizin için yararlı olacağına inanıyorum. Umarım yararlı olmuştur herkes için..Hoşçakalın..

Yararlanılan Kaynaklar : Burak Selin Şenyurt: İlk Bakışta .Net Resource Yönetimi

C# XmlReader Kullanımı

2010-03-14T22:23:00.002+02:00

XmlReader programlarınızın XML okumasını sağlar. Çeşitli metod ve propertylere sahiptir. Bunlara bir göz atacak olursak :

Metodlar:

Read: XML dökümanı üzerindeki sıradaki element'i okumamızı sağlar.

Skip: Readerın üzerinde bulunduğu element'in sıradaki child elementini'unu okumadan geçmemizi sağlar.

MoveToNextAttribute: Reader'ı üzerinde bulunduğu child elementin üzerinde bulunan attribute'ten bir sonraki attribute konumlanmasına sağlar

Properties:

Name: Üzerinde bulunduğu node'un adını döndürür.

Value: Üzerinde bulunduğu node'un değerini döndürür.

NodeType: Üzerinde bulunduğu node'un tipini döndürür.

Örnek Kullanım :

C üzerinde bulunan test isimdeki xml dosyasını okuyup result adındaki değişkene atayan örnek bir kod yazacak olursak:

using System.Xml;

            string result = "";
            XmlReader xmlReader = XmlReader.Create("C://test.xml");
            while (xmlReader.Read())
            {
                result += (xmlReader.Name + "=" + xmlReader.Value);
            }
            xmlReader.Close();

Bununla birlikte xml dosyalarını okurken xml okuyucumuza çeşitli ayarlar yapılandırabiliriz. Bunu XmlReaderSettings sınıfı ile yapabiliriz. Bu sınıfın önemli propertyleri:

IgnoreComments: Xml dökümanın içeriğindeki yorumların okunup okunamaması ayarının yapıldığı property.

IgnoreWhitespace: Xml dökümanın içeriğindeki boşluk karakterinin okunup okunamaması ayarının yapıldığı property.

CheckCharacters: Xml dökümanın içeriğini okurken karakter kontrolünün yapılıp yapılmaması ayarını yapabileceğiniz property.

şimdide xml okuma kodunumuzu okuyucumuza bazı ayarlar ekleyerek nasıl yazılır onu görelim:

            XmlReaderSettings xmlReaderSett = new XmlReaderSettings();
            xmlReaderSett.IgnoreComments = true;
            xmlReaderSett.IgnoreWhitespace = true;
            xmlReaderSett.CheckCharacters = true;

            string result = "";
            XmlReader xmlReader = XmlReader.Create("C://test.xml",xmlReaderSett);
            while (xmlReader.Read())
            {
                result += (xmlReader.Name + "=" + xmlReader.Value);
            }
            xmlReader.Close();

Bu yazımızında sonuna geldik. Umarım size yardımcı olabilmişimdir.

C# ExecuteScalar, ExecuteNonQuery ve ExecuteReader Kullanımı

2010-03-14T19:28:00.001+02:00

C# uygulamalarımızda veritabanıyla ilgili bir sorgu yazdırdığımızda bu sorguyu çalıştırmak için C# bize çeşitli metodlar sunmuştur. Bunlar :

ExecuteScalar : Sorgumuz scalar tek bir değer döndürüyorsa sorgumuzu bu metod ile çalıştırmakta sorgu hızı bakımından fayda vardır.

ExecuteNonQuery : Sorgumuzda UPDATE, DELETE gibi işlemler yapıyorsak bu metodu kullanmalıyız. Ayrıca bu metod ektilediği kayıt sayısını döndürür.

ExecuteReader : Eğer sorgumuzda bir tablo için SELECT işlemi yaptıysak SELECT attığımız kayıtları okumak için bu metodu kullanmalıyız.

ExecuteScalar kullanımı ile ilgili örnek

mySqlConnection.Open();
mySqlCommand.Connection = mySqlConnection;
mySqlCommand.CommandType = CommandType.Text;
mySqlCommand.CommandText = "SELECT COUNT(ID) FROM DENEMETABLE";
int count = (int) mySqlCommand.ExecuteScalar();

ExecuteNonQuery kullanımı ile ilgili örnek

mySqlConnection.Open();
mySqlCommand.Connection = mySqlConnection;
mySqlCommand.CommandType = CommandType.Text;
mySqlCommand.CommandText = "UPDATE DENEMETABLE SET WEBSITE = 'safakunel.blogspot.com' WHERE ID = 1";
mySqlCommand.ExecuteNonQuery();
int etkilenenKayitSayisi = mySqlCommand.ExecuteNonQuery();

ExecuteReader kullanımı ile ilgili örnek

mySqlConnection.Open();
mySqlCommand.Connection = mySqlConnection;
mySqlCommand.CommandType = CommandType.Text;
mySqlCommand.CommandText = "SELECT * FROM DENEMETABLE";
SqlDataReader r = mySqlCommand.ExecuteReader();
while (r.Read())
{
//okunan satırla ilgili işlemler buraya yazılır.
}
r.Close();
mySqlConnection.Close();

C# Connection String App.config ve Web.config İçinde Saklamak ve Çağırmak

2010-03-14T16:35:00.001+02:00

Eğer yazdığımız program bir veritabanına bağlanıyor ise bu bağlantıyı kurmak için bildiğiniz gibi bir ConnectionString kullanılır. Bu stringi hardcoded olarak bağlantı kuracağımız zaman yazabiliriz ama connectionString'de herhangi bir değişiklik yapmak zorunda kalırsak tüm programı tarayıp teker teker değiştirmemiz gerekecektir. Birde uzun bir program yazdığımızı düşünürsek bunu yapmak çok zor olacaktır. Bu durumu ortadan kaldırmak için bu stringi app.config ve web.cofig içerisinde saklayabiliriz. Böylece sadece buradan stringi değiştirmek bağlantı yaptığımız her yere etki edecektir.

Örnek:

<connectionstrings>
<add name="OrnekConnectionString"
connectionString="Data Source=(local);Initial
Catalog=AdvebtureWorks;Integrated Security=True"
providerName="System.Data.SqlClient" />
</connectionString>

ConnectionString Çağırma:

using System.Configration;

string myConnectionString = CongifrationManager.ConnectionStrings[OrnekConnectionString];

bu şekilde app.config veya web.config dosyası içerisine sakladığımız connectionStringi programımızda tanımladığımız string tipindeki myConnectionString değişkenine atamış oluruz.