Encapsulation (Kapsülleme) verileri ve fonksiyonları tek bir birim altında birleştirme işlemidir. Encapsulation içinde tuttuğu verilere dışarıdaki kodun erişmesini engelleyen koruyucu bir kalkan görevi görür. Kapsüllemeyi kullanma nedenimiz yazılımcının yaptığı hatalar nedeniyle veriyi yanlışlıkla bozmaya karşı korumaktır.
Encapsulation Nasıl Uygulanır ?
Encapsulation’ı Access Modifiers (Erişim Belirleyiciler) kullanarak gerçekleştiririz. Access Modifiers program içinde tanımlanan değişkenlerin erişim sınırlarını belirleyen anahtar kelimelerdir. Encapsulation’ı kullanmadan önce bu erişim belirleyicilerini tanıyalım.
- Public: Farklı projelerde de dahil olmak üzere Solution içindeki her alandan erişilmesini sağlayan erişim belirleyicidir.
- Private: Private olarak tanımlanmış bir alana sadece o class içinden ulaşılabilmektedir. Erişim belirleyiciler içinde en fazla kısıtlamayı private yapmaktadır. Aynı zamanda bir değişkenin varsayılan erişim belirleyicisidir.
- Protected: Protected ile tanımlanan alana sadece o sınıf içinden veya o sınıfı kalıtım alan (inheritance) sınıf içerisinden ulaşılabilmektedir.
class Xclass
{
public string ad = "Umut";
protected string soyad = "Baglan";
}
class Yclass : Xclass
{
public void Yazdir()
{
Console.WriteLine(soyad);
}
}
class Program
{
static void Main(string[] args)
{
Yclass y = new Yclass();
Console.WriteLine(y.ad);
Console.WriteLine(y.soyad);
}
}
Örneklerde de görebileceğiniz üzere protected olan soyada kalıtım alan sınıfta da ulaşabiliyoruz, fakat main de ulaşmak istediğimizde ise hata alıyoruz
class Xclass
{
public string ad = "Umut";
protected string soyad = "Baglan";
}
class Yclass : Xclass
{
public void Yazdir()
{
Console.WriteLine(soyad);
}
}
class Program
{
static void Main(string[] args)
{
Yclass y = new Yclass();
Console.WriteLine(y.ad);
y.Yazdir();
}
}
Bu durumda soyadı yazdırmak için Yclassımızda ki yazdır metodunu kullanıyoruz.
Internal: Internal olarak tanımladığımız alana proje içerisinde ya da namespace içerisinde erişebiliyoruz fakat tanımladığımız alana diğer projelerden erişim sağlayamıyoruz. Ayrıca internal, sınıfın varsayılan erişim belirleyicisidir.
namespace FirstProject
{
class Cars
{
public string Model = "VOLCO XC90";
}
class Program
{
static void Main(string[] args)
{
Cars c = new Cars();
Console.WriteLine(c.Model);
}
}
}
namespace SecondProject
{
class Program
{
static void Main(string[] args)
{
Cars c = new Cars();
Console.WriteLine(c.Model);
}
}
}
FirstProject ve SecondProject adlı 2 farklı Projemiz bulunmakta. FirstProject adlı projemizde Cars sınıfımız yer alıyor. Internal varsayılan belirleyici olduğundan dolayı internal class Cars yazma gereksinimi duymuyoruz. Cars sınıfımızı başka bir proje altında kullanmak istediğimizde koruma seviyesi nedeniyle erişilemez hatası alıyoruz.
Proctected Internal: Protected ve Internal erişim belirleyicilerinin birleşmiş halidir. Protected Internal tanımlı alan aynı proje içinde Internal olarak davranırken Farklı bir projede ise Protected özelliğini kullanır.
namespace FirstProject
{
class Zclass : Xclass
{
public string beden = "M";
public void yazdir()
{
Console.WriteLine(color);
}
}
class Program
{
static void Main(string[] args)
{
Zclass z = new Zclass();
Console.WriteLine(z.beden);
z.yazdir();
}
}
}
namespace SecondProject
{
public class Xclass
{
protected internal string color = "Siyah";
}
class Program
{
static void Main(string[] args)
{
Xclass x = new Xclass();
Console.WriteLine(x.color);
}
}
}
Yani Xclass sınıfında Protected Internal olarak tanımlanan color kendi projesi olan SecondProject’in altında kullanmamız gerektiğinde kalıtım yapma gereği duymadan direk kullanabiliriz. Fakat farklı bir proje olan FirstProject de kullanmamız gerekiyorsa kalıtım yapmak zorunda oluruz.
Private Protected: Private Protected olarak tanımladığımız alan katıldığı sınıflarda kullanılabilirken Private olduğu için başka bir proje veya namespace altında kullanılamaz. Yani kendi namespace altında protected olarak davranırken farklı bir namespacede Private olarak davranır.
Tabloyu inceleyerek erişim belirleyicilerinin kısıtladığı alanları daha net görebilirsiniz. Erişim belirleyicileri de tanıdığımıza göre kapsülleme ile ilgili örneğimize geçebiliriz.
Yapacağımız örnekte Encapsulation kullanarak girilen notların ortalamasını hesaplıyoruz girilen notun negatif olması durumunda değeri sıfırlıyoruz.
class Lesson
{
private string ad;
private double _firstnote;
public double Firstnote
{
get { return _firstnote; }
set
{
if (value < 0)
{
_firstnote = 0;
}
else
{
_firstnote = value;
}
}
}
private double _secondnote;
public double Secondnote
{
get { return _secondnote; }
set{
if (value < 0) { _secondnote = 0; } else { _secondnote = value; } } } public string Ad { get => ad; set => ad = value; }
public double Average()
{
double result = (_secondnote +_firstnote) / 2;
return result;
}
}
class Program
{
static void Main(string[] args)
{
Lesson l = new Lesson();
l.Firstnote = Convert.ToDouble(Console.ReadLine());
l.Secondnote = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("Ortalamanız {0}", l.Average());
}
}
Örneğimizde firstnote ve secondnote değerlerimizi kapsüllüyoruz. (Ctrl+R, Ctrl+E kısayollarını kullanarak da encapsulation yapabilirsiniz)
Bu sayede dışardan gelen kodun değerlerimizi bozmasını önlemiş oluyoruz. Bazen Private tanımladığımız değerlere ulaşmamız gerekebilir bu durumda örnekteki gibi property yapısını kullanıp dışardan gelen değerleri kontrol etmiş oluyoruz. Çıktımız bu şekilde oluyor.
Umarım sizin için yararlı bir yazı olmuştur. Diğer yazılarımızla görüşmek üzere.
Yorum Yap