Geliştirmekte olduğumuz uygulamalarda performans analizi yapmak için genellikle Stopwatch sınıfını kullanırız.

Aşağıdaki sınıf’ı kullanarak uygulamanın her method‘unu kolay analiz edebiliriz;

public class PerformansAnaliz
{
	public TimeSpan ToplamSure { get; private set; }
	public TimeSpan OrtalamaSure { get; private set; }

	public static PerformansAnaliz Yeni()
	{
		return new PerformansAnaliz();
	}

	public void Olcumle(Action Method, int TekrarAdet = 1)
	{
		var sw = Stopwatch.StartNew();
		for (int iLoop = 0; iLoop < TekrarAdet; iLoop++)
		{
			Method();
		}
		sw.Stop();
		OrtalamaSure = new TimeSpan(sw.Elapsed.Ticks / TekrarAdet);
		ToplamSure = sw.Elapsed;
	}
}

Geliştirmekte olduğumuz bir projede C:\ sürücüsünde bulunan OnemliDosya.xls dosyasını sıkışırmamız ve OnemliDosya.zip dosyasını oluşturmamız istendi.

Hemen arkasından sıkıştırdığımız dosyayı açmamız ve OnemliDosya.Yeni.xls dosyasını oluşturmamız bekleniyor.

Aşağıdaki method’ları bu görev için yazdık;

public static void Compress(string ZiplenecekDosyaAdi, string ZipDosyaAdi)
{
	FileStream InputStream = File.Open(ZiplenecekDosyaAdi, FileMode.Open);
	FileStream OutputStream = File.Open(ZipDosyaAdi, FileMode.Create);
	GZipStream ZipStream = new GZipStream(OutputStream, CompressionMode.Compress);

	try
	{
		byte[] Buffer = new byte[InputStream.Length];
		InputStream.Read(Buffer, 0, Buffer.Length);
		ZipStream.Write(Buffer, 0, Buffer.Length);
	}
	finally
	{
		OutputStream.Close();
		InputStream.Close();
	}
}

public static void Decompress(string ZiplenecekDosyaAdi, string ZipDosyaAdi)
{
	FileStream Input = File.Open(ZiplenecekDosyaAdi, FileMode.Open);
	FileStream Output = File.Open(ZipDosyaAdi, FileMode.Create);
	GZipStream ZipStream = new GZipStream(Input, CompressionMode.Decompress);

	try
	{
		int Data = ZipStream.ReadByte();
		while (Data > 0)
		{
			Output.WriteByte((byte)Data);
			Data = ZipStream.ReadByte();
		}
	}
	finally
	{
		Output.Close();
		Input.Close();
	}
}

Yazdığımız method’ları aşağıdaki gibi kullanıyoruz;

Compress("C:\\OnemliDosya.xls", "C:\\OnemliDosya.zip");
Decompress("C:\\OnemliDosya.zip", "C:\\OnemliDosya.Yeni.xls");

Kodumuzdan emin olmamıza rağmen, çalışmadığını farkediyoruz.

Sizce problem nedir ve nasıl düzeltilebilir?

Geliştirdiğimiz projelerde ekrana listeleyeceğimiz dizileri harf uzunluklarına göre sıralamak isteyebiliriz.

Bu makale ile, IEnumerable<string> tipinden değişkenlere bu özelliği nasıl ekleyeceğimizi göreceğiz.

Öncelikle Extension Method‘umuzu static bir sınıf içerisine (ExtensionManager) yazmamız lazım;

public static class ExtensionManager
{
	public static IEnumerable<string> Sirala(this IEnumerable<string> Liste)
	{
		string[] strArray = Liste.ToArray<string>();
		Array.Sort(strArray, new Comparison<string>(delegate(string Kelime1, string Kelime2)
		{
			if (Kelime1 == null && Kelime2 == null)
			{
				return 0;
			}
			else if (Kelime1 == null)
			{
				return -1;
			}
			else if (Kelime2 == null)
			{
				return 1;
			}
			else
			{
				if (Kelime1.Length < Kelime2.Length)
					return -1;
				else if (Kelime1.Length > Kelime2.Length)
					return 1;
				else
					return Kelime1.CompareTo(Kelime2);
			}
		}));

		return strArray;
	}
}

Yukarıdaki kod’da Array sınıfının static Sort method’unu çağırıyoruz. Karşılaştırma koşulunu, ikinci parametre’de delegate method olarak yazıyoruz.

Kullanımı;

var Rakamlar = new List { "12", "1", null, "2314", "55555", "123", "222" };

foreach (var Rakam in Rakamlar.Sirala())
{
	Console.WriteLine(Rakam);
}

Sonuç;

[null]
1
12
123
222
2314
55555

Eğer uygulama içerisinde Yönetici (Administrator) hesabının yetkisi ile yapılabilecek görevlerimiz varsa, öncelikle bu haklara sahip olduğumuza emin olmamız gerekir.

Günümüzde birçok uygulama Yönetici (Administrator) haklarına ihtiyaç duyar. Bu makalede bu haklara sahip olduğumuzu nasıl kontrol edeceğimizi işleyeceğiz.

Öncelikle kodumuzun using kısmına System.Security.Principal namespace‘ini eklememiz gerekiyor;

using System.Security.Principal;

Daha sonra IsAdministrator() isminde bir fonksiyon yazıyoruz;

public static bool IsAdministrator()
{
	WindowsIdentity identity = WindowsIdentity.GetCurrent();

	WindowsPrincipal principal = new WindowsPrincipal(identity);

	return principal.IsInRole(WindowsBuiltInRole.Administrator);
}

Bu fonksiyon sayesinde Yönetici (Administrator) haklarına sahip olup/olmadığımızı anlayabiliyoruz.

Fonksiyon içerisinde öncelikle WindowsIdentity sınıfından bir değişkene WindowsIdentity sınıfının static GetCurrent() methodundan dönen değeri atıyoruz.

İkinci adımda ise, bu değişkeni kullanarak WindowsPrincipal sınıfından yeni bir değişken oluşturuyoruz.

Son adımda, bu değişkenin IsInRole fonksiyonuna WindowsBuiltInRole enum’ından Administrator değerini parametre olarak geçiyoruz ve sonucu fonksiyondan geriye boolean değer olarak döndürüyoruz.

Uygulama içerisinde her ihtiyacımız olduğunda yukarıdaki fonksiyonu çağırarak Yönetici (Administrator) haklarına sahip olduğumuzu kontrol edebiliriz;

bool AdminRole = Program.IsAdministrator();

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

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

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

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

	private readonly string _tmpfile;

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

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

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

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

	public string FullPath
	{
		get { return _tmpfile; }
	}

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

Kullanımına örnek;

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

Bu yazımı okumadan önce XNA ile Oyun Programlama kategorisindeki diğer makalelerimi okumanızı tavsiye ederim.

Birçok oyunda arkaplan görselinin yavaşça kaydığını görmüşüzdür. Bu tarz bir etkiyi kendi oyunlarımızda nasıl sağlayacağımızı bu yazımda inceliyor olacağım.

Her zamanki gibi öncelikle görselleri paylaşarak başlıyorum;

Öncelikle sınıf seviyesinde birkaç değişken/sabit (readonly, const) ile oyun penceremizin özelliklerini ayarlayalım;

private const int PENCERE_GENISLIK = 800;
private const int PENCERE_YUKSEKLIK = 600;

private readonly Color PENCERE_ARKAPLAN = Color.Black;

Oyun sınıfının constructor‘ında ilgili sabitleri kullanalım;

graphics.PreferredBackBufferWidth = PENCERE_GENISLIK;
graphics.PreferredBackBufferHeight = PENCERE_YUKSEKLIK;

Oyun projemize, Uzay ve Ucak isimli iki tane sınıf (class) ekleyelim. Böylece arkaplan’da kayacak uzay görseli ile ilgili işleri Uzay sınıfında, klavye ile yöneteceğimiz uçak ile ilgili işleri de Ucak sınıfında gerçekleştirebileceğiz.

Ucak.cs dosyasında yeralan Ucak sınıfının yapacağı işler çok basit;

public class Ucak
{
	public Vector2 Position;
	public readonly Vector2 Size;

	public Texture2D Texture { get; private set; }

	public Ucak(Texture2D Texture)
	{
		this.Texture = Texture;
		this.Size = new Vector2(Texture.Width, Texture.Height);
	}
}

Uzay.cs dosyasında yeralan Uzay sınıfı ise, kendi Update() ve Draw() method’larına sahip olacak. Draw() method’unda sürekli arkaplan görselini kaydırarak oyun penceresine çizdirecek.

Bunu yapabilmek için, SpriteBatch sınıfından bir instance’a ihtiyaç duyacağız.

Uzay sınıfının constructor‘ında ihtiyacımız olacak SpriteBatch tipinden bir parametre alacak ve sınıf seviyesinde bir değişkende saklayacağız;

public class Uzay
{
	private readonly Texture2D _Texture;
	private readonly Texture2D _TextureSecond;

	private float _Position = 0f;

	private readonly int _Width;

	private readonly SpriteBatch _SpriteBatch;

	public Uzay(Texture2D Texture, SpriteBatch SpriteBatch)
	{
		this._SpriteBatch = SpriteBatch;

		this._Texture = Texture;
		this._TextureSecond = Texture;

		this._Width = _Texture.Width;

		this._Position = 0;
	}

	public void Update()
	{
		_Position -= 0.5f;

		if (_Position < -_Width)
		{
			_Position += _Width;
		}
	}

	public void Draw()
	{
		_SpriteBatch.Draw(_Texture, new Vector2(_Position, 0), Color.White);
		_SpriteBatch.Draw(_TextureSecond, new Vector2(_Position + _Width, 0), Color.White);
	}
}

Uzay sınıfının Update() method'unda, arkaplan görselini sürekli 0.5 birim sola kaydırıyoruz.

Not : Arkaplan görseli kaydıkça ekrandan dışarı çıkıyor olacak, arkaplansız kalmamak için aslında ekrana yanyana iki tane arkaplan görseli çizdiriyoruz.

Gelelim bu sınıflardan değişkenlerimizi oluşturmaya ve oyun sınıfımıza eklemeye;

private Uzay Arkaplan;
private Ucak SavasUcagi;

protected override void LoadContent()
{
	spriteBatch = new SpriteBatch(GraphicsDevice);

	Arkaplan = new Uzay(Content.Load<Texture2D>("Uzay"), spriteBatch);
	SavasUcagi = new Ucak(Content.Load<Texture2D>("Ucak"));
	SavasUcagi.Position = new Vector2(50, PENCERE_YUKSEKLIK / 2);
}

Oyunumuzun Update() method’unda, klavye tuş vuruş durumlarına göre uçağımızı kontrol ediyor olacağız. Ayrıca Arkaplan değişkeninde bulunan Uzay sınıfının instance‘ından Update() method’unu çağırıyor olacağız. Böylece arkaplan görseli 0.5 birim sola kaymış olacak ve oyun penceresine yeni yerinde çizilecek.

protected override void Update(GameTime gameTime)
{
	KeyboardState ks = Keyboard.GetState();

	if (ks.IsKeyDown(Keys.Escape))
		this.Exit();

	if (ks.IsKeyDown(Keys.Left))
		SavasUcagi.Position.X -= (ks.IsKeyDown(Keys.LeftShift) || ks.IsKeyDown(Keys.RightShift)) ? 6 : 3;

	if (ks.IsKeyDown(Keys.Right))
		SavasUcagi.Position.X += (ks.IsKeyDown(Keys.LeftShift) || ks.IsKeyDown(Keys.RightShift)) ? 6 : 3;

	if (ks.IsKeyDown(Keys.Up))
		SavasUcagi.Position.Y -= 3;

	if (ks.IsKeyDown(Keys.Down))
		SavasUcagi.Position.Y += 3;

	if (SavasUcagi.Position.X < 0)
		SavasUcagi.Position.X = 0;

	if (SavasUcagi.Position.X > PENCERE_GENISLIK - SavasUcagi.Size.X)
		SavasUcagi.Position.X = PENCERE_GENISLIK - SavasUcagi.Size.X;

	if (SavasUcagi.Position.Y < 0)
		SavasUcagi.Position.Y = 0;

	if (SavasUcagi.Position.Y > PENCERE_YUKSEKLIK - SavasUcagi.Size.Y)
		SavasUcagi.Position.Y = PENCERE_YUKSEKLIK - SavasUcagi.Size.Y;

	Arkaplan.Update();

	base.Update(gameTime);
}

Uçağı sağa/sola yönetmek için kullandığımız ok tuşlarına (Left – Right) basılırken, Shift tuşlarından birine (LeftShift – RightShift) basılıyorsa, uçağı normalin iki katı hızlı ilerletiyoruz (3 birim yerine 6 birim)

Son olarak, Draw() method’unda uçağı ekrana çizdirecek ve Uzay sınıfının instance‘ının (Arkaplan değişkeni) Draw() method’unu çağıracağız;

protected override void Draw(GameTime gameTime)
{
	GraphicsDevice.Clear(PENCERE_ARKAPLAN);

	spriteBatch.Begin();

	Arkaplan.Draw();
	spriteBatch.Draw(SavasUcagi.Texture, SavasUcagi.Position, Color.White);

	spriteBatch.End();

	base.Draw(gameTime);
}

Sonuç olarak, yukarıdaki kodları yazdıktan sonra oyun projemizi başlatırsak;

Hareketli ArkaPlan oyun projemizin kodlarını buradan indirebilirsiniz.

Mouse ikonumu bulamıyorum?

Evet, varsayılan olarak XNA, oyun penceresi içerisinde mouse ikonunu gizler. Eğer mouse’u görmek istiyorsanız;

this.IsMouseVisible = true;

kodunu eklemeniz gerekir.

Oyunu farklı çözünürlükte çalıştırmak istiyorum

XNA ile oyun geliştirmeye çalışan her programcının çok kısa süre sonra merak ettiği bir sorudur bu.

Çözüm;

public Game1()
{
	graphics = new GraphicsDeviceManager(this);

	Content.RootDirectory = "Content";

	/// Oyun penceresinin çözünürlüğünü 1920x1080 ayarlar
	this.graphics.PreferredBackBufferWidth = 1920;
	this.graphics.PreferredBackBufferHeight = 1080;
}

Not : Bu konu ile ilgili XNA – Oyun ekranının boyutlarını belirlemek yazımı okumanızı tavsiye ederim.

Oyunumu tam ekran oynatmak istiyorum

Çözünürlüğü değiştirdikten hemen sonra, tam ekran oyun nasıl oynatılır? sorusu gelir;

protected override void Initialize()
{
	/// Eğer tam ekran değilse, tam ekran moduna geç!
	if (!graphics.IsFullScreen)
	{
		graphics.ToggleFullScreen();
	}

	base.Initialize();
}

Not : Bu konu ile ilgili XNA – Oyun ekranının boyutlarını belirlemek yazımı okumanızı tavsiye ederim.

Oyun penceremin aktif olup/olmadığını nasıl anlarım?

Windows oyunları o anda çalışan tek uygulama olmayabilirler. Oyuncular, oyun oynarken, email adreslerini kontrol etmek, internette bir kelime araştırmak veya diğer oyuncular ile farklı ortamlarda sohbet etmek isteyebilirler.

Oyun penceresinden başka bir uygulamaya geçtiklerinde (yani oyun penceresi focus kaybettiğinde) oynadıkları oyunun durmasını (pause moduna geçmesini) isterler.

Oyun penceresinin Active veya InActive olduğunu kontrol etmemiz, Active değilse, Pause moduna geçmemiz gerekmektedir;

Not : Bu konu ile ilgili XNA Oyunu / Çanakkale Geçilmez – 1 yazımı okumanızı tavsiye ederim.

protected override void Update(GameTime gameTime)
{
	if (this.IsActive)
	{
		/// Sadece oyun penceresi aktif iken yapılması gereken işleri
		/// buraya yazıyoruz

		/// Joystik, klavye, mouse hareketlerini algılamak
		/// Yapay zeka görevlerini yürütmek gibi
	}

	base.Update(gameTime);
}

Oyun penceresinin başlığını nasıl değiştiririm?

protected override void Initialize()
{
	this.Window.Title = "Oyun oynamak içindir!";

	base.Initialize();
}

Çalıştığımız proje’de, aşağıda tanımı verilmiş struct‘tan 1000 tane üretip geri döndüren bir fonksiyon yazmamız gerekiyor;

struct Boyut
{
	public int Genislik;
	public int Yukseklik;
}

Proje Liderine yazdığımız kodu gösteriyoruz. Kod çalışırken hiçbir hata üretmemesine rağmen, kodu değiştirmemizi istiyor.

private Boyut[] BoyutlarListesi()
{
	Boyut[] boyutlar = new Boyut[1000];

	for (int iLoop = 0; iLoop < boyutlar.Length; iLoop++)
	{
		boyutlar[iLoop] = new Boyut();
	}

    return boyutlar;
}

Sizce neden böyle bir istekte bulunmuş olabilir?

İpucu : Proje Lideri performans takıntısı olan eski bir programcı

Nullable tipler, ilgili tip‘in değer aralığına ve karakteristiğine sahip olmakla birlikte ek olarak null değer de içerebilen yapılardır.

Basit olarak, değişkenin değer içerip içermediği bilgisini saklar.

Nullable tipler, System.Nullable<T> türündedirler (T, değer tipi olmalıdır)

Unutmayın! Sadece değer tipleri (value type) nullable olabilir.

C# dili değer tipi listesi‘ne daha önce yazdığım makale veya MSDN üzerinden ulaşabilirsiniz.

C# dilinde, Nullable tipte değişkenler iki şekilde tanımlanabilir.

Birinci yöntemde, System.Nullable generic tipini ilgili değer tipi ile birlikte yazabiliriz;

System.Nullable<int> adet;
System.Nullable<bool> sonuclandi;

İkinci yöntem, daha çok kullanılır ve daha kısa yazım şekline sahiptir. İlgili değer tipinin yanına soruişareti (?) karakteri koyarak yazılır;

int? adet;
bool? sonuclandi;

Bir nullable değişken, tanımlandığı anda null değerini içermez, sizin null eşitlemesini yapmanız beklenir;

int? adet = null;

Nullable tipteki bir değişkene değer ataması yapmak, normal bir değişkene değer ataması yapmak ile aynıdır.

adet = 100;

Nullable bir değişkenin değer içerip içermediğini anlamanın iki yolu vardır.

Birinci yöntemde, değişkenin null olup/olmadığı kontrol edilebilir.

if (adet != null)
{
	/// değeri var
}

Eğer değişken null değilse, değer içeriyor demektir.

İkinci yöntemde, değişkenin System.Nullable tipinden gelen sadece-okunabilir (read-only) HasValue özelliği kontrol edilir.

if (adet.HasValue)
{
	/// değeri var
}

Eğer değişken değer içeriyorsa, değeri okumak için, değişkenin System.Nullable tipinden gelen Value özelliği kullanılır.

Eğer değer içermeyen nullable bir değişkenin Value özelliğinden değer okumaya çalışırsanız, System.InvalidOperationException istisnası fırlatılır.

using System;

class NullableTipTest
{
	public static void Main()
	{
		int? adet = null;

		if (adet.HasValue)
			Console.WriteLine("adet değeri: " + adet.Value);
		else
			Console.WriteLine("adet değeri yok.");

		adet = 10;

		if (adet.HasValue)
			Console.WriteLine("adet değeri: " + adet.Value);
		else
			Console.WriteLine("adet değeri yok.");
	}
}

Yukarıdaki kodun çıktısı şöyle olacaktır;

adet değeri yok.
adet değeri: 10

C# ile geliştirdiğimiz sınıflardan event yayınlamaya genellikle ihtiyaç duyarız.

Bir sınıftan event yayınlamak için, artık ezberlediğimiz üzere, aşağıdaki yöntemi kullanırız;

public class EventTest
{
	public event EventHandler MyEvent;

	public void RaiseEvent()
	{
		if(MyEvent != null)
		{
			MyEvent(this, EventArgs.Empty);
		}
	}
}

Devlicious‘da gördüğüm makalede, Rob Eisenberg yeni bir yöntem öneriyor.

Makaleye göre, yukarıdaki event yayınlama kodunu aşağıdaki gibi de yazabiliriz;

public class EventTest
{
	public event EventHandler MyEvent = delegate {};

	public void RaiseEvent()
	{
		MyEvent(this, EventArgs.Empty);
	}
}

Sizce hangisini tercih etmeliyiz?