Bir programcının dünyası

Geliştirdiğiniz bir uygulamada, geçici bir dosyaya ihtiyacınız olduğunu düşünelim. Ama daha önce oluşturulmuş bir dosyanın ismini vermediğinizden emin olmak istiyorsunuz.

• Kullanıcının geçici dosyaları hangi dizinde tuttuğunu bulmak
• Rastgele bir dosya ismi üretmek, eğer bu dosya isminde bir dosya varsa, yeni bir dosya ismi bulana kadar rastgele yeni dosya ismi üretmek
• Ürettiğiniz rastgele isme sahip yeni bir dosya oluşturmak

adımlarını gerçekleştirmek yerine, Path.GetTempFileName() method’unu kullanabilirsiniz.

string GeciciDosya = Path.GetTempFileName(); /// GeciciDosya değişkeni kullanıcının Temp dizininde 0-byte boyutlu bir dosyanın tam dosya yolunu içerir.

using (StreamWriter sw = File.OpenText(GeciciDosya))
{
	sw.WriteLine("Geçici Dosyaya yazılacak bilginin ilk satırı");
}

Benim kullandığım bilgisayarda, Path.GetTempFileName() methodu geriye “C:\Documents and Settings\EnginPolat\Local Settings\Temp\tmp3A.tmp” string değeri döndürdü.

Eğer rastgele dosyanın gerçekten oluşturulmasını değil, sadece dosya isminin üretilmesini istiyorsanız; Path.GetRandomFileName() methodunu kullanabilirsiniz;

string DosyaAdi = Path.GetRandomFileName(); /// DosyaAdi değişkeni sadece rastgele bir dosya ismini içerir.

Benim bilgisayarımda, Path.GetRandomFileName() methodu geriye “z4a2sa4a.49e” string değeri döndürdü.

Uygulamanızda sizin belirlediğiniz şablona göre rastgele üretilmiş bir string’e ihtiyaç duyarsanız, aşağıdaki kod işinizi görebilir;

Random r = new Random();
string KullanilabilecekKarakterler = "AzByCxDwEvFuGtHsIrJqKpLoMnNmOlPkQjRiShTgUfVeWdXcYbZa1234567890";

MatchEvaluator Rastgele = delegate (Match m) {
	return KullanilabilecekKarakterler[r.Next(KullanilabilecekKarakterler.Length)].ToString();
};

Console.WriteLine(Regex.Replace("XXXX-XXXX-XXXX-XXXX", "X", Rastgele)); /// Lv2U-jHsa-TUep-NqKa
Console.WriteLine(Regex.Replace("Şifreniz : XXXX", "X", Rastgele)); /// Şifreniz : w6G0
Console.WriteLine(Regex.Replace("XXX.XXX-XX/XX", "X", Rastgele)); /// Fu8.c3Y-xT/6P
Console.WriteLine(Regex.Replace("XXXXXX", "X", Rastgele)); /// 8cPD2y

C# ile string dizisini elemanların uzunluğuna göre sıralama için aşağıdaki kod kullanılabilir;

private IList<string> SortStringLength(IList<string> arrString)
{
	string[] tmpString = arrString.ToArray<string>();
	Array.Sort(tmpString, new Comparison<string>(delegate(string str1, string str2)
	{
		if (str1 == null && str2 == null)
			return 0; ///iki değişkende null
		else if (str1 == null)
			return -1; ///birinci değişken null
		else if (str2 == null)
			return 1; ///ikinci değişken null
		else
		{
			if (str1.Length < str2.Length)
				return -1; ///birinci değişken daha kısa
			else if (str1.Length > str2.Length)
				return 1; ///ikinci değişken daha kısa
			else
				return str1.CompareTo(str2); ///iki değişken aynı uzunlukta, alfabetik sıralama yapılıyor
		}
	}));

	return tmpString;
}

string[] OrnekDizi = { "333", null, "1", "22", "12", "4444" };
OrnekDizi = (string[])SortStringLength(OrnekDizi);

foreach (string s in OrnekDizi)
    Console.WriteLine(s);

// Console Çıktısı:
// [null]
// 1
// 12
// 22
// 333
// 4444

Bu kodu kullanarak sıraladığınız string dizisinde, elemanlar önce uzunluklarına göre sıralanacaktır. Aynı uzunlukta olan elemanlar ise alfabetik dizilime göre sıralanacaktır.

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();
        }
    }
}

Bu yazımda aslında çok kolay bir konuyu işliyor olacağım, C# kodunuza yorum satır(lar)ı eklemek.

Bu konuyu yazmamdaki asıl amacım, BilgeAdam‘daki öğrencilerim için hatırlatma niteliğinde olmasıdır.

C# geleneksel C-tarzı yorum satır(lar)ını destekler; (// …) veya (/* … */)

// Bu satır örnek olarak yorum haline getirilmiştir.
/* Bu satır örnek olarak yorum haline getirilmiştir. */

Tek satır yorum operatörünün (//) satırda buluduğu noktadan satırın sonuna kadar herşey yorum olarak kabul edilir.

Çok satır yorum operastöründe (/* */), başlangıç operatöründen (/*) bitiş operatörüne (*/) kadar herşey yorum olarak kabul edilir.

Tek satırlı ve çok satırlı yorumlar şu şekilde yazılabilir;

// Tek satırlı yorum
/* Bu satırlar
çok satırlı yorum
için iyi bir örnektir. */

Aşağıdaki kod’da geçerlidir;

Console.WriteLine(/* İşte yorum! */ “Kodun burası derlenir.”);

Aynı zamanda aşağıdaki gibi kodlar sayesinde, satır içerisinde kod parçalarına yorum yazabilmek mümkündür;

EkranaCiz(Boy, /* Yukseklik */ 250);

Tabiki string karakterleri arasındaki yorum operatörleri, normal karakter olarak değerlendirilecektir;

string mesaj = “/* Bu normal bir metin değişkenidir */”;

Bu yazımda, bilgisayarda kurulu programları, LINQ kullanarak nasıl sorgulayacağımızı inceleyeceğim.

Bilgisayara kurduğumuz her program bilgisayarın Registry’sine kurulum ile ilgili bir kayıt bırakır.

Bilmeyenler için not: Registry’yi açmak için komut satırına regedit yazmanız yeterli.

Registry ile ilgili daha detaylı bilgi için MSDN: Registry sayfasına bakmanızı tavsiye ederim.

Registry‘nin LocalMachine\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall dalında, bilgisayara kurulu olan uygulamalara ve bu uygulamalar ile ilgili bilgilere ulaşılabilir.

Uygulamamızda, Registry class’ını kullanabilmek için, kodumuza aşağıdaki namespace’i eklememiz gerekiyor.

using Microsoft.Win32;

Hemen form tasarlamakla başlayalım.

Yukarıdaki formu oluşturduktan sonra btnGetir butonunun Click olayına aşağıdaki kodu yazalım;

using (RegistryKey rk = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall"))
{
	var programlar = from k in rk.GetSubKeyNames()
					 let r = rk.OpenSubKey(k)
					 select r.GetValue("DisplayName");

	foreach (string program in programlar)
		if (!string.IsNullOrWhiteSpace(program))
			lbProgramlar.Items.Add(program);
}

Registry sınıfının static LocalMachine üyesi üzerinden OpenSubKey() method’unu çağırıyoruz.

Daha sonra yaptığımız;

from k in rk.GetSubKeyNames()
let r = rk.OpenSubKey(k)
select r.GetValue("DisplayName");

LINQ sorgusunu yazmak oluyor. Bu sorgu, ilgili Registry dalının altında bulunan tüm dalları açar ve içlerindeki DisplayName anahtarının değerini getirir.

Son olarak basit bir foreach döngüsü ile bu değerleri lbProgramlar Listbox kontrolüne dolduruyoruz.

İşte benim bilgisayarımdaki sonuç;

.Net Framework içerisinde string.ToUpper() ve string.ToLower() fonksiyonlarını kullanarak string değişkenin içeriğini BÜYÜK ve küçük harfe çevirebiliyoruz.

Metni Upper Case (Tümü Büyük Harfler) ve Lower Case (Tümü Küçük Harfler) formatlamak haricinde Title Case (Kelimelerin Baş Harfleri Büyük Gerisi Küçük) çevirmek yaygın kullanılan başka bir formattır.

string sınıfına bir Extension Method yazarak bu özelliğe sahip olmasını sağlayabiliriz. Extension Method‘u yazarken bilmemiz gereken ilk şey, ToTitleCase() method’unun TextInfo sınıfında yer aldığıdır. TextInfo sınıfına CultureInfo sınıfının CurrentCulture özelliğinden ulaşabiliriz.

public static class ExtensionManager
{
	public static string ToTitleCase(this string Text)
	{
		return CultureInfo.CurrentCulture.TextInfo.ToTitleCase(Text);
	}
}

Artık projemiz içerisinde herhangi bir yerde string değişkenimizin ToTitleCase() method’unu kullanabiliriz.

private void frmMain_Load(object sender, EventArgs e)
{
	string AdSoyad = "engin polat".ToTitleCase();
}

Yukarıdaki kod parçası çalıştığı zaman, AdSoyad değişkeninin içeriği Engin Polat olacaktır.

Not : CultureInfo sınıfının CurrentCulture özelliğinden TextInfo sınıfının özelliklerine eriştiğimiz için, bilgisayarınızda kullandığınız dile göre sonuç farklılık gösterebilir.

Null Coalescing Operatörü (??) C# dilinin gözden kaçan, ama çok kullanışlı bir operatörüdür.

?? operatörü sayesinde bir değişkenin değerinin null olduğu durumda alternatif değer döndürebiliriz.

string mesaj = "merhaba dünya!";
string sonuc = mesaj ?? "mesaj yok";

Eğer mesaj değişkeni null değer içeriyor olsaydı, sonuc değişkenine “mesaj yok” değeri atanacaktı.

string mesaj = null;
string sonuc = mesaj ?? "mesaj yok";

int? yas = 30;
int sonuc = yas ?? -1;

Eğer yas değişkeni null ise, sonuc değişkenine -1 değeri ata.

int? yas = null;
int sonuc = yas ?? -1;

Hangi .Net yazılımcısına sorsanız, string tipinde değişkenin hafızada kapladığı yeri hesaplamak için, karakter sayısını 2 ile çarpmak gerektiğini söyler (UTF-8 kodlama).

Genel olarak kabul gören bu hesaplama yöntemi, birçok durumda gerçeğe çok yakın sonuç üretir. Fakat sonuç tam olarak doğru değildir.

UTF-8 (Unicode Transformation Format) hakkında daha fazla bilgiyi Wikipedia‘da yeralan şu makale‘den edinebilirsiniz.

Peki string değişkenin hafızada kapladığı alanı tam olarak nasıl hesaplayacağız?

string OrnekString = "ἄλφα βῆτα γάμμα δέλτα deneme test";
MessageBox.Show("Uzunluk * 2: " + OrnekString.Length * 2 + " Byte");
MessageBox.Show("Gerçek uzunluk: " + Encoding.UTF8.GetByteCount(OrnekString).ToString() + " Byte");

OrnekString.Length * 2: 66 Byte değerini üretirken,

Encoding.UTF8.GetByteCount(OrnekString): 53 Byte değerini üretmiştir.

String değişkenlerin hafızada kapladığı alanı tam olarak hesaplamanız gerektiği durumlarda, Encoding.UTF8.GetByteCount() fonksiyonunu kullanmanızı öneririm.

C# ile string tipindeki bir değişkenin dolu olduğunu kontrol etmek için yapılması gereken iki şey vardır;

• Değişkenin null olmadığını kontrol etmek
• Değişkenin boş olmadığını kontrol etmek

Aşağıdaki kod ile bu iki kontrolu doğru şekilde yapabiliriz;

string SiteUrl = "http://www.enginpolat.com";
if (SiteUrl != null && SiteUrl != "")
{
}

Daha iyi bir yöntem olarak aşağıdaki şekilde de yazabiliriz;

string SiteUrl = "http://www.enginpolat.com";
if (string.IsNullOrEmpty(SiteUrl) == false)
{
}

Fakat bu kod parçası ile ilgili canımı sıkan iki nokta var;

• Karşılaştırma işleminde negatiflik aramak. string.IsNullOrEmpty fonksiyonu, değişkenin dolu olduğu değil, boş olduğu durumda true değer döndürüyor. (“Dolu mu?” yerine “Boş değil, değil mi?”)
• Eğer bir değişkenin dolu olduğunu kontrol edeceksem, değişkenin ismini yazdıktan sonra karşılaştırma yapmam lazım. Yukarıdaki kodda ise, değişkenin ismini yazdıktan sonra başa dönüp, string.IsNullOrEmpty fonksiyonunu eklemem gerekiyor.

Benim için kafa karışıklığı olan bu kod yerine aşağıdaki ExtensionMethod‘u kullanıyorum;

public static class ExtensionMethods
{
	public static bool ContainsText(this string Karsilastirilacak)
	{
		return string.IsNullOrEmpty(Karsilastirilacak) == false;
	}
}

ContainsText “C” harfi ile başladığı için, Intellisense ilk set ile birlikte gösteriyor.

Bu yazımda, bir dizi’nin C# ile nasıl karıştırılacağı (shuffle edileceği) ile ilgili bir örnek yapacağım.

Aşağıdaki formu oluşturarak, hemen programlamaya başlayalım.

İlk ihtiyacımız olan şey, tabiiki bir Liste. Rastgele kelimelerden oluşan karışık bir liste oluşturmak için, aşağıdaki RastgeleKelimeUret fonksiyonunu yazalım.

const string Harfler = "1234567890abcdefghijklmnopqrstuvwxyz";
Random r = new Random();

public string RastgeleKelimeUret()
{
	char[] arrReturn = new char[15];

	Parallel.For(0, 15, iLoop => {
		arrReturn[iLoop] = Harfler[r.Next(0, Harfler.Length - 1)];
	});

	return new string(arrReturn);
}

Form’umuzun Load olayında, Parallel For yeteneklerinden faydalanarak, 15 harften oluşan 100 adet rastgele kelime üretiyoruz ve OrjinalListe isimli Generic Collection‘a dolduruyoruz.

private void MainForm_Load(object sender, EventArgs e)
{
	Parallel.For(0, 100, iLoop => {
		OrjinalListe.Add(RastgeleKelimeUret());
	});

	lbOrjinalListe.BeginUpdate();

	for (int iLoop = 0; iLoop < OrjinalListe.Count; iLoop++)
		lbOrjinalListe.Items.Add(OrjinalListe[iLoop]);

	lbOrjinalListe.EndUpdate();
}

Karıştır butonunun Click olayında ise; OrjinalListe collection’ının ListeKaristir() fonksiyonunu kullanıyoruz.

private void btnKaristir_Click(object sender, EventArgs e)
{
	lbKaristirilmisListe.BeginUpdate();

	lbKaristirilmisListe.Items.Clear();

	List<string> KaristirilmisListe = OrjinalListe.ListeKaristir();

	for (int iLoop = 0; iLoop < KaristirilmisListe.Count; iLoop++)
		lbKaristirilmisListe.Items.Add(KaristirilmisListe[iLoop]);

	lbKaristirilmisListe.EndUpdate();
}

Generic dizilerde ListeKaristir() isminde bir fonksiyon bulunmaz. Nereden geliyor bu fonksiyon?

public static class ExtensionManager
{
	private static Random r = new Random();

	public static List<T> ListeKaristir<T>(this List<T> Liste)
	{
		List<T> tmpList = Liste.GetRange(0, Liste.Count);
		List<T> arrReturn = new List<T>();

		while (tmpList.Count > 0)
		{
			int rastgele = r.Next(0, tmpList.Count);
			arrReturn.Add(tmpList[rastgele]);
			tmpList.RemoveAt(rastgele);
		}

		return arrReturn;
	}
}

ExtensionManager isimli static class‘ın içerisine yazdığım ListeKaristir<T> fonksiyonundan geliyor. İlk parametreye eklediğim this anahtar kelimesine dikkat edelim. Bu sayede, List<T> yapısında olan tüm nesnelerde ListeKaristir() fonksiyonunun çalışmasını sağlamış olduk.

Uygulamanın kaynak kodlarını buradan indirebilirsiniz.