diff options
| -rw-r--r-- | tr-tr/csharp-tr.html.markdown | 824 |
1 files changed, 824 insertions, 0 deletions
diff --git a/tr-tr/csharp-tr.html.markdown b/tr-tr/csharp-tr.html.markdown new file mode 100644 index 00000000..7755ed44 --- /dev/null +++ b/tr-tr/csharp-tr.html.markdown @@ -0,0 +1,824 @@ +--- +language: c# +contributors: + - ["Irfan Charania", "https://github.com/irfancharania"] + - ["Max Yankov", "https://github.com/golergka"] + - ["Melvyn Laïly", "http://x2a.yt"] + - ["Shaun McCarthy", "http://www.shaunmccarthy.com"] +translators: + - ["Melih Mucuk", "http://melihmucuk.com"] +lang: tr-tr +filename: LearnCSharp.cs + +--- + +C# zarif ve tip güvenli nesne yönelimli bir dil olup geliştiricilerin .NET framework üzerinde çalışan güçlü ve güvenli uygulamalar geliştirmesini sağlar. + +[Yazım yanlışları ve öneriler için bana ulaşabilirsiniz](mailto:melihmucuk@gmail.com) + +[Daha fazlasını okuyun.](http://msdn.microsoft.com/en-us/library/vstudio/z1zx9t92.aspx) + +```c# +// Tek satırlık yorumlar // ile başlar +/* +Birden fazla satırlı yorumlar buna benzer +*/ +/// <summary> +/// Bu bir XML dokümantasyon yorumu +/// </summary> + +// Uygulamanın kullanacağı ad alanlarını belirtin +using System; +using System.Collections.Generic; +using System.Data.Entity; +using System.Dynamic; +using System.Linq; +using System.Linq.Expressions; +using System.Net; +using System.Threading.Tasks; +using System.IO; + +// Kodu düzenlemek için paketler içinde alan tanımlayın +namespace Learning +{ + // Her .cs dosyası, dosya ile aynı isimde en az bir sınıf içermeli + // bu kurala uymak zorunda değilsiniz ancak mantıklı olan yol budur. + public class LearnCSharp + { + // TEMEL SÖZ DİZİMİ - daha önce Java ya da C++ kullandıysanız İLGİNÇ ÖZELLİKLER'e geçin + public static void Syntax() + { + // Satırları yazdırmak için Console.WriteLine kullanın + Console.WriteLine("Merhaba Dünya"); + Console.WriteLine( + "Integer: " + 10 + + " Double: " + 3.14 + + " Boolean: " + true); + + // Yeni satıra geçmeden yazdırmak için Console.Write kullanın + Console.Write("Merhaba "); + Console.Write("Dünya"); + + /////////////////////////////////////////////////// + // Tipler & Değişkenler + // + // Bir değişken tanımlamak için <tip> <isim> kullanın + /////////////////////////////////////////////////// + + // Sbyte - Signed 8-bit integer + // (-128 <= sbyte <= 127) + sbyte fooSbyte = 100; + + // Byte - Unsigned 8-bit integer + // (0 <= byte <= 255) + byte fooByte = 100; + + // Short - 16-bit integer + // Signed - (-32,768 <= short <= 32,767) + // Unsigned - (0 <= ushort <= 65,535) + short fooShort = 10000; + ushort fooUshort = 10000; + + // Integer - 32-bit integer + int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647) + uint fooUint = 1; // (0 <= uint <= 4,294,967,295) + + // Long - 64-bit integer + long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807) + ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615) + // Sayılar boyutlarına göre ön tanımlı olarak int ya da uint olabilir. + // L, değişken değerinin long ya da ulong tipinde olduğunu belirtmek için kullanılır. + + // Double - Çift hassasiyetli 64-bit IEEE 754 kayan sayı + double fooDouble = 123.4; // Hassasiyet: 15-16 basamak + + // Float - Tek hassasiyetli 32-bit IEEE 754 kayan sayı + float fooFloat = 234.5f; // Hassasiyet: 7 basamak + // f, değişken değerinin float tipinde olduğunu belirtmek için kullanılır. + + // Decimal - 128-bit veri tiğinde ve diğer kayan sayı veri tiplerinden daha hassastır, + // finansal ve mali hesaplamalar için uygundur. + decimal fooDecimal = 150.3m; + + // Boolean - true & false + bool fooBoolean = true; // veya false + + // Char - 16-bitlik tek bir unicode karakter + char fooChar = 'A'; + + // Strings -- Önceki baz tiplerinin hepsi değer tipiyken, + // string bir referans tipidir. Null değer atayabilirsiniz + string fooString = "\"escape\" quotes and add \n (new lines) and \t (tabs)"; + Console.WriteLine(fooString); + + // İndeks numarası kullanarak bir string'in bütün karakterlerine erişilebilirsiniz: + char charFromString = fooString[1]; // => 'e' + // String'ler değiştirilemez: fooString[1] = 'X' işlemini yapamazsınız; + + // String'leri geçerli kültür değeri ve büyük küçük harf duyarlılığı olmadan karşılaştırma + string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase); + + // sprintf baz alınarak formatlama + string fooFs = string.Format("Check Check, {0} {1}, {0} {1:0.0}", 1, 2); + + // Tarihler & Formatlama + DateTime fooDate = DateTime.Now; + Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy")); + + // Bir string'i iki satıra bölmek için @ sembolü kullanabilirsiniz. " işaretinden kaçmak için "" kullanın + string bazString = @"Here's some stuff +on a new line! ""Wow!"", the masses cried"; + + // Bir değişkeni değiştirilemez yapmak için const ya da read-only kullanın. + // const değerleri derleme sırasında hesaplanır + const int HOURS_I_WORK_PER_WEEK = 9001; + + /////////////////////////////////////////////////// + // Veri Yapıları + /////////////////////////////////////////////////// + + // Diziler - Sıfır indeksli + // Dizi boyutuna tanımlama sırasında karar verilmelidir. + // Dizi tanımlama formatı şöyledir: + // <veri tipi>[] <değişken ismi> = new <veri tipi>[<dizi boyutu>]; + int[] intArray = new int[10]; + + // Bir diğer dizi tanımlama formatı şöyledir: + int[] y = { 9000, 1000, 1337 }; + + // Bir diziyi indeksleme - Bir elemente erişme + Console.WriteLine("intArray @ 0: " + intArray[0]); + // Diziler değiştirilebilir. + intArray[1] = 1; + + // Listeler + // Listeler daha esnek oldukları için dizilerden daha sık kullanılırlar. + // Bir liste tanımlama formatı şöyledir: + // List<veri tipi> <değişken ismi> = new List<veri tipi>(); + List<int> intList = new List<int>(); + List<string> stringList = new List<string>(); + List<int> z = new List<int> { 9000, 1000, 1337 }; // tanımlama + // <> işareti generic ifadeler içindir - Güzel özellikler sekmesini inceleyin + + // Listelerin varsayılan bir değeri yoktur; + // İndekse erişmeden önce değer eklenmiş olmalıdır + intList.Add(1); + Console.WriteLine("intList @ 0: " + intList[0]); + + // Diğer veri yapıları için şunlara bakın: + // Stack/Queue (Yığın/Kuyruk) + // Dictionary (hash map'in uygulanması) (Sözlük) + // HashSet (karma seti) + // Read-only Collections (Değiştirilemez koleksiyonlar) + // Tuple (.Net 4+) (tüp) + + /////////////////////////////////////// + // Operatörler + /////////////////////////////////////// + Console.WriteLine("\n->Operators"); + + int i1 = 1, i2 = 2; // Birden çok tanımlamanın kısa yolu + + // Aritmetik basittir + Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3 + + // Mod + Console.WriteLine("11%3 = " + (11 % 3)); // => 2 + + // Karşılaştırma operatörleri + Console.WriteLine("3 == 2? " + (3 == 2)); // => false + Console.WriteLine("3 != 2? " + (3 != 2)); // => true + Console.WriteLine("3 > 2? " + (3 > 2)); // => true + Console.WriteLine("3 < 2? " + (3 < 2)); // => false + Console.WriteLine("2 <= 2? " + (2 <= 2)); // => true + Console.WriteLine("2 >= 2? " + (2 >= 2)); // => true + + // Bit düzeyi operatörleri! + /* + ~ Tekli bit tamamlayıcısı + << Sola kaydırma Signed left shift + >> Sağa kaydırma Signed right shift + & Bit düzeyi AND + ^ Bit düzeyi harici OR + | Bit düzeyi kapsayan OR + */ + + // Arttırma + int i = 0; + Console.WriteLine("\n->Inc/Dec-rementation"); + Console.WriteLine(i++); //i = 1. Post-Incrementation + Console.WriteLine(++i); //i = 2. Pre-Incrementation + Console.WriteLine(i--); //i = 1. Post-Decrementation + Console.WriteLine(--i); //i = 0. Pre-Decrementation + + /////////////////////////////////////// + // Kontrol Yapıları + /////////////////////////////////////// + Console.WriteLine("\n->Control Structures"); + + // If ifadesi c benzeridir + int j = 10; + if (j == 10) + { + Console.WriteLine("I get printed"); + } + else if (j > 10) + { + Console.WriteLine("I don't"); + } + else + { + Console.WriteLine("I also don't"); + } + + // Üçlü operatörler + // Basit bir if/else ifadesi şöyle yazılabilir + // <koşul> ? <true> : <false> + string isTrue = (true) ? "True" : "False"; + + // While döngüsü + int fooWhile = 0; + while (fooWhile < 100) + { + //100 kere tekrarlanır, fooWhile 0->99 + fooWhile++; + } + + // Do While Döngüsü + int fooDoWhile = 0; + do + { + //100 kere tekrarlanır, fooDoWhile 0->99 + fooDoWhile++; + } while (fooDoWhile < 100); + + //for döngüsü yapısı => for(<başlangıç ifadesi>; <koşul>; <adım>) + for (int fooFor = 0; fooFor < 10; fooFor++) + { + //10 kere tekrarlanır, fooFor 0->9 + } + + // For Each Döngüsü + // foreach döngüsü yapısı => foreach(<yineleyici tipi> <yineleyici ismi> in <enumerable>) + // foreach döngüsü, IEnumerable ya da IEnumerable<T> e dönüştürülmüş herhangi bir obje üzerinde döngü yapabilir + // .Net framework üzerindeki bütün koleksiyon tiplerinden (Dizi, Liste, Sözlük...) + // biri ya da hepsi uygulanarak gerçekleştirilebilir. + // (ToCharArray() silindi, çünkü string'ler aynı zamanda IEnumerable'dır.) + foreach (char character in "Hello World".ToCharArray()) + { + //String içindeki bütün karakterler üzerinde döner + } + + // Switch Case + // Bir switch byte, short, char ve int veri tipleri ile çalışır. + // Aynı zamanda sıralı tipler ile de çalışabilir.(Enum Tipleri bölümünde tartışıldı), + // String sınıfı, ve bir kaç özel sınıf kaydırılır + // basit tipler: Character, Byte, Short, and Integer. + int month = 3; + string monthString; + switch (month) + { + case 1: + monthString = "January"; + break; + case 2: + monthString = "February"; + break; + case 3: + monthString = "March"; + break; + // Bir aksiyon için birden fazla durum atayabilirsiniz + // Ancak, break olmadan yeni bir durum ekleyemezsiniz + // (Eğer bunu yapmak istiyorsanız, goto komutu eklemek zorundasınız) + case 6: + case 7: + case 8: + monthString = "Summer time!!"; + break; + default: + monthString = "Some other month"; + break; + } + + /////////////////////////////////////// + // Veri Tipleri Dönüştürme ve Typecasting + /////////////////////////////////////// + + // Veri Dönüştürme + + // String'i Integer'a Dönüştürme + // bu başarısız olursa hata fırlatacaktır + int.Parse("123");// "123" 'in Integer değerini döndürür + + // try parse hata durumunda değişkene varsayılan bir değer atamak için kullanılır + // bu durumda: 0 + int tryInt; + if (int.TryParse("123", out tryInt)) // Fonksiyon boolean'dır + Console.WriteLine(tryInt); // 123 + + // Integer'ı String'e Dönüştürme + // Convert sınıfı dönüştürme işlemini kolaylaştırmak için bir dizi metoda sahiptir + Convert.ToString(123); + // veya + tryInt.ToString(); + } + + /////////////////////////////////////// + // SINIFLAR - dosyanın sonunda tanımları görebilirsiniz + /////////////////////////////////////// + public static void Classes() + { + // Obje tanımlamalarını dosyanın sonunda görebilirsiniz + + // Bir sınıfı türetmek için new kullanın + Bicycle trek = new Bicycle(); + + // Obje metodlarını çağırma + trek.SpeedUp(3); // Her zaman setter ve getter metodları kullanmalısınız + trek.Cadence = 100; + + // ToString objenin değerini göstermek için kullanılır. + Console.WriteLine("trek info: " + trek.Info()); + + // Yeni bir Penny Farthing sınıfı türetmek + PennyFarthing funbike = new PennyFarthing(1, 10); + Console.WriteLine("funbike info: " + funbike.Info()); + + Console.Read(); + } // Ana metodun sonu + + // KONSOLE BAŞLANGICI Bir konsol uygulaması başlangıç olarak mutlaka ana metod'a sahip olmalı + public static void Main(string[] args) + { + OtherInterestingFeatures(); + } + + // + // İLGİNÇ ÖZELLİKLER + // + + // VARSAYILAN METOD TANIMLAMALARI + + public // Görünebilir + static // Sınıf üzerinden obje türetmeden çağırılabilir + int // Dönüş Tipi, + MethodSignatures( + int maxCount, // İlk değişken, int değer bekler + int count = 0, // Eğer değer gönderilmezse varsayılan olarak 0 değerini alır + int another = 3, + params string[] otherParams // Metoda gönderilen diğer bütün parametreleri alır + ) + { + return -1; + } + + // Metodlar tanımlamalar benzersiz ise aynı isimleri alabilirler + public static void MethodSignatures(string maxCount) + { + } + + // GENERIC'LER + // TKey ve TValue değerleri kullanıcı tarafından bu fonksiyon çağırılırken belirtilir. + // Bu metod Python'daki SetDefault'a benzer + public static TValue SetDefault<TKey, TValue>( + IDictionary<TKey, TValue> dictionary, + TKey key, + TValue defaultItem) + { + TValue result; + if (!dictionary.TryGetValue(key, out result)) + return dictionary[key] = defaultItem; + return result; + } + + // Gönderilen objeleri daraltabilirsiniz + public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int> + { + // Eğer T IEnumerable ise tekrarlayabiliriz + foreach (var item in toPrint) + // Item bir int + Console.WriteLine(item.ToString()); + } + + public static void OtherInterestingFeatures() + { + // İSTEĞE BAĞLI PARAMETRELER + MethodSignatures(3, 1, 3, "Some", "Extra", "Strings"); + MethodSignatures(3, another: 3); // isteğe bağlı olanlar gönderilmedi + + // UZANTI METODLARI + int i = 3; + i.Print(); // Aşağıda tanımlandı + + // NULLABLE TYPES - veri tabanı işlemleri için uygun / return values + // Herhangi bir değer tipi sonuna ? eklenerek nullable yapılabilir (sınıflar hariç) + // <tip>? <değiken ismi> = <değer> + int? nullable = null; // Nullable<int> için kısa yol + Console.WriteLine("Nullable variable: " + nullable); + bool hasValue = nullable.HasValue; // eğer null değilse true döner + + // ?? varsayılan değer belirlemek için söz dizimsel güzel bir özellik + // bu durumda değişken null'dır + int notNullable = nullable ?? 0; // 0 + + // TİPİ BELİRTİLMEMİŞ DEĞİŞKENLER - compiler değişkenin tipini bilmeden çalışabilir: + var magic = "magic is a string, at compile time, so you still get type safety"; + // magic = 9; string gibi çalışmayacaktır, bu bir int değil + + // GENERIC'LER + // + var phonebook = new Dictionary<string, string>() { + {"Sarah", "212 555 5555"} // Telefon rehberine bir kaç numara ekleyelim. + }; + + // Yukarıda generic olarak tanımlanan SETDEFAULT'u çağırma + Console.WriteLine(SetDefault<string,string>(phonebook, "Shaun", "No Phone")); // Telefonu yok + // TKey ve TValue tipini belirtmek zorunda değilsiniz + Console.WriteLine(SetDefault(phonebook, "Sarah", "No Phone")); // 212 555 5555 + + // LAMBDA IFADELERİ - satır içinde kod yazmanıza olanak sağlar + Func<int, int> square = (x) => x * x; // Son T nesnesi dönüş değeridir + Console.WriteLine(square(3)); // 9 + + // TEK KULLANIMLIK KAYNAK YÖNETİMİ - Yönetilemeyen kaynakların üstesinden kolayca gelebilirsiniz. + // Bir çok obje yönetilemeyen kaynaklara (dosya yakalama, cihaz içeriği, vb.) + // IDisposable arabirimi ile erişebilir. Using ifadesi sizin için IDisposable objeleri temizler. + using (StreamWriter writer = new StreamWriter("log.txt")) + { + writer.WriteLine("Nothing suspicious here"); + // Bu bölümün sonunda kaynaklar temilenir. + // Hata fırlatılmış olsa bile. + } + + // PARALEL FRAMEWORK + // http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx + var websites = new string[] { + "http://www.google.com", "http://www.reddit.com", + "http://www.shaunmccarthy.com" + }; + var responses = new Dictionary<string, string>(); + + // Her istek farklı bir thread de işlem görecek + // bir sonraki işleme geçmeden birleştirilecek. + Parallel.ForEach(websites, + new ParallelOptions() {MaxDegreeOfParallelism = 3}, // en fazla 3 thread kullanmak için + website => + { + // Uzun sürecek bir işlem yapın + using (var r = WebRequest.Create(new Uri(website)).GetResponse()) + { + responses[website] = r.ContentType; + } + }); + + // Bütün istekler tamamlanmadan bu döndü çalışmayacaktır. + foreach (var key in responses.Keys) + Console.WriteLine("{0}:{1}", key, responses[key]); + + // DİNAMİK OBJELER (diğer dillerle çalışırken kullanmak için uygun) + dynamic student = new ExpandoObject(); + student.FirstName = "First Name"; // Önce yeni bir sınıf tanımlamanız gerekmez! + + // Hatta metod bile ekleyebilirsiniz (bir string döner, ve bir string alır) + student.Introduce = new Func<string, string>( + (introduceTo) => string.Format("Hey {0}, this is {1}", student.FirstName, introduceTo)); + Console.WriteLine(student.Introduce("Beth")); + + // IQUERYABLE<T> - neredeyse bütün koleksiyonlar bundan türer, bu size bir çok + // kullanışlı Map / Filter / Reduce stili metod sağlar. + var bikes = new List<Bicycle>(); + bikes.Sort(); // Dizi sıralama + bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels)); // Wheels baz alınarak sıralama + var result = bikes + .Where(b => b.Wheels > 3) // Filters- chainable (bir önceki tipin IQueryable'ını döner) + .Where(b => b.IsBroken && b.HasTassles) + .Select(b => b.ToString()); // Map - sadece bunu seçiyoruz, yani sonuç bir IQueryable<string> olacak + + var sum = bikes.Sum(b => b.Wheels); // Reduce - koleksiyonda bulunan bütün wheel değerlerinin toplamı + + // Bike içindeki bazı parametreleri baz alarak bir liste oluşturmak + var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles }); + // Burada göstermek zor ama, compiler yukaridaki tipleri çözümleyebilirse derlenmeden önce tipi verebilir. + foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome)) + Console.WriteLine(bikeSummary.Name); + + // ASPARALLEL + // Linq ve paralel işlemlerini birleştirme + var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name); + // bu paralel bir şekilde gerçekleşecek! Threadler otomatik ve sihirli bir şekilde işleri paylaşacak! + // Birden fazla çekirdeğiniz varsa büyük veri setleri ile kullanmak için oldukça uygun bir yapı. + + // LINQ - IQueryable<T> objelerini mapler ve saklar, gecikmeli bir işlemdir + // e.g. LinqToSql - veri tabanını mapler, LinqToXml xml dökümanlarını mapler. + var db = new BikeRepository(); + + // işlem gecikmelidir, bir veri tabanı üzerinde sorgulama yaparken harikadır. + var filter = db.Bikes.Where(b => b.HasTassles); // sorgu henüz çalışmadı + if (42 > 6) // Filtreler eklemeye devam edebilirsiniz - ileri düzey arama fonksiyonları için harikadır + filter = filter.Where(b => b.IsBroken); // sorgu henüz çalışmadı + + var query = filter + .OrderBy(b => b.Wheels) + .ThenBy(b => b.Name) + .Select(b => b.Name); // hala sorgu çalışmadı + + // Şimdi sorgu çalışıyor, reader'ı açar ama sadece sizin sorgunuza uyanlar foreach döngüsüne girer. + foreach (string bike in query) + Console.WriteLine(result); + + + + } + + } // LearnCSharp sınıfının sonu + + // Bir .cs dosyasına diğer sınıflarıda dahil edebilirsiniz + + public static class Extensions + { + // UZANTI FONKSİYONLARI + public static void Print(this object obj) + { + Console.WriteLine(obj.ToString()); + } + } + + // Sınıf Tanımlama Sözdizimi: + // <public/private/protected/internal> class <sınıf ismi>{ + // //veri alanları, kurucular , fonksiyonlar hepsi içindedir. + // //Fonksiyonlar Java'daki gibi metod olarak çağırılır. + // } + + public class Bicycle + { + // Bicycle'ın Alanları/Değişkenleri + public int Cadence // Public: herhangi bir yerden erişilebilir + { + get // get - değeri almak için tanımlanan metod + { + return _cadence; + } + set // set - değer atamak için tanımlanan metod + { + _cadence = value; // Değer setter'a gönderilen value değeridir + } + } + private int _cadence; + + protected virtual int Gear // Protected: Sınıf ve alt sınıflar tarafından erişilebilir + { + get; // bir üye alanına ihtiyacınız yok, bu otomatik olarak bir değer oluşturacaktır + set; + } + + internal int Wheels // Internal: Assembly tarafından erişilebilir + { + get; + private set; // Nitelik belirleyicileri get/set metodlarında atayabilirsiniz + } + + int _speed; // Her şey varsayılan olarak private'dır : Sadece sınıf içinden erişilebilir. + // İsterseniz yinede private kelimesini kullanabilirsiniz. + public string Name { get; set; } + + // Enum sabitler kümesinden oluşan bir değer tipidir. + // Gerçekten sadece bir isim ile bir değeri tutmak için kullanılır. (aksi belirtilmedikçe bir int'dir). + // İzin verilen enum tipleri şunlardır byte, sbyte, short, ushort, int, uint, long, veya ulong. + // Bir enum aynı değeri birden fazla sayıda barındıramaz. + public enum BikeBrand + { + AIST, + BMC, + Electra = 42, // bir isme tam bir değer verebilirsiniz + Gitane // 43 + } + // Bu tipi Bicycle sınıfı içinde tanımladığımız için bu bir bağımlı tipdir. + // Bu sınıf dışında kullanmak için tipi Bicycle.Brand olarak kullanmamız gerekir + + public BikeBrand Brand; // Enum tipini tanımladıktan sonra alan tipini tanımlayabiliriz + + // Static üyeler belirli bir obje yerine kendi tipine aittir + // Onlara bir obje referans göstermeden erişebilirsiniz: + // Console.WriteLine("Bicycles created: " + Bicycle.bicyclesCreated); + static public int BicyclesCreated = 0; + + // readonly değerleri çalışma zamanında atanır + // onlara sadece tanımlama yapılarak ya da kurucular içinden atama yapılabilir + readonly bool _hasCardsInSpokes = false; // read-only private + + // Kurucular sınıf oluşturmanın bir yoludur + // Bu bir varsayılan kurucudur. + public Bicycle() + { + this.Gear = 1; // bu objenin üyelerine this anahtar kelimesi ile ulaşılır + Cadence = 50; // ama her zaman buna ihtiyaç duyulmaz + _speed = 5; + Name = "Bontrager"; + Brand = BikeBrand.AIST; + BicyclesCreated++; + } + + // Bu belirlenmiş bir kurucudur. (argümanlar içerir) + public Bicycle(int startCadence, int startSpeed, int startGear, + string name, bool hasCardsInSpokes, BikeBrand brand) + : base() // önce base'i çağırın + { + Gear = startGear; + Cadence = startCadence; + _speed = startSpeed; + Name = name; + _hasCardsInSpokes = hasCardsInSpokes; + Brand = brand; + } + + // Kurucular zincirleme olabilir + public Bicycle(int startCadence, int startSpeed, BikeBrand brand) : + this(startCadence, startSpeed, 0, "big wheels", true, brand) + { + } + + // Fonksiyon Sözdizimi: + // <public/private/protected> <dönüş tipi> <fonksiyon ismi>(<argümanlar>) + + // sınıflar getter ve setter'ları alanları için kendisi uygular + // veya property'ler eklenebilir (C# da tercih edilen yol budur) + + // Metod parametreleri varsayılan değerlere sahip olabilir. + // Bu durumda, metodlar bu parametreler olmadan çağırılabilir. + public void SpeedUp(int increment = 1) + { + _speed += increment; + } + + public void SlowDown(int decrement = 1) + { + _speed -= decrement; + } + + // property'lerin get/set değerleri + // sadece veri gerektiği zaman erişilebilir, kullanmak için bunu göz önünde bulundurun. + // property'ler sadece get ya da set'e sahip olabilir veya ikisine birden + private bool _hasTassles; // private değişken + public bool HasTassles // public accessor + { + get { return _hasTassles; } + set { _hasTassles = value; } + } + + // Ayrıca tek bir satırda otomatik property tanımlayabilirsiniz. + // bu söz dizimi otomatik olarak alan oluşturacaktır. + // Erişimi kısıtlamak için nitelik belirleyiciler getter veya setter'a ya da ikisine birden atanabilir: + public bool IsBroken { get; private set; } + + // Property'ler otomatik eklenmiş olabilir + public int FrameSize + { + get; + // nitelik beliryecileri get veya set için tanımlayabilirsiniz + // bu sadece Bicycle sınıfı Framesize değerine atama yapabilir demektir + private set; + } + + // Ayrıca obje üzerinde özel indeksleyici belirlemek mümkündür. + // Tüm bunlar bu örnek için çok kullanışlı değil, + // bicycle[0] ile ilk yolcu olan "chris" i almak mümkün veya + // bicycle[1] = "lisa" ile yolcuyu atayabilirsiniz. (bariz quattrocycle) + private string[] passengers = { "chris", "phil", "darren", "regina" } + + public string this[int i] + { + get { + return passengers[i]; + } + + set { + return passengers[i] = value; + } + } + + //Bu objenin nitelik değerlerini göstermek için bir metod. + public virtual string Info() + { + return "Gear: " + Gear + + " Cadence: " + Cadence + + " Speed: " + _speed + + " Name: " + Name + + " Cards in Spokes: " + (_hasCardsInSpokes ? "yes" : "no") + + "\n------------------------------\n" + ; + } + + // Metodlar static olabilir. Yardımcı metodlar için kullanışlı olabilir. + public static bool DidWeCreateEnoughBycles() + { + // Bir static metod içinde sadece static sınıf üyeleri referans gösterilebilir + return BicyclesCreated > 9000; + } // Eğer sınıfınızın sadece static üyelere ihtiyacı varsa, sınıfın kendisini static yapmayı düşünebilirsiniz. + + + } // Bicycle sınıfı sonu + + // PennyFarthing , Bicycle sınıfının alt sınıfıdır. + class PennyFarthing : Bicycle + { + // (Penny Farthing'ler ön jantı büyük bisikletlerdir. + // Vitesleri yoktur.) + + // Ana kurucuyu çağırmak + public PennyFarthing(int startCadence, int startSpeed) : + base(startCadence, startSpeed, 0, "PennyFarthing", true, BikeBrand.Electra) + { + } + + protected override int Gear + { + get + { + return 0; + } + set + { + throw new ArgumentException("You can't change gears on a PennyFarthing"); + } + } + + public override string Info() + { + string result = "PennyFarthing bicycle "; + result += base.ToString(); // Metodun temel versiyonunu çağırmak + return result; + } + } + + // Arabirimler sadece üyelerin izlerini içerir, değerlerini değil. + interface IJumpable + { + void Jump(int meters); // bütün arbirim üyeleri public'tir + } + + interface IBreakable + { + bool Broken { get; } // arabirimler property'leri, metodları ve olayları içerebilir + } + + // Sınıflar sadece tek bir sınıftan miras alabilir ama sınırsız sayıda arabirime sahip olabilir + class MountainBike : Bicycle, IJumpable, IBreakable + { + int damage = 0; + + public void Jump(int meters) + { + damage += meters; + } + + public bool Broken + { + get + { + return damage > 100; + } + } + } + + /// <summary> + /// LinqToSql örneği veri tabanına bağlanmak için kullanılır. + /// EntityFramework Code First harika! (Ruby'deki ActiveRecord'a benzer, ama iki yönlü) + /// http://msdn.microsoft.com/en-us/data/jj193542.aspx + /// </summary> + public class BikeRepository : DbSet + { + public BikeRepository() + : base() + { + } + + public DbSet<Bicycle> Bikes { get; set; } + } +} // namespace sonu +``` + +## İşlenmeyen Konular + + * Flags + * Attributes + * Static properties + * Exceptions, Abstraction + * ASP.NET (Web Forms/MVC/WebMatrix) + * Winforms + * Windows Presentation Foundation (WPF) + +## Daha Fazlasını Okuyun + + * [DotNetPerls](http://www.dotnetperls.com) + * [C# in Depth](http://manning.com/skeet2) + * [Programming C#](http://shop.oreilly.com/product/0636920024064.do) + * [LINQ](http://shop.oreilly.com/product/9780596519254.do) + * [MSDN Library](http://msdn.microsoft.com/en-us/library/618ayhy6.aspx) + * [ASP.NET MVC Tutorials](http://www.asp.net/mvc/tutorials) + * [ASP.NET Web Matrix Tutorials](http://www.asp.net/web-pages/tutorials) + * [ASP.NET Web Forms Tutorials](http://www.asp.net/web-forms/tutorials) + * [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208) + + + +[C# Kodlama Adetleri](http://msdn.microsoft.com/en-us/library/vstudio/ff926074.aspx) |