İlginizi Çekebilir
  1. Ana Sayfa
  2. C Sharp
  3. C# Inheritance – C# Miras Kavramı – OOP

C# Inheritance – C# Miras Kavramı – OOP

Bu yazımda C# Inheritance - C# Miras Kavramı konusunu birkaç örnek ile anlatmaya çalışacağım.  C# Inheritance kavramı Object Oriented Programming (OOP) (Nesne Yönelimli Programlama) konusunun 3 temel prensibinden birisidir.

C# Inheritance - C# Miras Kavramı

Merhaba, C# Inheritance – C# Miras Kavramı yazım ile C# Eğitim setime devam ediyorum. Bu yazımda C# InheritanceC# Miras Kavramı konusunu birkaç örnek ile anlatmaya çalışacağım.  C# Inheritance kavramı Object Oriented Programming (OOP) (Nesne Yönelimli Programlama) konusunun 4 temel prensibinden birisidir. Diğer iki prensip ise encapsulation ve polymorphism kavramlarıdır. Bu iki konu hakkında da birer yazı yazmaya çalışacağım.

OOP Nedir?

Object Oriented Programming (OOP), Nesne Yönelimli Programlama (NYP) nedir sorusunda ne kısa cevap, gerçek hayattaki her şeyin bilgisayar ortamında tanımlanması olarak cevap verebiliriz. Örneğin, Motorlu araçların ortak özelliklerini bir sınıfta tanımladık. Motorlu araçlar sınıfında, havada, denizde ve karada giden motorlu araçlar sınıflarını tanımladık. Karada giden araçlar sınıfında Otomobilleri tanımladık. Otomobiller sınıfında X bir markayı tanımladık.  Her sınıf bir üst kategorisinin sınıfından miras alır. Böylece XX Markası dediğimizde o sınıfın, karada giden motorlu bir taşıt olduğunu biliriz. İşte tüm bu yapıya OOP Türkçe ifadesi ile NYP deriz.

Daha detaylı bilgi için bkz Wikipedia.

C# Inheritance – C# Miras Kavramı

C# Inheritance Nedir? – C# Miras Alma Nedir?

C# inheritance nedir sorusuna verilebilecek en kısa cevap, bir sınıfı(class) miras alarak, onun metodlarını kullanan başka sınıflar türetebilmemizi sağlayan bir kavramdır.

Örnek vermek gerekirse bu yazıda kullanacağımız örnek üzerinden konuşalım.

Bir İnsan sınıfımız olduğunu düşünelim. Tüm insanlarda aynı olan temel özellikler vardır. Yemek yer, su içer vs. Bir de öğretmenleri düşünelim. Onlarda insandır ama tüm insanlarla aynı özelliklere sahip değillerdir. Farklı bir özellikleri vardır. Öğrenciler, işçiler, askerler ya da beyaz tenliler, koyu tenliler yada esmer tenliler. Bu saydıklarımızın hepsi insandır ama diğer onları ayıran bazı özellikleri vardır.

Biz burada bir öğretmen sınıfı hazırlamak istediğimizi düşünelim. Elimizde bir İnsan sınıfı var. Bir öğretmen sınıfı oluşturmak istediğimizde elimizde zaten bir İnsan sınıfı varken neden Öğretmen sınıfında tekrar insan olduğunu belirten özellikler yazmakla uğraşalım. Elimizde hazır olan İnsan sınıfını kullanarak bir Öğretmen sınıfı oluştursak ve sadece Öğretmenlere özel olan özellikleri eklesek daha hızlı ve mantıklı olmaz mı?

Eğer şarlar gereği İnsan sınıfında bir değişiklik yapmamız gerektiğinde, İnsan sınıfı türetilmeden tanımlanan sınıfları tek tek düzenlememiz gerekmez mi? Eğer temelde İnsan özelliklerini kullanan tüm sınıfları, İnsan  sınıfından türetirsek, İnsan sınıfında yaptığımız bir değişiklik, İnsan sınıfından türetilen tüm sınıflara uygulanır.

Bu yazıda c# inheritance örnekleri yani c# miras alma örnekleri vermek için iki farklı örnek yapacağız. Bu projenin videosuna YouTube, proje dosyasına da Github üzerinden erişebilirsiniz. Yazının sonuna ekleyeceğim.

C# Inheritance  (Miras Alma)

Person.cs

using System;
using System.Collections.Generic;
using System.Windows.Forms;

namespace C_sharp_Inheritance.Person
{
    //sınıfın sadece türetileceğini
    //belirtmek için sınıfı abstaract keyword’ünü kullanarak soyutladık
    public abstract class Person
    {
        public Person() { }
        //Ancak burada abstaract keyword’ünün kullanılmasındaki temel
        //faktör bu sınıfın abstract metod içermesidir.


        //Türetilen sınıflarda kullanılmak üzere 4 tane değişken tanımladık.
        protected string Adı;
        protected string Soyadı;
        protected DateTime DogumTarihi;
        protected string Cinsiyeti;


        //Türetilen sınıflarda metodun içi doldurulması için
        //abstract olarak makeAction metodu tanımladık
        public abstract void makeAction();
        
        public abstract void YemekYe();
        public abstract void SuIc();
        public abstract void Calis();
        public abstract void Uyu();
        // abstract metodlar kesinlikle türetildikleri sınıflarda da tanımlanmalıdır.
        // Eğer burada tanımlanan abstract metodlar, türetildikleri sınıflar kullanılmazlarsa
        // 'Student' does not implement inherited abstract member 'Person.Deneme()'	
        // şeklinde bir hata alırız.
    }
}

Person (İnsan) sınıfı içerisinde bir işlem yapmıyoruz. Çünkü Person sınıfı abstract (soyut) bir sınıftır. Hazırlayacağımız Student (Öğrenci), Teacher (Öğretmen) ve Worker (İşçi) sınıflarını bu Person sınıfımızdan türeteceğiz.

 public Person() { }

Bu metodumuz Constructor (Yapıcı) metodumuzdur.

        //Türetilen sınıflarda kullanılmak üzere 4 tane değişken tanımladık.
        protected string Adı;
        protected string Soyadı;
        protected DateTime DogumTarihi;
        protected string Cinsiyeti;

Burada tanımlanan değişkenler / özellikler, Person sınıfından türetilen tüm metodlarda kullanılabilir. Bunlara bir insanın temel özellikleri diyebiliriz. Sonuçta her insanın adı, soyadı, cinsiyeti ve doğum tarihi vardır.

public abstract void makeAction();
public abstract void YemekYe();
public abstract void SuIc();
public abstract void Calis();
public abstract void Uyu();

Buradaki abstract metodlarımız da tüm insanların yaptığını en temel eylemler olarak düşünülebilir.  Bu eylemleri tüm insanlar yapmaktadır. Videoda sadece makeAction() metodunu görebilirsiniz. Anlatımın daha iyi olması için dersi yazarken diğer metodları da yazdım.

Türetilecek olan Abstract sınıfında yer alan bütün abstract metodlar, türetilen sınıflarda kullanılmak zorundadır. Eğer tanımlanmazlarsa aşağıdaki görselde olduğu gibi hata alırız.

C# Inheritance - C# Miras Kavramı

Şimdi Student sınıfımızı Person sınıfından türetelim.

Student.cs

Sınıfın tüm içeriği aşağıdadır.

using System;
using System.Collections.Generic;
using System.Data;
using System.Windows.Forms;

namespace C_sharp_Inheritance.Person
{
    public class Student : Person // Student class'ı Person class'ından miras aldığını belirtiyoruz.
    {
        private string Okul; //  Stundent nesnesinde kullanacağımız bir değişken tanımlıyoruz.

        /// <summary>
        /// Boş bir constructor metod.
        /// </summary>
        public Student()
        {
            // constructor metod / yapıcı metod
        }

        /// <summary>
        ///  Parametre alan constructor metod.
        /// </summary>
        /// <param name="adi"></param>
        /// <param name="soyadi"></param>
        /// <param name="dogum_tarih"></param>
        /// <param name="cinsiyet"></param>
        /// <param name="okul"></param>
        public Student(string adi, string soyadi, DateTime dogum_tarih, string cinsiyet, string okul) 
        {
            // constructor metod / yapıcı metod
            this.Adı = adi;
            this.Soyadı = soyadi;
            this.DogumTarihi = dogum_tarih;
            this.Cinsiyeti = cinsiyet;
            this.Okul = okul;
        }

        /// <summary>
        /// Ben bir öğrenciyim MessageBox'u üretir ve eklenen öğrencinin bilgilerini gösterir.
        /// </summary>
        public override void makeAction()
        {
            //Person sınıfında tanımlanan makeAction abstract metodu override ederek
            //metodun içini istediğimiz gibi doldurduk.
            MessageBox.Show("Ben bir öğrenciyim" + Environment.NewLine
                  + Environment.NewLine + this.Adı
                  + Environment.NewLine + this.Soyadı
                  + Environment.NewLine + this.DogumTarihi
                  + Environment.NewLine + this.Cinsiyeti
                  + Environment.NewLine + this.Okul);
        }

        /// <summary>
        /// Gönderilen List nesnesinden DataTable Üretir.
        /// </summary>
        /// <param name="list"> List<Student> </param>
        /// <returns></returns>
        public DataTable makeDataTable(List<Student> list)
        {
            // Formda hazırladığımız List'i bu metoda gönderek bize bir DataTable üretmesini istiyoruz. 
            // bu metod bu Student Class'ına aittir.
            DataTable dt = new DataTable();
            dt.Columns.Add("ID");
            dt.Columns.Add("Adı");
            dt.Columns.Add("Soyadı");
            dt.Columns.Add("DogumTarihi");
            dt.Columns.Add("Cinsiyeti");
            dt.Columns.Add("Okul");

            int sayac = 0;
            foreach (Student item in list)
            {
                DataRow userRow = dt.NewRow();
                sayac++;
                userRow["ID"] = sayac;
                userRow["Adı"] = item.Adı;
                userRow["Soyadı"] = item.Soyadı;
                userRow["DogumTarihi"] = item.DogumTarihi;
                userRow["Cinsiyeti"] = item.Cinsiyeti;
                userRow["Okul"] = item.Okul;
                dt.Rows.Add(userRow);
            }
            return dt;
        }

        public override void Calis()
        {
            MessageBox.Show("Çalıştım");
        }
        public override void SuIc()
        {
            MessageBox.Show("Su İçtim");
        }

        public override void Uyu()
        {
            MessageBox.Show("Uyudum");
        }

        public override void YemekYe()
        {
            MessageBox.Show("Yemek Yedim");
        }
    }
}

Bu sınıfımız bir abstract sınıf değildir. Person abstract sınıfından türetilen normal bir sınıftır.

public class Student : Person // Student class'ı Person class'ından miras aldığını belirtiyoruz.

Yukarıdaki satırda görüldüğü ( : )  ifadesi ile Person sınıfından alınan miras’ı görebiliyoruz. Daha önce fark etmemiş olabilirsiniz ama bu ifadeyi her formda görebiliyoruz. Örneğin projemizdeki Form1 ‘e bakalım.

    public partial class Form1 : System.Windows.Forms.Form

Burada Form1’in System.Windows.Forms.Form sınıfından miras alındığını görebilirsiniz. Eğer DevExpress kullanıyorsanız. Burada XtraForm ifadesi görürsünüz.

 private string Okul; //  Stundent nesnesinde kullanacağımız bir değişken tanımlıyoruz.

Burada da, sadece Student sınıfına ait bir özellik yer almaktadır. Bu değişken/özellik Student’in okuduğu okul bilgisidir. Her insana değil sadece öğrencilere özel bir özelliktir.

        /// <summary>
        /// Boş bir constructor metod.
        /// </summary>
        public Student()
        {
            // constructor metod / yapıcı metod
        }

        /// <summary>
        ///  Parametre alan constructor metod.
        /// </summary>
        /// <param name="adi"></param>
        /// <param name="soyadi"></param>
        /// <param name="dogum_tarih"></param>
        /// <param name="cinsiyet"></param>
        /// <param name="okul"></param>
        public Student(string adi, string soyadi, DateTime dogum_tarih, string cinsiyet, string okul) 
        {
            // constructor metod / yapıcı metod
            this.Adı = adi;
            this.Soyadı = soyadi;
            this.DogumTarihi = dogum_tarih;
            this.Cinsiyeti = cinsiyet;
            this.Okul = okul;
        }

Burada iki tane constructor (yapıcı) metodumuz var. Bu metodlar overload metodlardır. Yapıcı metodlardan birisi parametre almazken, diğeri parametre almaktadır.

        /// <summary>
        /// Ben bir öğrenciyim MessageBox'u üretir ve eklenen öğrencinin bilgilerini gösterir.
        /// </summary>
        public override void makeAction()
        {
            //Person sınıfında tanımlanan makeAction abstract metodu override ederek
            //metodun içini istediğimiz gibi doldurduk.
            MessageBox.Show("Ben bir öğrenciyim" + Environment.NewLine
                  + Environment.NewLine + this.Adı
                  + Environment.NewLine + this.Soyadı
                  + Environment.NewLine + this.DogumTarihi
                  + Environment.NewLine + this.Cinsiyeti
                  + Environment.NewLine + this.Okul);
        }

Parametre alan yapıcı metodumuzu kullandıktan sonra, yukarıdaki metodu çağırdığımzıda, gönderdiğimiz bilgileri içeren bir MessageBox karşımıza gelir.

 /// <summary>
        /// Gönderilen List nesnesinden DataTable Üretir.
        /// </summary>
        /// <param name="list"> List<Student> </param>
        /// <returns></returns>
        public DataTable makeDataTable(List<Student> list)
        {
            // Formda hazırladığımız List'i bu metoda gönderek bize bir DataTable üretmesini istiyoruz. 
            // bu metod bu Student Class'ına aittir.
            DataTable dt = new DataTable();
            dt.Columns.Add("ID");
            dt.Columns.Add("Adı");
            dt.Columns.Add("Soyadı");
            dt.Columns.Add("DogumTarihi");
            dt.Columns.Add("Cinsiyeti");
            dt.Columns.Add("Okul");

            int sayac = 0;
            foreach (Student item in list)
            {
                DataRow userRow = dt.NewRow();
                sayac++;
                userRow["ID"] = sayac;
                userRow["Adı"] = item.Adı;
                userRow["Soyadı"] = item.Soyadı;
                userRow["DogumTarihi"] = item.DogumTarihi;
                userRow["Cinsiyeti"] = item.Cinsiyeti;
                userRow["Okul"] = item.Okul;
                dt.Rows.Add(userRow);
            }
            return dt;
        }

Form1 içerisinde tanımladığımız List<Student> içinde eklediğimiz tüm Student bilgilerini Foreach döngüsü ile bir DataTable içerisinde ekleyen metodumuz yer almaktadır. Bu DataTable ‘yi eklediğimiz verileri DataGridView içerisinde göstermek için kullanabiliriz. Yada bu DataTable ile SQl Server’e kayıt edebiliriz.

        public override void Calis()
        {
            MessageBox.Show("Çalıştım");
        }
        public override void SuIc()
        {
            MessageBox.Show("Su İçtim");
        }
        public override void Uyu()
        {
            MessageBox.Show("Uyudum");
        }
        public override void YemekYe()
        {
            MessageBox.Show("Yemek Yedim");
        }

Yukarıdaki metodlarımızı, Person sınıfından hatırlıyorsunuz. Bu metodları kullanmasak bile Person sınıfında Abstract olarak yer aldığı için, Person sınıfından türettiğimiz Student sınıfında yer almak zorundadır. Yani Öğrenci de olsa sonuçta insandır ve bu eylemleri yapmak zorundadır. Bu şekilde düşünebiliriz.

Teacher.cs

Teacher sınıfı da, Student ve Worker sınıfı ile neredeyse aynıdır. Tek fark, Student sınıfında Okul, Worker sınıfında Maas bilgileri vardır. Elbette Maas bilgisi Teacher sınıfı içinde geçerli bir özellik olabilir ama farklı olması açısından sadece Worker sınıfına ekledim.

using System;
using System.Collections.Generic;
using System.Data;
using System.Windows.Forms;

namespace C_sharp_Inheritance.Person
{
    public class Teacher : Person //Teacher class'ı Person class'ından miras alıyor.
    {

        private string Unvan; //Teacher sınıfında kullanılmak üzere Unvan adında bir değişken tanımladık.

        /// <summary>
        /// Boş bir constructor metod.
        /// </summary>
        public Teacher() 
        {
            // constructor metod / yapıcı metod
        }

        /// <summary>
        ///  Parametre alan constructor metod.
        /// </summary>
        /// <param name="adi"></param>
        /// <param name="soyadi"></param>
        /// <param name="dogum_tarih"></param>
        /// <param name="cinsiyet"></param>
        /// <param name="unvan"></param>
        public Teacher(string adi, string soyadi, DateTime dogum_tarih, string cinsiyet, string unvan) 
        {
            // constructor metod / yapıcı metod
            this.Adı = adi;
            this.Soyadı = soyadi;
            this.Cinsiyeti = cinsiyet;
            this.DogumTarihi = dogum_tarih;
            this.Unvan = unvan;
        }


        /// <summary>
        /// Ben bir öğretmenim MessageBox'u üretir ve eklenen öğretmenin bilgilerini gösterir.
        /// </summary>
        public override void makeAction()
        {
            //Person sınıfında tanımlanan abstract metodu override ederek
            //metodun içini istediğimiz gibi doldurduk.
            MessageBox.Show("Ben bir öğretmenim" + Environment.NewLine
              + Environment.NewLine + this.Adı
              + Environment.NewLine + this.Soyadı
              + Environment.NewLine + this.DogumTarihi
              + Environment.NewLine + this.Cinsiyeti
              + Environment.NewLine + this.Unvan);
        }


        /// <summary>
        /// Gönderilen List nesnesinden DataTable Üretir.
        /// </summary>
        /// <param name="list">List<Teacher></param>
        /// <returns></returns>
        public DataTable makeDataTable(List<Teacher> list)
        {
            // Formda hazırladığımız List'i bu metoda gönderek bize bir DataTable üretmesini istiyoruz. 
            // bu metod bu Teacher Class'ına aittir.
            DataTable dt = new DataTable();
            dt.Columns.Add("ID");
            dt.Columns.Add("Adı");
            dt.Columns.Add("Soyadı");
            dt.Columns.Add("DogumTarihi");
            dt.Columns.Add("Cinsiyeti");
            dt.Columns.Add("Unvan");

            int sayac = 0;
            foreach (Teacher item in list)
            {
                DataRow userRow = dt.NewRow();
                sayac++;
                userRow["ID"] = sayac;
                userRow["Adı"] = item.Adı;
                userRow["Soyadı"] = item.Soyadı;
                userRow["DogumTarihi"] = item.DogumTarihi;
                userRow["Cinsiyeti"] = item.Cinsiyeti;
                userRow["Unvan"] = item.Unvan;
                dt.Rows.Add(userRow);
            }
            return dt;
        }

        public override void Calis()
        {
            MessageBox.Show("Çalıştım");
        }
        public override void SuIc()
        {
            MessageBox.Show("Su İçtim");
        }

        public override void Uyu()
        {
            MessageBox.Show("Uyudum");
        }

        public override void YemekYe()
        {
            MessageBox.Show("Yemek Yedim");
        }
    }
}

Worker.cs

Form1’de Worker sınıfı ile ilgili bir işlem yoktur. Sadece sınıf olarak eklendi.

using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace C_sharp_Inheritance.Person
{
    public class Worker : Person // Worker class'ı Person class'ından miras alıyor.
    {

        private double Maas; //Worker sınıfında kullanılmak üzere Unvan adında bir değişken tanımladık.

        /// <summary>
        /// Boş bir constructor metod.
        /// </summary>
        public Worker()
        {
            // constructor metod / yapıcı metod
        }

        /// <summary>
        ///  Parametre alan constructor metod.
        /// </summary>
        /// <param name="adi"></param>
        /// <param name="soyadi"></param>
        /// <param name="dogum_tarih"></param>
        /// <param name="cinsiyet"></param>
        /// <param name="Maas"></param>
        public Worker(string adi, string soyadi, DateTime dogum_tarih, string cinsiyet, double Maas)
        {
            // constructor metod / yapıcı metod
            this.Adı = adi;
            this.Soyadı = soyadi;
            this.Cinsiyeti = cinsiyet;
            this.DogumTarihi = dogum_tarih;
            this.Maas = Maas;
        }


        /// <summary>
        /// Ben bir işçiyim MessageBox'u üretir ve eklenen işçinin bilgilerini gösterir.
        /// </summary>
        public override void makeAction()
        {
            //Person sınıfında tanımlanan abstract metodu override ederek
            //metodun içini istediğimiz gibi doldurduk.
            MessageBox.Show("Ben bir öğretmenim" + Environment.NewLine
              + Environment.NewLine + this.Adı
              + Environment.NewLine + this.Soyadı
              + Environment.NewLine + this.DogumTarihi
              + Environment.NewLine + this.Cinsiyeti
              + Environment.NewLine + this.Maas);
        }


        /// <summary>
        /// Gönderilen List nesnesinden DataTable Üretir.
        /// </summary>
        /// <param name="list">List<Worker></param>
        /// <returns></returns>
        public DataTable makeDataTable(List<Worker> list)
        {
            // Formda hazırladığımız List'i bu metoda gönderek bize bir DataTable üretmesini istiyoruz. 
            // bu metod bu Teacher Class'ına aittir.
            DataTable dt = new DataTable();
            dt.Columns.Add("ID");
            dt.Columns.Add("Adı");
            dt.Columns.Add("Soyadı");
            dt.Columns.Add("DogumTarihi");
            dt.Columns.Add("Cinsiyeti");
            dt.Columns.Add("Maaş");

            int sayac = 0;
            foreach (Worker item in list)
            {
                DataRow userRow = dt.NewRow();
                sayac++;
                userRow["ID"] = sayac;
                userRow["Adı"] = item.Adı;
                userRow["Soyadı"] = item.Soyadı;
                userRow["DogumTarihi"] = item.DogumTarihi;
                userRow["Cinsiyeti"] = item.Cinsiyeti;
                userRow["Maas"] = item.Maas;
                dt.Rows.Add(userRow);
            }
            return dt;
        }

        public override void Calis()
        {
            MessageBox.Show("Çalıştım");
        }
        public override void SuIc()
        {
            MessageBox.Show("Su İçtim");
        }

        public override void Uyu()
        {
            MessageBox.Show("Uyudum");
        }

        public override void YemekYe()
        {
            MessageBox.Show("Yemek Yedim");
        }
    }
}

 

Cokgen.cs

C# Inheritance – C# Miras Kavramı İşlemlerine geçmeden önce Cokgen Sınıfı ve ondan türetilen diğer sınıfları da verelim.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace C_sharp_Inheritance.Cokgen
{
    public abstract class Cokgen
    {
        public Cokgen() { }
        public abstract double AlaniniBul(params double[] kenarlar);//dinamik parametre alan metod.
        public abstract double CevresiniBul(params double[] kenarlar);//dinamik parametre alan metod.
    }
}

Bu sınıfımızda da çokgenlerin alanı ve çevresi için abstract metotlar tanımladık. Sonuçta her çokgenin bir alanı ve çevresi mutlaka vardır.

Ucgen.cs

Ucgen sınıfında, sadece ucgenin alanını (Heron formülü) ile nasıl bulabileceğimiz hakkında işlemler vardır. Çevresini bulma metodunu bu yazıyı yazarken eklediğim için çevresini bulma ile ilgili bir işlem yapmadım.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace C_sharp_Inheritance.Cokgen
{
    public class Ucgen : Cokgen
    {
        public Ucgen() { }

        public override double AlaniniBul(params double[] kenarlar)
        {
            double s = (kenarlar[0] + kenarlar[1] + kenarlar[2]) / 2;
            double d = Math.Sqrt(s * (s - kenarlar[0]) * (s - kenarlar[1]) * (s - kenarlar[2]));
            return d;
        }

        public override double CevresiniBul(params double[] kenarlar)
        {
            return 0;
        }
    }
}

Kare.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace C_sharp_Inheritance.Cokgen
{
    public class Kare : Cokgen
    {
        public Kare() { }
        public override double AlaniniBul(params double[] kenarlar)
        {
            return kenarlar[0] * kenarlar[0];
        }
        public override double CevresiniBul(params double[] kenarlar)
        {
            return 0;
        }
    }
}

Dikdortgen.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace C_sharp_Inheritance.Cokgen
{
    public class Dikdortgen : Cokgen
    {
        public Dikdortgen() { }
        public override double AlaniniBul(params double[] kenarlar)
        {
            return kenarlar[0] * kenarlar[1];
        }
        public override double CevresiniBul(params double[] kenarlar)
        {
            return 0;
        }
    }
}

Evet Cokgen sınıfından türetilen diğer sınıflarımızı da verdikten sonra bu sınıflar ile ilgili işlemlere geçebiliriz.

 

C# Inheritance – C# Miras Kavramı İşlemleri

Şimdi Form1 ‘e  geçelim ve bu sınıflar ile ilgili yaptığımız işlemlere bakalım. From tasarımı aşağıdaki gibidir. Uygulaması kolay olması için textboxların yazılı gelmesini sağladım.

C# Inheritance - C# Miras Kavramı

Form1.cs

Student, sekmesindeki ekle ve listele butonları kodları…

        Person.Student student = new Person.Student();
        List<Person.Student> student_list = new List<Person.Student>();
        private void btn_studen_ekle_Click(object sender, EventArgs e)
        {
            student_list.Add(new Person.Student(txt_Student_Ad.Text, txt_Student_soyAd.Text, dt_Student_dogum_Tar.Value, txt_StStudent_cinsiyet.Text, txt_Student_okul.Text));
            MessageBox.Show("Eklendi");
            st_listele();
        }
        private void btn_student_liste_Click(object sender, EventArgs e)
        {
            st_listele();
        }
        void st_listele()
        {
            dataGridView1.DataSource = student.makeDataTable(student_list);
        }

Öncelikle bir Student tanımlaması yaptık. Sonrada bir List<Student>  tanımlası yaptık. Student ‘leri ilk olarak bir listeye ekleyeceğiz sonrada bu listeyi bir DataTable’a aktarıp DataGridView’de göstereceğiz.

Burada, makeDataTable metodumuz geriye DataTable dönüşü veren bir metod olduğundan direk DataGridView’in DataSource özelliğine atamasını yaptık.

Teacher, sekmesindeki ekle ve listele butonları kodları…

Person.Teacher teacher = new Person.Teacher();
        List<Person.Teacher> teacher_list = new List<Person.Teacher>();
        private void btn_teacher_ekle_Click(object sender, EventArgs e)
        {
            teacher_list.Add(new Person.Teacher(txt_teacher_ad.Text, txt_teacher_soyAd.Text, dt_teacher_dogum_Tar.Value, txt_teacher_cinsiyet.Text, txt_teacher_unvan.Text));
            MessageBox.Show("Eklendi");
            tc_listele();
        }
        private void btn_teacher_liste_Click(object sender, EventArgs e)
        {
            tc_listele();
        }
        void tc_listele()
        {
            dataGridView2.DataSource = teacher.makeDataTable(teacher_list);
        }

Student sınıfı kullanımından çokta farklı değil.. 🙂

Cokgen sekmesindeki tasarıma ve işlemlerine bakalım.

C# Inheritance - C# Miras Kavramı 3

Şimdi işlemleri görelim.

NOT: Bu sekmedeki tüm textboxlar C# Sadece Sayı Girişi İçin Özelleştirilmiş TextBox Yapmak dersimizde hazırladığımız textboxlardır.

        private void btn_ucgen_alan_hesapla_Click(object sender, EventArgs e)
        {
            Cokgen.Ucgen ucgen = new Cokgen.Ucgen();
            txn_sonuc_uc.Text = ucgen.AlaniniBul(
                  Convert.ToDouble(txn_kenar_1_uc.Text)
                , Convert.ToDouble(txn_kenar_2_uc.Text)
                , Convert.ToDouble(txn_kenar_3_uc.Text)).ToString();
        }

        private void btn_kare_alan_hesapla_Click(object sender, EventArgs e)
        {
            Cokgen.Kare kare = new Cokgen.Kare();
            txn_sonuc_kare.Text = kare.AlaniniBul(
                  Convert.ToDouble(txn_kenar_kare.Text)).ToString();
        }

        private void btn_dd_alan_hesapla_Click(object sender, EventArgs e)
        {
            Cokgen.Dikdortgen dikdortgen = new Cokgen.Dikdortgen();
            txn_sonuc_dd.Text = dikdortgen.AlaniniBul(
                  Convert.ToDouble(txn_kenar_1_dd.Text)
                , Convert.ToDouble(txn_kenar_2_dd.Text)).ToString();
        }

Gördüğünüz gibi, AlaniniBul() metodumuz her sınıf için aynı olsa da, buradaki işlemlerde farklı sayılarda parametreler alıyor. Bu da dinamik parametre alan metodumuzdan kaynaklanıyor.

Bahsetmeden geçmeyelim; Sadece sayı girilebilmesi için hazırladığımız özel textbox nesnemiz’de textbox nesnesinden miras alıyor. 🙂

    class TextBoxNumbersOnly : TextBox

Bu yazımda iki tane kendimiz hazırladığımız c# inheritance örnekleri yani c# miras alma örnekleri ile birlikte sürekli kullandığımız ama fark etmediğimiz formlar içinde kullanımı gösterdim. Ek olarak önceki derslerimizde yaptığımız bir işlemde de kullandığımızı gösterdim. Bu noktada artık C# İnheritance Nedir?C# Miras Alma Nedir?  sorularına cevap vermiş oldum.

Bu ders için hazırladığım videoyu aşağıda görebilirsiniz.


C# Inheritance – C# Miras Kavramı yazımda bu kadar arkadaşlar. Umarım C# Miras kavramını güzelce açıklayabilmişimdir. Aslında bilmeden de olsa sürekli kullandığımız bir işlemdir.

Yazılarımın anlatımlarını destekleyebilmek adına artık yazıları videolar ile desteklemeye çalışıyorum. Umarım işinize yarıyordur. Bana destek olmak isterseniz, iletişim sayfamda verdiğim sosyal medya hesaplarımı takip edebilirsiniz.

C Sharp Eğitim Seti eğitimi sayfasına gitmek için tıklayınız. Derslerime özel olarak hazırladığım Github Projeme bu bağlantıdan ulaşabilirsiniz… Bu ders için hazırlanan projenin kodlarına buraya tıklayarak ulaşabilirsiniz.

Bu yazı, sitemdeki 428. yazıdır…

Sağlıcakla ve takipte kalın. 😉

Yorum Yap

Yazar Hakkında

Liseden, Ağ Sistemleri ve Yönetimi bölümünden mezun oldum. Üniversiteden (2 yıllık), Bilgisayar Programcılığı bölümünden mezun oldum. Şuanda da AÖF, Yönetim Bilişim Sistemleri bölümünde okumaktayım. Uzmanlık alanlarım; Windows Sistemleri, HTML, CSS, C# ve SQL’dir. Hobi olarak uğraştığım genel konular, Photoshop, After Affects, Corel Draw’dır.Film, YABANCI dizi, Anime izlemeyi ve Manga okumayı severim. Arkadaşlarımla yürüyüş yapmayı ve grup olarak aktivitelere gitmeyi severim. Geri kalan zamanlarımın tümü bilgisayar karşısında geçer.

Yorum Yap