C Sharp Programlama Dili/İsim alanları

Ders 16. İsim alanları

İsim alanları en temel anlamıyla sınıfları organize etmeye (gruplandırmaya) yarayan bir yapıdır.

.Net Framework kütüphanesindeki hazır isim alanlarına erişme

Bildiğiniz üzere şimdiye kadar .Net Framework kütüphanesindeki hazır isim alanlarına erişmek için using anahtar sözcüğünü kullandık. Bu anahtar sözcükle ilgili bilmeniz gereken bazı ufak detaylar:

using anahtar sözcüğüyle bir isim alanını varsayılan isim alanımız hâline getiririz. Yani o isim alanındaki sınıflara, yapılara, vb. direkt erişebiliriz. Eğer using anahtar sözcüğünü kullanmamış olsaydık söz konusu sınıfı ya da yapıyı kullanmadan önce söz konusu sınıfın ya da yapının bağlı olduğu isim alanını da . operatörüyle eklemek zorunda kalacaktık. Örneğin programımızın başında using anahtar sözcüğü ile System isim alanını belirtmezsek bu isim alanına bağlı olan Console sınıfının içindeki WriteLine metodunu System.Console.WriteLine() olarak kullanmak zorunda kalacaktık.
.Net Framework kütüphanesinin en tepesinde System isim alanı ve bunun altında çeşitli görevler için özelleşmiş farklı isim alanları bulunur. Örneğin System.Data isim alanında veri tabanı işlemleri için özelleşmiş çeşitli sınıflara ulaşabiliriz. Bu isim alanının altında yine çeşitli isim alanları da vardır.
using anahtar sözcüğüyle bir isim alanına erişim hakkı elde etmemiz onun altındaki veya üstündeki isim alanlarına da erişim hakkı elde ettiğimiz anlamına gelmez. Her bir isim alanını ayrı ayrı bildirmeliyiz.
Temel veri türleri (int, double, vs.) aslında .Net Framework kütüphanesindeki birer yapıdan başka bir şey değildir. Bu yapılar System isim alanının altında bulunur. Tür dönüşümü konusunda "değişken türlerinin CTS karşılıkları" adı altında bu yapıları tablolamıştık. Yani aslında int türünden bir değişken tanımlarken System.Int32 yapısından bir nesne tanımlamış oluyoruz. Ancak int a=34; gibi bir komutla bir değişken tanımlarken using anahtar sözcüğüyle System isim alanını eklememize gerek yoktur. Çünkü C# otomatik olarak temel veri türlerini bizim erişimimize açık tutar. Yani biz using anahtar sözcüğüyle System isim alanına erişim hakkı elde etmemiş olsak bile bu isim alanına bağlı olan Int32 yapısını kullanabiliriz. Bu durum yalnızca temel veri türlerinde geçerlidir. Aşağıdaki programı inceleyiniz:

 class Sinif
 {
    static void Main()
    {
       int a=5; //geçerli tanımlama
       Int32 a=5; //geçersiz tanımlama
    }
 }

Gördüğünüz gibi C# ikisinde de aynı yapıyı (System.Int32) kullanmamıza rağmen ikincisine izin vermedi. Programın başına using System; satırını ekleseydik ikincisine de izin verecekti. Yani değişkenleri C#'a özgü şekilde oluşturmuşsak System isim alanını eklememiz zorunlu değildir. Yapıların gerçek hâlleriyle değişken oluşturmak ise System isim alanının eklenmesini gerektirir.

Çoğu zaman programımıza using anahtar sözcüğüyle birden fazla isim alanı eklememiz gerekir. Bu gibi durumlarda her bir isim alanını using anahtar sözcüğüyle ayrı ayrı belirtmeliyiz. Virgül ile ortak bildirim yapamayız.

Kendi isim alanımızı yaratma

Fark ettiyseniz şu ana kadar yazdığımız sınıfları, yapıları vs. herhangi bir isim alanına yazmadık. Bu gibi durumlarda C# söz konusu sınıf ya da yapıları varsayılan isim alanımızda sayar. Yani biz bir isim alanı oluşturmamışsak bile C# hayalî bir isim alanı oluşturur ve bize bu isim alanına direkt erişim hakkı verir. Ancak istersek türlerimizi bir isim alanı içine koyabiliriz. Örnek bir isim alanı bildirimi

 namespace IsimAlani
 {
    ...
 }

Bir isim alanının içinde yalnızca sınıflar, temsilciler, enum sabitleri, arayüzler ve yapılar direkt olarak bulunabilir. Bundan sonra tüm bunlara kısaca "tür" diyeceğim. Temsilciler ve arayüzleri ileride göreceğiz. Örnek bir program:

 using System;
 namespace BirinciIsimAlani
 {
    class Deneme
    {
    }
 }
 class AnaSinif
 {
    static void Main()
    {
       BirinciIsimAlani.Deneme d=new BirinciIsimAlani.Deneme();
    }
 }

Gördüğünüz gibi bulunduğumuz isim alanından farklı bir isim alanındaki türle ilgili işlemleri ilgili isim alanını da belirterek yapıyoruz.

İsim alanları diğer bloklarda olduğu gibi blokun kapanmasıyla sonlanmaz. Eğer farklı dosyalardaki farklı türleri aynı isim alanına koyarsak bunlar aynı isim alanında sayılır. Örneğin Deneme1.cs dosyası şöyle olsun:

 using System;
 namespace Deneme
 {
    class Sinif1
    {
       public Sinif1()
       {
          Console.WriteLine("Sinif1 türünden nesne yaratıldı.");
       }   
    }
 }

Deneme2.cs dosyası şöyle olsun:

 using System;
 namespace Deneme
 {
    class Sinif2
    {
       public Sinif2()
       {
          Console.WriteLine("Sinif2 türünden nesne yaratıldı.");
       }
    }
 }

Ve son olarak Deneme3.cs dosyamız şöyle olsun:

 using System;
 class Sinif3
 {
    static void Main()
    {
       Console.WriteLine("Burası ana program");
       Deneme.Sinif1 a=new Deneme.Sinif1();
       Deneme.Sinif2 b=new Deneme.Sinif2();
    }
 }

Şimdi bu üç cs dosyasını aynı klasöre koyalım. DOS'un cd komutuyla o klasöre geçelim ve csc Deneme1.cs Deneme2.cs Deneme3.cs komutunu verelim. Bu komutla C# derleyicisinin bu üç dosyayı tek dosya gibi düşünmesini sağladık. Bunu sınıflar için de yapabiliriz. Örneğin bir şans oyunu programının kullanıcı arayüzüyle ilgili üye elemanların bulunduğu sınıfı ayrı bir dosyaya, arka planla ilgili üye elemanların bulunduğu sınıfı başka bir dosyaya ve son olarak içinde Main metodunun olduğu ve temel komutları içeren son üye elemanların bulunduğu sınıfı da başka bir dosyaya koyarak komut isteminde aynı yöntemi kullanarak derleyebiliriz. Bu tür bir yöntem programımızın karmaşıklığını azaltacaktır. Yine bu tür bir yöntemde yalnızca bir tane Main metodu olmalıdır. Programımız, Main metodunun içinde bulunduğu dosya adında oluşacaktır. Yukarıdaki programa tekrar dönersek, program ekrana şunları yazar:

Burası ana program.
Sinif1 türünden nesne yaratıldı.
Sinif2 türünden nesne yaratıldı.

C# bu tür bir durumda Sinif1 ve Sinif2 sınıflarını aynı isim alanında sayar. Şimdi başka bir örnek yapalım:

 using System;
 using Deneme;
 namespace Deneme
 {
    class Sinif1
    {
       public Sinif1()
       {
          Console.WriteLine("Sinif1 türünden nesne yaratıldı.");
       }   
    }
 }
 class Sinif2
 {
    static void Main()
    {
       Sinif1 a=new Sinif1();
    }
 }

Gördüğünüz gibi programımızın başında using Deneme; satırını da kullandığımız için artık bu isim alanındaki türlerle ilgili işlemleri direkt yapabiliyoruz. Programlarımızın ilk komutları using deyimleri olmalıdır. Bunun tek istisnası bir isim alanı bildirimi olması durumunda using deyimlerinin -isim alanının ilk komutları olması şartıyla- isim alanı bildiriminin içine de yazılabilmesidir. Örnek:

 using Deneme;
 namespace Deneme
 {
    using System;
    class Sinif1
    {
       public Sinif1()
       {
          Console.WriteLine("Sinif1 türünden nesne yaratıldı.");
       }   
    }
 }
 class Sinif2
 {
    static void Main()
    {
       Sinif1 a=new Sinif1();
    }
 }

Ancak bu durumda Sinif2'nin içinde System isim alanının içindeki türleri direkt kullanamayız. Bir isim alanının içine yazdığımız using deyimiyle sadece o isim alanının içinde ilgili türlere direkt erişim hakkı elde ederiz. Başka bir örnek:

using Deneme;
namespace Deneme
{
    using System;
    class Sinif1
    {
        public Sinif1()
        {
            Console.WriteLine("Sinif1 türünden nesne yaratıldı.");
        }
    }
}
namespace Deneme2
{
    using System;
    class Sinif2
    {
        static void Main()
        {
            Sinif1 a = new Sinif1();
            Console.WriteLine("Deneme");
        }
    }
}

Yani bir isim alanı bildiriminin ilk komutları using deyimleri olma şartıyla using deyimlerinin illaki programımızın en başında olma şartı yoktur.

Aynı using deyiminin birden fazla kez yazılması durumunda program hata vermez, ancak gereksizdir. Örneğin aşağıdaki program hata vermez.

 using System;
 using System;
 class Sinif
 {
    static void Main()
    {
       Console.WriteLine("Deneme");
    }
 }

using anahtar sözcüğünün bir başka kullanımı da istediğimiz bir blokun sonunda nesnelerin Dispose() metodunu çağırmaktır. Örnek:

 using System;
 class Deneme:IDisposable //Arayüzleri ileride göreceğiz, o yüzden bu kısma kafa yormanıza gerek yok.
 {
    public void Dispose()
    {
       Console.WriteLine("Dispose() metodu çağrıldı.");
    }
 }
 class AnaSinif
 {
    static void Main()
    {
       Deneme d=new Deneme();
       using(d)
       {
          Console.WriteLine("using bloku");
       }//d.Dispose() metodu burada çağrılır.
       Console.WriteLine("using bloku dışı");
    }
 }

Bu program ekrana sırayla şunları yazar.

using bloku
Dispose() metodu çağrıldı.
using bloku dışı

Gördüğünüz gibi using blokunun hemen sonunda Dispose() metodu çağrıldı. using blokunu aşağıdaki şekilde de yazabilirdik:

 using(Deneme d1=new Deneme(), d2=new Deneme())
 {
    Console.WriteLine("using bloku");
 }//d1.Dispose() ve d2.Dispose() metodu burada çağrılır.

Bu örnekte d1 ve d2 nesneleri için ayrı ayrı Dispose() metodu çağrılacaktır. Bu using blokunu aşağıdaki örnekteki gibi yazamazdık:

 using(Deneme d1=new Deneme,Deneme d2=new Deneme())
 {
    Console.WriteLine("using bloku");
 }

Yani nesneler aynı türden olmalıdır ve ortak tanımlama yapılmalıdır.

İç içe geçmiş isim alanları

İsim alanları iç içe geçebilir. Örneğin .Net Framework kütüphanesinde System isim alanı altında veri tabanı işlemleri için özelleşmiş olan System.Data isim alanı bulunur. Kendimiz de iki türlü iç içe geçmiş isim alanları oluşturabiliriz. Birincisi klasik üst isim alanının blokları içinde yeni bir isim alanı tanımlayarak gerçekleşir. İkincisi de aşağıdaki gibi:

 namespace UstIsimAlani.AltIsimAlani
 {      
    ...türler...
 }

Burada UstIsımAlani isim alanına bağlı AltIsimAlani adında bir isim alanı oluşturduk.

İsim çakışmaları

C# programlama dilinde aynı seviyedeki ögeler aynı isme sahip olamaz, ancak farklı seviyelerdeki ögeler aynı isme sahip olabilir. Derleyici ismin hangi ögeyi kastettiğini ismin kullanım bağlamından çıkarır.

Bir metot içinde bir isme atıfta bulunulduğunda derleyici ilk önce bunun bir yerel değişken olabileceğini düşünür, eğer metotta o isimli bir yerel değişken yoksa bunun o sınıftaki bir üye olabileceğini düşünür, eğer sınıfta o isimli bir üye yoksa bu sefer erişilebilir konumdaki tiplere bakar, eğer o isimli bir tip yoksa bu sefer o isimli isim alanlarına bakar, eğer o isimli bir isim alanı yoksa program hata verir ve derlenmez. Yani isim araması daima içerden dışarı doğrudur. Örnekler:

using System;
class Sinif
{
    static int Ozellik=5;
    static void Main()
    {
        int Ozellik=3;
        Console.WriteLine(Ozellik);
    }
}

Burada ekrana 3 çıktısı verilir. Burada yerel değişken aynı isimli alanı gizlemiştir.

using System;
class Sinif
{
    public void Metot()
    {
        Console.WriteLine("Sinif sınıfı");
    }
}
class Ana
{
    static void Main()
    {
        Ozellik.Metot();
    }

    static Sinif Ozellik
    {
        get
        {
            return new Sinif();
        }
    }
}
class Ozellik
{
    public static void Metot()
    {
        Console.WriteLine("Ozellik sınıfı");
    }
}

Burada ekrana "Sinif sınıfı" çıktısı verilecektir. Burada aynı isimli bir özellik aynı isimli bir sınıfın kullanılmasını engellemiştir.

class Program
{
    static void Main()
    {
        System.Console.WriteLine();
    }
}
class System
{
    public static Sinif Console
    {
        get { return new Sinif(); }
    }
}
class Sinif
{
    public void WriteLine()
    {

    }
}

Burada erişilebilir durumda System isimli hem bir isim alanı, hem bir sınıf varken System isimli sınıf tercih edilmiştir. C# programlama dili aynı assembly'de aynı isimli tip ve isim alanlarının oluşturulmasına izin vermez. Ancak ilişkilendirdiğimiz bütün assembly'lerdeki bütün isim alanı ve tür isimlerini bilmeyebiliriz, daha da ötesi her bir assembly'nin diğerlerindeki tür ve isim alanı adlarını bilmesi de beklenemez. Bu yüzden C#, farklı assembly'lerdeki isim alanı ve tür isimlerinin çakışmasına izin verir. Çağrı yapılırken tür ve isim alanı çakışması olması durumunda C# türü tercih eder. Ancak elbetteki çakışma isim alanı ile isim alanı arasında veya türle tür arasında olursa derleme zamanı hatası meydana gelir.

Eğer üzerinde çalıştığımız assembly ile ilişkilendirdiğimiz bir assembly arasında isim çakışması meydana gelirse C# üzerinde çalıştığımız assembly'deki ögeyi kabul eder. Örnek:

using System;
class Program
{
    static void Main()
    {
        Console.WriteLine();
    }
}
class Console
{
    public static void WriteLine()
    {
        
    }
}

using ile takma isim (alias) verme

Diyelim ki iki tane isim alanında aynı adlı türler var ve biz bu isim alanlarını using anahtar sözcüğü ile eklemişiz. Tahmin edersiniz ki bu durumda bu türlerden biriyle işlem yapmak istediğimizde hata oluşur. Çünkü derleyici hangi isim alanındaki türü kullanmak istediğimizi bilemez. İşte bu gibi durumlarda takma isim (alias) kullanılır. Örnek:

 using System;
 using IsimAlani1;
 using IsimAlani2;
 //Eğer aşağıdaki iki satırı yazmasaydık programımız hata verirdi.
 using Sinif1=IsimAlani1.Sinif;
 using Sinif2=IsimAlani2.Sinif;
 //Bu iki satırla derleyicinin IsimAlani1.Sinif sınıfını Sinif1, IsimAlani2.Sinif sınıfını Sinif2 olarak tanımasını sağladık. 
 namespace IsimAlani1
 {
    class Sinif
    {
       public Sinif()
       {
          Console.WriteLine("Burası IsimAlani1");
       }
    }
 }
 namespace IsimAlani2
 {
    class Sinif
    {
       public Sinif()
       {
          Console.WriteLine("Burası IsimAlani2");
       }
    }
 }
 class AnaSinif
 {
    static void Main()
    {
       Sinif1 a=new Sinif1();
       Sinif2 b=new Sinif2();
       //Gördüğünüz gibi nesne yaratırken programın başında belirttiğimiz takma isimleri kullandık.
    }
 }

NOT: Böyle bir programda asıl isim alanlarının using anahtar sözcüğüyle ayrı olarak belirtilmesi şart değildir. Yani programımızda using IsimAlani1; ve using IsimAlani2; satırları bulunmasa da olurdu.

NOT: Takma ad kullanımı .Net Framework kütüphanesindeki sınıflarda da geçerlidir. Örnek:

 using K=System.Console;
 class AnaSinif
 {
    static void Main()
    {
       K.WriteLine("Deneme");
    }
 }

Elbette ki programımızda Console dışında System isim alanına bağlı bir sınıf kullanacaksak using System; satırını programın başına eklemeliyiz. Ancak bu programda gerek yok. Başka bir örnek:

 using System;
 using S=Sinif;
 class Sinif
 {
    public Sinif()
    {
       Console.WriteLine("Deneme");
    }
 }
 class Ana
 {
    static void Main()
    {
       S a=new S();
    }
 }

Burada Sinif sınıfı varsayılan hayalî isim alanımızda olduğu için isim alanını belirtmedik.

 using System;
 using K=Console;
 class Ana
 {
    static void Main()
    {
       K.WriteLine("Deneme");
    }
 }

Burada System isim alanı varsayılan isim alanımız olmasına rağmen varsayılan hayalî isim alanımız olmadığı için program hata verir.

Tipler yanında isim alanlarına da takma isim verebiliriz. Örnek:

 using S=System;
 class Ana
 {
    static void Main()
    {
       S.Console.WriteLine("Deneme");
    }
 }

Eğer iki farklı isim alanında aynı isimli 100'er tane tür varsa bütün bu türlere farklı bir takma isim vermektense sadece isim alanlarına takma isim veririz. Ancak bu durumda türleri daima isim alanlarına vermiş olduğunuz takma isimlerle çağırırız, direkt tür çağırma yapamayız. Aslında bu durumda yaptığımız iş uzun isim alanlarına daha kısa alternatifler bulmaktır.

Haricî takma isimler

Daha önce, iki isim alanına bağlı aynı isimli türler bulunduğunda ve bu isim alanlarını using anahtar sözcüğüyle programımıza eklediğimizde aynı adlı türlerle bir işlem yapmak gerektiğinde hata çıktığını ve bunu önlemek için takma isimler kullandığımızı söylemiştik. Peki diyelim ki iki tane DLL dosyamız var ve bu dosyalarda 100'er tane aynı isimli sınıf var. Farklı olan sadece sınıfların içeriği. Her bir sınıfa ayrı ayrı takma isim mi koyacağız? Tabii ki hayır. Bunun için haricî takma isimleri kullanacağız. Hatta biz bu örneğimizi biraz daha abartalım ve isim alanları da aynı adlı olsun. Artık örneğimize başlayabiliriz. Şimdi dosya1.cs dosyası oluşturun ve içine şu kodları yazın:

 namespace IsimAlani
 {
    public class bir
    {
    }
    public class iki
    {
    }
 }

Şimdi dosya2.cs dosyası oluşturun ve içine şu kodları yazın:

 namespace IsimAlani
 {
    public class bir
    {
    }
    public class iki
    {
    }
 }

Bu iki dosyanın içeriği tamamen aynı. Ancak siz sınıfların içeriği farklıymış gibi düşünün. Şimdi her iki dosyayı da kütüphane dosyası (DLL) hâline getirmek için komut satırından

csc /t:library dosya1.cs
csc /t:library dosya2.cs

komutlarını ayrı ayrı verin. Artık elimizde dosya1.dll ve dosya2.dll adlı iki sınıf kütüphanesi var. Bunlar haricî kütüphanelerdir. Çoğu durumda bütün kütüphaneleri bir exe dosyasına gömmek pek kullanışlı olmayabilir. Çünkü aynı kütüphanelerden farklı exe dosyalarının da faydalanmasını isteyebiliriz. Bu yüzden DLL dosyaları oluştururuz. Ayrıca kodumuzda sınıfları public olarak belirttik. Bu sayede bu DLL'lerdeki sınıflara dışarıdan erişimi mümkün kıldık. Konumuza dönecek olursak yukarıdaki örneğimizde iki farklı DLL dosyası tamamen aynı isim alanı ve türleri içeriyor. Şimdi esas programımızı oluşturalım (ismi program.cs olsun):

 using IsimAlani;
 class Program
 {
    static void Main()
    {
       bir a=new bir();   
    }
 }

Şimdi bu ana programımızı derlememiz gerekiyor. Ancak dikkat etmemiz gereken bir nokta var. Bu ana programın önceki hazırladığımız iki DLL ile ilişkilendirilmesi gerekiyor. Bunun için komut satırında şu komutu veriyoruz:

csc /r:dosya1.dll /r:dosya2.dll program.cs

Henüz bu program derlenmeyecektir. Çünkü derleyici bir a=new bir(); satırında hangi DLL'deki bir sınıfını kullanacağını bilmemektedir. Programımızın hata vermemesi için program.cs dosyamızı yeni baştan şöyle yazalım:

 extern alias Dosya1;
 extern alias Dosya2;
 class Ana
 {
    static void Main()
    {
    }
 }

Şimdi komut satırından derleme işlemini yeni takma isimlere göre şöyle yapmamız gerekiyor.

csc /r:Dosya1=dosya1.dll /r:Dosya2=dosya2.dll program.cs

Bu derleme işlemi sorunsuz gerçekleşecektir. Burada dosya1.dll dosyasına Dosya1 takma adını, dosya2.dll dosyasına da Dosya2 takma adını verdik. Pratikte pek faydalı olmasa da bir kütüphaneye birden fazla takma ad verebilirsiniz. Bunun için takma adları virgülle ayırırsınız. Şimdi esas programımızdan DLL'lere ulaşmaya sıra geldi.

:: operatörü

:: (iki tane iki nokta yan yana) operatörü ile takma isim verilmiş DLL kütüphanlerindeki tür ve isim alanlarına erişiriz. Şimdi örneklendirelim. Hatırlarsanız esas programımızın Main blokunda hiçbir kod yoktu. Şimdi program.cs dosyasının Main blokuna şu kodları ekleyin:

 Dosya1::IsimAlani.Sinif a=new Dosya1::IsimAlani.Sinif();
 Dosya2::IsimAlani.Sinif b=new Dosya1::IsimAlani.Sinif();

Aynı şekilde bu tür uzun bir nesne yaratımı yapmak istemiyorsak programın başına

 using Dosya1::IsimAlani;
 using Dosya2::IsimAlani;

Ancak tabii ki yukarıdaki gibi bir using bildirimi aynı adlı isim alanlarında farklı adlı türler varsa mantıklıdır. Örneğimizde pek de mantıklı değildir.

global haricî takma ismi

.Net Framework kütüphanesi, kendi oluşturduğumuz kütüphaneler ve takma ad verilmemiş DLL kütüphanelerimiz otomatik olarak global takma adını alır. Yani programlar aşağıdaki gibi de yazılabilir.

 using System;
 namespace ia
 {
    class Yardimci
    {
       public Yardimci()
       {
          Console.WriteLine("Yardımcı");
       }
    }
 }
 namespace ana
 {
    class Sinif
    {
       static void Main()
       {
          global::ia.Yardimci a=new global::ia.Yardimci();
       }
    }
 }

Başka bir örnek:

 class prg
 {
    static void Main()
    {
       global::System.Console.WriteLine("Deneme");
    }
 }

Ancak az önce işlediğimiz örneği

 global::IsimAlani.Sinif a=new global::IsimAlani.Sinif();
 global::IsimAlani.Sinif b=new global::IsimAlani.Sinif();

şeklinde değiştiremezdik. Pek bir işimize yaramasa da bilmeniz de fayda var.

NOT: extern ifadeleri using ifadelerinden önce yazılmalıdır.
NOT: DLL dosyaları direkt türleri içerebileceği gibi isim alanlarını ve isim alanının altında da türleri içerebilir.
NOT: Eğer türler farklı bir DLL dosyasındaysa türleri public olarak belirtmek gerekir. Ancak aynı dosyada farklı bir isim alanındaysa, ya da dosyaları birlikte derleme söz konusuysa public anahtar sözcüğünü kullanmaya gerek yoktur. Şimdiye kadar öğrendiğimiz bütün türler public anahtar sözcüğüyle belirtilebilir.

Visual Studio'da DLL referansı ekleme ve DLL'lere takma isim verme

Daha sonra göreceğimiz Visual Studio programlama ortamında projemize bir DLL referansı vermek için "Solution Explorer" penceresindeki "References" klasörü sağ tıklanıp "Add Reference..." seçeneği seçilir.

Bir DLL dosyasına takma isim vermek içinse "References" klasöründeki herhangi bir kütüphane veya DLL seçilip "Properties" penceresindeki "Aliases" alanı doldurulur. Ayrıca burada önceden tanımlanmış kütüphanelere verilen "global" takma ismini de değiştirebiliriz.

Bu kitabın diğer sayfaları