4. BÖLÜM : NAMESPACE HAZIRLAMAK ve KULLANMAK(*)

.NET Framework ile gelen Class’lar namespace’lerde yer almaktadır. Namespace’ler ise referans adı verilen DLL dosyalarında yer alıyorlar. Kullanılmak istenen Class hangi namespace’de bulunuyorsa ilgili referansı DOS penceresinde derleme yaparken bundan derleyiciye söz etmeniz veya Visual Studio’nun Solution Explorer penceresinde listelenme­sini sağla­manız gerekiyor. Bu konuda adım adım bilgi vermek için aşağıdaki gibi bir konsol uygulaması hazırladık.



Bu konsol uygulamasında sizin için yeni bir şey yok. Bir önceki bölümde benzer konsol uygulamasını derlerken DOS penceresinde aşağıdaki gibi bir derleme yapmıştık. Bu derleme işlemine dikkat ederseniz herhangi bir referans işaret edilmemekte veya herhangi bir DLL dosyasından C# derleyicisi haberdar edilmemektedir.



Yine bir önceki bölümden hatırlayacağınız gibi konsol uygulamasında MessageBox sınıfının Show() metodunu kullandığımızda System.Windows.Forms.dll” adlı referanstan derleme sırasında derleyiciyi haberdar etmek(başka bir deyişle derleyiciye bu referanstaki Class’lardan yararlanmak istediğimizi söylememiz) gerekiyordu. Çalışma anında ne zaman ki ilgili DLL dosyasındaki bir sınıf kullanılmak istenirse DLL dosyaları doğaları gereği o an belleğe yüklenirler. Daha açık bir ifade ile derleme yaparken derleyiciye diyeceğiz ki “ey derleyici derlemek istediğim koddaki şu sınıf şuradaki şu DLL dosyasında yani referansta bulunmaktadır. Bu DLL dosyasının yerini EXE dosyanın içine bir yere not et. 

Daha sonra bu EXE dosya çalıştırıldığında söz konusu DLL dosyasındaki sınıflardan birisi kullanılmak istendiğinde EXE dosya gerek duyduğu DLL dosyasını bildiği klasörden belleğe yükler. Başka bir deyişle derleme yaparken ilgili DLL dosyasının nerede olduğunu söylediy­sek çalışma anında bu DLL dosyası yine aynı yerde olmalıdır. Bu konuda ayrıntılı bilgi Assembly adlı bölümde verilecektir. 

Şimdi bu konuda bir deneme yapalım ve bir konsol uygulaması hazırlayıp derleme sırasından rerefence parametresi ile herhangi bir referansı işaret etmeyelim. “ilk.cs” adını verip Main() metodunda birkaç satır olan bu uygulamayı derleyince “exe” dosya oldukça küçük oldu.



Şimdi aynı CS dosyasını bir de “System.Windows.Forms.dll” dosyasını referans ederek derle­yeceğiz. Bakalım exe dosyanın boyutu ne kadar büyük olacak. .NET Framework ile gelen System.Windows.Forms.dll dosyasının büyüklüğü yaklaşık 5 MB’tır. Buna rağmen aşağıdaki gibi bir derleme yapmama rağmen exe dosyanın büyüklüğü değişmedi.



O zaman şu soruyu da soralım: Yukarıda verdiğim konsol uygulamasını derlerken yararlandı­ğım Console sınıfının yer aldığı referansı neden göz ardı ettik? Çünkü System.Console veya System namespace’i System.core.dll adlı referansta yer almakta ve bu referans derleyici tarafından otomatik olarak EXE dosyaya dahil edilmektedir. Bu nedenle aşağıdaki gibi derleme yukarıdakinden farklı değildir.



Madem “System.Core.dll” adlı referans konsol uygulamalarına otomatik olarak dahil ediliyor o zaman bu referansta yer alan namespace’lerdeki sınıfları kullanmak için derleme sırasında herhangi bir hazırlık yapmak gerekmiyor. 

Yukarıda verilen örnekte yararlanılan Console sınıfının Write ve WriteLine metotları statik metotlar oldukları için direk kullanılabiliniyor. Diğer yandan Console sınıfı statik bir sınıf olduğu için zaten örneği alınamıyor. Yani aşağıda yapıldığı gibi Console sınıfın­dan yola çıkılıp nesne hazırlanmak istenirse derleyici hata rapor eder. 

class Program 
 { 
   static void Main(string[] args) 
    { 
      System.Console konsol = new System.Console(); 
    } 
 } 

Console veya başka bir sınıfı kullanmak istiyorsanız öncelikle o sınıfın hangi namespace’in içinde yer aldığını belirtmeniz gerekir. Bu nedenle yukarıda verilen kısa örnekte önce System ardından Console sınıfını, en son olarak ilgili metodun adını yazdık. 

System.Console.Write("Hangi Yıldayız :"); 

İlgili Class’ın adından önce Class’ı barındıran namespace’in adını her seferinde yazmak iste­miyorsanız söz konusu namespace’i kod dosyasının en üstünde using deyimi ile işaret etmeniz gerekir. Örneğin konsol uygulamasının en üstüne using System; yazıp ondan sonra 

Console.Write("Hangi Yıldayız :"); 

gibi bir satır yazarsanız C# derleyicisi burada ilk yazılanın(yani Console) bir class, tip veya yapı olduğuna hükmedip using deyimi ile işaret edilen Namespace’lerde arama yapar. Console sınıfı System adlı namespace’te bulunduğu için kod hatasız derlenir. 

DOS penceresinde derleme yapılırken System.Core.dll’den başka 2. bir DLL dosyası otomatik olarak referans edilmektedir. Çünkü değişken tanımlanırken kullanılan çok sayıda tip .NET Framework ile gelen System.dll adlı dosyada tanımlıdır. Bu nedenle DOS pencere­sinde aşağıdaki gibi bir derleme hataya neden olmaz ve böyle bir derlemenin artı bir etkisi olmaz.



Bu derleme işleminde yalnızca System.dll dosyasını veya referansını kullandığımı işaret etmeme rağmen System.Core.dll dosyası da otomatik olarak eklenir. Bu nedenle aşağı­daki gibi derleme yukarıdakinden farklı değildir. Tahmin edeceğiniz gibi yararlanılan referansların sayısı fazlalaştığında konsolda derlemek yapmak zorlaşmaktadır,



Şimdi gelelim referans ve namespace’leri bir de Visual Studio ile hazırlanan konsol uygula­maları içinde ele almaya. Bu konuyu incelemek için Visual Studio ile aşağıdaki gibi bir konsol uygulaması hazırladık. Aşağıda verilen ekran görüntüsünden tespit etmiş olacağınız gibi Visual Studio ile hazırlanan konsol uygulamalarına 6 referans otomatik olarak dahil edilmektedir.



Visual Studio tarafından uygulamaya dahil edilmesine rağmen gerek duymadığınız referans­lar varsa Solution Explorer penceresinde söz konusu referansa ait kısayol menü­sünden Remove komutunu vermeniz yeterlidir. 

Konunun ayrıntıları ortaya çıksın diye Visual Studio tarafından konsol uygulamasına dahil edilen bütün referansları Solution Explorer penceresinden ve using deyimlerinin kullanıl­dığı satırları sildik. Aşağıda verilen ekran görüntüsü alındığı sırada Solution Express penceresinde References adı altında listelenen herhangi bir seçenek yoktu.



Sizce bu konsol uygulaması Visual Studio yardımıyla çalıştırılmak istenirse hata meydana gelir mi? Her ne kadar konsol uygulamalarına System ve System.core referansları otomatik olarak dahil edilmekle birlikte bu referanslar silinse bile bu uygulama sorun­suzca çalışır. Çünkü adını andığım bu DLL dosyaları her şartta uygulamaya dahil edilmektedir. Alışkanlıktan “dahil” etmek desek bile bunu bir dahil etme işleminden öte yerinin not edilmesi olarak anlamak gerekir. 

Şimdi konuyu baştan alacağım. Konsol uygulamalarında ek bir hazırlık yapmadan Sistem adlı Namespace’teki sınıflar ve yapılar(struct) kullanılabilmektedir. Örneğin değişken tanımlanırken kullanılan yapıların hepsi System’de yer almaktadır. Bu nedenle yukarıda verilen konsol uygulamasında herhangi bir hazırlık yapılmadan istenen tipte değişken tanımlanabilir. Gelelim Visual Studio’nun sınıfları arama mekanizmasına: Programcının yukarıda verilen konsol uygulamasına Math sınıfının adını yazdığını varsayalım.



Bu sırada System’de yer alan Math sınıfını içeren referans uygulamaya dahil edilmiş olmasına rağmen Visual Studio veya derleyici Math sınıfını bulamaz. Bunun çaresi ya kod dosya­sının başında içeriği araştırılacak namespace’lere System’i dahil etmek ya da Math sınıfından önce ilgili namespace’in(System) adını doğrudan yazmaktır. 

Buna göre System adlı namespace’te yer alan Class’ları veya yapıları kullanabilmek için bu sınıfların System’de yer aldıklarını bir şekilde işaret etmek gerekiyor. Ancak C# uygulamala­rında System adlı Namespace’te Math ve Console gibi sınıfların dışında çok sayıda yapı bulunmaktadır. Örneğin sayısal bilgileri bellekte saklamak için int tipindeki değişkenler aşağıdaki gibi tanımlanmaktadır. 

class Program 
 { 
   static void Main(string[] args) 
    { 
      int yil; 
    } 
 } 

Hemen size sorayım: Bu int hangi sınıfta yer alan bir sınıftır? Cevap basit; int gerçekte System adlı namespace’teki Int16 yapısının takma adıdır. Dolayısıyla Int16 yapısının örne­ğini almak veya System.In16 tipinde değişken tanımlamak için System adlı Namespace’i using deyimi ile işaret etmek gerekmediği gibi değişken tanımlarken veya Int16 yapısının örneğini alırken System adlı namespace’i yapı adından önce yazmak gerekmiyor. System.Int16 yapısının(Struct) takma adı olmasaydı yukarıda verdiğim değişken tanımlama satırını aşağıdaki gibi yapmak zorunda kalırdık. 

class Program 
 { 
   static void Main(string[] args) 
    { 
      System.Int16 sayi; 
    } 
 } 

Bu kod dosyasının en üstünde using deyimi ile System adlı namespace’in kaynaklarının kullanılacağı işaret edilmiş olunsaydı Int16 yapısının örneğini alırken veya değişken tanım­larken System yazmak zorunda kalmazdık. 

using System;
namespace ConsoleApplication1
 {  
   class Program 
     { 
     static void Main(string[] args) 
     { 
       Int16 sayi; 
      } 
   }
}

Namespace Hazırlamak ve Kullanmak

Şimdiye kadar verilen bilgilere göre C# uygulamaları namespace şeklinde düzenlenmektedir. Namespace’lerin içinde başka namespace’ler, Class’lar ve/veya Struct’lar olabilmektedir. Hazır namespace’leri kullandığınız gibi kendiniz namespace hazırlayıp kullanabilirsiniz. Bu konuda bilgi vermek için Visual Studio ile “Proje1” adında bir C# projesi hazırladık. Dolayısıyla bu projedeki bütün Class’lar “Proje1” adlı namespace’e dahil edilecektir. Visual Studio’nun projelere ‘Program.cs’ dosyasını dahil ettiğini biliyorsunuz.



Hazırlayacağınız namespace’leri ve içerdikleri class’ları başka uygulamalarda kullanmak istiyorsanız .NET Framework ile gelen class’lar gibi DLL olarak düzenleyebilirsiniz. Bu işlemler için Visual Studio ile gelen Class Library şablonundan yararlanabilirsiniz.

Bu kod dosyasında hazırlanan “Program” adlı class proje ile aynı ada sahip namespace’e dahil edilmektedir. Yine bildiğiniz gibi Visual Studio ile hazırlanan projedeki ilk formu temsilen ve System.Windows.Forms’da yer alan Form Class’ının mirasçısı olan “Form1” adında bir Class hazırlanmaktadır.

Visual Studio ile hazırlanan projelerde proje ile aynı ada sahip namespace’e dahil edilen Class’lar yalnızca bunlar değildir. Örneğin Solution Explorer penceresinde Properties adı altında gruplanan dosyalardan birisi olan Settings.Designer dosyası dahilinde hazırlanan Class, önce Properties adında bir Namespace’e, bu namespace ise proje ile aynı ada sahip namespace’e dahil edilmektedir. Bundan çıkarılması gereken sonuç şudur: Değişik dosyalara dağılmış Class’lar aynı namespace’de toplanabilmektedir. Bu Class’ın işlevinden daha sonra söz edilecektir.

Hatırlayacağınız gibi konsol uygulamaları dahilinde hazırlanan Class’lar bir Namespace’e dahil edilmediği zaman derleyici kendiliğinden bir namespace hazırlamaktadır. Bir diğer konu ise şudur: .NET Framework ile gelen çok sayıda sınıf Namespace şeklinde paketlenip kullanıma sunulmaktadır. .NET Framework ile birlikte gelen namespace’ler DLL dosyaları içinde oldukları için öncelikle ilgili DLL dosyasının Add References diyalog kutusundan yararlanılıp Visual Studio’nun Solution Explorer penceresinde listelenmesi gerekmektedir. 

Her ne kadar namespace’lerle ilgilenme hazırlanan uygulama DLL şeklinde düzenlendiği zaman işlevsel olsa bile aynı proje dahilinde bazen birden fazla namespace hazırlamaya gerek duyulabilir. Şimdi örnek olması için aynı CS dosyası içinde 3 namespace hazırlayacağız.  

namespace Proje1
 {
  public partial class Form1 : Form
   {
     public Form1()
       {
         InitializeComponent();
       }
    }
 }
namespace Matemaik
{
  public partial class islemler
   { 
   }
}
namespace Aritmetik
{
  public partial class islemler
   {
   }
 }

Bu CS dosyasındaki “Proje1” adlı namespace Visual Studio tarafından proje için hazırlanan namespace’tir. Aynı CS dosyası içinde hazırladığımız “Matematik” ve “Aritmetik” adlı namespace’lerde ise “islemler” adında birer Class bulunmaktadır.  Bu koddaki her iki “islemler” sınıfını da partial olarak işaret etmiş olsak bile bu 2 class’ın başka parçaları yoktur. Form1 sınıfının diğer yarısının Form1.Designer.cs dosyasında olduğunu biliyorsunuz.

Bu şartlarda hem “Matematik” hem de “Aritmetik” adlı namespace’teki class’lardan yararlanılmak istendiği using deyimi ile belirtilir ve ardından “Matematik” adlı namespace’teki “islemler” sınıfının örneği alınmak istenirse hata meydana gelir. Çünkü derleyici hangi namespace’teki “islemler” sınıfının kullanılmak istendiğine karar veremez. Bu nedenle aşağıda yapıldığı gibi Class adından önce namespace adını yazmanız gerekir. 

namespaceProje1
{
  public partial class Form1 : Form
   {
     public Form1()
      {
        InitializeComponent();
      }

   private void Form1_Load(object sender, EventArgs e)
    {
      Matematik.islemler nesne;
      nesne = new Matematik.islemler(); 
    }
  }
}

C# derleyicisi iç-içe namespace tanımlanmasına izin verdiği için aşağıda verilen kod hataya neden olmaz. Bu kodda “Matematik” adını verdiğimiz namespace’in içinde “Aritmetik” adında ikinci bir namespace hazırladık.

namespace Matematik
{
  public partial class islemler
    { 
    }
  namespace Aritmetik
    {
      public partial class islemler
        {
        }
    }
}

Bu 2 namespace’te de “islemler” adında birer Class olduğu için bu Class’ların örnekleri alınırken dikkatli olmak gerekir. Aritmetik’te tanımlı “islemler” class’ının örneğini hazırlamak üzere aşağıdaki gibi kod yazdık. 

private void Form1_Load(object sender, EventArgs e)
 {
   Matematik.Aritmetik.islemler nesne;
   nesne = new Matematik.Aritmetik.islemler(); 
 }
 

Yukarıdaki sayfalarda hazırladığımız namespace’ler aynı kod dosyası içinde olduğu için ek bir işlem yapmaya gerek olmadan yani using deyimi ile namespace’i koda dahil etmeye gerek kalmadan kullandık. Konunun anlaşılması için Add New Item diyalog kutusundan yararlanıp projeye “Matematik.cs” adında boş bir kod dosyası dahil ettik. Ardından projenin ilk formunun veya “Form1” class’ının kod dosyasında hazırladığımız namespace’teki satırları bu dosyaya taşıdık. Namespace konusu asıl kendi bileşenlerini hazırlayıp geliştirdikleri uygulamalarda kullanan programcıları ilgilendirmektedir.



Bu şartlarda bu namespace’lerdeki “islemler” Class’ının örneği hazırlanabilir. Bu namespace DLL dosyası olarak düzenlenmiş olunsaydı Add Reference diyalog kutusundan yararlanıp Solution Explorer penceresinde listelemek gerekirdi.

Using Deyimi İle Namespace’lere Takma Ad Vermek

Şimdiye kadar anlatılanlara göre using deyimi ile kodun başında ilgilenilen namespace’ler işaret edilip bu namespace’lerdeki Class’lardan yararlanılmak istendiği zaman Class adından önce namesspace’in adını yazmak bir zorunluluk olmaktan çıkarılıyor. Yine yukarıda söylendiği gibi C# uygulamalarında değişken tanımlama işlemlerinin C++’deki gibi olmasını sağlamak için hem de her değişken tanımlandığında ilgili yapının örneğinin kolayca alınma­sını sağlamak için çok sayıda yapıya(struct) takma adlar verilmiştir. 

Örneğin System’de yer alan Int32 yapısının takma adı int’tir. Benzer şekilde kendi hazırladığınız namespace’lere takma adlar verebilirsiniz. Şimdi örnek olması için System.Drawing’de yer alan Imaging adlı namespace’e takma isim vereceğiz. Her ne kadar Visual Studio ile hazırlanan projelere using deyimi sayesinde System.Drawing’deki Class’lar erişilebilir yapılsa bile bu namespace’in içinde ayrıca Imaging adında başka bir namespace var. Şimdi bu namespace’e using deyimi ile takma ad vereceğiz. 

using imge = System.Drawing.Imaging;

Bu satır kodun üst kısmına yazıldıktan sonra System.Drawing.Imaging yazmak yerine kısaca “imge” denilebilir. using bloğunda System.Drawing.Imaging yazıldıktan sonra namespace’teki sınıflar zaten kullanılabilmekle birlikte takma isim verme ihtiyacı daha çok Class adı çakışmalarını önlemek için doğar. Bu konuda bilgi vermek için aşağı­daki gibi aynı ada sahip birer Class’a sahip 2 namespace hazırladık. 

namespace Fonksiyonlar1
 {
    class Class1
    {
       public string buyuk_harf(string str)
        {
           return str.ToUpper();
        }
    }
 }
namespace Fonksiyonlar2
  {
    class Class1
     {
       public string buyut(string str)
        {
           return str.ToUpper(); 
        }
     }
  }

Her iki namespace’te aynı ada sahip birer Class olduğu için bu 2 namespace’teki class’ları kullanmak istediğinizi using anahtar kelimesi ile belirtmeniz halinde hata meydana gelir. Ancak aşağıda yapıldığı gibi using deyimi ile bu namespace’lerden yalnızca birisini işaret ederseniz derleyici hata rapor etmez.

using System;
using System.Windows.Forms;
using Fonksiyonlar1;
namespace WindowsFormsApplication1
{
  public partial class Form1 : Form
   {
     public Form1()
      {
         InitializeComponent();
      }
     private void button1_Click(object sender, EventArgs e)
      {
        Class1 nesne1 = new Class1();
        textBox2.Text = nesne1.buyuk_harf(textBox1.Text);    
       }
    }
 }

Bu kod dosyasındaki “Fonksiyonlar2” adı verilen namespace’in kaynaklarını da using deyimiyle kullanmak istediğimizi beyan etmemiz halinde hata meydana gelir. Çünkü derleyici hangi namespace’teki “Class1” sınıfının kullanılmak istendiğine karar veremez. Bu durumda bu namespace’lere aşağıda yapıldığı gibi takma ad vermek gerekir.

using System;
using System.Windows.Forms;
using space1 = Fonksiyonlar1.Class1;
using space2 = Fonksiyonlar2.Class1;
namespace WindowsFormsApplication1
{
  public partial class Form1 : Form
   {
      public Form1()
       {
         InitializeComponent();
       }
      private void button1_Click(object sender, EventArgs e)
       {
         space1 nesne1 = new  space1();
         space2 nesne2 = new space2();
         textBox2.Text = nesne1.buyuk_harf(textBox1.Text);
         textBox3.Text = nesne2.buyut(textBox1.Text);    
       }
    }
}

Bu  kodda dikkat ederseniz takma ad namespace yerine ilgili Class’a verilmektedir. Sorunsuz çalışabilen bu takma ad verme tekniği ilgili Namespace’te çok sayıda Class varsa pratik olmamaya başlar. Çünkü bu durumda her Class için ayrı bir takma ad hazır­lamak gerekir. Bu gibi durumlarda her Class için ayrı bir takma ad hazırlamak yerine “::” operatöründen yararlanılır. Her ne kadar bu örnekte hazırlayıp “Fonksiyonlar1” ve “Fonksiyonlar2” adlarını verdiğimiz namespace’lerde birer Class olsa bile aynı operatörle sorun yaşamadan istediğiniz Class’ı kullanabilirsiniz. Tabi bu durumda takma adı class yerine namespace için hazırlamak gerekir.

using space1 = Fonksiyonlar1;
using space2 = Fonksiyonlar2; 
private void button1_Click(object sender, EventArgs e)
 {
   space1::Class1 nesne1 = new space1::Class1();
   space2::Class1 nesne2 = new space2::Class1();
   textBox2.Text = nesne1.buyuk_harf(textBox1.Text);
   textBox3.Text = nesne2.buyut(textBox1.Text);    
 }

using Deyimi ve IDisposable Arayüzü

using deyiminin yukarıda anlatılanlardan farklı bir kullanım şekli daha var. Bu kullanım şekli ancak IDisposable arayüzünü uygulayan, dolayısıyla Dispose() metoduna sahip sınıflar tarafından desteklenmektedir. Bu nedenle using deyiminin sözünü edeceğiz kullanım şekli hakkında bilgi vermeden önce IDisposable arayüzü hakkında kısaca bilgi vermek gerekiyor. Tabii Class’lar ve Interface’ler hakkında temel bilgiye sahip olunmadan IDisposable arayüzü hakkında verilecek bilgileri hemen kavramak zor olacağı için bu konuyu yüzeysel anlatmayı tercih ettik. Öncelikle aşağıdaki gibi basit bir Class hazırladık. 

class yoketme : IDisposable
 { 
  void IDisposable.Dispose()
   {
   }
 }

“yoketme” adını verdiğimiz bu Class’a IDisposable arayüzünü uyguladığımız için bu arayüzün gerekleri yerine getirilmezse, başka bir deyişle bu sınıf Dispose() adında bir metoda sahip olmazsa hata meydana gelir. Bu nedenle bu Class’ta herhangi bir satıra sahip olmayan Dispose() adında bir metot hazırladık. Ardından bu Class’ın örneğini aldığımızı göstermek için aşağıdaki gibi 2. bir metot hazırladık. 

class yoketme : IDisposable
 { 
  void IDisposable.Dispose()
   {
     MessageBox.Show("Yoketme sınıfının örneği bellekten silindi");  
    }
  public void nesne_durumu()
    {
     MessageBox.Show("Yoketme sınıfının örneği bellekte yaşıyor");  
    }
  }

Tabii bu sınıfın Dispose() metodunda söz konusu nesnenin bellekten silinmesini sağlayan herhangi bir işlem yapmadık. Yani bu sınıf bu hali ile yok etme yani dispose işlemini yapmaz. Buradaki amacımız using bloğunda hazırlanan nesne için Dispose() metodunun otomatik olarak işletildiğini göstermektedir. Şimdi sırada bu sınıfın örneğini alıp kullanmak var. Bunu yaparken using deyiminden yararlanacağız. using deyimini nasıl kullandığımızı aşağıda görebilirsiniz.

private void Form1_Click(object sender, EventArgs e)
 {
   using (yoketme nesne = new yoketme())
     {
       nesne.nesne_durumu();  
     }
  }

using deyiminde sonra parantezlerin içinde IDisposable arayüzünü uygulayan sınıfın örneğini aldıktan sonra using için bir blok hazırlayıp bu bloğun içinde sınıfın normal metodunu işlettik. Şimdi durup düşünürseniz using deyimine ait blokta ilgili metodun işletileceğini ve using bloğunun sonuna gelineceği için using’in işlevinin biteceğini sanabilirsiniz. Ancak böyle olmuyor; using bloğundan çıkıldığında using deyimine ait parantezlerin içinde hazırlanan nesne için otomatik olarak Dispose metodu işletilmektedir. 

Burada “yoketme” adını verdiğimiz Class’a IDisposable arayüzünü uygulamayıp, dolayısıyla bu sınıfın örneğini using deyimine parametre olarak vermeseydik hazırlanan nesne uygun bir zamanda Garbage Collector tarafından bellekten temizlenirdi. Bu konuda daha sonra bilgi verilecektir.

* Meraklısı İçin Notlar
Bu bölüm okunmadan önce ellerinde başka C# kitabı olan arkadaşların o kitapların Namespace'lerler ilgili sayfalarını okuyup ondan sonra bu sayfaları incelemelerini önermek istiyorum. Çünkü başka kaynaklar incelenmeden bu bölümde yazılanların kolay anlaşılması için nasıl bir anlatım tekniğinin seçilidiği fark edilmeyebilir. Şu an için kitabın 100 sayfasını geride bıraktık. Diğer kitapların ölçülerini dikkate alırsak kitabın yaklaşık 120 sayfasını yayınladık. Bu kitabın ilk 120 sayfasının neredeyse yarısını diğer kaynaklarda bulmazsınız. Başka bir deyişle C# konusunda uzmanlaşmak için bu sayfalarda yayınlanan kitap metnini okuyanlar fark atarlar. Yakın bir zamanda kitap satış sitelerinin çok satan kitaplar listelerinde C# kitaplarının birer birer kaybolacağına inanabilirsiniz. Çünkü bu kitabı burada okuyanların diğer yerli kitaplardan öğrenecekleri sınırlıdır.