"Enter"a basıp içeriğe geçin

Turkcell C# Eğitim Notları

Turkcell’in C# eğitimini tamamlarken aldığım notları aşağıda bulabilirsiniz. Notları sadece başlıkları hatırlatması ve eğitime yardımcı olması için almıştım. Daha detaylı bilgileri almak için her başlığın sonuna eklediğim kaynağı ziyaret edip okumanızı tavsiye ederim.

Eğitim linki https://gelecegiyazanlar.turkcell.com.tr/konu/c-sharp

C# Dilinin Tarihçesi

CLR

.NET altyapısında programların çalışmasını denetleyen, programın işletim sistemiyle haberleşmesini sağlayan birimdir.

Buna göre; C# program kodu MSIL Assembly’e, Assembly’i de CLR çalıştırılabilir bir makine koduna dönüştürür. Bu .NET programlarının derlenip çalıştırılma mantığıdır.

Yazılan programın her işletim sisteminde (Windows, Linux, MacOS) çalışmasını sağlamak görevi CLR’e düşer.bu nedenle de clr platform spesifik olmak durumundadır.1)https://tr.wikipedia.org/wiki/Ortak_Dil_%C3%87al%C4%B1%C5%9Fma_Platformu

Managed Code ve Unmanaged Code

CLR kontrolünde çalışan kodlara managed code denir. Unmanaged code ile makine diline direk erişim sağlanabilmesi mümkün iken Managed Code ile bu erişim aradaki katmanın CLR’ın size sağladığı sınırlar dahilinde gerçekleşebiliyor.2)https://www.mshowto.org/managed-code-ve-unmanaged-code-nedir-yonetilen-ve-yonetilemeyen-yazilim-dilleri.html

Generics

Generic’ler tasarlandığımız interface, class, metod yada parametrelerin (argümanların) belirli bir tip için değil bir şablon yapısına uyan her tip için çalışmasını sağlayan bir yapıdır.3)http://www.kazimcesur.com/c-generics/

Partial Class

Büyük projelerde oluşturduğumuz class’ lar zamanla okunması zor hale gelebilecek uzunlukta kod satırları ile dolabilmektedir. Partial class bize bir class’ ı birden fazla class olarak bölmemize, constructor, değişken, property, metodları vs. düzenli bir şekilde ayrı ayrı oluşturmamızı sağlamaktadır. Fiziksel olarak birden fazla parça ile oluşan partial class’ lar, çalışma zamanında tek bir class olarak bütün elemanları içerisinde barındırmaktadır.4)https://cemelma.wordpress.com/2015/07/07/c-partial-class-nedir/

partial class A
{
    public static void A1()
    {
        Console.WriteLine("A1");
    }
 }
partial class A
{
    public static void A2()
    {
        Console.WriteLine("A2");
    }
}
//Kullanımı
class Program
{
    static void Main()
    {
    A.A1();
    A.A2();
    }
}

Delegates

Delegeleri metodların referanslarını tutan akıllı konteynırlar olarak tanımlayabiliriz. Delegeler bir yada birden çok metodun referansını içerebilmektedir.

public delegate void MyDelegate(string myString);
//Register edilebilecek method
private void MyMethod(string someString) 
{
   // method gövdesi (body)
}
// Delegate instanceı oluşturup referans edilecek metod register edilmesi.
MyDelegate del = new MyDelegate(MyMethod);
// Aynı delege instance'ına ikinci bir metodun referansının register edilmesi.
del += new MyDelegate(MyOtherMethod);

del("delegeye register olan tüm metodlar invoke edilsin");

Önemli bir nokta ise delegeler .NET component’lerinin yazmış olduğunuz kodları çağırmasını sağlar, .Net component’leri metod signature (dönüş tipi ve aldığı argümanlar) dışında yazdığınız kod ile ilgili bişey bilmezler.5)http://www.kazimcesur.com/delegates-anonymous-methods-lambda-expressions-delegeler-anonimisimsiz-metodlar-lambda-ifadeleri/

Anonymous Methods

Anonim metodlar delegeler gibi bir metodun referansını tutmak yerine kod içerisinde metod varmış gibi kod bloğu yazmamızı sağlar. Ancak anonim metodların normal metodlardan en büyük farkı kullanıldıkları kod bloğu dışarısından erişilememeleridir.6)http://www.kazimcesur.com/delegates-anonymous-methods-lambda-expressions-delegeler-anonimisimsiz-metodlar-lambda-ifadeleri/

class Test
{
    delegate void TestDelegate(string s);
    static void M(string s)
    {
        Console.WriteLine(s);
    }
 
    static void Main(string[] args)
    {
        // Normal delege ile metoda referans
        TestDelegate testDelA = new TestDelegate(M);
         
        // String argüman alan ve anonim olan metod tanımı.
        // Aşağıdaki satıra dikkat edildiğinde referans edilen herhangi bir metod yoktur. 
        // Metod varmış gibi kod yazılıp daha sonra bu metoda erişim sağlanmıştır.
        TestDelegate testDelB = delegate(string s) { Console.WriteLine(s); };
 
        // delegeleri invoke edelim
        testDelA("Merhaba. Ben bir degeleyim ve M metoduna referans etmekteyim.");
        testDelB("Merhaba bende anonim metodum.");
 
        Console.WriteLine("Çıkmak için herhangi bir tuşa basınız.");
        Console.ReadKey();
    }
}
/* Kod çıktısı:
    Merhaba. Ben bir degeleyim ve M metoduna referans etmekteyim.
    Merhaba bende anonim metodum.
    Çıkmak için herhangi bir tuşa basınız.
 */

Iterator ve Yield

Iteratorlar, array veya koleksiyonlar üzerinde yield keyword’ü kullanılarak içerlerindeki elemanlar üzerinde özel iterasyonlar yapmamızı sağlayan yapılardır.

Iteratorlar foreach döngüleri tarafından kullanılırlar ve işlem yaptıkları kolleksiyonlar veya arrayler içerisindeki elemanları foreach döngüsüne iletirler.

Yield return ifadesi ile iterator’a çağrı yapılan foreach döngüsüne bir eleman döndürülürken yield break ifadesi ile de artık bulunan iterator içerisindeki iterasyonun sona erdiği bilgisi iterator’ı çağıran foreach döngüsüne iletilmekte.7)https://www.ilkayilknur.com/c-iteratorsyield-keywordu-ve-arka-planda-neler-oluyor

static IEnumerable<string> GetDays()
{
 yield return "Pazartesi";
 yield return "Salı";
 yield return "Çarşamba";
 yield return "Perşembe";
 yield return "Cuma";
 yield return "Cumartesi";
 yield return "Pazar";
}

//Foreach ile kullanımı
static void Main(string[] args)
{
 foreach (string day in GetDays())
   {
 Console.WriteLine(day);             
 }
}

Nullable Types

Nullable tipler, ilgili tip‘in değer aralığına ve karakteristiğine sahip olmakla birlikte ek olarak null değer de içerebilen yapılardır.8)https://enginpolat.com/nullable-tipler/

int? adet = null;

LINQ

LINQ, koleksiyonlar, ADO.Net DataSet, XML, SQL Server, Entity Framework ve diğer veritabanları gibi farklı veri kaynağı türlerinden veri almak için oluşturulmuş bir sorgu söz dizimidir.9)https://medium.com/@hakanyalitekin/linq-nedir-f55957d5bf52

// Veri Kaynağı (Bu veri yukarıda basettiğim gibi her hangi bir yerden sağlanıyor olabilir.)
int[] sayilar = new int[] { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
// LINQ sorgusu -> QUERY SÖZ DİZİMİ
var kucukSayilar1 = from sayi in sayilar
where sayi < 5
select sayi;
//LINQ sorgusu -> METHOD SÖZ DİZİMİ (Bayılırım 🙂)
var kucukSayilar2 = sayilar.Where(x => x < 5);
// Yazılan sorguyu kullanma
foreach (int sayi in kucukSayilar1)
{
Console.WriteLine(sayi);
}

Lambda Expressions

.Net 3.0 ile gelen olan Lambda ifadeleri anonim metod, delege, fonksiyon tanımları ve expression tree tiplerini daha kısa bir biçimde tanımlamamıza yardımcı olan bir özelliktir. Tüm lambda ifadeleri => lambda operatörünü kullanır. Lambda operatörünün sol tarafı (eğer varsa) giriş parametlerini (argümanlarını) belirtir, sağ tarafı ise koşul yada kod bloklarını barındırır.10)http://www.kazimcesur.com/delegates-anonymous-methods-lambda-expressions-delegeler-anonimisimsiz-metodlar-lambda-ifadeleri/

Extension Method

Extension method bize .Net içerisinde bulunan sınıflara yeni metodlar eklememizi sağlamaktadır. Extension metodlar static class içerisinde static olarak tanımlanmaktadır.11)https://www.hikmetokumus.com/makale/24/csharp-ile-extension-metod-kullanimi

public static class ExtensionClass  
{  
    public static int IntCevir(this string Deger)  
    {  
        return Int32.Parse(Deger);  
    }  
}  

//Kullanımı
string StringSayi = "25";  
int Sayi = StringSayi.IntCevir();

Expression Tree

Expression Tree, bir çok compiler’ın çalışma mantığında geçerli olan bir kavram aslında. Kodun, ağaç gibi dallar(node) ile temsil edildiği bir veri yapısı diyebiliriz Expression Tree için. Zaten adından da anlaşılıyor. Bu dallar, koddaki her bir parçayı temsil eder. Değişken, metod çağrısı, if-then-else bloğu gibi gibi…12)https://www.minepla.net/2015/02/expression-sinifi-ile-dinamik-ifadeler/

Implicit Type

Programlarınızı yazarken bir çok kez bir tipten diğer tipe çevirim yapmışsınızdır. Data kaybı yaşanmayan çevrim Implicit, data kaybı yaşanabilecek çevrim ise Explicit olarak adlandırabiliriz.13)http://safakunel.blogspot.com/2013/12/c-implicit-explicit-conversions-kullanimi.html

Anonymous Types

C# 3.0 ile gelen bir özellik olan anonim tipler adından da anlaşılacağı üzere bir değişkenin (objenin) tipini tanımlamadan objeler oluşturmamızı sağlayan bir yapıdır. “var” ifadesi ile tip adı belirtilmeden oluşturulan objeler compiler tarafından anonim tipte oluşturulmaktadır.14)http://www.kazimcesur.com/anonymous-types-anonim-tipler/

string MyString = “Merhaba”;
var MyString = “Merhaba”;

Dynamic Types

C# bilindiği üzere sıkı tip denetimli bir dildir. Bu şu demek oluyor: Eğer bir tip derleme sırasında atandığı bir tip ile uyuşmuyorsa derleme başarısız olacak (hata verecek) demektir. Bazen derleme zamanında da değişken tipli tanımlamalara ihtiyaç olabilir. C# 4.0 bu esnekliği sağlamak için yeni bir tip eklemiştir: dynamic tipi.15)http://letsgotocoding.blogspot.com/2018/02/cta-dynamic-tipler.html

dynamic s;
s = "karakter katarı";
s = s * 2; //Çalışma zamanı hatası!! string ile int çarpılamaz!!
//Dynamic ve object arasındaki fark tip uyumsuzluğu kontrolüdür.

Console.WriteLine(obj.GetType());//int yazar

obj = obj + 1; //Derleme hatası!!! obj'nin tipini belirtmeliyiz

obj = (int)obj + 1; //Şimdi çalıştı...

Opsiyonel ve İsimlendirilmiş Parametreler

Opsiyonel parametre metoda eklendiği sırada değer verilen parametrelere denir. İsinlendirilmiş parametre metodu çağırırken verdiğimiz parametrelerin istediğimiz sırayla verilebilmesini sağlar.16)https://www.srdrylmz.com/c-opsiyonel-ve-isimlendirilmis-parametreler/

private static double SilindirHacim(int yaricap, int yukseklik, double pi = 3)
{           
    return pi*yaricap*yaricap*yukseklik;
}

static void Main(string[] args)
{
    // Hangi parametreye hangi değeri atayacağımızı açık bir şekilde belirttik.
    Console.WriteLine(SilindirHacim(yaricap: 4, pi: 3.14, yukseklik: 56));
    Console.WriteLine(SilindirHacim(yukseklik: 10, yaricap: 5, pi: 3.14));
    Console.WriteLine(SilindirHacim(yukseklik: 3, yaricap: 5));
}

Covariance ve Contravariance

Covariance ve Contravariance, birbirinden türetilmiş tiplerin kendi arasında tür dönüşümü yapılması, birbiriyle yer değiştirilebilmesi ve eşitlikleri gibi karşılaştığımız belirli durumlardır. (Örneğin array tipleri, delegate tipleri ve generic tip argumanlar) Covariance atanabilme uyumluluğunu korumamıza olanak tanırken contravarience tam tersi olarak işlev görmektedir.

covariant : Geniş türlerin (more derived) daha küçük türlere (less derived) dönüştürülmesi durumu. Matematiksel olarak <= durumu.

contravariant: Küçük türlerin (less derived) daha büyük türlere (more derived) dönüştürülmesi durumu.17)http://www.kazimcesur.com/c-covariance-ve-contravariance/

Asenkron Programlama

private async void download(string url)
{
    var down = await Downloader.DownloadString(url);
}

Caller Information

Bir metodun nereden(hangi metod tarafından) çağrıldığı bilgisine ulaşabilmemizi sağlayan yapıdır.

Herhangi bir işlem için oluşturduğumuz bir fonksiyonu projemizin çoğu yerinde çağırıp kullandığımızı farz edelim.Proje derlenip çalıştığı aşamada fornksiyonumuz içerisinde bir hata verirse eğer, nerede hata aldığımızı zor kestirebiliriz.Çünkü çoğu yerde bu fonksiyonu kullandığımızdan dolayı hangi kod dosyasında olduğunu, hangi metod da ya da hangi satırda olduğunu bulabilmek için debug modunda çalıştırıp satır satır incelemeniz gerekmektedir. İşte bu gibi durumların üstesinden rahat bir şekilde gelebilmek için Caller Informations ile fonksiyonumuzu tam olarak satır numarasından tutun dosya yoluna kadar, nereden(hangi metoddan) çağrıldığı bilsine ulaşabiliriz.18)https://www.gencayyildiz.com/blog/c-5-0-caller-information/

Roslyn

İlgili bilgileri buradan kontrol edebilirsiniz.

C# 7.0 ile gelen yenilikler

  • Tuples
  • Out Variables
  • Pattern Matching
  • Local functions
  • Literal Düzenlemleri
  • Ref returns
  • Expression Bodied Üyelerde Düzenlemeler
  • Throw expressions19)https://denizirgin.com/c-7-0-yenilikleri-28a82f758fe8

C# 8.0 ile gelen yenilikler

  • Readonly Members
  • Default Interface Methods
  • Pattern Matching
  • Using Declarations
  • Static Local Functions
  • Disposable ref Structs
  • Nullable Reference Types
  • Asynchronous Streams
  • Asynchronous Disposable
  • Indices and Ranges
  • Null-coalescing Assignment
  • Unmanaged Constructed Types
  • Stackalloc In Nested Expressions
  • Interpolated Verbatim String İyileştirmesi20)https://medium.com/bili%C5%9Fim-hareketi/c-8-yenilikleri-869f355d8dc7

C# 9.0 ile gelecek yenilikler

  • Target-type new
  • Parameter null checking
  • Target-typed conditional expressions
  • Covariant return
  • Top-level statements
  • Extending Partial Methods
  • Pattern matching improvements21)http://devnot.com/2020/c-9-ile-gelecek-yenilikler/

Değişkenler, Veri Tipleri ve İşlemler

Değişken Türleri

bool, object, var, Datetime

const double pi = 3.14159;

double alan, cevre, yaricap;

//Değişkenin türünü ekrana yazdırır
Console.WriteLine(sayi.GetType());

Değişkenlerin Tanımlanma Yerleri

//Method içinde local değişken
private void button1_Click(object sender
 EventArgs e)

{
   int i = 0;
   i = i + 1; // i++ şeklinde de yazılabilir.
}


int i = 0; // değişken, button1_Click metodu içinde değil, doğrudan Form1 sınıfının altında tanımlandı.

private void button1_Click(object sender
 EventArgs e)

{
   i = 1 + 1; // i++ şeklinde de yazılabilir.
}

//Değişkenin, tüm proje içinde geçerli olması içinse, şu şekilde bir tanımlama yapılması gerekir:
public static degiskenTipi degiskenAdi 

Structurelar

Structure (Yapı) veri türü, farklı tiplerden değişken tiplerini bir çatı altında toplayarak, gruplandırmayı sağlayan bir veri türü yapısıdır.22)https://gelecegiyazanlar.turkcell.com.tr/konu/c-sharp/egitim/c-101/structure-yapi-olusturmak-ve-kullanmak

struct otomobil
{
   public string model;
   public int motorHacmi;
   public bool otomatikVites;
   public string renk;
}

bmw otomobil = new otomobil();
bmw.model = "Tourer";
bmw.motorHacmi = 2000;
bmw.otomatikVites = true;
bmw.renk = "Gümüş";

Kısa Devre Operatörler

Kısa devre operatörleri, normal VE (&) ve VEYA (|) operatörlerinden biraz daha farklı çalışır. Normal operatörlerin kullanıldığı bir deyimde, ilk operandın sonucu ne olursa olsun diğer operandlar da kontrol edilir. Örneğin, normal VE operatörüyle yapılan bir işlemde, ilk operandın sonucu yanlış (false) ise, ikinci operandın sonucu ne olursa olsun, sonuç yanlış (false) olacaktır. Aynı şekilde, VEYA (|) operatörü kullanıldığında, ilk operandın sonucu doğru (true) ise, ikinci operandın sonucu ne olursa olsun, sonuç doğru (true) olacaktır. Bu iki durumda da, ikinci operandın kontrol edilmesi gereksizdir, ancak normal operatörlerde bu kontrol yapılır. Kısa devre operatörleri (&& ile ||) kullanıldığında ise, ilk operandla alınan sonuca bağlı olarak, ikinci operand kontrol edilmez. Kısa devre VE (&&) işleminde ilk operandın yanlış (false), kısa devre VEYA (||) işleminde ilk operandın doğru (true) olması durumunda ikinci operand kontrol edilmez. Bu, performans artışı sağlayacağı gibi, bazı istisnai durumlarda programın hata vermesini de engeller.23)https://gelecegiyazanlar.turkcell.com.tr/konu/c-sharp/egitim/c-101/kontrol-yapilari

If Kullanımı

byte ay = Convert.ToByte(Console.ReadLine());
 
if (ay == 1)
Console.WriteLine("Ocak");
else if (ay == 2)
Console.WriteLine("Şubat");
else if (ay == 3)
Console.WriteLine("Mart");
else if (ay == 4)
Console.WriteLine("Nisan");
else if (ay == 5)
Console.WriteLine("Mayıs");
else if (ay == 6)
Console.WriteLine("Haziran");
else if (ay == 7)
Console.WriteLine("Temmuz");
else if (ay == 8)
Console.WriteLine("Ağustos");
else if (ay == 9)
Console.WriteLine("Eylül");
else if (ay == 10)
Console.WriteLine("Ekim");
else if (ay == 11)
Console.WriteLine("Kasım");
else if (ay == 12)
Console.WriteLine("Aralık");
else
Console.WriteLine("1-12 arası sayı girmelisiniz");

switch Kullanımı

switch (değişken)
{
    case 1:
        //yapılacak işler
    break;
    case 2:
        //yapılacak işler
    break;
    case 3:
        //yapılacak işler
    break;
    default:
        //yapılacak işler;
    break;
}

for Kullanımı

int toplam = 0;
 
for (int i = 0; i < 100; i++)
{
    toplam += i;
}
 
Console.WriteLine(toplam);

while Kullanımı

int toplam = 0;
int i = 0;
 
while (i < 100)
{
    toplam += i;
    i++;
}
 
Console.WriteLine(toplam);

do…while Kullanımı

int toplam = 0;
int sayac = 0;
 
do
{
    sayac++;
    toplam += sayac;
}
while (sayac < 100);
 
Console.WriteLine("Toplam: " + toplam.ToString() + ",Sayaç: " + sayac.ToString());

foreach Kullanımı

int[] sayilar = { 1, 2, 3, 4, 5, 6 };

int carpim = 1;
foreach (int x in sayilar){
    carpim = carpim*x;
}

Diziler

tip diziismi = new tip[elemansayisi];

int[] sayilar = new int[5];

sayilar[3] = 99;

//Bir diziyi tanımlarken, aynı zamanda elemanlarına ilk değerleri de verebilirsiniz:
short[] futbolTakimi = {1, 4, 5, 2, 8, 12, 19, 99, 22, 10, 11};

//Length: Bu metot, dizideki toplam eleman sayısını döndürür.
Console.WriteLine(isimler.Length);

//Clear: Bu metot, içine parametreler alarak, dizinin belirtilen alanındaki değerleri temizler. İlk parametre, dizinin kendisidir. İkinci parametre, silme işleminin dizinin hangi indeks’inden başlayarak gerçekleştirileceğidir. Üçüncü parametre toplamda //kaç eleman silineceğinin belirtildiği alandır. İkinci ve üçüncü parametreler tamsayı(int) olarak atanmalıdır.

int[] dizi = {50, 63, 64, 75};
 
//1. elemandan itibaren (63) siler
Array.Clear(dizi, 1, 2);
 
// Dizideki tüm elemanları siler
Array.Clear(dizi, 0, dizi.Length);

//Reverse: Bu metot, dizi elemanlarının sıralamasını indeks sırasına göre tersine çevirir.
Array.Reverse(harfler);

//Sort: Bu metot, dizi elemanlarını dizinin tipine bağlı olarak sıralar. Dizi metinsel ise alfabetik olarak, numerik ise rakamların büyüklüğüne göre sıralama yapılır.
string [] harfler = {"C","B","A"};
Array.Sort(harfler);
Console.WriteLine(harfler[2]);

//IndexOf : Bu metot, dizi içindeki bir elemanın indeksini döndürür.
decimal[] sonuclar = { 78, 99, 100, 12 };
decimal maksimum = 100;
Console.WriteLine(Array.IndexOf(sonuclar,maksimum).ToString());

Metotlar

//Metotlar bu şekilde çağrılabilir
Random sayi = new Random();
int no = sayi.Next(1,5);
button1.Text = no.ToString();

//Geriye değer döndüren metot
int KareAl(int sayi)
{
    int sonuc;
    sonuc=sayi*sayi;
    return sonuc;
}

//Geriye değer döndürmeyen metot
void Temizle()
{
    textBox1.Clear();
    textBox2.Clear();
    comboBox1.Items.Clear();
}
//Overload
int YasHesapla(DateTime tarih)
{
    int sonuc;
    int dogumYili = tarih.Year;
    sonuc = DateTime.Now.Year - dogumYili;
 
    return sonuc;
}
 

 

int YasHesapla(int yil)
{
    int sonuc;
    sonuc = DateTime.Now.Year - yil;
 
    return sonuc;
}

Sınıflar

Button yenibuton = new Button();

yenibuton.Text = "Click me";
yenibuton.Click += yenibuton_Click;

private void yenibuton_Click(object sender, EventArgs e)
{
    Console.WriteLine("Merhaba");
}

Access Modifiers

Public: Her yerden erişilebilir.
Private: Sadece tanımlandığı sınıf içerisinden erişilebilir.
Internal: Sadece bulunduğu projede erişilebilir.
Protected: Sadece tanımlandığı sınıfta ya da o sınıfı miras alan sınıflardan erişilebilir.
Protected Internal: Sadece tanımlandığı sınıfta ya da o sınıfı miras alan sınıflardan erişilebilir. Ayrıca tanımlamanın aynı proje içerisinde olma şartı yoktur. Protected’dan farkı budur.
Eğer erişim belirleyici belirtilmemişse, sınıflar internal’dır.

//Fields
//Genellikle, nesnenin özellikleri (property) için değer saklama alanıdır. Varsayılan durumda private yapılardır.
//Field,  global alanda tanımlanmış bir değişken olarak da düşünülebilir. Yani class içerisindeki tüm metotlardan erişilebilecek bir değerdir.
public class Insan
{
    private string _isim;
}

//Properties
//Nesnenin özellikleridir.
//set ve get metodları vardır.
private string _isim;
public string Isim
{
    get
    {
        return _isim;
    }
    set
    {
        isim = value;
    }
}

//Methods
//Nesnenin yapabildiği işlerdir.
//Virtual, override, abstract metotlar oluşturulabilir. Bu sayede, miras alan sınıfın bu metot ile yapabileceği işler belirlenebilir.
//Static olarak oluşturulabilir. Bu sayede, metot nesnenin değil sınıfın metotu haline gelir.
public void kos()
{
}

public static void aya_ayak_bas ()
{
}

//Constructor
//Constructor ismi, class’ın ismi ile aynı olmak zorundadır.
//Nesne ortaya çıkartılırken yapılacak işlemleri barındırır.
//Farklı parametreleri alarak aşırı yüklenebilir (overload).
public Insan ()
{
    This.Isim = “Doe”;
}

// Burada kullanılan This, işlem yapılan sınıfı ya da sayfayı temsil etmektedir.

public Insan(string adi)
{
    This.Isim = adi;
}

//Events
//Nesnelerin tepkileridir. Delegate’ler ile birlikte kullanılır. 
//Aşağıdaki örnekte, Kettle sınıfına SuKaynama Eventi eklenmiş ve su derecesi 100’ü geçerse bu event’in tetikleneceği belirtilmiştir. 
public delegate void SuKaynamaDelege();
public class Kettle
{
    public event SuKaynamaDelege SuKaynamaEventi;
    private byte _susicakligi;
    public byte Susicakligi
    {
        get 
        { 
            return _susicakligi; 
        }
        set
        {
            _susicakligi = value;
            if (this._susicakligi >=100)
            {
                if (SuKaynamaEventi != null)
                {
                    SuKaynamaEventi();
                }
            }
        }
    }
}

Enum

enum renkler{kirmizi,mavi,sari} renk;
enum günler
{
    pazartesi,sali,carsamba,persembe,cuma,cumartesi,Pazar
};

enum bolumler bolum;
enum gunler gun;
bolum = muhasebe // bolum = 2 anlaminda
gun = cuma;     // gun = 4 anlaminda
renk = kirmizi; // renk = 0 anlaminda

Encapsulation

Bir nesnenin özelliklerinin dışarıdan kullanılmasını sınırlamak için kullanılır.

public class Insan
{
    private void KirlikandakiKarbondioksitiAl()
    {
        //.......
    }
    private void OksijenikanaVer()
    {
        //.......
    }
    private void CigeriSisir()
    {
        //.......
    }
    private void CigeriDaralt()
    {
        //.......
    }
    public void NefesAl()
    {
        CigeriSisir();
        OksijenikanaVer();
        KirlikandakiKarbondioksitiAl();
        CigeriDaralt();
    }
}

Inheritance

C# dilinde sadece tek bir sınıftan miras alabilirsiniz.

public class Canli
{

    public int ayak;      // Canlının kaç ayağı olduğunu tutan field
    public int el;        // Canlının kaç eli olduğunu tutan field
    public string tur;    // Ne tür bir canlı olduğunu belirleyeceğimiz field.
}

class Insan : Canli
{
    public void Konus()
    {
        Console.WriteLine(“Selam benim {0} adet elim ve {1} adet ayağım vardır.”,el,ayak);
        Console.ReadLine();

    }
}

Interface

Interface sınıflara sunabileceğiniz, sınıfın hangi isimde ve hangi tipte parametreleri alan bir metoda sahip olacağını söylemenizi sağlayan yapıdır. Bir sınıfa istediğiniz kadar arayüz uygulayabilir / giydirebilirsiniz (implement).

Arayüzler hangi işin yapılması gerektiğini belirtir ama nasıl yapılacağına karışmaz. Bu metotların işlemleri, arayüzün uygulandığı sınıfta yazılır.

interface KayitIslemleri
    {
        void Kaydet();
        void Guncelle();
        void Sil();
    }

    class Ogrenci:KayitIslemleri
    {
        public void Kaydet()
        {
            throw new NotImplementedException();
        }
        public void Guncelle()
        {
            throw new NotImplementedException();
        }
        public void Sil()
        {
            throw new NotImplementedException();
        }
    }

    class Ogretmen : KayitIslemleri
    {
        public void Kaydet()
        {
            throw new NotImplementedException();
        }
        public void Guncelle()
        {
            throw new NotImplementedException();
        }
        public void Sil()
        {
            throw new NotImplementedException();
        }
}

Polymorphism

Statik çokbiçimlilik; metot ve operatörlerin aşırı yüklenmesi (overload) olarak belirtilir.
Dinamik çokbiçimlilik;(Runtime, Dynamic Polymorphism) özet sınıflardan miras alma yoluyla işlemlerin gerçekleştirilmesi işlemine verilen isimdir.

Sonuç olarak, çokbiçimlilik bir nesnenin bir işlemi farklı şekillerde yapabileceğini gösteren bir kavramdır. Birbirine benzeyen nesneleri ortak özellikleriyle ele alabilmenizi ya da bir nesnenin aynı işi farklı şekillerde yapabilmesini sağlar.

// Yazıcı sınıfı ile çıktısını almak istediğimiz değerleri tek bir metot ile farklı formatlarda çıkarttırabiliriz.
// Nedenle içine Yazdir isimli iki metot tanımlıyor ve aldıkları parametreleri değiştiriyoruz.

        public class Yazici
        {
            public void Yazdir(int i)

            {
                Console.WriteLine("Sayısal değer yazdırılıyor - {0}", i);
            }

            public void Yazdir(string s)
            {
                Console.WriteLine("Metinsel değer yazdırılıyor - {0}", s);
            }
        }

static void Main(string[] args)
        {
            Yazici yazici = new Yazici();
            yazici.Yazdir("Turkcell Geleceği Yazanlar");
            yazici.Yazdir(1);
            Console.WriteLine("İşlem tamamlanmıştır");
            Console.ReadKey();
        }

Abstract (soyut) sınıflar, aslında daha önceki konularda gördüğümüz arayüzlerle benzerlik göstermektedirler. Aynı arayüzlerde olduğu gibi kalıtım alındıkları sınıflara şablon getirmektedir. Şablonu oluşturmak için Abstract Sınıfların içerisine Abstract özellikler eklenmektedir (Örn: Metot, Değişken gibi). Buna ek olarak, normal özellikler ekleyip bunların içerisine kod yazmanız da mümkündür. Aslında Abstract Sınıfları Base Class (Ana Sınıf) olarak düşünebiliriz.

//Abstract Class
public abstract class Yazici
    {
        //aşağıdaki gibi aynı tipte olan değişkenleri tek satırda tanımlayabiliyoruz.
        protected int Genislik, Yukseklik;
        //daha önceki derslerimizde öğrendiğimiz constructor (yapıcı) metodu tanımlıyoruz.
        //bu sayede sınıf örneği alınırken genislik ve yükseklik değerlerini vermek zorunlu bırakılıyor.

        public Yazici(int genislik, int yukseklik)
        {
            //yapıcı metoda gönderilen değerler Yazici sınıfının içerisindeki Genislik ve Yukseklik
            //özelliklerine atanıyor. Bu atama sırasında this anahtar kelimesi sayesinde sınıfın kendi
            //öz kaynaklarına erişebiliyoruz.
            this.Genislik = genislik;
            this.Yukseklik = yukseklik;
        }
        //Yazici sınıfını kalıtım alacak bütün sınıflar Yazdir metodunu kullanacaklardır.
        public abstract void Yazdir();
   }

//New Classes
public class ResimYazicisi : Yazici
    {
        //Image tipi resimler ile ilgili işlemler yapmak istediğimiz zaman kullandığımız .Net Framework sınıfıdır.
        //Kullanabilmek için System.Drawing referansını projemize eklememiz gerekir.
     //Temsilen eklenmiştir. Image işlemleri yapmayacağımızı için kullanılmayacaktır.
        protected Image Resim;

        //Kalıtım alınan sınıfın (Yazici sınıfı) constructor'ında parametre bekleniyor ise base anahtar kelimesi ile
        //kalıtım alan sınıftan bu parametrelerin içeriye gönderilmesi gerekmektedir.
        public ResimYazicisi(int genislik, int yukseklik):
            base(genislik, yukseklik)
        { }

     //Başarılı şekilde yazdırıldığını bildirmek için geriye True/False değeri döndürüyoruz.
        public override bool Yazdir()
        {
            Console.WriteLine("Resim yazdırılıyor. Boyutları : Genişlik {0} Uzunluk {1}", Genislik, Yukseklik);
         return true;
        }
    }

    public class MetinYazici : Yazici
    {
        protected string Metin;
        public MetinYazici(int genislik, int yukseklik)
            :base(genislik, yukseklik)
        { }
        
        public override bool Yazdir()
        {
            Console.WriteLine("Metin yazdırılıyor. Boyutları : Genişlik {0} Uzunluk {1}", Genislik, Yukseklik);
         return false;
        }
    }

Streaming

Stream’ler (akım veya kanal), .NET ortamında dosya okuma ve yazma işlemlerini gerçekleştirir. Bu kanallar byte düzeyinde olup, veri girdisi oluşturan veya çıktı bilgisi elde eden birimlerdir.

//Dosya Okuma
StreamReader sr =new StreamReader("dosya.txt");
Console.WriteLine(sr.ReadToEnd());
sr.Close();

//Dosyaya Yazma
StreamWriter Yaz = new StreamWriter("D:\\Yaz.txt");
Yaz.Write("C# StreamWriter");
Yaz.WriteLine("Örnek İçerik");
Yaz.Close();

Threading

Threading, birden fazla thread’in (iş parçacığı) aynı anda çalışması diye açıklanabilir.

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

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {

            while (true == true)
            {
                Console.WriteLine("İşlem seçiniz:");
                Console.WriteLine("1-Dosyayı kaydet, 2-Yazdır");
                string Islem = Console.ReadLine();
                switch (Islem)
                {
                    case "1":
                        Console.WriteLine("Dosya arka planda kaydediliyor... ");
                        Thread DosyayiKaydet_Thread = new Thread(new ThreadStart(DosyayiKaydet)); // Bu satırda iş parçacığı henüz çalışmaya başlamamıştır. Sadece çalıştırılacağında hangi metodu çağıracağı belirtilmiştir. DosyayiKaydet_Thread isimli thread, DosyayiKaydet metodunu çağıracaktır.
                        DosyayiKaydet_Thread.Start(); //DosyayiKaydet metodunu çağırarak iş parçacağının paralel çalışmasını sağlar.
                        // Dosyanın kaydedilmesinin bitirilmesi beklenmeden aşağıdaki kod parçacığının çalışmasına devam edilerek menü hemen gelecektir.
                        break;
                    case "2":
                        Yazdir();
                        break;
                }

            }
        }

        static void DosyayiKaydet()
        {
            Thread.Sleep(10000); // 10 saniye bekle. Bu metot milisaniye cinsinden bekleme süresi almaktadır. Bekleme esnasında diğer thread'ler çalışabilmektedir.
            Console.WriteLine("Dosya kaydedildi.");
        }

        static void Yazdir()
        {
            for (int Sayac = 0; Sayac <= 1000; Sayac++)
            {
                Console.WriteLine("Yazdırılıyor... " + Sayac.ToString());
            }

            Console.WriteLine("Yazdırıldı. Enter tuşuna basınız..");
            Console.ReadLine();
        }

    }
}

 

Referanslar   [ + ]

Bir Cevap Yazın

%d blogcu bunu beğendi: