C # - Hızlı Kılavuz

C #, Microsoft tarafından geliştirilen ve Avrupa Bilgisayar Üreticileri Birliği (ECMA) ve Uluslararası Standartlar Organizasyonu (ISO) tarafından onaylanan modern, genel amaçlı, nesneye yönelik bir programlama dilidir.

C #, .Net Framework'ün geliştirilmesi sırasında Anders Hejlsberg ve ekibi tarafından geliştirilmiştir.

C #, farklı bilgisayar platformları ve mimarilerinde çeşitli üst düzey dillerin kullanımına izin veren çalıştırılabilir kod ve çalışma zamanı ortamından oluşan Ortak Dil Altyapısı (CLI) için tasarlanmıştır.

Aşağıdaki nedenler, C # 'ı yaygın olarak kullanılan bir profesyonel dil yapar -

• Modern, genel amaçlı bir programlama dilidir
• Nesne yönelimli.
• Bileşen odaklıdır.
• Öğrenmesi kolay.
• Yapılandırılmış bir dildir.
• Verimli programlar üretir.
• Çeşitli bilgisayar platformlarında derlenebilir.
• .Net Framework'ün bir parçasıdır.

C #’ın Güçlü Programlama Özellikleri

C # yapıları geleneksel yüksek seviyeli dilleri, C ve C ++ 'yı yakından takip etse de ve nesne yönelimli bir programlama dili. Java ile güçlü bir benzerliğe sahiptir, onu dünya çapında bir dizi programcıya sevdiren çok sayıda güçlü programlama özelliğine sahiptir.

C # 'ın birkaç önemli özelliğinin listesi aşağıdadır -

• Boole Koşulları
• Otomatik Çöp Toplama
• Standart Kitaplık
• Montaj Versiyonlama
• Özellikler ve Olaylar
• Temsilciler ve Etkinlik Yönetimi
• Kullanımı Kolay Jenerikler
• Indexers
• Koşullu Derleme
• Basit Çoklu Okuma
• LINQ ve Lambda İfadeleri
• Windows ile entegrasyon

Çevrimiçi Seçeneği Deneyin

C # Programlama ortamını çevrimiçi olarak kurduk, böylece mevcut tüm örnekleri çevrimiçi olarak derleyip çalıştırabilirsiniz. Okuduğunuz şey konusunda size güven verir ve programları farklı seçeneklerle doğrulamanızı sağlar. Herhangi bir örneği değiştirmekten ve çevrimiçi yürütmekten çekinmeyin.

CodingGround'da bulunan çevrimiçi derleyicimizi kullanarak aşağıdaki örneği deneyin

using System;

namespace HelloWorldApplication {
   
   class HelloWorld {

      static void Main(string[] args) {
         /* my first program in C# */
         Console.WriteLine("Hello World");
         Console.ReadKey();
      }
   }
}

Bu eğitimde verilen örneklerin çoğu için, sizi çevrimiçi derleyiciye götürecek sağ üst köşedeki web sitesi kodu bölümlerimizde bir Deneyin seçeneğini bulacaksınız. Bu yüzden sadece onu kullanın ve öğrenmenin tadını çıkarın.

Bu bölümde, C # programlaması oluşturmak için gerekli araçları tartışacağız. C # 'ın .Net çerçevesinin bir parçası olduğundan ve .Net uygulamaları yazmak için kullanıldığından bahsetmiştik. Bu nedenle, bir C # programını çalıştırmak için mevcut araçları tartışmadan önce, C # ile .Net çerçevesi arasındaki ilişkiyi anlayalım.

.Net Çerçevesi

.Net çerçevesi, aşağıdaki uygulama türlerini yazmanıza yardımcı olan devrim niteliğinde bir platformdur -

• Windows uygulamaları
• Web uygulamaları
• Ağ hizmetleri

.Net çerçeve uygulamaları çoklu platform uygulamalarıdır. Çerçeve, aşağıdaki dillerden herhangi birinden kullanılabilecek şekilde tasarlanmıştır: C #, C ++, Visual Basic, Jscript, COBOL, vb. Tüm bu diller çerçeveye erişebilir ve birbirleriyle iletişim kurabilir.

.Net çerçevesi, C # gibi istemci dilleri tarafından kullanılan devasa bir kod kitaplığından oluşur. Aşağıda .Net çerçevesinin bazı bileşenleri verilmiştir -

• Ortak Dil Çalışma Zamanı (CLR)
• .Net Framework Sınıf Kitaplığı
• Ortak Dil Belirtimi
• Ortak Tip Sistem
• Meta Veriler ve Montajlar
• Windows Formları
• ASP.Net ve ASP.Net AJAX
• ADO.Net
• Windows Workflow Foundation (WF)
• Windows Presentation Foundation
• Windows Communication Foundation (WCF)
• LINQ

Bu bileşenlerin her birinin gerçekleştirdiği işler için lütfen ASP.Net - Giriş bölümüne bakın ve her bileşenin ayrıntıları için lütfen Microsoft'un belgelerine bakın.

C # için Entegre Geliştirme Ortamı (IDE)

Microsoft, C # programlama için aşağıdaki geliştirme araçlarını sağlar -

• Visual Studio 2010 (VS)
• Visual C # 2010 Express (VCE)
• Görsel Web Geliştiricisi

Son ikisi Microsoft resmi web sitesinden ücretsiz olarak edinilebilir. Bu araçları kullanarak, basit komut satırı uygulamalarından daha karmaşık uygulamalara kadar her türlü C # programını yazabilirsiniz. Ayrıca Not Defteri gibi temel bir metin düzenleyicisi kullanarak C # kaynak kodu dosyaları yazabilir ve yine .NET Framework'ün bir parçası olan komut satırı derleyicisini kullanarak kodu derlemeler halinde derleyebilirsiniz.

Visual C # Express ve Visual Web Developer Express sürümü, Visual Studio'nun kırpılmış sürümleridir ve aynı görünüme sahiptir. Visual Studio'nun çoğu özelliğini korurlar. Bu eğitimde, Visual C # 2010 Express kullandık.

Microsoft Visual Studio'dan indirebilirsiniz . Makinenize otomatik olarak kurulur.

Not: Ekspres sürümü yüklemek için aktif bir internet bağlantısına ihtiyacınız var.

Linux veya Mac OS üzerinde C # Programları Yazma

.NET Framework, Windows işletim sisteminde çalışsa da, diğer işletim sistemlerinde çalışan bazı alternatif sürümler vardır. Mono.NET Framework'ün bir C # derleyicisi içeren ve çeşitli Linux ve Mac OS sürümleri dahil olmak üzere çeşitli işletim sistemlerinde çalışan açık kaynaklı bir sürümüdür. Lütfen Mono'ya Geç'i işaretleyin .

Mono'nun belirtilen amacı, yalnızca Microsoft .NET uygulamalarını çapraz platformda çalıştırabilmek değil, aynı zamanda Linux geliştiricileri için daha iyi geliştirme araçları sağlamaktır. Mono, Android, BSD, iOS, Linux, OS X, Windows, Solaris ve UNIX dahil birçok işletim sisteminde çalıştırılabilir.

C # programlama dilinin temel yapı taşlarını incelemeden önce, onu gelecek bölümlerde referans olarak alabilmemiz için minimum C # program yapısına bakalım.

Merhaba Dünya Programı Oluşturma

AC # programı aşağıdaki bölümlerden oluşur -

• Ad alanı beyanı
• Bir sınıf
• Sınıf yöntemleri
• Sınıf özellikleri
• Bir Ana yöntem
• İfadeler ve İfadeler
• Comments

"Merhaba Dünya" kelimesini yazan basit bir koda bakalım -

using System;

namespace HelloWorldApplication {
   
   class HelloWorld {
      
      static void Main(string[] args) {
         /* my first program in C# */
         Console.WriteLine("Hello World");
         Console.ReadKey();
      }
   }
}

Bu kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Hello World

Verilen programın çeşitli bölümlerine bakalım -

• Programın ilk satırı using System; - using anahtar kelime eklemek için kullanılır System programdaki ad alanı. Bir programda genellikle birden çokusing ifadeler.

• Sonraki satırda namespacebeyanname. Birnamespacesınıfların bir koleksiyonudur. HelloWorldApplication ad sınıfı içeren MerhabaDünya .

• Sonraki satırda classbildirimi, HelloWorld sınıfı , programınızın kullandığı verileri ve yöntem tanımlarını içerir. Sınıflar genellikle birden çok yöntem içerir. Yöntemler, sınıfın davranışını tanımlar. Ancak, HelloWorld sınıfının yalnızca bir yöntemi vardır Main.

• Sonraki satır, Main yöntem olan entry pointtüm C # programları için. Main yöntem, sınıfın çalıştırıldığında ne yaptığını belirtir.

• Sonraki satır /*...*/ derleyici tarafından yok sayılır ve comments programda.

• Main yöntemi, davranışını ifade ile belirtir. Console.WriteLine("Hello World");

  WriteLine , System ad alanında tanımlanan Console sınıfının bir yöntemidir . Bu ifade "Merhaba, Dünya!" Mesajına neden olur. ekranda görüntülenecek.

• Son satır Console.ReadKey();VS.NET Kullanıcıları içindir. Bu, programın bir tuşa basılmasını beklemesine neden olur ve program Visual Studio .NET'ten başlatıldığında ekranın hızlı bir şekilde çalışmasını ve kapanmasını engeller.

Aşağıdaki noktalara dikkat etmek önemlidir -

• C # büyük / küçük harfe duyarlıdır.
• Tüm ifadeler ve ifadeler noktalı virgül (;) ile bitmelidir.
• Programın yürütülmesi Ana yöntemde başlar.
• Java'nın aksine, program dosya adı sınıf adından farklı olabilir.

Programın Derlenmesi ve Yürütülmesi

C # programlarını derlemek ve yürütmek için Visual Studio.Net kullanıyorsanız, aşağıdaki adımları uygulayın -

• Visual Studio'yu başlatın.

• Menü çubuğunda Dosya -> Yeni -> Proje'yi seçin.

• Şablonlardan Görsel C # seçin ve ardından Windows'u seçin.

• Konsol Uygulaması'nı seçin.

• Projeniz için bir isim belirtin ve OK butonuna tıklayın.

• Bu, Solution Explorer'da yeni bir proje oluşturur.

• Kod Düzenleyicide kod yazın.

• Projeyi yürütmek için Çalıştır düğmesine tıklayın veya F5 tuşuna basın. Hello World satırını içeren bir Komut İstemi penceresi açılır.

Visual Studio IDE yerine komut satırını kullanarak bir C # programı derleyebilirsiniz -

• Bir metin düzenleyici açın ve yukarıda belirtilen kodu ekleyin.

• Dosyayı farklı kaydedin helloworld.cs

• Komut istemi aracını açın ve dosyayı kaydettiğiniz dizine gidin.

• Tür csc helloworld.cs ve kodunuzu derlemek için enter tuşuna basın.

• Kodunuzda hata yoksa, komut istemi sizi bir sonraki satıra götürür ve oluşturur helloworld.exe çalıştırılabilir dosya.

• Tür helloworld programınızı yürütmek için.

• Ekranda yazdırılan Hello World çıktısını görebilirsiniz.

C #, nesne yönelimli bir programlama dilidir. Nesne Yönelimli Programlama metodolojisinde bir program, eylemler aracılığıyla birbiriyle etkileşime giren çeşitli nesnelerden oluşur. Bir nesnenin alabileceği eylemlere yöntemler denir. Aynı türden nesnelerin aynı türe sahip olduğu veya aynı sınıfta olduğu söylenir.

Örneğin, bir Rectangle nesnesini ele alalım. Uzunluk ve genişlik gibi özelliklere sahiptir. Tasarıma bağlı olarak, bu niteliklerin değerlerini kabul etmek, alanı hesaplamak ve ayrıntıları görüntülemek için yollara ihtiyaç duyabilir.

Bir Rectangle sınıfının uygulanmasına bakalım ve C # temel sözdizimini tartışalım -

using System;

namespace RectangleApplication {
   
   class Rectangle {
      // member variables
      double length;
      double width;
      
      public void Acceptdetails() {
         length = 4.5;    
         width = 3.5;
      }
      
      public double GetArea() {
         return length * width; 
      }
      
      public void Display() {
         Console.WriteLine("Length: {0}", length);
         Console.WriteLine("Width: {0}", width);
         Console.WriteLine("Area: {0}", GetArea());
      }
   }
   
   class ExecuteRectangle {
   
      static void Main(string[] args) {
         Rectangle r = new Rectangle();
         r.Acceptdetails();
         r.Display();
         Console.ReadLine(); 
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Length: 4.5
Width: 3.5
Area: 15.75

kullanarak Kelimeler

Herhangi bir C # programındaki ilk ifade

using System;

usinganahtar kelime, programa ad alanlarını dahil etmek için kullanılır. Bir program birden çok kullanım ifadesi içerebilir.

sınıf Kelimeler

class anahtar kelime, bir sınıfı bildirmek için kullanılır.

C # dilinde yorumlar

Kodları açıklamak için yorumlar kullanılır. Derleyiciler yorum girişlerini dikkate almazlar. C # programlarındaki çok satırlı yorumlar / * ile başlar ve aşağıda gösterildiği gibi * / karakterleriyle biter -

/* This program demonstrates
The basic syntax of C# programming 
Language */

Tek satırlık yorumlar '//' sembolüyle belirtilir. Örneğin,

}//end class Rectangle

Üye Değişkenleri

Değişkenler, verileri depolamak için kullanılan bir sınıfın öznitelikleri veya veri üyeleridir. Önceki programda, Rectangle sınıfının uzunluk ve genişlik adında iki üye değişkeni vardır .

Üye İşlevleri

Fonksiyonlar, belirli bir görevi yerine getiren ifadeler kümesidir. Bir sınıfın üye işlevleri, sınıf içinde bildirilir. Örnek sınıfımız Rectangle, üç üye işlevi içerir: AcceptDetails , GetArea ve Display .

Sınıf Örneği

Yukarıdaki programında, sınıf ExecuteRectangle içeren ana () metodu ve başlatır Dikdörtgen sınıfı.

Tanımlayıcılar

Bir tanımlayıcı, bir sınıfı, değişkeni, işlevi veya diğer herhangi bir kullanıcı tanımlı öğeyi tanımlamak için kullanılan bir addır. C # 'da sınıfları adlandırmanın temel kuralları aşağıdaki gibidir -

• Bir isim, bir harf, rakam (0 - 9) dizisi veya alt çizgi ile devam edebilecek bir harfle başlamalıdır. Bir tanımlayıcıdaki ilk karakter rakam olamaz.

• Gibi herhangi bir gömülü boşluk veya sembol içermemelidir. - +! @ #% ^ & * () [] {}. ; : "'/ ve \. Bununla birlikte, bir alt çizgi (_) kullanılabilir.

• Bir C # anahtar sözcüğü olmamalıdır.

C # Anahtar Kelimeler

Anahtar sözcükler, C # derleyicisine önceden tanımlanmış ayrılmış sözcüklerdir. Bu anahtar sözcükler tanımlayıcı olarak kullanılamaz. Ancak, bu anahtar sözcükleri tanımlayıcı olarak kullanmak isterseniz, anahtar sözcüğün önüne @ karakterini ekleyebilirsiniz.

C # 'da, bazı tanımlayıcıların kod bağlamında özel anlamları vardır, örneğin get ve set, bağlamsal anahtar kelimeler olarak adlandırılır.

Aşağıdaki tablo C # 'da ayrılmış anahtar kelimeleri ve içeriğe dayalı anahtar kelimeleri listeler -

Ayrılmış Anahtar Kelimeler
Öz	gibi	temel	bool	kırmak	bayt	durum
tutmak	kömür	kontrol	sınıf	sabit	devam et	ondalık
varsayılan	temsilci	yapmak	çift	Başka	Sıralama	Etkinlik
açık	dış	yanlış	en sonunda	sabit	yüzen	için
her biri için	git	Eğer	örtük	içinde	in (genel değiştirici)	int
arayüz	iç	dır-dir	kilit	uzun	ad alanı	yeni
boş	nesne	Şebeke	dışarı	out (genel değiştirici)	geçersiz kılmak	parametreler
özel	korumalı	halka açık	Sadece oku	ref	dönüş	sbyte
Mühürlü	kısa	boyutu	Stackalloc	statik	dizi	yapı
değiştirmek	bu	atmak	doğru	Deneyin	bir çeşit	uint
ulong	kontrol edilmemiş	güvensiz	ushort	kullanma	gerçek	geçersiz
uçucu	süre
Bağlamsal Anahtar Kelimeler
Ekle	takma ad	yükselen	Azalan	dinamik	itibaren	almak
küresel	grup	içine	katılmak	İzin Vermek	tarafından sipariş	kısmi (tür)
kısmi (yöntem)	Kaldırmak	seç	Ayarlamak

C # 'daki değişkenler aşağıdaki türlere ayrılmıştır -

• Değer türleri
• Referans türleri
• İşaretçi türleri

Değer türü

Değer türü değişkenlerine doğrudan bir değer atanabilir. Sınıftan türetilirler System.ValueType.

Değer türleri doğrudan verileri içerir. Bazı örneklerint, char, and float, sırasıyla sayıları, alfabeleri ve kayan nokta sayılarını depolayan. Bir ilan ettiğindeint türü, sistem değeri depolamak için bellek ayırır.

Aşağıdaki tablo, C # 2010'daki mevcut değer türlerini listeler -

Tür	Temsil eder	Aralık	Varsayılan değer
bool	Boole değeri	Doğru ya da yanlış	Yanlış
bayt	8 bitlik işaretsiz tamsayı	0 ile 255	0
kömür	16 bit Unicode karakteri	U +0000 ile U + ffff	'\ 0'
ondalık	28-29 anlamlı basamaklı 128-bit kesin ondalık değerler	(-7,9 x 10 28 ila 7,9 x 10 28 ) / 10 0 ila 28	0,0 milyon
çift	64 bit çift duyarlıklı kayan nokta türü	(+/-) 5.0 x 10-324 ila (+/-) 1.7 x 10308	0.0D
yüzen	32 bitlik tek duyarlıklı kayan nokta türü	-3,4 x 10 38 ile + 3,4 x 10 38	0.0F
int	32 bitlik işaretli tamsayı türü	-2.147.483.648 ile 2.147.483.647	0
uzun	64 bitlik işaretli tamsayı türü	-9,223,372,036,854,775,808 ile 9,223,372,036,854,775,807	0L
sbyte	8 bitlik işaretli tamsayı türü	-128 ila 127	0
kısa	16 bitlik işaretli tamsayı türü	-32.768 ila 32.767	0
uint	32 bit işaretsiz tamsayı türü	0 ile 4.294.967.295	0
ulong	64 bit işaretsiz tamsayı türü	0 ile 18,446,744,073,709,551,615	0
ushort	16 bitlik işaretsiz tamsayı türü	0 ile 65.535	0

Belirli bir platformda bir türün veya değişkenin tam boyutunu elde etmek için, sizeofyöntem. Sizeof (type) ifadesi , nesnenin veya türün bayt cinsinden depolama boyutunu verir. Aşağıda, herhangi bir makinede int türünün boyutunu elde etmek için bir örnek verilmiştir -

using System;

namespace DataTypeApplication {
   
   class Program {

      static void Main(string[] args) {
         Console.WriteLine("Size of int: {0}", sizeof(int));
         Console.ReadLine();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Size of int: 4

Referans Tipi

Referans türleri, bir değişkende depolanan gerçek verileri içermez, ancak değişkenlere bir referans içerir.

Başka bir deyişle, bir hafıza konumuna başvururlar. Birden çok değişken kullanarak, referans türleri bir bellek konumuna başvurabilir. Hafıza konumundaki veriler değişkenlerden biri tarafından değiştirilirse, diğer değişken bu değerdeki değişikliği otomatik olarak yansıtır. Nın bir örneğibuilt-in referans türleri şunlardır: object, dynamic, ve string.

Nesne türü

Object TypeC # Ortak Tip Sistemindeki (CTS) tüm veri türleri için nihai temel sınıftır. Object, System.Object sınıfı için bir takma addır. Nesne türlerine diğer türlerin, değer türlerinin, başvuru türlerinin, önceden tanımlanmış veya kullanıcı tanımlı türlerin değerleri atanabilir. Ancak, değerleri atamadan önce, tür dönüştürmeye ihtiyacı vardır.

Bir değer türü nesne türüne dönüştürüldüğünde, boxing ve diğer yandan, bir nesne türü bir değer türüne dönüştürüldüğünde, unboxing.

object obj;
obj = 100; // this is boxing

Dinamik Tip

Dinamik veri türü değişkeninde herhangi bir türde değeri saklayabilirsiniz. Bu tür değişkenler için tür denetimi çalışma zamanında gerçekleşir.

Dinamik tür bildirmek için sözdizimi -

dynamic <variable_name> = value;

Örneğin,

dynamic d = 20;

Dinamik türler, nesne türü değişkenleri için tür denetiminin derleme zamanında gerçekleşmesi dışında, dinamik tür değişkenleri için çalışma zamanında gerçekleşmesi dışında nesne türlerine benzer.

Dize Türü

String Typebir değişkene herhangi bir dize değeri atamanıza izin verir. Dize türü, System.String sınıfı için bir diğer addır. Nesne türünden türetilmiştir. Bir dize türünün değeri, iki biçimde dize değişmezleri kullanılarak atanabilir: tırnaklı ve @ tırnaklı.

Örneğin,

String str = "Tutorials Point";

@Quoted string değişmez değeri aşağıdaki gibi görünür -

@"Tutorials Point";

Kullanıcı tanımlı başvuru türleri şunlardır: sınıf, arabirim veya temsilci. Bu türleri daha sonraki bölümde tartışacağız.

İşaretçi Türü

İşaretçi türü değişkenleri, başka bir türün bellek adresini depolar. C # 'teki işaretçiler, C veya C ++' daki işaretçilerle aynı yeteneklere sahiptir.

Bir işaretçi türü bildirmek için sözdizimi -

type* identifier;

Örneğin,

char* cptr;
int* iptr;

İşaretçi türlerini 'Güvenli Olmayan Kodlar' bölümünde tartışacağız.

Tür dönüştürme, bir tür veriyi başka bir türe dönüştürmektir. Aynı zamanda Tip Döküm olarak da bilinir. C # 'da tür çevirmenin iki biçimi vardır -

• Implicit type conversion- Bu dönüştürmeler C # tarafından tür güvenli bir şekilde gerçekleştirilir. Örneğin, küçükten büyüğe integral türlerinden dönüştürmeler ve türetilmiş sınıflardan temel sınıflara dönüştürmelerdir.

• Explicit type conversion- Bu dönüştürmeler, önceden tanımlanmış işlevler kullanılarak kullanıcılar tarafından açıkça yapılır. Açık dönüşümler bir döküm operatörü gerektirir.

Aşağıdaki örnek, açık bir tür dönüşümünü gösterir -

using System;

namespace TypeConversionApplication {

   class ExplicitConversion {
   
      static void Main(string[] args) {
         double d = 5673.74; 
         int i;
         
         // cast double to int.
         i = (int)d;
         Console.WriteLine(i);
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

5673

C # Tipi Dönüştürme Yöntemleri

C #, aşağıdaki yerleşik tür dönüştürme yöntemlerini sağlar -

Sr.No.	Yöntemler ve Açıklama
1	ToBoolean Mümkün olduğunda bir türü Boolean değerine dönüştürür.
2	ToByte Bir türü bayta dönüştürür.
3	ToChar Mümkün olduğunda bir türü tek bir Unicode karakterine dönüştürür.
4	ToDateTime Bir türü (tamsayı veya dize türü) tarih-saat yapılarına dönüştürür.
5	ToDecimal Kayan noktayı veya tamsayı türünü ondalık türe dönüştürür.
6	ToDouble Bir türü çift türe dönüştürür.
7	ToInt16 Bir türü 16 bitlik tam sayıya dönüştürür.
8	ToInt32 Bir türü 32 bitlik tam sayıya dönüştürür.
9	ToInt64 Bir türü 64 bitlik tam sayıya dönüştürür.
10	ToSbyte Bir türü işaretli bayt türüne dönüştürür.
11	ToSingle Bir türü küçük bir kayan noktalı sayıya dönüştürür.
12	ToString Bir türü dizeye dönüştürür.
13	ToType Bir türü belirli bir türe dönüştürür.
14	ToUInt16 Bir türü işaretsiz bir int türüne dönüştürür.
15	ToUInt32 Bir türü işaretsiz uzun bir türe dönüştürür.
16	ToUInt64 Bir türü işaretsiz büyük bir tam sayıya dönüştürür.

Aşağıdaki örnek, çeşitli değer türlerini dize türüne dönüştürür -

using System;

namespace TypeConversionApplication {
   
   class StringConversion {
      
      static void Main(string[] args) {
         int i = 75;
         float f = 53.005f;
         double d = 2345.7652;
         bool b = true;

         Console.WriteLine(i.ToString());
         Console.WriteLine(f.ToString());
         Console.WriteLine(d.ToString());
         Console.WriteLine(b.ToString());
         Console.ReadKey();
            
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

75
53.005
2345.7652
True

Değişken, programlarımızın değiştirebileceği bir depolama alanına verilen addan başka bir şey değildir. C # 'daki her değişkenin, değişkenin belleğinin boyutunu ve düzenini, bu bellekte saklanabilecek değerler aralığını ve değişkene uygulanabilecek işlem kümesini belirleyen belirli bir türü vardır.

C # ile sağlanan temel değer türleri şu şekilde kategorize edilebilir:

Tür	Misal
İntegral türleri	sbyte, byte, short, ushort, int, uint, long, ulong ve char
Kayan nokta türleri	float ve double
Ondalık türler	ondalık
Boole türleri	doğru veya yanlış değerler, atandığı gibi
Null yapılabilir türler	Null yapılabilir veri türleri

C # ayrıca değişkenlerin diğer değer türlerinin tanımlanmasına da izin verir. enum ve değişkenlerin referans türleri classsonraki bölümlerde ele alacağız.

Değişkenleri Tanımlama

C # 'da değişken tanımı için sözdizimi -

<data_type> <variable_list>;

Burada veri_türü, char, int, float, double veya herhangi bir kullanıcı tanımlı veri türü dahil olmak üzere geçerli bir C # veri türü olmalıdır ve değişken_listesi, virgülle ayrılmış bir veya daha fazla tanımlayıcı adından oluşabilir.

Bazı geçerli değişken tanımları burada gösterilmektedir -

int i, j, k;
char c, ch;
float f, salary;
double d;

Bir değişkeni tanım anında şu şekilde başlatabilirsiniz:

int i = 100;

Değişkenleri Başlatma

Değişkenler, bir eşittir işaretiyle ve ardından sabit bir ifade ile başlatılır (bir değer atanır). Genel başlatma şekli -

variable_name = value;

Değişkenler bildirimlerinde başlatılabilir. Başlatıcı bir eşittir işaretinden ve ardından aşağıdaki gibi sabit bir ifadeden oluşur:

<data_type> <variable_name> = value;

Bazı örnekler -

int d = 3, f = 5;    /* initializing d and f. */
byte z = 22;         /* initializes z. */
double pi = 3.14159; /* declares an approximation of pi. */
char x = 'x';        /* the variable x has the value 'x'. */

Değişkenleri doğru şekilde başlatmak iyi bir programlama uygulamasıdır, aksi takdirde bazen program beklenmedik sonuçlar verebilir.

Aşağıdaki örnek, çeşitli değişken türlerini kullanır -

using System;

namespace VariableDefinition {

   class Program {
   
      static void Main(string[] args) {
         short a;
         int b ;
         double c;

         /* actual initialization */
         a = 10;
         b = 20;
         c = a + b;
         Console.WriteLine("a = {0}, b = {1}, c = {2}", a, b, c);
         Console.ReadLine();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

a = 10, b = 20, c = 30

Kullanıcıdan Değer Kabul Etme

Console sınıf System ad alanı bir işlev sağlar ReadLine() kullanıcıdan girdi kabul etmek ve bir değişkene kaydetmek için.

Örneğin,

int num;
num = Convert.ToInt32(Console.ReadLine());

İşlev Convert.ToInt32() kullanıcı tarafından girilen verileri int veri türüne dönüştürür çünkü Console.ReadLine() verileri dize biçiminde kabul eder.

C # 'da Lvalue ve Rvalue İfadeleri

C # 'da iki tür ifade vardır -

• lvalue - Bir değer olan bir ifade, ödevin sol veya sağ tarafı olarak görünebilir.

• rvalue - Bir rdeğeri olan bir ifade, atamanın sağ tarafında görünebilir ancak sol tarafında görünmeyebilir.

Değişkenler ldeğerlerdir ve dolayısıyla bir atamanın sol tarafında görünebilirler. Sayısal değişmez değerler r değerleridir ve bu nedenle atanamazlar ve sol tarafta görünemezler. Aşağıda geçerli bir C # ifadesi verilmiştir -

int g = 20;

Ancak aşağıdaki geçerli bir ifade değildir ve derleme zamanı hatası oluşturur -

10 = 20;

Sabit değerler, programın yürütülmesi sırasında değiştiremeyeceği sabit değerleri ifade eder. Bu sabit değerlere sabit değerler de denir. Sabitler, bir tamsayı sabiti, bir kayan sabit, bir karakter sabiti veya bir dize değişmezi gibi temel veri türlerinden herhangi biri olabilir. Ayrıca numaralandırma sabitleri de vardır.

Sabit değerler, tanımlarından sonra değerlerinin değiştirilememesi dışında, normal değişkenler gibi ele alınır.

Tamsayı Değişmezleri

Tamsayı değişmez değeri, ondalık veya onaltılık sabit olabilir. Bir önek, tabanı veya tabanı belirtir: 0x veya 0X onaltılık için ve ondalık için önek kimliği yoktur.

Bir tamsayı değişmezi ayrıca, sırasıyla işaretsiz ve uzun için U ve L'nin bir kombinasyonu olan bir son eke sahip olabilir. Son ek, büyük veya küçük harf olabilir ve herhangi bir sırada olabilir.

İşte tamsayı değişmez değerlerine bazı örnekler -

212         /* Legal */
215u        /* Legal */
0xFeeL      /* Legal */

Aşağıda, çeşitli Tamsayı değişmez değerlerinin diğer örnekleri verilmiştir -

85         /* decimal */
0x4b       /* hexadecimal */
30         /* int */
30u        /* unsigned int */
30l        /* long */
30ul       /* unsigned long */

Kayan nokta değişmezleri

Bir kayan noktalı değişmez değerin bir tamsayı bölümü, bir ondalık noktası, bir kesirli bölümü ve bir üs bölümü vardır. Kayan noktalı değişmez değerleri ondalık veya üstel biçimde temsil edebilirsiniz.

İşte kayan noktalı değişmez değerlere bazı örnekler -

3.14159       /* Legal */
314159E-5F    /* Legal */
510E          /* Illegal: incomplete exponent */
210f          /* Illegal: no decimal or exponent */
.e55          /* Illegal: missing integer or fraction */

Ondalık biçimde temsil ederken, ondalık noktayı, üssü veya her ikisini birden eklemeniz gerekir; ve üstel biçimi kullanarak temsil ederken tamsayı bölümünü, kesirli bölümü veya her ikisini birden eklemeniz gerekir. İmzalı üs, e veya E ile tanıtılır.

Karakter Sabitleri

Karakter değişmezleri tek tırnak içine alınır. Örneğin, 'x' ve char türünün basit bir değişkeninde saklanabilir. Bir karakter değişmezi, düz bir karakter ("x" gibi), bir çıkış dizisi ("\ t" gibi) veya bir evrensel karakter ("\ u02C0" gibi) olabilir.

C # 'da önünde ters eğik çizgi bulunan belirli karakterler vardır. Özel anlamları vardır ve satırsonu (\ n) veya sekme (\ t) gibi temsil etmek için kullanılırlar. İşte, bu tür kaçış dizisi kodlarının bir listesi -

Kaçış dizisi	Anlam
\\	\ karakteri
\ '	karakter
\ "	"karakteri
\?	? karakter
\ a	Uyarı veya zil
\ b	Geri tuşu
\ f	Form besleme
\ n	Yeni hat
\ r	Satırbaşı
\ t	Yatay sekme
\ v	Dikey sekme
\ xhh. . .	Bir veya daha fazla basamağın onaltılık sayısı

Aşağıda, birkaç kaçış dizisi karakterini gösteren örnek verilmiştir -

using System;

namespace EscapeChar {

   class Program {
   
      static void Main(string[] args) {
         Console.WriteLine("Hello\tWorld\n\n");
         Console.ReadLine();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Hello   World

Dize Değişmezleri

Dize değişmezleri veya sabitleri çift tırnak "" içine veya @ "" içine alınır. Bir dize, karakter değişmezlerine benzer karakterler içerir: düz karakterler, kaçış dizileri ve evrensel karakterler.

Dize değişmezlerini kullanarak ve boşlukları kullanarak parçaları ayırarak uzun bir satırı birden çok satıra bölebilirsiniz.

İşte dize değişmezlerine bazı örnekler. Üç formun tümü aynı dizelerdir.

"hello, dear"
"hello, \
dear"
"hello, " "d" "ear"
@"hello dear"

Sabitleri Tanımlama

Sabitler kullanılarak tanımlanır constanahtar kelime. Bir sabiti tanımlamak için sözdizimi -

const <data_type> <constant_name> = value;

Aşağıdaki program, programınızda bir sabiti tanımlamayı ve kullanmayı gösterir -

using System;

namespace DeclaringConstants {

    class Program {
    
        static void Main(string[] args) {
            const double pi = 3.14159;   
            
            // constant declaration 
            double r;
            Console.WriteLine("Enter Radius: ");
            r = Convert.ToDouble(Console.ReadLine());
            double areaCircle = pi * r * r;
            Console.WriteLine("Radius: {0}, Area: {1}", r, areaCircle);
            Console.ReadLine();
        }
    }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Enter Radius: 
3
Radius: 3, Area: 28.27431

Operatör, derleyiciye belirli matematiksel veya mantıksal işlemleri gerçekleştirmesini söyleyen bir semboldür. C # zengin yerleşik işleçlere sahiptir ve aşağıdaki işleç türlerini sağlar -

• Aritmetik operatörler
• İlişkisel Operatörler
• Mantıksal operatörler
• Bitsel Operatörler
• Atama Operatörleri
• Çeşitli Operatörler

Bu eğitim, aritmetik, ilişkisel, mantıksal, bitsel, atama ve diğer operatörleri tek tek açıklamaktadır.

Aritmetik operatörler

Aşağıdaki tablo C # tarafından desteklenen tüm aritmetik operatörleri göstermektedir. Değişken varsayA 10 ve değişken tutar B 20 tutar sonra -

Örnekleri Göster

Şebeke	Açıklama	Misal
+	İki işlenen ekler	A + B = 30
-	İlk işlenenden ikinci işleneni çıkarır	A - B = -10
*	Her iki işleneni de çarpar	A * B = 200
/	Payı, pay azaltıcıya böler	B / A = 2
%	Modül İşleci ve bir tamsayı bölmesinden sonra kalanı	B% A = 0
++	Arttırma operatörü, tamsayı değerini bir artırır	A ++ = 11
-	Azaltma operatörü tamsayı değerini bir azaltır	A-- = 9

İlişkisel Operatörler

Aşağıdaki tablo C # tarafından desteklenen tüm ilişkisel operatörleri göstermektedir. Değişken varsayA 10 ve değişken tutar B 20 tutar, sonra -

Örnekleri Göster

Şebeke	Açıklama	Misal
==	İki işlenenin değerlerinin eşit olup olmadığını kontrol eder, evet ise koşul doğru olur.	(A == B) doğru değil.
! =	İki işlenenin değerlerinin eşit olup olmadığını kontrol eder, değerler eşit değilse koşul doğru olur.	(A! = B) doğrudur.
>	Soldaki işlenenin değerinin sağ işlenenin değerinden büyük olup olmadığını kontrol eder, evet ise koşul doğru olur.	(A> B) doğru değil.
<	Soldaki işlenenin değerinin sağ işlenenin değerinden küçük olup olmadığını kontrol eder, evet ise koşul doğru olur.	(A <B) doğrudur.
> =	Sol işlenenin değerinin sağ işlenenin değerinden büyük veya ona eşit olup olmadığını kontrol eder, evet ise koşul doğru olur.	(A> = B) doğru değil.
<=	Sol işlenenin değerinin sağ işlenenin değerinden küçük veya ona eşit olup olmadığını kontrol eder, evet ise koşul doğru olur.	(A <= B) doğrudur.

Mantıksal operatörler

Aşağıdaki tablo C # tarafından desteklenen tüm mantıksal operatörleri göstermektedir. Değişken varsayA Boolean değerini true ve değişken tutar B Boolean değerini yanlış tutar, sonra -

Örnekleri Göster

Şebeke	Açıklama	Misal
&&	Mantıksal AND operatörü çağrıldı. Her iki işlenen de sıfır değilse, koşul doğru olur.	(A && B) yanlıştır.
||	Mantıksal VEYA Operatörü çağrıldı. İki işlenenden herhangi biri sıfır değilse, koşul doğru olur.	(A || B) doğrudur.
!	Mantıksal NOT Operatörü olarak adlandırıldı. İşleneninin mantıksal durumunu tersine çevirmek için kullanın. Bir koşul doğruysa, Mantıksal NOT operatörü yanlış yapar.	! (A && B) doğrudur.

Bitsel Operatörler

Bitsel operatör bitler üzerinde çalışır ve bit işlem gerçekleştirir. &, | Ve ^ için doğruluk tabloları aşağıdaki gibidir -

p	q	p & q	p | q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

A = 60 ise; ve B = 13; sonra ikili biçimde aşağıdaki gibidirler -

Bir = 0011 1100

B = 0000 1101

-------------------

A&B = 0000 1100

A | B = 0011 1101

A ^ B = 0011 0001

~ A = 1100 0011

C # tarafından desteklenen Bitsel operatörler aşağıdaki tabloda listelenmiştir. A değişkeninin 60 ve B değişkeninin 13 olduğunu varsayalım, o zaman -

Örnekleri Göster

Şebeke	Açıklama	Misal
&	İkili VE İşleci, her iki işlenende de varsa sonuca bir bit kopyalar.	(A & B) = 12, 0000 1100
|	İkili VEYA İşleci, işlenenlerden herhangi birinde varsa bir bit kopyalar.	(A | B) = 61, 0011 1101
^	İkili XOR İşleci, bir işlenen içinde ayarlanmışsa, ancak her ikisinde birden değil ise biti kopyalar.	(A ^ B) = 49, 0011 0001
~	İkili Birler Tamamlayıcı Operatörü tekli ve bitleri 'çevirme' etkisine sahiptir.	(~ A) = -61, işaretli bir ikili sayı nedeniyle 2'nin tamamlayıcısında 1100 0011'dir.
<<	İkili Sol Kaydırma Operatörü. Soldaki işlenenler değeri, sağ işlenen tarafından belirtilen bit sayısı kadar sola taşınır.	A << 2 = 240, yani 1111 0000
>>	İkili Sağ Shift Operatörü. Soldaki işlenenler değeri, sağ işlenen tarafından belirtilen bit sayısı kadar sağa taşınır.	A >> 2 = 15, 0000 1111

Atama Operatörleri

C # tarafından desteklenen aşağıdaki atama operatörleri vardır -

Örnekleri Göster

Şebeke	Açıklama	Misal
=	Basit atama operatörü, sağ taraftaki işlenenlerden sol taraftaki işlenenlere değerler atar	C = A + B, A + B'nin değerini C'ye atar
+ =	VE atama operatörü ekle, Sol operanda sağ operandı ekler ve sonucu sol operanda atar.	C + = A, C = C + A'ya eşdeğerdir
- =	Çıkar VE atama operatörü, Sağ operandı sol operanddan çıkarır ve sonucu sol operanda atar.	C - = A, C = C - A'ya eşdeğerdir
* =	AND atama operatörünü çarpın, sağ operandı sol operand ile çarpar ve sonucu sol operanda atar	C * = A, C = C * A'ya eşdeğerdir
/ =	VE atama operatörünü böl, Sol operandı sağ operandla böler ve sonucu sol operanda atar.	C / = A, C = C / A'ya eşdeğerdir
% =	Modül VE atama operatörü, İki işlenen kullanarak modülü alır ve sonucu sol operanda atar	C% = A eşdeğerdir C = C% A
<< =	Sol kaydırma VE atama operatörü	C << = 2, C = C << 2 ile aynıdır
>> =	Sağ kaydırma VE atama operatörü	C >> = 2, C = C >> 2 ile aynıdır
& =	Bitsel AND atama operatörü	C & = 2, C = C & 2 ile aynıdır
^ =	bit düzeyinde özel OR ve atama operatörü	C ^ = 2, C = C ^ 2 ile aynıdır
| =	bitsel kapsayıcı OR ve atama operatörü	C | = 2, C = C | ile aynıdır | 2

Çeşitli Operatörler

Aşağıdakileri içeren birkaç önemli operatör vardır: sizeof, typeof ve ? : C # tarafından desteklenmektedir.

Örnekleri Göster

Şebeke	Açıklama	Misal
boyutu()	Bir veri türünün boyutunu döndürür.	sizeof (int), 4 döndürür.
bir çeşit()	Bir sınıfın türünü döndürür.	typeof (StreamReader);
&	Bir değişkenin adresini verir.	& a; değişkenin gerçek adresini döndürür.
*	Bir değişkene işaretçi.	* a; bir değişkene 'a' adında bir işaretçi oluşturur.
? :	Koşullu İfade	Koşul doğruysa? Ardından X değeri: Aksi takdirde Y değeri
dır-dir	Bir nesnenin belirli bir türde olup olmadığını belirler.	If (Ford is Car) // Ford'un Car sınıfının bir nesnesi olup olmadığını kontrol eder.
gibi	Atış başarısız olursa bir istisna oluşturmadan yayın yapın.	Nesne obj = new StringReader ("Merhaba"); StringReader r = nesne olarak StringReader;

C # 'da Operatör Önceliği

Operatör önceliği, bir ifadedeki terimlerin gruplandırılmasını belirler. Bu, bir ifadenin değerlendirilmesini etkiler. Bazı operatörler diğerlerinden daha yüksek önceliğe sahiptir; örneğin, çarpma operatörü toplama operatöründen daha yüksek önceliğe sahiptir.

Örneğin x = 7 + 3 * 2; burada, x operatörü + 'dan daha yüksek önceliğe sahip olduğu için 20 değil, 13 olarak atanır, bu nedenle ilk değerlendirme 3 * 2 için yapılır ve sonra 7 eklenir.

Burada, en yüksek önceliğe sahip operatörler tablonun en üstünde, en düşük olanlar ise en altta görünür. Bir ifade içinde, önce yüksek öncelikli operatörler değerlendirilir.

Örnekleri Göster

Kategori	Şebeke	İlişkisellik
Postfix	() [] ->. ++ - -	Soldan sağa
Tekli	+ -! ~ ++ - - (tür) * & sizeof	Sağdan sola
Çarpımsal	* /%	Soldan sağa
Katkı	+ -	Soldan sağa
Vardiya	<< >>	Soldan sağa
İlişkisel	<<=>> =	Soldan sağa
Eşitlik	==! =	Soldan sağa
Bitsel AND	&	Soldan sağa
Bitsel ÖZELVEYA	^	Soldan sağa
Bit tabanlı VEYA	|	Soldan sağa
Mantıksal AND	&&	Soldan sağa
Mantıksal VEYA	||	Soldan sağa
Koşullu	?:	Sağdan sola
Görev	= + = - = * = / =% = >> = << = & = ^ = | =	Sağdan sola
Virgül	,	Soldan sağa

Karar verme yapıları, programcının, program tarafından değerlendirilecek veya test edilecek bir veya daha fazla koşulu, koşulun doğru olduğu belirlenirse yürütülecek bir ifade veya ifadeyle birlikte belirtmesini ve isteğe bağlı olarak, koşulun doğru olması durumunda yürütülecek diğer ifadeleri gerektirir. yanlış olduğu belirlenir.

Aşağıda, programlama dillerinin çoğunda bulunan tipik bir karar verme yapısının genel biçimi verilmiştir -

C #, aşağıdaki türden karar verme beyanları sağlar. Ayrıntılarını kontrol etmek için aşağıdaki bağlantıları tıklayın.

Sr.No.	Açıklama ve Açıklama
1	eğer ifadesi Bir if statement bir boole ifadesinin ardından bir veya daha fazla ifadeden oluşur.
2	if ... else ifadesi Bir if statement ardından isteğe bağlı bir else statement, boolean ifadesi yanlış olduğunda çalıştırılır.
3	yuvalanmış if ifadeleri Birini kullanabilirsin if veya else if bir başkasının içinde ifade if veya else if beyan (lar).
4	anahtar deyimi Bir switch ifadesi, bir değişkenin bir değerler listesine karşı eşitlik açısından test edilmesine izin verir.
5	yuvalanmış anahtar ifadeleri Birini kullanabilirsin switch bir başkasının içinde ifade switch beyan (lar).

? : Şebeke

Biz kapladık conditional operator ? : değiştirmek için kullanılabilecek önceki bölümde if...elseifadeler. Aşağıdaki genel biçime sahiptir -

Exp1 ? Exp2 : Exp3;

Burada Exp1, Exp2 ve Exp3 ifadelerdir. Kolonun kullanımına ve yerleştirilmesine dikkat edin.

A'nın değeri? ifade şu şekilde belirlenir: Exp1 değerlendirilir. Doğruysa, Exp2 değerlendirilir ve tamamının değeri olur? ifade. Exp1 yanlışsa, Exp3 değerlendirilir ve değeri ifadenin değeri olur.

Bir kod bloğunu birkaç kez çalıştırmanız gereken bir durum olabilir. Genel olarak, ifadeler sırayla yürütülür: Bir fonksiyondaki ilk ifade önce çalıştırılır, ardından ikincisi yapılır ve bu böyle devam eder.

Programlama dilleri, daha karmaşık yürütme yollarına izin veren çeşitli kontrol yapıları sağlar.

Bir döngü ifadesi, bir ifadeyi veya bir grup ifadeyi birden çok kez yürütmemize izin verir ve aşağıdaki programlama dillerinin çoğunda bir döngü ifadesinin genelidir -

C #, döngü gereksinimlerini karşılamak için aşağıdaki döngü türlerini sağlar. Ayrıntılarını kontrol etmek için aşağıdaki bağlantıları tıklayın.

Sr.No.	Döngü Tipi ve Açıklaması
1	döngü sırasında Belirli bir koşul doğruyken bir ifadeyi veya bir grup ifadeyi tekrarlar. Döngü gövdesini çalıştırmadan önce koşulu test eder.
2	döngü için Bir dizi ifadeyi birden çok kez yürütür ve döngü değişkenini yöneten kodu kısaltır.
3	döngü sırasında yap Döngü gövdesinin sonundaki koşulu test etmesi dışında while ifadesine benzer
4	İç içe geçmiş döngüler Döngü while, for veya do.. while döngüsü içinde bir veya daha fazla döngü kullanabilirsiniz.

Döngü Kontrol İfadeleri

Döngü kontrol ifadeleri, yürütmeyi normal sırasından değiştirir. Yürütme bir kapsam bıraktığında, bu kapsamda oluşturulan tüm otomatik nesneler yok edilir.

C # aşağıdaki kontrol ifadelerini sağlar. Ayrıntılarını kontrol etmek için aşağıdaki bağlantıları tıklayın.

Sr.No.	Kontrol İfadesi ve Açıklama
1	break ifadesi Sonlandırır loop veya switch deyim ve yürütmeyi döngü veya anahtardan hemen sonra deyime aktarır.
2	devam ifadesi Döngünün vücudunun geri kalanını atlamasına ve yinelemeden önce durumunu hemen yeniden test etmesine neden olur.

Sonsuz döngü

Bir koşul asla yanlış olmazsa döngü sonsuz döngü haline gelir. fordöngü geleneksel olarak bu amaç için kullanılır. For döngüsünü oluşturan üç ifadeden hiçbiri gerekli olmadığından, koşullu ifadeyi boş bırakarak sonsuz bir döngü oluşturabilirsiniz.

Misal

using System;

namespace Loops {

   class Program {
   
      static void Main(string[] args) {
         for (; ; ) {
            Console.WriteLine("Hey! I am Trapped");
         }
      }
   }
}

Koşullu ifade olmadığında, doğru olduğu varsayılır. Bir başlatma ve artış ifadeniz olabilir, ancak programcılar daha çok sonsuz bir döngüyü belirtmek için for (;;) yapısını kullanırlar.

Encapsulation"fiziksel veya mantıksal bir paket içinde bir veya daha fazla öğeyi kapatma işlemi" olarak tanımlanır. Nesne yönelimli programlama metodolojisinde kapsülleme, uygulama ayrıntılarına erişimi engeller.

Soyutlama ve kapsülleme, nesne yönelimli programlamadaki ilgili özelliklerdir. Soyutlama, ilgili bilgilerin görünür hale getirilmesine izin verir ve kapsülleme, bir programcının istenen soyutlama düzeyini uygulamasını sağlar .

Kapsülleme kullanılarak gerçekleştirilir access specifiers. Biraccess specifierbir sınıf üyesinin kapsamını ve görünürlüğünü tanımlar. C # aşağıdaki erişim belirticilerini destekler -

• Public
• Private
• Protected
• Internal
• Dahili korumalı

Public Access Specifier

Genel erişim belirticisi, bir sınıfın üye değişkenlerini ve üye işlevlerini diğer işlevlere ve nesnelere göstermesine izin verir. Herkese açık herhangi bir üyeye sınıf dışından erişilebilir.

Aşağıdaki örnek bunu göstermektedir -

using System;

namespace RectangleApplication {

   class Rectangle {
      //member variables
      public double length;
      public double width;
      
      public double GetArea() {
         return length * width;
      }
      
      public void Display() {
         Console.WriteLine("Length: {0}", length);
         Console.WriteLine("Width: {0}", width);
         Console.WriteLine("Area: {0}", GetArea());
      }
   }//end class Rectangle
   
   class ExecuteRectangle {
      static void Main(string[] args) {
         Rectangle r = new Rectangle();
         r.length = 4.5;
         r.width = 3.5;
         r.Display();
         Console.ReadLine();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Length: 4.5
Width: 3.5
Area: 15.75

Önceki örnekte, uzunluk ve genişlik üye değişkenleri bildirilmiştir publicolarak adlandırılmış Rectangle sınıfının bir örneği kullanılarak Main () işlevinden erişilebilirler. r.

Üye işlevi Display () ve GetArea () , sınıfın herhangi bir örneğini kullanmadan bu değişkenlere doğrudan erişebilir.

Üye işlevleri Display () de bildirilmiştirpublic, dolayısıyla adı verilen Rectangle sınıfının bir örneği kullanılarak Main () öğesinden de erişilebilir.r.

Özel Erişim Tanımlayıcı

Özel erişim belirteci, bir sınıfın üye değişkenlerini ve üye işlevlerini diğer işlevlerden ve nesnelerden gizlemesine izin verir. Yalnızca aynı sınıfın işlevleri, özel üyelerine erişebilir. Bir sınıfın bir örneği bile özel üyelerine erişemez.

Aşağıdaki örnek bunu göstermektedir -

using System;

namespace RectangleApplication {

   class Rectangle {
      //member variables
      private double length;
      private double width;
      
      public void Acceptdetails() {
         Console.WriteLine("Enter Length: ");
         length = Convert.ToDouble(Console.ReadLine());
         Console.WriteLine("Enter Width: ");
         width = Convert.ToDouble(Console.ReadLine());
      }
      
      public double GetArea() {
         return length * width;
      }
      
      public void Display() {
         Console.WriteLine("Length: {0}", length);
         Console.WriteLine("Width: {0}", width);
         Console.WriteLine("Area: {0}", GetArea());
      }
   }//end class Rectangle
   
   class ExecuteRectangle {
      static void Main(string[] args) {
         Rectangle r = new Rectangle();
         r.Acceptdetails();
         r.Display();
         Console.ReadLine();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Enter Length:
4.4
Enter Width:
3.3
Length: 4.4
Width: 3.3
Area: 14.52

Önceki örnekte, uzunluk ve genişlik üye değişkenleri bildirilmiştir private, dolayısıyla Main () işlevinden erişilemezler. Üye fonksiyonları AcceptDetails () ve Display () bu değişkenlere erişebilir. Üye fonksiyonları AcceptDetails () ve Display () bildirildiğindenpublic, bunlara Main () adlı Rectangle sınıfının bir örneği kullanılarak erişilebilir.r.

Korumalı Erişim Tanımlayıcısı

Korumalı erişim belirticisi, bir alt sınıfın, temel sınıfının üye değişkenlerine ve üye işlevlerine erişmesine izin verir. Bu şekilde, kalıtımın uygulanmasına yardımcı olur. Bunu miras bölümünde daha ayrıntılı olarak tartışacağız.

Dahili Erişim Belirteci

Dahili erişim belirticisi, bir sınıfın üye değişkenlerini ve üye işlevlerini geçerli derlemedeki diğer işlevlere ve nesnelere göstermesine izin verir. Başka bir deyişle, dahili erişim tanımlayıcısına sahip herhangi bir üyeye, üyenin tanımlandığı uygulama içinde tanımlanan herhangi bir sınıf veya yöntemden erişilebilir.

Aşağıdaki program bunu göstermektedir -

using System;

namespace RectangleApplication {

   class Rectangle {
      //member variables
      internal double length;
      internal double width;
      
      double GetArea() {
         return length * width;
      }
      
      public void Display() {
         Console.WriteLine("Length: {0}", length);
         Console.WriteLine("Width: {0}", width);
         Console.WriteLine("Area: {0}", GetArea());
      }
   }//end class Rectangle
   
   class ExecuteRectangle {
      static void Main(string[] args) {
         Rectangle r = new Rectangle();
         r.length = 4.5;
         r.width = 3.5;
         r.Display();
         Console.ReadLine();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Length: 4.5
Width: 3.5
Area: 15.75

Önceki örnekte, üye işlevinin GetArea () herhangi bir erişim belirteci ile bildirilmediğine dikkat edin. Öyleyse, herhangi birinden bahsetmezsek, bir sınıf üyesinin varsayılan erişim tanımlayıcısı ne olurdu? Buprivate.

Korumalı Dahili Erişim Belirteci

Korunan dahili erişim belirteci, bir sınıfın üye değişkenlerini ve üye işlevlerini, aynı uygulama içindeki bir alt sınıf dışında diğer sınıf nesnelerinden ve işlevlerinden gizlemesine olanak tanır. Bu, kalıtım uygulanırken de kullanılır.

Yöntem, bir görevi birlikte gerçekleştiren bir grup deyimdir. Her C # programı, Main adında bir yönteme sahip en az bir sınıfa sahiptir.

Bir yöntemi kullanmak için yapmanız gerekenler -

• Yöntemi tanımlayın
• Yöntemi çağırın

C # 'da Yöntemleri Tanımlama

Bir yöntemi tanımladığınızda, temelde yapısının öğelerini bildirmiş olursunuz. C # 'da bir yöntemi tanımlamak için sözdizimi aşağıdaki gibidir -

<Access Specifier> <Return Type> <Method Name>(Parameter List) {
   Method Body
}

Bir yöntemin çeşitli unsurları aşağıdadır -

• Access Specifier - Bu, bir değişkenin veya başka bir sınıftan bir yöntemin görünürlüğünü belirler.

• Return type- Bir yöntem bir değer döndürebilir. Dönüş türü, yöntemin döndürdüğü değerin veri türüdür. Yöntem herhangi bir değer döndürmüyorsa, dönüş türüvoid.

• Method name- Yöntem adı benzersiz bir tanımlayıcıdır ve büyük / küçük harfe duyarlıdır. Sınıfta belirtilen diğer herhangi bir tanımlayıcı ile aynı olamaz.

• Parameter list- Parantezler arasında, parametreler bir yöntemden veri aktarmak ve almak için kullanılır. Parametre listesi, bir yöntemin parametrelerinin türü, sırası ve sayısı ile ilgilidir. Parametreler isteğe bağlıdır; yani bir yöntem hiçbir parametre içermeyebilir.

• Method body - Bu, gerekli aktiviteyi tamamlamak için gereken talimatları içerir.

Misal

Aşağıdaki kod parçacığı, iki tamsayı değeri alan ve ikisinden büyük olanı döndüren FindMax işlevini gösterir . Ortak erişim tanımlayıcısına sahiptir, bu nedenle sınıfın bir örneği kullanılarak sınıfın dışından erişilebilir.

class NumberManipulator {

   public int FindMax(int num1, int num2) {
      /* local variable declaration */
      int result;

      if (num1 > num2)
         result = num1;
      else
         result = num2;

      return result;
   }
   ...
}

C # 'da Çağrı Yöntemleri

Yöntemin adını kullanarak bir yöntemi çağırabilirsiniz. Aşağıdaki örnek bunu göstermektedir -

using System;

namespace CalculatorApplication {

   class NumberManipulator {
   
      public int FindMax(int num1, int num2) {
         /* local variable declaration */
         int result;
         
         if (num1 > num2)
            result = num1;
         else
            result = num2;
         return result;
      }
      
      static void Main(string[] args) {
         /* local variable definition */
         int a = 100;
         int b = 200;
         int ret;
         NumberManipulator n = new NumberManipulator();

         //calling the FindMax method
         ret = n.FindMax(a, b);
         Console.WriteLine("Max value is : {0}", ret );
         Console.ReadLine();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Max value is : 200

Ayrıca, sınıfın örneğini kullanarak diğer sınıflardan public yöntemi de çağırabilirsiniz. Örneğin, yöntem FindMax aittir NumberManipulator sınıfına, başka sınıf onu çağırabilir Testi .

using System;

namespace CalculatorApplication {

   class NumberManipulator {
   
      public int FindMax(int num1, int num2) {
         /* local variable declaration */
         int result;
         
         if(num1 > num2)
            result = num1;
         else
            result = num2;
         
         return result;
      }
   }
   
   class Test {
   
      static void Main(string[] args) {
         /* local variable definition */
         int a = 100;
         int b = 200;
         int ret;
         NumberManipulator n = new NumberManipulator();
         
         //calling the FindMax method
         ret = n.FindMax(a, b);
         Console.WriteLine("Max value is : {0}", ret );
         Console.ReadLine();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Max value is : 200

Yinelemeli Yöntem Çağrısı

Bir yöntem kendisini çağırabilir. Bu olarak bilinirrecursion. Aşağıda, özyinelemeli bir işlev kullanarak belirli bir sayı için faktöriyel hesaplayan bir örnek verilmiştir -

using System;

namespace CalculatorApplication {

   class NumberManipulator {
   
      public int factorial(int num) {
         /* local variable declaration */
         int result;
         if (num == 1) {
            return 1;
         }
         else {
            result = factorial(num - 1) * num;
            return result;
         }
      }
      
      static void Main(string[] args) {
         NumberManipulator n = new NumberManipulator();
         //calling the factorial method {0}", n.factorial(6));
         Console.WriteLine("Factorial of 7 is : {0}", n.factorial(7));
         Console.WriteLine("Factorial of 8 is : {0}", n.factorial(8));
         Console.ReadLine();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Factorial of 6 is: 720
Factorial of 7 is: 5040
Factorial of 8 is: 40320

Bir Yönteme Parametreleri Geçirme

Parametreli yöntem çağrıldığında, parametreleri yönteme iletmeniz gerekir. Bir yönteme parametrelerin aktarılmasının üç yolu vardır:

Sr.No.	Mekanizma ve Açıklama
1	Değer parametreleri Bu yöntem, bir bağımsız değişkenin gerçek değerini işlevin biçimsel parametresine kopyalar. Bu durumda, işlevin içindeki parametrede yapılan değişikliklerin bağımsız değişken üzerinde hiçbir etkisi yoktur.
2	Referans parametreleri Bu yöntem, bir bağımsız değişkenin bellek konumuna başvuruyu biçimsel parametreye kopyalar. Bu, parametrede yapılan değişikliklerin bağımsız değişkeni etkilediği anlamına gelir.
3	Çıkış parametreleri Bu yöntem, birden fazla değer döndürmeye yardımcı olur.

C # özel bir veri türü sağlar, nullable Normal değerler aralığı ve null değerler atayabileceğiniz türler.

Örneğin, bir Nullable <Int32> değişkeninde -2,147,483,648 ile 2,147,483,647 arasındaki herhangi bir değeri veya null depolayabilirsiniz. Benzer şekilde, bir Nullable <bool> değişkeninde true, false veya null atayabilirsiniz. Bir bildirmek için sözdiziminullable tür aşağıdaki gibidir -

< data_type> ? <variable_name> = null;

Aşağıdaki örnek, null yapılabilir veri türlerinin kullanımını gösterir -

using System;

namespace CalculatorApplication {

   class NullablesAtShow {
   
      static void Main(string[] args) {
         int? num1 = null;
         int? num2 = 45;
         double? num3 = new double?();
         double? num4 = 3.14157;
         
         bool? boolval = new bool?();

         // display the values
         Console.WriteLine("Nullables at Show: {0}, {1}, {2}, {3}", num1, num2, num3, num4);
         Console.WriteLine("A Nullable boolean value: {0}", boolval);
         Console.ReadLine();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Nullables at Show: , 45,  , 3.14157
A Nullable boolean value:

Boş Birleştirme Operatörü (??)

Null birleştirme operatörü, null yapılabilir değer türleri ve başvuru türleriyle kullanılır. Bir işleneni, örtük bir dönüşümün mümkün olduğu başka bir null yapılabilir (veya değil) değer türü işlenen türüne dönüştürmek için kullanılır.

İlk işlenenin değeri null ise, operatör ikinci işlenenin değerini döndürür, aksi takdirde birinci işlenenin değerini döndürür. Aşağıdaki örnek bunu açıklıyor -

using System;

namespace CalculatorApplication {

   class NullablesAtShow {
   
      static void Main(string[] args) {
         double? num1 = null;
         double? num2 = 3.14157;
         double num3;
         num3 = num1 ?? 5.34;      
         Console.WriteLine(" Value of num3: {0}", num3);
         num3 = num2 ?? 5.34;
         Console.WriteLine(" Value of num3: {0}", num3);
         Console.ReadLine();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Value of num3: 5.34
Value of num3: 3.14157

Bir dizi, aynı türden sabit boyutlu sıralı bir öğe koleksiyonunu depolar. Bir dizi veri koleksiyonunu depolamak için kullanılır, ancak bir diziyi bitişik bellek konumlarında depolanan aynı türden değişkenlerin bir koleksiyonu olarak düşünmek genellikle daha kullanışlıdır.

Sayı0, sayı1, ... ve sayı99 gibi tek tek değişkenleri bildirmek yerine, sayılar gibi bir dizi değişkeni bildirir ve temsil etmek için sayılar [0], sayılar [1] ve ..., sayılar [99] kullanırsınız bireysel değişkenler. Bir dizideki belirli bir öğeye bir dizinle erişilir.

Tüm diziler bitişik bellek konumlarından oluşur. En düşük adres ilk öğeye ve en yüksek adres son öğeye karşılık gelir.

Dizileri Bildirme

C # 'da bir dizi bildirmek için aşağıdaki sözdizimini kullanabilirsiniz -

datatype[] arrayName;

nerede,

• veri türü , dizideki öğelerin türünü belirtmek için kullanılır.

• [] dizinin sırasını belirtir. Sıra, dizinin boyutunu belirtir.

• arrayName , dizinin adını belirtir.

Örneğin,

double[] balance;

Bir Diziyi Başlatma

Bir dizinin bildirilmesi, bellekteki diziyi başlatmaz. Dizi değişkeni başlatıldığında, diziye değerler atayabilirsiniz.

Dizi bir başvuru türüdür, bu nedenle newdizinin bir örneğini oluşturmak için anahtar kelime. Örneğin,

double[] balance = new double[10];

Bir Diziye Değer Atama

Dizin numarasını kullanarak, tek tek dizi öğelerine değerler atayabilirsiniz, örneğin -

double[] balance = new double[10];
balance[0] = 4500.0;

Gösterildiği gibi, bildirim sırasında diziye değerler atayabilirsiniz -

double[] balance = { 2340.0, 4523.69, 3421.0};

Ayrıca gösterildiği gibi bir dizi oluşturabilir ve başlatabilirsiniz -

int [] marks = new int[5]  { 99,  98, 92, 97, 95};

Gösterildiği gibi, dizinin boyutunu da atlayabilirsiniz -

int [] marks = new int[]  { 99,  98, 92, 97, 95};

Bir dizi değişkenini başka bir hedef dizi değişkenine kopyalayabilirsiniz. Böyle bir durumda, hem hedef hem de kaynak aynı hafıza konumuna işaret eder -

int [] marks = new int[]  { 99,  98, 92, 97, 95};
int[] score = marks;

Bir dizi oluşturduğunuzda, C # derleyicisi her dizi öğesini dizi türüne bağlı olarak varsayılan bir değere örtük olarak başlatır. Örneğin, bir int dizisi için tüm öğeler 0 olarak başlatılır.

Dizi Öğelerine Erişim

Dizi adını indeksleyerek bir elemana erişilir. Bu, elemanın dizini dizinin isminden sonra köşeli parantez içine yerleştirilerek yapılır. Örneğin,

double salary = balance[9];

Aşağıdaki örnek, yukarıda belirtilen kavramları bildirimi, atamayı ve dizilere erişmeyi gösterir -

using System;

namespace ArrayApplication {

   class MyArray {
   
      static void Main(string[] args) {
         int []  n = new int[10]; /* n is an array of 10 integers */
         int i,j;

         /* initialize elements of array n */
         for ( i = 0; i < 10; i++ ) {
            n[ i ] = i + 100;
         }
         
         /* output each array element's value */
         for (j = 0; j < 10; j++ ) {
            Console.WriteLine("Element[{0}] = {1}", j, n[j]);
         }
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109

Foreach Döngüsünü kullanma

Önceki örnekte, her bir dizi öğesine erişmek için bir for döngüsü kullandık. Ayrıca birforeach bir dizi boyunca yineleme yapmak için ifade.

using System;

namespace ArrayApplication {

   class MyArray {
   
      static void Main(string[] args) {
         int []  n = new int[10]; /* n is an array of 10 integers */
         
         /* initialize elements of array n */
         for ( int i = 0; i < 10; i++ ) {
            n[i] = i + 100;
         }
         
         /* output each array element's value */
         foreach (int j in n ) {
            int i = j-100;
            Console.WriteLine("Element[{0}] = {1}", i, j);
            
         }
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109

C # Diziler

Bir C # programcısı için açık olması gereken, diziyle ilgili aşağıdaki birkaç önemli kavram vardır:

Sr.No.	Konsept ve Açıklama
1	Çok boyutlu diziler C # çok boyutlu dizileri destekler. Çok boyutlu dizinin en basit şekli iki boyutlu dizidir.
2	Pürüzlü diziler C #, dizi dizileri olan çok boyutlu dizileri destekler.
3	Dizileri işlevlere geçirme Dizinin adını indeks olmadan belirterek işleve bir diziye bir işaretçi iletebilirsiniz.
4	Parametre dizileri Bu, bilinmeyen sayıda parametreyi bir işleve geçirmek için kullanılır.
5	Dizi Sınıfı Sistem ad alanında tanımlanan, tüm diziler için temel sınıftır ve dizilerle çalışmak için çeşitli özellikler ve yöntemler sağlar.

C # 'da, dizeleri karakter dizisi olarak kullanabilirsiniz, ancak daha yaygın uygulama, stringbir dize değişkeni bildirmek için anahtar kelime. String anahtar kelimesi,System.String sınıf.

Bir String Nesnesi Oluşturma

Aşağıdaki yöntemlerden birini kullanarak dize nesnesi oluşturabilirsiniz -

• Bir String değişkenine bir dize değişmezi atayarak

• String sınıfı yapıcısı kullanarak

• Dize birleştirme operatörünü (+) kullanarak

• Bir özelliği alarak veya bir dize döndüren bir yöntemi çağırarak

• Bir değeri veya nesneyi dize gösterimine dönüştürmek için bir biçimlendirme yöntemini çağırarak

Aşağıdaki örnek bunu göstermektedir -

using System;

namespace StringApplication {

   class Program {
   
      static void Main(string[] args) {
         //from string literal and string concatenation
         string fname, lname;
         fname = "Rowan";
         lname = "Atkinson";
			
         char []letters= { 'H', 'e', 'l', 'l','o' };
         string [] sarray={ "Hello", "From", "Tutorials", "Point" };
			
         string fullname = fname + lname;
         Console.WriteLine("Full Name: {0}", fullname);
         
         //by using string constructor { 'H', 'e', 'l', 'l','o' };
         string greetings = new string(letters);
         Console.WriteLine("Greetings: {0}", greetings);
         
         //methods returning string { "Hello", "From", "Tutorials", "Point" };
         string message = String.Join(" ", sarray);
         Console.WriteLine("Message: {0}", message);
         
         //formatting method to convert a value
         DateTime waiting = new DateTime(2012, 10, 10, 17, 58, 1);
         string chat = String.Format("Message sent at {0:t} on {0:D}", waiting);
         Console.WriteLine("Message: {0}", chat);
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Full Name: RowanAtkinson
Greetings: Hello
Message: Hello From Tutorials Point
Message: Message sent at 5:58 PM on Wednesday, October 10, 2012

String Sınıfının Özellikleri

String sınıfı aşağıdaki iki özelliğe sahiptir -

Sr.No.	Özellik ve Açıklama
1	Chars Alır Char akım belirlenen bir pozisyonda nesne dize nesne.
2	Length Geçerli String nesnesindeki karakter sayısını alır.

String Sınıfının Yöntemleri

String sınıfı, dize nesneleriyle çalışmanıza yardımcı olacak çok sayıda yönteme sahiptir. Aşağıdaki tablo en yaygın kullanılan yöntemlerden bazılarını göstermektedir -

Aşağıda, String sınıfının yöntemlerinin listesi verilmiştir.

Sr.No.	Yöntemler ve Açıklama
1	public static int Compare(string strA, string strB) Belirtilen iki dize nesnesini karşılaştırır ve sıralama düzenindeki göreli konumlarını gösteren bir tamsayı döndürür.
2	public static int Compare(string strA, string strB, bool ignoreCase ) Belirtilen iki dize nesnesini karşılaştırır ve sıralama düzenindeki göreli konumlarını gösteren bir tamsayı döndürür. Ancak, Boolean parametresi doğruysa durumu yok sayar.
3	public static string Concat(string str0, string str1) İki dize nesnesini birleştirir.
4	public static string Concat(string str0, string str1, string str2) Üç dize nesnesini birleştirir.
5	public static string Concat(string str0, string str1, string str2, string str3) Dört dize nesnesini birleştirir.
6	public bool Contains(string value) Belirtilen String nesnesinin bu dizede oluşup oluşmadığını gösteren bir değer döndürür.
7	public static string Copy(string str) Belirtilen dizeyle aynı değere sahip yeni bir String nesnesi oluşturur.
8	public void CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count) String nesnesinin belirtilen bir konumundan belirtilen sayıda karakteri bir Unicode karakter dizisindeki belirtilen bir konuma kopyalar.
9	public bool EndsWith(string value) Dize nesnesinin sonunun belirtilen dizeyle eşleşip eşleşmediğini belirler.
10	public bool Equals(string value) Geçerli String nesnesinin ve belirtilen String nesnesinin aynı değere sahip olup olmadığını belirler.
11	public static bool Equals(string a, string b) Belirtilen iki String nesnesinin aynı değere sahip olup olmadığını belirler.
12	public static string Format(string format, Object arg0) Belirtilen dizedeki bir veya daha fazla biçim öğesini, belirtilen nesnenin dize gösterimiyle değiştirir.
13	public int IndexOf(char value) Geçerli dizede belirtilen Unicode karakterinin ilk oluşumunun sıfır tabanlı dizinini döndürür.
14	public int IndexOf(string value) Bu örnekte belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini döndürür.
15	public int IndexOf(char value, int startIndex) Bu dizedeki belirtilen Unicode karakterinin ilk oluşumunun sıfır tabanlı dizinini döndürür, aramayı belirtilen karakter konumunda başlatır.
16	public int IndexOf(string value, int startIndex) Aramayı belirtilen karakter konumunda başlatarak, bu örnekte belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini döndürür.
17	public int IndexOfAny(char[] anyOf) Belirtilen bir Unicode karakter dizisindeki herhangi bir karakterin bu örneğindeki ilk oluşumunun sıfır tabanlı dizinini döndürür.
18	public int IndexOfAny(char[] anyOf, int startIndex) Aramayı belirtilen karakter konumunda başlatarak, belirtilen Unicode karakter dizisindeki herhangi bir karakterin bu örneğindeki ilk oluşumunun sıfır tabanlı dizinini döndürür.
19	public string Insert(int startIndex, string value) Geçerli dize nesnesindeki belirtilen dizin konumuna belirtilen dizenin eklendiği yeni bir dize döndürür.
20	public static bool IsNullOrEmpty(string value) Belirtilen dizenin boş mu yoksa Boş bir dize mi olduğunu gösterir.
21	public static string Join(string separator, params string[] value) Her öğe arasında belirtilen ayırıcıyı kullanarak bir dize dizisinin tüm öğelerini birleştirir.
22	public static string Join(string separator, string[] value, int startIndex, int count) Her öğe arasında belirtilen ayırıcıyı kullanarak bir dize dizisinin belirtilen öğelerini birleştirir.
23	public int LastIndexOf(char value) Geçerli dize nesnesi içinde belirtilen Unicode karakterinin son oluşumunun sıfır tabanlı dizin konumunu döndürür.
24	public int LastIndexOf(string value) Geçerli dize nesnesi içinde belirtilen dizenin son oluşumunun sıfır tabanlı dizin konumunu döndürür.
25	public string Remove(int startIndex) Belirtilen bir konumdan başlayıp son konumdan devam ederek geçerli örnekteki tüm karakterleri kaldırır ve dizeyi döndürür.
26	public string Remove(int startIndex, int count) Belirtilen bir konumdan başlayan geçerli dizedeki belirtilen sayıda karakteri kaldırır ve dizeyi döndürür.
27	public string Replace(char oldChar, char newChar) Geçerli dize nesnesindeki belirtilen Unicode karakterinin tüm oluşumlarını belirtilen Unicode karakteriyle değiştirir ve yeni dizeyi döndürür.
28	public string Replace(string oldValue, string newValue) Geçerli dize nesnesindeki belirtilen dizenin tüm oluşumlarını belirtilen dizeyle değiştirir ve yeni dizeyi döndürür.
29	public string[] Split(params char[] separator) Geçerli dize nesnesindeki alt dizeleri içeren, belirtilen bir Unicode karakter dizisinin öğeleriyle ayrılmış bir dize dizisi döndürür.
30	public string[] Split(char[] separator, int count) Geçerli dize nesnesindeki alt dizeleri içeren, belirtilen bir Unicode karakter dizisinin öğeleriyle ayrılmış bir dize dizisi döndürür. İnt parametresi, döndürülecek maksimum alt dize sayısını belirtir.
31	public bool StartsWith(string value) Bu dize örneğinin başlangıcının belirtilen dizeyle eşleşip eşleşmediğini belirler.
32	public char[] ToCharArray() Geçerli dize nesnesindeki tüm karakterleri içeren bir Unicode karakter dizisi döndürür.
33	public char[] ToCharArray(int startIndex, int length) Belirtilen dizinden başlayıp belirtilen uzunluğa kadar geçerli dize nesnesindeki tüm karakterleri içeren bir Unicode karakter dizisi döndürür.
34	public string ToLower() Bu dizenin küçük harfe dönüştürülmüş bir kopyasını döndürür.
35	public string ToUpper() Bu dizenin büyük harfe dönüştürülmüş bir kopyasını döndürür.
36	public string Trim() Geçerli String nesnesinden tüm öndeki ve sondaki beyaz boşluk karakterlerini kaldırır.

Yöntemlerin ve String sınıfı yapıcılarının tam listesi için MSDN kitaplığını ziyaret edebilirsiniz.

Örnekler

Aşağıdaki örnek, yukarıda bahsedilen yöntemlerden bazılarını göstermektedir -

Dizeleri Karşılaştırma

using System;

namespace StringApplication {

   class StringProg {
   
      static void Main(string[] args) {
         string str1 = "This is test";
         string str2 = "This is text";

         if (String.Compare(str1, str2) == 0) {
            Console.WriteLine(str1 + " and " + str2 +  " are equal.");
         } else {
            Console.WriteLine(str1 + " and " + str2 + " are not equal.");
         }
         Console.ReadKey() ;
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

This is test and This is text are not equal.

Dize Dizeyi İçerir

using System;

namespace StringApplication {

   class StringProg {
   
      static void Main(string[] args) {
         string str = "This is test";
         
         if (str.Contains("test")) {
            Console.WriteLine("The sequence 'test' was found.");
         }
         Console.ReadKey() ;
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

The sequence 'test' was found.

Bir Alt Dize Alma

using System;

namespace StringApplication {

   class StringProg {
   
      static void Main(string[] args) {
         string str = "Last night I dreamt of San Pedro";
         Console.WriteLine(str);
         string substr = str.Substring(23);
         Console.WriteLine(substr);
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

San Pedro

Dizelere Katılma

using System;

namespace StringApplication {

   class StringProg {
   
      static void Main(string[] args) {
         string[] starray = new string[]{"Down the way nights are dark",
            "And the sun shines daily on the mountain top",
            "I took a trip on a sailing ship",
            "And when I reached Jamaica",
            "I made a stop"};

         string str = String.Join("\n", starray);
         Console.WriteLine(str);
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Down the way nights are dark
And the sun shines daily on the mountain top
I took a trip on a sailing ship
And when I reached Jamaica
I made a stop

C # 'da bir yapı, bir değer türü veri türüdür. Çeşitli veri türleriyle ilgili verileri tek bir değişken tutmanıza yardımcı olur. struct anahtar kelime bir yapı oluşturmak için kullanılır.

Yapılar bir kaydı temsil etmek için kullanılır. Kitaplarınızı bir kütüphanede takip etmek istediğinizi varsayalım. Her kitapla ilgili aşağıdaki öznitelikleri izlemek isteyebilirsiniz -

• Title
• Author
• Subject
• Kitap kimliği

Bir Yapının Tanımlanması

Bir yapıyı tanımlamak için struct ifadesini kullanmanız gerekir. Struct deyimi, programınız için birden fazla üye içeren yeni bir veri türünü tanımlar.

Örneğin, Kitap yapısını şu şekilde bildirebilirsiniz -

struct Books {
   public string title;
   public string author;
   public string subject;
   public int book_id;
};

Aşağıdaki program yapının kullanımını göstermektedir -

using System;

struct Books {
   public string title;
   public string author;
   public string subject;
   public int book_id;
};  

public class testStructure {

   public static void Main(string[] args) {
      Books Book1;   /* Declare Book1 of type Book */
      Books Book2;   /* Declare Book2 of type Book */

      /* book 1 specification */
      Book1.title = "C Programming";
      Book1.author = "Nuha Ali"; 
      Book1.subject = "C Programming Tutorial";
      Book1.book_id = 6495407;

      /* book 2 specification */
      Book2.title = "Telecom Billing";
      Book2.author = "Zara Ali";
      Book2.subject =  "Telecom Billing Tutorial";
      Book2.book_id = 6495700;

      /* print Book1 info */
      Console.WriteLine( "Book 1 title : {0}", Book1.title);
      Console.WriteLine("Book 1 author : {0}", Book1.author);
      Console.WriteLine("Book 1 subject : {0}", Book1.subject);
      Console.WriteLine("Book 1 book_id :{0}", Book1.book_id);

      /* print Book2 info */
      Console.WriteLine("Book 2 title : {0}", Book2.title);
      Console.WriteLine("Book 2 author : {0}", Book2.author);
      Console.WriteLine("Book 2 subject : {0}", Book2.subject);
      Console.WriteLine("Book 2 book_id : {0}", Book2.book_id);       

      Console.ReadKey();
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Book 1 title : C Programming
Book 1 author : Nuha Ali
Book 1 subject : C Programming Tutorial
Book 1 book_id : 6495407
Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495700

C # Yapılarının Özellikleri

Zaten Books adında basit bir yapı kullandınız. C # 'teki yapılar geleneksel C veya C ++' dan oldukça farklıdır. C # yapıları aşağıdaki özelliklere sahiptir -

• Yapıların yöntemleri, alanları, dizinleyicileri, özellikleri, operatör yöntemleri ve olayları olabilir.

• Yapılar tanımlı yapıcılara sahip olabilir, ancak yıkıcılar olamaz. Ancak, bir yapı için varsayılan bir kurucu tanımlayamazsınız. Varsayılan kurucu otomatik olarak tanımlanır ve değiştirilemez.

• Sınıfların aksine, yapılar diğer yapıları veya sınıfları devralamaz.

• Yapılar, diğer yapılar veya sınıflar için temel olarak kullanılamaz.

• Bir yapı, bir veya daha fazla arayüz uygulayabilir.

• Yapı üyeleri soyut, sanal veya korumalı olarak belirtilemez.

• Kullanarak bir struct nesnesi oluşturduğunuzda Newoperatörü oluşturulur ve uygun kurucu çağrılır. Sınıfların aksine, yapılar New operatörü kullanılmadan başlatılabilir.

• Yeni işleci kullanılmazsa, alanlar atanmadan kalır ve tüm alanlar başlatılana kadar nesne kullanılamaz.

Sınıf ve Yapı

Sınıflar ve Yapılar aşağıdaki temel farklılıklara sahiptir -

• sınıflar başvuru türleridir ve yapılar değer türleridir
• yapılar mirası desteklemiyor
• yapıların varsayılan kurucusu olamaz

Yukarıdaki tartışmalar ışığında, önceki örneği yeniden yazalım -

using System;

struct Books {
   private string title;
   private string author;
   private string subject;
   private int book_id;
   
   public void getValues(string t, string a, string s, int id) {
      title = t;
      author = a;
      subject = s;
      book_id = id;
   }
   
   public void display() {
      Console.WriteLine("Title : {0}", title);
      Console.WriteLine("Author : {0}", author);
      Console.WriteLine("Subject : {0}", subject);
      Console.WriteLine("Book_id :{0}", book_id);
   }
};  

public class testStructure {

   public static void Main(string[] args) {
      Books Book1 = new Books();   /* Declare Book1 of type Book */
      Books Book2 = new Books();   /* Declare Book2 of type Book */

      /* book 1 specification */
      Book1.getValues("C Programming",
      "Nuha Ali", "C Programming Tutorial",6495407);

      /* book 2 specification */
      Book2.getValues("Telecom Billing",
      "Zara Ali", "Telecom Billing Tutorial", 6495700);

      /* print Book1 info */
      Book1.display();

      /* print Book2 info */
      Book2.display(); 

      Console.ReadKey();
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Title : C Programming
Author : Nuha Ali
Subject : C Programming Tutorial
Book_id : 6495407
Title : Telecom Billing
Author : Zara Ali
Subject : Telecom Billing Tutorial
Book_id : 6495700

Numaralandırma, adlandırılmış tamsayı sabitleri kümesidir. Numaralandırılmış bir tür,enum anahtar kelime.

C # numaralandırmaları değer veri türüdür. Başka bir deyişle, numaralandırma kendi değerlerini içerir ve mirası devralamaz veya geçemez.

Bildirilmesi numaralama Değişken

Bir numaralandırma bildirmek için genel sözdizimi -

enum <enum_name> {
   enumeration list 
};

Nerede,

• Enum_name numaralandırma türü adını belirtir.

• Numaralandırma Listesi tanımlayıcıları virgülle ayrılmış bir listesidir.

Numaralandırma listesindeki sembollerin her biri, kendisinden önce gelen sembolden büyük olan bir tamsayı değerini ifade eder. Varsayılan olarak, ilk numaralandırma sembolünün değeri 0'dır. Örneğin -

enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat };

Misal

Aşağıdaki örnek, enum değişkeninin kullanımını gösterir -

using System;

namespace EnumApplication {

   class EnumProgram {
      enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat };

      static void Main(string[] args) {
         int WeekdayStart = (int)Days.Mon;
         int WeekdayEnd = (int)Days.Fri;
         Console.WriteLine("Monday: {0}", WeekdayStart);
         Console.WriteLine("Friday: {0}", WeekdayEnd);
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Monday: 1
Friday: 5

Bir sınıf tanımladığınızda, bir veri türü için bir plan tanımlarsınız. Bu aslında herhangi bir veriyi tanımlamaz, ancak sınıf adının ne anlama geldiğini tanımlar. Yani, sınıfın bir nesnesi nelerden oluşur ve bu nesne üzerinde hangi işlemler yapılabilir. Nesneler, bir sınıfın örnekleridir. Bir sınıfı oluşturan yöntemler ve değişkenler, sınıfın üyeleri olarak adlandırılır.

Sınıf Tanımlama

Bir sınıf tanımı, class anahtar sözcüğü ve ardından sınıf adı ile başlar; ve bir çift kaşlı ayraç içine alınmış sınıf gövdesi. Aşağıda bir sınıf tanımının genel şekli verilmiştir -

<access specifier> class  class_name {
   // member variables
   <access specifier> <data type> variable1;
   <access specifier> <data type> variable2;
   ...
   <access specifier> <data type> variableN;
   // member methods
   <access specifier> <return type> method1(parameter_list) {
      // method body
   }
   <access specifier> <return type> method2(parameter_list) {
      // method body
   }
   ...
   <access specifier> <return type> methodN(parameter_list) {
      // method body
   }
}

Not -

• Erişim belirticileri, üyelerin yanı sıra sınıfın kendisi için erişim kurallarını belirtir. Bahsedilmediyse, sınıf türü için varsayılan erişim belirticisiinternal. Üyeler için varsayılan erişimprivate.

• Veri türü değişkenin türünü belirtir ve dönüş türü, varsa yöntemin döndürdüğü verilerin veri türünü belirtir.

• Sınıf üyelerine erişmek için nokta (.) Operatörünü kullanırsınız.

• Nokta operatörü, bir nesnenin adını bir üyenin adıyla ilişkilendirir.

Aşağıdaki örnek, şimdiye kadar tartışılan kavramları göstermektedir -

using System;

namespace BoxApplication {

    class Box {
       public double length;   // Length of a box
       public double breadth;  // Breadth of a box
       public double height;   // Height of a box
    }
    
    class Boxtester {

        static void Main(string[] args) {
            Box Box1 = new Box();   // Declare Box1 of type Box
            Box Box2 = new Box();   // Declare Box2 of type Box
            double volume = 0.0;    // Store the volume of a box here

            // box 1 specification
            Box1.height = 5.0;
            Box1.length = 6.0;
            Box1.breadth = 7.0;

            // box 2 specification
            Box2.height = 10.0;
            Box2.length = 12.0;
            Box2.breadth = 13.0;
           
            // volume of box 1
            volume = Box1.height * Box1.length * Box1.breadth;
            Console.WriteLine("Volume of Box1 : {0}",  volume);

            // volume of box 2
            volume = Box2.height * Box2.length * Box2.breadth;
            Console.WriteLine("Volume of Box2 : {0}", volume);
            Console.ReadKey();
        }
    }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Volume of Box1 : 210
Volume of Box2 : 1560

Üye İşlevleri ve Kapsülleme

Bir sınıfın üye işlevi, tanımına veya prototipine diğer herhangi bir değişkene benzer sınıf tanımı içinde sahip bir işlevdir. Üyesi olduğu sınıfın herhangi bir nesnesi üzerinde çalışır ve bu nesne için bir sınıfın tüm üyelerine erişime sahiptir.

Üye değişkenler, bir nesnenin özellikleridir (tasarım açısından) ve kapsüllemeyi uygulamak için gizli tutulurlar. Bu değişkenlere yalnızca genel üye işlevleri kullanılarak erişilebilir.

Bir sınıftaki farklı sınıf üyelerinin değerini belirlemek ve elde etmek için yukarıdaki kavramları koyalım -

using System;

namespace BoxApplication {

   class Box {
      private double length;   // Length of a box
      private double breadth;  // Breadth of a box
      private double height;   // Height of a box
      
      public void setLength( double len ) {
         length = len;
      }
      
      public void setBreadth( double bre ) {
         breadth = bre;
      }
      
      public void setHeight( double hei ) {
         height = hei;
      }
      public double getVolume() {
         return length * breadth * height;
      }
   }
   
   class Boxtester {
   
      static void Main(string[] args) {
         Box Box1 = new Box();   // Declare Box1 of type Box
         Box Box2 = new Box();
         double volume;
         
         // Declare Box2 of type Box
         // box 1 specification
         Box1.setLength(6.0);
         Box1.setBreadth(7.0);
         Box1.setHeight(5.0);
         
         // box 2 specification
         Box2.setLength(12.0);
         Box2.setBreadth(13.0);
         Box2.setHeight(10.0);
         
         // volume of box 1
         volume = Box1.getVolume();
         Console.WriteLine("Volume of Box1 : {0}" ,volume);
         
         // volume of box 2
         volume = Box2.getVolume();
         Console.WriteLine("Volume of Box2 : {0}", volume);
         
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Volume of Box1 : 210
Volume of Box2 : 1560

C # Oluşturucular

Bir sınıf constructor o sınıftan yeni nesneler yarattığımızda çalıştırılan bir sınıfın özel üye fonksiyonudur.

Bir kurucu, sınıfın adıyla tam olarak aynı ada sahiptir ve herhangi bir dönüş türüne sahip değildir. Aşağıdaki örnek, kurucu kavramını açıklamaktadır -

using System;

namespace LineApplication {

   class Line {
      private double length;   // Length of a line
      
      public Line() {
         Console.WriteLine("Object is being created");
      }

      public void setLength( double len ) {
         length = len;
      }
      
      public double getLength() {
         return length;
      }

      static void Main(string[] args) {
         Line line = new Line();    
         
         // set line length
         line.setLength(6.0);
         Console.WriteLine("Length of line : {0}", line.getLength());
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Object is being created
Length of line : 6

Bir default constructorherhangi bir parametreye sahip değildir, ancak ihtiyacınız varsa, bir kurucu parametrelere sahip olabilir. Bu tür kurucular denirparameterized constructors. Bu teknik, aşağıdaki örnekte gösterildiği gibi, nesnenin oluşturulduğu sırada bir nesneye başlangıç ​​değeri atamanıza yardımcı olur -

using System;

namespace LineApplication {

   class Line {
      private double length;   // Length of a line
      
      public Line(double len) {  //Parameterized constructor
         Console.WriteLine("Object is being created, length = {0}", len);
         length = len;
      }

      public void setLength( double len ) {
         length = len;
      }
      
      public double getLength() {
         return length;
      }

      static void Main(string[] args) {
         Line line = new Line(10.0);
         Console.WriteLine("Length of line : {0}", line.getLength()); 
         
         // set line length
         line.setLength(6.0);
         Console.WriteLine("Length of line : {0}", line.getLength()); 
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Object is being created, length = 10
Length of line : 10
Length of line : 6

C # Yıkıcılar

Bir destructorsınıfının bir nesnesi kapsam dışına çıktığında çalıştırılan bir sınıfın özel üye işlevidir. Birdestructor tilde (~) önekli sınıfın adıyla tam olarak aynı ada sahiptir ve ne bir değer döndürebilir ne de herhangi bir parametre alabilir.

Destructor, programdan çıkmadan önce bellek kaynaklarını serbest bırakmak için çok yararlı olabilir. Yıkıcılar miras alınamaz veya aşırı yüklenemez.

Aşağıdaki örnek yıkıcı kavramını açıklıyor -

using System;

namespace LineApplication {

   class Line {
      private double length;   // Length of a line
      
      public Line() {   // constructor
         Console.WriteLine("Object is being created");
      }
      
      ~Line() {   //destructor
         Console.WriteLine("Object is being deleted");
      }

      public void setLength( double len ) {
         length = len;
      }

      public double getLength() {
         return length;
      }

      static void Main(string[] args) {
         Line line = new Line();

         // set line length
         line.setLength(6.0);
         Console.WriteLine("Length of line : {0}", line.getLength());           
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Object is being created
Length of line : 6
Object is being deleted

C # Sınıfının Statik Üyeleri

Sınıf üyelerini statik olarak tanımlayabiliriz. staticanahtar kelime. Bir sınıfın bir üyesini statik olarak ilan ettiğimizde, bu, sınıfın kaç nesnesi oluşturulursa oluşturulsun, statik üyenin yalnızca bir kopyası olduğu anlamına gelir.

Anahtar kelime staticBir sınıf için üyenin yalnızca bir örneğinin var olduğunu ima eder. Statik değişkenler, sabitleri tanımlamak için kullanılır, çünkü değerleri, bir örneğini oluşturmadan sınıfı çağırarak alınabilir. Statik değişkenler, üye işlevi veya sınıf tanımının dışında başlatılabilir. Ayrıca sınıf tanımının içindeki statik değişkenleri de başlatabilirsiniz.

Aşağıdaki örnek, static variables -

using System;

namespace StaticVarApplication {

   class StaticVar {
      public static int num;
      
      public void count() {
         num++;
      }
      
      public int getNum() {
         return num;
      }
   }
   
   class StaticTester {
   
      static void Main(string[] args) {
         StaticVar s1 = new StaticVar();
         StaticVar s2 = new StaticVar();
         s1.count();
         s1.count();
         s1.count();
         s2.count();
         s2.count();
         s2.count();
         Console.WriteLine("Variable num for s1: {0}", s1.getNum());
         Console.WriteLine("Variable num for s2: {0}", s2.getNum());
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Variable num for s1: 6
Variable num for s2: 6

Ayrıca bir member function gibi static. Bu tür işlevler yalnızca statik değişkenlere erişebilir. Statik işlevler, nesne oluşturulmadan önce bile mevcuttur. Aşağıdaki örnek,static functions -

using System;

namespace StaticVarApplication {

   class StaticVar {
      public static int num;
      
      public void count() {
         num++;
      }
      
      public static int getNum() {
         return num;
      }
   }
   
   class StaticTester {
   
      static void Main(string[] args) {
         StaticVar s = new StaticVar();
         s.count();
         s.count();
         s.count();
         Console.WriteLine("Variable num: {0}", StaticVar.getNum());
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Variable num: 3

Nesne yönelimli programlamadaki en önemli kavramlardan biri kalıtımdır. Kalıtım, bir sınıfı başka bir sınıf açısından tanımlamamıza izin verir, bu da bir uygulama oluşturmayı ve sürdürmeyi kolaylaştırır. Bu aynı zamanda kod işlevselliğini yeniden kullanma fırsatı sağlar ve uygulama süresini hızlandırır.

Bir sınıf oluştururken, tamamen yeni veri üyeleri ve üye işlevler yazmak yerine, programcı yeni sınıfın mevcut bir sınıfın üyelerini miras alması gerektiğini belirleyebilir. Bu mevcut sınıfabase sınıf ve yeni sınıf, derived sınıf.

Kalıtım fikri, IS-Ailişki. Örneğin, memeliIS A hayvan, köpek IS-A Memeli dolayısıyla köpek IS-A hayvan da vb.

Temel ve Türetilmiş Sınıflar

Bir sınıf, birden fazla sınıf veya arabirimden türetilebilir; bu, birden çok temel sınıftan veya arabirimden verileri ve işlevleri miras alabileceği anlamına gelir.

Türetilmiş sınıflar oluşturmak için C # 'da kullanılan sözdizimi aşağıdaki gibidir -

<acess-specifier> class <base_class> {
   ...
}

class <derived_class> : <base_class> {
   ...
}

Shape temel sınıfını ve onun türetilmiş Rectangle sınıfını düşünün -

using System;

namespace InheritanceApplication {
   
   class Shape {
      
      public void setWidth(int w) {
         width = w;
      }
      
      public void setHeight(int h) {
         height = h;
      }
      protected int width;
      protected int height;
   }

   // Derived class
   class Rectangle: Shape {
      
      public int getArea() { 
         return (width * height); 
      }
   }
   
   class RectangleTester {
   
      static void Main(string[] args) {
         Rectangle Rect = new Rectangle();

         Rect.setWidth(5);
         Rect.setHeight(7);

         // Print the area of the object.
         Console.WriteLine("Total area: {0}",  Rect.getArea());
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Total area: 35

Temel Sınıf Başlatılıyor

Türetilmiş sınıf, temel sınıf üye değişkenlerini ve üye yöntemlerini miras alır. Bu nedenle, süper sınıf nesnesi, alt sınıf oluşturulmadan önce oluşturulmalıdır. Üye başlatma listesinde süper sınıf başlatma için talimatlar verebilirsiniz.

Aşağıdaki program bunu göstermektedir -

using System;

namespace RectangleApplication {

   class Rectangle {
      //member variables
      protected double length;
      protected double width;
      
      public Rectangle(double l, double w) {
         length = l;
         width = w;
      }
      
      public double GetArea() {
         return length * width;
      }
      
      public void Display() {
         Console.WriteLine("Length: {0}", length);
         Console.WriteLine("Width: {0}", width);
         Console.WriteLine("Area: {0}", GetArea());
      }
   }//end class Rectangle  
   
   class Tabletop : Rectangle {
      private double cost;
      public Tabletop(double l, double w) : base(l, w) { }
      
      public double GetCost() {
         double cost;
         cost = GetArea() * 70;
         return cost;
      }
      
      public void Display() {
         base.Display();
         Console.WriteLine("Cost: {0}", GetCost());
      }
   }
   
   class ExecuteRectangle {
      
      static void Main(string[] args) {
         Tabletop t = new Tabletop(4.5, 7.5);
         t.Display();
         Console.ReadLine();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Length: 4.5
Width: 7.5
Area: 33.75
Cost: 2362.5

C # 'da Çoklu Kalıtım

C# does not support multiple inheritance. Bununla birlikte, birden çok kalıtım uygulamak için arabirimleri kullanabilirsiniz. Aşağıdaki program bunu göstermektedir -

using System;

namespace InheritanceApplication {
   
   class Shape {
      
      public void setWidth(int w) {
         width = w;
      }
      
      public void setHeight(int h) {
         height = h;
      }
      protected int width;
      protected int height;
   }

   // Base class PaintCost
   public interface PaintCost {
      int getCost(int area);
   }
   
   // Derived class
   class Rectangle : Shape, PaintCost {
      
      public int getArea() {
         return (width * height);
      }
      
      public int getCost(int area) {
         return area * 70;
      }
   }
   
   class RectangleTester {
      
      static void Main(string[] args) {
         Rectangle Rect = new Rectangle();
         int area;
         Rect.setWidth(5);
         Rect.setHeight(7);
         area = Rect.getArea();
         
         // Print the area of the object.
         Console.WriteLine("Total area: {0}",  Rect.getArea());
         Console.WriteLine("Total paint cost: ${0}" , Rect.getCost(area));
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Total area: 35
Total paint cost: $2450

Kelime polymorphismbirçok biçime sahip olmak anlamına gelir. Nesne yönelimli programlama paradigmasında, polimorfizm genellikle 'tek arayüz, çoklu fonksiyonlar' olarak ifade edilir.

Polimorfizm statik veya dinamik olabilir. İçindestatic polymorphism, bir işleve verilen yanıt derleme zamanında belirlenir. İçindedynamic polymorphism, çalışma zamanında karar verilir.

Statik Polimorfizm

Derleme süresi sırasında bir işlevi bir nesneye bağlama mekanizmasına erken bağlama denir. Statik bağlama olarak da adlandırılır. C #, statik polimorfizmi uygulamak için iki teknik sağlar. Onlar -

• Fonksiyon aşırı yükleme
• Operatör aşırı yükleme

Operatör aşırı yüklemesini sonraki bölümde tartışacağız.

Fonksiyon Aşırı Yüklemesi

Aynı kapsamda aynı işlev adı için birden fazla tanımınız olabilir. Fonksiyonun tanımı, argüman listesindeki türler ve / veya argümanların sayısı bakımından birbirinden farklı olmalıdır. Yalnızca dönüş türüne göre farklılık gösteren işlev bildirimlerini aşırı yükleyemezsiniz.

Aşağıdaki örnek, işlevi kullanmayı gösterir print() farklı veri türlerini yazdırmak için -

using System;

namespace PolymorphismApplication {

   class Printdata {
   
      void print(int i) {
         Console.WriteLine("Printing int: {0}", i );
      }

      void print(double f) {
         Console.WriteLine("Printing float: {0}" , f);
      }

      void print(string s) {
         Console.WriteLine("Printing string: {0}", s);
      }
      
      static void Main(string[] args) {
         Printdata p = new Printdata();
         
         // Call print to print integer
         p.print(5);
         
         // Call print to print float
         p.print(500.263);
         
         // Call print to print string
         p.print("Hello C++");
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Printing int: 5
Printing float: 500.263
Printing string: Hello C++

Dinamik Polimorfizm

C #, bir arabirimin kısmi sınıf uygulamasını sağlamak için kullanılan soyut sınıflar oluşturmanıza olanak tanır. Türetilmiş bir sınıf ondan miras aldığında uygulama tamamlanır.Abstractsınıflar, türetilmiş sınıf tarafından uygulanan soyut yöntemler içerir. Türetilmiş sınıflar daha özel işlevlere sahiptir.

Soyut sınıflarla ilgili kurallar şunlardır -

• Soyut bir sınıfın bir örneğini oluşturamazsınız

• Soyut bir sınıfın dışında soyut bir yöntem bildiremezsiniz

• Bir sınıf bildirildiğinde sealed, miras alınamaz, soyut sınıflar mühürlenmiş olarak ilan edilemez.

Aşağıdaki program soyut bir sınıfı göstermektedir -

using System;

namespace PolymorphismApplication {

   abstract class Shape {
      public abstract int area();
   }
   
   class Rectangle:  Shape {
      private int length;
      private int width;
      
      public Rectangle( int a = 0, int b = 0) {
         length = a;
         width = b;
      }
      
      public override int area () { 
         Console.WriteLine("Rectangle class area :");
         return (width * length); 
      }
   }

   class RectangleTester {
      
      static void Main(string[] args) {
         Rectangle r = new Rectangle(10, 7);
         double a = r.area();
         Console.WriteLine("Area: {0}",a);
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Rectangle class area :
Area: 70

Miras alınan sınıf (lar) da uygulanmasını istediğiniz bir sınıfta tanımlanmış bir fonksiyonunuz olduğunda, virtualfonksiyonlar. Sanal işlevler, farklı miras alınan sınıfta farklı şekilde uygulanabilir ve bu işlevlere yapılan çağrı çalışma zamanında kararlaştırılacaktır.

Dinamik polimorfizm, abstract classes ve virtual functions.

Aşağıdaki program bunu göstermektedir -

using System;

namespace PolymorphismApplication {

   class Shape {
      protected int width, height;
      
      public Shape( int a = 0, int b = 0) {
         width = a;
         height = b;
      }
      
      public virtual int area() {
         Console.WriteLine("Parent class area :");
         return 0;
      }
   }
   
   class Rectangle: Shape {
      public Rectangle( int a = 0, int b = 0): base(a, b) {

      }
      
      public override int area () {
         Console.WriteLine("Rectangle class area :");
         return (width * height); 
      }
   }
   
   class Triangle: Shape {
      public Triangle(int a = 0, int b = 0): base(a, b) {
      
      }
      
      public override int area() {
         Console.WriteLine("Triangle class area :");
         return (width * height / 2); 
      }
   }
   
   class Caller {
      public void CallArea(Shape sh) {
         int a;
         a = sh.area();
         Console.WriteLine("Area: {0}", a);
      }
   }  
   
   class Tester {

      static void Main(string[] args) {
         Caller c = new Caller();
         Rectangle r = new Rectangle(10, 7);
         Triangle t = new Triangle(10, 5);
         c.CallArea(r);
         c.CallArea(t);
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Rectangle class area:
Area: 70
Triangle class area:
Area: 25

C # 'da bulunan yerleşik operatörlerin çoğunu yeniden tanımlayabilir veya aşırı yükleyebilirsiniz. Böylece bir programcı, kullanıcı tanımlı tiplere sahip operatörleri de kullanabilir. Aşırı yüklenmiş operatörler, anahtar kelime olarak özel adlara sahip işlevlerdir.operatorve ardından tanımlanmakta olan operatörün sembolü gelir. diğer herhangi bir işleve benzer şekilde, aşırı yüklenmiş bir operatörün bir dönüş türü ve bir parametre listesi vardır.

Örneğin, aşağıdaki işlevi uygulayın -

public static Box operator+ (Box b, Box c) {
   Box box = new Box();
   box.length = b.length + c.length;
   box.breadth = b.breadth + c.breadth;
   box.height = b.height + c.height;
   return box;
}

Yukarıdaki işlev, kullanıcı tanımlı bir Box sınıfı için toplama operatörünü (+) uygular. İki Box nesnesinin niteliklerini ekler ve ortaya çıkan Box nesnesini döndürür.

Operatör Aşırı Yüklemesinin Uygulanması

Aşağıdaki program tam uygulamayı gösterir -

using System;

namespace OperatorOvlApplication {

   class Box {
      private double length;   // Length of a box
      private double breadth;  // Breadth of a box
      private double height;   // Height of a box

      public double getVolume() {
         return length * breadth * height;
      }
      
      public void setLength( double len ) {
         length = len;
      }

      public void setBreadth( double bre ) {
         breadth = bre;
      }

      public void setHeight( double hei ) {
         height = hei;
      }
      
      // Overload + operator to add two Box objects.
      public static Box operator+ (Box b, Box c) {
         Box box = new Box();
         box.length = b.length + c.length;
         box.breadth = b.breadth + c.breadth;
         box.height = b.height + c.height;
         return box;
      }
   }

   class Tester {
   
      static void Main(string[] args) {
         Box Box1 = new Box();   // Declare Box1 of type Box
         Box Box2 = new Box();   // Declare Box2 of type Box
         Box Box3 = new Box();   // Declare Box3 of type Box
         double volume = 0.0;    // Store the volume of a box here

         // box 1 specification
         Box1.setLength(6.0);
         Box1.setBreadth(7.0);
         Box1.setHeight(5.0);

         // box 2 specification
         Box2.setLength(12.0);
         Box2.setBreadth(13.0);
         Box2.setHeight(10.0);

         // volume of box 1
         volume = Box1.getVolume();
         Console.WriteLine("Volume of Box1 : {0}", volume);

         // volume of box 2
         volume = Box2.getVolume();
         Console.WriteLine("Volume of Box2 : {0}", volume);

         // Add two object as follows:
         Box3 = Box1 + Box2;

         // volume of box 3
         volume = Box3.getVolume();
         Console.WriteLine("Volume of Box3 : {0}", volume);
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Volume of Box1 : 210
Volume of Box2 : 1560
Volume of Box3 : 5400

Aşırı Yüklenebilir ve Aşırı Yüklenemez Operatörler

Aşağıdaki tablo operatörlerin C # 'da aşırı yüklenme kabiliyetini açıklamaktadır -

Sr.No.	Operatörler ve Açıklama
1	+, -, !, ~, ++, -- Bu tekli operatörler bir işlenen alır ve aşırı yüklenebilir.
2	+, -, *, /, % Bu ikili operatörler bir işlenen alır ve aşırı yüklenebilir.
3	==, !=, <, >, <=, >= Karşılaştırma operatörleri aşırı yüklenebilir.
4	&&, || Koşullu mantıksal operatörler doğrudan aşırı yüklenemez.
5	+=, -=, *=, /=, %= Atama operatörleri aşırı yüklenemez.
6	=, ., ?:, ->, new, is, sizeof, typeof Bu operatörler aşırı yüklenemez.

Misal

Yukarıdaki tartışmaların ışığında, önceki örneği genişletelim ve birkaç operatöre daha fazla yükleme yapalım -

using System;

namespace OperatorOvlApplication {

   class Box {
      private double length;    // Length of a box
      private double breadth;   // Breadth of a box
      private double height;    // Height of a box
      
      public double getVolume() {
         return length * breadth * height;
      }
      
      public void setLength( double len ) {
         length = len;
      }
      
      public void setBreadth( double bre ) {
         breadth = bre;
      }
      
      public void setHeight( double hei ) {
         height = hei;
      }
      
      // Overload + operator to add two Box objects.
      public static Box operator+ (Box b, Box c) {
         Box box = new Box();
         box.length = b.length + c.length;
         box.breadth = b.breadth + c.breadth;
         box.height = b.height + c.height;
         return box;
      }

      public static bool operator == (Box lhs, Box rhs) {
         bool status = false;
         if (lhs.length == rhs.length && lhs.height == rhs.height && lhs.breadth == rhs.breadth) {
            status = true;
         }
         return status;
      }
      
      public static bool operator !=(Box lhs, Box rhs) {
         bool status = false;
         
         if (lhs.length != rhs.length || lhs.height != rhs.height || lhs.breadth != rhs.breadth) {
            status = true;
         }
         return status;
      }
      
      public static bool operator <(Box lhs, Box rhs) {
         bool status = false;
         
         if (lhs.length < rhs.length && lhs.height < rhs.height && lhs.breadth < rhs.breadth) {
            status = true;
         }
         return status;
      }
      
      public static bool operator >(Box lhs, Box rhs) {
         bool status = false;
         
         if (lhs.length > rhs.length && lhs.height > rhs.height && lhs.breadth > rhs.breadth) {
            status = true;
         }
         return status;
      }
      
      public static bool operator <=(Box lhs, Box rhs) {
         bool status = false;
         
         if (lhs.length <= rhs.length && lhs.height <= rhs.height && lhs.breadth <= rhs.breadth) {
            status = true;
         }
         return status;
      }
      
      public static bool operator >=(Box lhs, Box rhs) {
         bool status = false;
         
         if (lhs.length >= rhs.length && lhs.height >= rhs.height && lhs.breadth >= rhs.breadth) {
            status = true;
         }
         return status;
      }
      
      public override string ToString() {
         return String.Format("({0}, {1}, {2})", length, breadth, height);
      }
   }
   
   class Tester {
   
      static void Main(string[] args) {
         Box Box1 = new Box();   // Declare Box1 of type Box
         Box Box2 = new Box();   // Declare Box2 of type Box
         Box Box3 = new Box();   // Declare Box3 of type Box
         Box Box4 = new Box();
         double volume = 0.0;    // Store the volume of a box here
         
         // box 1 specification
         Box1.setLength(6.0);
         Box1.setBreadth(7.0);
         Box1.setHeight(5.0);
         
         // box 2 specification
         Box2.setLength(12.0);
         Box2.setBreadth(13.0);
         Box2.setHeight(10.0);
         
         //displaying the Boxes using the overloaded ToString():
         Console.WriteLine("Box 1: {0}", Box1.ToString());
         Console.WriteLine("Box 2: {0}", Box2.ToString());
         
         // volume of box 1
         volume = Box1.getVolume();
         Console.WriteLine("Volume of Box1 : {0}", volume);
         
         // volume of box 2
         volume = Box2.getVolume();
         Console.WriteLine("Volume of Box2 : {0}", volume);
         
         // Add two object as follows:
         Box3 = Box1 + Box2;
         Console.WriteLine("Box 3: {0}", Box3.ToString());
         
         // volume of box 3
         volume = Box3.getVolume();
         Console.WriteLine("Volume of Box3 : {0}", volume);
         
         //comparing the boxes
         if (Box1 > Box2)
            Console.WriteLine("Box1 is greater than Box2");
         else
            Console.WriteLine("Box1 is  greater than Box2");
         
         if (Box1 < Box2)
            Console.WriteLine("Box1 is less than Box2");
         else
            Console.WriteLine("Box1 is not less than Box2");
         
         if (Box1 >= Box2)
            Console.WriteLine("Box1 is greater or equal to Box2");
         else
            Console.WriteLine("Box1 is not greater or equal to Box2");
         
         if (Box1 <= Box2)
            Console.WriteLine("Box1 is less or equal to Box2");
         else
            Console.WriteLine("Box1 is not less or equal to Box2");
         
         if (Box1 != Box2)
            Console.WriteLine("Box1 is not equal to Box2");
         else
            Console.WriteLine("Box1 is not greater or equal to Box2");
         Box4 = Box3;
         
         if (Box3 == Box4)
            Console.WriteLine("Box3 is equal to Box4");
         else
            Console.WriteLine("Box3 is not equal to Box4");

         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Box 1: (6, 7, 5)
Box 2: (12, 13, 10)
Volume of Box1 : 210
Volume of Box2 : 1560
Box 3: (18, 20, 15)
Volume of Box3 : 5400
Box1 is not greater than Box2
Box1 is less than Box2
Box1 is not greater or equal to Box2
Box1 is less or equal to Box2
Box1 is not equal to Box2
Box3 is equal to Box4

Arayüz, arayüzü miras alan tüm sınıfların izlemesi gereken sözdizimsel bir sözleşme olarak tanımlanır. Arayüz,'what' sözdizimsel sözleşmenin bir parçası ve türetilen sınıflar, 'how' sözdizimsel sözleşmenin bir parçası.

Arayüzler, arayüzün üyeleri olan özellikleri, yöntemleri ve olayları tanımlar. Arayüzler sadece üyelerin beyanını içerir. Üyeleri tanımlamak türetilen sınıfın sorumluluğundadır. Genellikle türetilen sınıfların izleyeceği standart bir yapı sağlamaya yardımcı olur.

Soyut sınıflar bir dereceye kadar aynı amaca hizmet eder, ancak bunlar çoğunlukla temel sınıf tarafından yalnızca birkaç yöntem bildirildiğinde ve türetilen sınıf işlevsellikleri uyguladığında kullanılır.

Arayüzleri Bildirme

Arayüzler, interface anahtar sözcüğü kullanılarak bildirilir. Sınıf bildirimine benzer. Arayüz ifadeleri varsayılan olarak herkese açıktır. Aşağıda bir arayüz bildirimi örneği verilmiştir -

public interface ITransactions {
   // interface members
   void showTransaction();
   double getAmount();
}

Misal

Aşağıdaki örnek, yukarıdaki arayüzün uygulanmasını gösterir -

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

namespace InterfaceApplication {
   
   public interface ITransactions {
      // interface members
      void showTransaction();
      double getAmount();
   }
   
   public class Transaction : ITransactions {
      private string tCode;
      private string date;
      private double amount;
      
      public Transaction() {
         tCode = " ";
         date = " ";
         amount = 0.0;
      }
      
      public Transaction(string c, string d, double a) {
         tCode = c;
         date = d;
         amount = a;
      }
      
      public double getAmount() {
         return amount;
      }
      
      public void showTransaction() {
         Console.WriteLine("Transaction: {0}", tCode);
         Console.WriteLine("Date: {0}", date);
         Console.WriteLine("Amount: {0}", getAmount());
      }
   }
   
   class Tester {
     
      static void Main(string[] args) {
         Transaction t1 = new Transaction("001", "8/10/2012", 78900.00);
         Transaction t2 = new Transaction("002", "9/10/2012", 451900.00);
         t1.showTransaction();
         t2.showTransaction();
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Transaction: 001
Date: 8/10/2012
Amount: 78900
Transaction: 002
Date: 9/10/2012
Amount: 451900

Bir namespacebir isim kümesini diğerinden ayrı tutmanın bir yolunu sağlamak için tasarlanmıştır. Bir ad alanında bildirilen sınıf adları, başka bir ad alanında bildirilen aynı sınıf adlarıyla çakışmaz.

Bir Ad Alanı Tanımlama

Bir ad alanı tanımı anahtar kelimeyle başlar namespace ardından aşağıdaki ad alanı adı gelir -

namespace namespace_name {
   // code declarations
}

İşlev veya değişkenin ad alanı etkin sürümünü çağırmak için ad alanı adını aşağıdaki gibi ekleyin -

namespace_name.item_name;

Aşağıdaki program ad alanlarının kullanımını gösterir -

using System;

namespace first_space {

   class namespace_cl {
   
      public void func() {
         Console.WriteLine("Inside first_space");
      }
   }
}

namespace second_space {

   class namespace_cl {
   
      public void func() {
         Console.WriteLine("Inside second_space");
      }
   }
}

class TestClass {

   static void Main(string[] args) {
      first_space.namespace_cl fc = new first_space.namespace_cl();
      second_space.namespace_cl sc = new second_space.namespace_cl();
      fc.func();
      sc.func();
      Console.ReadKey();
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Inside first_space
Inside second_space

kullanarak Kelimeler

usinganahtar kelime, programın verilen ad alanındaki adları kullandığını belirtir. Örneğin, kullanıyoruzSystemprogramlarımızdaki ad alanı. Konsol sınıfı burada tanımlanır. Biz sadece yazıyoruz -

Console.WriteLine ("Hello there");

Tam nitelikli ismi şöyle yazabilirdik -

System.Console.WriteLine("Hello there");

Ayrıca ad alanlarının önceden eklenmesini önleyebilirsiniz. usingad alanı yönergesi. Bu yönerge derleyiciye sonraki kodun belirtilen ad alanındaki isimleri kullandığını söyler. Ad alanı bu nedenle aşağıdaki kod için ima edilir -

Direktif kullanarak önceki örneğimizi yeniden yazalım -

using System;
using first_space;
using second_space;

namespace first_space {

   class abc {
   
      public void func() {
         Console.WriteLine("Inside first_space");
      }
   }
}

namespace second_space {

   class efg {
   
      public void func() {
         Console.WriteLine("Inside second_space");
      }
   }
}   

class TestClass {

   static void Main(string[] args) {
      abc fc = new abc();
      efg sc = new efg();
      fc.func();
      sc.func();
      Console.ReadKey();
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Inside first_space
Inside second_space

İç içe geçmiş ad alanları

Bir ad alanını başka bir ad alanı içinde aşağıdaki gibi tanımlayabilirsiniz -

namespace namespace_name1 {
   
   // code declarations
   namespace namespace_name2 {
      // code declarations
   }
}

Aşağıdaki gibi nokta (.) Operatörünü kullanarak yuvalanmış ad alanı üyelerine erişebilirsiniz -

using System;
using first_space;
using first_space.second_space;

namespace first_space {

   class abc {
   
      public void func() {
         Console.WriteLine("Inside first_space");
      }
   }
   
   namespace second_space {
   
      class efg {
      
         public void func() {
            Console.WriteLine("Inside second_space");
         }
      }
   }   
}
 
class TestClass {

   static void Main(string[] args) {
      abc fc = new abc();
      efg sc = new efg();
      fc.func();
      sc.func();
      Console.ReadKey();
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Inside first_space
Inside second_space

Önişlemci yönergeleri, derleyiciye gerçek derleme başlamadan önce bilgileri ön işleme talimatı verir.

Tüm önişlemci yönergeleri # ile başlar ve bir satırdaki önişlemci yönergesinden önce yalnızca boşluk karakterleri görünebilir. Önişlemci yönergeleri deyimler değildir, bu nedenle noktalı virgülle (;) bitmezler.

C # derleyicisinin ayrı bir ön işlemcisi yoktur; ancak direktifler varmış gibi işlenir. C # 'da önişlemci yönergeleri koşullu derlemeye yardımcı olmak için kullanılır. C ve C ++ direktiflerinin aksine, makro oluşturmak için kullanılmazlar. Bir önişlemci yönergesi bir satırdaki tek talimat olmalıdır.

C # Önişlemci Direktifleri

Aşağıdaki tablo C # 'da bulunan önişlemci direktiflerini listeler -

Sr.No.	Önişlemci Direktifi ve Tanımı
1	#define Sembol adı verilen bir karakter dizisini tanımlar.
2	#undef Bir sembolü tanımlamanıza izin verir.
3	#if Doğru olarak değerlendirilip değerlendirilmediklerini görmek için bir sembolün veya sembollerin test edilmesini sağlar.
4	#else #İf ile birlikte bileşik bir koşullu yönerge oluşturmaya izin verir.
5	#elif Bileşik bir koşullu yönerge oluşturmaya izin verir.
6	#endif Koşullu bir direktifin sonunu belirtir.
7	#line Derleyicinin satır numarasını ve (isteğe bağlı olarak) hatalar ve uyarılar için dosya adı çıktısını değiştirmenize izin verir.
8	#error Kodunuzdaki belirli bir konumdan hata oluşturmanıza olanak tanır.
9	#warning Kodunuzdaki belirli bir konumdan birinci seviye bir uyarı oluşturulmasına izin verir.
10	#region Visual Studio Kod Düzenleyicisi'nin ana hat oluşturma özelliğini kullanırken genişletebileceğiniz veya daraltabileceğiniz bir kod bloğu belirtmenize olanak tanır.
11	#endregion Bir # bölge bloğunun sonunu işaretler.

#Define Ön İşlemci

#Define önişlemci yönergesi sembolik sabitler yaratır.

#define, #if direktifine iletilen ifade olarak sembolü kullanarak, ifadenin doğru olarak değerlendirilmesini sağlayacak şekilde bir sembol tanımlamanıza izin verir. Sözdizimi aşağıdaki gibidir -

#define symbol

Aşağıdaki program bunu göstermektedir -

#define PI 
using System;

namespace PreprocessorDAppl {

   class Program {
   
      static void Main(string[] args) {
         #if (PI)
            Console.WriteLine("PI is defined");
         #else
            Console.WriteLine("PI is not defined");
         #endif
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

PI is defined

Koşullu Direktifler

Koşullu bir yönerge oluşturmak için #if yönergesini kullanabilirsiniz. Koşullu yönergeler, doğru olarak değerlendirilip değerlendirilmediklerini kontrol etmek için bir sembol veya sembolleri test etmek için kullanışlıdır. Doğru olarak değerlendirilirlerse, derleyici #if ve sonraki yönerge arasındaki tüm kodu değerlendirir.

Koşullu yönerge için sözdizimi -

#if symbol [operator symbol]...

Nerede, sembol , test etmek istediğiniz sembolün adıdır. Ayrıca true ve false kullanabilir veya olumsuzlama operatörüyle sembolün başına ekleyebilirsiniz.

Operatör sembol sembol değerlendirmek için kullanılan operatörüdür. Operatörler aşağıdakilerden biri olabilir -

• == (eşitlik)
• ! = (eşitsizlik)
• && (ve)
• || (veya)

Ayrıca sembolleri ve operatörleri parantezlerle gruplandırabilirsiniz. Koşullu yönergeler, bir hata ayıklama derlemesi için kod derlemek için veya belirli bir yapılandırma için derlerken kullanılır. Bir ile başlayan koşullu yönerge#if direktif açıkça bir ile sonlandırılmalıdır #endif direktif.

Aşağıdaki program koşullu yönergelerin kullanımını göstermektedir -

#define DEBUG
#define VC_V10
using System;

public class TestClass {

   public static void Main() {
      #if (DEBUG && !VC_V10)
         Console.WriteLine("DEBUG is defined");
      #elif (!DEBUG && VC_V10)
         Console.WriteLine("VC_V10 is defined");
      #elif (DEBUG && VC_V10)
         Console.WriteLine("DEBUG and VC_V10 are defined");
      #else
         Console.WriteLine("DEBUG and VC_V10 are not defined");
      #endif
      Console.ReadKey();
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

DEBUG and VC_V10 are defined

Bir regular expressionbir giriş metniyle eşleştirilebilecek bir kalıptır. .Net çerçevesi, bu tür eşleştirmeye izin veren normal bir ifade motoru sağlar. Bir kalıp, bir veya daha fazla karakter değişmezi, operatör veya yapıdan oluşur.

Normal İfadeleri Tanımlamaya Yönelik Yapılar

Normal ifadeleri tanımlamanıza izin veren çeşitli karakter kategorileri, operatörler ve yapılar vardır. Bu yapıları bulmak için aşağıdaki bağlantıları tıklayın.

• Karakter kaçışları

• Karakter sınıfları

• Anchors

• Yapıları gruplama

• Quantifiers

• Geri referans yapıları

• Alternatif yapılar

• Substitutions

• Çeşitli yapılar

Regex Sınıfı

Regex sınıfı, bir normal ifadeyi temsil etmek için kullanılır. Aşağıdaki yaygın olarak kullanılan yöntemlere sahiptir -

Sr.No.	Yöntemler ve Açıklama
1	public bool IsMatch(string input) Regex yapıcısında belirtilen normal ifadenin belirtilen bir giriş dizesinde bir eşleşme bulup bulmadığını gösterir.
2	public bool IsMatch(string input, int startat) Regex yapıcısında belirtilen normal ifadenin, dizedeki belirtilen başlangıç ​​konumundan başlayarak belirtilen giriş dizesinde bir eşleşme bulup bulmadığını gösterir.
3	public static bool IsMatch(string input, string pattern) Belirtilen normal ifadenin belirtilen giriş dizesinde bir eşleşme bulup bulmadığını gösterir.
4	public MatchCollection Matches(string input) Bir normal ifadenin tüm tekrarları için belirtilen girdi dizesini arar.
5	public string Replace(string input, string replacement) Belirtilen bir girdi dizesinde, normal ifade modeliyle eşleşen tüm dizeleri belirtilen değiştirme dizesiyle değiştirir.
6	public string[] Split(string input) Bir giriş dizesini, Regex yapıcısında belirtilen normal bir ifade deseni tarafından tanımlanan konumlarda bir alt dizeler dizisine böler.

Yöntemlerin ve özelliklerin tam listesi için lütfen C # üzerindeki Microsoft belgelerini okuyun.

örnek 1

Aşağıdaki örnek, 'S' ile başlayan sözcüklerle eşleşir -

using System;
using System.Text.RegularExpressions;

namespace RegExApplication {

   class Program {
   
      private static void showMatch(string text, string expr) {
         Console.WriteLine("The Expression: " + expr);
         MatchCollection mc = Regex.Matches(text, expr);
         foreach (Match m in mc) {
            Console.WriteLine(m);
         }
      }
      
      static void Main(string[] args) {
         string str = "A Thousand Splendid Suns";
         
         Console.WriteLine("Matching words that start with 'S': ");
         showMatch(str, @"\bS\S*");
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Matching words that start with 'S':
The Expression: \bS\S*
Splendid
Suns

Örnek 2

Aşağıdaki örnek, 'm' ile başlayan ve 'e' ile biten sözcüklerle eşleşir -

using System;
using System.Text.RegularExpressions;

namespace RegExApplication {

   class Program {
      private static void showMatch(string text, string expr) {
         Console.WriteLine("The Expression: " + expr);
         MatchCollection mc = Regex.Matches(text, expr);
         foreach (Match m in mc) {
            Console.WriteLine(m);
         }
      }
      static void Main(string[] args) {
         string str = "make maze and manage to measure it";

         Console.WriteLine("Matching words start with 'm' and ends with 'e':");
         showMatch(str, @"\bm\S*e\b");
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Matching words start with 'm' and ends with 'e':
The Expression: \bm\S*e\b
make
maze
manage
measure

Örnek 3

Bu örnek, fazladan beyaz boşluğun yerine geçer -

using System;
using System.Text.RegularExpressions;

namespace RegExApplication {

   class Program {
   
      static void Main(string[] args) {
         string input = "Hello   World   ";
         string pattern = "\\s+";
         string replacement = " ";
         Regex rgx = new Regex(pattern);
         string result = rgx.Replace(input, replacement);

         Console.WriteLine("Original String: {0}", input);
         Console.WriteLine("Replacement String: {0}", result);    
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Original String: Hello World   
Replacement String: Hello World

İstisna, bir programın yürütülmesi sırasında ortaya çıkan bir sorundur. AC # istisnası, sıfıra bölme girişimi gibi bir program çalışırken ortaya çıkan istisnai bir duruma verilen yanıttır.

İstisnalar, kontrolü bir programın bir bölümünden diğerine aktarmanın bir yolunu sağlar. C # istisna işleme, dört anahtar sözcük üzerine kurulmuştur:try, catch, finally, ve throw.

• try- Bir try bloğu, belirli istisnaların etkinleştirildiği bir kod bloğunu tanımlar. Bunu bir veya daha fazla yakalama bloğu izler.

• catch- Bir program, bir programda sorunu çözmek istediğiniz yerde bir istisna işleyicisi ile bir istisna yakalar. Catch anahtar sözcüğü, bir istisnanın yakalandığını gösterir.

• finally- Nihayet bloğu, bir istisna atılsa da atılmasa da, belirli bir ifade kümesini yürütmek için kullanılır. Örneğin, bir dosyayı açarsanız, bir istisna ortaya çıksa da çıkmasa da kapatılmalıdır.

• throw- Bir program bir sorun ortaya çıktığında bir istisna atar. Bu, bir throw anahtar sözcüğü kullanılarak yapılır.

Sözdizimi

Bir bloğun bir istisna oluşturduğunu varsayarsak, bir yöntem, dene ve yakala anahtar sözcüklerinin bir kombinasyonunu kullanarak bir istisnayı yakalar. Bir istisna oluşturabilecek kodun etrafına bir dene / yakala bloğu yerleştirilir. Bir dene / yakala bloğundaki kod korumalı kod olarak adlandırılır ve dene / yakala kullanımının sözdizimi aşağıdaki gibi görünür -

try {
   // statements causing exception
} catch( ExceptionName e1 ) {
   // error handling code
} catch( ExceptionName e2 ) {
   // error handling code
} catch( ExceptionName eN ) {
   // error handling code
} finally {
   // statements to be executed
}

Try bloğunuzun farklı durumlarda birden fazla istisnayı artırması durumunda, farklı istisna türlerini yakalamak için birden fazla catch ifadesini listeleyebilirsiniz.

C # 'ta Özel Durum Sınıfları

C # istisnaları, sınıflarla temsil edilir. C # 'daki istisna sınıfları esas olarak doğrudan veya dolaylı olarakSystem.Exceptionsınıf. System.Exception sınıfından türetilen istisna sınıflarından bazıları,System.ApplicationException ve System.SystemException sınıflar.

System.ApplicationExceptionsınıf, uygulama programları tarafından oluşturulan istisnaları destekler. Bu nedenle, programcılar tarafından tanımlanan istisnalar bu sınıftan türetilmelidir.

System.SystemException sınıfı, önceden tanımlanmış tüm sistem istisnaları için temel sınıftır.

Aşağıdaki tablo, Sytem.SystemException sınıfından türetilen önceden tanımlanmış bazı istisna sınıflarını sağlar -

Sr.No.	İstisna Sınıfı ve Açıklama
1	System.IO.IOException G / Ç hatalarını işler.
2	System.IndexOutOfRangeException Bir yöntem, aralık dışındaki bir dizi dizinine başvurduğunda üretilen hataları işler.
3	System.ArrayTypeMismatchException Tür, dizi türüyle uyuşmadığında üretilen hataları işler.
4	System.NullReferenceException Boş bir nesneye referans verilmesinden kaynaklanan hataları işler.
5	System.DivideByZeroException Temettüyü sıfıra bölmekten kaynaklanan hataları işler.
6	System.InvalidCastException Yazım sırasında oluşan hataları işler.
7	System.OutOfMemoryException Yetersiz boş bellekten üretilen hataları işler.
8	System.StackOverflowException Yığın taşmasından kaynaklanan hataları işler.

İstisnaları İşleme

C #, dene ve yakala blokları biçiminde istisna işlemeye yapılandırılmış bir çözüm sağlar. Bu blokları kullanarak, temel program ifadeleri hata işleme ifadelerinden ayrılır.

Bu hata işleme blokları, try, catch, ve finallyanahtar kelimeler. Aşağıda, sıfır koşuluna bölündüğünde bir istisna atma örneği verilmiştir -

using System;

namespace ErrorHandlingApplication {

   class DivNumbers {
      int result;
      
      DivNumbers() {
         result = 0;
      }
      
      public void division(int num1, int num2) {
         try {
            result = num1 / num2;
         } catch (DivideByZeroException e) {
            Console.WriteLine("Exception caught: {0}", e);
         } finally {
            Console.WriteLine("Result: {0}", result);
         }
      }
      
      static void Main(string[] args) {
         DivNumbers d = new DivNumbers();
         d.division(25, 0);
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Exception caught: System.DivideByZeroException: Attempted to divide by zero. 
at ...
Result: 0

Kullanıcı Tanımlı İstisnalar Oluşturma

Ayrıca kendi istisnanızı da tanımlayabilirsiniz. Kullanıcı tanımlı istisna sınıfları,Exceptionsınıf. Aşağıdaki örnek bunu göstermektedir -

using System;

namespace UserDefinedException {

   class TestTemperature {
   
      static void Main(string[] args) {
         Temperature temp = new Temperature();
         try {
            temp.showTemp();
         } catch(TempIsZeroException e) {
            Console.WriteLine("TempIsZeroException: {0}", e.Message);
         }
         Console.ReadKey();
      }
   }
}

public class TempIsZeroException: Exception {

   public TempIsZeroException(string message): base(message) {
   
   }
}

public class Temperature {
   int temperature = 0;
   
   public void showTemp() {
      
      if(temperature == 0) {
         throw (new TempIsZeroException("Zero Temperature found"));
      } else {
         Console.WriteLine("Temperature: {0}", temperature);
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

TempIsZeroException: Zero Temperature found

Nesneleri Fırlatmak

Doğrudan ya da dolaylı olarak şu nesneden türetilmişse bir nesneyi atabilirsiniz. System.Exceptionsınıf. Mevcut nesneyi şu şekilde atmak için catch bloğunda bir throw ifadesi kullanabilirsiniz -

Catch(Exception e) {
   ...
   Throw e
}

Bir filebelirli bir ad ve bir dizin yolu ile bir diskte depolanan verilerin bir koleksiyonudur. Bir dosya okumak veya yazmak için açıldığında, dosyastream.

Akış, temelde iletişim yolundan geçen bayt dizisidir. İki ana akış vardır:input stream ve output stream. input stream dosyadan veri okumak için kullanılır (okuma işlemi) ve output stream dosyaya yazmak için kullanılır (yazma işlemi).

C # I / O Sınıfları

System.IO ad alanı, dosya oluşturma ve silme, bir dosyadan okuma veya dosyaya yazma, bir dosyayı kapatma vb. Gibi dosyalarla sayısız işlemi gerçekleştirmek için kullanılan çeşitli sınıflara sahiptir.

Aşağıdaki tablo, System.IO ad alanında yaygın olarak kullanılan bazı soyut olmayan sınıfları gösterir -

Sr.No.	G / Ç Sınıfı ve Tanımı
1	BinaryReader İkili bir akıştan ilkel verileri okur.
2	BinaryWriter İlkel verileri ikili biçimde yazar.
3	BufferedStream Bayt akışı için geçici bir depolama.
4	Directory Bir dizin yapısının değiştirilmesine yardımcı olur.
5	DirectoryInfo Dizinler üzerinde işlem yapmak için kullanılır.
6	DriveInfo Sürücüler için bilgi sağlar.
7	File Dosyaları değiştirmeye yardımcı olur.
8	FileInfo Dosyalarda işlem yapmak için kullanılır.
9	FileStream Bir dosyadaki herhangi bir yerden okumak ve yazmak için kullanılır.
10	MemoryStream Bellekte depolanan akışlı verilere rastgele erişim için kullanılır.
11	Path Yol bilgileri üzerinde işlemler gerçekleştirir.
12	StreamReader Bir bayt akışından karakterleri okumak için kullanılır.
13	StreamWriter Bir akıma karakter yazmak için kullanılır.
14	StringReader Bir string tampondan okumak için kullanılır.
15	StringWriter Bir dizge tamponuna yazmak için kullanılır.

FileStream Sınıfı

FileStreamSystem.IO ad alanındaki sınıf, dosyalardan okuma, dosyaya yazma ve kapatma işlemlerinde yardımcı olur. Bu sınıf, Stream soyut sınıfından türetilir.

Bir yaratmanız gerekiyor FileStreamyeni bir dosya oluşturmak veya mevcut bir dosyayı açmak için nesne. Bir oluşturmak için sözdizimiFileStream nesne aşağıdaki gibidir -

FileStream <object_name> = new FileStream( <file_name>, <FileMode Enumerator>,
   <FileAccess Enumerator>, <FileShare Enumerator>);

Örneğin, bir FileStream nesnesi oluşturuyoruz F adlı bir dosyayı okumak için sample.txt as shown -

FileStream F = new FileStream("sample.txt", FileMode.Open, FileAccess.Read,
   FileShare.Read);

Sr.No.	Parametre ve Açıklama
1	FileMode FileModenumaralandırıcı, dosyaları açmak için çeşitli yöntemler tanımlar. FileMode numaralandırıcısının üyeleri şunlardır: Append - Mevcut bir dosyayı açar ve imleci dosyanın sonuna koyar veya dosya yoksa dosyayı oluşturur. Create - Yeni bir dosya oluşturur. CreateNew - İşletim sistemine yeni bir dosya oluşturması gerektiğini belirtir. Open - Mevcut bir dosyayı açar. OpenOrCreate - İşletim sistemine, varsa bir dosya açması gerektiğini, aksi takdirde yeni bir dosya oluşturması gerektiğini belirtir. Truncate - Var olan bir dosyayı açar ve boyutunu sıfır bayta indirir.
2	FileAccess FileAccess numaralandırıcıların üyeleri var: Read, ReadWrite ve Write.
3	FileShare FileShare sayım görevlilerinin aşağıdaki üyeleri var - Inheritable - Bir dosya tutamacının kalıtımı alt süreçlere geçirmesine izin verir None - Mevcut dosyanın paylaşımını reddeder Read - Dosyanın okunması için açılmasına izin verir. ReadWrite - Dosyanın okunması ve yazılması için açılmasını sağlar Write - Dosyanın yazılmak üzere açılmasını sağlar

Misal

Aşağıdaki program, FileStream sınıf -

using System;
using System.IO;

namespace FileIOApplication {
   
   class Program {
      
      static void Main(string[] args) {
         FileStream F = new FileStream("test.dat", FileMode.OpenOrCreate, 
            FileAccess.ReadWrite);
         
         for (int i = 1; i <= 20; i++) {
            F.WriteByte((byte)i);
         }
         
         F.Position = 0;
         for (int i = 0; i <= 20; i++) {
            Console.Write(F.ReadByte() + " ");
         }
         F.Close();
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 -1

C # 'da Gelişmiş Dosya İşlemleri

Yukarıdaki örnek, C # 'da basit dosya işlemleri sağlar. Ancak, C # System.IO sınıflarının muazzam güçlerinden yararlanmak için, bu sınıfların yaygın olarak kullanılan özelliklerini ve yöntemlerini bilmeniz gerekir.

Sr.No.	Konu Açıklama
1	Metin dosyalarından Okuma ve Yazma Metin dosyalarından okumayı ve metin dosyalarına yazmayı içerir. StreamReader ve StreamWriter sınıf bunu başarmaya yardımcı olur.
2	İkili dosyalardan Okuma ve Yazma İkili dosyalardan okumayı ve bunlara yazmayı içerir. BinaryReader ve BinaryWriter sınıf bunu başarmaya yardımcı olur.
3	Windows dosya sistemini düzenleme Bir C # programcısına Windows dosya ve dizinlerine göz atma ve bulma yeteneği verir.

Bir attributeprogramınızdaki sınıflar, yöntemler, yapılar, numaralandırıcılar, derlemeler vb. gibi çeşitli öğelerin davranışları hakkındaki bilgileri çalışma zamanına iletmek için kullanılan bildirimsel bir etikettir. Bir öznitelik kullanarak bir programa bildirime dayalı bilgi ekleyebilirsiniz. Bildirimsel bir etiket, kullanıldığı öğenin üzerine yerleştirilmiş köşeli ([]) parantezlerle gösterilir.

Öznitelikler, derleyici talimatı gibi meta veriler ve bir programa yorumlar, açıklama, yöntemler ve sınıflar gibi diğer bilgileri eklemek için kullanılır. .Net Framework iki tür öznitelik sağlar: önceden tanımlanmış öznitelikler ve özel oluşturulmuş öznitelikler.

Bir Öznitelik Belirtme

Bir özniteliği belirtmek için sözdizimi aşağıdaki gibidir -

[attribute(positional_parameters, name_parameter = value, ...)]
element

Özelliğin adı ve değerleri, özniteliğin uygulandığı öğeden önce köşeli parantez içinde belirtilir. Konum parametreleri temel bilgileri belirtir ve ad parametreleri isteğe bağlı bilgileri belirtir.

Önceden Tanımlanmış Özellikler

.Net Framework üç önceden tanımlanmış öznitelik sağlar -

• AttributeUsage
• Conditional
• Obsolete

Öznitelik Kullanım

Önceden tanımlanmış öznitelik AttributeUsageözel bir özellik sınıfının nasıl kullanılabileceğini açıklar. Özelliğin uygulanabileceği öğe türlerini belirtir.

Bu özniteliği belirtmek için sözdizimi aşağıdaki gibidir -

[AttributeUsage (
   validon,
   AllowMultiple = allowmultiple,
   Inherited = inherited
)]

Nerede,

• Validon parametresi, özniteliğin yerleştirilebileceği dil öğelerini belirtir. Bir numaralandırıcı AttributeTargets değerinin birleşimidir . Varsayılan değer, AttributeTargets.All şeklindedir .

• Allowmultiple (isteğe bağlı) parametresi , bu özniteliğin AllowMultiple özelliği için bir Boolean değeri sağlar. Bu doğruysa, özellik çok amaçlıdır. Varsayılan yanlıştır (tek kullanımlık).

• Miras alınan parametre (isteğe bağlı), bu özniteliğin Devralınan özelliği için bir Boolean değeri sağlar. Doğruysa, öznitelik türetilmiş sınıflar tarafından miras alınır. Varsayılan değer yanlıştır (miras alınmaz).

Örneğin,

[AttributeUsage(AttributeTargets.Class |
AttributeTargets.Constructor |
AttributeTargets.Field |
AttributeTargets.Method |
AttributeTargets.Property, 
AllowMultiple = true)]

Koşullu

Bu önceden tanımlanmış öznitelik, yürütülmesi belirli bir ön işleme tanımlayıcısına bağlı olan bir koşullu yöntemi işaretler.

Belirtilen değere bağlı olarak yöntem çağrılarının koşullu derlemesine neden olur. Debug veya Trace. Örneğin, bir kodda hata ayıklarken değişkenlerin değerlerini görüntüler.

Bu özniteliği belirtmek için sözdizimi aşağıdaki gibidir -

[Conditional(
   conditionalSymbol
)]

Örneğin,

[Conditional("DEBUG")]

Aşağıdaki örnek, özniteliği gösterir -

#define DEBUG
using System;
using System.Diagnostics;

public class Myclass {
   [Conditional("DEBUG")]
   
   public static void Message(string msg) {
      Console.WriteLine(msg);
   }
}

class Test {
   static void function1() {
      Myclass.Message("In Function 1.");
      function2();
   }
   
   static void function2() {
      Myclass.Message("In Function 2.");
   }
   
   public static void Main() {
      Myclass.Message("In Main function.");
      function1();
      Console.ReadKey();
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

In Main function
In Function 1
In Function 2

Eski

Bu önceden tanımlanmış öznitelik, kullanılmaması gereken bir program varlığını işaretler. Derleyiciye belirli bir hedef öğeyi atmasını bildirmenizi sağlar. Örneğin, bir sınıfta yeni bir yöntem kullanıldığında ve hala eski yöntemi sınıfta tutmak istiyorsanız, eski yöntem yerine yeni yöntemin kullanılması gereken bir mesaj görüntüleyerek onu eski olarak işaretleyebilirsiniz.

Bu özniteliği belirtmek için sözdizimi aşağıdaki gibidir -

[Obsolete (
   message
)]

[Obsolete (
   message,
   iserror
)]

Nerede,

• Parametre mesajı , öğenin neden eski olduğunu ve bunun yerine ne kullanılacağını açıklayan bir dizedir.

• İserror parametresi bir Boole değeridir. Değeri doğruysa, derleyici öğenin kullanımını bir hata olarak değerlendirmelidir. Varsayılan değer yanlıştır (derleyici bir uyarı oluşturur).

Aşağıdaki program bunu göstermektedir -

using System;

public class MyClass {
   [Obsolete("Don't use OldMethod, use NewMethod instead", true)]
   
   static void OldMethod() {
      Console.WriteLine("It is the old method");
   }
   
   static void NewMethod() {
      Console.WriteLine("It is the new method"); 
   }
   
   public static void Main() {
      OldMethod();
   }
}

Programı derlemeye çalıştığınızda, derleyici şunu belirten bir hata mesajı verir -

Don't use OldMethod, use NewMethod instead

Özel Nitelikler Oluşturma

.Net Framework, bildirime dayalı bilgileri depolamak için kullanılabilen ve çalışma zamanında alınabilen özel özniteliklerin oluşturulmasına izin verir. Bu bilgiler, tasarım kriterlerine ve uygulama ihtiyacına bağlı olarak herhangi bir hedef unsurla ilgili olabilir.

Özel özniteliklerin oluşturulması ve kullanılması dört adımdan oluşur -

• Özel bir öznitelik bildirmek
• Özel özniteliğin oluşturulması
• Özel özniteliği bir hedef program öğesine uygulayın
• Yansıtma Yoluyla Niteliklere Erişim

Son adım, çeşitli gösterimleri bulmak için meta verileri okumak için basit bir program yazmayı içerir. Meta veriler, diğer verileri açıklamak için kullanılan veriler veya bilgilerle ilgili verilerdir. Bu program, çalışma zamanında özniteliklere erişmek için yansımalar kullanmalıdır. Bunu bir sonraki bölümde tartışacağız.

Özel Bir Öznitelik Bildirme

Yeni bir özel öznitelik türetilmelidir System.Attributesınıf. Örneğin,

//a custom attribute BugFix to be assigned to a class and its members
[AttributeUsage(AttributeTargets.Class |
AttributeTargets.Constructor |
AttributeTargets.Field |
AttributeTargets.Method |
AttributeTargets.Property,
AllowMultiple = true)]

public class DeBugInfo : System.Attribute

Yukarıdaki kodda, DeBugInfo adlı özel bir öznitelik bildirdik .

Özel Nitelik Oluşturma

Herhangi bir programın hata ayıklamasıyla elde edilen bilgileri depolayan DeBugInfo adlı özel bir öznitelik oluşturalım. Aşağıdaki bilgileri saklasın -

• Hatanın kod numarası
• Hatayı tanımlayan geliştiricinin adı
• Kodun son inceleme tarihi
• Geliştiricinin açıklamalarını saklamak için bir dizi mesaj

Debuginfo sınıf ilk üç bilgi ve mesajı saklamak için bir ortak özelliği depolamak için üç özel özellikleri vardır. Dolayısıyla, hata numarası, geliştiricinin adı ve inceleme tarihi, DeBugInfo sınıfının konumsal parametreleridir ve mesaj isteğe bağlı veya adlandırılmış bir parametredir.

Her öznitelik en az bir kurucuya sahip olmalıdır. Konumsal parametreler yapıcıdan geçirilmelidir. Aşağıdaki kod, DeBugInfo sınıfını gösterir -

//a custom attribute BugFix to be assigned to a class and its members
[AttributeUsage(AttributeTargets.Class |
AttributeTargets.Constructor |
AttributeTargets.Field |
AttributeTargets.Method |
AttributeTargets.Property,
AllowMultiple = true)]

public class DeBugInfo : System.Attribute {
   private int bugNo;
   private string developer;
   private string lastReview;
   public string message;
   
   public DeBugInfo(int bg, string dev, string d) {
      this.bugNo = bg;
      this.developer = dev;
      this.lastReview = d;
   }

   public int BugNo {
      get {
         return bugNo;
      }
   }
   
   public string Developer {
      get {
         return developer;
      }
   }
   
   public string LastReview {
      get {
         return lastReview;
      }
   }
   
   public string Message {
      get {
         return message;
      }
      set {
         message = value;
      }
   }
}

Özel Özniteliği Uygulama

Özellik, hedefinin hemen önüne yerleştirilerek uygulanır -

[DeBugInfo(45, "Zara Ali", "12/8/2012", Message = "Return type mismatch")]
[DeBugInfo(49, "Nuha Ali", "10/10/2012", Message = "Unused variable")]
class Rectangle {
   //member variables
   protected double length;
   protected double width;
   public Rectangle(double l, double w) {
      length = l;
      width = w;
   }
   [DeBugInfo(55, "Zara Ali", "19/10/2012", Message = "Return type mismatch")]
   
   public double GetArea() {
      return length * width;
   }
   [DeBugInfo(56, "Zara Ali", "19/10/2012")]
   
   public void Display() {
      Console.WriteLine("Length: {0}", length);
      Console.WriteLine("Width: {0}", width);
      Console.WriteLine("Area: {0}", GetArea());
   }
}

Sonraki bölümde, bir Reflection sınıfı nesnesi kullanarak öznitelik bilgilerini alacağız.

Reflectionnesneler, çalışma zamanında tür bilgileri elde etmek için kullanılır. Çalışan bir programın meta verilerine erişim sağlayan sınıflar,System.Reflection ad alanı.

System.Reflection ad alanı, uygulama hakkında bilgi edinmenize ve uygulamaya türler, değerler ve nesneler dinamik olarak eklemenize olanak tanıyan sınıfları içerir.

Yansıma Uygulamaları

Yansıma aşağıdaki uygulamalara sahiptir -

• Çalışma zamanında öznitelik bilgilerini görüntülemeye izin verir.

• Bir montajdaki çeşitli türlerin incelenmesine ve bu türlerin somutlaştırılmasına olanak tanır.

• Yöntemlere ve özelliklere geç bağlanmaya izin verir

• Çalışma zamanında yeni türler oluşturmaya izin verir ve ardından bu türleri kullanarak bazı görevleri gerçekleştirir.

Meta Verileri Görüntüleme

Önceki bölümde yansıma kullanarak öznitelik bilgilerini görüntüleyebileceğinizden bahsetmiştik.

MemberInfo nesnesi System.Reflectionbir sınıfla ilişkili öznitelikleri keşfetmek için sınıfın başlatılması gerekir. Bunu yapmak için, hedef sınıfın bir nesnesini şu şekilde tanımlarsınız:

System.Reflection.MemberInfo info = typeof(MyClass);

Aşağıdaki program bunu göstermektedir -

using System;

[AttributeUsage(AttributeTargets.All)]
public class HelpAttribute : System.Attribute {
   public readonly string Url;
   
   public string Topic   // Topic is a named parameter {
      get {
         return topic;
      }
      
      set {
         topic = value;
      }
   }
   
   public HelpAttribute(string url)   // url is a positional parameter {
      this.Url = url;
   }
   private string topic;
}

[HelpAttribute("Information on the class MyClass")]
class MyClass {

}

namespace AttributeAppl {

   class Program {
   
      static void Main(string[] args) {
         System.Reflection.MemberInfo info = typeof(MyClass);
         object[] attributes = info.GetCustomAttributes(true);
         for (int i = 0; i < attributes.Length; i++) {
            System.Console.WriteLine(attributes[i]);
         }
         Console.ReadKey();
      }
   }
}

Derlendiğinde ve çalıştırıldığında, Sınıfım sınıfına eklenen özel özniteliklerin adını görüntüler -

HelpAttribute

Misal

Bu örnekte, önceki bölümde oluşturulan DeBugInfo niteliğini ve Rectangle sınıfındaki meta verileri okumak için yansımayı kullanıyoruz .

using System;
using System.Reflection;

namespace BugFixApplication {
   //a custom attribute BugFix to be
   //assigned to a class and its members
   [AttributeUsage(AttributeTargets.Class |
   AttributeTargets.Constructor |
   AttributeTargets.Field |
   AttributeTargets.Method |
   AttributeTargets.Property,
   AllowMultiple = true)]

   public class DeBugInfo : System.Attribute {
      private int bugNo;
      private string developer;
      private string lastReview;
      public string message;
      
      public DeBugInfo(int bg, string dev, string d) {
         this.bugNo = bg;
         this.developer = dev;
         this.lastReview = d;
      }
      
      public int BugNo {
         get {
            return bugNo;
         }
      }
      
      public string Developer {
         get {
            return developer;
         }
      }
      
      public string LastReview {
         get {
            return lastReview;
         }
      }
      
      public string Message {
         get {
            return message;
         }
         set {
            message = value;
         }
      }
   }
   [DeBugInfo(45, "Zara Ali", "12/8/2012", Message = "Return type mismatch")]
   [DeBugInfo(49, "Nuha Ali", "10/10/2012", Message = "Unused variable")]
   
   class Rectangle {
      //member variables
      protected double length;
      protected double width;
      public Rectangle(double l, double w) {
         length = l;
         width = w;
      }
      
      [DeBugInfo(55, "Zara Ali", "19/10/2012", Message = "Return type mismatch")]
      public double GetArea() {
         return length * width;
      }
      
      [DeBugInfo(56, "Zara Ali", "19/10/2012")]
      public void Display() {
         Console.WriteLine("Length: {0}", length);
         Console.WriteLine("Width: {0}", width);
         Console.WriteLine("Area: {0}", GetArea());
      }
   }//end class Rectangle
   
   class ExecuteRectangle {
      static void Main(string[] args) {
         Rectangle r = new Rectangle(4.5, 7.5);
         r.Display();
         Type type = typeof(Rectangle);
         
         //iterating through the attribtues of the Rectangle class
         foreach (Object attributes in type.GetCustomAttributes(false)) {
            DeBugInfo dbi = (DeBugInfo)attributes;
            
            if (null != dbi) {
               Console.WriteLine("Bug no: {0}", dbi.BugNo);
               Console.WriteLine("Developer: {0}", dbi.Developer);
               Console.WriteLine("Last Reviewed: {0}", dbi.LastReview);
               Console.WriteLine("Remarks: {0}", dbi.Message);
            }
         }

         //iterating through the method attribtues
         foreach (MethodInfo m in type.GetMethods()) {
            
            foreach (Attribute a in m.GetCustomAttributes(true)) {
               DeBugInfo dbi = (DeBugInfo)a;
               
               if (null != dbi) {
                  Console.WriteLine("Bug no: {0}, for Method: {1}", dbi.BugNo, m.Name);
                  Console.WriteLine("Developer: {0}", dbi.Developer);
                  Console.WriteLine("Last Reviewed: {0}", dbi.LastReview);
                  Console.WriteLine("Remarks: {0}", dbi.Message);
               }
            }
         }
         Console.ReadLine();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Length: 4.5
Width: 7.5
Area: 33.75
Bug No: 49
Developer: Nuha Ali
Last Reviewed: 10/10/2012
Remarks: Unused variable
Bug No: 45
Developer: Zara Ali
Last Reviewed: 12/8/2012
Remarks: Return type mismatch
Bug No: 55, for Method: GetArea
Developer: Zara Ali
Last Reviewed: 19/10/2012
Remarks: Return type mismatch
Bug No: 56, for Method: Display
Developer: Zara Ali
Last Reviewed: 19/10/2012
Remarks:

Propertiessınıfların, yapıların ve arabirimlerin üyeleridir. Bir sınıf veya yapılardaki üye değişkenler veya yöntemler denirFields. Özellikler, alanların bir uzantısıdır ve aynı sözdizimi kullanılarak erişilir. Onlar kullanırlaraccessors özel alanların değerlerinin okunabileceği, yazılabileceği veya değiştirilebileceği.

Özellikler, depolama konumlarını adlandırmaz. Bunun yerine,accessors değerlerini okuyan, yazan veya hesaplayan.

Örneğin, yaş, ad ve kod için özel alanları olan Öğrenci adında bir sınıfımız olsun. Bu alanlara sınıf kapsamı dışından doğrudan erişemeyiz, ancak bu özel alanlara erişmek için özelliklere sahip olabiliriz.

Erişimciler

accessorBir özelliğin, özelliğin alınmasına (okunmasına veya hesaplanmasına) veya ayarlanmasına (yazılmasına) yardımcı olan çalıştırılabilir ifadeler içerir. Erişimci bildirimleri bir alma erişimcisi, bir ayar erişimcisi veya her ikisini birden içerebilir. Örneğin -

// Declare a Code property of type string:
public string Code {
   get {
      return code;
   }
   set {
      code = value;
   }
}

// Declare a Name property of type string:
public string Name {
   get {
      return name;
   }
   set {
      name = value;
   }
}

// Declare a Age property of type int:
public int Age { 
   get {
      return age;
   }
   set {
      age = value;
   }
}

Misal

Aşağıdaki örnek, özelliklerin kullanımını gösterir -

using System;
namespace tutorialspoint {
   class Student {
      private string code = "N.A";
      private string name = "not known";
      private int age = 0;
      
      // Declare a Code property of type string:
      public string Code {
         get {
            return code;
         }
         set {
            code = value;
         }
      }
      
      // Declare a Name property of type string:
      public string Name {
         get {
            return name;
         }
         set {
            name = value;
         }
      }
      
      // Declare a Age property of type int:
      public int Age {
         get {
            return age;
         }
         set {
            age = value;
         }
      }
      public override string ToString() {
         return "Code = " + Code +", Name = " + Name + ", Age = " + Age;
      }
   }
   
   class ExampleDemo {
      public static void Main() {
      
         // Create a new Student object:
         Student s = new Student();
         
         // Setting code, name and the age of the student
         s.Code = "001";
         s.Name = "Zara";
         s.Age = 9;
         Console.WriteLine("Student Info: {0}", s);
         
         //let us increase age
         s.Age += 1;
         Console.WriteLine("Student Info: {0}", s);
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Student Info: Code = 001, Name = Zara, Age = 9
Student Info: Code = 001, Name = Zara, Age = 10

Soyut Özellikler

Soyut bir sınıf, türetilmiş sınıfta uygulanması gereken soyut bir özelliğe sahip olabilir. Aşağıdaki program bunu göstermektedir -

using System;
namespace tutorialspoint {
   public abstract class Person {
      public abstract string Name {
         get;
         set;
      }
      public abstract int Age {
         get;
         set;
      }
   }
   
   class Student : Person {
   
      private string code = "N.A";
      private string name = "N.A";
      private int age = 0;
      
      // Declare a Code property of type string:
      public string Code {
         get {
            return code;
         }
         set {
            code = value;
         }
      }
      
      // Declare a Name property of type string:
      public override string Name {
         get {
            return name;
         }
         set {
            name = value;
         }
      }
      
      // Declare a Age property of type int:
      public override int Age {
         get {
            return age;
         }
         set {
            age = value;
         }
      }
      public override string ToString() {
         return "Code = " + Code +", Name = " + Name + ", Age = " + Age;
      }
   }
   
   class ExampleDemo {
      public static void Main() {
         // Create a new Student object:
         Student s = new Student();
         
         // Setting code, name and the age of the student
         s.Code = "001";
         s.Name = "Zara";
         s.Age = 9;
         Console.WriteLine("Student Info:- {0}", s);
         
         //let us increase age
         s.Age += 1;
         Console.WriteLine("Student Info:- {0}", s);
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Student Info: Code = 001, Name = Zara, Age = 9
Student Info: Code = 001, Name = Zara, Age = 10

Bir indexerdizi gibi bir nesnenin indekslenmesine izin verir. Bir sınıf için bir dizin oluşturucu tanımladığınızda, bu sınıf birvirtual array. Daha sonra dizi erişim operatörünü ([]) kullanarak bu sınıfın örneğine erişebilirsiniz.

Sözdizimi

Tek boyutlu bir indeksleyici aşağıdaki sözdizimine sahiptir -

element-type this[int index] {

   // The get accessor.
   get {
      // return the value specified by index
   }
   
   // The set accessor.
   set {
      // set the value specified by index
   }
}

Dizinleyicilerin Kullanımı

Bir indeksleyicinin davranış beyanı bir dereceye kadar bir özelliğe benzer. mülklere benzer, kullandığınız get ve setbir dizin oluşturucu tanımlamak için erişimciler. Bununla birlikte, özellikler belirli bir veri üyesini döndürür veya ayarlarken, dizinleyiciler nesne örneğinden belirli bir değeri döndürür veya ayarlar. Başka bir deyişle, örnek verilerini daha küçük parçalara böler ve her parçayı indeksler, her parçayı alır veya ayarlar.

Bir özelliği tanımlamak, bir özellik adı sağlamayı içerir. Dizinleyiciler adlarla değil,thisnesne örneğini ifade eden anahtar sözcük. Aşağıdaki örnek kavramı göstermektedir -

using System;

namespace IndexerApplication {
   
   class IndexedNames {
      private string[] namelist = new string[size];
      static public int size = 10;
      
      public IndexedNames() {
         for (int i = 0; i < size; i++)
         namelist[i] = "N. A.";
      }
      
      public string this[int index] {
      
         get {
            string tmp;
         
            if( index >= 0 && index <= size-1 ) {
               tmp = namelist[index];
            } else {
               tmp = "";
            }
            
            return ( tmp );
         }
         set {
            if( index >= 0 && index <= size-1 ) {
               namelist[index] = value;
            }
         }
      }
      
      static void Main(string[] args) {
         IndexedNames names = new IndexedNames();
         names[0] = "Zara";
         names[1] = "Riz";
         names[2] = "Nuha";
         names[3] = "Asif";
         names[4] = "Davinder";
         names[5] = "Sunil";
         names[6] = "Rubic";
         
         for ( int i = 0; i < IndexedNames.size; i++ ) {
            Console.WriteLine(names[i]);
         }
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Zara
Riz
Nuha
Asif
Davinder
Sunil
Rubic
N. A.
N. A.
N. A.

Aşırı Yüklenmiş Dizinleyiciler

Dizinleyiciler aşırı yüklenebilir. Dizinleyiciler ayrıca birden çok parametre ile bildirilebilir ve her bir parametre farklı bir tür olabilir. Dizinlerin tam sayı olması gerekli değildir. C #, dizinlerin başka türlerde olmasına izin verir, örneğin bir dizge.

Aşağıdaki örnek, aşırı yüklenmiş dizinleyicileri gösterir -

using System;

namespace IndexerApplication {

   class IndexedNames {
      private string[] namelist = new string[size];
      static public int size = 10;
      
      public IndexedNames() {
         for (int i = 0; i < size; i++) {
            namelist[i] = "N. A.";
         }
      }
      
      public string this[int index] {
         
         get {
            string tmp;
            
            if( index >= 0 && index <= size-1 ) {
               tmp = namelist[index];
            } else {
               tmp = "";
            }
            
            return ( tmp );
         }
         set {
            if( index >= 0 && index <= size-1 ) {
               namelist[index] = value;
            }
         }
      }
      
      public int this[string name] {
         
         get {
            int index = 0;
            
            while(index < size) {
               if (namelist[index] == name) {
                return index;
               }
               index++;
            }
            return index;
         }

      }

      static void Main(string[] args) {
         IndexedNames names = new IndexedNames();
         names[0] = "Zara";
         names[1] = "Riz";
         names[2] = "Nuha";
         names[3] = "Asif";
         names[4] = "Davinder";
         names[5] = "Sunil";
         names[6] = "Rubic";
         
         //using the first indexer with int parameter
         for (int i = 0; i < IndexedNames.size; i++) {
            Console.WriteLine(names[i]);
         }
         
         //using the second indexer with the string parameter
         Console.WriteLine(names["Nuha"]);
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Zara
Riz
Nuha
Asif
Davinder
Sunil
Rubic
N. A.
N. A.
N. A.
2

C # delegeleri, C veya C ++ 'da işlevlere işaretçilerle benzerdir. Birdelegatebir yönteme başvuruyu tutan başvuru türü değişkendir. Referans, çalışma zamanında değiştirilebilir.

Temsilciler özellikle olayları ve geri arama yöntemlerini uygulamak için kullanılır. Tüm delegeler örtük olarakSystem.Delegate sınıf.

Temsilci Bildirme

Temsilci bildirimi, temsilci tarafından başvurulabilecek yöntemleri belirler. Temsilci, temsilcinin imzasıyla aynı imzaya sahip bir yönteme başvurabilir.

Örneğin, bir temsilci düşünün -

public delegate int MyDelegate (string s);

Önceki temsilci, tek bir dize parametresi olan ve int türü bir değişken döndüren herhangi bir yönteme başvurmak için kullanılabilir .

Temsilci bildirimi için sözdizimi -

delegate <return type> <delegate-name> <parameter list>

Temsilciler Örnekleme

Bir temsilci türü bildirildikten sonra, bir delege nesnesi, new anahtar kelime ve belirli bir yöntemle ilişkilendirilebilir. Bir temsilci oluştururken, argümannewifade bir yöntem çağrısına benzer şekilde, ancak yöntemin argümanları olmadan yazılır. Örneğin -

public delegate void printString(string s);
...
printString ps1 = new printString(WriteToScreen);
printString ps2 = new printString(WriteToFile);

Aşağıdaki örnek, bir tamsayı parametresi alan ve bir tamsayı değeri döndüren yöntemlere başvurmak için kullanılabilen bir temsilcinin bildirimi, somutlaştırılması ve kullanımını gösterir.

using System;

delegate int NumberChanger(int n);
namespace DelegateAppl {
   
   class TestDelegate {
      static int num = 10;
      
      public static int AddNum(int p) {
         num += p;
         return num;
      }

      public static int MultNum(int q) {
         num *= q;
         return num;
      }
      
      public static int getNum() {
         return num;
      }

      static void Main(string[] args) {
         //create delegate instances
         NumberChanger nc1 = new NumberChanger(AddNum);
         NumberChanger nc2 = new NumberChanger(MultNum);
         
         //calling the methods using the delegate objects
         nc1(25);
         Console.WriteLine("Value of Num: {0}", getNum());
         nc2(5);
         Console.WriteLine("Value of Num: {0}", getNum());
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Value of Num: 35
Value of Num: 175

Bir Delegenin Çoklu Yayını

Delege nesneleri "+" operatörü kullanılarak oluşturulabilir. Oluşan bir delege, oluşturduğu iki delegeyi çağırır. Yalnızca aynı türden delegeler oluşturulabilir. "-" operatörü, oluşan bir temsilciden bir bileşen temsilcisini kaldırmak için kullanılabilir.

Temsilcilerin bu özelliğini kullanarak, bir temsilci çağrıldığında çağrılacak yöntemlerin bir çağrı listesi oluşturabilirsiniz. Bu denirmulticastingbir delegenin. Aşağıdaki program, bir delegenin çok noktaya yayınını göstermektedir -

using System;

delegate int NumberChanger(int n);
namespace DelegateAppl {

   class TestDelegate {
      static int num = 10;
      
      public static int AddNum(int p) {
         num += p;
         return num;
      }

      public static int MultNum(int q) {
         num *= q;
         return num;
      }
      
      public static int getNum() {
         return num;
      }

      static void Main(string[] args) {
         //create delegate instances
         NumberChanger nc;
         NumberChanger nc1 = new NumberChanger(AddNum);
         NumberChanger nc2 = new NumberChanger(MultNum);
         nc = nc1;
         nc += nc2;
         
         //calling multicast
         nc(5);
         Console.WriteLine("Value of Num: {0}", getNum());
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Value of Num: 75

Temsilcileri Kullanma

Aşağıdaki örnek, temsilci kullanımını gösterir. Temsilci printString , bir dizeyi girdi olarak alan ve hiçbir şey döndürmeyen yönteme başvurmak için kullanılabilir.

Bu delegeyi iki yöntemi çağırmak için kullanıyoruz, ilki dizeyi konsola yazdırıyor ve ikincisi bir dosyaya yazdırıyor -

using System;
using System.IO;

namespace DelegateAppl {

   class PrintString {
      static FileStream fs;
      static StreamWriter sw;
      
      // delegate declaration
      public delegate void printString(string s);

      // this method prints to the console
      public static void WriteToScreen(string str) {
         Console.WriteLine("The String is: {0}", str);
      }
      
      //this method prints to a file
      public static void WriteToFile(string s) {
         fs = new FileStream("c:\\message.txt",
         FileMode.Append, FileAccess.Write);
         sw = new StreamWriter(fs);
         sw.WriteLine(s);
         sw.Flush();
         sw.Close();
         fs.Close();
      }
      
      // this method takes the delegate as parameter and uses it to
      // call the methods as required
      public static void sendString(printString ps) {
         ps("Hello World");
      }
      
      static void Main(string[] args) {
         printString ps1 = new printString(WriteToScreen);
         printString ps2 = new printString(WriteToFile);
         sendString(ps1);
         sendString(ps2);
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

The String is: Hello World

Eventstuşa basma, tıklamalar, fare hareketleri vb. gibi kullanıcı eylemleri veya sistem tarafından oluşturulan bildirimler gibi bazı olaylar. Uygulamalar meydana geldiklerinde olaylara yanıt vermelidir. Örneğin, keser. Olaylar, süreçler arası iletişim için kullanılır.

Temsilcileri Etkinliklerle Kullanma

Olaylar, bir sınıfta bildirilir ve oluşturulur ve aynı sınıf veya başka bir sınıf içindeki temsilciler kullanılarak olay işleyicileriyle ilişkilendirilir. Olayı içeren sınıf, olayı yayınlamak için kullanılır. Bu denirpublishersınıf. Bu olayı kabul eden başka bir sınıfa,subscriber sınıf. Etkinlikler şunu kullanır:publisher-subscriber model.

Bir publisherolayın ve temsilcinin tanımını içeren bir nesnedir. Olay temsilcisi ilişkisi de bu nesnede tanımlanır. Bir yayıncı sınıfı nesnesi, olayı çağırır ve diğer nesnelere bildirilir.

Bir subscriberolayı kabul eden ve bir olay işleyicisi sağlayan bir nesnedir. Publisher sınıfındaki temsilci, abone sınıfının yöntemini (olay işleyicisi) çağırır.

Olayları Bildirme

Bir sınıf içinde bir olay bildirmek için, her şeyden önce, şu çift için bir temsilci türü bildirmelisiniz:

public delegate string BoilerLogHandler(string str);

ardından, olayı kullanarak event anahtar kelime -

event BoilerLogHandler BoilerEventLog;

Önceki kod, BoilerLogHandler adında bir temsilci ve yükseltildiğinde temsilciyi çağıran BoilerEventLog adlı bir olay tanımlar .

Misal

using System;

namespace SampleApp {
   public delegate string MyDel(string str);
	
   class EventProgram {
      event MyDel MyEvent;
		
      public EventProgram() {
         this.MyEvent += new MyDel(this.WelcomeUser);
      }
		
      public string WelcomeUser(string username) {
         return "Welcome " + username;
      }
		
      static void Main(string[] args) {
         EventProgram obj1 = new EventProgram();
         string result = obj1.MyEvent("Tutorials Point");
         Console.WriteLine(result);
      }

   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Welcome Tutorials Point

Koleksiyon sınıfları, veri depolama ve alma için özel sınıflardır. Bu sınıflar yığınlar, kuyruklar, listeler ve karma tablolar için destek sağlar. Çoğu koleksiyon sınıfı aynı arabirimleri uygular.

Koleksiyon sınıfları, belleğin öğelere dinamik olarak tahsis edilmesi ve bir dizin temelinde bir öğe listesine erişilmesi vb. Gibi çeşitli amaçlara hizmet eder. Bu sınıflar, C # 'daki tüm veri türleri için temel sınıf olan Object sınıfının nesne koleksiyonlarını oluşturur.

Çeşitli Koleksiyon Sınıfları ve Kullanımları

Aşağıdakiler, yaygın olarak kullanılan çeşitli sınıflardır. System.Collectionad alanı. Ayrıntılarını kontrol etmek için aşağıdaki bağlantıları tıklayın.

Sr.No.	Sınıf & Açıklama ve Kullanım
1	Dizi Listesi Olabilecek bir nesnenin sıralı koleksiyonunu temsil eder. indexed bireysel olarak. Temelde bir diziye bir alternatiftir. Bununla birlikte, diziden farklı olarak, bir listeden belirli bir konumdaki öğeleri ekleyip kaldırabilirsiniz.indexve dizi otomatik olarak yeniden boyutlandırılır. Ayrıca dinamik bellek ayırmaya, listedeki öğeleri eklemeye, aramaya ve sıralamaya izin verir.
2	Hashtable Bir key koleksiyondaki öğelere erişmek için. Anahtar kullanarak öğelere erişmeniz gerektiğinde bir karma tablo kullanılır ve kullanışlı bir anahtar değeri tanımlayabilirsiniz. Karma tablosundaki her öğenin birkey/valueçift. Anahtar, koleksiyondaki öğelere erişmek için kullanılır.
3	Sıralanmış Liste Bir key yanı sıra bir index bir listedeki öğelere erişmek için. Sıralanmış bir liste, bir dizi ve bir karma tablo kombinasyonudur. Bir anahtar veya dizin kullanılarak erişilebilen öğelerin bir listesini içerir. Öğelere bir dizin kullanarak erişirseniz, bu bir ArrayList'tir ve öğelere bir anahtar kullanarak erişirseniz, bu bir Hashtable'dır. Öğelerin koleksiyonu her zaman anahtar değerine göre sıralanır.
4	Yığın Temsil eder last-in, first out nesne koleksiyonu. Öğelere son giren ilk çıkar erişimine ihtiyacınız olduğunda kullanılır. Listeye bir öğe eklediğinizde bunapushing öğe ve onu kaldırdığınızda adı popping eşya.
5	Kuyruk Temsil eder first-in, first out nesne koleksiyonu. Öğelere ilk giren ilk çıkar erişimine ihtiyacınız olduğunda kullanılır. Listeye bir öğe eklediğinizde bunaenqueue ve bir öğeyi kaldırdığınızda buna deque.
6	BitArray Bir diziyi temsil eder binary representation 1 ve 0 değerlerini kullanarak. Bitleri kaydetmeniz gerektiğinde, ancak önceden bit sayısını bilmediğinizde kullanılır. BitArray koleksiyonundaki öğelere birinteger index, sıfırdan başlar.

GenericsProgramda gerçekten kullanılana kadar, bir sınıf veya yöntemdeki programlama öğelerinin veri türünün özelliklerini tanımlamanıza olanak tanır. Diğer bir deyişle, jenerikler, herhangi bir veri türüyle çalışabilen bir sınıf veya yöntem yazmanıza izin verir.

Veri türleri için yedek parametrelerle birlikte sınıf veya yöntemin belirtimlerini yazarsınız. Derleyici, sınıf için bir yapıcıyla veya yöntem için bir işlev çağrısıyla karşılaştığında, belirli veri türünü işlemek için kod üretir. Basit bir örnek, kavramı anlamanıza yardımcı olabilir -

using System;
using System.Collections.Generic;

namespace GenericApplication {

   public class MyGenericArray<T> {
      private T[] array;
      
      public MyGenericArray(int size) {
         array = new T[size + 1];
      }
      
      public T getItem(int index) {
         return array[index];
      }
      
      public void setItem(int index, T value) {
         array[index] = value;
      }
   }
   
   class Tester {
      static void Main(string[] args) {
         
         //declaring an int array
         MyGenericArray<int> intArray = new MyGenericArray<int>(5);
         
         //setting values
         for (int c = 0; c < 5; c++) {
            intArray.setItem(c, c*5);
         }
         
         //retrieving the values
         for (int c = 0; c < 5; c++) {
            Console.Write(intArray.getItem(c) + " ");
         }
         
         Console.WriteLine();
         
         //declaring a character array
         MyGenericArray<char> charArray = new MyGenericArray<char>(5);
         
         //setting values
         for (int c = 0; c < 5; c++) {
            charArray.setItem(c, (char)(c+97));
         }
         
         //retrieving the values
         for (int c = 0; c< 5; c++) {
            Console.Write(charArray.getItem(c) + " ");
         }
         Console.WriteLine();
         
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

0 5 10 15 20
a b c d e

Jeneriklerin Özellikleri

Jenerikler, programlarınızı aşağıdaki şekillerde zenginleştiren bir tekniktir:

• Kodun yeniden kullanımını, yazım güvenliğini ve performansı en üst düzeye çıkarmanıza yardımcı olur.

• Genel koleksiyon sınıfları oluşturabilirsiniz. .NET Framework sınıf kitaplığı, System.Collections.Generic ad alanında birkaç yeni genel koleksiyon sınıfı içerir . System.Collections ad alanındaki koleksiyon sınıfları yerine bu genel koleksiyon sınıflarını kullanabilirsiniz .

• Kendi genel arayüzlerinizi, sınıflarınızı, yöntemlerinizi, olaylarınızı ve temsilcilerinizi oluşturabilirsiniz.

• Belirli veri türlerindeki yöntemlere erişim sağlamak için kısıtlanmış genel sınıflar oluşturabilirsiniz.

• Çalışma zamanında genel bir veri türünde kullanılan türler hakkında yansıma yoluyla bilgi alabilirsiniz.

Genel Yöntemler

Önceki örnekte, genel bir sınıf kullandık; bir tür parametresiyle genel bir yöntem bildirebiliriz. Aşağıdaki program kavramı göstermektedir -

using System;
using System.Collections.Generic;

namespace GenericMethodAppl {
   
   class Program {
      
      static void Swap<T>(ref T lhs, ref T rhs) {
         T temp;
         temp = lhs;
         lhs = rhs;
         rhs = temp;
      }
      
      static void Main(string[] args) {
         int a, b;
         char c, d;
         a = 10;
         b = 20;
         c = 'I';
         d = 'V';
         
         //display values before swap:
         Console.WriteLine("Int values before calling swap:");
         Console.WriteLine("a = {0}, b = {1}", a, b);
         Console.WriteLine("Char values before calling swap:");
         Console.WriteLine("c = {0}, d = {1}", c, d);
         
         //call swap
         Swap<int>(ref a, ref b);
         Swap<char>(ref c, ref d);
         
         //display values after swap:
         Console.WriteLine("Int values after calling swap:");
         Console.WriteLine("a = {0}, b = {1}", a, b);
         Console.WriteLine("Char values after calling swap:");
         Console.WriteLine("c = {0}, d = {1}", c, d);
         
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Int values before calling swap:
a = 10, b = 20
Char values before calling swap:
c = I, d = V
Int values after calling swap:
a = 20, b = 10
Char values after calling swap:
c = V, d = I

Genel Temsilciler

Tür parametreleriyle genel bir temsilci tanımlayabilirsiniz. Örneğin -

delegate T NumberChanger<T>(T n);

Aşağıdaki örnek, bu temsilcinin kullanımını gösterir -

using System;
using System.Collections.Generic;

delegate T NumberChanger<T>(T n);
namespace GenericDelegateAppl {
   
   class TestDelegate {
      static int num = 10;
      
      public static int AddNum(int p) {
         num += p;
         return num;
      }
      
      public static int MultNum(int q) {
         num *= q;
         return num;
      }
      
      public static int getNum() {
         return num;
      }
      
      static void Main(string[] args) {
         //create delegate instances
         NumberChanger<int> nc1 = new NumberChanger<int>(AddNum);
         NumberChanger<int> nc2 = new NumberChanger<int>(MultNum);
         
         //calling the methods using the delegate objects
         nc1(25);
         Console.WriteLine("Value of Num: {0}", getNum());
         nc2(5);
         Console.WriteLine("Value of Num: {0}", getNum());
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Value of Num: 35
Value of Num: 175

Temsilcilerin, temsilcinin imzasıyla aynı imzaya sahip herhangi bir yöntemi referans almak için kullanıldığını tartıştık. Başka bir deyişle, bu temsilci nesnesini kullanarak bir temsilci tarafından başvurulabilecek bir yöntemi çağırabilirsiniz.

Anonymous methodsbir kod bloğunu temsilci parametresi olarak geçirmek için bir teknik sağlar. Anonim yöntemler, isimsiz yöntemlerdir, sadece vücut.

Anonim bir yöntemde dönüş türünü belirtmenize gerek yoktur; yöntem gövdesi içindeki return ifadesinden çıkarılır.

Anonim Bir Yöntem Yazma

Anonim yöntemler, temsilci örneğinin oluşturulmasıyla bildirilir. delegateanahtar kelime. Örneğin,

delegate void NumberChanger(int n);
...
NumberChanger nc = delegate(int x) {
   Console.WriteLine("Anonymous Method: {0}", x);
};

Console.WriteLine kod bloğu ("Anonim Yöntem: {0}", x); anonim yöntemin gövdesidir.

Temsilci, hem anonim yöntemlerle hem de adlandırılmış yöntemlerle aynı şekilde çağrılabilir, yani yöntem parametrelerini temsilci nesnesine ileterek.

Örneğin,

nc(10);

Misal

Aşağıdaki örnek kavramı göstermektedir -

using System;

delegate void NumberChanger(int n);
namespace DelegateAppl {
   
   class TestDelegate {
      static int num = 10;
      
      public static void AddNum(int p) {
         num += p;
         Console.WriteLine("Named Method: {0}", num);
      }
      
      public static void MultNum(int q) {
         num *= q;
         Console.WriteLine("Named Method: {0}", num);
      }
      
      public static int getNum() {
         return num;
      }
      
      static void Main(string[] args) {
         //create delegate instances using anonymous method
         NumberChanger nc = delegate(int x) {
            Console.WriteLine("Anonymous Method: {0}", x);
         };
         
         //calling the delegate using the anonymous method 
         nc(10);
         
         //instantiating the delegate using the named methods 
         nc =  new NumberChanger(AddNum);
         
         //calling the delegate using the named methods 
         nc(5);
         
         //instantiating the delegate using another named methods 
         nc =  new NumberChanger(MultNum);
         
         //calling the delegate using the named methods 
         nc(2);
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Anonymous Method: 10
Named Method: 15
Named Method: 30

C # ile işaretlendiğinde kod bloğunun bir işlevinde işaretçi değişkenlerinin kullanılmasına izin verir. unsafedeğiştirici. unsafe code veya yönetilmeyen kod, bir pointer değişken.

Note- Bu bölümde bahsedilen programları kodlama alanında çalıştırmak için , lütfen Proje >> Derleme Seçenekleri >> Derleme Komutunda derleme seçeneğini ayarlayın .

mcs *.cs -out:main.exe -unsafe"

İşaretçiler

Bir pointerdeğeri başka bir değişkenin adresi, yani bellek yerinin doğrudan adresi olan bir değişkendir. herhangi bir değişken veya sabite benzer şekilde, herhangi bir değişken adresini saklamak için kullanmadan önce bir işaretçi bildirmelisiniz.

İşaretçi bildiriminin genel biçimi şöyledir:

type *var-name;

Aşağıdakiler geçerli işaretçi bildirimleridir -

int    *ip;    /* pointer to an integer */
double *dp;    /* pointer to a double */
float  *fp;    /* pointer to a float */
char   *ch     /* pointer to a character */

Aşağıdaki örnek, güvenli olmayan değiştirici kullanılarak C # 'da işaretçilerin kullanımını gösterir -

using System;

namespace UnsafeCodeApplication {
   
   class Program {
      
      static unsafe void Main(string[] args) {
         int var = 20;
         int* p = &var;
         Console.WriteLine("Data is: {0} ",  var);
         Console.WriteLine("Address is: {0}",  (int)p);
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Data is: 20
Address is: 99215364

Tüm bir yöntemi güvensiz olarak bildirmek yerine, kodun bir bölümünü güvensiz olarak da bildirebilirsiniz. Aşağıdaki bölümdeki örnek bunu göstermektedir.

İşaretçi Kullanarak Veri Değerini Alma

İşaretçi değişkeni tarafından referans gösterilen konumdaki verileri, ToString()yöntem. Aşağıdaki örnek bunu göstermektedir -

using System;

namespace UnsafeCodeApplication {
   
   class Program {
      
      public static void Main() {
         
         unsafe {
            int var = 20;
            int* p = &var;
            Console.WriteLine("Data is: {0} " , var);
            Console.WriteLine("Data is: {0} " , p->ToString());
            Console.WriteLine("Address is: {0} " , (int)p);
         }
         
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Data is: 20
Data is: 20
Address is: 77128984

İşaretçileri Parametre Olarak Yöntemlere Aktarma

Bir işaretçi değişkenini bir yönteme parametre olarak iletebilirsiniz. Aşağıdaki örnek bunu göstermektedir -

using System;

namespace UnsafeCodeApplication {
   
   class TestPointer {
      
      public unsafe void swap(int* p, int *q) {
         int temp = *p;
         *p = *q;
         *q = temp;
      }
      
      public unsafe static void Main() {
         TestPointer p = new TestPointer();
         int var1 = 10;
         int var2 = 20;
         int* x = &var1;
         int* y = &var2;
         
         Console.WriteLine("Before Swap: var1:{0}, var2: {1}", var1, var2);
         p.swap(x, y);

         Console.WriteLine("After Swap: var1:{0}, var2: {1}", var1, var2);
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Before Swap: var1: 10, var2: 20
After Swap: var1: 20, var2: 10

İşaretçi Kullanarak Dizi Öğelerine Erişim

C # 'da, bir dizi adı ve dizi verileriyle aynı olan bir veri türüne işaretçi, aynı değişken türü değildir. Örneğin, int * p ve int [] p, aynı tür değildir. P işaretçi değişkenini artırabilirsiniz çünkü bellekte sabit değildir, ancak bir dizi adresi bellekte sabitlenmiştir ve bunu arttıramazsınız.

Bu nedenle, geleneksel olarak C veya C ++ 'da yaptığımız gibi bir işaretçi değişkeni kullanarak bir dizi verilerine erişmeniz gerekiyorsa (lütfen kontrol edin: C İşaretçileri ), işaretçiyi kullanarakfixed anahtar kelime.

Aşağıdaki örnek bunu göstermektedir -

using System;

namespace UnsafeCodeApplication {
   
   class TestPointer {
      
      public unsafe static void Main() {
         int[]  list = {10, 100, 200};
         fixed(int *ptr = list)
         
         /* let us have array address in pointer */
         for ( int i = 0; i < 3; i++) {
            Console.WriteLine("Address of list[{0}]={1}",i,(int)(ptr + i));
            Console.WriteLine("Value of list[{0}]={1}", i, *(ptr + i));
         }
         
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Address of list[0] = 31627168
Value of list[0] = 10
Address of list[1] = 31627172
Value of list[1] = 100
Address of list[2] = 31627176
Value of list[2] = 200

Güvenli Olmayan Kodu Derleme

Güvenli olmayan kodu derlemek için, /unsafe komut satırı derleyicili komut satırı anahtarı.

Örneğin, güvenli olmayan kod içeren prog1.cs adlı bir programı komut satırından derlemek için şu komutu verin -

csc /unsafe prog1.cs

Visual Studio IDE kullanıyorsanız proje özelliklerinde güvenli olmayan kod kullanımını etkinleştirmeniz gerekir.

Bunu yapmak için -

• Açık project properties Çözüm Gezgini'ndeki özellikler düğümüne çift tıklayarak.

• Tıkla Build sekmesi.

• "Seçeneğini seçin"Allow unsafe code".

Bir threadbir programın yürütme yolu olarak tanımlanır. Her iş parçacığı benzersiz bir kontrol akışını tanımlar. Uygulamanız karmaşık ve zaman alan işlemler içeriyorsa, her iş parçacığının belirli bir işi gerçekleştirdiği farklı yürütme yolları veya iş parçacıkları ayarlamak genellikle yararlıdır.

Konular lightweight processes. İş parçacığı kullanımının yaygın bir örneği, modern işletim sistemleri tarafından eşzamanlı programlamanın uygulanmasıdır. İş parçacığı kullanımı CPU döngüsü israfından tasarruf sağlar ve bir uygulamanın verimliliğini artırır.

Şimdiye kadar, tek bir iş parçacığının, uygulamanın çalışan örneği olan tek bir işlem olarak çalıştığı programları yazdık. Ancak bu şekilde uygulama aynı anda bir iş yapabilir. Bir seferde birden fazla görevi yürütmesini sağlamak için daha küçük iş parçacıkları olarak bölünebilir.

İplik Yaşam Döngüsü

Bir iş parçacığının yaşam döngüsü, System.Threading.Thread sınıfının bir nesnesi oluşturulduğunda başlar ve iş parçacığı sonlandırıldığında veya yürütmeyi tamamladığında sona erer.

Bir iş parçacığının yaşam döngüsündeki çeşitli durumlar aşağıdadır -

• The Unstarted State - İş parçacığı örneğinin oluşturulduğu, ancak Start yönteminin çağrılmadığı durumdur.

• The Ready State - İş parçacığının çalışmaya hazır olduğu ve CPU döngüsünü beklediği durumdur.

• The Not Runnable State - Bir iş parçacığı yürütülebilir değildir,

  • Uyku yöntemi çağrıldı
  • Bekleme yöntemi çağrıldı
  • G / Ç işlemleri tarafından engellendi

• The Dead State - İş parçacığının yürütmeyi tamamladığı veya durdurulduğu durumdur.

Ana Konu

C # dilinde System.Threading.Threadsınıfı iş parçacıklarıyla çalışmak için kullanılır. Çok iş parçacıklı bir uygulamada bireysel iş parçacıklarının oluşturulmasına ve bunlara erişilmesine izin verir. Bir işlemde çalıştırılacak ilk iş parçacığı,main Konu.

Bir C # programı çalışmaya başladığında, ana iş parçacığı otomatik olarak oluşturulur. Kullanılarak oluşturulan konularThreadsınıf, ana iş parçacığının alt konuları olarak adlandırılır. Bir iş parçacığına erişebilirsiniz.CurrentThread Thread sınıfının özelliği.

Aşağıdaki program ana iş parçacığının yürütülmesini gösterir -

using System;
using System.Threading;

namespace MultithreadingApplication {
   
   class MainThreadProgram {
      
      static void Main(string[] args) {
         Thread th = Thread.CurrentThread;
         th.Name = "MainThread";
         Console.WriteLine("This is {0}", th.Name);
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

This is MainThread

Diş Sınıfının Özellikleri ve Yöntemleri

Aşağıdaki tablo en sık kullanılanları göstermektedir properties of Thread sınıf -

Sr.No.	Özellik ve Açıklama
1	CurrentContext İş parçacığının yürütüldüğü geçerli bağlamı alır.
2	CurrentCulture Geçerli iş parçacığı için kültürü alır veya ayarlar.Gets or sets the culture for the current thread.
3	CurrentPrinciple İş parçacığının geçerli ilkesini alır veya ayarlar (rol tabanlı güvenlik için).
4	CurrentThread Şu anda çalışan iş parçacığını alır.
5	CurrentUICulture Çalışma zamanında kültüre özgü kaynakları aramak için Kaynak Yöneticisi tarafından kullanılan geçerli kültürü alır veya ayarlar.Gets or sets the current culture used by the Resource Manager to look up culture-specific resources at run-time.
6	ExecutionContext Geçerli iş parçacığının çeşitli bağlamları hakkında bilgi içeren bir ExecutionContext nesnesi alır.
7	IsAlive Geçerli iş parçacığının yürütme durumunu gösteren bir değer alır.
8	IsBackground Bir iş parçacığının arka plan iş parçacığı olup olmadığını gösteren bir değer alır veya ayarlar.
9	IsThreadPoolThread Bir iş parçacığının yönetilen iş parçacığı havuzuna ait olup olmadığını gösteren bir değer alır.
10	ManagedThreadId Geçerli yönetilen iş parçacığı için benzersiz bir tanımlayıcı alır.
11	Name İş parçacığının adını alır veya ayarlar.
12	Priority Bir iş parçacığının zamanlama önceliğini gösteren bir değer alır veya ayarlar.
13	ThreadState Geçerli iş parçacığının durumlarını içeren bir değer alır.

Aşağıdaki tablo en sık kullanılanlardan bazılarını göstermektedir methods of Thread sınıf -

Sr.No.	Yöntem ve Açıklama
1	public void Abort() İş parçacığını sonlandırma işlemine başlamak için çağrıldığı iş parçacığında bir ThreadAbortException oluşturur. Bu yöntemi çağırmak genellikle iş parçacığını sonlandırır.
2	public static LocalDataStoreSlot AllocateDataSlot() Tüm evrelerde isimsiz bir veri yuvası tahsis eder. Daha iyi performans için, bunun yerine ThreadStaticAttribute özniteliğiyle işaretlenmiş alanları kullanın.
3	public static LocalDataStoreSlot AllocateNamedDataSlot(string name) Tüm iş parçacıkları üzerinde adlandırılmış bir veri yuvası tahsis eder. Daha iyi performans için, bunun yerine ThreadStaticAttribute özniteliğiyle işaretlenmiş alanları kullanın.
4	public static void BeginCriticalRegion() Bir ana bilgisayara, yürütmenin, iş parçacığı iptalinin veya işlenmemiş istisnanın etkilerinin uygulama etki alanındaki diğer görevleri tehlikeye atabileceği bir kod bölgesine girmek üzere olduğunu bildirir.
5	public static void BeginThreadAffinity() Yönetilen kodun mevcut fiziksel işletim sistemi iş parçacığının kimliğine bağlı talimatları yürütmek üzere olduğunu bir ana bilgisayara bildirir.
6	public static void EndCriticalRegion() Bir ana bilgisayara, işlemin bir iş parçacığı iptalinin veya işlenmemiş istisnanın etkilerinin mevcut görevle sınırlı olduğu bir kod bölgesine girmek üzere olduğunu bildirir.
7	public static void EndThreadAffinity() Yönetilen kodun, geçerli fiziksel işletim sistemi iş parçacığının kimliğine bağlı talimatları yürütmeyi bitirdiğini ana bilgisayara bildirir.
8	public static void FreeNamedDataSlot(string name) İşlemdeki tüm iş parçacıkları için bir ad ve yuva arasındaki ilişkiyi ortadan kaldırır. Daha iyi performans için, bunun yerine ThreadStaticAttribute özniteliğiyle işaretlenmiş alanları kullanın.
9	public static Object GetData(LocalDataStoreSlot slot) Geçerli iş parçacığının geçerli etki alanı içinde, geçerli iş parçacığı üzerindeki belirtilen yuvadan değeri alır. Daha iyi performans için, bunun yerine ThreadStaticAttribute özniteliğiyle işaretlenmiş alanları kullanın.
10	public static AppDomain GetDomain() Geçerli iş parçacığının çalıştığı geçerli etki alanını döndürür.
11	public static AppDomain GetDomainID() Benzersiz bir uygulama etki alanı tanımlayıcısı döndürür
12	public static LocalDataStoreSlot GetNamedDataSlot(string name) Adlandırılmış bir veri yuvasını arar. Daha iyi performans için, bunun yerine ThreadStaticAttribute özniteliğiyle işaretlenmiş alanları kullanın.
13	public void Interrupt() WaitSleepJoin iş parçacığı durumunda olan bir iş parçacığını keser.
14	public void Join() Standart COM ve SendMessage pompalama yapmaya devam ederken, bir iş parçacığı sona erene kadar çağıran iş parçacığını engeller. Bu yöntemin farklı aşırı yüklenmiş formları vardır.
15	public static void MemoryBarrier() Bellek erişimini aşağıdaki şekilde senkronize eder: Mevcut iş parçacığını çalıştıran işlemci, MemoryBarrier çağrısını takip eden bellek erişiminden sonra MemoryBarrier çağrısından önce belleğe erişecek şekilde talimatları yeniden sıralayamaz.
16	public static void ResetAbort() Mevcut iş parçacığı için talep edilen bir İptali iptal eder.
17	public static void SetData(LocalDataStoreSlot slot, Object data) Bu iş parçacığının geçerli etki alanı için, o anda çalışan iş parçacığı üzerinde belirtilen yuvadaki verileri ayarlar. Daha iyi performans için bunun yerine ThreadStaticAttribute özniteliğiyle işaretlenmiş alanları kullanın.
18	public void Start() Bir iş parçacığı başlatır.
19	public static void Sleep(int millisecondsTimeout) İş parçacığını bir süre duraklatır.
20	public static void SpinWait(int iterations) Bir iş parçacığının yineleme parametresi tarafından tanımlanan sayıda beklemesine neden olur
21	public static byte VolatileRead(ref byte address) public static double VolatileRead(ref double address) public static int VolatileRead(ref int address) public static Object VolatileRead(ref Object address) Bir alanın değerini okur. Değer, işlemci sayısına veya işlemci önbelleğinin durumuna bakılmaksızın bilgisayardaki herhangi bir işlemci tarafından en son yazılan değerdir. Bu yöntemin farklı aşırı yüklenmiş formları vardır. Yukarıda sadece bazıları verilmiştir.
22	public static void VolatileWrite(ref byte address,byte value) public static void VolatileWrite(ref double address, double value) public static void VolatileWrite(ref int address, int value) public static void VolatileWrite(ref Object address, Object value) Değerin bilgisayardaki tüm işlemciler tarafından görülebilmesi için bir alana hemen bir değer yazar. Bu yöntemin farklı aşırı yüklenmiş formları vardır. Yukarıda sadece bazıları verilmiştir.
23	public static bool Yield() Çağıran iş parçacığının, geçerli işlemcide çalışmaya hazır başka bir iş parçacığına yürütme sağlamasına neden olur. İşletim sistemi, verilecek iş parçacığını seçer.

Konu Oluşturma

Dişler, Thread sınıfını genişleterek oluşturulur. Genişletilmiş Thread sınıfı daha sonraStart() çocuk iş parçacığı yürütmeye başlamak için yöntem.

Aşağıdaki program kavramı göstermektedir -

using System;
using System.Threading;

namespace MultithreadingApplication {
   
   class ThreadCreationProgram {
      
      public static void CallToChildThread() {
         Console.WriteLine("Child thread starts");
      }
      
      static void Main(string[] args) {
         ThreadStart childref = new ThreadStart(CallToChildThread);
         Console.WriteLine("In Main: Creating the Child thread");
         Thread childThread = new Thread(childref);
         childThread.Start();
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

In Main: Creating the Child thread
Child thread starts

İleti Dizilerini Yönetme

Thread sınıfı, iş parçacıklarını yönetmek için çeşitli yöntemler sağlar.

Aşağıdaki örnek, sleep() belirli bir süre için iş parçacığını duraklatma yöntemi.

using System;
using System.Threading;

namespace MultithreadingApplication {
   
   class ThreadCreationProgram {
      
      public static void CallToChildThread() {
         Console.WriteLine("Child thread starts");
         
         // the thread is paused for 5000 milliseconds
         int sleepfor = 5000; 
         
         Console.WriteLine("Child Thread Paused for {0} seconds", sleepfor / 1000);
         Thread.Sleep(sleepfor);
         Console.WriteLine("Child thread resumes");
      }
      
      static void Main(string[] args) {
         ThreadStart childref = new ThreadStart(CallToChildThread);
         Console.WriteLine("In Main: Creating the Child thread");
         Thread childThread = new Thread(childref);
         childThread.Start();
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

In Main: Creating the Child thread
Child thread starts
Child Thread Paused for 5 seconds
Child thread resumes

Konuları Yok Etmek

Abort() yöntemi iplikleri yok etmek için kullanılır.

Çalışma zamanı, iş parçacığını bir ThreadAbortException. Bu istisna yakalanamaz, kontrol varsa son bloğa gönderilir .

Aşağıdaki program bunu göstermektedir -

using System;
using System.Threading;

namespace MultithreadingApplication {
   
   class ThreadCreationProgram {
      
      public static void CallToChildThread() {
         
         try {
            Console.WriteLine("Child thread starts");
            
            // do some work, like counting to 10
            for (int counter = 0; counter <= 10; counter++) {
               Thread.Sleep(500);
               Console.WriteLine(counter);
            }
            
            Console.WriteLine("Child Thread Completed");
         } catch (ThreadAbortException e) {
            Console.WriteLine("Thread Abort Exception");
         } finally {
            Console.WriteLine("Couldn't catch the Thread Exception");
         }
      }
      
      static void Main(string[] args) {
         ThreadStart childref = new ThreadStart(CallToChildThread);
         Console.WriteLine("In Main: Creating the Child thread");
         Thread childThread = new Thread(childref);
         childThread.Start();
         
         //stop the main thread for some time
         Thread.Sleep(2000);
         
         //now abort the child
         Console.WriteLine("In Main: Aborting the Child thread");
         
         childThread.Abort();
         Console.ReadKey();
      }
   }
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

In Main: Creating the Child thread
Child thread starts
0
1
2
In Main: Aborting the Child thread
Thread Abort Exception
Couldn't catch the Thread Exception