.NET Uygulamalarında temel olarak; program kodu, veri ve metadata olunur. Metadata veri hakkında veri olarak tanımlanır ve programın binary dosyalarının (exe veya dll gibi)içine gömülür. Program kodu, assembly ve veri tipleri, metotlar vs.. hakkında metadataları .NET platformda bulmak mümkündür.

Nitelikler(Attributes) ile programlarımıza ve onun elemanlarına derleyici direktifleri(compiler instructions) ve diğer metadata bilgilerini ekleyebiliriz. Nitelikleri ILDasm ile okuyabilir/görebiliriz. Bu sayede C# dilinin kendisini de genişletebiliriz. Bunun nasıl yapıldığı makalenin ilerleyen kısımlarında örnekler ile inceleyeceğiz.

Nitelikler aslında C# veya .NET’teki diğer nesneler gibi birer nesnedir. İki tür nitelik bulunmaktadır; birincisi CLR içinde gelen niteliklerdir. Diğeri ise programcının kendisinin oluşturduğu niteliklerdir. Niteliklerin program içinde değişik elemanlara ait olabileceklerini söylemiştik.

C# dilinde;

·         Sınıflara,

·         Sınıf üyelerine( alanlar, metotlar, özellikler, indeksleyiciler, yapılandırıcılar, yıkıcılar),

·         Yapılara,

·         Arayüzlere,

·         Arayüz elemanlarına( metotlar, özellikler, olaylar, indeksleyiciler),

·         Enumarasyonlara ve üyelerine

·         Delegelere

uygulanmak üzere nitelikler tanımlayabiliriz. Tanımlanan nitelikleri kullanırken onları köşeli parantezler ,[NitelikIsmi] gibi, içinde belirtiriz.

En basit nitelik kullanımı örneği olarak C#’da konsol uygulaması projesi verebiliriz.

/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main(string[] args)
{
//
// TODO: Add code to start application here
//
}

Yukarıdaki kod içerisindeki [STAThread] niteliği Main fonksiyonuna yugulanmak üzere tanımlanmıştır. Bu sayede Main() metodumuz herhangi bir COM tabanlı kod çalıştırılmadan önce COM Single Thread Apartment’ına (STA) girmesi gerektiği derleyiciye bildiriliyor.

Nitelikler parametrik olarak tanımlanmış olabilir. Niteliklere parametre aktarmak parametreleri nitelik isminden sonra parantez içinde yazarız:

[NitelikIsmi(parametre)]

Nitelik isimlerinde ilginç bir hususu da burda belirtmek gerekiyor. Normalde nitelik isimlerinde "Attribute" sonek (suffix) bulunur. Örnek [ObsoleteAttribute] niteliğini verebiliriz. Fakat "Atrribute" sonekini belirtmeden nitelikleri kullanmamız mümküdür( [Obsolete] gibi ).

Niteliklerin tanımını, hangi amaçlarla kullanıldıklarını öğrendikten sonra .NET içinde varsayılan olarak gelen niteliklerin çok kullanılanlarını incelemeye geçebiliriz. Ancak bu noktada şunu vurgulamak gerekir ki, nitelikler sadece C# diline has bir özellik değildir. Diğer .NET uyumlu diller de nitelikler tanımlanabilir ve kullanılabilir.

.NET Framework Nitelikleri Örnekleri

.NET sınıf kütüphanesinde yüzlerce nitelik sınıfları bulunmaktadır. Bunların tamamını burada incelememiz mümkün değildir. Hepsi kullanıldıkları yerlerde anlamlanıyorlar. Mesala COM interop ile ilgili işlemleri yaparken kullanılan sınıflarla birlikte 20’nin üzerinde nitelik tanımlanmıştır. COM interop konularını anlatan makale, kitap veya MSDN dökümantasyonlarında bunları nerde nasıl kullanılacakları tek tek detaylı biçimde açıklanmıştır.

1. System.Diagnostics.ConditionalAttribute

Sadece metotlara uygulanan ConditionalAttribute ya da kısaca Conditional niteliği; program kodu içindeki belirli bir metodu derlerken koda dahil edip etmeyeceğimizi bildirmek için kullanılır. Bunun için derleyiciye derleme sırasında geçilen using System;
using System.Diagnostics;

namespace Conditional_Attribute
{
public class TestSinifi
{
public void Metot_A()
{
Console.WriteLine("Metot_A’dan merhaba dünya !");
}

[Conditional("DEBUG")]
public void Metot_B()
{
Console.WriteLine("Metot_B’den merhaba dünya !");
}
public void Metot_C()
{
Console.WriteLine("Metot_C’den merhaba dünya !");
}
}

class ConditionalAttributeProgram
{
public static void Main()
{
TestSinifi myTestSinifi = new TestSinifi();

myTestSinifi.Metot_A();
myTestSinifi.Metot_B();
myTestSinifi.Metot_C();
}
}
}

Yukarıdaki programınız konsol uygulaması olup iki sınıf içermektedir: TestSinifi ve ConditionalAttributeProgram. TestSinifi’nda üç adet metot tanımı yapıyoruz. Bunlardan Metot_B’ye [Conditional("DEBUG")] niteliğini ekledik. Diğer sınıfta ise sadece Main() metodu bulunmaktadır.

Önce programımızı aşağıdaki gibi derleyelim:

csc ConditionalAttributeProgram

Derlenen kodu çalıştırdığımızda şu şekilde bir sonuç elde ederiz:

Metot_A’dan merhaba dünya !
Metot_C’den merhaba dünya !

Ama bir saniye, biz Main() metodu içinde Metot_A(), Metot_B() ve Metot_C()’yi çağırdık. Fakat Metot_B() çağrımız dikkate alınmadı. Sebebi ise Metot_B() ’ye eklediğimiz [Conditional("DEBUG")] niteliğini eklememiz ve derlememe işlemini Debug mod yerine Release modda yaptık. Eğer kodumuzu

csc /d:DEBUG ConditionalAttributeProgram

veya

csc /define:DEBUG ConditionalAttributeProgram

şeklinde derleyip derleyip çalıştırırsak şöyle bir çıktı elde ederiz:

Metot_A’dan merhaba dünya !
Metot_B’den merhaba dünya !
Metot_C’den merhaba dünya !

Sonuç olarak derleme işleminde "DEBUG" sembolu eklemezsek, kod içindeki [Conditional("DEBUG")] niteliği ile işaretlenmiş metotları derleyeyici dikkate almıyor.

Sizlerde isterseniz kendi özel sembollerinizi kullanarak derleme işlemi üzerinde kontrol sahibi olabilirsiniz. Mesela TEST sembolü ile test kodunu yazdığınız metot(ları) deneyebilirsiniz.

2. System.SerializableAttribute

Serializable niteliği sınıflara uygulanır ve sınıfın verilerinin sabit disk veya başka bir depolama birimine serileştirilebileceğini belirtir. Bu sayede sınıf içindeki tüm alanlarını serileşebilir olarak işaretlenir. Eğer bir takım sınıf verilerini serileştirmek istemiyorsak bunları NonSerialized niteliği ile işaretleyebiliriz.

Serializable niteliğinin nasıl kullanabileceğimize dair tam örnek program kodumuz ise:

 parametresinden faydalanırız. İsterseniz Conditional niteliğinin nasıl kullanıldığına dair bir örnek yapalım.

using System;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;

namespace SerializationAttributeProgram
{
[Serializable()]
public class Kullanici
{
public string ismi;
public string email;
public string telefon;

//Serileştirmek istemediğimiz sınıf alan
[NonSerialized()] public string parola;

public Kullanici(string Ismi, string Email, string Telefon, string Parola)
{
this.ismi = Ismi;
this.email = Email;
this.telefon = Telefon;
this.parola = Parola;
}

public Kullanici()
{
}

public void Serilestir()
{
Stream streamYaz = File.Create("KullaniciKaydi.bin");

BinaryFormatter binaryYaz = new BinaryFormatter();

binaryYaz.Serialize( streamYaz, this );
streamYaz.Close();
}

public static Kullanici DeSerilestir()
{
Stream streamOku = File.OpenRead("KullaniciKaydi.bin");

BinaryFormatter binaryOku = new BinaryFormatter();

Kullanici yeniKullanici = new Kullanici();

yeniKullanici = (Kullanici)binaryOku.Deserialize(streamOku);
streamOku.Close();

return yeniKullanici;
}

public override string ToString()
{
string strReturn = " Ismi: " + this.ismi + "\n";

strReturn += " Email: " + this.email + "\n";
strReturn += " Telefon: " + this.telefon + "\n";
strReturn += " Parola: " + this.parola + "\n";

return strReturn;
}
}

public class SerializationAttributeProgram
{
public static void Main()
{
Kullanici kullanicim = new Kullanici("Ahmet Faruk", "nacaroglu@nacaroglu.net",
"0555-6663399", "parolam");

Console.WriteLine(" Serileştirmeden önce kullanıcım: ");
Console.WriteLine( kullanicim.ToString() );
Console.WriteLine(" ----------------------------------------------- ");

kullanicim.Serilestir();

Kullanici yeniKullanici = Kullanici.DeSerilestir();
Console.WriteLine(" DeSerileştirmeden sonra kullanıcım: ");
Console.WriteLine( yeniKullanici.ToString() );

Console.ReadLine();
}
}
}

Yukarıdaki kodda iki sınıfımız bulunmaktadır. Birincisi Kullanici ve ikincisi SerializationAttributeProgram sınıflarıdır. Kullanici sınıfında iki tane yapılandırıcı (biri varsayılan diğeri parametrik), Serilestir(), DeSerilestir() ve ToString() metotları bulunmaktadır.

3. System.ObsoleteAttribute

Bu makalede son olarak Obsolete niteliğini inceleyeceğiz. Program kaynak kodunda varolan bir kod elemanın artık kullanılmayacağı durumlarda onu koddan silmek yerine [Obsolete] niteliği ile işaretleyebiliriz. Bu nitelik assembly dışında tüm kod elemanları için kullanılabilir. Obsolete niteliğinin Message(string) ve IsError(bool) olmak üzere iki tane özelliği parametre ile niteliğe geçirilebilir. Varsayılan olarak IsError false değeri alır ve uyarı(Warning). Eğer IsError özelliğini true yaparsak derleme zamanında hata olarak karşımıza çıkar. Message özelliği ise niteliğin tanımlanma sebebini içerebilir ve bu hata/uyarı mesajında görüntülenir.

using System;

namespace ObsoleteAttributeProgram
{
class ObsoleteAttributeProgram
{
[STAThread]
static void Main(string[] args)
{
Console.WriteLine( ObsoleteAttributeProgram.MerhabaDunya() );
Console.ReadLine();
}

[Obsolete("MerhabaDunya metodu artık kullanılmıyor", false )]
public static string MerhabaDunya()
{
return ("HelloWorld");
}
}
}

TCP protokolüyle basit bir Client/Server programı yapacağız, C# ile socket programlama yapabilmek için System.Net.Sockets isimalanı altında bulunan sınıfları kullanacağız. Yapacağımız programda server bir console uygulaması, client ise windows formlarını kullanarak yapacağımız windows uygulaması olacak.Amacımız basit bir Client/Server çatisi kurmak olduğu için uygulamamız çok basit olacaktır. Siz yazının tamamını dikkatlice incelediğinizde ve yaratıcılığınızı kullandığınızda çok daha gelişmiş uygulamalar yapabilirsiniz. Belki bir sunucu tabanlı script dili bile geliştirebilirsiniz :).

şimdi yazacağımız programda kullanıcı Windows uygulaması vasıtası ile server olan programımıza bağlanacak. Form üzerinde bulunan butona tıkladığımızda yine form üzerinde bulunan textbox girişindeki yazıyı server programımız alacak ve yazıda kaç karakter olduğunu client programına gönderecek.Client program ise bir mesaj kutusu ile kullanıcıya bildirecek.Öncelikle client olan kullanıcıdan mesajın geldiğini düşünürek Server programımızı yazalım. Server programımızı yazmaya başlamadan önce programda Soket programlama için kullandığımız sınıflara ve onların üye fonksiyonlarına kullandığımız kadarıyla bir göz atalım.

:::: TcpListener Sınıfı(System.Net.Sockets) ::::

TcpListener sınıfı TCP protokolü ile çalışan servislere bağlanmamızı sağlar. Mesela HTTP ve FTP protokolleri TCP servislerini kullanırlar. TcpListener sınıfının kurucu fonksiyonunu 3 değişik şekilde çağırabiliriz.

1- )IPEndPoint sınıfını kullanarak IP numarası ve port numarası içeren bir bilgiyi kullanma yolu ile
2- )IP adresi ve port numarasını geçerek çağırma
3- )Sadece Port numarası ile çağırma.Bu durumda varsayılan ağ arayüzünüz TCP servislerini sağlayacaktır.

Biz bu programda 3. şıktaki gibi bir kullanımı tercih ettik.

public void Start();

TcpListener sınıfına ait bu metod network servislerinden ilgili port'u dinleyerek verileri almaya başlamamızı sağlar.

public Socket AcceptSocket();

TcpListener sınıfına ait bu metod veri transferi için geri dönüş değeri olarak bir Socket nesnesi döndürür.Bu geri dönen socket ilgili makinanın IP adresi ve port numarası ile kurulur.(kurucu işlev ile)

:::: Socket Sınıfı(System.Net.Sockets) ::::

Socket Sınıfı ile ilgili aşağıdaki örneği inceleyelim

Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream,ProtocolType.Tcp );

Socket sınıfının bu kurucu işlevi parametre olarak AdressFamily dedigimiz adresleme semasi Soket tipi ve kullanacagimiz protokol tipini alir. Bu 3 paremtere de .NET Framework class kütüphanesinde Enum sabitleri olarak tanimlanmistir.

Programimizda yazdigimiz "Socket IstemciSoketi = TcpDinleyicisi.AcceptSocket();" satiri ile geri dönen soket nesnesinde bu 3 parametrede tanimlanmistir.

public bool Connected();

Bu metod ile Soketin baglanip baglanmadigini geri dönen bool degeri ile anliyoruz.Eger soket hedef kaynaga bagliysa true degilse false degerine geri döner.

:::: NetworkStream Sinifi(System.Net.Sockets) ::::

NetworkStream sinifi kurucularindan olan "void NetworkStream(Socket x);" fonksiyonu ilgili kendisine gönderilen soket nesnesine ait datalari NetworkStream türünden nesnede tutar.bu programda kullandigimiz soket tipi stream oldugu için bu sinifi kullaniyoruz. NetworkStream sinifi içinde islem yapabilmemeiz için ise System.IO isiamalaninda bulunan StreamReader ve StreamWriter siniflarini kullanacagiz.

Ön bilgileri aldığımıza göre server programımızı yazalım. Aşağıdaki ilk kaynak kod server.cs dir. Satır aralarına size yardımcı olabilecek yorumlar ekledim.Kaynak dosyayı özellikle makaleme dosya olarak eklemiyorumki siz aşağıdaki kodları tek tek yazıp daha iyi öğrenin.

:::: TcpClient Sinifi(System.Net.Sockets) ::::

Tcp servislerine bağlantı sağlamak için TcPClient sınıfı kullanılır. Istemci programımızda TcpClient sınıfının <public TcpClient(string, int);> kurucu işlevini kullanıyoruz. İlk parametre bilgisayar adı ikincisi ise port numarasıdır.

public NetworkStream GetStream();

Bu metod ile belirtilen port tan gelen veriler bir NetworkStream nesnesine aktarılır. GetStream metodunun geri dönüş değeri NetworkStream olduğu için atama işlemini NetworkStream türünden bir nesneye yapmamız gerekir.

Not: Yeşil ile yazılan satırlar yorum satırlarıdır.Html formatında bir alt satıra inmiş olan yorum satırlarını copy&paste ile programınıza aktarırken o satırları tekrar tek satır haline getirmeyi unutmayın, aksi halde programınız derlenemez.

//Server.cs

using System; // bunu her zaman eklememiz lazim
using System.IO ; //StreamReader ve StreamWriter siniflari için
using System.Net.Sockets; // Socket, TcpListener ve NetworkStrem siniflari için

public class Server
{

public static void Main()
{

//Bilgi alisverisi için bilgi almak istedigimiz port numarasini TcpListener sinifi ile gerçeklestiriyoruz

TcpListener TcpDinleyicisi = new TcpListener(1234);
TcpDinleyicisi.Start();

Console.WriteLine("Sunucu baslatildi...") ;

//Soket baglantimizi yapiyoruz.Bunu TcpListener sinifinin AcceptSocket metodu ile yaptigimiza dikkat edin
Socket IstemciSoketi = TcpDinleyicisi.AcceptSocket();

// Baglantının olup olmadığını kontrol ediyoruz
if (!IstemciSoketi.Connected)
{
Console.WriteLine("Sunucu baslatilamiyor...") ;
}
else
{
//Sonsuz döngü sayesinde AgAkimini sürekli okuyoruz
while(true)
{
Console.WriteLine("Istemci baglantisi saglandi...");

//IstemciSoketi verilerini NetworkStream sinifi türünden nesneye aktariyoruz.
NetworkStream AgAkimi = new NetworkStream(IstemciSoketi);

//Soketteki bilgilerle islem yapabilmek için StreamReader ve StreamWriter siniflarini kullaniyoruz
StreamWriter AkimYazici = new StreamWriter(AgAkimi);
StreamReader AkimOkuyucu = new StreamReader(AgAkimi);

//StreamReader ile String veri tipine aktarma islemi önceden bir hata olursa bunu handle etmek gerek
try
{
string IstemciString = AkimOkuyucu.ReadLine();

Console.WriteLine("Gelen Bilgi:" + IstemciString);

//Istemciden gelen bilginin uzunlugu hesaplaniyor
int uzunluk = IstemciString.Length;

//AgAkimina, AkimYazını ile IstemciString inin uzunluğunu yazıyoruz
AkimYazici.WriteLine(uzunluk.ToString());

AkimYazici.Flush() ;
}

catch
{
Console.WriteLine("Sunucu kapatiliyor...");
return ;
}
}
}

IstemciSoketi.Close();
Console.WriteLine("Sunucu Kapatiliyor...");
}
}

İşte buda Istemci programımız. Öncelikle şunu belirtiyimki aşağıdaki kodların çoğunu Visual C# kendiliğinden hazırladı, o yüzden size Tavsiyem Visual C# kullanmanız. Öncelikle aşağıdaki şekilde gördüğünüz form yapısını benzer bir form hazırlayın.Sonra da buton_click metodunu form_kapatma metodunu ve using ifadelerini ekleyin.

//client.cs

using System;
using System.Net.Sockets;
using System.IO ;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;

public class Form1 : System.Windows.Forms.Form
{
//Burda server da tanımladıklarımızdan farklı olarak TcpClient sınıfı ile serverdan gelen bilgileri alıyoruz
public TcpClient Istemci;
private NetworkStream AgAkimi;
private StreamReader AkimOkuyucu;
private StreamWriter AkimYazici;

private System.Windows.Forms.Button buton;
private System.Windows.Forms.TextBox textbox;

private System.ComponentModel.Container components = null;

public Form1()
{
InitializeComponent();
}

protected override void Dispose( bool disposing )
{
if( disposing )
{
if (components != null)
{
components.Dispose();
}
}
base.Dispose( disposing );
}

private void InitializeComponent()
{
//Bu satırları Visual C# oluşturdu.
this.buton = new System.Windows.Forms.Button();
this.textbox = new System.Windows.Forms.TextBox();
this.SuspendLayout();

this.buton.Location = new System.Drawing.Point(8, 40);
this.buton.Name = "buton";
this.buton.Size = new System.Drawing.Size(248, 23);
this.buton.TabIndex = 0;
this.buton.Text = "Sunucuya Baglan";
this.buton.Click += new System.EventHandler(this.buton_Click);

this.textbox.Location = new System.Drawing.Point(8, 8);
this.textbox.Name = "textbox";
this.textbox.Size = new System.Drawing.Size(248, 20);
this.textbox.TabIndex = 1;
this.textbox.Text = "Buraya Sunucuya göndereceginiz yaziyi yazin";

this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
this.ClientSize = new System.Drawing.Size(264, 69);
this.Controls.AddRange(new System.Windows.Forms.Control[] {
this.textbox,
this.buton});
this.MaximizeBox = false;
this.Name = "Form1";
this.Text = "C#nedir?com";
this.Closing += new System.ComponentModel.CancelEventHandler(this.form1_kapatma);
this.Load += new System.EventHandler(this.Form1_Load);
this.ResumeLayout(false);
}

//giriş noktamız olan mainde yeni bir form1 nesnesini çalıştırıyoruz
static void Main()
{
Application.Run(new Form1());
}

//From1 yüklendiğinde TcpClient nesnesi oluşturup AgAkımından(NetworkStream) verileri okuyoruz
private void Form1_Load(object sender, System.EventArgs e)
{
try
{
Istemci = new TcpClient("localhost", 1234);
}
catch
{
Console.WriteLine("Baglanamadi");
return;
}
//Server programında yaptıklarımızı burda da yapıyoruz.
AgAkimi = Istemci.GetStream();
AkimOkuyucu = new StreamReader(AgAkimi);
AkimYazici = new StreamWriter(AgAkimi);
}
}

private void buton_Click(object sender, System.EventArgs e)
{

//Kullanıcı butona her tıkladığında textbox'ta yazı yoksa uyarı veriyoruz
//Sonra AkimYazici vasıtası ile AgAkımına veriyi gönderip sunucudan gelen
//cevabı AkimOkuyucu ile alıp Mesaj la kullanıcıya gösteriyoruz
//Tabi olası hatalara karşı, Sunucuya bağlanmada hata oluştu mesajı veriyoruz.
try
{
if (textbox.Text=="")
{
MessageBox.Show("Lütfen bir yazi giriniz","Uyari");
textbox.Focus();
return ;
}

string yazi;
AkimYazici.WriteLine(textbox.Text);
AkimYazici.Flush();
yazi = AkimOkuyucu.ReadLine();
MessageBox.Show(yazi,"Sunucudan Mesaj var");
}

catch
{
MessageBox.Show("Sunucuya baglanmada hata oldu...");
}
}

//TVe bütün oluşturduğumuz nesneleri form kapatıldığında kapatıyoruz.
public void form1_kapatma(object o , CancelEventArgs ec)
{
try
{
AkimYazici.Close();
AkimOkuyucu.Close();
AgAkimi.Close();
}

catch
{
MessageBox.Show("Düzgün kapatilamiyor");
}
}

Nesne yönelimli programlamanın günümüzde ne kadar yaygın olduğunu programlama ile ilgilenen herkes bilmektedir. Nesne Yönelimli Programlama (NYP) yaklaşımında temel olan prensiplerden birisi bilgi gizleme (information hiding)'dir. Bu prensibi projelerimizde uygulamak için C#'in sunduğu en önemli araçlardan biri olan sınıf özellikleri (class properties) konusunu inceleyeceğiz.
Bildiğiniz gibi, C# dilinde tasarlanmış bir sınıfta iki temel unsur bulunur. Birincisi sınıfın özellikleri (fields), ikinicisi ise sınıfın metodlari (methods)'dır. Herhangi bir sınıfın özellikeri sınıfta tutulan ilişikili verilerlerdir. Diğer taraftan sınıfın bizim için değişik işleri yapmasını metodları vasıtasıyla sağlarız. Sınıf tasarımı çok önemli bir iş olup; deneyim, konsantrasyon ve dikkat ister. Sınıfımızın özelliklerini tutan veriler, program akışı sırasında sınıf dışında değiştirilebilir veya bu değerlere ulaşmak istenebilir.
Bu durumda akla ilk gelen çözüm sınıfın verilerinin hepsinin dışarıdan ulaşilabilmesini ve değiştirilebilmesine olanak sağlayan public anahtari ile tanımlamakdir. Aşağıdaki programda bu tür bir çözümün uygun olabileceği düşünülmüştür:
 

Yukarıdaki kod örneğimizde iki tane sınıf bulunmaktadır. Otomobil sınıfı ile otomobil nesnelerimizi oluşturabiliriz. Ayrıca bu sınıfın OzellikleriGoster() metodu ile herhangi bir otomobil nesnemizin özelliklerini görmek için ekrarana yazdırıyoruz. İkinci sınıfımızda (OtomobilTest) ise Otomobil sınıfımızdan nesneler oluşturmak ve onların özellikerini çağırmak için kullanacağız. Şimdi isterseniz Main() fonksiyonunu incelemeye başlayalım. Metodun hemen ilk başında oto1 isimli nesnemizi oluşturuyoruz. oto1 nesnemizin özellikleri 2000 model, siyah ve BMW olsun. Bir sonraki satırda oto1 nesnemizin modelini 300 yapıyoruz. İşte burda büyük bir hata yapılıyor! Çünkü 300 yılında henüz otomobil üretilmemişti. Böyle bir hatayı nasıl önleriz? Çözüm olarak otomobil nesnemizin herhangi bir özelliğini değiştirmek için ayrı bir metod yazmamız gerekir. O zaman programızı şu şekilde değiştirmemiz gerekiyor:

using System;
namespace Property_Makale
{

    class Otomobil
    {
        private int model;
        public string marka;
        public string renk;
        public Otomobil(int model, string marka, string renk)
        {
            if (model > DateTime.Now.Year)
                this.model = DateTime.Now.Year;
            else this.model = model;

            this.marka = marka;
            this.renk = renk;
        }
        public void OzellikleriGoster()
        {
            Console.WriteLine("\nOtomobilimizin Özellikleri: ");
            Console.WriteLine("\t Marka: " + marka);
            Console.WriteLine("\t Model: " + model);
            Console.WriteLine("\t Renk: " + renk + "\n");
        }
        public void ModelDegistir(int yeniModel)
        {
            if ((yeniModel > DateTime.Now.Year) || (yeniModel < 1900))
                Console.WriteLine("Otomobilin modeli su an ki yildan büyük veya 1900'den küçük olamaz ! ");
            else this.model = yeniModel;
        }
    }
    class OtomobilTest
    {
        static void Main(string[] args)
        {
            Otomobil oto1 = new Otomobil(2000, "BMW", "Siyah");
            oto1.OzellikleriGoster();
            oto1.ModelDegistir(300);
            oto1.OzellikleriGoster();
        }
    }
}


Yukarıdaki programda Otomobil sınıfına ModelDegistir(int yeniModel) metodunu ekledik. Bu metod ile modeli değiştirilecek nesnenin modelinin şu anda bulunulan yıldan sonra ve 1900'den önce yapılmak istendiğinde hata mesajı veriyor ve modelini değiştirmiyor. Ayrıca sınıf içindeki model değişkenin tanımlanmasında private anahtarını da kullandığımıza dikkat ediniz. Bu şekildeki bir yaklaşım ile hem sınıfın iç işleyişini sınıf dışından saklamış oluyoruz hem de sınıfa ait verilerin değiştirilmesini sırasındaki hataları en az seviyede tutmayı sağlıyoruz.
Fakat yukarıdaki yöntemi genelde C++ programcıları kullanır(dı). Bizler C# programcıları olarak daha gelişmiş bir yola sahibiz. Sınıf içindeki değerleri değiştirmek ve ulaşmak için özellik (Property) aracını kullanırız. Aşağıdaki program ise C#'ın özellikleri nasıl kullandığına bir örnektir:

using System;
namespace Property_Makale
{
    class Otomobil
    {
        private int model;
        public string marka;
        public string renk;
        public Otomobil(int model, string marka, string renk)
        {
            if (model > DateTime.Now.Year)
                this.model = DateTime.Now.Year;
            else this.model = model;

            this.marka = marka;
            this.renk = renk;
        }
        public void OzellikleriGoster()
        {
            Console.WriteLine("\nOtomobilimizin Özellikleri: ");
            Console.WriteLine("\t Marka: " + marka);
            Console.WriteLine("\t Model: " + model);
            Console.WriteLine("\t Renk: " + renk + "\n");
        }
        public int Model
        {
            get
            {
                return model;
            }
            set
            {
                if ((value > DateTime.Now.Year) || (value < 1900))
                {
                    Console.WriteLine("Otomobilin modeli su an ki yildan büyük veya 1900'den küçük olamaz ! \n");
                }
                else this.model = value;
            }
        }
    }
    class OtomobilTest
    {
        static void Main(string[] args)
        {
            Otomobil oto = new Otomobil(2000, "BMW", "Siyah");
            Console.WriteLine("Otomobilimizin modeli: " + oto.Model);
            oto.Model = 300;
            oto.OzellikleriGoster();
        }
    }
}


Çıktısını gördüğünüz program kodunda C#'ın özellik tanımlama ve kullanma yöntemini kullandık. Özellikler ile herhangi bir nesneye ait değişkenin değerini öğrenebilir ve değiştirebiliriz. Yukarıdaki örnek kodda yeralan aşağıdaki kısımda bir özellik(Property) tanımlıyoruz. Genellikle bir özelliğin ismi üzerinde iş yaptığı değişkenin ismi ile aynı olup sadece ilk harfi büyük olur. Aslında bu bir zorunluluk değil. Sadece C#'da bu bir gelenektir. Bu şekilde bir kullanım bizim kodumuzu okuyanların kodu daha kolay anlaması ve bizim başkalarının kodlarını daha kolay anlamamıza yardımcı olur. Bir özelliğin tanımında özellik isminden önce ne tür bir değer dönderecekse onun tipini belirtmeliyiz. Bu genelde özelliğin ilgili olduğu değişkenin tipidir

public int Model
        {
            get
            {
                return model;
            }
            set
            {
                if ((value > DateTime.Now.Year) || (value < 1900))
                {
                    Console.WriteLine("Otomobilin modeli su an ki yildan büyük veya 1900'den küçük olamaz ! \n");
                }
                else this.model = value;
            }
        }
Özellikler içinde get ve set olmak üzere iki ayrı blok kod olur. İstersek sadece get veya sadece set blokları olan özellikler de yazabiliriz. get bloğunda ilgili değişkenimizin değerini dışarıya döndeririz. set bloğunda ise değişkenimizin değerini değiştiririz. Burda gereken kontrolleri yapıp daha sonra uygunsa girilen değeri kabul edebiliriz. Eminimki get bloğu içinde dikkattinizi değişkeni ismi yerine value şeklinde çağırmamız çekmiştir. Bu sayede kod içinde karışıklık olmaz. Zaten sadece bir tane değişken üzerinde çalışıyorsunuz.
Bu makalemizde C# dilinde yeralan özellik (Property) kavramını inceledik. Bir ilerleyen makalelerimizde sadece yazılabilir (read-only) ve sadece okunabilir (write-only) özellik yazmayı ve kullanmayı inceleyeceğiz.