C # Tutorial: Ang Mga Pangunahing Batayan na Kailangan Mong Magtutudlo C #

Ang C # ay lahat ng layunin at ang matatag na wika ng programa na binuo ng Microsoft Corporation noong taong 2000 bilang isang nakamamatay na katunggali sa Java. Ito ay pinaka-tanyag at isang nangingibabaw na wika ng programa pagdating sa parehong pag-unlad ng web pati na rin ang pag-unlad ng aplikasyon sa desktop.

Sa C # Tutorial na ito, malalaman natin ang mga sumusunod na konsepto.

• Mga Pangunahing Kaalaman sa C #
• Programming na Nakatuon sa Bagay
• Mga advanced na C # Concept
• Mga Katanungan sa Panayam batay sa C #

Mga Pangunahing Kaalaman sa C #

• Panimula sa C # Programming Wika
• Mga Tampok ng C # Programming Wika
• Pag-install
• C # Istraktura ng Programa
• Uri ng data
• Mga variable
• Mga Operator
• Mga loop
• Kundisyon
• Mga kuwerdas
• Mga array
• Mga Koleksyon
  • Listahan
  • Itakda ang Hash
  • Naayos na Hanay
  • Stack
  • Pila
  • Listahan ng naka-link
  • Diksyonaryo
  • Pinagbukud-bukod na Diksiyonaryo
  • Inayos na Listahan
• Istraktura
• Mga pagpapaandar

Panimula sa C # Programming Wika

Bumalik sa unang bahagi ng 90s, ang Java ay ang nangungunang wika ng programa para sa pag-unlad ng web, pagbuo ng aplikasyon ng desktop at maraming iba pang mga larangan. Nais ng Microsoft na makabuo ng isang kakumpitensya na may maraming mga advanced na tampok na maaaring iwan ang Java sa likod.

Ito ay sa taong 2000, Anders Hejlsberg at ang kanyang koponan sa Microsoft ay nagmula sa ideya ng C # na tanyag na tinatawag na C-Sharp. Ang hakbangin na ito ay inaprubahan ng International Standards Organization (MAJOR) at ang European Computer Manufacturer Association (ECMA). at sa wakas, ang C # ay pumasok sa mundo ng pag-unlad ng software.

Mga Tampok ng C # Programming Wika

• Wika sa Programming na Nakatuon sa Bagay

Ang diskarte sa Programming na Nakatuon sa Bagay ay kung bakit ang C # matalim upang maging pinaka programmer-friendly at madaling bumuo at mapanatili ang wika ng programa.

• Uri-Ligtas na Wika

Ang kahulugan ng Type-Safe ay bibigyan ng access ang tagatala sa lokasyon ng memorya na may pahintulot na magpatupad. Ang tampok na ito ay nagpapabuti sa kaligtasan ng code sa isang antas ng exponential.

• Pakikipag-ugnay

Ang tampok na Interoperability ay gumagawa ng sapat na may kakayahang C # upang gawin ang lahat na katutubong sa C ++ sa isang mas mahusay na paraan na maaaring lumagpas sa C ++ mismo.

• Mayamang Library

Nagbibigay ang C # ng access sa maraming bilang ng mga in-built na aklatan na nagbibigay ng mga naka-preprogram na pagpapaandar upang mabawasan ang oras na ginugol sa proseso ng pag-unlad.

• Masusukat at Maa-update

Ang C # ay dinisenyo upang maging superior sa gitna ng iba pang mga wika ng programa. Samakatuwid, palaging bukas ito sa mga pag-update at pinapanatili nito ang sarili nitong lubos na nasusukat sa mga tampok nito.

• Oriented na bahagi

Ginamit ng mga developer sa Microsoft ang diskarte na batay sa sangkap upang paunlarin ang C #. Ito ang pinaka namamayani na pamamaraan ng pag-unlad upang mapanatili ang C # lubos na nasusukat at na-update.

• Balangkas na Wika

Ang diskarte sa Structured Programming ay ginustong sa panahon ng life-cycle ng pag-unlad ng software dahil madali itong mabuo sumulat at maipalawak ang software kumpara sa diskarte sa program na nakatuon sa pamamaraan.

• Mabilis

Ang C # Programming ay nangyayari na mas mabilis sa pag-ipon at pagpapatupad kumpara sa C ++ at iba pang mga wika sa pagprograma.

Pag-install

Napatunayan na Microsoft Visual Studio ay ang pinakamahusay sa klase Editor para sa C # Programming. Kami ay mag-install at Magse-set up ng Microsoft Visual Studio para sa pagpapatupad ng aming C # Programs sa pamamagitan ng pagsunod sa mga hakbang na nabanggit sa ibaba:

Hakbang 1 : I-download ang Microsoft Visual Studio

Google para sa pinakabagong bersyon ng Visual Studio at i-download ang i-install file sa iyong lokal na system at pagkatapos tumakbo ang file ng installer bilang isang tagapangasiwa.

Hakbang 2: Piliin ang .NET Desktop Development Package

Sa sandaling patakbuhin mo ang Installer, matagumpay na mai-download ang Visual Studio Editor sa iyong lokal na system, Mamaya isang kahon ng dayalogo ang ipapakita sa iyong desktop screen na humihiling sa isang kalaban partikular na package kailangan mo sa iyong system. Dito, kailangan mong piliin ang .NET Pag-unlad ng Desktop pakete

Hakbang 3: Itakda ang C # Kapaligiran

Kapag ang iyong mga pakete para sa .NET Development na-download, pagkatapos ay isa pang kahon ng dayalogo ang ipapakita sa iyong screen na humihiling para sa kapaligiran sa pag-unlad na iyong hinahanap. Narito, kailangan mo piliin ang kapaligiran para sa C #.

Hakbang 4: Lumikha ng iyong Unang Proyekto

Kapag ang kapaligiran ay naitakda, lahat ka ng mabuti upang pumunta. Simulan ang iyong Visual Studio at piliin lumikha ng bagong proyekto pagpipilian sa ipinakitang kahon ng dayalogo.

Ire-redirect ka sa susunod na kahon ng dayalogo at doon kailangan mong piliin ang Library ng klase bilang . Pamantayang NET tulad ng ipinakita sa ibaba.

Sa susunod na kahon ng dayalogo, hihilingin sa iyo I-configure ang iyong proyekto . I-configure ito at nasa Editor ka na ngayon. Isulat ang iyong unang programa at tumakbo ito Ang output ay matagumpay na maipakita sa Command Prompt.

gamit ang System class Edureka {static void Main (string [] args) {Console.WriteLine ('Maligayang Pagdating sa Edureka !, Maligayang Pag-aaral ..!')}}

// Output:

Ipatupad natin ang aming unang C # Program.

C # Istraktura ng Programa

Ngayon na naisagawa na namin ang aming unang C # Program, ipaalam sa amin na maunawaan ang istraktura nito nang detalyado. Ang isang simpleng programa ng C # ay may mga sumusunod na bahagi.

gamit ang System namespace ConsoleApplication1 {public class Edureka {public static void Main (string [] args) {Console.WriteLine ('Maligayang Pagdating sa Edureka !, Maligayang Pag-aaral ..!')}}}

// Output:

Maligayang Pagdating sa Edureka !, Maligayang Pag-aaral ..!

• klase: klase ay maaaring sa pangkalahatan ay tinukoy bilang isang keyword ginagamit iyon upang tukuyin ang isang klase sa C # Program.
• Edureka: Ito ang pangalan ng Klase. Ang klase ay madalas na isinasaalang-alang bilang isang blueprint na nag-iimbak ng mga kasapi at pamamaraan na nauugnay sa klase.
• Pangunahing: Karaniwan ay ang pangunahing pamamaraan ng buong C # Program, Gumaganap ito bilang gateway para sa kontrol na ipasok ang programa. Ito ay naisasagawa bago ang anumang iba pang pamamaraan ng programa ay naisakatuparan.
• walang bisa: Ang segment na ito ng code ay itinalaga sa uri ng pagbabalik ng pamamaraan. Maaari itong maging anumang Datatype maliban sa walang bisa. Ibig sabihin ng walang bisa ang pamamaraan ay walang anumang data na nababalik mula rito.
• static: Ito ay keyword na nagsasabing ang mga kasapi ng data na idineklara ay static at isang nakalaang memorya ay inilalaan sa mga idineklarang myembro.
• String [] args: Ito ay kahawig ng mga argumento ng linya ng utos na ginagamit namin sa aming programa. Habang isinasagawa namin ang aming programa, karaniwang pumasa kami sa ilan mga pagtatalo, na tatanggapin ng programa dahil sa pahayag na ito.
• System.Console.WriteLine ('Maligayang Pagdating sa Edureka !, Maligayang Pag-aaral ..!') Dito, Sistema ay ang namespace. Ang consoleyun bang kategorya ang nakabalangkassa namespace ng system. Ang Isulat ang Linya () yan ba angstaticdiskartengng Consolekategorya na nagtatrabaho upang magsulatang teksto sa console.

Ngayon, alamin natin ang mga Datatyp na magagamit sa C #.

Uri ng data

Ang mga datatypes sa C # ay nahahati sa tatlong mga kategorya ay inilarawan sa ibaba.

Mga Datatyp na Halaga

Ang Mga Datatyp na Halaga ay matatagpuan sa System.ValueType Library at palaging handa na direktang ma-access at ang mga variable ay maaaring direktang italaga sa isang partikular na halaga. Ang Mga Datatyp na Halaga ay karagdagang naiuri sa dalawang uri tulad ng ipinakita sa ibaba:

• Mga Paunang Natukoy na Datatypes
• Mga Datatyp na tinukoy ng gumagamit

Mga Paunang Natukoy na Datatypes: Ito ang mga karaniwang ginagamit natin sa aming pang-araw-araw na pag-program. Ang mga Datatypes na ito ay paunang natukoy ng mga tagabuo ng wika at pinananatiling handa na gamitin para sa mga programmer.

Halimbawa:

int, float, char, maikling dobleng, atbp

Mga Datatyp na Tinukoy ng Gumagamit: Mayroong mga sitwasyon kung saan maaaring kailanganin nating mag-imbak ng iba't ibang mga halaga mula sa Mga Datatypes sa isang solong variable. Sa mga kasong ito, ang Mga Paunang Natukoy na Datatypes hindi lang sapat. Natukoy ng Gumagamit Ang mga Datatyp ay tulad ng napapasadyang mga datatyp para sa gumagamit.

Halimbawa: Istraktura, Enum

Pointer Datatype

Ang Uri ng Pointer ay isang simpleng datatype. Ang pag-andar nito ay ganap na katulad ng mga Turo sa C. Ang mga ito ay dinisenyo upang iimbak ang address ng isa pang pointer.

float * ptr

Mga Datatyp na Sanggunian

Ang pangalan ay nagpapaliwanag sa sarili. Ang Mga Datatyp na Sanggunian talagang hindi iniimbak ang mga variable, sa halip, iniimbak nila ang sangguniang halaga sa partikular na variable na iyon. Sa madaling salita, iniimbak nila ang address ng aktwal na variable.

Ang Mga Variable ng Sanggunian ay inuri sa tatlong magkakaibang uri tulad ng nabanggit sa ibaba:

• Uri ng object

Ang Object Datatype ay magagamit sa System.Object Klase.Ang bagaymga uriay maaaring magingnakatalaga sahalaga ngang iba pang mga uri,sanggunianmga uri, paunang natukoy, tinukoy ng gumagamitmga uri. Ngunit, datitakdang-aralinhalaga, kailangan nito uri pagbabalik-loob

object abc abc = 50 // tinatawag itong boxing

• Dynamic na Uri

Ang mga variable ng Dynamic na Uri ay idinisenyo upang mag-imbak ng halos lahat ng uri ng mga halaga. Tinawag ito bilang Dynamic Type dahil ang pag-check-type ng mga halaga ay nagaganap sa run-time

pabago-bago x = 10

• Uri ng String

Magagamit ang Uri ng String sa System.String klase Ang Uri ng String ay dinisenyo upang mag-imbak ng mga string literal. Ang mga String Literal ay nakaimbak sa dalawang anyo sadalawang anyo

• • sinipi
  • @quoted.

String S = 'Edureka'

• Ang @quoted string literal na kamukha

@ 'Edureka'

Ngayon ipaalam sa amin na maunawaan ang mga variable.

Mga variable

Ang mga variable ay ang mga pangalan na inilaan para sa lokasyon ng memorya na nag-iimbak ng ilang data na ibinigay ng gumagamit at ang data na madaling ma-access sa pamamagitan ng paggamit ng variable na pangalan. Mayroong limang uri ng mga variable na magagamit sa C #

Halimbawa:

int a, b doble x float p char abc

Mga sinusunod na panuntunan upang ideklara ang mga variable sa C #

• Ang isang variable ay maaaring magsama ng mga alpabeto, digit at underscore.
• Ang isang variable na pangalan ay maaari lamang magsimula sa isang alpabeto o isang underscore lamang.
• Ang mga variable ay hindi maaaring magsimula sa isang digit o espesyal na karakter.
• Hindi pinapayagan ang mga puting puwang sa pagitan ng variable na pangalan.
• Ang mga nakareserba na keyword ay pinaghihigpitan mula sa paggamit bilang mga variable na pangalan.

Mga Operator

Ang isang Operator ay maaaring tukuyin bilang isang espesyal na simbolo na nagpapaliwanag sa computer upang maisagawa ang isang partikular na Matematika ay isang Lohikal na Operasyon sa isang hanay ng mga variable. Kasama sa C # ang iba't ibang mga Operator na nabanggit sa ibaba.

• Mga Operator ng Arithmetic
• Mga kaugnay na Operator
• Mga Lohikal na Operator
• Mga Bitwise Operator
• Mga Operator ng Asignatura

Mga Operator ng Arithmetic

Mga kaugnay na Operator

Mga Lohikal na Operator

Mga Bitwise Operator

Mga Operator ng Asignatura

Mga loop

SA loop ginamit ang pahayag para sa pagpapatupad ng isang bloke ng mga pahayag nang paulit-ulit hanggang sa nasiyahan ang isang partikular na kondisyon. Ang C # Wika ay binubuo ng mga sumusunod na Mga Pahayag ng Loop.

• Para sa Loop
• Habang Loop
• Gawin Habang Loop

Para sa Loop

Ang para sa loop ay ginagamit upang magpatupad ng isang partikular na segment ng code sa maraming beses hanggang sa nasiyahan ang ibinigay na kundisyon.

Syntax

para sa (pagsisimula ng kalagayan sa pagpapasimula / pagbawas) {// segment ng code}

Tsart ng Flow:

Halimbawa:

gamit ang System public class na ForExample {public static void Main (string [] args) {para sa (int i = 1 i<= 5 i++) { Console.WriteLine(i) } } } 

// Output:

isa
2
3
4
5

Habang Loop

Ang Habang loop ay ginagamit upang magpatupad ng isang segment ng code para sa maraming mga beses hanggang sa nasiyahan ang isang tukoy na kundisyon.

Syntax

habang (kondisyon) {// code na naisakatuparan}

Tsart ng Flow:

Halimbawa:

gamit ang System namespace Loops {class Program {static void Main (string [] args) {int x = 5 habang (x<= 10) { Console.WriteLine('The value of a: {0}', x) x++ } Console.ReadLine() } } } 

// Output:

Ang halaga ng isang: 5
Ang halaga ng isang: 6
Ang halaga ng isang: 7
Ang halaga ng isang: 8
Ang halaga ng isang: 9
Ang halaga ng isang: 10

Gawin Habang Loop

Gawin habang ang loop ay ganap na katulad ng Habang Loop ngunit ang pagkakaiba lamang ay ang kondisyon ay nakalagay sa dulo ng loop. Samakatuwid, ang loop ay naisagawa nang hindi bababa sa isang beses.

Syntax

gawin ang {// code upang maipatupad} habang (kondisyon)

Tsart ng Flow:

Halimbawa:

gumagamit ng namespace ng system Edureka {class DoWhileLoop {public static void Main (string [] args) {int i = 1, n = 5, product do {product = n * i Console.WriteLine ('{0} * {1} = { 2} ', n, i, produkto) i ++} habang (i<= 10) } } } 

// Output:

5 * 1 = 5
5 * 2 = 10
5 * 3 = 15
5 * 4 = 20
5 * 5 = 25
5 * 6 = 30
5 * 7 = 35
5 * 8 = 40
5 * 9 = 45
5 * 10 = 50

Kundisyon

Mga kondisyon na pahayag ay ginagamit upang magpatupad pahayag o pangkat ng pahayag batay sa ilang kundisyon. Kung ang kalagayan totoo noon C # pahayag ay naisakatuparan kung hindi man sa susunod pahayag ay papatayin.

Ang iba't ibang mga uri ng Mga Pahayag na Kondisyon sa Wika ng C ++ ay ang mga sumusunod:

1. Kung pahayag
2. Kung-Iba pang pahayag
3. Salot sa pahayag na Kung-iba pa
4. Kung-Iba Kung hagdan
5. Lumipat ng pahayag

Kung pahayag

Ang nag-iisang kung ang pahayag sa wikang C # ay ginagamit upang maisagawa ang code kung ang isang kondisyon ay totoo. Tinatawag din itong one-way na pahayag ng pagpili.

Syntax

kung (boolean-expression) {// mga pahayag na naisakatuparan kung ang boolean-expression ay totoo}

Tsart ng Flow:

Halimbawa:

gamit ang System namespace Conditional {class IfStatement {public static void Main (string [] args) {int number = 2 if (number<5) { Console.WriteLine('{0} is less than 5', number) } Console.WriteLine('This statement is always executed.') } } } 

// Output:

Ang 2 ay mas mababa sa 5
Ang pahayag na ito ay laging naisakatuparan.

Kung-Iba pang pahayag

Ang kung hindi ang pahayag sa wikang C ay ginagamit upang maisagawa ang code kung ang kondisyon ay totoo o hindi. Tinatawag din itong two-way na pahayag ng pagpili.

Syntax

kung (boolean-expression) {// mga pahayag na naisakatuparan kung ang boolean-expression ay totoo} iba pa {// mga pahayag na naisakatuparan kung ang boolean-expression ay hindi totoo}

Tsart ng Flow:

Halimbawa:

gamit ang System namespace Conditional {class IfElseStatement {public static void Main (string [] args) {int number = 12 if (number<5) { Console.WriteLine('{0} is less than 5', number) } else { Console.WriteLine('{0} is greater than or equal to 5', number) } Console.WriteLine('This statement is always executed.') } } } 

// Output:

12 ay mas malaki sa o katumbas ng 5
Ang pahayag na ito ay laging naisakatuparan.

Salot sa pahayag na Kung-iba pa

Ang pugad kung hindi ginamit ang pahayag kapag ang isang programa ay nangangailangan ng higit sa isang pagpapahayag ng pagsubok. Tinatawag din itong isang multi-way na pahayag ng pagpili. Kapag ang isang serye ng desisyon ay kasangkot sa isang pahayag, ginagamit namin kung hindi pahayag sa pugad na form.

Syntax

kung (boolean-expression) {kung (nested-expression-1) {// code na naisakatuparan} iba pa {// code na naisakatuparan}} iba pa {kung (nested-expression-2) {// na code na naisakatuparan } iba pa {// code na naisakatuparan}}

Tsart ng Flow:

Halimbawa:

gamit ang System namespace Conditional {class Nested {public static void Main (string [] args) {int first = 7, second = -23, third = 13 if (first & gt second) {if (first
 // Output: 
13 ang pinakamalaki
 Iba pa-kung Hagdan 
Ang  kung-sino pa-kung  ginamit ang pahayag upang magpatupad ng isang code mula sa maraming mga kundisyon. Tinatawag din itong pahayag sa multipath decision. Ito ay isang tanikala ng kung..else mga pahayag kung saan ang bawat kung pahayag ay naiugnay sa iba kung ang pahayag at ang huli ay magiging ibang pahayag.
 Syntax 
kung (condition1) {// code na naisakatuparan kung ang condition1 ay totoo} iba pa kung (condition2) {// code na naisakatuparan kung ang kondisyon2 ay totoo} iba pa kung (condition3) {// code na naisakatuparan kung ang condition3 ay totoo} ... iba pa {// code na naisakatuparan kung ang lahat ng mga kundisyon ay hindi tama}
 Tsart ng Flow: 
 Halimbawa: 
gamit ang System class Edureka {public static void Main (String [] args) {int i = 20 if (i == 10) Console.WriteLine ('i is 10') else if (i == 15) Console.WriteLine (' ako ay 15 ') iba pa kung (i == 20) Console.WriteLine (' ako ay 20 ') iba pa Console.WriteLine (' wala ako ')}}
 // Output: 
ako ay 20
 Lumipat ng pahayag 
 Lumipat  ang pahayag ay gumaganap bilang isang kapalit ng isang mahaba kung-kung-kung hagdan na ginagamit upang subukan ang isang listahan ng mga kaso. Naglalaman ang isang switch statement ng isa o higit pang mga label ng kaso na nasubok laban sa expression ng switch. Kapag ang expression ay tumutugma sa isang kaso kung gayon ang mga nauugnay na pahayag sa kasong iyon ay naisakatuparan.
 Syntax 
switch (variable / expression) {case value1: // Mga pahayag na naisakatuparan kung expression (o variable) = value1 break case halaga2: // Mga pahayag na naisagawa kung expression (o variable) = value1 break ... ... ... .. . ... ... default: // Mga pahayag na naisakatuparan kung walang kaso na tumutugma}
 Tsart ng Flow: 
 Halimbawa: 
gamit ang System namespace Conditional {class SwitchCase {public static void Main (string [] args) {char ch Console.WriteLine ('Enter an alphabet') ch = Convert.ToChar (Console.ReadLine ()) switch (Char.ToLower (ch )) {case 'a': Console.WriteLine ('Vowel') break case 'e': Console.WriteLine ('Vowel') break case 'i': Console.WriteLine ('Vowel') break case 'o': Ang kaso ng break ng Console.WriteLine ('Vowel') 'u': Ang Console.WriteLine ('Vowel') ay nagbabagong default: Console.WriteLine ('Not a vocel') break}}}}
 // Output: 
Magpasok ng isang alpabeto 
 ay 
 Patinig
 Mga kuwerdas 
 String Ang Datatype ay isang miyembro ng System.String Klase. Ito ay may kakayahang mag-imbak ng uri ng data ng character. Maaari kaming magsagawa ng iba't ibang mga operasyon sa Stings tulad ngpagsasama-sama, paghahambing, pagkuha ng substring, paghahanap, trim, kapalit at marami pa.
 Ang pagkakatulad ng String at string 
Sa C # String at lubid ay katumbas. Ang salitang string ay a keyword at kumikilos bilang ang System.String klase Maaari naming gamitin ang alinman sa mga bersyon upang ideklara ang mga string.
 Syntax: 
string s1 = 'Edureka' // paglikha ng string gamit ang string keyword String s2 = 'Happy Learning' // paglikha ng string gamit ang String class
 Halimbawa: 
gamit ang System public class na StringExample {public static void Main (string [] args) {string s1 = 'Edureka' char [] ch = {'C', 's', 'h', 'a', 'r', ' p ',' ',' T ',' u ',' t ',' o ',' r ',' i ',' a ',' l '} string s2 = bagong string (ch) Console.WriteLine ( s1) Console.WriteLine (s2)}}
 // Output: 
Edureka 
 Tutorial sa Csharp
 Mga Paraan ng String sa C # 
 Pamamaraan 
 Paglalarawan 
 I-clone () 
Ginamit upang ibalik ang isang sanggunian sa pagkakataong ito ng String.
 Paghambingin (String, String) 
Ginamit upang ihambing ang dalawang tinukoy na bagay ng String.
 Concat (String, String) 
Pagsamahin ang dalawang tinukoy na mga pagkakataon ng String.
 Naglalaman ng (String) 
Ibalik ang isang halaga na nagpapahiwatig ng isang tinukoy na sub-string
 Kopyahin (String) 
Ginamit upang lumikha ng isang bagong halimbawa ng String na may parehong halaga
 CopyTo (Int, Char [], Int, Int) 
Kinokopya ang mga character mula sa isang tinukoy na posisyon
 Katumbas (String, String) 
Natutukoy na ang dalawang bagay ng String ay may parehong halaga.
 Format (String, Object) 
Palitan ang isa o higit pang mga item sa format sa isang tinukoy na string
 IndexOf (String) 
Iniuulat ang zero-based index ng unang paglitaw
 Ipasok (Int32, String) 
Nagbabalik ng isang bagong string kung saan ang isang string ay naipasok sa isang index.
 IsInterned (String) 
Ipinapahiwatig na ang string na ito ay nasa form na normalisasyon ng Unicode C.
 IsNullOrEmpty (String) 
Ipinapahiwatig na ang tinukoy na string ay null o isang walang laman na string.
 IsNullOrWhiteSpace (String) 
Ginamit upang ipahiwatig kung ang isang tinukoy na string ay null, walang laman,
 Sumali (String, String []) 
Ginamit upang pagsamahin ang lahat ng mga elemento ng isang string array
 LastIndexOf (Char) 
Iniuulat ang zero-based na posisyon ng index ng huling character
 LastIndexOfAny (Char []) 
Iniuulat ang zero-based na posisyon ng index ng huling character
 Alisin (Int32) 
Nagbabalik ng isang bagong string kung saan lahat ng mga character
 Palitan (String, String) 
Nagbabalik ng isang bagong string kung saan ang lahat ng mga paglitaw ng isang string
 Hatiin (Char []) 
Ginagamit ito upang hatiin ang isang string sa mga substring
 StartsWith (String) 
Ginagamit ito upang suriin kung ang simula ng string na ito
 Substring (Int32) 
Ginagamit ito upang makuha ang isang substring mula sa halimbawang ito.
 ToCharArray () 
Kinokopya ang mga character sa pagkakataong ito sa isang Unicode array.
 ToString () 
Ginagamit ito upang ibalik ang halimbawa ng String.
 Putulin () 
Trims ang string
  
Mga array 
Katulad ng ibang mga wika ng pagprograma, ang C # ay mayroong mga array. Ang mga array ay ang mga simpleng istruktura ng data na idinisenyo upang mag-imbak ng parehong datatype ng mga elemento sa isang magkadikit na lokasyon ng memorya.
Sinusuportahan ng C # ang mga sumusunod na uri ng Array.
Single Dimensional Array
Multidimensional Array
Jagged Array
 Single Dimensional Array 
Nag-iimbak ang Single Dimensional Array ng mga elemento sa anyo ng isang solong hilera.
 Syntax 
int [] arr = bagong int [5] // lumilikha ng array
 Halimbawa: 
gamit ang System public class ArrayExample {public static void Main (string [] args) {int [] arr = new int [5] arr [0] = 10 arr [1] = 20 arr [2] = 30 arr [3] = 40 arr [4] = 50 para sa (int i = 0 i 
 // Output: 
10 
 dalawampu 
 30 
 40 
 limampu
 Multidimensional Array 
Nag-iimbak ang Multidimensional Array ng mga elemento sa anyo ng maraming sukat tulad ng isang matrix at isang cube atbp.
 Syntax 
int val = a [2,3]
 Halimbawa: 
gamit ang System namespace ArrayApplication {class MyArray {static void Main (string [] args) {int [,] a = new int [5, 2] {{0, 0}, {1, 2}, {2, 4}, {3, 6}, {4, 8}} int i, j para sa (i = 0 i<5 i++) { for (j = 0 j < 2 j++) { Console.WriteLine('a[{0},{1}] = {2}', i, j, a[i, j]) } } Console.ReadKey() } } } 
 // Output: 
isang [0,0] = 0 
 isang [0,1] = 0 
 isang [1,0] = 1 
 isang [1,1] = 2 
 isang [2,0] = 2 
 isang [2,1] = 4 
 isang [3,0] = 3 
 isang [3,1] = 6 
 isang [4,0] = 4 
 isang [4,1] = 8
  
 Jagged Array 
Ang Jagged Array ay simpleng isang array ng arrays.
 Halimbawa: 
gamit ang System namespace ArrayApplication {class MyArray {static void Main (string [] args) {int [] [] a = new int [] [] {new int [] {0,0}, bagong int [] {1,2 }, bagong int [] {2,4}, bagong int [] {3, 6}, bagong int [] {4, 8}} int i, j para sa (i = 0 i<5 i++) { for (j = 0 j < 2 j++) { Console.WriteLine('a[{0}][{1}] = {2}', i, j, a[i][j]) } } Console.ReadKey() } } } 
 // Output: 
isang [0] [0] = 0 
 isang [0] [1] = 0 
 isang [1] [0] = 1 
 isang [1] [1] = 2 
 isang [2] [0] = 2 
 isang [2] [1] = 4 
 isang [3] [0] = 3 
 isang [3] [1] = 6 
 isang [4] [0] = 4 
 isang [4] [1] = 8
 Mga Koleksyon 
Ang koleksyon ay maaaring isaalang-alang lamang bilang isang pangkat ng mga bagay na nakolekta nang magkasama upang mailapat ang ilang mga pagpapaandar sa nakolektang data. Ang mga pagpapatakbo na maaaring gumanap sa isang koleksyon ay,
bagay sa tindahan
i-update ang object
tanggalin ang bagay
kunin ang bagay
object sa paghahanap, at
pag-uuri ng bagay
 Mga Uri ng Koleksyon 
Mayroong tatlong magkakaibang mga posibilidad upang gumana sa mga koleksyon. Ang tatlong namespaces ay nabanggit sa ibaba:
 System.Collection.Generic  mga klase
 Sistema. Mga koleksyon  mga klase
 Sistema. Mga Koleksyon. Magkasabay  mga klase
Ang System.Collection. Ang Generic Class ay may mga sumusunod na pagkakaiba-iba ng mga klase:
Listahan
Stack
Pila
LinkedList
HashSet
Pinagbukud-bukurin
Diksyonaryo
Nakahiwalay na pagsasalarawan
Naayos na Listahan
Ang Sistema. Mga koleksyon ang mga klase ay itinuturing na mga klase sa pamana. isinasama nila ang mga sumusunod na klase.
Listahan ng Array
Stack
Pila
Hashtable
Ang Sistema. Mga Koleksyon. Magkasabay  mga klaseAng namespace ay nagbibigay ng mga klase para sa mga ligtas na pagpapatakbo ng thread. Ngayon maraming mga thread ay hindi lilikha ng isang problema para sa pag-access sa mga item sa koleksyon. ang mga klase na magagamit dito ay,
BlockingCollection
KasabayBag
Kasabay na Stack
Kasabay na Quueue
KasabayDictional
Mga partisyon
Mga partisyon
OrderablePartitioner
 Listahan 
Ang listahan ay isinasaalang-alang bilang isang istraktura ng data na magagamit sa System.Collection.Generics namespace. Maaari itong mag-imbak at kumuha ng mga elemento. Ang listahan ay may kakayahang mag-imbak ng mga duplicate na elemento.
 Halimbawa: 
gamit ang System using System.Collections.Generic public class Edureka {public static void Main (string [] args) {var names = new List () names.Add ('Sandhya') names.Add ('Arun') names.Add ( Mga pangalan na 'Prashanth'). Idagdag ('Kiran') na paunahin (pangalan ng var sa mga pangalan) {Console.WriteLine (pangalan)}}}
 // Output: 
Sandhya 
 Arun 
 Prashanth 
 Kiran
 Itakda ang Hash 
C # HashSetkategorya ay madalas na bihasatindahan,ilayo moobasahin ang mga sangkap. Itohindimag-imbak ng duplicatemga sangkap.hinihimok itogamitin HashSet  kategoryakungmayroon kangsa tindahannag-iisa lang  natatangi   mga sangkap . ito ay matatagpuan sa System.Collection. Generic namespace.
 Halimbawa: 
gamit ang System using System.Collections.Generic public class Edureka {public static void Main (string [] args) {var names = new HashSet () names.Add ('Sunil') names.Add ('Amar') names.Add ( Mga pangalan na 'Pujari'). Magdagdag ng ('Imran') mga pangalan. Idagdag ('karan') na paunahin (pangalan ng var sa mga pangalan) {Console.WriteLine (pangalan)}}}
 // Output: 
Sunil 
 Amar 
 Pujari 
 Imran 
 karan
 Naayos na Hanay 
C # SortadongSetmadalas sanay ang klasetindahan, tanggalin o basahin   mga elemento . Pinapanatili nito ang pataas na kaayusan athindimag-imbak ng duplicatemga elemento.ito ay mabilisupang magamit ang SortSetkategoryakungmayroon kangsa tindahan natatangi   mga sangkap at mapanatili ang pataas na kaayusan.ito aymatatagpuan sa System.Collection. Generic namespace.
 Halimbawa: 
gamit ang System using System.Collections.Generic public class Edureka {public static void Main (string [] args) {var names = new SortsSet () names.Add ('Sanjay') names.Add ('Anuradha') names.Add ( Mga pangalan ng 'Praveen'). Idagdag ang mga pangalan na '' Ravi '). Idagdag (' Kajol ') na pauna (pangalan ng var sa mga pangalan) {Console.WriteLine (pangalan)}}}
 // Output: 
Anuradha 
 Kajol 
 Praveen 
 Si Ravi 
 Sanjay
 Stack 
Ang salansan ay isang simpleng koleksyon na sumusunod EDGE o una sa huling pamamaraan habang pinoproseso ang mga elemento na nakaimbak dito.
 Halimbawa: 
gamit ang System using System.Collections.Generic public class Edureka {public static void Main (string [] args) {Stack names = new Stack () names.Push ('Chandan') names.Push ('Pooja') names.Push ( Mga pangalan na 'James'). Mga pangalan ng Push ('Rajesh'). Push ('kumar') frontach (pangalan ng string sa mga pangalan) {Console.WriteLine (pangalan)} Console.WriteLine ('Peek element:' + names.Peek () ) Console.WriteLine ('Pop:' + names.Pop ()) Console.WriteLine ('After Pop, Peek element:' + names.Peek ())}}
 // Output: 
kumar 
 Rajesh 
 James 
 Pooja 
 Chandan 
 Elementong sumilip: kumar 
 Pop: kumar 
 Pagkatapos ng Pop, Peek element: Rajesh
 Pila 
Ang pila ay ganap na katulad sa Stack ngunit ang pagkakaiba lamang ay ang sumusunod na pila FIFO o una sa at unang prinsipyo habang pinoproseso ang mga elemento na nakaimbak dito.
 Halimbawa: 
gamit ang System using System.Collections.Generic public class Edureka {public static void Main (string [] args) {Mga pangalan ng pila = bagong mga pangalan ng Queue (). Mga pangalan ng Enqueue ('Srujan'). Mga pangalan ng Enqueue ('Prajat'). Ennueue ( Mga pangalan na 'John'). Mga ennteue ('Raju') na pangalan. Ennueue ('Hari') na paunahan (pangalan ng string sa mga pangalan) {Console.WriteLine (pangalan)} Console.WriteLine ('Elementong sumilip:' + mga pangalan. Humingi ng () ) Console.WriteLine ('Dequeue:' + names.Dequeue ()) Console.WriteLine ('After Dequeue, Peek element:' + names.Peek ())}}
 // Output: 
Srujan 
 Prajat 
 John 
 Mabangis 
 Araw 
 Elementong sumilip: Srujan 
 Dequeue: Srujan 
 Pagkatapos ng Dequeue, Peek element: Prajat
 Listahan ng naka-link 
Ang naka-link na listahan ay isang koleksyon ng pabuong memorya. Ang mga elemento sa listahan ng Naka-link ay nakaimbak sa pamamagitan ng pag-access sa memorya mula sa tambak at pag-iimbak ng mga elemento sa isang tuloy-tuloy na pagkakasunud-sunod sa pamamagitan ng pag-link ng kanilang mga address.
i-convert ang decimal sa binary python
 Halimbawa: 
gamit ang System using System.Collections.Generic public class Edureka {public static void Main (string [] args) {var names = new LinkedList () names.AddLast ('Rajat') names.AddLast ('Arun') names.AddLast ( Mga pangalan ng 'Prakash') .AddLast ('jay') mga pangalan. AddFirst ('sai') maaga (var name in names) {Console.WriteLine (name)}}}
 // Output: 
sai 
 Mga hangganan 
 Arun 
 Prakash 
 jay
 Diksyonaryo 
 Diksyonaryo  kategoryaginagamit angideang nai-tweet. Nag-iimbak ito ng mga halagasaliganng susi. Naglalaman itonatatangimga susinag-iisa lang. Niang tulongng susi,gagawin namin nang simplemaghanap oalisin ang mga elemento.ito aymatatagpuan sa System.Collection. Generic namespace.
 Halimbawa: 
gamit ang System using System.Collections.Generic public class Edureka {public static void Main (string [] args) {Mga pangalan ng diksyonaryo = bagong mga pangalan ng Diksyonaryo () mga pangalan. Idagdag ('1', 'Shiva') mga pangalan. Idagdag ('2', Mga pangalan ng 'Prasad'). Magdagdag ng ('3', 'Preetam') mga pangalan. Idagdag ('4', 'Roy') mga pangalan. Idagdag ('5', 'Akash') na paunahin (KeyValuePair kv sa mga pangalan) {Console. WritingLine (kv.Key + '' + kv.Value)}}}
 // Output: 
1 Shiva 
 2 Prasad 
 3 Preetam 
 4 Roy 
 5Akash
 Pinagbukud-bukod Diksiyonaryo 
Ang Nakahiwalay na pagsasalarawan  kategoryaginagamit angdisenyong nai-tweet. Nag-iimbak ito ng mga halagaang ideyang susi. Naglalaman itonatatangisusi at pinapanatili ang pataas na kaayusan saang ideyang susi. Niang tulongng susi,gagawin namin nang simplemaghanap oalisin ang mga elemento.ito aymatatagpuan sa System.Collection. Generic namespace.
 Halimbawa: 
gamit ang System using System.Collections.Generic public class Edureka {public static void Main (string [] args) {SortDictionary names = new SortDictionary () names.Add ('1', 'Arun') names.Add ('4', Mga pangalan ng 'Vishal'). Magdagdag ng ('5', 'Ramesh') mga pangalan. Idagdag ('3', 'Vidya') mga pangalan. Idagdag ('2', 'Pallavi') na pauna (KeyValuePair kv sa mga pangalan) {Console. WritingLine (kv.Key + '' + kv.Value)}}}
 // Output: 
1 Shiva 
 2 Prasad 
 3 Preetam 
 4 Roy 
 5Akash
 Inayos na Listahan 
Ang Naayos na Listahan ayisanghanay ng mga pares ng key / halaga. Nag-iimbak ito ng mga halagasaliganng susi. Ang Inayos na Listahankategoryanaglalaman ngnatatangisusi at pinapanatili ang pataas na kaayusan sasaliganng susi. Niang tulongng susi,nagagawa naming simplemaghanap o magtanggalmga elemento.ito aymatatagpuan sa System.Collection.Generic namespace.
 Halimbawa: 
gamit ang System using System.Collections.Generic public class Edureka {public static void Main (string [] args) {SortDictionary names = new SortDictionary () names.Add ('1', 'Arun') names.Add ('4', Mga pangalan ng 'Vishal'). Magdagdag ng ('5', 'Ramesh') mga pangalan. Idagdag ('3', 'Vidya') mga pangalan. Idagdag ('2', 'Pallavi') na pauna (KeyValuePair kv sa mga pangalan) {Console. WritingLine (kv.Key + '' + kv.Value)}}}
 // Output: 
1 Arun 
 2 Pallavi 
 3 Vidya 
 4 Vishal 
 5Ramesh
 Istraktura 
Ang istraktura ay isang datatype na tinukoy ng gumagamit na idinisenyo upang mag-imbak ng maraming mga elemento ng iba't ibang mga datatype. Ang istraktura ay idineklara gamit ang keyword istruktura 
 Halimbawa: 
gamit ang System struktura ng Libro {pamagat ng string ng pampubliko string may-akda pampubliko string paksa pampubliko int book_id} pampublikong klase Edureka {public static void Main (string [] args) {Books Book1 Books Book2 Book1.title = 'C # Programming' Book1.author = ' Ramchandra Kumar 'Book1.subject =' C ++ Programming Tutorial 'Book1.book_id = 95908978 Book2.title =' Telecom Billing 'Book2.author =' Karan 'Book2.subject =' Telecom Billing Tutorial 'Book2.book_id = 18674900 Console.WriteLine ( 'Pamagat ng Book 1: {0}', Book1.title) Console.WriteLine ('May-akda ng Book 1: {0}', Book1.author) Console.WriteLine ('Paksa ng Book 1: {0}', Book1.subject) Console.WriteLine ('Book 1 book_id: {0}', Book1.book_id) Console.WriteLine (pamagat na 'Book 2: {0}', Book2.title) Console.WriteLine ('May-akda ng 2 Libro: {0}', Book2.author) Console.WriteLine ('Paksa ng Aklat 2: {0}', Book2.subject) Console.WriteLine ('Book 2 book_id: {0}', Book2.book_id) Console.ReadKey ()}}
 // Output: 
Pamagat ng Book 1: Programming sa C # 
 Book 1 May-akda: Ramchandra Kumar 
 Paksa ng Book 1: Tutorial sa Programming C ++ 
 Book 1 book_id: 95908978 
 Pamagat ng Book 2: Pagsingil sa Telecom 
 Book 2 May-akda: Karan 
 Paksa ng Book 2: Tutorial sa Pagsingil ng Telecom 
 Book 2 book_id: 18674900
 Mga pagpapaandar 
Ang pagpapaandar ay tinukoy bilang isang bloke ng code ng pangunahing code. Ginagamit ang pagpapaandar upang maipatupad ang mga pahayag na tinukoy sa code block. Ang isang pagpapaandar ay binubuo ng mga sumusunod na sangkap.
 Pangalan ng pagpapaandar:  Ito ay isang natatanging pangalan na ginagamit upang tumawag sa isang Pag-andar.
 Uri ng pagbalik:  Tinutukoy nito ang uri ng data ng halaga ng pagbalik ng pag-andar.
 Katawan:  Naglalaman ito ng maipapatupad na mga pahayag.
 Access specifier:  Tinutukoy nito ang pag-access sa pag-andar sa application.
 Mga Parameter:  Ito ay isang listahan ng mga argumento na maaari naming maipasa sa pagpapaandar sa panahon ng tawag.
 Syntax 
FunctionName () {// function body // return statement}
 Halimbawa: 
gamit ang namespace ng System FunctionExample {class Edureka {public string Show (string message) {Console.WriteLine ('Inside Show Function') return message} static void Main (string [] args) {Edureka program = new Edureka () string message = program . Ipakita ('To Edureka') Console.WriteLine ('Maligayang pagdating' + mensahe)}}}
 // Output: 
Inside Show Function 
 Maligayang Pagdating Sa Edureka
Ang mga pagpapaandar ay maaaring maipatupad sa 3 magkakaibang paraan:
Tumawag ayon sa Halaga
Tumawag sa pamamagitan ng Sanggunian
Out Parameter
 Tumawag ayon sa Halaga 
Sa C #, halaga  -type mga parameteraypumasa yanisang kopyang orihinal na halaga sagumana sa halip nasanggunian Itohindibaguhinang unang halaga. Isangnilikha ang susogsa nakapasaang halaga ay hindiEdadang partikular na halaga.sa loob ngsumusunod na halimbawa,mayroon kamingpumasahalaga sa buongangtawagan
 Halimbawa: 
gamit ang System namespace CallByValue {class Edureka {public void Show (int val) {val * = val Console.WriteLine ('Ang halaga sa loob ng show function' + val)} static void Main (string [] args) {int val = 50 Edureka program = bagong Edureka () Console.WriteLine ('Halaga bago tawagan ang pagpapaandar' + val) na programa. Ipakita ang (val) Console.WriteLine ('Halaga pagkatapos tawagan ang pagpapaandar' + val)}}}
// Output:
Halaga bago tawagan ang pagpapaandar 50 
 Ang halaga sa loob ng palabas na pagpapaandar 2500 
 Halaga pagkatapos tawagan ang pagpapaandar 50
 Tumawag sa pamamagitan ng Sanggunian 
Sa paraan ng Pagtawag sa pamamagitan ng Sanggunian,sa ref keyword upang maipasa ang argumento bilang uri ng sanggunian. Ipinapasa nito ang sanggunian ng mga argumento sa pagpapaandar sa halip na isang kopya ng orihinal na halaga. Ang mga pagbabago sa naipasa na halaga ay permanente at baguhin ang orihinal na halaga ng variable.
 Halimbawa: 
gamit ang System namespace CallByReferensyo {class Edureka {public void Show (ref int val) {val * = val Console.WriteLine ('Ang halaga sa loob ng show function' + val)} static void Main (string [] args) {int val = 50 Edureka program = bagong Edureka () Console.WriteLine ('Halaga bago tawagan ang pagpapaandar' + val) na programa. Ipakita (ref val) Console.WriteLine ('Halaga pagkatapos tawagan ang pagpapaandar' + val)}}}
// Output:
Halaga bago tawagan ang pagpapaandar 50 
 Ang halaga sa loob ng palabas na pagpapaandar 2500 
 Halaga pagkatapos tumawag sa pagpapaandar 2500
 Out Parameter 
Ang Out Parameternagbibigay palabas ang keyword upang pumasa sa mga argumento bilang out-type. Ito ay tulad ng uri ng sanggunian, maliban na hindi ito nangangailangan ng variable upang simulan bago pumasa. Dapat nating gamitin palabas keyword upang maipasa ang argument bilang out-type. Ito ay kapaki-pakinabang kapag nais namin ang isang pagpapaandar na bumalik sa maraming mga halaga.
 Halimbawa: 
gamit ang System namespace OutParameter {class Edureka {public void Show (out int val) {int square = 5 val = square val * = val} static void Main (string [] args) {int val = 50 Edureka program = new Edureka () Console.WriteLine ('Halaga bago maipasa ang variable' + val) na programa. Ipakita ang (out val) Console.WriteLine ('Halaga pagkatapos matanggap ang out variable' + val)}}}
// Output:
Halaga bago lumipas ang variable 50
Halagapagkatapos matanggap ang out variable 25
Ngayon ay lumipat tayo sa programa na nakatuon sa object
 Programming na Nakatuon sa Bagay 
 Programming na nakatuon sa object Sistemaay isang paradaym sa programa batay sa konsepto ng mga bagay naglalaman iyon mga kasapi ng data at paraan may kaugnayan sa kanila. Ang pangunahing layunin ng object-oriented na programa ay upang madagdagan ang kakayahang umangkop at mapanatili ang mga programa
 Mga tampok ng programa na nakatuon sa object: 
Mas binibigyang diin nito ang data kaysa sa pamamaraan.
Ang mga programa ay nahahati sa mga bagay kaya't ginagawang madali upang gumana.
Ang mga istraktura ng data ay dinisenyo sa isang paraan na nailalarawan nila ang mga object.
Mga pagpapaandar na gumagana saang data ng isang bagay ay nakalagay magkasama sa istraktura ng data.
Ang data ay nakatago at hindi mai-access ng mga panlabas na pag-andar nang walang pahintulot.
Ang komunikasyon sa pagitan ng mga bagay ay maaaring maganap sa tulong ng mga pagpapaandar.
Ang pagdaragdag ng bagong data at mga pagpapaandar ay naging madali.
Sinusundan ang pang-ilalim na diskarte sa disenyo ng programa.
Ang Mga Layunin na Nauugnay sa Bagay sa C # ay ang mga sumusunod
 Enumerasyon sa C # 
 Pag-uugali sa Programming na Nakatuon sa Bagay 
 Encapsulasyon 
 Abstraction 
 Interface 
 Polymorphism 
 Mana 
 Overloading at Overriding 
 Namespace 
 Pagpapatakbo ng File 
 Mga Kaganapan 
 Generics 
 Mga delegado 
 Pagninilay 
 Enumerasyon sa C # 
 Enum o tinatawag din bilang isang bilang ng bilang sa C # ay ginagamit upang mag-imbak ng mga pare-pareho na halaga nang hindi kinakailangang baguhin ito habang buong pagpapatupad ng isang C # Program. Itoay ginagamit upang mag-imbak ng isang hanay ng mga pinangalanang pare-pareho tulad ng panahon, araw, buwan, laki atbp
 Halimbawa: 
gamit ang Sistema ng pampublikong klase na EnumExample {pampublikong enum linggo {Lunes, Martes, Miyerkules, Huwebes, Biyernes, Sabado, Linggo} pampublikong static na walang bisa Main () {int x = (int) linggo. Lunes int y = (int) linggo. Biyernes Console .WriteLine ('Monday = {0}', x) Console.WriteLine ('Friday = {0}', y)}}
 // Output: 
Lunes = 0 
 Biyernes = 4
 Pag-uugali sa Programming na Nakatuon sa Bagay 
Ang istilo ng pag-program na oriented ng Object ay maaaring makamit sa pamamagitan ng pagsunod sa mga pamamaraan na inireseta sa ibaba.
 Encapsulasyon 
  
 Encapsulasyon ay isang pamamaraan upang pagsamahin ang paraan kasama ang kanilang mga kasapi ng data. 
 Halimbawa: 
gamit ang System namespace Edureka {class Rectangle {public double length public double width public double GetArea () {return haba * lapad} public void Display () {Console.WriteLine ('Length: {0}', haba) Console.WriteLine (' Lapad: {0} ', lapad) Console.WriteLine (' Lugar: {0} ', GetArea ())}} klase ExecutRectangle {static void Main (string [] args) {Rectangle r = new Rectangle () r.length = 50 r.width = 35 r. Ipakita () Console.ReadLine ()}}}
 // Output: 
Haba: 50 
 Lapad: 35 
 Lugar: 1750
 Abstraction 
 Abstraction ay isang pamamaraan upang tago ang kumplikadong bahagi ng pag-coding mula sa gumagamit sa pamamagitan ng pagbibigay sa kanya ng kinakailangang impormasyon lamang na kailangan niya.
 Halimbawa: 
gamit ang System public abstract class Hugis {public abstract void draw ()} public class Rectangle: Shape {public override void draw () {Console.WriteLine ('drawing rectangle ...')}} public class Circle: Shape {public override void gumuhit () {Console.WriteLine ('circle circle ...')}} pampublikong klase ng TestAbstract {public static void Main () {Shape ss = new Rectangle () s.draw () s = new Circle () s.draw ()}}
 // Output: 
pagguhit ng parihaba ... 
 pagguhit ng bilog ...
 Interface 
  
Ang interface ay ganap na katulad ng Abstraction. Ang Pag-andar ng isang Interface ay upang itago ang hindi mahalagang data mula sa gumagamit at bigyan siya ng tanging mahalagang data na kailangan niya.
 Halimbawa: 
gamit ang Public interface ng system na Nakaka-draw {void draw ()} pampublikong klase Rectangle: Drawable {public void draw () {Console.WriteLine ('drawing rectangle ...')}} public class Circle: Drawable {public void draw () {Console .WriteLine ('circle circle ...')}} pampublikong klase TestInterface {public static void Main () {Drawable dd = new Rectangle () d.draw () d = new Circle () d.draw ()}}
 // Output: 
pagguhit ng parihaba ... 
 pagguhit ng bilog ...
 Polymorphism 
Polymorphismay ang kombinasyon ng 'Poly' + 'Morphs' na nangangahulugang maraming anyo. Ito ay isang greek na salita. Nangangahulugan ito na ang segment ng code ay maaaring tumagal ng maraming mga form. Mayroon kaming dalawang uri ng Polymorphism.
Compile Time Polymorphism
Run Time Polymorphism
 Halimbawa: 
gamit ang System public class Animal {public string color = 'white'} public class Dog: Animal {public string color = 'black'} public class TestSealed {public static void Main () {Animal d = new Dog () Console.WriteLine ( d.color)}}
 // Output: 
maputi
 Mana 
 Mana ay isang proseso kung saan ang isang bagay ay nakakakuha ng lahat ng mga katangian at pag-uugali ng magulang na bagay na ito na awtomatiko. Maaari mong magamit muli, palawakin o baguhin ang mga katangian at pag-uugali na tinukoy sa ibang klase. ang klase na nagmamana ng mga kasapi ng ibang klase ay tinawag nagmula sa klase at ang klase na ang mga kasapi ay minana ay tinawag na base klase Ang nagmula sa klase ay ang dalubhasang klase para sa batayang klase.
 Halimbawa para sa Single Level Mana 
gamit ang Sistema ng namespace RectangleApplication {class Rectangle {protektado ng doble haba na protektado ng doble na lapad ng publiko Rectangle (dobleng l, dobleng w) {haba = l lapad = w} pampubliko na doble ng GetArea () {haba ng pagbalik * lapad} publiko na walang bisa na Display () {Console. WritingLine ('Haba: {0}', haba) Console.WriteLine ('Lapad: {0}', lapad) Console.WriteLine ('Area: {0}', GetArea ())}} class Tabletop: Parihaba {pribado dobleng gastos sa publiko Tabletop (dobleng l, dobleng w): base (l, w) {} publikong dobleng GetCost () {dobleng gastos sa gastos = GetArea () * 70 pagbalik sa gastos} pampublikong walang bisa na Display () {base.Display () Console .WriteLine ('Cost: {0}', GetCost ())}} class ExecutRectangle {static void Main (string [] args) {Tabletop t = new Tabletop (4.5, 7.5) t. Ipakita () Console.ReadLine () }}}
 // Output: 
Haba: 4.5 
 Lapad: 7.5 
 Lugar: 33.75 
 Gastos: 2362.5
 Halimbawa ng Multi-Level Na Mana 
gamit ang System namespace InheritanceApplication {class Shape {public void setWidth (int w) {width = w} public void setHeight (int h) {taas = h} protektado int lapad protektado int taas} pampublikong interface PaintCost {int getCost (int area)} class Rectangle: Hugis, PaintCost {public int getArea () {return (lapad * taas)} public int getCost (int area) {return area * 70}} class RectangleTester {static void Main (string [] args) {Rectangle Rect = bagong Rectangle () int area Rect.setWidth (5) Rect.setHeight (7) area = Rect.getArea () Console.WriteLine ('Total area: {0}', Rect.getArea ()) Console.WriteLine ('Total gastos sa pintura: $ {0} ', Rect.getCost (area)) Console.ReadKey ()}}}
 // Output: 
Kabuuang lugar: 35 
 Kabuuang gastos sa pintura: $ 2450
 Labis na karga 
Ang labis na pag-load ay isang sitwasyon kung saan mayroon kaming dalawa o miyembro na idineklara na gumagamit ng parehong pangalan. Posible rin ang labis na pag-load kapag idineklara namin ang dalawa o higit pang mga pamamaraan na may parehong pangalan din. Suriin natin ang mga halimbawa ng pareho.
 Overloading ng Miyembro 
 Halimbawa: 
gamit ang System public class Edureka {public static int add (int a, int b) {return a + b} public static int add (int a, int b, int c) {return a + b + c}} public class TestMemberOverloading { public static void Main () {Console.WriteLine (Edureka.add (12, 23)) Console.WriteLine (Edureka.add (12, 23, 25))}}
 // Output: 
35 
 60
 Pamamaraan ng Overloading 
 Halimbawa: 
gamit ang System public class Edureka {public static int add (int a, int b) {return a + b} public static float add (float a, float b) {return a + b}} public class TestMemberOverloading {public static void Main ( ) {Console.WriteLine (Edureka.add (12, 23)) Console.WriteLine (Edureka.add (12.4f, 21.3f))}}
 // Output: 
35 
 33.699997
 Overriding 
Ang overriding ay isang sitwasyon kung saan ang klase ng bata ay tumutukoy sa parehong pamamaraan na tinutukoy din ng magulang. Unawain natin ito sa pamamagitan ng isang maliit na halimbawa.
 Halimbawa: 
gamit ang System public class Edureka {public virtual void eat () {Console.WriteLine ('Eating')}} public class Dog: Edureka {public override void eat () {Console.WriteLine ('Eating food')}} public class Overriding {public static void Main () {Dog d = new Dog () d.eat ()}}
 // Output: 
Kumakain ng pagkain
 Namespace 
Ang namespace ay karaniwang ginagamit upang hawakan ang maramihang mga klase na naroroon sa programa. Ang namespace ay magagamit sa iba't ibang mga paraan.
 System. Console: Narito, ang Sistema nagiging namespace
Upang ma-access ang klase ng isang namespace, kailangan naming gamitin namespacename.classname. 
Maaari nating gamitin ang gamit keyword din.
 Halimbawa: 
gamit ang System using First using Second namespace First {public class Edureka {public void sayWelcome () {Console.WriteLine ('Welcome To Edureka')}}} namespace Second {public class Happy_Learning {public void sayWishes () {Console.WriteLine (' Maligayang Pag-aaral ')}}} pampublikong klase Namespace {public static void Main () {Edureka h1 = new Edureka () Happy_Learning w1 = new Happy_Learning () h1.sayWelcome () w1.sayWishes ()}}
 // Output: 
Maligayang Pagdating Sa Edureka 
 Maligayang Pag-aaral
 Pagpapatakbo ng File 
Ang pagpapatakbo ng file magagamit sa C # ay ang mga sumusunod:
 Pagpapatakbo 
 Paglalarawan 
 BinaryReader 
Nagbabasa ng primitive data mula sa isang binary stream.
 BinaryWriter 
Nagsusulat ng primitive data sa binary format.
 BufferedStream 
Pansamantalang pag-iimbak para sa isang stream ng bytes.
 Direktoryo 
Mga tulong sa pagmamanipula ng isang istraktura ng direktoryo.
 DirectoryInfo 
Ginamit para sa pagsasagawa ng mga pagpapatakbo sa mga direktoryo.
 DriveInfo 
Nagbibigay ng impormasyon para sa mga drive.
 File 
Mga tulong sa pagmamanipula ng mga file.
 FileInfo 
Ginamit para sa pagsasagawa ng mga pagpapatakbo sa mga file.
 FileStream 
Ginamit upang basahin mula at sumulat sa anumang lokasyon sa isang file.
 MemoryStream 
Ginamit para sa random na pag-access sa nai-stream na data na nakaimbak sa memorya.
 Landas 
Nagsasagawa ng mga operasyon sa impormasyon sa landas.
 StreamReader 
Ginamit para sa pagbabasa ng mga character mula sa isang byte stream.
 StreamWriter 
Ginagamit para sa pagsusulat ng mga character sa isang stream.
 StringReader 
Ginagamit para sa pagbabasa mula sa isang string buffer.
 StringWriter 
Ginagamit para sa pagsusulat sa isang string buffer.
 FileMode 
Ang FileMode ay isang enumerator na tumutukoy sa maraming pamamaraan sa pagbubukas ng file. Ang mga miyembro ng FileMode Enumerator ay inilarawan tulad ng sumusunod:
 Ikabit: Nagbubukas ito ng isang mayroon nang file at inilalagay ang cursor sa dulo ng file, o lumilikha ng file kung ang file ay walang.
 Lumikha: Dinisenyo ito upang lumikha ng isang bagong file.
 Gumawa ng bago: Dinisenyo ito upang tukuyin sa operating system, na dapat itong lumikha ng isang bagong file.
 Buksan: Dinisenyo ito upang buksan ang isang mayroon nang file.
 OpenOrCreate: Dinisenyo ito upang tukuyin ang operating system na dapat itong magbukas ng isang file kung mayroon ito, kung hindi man ay dapat itong lumikha ng isang bagong file.
 Putulin: Nagbubukas ang truncate ng isang mayroon nang file at pinuputol ang laki nito sa zero bytes.
 FileAccess 
 FileAccess Ginamit ang Enumerator upang makakuha ng pag-access sa isang partikular na file. Mayroon itong mga sumusunod na miyembro.
 Basahin 
 Sumulat 
 Basa sulat 
 Pagbabahagi ng mga files 
Ang Pagbabahagi ng mga files Ginagamit ang Enumerator upang magbahagi ng isang partikular na file. Mayroon itong mga sumusunod na miyembro.
 Magmana: Pinapayagan ng mana na mapanatili ang isang filehandle na ipasa ang isang mana sa mga proseso ng bata.
 Wala: Walang tinanggihan ang pagbabahagi ng kasalukuyang file
 Basahin: Pinapayagan ng Basahin ang pagbubukas ng file para sa pagbabasa.
 Basa sulat: Pinapayagan ng ReadWrite na buksan ang file para sa pagbabasa at pagsusulat.
 Isulat: Pinapayagan ng pagsulat ang pagbubukas ng file para sa pagsusulat.
 Mga Kaganapan 
Ang isang Kaganapan sa pangkalahatan ay kilala bilang isang aksyon na nabuo ng gumagamit. Maaaring ito ay isang pag-click ng mouse at kahit isang solong keystroke mula sa keyboard. Katulad nito, ang mga programa ng C # ay mayroon ding mga kaganapan. Ang tagabuo ng kaganapan ay tinawag na publisher at ang tatanggap ng kaganapan ay tinawag na subscriber. 
 Publisher 
SA publisher naglalaman ng kahulugan ng kaganapan at ng delegado. Ang event-delegate ang pagkakaugnay ay tinukoy sa bagay na ito. A publisher inaanyayahan ng object ng klase ang kaganapan at aabisuhan ito sa iba pang mga object.
 Subscriber 
SA subscriber tinatanggap ang kaganapan at nagbibigay ng isang handler ng kaganapan. Ang delegado sa klase ng publisher inilalagay ang pamamaraan / kaganapan handler ng klase ng subscriber.
 Halimbawa: 
gamit ang System namespace Edureka {public delegate string Del (string str) class EventBlock {event Del NewEvent public EventBlock () {this.NewEvent + = new Del (this.WelcomeUser)} public string WelcomeUser (string username) {return 'Welcome To Edureka . '+ username} static void Main (string [] args) {EventBlock obj1 = new EventBlock () string resulta = obj1.NewEvent (' Happy Learning ') Console.WriteLine (resulta)}}}
 // Output: 
Maligayang Pagdating Sa Edureka. Maligayang Pag-aaral
 Generics 
 Generics ay isang konsepto ng pagbibigay ng mga kasapi at pamamaraan ng isang klase sa mga may hawak ng lugar Run-time. Maaari naming tukuyin ang paggamit ng Mga Generic mga braket Suriin natin ang mga sumusunod na halimbawa.
 Generics sa isang Klase 
gamit ang System namespace Edureka {class GenericClass {public GenericClass (T msg) {Console.WriteLine (msg)}} class Program {static void Main (string [] args) {GenericClass gen = new GenericClass ('Ang mensaheng ito ay mula sa generic class' ) GenericClass genI = bagong GenericClass (123) GenericClass getCh = bagong GenericClass ('E')}}}
 // Output: 
Ang mensaheng ito ay mula sa generic na klase 
 123 
 AY
 Generics sa isang Paraan 
gumagamit ng namespace ng system Edureka {class GenericClass {public void Show (T msg) {Console.WriteLine (msg)}} class Program {static void Main (string [] args) {GenericClass genC = new GenericClass () genC.Show ('This ang mensahe ay mula sa generic na pamamaraan ') genC. Ipakita (321) genC. Ipakita (' H ')}}}
 // Output: 
Ang mensaheng ito ay mula sa pangkalahatang pamamaraan 
 321 
 H
 Mga delegado 
Ang Delegado gumaganap bilang isang sanggunian sa pamamaraan. Karaniwan katulad ito ng a function pointer sa C at C ++ ngunit mas mahusay at type-safe. Ang Delegado sa static na pamamaraan encapsulate paraan lamang. Habang ang delegado sa halimbawa encapsulate ng pamamaraan ang parehong pamamaraan at halimbawa. Ang pinakamahusay na paggamit ng delegado ay gamitin bilang isang pangyayari 
 Halimbawa: 
gamit ang System delegate int Calculator (int n) pampublikong klase Edureka {static int number = 25 public static int add (int n) {number = number + n return number} public static int mul (int n) {number = number * n return number} public static int getNumber () {return number} public static void Main (string [] args) {Calculator c1 = new Calculator (add) Calculator c2 = new Calculator (mul) c1 (20) Console.WriteLine ('After calculator isang delegado, ang bagong Numero ay: '+ getNumber ()) c2 (3) Console.WriteLine (' Matapos ang calculator ng dalawang delegado, ang bagong Numero ay: '+ getNumber ())}}
 // Output: 
Pagkatapos ng calculator ng isang delegado, ang bagong Numero ay: 45 
 Pagkatapos ng calculator ng dalawang delegado, ang bagong Numero ay: 135
 Pagninilay 
Kinakailangan ang Pagninilay upang makuha ang metadata sa run-time. Magagamit ang Sanggunian sa Sistema. Pagrerepekto namespace. Kinakailangan nito ang mga sumusunod na klase upang maipatupad.
Uri
MemberInfo
TagabuoInfo
PamamaraanInfo
FieldInfo
Ari-arianInfo
TypeInfo
EventInfo
Modyul
Assembly
AssemblyName
Pointer
 Uri ng klase 
Ang klase ng uri ng C # ay kumakatawan sa mga pagdedeklara ng uri para sa mga uri ng klase, uri ng interface, uri ng enumerasyon, uri ng array, uri ng halaga
Uri ng Mga Katangian
Ang isang listahan ng mga mahahalagang katangian ng mga uri ng uri ay nabanggit sa ibaba.
 Pag-aari 
 Paglalarawan 
 Assembly 
Nakukuha ang Assembly para sa ganitong uri.
 AssemblyQualifiedName 
Nakukuha ang kwalipikadong pangalan ng Assembly para sa ganitong uri.
 Mga Katangian 
Nakukuha ang Mga Katangian na nauugnay sa uri.
 BaseType 
Nakukuha ang base o uri ng magulang.
 Buong pangalan 
Nakakakuha ng ganap na kwalipikadong pangalan ng uri.
 IsAbstract 
ay ginagamit upang suriin kung ang uri ay Abstract.
 IsArray 
ay ginagamit upang suriin kung ang uri ay Array.
 IsClass 
ay ginagamit upang suriin kung ang uri ay Klase.
 IsEnum 
ay ginagamit upang suriin kung ang uri ay Enum.
 IsInterface 
ay ginagamit upang suriin kung ang uri ay Interface.
 AyNest 
ay ginagamit upang suriin kung ang uri ay Pugad.
 IsPrimitive 
ay ginagamit upang suriin kung ang uri ay Primitive.
 IsPointer 
ay ginagamit upang suriin kung ang uri ay Pointer.
 IsNotPublic 
ay ginagamit upang suriin kung ang uri ay hindi Pampubliko.
 IsPublic 
ay ginagamit upang suriin kung ang uri ay Pampubliko.
 IsSealed 
ay ginagamit upang suriin kung ang uri ay Sealed.
 IsSerializable 
ay ginagamit upang suriin kung ang uri ay Serializable.
 MemberType 
ay ginagamit upang suriin kung ang uri ay Miyembro na uri ng Sarang uri.
 Modyul 
Nakukuha ang module ng uri.
 Pangalan 
Nakukuha ang pangalan ng uri.
 Namespace 
Nakukuha ang namespace ng uri.
 Pag-aari 
 Paglalarawan 
 GetConstructors () 
Ibinabalik ang lahat ng mga pampublikong konstruktor para sa Uri.
 GetConstructors (BindingFlags) 
Ibinabalik ang lahat ng mga tagapagbuo para sa Uri na may tinukoy na BindingFlags.
 GetFields () 
Ibinabalik ang lahat ng mga pampublikong patlang para sa Uri.
 GetFields (BindingFlags) 
Ibinabalik ang lahat ng mga pampublikong konstruktor para sa Uri na may tinukoy na BindingFlags.
 GetMembers () 
Ibinabalik ang lahat ng mga kasapi sa publiko para sa Uri.
 GetMembers (BindingFlags) 
Ibinabalik ang lahat ng mga miyembro para sa Uri na may tinukoy na BindingFlags.
 GetMethods () 
Ibinabalik ang lahat ng mga pampublikong pamamaraan para sa Uri.
 GetMethods (BindingFlags) 
Ibinabalik ang lahat ng mga pamamaraan para sa Uri na may tinukoy na BindingFlags.
 GetProperties () 
Ibinabalik ang lahat ng mga pampublikong pag-aari para sa Uri.
 GetProperties (BindingFlags) 
Ibinabalik ang lahat ng mga pag-aari para sa Uri na may tinukoy na BindingFlags.
 GetType () 
Nakukuha ang kasalukuyang Uri.
 GetType (String) 
Nakukuha ang Uri para sa ibinigay na pangalan.
 Mga Halimbawa ng Pagninilay: 
 Kumuha ng Uri 
 Halimbawa: 
gumagamit ng System public class na GetType {public static void Main () {int a = 10 Type type = a.GetType () Console.WriteLine (type)}}
 // Output: 
System.Int32
 
 Kumuha ng Assembly 
 Halimbawa: 
gamit ang System using System.Reflection public class GetAss Assembly {public static void Main () {Type t = typeof (System.String) Console.WriteLine (t.Ass Assembly)}}
 // Output: 
System.Private.CoreLib, Bersyon = 4.0.0.0, Kultura = walang kinikilingan, PublicKeyToken = 7cec85d7bea7798e
 
 Impormasyon sa Uri ng Pag-print 
 Halimbawa: 
gamit ang System using System.Reflection public class PrintType {public static void Main () {Type t = typeof (System.String) Console.WriteLine (t.FullName) Console.WriteLine (t.BaseType) Console.WriteLine (t.IsClass) Console.WriteLine (t.IsEnum) Console.WriteLine (t.IsInterface)}}
 // Output: 
Totoo 
 Mali 
 Mali
 
 Mga taga-print na Print 
 Halimbawa: 
gamit ang System using System.Reflection public class PrintConstructors {public static void Main () {Type t = typeof (System.String) Console.WriteLine ('Constructors of {0} type ...', t) ConsonstrorInfo [] ci = t .GetConstructors (BindingFlags.Public | BindingFlagsInstance) maaga (Cons konstruktorInfo c sa ci) {Console.WriteLine (c)}}}
 // Output: 
Mga Bumubuo ng System. Uri ng String ... 
 Walang bisa .ctor (Char []) 
 Void .ctor (Char [], Int32, Int32) 
 Walang bisa .ctor (Char *) 
 Void .ctor (Char *, Int32, Int32) 
 Walang bisa .ctor (SByte *) 
 Void .ctor (SByte *, Int32, Int32) 
 Void .ctor (SByte *, Int32, Int32, System.Txt.Encoding) 
 Void .ctor (Char, Int32) 
 Void .ctor (System.ReadOnlySpan`1 [System.Char])
 
 Mga Paraan ng Pag-print 
 Halimbawa: 
gamit ang System using System.Reflection public class PrintMethods {public static void Main () {Type t = typeof (System.String) Console.WriteLine ('Mga Paraan ng {0} uri ...', t) MethodInfo [] ci = t .GetMethods (BindingFlags.Public | BindingFlagsInstance) maaga (MethodInfo m in ci) {Console.WriteLine (m)}}}
 // Output: 
Mga Paraan ng System. Uri ng String ... 
 System.String Change (System.String, System.String) 
 System.String [] Hati (Char, System.StringSplitOptions) 
 System.String [] Hati (Char, Int32, System.StringSplitOptions) 
 System.String [] Hati (Char []) 
 System.String [] Hati (Char [], Int32) 
 System.String [] Hati (Char [], System.StringSplitOptions) 
 System.String [] Hati (Char [], Int32, System.StringSplitOptions) 
 System.String [] Hati (System.String, System.StringSplitOptions) 
 System.String [] Hati (System.String, Int32, System.StringSplitOptions) 
 System.String [] Hati (System.String [], System.StringSplitOptions) 
 System.String [] Hati (System.String [], Int32, System.StringSplitOptions) ......
 
 Mga Patlang ng Pag-print 
 
 Halimbawa: 
gamit ang System using System.Reflection public class PrintFields {public static void Main () {Type t = typeof (System.String) Console.WriteLine ('Fields of {0} type ...', t) FieldInfo [] ci = t .GetFields (BindingFlags.Public | BindingFlags.Static | BindingFlags.NonPublic) maaga (FieldInfo f in ci) {Console.WriteLine (f)}}}
 // Output: 
Mga Patlang ng System. Uri ng String ... 
 Sistema. Walang laman ang Sining
Ngayon, magpatuloy tayo sa ilang mga advanced C # Programming Concepts
 Mga advanced na C # Concept 
 Anonymous na Pag-andar 
 Multi-Threading 
 Exception na Pangangasiwa 
 Pagsasabay 
 Mga bagong katangian 
 Anonymous na Pag-andar 
Ang Pag-andar na walang isang tiyak na pangalan ay tinatawag Hindi nagpapakilala Mga pagpapaandar. Mayroong dalawang uri ng Mga Anonymous na Pag-andar na magagamit sa C #
Mga expression ng Lambda
Mga Paraang Hindi nagpapakilala
 Halimbawa: 
gamit ang System namespace LambdaExpressions {class Edureka {delegate int Square (int num) static void Main (string [] args) {Square GetSquare = x => x * x int j = GetSquare (25) Console.WriteLine ('Square:' + j)}}}
 // Output: 
Kuwadro: 625
 Mga Paraang Hindi nagpapakilala 
Ang hindi nagpapakilalang pamamaraan nagbibigay ng parehong pag-andar bilang a lambda expression, maliban na pinapayagan kaming hindi pansinin ang listahan ng parameter.
 Halimbawa: 
gamit ang System namespace AnonymousMethods {class Program {public delegate void AnonymousFun () static void Main (string [] args) {AnonymousFun fun = delegate () {Console.WriteLine ('This is anonymous function')} masaya ()}}}
 // Output: 
Ito ay hindi nagpapakilalang pagpapaandar
 Multi-Threading 
Ang Multithreading ay isang proseso kung saan maraming mga thread ang nilikha at nakatalaga para sa iba't ibang mga gawain. nakakatipid ito ng oras sa pamamagitan ng pagpapatupad ng maraming mga trabaho nang paisa-isa. Ang multithreading class ay magagamit sa Sistema. Pag-Thread namespace.
 System. Pag-Thread sa Namespace 
Ang Sistema. Pag-Thread Naglalaman ang namespace ng mga klase at interface upang mapadali ang multithreading. Nagbibigay ito ng mga klase upang maisabay ang mapagkukunan ng thread. Ang isang listahan ng mga karaniwang ginagamit na klase ay ibinibigay sa ibaba:
Thread
Mutex
Timer
Subaybayan
Semaphore
Lokal na Thread
ThreadPool
Pabagu-bago
 Proseso at thread 
Ang Proseso ay talagang at aplikasyon at ito ay itinuturing na isang bigat sangkap Sa kabilang banda, ang thread ay isang solong modyul ng buong aplikasyon. Ito ay magaan kumpara sa proseso
 Ang LifeCycle ng isang Thread 
Ang bawat Thread ay mayroong Life Cycle. Ang Siklo ng Buhay ng thread ay tinukoy sa System.Threading.Thread class. Ang mga sumusunod ay ang mga yugto sa Life Cycle ng anumang thread.
Hindi nasimulan
Runnable (Handa nang tumakbo)
Tumatakbo
Hindi Runnable
Patay na
Nagbibigay ang klase ng Thread ng mga sumusunod na katangian at pamamaraan tulad ng sumusunod.
 Mga Katangian sa Thread 
 Pag-aari 
 Paglalarawan 
 KasalukuyangThread 
ibabalik ang halimbawa ng kasalukuyang tumatakbo na thread.
 Ay buhay 
sinusuri kung ang kasalukuyang thread ay buhay o hindi.
 IsBackground 
Upang makuha / itakda ang halaga ng kasalukuyang thread ay nasa background o hindi.
 Pinamahalaan ang ThreadId 
ay ginagamit upang makuha ang natatanging id para sa kasalukuyang pinamamahalaang thread.
 Pangalan 
ay ginagamit upang makuha o maitakda ang pangalan ng kasalukuyang thread.
 Prayoridad 
ay ginagamit upang makuha o itakda ang priyoridad ng kasalukuyang thread.
 ThreadState 
ay ginagamit upang ibalik ang isang halaga na kumakatawan sa estado ng thread.
 Mga Paraan ng Thread 
 Pamamaraan 
 Paglalarawan 
 Pagpapalaglag () 
ay ginagamit upang wakasan ang thread. Itinaas nito ang ThreadAbortException.
 Makagambala () 
ay ginagamit upang matakpan ang isang thread na kung saan ay nasa estado ng WaitS SleepJoin.
 Sumali () 
ay ginagamit upang harangan ang lahat ng mga thread ng pagtawag hanggang sa magtapos ang thread na ito.
 I-reset angAbort () 
ay ginagamit upang kanselahin ang kahilingan sa Pag-abort para sa kasalukuyang thread.
 Ipagpatuloy() 
ay ginagamit upang ipagpatuloy ang nasuspindeng thread. Ito ay lipas na.
 Tulog (Int32) 
ay ginagamit upang suspindihin ang kasalukuyang thread para sa mga tinukoy na milliseconds.
 Simula () 
binabago ang kasalukuyang estado ng thread sa Runnable.
 Suspindihin () 
sinuspinde ang kasalukuyang thread kung hindi ito nasuspinde. Ito ay lipas na.
 Magbunga () 
ay ginagamit upang ibigay ang pagpapatupad ng kasalukuyang thread sa isa pang thread.
 Pangunahing Halimbawa ng Thread 
gamit ang System using System.Threading public class Edureka {public static void Main (string [] args) {Thread t = Thread.CurrentThread t.Name = 'MainThread' Console.WriteLine (tName)}}
 // Output: 
MainThread
 
 Exception na Pangangasiwa 
Ang pagbubukod ay isang error na itinapon ng programa sa kanyang run-time. Nagsasagawa kami ng Exception-Handling upang mapalaya ang aming programa.
 Pagbubukod 
 Paglalarawan 
 System.DivideByZeroException 
Error na nabuo sa pamamagitan ng paghahati ng isang numero na may zero.  
  
 System.NullReferensiException 
humahawak ng error na nabuo sa pamamagitan ng pagsangguni sa null object.  
  
 System.InvalidCastException 
hinahawakan ang error na nabuo sa pamamagitan ng hindi wastong typecasting.  
  
 Sistema.IO.IOException 
hinahawakan ang mga error sa Input / Output.
 System.FieldAccessException 
Error na nabuo ng hindi wastong pribado / protektadong pag-access.
 
Sa C #, gumagamit kami ng 4 na keyword upang maisagawa paghawak ng pagbubukod: 
subukan mo
mahuli
sa wakas, at
magtapon
  Halimbawa:  
gamit ang System public class EdurekExample {public static void Main (string [] args) {try {int a = 10 int b = 0 int x = a / b} catch (Exception e) {Console.WriteLine (e)} Console.WriteLine ('Ang mensaheng ito ay mula sa catch block')}}
 
 // Output: 
System.DivideByZeroException: Sinubukan na hatiin ng zero. 
 sa ExExaEdurekample.Main (String [] args) sa F: C # TutorialC # ProgramsConsoleApp1ConsoleApp1Program.cs: linya 10 
 Ang mensahe na ito ay mula sa catch block
 Pasadyang Halimbawa ng Exception 
gamit ang System public class InvalidAgeException: Exception {public InvalidAgeException (String message): base (message) {}} public class Customized {static void validate (int age) {if (age<18) { throw new InvalidAgeException('Sorry, Age is expected to be greater than 18') } } public static void Main(string[] args) { try { validate(12) } catch (InvalidAgeException e) { Console.WriteLine(e) } Console.WriteLine('Catch block is being executed now.') } } 
 // Output: 
InvalidAgeException: Paumanhin, inaasahan na mas malaki sa 18 ang edad 
 sa Customized.validate (Int32 edad) sa F: C # TutorialC # ProgramsConsoleApp1ConsoleApp1Program.cs: linya 18 
 sa Customized.Main (String [] args) sa F: C # TutorialC # ProgramsConsoleApp1ConsoleApp1Program.cs: linya 23 
 Ang catch block ay isinasagawa ngayon.
 
 Sa wakas i-block ang halimbawa 
gamit ang System public class FinalExecption {public static void Main (string [] args) {try {int a = 10 int b = 0 int x = a / b} catch (Exception e) {Console.WriteLine (e)} sa wakas {Console .WriteLine ('Sa wakas ang block ay naisakatuparan')} Console.WriteLine ('Ang catch block ay naisagawa')}}
 // Output: 
System.DivideByZeroException: Sinubukan na hatiin ng zero. 
 sa FinalExecption.Main (String [] args) sa F: C # TutorialC # ProgramsConsoleApp1ConsoleApp1Program.cs: linya 10 
 Sa wakas ang block ay naisagawa 
 Ang catch block ay naisakatuparan
 Lagda ng Exception ng System 
[SerializableAttribut] [ComVisibleAttribute (totoo)] pampublikong klase SystemException: Exception
 Mga Exception ng System Exception 
 Tagabuo 
 Paglalarawan 
 SystemException () 
Ginagamit ito upang simulan ang isang bagong halimbawa ng klase ng SystemException.
 SystemException 
 (SerializationInfo, StreamingContext) 
Ginagamit ito upang simulan ang isang bagong halimbawa ng klase ng SystemException na may serialized data.
 SystemException (String) 
Ginagamit ito upang simulan ang isang bagong halimbawa ng klase ng SystemException na may tinukoy na mensahe ng error.
 SystemException (String, Exception) 
Ginagamit ito upang simulan ang isang bagong halimbawa ng klase ng SystemException na may tinukoy na mensahe ng error at isang sanggunian sa panloob na pagbubukod na siyang sanhi ng pagbubukod na ito.
 Mga Katangian sa Pagbubukod ng System 
 Pag-aari 
 Paglalarawan 
 Data 
Ginagamit ito upang makakuha ng isang koleksyon ng mga pares ng key / halaga na nagbibigay ng karagdagang impormasyon na tinukoy ng gumagamit tungkol sa pagbubukod.
 HelpLink 
Ginagamit ito upang makakuha o magtakda ng isang link sa file ng tulong na nauugnay sa pagbubukod na ito.
 HResult 
Ginagamit ito upang makakuha o magtakda ng HRESULT, isang naka-code na numerong halaga na nakatalaga sa isang tukoy na pagbubukod.
 InnerException 
Ginagamit ito upang makuha ang halimbawa ng Exception na naging sanhi ng kasalukuyang pagbubukod.
 Mensahe 
Ginagamit ito upang makakuha ng isang mensahe na naglalarawan sa kasalukuyang pagbubukod.
 Pinagmulan 
Ginagamit ito upang makuha o maitakda ang pangalan ng application na nagdudulot ng error.
 StackTrace 
Ginagamit ito upang makakuha ng isang string na representasyon ng mga agarang mga frame sa stack ng tawag.
 TargetSite 
Ginagamit ito upang makuha ang pamamaraan na nagtatapon ng kasalukuyang pagbubukod.
 Mga Paraan ng Pagbubukod ng System 
 Paraan 
 Paglalarawan 
 Katumbas (Bagay) 
Ginagamit ito upang suriin na ang tinukoy na bagay ay katumbas ng kasalukuyang object o hindi.
 I-finalize () 
Ginagamit ito upang magbakante ng mga mapagkukunan at magsagawa ng mga operasyon sa paglilinis.
 GetBaseException () 
Ginagamit ito upang makakuha ng pagbubukod ng ugat.
 GetHashCode () 
Ginagamit ito upang makuha ang hash code.
 GetObjectData 
 (SerializationInfo, StreamingContext) 
Ginagamit ito upang makakuha ng data ng object.
 GetType () 
Ginagamit ito upang makuha ang uri ng runtime ng kasalukuyang halimbawa.
 MemberwiseClone () 
Ginagamit ito upang lumikha ng isang mababaw na kopya ng kasalukuyang Bagay.
 ToString () 
Ginagamit ito upang lumikha at bumalik ng isang representasyon ng string ng kasalukuyang pagbubukod.
 Halimbawa ng Exception ng System 
gamit ang System namespace CSharpProgram {class SystemExceptionExample {static void Main (string [] args) {try {int [] arr = new int [5] arr [10] = 25} catch (SystemException e) {Console.WriteLine (e)} }}}
 // Output: 
System.IndexOutOfRangeException: Ang index ay nasa labas ng mga hangganan ng array. 
 sa CSharpProgram.SystemExceptionExample.Main (String [] args) sa F: C # TutorialC # ProgramsConsoleApp1ConsoleApp1Program.cs: linya 11
 
 Pagsasabay 
Ang pag-synchronize ay maaaring isang pamamaraan na nagbibigay-daan lamang sa 1 thread upang ma-access ang mapagkukunan para sa isang tukoy na oras. Walang alternatibong thread ang makagambala hanggang sa natapos ng naatasang thread ang gawain nito.
Sa multithreading program, pinapayagan ang mga threadupang ma-access ang anumang mapagkukunan para satinukoy na pagpapatupadoras Ang mga thread ay nagbabahagi ng mga mapagkukunan at hindi isinasagawa ang asynchronous. Pag-access sa mga nakabahaging mapagkukunan (data)maaaring isang mahalagang gawainna sa pangkalahatanmaaaring tumigilang sistema.mayroon tayong tendensya na impluwensyahan itosa pamamagitan ng paglikha ng mga thread sa isang kasabay na pamamaraan.
 Halimbawa Nang Walang Pagsabay 
gamit ang System using System.Threading class Edureka {public void PrintTable () {for (int i = 1 i<= 10 i++) { Thread.Sleep(100) Console.WriteLine(i) } } } class Program { public static void Main(string[] args) { Edureka p = new Edureka() Thread t1 = new Thread(new ThreadStart(p.PrintTable)) Thread t2 = new Thread(new ThreadStart(p.PrintTable)) t1.Start() t2.Start() } } 
 // Output: 
 
isa 
 isa 
 2 
 2 
 3 
 3 
 4 
 4 
 5 
 5 
 6 
 6 
 7 
 7 
 8 
 8 
 9 
 9 
 10 
 10
 
 Halimbawa Sa Pagsabay 
gamit ang System using System.Threading class Edureka {public void PrintTable () {lock (this) {for (int i = 1 i<= 10 i++) { Thread.Sleep(100) Console.WriteLine(i) } } } } class Program { public static void Main(string[] args) { Edureka p = new Edureka() Thread t1 = new Thread(new ThreadStart(p.PrintTable)) Thread t2 = new Thread(new ThreadStart(p.PrintTable)) t1.Start() t2.Start() } } 
 // Output: 
isa 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 isa 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10
 Mga bagong katangian 
Nagdagdag ang Microsoft ng maraming pinakabagong tampok sa wikang C # ang ilan sa mga ito ay nabanggit sa ibaba.
C # 6.0
Paggamit ng static na direktiba
Mga pansalang filter
Maghintay sa catch / sa wakas ay mga bloke
Mga nagpapasimula ng auto property
Mga default na halaga para sa mga pag-aari na getter-only
Mga kasapi na may ekspresyon sa katawan
Null propagator
String interpolation
Pangalan ng operator
Nagpapasimula ng diksyonaryo
Compiler-as-a-service (Roslyn)
C # 7.0
Pagtutugma sa pattern
Tuples
Pagpapatayo
Mga lokal na pag-andar
Paghihiwalay ng digit
Mga binary na literal
Mga pagbabalik ng ref at mga lokal
Ekspresyon ng mga nakabubuo ng katawan at finalizer
Mga pagpapahayag na may katawan na mga getter at setter
Out variable
Pangkalahatang mga uri ng pagbabalik ng async
C # 7.1
Async pangunahing
Mga default na expression
 Mga Katanungan sa Panayam batay sa C # 
Ang mahahalagang mga Katanungan sa pakikipanayam batay sa C # Programming Wika ay matatagpuan sa na-update na ito  .
Sa pamamagitan nito, natapos namin ang artikulong 'C # Tutorial' na ito. Inaasahan kong naunawaan mo ang kahalagahan ng Mga Istraktura ng Data, Syntax, pagpapaandar, at pagpapatakbo na isinagawa gamit ang mga ito. Ngayon na naintindihan mo ang mga pangunahing kaalaman sa Programming sa C # sa pamamagitan nitoC # Tutorial, suriin ang  ibinigay ang pagsasanay  ni Edureka sa maraming mga teknolohiya tulad ng Java, Spring at maramihigit pa, isang mapagkakatiwalaang kumpanya sa online na pag-aaral na may isang network ng higit sa 250,000 mga nasiyahan na nag-aaral na kumalat sa buong mundo ay nakakuha ng  tanong sa amin? Nabanggit ito sa seksyon ng mga komento ng blog na 'C # Tutorial' at babalikan ka namin sa lalong madaling panahon.