Open
OOP özellikler ve Sınıf

Nesne Dayalı Programlamanın Temel 4 Özelliği vardır.

Bu 4 özellikten birini sağlamayan programlama dili nesne yönelikli programlama dili sayılmaz.
1.) Soyutlama (Abstraction)
2.) Kapsülleme (Encapsulation)
3.) Miras Alma (Inheritance)
4.) Çok biçimlilik (Polymorphism)

1-Soyutlama
“abstract” olarak nitelendirilen bir sınıf, soyut bir sınıf olarak adlandırılır. Çoklu mirasları desteklemez. Soyutlamanın Avantajları ,birkaç ilgili sınıfı kardeş olarak gruplandırmanıza izin verir,karmaşıklığı azaltır.

 
    public abstract class Arac
    { }

    public class Tir : Arac
    { }

    public class Otobus : Arac
    { }

2-Kapsülleme (Encapsulation)
Bir nesnenin verilerini ve özelliklerini diğer nesnelerin doğrudan erişime kapatılması anlamına gelir.
Property’lerini korumaya alır, private ve protected access modifier’larını (erişim belirteci) kullanırız.

  • public
  • private
  • protected
  • internal
  • protected internal

Public: her yerden erişim izni verilmiş olur.
Private: Dışarıdan hiçbir şekilde erişilemez. Sadece bulunduğu class içerisinde erişilebilir.
Protected: Bulunduğu class’dan ve bulunduğu class’da türetilen class’lardan erişilebilir.
Internal: Bu erişim türünde tanımlanmış üyelere sadece aynı assembly içinden erişim izni verilmiş olur.
Protected Internal: Bu erişim türü protected ve internal erişim türlerinin veya işlemiyle birleştirilmiş halidir.
internal demek içerisinde bulundugu projede public gibi , baska bir projeye add reference denilerek eklenirse private takılmak demektir.

Miras Alma (Inheritance)
bir nesnenin özelliklerinin farklı nesneler tarafından da kullanılabilmesine olanak sağlar. public class Insan : Canli


Çok Biçimlilik (Polymorphism)
Bir sınıf başka bir sınıftan türetildiğinde tüm özelliklerini miras alır.
Sınıfın miras aldığı özelliklerin değiştirilebilmesine ve nesne üzerinden çağrılabilmesine çok biçimlilik denir.
Kısaca virtual ve override prensibini uygulamak, Nesne üzerinden çağırmak.

Polymorphism Yöntemi 1 - Overriding (Ezme)
class Uye
{
    public string Ad { get; set; }
    public virtual void Oyna ()  //virtual yaptık çünkü iliştiricez ve değiştiricez
    {
        Console.WriteLine(this.Ad + ": Oynadim.");
    }
}

class Admin : Uye
{
    public override void Oyna()   //override çünkü eskisinin yerini alıcak ezicez
    {
        base.Oyna();
        Console.WriteLine(this.Ad + ": Odevimi yapıp oynadım.");
    }
}
Uye uye = new Uye { Ad = "Ko" };
Admin admin = new Admin { Ad = "Walter" };

uye.Oyna();
admin.Oyna();

Ploymorphism Yöntem 2 = Shadowing Gölgeleme

Gölgeleme işlemi new deyimi ile yapılır. Admin admin = new Admin { Ad = "Umut" };




Sınıf

Sınıf : Bir yapıdır. Bir Kümedir. Soyut bir veri tipidir.
Her sınıfın yapısında veriler ve fonksiyonlar, metotlar, özellikler bulunur. Nesne : Sınıfın oluşturduğu birer Değişkendir.Yapıtaşıdır.
Sınıftaki verileri modeller ve işe yarar hale getirir.
Sınıflar kendı başlarına çalışamazlar. Çağrılmaya ve Örneklenmeye (instance) ihtiyaç duyarlar.
(Örnekleme oluşturmak için new operatörü kullanılır.)
örn;Repository nesne = new Repository() - Repository sınıfın nesnesi


Nesnenin sahip olması gereken özelliklerine field ya da değişken denir.
Degişkenler privatedır yani erişilemezdir.Erişilebilmesi için Public olmasına ihtiyaç duyarlar.
Degiskenler varsayılan olarak privattedir. yani parantezler dısında bir yerden erişilemezler.
Dıs dunya ile irtibata gecebilmek için propertyler yazılır.

public string OkulAdi
{
    get { return this._Adi; }  // field ın değerini almamıza yarar..
    set { this._Adi = value; }  // field ın değerini ayarlamamıza yarar.
}
Property: Degiskenlerin get (getirme) ve set (ayarlama) islemlerini yurutmemize olanak saglayan nesnelerimiz, ozelliklerimizdir.
KısaYolu :prop yazıp 2 taba basarak hızlı bir şekilde encapsulation olayını yapmış oluruz..
Kısa şekli: public int Ad { get; set; }

SINIF : Bir Kümedir. Soyut bir veri tipidir.c# Referans veri tipindedir. Ram'in heap bölgesindedir.
Nesne , çevrenizdeki nesnelerdir. Sınıfa ait bir varlık diyebiliriz.
public class Ogrenci
{
    string _adi; 
    public string Ad
    { 
        get { return this._adi; }     //(GET) ramdeki bilgiyi al,oku  ( ve döndür) 
        set { this._adi = value; }   //(SET) ramdeki bilgiyi sakla (ve  degiskene veri aktar gönder)
    }
    //ya da  public string Ad {get;set;}
}
Okuma veya Atama işlemlerinde herhangi bir aksiyon almak istediğinizde get/set'leri kullanırız.

Degiskenler varsayılan olarak privattedir,parantezler dısında bir yerden erişilemezler.
Dıs dunya ile irtibata gecip getir gotur işlemleri için propertyler yazılır.


Sınıflar içerisinde Metotlar barıdırır

Bunlar, Constructor,Destructor,Overload,Override metotlardır.

Constructor (Yapıcı Metot)

Constructorlar,dogum ani olarak anlamlandirilabilir.
"Nesne nasıl yaratilsin?" sorusunun cevabidir...
Constructor aninda illa ki ozelliklere atama yapmak zorunda degilsiniz.
Isterseniz dogum aninda bir islemin gerceklesmesini de saglayabilirsiniz, yani icerisine metot da yazilabilir...

public class Repository 
{
  public Repository() { }
  public Repository(string A){this.Veri = A; }
}
 
Constructor:Doğum anı, class ile aynı isimdedir.nesne ram uzerinde yaratılırken yapılması gerekenleri temsil eder.
İkinci örnekte, Bu Nesne doğarken(yaratılırken), dışardan A parametresi alsın.(artık çağrıldığında direk = new KumeA("Kotaku")denilir)

Destructor (Yıkıcı Metot)

Destructor Metotlar, bulunduğu metodun bittiği an devreye geçer.
Nesne RAM uzerinden kaldırılmadan hemen once yapilmasi gereken islemler icin kullanilir.
Eger nesnenin destructor ozelligine kodlar yazildiysa bu kodlar calismadan nesne RAM uzerinden asla kaldırılmaz!
Ölüm aninda calismasi gereken kodlardır...
//Ornegin; elektrik kesilmeden hemen once Word'un son yazilan belgeyi kaydetmesi gibi...


class Word
{
    public string İcerik { get; set; }
    //CONSTRUCTOR
    public Word()
    { }

    //DESTRUCTOR
    ~Word()
    {
        StreamWriter sw = new StreamWriter(Application.StartupPath + "\\Yazilarim.txt");
        sw.Write(this.İcerik);
        //Text dosyasını serbest birakmak icin;
        sw.Close();
    }
}
Word wrd;

private void Form1_Load(object sender, EventArgs e)
{
    wrd = new Word();
    StreamReader sr = new StreamReader(Application.StartupPath + "\\Yazilarim.txt");
    txtYazi.Text = sr.ReadToEnd();
    sr.Close();
}

private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
    //Form tam kapanmadan hemen once, Word classından aldıgımız "wrd" adli instance'ın Icerik property'sine textbox'taki degeri atıyoruz. Boylece destructor o degeri alip icerisindeki metot sayesinde ilgili text dosyasina veriyi yazdiracaktir...
    wrd.İcerik = txtYazi.Text;
}

Override (Ez Metodu)
public override string ToString()   
{
  return Ad; 
}
     
//Bu classın adının nasıl görüneceğini belirliyoruz..
public override string ToString()
{
    return Veri; 
} 

public class Kisi
{
    public string Ad;
    public string Soyad; 
    public string TcNo;

    public override string ToString()
    {
        return "Adi:"+Ad + "\n" +"Soyadi:"+ Soyad + "\n" +"TcNumber:"+ TcNo;
    }
}

protected void Page_Load(object sender, EventArgs e)
{
    Kisi kisi = new Kisi();
    kisi.Ad = "Abc";
    kisi.Soyad = "Xyz";
    kisi.TcNo = "12345678911";
    Response.Write(kisi.ToString());
}
    

virtual keyword u bu metotun ovveride edilebilmesini saglar..
virtual keyword:virtual olarak tanımlanan metot başka bir class içerisinde classın içeriği isteğe göre değiştirilebilir.(ezilebilir) hale getirilebilir.




Sınıflar'ın Birkaç Türleri vardır

Sealed class: Sealed olarak tanımlanan bir class, başka bir class’a inheritance için kullanılamaz.
Sealed class başka bir classa kalıtım veremez ama bir classtan kalıtım alabilir.
Abstract Class Abstract class’lardan instance (örnekleme) oluşturulamaz. İçerisine kod yazılabilir. Private olarak tanımlanamazlar.
Static Clas Statik sözcüğü, sınıflar ve üyeleri için herhangi bir instance işlemine gerek duyulmadan direk erişilebilmesini sağlar
Static sınıfı new diye yaratmak yerine .(nokta koyup) metodun ozelliklerine kavuşulur.

    public static class Metot 
    {  
        public static string Property1 = "Hello";
        public static string Property2 = "World";
  
    }
    string metin = Metot.Property1 + " " + Metot.Property2;
    



Interface Yapılar

Interface,kendinden kalıtım alan sınıflara bir şablon,arabirim,imza gösteren bir yapıdır.
İçerisine metotların imzaları ya da metotların başlıkları yazılır.
Nesne oluşturmaz. Public,private.. gibi erişim belirleyicileri olmaz.
Bir kitabın içiçndekiler sayfası gibidir.
Genelde MEtodun başına I harfi ilave edilir. IMetot..


Delege Yapılar

Delege yapılar birden fazla iş çalıştırılabilir.

DelegeMetot dlg = new DelegeMetot(Renklendir);
dlg += Selamla;
//dlg -= Selamla;
dlg.Invoke();
//dlg();

Örnek A
public string EmailYarat(string ad, string soyad)
{
    StringBuilder sb = new StringBuilder();
    sb.Append(ad);
    sb.Append(".");
    sb.Append(soyad);
    sb.Append("@bilgeadam.com");
    return sb.ToString();
}

public delegate string EmailTemsilcisi(string a, string b);

private void button1_Click(object sender, EventArgs e)
{
    EmailTemsilcisi temsil = new EmailTemsilcisi(EmailYarat);
    this.Text = temsil.Invoke(textBox1.Text, textBox2.Text);
}
Ornek B
 public double Topla(double a, double b)
{
    double snc = a + b;
    listBox1.Items.Add(snc);
    return snc;
}
public double Bol(double a, double b)
{
    double snc = a / b;
    listBox1.Items.Add(snc);
    return snc;
}
public double Carp(double a, double b)
{
    double snc = a * b;
    listBox1.Items.Add(snc);
    return snc;
}
public double Cikart(double a, double b)
{
    double snc = a - b;
    listBox1.Items.Add(snc);
    return snc;
}

public delegate double IslemDelege(double a, double b);

private void button1_Click(object sender, EventArgs e)
{
    IslemDelege dlg = new IslemDelege(Topla);
    dlg += Bol;
    dlg += Carp;
    dlg += Cikart;
    dlg.Invoke(double.Parse(textBox1.Text), double.Parse(textBox2.Text));
}

OrnekC
Yine aynı işlem fakat farklı özelliklerle
public double Topla(double a, double b)
{
    double snc = a + b;
    listBox1.Items.Add(snc);
    return snc;
}
public double Bol(double a, double b)
{
    double snc = a / b;
    listBox1.Items.Add(snc);
    return snc;
}
public double Carp(double a, double b)
{
    double snc = a * b;
    listBox1.Items.Add(snc);
    return snc;
}
public double Cikart(double a, double b)
{
    double snc = a - b;
    listBox1.Items.Add(snc);
    return snc;
}

public delegate double IslemDelege(double a, double b);

private void button1_Click(object sender, EventArgs e)
{
    IslemDelege dlg = new IslemDelege(Topla);
    dlg += Bol;
    dlg += Carp;
    dlg += Cikart;
    dlg.Invoke(double.Parse(textBox1.Text), double.Parse(textBox2.Text));
}
    
Orndek D
public delegate void Tetikci();
private void Page_Load(object sender, EventArgs e)
{
    Tetikci t = new Tetikci(BahceyiSula);  
    t += CocuklariGezdir;
    t += MaasiniCek;
    //Fakat Tetikci cocuk bakmasını nerden bılsın? O halde bu gorevı tetıkcıden gerı alıyorum....
    t -= CocuklariGezdir; 
    //Görevler verildi verilmesine.Peki bu gorevleri tetikciye nasıl yapmasını soylerım? 
    t.Invoke();//Tetikci içerisine yer alan olaylari gerceklestir.

}

Tetikciye ilk Gorev ilk satırda verilir.
Eğer Baska Gorevlerde vermek ıstıyorsanız += Op kullanmalısınız.
Görevi gerı almak ıstıyorsanız -= ile alabilirsiniz.


Constructor Örnekler

Constructorlar,dogum ani olarak anlamlandirilabilir.
"Nesne nasıl yaratilsin?" sorusunun cevabidir...
Constructor aninda illa ki ozelliklere atama yapmak zorunda degilsiniz.
Isterseniz dogum aninda bir islemin gerceklesmesini de saglayabilirsiniz, yani icerisine metot da yazilabilir...

constructor : dogum ani. yapici method. nesne ram uzerinde yaratılırken yapılması gerekenleri temsil eder.

Birkaç Örnek

public class Ev
{
    public string Adres { get; set; }
    public double Fiyat { get; set; }
    public bool Bacasivarmi { get; set; }


    public Ev(string prmAdres, double prmFiyat, bool prmKombi)
    {
        this.Adres = prmAdres;
        this.Fiyat = prmFiyat;
        this.Bacasivarmi = Bacasivarmi;
    }

    public Ev()
    {

    } 
}
    
protected void Page_Load(object sender, EventArgs e)
{
    Ev ev = new Ev("yesilkoy", 15000, false);
    Response.Write(ev.Adres + ev.Fiyat.ToString() + " TL" + ev.Bacasivarmi);
}
    



class Araba
{
    string _marka;
    byte _kapiSayisi;
    double _motorHacmi;
    DateTime _uretimYili;

    public string Markasi
    {
        get { return this._marka; } // Değişken üzerindeki değeri geriye döndür
        set { this._marka = value; }// Değişken üzerine değeri yaz
    }
    public byte Kapisayisi
    {
        get { return this._kapiSayisi; }
        set { this._kapiSayisi = value; }
    }
    public double MotorHacmi
    {
        get { return this._motorHacmi / 1000; }
        //get özellğini handled ederek istedgimiz formatta deger dondurmesini saglayabiliriz.. Encaplusation (sarmalanmış değişken) get set olayını böylece tamamıyla kontrol altına almamızı saglayan bir yapıdır..
        set
        {
            if (!(value < 1000)) // 1000 den ağagı degilse goster 
                this._motorHacmi = value;
        }
    }
    public DateTime UretimYili
    {
        get { return this._uretimYili; }
        set { this._uretimYili = value; }
        //Bazen sadece geriye deger döndürmesini ve üzerinde ki degerin sonradan degistirelemesini istersek set olayını devre dışı bırakarak sadece geriye deger dondurmesini sağlarız..
    }

//doğum anında 4 parametre alsın
    public Araba(string prmMarka, byte prmKapi, double prmMotor , DateTime prmUretim)
{
    this._marka = prmMarka;
    this._kapiSayisi = prmKapi;
    this._motorHacmi = prmMotor;
    this._uretimYili = prmUretim; 

}

    public override string ToString()
    {
        return Markasi + " " + Kapisayisi + " " + MotorHacmi +" " + UretimYili;
    }
}
protected void Page_Load(object sender, EventArgs e)
{
    Araba araba = new Araba("Ferrari", 4, 50000, Convert.ToDateTime("12/12/2010"));
    Response.Write(araba);
}



Base Kullanımı

Bir modelin içerisinde constructor metot varsa ve bu modelden kalıtım alan başka bir model varsa
O zaman yeni model de aynı constructorı alacaktır. ve o da kalıtımı : base () olarak alır.

public class Personel 
{
    public string Ad { get; set; }
    public int Maas  { get; set; }

    public Personel(string ad, int maas)   ////Cunstroctor metotu  
    {
    this.Ad = ad;
    this.Maas = maas;
    }
}

public class Yonetici : Personel   
{
    public Yonetici(string ad, int maas) : base(ad,maas) 
    { }
}

Static: Sınıfı new diye yaratmak yerine . denildikten sonra ozelliklere kavusma halidir.
Hızlıca erismek istediginiz nesneler için kullanılabilir ancak her nesne static yazılmamalıdır.

public class Kume
{
    public int sayi { get; set; }
    public static int Toplama(int sayi1, int sayi2)
    {
        return sayi1 + sayi2;
    } 
}
protected void Page_Load(object sender, EventArgs e)
{
    //  //Static :
    Response.Write(Kume.Toplama(4, 5));
}
    

Garbage Collector

GC : Temizleyici demektir.
Sistemde kullanılmayan Ram alanlarını iade eder,temizler.
Tabi nesnenin kullanılmadıgı zaman ortadan kaldırılması için Idisposable ozelligine sahip olması lazım.

 public class Kisi : IDisposable
 { 
    public Ad {get;set;}
    public Kisi() { }  //varsayılan olarak boş bir constructor her zaman vardır.

    public void Dispose()
   { 
    GC.SuppressFinalize(this);
   }
 }

    

Kapsülleme

Kapsülleme sınıftaki alanı gizleyerek dışarıya istenen kadarını açma terminolojisidir.
Bir alanı private yaptığımızda sınıfın içi hariç hiçbiryerden erişilemez kılarız.
Sadece o sınıf ve o sınıftan türeyen sınıflar.

Çok Biçimlilik Polimorphism

Bu metod virtual anahtar kelimesini ekleyerek olur.
Kendinden türeyen sınıflar, isterlerse bu metodu ezebilme yeteneği kazandırmış olur.
Bu da override anahtar kelimesiyle gerçekleştirilir.
Ezilmezse de ana sınıftaki metot geçerli olur.
Aynı sınıftan türemiş aynı davranışın farklı gerçeleştirilmesine çok biçimlilik denir.

Birbirine benziyen sınıflar ya da aynı konulu sınıflar bir araya gelip gruplaştırılarak Namespace yapısını oluşturur. Namespace bir gruplama , bir paketleme işlemidir. Protected : sadece bulundugu class içerisinden ve kalıtım verilen class içerisinden ulaşılmasını saglayan erişim belirleyicisi.. Private Belirtgeci Sadece sınıf metotları tarafından erişilebilir. Public Belitgeci heryere erişebilir. Internal Aynı kütüphanede sınıflar tarafından erişilebilinir.

 public class insan
{
    private string ad;
    private string soyad;
    public string Kimlik { get { return ad + soyad; } }

    private DateTime dogumtarihi;
    public int Yas { get { return DateTime.Today.Year - dogumtarihi.Year; } }
}

public class FutbolTakimi : insan
{
    public virtual string SUTCEK() { return "Ortalama Sut"; }
}

class savunmasurtu : insan
{
    public override string SUTCEK() { return " zayif sut"; }
}

class hucumsutu : insan
{
    public override string SUTCEK() { return " Etkili sut"; }
}





Virtual ve Override İkinci bir Örnek

virtual keyword u bu metotun ovveride edilebilmesini saglar..
virtual keyword:virtual olarak tanımlanan metot başka bir class içerisinde classın içeriği isteğe göre değiştirilebilir.(ezilebilir) hale getirilebilir.

public class EsasSirket 
{
    public string Ad { get; set; }
    public string Soyad { get; set; }

    public virtual string IsYeri()
    {
        return "Normal Calisiyorum";
    }
}


burda VİRTUAL olarak tanımladımız calis metodunu eziyoruz.İçeriği değiştiriyoruz
public class Muhasebe : EsasSirket
{  
    public override string IsYeri()
    {
        return "Hesap Ekstrelerini denetliyorum ";
    } 
}



public class Bilisim : EsasSirket
{
    public override string IsYeri()
    {
        return " Sotek Programlamayı uyguluyorum";
    }
}

Aşağıdaki click olaylarıyla sayfaya farklı metin değerler dönecektir.

protected void btn_futbol_Click(object sender, EventArgs e)
{
    Muhasebe muhasebe = new Muhasebe();
    Response.Write(muhasebe.IsYeri());
}
protected void btn_basketbol_Click(object sender, EventArgs e)
{

    Bilisim bilisim = new Bilisim();
    Response.Write(bilisim.IsYeri());
}
    



public class EsasTakim 
{ 
    public string Ad { get; set; }
    public bool Cinsiyet { get; set; }

    public virtual string Oyna()
    {
        return " Normal Oynuyorum";
    }
}

public class Tenis : EsasTakim
{ 
    public override string Oyna()
    {
        return " Tenis Topu ile oynuyorum";
    }
}


public class Voleybol : EsasTakim
{
    public override string Oyna()
    {
        return " Voley Topu ile oynuyorum";
    }
}
protected void btn_futbol_Click(object sender, EventArgs e)
{
    Voleybol voleybol = new Voleybol();
    Response.Write(voleybol.Oyna());
}

protected void btn_basketbol_Click(object sender, EventArgs e)
{
    Tenis tenis = new Tenis();
    Response.Write(tenis.Oyna());
}



Abstract sınıflar

Sadece kalıtım vermesi için ve instance alınarak kullanılmasını istemediğiniz classları abstract olarak tanımlarız.
Böylece bu class üzerinden sadece diğer classların yapılarını belirleriz.
Amac : benzer turde nesneler ile calısırken bu nesnelerin ortak noktaları bir classin içerisine yazılır.
bu classın içerisindeki bilgiler digerlerine aktarılarak (inheritance) kısa yoldan yapılar cesitlendirilir.
1- classın basına abstract yazılmalıdır.
2- degiskenlerin basına protected yazılmalıdır. eger private bırakırsan parantezler dısına cıkamayacagından diger sınıflara da aktarılamaz.
3- constructor yazılmaz amac onu yaratmak degil ortak ozellikleri tutmaktır.

public abstract class Arac
{
    protected string _Markasi;
    public string MarkaAdi
    {
        get { return this._Markasi; }
        set { this._Markasi = value; }
    }

    protected int _Hizi;
    public int Hizlanma
    {
        get { return this._Hizi; }
        set { this._Hizi = value; }
    }
    public virtual void HiziniArttir()
    {
        this._Hizi += 10;
    }
}

public class Kamyonet : Arac
{ 
    public override void HiziniArttir()
    {
        this.Hizlanma += 10;
    } 
}

public class SporArabasi : Arac
{
    public override void HiziniArttir()
    {
        this.Hizlanma += 20;
    }
}



Sealed Sınıflar

Bir class'i sealed class olarak tanimladiysaniz, artik kalitimin bu classtan son buldugunu belirtmis olmaktasiniz.
Bu saatten sonra, supermen class'ina ait ozellikler farkli bir class'a aktarilamaz.
Sealed classlarda normal bir class olduklari icin, rahatlikla "new" diyerek instance alinabilir classlardir.
Sealed class başka bir classa kalıtım veremez ama bir classtan kalıtım alabilir.
Özellikleri kendine has olan başka bir classta olamayacak class ları sealed tanımlarız..

public abstract class Insan
{
    protected string _Adi;
    public string Ad
    {
        get { return this._Adi; }
        set { this._Adi = value; }
    }
}

     public sealed class Supermen : Insan
     {
         private int _UcusHizi;
         public int UcusHizi
         {
             get { return this._UcusHizi; }
             set { this._UcusHizi = value; }
         }
     }
    

Struct Yapı

Methodlar ve Degişkenler bir arada tutan özelliktir.
Bir ya da birden fazla özelliğin ve metotların bir araya gelmesiyle oluşan yapılara "STRUCT" denir.
İngilizce'deki "Structure" kelimesinin kısaltılmış halidir...

struct Metot
{ 
  public int SayininKaresi(string prm)
  {
     int sayi = Convert.ToInt32(prm);
     int sonuc = sayi * sayi;
     return sonuc;
  }
}
        
private void Button1_Click(object sender, EventArgs e)
{
Metot metot = new Metot();
int Donen = metot.SayininKaresi(textBox1.Text);

label1.Text=Donen.ToString();
}
Kullanılan Kontroller           
Label  ID="label1" runat="server"
TextBox runat="server" ID="textBox1"
          



public struct Personel
{
    //Yapımızda kullanacağımız ortak özellikler aşağıdaki gibi tanımlanır...
    public string Adi;
    public string Soyadi;
    public string Telefonu;
    public string Adresi;
}
        
private void Button1_Click(object sender, EventArgs e)
{  
        Personel prs = new Personel();
        prs.Adi = "Abc";
        prs.Soyadi = "Xyz";
        prs.Telefonu = "111222333";
        prs.Adresi = "İstanbul";
        Response.Write(prs.Adi); 
}

          



    public struct Araba
{
    public string Markasi;
    public string Modeli;
    public int MaxHizi;
    public bool OtomatikVitesMi;
    public double Fiyati; 

    public override string ToString()
    {
        return this.Markasi + " - " + this.Modeli;
    }
}
    //Bir struct içerisinde birden fazla özellik bulunduğu için,
    sistem bu özelliklerden hangisinin o struct'u temsil ettiğini bilemez. 
    Biz sisteme aşağıdaki yoldan bunu gösterebiliriz.

    //Override denildikten sonra bir boşluk bırakılır.
    Çıkan menünden ToString() seçilir.
    Açılan method alanında return'den sonraki alan silinip,
    toString methoduyla gösterilmesi istenilen özellikler yazılır...
private void Button1_Click(object sender, EventArgs e)
{  
    Araba araba = new Araba();
    araba.Markasi = "Lamburcini";
    araba.Modeli = "Toros";
    araba.MaxHizi = 120;
    araba.OtomatikVitesMi = true;
    araba.Fiyati = 12.000;

    Response.Write(araba.ToString());
}
 
02.02.2020