Diyelim ki bir uygulama geliştirdiniz. Belirli uzantıdaki dosyalar üzerinde işlem yapıyor. Ve kullanıcı bu uzantıdaki dosyaya tıkladığında uygulamanızın otomatik olarak açılmasını sağlamak istiyorsanız aşağıdaki kod işinize yarayacaktır.

RegistryKey key = Registry.ClassesRoot.CreateSubKey(".dna");
key.SetValue(null, "DnaFile.dna");
RegistryKey subkey = Registry.ClassesRoot.CreateSubKey("DnaFile.dna");
subkey.CreateSubKey("DefaultIcon").SetValue(null, @"%SystemRoot%\system32\msxml3.dll,0");
RegistryKey hedekey = subkey.CreateSubKey(@"shell\open\command");
hedekey.SetValue(null, "\"C:\\dna210506\\dnaPad\\dnaPad\\bin\\Debug\\dnaPad.exe\" \"%1\"");

subkey.CreateSubKey("DefaultIcon").SetValue(null, @"%SystemRoot%\system32\msxml3.dll,0");

kod ile *.dna uzantılı dosyanın kendisine özel bir icona sahip olmasını sağlıyor.

Yukardaki kod ile *.dna uzantılı dosyaya tıklandığında C:\...\dnaPad.exe yolundaki dnaPad.exe windows tarafından otomatik olarak çalıştırılır. Peki dosyayı uygulamaya parametre olarak windows geçiriyor da biz nasıl alacağız ?
Çözüm : string[] args = Environment.GetCommandLineArgs();
args[1] size ilgili dosyayı verecektir.

 

C# 3.0'ın getirdiği güzel özelliklerden birisi olan İsimsiz Tipler'in bazı kısıtlamaları bulunmakta. Özellikle de metodlara parametre olarak geçirilme konusunda sıkıntı yaratıyor. Örneğin

static void Main(string[] args)
{
    var v = new
    {
        Ad = "oğuz",
        No = 44,
        Miktar = 122.2
    };
    BirDost(v);
}

şeklindeki bir tipi metoda parametre olarak geçirmek isteyelim.Amacımız bu tipin özelliklerindeki - property - değerleri almak ve işlem yapmak olsun.

public static void BirDost(var belirsizTip)
{
...
}

hmmm..işler düşündüğümüz gibi gitmeyecek ve derleyici şöyle bir  hata verecek.

Error 1 The contextual keyword 'var' may only appear within a local variable declaration

Tamam o zaman herşey object'tir mantığından yola çıkarak metodumuzu aşağıdaki gibi değiştirelim.

public static void BirDost(object belirsizTip)
{
 // belirsizTip. (???)
}

Tamam oldu gibi..Ama belirsizTip nesnesi üzerinden Ad,No,Miktar gibi özelliklere nasıl erişebilir ki? Seni seviyorum .NET diyerek biraz reflection uyguluyoruz ve sonuç.

public static void BirDost(object belirsizTip)
{
    Type t = belirsizTip.GetType();
    PropertyInfo[] ps = t.GetProperties();

    foreach (PropertyInfo p in ps)
    {
        Console.WriteLine(p.Name + " => " + p.GetValue(belirsizTip,null));
    }
}

Artık isimsiz tiplerimizi gönül rahatlığı ile - çok mu duygusal oldu nedir? - metodlara parametre olarak aktarbiliriz ;)

 

 

Debug işlemleri yaparken yeri geldiğinde bir o kadar yararlı ve zaman kazandırıcı özellikleri  çoğunlukla gözden kaçırıyoruz. Oysa yapmamız gereken breakpoint üzerine sağ tıklamak ve özellikleri incelemek.

Condition : Eğer belirli bir duruma göre debug işlemini gerçekleştirmek istediğinizde bu özelliği aktif hale getirebilirsiniz. Aşağıdaki kod üzerinden örnek vermek gerekirse; Do metodunda dummyValue değişkenin değeri 22 ise debug işleminin aktif hale gelmesini istersem ;

gibi bir Condition eklemem yeterli olacaktır. Eğer dummyValue 22 den farklı bir değer ise debug işlemi sırasında breakpoint yokmuş gibi işlem görecektir. BreakPoint'e bir Condition eklediğinizde breakpoint'in ikonunun değiştiğini göreceksiniz. Bu kısımda da  otomatik isim tamamlama özelliğinin aktif olması harika birşey!

Hit Count : Debug işlemi sırasında o ana kadar kaç defa breakpoint'e gelindiğini takip edebiliriz.İsterseniz de "eğer bu breakpoint'e x kadar gelindiğinde artık debug işlemi yapılmasın" da diyebilirsiniz. (Açılan dialog penceresindeki combobox'dan diğer seçenekleri inceleyiniz.)

Filter : Belirli filitreler koyarak debug işlemlemini aktif hale getirebiliriz. Aşağıdaki resimde hangi filitreleri uygulayacağımız açıklanıyor zaten. Bunlar dışında bir filitre uygulamak istediğinizde buna izin verilmediğini göreceksiniz.Örneğimizdeki filitrede eğer bu metod "debugTest" isimli Thread tarafından çağrılmışsa debug işlemi aktif hale gelecektir.

When Hit... : Debug işemi aktif hale geldiğinde isterseniz Output Window'a durum bilgilerini yazdırabilir, isterseniz de VS.NET 2005'e ait çeşitli makrolardan birini çağırabilirsiniz. Örneğimizde breakpoint'in hangi metod içinde olduğunu ve bu metodu kimin çağırdığını yazdırıyoruz. Ardından da o satırı yorum satırı haline getiren bir makroyu çalışrırıyoruz.

 

Tanımlamarımızı yapıp debug modunda uygulamamızı çalıştırdığımızda aşağıdaki gibi bir sonuç alıyoruz.

public Form1()
{
    InitializeComponent();
    CheckForIllegalCrossThreadCalls = false;
}
private void button1_Click(object sender, EventArgs e)
{
    DoOp();
}

public void DoOp()
{
    Thread th = new Thread(Do);
    th.Name = "debugTest";
    th.Start();
}

int dummyValue = 22;
public void Do()
{
    for (int i = 0; i < 5; i++)
    {
         Text = i.ToString(); //Breakpoint konulan satır
    }
}

 

 

Debug işlemleri yaparken işimize yarayacak 3 adet Attribute'ü aşağıdaki örnek üzerinden incelersek ;

DebuggerDisplay attribute'ü ilgili sınıfdan nesne örneğini incelediğimizde debug penceresinde istediğimiz şekilde görünmesini sağlayabiliriz.

DebuggerStepThrough  attribute'ü ile de F11 ile kod debug edildiğinde bu kod satırların debug işlemi sırasında dikkate alınmayacağını belirtir. Örneğin

Ogrenci o = new Ogrenci();
o.Name = "ali";
o.No = 22;

gibi bir kod satırında o.Name="ali"; satırında iken F11 'e bastığımızda Name özelliğinin set metoduna dallanacağını biliyoruz. Fakat DebuggerStepThrough attribute'ü set için uygulandığından bu dallanma gerçekleşmeyecek o.No=22 satırından itibaren debug işlemi devam ecektir. (Laf aramızda süper bir atrribute'müş kendisi yahu ;) )

DebuggerBrowsable isminden de açıkça belli olduğu üzere bu attibute'ün uygulanmış olduğu nesnenin X özelliği debug ekranında görüntülenmeyecektir.

 

[DebuggerDisplay("Ad ={Name},No = {No}")]
public class Ogrenci
{

   private string _name; 
   public string Name
   {
      [DebuggerStepThrough]
      get { return _name; }

      [DebuggerStepThrough]
      set { _name = value; }
   }

   private int _no;
   public int No
   {
      get { return _no; }
      set { _no = value; }
   }
   private int _x;
   [DebuggerBrowsable(DebuggerBrowsableState.Never)]
   public int X
   {
      get { return _x; }
      set { _x = value; }
   }
}

 

Birçoğuz biliyoruz ki, kimi zaman belirli bir classdan çalışma zamanında sadece tek bir nesne oluşturulmasını isteriz. Aynı sınıfa ait ikinci bir nesne oluşmasını engellemek isteriz. Bu durumda Singleton Tasarım Kalıbını (Alper Hoca'nın kulakları çınlasın)  uygularız. Fakat birçok class için bu durum geçerli ise her defasında bunu uygulamak bizim gibi üşengeç programcılar için can sıkıcı hal alır. Çözüm ise,

    
class GenericSingleton<T> where T : class, new()
{
    private static object lockObject = new object();
    private static T m_Instance;

    public static T GetInstance()
    {
        if( m_Instance != null)
            return m_Instance;
        lock ( lockObject)
        {
            if (m_Instance == null)
            {
                m_Instance = new T();
            }            
        }
        return m_Instance;
    }
}


    

Bu generics süper bişi! - ben bu lafı bir yerden hatırlıyorum ama -