C# Abstract Class Nedir?

Merhaba Arkadaşlar,

Abstact sözcüğünü soyut ya da özet olarak Türkçe’ye çevirebiliriz ancak teknik olarak devam edersek kendisinden kalıtım veren ancak new anahtar sözcüğüyle instance (örnek kopya) alınamayan sınıflardır diyebiliriz.

Aynı zamanda bir abstract sınıf içerisinde yine abstract sözcüğünü kullanarak metotlar oluşturabilir ve böylece abstract sınıfı tıpkı bir interface (arayüz) gibi kullanabiliriz.

Şimdi Visual Studio’yu açıyor ve C# programlama dilinde yeni bir Windows Form projesi oluşturuyoruz.Ardından
“kedi” adında bir abstract class oluşturuyoruz, daha sonra Abstact classımız tıpkı normal bir class niteliğinde olduğu için içerisine property ve metotlarımızı yazıyoruz:

Abstract sınıfımızı oluşturduktan sonra formumuzun load eventi (olayı) içerisinde new anahtar sözcüğüyle instance almaya
çalışıyor ve ortaya çıkan hatayı görüyoruz:

Visual Studio’nun bahsettiği gibi abstract olarak işaretli bir sınıftan instance alınamaz demiştik,ancak abstract class
başka bir sınıfa kalıtım verebilir.O yüzden “Tom” adında bir kedimiz olsun ve abstract olarak yazdığımız kedi sınıfından
kalıtım alsın:

Formumuza tekrar dönüyoruz ve “Tom” sınıfından instance alıyoruz:

Böylece abstract sınıftan kalıtım alan normal bir sınıftan instance alınabildiğini öğrenmiş oluyoruz

Abstact bir sınıfı interface gibi kullanmak için uyacağımız en önemli kural, sınıf içerisindeki hangi üyeyi interface
olarak kullanmak istiyorsak o üyenin başına mutlaka abstract sözcüğünü eklemek ve erişim tipini private olarak belirtmemek zorundayız.

Eğer bir abstract classı interface gibi kullanmaya karar verirseniz, sınıf içerisindeki metotların başına abstract sözcüğünü kullanacağınız için metotlarınız mutlaka ama mutlaka erişim belirteçlerinden (access modifiers – ileride göreceğiz) public (her yere açık şekilde) olarak tanımlanmak zorundadırlar.
Bunun yanı sıra abstract metotları virtual (sanal) olarak işaretleyemeyiz çünkü abstract sınıf kalıtım verme niteliğinde olduğu için zaten sanal yapıdadırlar.

Interface gibi kullanmak istediğimiz metotlar static (durağan) olarak belirtilemezler çünkü interface mantığında static kavramına yer yok. (Kalıtım veren dinamik yapıdadır her zaman)

Şimdi tekrar Visual Studio’ya geri dönüyor ve “köpek” adında yeni bir abstract class oluşturuyoruz.Bu sınıfımız
içerisindeki metotlara dikkat ederseniz tamamının başında abstract olduğunu ve interface konusunda öğrendiğimiz
gibi metodun içinin boş yalnızca gövdesinin olduğunu göreceksiniz:

Kopek sınıfımızdan Karabaş isimli köpeğimiz için “Karabaş ” adında bir sınıf oluşturuyor ve kopek sınıfından kalıtım alıyoruz:

Sanki normal bir interface’den kalıtım almış gibi sınıfımız üyeleri otomatik biçimde doluyor ve metotlarımızın içerisini
doldurmamız için metot içerikleri genişletiliyor.

Bir abstract class ile interface’den kalıtım almanın en önemli farkı şudur: kalıtım alacak sınıf birden çok interface’den
kalıtım alabiliyorken, interface gibi davranan abstract sınıflardan en çok bir kalıtım alabilmektedir.
Yani çoklu kalıtım almak istiyorsak her zaman interface’leri tercih etmeliyiz.

Abstact sınıfların bir başka özelliği ise bir abstract sınıf hem interface gibi hem de kalıtım vermeyen normal bir sınıf
gibi davranabilir.

eki nasıl oluyor?

Abstact bir sınıf içerisindeki metotlardan hangisinin başında abstract yazıyorsa o metot interface üyesi olarak varsayılırken başında abstract yazmayan metotlar normal bir sınıf üyesi gibi davranırlar ve doğal olarak interface gibi davranmasını istediğimiz metotlar yalnızca gövde yapısındayken normal metot yapısında çalışan metotların içine istediğimiz kodları yazabiliriz.

Gelelim pratik bir örneğe…

“Tavsan” adında bir abstract sınıf oluşturalım ve içerisine abstract olan “koş”, abstract olmayan “zıpla” isimli iki metot ve tipi (string,int) önemli olmayan abstract olan ve olmayan renk ve yaş property’leri ekleyelim:

Şimdi de “Pamuk” adında bir sınıf oluşturalım ve abstract olan tavşan sınıfımızdan kalıtım alalım:

Dikkat ederseniz kalıtım aldıktan sonra yalnızca interface gibi davranan “koş” metodumuzun gövdesi “Pamuk” isimli sınıfımızın içerisinde dolduruldu.Interace gibi davranmayan “zıpla” isimli metodumuz ise aslında bir yere kaybolmadı,arka planda bizi bekliyor.

“Pamuk” isimli metodumuzdan instance alıyoruz:

Gördüğünüz gibi soyut sınıfında oluşturduğumuz metotların ikiside geldi ancak aralarındaki tek fark; interface gibi davranan metodun ne yapacağı “normal” isimli metotta “Pamuk” isimli sınıfta  belirlenirken diğeri Abstract isimli sınıfımızda baştan belirlendi.

C# Virtual ve Override Kullanımı

Merhaba Arkadaşlar,

Bugünkü konumuzda Virtual ve Override Kullanımı ile ilgili bir çrnek yapmaya çalışacağım.

Öncelikle virtual anahtar kelimesini inceleyelim; virtual sözcüğü Türkçe’ye çevrildiğinde “sanal” anlamına gelmektedir ve bir sınıfın metodunu sanallaştırarak daha sonra o sınıftan alınacak kalıtım ile metodun içeriğinde değişiklikler yapılarak yeniden kullanılmasına izin verir.

Override sözcüğü ise tam olarak Türkçe’ye çevirilemesinde bazı programcılar “ezmek,büzmek” anlamında kullanırlar.

Visual Studio’yu açalım ve C# programlama dilinde yeni bir Windows Form projesi oluşturduktan sonra “Hesaplamalar” isimli bir sınıf oluşturalım:

Bu sınıfın içerisine “Hesapla” adında virtual bir metot yazalım ve bizden iki sayı istesin ve geriye ondalık sayılar döndürmesi için double değişken değeri döndürtelim.

Hesaplamalar isimli sınıf henüz bir anlam ifade etmediği için hesapla metodunun içerisini boş bıraktık ve herhangi bir matematiksel işlem yaptırmadan sıfır döndürsün istedik,buradaki amacımız bu sınıfın kalıtım verdikten sonra bu metodu yeniden yapılandırmak olacak.
Şimdi bu metodumuzu test edebilmek için formumuza bir buton ve 2 textbox ekliyoruz:

Kullanıcı 2 sayı girecek ve metodumuz girilen sayılara göre hareket edecek,o yüzden kullanıcının butona tıklaması gerektiği için butonumuzun click eventine geçiyor ve “Hesaplamalar” sınıfımızdan instance (örnek kopya) alıyor ve MessageBox.Show() ile sınıfımızın döndüreceği sayısal değeri ekranda göstereceğiz.

Sıra geldik “Topla” isimli bir sınıf yaratmaya,bu sınıfımız “Hesaplamalar” sınıfından kalıtım alsın:

Aldığımız bu kalıtım sayesinde Topla isimli sınıfımız hesapla metodunu da devralmış oldu,yani üst sınıftaki metodu bu sınıftada kullabiliyoruz ancak hesaplamalar sınıfındaki hesapla metodumuz hiçbir işlem yapmadan sıfır döndürdüğü için burada iki sayıyı toplamasını istiyoruz.

Bunun için metodumuzun adını ve parametrelerini bire bir aynı yazıyor ve override sözcüğünü yanına ekliyoruz:

Bu sayede hesaplamalar üst sınıfındaki metodun içeriğini değiştirmiş olduk ve kendisine toplama fonksiyonu vermiş
olduk.Şimdi bu topla sınıfımızdan form üzerinde instance alarak yeniden kullanalım:

Gördüğünüz gibi hesaplamalar sınıfındaki hesapla metodu sıfır döndürürken aynı metodu kalıtım alan topla sınıfında
yeniden yapılandırarak toplama yapmasını sağladık,işte bu olaya metotların kalıtım alarak yeniden yapılandırılması ya da
sık olarak söylendiği gibi  “ezilmesi” diyoruz.

Şimdi ise ”Çarpma” işlemi için bir sınıf oluşturalım ve aynı şeyleri yapalım.

Şimdi bu carpmasınıfımızdan form üzerinde instance alarak yeniden kullanalım:

Virtual ve override konusunda dikkat etmemiz gereken iki nokta var; birincisi bir metodun kalıtım alınarak yeniden yapılandırılabilmesi için adının,dönüş tipinin (int,string gibi) ve parametrelerinin bire bir aynı olması gerekmektedir.

Bir diğer dikkat etmemiz gereken ise daha sonra override edilmeyecek metotlarımızı gereksiz yere virtual ile sanallaştırarak performans düşüşü yaşayabileceğimizi göz önünde bulundurmalıyız.Yani yok yere virtual işaretleme yapmamalıyız.

C# İnterface ve multi interface kullanımı

Merhaba Arkadaşlar,
C# OOP kullanımın bir güzelliği ile yine beraberiz.
Daha önce inheritance (kalıtım, miras) almayı görmüştük.
inheritance bize güzel bir kolaylık getirmişti. Ama bir sınıf ancak bir adet miras alabiliyordu. (insan:Canlı) yani şu şekilde bir yapı yoktu; Öğrenci:İnsan:Canlı
İşte tamda bu noktada C# ın yazılımcı abileri “İnterface” diye bir yapı ile bunu çözmüşler. İnterface türkçe kelime anlamı “Arayüz” olsa da gözümüzde canlandığı gibi  değişik ekranlarla karşılaşmayacağız.
Bu yapıda miras alırken istediğimiz kadar miras alabileceğiz.

Interface, kendisinden kalıtım alacak bir sınıfın ana hatlarını belirler.
Örneğin bir sınıfın içerisinde property’ler,metotlar vs. yer alacaksa bunları sınıfın içine yazmak yerine interface denilen yapıya yazar ve bu interface’den defalarca istediğimiz sayıda sınıfa kalıtım vererek ana hatlarını belirleriz.

Az öncede dediğim gibi interface, kendisinden kalıtım alacak olan sınıfların ana hatlarını içerir ancak interface içerisine örneğin metodun ne yapacağı yazılmaz.Yani detaycı bir yapı değildir.

Gelin şimdi Visual Studio’yu açalım ve interface konusunu biraz inceleyelim.
Bilgisayar üzerine bir proje yapalım ve konumuza “Bilgisayar” adında bir içi boş class ile başlayalım.

Şimdi bir bilgiyarın parçalarını düşünelim; İşlemci, ram, hdd, ekran kartı, ses kartı, Anakar vb. bir sürü parça bulunmaktadır.
Şimdi bu parçaların hepsini ayrı ayrı sınıflarla tanımlarsak “Bilgisayar” classımızda bu özelliklerin hepsini içeren sınıfları miras alamayız.
ama bunun yerine bu parçaları İnterface  olarak tanımlarsak?
O halde her bileşeni birer interface olarak kullanarak kalıtım alabilmek oldukça akıllıca olacaktır.

Interface’ler konusunda bilmemiz gereken ilk genel kültür konusu ise interfacelerin adının başına “I” büyük harfle  konulması gerektiğidir.Böylece Solution Explorer penceresinden bir dosyanın interface’mi yoksa class’mı olduğunu kolaylıkla alyabiliriz,bunu yapmakta zorunlu degiliz ama büyük çaplı projelerde işimize yarar.

İlk önce islemci adında public erişim belirleyicisi ile bir interface tanımlayım ve içini biraz dolduralım.

Çok basit bir manada bir interface oluşturduk ve bu interface’imiz görüldüğü gibi üç property ve bir de metot
içeriyor..Şimdi gelelim oluşturulan bir interface nasıl kullanılır görelim…

Bilgisayar classımıza geri dönüyoruz ve tıpkı daha önce öğrendiğimiz gibi sınıfımızın adının yanın iki nokta ile
interface’imizin adını yazıyoruz:

Ardından Visual Studio bize implicitly (doğrudan) mi yoksa klasik kodlama(implement) mı kalıtım alacağımızı soruyor.Bu şu demektir: işlemci interface’inden alacağımız kalıtım ile sınıfımıza gelecek olan property ve metot gibi üyelerin nereden geldiğini detaylı olup olmayacağını soruyor.Daha sade bir anlatımla her üye hangi interface’den geliyorsa başına o interface’in yolunu ve adını yazar.

Bu örneğimizde gerek duymadığımız için klasik seçeneğini  seçtikten sonra sınıfımızın property ve metotları şu şekilde geliyor:

Metotlara bakarsak sanki elle yazmış gibi otomatik bir şekilde gayet güzel geliyor ancak property’ler o kadar basit
bir şekilde gelmiyor ve Visual Studio diyor ki;

Nasıl ki interface’den gelen metodun içi boş geliyor ve içeriğini istediğin gibi yazıyorsan, interface’den gelen
property’leri de aynen o şekilde kullan..
Bu yüzden her property ve metodun içeriğinde başlangıç olarak Throw new NotImplementedException (kodlanmamış yeni bir istisnai durum yürüt – göz göre göre hata ver ki yazılımcı eksik kod yazdığının farkına varsın.

Tam da böyle bir cümlenin ardından field (alan) adında yeni bir kavramla karşılaşıyoruz.Field denen küçük yapıyı global
bir değişken olarak düşünebilirsiniz ve field’ler property’lerin kendilerine anlam kattıkları nesnelerdir.

Örneğin işlemciminizin hızını nasıl double cinsinde gösteriyorsak hemen double tipinde bir field oluşturalım:

Bu field’in başına public gibi erişim belirleyicisi koymadık çünkü bu sınıf dışında dışarıdan bu field’e erişmek için yine double tipindeki işlemci hızı property’sini kullanacağız.O yüzden field’lerin genel yazılım kodlama standartlarındaki
yeri property’ninkiyle oldukça yakın durur.

Şimdi islemcihızı isimli property’mize odaklanıyor ve get ile set adında iki yeni daha kavram görüyoruz:

Get’in Türkçe karşılığı (elde etmek), set’in Türkçe karşılığı ise (ayarlamak,tanımlamak,kurmak) şeklindedir.Get o property’den dışarıya vermek istediğimiz değeri temsil ederken, set ise o property’nin alacağı değeri temsil eder.Yani get ve set bir property’nin değer alıp verebilmesini sağlar.

İşlemcihizi property’mizin get bloğuna _hiz isimli field’ımızı tanımlıyor ve return sözcüğüyle geri döndürüyoruz.Aslında demek istediğimiz olay şudur:bu metot _hiz isimli field’in değerini geri döndürür.

Set bloğuna ise _hiz field’ımıza dışarıdan bir değer (value) yüklenebilmesini istiyoruz:

Bir property’nin get ve set kısımları oldukça esnek oldukları için istediğiniz gibi kullanabilirsiniz.Mesela hızın _hiz*10 ile
10 katını get bloğunda return diyerek geri döndürebildiğiniz gibi set bloğunu kaldırarak _hiz field’ına bir değerin verilmesini engelleyebilirsiniz.

Bir sınıf birden çok interface’den kalıtım alabilir ve aldığı her interface’den gelen property ve metotları bünyesinde barındırabilir.Bu sayede tek bir sınıftan kalıtım alabilmenin ötesine geçer..
Şimdi Ram isimli bir interface daha oluşturuyor ve içerisine bellek boyutu ile bellek tut isimli birer property ve metot yazıyoruz:

ve birde Hard disk için bir interface oluşturalım.

Şimdi “Bilgisayar” sınıfımıza gidelim ve bütün bu interfaceler den hep beraber kalıtım alalım (MULTİ İNTERFACE)

ilk başta islemci interface den kalıtım aldığımızda olduğu gibi ram ve hdd interface ileri içinde property ve metotlar yine sınıfımızın içerisine gelecektir.

Gördüğünüz gibi interface’ler içerisine ne yazdıysak hepsi birer birer tek sınıf altında gayet güzel bir şekilde geldi,biz de bu üyelere değerler verelim ve metotlarını da formumuzun load ında  çağıralım:

Olay budur.
Saygıılar.

C# Inheritance (kalıtım) Nedir ve Nasıl Kullanılır?

Merhaba Arkadaşlar,

Bir perşembe akşamı işten  yorgun argın geldim ama  “Eğitime devam” 🙂
Bugünkü konumuza object oriented programming (OOP) olmazsa olmazlarından inheritance (kalıtım) konusuna değineceğiz.
Nedir bu inheritance?
Türkçe de buna anlayacağımız dilde “Miras alma” diyebiliriz. Yani babanızdan veya dedenizden miras aldığınızı düşünün. Ama şunu da unutmak gerek babadan miras alan babaya miras veremez:)

Inheritance; bir sınıfın kendi özellikleri ve metotlarının yanı sıra kalıtım aldığı base (taban-kalıtım veren) sınıfın özellik ve metotlarına da sahip olabilmesidir,ancak kalıtım alan sınıf herhangi bir özellik veya metoda sahip olmasa da olur yeter ki üst sınıftan birşeyleri kalıtım alsın.

Hiç zaman kaybetmeden örnekler üzerinden ilerleyelim ve Visual Studio’yu açıp C# programlama dilinde yeni bir Windows Form uygulaması oluşturalım ve “İnsan” adında public bir sınıf
oluşturalım. Aynı zamanda bu sınıfın propertylerini insan özelliklerine göre verelim.

“Insan” isimli sınıfımıza gerçek bir insana ait olabilecek temel özellikleri property ve metotlar halinde yazdık.Şimdi bu sınıfımızdan new anahtar sözcüğüyle formumuzun load eventinde instance alalım ve sınıfımızın üyelerini çağıralım:

Şimdide “Öğrenci” isimli bir sınıf oluşturalım ancak bu defa bir insana ait olabilecek özellikler dışında okul, bölüm vb. bilgilerle  sınıf oluşturalım:

Yeni oluşturduğumuz “Öğrenci” classını da Formumuzun load ında çağıralım(instance  alalım) ;

Şimdi diyoruz ki öğrencide sonuçta bir insan ve bu öğrencininde bir ad, soyad ve yaşı bilgisi var?
Ee ne yapalım şimdi aynı parametreleri(property ve metotları )birde “Öğrenci” classında oluşturarak gereksiz bir kalabalık mı yapalım?

HAYIR HAYIR HAYIR!!!

Bu özellikleri yeniden yazmak yerine “Insan” isimli base sınıfımızdan kalıtım alarak insani özellikleri devralacağız yani; İnsan sınıfından “Miras” alacağızçBunun için sınıfımızın adının yanına iki nokta (:) koyarak kalıtım almak istediğimiz sınıfın adını yazıyoruz:

Ogrenci isimli sınıfımız artık derived (kalıtım alan) class,Insan isimli sınıfımız ise base class (kalıtım veren) sınıf olduğuna göre ogrenci sınıfımızdan oluşturduğumuz instance’a nokta koyarak insan özelliklerini de devraldığını görüyoruz:

Inheritance konusuyla ilgili bilmemiz gereken noktalardan birisi kalıtım alan bir sınıf yalnızca bir defalığına kalıtım alır ve Base classa kalıtım veremez.

Yararı olması dileğiyle.

C# Static Sınıflar ve Üyeler

Merhaba Arkadaşlar,
Bugünkü konumuzda ise static anahtarı sözcüğü ile bir kaç örnekle “Static sınıf nedir? Static üye nedi? nasıl çağrılır? Avantaj ve dezavantajları nedir?” bilgilerine yönelik paylaşım yapmayı planlıyorum.

Öncelikle “static” sözcüğünden bahsetmek istiyorum;
.Net Framework mimarisi üzerine kurulu sınıflar,metotlar,yapılar ve daha birçok konu barındırmaktadır.Henüz birçoğunun ismini saymadığım halde gelen bu kod yapılarının bazıları sürekli RAMbellekte bazıları ise yeri geldiğinde RAM belleğe yazılır ve işleri bittiğinde bellekten silinirler.

Bellekte sürekli kalan kod yapılarına static diyoruz.
Static olarak tanımlanan nesneler bilgisayarımızın belleğinde program kapatılıncaya kadar sabit bir şekilde kalırlar ve bunlar bir sınıfın propertyleri gibi değer
alabiliyorlarsa üzerlerine yeni değer yazılana kadar hep öyle kalırlar.

Static olarak tanımlanan nesneler bilgisayar belleğinde sürekli kaldığı için belli bir RAM tüketirler ancak en büyük avantajları ise new instance almadan anlık bir biçimde erişilebilme ve kullanılabilme şansı tanırlar.

Static anahtar sözcüğüyle tanımlanan nesnelerden en başta olanlar ise classlardır.
*/Static tanımlanan bir sınıfın içerisindeki metotlar,propertyler,fieldler vs. her şey yine static sözcüğüyle belirtilmek zorundadır.

*/Static olmayan bir sınıfta  nesnelerin hepsi static olmak zorunda değildir.

Visual Studio’yu açıyor ve C# dilinde yeni bir Windows Form projesi oluşturduktan sonra projemize “Insan” adında yeni bir sınıf ekliyoruz:

Insan sınıfımız şimdilik static yapıda olmasın ancak sınıfımızın içine “Gul” isimli static bir metot yazalım:

Dikkat ederseniz sınıfın kendisi static tanımlı değil ancak içerisindeki metot static yapıdadır.Bu bize ne kazandıracak derseniz şimdi projemizin formuna gidiyor ve Form_Load metodu içerisine sınıfımızın adını yazıyor ardından nokta tuşuna basarak metodumuza ulaşıyoruz:

Gördüğünüz gibi sınıfımız için new anahtar sözcüğü olmadan yaniinstance oluşturmadan doğrudan sınıfın içersindeki elemana ulaştık.

Sınıfımıza tekrar geri dönelim ve bu kezde “Isim” adında static bir property oluşturalım:

Tekrar formun load eventine gidiyor ve insan class’ının isim property’sine değer veriyoruz:

Artık bu değer program kapatılıncaya ya da tekrar değer verilinceye kadar hep bilgisayar belleğinde sabit bir şekilde kalacak ama sınıftan instance almaya gerek kalmadan çok kolay bir şekilde bu property’nin değerine ulaşabileceğiz.

Static kavramı ile bilmemiz gereken önemli bir nokta ise,eğer static olmayan (bu örnekteki gibi) bir sınıfın içerisindeki nesne (property,metod vs) static olarak tanımlanmazsa o nesneye sadece instance alınarak ulaşılabilir.
Bu savı doğrulamak için yine Insan sınıfının içerisine bu defa static olmayan “Kos” isimli bir metot yazalım:

Tekrar formun load eventine dönelim ve sınıf adını yazarak “Kos” metoduna erişmeye çalışalım ve hata aldığımız görelim.

Gördüğünüz gibi static olmayan sınıfımızın içerisindeki metodumuz static olmadığı için ulaşamıyoruz,eğer ulaşmak istersek instance alarak ulaşmamız gerekmektedir.
Çünkü bu sınıf static değil ve bu metot da static değildir. Yani RAm de yer kaplamıyor ve yeri hazır değildir.

Ayrıca static olmayan bir sınıfta static olan nesneleri  instance alarak çağırmak istesek bu nesnleler static olmayan bir sınıfta olduğu halde instance alarak çağıramayacağızdır.

Yararlı olması dileğiyle.

C# Constructor (Yapıcı-Kurucu) Metotlar

Merhaba,

Yapıcı metotlardan kısaca bahsedersek; static olmayan bir sınıf içerisindeki property’lere (özelliklere) sınıfıninstance (örnek kopyası) alımı esnasında değerler verme işlemidir.Bu metotlar tıpkı void metodu gibi çalışır ve geriye herhangi bir tipte (int,string..) değer döndürmezler ancak bu metodun bir adı da olmaz çünkü yapıcı metotlar sınıfın birebir kendi adıyla yazılmak zorundadırlar.

Örneklerle ilerlemek gerekirse;

Visual Studio’yu açarak yeni bir Windows Form projesi oluşturalım ve “Bilgisayar” adında yeni bir sınıf yazalım:

Aşağıdaki ekran görüntülerinde sol tarafta sınıfımızı oluşturduk, sağ tarafta ise bu sınıfımızdan formumuzun Form_Load metoduna bir instance aldım ve property’lere tek tek
değerler verdim;

şimdi tekrar bilgisayar classına geri dönelim ve constructor metot yazalım.Hatırlarsanız constructor metotlar içinde bulunduğu sınıfın adını alır demiştik ve bu metotların parametreleri olur.
Constructor metotların parametreleri, içinde bulunduğu sınıfın hangi property’lerine değerler atamak istiyorsak o şekilde yazılırlar ve varsayılan olarak sınıfımızdaki tüm property’lere yapıcı metodumuz
üzerinden değerler vereceğiz:

Aşağıdaki görüldüğü gibi sınıfımız içerisinde oluşturduğumuz Constructor metota değer  girilmesini zorunlu hale getirdk ve formumuzda hataları gördük, Sınıfımızdan instance alırken bizden parametre istiyor, o halde sınıfımızın üyelerine vermek istediğimiz değerleri parametreler halinde veriyoruz:

Yapıcı metodumuzun parametrelerini sınıfın property leri ile  eşleştirdiğimizde ise sorun ortadan gidecektir.

İşte bu şekilde sınıfın instance alındığı esnada sınıf özelliklerine değer vermemizi sağlayan metotlara yapıcı-kurucu metotlar diyoruz.
İçerisinde bu örneğimizdeki gibi içerisinde tek başına constructor metot içeren sınıflar “new” sözcüğüyle instance alınırken daha önce öğrendiğimiz property’lere tek tek değerler vermemizi sağlayan

Bilgisayar bilgisayar=new Bilgisayar();
blg.Marka=”Hp”;

gibi yapıya izin vermemektedir.Bunun sebebi yapıcı metodun parametrelerini boş geçememizden kaynaklanmaktadır.
Eğer parametreleri doğru girdikten sonra instance aldığımız değişkene yukarıdaki gibi tekrar property’lere tek tek değerler atayabiliriz ancak aynı özelliklere aynı değerleri tekrar yazmak hem zahmetli hem de gereksiz bir işlem olacaktır.
O yüzden boş constructor metot kavramını da bilmemiz gerekiyor.

Boş yapıcı metotlar, ilgili sınıfın hem constructor metodu ile hem de daha önce öğrendiğimiz klasik bir biçimde sınıfın property’lerine tek tek değerler vermemize olanak sağlayan metotdur.Normal bir yapıcı metot gibi sınıfın ismini alırlar ancak parametreleri ve içeriğinde herhangi bir kod yoktur,böylece sınıfın instance’ını alırken parametre girme zorunluluğu ortadan kalkmaktadır.
Örneğimize uygularsak Bilgisayar classı içerisinde boş yapıcı metodumuzu yazalım:

Gördüğünüz gibi artık sınıfın property’lerine her iki şekilde de değerler verebiliyoruz.

C# IsNullOrEmpty Metodu Kullanımı

Merhaba,
Bu metot sayesinde parametre olarak verien string tipindeki değilkenin boş olup olmadığını kontrol etmektedir.

Eğer değişkenin içeriği boşsa geriye bool türünde false değeri
döndürür. Eğer değişkene herhangi bir değer ataması yapılmışsa geriye true değerini
döndürür.
Kullanımı aşağıdaki gibidir;

veya;

bool kontrol=String.IsNullOrEmpty(deger);

C# Erişim Belirleyiciler – Access Modifiers

Merhaba,

Öncelikle erişim belirleyicilerin (access modifiers) nerelere uygulandığını bilmemiz lazım; C# projesinde tanımlanmış tüm varlıklara uygulanabilir, buna class, struct, function, method, property ve class seviyesindeki tüm değişkenler dahildir.

Uygulamamızda kullandığımız varlıkların bulundukları kod bloğunun dışından erişilip/erişilemeyeceğini belirlemek isteriz bunun içinde ”Erişim Belirleyicileri” ni kullanırız.
PUBLİC:
Örneğin oturduğumuz apartmanda farklı farklı daireler bulunmaktadır. Her daireyi bir class olduğunu  düşünelim;
Evimizin kapısından içeri herkesin girmesini ve içerdeki herşeye müdahale edebilmesini istiyorsak anahtarımızı bir yedeğini herkese vermeliyiz yani anahtarımızı PUBLİC olarak tanımlamalıyız.

Aşağıdaki ekran görüntülerinde görüleceği gibi bir “erisimbelirleyiciler.cs” diye sınıf oluşturdum.
Bu sınıf  içerisindeki bir metot ve property tanımladım. Bunların hepsi ”Public” olarak tanımlandı.
Public anahtarı ile form load ından bu sınıf ve içerisindeki nesnelere erişim yapıldığı görülmektedir.

PROTECTED:

protected olarak tanımlanan öğe, sadece tanımlandığı class’ın içinde ve o class’tan türetilmiş diğer class’ların içinde erişilebilirdir.
Yani bu class sadece evimize girmeyi ve evimizin içindeki odaların kapısını açmaya yarar aynı zamanda diğer daireler ile evimizin bir bağlantısı varsa ise o dairelerin kapısınıda açar.

Şimdi “erisimbelirleyiciler” class ımızda PROTECTED olara bir int sayi tanımlayalım ve bunu fprm loadıda göremediğimiz görelim.

İNTERNAL:

internal olarak tanımlanan öğe, bulunduğu assembly’nin (Dll veya Exe dosyası) içinde erişilebilirdir. Dll veya Exe dosyasının içerisinde erişim için kısıtlama yoktur, ama dışarıdan erişilemez.

PROTECTED INTERNAL:

protected internal erişim belirleyicisi, protected ve internal erişim belirleyicilerinin VEYA (OR) işlemiyle birleştirilmiş halidir. protected internal olarak tanımlanmış öğe, tanımlandığı class’ın içinde ve o class’tan türetilmiş diğer class’ların içinde erişilebilir. Ayrıca, aynı assembly içinde olmasalar dahi, tanımlandığı class’tan türetilmiş diğer class’ların içinde de erişilebilirdir.

PRİVATE:

private olarak tanımlanan öğe, sadece tanımlandığı class’ın içerisinde erişilebilirdir. En katı erişim belirleyicidir. Yani eivimize bizden başka kimse giremez diyebiliriz, bize özel alandır, dışardan müdahale edilemez.

C# Kare, Dikdörtgen, Üçgen Alan hesapla(OOP)

Merhaba Arkadaşlar,

Şimdiki konumuzda ise C# OOP abstract class ile  Kare, Dikdörtgen, Üçgen gibi Geometik ifadelerin alanlarını basit bir yol ile hesaplayacağız.

C# TextBox’a Sadece Sayi Girilmesini Saglamak

Merhaba Arkadaşlar,
Bu istek bir çok karşımıza çıkabilir ve işimize yarayabilir.

İlgili  Textbox’in Keypress Event’ine aşağıdaki  kodlari yazarsanız, kullanıcının textbox’a sadece sayı girmesini sağlamış olursunuz.

Textbox’in Keypress Event’ine girdikten sonra aşağıdaki kodları yazmamış yeterli olacaktır.

private void textbin_KeyPress(object sender, KeyPressEventArgs e)
{
if (char.IsLetter(e.KeyChar) || char.IsSymbol(e.KeyChar) || char.IsWhiteSpace(e.KeyChar) || char.IsPunctuation(e.KeyChar))
{
e.Handled = true;
}