Bir programcının dünyası

Elimizdeki bir dizide, belli bir elemandan kaç adet olduğunu bulmamız gerekebilir.

Bunu yapmanın programatik olarak en kolay yolu LINQ sorgusu yazmaktır.

Örneğin aşağıdaki Extension Method, LINQ sorgusu ile aranan elemandan, ilgili listede kaç adet olduğu sonucunu döndürür;

public static int CountTimes< T >(this List< T > list, T item)
{
	return ((from t in list where t.Equals(item) select t).Count());
}

Örnek kullanım;

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

public static class Program
{
	static void Main(string[] args)
	{
		var list1 = new List< int >() { 1, 2, 3, 4, 5, 6, 7, 7, 8, 9 };
		var list2 = new List< string >() { "a", "b", "b", "b", "c", "d", "e", "f" };

		Console.WriteLine("Birinci listede 7, " + list1.CountTimes(7) + " adet var");
		Console.WriteLine("İkinci  listede b, " + list2.CountTimes("b") + " adet var");

		Console.ReadLine();
	}

	public static int CountTimes< T >(this List< T > list, T item)
	{
		return ((from t in list where t.Equals(item) select t).Count());
	}
}

Yukarıdaki örnek kodu çalıştırdığınızda, şöyle bir sonuç almanız lazım;

Birinci listede 7, 2 adet var
İkinci  listede b, 3 adet var

FileStream sınıfına yazacağımız Save() method’u sayesinde, aşağıdaki kodu kolaylıkla yazabilir olacağız. Üstelik bir tane de overload yazarak, varolan dosyanın üstüne yazmasını engelleyip, yeni bir dosya adı oluşturup yazma işlemine devam ettirebileceğiz.

fs.Kaydet("c:\\dosya_adi.uzanti");

Eğer aynı kodu, ikinci bir boolean parametreye true değeri vererek çağırırsak, klasörde dosya_adi.uzanti dosyası varsa dosya_adi[1].uzanti dosyasına yazmayı deneyecek, eğer bu dosya da varsa, dosya_adi[2].uzanti dosyasına deneyecek, vs..

fs.Kaydet("c:\\dosya_adi.uzanti", true);

İşte kodumuz;

namespace ExtensionManager
{
	public static class Extensions
	{
		public static string Kaydet(this FileStream Dosya, string Dizin)
		{
			return Dosya.Kaydet(Dizin, false);
		}

		public static string Kaydet(this FileStream Dosya, string Dizin, bool UstuneYaz)
		{
			int DosyaSayac = 1;

			string _Dizin = Path.GetDirectoryName(Dizin);

			if (!Directory.Exists(_Dizin))
				Directory.CreateDirectory(_Dizin);

			int DosyaBoyu = Convert.ToInt32(Dosya.Length);
			string DosyaAdi = Path.GetFileName(Dosya.Name);

			Byte[] b = new Byte[DosyaBoyu];
			Dosya.Read(b, 0, DosyaBoyu);

			string root = Path.GetDirectoryName(Dizin) + "\\" + Path.GetFileNameWithoutExtension(Dizin);

			while (!UstuneYaz && File.Exists(Dizin))
				Dizin = root + "[" + DosyaSayac++.ToString() + "]" + Path.GetExtension(Dizin);

			File.WriteAllBytes(Dizin, b);

			return Path.GetFileName(Dizin);
		}
	}
}

Deneysel amaçlı yazdığım extension method’lardan biridir;

namespace Extensions
{
	public static class ExtensionManager
	{
		public static bool SadeceOkunabilir(this DirectoryInfo Dizin)
		{
			if (Dizin == null)
				throw new ArgumentNullException("Dizin parametresi boş olamaz");

			return (Dizin.Attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly;
		}
	}
}

.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.

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.

Eminim hepimiz, kendi aramızda, “Kelimenin Son Harfi ile Başlayan Kelime Oyunu“nu oynamışızdır.

Oyunun kuralları basittir, iki “oyuncu” karşılıklı oturur, oyunculardan biri, bir kelime söyleyerek oyunu başlatır. Sonra oyuncular sırayla, diğerinin söylediği kelimenin son harfi ile başlayan başka bir kelime söylemek zorundadır. Söyleyecek kelime bulamayan oyuncu “oyunu” kaybeder.

Gelin bu basit oyunu C# ile yazalım. Hemen ekran görüntüsü vererek başlıyorum;

Oyunu, bir Oyuncu, bir Bilgisayar Oyuncusuna karşı oynayacak. İhtiyacımız olan ilk şey, Bilgisayar Oyuncusu’nun içinden kelime seçeceği sözlük. Sözlük oluşturmak için daha önce yazdığım Web Sayfasından Sözlük Oluşturma ve Dizi Karıştırma makalelerini birleştirip kullanacağız.

btnYeniOyun butonunun Click olayında, txtAdres kontrolüne yazılmış olan web sayfasındaki kelimeler bir listeye dolduruluyor, ayıklanıyor, karıştırılıyor ve lbKullanilabilecekKelimeler ListBox kontrolünde gösteriliyor.

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

private void btnYeniOyun_Click(object sender, EventArgs e)
{
	lbKullanilabilecekKelimeler.Items.Clear();
	lbKullanilabilecekKelimeler.BeginUpdate();

	WebRequest wr = WebRequest.Create(txtAdres.Text);
	WebResponse ws = wr.GetResponse();
	StreamReader sr = new StreamReader(ws.GetResponseStream(), Encoding.UTF8);
	string response = sr.ReadToEnd();
	sr.Close();
	ws.Close();

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

	Regex r = new Regex("<(.|\n)*?>");
	foreach (string satir in r.Replace(response, "").Split(" \t\r\n({[]}),.;:*-+/?<>&%'#@=\"\\_".ToCharArray(), StringSplitOptions.RemoveEmptyEntries))
		if (satir.Trim().Length > 5 && !arrKelime.Contains(satir.Trim()))
			arrKelime.Add(satir.Trim());

	lbKullanilabilecekKelimeler.Items.AddRange(arrKelime.ListeKaristir().ToArray());

	lbKullanilabilecekKelimeler.EndUpdate();

	txtYeniKelime.Clear();
	txtOyunTarihce.Clear();
}

Oyun, birinci oyuncunun txtYeniKelime kontrolüne yazdığı kelime ile başlıyor.

string OncekiKelimeninSonHarfi = string.Empty;
private void btnYeniKelime_Click(object sender, EventArgs e)
{
	if (txtYeniKelime.Text != "" && txtYeniKelime.Text.StartsWith(OncekiKelimeninSonHarfi))
	{
		string Kelime = txtYeniKelime.Text.Trim();
		txtOyunTarihce.Text = string.Format("(O): {0}{1}{2}", Kelime, Environment.NewLine, txtOyunTarihce.Text);
		txtYeniKelime.Clear();
		KelimeSec(Kelime);
		txtYeniKelime.Focus();
	}
}

Bilgisayar Oyuncusu Sözlük’ten kelimenin son harfi ile başlayan kelimelerden bir tanesini rastgele olarak seçiyor.

Kullandığı her kelimeyi lbKullanilabilecekKelimeler ListBox kontrolünden çıkartıp, lbKullanilmisKelimeler ListBox listesine ekliyor.

private void KelimeSec(string OncekiKelime)
{
	Random r = new Random();

	var Kelimeler = (from k in lbKullanilabilecekKelimeler.Items.OfType<string>() where k.StartsWith(OncekiKelime.Substring(OncekiKelime.Length - 1, 1)) select k).ToList<string>();

	if (Kelimeler.Count == 0)
	{
		MessageBox.Show(lbKullanilmisKelimeler.Items.Count + ". Kelimede Bilgisayar Oyuncusu oynayacak Kelime bulamadı!.", "Oyun Bitti!", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
		return;
	}

	int Sira = r.Next(0, Kelimeler.Count);
	string Kelime = Kelimeler[Sira];
	OncekiKelimeninSonHarfi = Kelime.Substring(Kelime.Length - 1, 1);

	lbKullanilabilecekKelimeler.Items.Remove(Kelime);
	lbKullanilmisKelimeler.Items.Add(Kelime);

	txtOyunTarihce.Text = string.Format("(B): {0}{1}{2}", Kelime, Environment.NewLine, txtOyunTarihce.Text);
}

Oyun, Bilgisayar Oyuncusu’nun kelime bulamamasına kadar devam ediyor.

Oyunun kaynak kodlarını buradan indirebilirsiniz.

Bilgeadam’da öğrencilerimden birinin sorduğu soru üzerine, bir dizinin, belli sayıda elemanlardan oluşan alt dizilere bölünmesi ile ilgili aşağıdaki uygulamayı yazdım.

Uygulama şöyle çalışıyor; rastgele kelimelerden oluşan bir dizimiz var, bu diziyi, n elemanlı alt dizilere bölmek istiyoruz.

Hemen kolları sıvayalım ve kod yazmaya başlayalım.

Öncelikle rastgele kelime oluşturma fonksiyonunu yazalım;

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

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

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

	return new string(arrReturn);
}

Bu fonksiyonu C# ile Dizi Karıştırma yazımdan hatırlayacaksınız. Şimdi bu fonksiyonu kullanarak List<string> tipinde bir diziye 25 eleman dolduran kodumuzu yazalım;

List<string> BolunecekDizi = new List<string>();
Parallel.For(5, 25, iLoop => {
	BolunecekDizi.Add(RastgeleKelimeUret(iLoop));
});

Parallel For kullanarak Multi-Core ve Multi-Thread destekli kod yazdığımıza dikkat edelim. Bölümleme fonksiyonunu ExtensionMethod olarak yazacağız.

public static class ExtensionManager
{
	public static List<T>[] Bolumle<T>(this List<T> Dizi, int ParcaAdet)
	{
		if (Dizi == null)
			throw new Exception("Dizi boş olamaz..");

		if (ParcaAdet < 1)
			throw new Exception("Parça Adet 1'den küçük olamaz..");

		int DiziBoyu = (int)Math.Floor(Dizi.Count / (double)ParcaAdet) + 1;

		List<T>[] arrReturn = new List<T>[DiziBoyu];

		int Adim = 0;
		Parallel.For(0, Dizi.Count, iLoop => {
			if (iLoop % ParcaAdet == 0 && iLoop > 0)
				Adim += 1;

			if (arrReturn[Adim] == null)
				arrReturn[Adim] = new List<T>();

			arrReturn[Adim].Add(Dizi[iLoop]);
		});

		return arrReturn;
	}
}

Artık tek yapmamız gereken List<T> generic tipinde nesnelerde Bolumle() fonksiyonunu kullanmak olacak.

List<string>[] Bolumler = BolunecekDizi.Bolumle(3);

Uygulamanın kaynak kodlarını buradan indirebilirsiniz.

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.