Fakat bu IDE’nin kullanıcılarından birisi (Andread Hausladen) öyle bir yama yapıyorki derleme zamanı %75 azalıyor. Görünen o ki; derleme işlemi başlatıldığında derleyiciye IDE tarafından bazı callback fonksiyonları kaydediliyormuş ve bunlardan birisi de OpenFile fonksiyonuymuş. Sorun ise OpenFile fonksiyonunun aynı zamanda dosya var mı yok mu kontrol etmek için de kullanılıyor olmasıymış ki bu da oldukça zaman kaybına neden oluyormuş. Andreas ise yamasında OpenFile çağırılmadan önce GetFileAttributes fonksiyonu ile dosyanın var olup olmadığının kontrol edilmesini, dosya varsa OpenFile çağırılmasını sağlamış ki bu da 30 saniyelik derleme süresini 4.5 saniyeye düşürmüş!

İşin ironik tarafı ise enerji tasarruflu uygulama geliştirme için yapılabileceklerle ilgili StackOverflow’da sorulan bu soruda karşıma çıktı. İlk cevap şu an C++ Builder’ı geliştiren CodeGear’ın ürün sorumlusu Nick Hodges‘dan gelmiş, ikinci cevap ise tam bir ayar niteliğinde.

C++ Builder’ın yılda 200 gün çalışıp, günde 15 dakikasını derleme işleminin bitmesini bekleyerek harcayan 20000 geliştirici tarafından 5 yıldır kullanıldığını düşünürsek saatte 50$ masraf ile toplam maliyet 187.5 milyon doları buluyor. Borland’ın neden bu hale geldiğine şaşmamak lazım.

Assert.IsNotNull(items);
Assert.AreEqual(2, items.Count);

Assert.That(items, Is.Not.Null);
Assert.That(items.Count, Is.EqualTo(2));

Distances = new int[W*H];
Previous = new int[W*H];
for (int i = 0; i < W*H; i++)
{
  Distances[i] = INF;
  Previous[i] = -1;
}
Distances[0] = 0;

Algoritmadaki her adımda kaynak bir nokta seçip, bu noktadan komşu noktalara gitmenin bize maliyetini hesaplayacağız ve bu nokta için bir daha hesap yapmayacağız. Bu yüzden hangi noktalar üzerinde çalıştığımızı da bir şekilde tutmamız gerekiyor. Bunun için bir liste kullanabilirsiniz. Gidilen noktaları listeden çıkarıp geriye kalanlar içinde hedefe en yakın olanı seçerek devam edebilirsiniz. Liste boşalana kadar bu işleme devam edip tüm noktalar için hesaplamalarımızı yapmış oluruz:

var list = new List<int>();
for (int i = 0; i < W * H; i++) list.Add(i);
while(list.Count > 0)
{
  //hesaplamalar
}

Çapraz hareketler yapamayacağımız için her kare üzerinde gidilebilecek 4 yön var: sağa, sol, yukarı ve aşağı.

private static readonly int[] dx = { 1, 0, -1, 0 };
private static readonly int[] dy = { 0, 1, 0, -1 };

Tüm bu yönlere hareket etmenin bizim için maliyeti nedir hesaplayalım ve Distance dizisinde bu noktaya karşılık gelen indekse bu değeri yazalım.

while (list.Count > 0)
{
  // hedefe en yakın noktanın indeksini al
  int bi = GetClosestIndex(list);
  int cx = bi % W, cy = bi / W; 

  for (int i = 0; i < dx.Length; i++ )
  {
    int nx = cx + dx[i];
    int ny = cy + dy[i];
    // dışarıda kalıyorsa çık
    if (0 > nx || nx >= W || 0 > ny || ny >= H) continue;
    int ci = ny * W + nx;
    // bi'den ci'ye gidersek maliyeti nedir
    int cost = CostOfGoing(bi,ci);
    int alt = Distances[bi] + cost;
    //daha kazançlıysa burdan gidelim
    if (Distances[ci] > alt)
    {
      Distances[ci] = alt;
      Previous[ci] = bi;
    }
  }
}

Bu işlem tüm noktalar için yapıldığında hedef noktanın kaynak noktaya olan mesafesi Distance[Hedef] olacaktır. Gidilecek yol ise şöyle çıkarılabilir:

int target = 99;
List path = new List<int>();
while(Previous[target]!=-1)
{
    path.Add(target);
    target = Previous[target];
}
path.Reverse();

Dijkstra Algoritmasının en güçlü taraflarından birisi, çalışma süresinin kısa olmasıdır. Örnekte, kaynaktan başlayarak diğer tüm noktalara olan mesafeyi hesaplıyoruz sonra hedefimize giden yolu çıkarıyoruz. Bunu tüm noktalar için yapmak zorunda değiliz; eğer isterseniz algoritma içinde bi = target olduğu zaman algoritmayı sonlandırarak çalışma süresini de kısaltmış olabiliriz. İkinci olarak ise; bir noktanın diğer noktaya olan mesafesini bir maliyet fonksiyonu ile hesaplıyorruz. Sadece bu fonksiyonu değiştirerek farklı sonuçlar elde edebiliriz. Örneğin; tahtanın üzerindeki her kareyi bir tepe olarak düşünelim ve üzerindeki sayı ise o tepenin yüksekliği olsun. Bir tepeden diğerine geçerken; tırmanmamız yükseklik farkı kadar, aşağı inmemiz ise yükseklik farkının yarısı kadar zaman alsın. Bu durumda maliyet fonksiyonumuzu aşağıdaki gibi değiştirmek bize istediğimiz sonucu verecektir:

private int GetCostOfGoing(int bi, int ci)
{
    int diff = Height[bi] - Height[ci];
    if (diff < 0) return -diff / 2;
    return diff;
}

Tüm bu işlemi görsel olarak takip etmeniz için bir WPF projesi hazırladım. Buradan indirip inceleyebilirsiniz.

DipNot: Bu yazıyı, yazarken kaybettiğim o tuşuma armağan ediyorum.

Bahsedeceğim iyileştirmelerin bir çoğunun temeli C# 2′de atıldı. Örneğin C# 1′de bir formu kapatmak için bir butona event handler eklemek istediğimizde aşağıdaki gibi bir kod yazmamız gerekiyordu.

//C# 1
public Form1()
{
  InitializeComponent();
  button1.Click += new EventHandler(button1Click);
}
void button1Click(object sender, EventArgs e)
{
  Close();
}

public Form1()
{
  InitializeComponent();
  button1.Click += button1Click;
}
void button1Click(object sender, EventArgs e)
{
  Close();
}

public Form1()
{
  InitializeComponent();
  button1.Click += delegate(object sender, EventArgs e) { Close(); };
}

public Form1()
{
  InitializeComponent();
  button1.Click += delegate { Close(); };
}

string[] nums = new string[] { "1","2","3","4","5","6" };
int[] arr =Array.ConvertAll<string, int>(nums, delegate(string input)
                                                              {
                                                                  return int.Parse(input);
                                                              });

string[] nums = new string[] { "1","2","3","4","5","6" };
int[] arr =Array.ConvertAll<string, int>(nums, int.Parse);

string[] nums = new string[] { "1","2","3","4","5","6" };
var arr =Array.ConvertAll(nums, x=>int.Parse(x));

string[] nums = new [] { "1","2","3","4","5","6" };
//ya da kısaca:
string[] nums = { "1","2","3","4","5","6" };

Mesela LINQ. Deneme olsun diye bir klasör içinde yer alan dosyalardan adında önce o sonra a harfi geçen kaç tane var bir saydırayım dedim. Efendim oldu bitti. Yaptım, gözlerim karardı bir an ve şöyle bir maziye gittim, taa pascal günlerine…

Turbo Pascal veya Delphi veya dinamik olmayan herhangi bir dilde bu işi yapmak için en az 5-10 satır kod yazmak lazım. Peki bu işlem c# 3.0′da kaç satır? Bu yazıyı yazdığıma göre 5 satırdan kısa ve büyük ihtimalle 1 satır. Evet bildiniz, ben kod ekrandan taşmasın diye birkaç satıra bölüp yazıyorum buraya ama aslında 1 satır.

Console.WriteLine(
  new DirectoryInfo(@"c:\downloads")
  .GetFiles()
  .Count(f => Regex.IsMatch(System.IO.Path.GetFileName(f.Name), "o.*a"))
);

Aynı dosyaların toplam boyutu??

Console.WriteLine(
  new DirectoryInfo(@"c:\downloads")
  .GetFiles()
  .Where(x => Regex.IsMatch(System.IO.Path.GetFileName(x.Name), "o.*a"))
  .Sum(x => x.Length)
);

Hiçbir döngü yok.