HAFTA 1: PROGRAMLAMANIN TEMELLERİ · Web viewstring ad = "Melih Cevdet Anday"; ifadesi ad isimli yerel değişkenimize atama yaparken, this.ad = "Orhan Veli Kanık"; ifadesi ad isimli

HAFTA 1: PROGRAMLAMANIN TEMELLERİ

Önce Visual Studio 2008 ortamında yeni bir proje oluşturalım. File-New Project-Console Application ile yeni bir console uygulaması açalım. İsim olarak ise h1orn1 ismini verelim.

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

namespace h1orn1{ class Program { static void Main(string[] args) { Console.WriteLine("Bu ilk uygulamamız"); // Arkadaşlar! Ekrana Bu ilk uygulamamız yazacak. } }}

Şimdi yukarıdaki kod bloğunun bazı özelliklerini giriş seviyesinde açıklayalım. Çünkü daha sonra bu değindiğimiz konular ayrıntılı olarak incelenecektir.

Namespace (İsim Uzayı): C# ortamında metotların ve değişkenlerin her biri sınıfların içinde yer alır. Bu sınıfların sayıları da çok fazla olmaktadır. Erişimi kolaylaştırmak için sınıflar gruplara ayrılır ve birbiriyle ilgili sınıflar namespace ler içine alınırlar. Örneğin yukarıda console sınıfı içindeki WriteLine( ) metodu çalıştırılmıştır. Biz eğer en tepeye using System; satırı ile system isim uzayının kullanılacağını tanımlamasaydık, program Console sınıfınıda tanımayacağı için WriteLine( ) metodu da çalışmayacaktı.Eğer programımızda bir namespace eklemek istersek using ile birlikte ekleneceğini de öğrenmiş olduk.Ayrıca ekrana bir yazı yazmak için yapmamız gereken de çift tırnak içinde yazmak şartıyla Console.WriteLine(""); yada Console.Write (""); metodlarını kullanmak olacaktır. Bu ikisi arasındaki farkı aşağıda görelim.

Sınıf(Class): Nesne yönelimli programlamanın temel taşlarıdır. Program içinde kullanılan her değişken, metot ve deyim mutlaka bir sınıf içinde tanımlanır. Örnekte program adında bir sınıf tanımlanmıştır. Bir sınıfta aynı ismi taşıyan 2 öğe olamaz.

Bloklar: Bloklar {} parantezlerini ifade eder. Açılan her parantez mutlaka yeri gelince kapanmalıdır. Main( ){} Üstteki blok ana program bloğu olup program işletilmeye başlanınca ilk çalıştırılacak kodlar bu blok içinde yer alır.

Açıklama Satırları: Büyük bir kod bloğundan oluşan programı sizden başka kişilerinde okuduğu zaman anlaması gerekli olabilir. Bu durumlarda açıklama satırları ile kodları tanıtabiliriz.Açıklama satırı tek satır için ise // işaretlerinden sonra yazılan ifadeleri temsil eder. Eğer tek satır değil de alt alta birçok satırdan oluşan açıklama için /* */ ifadeleri arasına yazmak gerekir.


namespace h1orn1{ class Program { static void Main(string[] args) { Console.WriteLine("Merhaba"); Console.WriteLine("Nasılsınız?"); Console.Write("Ben iyiyim"); Console.Write("Teşekkürler"); } }}

Yanda metotların kullanımı ile ilgili bir örnek görülmektedir. İnteger türünde değişkenler (sonuc,x,y,a,b,n) görülmektedir. Bu örnekte hesapla adında bir metodumuz vardır. Bu metot türü int olan 2 adet parametre almaktadır. Bu parametreleri sırasıyla 3 ile çarpar diğerini de 2 ye bölerek sonuçları toplamaktadır. Return ifadesi sayesinde de elde edilen sonuç isteğin yapıldığı yere iletilmektedir. Peki, istek nereden yapılmıştır? Yani metot nereden çağrılmıştır? Bu sorunun cevabı da Main( ) bloğundadır. hesapla(4,8); Satırı ile aslında hesapla metoduna 2 adet parametre gönderilmiştir.

*Peki hesapla (2,4,6); şeklinde bir ifade doğru olur mu?

*Peki hesapla (2.9 , 4); şeklinde bir ifade doğru olur mu?

static int sonuc; deyimi sınıfa ait sonuç adlı int türünde bir değişken tanımlar. Bu tür değişkenlere sınıf değişkeni denir. Static olarak nitelendirilmiş değişkenler sınıfa ait bir nesne yaratmadan kullanılabilir.

using System;

namespace h1orn1{ class Hesap { static int sonuc; static int hesapla(int a, int b) { int x, y; x = 3 * a; y = b / 2; return x + y; } public static void Main() { int n; n = hesapla(4,8); sonuc = n; Console.WriteLine(sonuc); } }}

// KÜRENİN HACMİNİ VE ALANINI VEREN PROGRAM KODU(4/3 * ח* r3)


namespace h1orn1{ class Hesap { static void Main() { double hacim, alan, pi, yaricap, kup; string cikis, yaristr;

do { Console.Write("lütfen kürenin yarıçapı giriniz : "); yaristr = Console.ReadLine(); yaricap = Int64.Parse(yaristr); pi = 3; kup = yaricap * yaricap * yaricap; hacim = 4 / 3.0 * pi * kup; Console.WriteLine("girdiginiz yarıçapa göre kürenin hacmi {0}", hacim); alan = 4 * pi * yaricap * yaricap; Console.WriteLine("girdiginiz yarıçapa göre kürenin alanı {0}", alan);Console.WriteLine("Alan ve hacim toplamı {0} iken çarpımları ise {1} dir",alan+hacim,alan*hacim); Console.WriteLine("cıkmak istiyorsanız <e> veya <E> tuşuna basınız "); cikis = Console.ReadLine(); } while ((cikis != "e") && (cikis != "E"));

} }}

Parse: Kullanıcının girdiği sayısal veri ReadLine( ) metodu tarafından string olarak okunur. Okunan bu veriyi olması gereken sayısal veri tipine dönüştürmek için Parse( ) metodu kullanılır.Yukarıdaki örnekte Console.WriteLine() metodunun formatlı kullanımını görmektesiniz.

***ŞİMDİ SAYFA 28 DEKİ ÖRNEKLERİ İNCELEYELİM.

HAFTA 2: SINIFLAR VE NESNELER1. Sınıf(Class) ve Nesne(Object) KavramlarıSınıf nesneyi tanımlayan bir veri türüdür. Nesne ise bir sınıfın aynısını alıp ondan oluşturduğumuz özelliklerini belirlediğimiz canlı modeldir. Daha sonra tekrar kullanmak üzere oluşturulmuş parçalardır. Sınıfı bir mimarın çizdiği ev projesine, nesneyi de bu projeden yapılmış evlere benzetebiliriz. Bu proje kullanılarak istenildiği kadar ev yapılabilir. Yani bir sınıftan istediğimiz kadar nesne kurabiliriz. O nesnelerin yapıları aynıdır ama öz nitelikleri farklıdır.

Üstte Ağaç sınıfı ve ağaç sınıfından türetilmiş 2 tane nesne görülmektedir.Sınıflar, bir proje geliştirdiğimizde o projede kullanılacak genel taslaklardır. Proje içerisinde o taslakları kullanarak şekillendirdiğimiz canlı modellere de nesne denir. Örneğin bir emlak uygulamasında müşteri satış temsilcisi, gayrimenkul gibi varlıklar daha sonra kendilerinden nesne türetilmek üzere birer sınıf olarak tanımlanır. Sınıf daha önce ki konularda işlediğimiz veri tiplerine ek olarak kullanıcı tarafından tanımlanmış yeni bir tiptir.

Sınıflar; değişken, sabitler, fonksiyonlar, metotlar, özellikler, olaylar, yapıcılar, yıkıcılar ve indeksleyiciler gibi öğeler içermektedirler.

Yanda bir ütü sınıfı görülmektedir. Bu Ütünün markası, modeli, rengi, çalıştığı voltajı, ütülediği kumaş cinsleri gibi özellikleri (property) olabilir. Aynı zamanda ütüyü ısıtabiliriz, soğumaya bırakabiliriz, kullanabiliriz. Bunlar ise ütünün metodları (yordamları) olabilir.

2. Sınıf TanımlamakSınıf Class anahtar kelimesi kullanılarak oluşturulur. Aşağıdaki yapı bir değişken ve metot içeren bir sınıfı oluşturmakta kullanılabilir. .NET Framework ortamında tanımlanan tüm sınıflar default olarak System.Object sınıfından türetilmiştir.

class Sınıfİsmi { Erişim dönüş_tipi Metod(Parametreler) metod tanımlama alanı { } Erişim tip değişken; // Değişken tanımlama }

Erişim: Erişim belirleyicileri ile nesne sahip olduğu üyelere kimin ve hangi şartla erişilebileceğini belirtir. Bir sınıfın erişim öğeleri aşağıdaki değerler olabilir.

Public: Public olarak tanımlanmış bir metot veya özelliğe herhangi bir yerden ulaşmak mümkündür. Herkese açık olarak tanımlayabiliriz.Private: Bu sıfat ile tanımlanmış metot veya özelliklere sadece tanımlandığı sınıf içerisinden ulaşabiliriz.Protected: Protected metotlara veya özelliklere tanımlandıkları sınıftan ve bu sınıftan üretilmiş alt sınıflardan ulaşabiliriz.

2.1. Nesne TanımlamakSınıftan bir örnek (instance) yani bir nesne oluşturmak için new anahtar sözcüğü kullanılır. Aşağıda yapı sınıfına ait ev adında bir nesne oluşturulmuştur.

Sınıf_adı nesne_adı = new sınıf_adı( );Yapi Ev=new Yapi( );// Yapı sınıfından ev adlı bir nesne oluşturulmuştur.

Nesne tanımlandıktan sonra sınıf içindeki metot ve değişkenlere "." işaretinden sonra metot veya değişken ismini yazarak ulaşabiliriz.

class yapi { public int kat; public int alan; public int oturan_sayisi; }

class yapi_orn { public static void Main(string[] args) { yapi villa = new yapi(); //yapi sınıfından villa adında bir nesne oluştur. int alankb; //Kişi Başına Düşen alan villa.kat = 2; villa.alan = 3000; villa.oturan_sayisi = 10; alankb=villa.alan/villa.oturan_sayisi; //kişi başına düşen alan hesaplanıyor. Console.WriteLine("Villanın kat sayısı{0}dır",villa.kat);

Console.WriteLine("Villanın Kişi başına Düşen alanı{0} dır.\n"+ "Ayrıca bu villada {1} kişi oturmaktadır", alankb, villa.oturan_sayisi); } }

Örnekte yapı sınıfının içindeki değişkenler public olarak tanımlanmasaydı bir hata ile karşılaşacaktır. Daha sonra da anlatılacağı üzere public tanımlaması değişkenlere dışarıdan erişime izin vermektedir. Programlamada kapsülleme denilen bu yöntem güvenlik için önemli bir yer tutmaktadır.

2.2. İç içe sınıf oluşturmakAynı isim uzayında olmak şartıyla iç içe sınıflar(nested classes) oluşturulabilir.ÖRNEK 2public class arabalar { public class binek_arabalar {

public class sedan_arabalar { public int motorhacmi = 2000; } public class hb_arabalar { public int motorhacmi = 1600; } }

public class ticari_arabalar {

public class agir_ticari_araba { public string vergi = "yüksek"; } public class orta_ticari_araba { public string vergi = "orta"; } } class oto_karsilastirma { static void Main() { arabalar.binek_arabalar.sedan_arabalar otobinek = new arabalar.binek_arabalar.sedan_arabalar(); arabalar.ticari_arabalar.orta_ticari_araba ototicari = new arabalar.ticari_arabalar.orta_ticari_araba(); Console.WriteLine("Binek sedan arabaların motor hacmi {0} olabilir", otobinek.motorhacmi); Console.WriteLine("orta ticari arabaların vergisi {0} düzeydedirdir",ototicari.vergi); } } }

ÖRNEK:using System;using System.Collections.Generic;using System.Linq;using System.Text;

namespace h1orn1{ class uygulama { class Ev { public static int kapiNo; public static string sokakAdi; } static public void Main() { Ev.kapiNo = 123; Ev.sokakAdi = "Menekşe"; Console.WriteLine("ADRES:{0} Sokak, No:{1}",Ev.sokakAdi,Ev.kapiNo);

} }}

Örnekte bir nesne yaratılmamış onun yerine Ev sınıfının değişkenlerini public static ifadeleriyle tanımlanmıştır. Ev sınıfına ait bir nesne oluşturmadan ev sınıfının kapiNo ve sokakAdi gibi değişkenlerine nasıl erişildi ve değer ataması yapıldı? Bu sorunun cevabı şudur. Derleyici Ev sınıfı için kendiliğinden bir nesne yarattı ve o nesneye sınıfın adını verdi. Ev.kapiNo = 123; deyiminin başındaki Ev adı sınıfın değil bizden habersiz yaratılan ve sınıf ile aynı adı taşıyan nesnenin adıdır.

NOT: Bir sınıfın bazı öğeleri static bazıları static değilse, static öğelere sınıf işaretçisi ile, static olmayan öğelere de nesne işaretçisi ile erişilebilir.using System;using System.Collections.Generic;using System.Linq;using System.Text;

namespace h1orn1{ class uygulama { class Ev { public static int kapiNo; public string sokakAdi; } static public void Main() { Ev.kapiNo = 777; Ev eskiev = new Ev(); eskiev.sokakAdi = "yasemin"; Console.WriteLine("ADRES:{0} Sokak, No:{1}",eskiev.sokakAdi,Ev.kapiNo); } } }

NOT: Sınıf değişkenlerinin değerleri nesnelere aynen gitmektedir. Program çalışırken o değerleri nesne içinde değiştirmek mümkündür; ama nesne içindeki değişiklik, sınıf tanımındaki değerleri etkilemez. Örnekte yazlikev nesnesi içinde yapılan değişiklikler sınıf değişkenine yansımamıştır. using System;using System.Collections.Generic;using System.Linq;using System.Text;

namespace h1orn1{ class Ev { public int kapino = 444; public string sokakadi = "papatya"; public void yaz() { Console.WriteLine("Adres:{0} Sokak, No:{1}", sokakadi, kapino); } } class uygulama { public static void Main() { Ev yazlikEv = new Ev(); yazlikEv.yaz();

yazlikEv.kapino = 334; yazlikEv.sokakadi = "Sümbül"; yazlikEv.yaz();

Ev kislikev = new Ev(); kislikev.yaz();

} }}

2.4 This anahtarıMetotların içinde tanımlanan yerel değişkenler ancak ait olduğu metot içinden erişilir, kendi sınıfından veya başka sınıflardan erişilemez. Bazı durumlarda yerel değişken adları ile sınıf değişken adları aynı olabilir.

using System;using System.Collections.Generic;

using System.Linq;using System.Text;

namespace h1orn1{ public class ozanlar { public string ad; public void yaz() { string ad = "Melih Cevdet Anday"; this.ad = "Orhan Veli Kanık"; Console.WriteLine(ad); Console.WriteLine(this.ad);

} } class uygulama { public static void Main() { ozanlar a = new ozanlar(); a.yaz(); } }}

Örnekte;string ad = "Melih Cevdet Anday"; ifadesi ad isimli yerel değişkenimize atama yaparken, this.ad = "Orhan Veli Kanık"; ifadesi ad isimli ozanlar sınıfı değişkenine değer ataması yapar. İki değişkenin adı da aynı olmasına rağmen bellekte farklı yerler tahsis edilir.

3. Yapılandırıcılar(Kurucular-Constructors)

3.1 Static ve Dinamik Öğelere erişim


namespace h1orn1{ class Ev { public int kapino = 444; public static string sokakadi = "NERGİS"; public void kapinoyaz() { Console.WriteLine("Kapı no:{0} ", kapino); } public static void sokakadiyaz() { Console.WriteLine("Sokak Adı:{0} ", sokakadi); } } class uygulama { static public void Main() { Ev yazlikEv = new Ev(); yazlikEv.kapinoyaz(); Ev.sokakadiyaz();

} }}

Yukarıda ev sınıfı içindeki kapinoyaz( ) metodunu çağırmak için yeni bir sınıf nesnesi tanımlamamız gerekti çünkü kapinoyaz( ) metodu dinamiktir. Sokakadiyaz( ) metoduna nesne içinde değil, nesne dışında onlara ana bellekte ayrılan adreslerde erişilebilir. Burada Ev asıl sınıf değil, söz konusu bellek adresini işaret eden referanstır.

3.2 Kurucular(Yapıcılar)

Bir sınıftan nesne oluşturulduğu zaman nesneyi hazırlayan, şekillendiren özel metodlara yapıcı(yapılandırıcı) denir. Dışarıdan parametre alabilirler ancak geriye değer döndüremezler. Nesneleri oluşturmak için kullanılan new operatörü ile tetiklenirler. Yapıcılar sınıf ile aynı ismi taşır. Public olarak tanımlanmaları gerekir.C# bir sınıf içinde o sınıfın adını alan bir metodu(kurucuyu) başkasının çalıştırmasına asla izin vermez. Sınıfa ait bir nesne kurulur kurulmaz kurucu kendiliğinden çalışır ve üstüne düşen görevi yerine getirir. Kurucular bizim o an ilgilenmediğimiz ama yapılması gereken işleri yaparlar. Birçok zahmetten bizi kurtarırlar. Kurucular short,

int, bool gibi değerler almazlar. Eğer sınıfın bir kurucusu yoksa CLR tarafından kendiliğinden sınıfa ait bir nesne yaratılır buna genkurucu denilir. Bir sınıfın istenildiği kadar kurucusu olabilir.(aşkın kurucular)

Aşağıda 2 parametreli bir kurucu tanımlanmıştır. Örnekte Main( ) metodu hiçbir fonksiyon çağırmadı, yalnızca new operatörü ile ev sınıfına ait bir nesne yarattı. Aynı zamanda yapıcıya 2 adet parametre gönderdi. Yapıcı da bu parametreleri alarak ekrana adresi yazdırdı.using System;using System.Collections.Generic;using System.Linq;using System.Text;

namespace h1orn1{ class Ev { int kapino; string sokakadi; public Ev(int n, string s) { kapino = n; sokakadi = s; Console.WriteLine("ADRES:{0}Sokak, No:{1}",sokakadi,kapino); } } class uygulama { static void Main() { new Ev(123,"menekşe");

} }}

3.2.1 Aşkın Kurucular

Bir kurucu tanımlamak için parametrelerin sayısını, sırasını ve tipini değiştirmek gerekecektir. Bu işi yaparken parametrelere yüklendiğimiz için farklı parametrelerle birden çok kurucu tanımlama işine aşırı yükleme (overloading ) denir.


namespace h1orn1{ class Ev { int kapino=123; string sokakadi="menekşe";

public Ev() { Console.WriteLine("ADRES:{0}Sokak, No:{1}", sokakadi, kapino); }

public Ev(int n) { kapino = n; Console.WriteLine("ADRES:{0}Sokak, No:{1}", sokakadi, kapino); } public Ev(int n, string s) { kapino = n; sokakadi = s; Console.WriteLine("ADRES:{0}Sokak, No:{1}",sokakadi,kapino); } } class uygulama { static void Main() { new Ev(); new Ev(334); new Ev(123,"papatya");

} }}

Aşağıdaki örnekte; Ev ve ofis nesneleri oluşturulduklarında, yapi( ) yapılandırıcısı ile ilk kullanıma hazırlanırlar. Nesnelerin her birine ilk değerleri, parametrelerde belirtildiği şekliyle kendi yapılandırıcısı tarafından atanır.

class yapi { public int kat; //kat sayısı public int alan; //toplam bina alanı public int oturanlar; //oturan sayısı

public yapi(int k, int a, int o){ kat=k; alan=a; oturanlar=o; } public int kisibasialan() {

return alan / oturanlar; } public int maxoturan(int minalan) { return alan / minalan; } } class yapi_uygulama { public static void Main() { yapi ev = new yapi(2, 2500, 4); yapi ofis = new yapi(3,4200,25); Console.WriteLine("Ev için 300 metrekarede oturan maksimum kişi"+ev.maxoturan(300)); Console.WriteLine("Ofis için 300 metrekarede oturan maksimum kişi" + ofis.maxoturan(300)); } }

3. Yıkıcılar(Destructors)Oluşturulan nesnenin yüklendiği bellekten yok edilmeden hemen önce çalışan metotlara yıkıcı metot denir. Nesne bellekten silinmeden son kez yapacağı işlemleri(açık olan bir database bağlantısını kapamak gibi) yıkıcı metotlara tanımlarız. Tıpkı yapıcılar gibi yazılırlar tek fark başındaki tilda işaretidir.

Aşağıda sipariş sınıfının yıkıcı metodu tanımlanmıştır.Public class Siparis{~Siparis(){}}

Bir sınıf en fazla 1 tane yıkıcı metoda sahip olabilir. Yıkıcı metotlar parametre almazlar ve geriye değer döndürmezler. Yıkıcı metotla programcı tarafından değil ancak garbage collection tarafından çalıştırılırlar.

HAFTA 3: VERİ TİPLERİ VE DEĞİŞKENLER

Değişken ana bellekte belli bir veri tipine ait değerlerin girilebileceği bir adrestir. Bir değişken bildirimi yapılırken o değişkenin veri tipi mutlaka belirtilir. Bazı durumlarda bir değişkenin tuttuğu verinin başka tiplere dönüşümü söz konusu olabilir(casting).Bir değişken aşağıdaki şekilde tanımlanır.

Veri_tipi Değişken_adı = İlk_değer;

Burada ilk değer vermek zorunlu değildir.*Değişkenler Türkçe karakter içermemelidir.*Sayı ile başlayamazlar.*Alt çizgi hariç diğer operatörleri(+/&%.=# gibi) içeremezler*Aynı tipe ait değişkenler aralarına virgül konarak tanımlanabilirler.

İnt a,b,tutar=0;String musteriAdi,musteriSoyadi; Byte fizikNotu1;String ad=”mustafa”;Char deger=’E’;Bool mezun=true;

*Matematiksel anlam taşımayan ifadeleri(tc kimlik no, telefon no) sayısal veri tipi olarak seçmemek gerekmektedir.* Genellikle bölme ve yüzde işlemlerinin uygulandığı değişkenler ondalıklı sayısal tipler ile tanımlanmalıdır.* Tek bir simge ile temsil edilemeyen karakterler\n yeni satır\t tab kadar boşluk\r satır başıGeçerlilik Bölgesi:Bir değişken sınıfın bir öğesi ise, bütün sınıf içinde geçerlidir. Ona sınıfın her metodu her bloğu erişebilir. Sınıfa ait nesne bellekte kaldığı sürece değişken kendini korur.Bir metot veya döngü veya {} parantezleri ile belirlenen bir blok içinde tanımlı değişkenlere yerel değişkenler diyoruz. Sınıf içinde olup hiçbir blok içinde olmayan değişkenlere de sınıf değişkenleri denir.

Bilgisayarda BellekBilgisayar ortamında veriler;

1. Cache bellek(işlemci içindeki register alanları)2. Kayıt Ortamları(Harddisk, CD,DVD,Disket..)3. RAM Bellek

Ortamlarında tutulurlar.Ram Bellek içinde Stack(Yığın) ve Heap alanları önemli yer tutar.

Stack : LIFO(last input first output) mantığına göre çalışır. Üst üste yığılmış kutuları andırır, son koyulan kutu önce alınır. Ram de en hızlı erişim sağlanan bölgedir. C# daki değer türleri bu bölgede tutulurlar ve doğrudan veriyi taşırlar.Heap : Tüm referans tiplerinin tutulduğu bellek bölgesidir. Dolayısıyla bir sınıfa ait türetilen nesneler heap bölgesinde tutulur. Nesne için ayrılan adres, bu nesneyi işaret eden referans(işaretçi, pointer) tarafından bilinir. Referans türleri(class, string, object, array, delegate ve pointer) bu alanda depolanmışlardır. Bunlar doğrudan verinin kendisini değil verilerin adresini tutarlar.

Değişken Türleri

A.BAŞVURU(REFARANS )TÜRLERİ1.Nesne2.String

B.DEĞER TÜRLERİ1.Tamsayı

(byte(System.Byte)-short(System.Int16)-int(System.Int32)-long(System.Int64)) 8 bit 16 bit 32 bit 64 bit

2.Kesirli Sayı(float(System.Single)-double(System.Double)-decimal(System.decimal)) 32 bit 64 bit 128 bit

3.Karakter(char(System.Char))16 bit

4.Diğer(bool(System.Boolean)-datetime(System.Datetime))16 bit 32 bit

İyi bir programcı saklayacağı veriler için doğru türü tercih eder.Örneğin evli-bekar gibi 2 olasılık için bool, yaş bilgisi için byte, borsa, trigonometri gibi hassas mat. İşlemleri için double veya decimal, “A” gibi tek karakter için char veri tipi tercih edilmelidir.

NOT:C# ta yerel bir değişken tanımlandığında bu değişken kullanılmadan önce kendisine ilk değer atanmalıdır.

using System;namespace h1orn1{ class uygulama { static void Main() {

int x;

Console.Write(x.ToString());

} }}

Üstteki kod bloğu x değişkeninin ilk değeri olmadığı için hata mesajı verecektir. int x=9; şeklinde değiştirilirse hata ortadan kalkar.C# ta veri türlerini varsayılan değerleri ile kullanmak için değişkenleri tanımlarken new ile ilgili türün yapıcı yordamı çağrılmalıdır.


int x = new int(); Console.Write(x.ToString());

} }}

Üstte kodu çalıştırdığımızda ekranda sıfır değeri görülecektir.

NOT:using System;namespace h1orn1{ class uygulama { static void Main() {

int x = 5; Console.Write(x.GetType());

} }}

GetType() metodu ile bir değişkenin türü öğrenilebilir.

NOT: Uzun ifadeler aşağıdaki gibi birleştirilerek yazılabilir.

string metin1 = "Merhaba bu metin örnek olarak hazırlanmış," + "uzun bir metinden oluşmaktadır." + "tek satırda yazmaktan daha kullanışlıdır";

Veri Türleri Arasında Dönüşüm.Net Framework 2 tür dönüşümü destekler.

1. implicit type conversion(Bilinçsiz tip dönüşüm): Derleyicinin bir değişkenin türünü değişkenin değerinde herhangi bir veri kaybına neden olmadan başka bir türe dönüştürmesidir.

2. explicit type conversion(Bilinçli tip dönüşüm): Derleyici desteklemese de programcının dönüştürme operatör veya yordamlarını kullanarak bilinçli olarak 2 türlü birbirine dönüştürmesidir.Bu 2 dönüşüm türü küçük türün büyük türe yada tersi biçimde gerçekleşir.

Küçük türden büyük türe dönüşümde bir veri kaybı yaşanmaz. Short türünden integer veya long türüne dönüşüm gibi. Bu işleme widening (genişletme )denir. Bu işlemi programcının belirtmesine gerek kalmadan derleyici otomatik olarak yapar.


byte x = 37; long y = x; Console.Write(y.ToString());

//implicit conversion } }}

Her hangi bir türden char türüne implicit conversion gerçekleşmez. C# ta büyük türlerin küçük türlere dönüşümüne veri kaybından dolayı izin

verilmemektedir. Böyle bir dönüşüm için explicit dönüşüm yapılmalıdır.

Aşağıdaki örnekte y değerinin program çalıştırıldığında 40 değerini aldığı görülmüştür. Bu nasıl gerçekleşmiştir?CEVAP: Aşağıdaki satırları siyah renk yapalım.Short 16 bit ve byte 8 bit296 = 0000 0001 0010 1000 40 = 0010 1000 short türünden byte türüne çevrilince soldaki 8 bit dışarıda kalır. Geriye sağdaki 8 bit kalır buda 40 değerine eşittir.using System;namespace h1orn1

{ class uygulama { static void Main() {

short x = 296; byte y ; y = (byte)(x); Console.Write(y.ToString());

} }}

Bilinçli dönüştürme yapmanın diğer yolu System.Convert fonksiyonlarını kullanmaktır.

Bir sayısal veri türünü string türüne çevirmek için o türün .ToString() metodu kullanılır. String türünden sayısal türe çevirmek için ise Parse() metodu kullanılabilir.

using System;namespace h1orn1{ class uygulama { static void Main() { int b = 66000; string s = b.ToString(); Console.WriteLine(s); //Burada sonuç 66000 olarak ekrana yazılır. int a = Int32.Parse(s); Console.WriteLine(a); //burada da string değeri integer değere çevirdik ve ekrana 66000 yazdırdık } }}

ÖDEV: Daire diliminin alanını hesaplayan program.


namespace h1orn1{ class uygulama { static void Main() {

string alfastr, yaristr, cikis; // string degiskenleri tanımladıgım satır double alan, alfa, pi, yaricap, kare; // double degiskenleri tanımladıgım satır

do { Console.Write("Alfa sayısını giriniz "); // sayı girmesini istiyorum alfastr = Console.ReadLine();();// degiskeni okutuyorum alfa = Int32.Parse(alfastr));// degiskeni integer'a ceviriyorum Console.Write("Yarı cap sayısını giriniz ");// sayı girmesini istiyorum yaristr = Console.ReadLine();// degiskeni okutuyorum yaricap = Int32.Parse(yaristr);// degiskeni integer'a ceviriyorum

pi = 3;// degiskeni bir sayıya ceviriyorum kare = yaricap * yaricap;

alan = alfa / 360 * pi * kare; // islem yaptırdıgım satır Console.WriteLine("Daire diliminin alanı {0}", alan);// sonucu ekrana yazdırdıgım satır Console.WriteLine("Çıkmak istiyorsanız <E> yada <e> tuşuna basınız ");// çıkmak istiyorsa cikis = Console.ReadLine();// degiskeni okutuyorum } while ((cikis != "e") && (cikis != "E"));// burda WHİLE komutu ile kontrol ettiriyorum ve aynı zamanda sart kosuyorum

} }}

OPERATÖRLERVeriler üzerinde matematiksel işlem gerçekleştirmek, onları birbiriyle karşılaştırmak veya onları hesaplamalarda kullanmak için operatörler kullanılır.

Aritmetiksel Operatörler:= + - * / % ++ --

Int a,b=100;a=b++; // b değerini önce a değerine atama yapar, sonra b değerini 1 artırır. // a=100 b=101a=++b; // Önce b değerini 1 artırır. Sonra b değerini a ya atar. // a=101 b=101a=--b; // Önce b değerini 1 azaltır. Sonra b değerini a ya atar. // a=99 b=99A=b--; // b değerini önce a değerine atama yapar, sonra b değerini 1 azaltır. // a=100 b=99

İşlemli Özel Atama Operatörleria+=b a=a+ba-=b a=a-ba*=b a=a*ba/=b a=a/ba%=b a=a%b

İlişkisel Operatörlerİki operant arasında karşılaştırma yapıp bool türünde(true -false) değer döndürür. Sadece birbirleri ile mukayese edilebilir veriler arasında ilişki kurar. Bir metin ile sayı ya da mantıksal değer ile sayı mukayese edilemez.a= =b //Eşittira<b //Küçüka>b //Büyüka<=b //Küçük eşita>=b //Büyük eşita!=b //Farklı

Mantıksal OperatörlerBelirlenmiş koşulları karşılaştırarak bool türünde değer döndürür.& ve (true&false=false true&true=true false&false=false)| veya (true|false=true true|true=true false|false=false)|| koşula bağlı veya&& koşula bağlı ve

Koşula bağlı ve(&&) operatörünün & operatöründen farkı; eğer ilk operatör false ise diğer operatöre bakılmaksızın sonuç false olur. İlk operatör true ise

diğer operatöre bakılır. Koşula bağlı veya(||) operatörünün | operatöründen farkı; eğer ilk operatör true ise diğer operatöre bakılmaksızın sonuç true olur. İlk operatör false ise diğer operatöre bakılır. Dolayısı ile işlem süresi olarak daha kısa bir sürede çalışırlar.

Operatör Öncelikleri1. x++ ,x--2. --x, ++x3. *, /, %4. +, -5. <,>,<=,>=6. ==, !=7. &8. |9. &&10.||11.Atama(=,+=,….)

**Şimdi kitabımızın 97. sayfasındaki 6. örneği yapalım.

ÖDEV:1. 2. dereceden denklemin köklerini hesaplayan ifadeyi operatörlerin önceliğini de göz önünde bulundurarak program satırı olabilecek şekilde yazınız.

2. x=10 y=5 ise a. x=++x*(40+y++)b. x+=y+x--c. x%=3+ ++y

3 . x=10 başlangıç değeri için x=x+25-6*8/2+6 işleminde x’in son değeri nedir?

HAFTA 4: KONTROL DEYİMLERİ

A.KOŞUL DEYİMLERİProgramın, belirlenen koşulun sonucuna göre istediğimiz işlemi tercih etmesini sağlayan deyimlerdir. “Eğer böyleyse şöyle yap aksi taktirde böyle yap” şeklinde özetlenebilir.

1.Yapı if (mantıksal koşul){ işlem1 } else{ işlem2 }

2.Yapı if (mantıksal koşul){

işlem1 } else if (koşul){ işlem2 } else if (koşul){ işlem3 }. . . else{ işlem n ; }

Bu programda if yapısı kullanımına bir örnek görülmektedir.using System;

namespace h1orn1{ class uygulama { static void Main() { string yas; do { Console.Write("yaşınızı giriniz : cıkmak istiyorsanız -1 giriniz : "); yas = Console.ReadLine();

if (Int32.Parse(yas) >= 50) Console.WriteLine("yaşlısınız "); else if (Int32.Parse(yas) >= 20) Console.WriteLine("gençsiniz "); else if ((Int32.Parse(yas) >= 0) && (Int32.Parse(yas) <= 20)) Console.WriteLine("daha çocuksunuz "); } while (yas != "-1");

} }}

Aşağıda iç içe if kullanımına bir örnek görülmektedir. Girilen 3 sayıdan en büyüğünü bulan program.using System;using System.Collections.Generic;using System.Linq;using System.Text;

namespace h1orn1{

class uygulama { static void Main() {

byte sayi1; byte sayi2; byte sayi3; byte buyuksayi; Console.WriteLine("1. sayıyı girin"); sayi1 = byte.Parse(Console.ReadLine()); Console.WriteLine("2. sayıyı girin"); sayi2 = byte.Parse(Console.ReadLine()); Console.WriteLine("3. sayıyı girin"); sayi3 = byte.Parse(Console.ReadLine()); if (sayi1 > sayi2) { buyuksayi = sayi1; if (sayi1 > sayi3) { buyuksayi = sayi1; } else { buyuksayi = sayi3; } } else { if (sayi2 > sayi3) { buyuksayi = sayi2; } else { buyuksayi = sayi3; }

} Console.WriteLine(""); Console.WriteLine("E büyük sayi {0} dır",buyuksayi);

} }}

3.Yapı Bu yapıda koşulun sonucu belirli değer veya değerlerle karşılaştırılır. case satırındaki koşullar sağlanmazsa default bölümü yürütülür. switch (degisken) { case deger1: şunu yap break; case deger2: bunu yap break; . . . default: hiç bir şey yapma break; }

* Şimdi kitabımızda sayfa 142 deki 4. örneği yapalım

ÖDEV: 1. Bir üçgenin eşkenar ikizkenar ya da çeşit kenar olup olmadığını bulduran program.2. Klavyeden 1 tuşuna basınca YTL-TL ve 2 tuşuna basınca TL-YTL dönüştüren programı kodlayınız.(switch yapısı kullanınız)

Örnek YTL_TL dönüştürücüusing System;using System.Collections.Generic;using System.Linq;using System.Text;

namespace h1orn1{

class uygulama { static void Main() { int deger; long paraTL, paraYTL; short paraYKR; Console.WriteLine("Seçiminizi yapınız"); Console.WriteLine("YTL-TL çevirmek için [1]'e basınız"); Console.WriteLine("TL-YTL çevirmek için [2]'e basınız"); deger = Int32.Parse(Console.ReadLine()); switch (deger) { case 1: Console.WriteLine("PAranızın YTL değerini giriniz"); paraYTL = Int64.Parse(Console.ReadLine()); Console.WriteLine("PAranızın YKR değerini giriniz"); paraYKR = Int16.Parse(Console.ReadLine()); paraTL = paraYTL * 1000000 + paraYKR * 10000; Console.WriteLine("{0} YTL {1} YKR olan paranızın çevrilmiş hali {2} TL dir.", paraYTL, paraYKR, paraTL); break;

case 2: Console.WriteLine("PAranızın TL değerini giriniz"); paraTL = Int64.Parse(Console.ReadLine());

paraYTL = paraTL / 1000000; paraYKR = Convert.ToInt16(Math.Round((double)(paraTL % 1000000) / 10000, 2)); Console.WriteLine("{0} TL paranız {1} YTL , {2} YKR dir.", paraTL, paraYTL, paraYKR); break; default: Console.WriteLine("yanlış seçim yaptınız"); break;

}

} }}

B. DÖNGÜ DEYİMLERİ

1. While Döngüsü:Koşul gerçekleştiği sürece döngü tekrarlanır. Koşul döngüye girilmeden sınanır.

while(koşul){ işlem }

2. Do-while Döngüsü:Koşul gerçekleştiği sürece döngü tekrarlanır. Koşul döngü sonunda sınanır. Yani döngüye girilir ve ilk çevrimin sonunda koşul sınanır. Koşul doğru ise tekrarlanır. Yanlış ise döngüden çıkılır.

do{ işlem }while koşul

3. For Döngüsü:Bir deyim önceden belirlenmiş bir sayıda tekrar edilecek ise for döngüsü kullanmak idealdir.

for(x= <başlangıç değeri>; x<= <bitiş değeri>; x+=<artış>) { işlem }

4. Foreach Döngüsü:Dizi veya koleksiyon türündeki nesnelerin elemanlarına döngü ile erişilmesini sağlayan deyimdir.

foreach(datatipi değişken in grup){ işlem }

string[] ogrenciler = { "Ali","Veli","Ayşe","Mehmet"}; foreach (string student in ogrenciler) { Console.WriteLine(student); }

Break: Döngünün kesilmesine ve program akışının döngü bloğunun dışına çıkmasına neden olur.Continue: Döngü bloğu içinde kendisinden sonra gelen deyime geçmeden akışı durdurur, döngü başına gönderir ve döngünün bir sonraki adımının atılmasını sağlar.

Örnek: Aşağıdaki örnekte 5 sayısı ekrana yazdırılmazusing System;namespace h1orn1{

class uygulama

{ static void Main() { int sayac; for (sayac = 0; sayac < 10; sayac++) { if (sayac == 5){ continue; } Console. WriteLine(sayac); }

} }}

Örnek: Klavyeden girilen sayıya kadarki sayıların karelerini toplayan programusing System;using System.Collections.Generic;using System.Linq;using System.Text;

namespace h1orn1{


int sayi, sayac, kare = 0, toplam = 0; Console.Write("bir sayı giriniz :"); sayi = Int32.Parse(Console.ReadLine());

for (sayac = 1; sayac <= sayi; sayac++) { kare = sayac * sayac; toplam = toplam + kare; }

Console.WriteLine("Girdiğiniz sayıya kadar olan sayıların karelerinin toplamı {0}", toplam); Console.ReadLine();

}

}}

Örnek: 1-100 arasındaki tek sayıları ekrana yazan programusing System;namespace h1orn1{


int sayi = 0; for (sayi = 0; sayi <= 99; sayi++) { sayi += 1; Console.WriteLine(sayi); }

} }}

Örnek: İstediğimiz kadar öğrenci notu girer ve çıkmak istediğimizde -1 tıklar çıkarız girdiğimiz öğrenci notlarını ortalamasını hesaplarusing System;namespace h1orn1{


int sayac=0; int toplam=0; string notstr="";

while (notstr != "-1") { sayac++; Console.Write("{0}.öğrencinin notu ,çıkmak için -1 girin :", sayac); notstr = Console.ReadLine(); toplam += Int32.Parse(notstr); } sayac--; Console.WriteLine("{0}.öğrenci girdiniz", sayac);

toplam++; Console.WriteLine("toplama not {0},ortalama{1}", toplam, toplam / sayac);

} }}

Örnek: Üstlü ifadenin değerini hesaplamausing System;namespace h1orn1{

class uygulama { static void Main() { int taban, ust; int sonuc=1; int sayac; string tabanstr, uststr; Console.Write("taban sayısını giriniz :"); tabanstr = Console.ReadLine(); Console.Write("üst sayısını giriniz :"); uststr = Console.ReadLine(); taban = Int32.Parse(tabanstr); ust = Int32.Parse(uststr); for (sayac = 1; sayac <= ust; sayac++) sonuc *= taban; Console.WriteLine("sonuc={0}", sonuc);

} }}

Ödev:1 Bankaya yatırılan 1000TL ye aylık %5 faiz verilmektedir; 12 ay sonra bu paranın ne kadar olacağını hesaplayan programı ay ay hesaplatınız.Ödev2: Hanelerinin toplamı, hane sayısına eşit olan 100-999 arasındaki tamsayıları bulan program. (Örneğin 102 tamsayısında; 1+0+2=3 haneler toplamıdır. Program bu tür tam sayıları üretecektir. Üç hanelei tam sayıları oluşturmak için iç içe 3 döngü kullanmalısınız.)

HAFTA 5: DİZİLER(ARRAYS)Genel olarak değişkenler tek bir değeri veya sınırlı bilgiyi tutmakta kullanılır. Ancak zaman zaman aynı değişken adı altında birçok değerin tutulması gerekebilir. Bu durumlar da diziler kullanılabilir. Diziler aracılığıyla bellek üzerinde bir alan tanımlanarak o alana değerler atanabilir..NET ortamında diziler değer türü olmayıp System.Array sınıfına sahip referans türleridir. Dizilerin barındıracağı tüm değerlerin aynı türden olması gerekir. Dizideki her elemanın dizi içindeki sırasını belirten bir konum numarası vardır. Buna indis(index) denir. İlk elemanın indis numarası 0 dır. En son indisin bir fazlası dizinin kaç elemanlı olduğunu verir. İndis tanımlaması için[ ] ler kullanılır. Diziler 1-2-3.. boyutlu olabilirler.

Tek Boyutlu Diziler:Aşağıda string türünde ve 3 elemanlı tek boyutlu bir dizi tanımlanmıştır. Dizi elemanlarına da değerler atanmıştır.

string[] Ogrenci = new string[3]; Ogrenci[0]="Ali"; Ogrenci[1] = "Veli"; Ogrenci[2]="Ayşe";

Dizilerin kendisi bir değer değildir. Kendisine ait nesnenin bellekte bulunduğu adresi işaret eden referanstır. Dizinin elemanları bellek üzerinde ardı ardına yerleştirilir. Burada veli 2. elemandır ve indis numarası 1 dir. Elemanlara değer atarken veya değerleri okurken girdiğimiz indis değerleri dizinin sınırlarını aşmamalıdır.

STACK(değer türler tutulur) HEAP(referans türler tutulur)

int[] dizi = new int[7] { 1, 2, 3, 4, 5, 6, 7 };

Diziler üstteki gibi değerleri verilerekte tanımlanabilirler. Eğer bir dizinin eleman sayısını önceden biliyorsak üstteki gibi belirtebiliriz. Bilmiyorsak dizi boyutunu dinamik olarak belirlemek gerekir. Bu durumda dizi uzunluğu biz yeni eleman ekledikçe kendiliğinden artar.

int[] dizi = new int[ ] { 1, 2, 3};

ALİ VELİ AYŞEögrenci


namespace h1orn1{

class uygulama { static void Main() { byte adet, sayac; Console.WriteLine("Kaç sayı girilecek?"); adet = Convert.ToByte(Console.ReadLine()); byte[] sayi = new byte[adet]; Console.WriteLine(""); for (sayac = 0; sayac <= adet-1;sayac++ ) { Console.WriteLine("{0}.sayıyı giriniz",sayac+1); sayi[sayac]=Convert.ToByte(Console.ReadLine()); } byte toplam = 0; double ortalama;

Console.WriteLine(""); Console.WriteLine("::::::Girilen sayılar:::::::"); for (sayac = 0; sayac <= adet - 1; sayac++) { Console.WriteLine("{0} . sayı: {1}",sayac+1,sayi[sayac]); toplam = Convert.ToByte(toplam+sayi[sayac]); } ortalama = toplam / (Convert.ToDouble(adet)); Console.WriteLine("Sayıların toplamı {0}",toplam); Console.WriteLine("Sayıların ortalaması {0}", ortalama); } }}

Çok Boyutlu Diziler:

Aşağıda 3*2 yani 3satır 2 sütunluk bir matris(2 boyutlu dizi) tanımlanmıştır. Dizi kaç boyutlu ise 1 eksiği kadar virgül koyulur. Dizinin uzunluğu satır ve sütun sayılarının çarpımı kadardır. Yani 6 dır.

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

3*3 LÜK MATRİS YAPISI

3 satır 3 sütunluk bir A dizisi ve elemanlarının yerleşimi

NOT: Dizilere eleman atarken ve dizinin elemanlarını kullanırken dizi boyutu sayısınca iç içe for döngüsü kullanılmalıdır.

Aşağıdaki örnek 1 den 12 ye kadar sayıları ekrana yazdıracaktır.

0.sütun 1. sütun 2.sütun

0.satır A[0,0] A[0,1] A[0,2]

1.satır A[10] A[1,1] A[1,2]

2.satır A[2,0] A[2,1] A[2,2]

using System;namespace h1orn1{

class uygulama { static void Main() { int t, i; int[,] dizi = new int[3, 4]; for (t = 0; t < 3; t++ ) { for (i = 0; i < 4; i++ ) { dizi[t, i] = (t * 4) + i + 1; Console.Write(dizi[t, i]); }

} Console.WriteLine(); } }}

dizi[t,i]=dizi[0,0]=1dizi[0,1]=2dizi[0,2]=3dizi[0,3]=4

dizi[1,0]=5dizi[1,1]=6dizi[1,2]=7

dizi[1,3]=8

dizi[2,0]=9dizi[2,1]=10dizi[2,2]=11

dizi[2,3]=12

Length() özelliği:Bu özellik dizinin tutabileceği eleman sayısını döndürür.

Örnek: elemanları dışarıdan girilen 10 elemanlı bir dizinin 3. elemanı ile 7. elemanını toplayıp ekrana yazan program.using System;using System.Collections.Generic;using System.Linq;using System.Text;

namespace h1orn1{

class uygulama { static void Main() { int[] dizi=new int[10]; int a, top = 0; for (a = 0; a < dizi.Length;a++ ) { Console.Write("{0}. elemanı gir",a); dizi[a]=Int32.Parse( Console.ReadLine());

} top = dizi[2] + dizi[6]; Console.Write(top); Console.ReadLine();

} }}

Örnek: n*n boyunda birim matris elde ederek ekrana yazdırınız.İpucu:3*3lük birim matris: 1 0 0 0 1 0 0 0 1


namespace h1orn1{

class uygulama { static void Main(string[] args) { int n, satir, sutun; Console.Write("n*n için n değerini giriniz"); n = Int32.Parse(Console.ReadLine()); int[,] a=new int[n,n]; for (satir = 0; satir <= n-1 ; satir++ ) //A birim matrisini oluştur. { for (sutun = 0; sutun <= n-1 ;sutun++ ) { if (satir == sutun) a[satir, sutun] = 1; else a[satir, sutun] = 0; }

} for (satir = 0; satir <= n-1; satir++) //Ekrana A matrisini yazdır { for (sutun = 0; sutun <= n-1; sutun++) { Console.Write(a[satir,sutun]+"\t"); } Console.WriteLine("\n"); } Console.ReadLine(); } }}

System.Array sınıfının özellik ve metodları:

1. SetValue( ): Nesne olarak oluşturulan dizinin elemanlarına değer atar.2. GetValue(): İndis numarası verilen dizi elemanını bulur.3. Rank: Bu özellik dizi uzunluğunu döndürür.4. Length: Dizinin eleman sayısını döndürür.5. GetLength(): Bu yordam GetLength(0) ifadesi ile çok boyutlu dizilerin satır

sayısını, GetLength(1) ifadesi ile çok boyutlu dizilerin sütun sayısını döndürür.6. Reverse(): Tek boyutlu dizinin elemanlarını ters sırada verir.7. Sort(): Dizi elemanlarını sıralar.

using System;namespace h1orn1{

class uygulama { static void Main(string[] args) { string[,] kayitlar =new string[2,3]; kayitlar.SetValue("ali",0,0); Console.WriteLine(kayitlar[0, 0]); //ekrana Ali yazacaktır. Console.WriteLine(kayitlar.GetValue(0, 0));//ekrana Ali yazar. Console.WriteLine(kayitlar.Rank); //ekrana 2 yazar Console.WriteLine(kayitlar.Length); //ekrana 6 yazar Console.WriteLine(kayitlar.GetLength(0));//ekrana 2 yazar Console.WriteLine(kayitlar.GetLength(1)); //ekrana 3 yazar } }}

Aşağıdaki örnek sort() metodunu açıklamaktadır.using System;namespace h1orn1{

class uygulama { static void Main(string[] args) { byte adet,sayac; Console.WriteLine("Kaç sayı girilecek?"); adet = Convert.ToByte(Console.ReadLine()); byte[] sayi = new byte[adet]; Console.WriteLine(""); for (sayac = 0; sayac <= adet - 1; sayac++) //diziye eleman atıyoruz { Console.WriteLine("{0}.sayıyı giriniz", sayac + 1); sayi[sayac] = Convert.ToByte(Console.ReadLine()); } for (sayac = 0; sayac <= adet - 1; sayac++) //diziyi ekrana yazdırıyoruz { Console.WriteLine("{0} . sayı: {1}", sayac + 1, sayi[sayac]); } Array.Sort(sayi);//sayi dizisini sıralıyoruz. Console.WriteLine("Sıraladıktan sonra görelim");

for (sayac = 0; sayac <= adet - 1; sayac++) //diziyi sıraladıktan sonra ekrana yazdırıyoruz. { Console.WriteLine("{0} . sayı: {1}", sayac + 1, sayi[sayac]);

} } }}

Ödev:1. Öğrenci sayısı dışarıdan girilmek üzere, bu sayı kadar elemana sahip bir A dizisi tanımlayarak öğrencilerin adını bu diziye alıp, ilk ve son öğrencinin isimlerini ekrana yazdıran program.2. 10 elemanlı bir dizinin elemanlarını küçükten büyüğe sıralatarak ekrana yazdırınız.3. n*n tipindeki 2 matrisin toplamını bulunuz(matematikte matrisleri toplama konusunu inceleyiniz.) 4. Elemanları dışarıdan girilen 3*3 lük bir matrisin en büyük elemanının satır numarasını bulunuz.5. Diziler için Copy,Clone() ve CopyTo() metodlarını araştırıp küçük örnek yapınız.

HAFTA 6: STATİK VE DİNAMİK ÖĞELER

Bir sınıfın static öğeleri , o sınıfa ait bir nesne yaratılmadan erişilebilen öğelerdir. Öğelere globallik(her yerden erişim) kazandırmanın 2 yolu vardır. Bunlardan birincisi public deyimini kullanmak diğeri ise öğeleri static olarak nitelemektir. Static öğeler sınıfın bir nesnesi içinde olmadığından onlara her yerden erişilebilir. Örneğin Main() metodu bu nedenle static nitelemesini alır. Nesnelerin yaratılıp yok edilmesi yada nesneler içindeki değişimler static öğeleri etkilemez. Bütün static üyeler değer veya referans türü olup olmamasına bakılmaksızın belleğin heap alanında tutulurlar.Static üyelerin ilk değeri atanmamış ise çalışma anında üye türüne göre değer verilir. Yani sayısal veri ise 0, nesne ise null, bool türü ise false değeri atanır.


namespace h1orn1{

class uygulama { public static void Main(string[] args) { Console.WriteLine("static mağaza kod değeri{0}", islem.magazakod); //islem sınıfındaki magazakod değişkenine //static olduğundan direk ulaşılabilir islem nesneislem = new islem(); Console.WriteLine("static olmayan siparis kod değeri{0}", islem.sipariskod); //Üstteki satır için hata oluşacaktır. //sipariskod değişkenine ulaşamaz. Console.WriteLine("static indirim değeri{0}", islem.indirim); //islem sınıfındaki indirim değişkenine // static olduğundan direk ulaşılabilir Console.WriteLine("magazakod değeri{0}",nesneislem.magazakod); //Üstte ise static bir değişkene nesne ile erişilmeye //çalışıldığı için hata vermektedir } public class islem { public int sipariskod = 45; public static string magazakod = "w32wwe"; public static bool indirim; //ilk değer otomatik olarak false atanır. } }}

**Static yordamlar sadece statik yordamlara erişebilirler. Aşağıdaki örnekte duragan adlı static metodumuz normal adlı dinamik metoda erişemez ve hata oluşur.

public class islem { public static void duragan { normal(); } public void normal() { //işlem kodları } }

NOT: Kurucular(yapıcılar) da static olarak tanımlanabilirler. Static yapıcılar:1. Doğrudan çağrılamaz; bu nedenle private olarak tanımlanırlar.2. Kaç nesne yaratılırsa yaratılsın sadece ilk nesnede bir kez çalıştırılır.3. Parametre alamazlar.4. Sınıfa ait her hangi bir instance(örnek )oluşturulmadan önce çalışırlar.5. Her hangi bir erişim tanımlayıcı alamazlar.6. Yeniden yüklenemezler (miras alınamazlar)

Statik sınıflar:Statik sınıflar static ifadesi ile tanımlanırlar. Statik bir sınıf, bu sınıfı içeren herhangi bir program veya isim uzayı yüklendiği zaman otomatik olarak belleğe yüklenir. Sadece static üye içerebilirler, içerisinde herhangi bir yapıcı yordam tanımlanamaz, bu sınıflardan başka sınıflar staticte olsalar türetilemezler. İçerisinde sadece static üye içeren sınıflardan new operatörü kullanılarak hiçbir şekilde nesne oluşturulamayacaktır. Aşağıdaki örnekte static bir sınıfa nesne oluşturularak çağrılma girişimi hataya yol açacaktır.using System;using System.Collections.Generic;using System.Linq;using System.Text;

namespace h1orn1{

class uygulama { public static void Main(string[] args) { islem nesne1 = new islem();//hatalı durum } static class islem { static int sayi; public static void kareal(int sayi) { Console.WriteLine("sayının karesi" + sayi * sayi); } }

}}

ERİŞİM BELİRTEÇLERİ

Bir nesnenin içerisindeki bazı özel üyeleri kullanıcılardan gizleyebilme özelliğine sarmalama(encapsulation) denir. Bunun görevi programcıdan programcıyı ilgilendirmeyen veya belirli arabirimler üzerinden erişilmesi istenen alanları saklamaktır. Verileri dıştan gelebilecek bozulmalara karşı korumaktır. Erişim belirleyiciler ve özellikler ile encapsulation işlemi gerçekleştirilebilir. Erişim belirleyiciler; kullanıcının sınıf içerisindeki değişken veya yordamlara nasıl ve ne zaman ulaşacağını karalaştıran niteleyicilerdir. Bir sınıf üyelerinin erişilebilirliğini sağlayan 4 belirleyici vardır.1. public Tüm erişimlere açık.2. private Sadece üyesi olduğu sınıftan erişilir.3. protected Üyesi olduğu sınıftan ve bu sınıftan türemiş sınıflardan erişilir.4. internal Etkin projeye ait sınıflardan erişilir. 5. protected internal Etkin projeye ait sınıflardan ve onların türevlerinden erişilebilir.

Sınıflar public ya da internal nitelemesi alabilirler. Protected ile private nitelemesi alamazlar.

Kitabımızın 169. sayfasındaki 1. örneğe bakalım. Burada Ev adlı sınıfımızda 3 adet değişken 4 adet metod tanımlanmıştır. Main bloğundan metodların hepsine direk erişim sağlandığı görülüyor. Çünkü metodlar public olarak nitelendirilmiştir. Ancak değişkenlerden sadece public olarak tanımlanan kapı adlı değişkene erişim sağlanabiliyor. Oda ve dolap değişkenleri private oldukları için erişim sağlanamıyor.

Şimdide 171. sayfadaki örneğe bakalım. Burada hesap adlı bir sınıf oluşturulmuş ve içinde topla ve çıkar adlı 2 metod tanımlanmıştır. Topla metodu public olduğu için main bloğundan erişilebilirken, çıkar metodu private olduğu için main bloğundan erişilemez. Eğer çıkar metodunu public, internal veya protect internal nitelemelerinden birini yapmak çıkar metoduna erişim için yeterli olacaktır. Ya da main metodunu hesap sınıfı içine dahil etmek programın çalışmasını sağlayacaktır. Çünkü private sadece üyesi olduğu sınıftan erişime izin verir.

METODLAR(YORDAMLAR)Metodlar, dışarıdan bilgi alarak veya almayarak belirli işlemleri gerçekleştirip geriye veri döndüren veya döndürmeyen kod parçacıklarıdır. Metodların işlemek üzere dışarıdan aldıkları değişkenlere parametre denir. Parametreler değer veya referans türünden değişkenler olabilir.void: Geriye değer döndürmeyen metodlar void sözcüğüyle ifade edilir.main: Bu isim eğer bir metoda verilecek olursa bunun anlamı programın bu metoddan başlayacağıdır. Eğer projede Main() metodu içeren birden fazla sınıf varsa projenin properties-startup object alanında programın ilk olarak başlayacağı sınıfın adı seçilmelidir.Return deyimi: Tek başına kullanıldığında metoddan çıkmak için return deyimi kullanılır. Return satırından sonraki kodlar çalıştırılmaz bu kodlara erişilmeyen kodlar denir.

class ucgen { public int alan; //sınıf içindeki metodlar tarafından ulaşılabilir. public void ucgenalanhesapla(int h,int taban) { alan=h*taban/2; // Alan hesaplanıyor } public int sonucugonder() { return alan; // alan değeri dışarı gönderiliyor. } } class Uygulama { static void Main() { ucgen obj_ucgen = new ucgen(); int sonuc = 0; int x, y; Console.WriteLine("yüksekliği giriniz"); x = Convert.ToInt32(Console.ReadLine()); Console.WriteLine("taban alanı giriniz"); y = Convert.ToInt32(Console.ReadLine()); obj_ucgen.ucgenalanhesapla(x, y); sonuc = obj_ucgen.sonucugonder(); Console.WriteLine("Üçgenin Alanı:{0}", sonuc); } }

Üstte ki programda metodların kullanımına bir örnektir. Ana programdan 2 parametre uçgen sınıfına ait bir ucgenalanhesapla metoduna gönderiliyor. Bu metodda hesaplanan alan sonucugonder metodu ile ana program bloğuna gönderilmektedir. Metodların dışında tanımlanmış değişkenlere genel(global), içinde tanımlanmış değişkenlere yerel(local) değişkenler denir. Örnek de üçgen sınıfının içindeki alan değişkeni genel bir değişkendir.

ParametrelerParametreler birer değişken oldukları için metodlara argüman girilirken parametrelerin türlerine dikkat edilmelidir. Bir metoda birden fazla parametre tanımlanabilir. Bu durumda her parametre virgülle ayrılmalıdır.Parametrelerin değer olarak aktarılması: Şu ana kadar işlenen örneklerde parametreler değer tipi olarak aktarıldı. Bu türde yapılmış parametreler üzerinde yapılan değişiklikler, gönderilen argümanı etkilemez. Bunun nedeni değişkenin kopyasının gönderilmiş olmasıdır. Fakat referans türü olarak gönderilirse argümanın değeri kopyalanmaz doğrudan bellekteki adresi üzerinde değişiklik yapılır.

class deger_test { public void karesi( int i) { i = i * i; } } class deger_uygulama { public static void Main() { deger_test obj_x = new deger_test(); int a = 20; Console.WriteLine("a nın ilk hali {0}", a); obj_x.karesi( a); Console.Write("a nın son hali {0}", a); } }

Parametrelerin referans olarak aktarılması: ref ve out anahtar kelimelerinin kullanımı sayesinde değer tiplerini referans olarak aktarmak mümkündür. Bir değer tipini neden referans olarak aktarmak isteyebiliriz sorusunun 2 yanıtı olabilir. İlki metodun kendi argümanının içeriğinin değiştirilmesine imkan vermek diğeri ise metodun birden fazla değer döndürmesine imkan vermek olabilir.class ref_test { public void karesi(ref int i) { i = i * i; } } class ref_uygulama { public static void Main() { ref_test obj_x = new ref_test(); int a = 20; Console.WriteLine("a nın ilk hali {0}",a); obj_x.karesi(ref a); Console.Write("a nın son hali {0}",a); } }

Out parametresi tek bir farkla ref parametresiyle aynıdır. Out sadece bir metoddan dışarıya bir değer aktarmak için kullanılır. Out parametresi kullanılarak ilk değer vermeden bir değişken metoda gönderilebilir.class out_uygulama { public static void Main() { byte X; islem(out X); Console.WriteLine("X değeri {0}", X); } public static void islem(out byte Y) { Y = 10; } }

Örnek de görüldüğü gibi X değişkeninin ilk değeri bulunmamaktadır. İşlem metoduna ilk değeri olmayan bir parametre gönderilmiştir. Son durumda X in değeri 10 olmuştur.

Metodlara Farklı Sayıda Parametre GöndermekBir metodun alacağı parametreler genellikle belli olmaktadır. Ama bazen bu sayı belli olmayabilir. Mesela en küçük sayıyı bulduran bir metod düşünelim. Bu durumda rastgele sayıda parametreye karşılık gelen özel tipte bir parametre kullanmalıyız. Bu parametre params dır. Params niteleyicisi sıfır yada daha fazla argüman alabilen bir dizi parametre deklare etmek için kullanılır.

class minimum { public int minimumdeger(params int[] sayilar) { int m; if (sayilar.Length == 0) { Console.WriteLine("Argüman olmadığı için hata oluştu"); return 0; } m = sayilar[0]; for(int i=1; i<sayilar.Length; i++) if(sayilar[i]<m) m=sayilar[i]; return m; } } class params_uygulama { public static void Main() { minimum obj_min = new minimum(); int min; int a = 10, b = 20; min = obj_min.minimumdeger(a, b, -1); //3 değer ile çağırma

Console.WriteLine("minimum değer{0}",min); min = obj_min.minimumdeger(18,23,3,14,55);// 5 değer ile çağırma Console.WriteLine("minimum değer{0}", min); int[] argumanlar ={ 45, 67, 34, 9, 112, 8 };//bir int dizisi ile çağrılabilir. min = obj_min.minimumdeger(argumanlar); Console.WriteLine("minimum değer{0}", min); } }

Örnekte minimumdeger metodu her çağrıldığında argümanlar sayılar dizisi üzerinden metoda aktarılır. Dizinin uzunluğu elman sayısına eşittir. Böylece bu metodu her sayıda en küçük sayıyı bulmakta kullanabiliriz.

Hazır metodlar:Şimdiye kadar kullandığımız Write(),WriteLine(),ReadLine() gibi metodlar Console sınıfına aittir.Kitabımızda sayfa 179 daki örnek Char sınıfına ait isLower() : Küçük harf ise true döndürür.isUpper() : Büyük harf ise true döndürür.isDigit() : Rakam ise true döndürür.isLetterOrDigit() : Alfa sayısal ise true döndürür. Metodları içeren bir örnek görmekteyiz.

Sayfa 183 de ise System.Math sınıfına ait Math.Abs() : Mutlak değerMath.Ceiling():kendisinden büyük bir sayıya yuvarlar. (15.8’i -16 yapar)Math.Round(): yuvarlama yapar.(13.2—13 ve 13.7—14 yuvarlar.)Math.Exp(): Logaritmik e değeri.Math.Floor():kendisinden küçük bir sayıya yuvarlar. (15.8’i -15 yapar)Math.Max():İki sayıdan büyük olanını verir. Math.Max(15,16)—16 çıkarMath.Min():İki sayıdan küçük olanını verir.Math.Sqrt():Sayının karekökünü alır.Math.Pow():1.sayı 2. sayının değeri kadar üssünü alır. Math.Pow(2,4)--16

Math.Cos(): kosinüsünü alır.Metodları içeren bir örnek görmekteyiz.

HAFTA 7: YAPI(STRUCT)Yapı, struct anahtar sözcüğü, birden çok üyesi olan yeni bir veri türü oluşturmak için kullanılır. Sınıflar gibi içerisinde kurucu, sabit, metod, özellik, değişken ve indeksleyici gibi üyeler tanımlanabilir; ancak yıkıcı(destructor) içermezler. Erişim belirteçlerini alabilirler.Sınıflardan farklı bir özellik olarak yapı içerisinde sabitler dışındaki genel alanlara başlangıç değeri verilmesine izin verilmez. Buna ancak yapının kurucu metodu içinde izin verilir. struct ogrenci{ string ad="murat"; //hatalı tanımlama string ad; const string ulke="Türkiye"; //doğru tanımlama }

Yapılar kalıtım kavramını desteklemezler. Sınıflar gibi yapılarda iç içe tanımlanabilirler.Yapı ile sınıf arasındaki en önemli fark; sınıfın referans türü olması, yapının ise değer türü olmasıdır. Bu yüzden sınıflar belleğin Heap alanında , yapılar ise stack alanı üzerinde tutulurlar. Yapılara doğrudan erişilebilir. Buda sınıfa oranla hız konusunda avantajlar sağlar. Yapılar genellikle büyüklüğü belli verileri saklamak için kullanılır. Programlarımız içerisinde nesnesel işlemlerin önemli olmadığı, sadece verileri gruplamaya ihtiyaç duyduğumuz yerlerde yapıları tercih edebiliriz.

Örnekte görüldüğü gibi yapılar sınıf içinde de oluşturulabilirler.

using System;

namespace h1orn1{

class uygulama { struct kimlik { public string ad; public int yas; } public static void Main(string[] args) { kimlik y = new kimlik(); y.yas = 19; y.ad = "dilek"; Console.WriteLine(y.yas); Console.WriteLine(y.ad);

} }}

Bir yapı nesnesi, bir sınıf nesnesi gibi aynı şekilde new kullanılarak oluşturulabilir; fakat bu gerekli değildir. New kullanılınca belirtilen yapılandırıcı çağırılır. New kullanılmıyorsa nesne bu durumda da oluşturulur fakat nesneye ilk değer atanmaz. Böylece, ilk değer atama işlemlerini elle gerçekleştirmek gerekecektir.

Aşağıda new operatörü kullanmadan yapılara erişim görülmektedir. Burada main() bloğu yapının içinde tanımlanmıştır.Örnekte eğer açıklama satırını aktif yapmazsak hata verir. Çünkü yapıyı temel veri tipi gibi kullanarak tanımlarsak, onun bütün öğelerine değer atamadan kullanamayız.

using System;

namespace h1orn1{ struct kimlik { static string ad = "Ali"; static int yas = 34;

public static void Main(string[] args) { /* kimlik k = new kimlik(); Console.WriteLine(k.yas); Console.WriteLine(k.ad); Bu şekilde nesne ile erişim yapamayız çünkü değişkenlerimiz static tanımlanmışlardır.*/ Console.WriteLine(kimlik.ad); Console.WriteLine(kimlik.yas);

} }

}

Aşağıda ise main() bloğunu yapı dışındaki bir sınıfın içine koyduk. Eğer kimlik yapısı içindeki değişkenlerin public anahtarlarını kaldırırsak, main() bloğundan erişim gerçekleşemezdi.

using System;

namespace h1orn1{ struct kimlik { public string ad ; public int yas ; } class uygulama { public static void Main(string[] args) { kimlik k = new kimlik(); k.ad="ali"; k.yas = 15; Console.WriteLine(k.ad +k.yas); } }}

Class lar konusunda değindiğimiz static nitelendirmelerin özellikleri yapılar içinde geçerlidir. Static nitelemeli değişkenler yapıya ait nesneler içinde yaratılamaz. Yapıya ait kaç nesne yaratılırsa yaratılsın, static değişkenin bir tek adresi ve dolayısıyla herhangi bir anda bir tek değeri vardır, o da en son atanan değerdir.

Şimdi kitabımızın 203. sayfasındaki örneği inceleyelim.

ÖZELLİK(ÖZGEN-PROPERTY)C#, sınıf değişkenlerini veri alanı ve özellik olarak 2 ‘ye ayırır. Alan ana bellekte kendine yer ayrılan normal bir değişkendir. Özellik ise alan ile metod arasında bir yerdir. Özellikler kontrollere ait özelliklerin belirlendiği alanlardır. Örneğin bir TextBox nesnesinin yazı rengini belirlemek için ilgili özelliğini(ForeColor) kullanmak gerekir. Özellikler get() ve set() adlı 2 metoddan oluşur. Veri okumaya çalışıldığında get(), veri yazılmaya çalışıldığında ise set() metodlarını kullanmamız gerekecektir. Özelliğe gönderilen değer value ifadesi ile temsil edilir.

class skorlar { private int skor; public int netice { get { return skor; } set { skor = value; } } }

Üstteki örnekte private olan skor değişkenine değer atama ve okuma eylemelerini public olan netice değişkeni yapıyor. Böylece sınıf dışından erişilemeyen private nitelemeli değişkene dışarıdan erişilme olanağı yaratılıyor.

using System;namespace h1orn1{ class kisi { private int yas; private string dogumyeri;

public int yasim { get { return yas; } set { if (value <= 65 && value >= 18) { yas = value; } else yas = 18; }

} public string dogumyerim { get { return dogumyeri; } set {

dogumyeri = value;

}

}

} class uygulama { static void Main(string[] args) { kisi mehmet = new kisi(); kisi dilek = new kisi(); mehmet.yasim = 21; mehmet.dogumyerim = "malatya"; dilek.yasim = 18; dilek.dogumyerim = "izmir";

Console.WriteLine("Mehmet'in yaşı{0} ve doğum yeri {1} dir",mehmet.yasim,mehmet.dogumyerim); Console.WriteLine("Dilek'in yaşı{0} ve doğum yeri {1} dir", dilek.yasim, dilek.dogumyerim);

} }}

HAFTA 8: STRING VE KARAKTER BİÇİMLENDİRME

Katar veya sözce olarak kullanılan string kavramı ardı ardına gelen karakter dizisi anlamına gelir ve System.String sınıfını temsil eder.String türü düşünüldüğünün aksine değer değil bir referans türüdür ve heap alanında tutulur. Nitekim string türünde bir değişken tanımlandığı zaman arka planda System.string sınıfından bir örnek oluşturulmuş olur. String türü immutable karakterli olup bir kere tanımlandıktan sonra bir daha değeri değiştirilemez.Peki uygulamalarda bu değer nasıl sonradan değiştirilebiliyor.

string str = "merhaba dünya"; str.Replace("merhaba","selam");

Üstteki ifadede str değişkenine replace () metodu uygulanmıştır. Bu işlemden sonra selam dünya olması beklenirken merhaba dünya olarak kaldığı görülür.

string str = "merhaba dünya"; str = str.Replace("merhaba","selam");

şeklinde düzenlersek selam dünya mesajı döner.2. kodun yaptığı şey str değişkeninin işaret ettiği string nesnesinin asıl değerini değiştirmedi, yaptığı şey yeni değeri(selam dünya) yani bir bellek alanında tutup str işaretçisini bu yeni bellek alanını gösterecek şekilde güncellemektir. Oysa hala bellek üzerinde merhaba dünya duruyor ama ona ulaşamıyoruz.

String türünün diğer özelliği null değer alabilmesidir. Bu durumda bellek üzerinde bir alan ayrılmaz ve length özelliği kullanıldığında hata mesajı çıkar. String.Empty değeri atanması halinde içi boş olarak bellekten bir alan ayrılır ve length özelliği kullanıldığında 0 değeri alınır.

Aslında string ler elemanları char türünde olan bir dizi yapısıdır. Bu yönüyle string sınıfının indeksleyicisi kullanılarak istenilen elemana erişilebilir. Aşağıdaki kod çalıştığında e harfini ekrana yazacaktır.using System;namespace h1orn1{ class uygulama { static void Main(string[] args) { string str = "merhaba dünya"; char chr = str[1]; Console.WriteLine(chr); } }}

C# dilinde bazı karakterlerin komut olarak algılanmaması için kaçış karakterleri( \ ) kullanılır.1. string str = "merhaba \"dünya\" nasılsın";2. string yol="C:\Windows\System32"; yerine string yol="C:\\Windows\\System32";

String Sınıfının Metodları:

A.Karşılaştırma Yordamları1. Equals(): İki string değişkenin değerini karşılaştırır ve geriye bool türünde bir

değer döndürür.2. Compare To(): iki değer birbirine eşitse 0, ilk değer küçük ise -1 ve ilk değer

büyükse 1 değerlerini geri döndürür.

using System;namespace h1orn1{ class uygulama { static void Main(string[] args) { string output; long deger1; long deger2; deger1 = 15; deger2 = 15; output = deger1.Equals(deger2).ToString(); Console.WriteLine(output); //Sonuç true olarak gelir

} }}

using System;namespace h1orn1{ class uygulama { static void Main(string[] args) { string output; long deger1; long deger2; deger1 = 15; deger2 = 15; output = deger1.CompareTo(deger2).ToString(); Console.WriteLine(output); //Sonuç sıfır olarak gelir.

} }}

B.Arama Yordamları1. IndexOf(): Sözce içerisinde herhangi bir karakteri veya alt sözceyi arar.

Geriye aranılan değerin bulunduğu yerdeki ilk konumunu döndürür. Arama sonucu bir şey bulamaz ise -1 döndürür. LastIndexOf() ise aranılan değerin bulunduğu yerdeki en son konumu döndürür.

2. IndexOfAny():Bu metod bir string içinde bir karakter dizisine ait herhangi bir karakterin olup olmadığını denetler, varsa bulduğu karakterin string içinde kaçıncı karakterden sonra geldiğini belirtir. Bulamazsa -1 değerini alır.

using System;namespace h1orn1{ class uygulama { static void Main(string[] args) { string s = "[email protected]"; Console.WriteLine(s.IndexOf("n")); //2 Console.WriteLine(s.IndexOf("com")); //18 Console.WriteLine(s.IndexOf("s")); //-1 Console.WriteLine(s.IndexOf("S")); //0

char[] kayit = { '#','%','&','@'}; Console.WriteLine(s.IndexOfAny(kayit)); //9 } }}

B.Birleştirme ve Parçalama:1. Concat(): Sözcükleri birleştirmek için kullanılır. + operatörü ile eşdeğerdir.

Console.WriteLine(string.Concat("Galata","saray"));//Galatasaray

2. Join(): String türündeki bir dizinin elemanlarını tek bir string değişkende birleştirir. string[] kisiler = { "Ali","Veli","Ayşe"}; string cumle = string.Join("-",kisiler); Console.WriteLine(cumle); //Ali-Veli-Ayşe

3. Split():String türündeki veriyi belirtilen bir ayraç karaktere göre parçalayıp alt sözcükler şeklinde bir dizi oluşturur.

string cumle = "Ali-Veli-Ayşe"; string[] kisiler = cumle.Split('-'); foreach (string k in kisiler) { Console.WriteLine(k); }

4. PadRight() ve PadLeft(): String değerin sağına ve soluna belirli sayıda

karakterler ekleyerek uzunluğunu belirli bir adete tamamlar. string urunkod = "123"; urunkod = urunkod.PadRight(8, '0'); //12300000 urunkod = urunkod.PadLeft('0',8); //00000123 Console.WriteLine(urunkod);

C.Kopyalama ve Değiştirme:1. CopyTo(): Bir string’in belirli bir konumdan sonraki karakterlerini konumu

ve uzunluğu belli bir diziye kopyalar. string soyad = "can"; //kaynak değer char[] adsoyad = { 'A','l','i',' ','Ş','e','n'};//hedef değer Console.WriteLine(adsoyad); //Ali Şen soyad.CopyTo(0, adsoyad, 4, soyad.Length);

Console.WriteLine(adsoyad); //Ali Can

Burada 4 parametre var. İlki kaynak değerin başlangıç parametresi, 2. si hedef değer, 3.kopyalanmaya başlanacak indeks 4.sü kaynak değer uzunluğu 2. Insert(): Bir string değeri başka bir string içine belirli bir konumdan itibaren ekler. string metin="İstanbul'da hava çok güzel."; string ekmetin="daha" ; metin =metin.Insert(20,ekmetin); Console.WriteLine(metin); //İstanbul'da hava çok daha güzel.

3. Replace(): String değer içinde belirtilen bir karakter veya alt stringi bir başka string ile yer değiştirir.

string metin="İstanbul'da hava çok güzel."; string yenimetin ; yenimetin = metin.Replace("İstanbul","Ankara"); Console.WriteLine(yenimetin);//Ankara'da hava çok güzel

4. SubString(): Bir string içerisinde başlangıç yeri ve uzunluğu belirtilen alt stringi seçer. string metin="İstanbul'da hava çok güzel."; string yenimetin ; yenimetin = metin.Substring(0,8); Console.WriteLine(yenimetin);//İstanbul

5. ToLower()- ToUpper(): Değişkenin içeriğini küçük harfe ve büyük harfe çevirirler.

string metin="İstanbul'da hava çok güzel."; metin = metin.ToUpper();

Console.WriteLine(metin); //İSTANBUL'DA HAVA ÇOK DAHA GÜZEL.

6. Trim()-TrimStart()-TrimEnd(): Bir string’in başındaki ve sonundaki boşluk karakterlerini siler. TrimStart sadece başındaki TrimEnd ise sondaki karakterleri siler.

Ödev: Kitabınızın 228. sayfasındaki alıştırmaları yapınız.

Char YapısıC# dilinde Char bir sınıf değil, bir yapıdır(struct). Unicode karakterlerini temsil eder. Kitabınızın 234. sayfasında Unicode sistemi hakkında bilgi alabilirsiniz. Char yapısının bir çok metodu bulunmaktadır. Bunlardan bazılarını açıklayalım.1.GetNumericValue():Bir karakter rakam ise mevcut değerini, değilse de -1 değerini döndürür. char x='a'; Console.Write(char.GetNumericValue(x)); //-1

2. IsLetter():Bir karakterin ya da bir stringin içinde numarası verilen karakterin bir harf olup olmadığını belirler. Harf ise True, değilse False döndürür.

HAFTA 9: KALITIM(INHERITANCE)OOP’nın en önemli bacağını teşkil eden kalıtım, var olan bir sınıftan yeni bir sınıf türetme işlemidir. Bu işlem hem var olan sınıfları geliştirmemizi onları kendi isteğimize göre şekillendirmemizi hem de sil baştan sınıflar oluşturmamızı sağlar. Yapılan işlem asıl sınıfı miras alıp ondan yeni bir sınıf türetmektir. Türetilen sınıflar, türediği sınıfın üyelerine sahip olup tüm özelliklerini taşır. Ana sınıftan birçok sınıf türetilebilir. Bir sınıfın ise sadece bir ana sınıfı vardır.Kalıtımın amacı, sınıflar arsında ilişki kurarak sınıfların bazı özelliklerini birbirlerinden miras almasını sağlamaktır. Günlük hayatta da örneğin bir araba modeli geliştirilecek ise öncelikle önceki modelini temel alarak onun üzerinde değişiklik yaparız.

using System;namespace h1orn1{ public class atarabasi { public byte tekerleksayisi { get { return 4; } } }

public class ferrari : atarabasi { byte kapisayisi;

public byte Kapisayisi { get { return kapisayisi; } set { kapisayisi = value; } } }

class uygulama { static void Main(string[] args) { ferrari nesneferrari = new ferrari(); nesneferrari.Kapisayisi = 2; Console.WriteLine("Ferrarinin kapı sayısı:{0}", nesneferrari.Kapisayisi); Console.WriteLine("Ferrarinin teker sayısı:{0}", nesneferrari.tekerleksayisi);

} }}

Örneğimizi Ferrari‘nin aslında ilk arabalardan sayabileceğimiz at arabasında türediğini düşünerek incelememiz doğru olacaktır. Peki Ferrari’nin at arabasından miras alacağı özelliği ne olabilir? Cevap tekerlek sayısıdır. public class ferrari : atarabasi Satırını incelersek : işaretinin kalıtımı tanımladığını görebiliriz. Yani ferrari sınıfı atarabası sınıfından türeyecektir.

Türemiş sınıflar, türedikleri ana sınıflarından private türündeki üyelere erişemezler. Bu sıkıntıyı aşmak için sadece türeyen sınıfın erişebileceği protected niteleyicisi kullanılır.Sınıflar kalıtımı destekleme konusunda 3’e ayrılır.

Inherit (miras) edilemeyen sınıflar Inherit edilmesi zorunlu sınıflar Normal sınıflar

Sealed sözcüğü ile bir sınıfı tanımlarsak bu sınıf herhangi bir türeme gerçekleştiremez. Abstract sözcüğü ile bir sınıfı tanımlarsak bu sınıf başka bir sınıf tarafından inherit edilmeden kullanılamaz.Override sözcüğüyle tanımlanan bir sınıf, türediği sınıfın üyelerini geçersiz kılabilir/üzerine yazabilir. Tabi bu her üyeyi geçersiz kılar anlamına gelmez. Sadece üzerine yazılmasına izin verilen üyeler geçersiz kılınabilir. Bir üyeyi üzerine yazılabilir yapmak için virtual sözcüğü kullanılır. Aynı şekilde override edilmesine izin verilmeyen üyeler sealed ile tanımlanır.

using System;namespace h1orn1{ //::::::::::::Temel Şahıs Sınıfı::::::::: public abstract class sahis { public string adsoyad; public abstract string meslek { get; } public virtual void bilgi() { Console.WriteLine("Adı Soyadı:{0}", adsoyad); Console.WriteLine("Mesleği:{0}", meslek); } public string temelsinifadi { get { return "Şahıs sınıfı"; }

}

} //::::::::::::Öğrenci Sınıfı::::::::: public class ogrenci : sahis { public string dersdurumu; //Temel sınıftaki meslek özelliği geçersiz kılınması //gerektiğinden yeniden tanımlandı public override string meslek { get { return "ogrenci"; } }

public override void bilgi() { Console.WriteLine("Adı Soyadı:{0}", adsoyad); Console.WriteLine("Mesleği:{0}", meslek); Console.WriteLine("Ders durumu:{0}", dersdurumu); } }

//::::::::::::Tüccar Sınıfı::::::::: public class Tuccar : sahis { public string servet; //Temel sınıftaki meslek özelliği geçersiz kılınması //gerektiğinden yeniden tanımlandı public override string meslek { get { return "İş Veren"; } }

public override void bilgi() { Console.WriteLine("Adı Soyadı:{0}", adsoyad); Console.WriteLine("Mesleği:{0}", meslek); Console.WriteLine("Servet:{0}", servet); } }

class uygulama

{ static void Main(string[] args) { ogrenci nesneogrenci = new ogrenci(); nesneogrenci.adsoyad = "Ali serdar"; nesneogrenci.dersdurumu = "Başarılı"; Console.WriteLine("Öğrenci sınıfının miras aldığı sınıf:{0}", nesneogrenci.temelsinifadi); nesneogrenci.bilgi(); Console.WriteLine("--------------------"); Tuccar nesnetuccar = new Tuccar(); nesnetuccar.adsoyad = "Ali serdar"; nesnetuccar.servet = "100bin lira"; Console.WriteLine("Tuccar sınıfının miras aldığı sınıf:{0}", nesnetuccar.temelsinifadi); nesnetuccar.bilgi(); Console.ReadLine();

} }}

Örnekte Şahıs sınıfına ait bilgi metodu, şahıs sınıfından türemiş olan öğrenci ve tüccar sınıflarında üzerine yazılarak ekleme yapılmıştır. Eğer bilgi metodu virtual olarak tanımlanmasaydı üzerine yazılamazdı. Aynı şekilde öğrenci ve tüccar sınıflarındaki bilgi metodu da override yapılarak türediği sınıfın üzerine yazabilmektedirler.Şahıs sınıfı abstract olarak tanımlandığı için türediği sınıflardan başka yerde kullanılamaz. Meslek özelliğini öğrenci ve tüccar sınıfında yeniden oluşturmamızın nedeni, şahıs sınıfında meslek özelliğinin geçersiz kılıması gerektiğinden abstract olarak tanımlanmasından dolayıdır.

HAFTA 10: ARAYÜZLER (INTERFACES)C++ programlama dilinde, sınıflar arasında çok kalıtımlılık söz konusu idi. Yani bir sınıf, kalıtımsal olarak, birden fazla sınıftan türetilebiliyordu. Ancak bu teknik bir süre sonra kodların daha da karmaşıklaşmasına ve anlaşılabilirliğin azalmasına neden oluyordu. Bu sebepten ötürü değerli Microsoft mimarları, C# dilinde, bir sınıfın sadece tek bir sınıfı kalıtımsal olarak alabileceği kısıtlamasını getirdiler. Çok kalıtımlık görevini ise anlaşılması daha kolay arayüzlere bıraktılar. İşte ara yüzleri kullanmamızın en büyük nedenlerinden birisi budur.

Diğer yandan, uygulamalarımızın geleceği açısından da ara yüzlerin çok kullanışlı olabileceğini söylememiz gerekiyor. Düşününki, bir ekip tarafından yazılan ve geliştirilen bir uygulamada görevlisiniz. Kullandığınız nesnelerin, türetildiği sınıflar zaman içerisinde, gelişen yeniliklere adapte olabilmek amacıyla, sayısız yeni metoda, özelliğe vb.. sahip olduklarını farz edin. Bir süre sonra, nesnelerin türetildiği sınıflar içerisinde yer alan kavram kargaşasını, "bu neyi yapıyordu?, kime yapıyordu? , ne için yapıyordu?" gibi soruların ne kadar çok sorulduğunu düşünün. Oysa uygulamanızdaki sınıfların izleyeceği yolu gösteren rehber(ler) olsa fena mı olurdu? İşte size ara yüzler. Bir ara yüz oluşturun ve bu ara yüzü uygulayan sınıfların hangi metodları, özellikleri vb kullanması gerektiğine karar verin. Programın gelişmesi mi gerekiyor? Yeni niteliklere mi ihtiyacın var? İster kullanılan arayüzleri, birbirlerinden kalıtımsal olarak türetin, ister yeni arayüzler tasarlayın. Tek yapacağınız sınıfların hangi arayüzlerini kullanacağını belirtmek olacaktır.

Yazılan kod bloğunun bir arayüz olduğunu Interface anahtar sözcüğü belirtmektedir. Arayüz isminin başında I harfi kullanıldığına dikkat edin. Bu kullanılan sınıfın bir arayüz olduğunu anlamamıza yarayan bir isim kullanma tekniğidir.Arayüzler sadece özellikler, metodlar, olaylar ve indeksleyicilere sahip olabilirler. Yapıcı, yok edici ve alanları kesinlikle kullanamazlar.

Peki bu üyeler nasıl tanımlanır. Her şeyden önce arayüzler ile ilgili en önemli kural onun bir rehber olmasıdır. Yani arayüzler sadece, kendisini rehber alan sınıfların kullanacağı üyeleri tanımlarlar. Herhangi bir kod satırı içermezler. Sadece özelliğin, metodun, olayın veya indeksleyicinin tanımı vardır. Onların kolay okunabilir olmalarını sağlayan ve çoklu kalıtım için tercih edilmelerine neden olan sebepte budur.

public interface IArayuz{ /* double tipte bir özellik tanımı. get ve set anahtar sözcüklerinin herhangibir blok {} içermediğine dikkat edin. */

double isim { get; set; }

/* Yanlız okunabilir (ReadOnly) string tipte bir özellik tanımı. */ string soyisim { get ; }

/* integer değer döndüren ve iki integer parametre alan bir metod tanımı. Metod tanımlarında da metodun dönüş tipi, parametreleri, ismi dışında herhangi bir kod satırı olmadığına dikkat edin. */

int topla(int a, int b);

/* Dönüş değeri olmayan ve herhangi bir parametre almayan bir metod tanımı. */

void yaz();

/* Bir indeksleyici tanımı */ string this [ int index] { get; set; }}

Görüldüğü gibi sadece tanımlamalar mevcut. Herhangi bir kod satırı mevcut değil. Bir arayüz tasarlarken uymamız gereken bir takım önemli kurallar vardır. Bu kurallar aşağıdaki tabloda kısaca listelenmiştir.

Bir arayüz'ün tüm üyeleri public kabul edilir. Private, Protected gibi belirtiçler kullanamayız. Bunu yaptığımız takdirde örneğin bir elemanı private tanımladığımız takdirde, derleme zamanında şu hatayı alırız. "The modifier 'private' is not valid for this item"

Diğer yandan bir metodu public olarakta tanımlayamayız. Çünkü zaten varsayılan olarak bütün üyeler public tanımlanmış kabul edilir. Bir metodu public tanımladığımızda yine derleme zamanında şu hatayı alırız. "The modifier 'public' is not valid for this item"

Bir arayüz, bir yapı(struct)'dan veya bir sınıf(class)'tan kalıtımla türetilemez. Ancak, bir arayüzü başka bir arayüzden veya arayüzlerden kalıtımsal olarak türetebiliriz.Arayüz elemanlarını static olarak tanımlayamayız.Arayüzlerin uygulandığı sınıflar, arayüzde tanımlanan bütün üyeleri kullanmak zorundadır.

using System;

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

public interface ISifre{ string kodlayici(string str); string cozucu(string str);}

class basitsifre : ISifre{ //Orijinal metin verilince şifrelenmiş strigi döndürür. public string cozucu(string str) { string sifretext = " "; for (int i = 0; i < str.Length; i++)

sifretext = sifretext + (char)(str[i] + 1);

return sifretext; }//Şifrelenmiş metin verilince şifresi çözülmüş stringi döndürür. public string kodlayici(string str) { string normaltext = " "; for (int i = 0; i < str.Length; i++)

normaltext = normaltext + (char)(str[i] - 1);

return normaltext; }}class bitsifre : ISifre{ ushort key;//bitsifre kurarken bir anahtar belirtildi. public bitsifre(ushort k) { key = k; }//Orijinal metin verilince şifrelenmiş strigi döndürür. public string cozucu(string str) { string sifretext = " "; for (int i = 0; i < str.Length; i++)

sifretext = sifretext + (char)(str[i] ^ key);

return sifretext; }

//Şifrelenmiş metin verilince şifresi çözülmüş stringi döndürür.

public string kodlayici(string str) { string normaltext = " "; for (int i = 0; i < str.Length; i++)

normaltext = normaltext + (char)(str[i] ^ key);

return normaltext; }}

class Isifredemo{ static void Main(string[] args) { ISifre sifreref; bitsifre bit = new bitsifre(27); basitsifre bs = new basitsifre(); string normal; string kod; //öncelikle sifreref, basitsifreleyiciye referansta bulunur. sifreref = bs; Console.WriteLine("Basit şifre kullanımı"); normal = "testing"; kod = sifreref.cozucu(normal); Console.WriteLine("Sifreli Text:"+kod);

normal = sifreref.kodlayici(kod); Console.WriteLine("Normal text:"+normal); //artık, sifreref’in bit tabanlı şifrelemeye referansta bulunmasına //izin ver sifreref = bit; Console.WriteLine("\n bitsel şifreleme kullanımı"); normal = "testing"; kod = sifreref.cozucu(normal); Console.WriteLine("Sifreli Text:" + kod); normal = sifreref.kodlayici(kod); Console.WriteLine("Normal text:" + normal);

}}

Bu örnekte Isifre adında bir arayüz oluşturulmuştur. Isifre içinde şifreleme için kullanılan stringleri destekleyen metodlar belirtilecektir. Isifre içinde 2 metod belirtilmektedir. Kodlayıcı ve çözücü. Şimdi Isifre ara yüzünü uygulayan 2 sınıfa göz atalım. Basitşifre sınıfı; her karakteri bir konum yukarı kaydırarak bir string i şifreler.(A,B olur B,C olur gibi). Bitsifre sınıfı ise bir anahtar gibi davranan 16 bitlik bir değer ile her karaktere XOR uygulayarak bir karakter katarını şifreler.Basitsifre ve bitsifre uygulamada farklılık gösteriyor olsa da her ikisi de ISifre arayüzünü uygulamaktadır.

HAFTA 11: KOLLEKSİYONLARKolleksiyon nesneleri dizilerin yapısına benzer olup çoklu eleman üzerinde işlem yapılmasını sağlarlar. Bu işlemler için System.Collection isim uzayı altında çeşitli sınıf ve arabirimler bulunmaktadır. Özellikle klasik dizi yapısının yetersiz kaldığı durumlarda tercih edilirler. Koleksiyonlar nesnelerin gruplandırılmasında kolaylık sağlarlar, ayrıca boyut ve büyüklüğünün başlangıçta belirtilmesine gerek yoktur. Diziler gibi çok boyutlu olmayıp tek boyutludurlar. Koleksiyon sınıflarının tuttuğu değerler object türündedir.

1.ArrayListNormal dizi yapısı gibi veri grubunu saklamak için kullanılan bir nesnedir. İndis yapısı kullanılır. Ekleme, silme,sıralama,arama,ters çevirme gibi işlemler için özel metodlar içerir.

using System;using System.Collections;//Eklemeyi unutmayınusing System.Collections.Generic;using System.Linq;using System.Text;

namespace ConsoleApplication1{ class Program { static void Main(string[] args) { ArrayList kayitlar = new ArrayList(); byte x = 0; kayitlar.Add("Berna"); kayitlar.Add("Ali"); kayitlar.Add("Kemal"); kayitlar.Add("Aslı"); kayitlar.Add("Süleyman"); Console.WriteLine("kayıtlar listeleniyor"); Console.WriteLine("---------------------------"); for (x = 0; x <= kayitlar.Count - 1;x++ ) { Console.WriteLine(Convert.ToString(kayitlar[x]));

} Console.WriteLine("kayıt sayısı bulunuyor"); Console.WriteLine("----------------------------"); byte kayitsayisi = (byte)kayitlar.Count; Console.WriteLine(kayitsayisi);

Console.WriteLine("Kemal sözcüğü aranıyor"); Console.WriteLine("----------------------------"); Int32 sonuc = 0; //Büyük küçük harfe duyarsız arama yapar. sonuc = kayitlar.BinarySearch("kemal",new CaseInsensitiveComparer()); if (sonuc > 0) { Console.WriteLine("Kemal kaydı{0}. indekste bulundu", sonuc); } else { Console.WriteLine("Kayıt bulunamadı"); }

Console.WriteLine("Kayıtlar sıralanıyor"); Console.WriteLine("----------------------------"); kayitlar.Sort(); for (x = 0; x <= kayitlar.Count - 1; x++) { Console.WriteLine(Convert.ToString(kayitlar[x]));

}

Console.WriteLine("Süleyman siliniyor"); Console.WriteLine("----------------------------"); kayitlar.Remove("Süleyman"); for (x = 0; x <= kayitlar.Count - 1; x++) { Console.WriteLine(Convert.ToString(kayitlar[x]));

}

Console.WriteLine("Ters çevriliyor"); Console.WriteLine("----------------------------"); kayitlar.Reverse(); for (x = 0; x <= kayitlar.Count - 1; x++) { Console.WriteLine(Convert.ToString(kayitlar[x]));

}

Console.WriteLine("Leyla yı en başa ekler"); Console.WriteLine("----------------------------"); kayitlar.Insert(0, "Leyla"); for (x = 0; x <= kayitlar.Count - 1; x++) { Console.WriteLine(Convert.ToString(kayitlar[x]));

} } }}

ArrayList türü eleman eklendikçe kendini genişletir.Genişleme ölçüsücapacitiy olarak tanımlanan nesnenin sığasıyla ilglidir. Varsayılan sığa 16 dır. Eğer 5 kayıt girilecekse 5 elemanlık bellek ayrılması uygundur. Bunun için TrimToState() metodu kullanılarak liste kapasitesi eleman sayısına eşitlenebilir. ArrayList kayitlar1 = new ArrayList(); kayitlar1.Add("Berna"); kayitlar1.Add("Ali"); kayitlar1.Add("Kemal"); Console.WriteLine("default kapasite {0}", kayitlar1.Capacity);//16 kayitlar1.TrimToSize(); Console.WriteLine("şuanki kapasite {0}",kayitlar1.Capacity);//3

2.HastableArrayList ‘ten farklı olarak her elemana bir indis değeri verilmesi yerine belli bir anahtar(key) verilir. Bir kere tanımlanan anahtar değeri bir daha değişemez. Anahtarlar Add() metodu ile eklenirler. Anahtar değeri tekil olmalıdır. Hastable nesnesinde hem değer hem de anahtar içeriğine göre arama yapılabilir. Değer alanına

göre arama yapmak için ContainsValue(), Key değerine göre arama yapmak için ContainsKey() metodları kullanılır. Her iki metod da bool türünden değer döndürür. Aşağıda hem değer hem de anahtara göre arama yapılmıştır.


namespace ConsoleApplication1{ class Program { static void Main(string[] args) { Hashtable sehirler = new Hashtable(); sehirler.Add("A", "Adana"); sehirler.Add("B", "Bursa"); sehirler.Add("D", "Denizli"); //sehirler.Count(); Eleman sayısı öğrenilebilir //sehirler.Remove("B"); Bursa yı siler //sehirler.Clear(); Hepsini temizler Console.WriteLine("Aranacak değeri giriniz"); string sehir = Console.ReadLine(); if (sehirler.ContainsValue(sehir)) { Console.WriteLine("{0} değeri bılundu", sehir); } else { Console.WriteLine("{0} değeri bulunamadı", sehir); } Console.WriteLine("Aranacak anahtarı giriniz"); string key = Console.ReadLine(); if (sehirler.ContainsKey(key)) { Console.WriteLine("{0} anahtar bulundu", key); } else { Console.WriteLine("{0} anahtar bulunamadı", key); }

} }}

3.SortedList(Sıralı Liste)HasTable gibi key/value mantığı üzerine kurulu bir kolleksiyon sınıfıdır. Tek fark elemanların hep sıralı tutulmasıdır.


namespace ConsoleApplication1{ class Program { static void Main(string[] args) { SortedList sehirler = new SortedList();

sehirler.Add("B", "Bursa"); sehirler.Add("D", "Denizli"); sehirler.Add("A", "Adana"); sehirler.Add("Z","Zonguldak"); Console.WriteLine("Tüm elemanlar:"); foreach (string anahtar in sehirler.Keys) { Console.WriteLine(sehirler[anahtar]); }

} }}

4.Yığın(Stack)Stack nesnelerin üst üste konularak oluşturulduğu liste yapısıdır. Tenis toplarının konulduğu silindir kutuları yığın gibi düşünülebilir. Kutuya ilk konan top en son, son konan top ise ilk alınır. Yığından okuma işlemi sadece en son elemanı döndürür.Push() fonksiyonu yığına eleman eklemekte, pop() fonksiyonu en üstteki elemanı listeden çıkararak almamızı sağlar.Peek() ise en üstteki elemanı listeden çıkarmadan okumamızı sağlar. Diğer listeler gibi clear ve count kullanılabilir.


namespace ConsoleApplication1{ class Program { static void Main(string[] args) { Stack harfler = new Stack(3); harfler.Push("A"); harfler.Push("B"); harfler.Push("C"); foreach(string harf in harfler){

Console.WriteLine(harf); } Console.WriteLine("şimdi en üsttekini çağıralım"); Console.WriteLine(harfler.Pop());

Console.WriteLine("Şimdi yığında arama yapalım"); if (harfler.Contains("B")) { Console.WriteLine("Yığında B harfi var"); }else Console.WriteLine("Yığında B harfi yok"); } }}

4.Kuyruk(Queue)Davranış olarak yığının tersidir. İlk giren ilk çıkar şeklinde davranır. Varsayılan kapasitesi 32 elemandır. Enqueu() , listenin sonuna eleman ekler, Dequeu() listenin en baştaki elemanını kuyruktan çıkararak alır. Peek() ise kuyruktan çıkarmadan alır. Ayrıca TrimToSize,count ve clear özellikleride kullanılabilir.Kuyrukta arama yapmak için yine Contains() fonksiyonu kullanılır.


namespace ConsoleApplication1{ class Program { static void Main(string[] args) { Queue kuyruk=new Queue(); kuyruk.Enqueue("Selim"); kuyruk.Enqueue("Mehmet"); kuyruk.Enqueue("Ayşe"); foreach(string x in kuyruk){ Console.WriteLine(x); } Console.WriteLine("şimdi en üsttekini çağıralım"); Console.WriteLine(kuyruk.Dequeue());

Console.WriteLine("Şimdi kuyrukta arama yapalım"); if (kuyruk.Contains("Orhan")) { Console.WriteLine(" var"); }else Console.WriteLine(" yok"); } }}

5.BitArrayBool değerlerden oluşan bitleri saklayan bir sınıftır. True ve false değerleri atanabilir. Count özelliğini destekler. Not(), And(), Or() ve XOR() gibi fonksiyonları destekler.

//3 tane bool değerden oluşan dizi tanımlayalım //Dafault olarak hepsi false olur. BitArray dizi = new BitArray(3); dizi.Set(2,true);//son elemanını true yaptık

HAFTA 12: DELEGELER

Delegeler metod işaret eden referanslardır. Delege hangi sınıftan hangi metodu çağıracağımızı bilmeden, çağrılacak metodumuzun neye benzediğini belirlememizi sağlar.Aşağıdaki bildirimde strmod adlı delege string tipinde bir parametreye bağlı olan ve string değer alan metodları işler.delegate string strmod(string str);

Aşağıdaki kodda strmod delegesinden nesnedelege adında bir nesne yaratılmıştır. Bu nesne boslukdegistir metodunu işaret etmektedir.strmod nesnedelege = new strmod(boslukdegistir);

ÖRNEK:using System;using System.Collections.Generic;using System.Linq;using System.Text;

namespace ConsoleApplication1{

delegate string strmod(string str);// delege deklare edelim class delegetest { //boşlukları tire ile değiştirir. static string boslukdegistir(string a) { Console.WriteLine("Boşlukları tire ile değiştir"); return a.Replace(' ', '-'); } //Boşlukları yok et static string bosluksil(string a) { string temp = " "; int i; Console.WriteLine("boşluklar siliniyor"); for (i = 0; i < a.Length; i++)

if (a[i] != ' ') temp += a[i]; return temp;

} //Bir stringi ters çevir static string terscevir(string a) { string temp = " "; int i, j; Console.WriteLine("string ters çevriliyor"); for (j = 0, i = a.Length-1; i >= 0; i--, j++) temp += a[i]; return temp; } static void Main(string[] args) { //Bir delege yapılandır strmod nesnedelege = new strmod(boslukdegistir); string str; //delege aracılığı ile metodları çağır str = nesnedelege("Bu bir test dir"); Console.WriteLine("string sonuç:" + str); Console.WriteLine();

nesnedelege = new strmod(bosluksil); str = nesnedelege("Bu bir test dir"); Console.WriteLine("string sonuç:" + str); Console.WriteLine();

nesnedelege = new strmod(terscevir); str = nesnedelege("Bu bir test dir"); Console.WriteLine("string sonuç:" + str);

}

} }

Program bir string parametresi alan ve bir string döndüren Strmod adında bir delege deklare etmektedir. Delegetest class’ı içinde 3 static metod deklare edilmektedir. Bu metodlar bir tür string değişikliği gerçekleştireceklerdir. Main() de nesnedelege adında bir delege referansı oluşturulur ve buna boslukdegistir()’ e atıfta bulunan bir referans atanır. strmod nesnedelege = new strmod(boslukdegistir);

boslukdegistirin parametre olarak nasıl aktarıldığına dikkat edelim. Metodun yalnızca ismi kullanılmaktadır, parametreleri belirtilmemiştir. Bir delegeyi örneklerken yalnızca delegenin referansta bulunmasını istediğiniz metodun ismini belirtirsiniz. Ayrıca metodun deklerasyonu, delegeninki ile eşleşmelidir.(türü, parametreli ise parametre sayısı ve türü gibi)

Sonra nesnedelege aracılığı ile boslukdegistir çağırılır.str = nesnedelege("Bu bir test dir");

nesnedelege, boslukdegistir()’e referansta bulunduğu için burada çağırılan boslukdegistir()dir.Daha sonra nesnedelege’ye, terscevir()’e atıfta bulunan bir referans atanır ve nesnedelege tekrar çağırılır. Bu kez bosluksil() çağrılmıştır.Son olarak nesnedelege’ye terscevir()’e atıfta bulunan bir referans atanır ve nesnedelege çağrılır. Bu, terscevir()’in çağrılması ile sonuçlanır.Bu örnek, çok önemli bir özelliğe sahiptir: nesnedelege’ye yapılan çağrı, nesnedelegenin çağrıldığı sırada nesnedelegenin referansta bulunduğu metodunda çağrılması ile sonuçlanır. Böylece, hangi metodun çağrılacağı derleme zamanında değil çalışma zamanında çözümlenir.

BOXING(KUTULAMA)

Documents

HAFTA 1: PROGRAMLAMANIN TEMELLERİ · Web viewstring ad = "Melih Cevdet Anday"; ifadesi ad isimli yerel değişkenimize atama yaparken, this.ad = "Orhan Veli Kanık"; ifadesi ad isimli