Nesne Yönelimli Programla Nedir? başlıklı anlatımımın notları

Interface


ILDASM


VIRTUAL


BASE


ABSTRACT

using System;
using System.Collections.Generic;
using Fresenius.Turkiye.Dersler.CSharp.OOP;
using Fresenius.Turkiye.Dersler.CSharp.OOP.Abstract;
using Fresenius.Turkiye.Dersler.CSharp.OOP.Interface;

namespace ConsoleApplication3
{
    class Program
    {
        static void Main()
        {
            #region Genel
            try
            {
                Kisi kisi = new Kisi('E', "Cem", "Topkaya", "83450930945", DateTime.Now);
                Ogrenci og = new Ogrenci()
                                 {
                                     OgrenciNo = 111,
                                     Sinifi = 2,
                                     mDersleri = new List()
                                                     {
                                                         new Ders()
                                                             {
                                                                 Adi = "Coğrafya",
                                                                 Dersligi = "C101"
                                                             },
                                                         new Ders()
                                                             {
                                                                 Adi = "Matematik",
                                                                 Dersligi = "Mat101"
                                                             }
                                                     }
                                 };
            }
            catch (ArgumentOutOfRangeException aor)
            {
                Console.WriteLine("Başlangıç parametleri hatalıdır.");
                Console.WriteLine("İstisna: " + aor.ToString());
            }
            catch (Exception e)
            {
                throw (e);
            }
            #endregion

            #region interface anlatımı
            Akitler akit = new Akitler();
            IKontrat kontrat = new Akitler();
            IKontrat contract = new Contracts();
            kontrat.Anlas();
            kontrat.Boz(1);

            contract.Anlas();
            contract.Boz(1);

            Console.WriteLine(kontrat.GetType());
            Console.WriteLine(contract.GetType());
            #endregion

            #region Abstract
            AKontrat ak1 = new Akit();
            AKontrat ak2 = new Contract();

            Akit akt = new Akit(); 
            #endregion
        }
    }
}

namespace Fresenius.Turkiye.Dersler.CSharp.OOP.Abstract
{
    public abstract class AKontrat
    {
        public abstract void Anlas();
        protected abstract bool Boz(int _iAnlasmaId);

        public void OrtakMetot()
        {
            // code....
        }
    }

    public class Akit : AKontrat
    {
        public override void Anlas() { }
        protected override bool Boz(int _iAnlasmaId) { return false; }
    }

    public class Contract:AKontrat
    {
        public override void Anlas() { }
        protected override bool Boz(int _iAnlasmaId) { return false; }
    }
}

namespace Fresenius.Turkiye.Dersler.CSharp.OOP
{
    class Kisi
    {
        #region Props & Backing Fields
        char mCinsiyet;
        /// 

        /// Cinsiyet bilgisini içerir. Sadece 'E' ve 'K' karakterlerini alır.
        /// 
        public char Sex
        {
            get
            {
                // if (mCinsiyet != 'E' && mCinsiyet != 'K') : Henüz değer atanmamış
                // {
                //      DB  bağlantısı kur,
                //      TC Kimlikten elemanın cinsiyetini çek
                //      DB bağlantısını kapat
                //      mCinsiyet = bulunanDeger
                // }
                // return mCinsiyet;
                return mCinsiyet;
            }
            set
            {
                char[] kabulEdilenDegerler = new[] { 'E', 'K' };
                foreach (char cDeger in kabulEdilenDegerler)
                {
                    if (cDeger.Equals(value))
                    {
                        mCinsiyet = value;
                        return;
                    }
                }


                throw new ArgumentOutOfRangeException();

            }
        }
        #endregion


        #region Fields
        string mTcKimlik;
        string mAdi;
        string mSoyadi;
        DateTime mDogumTarihi;
        #endregion


        #region Constructor (Yapıcı) Metotlar
        public Kisi(char _cinsiyet, string _adi, string _soyadi, string _tc, DateTime _dogum)
        {

            if (_cinsiyet != 'E' && _cinsiyet != 'K')
            {
                throw new ArgumentOutOfRangeException("Cinsiyet E ya da K olmak zorundadır.");
            }
            mCinsiyet = _cinsiyet;
            mAdi = _adi;
            mSoyadi = _soyadi;
            mTcKimlik = _tc;
            mDogumTarihi = _dogum;


            #region this ayrımını yapmak için
            char Sex = 'A';
            this.Sex = _cinsiyet;
            #endregion
        }

        public Kisi()
        {

        }
        #endregion

        protected string SadeceAltSiniftan()
        {
            return base.ToString();
        }

        public string TumBilgiler()
        {
            string sonuc;
            sonuc = String.Format("Adı: {0}\nSoyadı: {1}", mAdi, mSoyadi);
            return sonuc;
        }

        public override string ToString()
        {
            string sonuc;

            sonuc = "üst sınıftan gelen: " + base.ToString();
            sonuc += "\nEzilmiş metodun dönen değeri.";

            return sonuc;
        }

    }

    class Ogrenci : Kisi
    {
        private int mOgrenciNo;
        public int OgrenciNo
        {
            get { return mOgrenciNo; }
            set { mOgrenciNo = value; }
        }

        private int mSinifi;
        public int Sinifi
        {
            get { return mSinifi; }
            set { mSinifi = value; }
        }

        public List mDersleri = new List();


        public Ogrenci()
        {
            Ders dersi = new Ders()
            {
                Adi = "Tarih",
                Dersligi = "T101"
            };
            mDersleri.Add(dersi);

        }
    }

    public class Ders
    {
        public string Adi { get; set; }
        public string Dersligi { get; set; }
    }
}
namespace Fresenius.Turkiye.Dersler.CSharp.OOP.Interface
{
    public interface IKontrat
    {
        void Anlas();
        bool Boz(int _iAnlasmaId);
    }

    public class Akitler : IKontrat
    {
        public void Anlas() { }
        public bool Boz(int _iAnlasmaId) { return true; }

        public void AkitMetodu() { }
    }

    public class Contracts : IKontrat
    {
        public void Anlas() { }
        public bool Boz(int _iAnlasmaId) { return true; }

        public void ContractMethod() { }
    }
}

// Program : Çalışmayan ama çalıştırılabilen dosya
// Process : Programın RAM üzerine alındığı (yani çalıştırıldığı) hali

// Ezgi : Object (Bir sınıftan türeyen nesne)
// Ogrenci : Class (Bir varlığın bilgi/eylemlerini içeren yapı sınıftır)
// Kisi : Class (Class aynı zamanda Tip tir)


// dll(dynamic link library),exe : Assembly
// Ne kodu olursa olsun en az 1 class vardır.
// CSharp : %100 OO
// Executable uygulamalarda başlangıç noktası(entry point) Main fonksiyonudur.

// Hiyerarşik gruplandırma sistemidir.
// namespace HizliBilisim.Media.Sound.Recording { }
// namespace HizliBilisim.Media.Video.Editing { }

// Yapıcı metotlar nesenin başlatıldığı noktaya erişmemizi sağlar. Bu sayede başlangıç değerlerinin uygunluğunu kontrol edebiliriz.
// Default Constructor (Yapıcı Metot) parametresizdir: SınıfınAdı() {}
// Sınıf içinde tanımlı hiç yapıcı metot yoksa compiler otomatik olarak yapıcı metot ekler.
// Parametre alan diğer yapıcı metotlar Overloaded (aşırı yüklenmiş) metotlardır.

// Sınıfa bağlı özellik veya metotlara erişebilmek için, onları "public static " ile tanımlamız gerekir.

// Ctrl + H : find & replace
// Ctrl + K , D : Kodu düzenle
// F9 : Break Point eklemek.
// F5 : Çalıştır
// F10 : Satırın kodunu çalıştır ilerle
// F11 : Satırın içine git ilerle
// Ctrl + K,S kod bloğunu sarmak için

// region ile kodları daraltabiliyoruz.

// override : üst sınıfta tanımlı metodun alt sınıfta ezilerek tekrar yazılmasıdır.
// base : üst sınıfı işaret eder.
// unreachable code : örneğin, return den sonraki satırlar

// public : Umuma açık
// private : Sadece sınıfın içinden erişilebilen
// protected : Türetilen sınıfın içinden ulaşılabilen (Hiç bir obje erişemez).
// property içindeki get ve set metotları eğer {get;set;} şekilde ise, IL koduna compiler tarafından otomatik olarak eklenirler.
// Backing Field : property içinde set ve get edilen sınıf değişkenleridir(Sınıf değişkenleri(field) global değişkenlerdir ve tüm sınıf içinden erişilebilirler).

// Exception : İstisnaları sınıflandırmak ve istisnaya uygun eylemleri gerçekleştirmek için kullanırız.
// İstisnalarda en üst sınıf Exception, alt sınıflar daha belirli istisnaları işaret eder.

// IL : Intermediate Language (Ara dil): .NET içinde yazılan her dilin framework tarafından anlaşılabilen ortak dili

// Encapsulation : Kapsulleyerek erişimini yalıtma.

// Polymorphism : Bir sınıfa bir ya da daha fazla üst sınıf atanabilmesi hali.

// this, bulunduğumuz yeri (yani sınıf) işaret eder. 

// virtual : alt sınıf tarafından ezilebilir demektir ve metod imzasına eklenir (protected virtual void ff())

// Dizi başlatıldığı anda boyutu verilmek zorundadır.
// List değişkenlerin boyutu her hangi bir anda değişebilir. Bu yüzden dizilere göre daha yavaştır.

// interface : Arayüzü uygulayan sınıflara tanımlaması mecburi metotların imzasını(metot gövdesi olmayan kısmı) içerir. Bir kontrattır ve aynı zaman ortak tip demektir.
// arayüzlerden nesne türetilemez. Sadece concrete class lardan obje türetilebilir.
// arayüzlerdeki tüm metot imzaları varsayılan olarak public tir. Ve Accessor Type verilemez(public, private, protected yazılamaz).

// abstract sınıflar interface ile sınıf arasındaki yapılardır ve bu yapılardan nesne üretilemez.
// abstract sınıflarda belirtilen abstract metotlar public ya da protected erişim belirleyicisi alabilirler.
// abstract sınıflar gövdesi olan metotlarıda içerebilir. Bu metotlar istenirse alt sınıflara(protected) ya da nesnelere(public) kullandırılabilir. Bu sayede ortak metotları "abstract class" içinde bir kere yazmış oluruz.