C # oktatóanyag: A C # elsajátításához szükséges alapismeretek

A C # univerzális és robusztus programozási nyelv, amelyet a Microsoft Corporation fejlesztett ki 2000-ben, mint a Java halálos versenytársa. A legnépszerűbb és a domináns programozási nyelv mind a webfejlesztés, mind az asztali alkalmazások fejlesztése terén.

Ebben a C # oktatóanyagban a következő fogalmakat tanuljuk meg.

• C # alapok
• Objektumorientált programozás
• Haladó C # fogalmak
• Interjúkérdések a C # alapján

C # alapok

• Bevezetés a C # programozási nyelvbe
• A C # programozási nyelv jellemzői
• Telepítés
• C # Program felépítése
• Adattípusok
• Változók
• Operátorok
• Hurkok
• Feltételes
• Húrok
• Tömbök
• Gyűjtemények
  • Lista
  • Hash Set
  • Rendezett készlet
  • Kazal
  • Sor
  • Összekapcsolt lista
  • Szótár
  • Rendezett szótár
  • Rendezett lista
• Szerkezet
• Funkciók

Bevezetés a C # programozási nyelvbe

A 90-es évek elején a Java volt a vezető programozási nyelv a webfejlesztés, az asztali alkalmazások fejlesztése és sok más területen. A Microsoft egy olyan versenytárssal akart előállni, amely számos fejlett funkcióval rendelkezik, amelyek messze maguk mögött hagyhatják a Java-t.

2000-ben volt, Anders Hejlsberg és a Microsoft csapata felvetette a C # ötletét, amelyet népszerûen C-Sharpnak hívnak. Ezt a kezdeményezést a Nemzetközi Szabványügyi Szervezet jóváhagyta (JELENTŐSEBB) és az Európai Számítógépgyártók Szövetsége (ECMA). végül pedig a C # belép a szoftverfejlesztés világába.

A C # programozási nyelv jellemzői

• Objektumorientált programozási nyelv

Az objektum-orientált programozási megközelítés az, ami a C # sharp-ot a programozóbarátabbá, valamint könnyen fejleszthetővé és fenntarthatóvá teszi a programozási nyelvet.

• Típusbiztos nyelv

A Type-Safe jelentése az, hogy a fordító csak ahhoz a memóriahelyhez kap hozzáférést, amelynek engedélye van a végrehajtásra. Ez a szolgáltatás exponenciális szintre javítja a kód biztonságát.

• Átjárhatóság

Az interoperabilitás sajátossága teszi a C # -t eléggé alkalmassá arra, hogy mindent hatékonyabban végezzen, ami a C ++ - ban rejlik, és amely önmagában is felülmúlhatja a C ++ szintet.

• Gazdag Könyvtár

A C # hozzáférést biztosít számos beépített könyvtárhoz, amelyek előre beprogramozott funkciókat biztosítanak a fejlesztési folyamatban eltöltött idő csökkentése érdekében.

• Skálázható és frissíthető

A C # -ot úgy tervezték, hogy kiválóbb legyen a többi programozási nyelv között. Ezért mindig nyitott a frissítésekre, és jellemzőivel rendkívül jól skálázható.

• Komponensorientált

A Microsoft fejlesztői a komponens alapú megközelítést használták a C # fejlesztéséhez. Ez a legfőbb fejlesztési módszertan a C # nagymértékben skálázható és naprakészen tartása érdekében.

• Strukturált nyelv

A strukturált programozási megközelítést előnyben részesítik a szoftverfejlesztés életciklusa során, mivel az eljárásorientált programozási megközelítéshez képest könnyűvé válik a szoftver összeállítása és telepítése.

• Gyors

A C # programozása történetesen gyorsabb a fordításban és a végrehajtásban, összehasonlítva a C ++ és más programozási nyelvekkel.

Telepítés

Bizonyított, hogy Microsoft Visual Studio az osztály legjobb szerkesztője a C # programozáshoz. Telepítjük és beállítjuk a Microsoft Visual Studiot a C # programjaink futtatásához az alábbiak szerint:

1. lépés : Töltse le a Microsoft Visual Studio alkalmazást

hogyan kell használni a hatalmakat a java-ban

Google a A Visual Studio legújabb verziója és töltse le a telepítés fájlt a helyi rendszerbe, majd fuss a telepítőfájlt mint egy adminisztrátor.

2. lépés: Válassza ki a .NET asztali fejlesztői csomagot

Az Installer futtatása után a Visual Studio Editor sikeresen letöltésre kerül a helyi rendszerbe. Később egy párbeszédpanel jelenik meg az asztalon. adott csomagot amire szüksége van a rendszerében. Itt ki kell választania a .NET asztali fejlesztés csomag.

3. lépés: Állítsa be a C # Környezet beállítást

Miután a csomagok a .NET fejlesztés letöltődnek, akkor egy újabb párbeszédpanel jelenik meg a képernyőn, amely a keresett fejlesztői környezetet kéri. Itt kell válassza ki a C # környezetét.

4. lépés: Készítse el az első projektet

Miután beállítottuk a környezetet, mindannyian jól tudtok menni. Indítsa el a Visual Studio alkalmazást, majd válassza a lehetőséget hozzon létre új projektet opciót a megjelenített párbeszédpanelen.

Átirányít a következő párbeszédpanelre, és ott ki kell választania a Class library as elemet .NET Standard az alábbiak szerint.

A következő párbeszédpanelen a rendszer kéri Konfigurálja a projektet . Konfigurálja, és máris a szerkesztőben van. Írja meg első programját és fuss azt. A kimenet sikeresen megjelenik a Parancssor.

az Edureka rendszerosztály használatával {static void Main (string [] args) {Console.WriteLine ('Üdvözöljük az Edureka !, Boldog tanulást ..!')}}

//Kimenet:

Hajtsuk végre az első C # programunkat.

C # Program felépítése

Most, hogy végrehajtottuk az első C # programunkat, értsük meg részletesen annak felépítését. Egy egyszerű C # program a következő részeket tartalmazza.

a System névtér használatával ConsoleApplication1 {public class Edureka {public static void Main (string [] args) {Console.WriteLine ('Welcome to Edureka !, Happy Learning ..!')}}}

//Kimenet:

Üdvözöljük az Edureka !, Boldog tanulást ..!

• osztály: osztály általában úgy határozható meg, mint a kulcsszó amelyet egy osztály definiálására használunk a C # Programban.
• Edureka: Ez a neve Osztály. Az osztályt gyakran olyan tervnek tekintik, amely tárolja az osztályhoz tartozó tagokat és módszereket.
• Fő: Alapvetően az elsődleges módszer a teljes C # programból, átjáróként működik a vezérlőnek a programba való belépéshez. A program bármely más módjának végrehajtása előtt végrehajtásra kerül.
• üres: A kód ezen szegmense a visszatérési típus a módszer. Bármilyen típusú lehet, a void kivételével. Az érvénytelen azt jelenti, hogy a módszer nem ad vissza adatokat.
• statikus: Ez egy kulcsszó amely azt mondja, hogy a deklarált adatok tagjai statikusak, és dedikált memóriát osztanak ki a deklarált tagoknak.
• String [] azzal érvel: Hasonlít a parancssori argumentumokra, amelyeket a programunkban használunk. Amíg végrehajtjuk a programunkat, alapvetően átadunk néhányat érvek, amelyet a program ezen állítás miatt elfogad.
• System.Console.WriteLine („Üdvözöljük az Edureka !, Boldog tanulást ..!”) Itt, Rendszer az a névtér. A konzolaz, hogy a felvázolt kategóriaa Rendszer névtérben. Az WriteLine () az azstatikustechnikaof Consolekategória, amelyet leírásra alkalmaznaka szöveg a konzolon.

Most tanuljuk meg a C # nyelven elérhető adattípusokat.

Adattípusok

A C # adattípusokat három kategóriába sorolják az alábbiakban.

Értékadattípusok

Az Értékadattípusok találhatók a System.ValueType Könyvtár, és mindig készen állnak a közvetlen hozzáférésre, és a változók közvetlenül hozzárendelhetők egy adott értékhez. Az értékadattípusokat további két típusba sorolják az alábbiak szerint:

• Előre definiált adattípusok
• Felhasználó által definiált adattípusok

Előre definiált adattípusok: Ezeket szoktuk használni a mindennapi programozás során. Ezeket az adattípusokat a nyelvfejlesztők előre definiálják, és használatukra készen tartják a programozók számára.

Példa:

int, float, char, rövid kettős stb

Felhasználó által definiált adattípusok: Vannak olyan helyzetek, amikor szükség lehet arra, hogy az Adattípusoktól különböző értékeket tároljunk egyetlen változóba. Ezekben az esetekben a Előre definiált adattípusok nem elég. Felhasználó által meghatározott Az adattípusok olyanok, mint a felhasználó testreszabható adattípusai.

Példa: Struktúra, Enum

Mutató adattípusa

A Pointer Type egyszerű adattípus. Funkcionalitása teljesen hasonló a C-ben levő mutatókhoz. Úgy tervezték, hogy egy másik mutató címét tárolják.

úszó * ptr

Referencia-adattípusok

A név magától értetődő. Az Referencia-adattípusok valójában nem tárolják a változókat, ehelyett az adott változó referenciaértékét tárolják. Más szavakkal, eltárolják a tényleges változó címét.

A referenciaváltozókat három különböző típusba sorolják, az alábbiak szerint:

• Objektumtípus

Az Object Datatype a Rendszer.Tárgy Osztály.A tárgytípusoklehetaértékeia többi típus,referenciatípusok, előre definiált, felhasználó által definiálttípusok. De előttefeladatértékeket igényel típus átalakítás.

object abc abc = 50 // ezt boksznak hívjuk

• Dinamikus típus

A dinamikus típusú változókat szinte minden típusú érték tárolására tervezték. Dinamikus típusnak hívják, mert az értékek típus-ellenőrzése futási időben történik

dinamikus x = 10

• Karakterlánc típusa

A karakterlánc típusa itt érhető el System.String osztály. A String Type karakterlánc-literálok tárolására készült. A húrliterálist két formában tároljukkét forma

• • idézett
  • @idézett.

S karakterlánc = 'Edureka'

• Az @idézett string literal úgy néz ki

@ 'Edureka'

Most értsük meg a változókat.

Változók

A változók a memória helyének kijelölt nevek, amelyek a felhasználó által megadott bizonyos adatokat tárolnak, és amelyek könnyen hozzáférhetők a változó név használatával. A C # -ben ötféle változó áll rendelkezésre

Példa:

int a, b dupla x úszó p char abc

A változók C # -ben való deklarálásához betartandó szabályok

• Egy változó tartalmazhat ábécét, számjegyeket és aláhúzásokat.
• A változó neve csak ábécével vagy aláhúzással kezdődhet.
• A változók nem kezdődhetnek számjeggyel vagy speciális karakterrel.
• A szóköz nem megengedett a változó neve között.
• A fenntartott kulcsszavak korlátozottan használhatók változó névként.

Operátorok

Az operátor meghatározható egy speciális szimbólumként, amely megmagyarázza a számítógép számára, hogy egy adott matematikai műveletet egy változóhalmazon alapuló logikai művelet végezzen. A C # számos operátort tartalmaz, amelyeket az alábbiakban említünk.

• Számtani operátorok
• Relációs operátorok
• Logikai operátorok
• Bitenkénti operátorok
• Feladatkezelők

Számtani operátorok

Relációs operátorok

Logikai operátorok

Bitenkénti operátorok

Feladatkezelők

Hurkok

NAK NEK hurok utasítás egy utasításblokk ismételt végrehajtására szolgál, amíg egy adott feltétel nem teljesül. A C # nyelv a következő hurok utasításokból áll.

• A hurok számára
• Míg a hurok
• Csináld, amíg hurok

A hurok számára

Az hurokhoz egy adott kódszegmens többszöri végrehajtására szolgál, amíg az adott feltétel teljesül.

Szintaxis

for (inicializálási feltétel növekménye / csökkenése) {// kódszegmens}

Folyamatábra:

Példa:

Rendszer nyilvános osztály használata ForExample {public static void Main (string [] args) {for (int i = 1 i<= 5 i++) { Console.WriteLine(i) } } } 

//Kimenet:

egy
2
3
4
5.

Míg a hurok

Az Miközben hurok kódszegmens többszöri végrehajtására szolgál, amíg egy adott feltétel teljesül.

Szintaxis

while (feltétel) {// végrehajtandó kód}

Folyamatábra:

Példa:

a rendszer névtér használatával Hurkok {class Program {static void Main (string [] args) {int x = 5 while (x<= 10) { Console.WriteLine('The value of a: {0}', x) x++ } Console.ReadLine() } } } 

//Kimenet:

A értéke: 5
A értéke: 6
A értéke: 7
A értéke: 8
A értéke: 9
A értéke: 10

Csináld, amíg hurok

A Do while ciklus teljesen hasonló a While Loop-hoz, de az egyetlen különbség az, hogy a feltétel a hurok végén helyezkedik el. Ezért a ciklus legalább egyszer végrehajtásra kerül.

Szintaxis

do {// végrehajtandó kód}} while (feltétel)

Folyamatábra:

Példa:

a Rendszer névtér használatával 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, szorzat) i ++} míg (i<= 10) } } } 

//Kimenet:

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

Feltételes

Feltételes nyilatkozatok végrehajtására használják nyilatkozat vagy csoportja nyilatkozatok valamilyen feltétel alapján. Ha a állapot akkor igaz C # állítások kivégzik egyébként a következő nyilatkozat kivégzik.

A C ++ nyelvű feltételes állítások különböző típusai a következők:

1. Ha állítás
2. If-Egyéb nyilatkozat
3. Beágyazott If-else utasítás
4. If-Egyéb If létra
5. Switch utasítás

Ha állítás

Az egyedülálló ha utasítás C # nyelven használható a kód végrehajtására, ha egy feltétel igaz. Egyirányú kiválasztási nyilatkozatnak is nevezik.

Szintaxis

if (logikai kifejezés) {// utasítások végrehajtva, ha a logikai kifejezés igaz}

Folyamatábra:

Példa:

a Rendszer névtér használatával Feltételes {class IfStatement {public static void Main (string [] args) {int szám = 2 if (szám<5) { Console.WriteLine('{0} is less than 5', number) } Console.WriteLine('This statement is always executed.') } } } 

//Kimenet:

2 kisebb, mint 5
Ez az utasítás mindig végrehajtásra kerül.

If-Egyéb nyilatkozat

Az ha más utasítás C nyelven használható a kód végrehajtására, ha a feltétel igaz vagy hamis. Kétirányú kiválasztási nyilatkozatnak is nevezik.

Szintaxis

if (logikai kifejezés) {// utasítások végrehajtása, ha a logikai kifejezés igaz} else {// utasítások végrehajtása, ha a logikai kifejezések hamisak}

Folyamatábra:

Példa:

a Rendszer névtér használatával Feltételes {class IfElseStatement {public static void Main (string [] args) {int szám = 12 if (szám<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.') } } } 

//Kimenet:

A 12 értéke nagyobb vagy egyenlő, mint 5
Ez az utasítás mindig végrehajtásra kerül.

Beágyazott If-else utasítás

A beágyazott ha más utasítás akkor használható, ha egy programhoz több teszt kifejezés szükséges. Többirányú kiválasztási utasításnak is nevezik. Amikor egy döntéssorozat szerepel egy nyilatkozatban, akkor azt használjuk ha más nyilatkozat beágyazott formában.

Szintaxis

if (logikai kifejezés) {if (beágyazott kifejezés-1) {// végrehajtandó kód} else {// végrehajtandó kód}} else {if (beágyazott kifejezés-2) {// végrehajtandó kód } else {// végrehajtandó kód}}}

Folyamatábra:

Példa:

a rendszer névterének használata Feltételes {osztály Beágyazva {public static void Main (string [] args) {int első = 7, második = -23, harmadik = 13 if (első & gt másodperc) {if (első
 //Kimenet: 
13 a legnagyobb
 Egyébként, ha létra 
Az  ha-másképp-ha  utasítás egy kód több feltételből történő végrehajtására szolgál. Többutas döntési nyilatkozatnak is nevezik. Ez az if..else utasítások láncolata, amelyben mindegyik if utasítás társul a else if utasításhoz és last egy else utasítás lenne.
 Szintaxis 
if (feltétel1) {// végrehajtandó kód, ha a feltétel1 igaz} else if (feltétel2) {// végrehajtandó kód, ha a feltétel2 igaz} else if (feltétel3) {// végrehajtandó kód, ha a feltétel3 igaz} ... else {// végrehajtandó kód, ha az összes feltétel hamis}
 Folyamatábra: 
 Példa: 
az Edureka rendszerosztály használatával {public static void Main (String [] args) {int i = 20 if (i == 10) Console.WriteLine ('i is 10') else if (i == 15) Console.WriteLine (' i is 15 ') else if (i == 20) Console.WriteLine (' i is 20 ') else Console.WriteLine (' i nincs jelen ')}}
 //Kimenet: 
én 20 vagyok
 Switch utasítás 
 Kapcsoló  utasítás egy hosszú if-else-if létra helyettesítőjeként működik, amelyet az esetek listájának tesztelésére használnak. A switch utasítás egy vagy több esetcímkét tartalmaz, amelyeket a kapcsoló kifejezéssel szemben tesztelnek. Amikor a kifejezés megegyezik egy esettel, akkor az adott esethez társított utasítások végrehajtásra kerülnek.
 Szintaxis 
kapcsoló (változó / kifejezés) {esetérték1: // utasítások végrehajtása, ha kifejezés (vagy változó) = érték1 töréses esetérték2: // utasítások végrehajtása, ha kifejezés (vagy változó) = érték1 törés ... ... ... .. . ... ... alapértelmezett: // utasítások végrehajtva, ha egyetlen eset sem felel meg}
 Folyamatábra: 
 Példa: 
Rendszernévtér használata Feltételes {class SwitchCase {public static void Main (string [] args) {char ch Console.WriteLine ('Adj meg egy ábécét') ch = Convert.ToChar (Console.ReadLine ()) kapcsoló (Char.ToLower (ch )) {eset 'a': Console.WriteLine ('magánhangzó') törés: 'e': Console.WriteLine ('magánhangzó') break case 'i': Console.WriteLine ('magánhangzó') break case 'o': Console.WriteLine ('magánhangzó') törés: 'u': Console.WriteLine ('magánhangzó') törés alapértelmezett: Console.WriteLine ('nem magánhangzó') törés}}}}
 //Kimenet: 
Írjon be egy ábécét 
 van 
 Magánhangzó
 Húrok 
 Húr Az Adattípus a System.String Osztály. Képes karakter típusú adatok tárolására. Különféle műveleteket hajthatunk végre a Stings-en, mint plösszefűzés, összehasonlítás, szubsztring megszerzése, keresés, kivágás, csere és még sok más.
 A húr és a húr analógiája 
C # -ben Húr és húr egyenértékűek. A húr szó a kulcsszó és a System.String osztály. A karakterláncok deklarálásához bármelyik verziót használhatjuk.
 Szintaxis: 
string s1 = 'Edureka' // karakterlánc létrehozása karakterlánc kulcsszóval String s2 = 'Happy Learning' // karakterlánc létrehozása karakterlánc osztály használatával
 Példa: 
Rendszer nyilvános osztály használata 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 = új karakterlánc (ch) Console.WriteLine ( s1) Console.WriteLine (s2)}}
 //Kimenet: 
Edureka 
 Csharp bemutató
 Karakterláncok a C # -ben 
 Módszer 
 Leírás 
 Klón () 
A String ezen példányára való hivatkozás visszaadására szolgál.
 Összehasonlítás (karakterlánc, karakterlánc) 
Két megadott String objektum összehasonlítására szolgál.
 Concat (húr, húr) 
Összekapcsolja a String két meghatározott példányát.
 Tartalmaz (karakterlánc) 
Adjon meg egy értéket, amely egy megadott részláncot jelöl
 Másolás (karakterlánc) 
Új azonos karakterláncú String példány létrehozására szolgál
 CopyTo (Int, Char [], Int, Int) 
Karaktereket másol egy megadott pozícióból
 Egyenlő (húr, húr) 
Meghatározza, hogy két karakterlánc objektumnak ugyanaz az értéke.
 Formátum (karakterlánc, objektum) 
Cseréljen egy vagy több formátumot egy megadott karakterláncba
 IndexOf (karakterlánc) 
Jelzi az első előfordulás nulla alapú indexét
 Beszúrás (Int32, String) 
Visszaad egy új karakterláncot, amelyben egy karakterlánc szerepel egy indexben.
 IsInterned (karakterlánc) 
Azt jelzi, hogy ez a karakterlánc Unicode normalizációs C formában van.
 IsNullOrEmpty (karakterlánc) 
Azt jelzi, hogy a megadott karakterlánc null vagy üres karakterlánc.
 IsNullOrWhiteSpace (karakterlánc) 
Jelzi, hogy egy megadott karakterlánc null, üres,
 Csatlakozás (húr, húr []) 
A string tömb összes elemének összefűzésére szolgál
 LastIndexOf (Char) 
Jelzi az utolsó karakter nulla alapú indexpozícióját
 LastIndexOfAny (Char []) 
Jelzi az utolsó karakter nulla alapú indexpozícióját
 Eltávolítás (Int32) 
Új karakterláncot ad vissza, amelyben az összes karakter szerepel
 Csere (karakterlánc, karakterlánc) 
Visszaad egy új karakterláncot, amelyben a karakterlánc minden előfordulása szerepel
 Felosztás (Char []) 
Arra szolgál, hogy egy karakterláncot sztringekre bontson
 Starts (String) 
Arra használják, hogy ellenőrizzék, hogy a karakterlánc eleje-e
 Substring (Int32) 
Arra szolgál, hogy lekérdezzünk egy alszekciót erről a példányról.
 ToCharArray () 
Az ebben a példában szereplő karaktereket egy Unicode tömbbe másolja.
 ToString () 
A String példányának visszaadására szolgál.
 Vágás () 
Vágja le a húrot
  
Tömbök 
A többi programozási nyelvhez hasonlóan a C # is rendelkezik tömbökkel. A tömbök azok az egyszerű adatstruktúrák, amelyeket ugyanazon elemtípusok tárolására terveztek egy összefüggő memóriahelyen.
A C # a következő tömbtípusokat támogatja.
Egydimenziós tömb
Többdimenziós tömb
Jagged Array
 Egydimenziós tömb 
Az Egydimenziós tömb elemeit egyetlen sor formájában tárolja.
 Szintaxis 
int [] arr = new int [5] // tömb létrehozása
 Példa: 
Array rendszer nyilvános osztályának használataPélda {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 for (int i = 0 i 
 //Kimenet: 
10. 
 húsz 
 30 
 40 
 ötven
 Többdimenziós tömb 
A Többdimenziós tömb több dimenzió formájában tárolja az elemeket, például mátrix, kocka stb.
 Szintaxis 
int val = a [2,3]
 Példa: 
Rendszernévtér használata 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 for (i = 0 i<5 i++) { for (j = 0 j < 2 j++) { Console.WriteLine('a[{0},{1}] = {2}', i, j, a[i, j]) } } Console.ReadKey() } } } 
 //Kimenet: 
a [0,0] = 0 
 a [0,1] = 0 
 a [1,0] = 1 
 a [1,1] = 2 
 a [2,0] = 2 
 a [2,1] = 4 
 a [3,0] = 3 
 a [3,1] = 6 
 a [4,0] = 4 
 a [4,1] = 8
  
 Jagged Array 
A Jagged Array egyszerűen tömbtömb.
 Példa: 
ArrayApplication rendszernévtér használata {class MyArray {static void Main (string [] args) {int [] [] a = new int [] [] {new int [] {0,0}, new int [] {1,2 }, új int [] {2,4}, új int [] {3, 6}, új int [] {4, 8}} int i, j for (i = 0 i<5 i++) { for (j = 0 j < 2 j++) { Console.WriteLine('a[{0}][{1}] = {2}', i, j, a[i][j]) } } Console.ReadKey() } } } 
 //Kimenet: 
a [0] [0] = 0 
 a [0] [1] = 0 
 a [1] [0] = 1 
 a [1] [1] = 2 
 a [2] [0] = 2 
 a [2] [1] = 4 
 a [3] [0] = 3 
 a [3] [1] = 6 
 a [4] [0] = 4 
 a [4] [1] = 8
 Gyűjtemények 
A gyűjtést egyszerűen az objektumok együttes csoportjának tekinthetjük, hogy bizonyos funkciókat alkalmazzunk az összegyűjtött adatokra. Azok a műveletek, amelyek egyszer csak elvégezhetők egy gyűjteményen,
tárolja az objektumot
objektum frissítése
objektum törlése
objektum lekérése
keresési objektum, és
objektum rendezése
 Gyűjteménytípusok 
Három különböző lehetőség van a gyűjteményekkel való együttműködésre. A három névteret az alábbiakban említjük:
 Rendszer. Gyűjtemények. Általános  osztályok
 Rendszer. Gyűjtemények  osztályok
 System.Collections.Concurrent  osztályok
A System.Collections.Generic osztály a következő osztályfajtákkal rendelkezik:
Lista
Kazal
Sor
LinkedList
HashSet
SortedSet
Szótár
SortedDictionary
SortedList
Az Rendszer. Gyűjtemények osztályokat örökölt osztályoknak tekintjük. a következő osztályokat tartalmazzák.
Tömb lista
Kazal
Sor
Hashtable
Az System.Collections.Concurrent  osztályokA névtér osztályokat kínál a szálbiztos műveletekhez. Most több szál nem okoz problémát a gyűjteményelemek elérésében. az ebben elérhető osztályok:
BlockingCollection
ConcurrentBag
ConcurrentStack
ConcurrentQueue
ConcurrentDictionary
Partíciók
Partíciók
OrderablePartitioner
 Lista 
Az lista alatt elérhető adatstruktúrának tekinthető System.Collection.Generics névtér. Elemeket tud tárolni és lekérni. A lista képes duplikált elemek tárolására.
 Példa: 
Rendszer használata a System.Collections.Generic public class Edureka {public static void Main (string [] args) {var names = new List () names.Add ('Sandhya') names.Add ('Arun') names.Add ( 'Prashanth') nevek. Add ('Kiran') foreach (var név a nevekben) {Console.WriteLine (név)}}}
 //Kimenet: 
Sandhya 
 Egy futás 
 Prashanth 
 Kiran
 Hash Set 
C # HashSetkategória gyakran szokottbolt,elvitelvagyolvassa el az összetevőket. Aztnemtárolja a másolatotalkatrészek.sürgetikhasználni HashSet  kategóriahamegvantárolnikizárólag  megkülönböztető   alkatrészek . ez van megtalálható a System.Collections.Generic névtérben.
 Példa: 
Rendszer használata a System.Collections.Generic public class Edureka {public static void Main (string [] args) {var names = new HashSet () names.Add ('Sunil') names.Add ('Amar') names.Add ( 'Pujari') nevek. Add hozzá ('Imran') neveket. Add ('karan') foreach (var név a nevekben) {Console.WriteLine (név)}}}
 //Kimenet: 
Sunil 
 Amar 
 Pujari 
 Imran 
 karan
 Rendezett készlet 
C # SortedSetosztály gyakran megszoktabolt, eltávolítani vagy olvas   elemek . Fenntartja a növekvő rendet ésnemtárolja a másolatotelemek.gyorsa SortedSet használatáhozkategóriahamegvantárolni megkülönböztető   alkatrészek és fenntartani a növekvő rendet.ez vanmegtalálható a System.Collections.Generic névtérben.
 Példa: 
Rendszer használata a System.Collections.Generic public class Edureka {public static void Main (string [] args) {var names = new SortedSet () names.Add ('Sanjay') names.Add ('Anuradha') names.Add ( 'Praveen') nevek. Add hozzá ('Ravi') neveket. Add ('Kajol') foreach (var név a nevekben) {Console.WriteLine (név)}}
 //Kimenet: 
Anuradha 
 Kajol 
 Praveen 
 Ravi 
 Sanjay
 Kazal 
Az Kazal egy egyszerű gyűjtemény, amely ezt követi ÉL vagy az első a legutolsó művelet során a benne tárolt elemek feldolgozása közben.
 Példa: 
Rendszer használata a System.Collections.Generic public class Edureka {public static void Main (string [] args) {Stack names = new Stack () names.Push ('Chandan') names.Push ('Pooja') names.Push ( 'James') nevek. Nyomja meg a ('Rajesh') neveket. Nyomja meg ('kumar') foreach (karakterlánc neve a nevekben) {Console.WriteLine (name)} Console.WriteLine ('Peek element:' + names.Peek () ) Console.WriteLine ('Pop:' + nevek.Pop ()) Console.WriteLine ('Pop után Peek elem:' + nevek.Peek ())}}
 //Kimenet: 
kumar 
 Rajesh 
 James 
 Pooja 
 Chandan 
 Peek elem: kumar 
 Pop: kumar 
 A Pop, Peek elem után: Rajesh
 Sor 
A sor teljesen hasonlít a Stack-hez, de az egyetlen különbség az, hogy a sor következik FIFO vagy az első be és az első kimenet elve a benne tárolt elemek feldolgozása közben.
 Példa: 
Rendszer használatával a System.Collections.Generic public class Edureka {public static void Main (string [] args) {Queue names = new Queue () names. Enqueue ('Srujan') names.Enqueue ('Prajat') names.Enqueue ( 'John') nevek. Enqueue ('Raju') nevek. Enqueue ('Hari') foreach (karakterlánc neve a nevekben) {Console.WriteLine (név)} Console.WriteLine ('Peek elem:' + nevek.Peek () ) Console.WriteLine ('Dequeue:' + nevek.Dequeue ()) Console.WriteLine ('Dequeue után Peek elem:' + nevek.Peek ())}}
 //Kimenet: 
Srujan 
 Prajat 
 János 
 Vad 
 Nap 
 Peek elem: Srujan 
 Dequeue: Srujan 
 Dequeue után Peek elem: Prajat
 Összekapcsolt lista 
A csatolt lista egy dinamikus memóriagyűjtemény. A Csatolt lista elemeit úgy tárolják, hogy hozzáférnek a memóriához a kupacból, és az elemeket folyamatos sorrendben tárolják a címeik összekapcsolásával.
 Példa: 
Rendszer használata a System.Collections.Generic public class Edureka {public static void Main (string [] args) {var names = new LinkedList () names.AddLast ('Rajat') names.AddLast ('Arun') names.AddLast ( 'Prakash') nevek.AddLast ('jay') nevek.AddFirst ('sai') foreach (var név a nevekben) {Console.WriteLine (név)}}}
 //Kimenet: 
sai 
 Határok 
 Egy futás 
 Prakash 
 szajkó
 Szótár 
 Szótár  kategóriahasználja aötleta hashtable. Értékeket tárol aaz előfeltevésa kulcs. Tartalmazmegkülönböztetőkulcsokkizárólag. Általa segítségnyújtáskulcs,egyszerűen fogunkkeresés vagyelemeket elvinni.ez vanmegtalálható a System.Collections.Generic névtérben.
 Példa: 
Rendszer használata a System.Collections.Generic public class Edureka {public static void Main (string [] args) {Dictionary names = new Dictionary () names.Add ('1', 'Shiva') names.Add ('2', 'Prasad') nevek. Adjon hozzá ('3', 'Preetam') neveket. Adjon hozzá ('4', 'Roy') neveket. Add ('5', 'Akash') foreach (KeyValuePair kv a nevekben) {Console. WriteLine (kv.Key + '' + kv.érték)}}}
 //Kimenet: 
1 Shiva 
 2 Prasad 
 3 Preetam 
 4 Roy 
 5.Akash
 Rendezett szótár 
Az SortedDictionary  kategóriahasználja atervezésa hashtable. Értékeket tárol aAz ötleta kulcs. Tartalmazmegkülönböztetőkulcsokat és fenntartja a növekvő sorrendetAz ötleta kulcs. Általa segítségnyújtáskulcs,egyszerűen fogunkkeresés vagyelemeket elvinni.ez vanmegtalálható a System.Collections.Generic névtérben.
 Példa: 
A System használata a System.Collections.Generic public class Edureka {public static void Main (string [] args) {SortedDictionary names = new SortedDictionary () names. Add ('1', 'Arun') names.Add ('4', 'Vishal') nevek. Adjon hozzá ('5', 'Ramesh') neveket. Adjon hozzá ('3', 'Vidya') neveket. Add ('2', 'Pallavi') foreach (KeyValuePair kv névben) {Konzol. WriteLine (kv.Key + '' + kv.érték)}}}
 //Kimenet: 
1 Shiva 
 2 Prasad 
 3 Preetam 
 4 Roy 
 5.Akash
 Rendezett lista 
Az SortedList vanankulcs / érték pár tömb. Értékeket tárol aaz előfeltevésa kulcs. A rendezett listakategóriatartalmazmegkülönböztetőkulcsokat és fenntartja a növekvő sorrendetaz előfeltevésa kulcs. Általa segítségnyújtáskulcs,egyszerűen képesek vagyunkkeresés vagy eltávolításelemek.ez vantalálhatók Rendszer. Gyűjtemények. Általános névtér.
 Példa: 
A System használata a System.Collections.Generic public class Edureka {public static void Main (string [] args) {SortedDictionary names = new SortedDictionary () names. Add ('1', 'Arun') names.Add ('4', 'Vishal') nevek. Adjon hozzá ('5', 'Ramesh') neveket. Adjon hozzá ('3', 'Vidya') neveket. Add ('2', 'Pallavi') foreach (KeyValuePair kv névben) {Konzol. WriteLine (kv.Key + '' + kv.érték)}}}
 //Kimenet: 
1 Arun 
 2 Pallavi 
 3 Vidya 
 4 Vishal 
 5.Ramesh
 Szerkezet 
A szerkezet egy felhasználó által definiált adattípus, amelyet a különböző adattípus több elemének tárolására terveztek. A struktúra deklarálása a kulcsszóval történik strukturált. 
 Példa: 
System struct Books használatával {public string title public string author public string subject public int book_id} public class 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 ( '1. könyv címe: {0}', Book1.title) Console.WriteLine ('1. Book Author: {0}', Book1.author) Console.WriteLine ('1. könyv tárgya: {0}', Book1.subject) Console.WriteLine ('1. könyv book_id: {0}', Book1.book_id) Console.WriteLine ('2. könyv címe: {0}', Book2.title) Console.WriteLine ('2. könyv szerzője: {0}', Book2.author) Console.WriteLine ('2. könyv tárgya: {0}', Book2.subject) Console.WriteLine ('2. könyv book_id: {0}', Book2.book_id) Console.ReadKey ()}}
 //Kimenet: 
1. könyv címe: C # Programozás 
 1. könyv Szerző: Ramchandra Kumar 
 1. könyv tárgya: C ++ programozási bemutató 
 1. könyv book_id: 95908978 
 2. könyv címe: Távközlési számlázás 
 2. könyv Szerző: Karan 
 2. könyv tárgya: Távközlési számlázási útmutató 
 2. könyv book_id: 18674900
 Funkciók 
A függvény meghatározása a főkód kódblokkja. A függvény a kódblokkban megadott utasítások végrehajtására szolgál. A függvény a következő összetevőkből áll.
 Funkció neve:  Ez egy megkülönböztető név, amelyet a Function hívás kezdeményezésére használnak.
 Vissza típus:  Megadja a függvény visszatérési értékének adattípusát.
 Test:  Futtatható utasításokat tartalmaz.
 Hozzáférési specifikátor:  Megadja a funkciók akadálymentességét az alkalmazásban.
 Paraméterek:  Ez egy olyan argumentumlista, amelyet átadhatunk a függvénynek a hívás során.
 Szintaxis 
FunctionName () {// function body // return utasítás}
 Példa: 
A Rendszer névtér használata FunkcióPélda {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 .Show ('Edureka') Console.WriteLine ('Welcome' + üzenet)}}}
 //Kimenet: 
Inside Show funkció 
 Üdvözöljük az Edurekában
A funkciókat 3 különböző módon lehet végrehajtani:
Hívás érték szerint
Hívás referenciával
Ki paraméter
 Hívás érték szerint 
C # -ben, érték  -típus paraméterekvannakhogy átmásolateredeti értéket afunkció helyettreferencia. Aztnemmódosítaz első érték. Anmódosítás létrehozvapasszbanérték nemKoraz adott érték.belülkövetkező példa,megvanpasszérték az egészazhívás.
 Példa: 
a Rendszer névtér használatával CallByValue {class Edureka {public void Show (int val) {val * = val Console.WriteLine ('A show függvényen belüli érték' + val)} static void Main (string [] args) {int val = 50 Edureka program = új Edureka () Console.WriteLine ('Érték a függvény meghívása előtt' + val) program. Show (val) Console.WriteLine ('Érték a függvény meghívása után' + val)}}}
//Kimenet:
Érték az 50-es függvény meghívása előtt 
 A show függvényen belüli érték 2500 
 Érték az 50-es függvény meghívása után
 Hívás referenciával 
A Call by Reference módszerbennak nek ref kulcsszó az argumentum referenciatípusként történő továbbításához. Az argumentumok hivatkozását a függvényre továbbítja, nem pedig az eredeti érték másolatára. Az átadott értékek változása állandó és módosít az eredeti változó értéke.
 Példa: 
a Rendszer névtér használatával CallByReference {class Edureka {public void Show (ref int val) {val * = val Console.WriteLine ('Az érték a show függvény belsejében' + val)} static void Main (string [] args) {int val = 50 Edureka program = új Edureka () Console.WriteLine ('Érték a függvény meghívása előtt' + val) program. Show (ref val) Console.WriteLine ('Érték a függvény meghívása után' + val)}}}
//Kimenet:
Érték az 50-es függvény meghívása előtt 
 A show függvényen belüli érték 2500 
 Érték a függvény 2500 meghívása után
 Ki paraméter 
Az Out paraméterbiztosítja ki kulcsszó az argumentumok out-típusként történő továbbításához. Olyan, mint a referencia-típus, azzal a különbséggel, hogy nem szükséges a változó inicializálása az átadás előtt. Ki kell használnunk ki kulcsszó az argumentum out-típusként történő továbbításához. Akkor hasznos, ha azt akarjuk, hogy egy függvény több értéket adjon vissza.
 Példa: 
A Rendszer névtér használata 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 ('Érték a' + val változó elosztása előtt 'program. Show (out val) Console.WriteLine (' Érték a kimenő változó beérkezése után '+ val)}}}
//Kimenet:
Érték az 50-es változó kiadása előtt
Értékmiután megkapta a kimenő 25 változót
Most térjünk át az objektum-orientált programozásra
 Objektumorientált programozás 
 Objektumorientált programozás Rendszerfogalmán alapuló programozási paradigma tárgyakat amelyek tartalmazzák adattagok és mód velük kapcsolatos. Az objektum-orientált programozás elsődleges célja a programok rugalmasságának és fenntarthatóságának növelése
 Az objektum-orientált programozás jellemzői: 
Az eljárás helyett inkább az adatokra helyezi a hangsúlyt.
A programok objektumokra vannak osztva, így megkönnyítik a munkát.
Az adatszerkezetek úgy vannak megtervezve, hogy jellemezzék az objektumokat.
Működő funkciók továbbegy objektum adatait együtt helyezzük el az adatstruktúrában.
Az adatok rejtve vannak, és külső funkciók nem férhetnek hozzá engedély nélkül.
Az objektumok közötti kommunikáció funkciók segítségével valósulhat meg.
Új adatok és funkciók hozzáadása egyszerűvé vált.
Az alulról felfelé építkező megközelítést követi a program tervezésében.
A C # objektumorientált paradigmái a következők
 Számlálás C # számban 
 Objektumorientált programozási megközelítés 
 Egységbezárás 
 Absztrakció 
 Felület 
 Polimorfizmus 
 Öröklés 
 Túlterhelés és felülbírálás 
 Névtér 
 Fájlműveletek 
 Események 
 Generikusok 
 Küldöttek 
 Visszaverődés 
 Számlálás C # számban 
 Enum vagy anként is hívják felsorolás A C # -ban állandó értékek tárolására szolgál, anélkül, hogy azokat a C # program teljes végrehajtása során meg kellene változtatni. Azta megnevezett állandók készletének tárolására szolgál, például évszak, napok, hónap, méret stb
 Példa: 
Rendszer nyilvános osztály használata EnumPélda {public enum hét {hétfő, kedd, szerda, csütörtök, péntek, szombat, vasárnap} public static void Main () {int x = (int) week. .WriteLine ('Monday = {0}', x) Console.WriteLine ('Friday = {0}', y)}}
 //Kimenet: 
Hétfő = 0 
 Péntek = 4
 Objektumorientált programozási megközelítés 
Az objektum-orientált programozási stílust az alábbiakban leírt módszerek követésével lehet elérni.
 Egységbezárás 
  
 Egységbezárás egy módszer a mód velük együtt adattagok. 
 Példa: 
a Rendszer névtér használatával Edureka {osztály Téglalap {nyilvános kettős hosszúságú nyilvános kettős szélességű nyilvános kettős GetArea () {visszatérési hossz * szélesség} nyilvános érvénytelen Display () {Console.WriteLine ('Hossz: {0}', hossz) Console.WriteLine (' Szélesség: {0} ', width) Console.WriteLine (' Area: {0} ', GetArea ())}} class ExecuteRectangle {static void Main (string [] args) {Rectangle r = new Rectangle () r.length = 50 r.szélesség = 35 r.Display () Console.ReadLine ()}}}
 //Kimenet: 
Hossz: 50 
 Szélesség: 35 
 Terület: 1750
 Absztrakció 
 Absztrakció egy módszer arra elrejt a felhasználó bonyolult kódoló részét azáltal, hogy csak a szükséges információkat megadja neki.
 Példa: 
A rendszer használata public absztrakt osztály Alakzat {public abstract void draw ()} nyilvános osztály Téglalap: Alakzat {public override void draw () {Console.WriteLine ('rajz téglalap ...')}} public class Kör: Alakzat {public override void draw () {Console.WriteLine ('rajzkör ...')}} public class TestAbstract {public static void Main () {Shape ss = new Rectangle () s.draw () s = new Circle () s.draw ()}}
 //Kimenet: 
téglalap rajzolása ... 
 rajz kör ...
 Felület 
  
Az felület teljesen hasonló az Absztrakcióhoz. Az interfész funkciója az, hogy elrejtse a nem fontos adatokat a felhasználó elől, és megadja neki az egyetlen fontos adatot, amelyre szüksége van.
 Példa: 
a rendszer nyilvános felületének használata Drawable {void draw ()} public class Téglalap: Drawable {public void draw () {Console.WriteLine ('drawing rectangle ...')}} public class Circle: Drawable {public void draw () {Console .WriteLine ('rajzkör ...')}} public class TestInterface {public static void Main () {Rajzolható dd = új téglalap () d.draw () d = új kör () d.draw ()}}
 //Kimenet: 
téglalap rajzolása ... 
 rajz kör ...
 Polimorfizmus 
Polimorfizmuskombinációja „Poli” + „Morphs” ami sokféle formát jelent. Ez egy görög szó. Ez azt jelenti, hogy a kódszegmens többféle formát ölthet. A polimorfizmusnak két típusa van.
Időpolimorfizmus összeállítása
Futási idő polimorfizmus
 Példa: 
A rendszer használatával 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)}}
 //Kimenet: 
fehér
 Öröklés 
 Öröklés olyan folyamat, amelynek során egy objektum automatikusan megszerzi a szülő objektum összes tulajdonságát és viselkedését. Újra felhasználhatja, kiterjesztheti vagy módosíthatja az attribútumokat és a viselkedést, amelyet egy másik osztály határoz meg. azt az osztályt hívják, amely egy másik osztály tagjait örökli származtatott osztály és azt az osztályt, amelynek tagjai örököltek, az bázis osztály. A levezetett osztály az alaposztály speciális osztálya.
 Példa az egyszintű öröklésre 
Rendszer névtér használata RectangleApplication {class Rectangle {védett dupla hosszúságú védett dupla szélességű public Rectangle (double l, double w) {length = l width = w} public double GetArea () {return length * width} public void Display () {Console. WriteLine ('Hossz: {0}', hossz) Console.WriteLine ('Szélesség: {0}', szélesség) Console.WriteLine ('Terület: {0}', GetArea ())}} osztály Asztallap: Téglalap {privát dupla költségű nyilvános asztali (dupla l, dupla w): alap (l, w) {} public double GetCost () {double cost cost = GetArea () * 70 return cost} public void Display () {base.Display () Console .WriteLine ('Költség: {0}', GetCost ())}}} osztály ExecuteRectangle {static void Main (string [] args) {Asztali t = új Asztali (4.5, 7.5) t.Display () Console.ReadLine () }}}
 //Kimenet: 
Hossz: 4.5 
 Szélesség: 7.5 
 Terület: 33,75 
 Költség: 2362,5
 Példa többszintű öröklődésre 
a Rendszer névtér használatával InheritanceApplication {class Shape {public void setWidth (int w) {width = w} public void setHeight (int h) {height = h} protected int width protected int height} public interface PaintCost {int getCost (int area)} osztály Téglalap: Alak, PaintCost {public int getArea () {return (width * height)} public int getCost (int area) {return area * 70}} class RectangleTester {static void Main (string [] args) {Téglalap Rect = új Téglalap () int terület Rect.setWidth (5) Rect.setHeight (7) terület = Rect.getArea () Console.WriteLine ('Teljes terület: {0}', Rect.getArea ()) Console.WriteLine ('Összesen festékköltség: $ {0} ', Rect.getCost (area)) Console.ReadKey ()}}}
 //Kimenet: 
Teljes terület: 35 
 Teljes festékköltség: 2450 USD
 Túlterhelés 
A túlterhelés olyan helyzet, amikor kettőnk vagy tagunk van azonos néven deklarálva. Túlterhelés akkor is lehetséges, ha két vagy több metódust is deklarálunk ugyanazzal a névvel. Nézzünk példákat mindkettőre.
 Tag túlterhelése 
 Példa: 
System nyilvános osztály használata 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 TestMemberOerloading { public static void Main () {Console.WriteLine (Edureka.add (12, 23)) Console.WriteLine (Edureka.add (12, 23, 25))}}
 //Kimenet: 
35 
 60
 Módszer Túlterhelés 
 Példa: 
a rendszer használatával 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))}}
 //Kimenet: 
35 
 33.699997
 Felülbíráló 
Az elsőbbség olyan helyzet, amikor a gyermekosztály ugyanazt a módszert definiálja, amelyet a szülő is. Értsük meg ezt egy kis példán keresztül.
 Példa: 
Rendszer használata nyilvános osztály 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 () {Kutya d = új Kutya () d.eat ()}}
 //Kimenet: 
Ételt enni
 Névtér 
Az névtér alapvetően a programban jelenlévő több osztály kezelésére szolgál. A névtér különféle módon érhető el.
 System.Console: Itt a Rendszer névtérré válik
A névtér osztályának eléréséhez használnunk kell namespacename.clnamename. 
Használhatjuk a felhasználásával kulcsszó is.
 Példa: 
Rendszer használata Első használatával Második névtér használata Első {public class Edureka {public void sayWelcome () {Console.WriteLine ('Welcome to Edureka')}}}} névtér Második {public class Happy_Learning {public void sayWishes () {Console.WriteLine (' Boldog tanulást ')}}} public class Namespace {public static void Main () {Edureka h1 = new Edureka () Happy_Learning w1 = new Happy_Learning () h1.sayWelcome () w1.sayWishes ()}}
 //Kimenet: 
Üdvözöljük az Edurekában 
 Boldog tanulást
 Fájlműveletek 
Az fájlműveletek C # -ben elérhetőek a következők:
 Művelet 
 Leírás 
 BinaryReader 
A primitív adatokat bináris adatfolyamból olvassa le.
 BinaryWriter 
A primitív adatokat bináris formátumban írja.
 BufferedStream 
Ideiglenes tárolás bájtfolyamhoz.
 Könyvtár 
Segít a címtárstruktúra manipulálásában.
 DirectoryInfo 
Könyvtárak műveleteinek végrehajtására szolgál.
 DriveInfo 
Információt nyújt a meghajtókról.
 File 
Segít a fájlok manipulálásában.
 FileInfo 
Fájlokkal végzett műveletek végrehajtására szolgál.
 FileStream 
Egy fájl bármely helyéről történő olvasásra és írásra használható.
 MemoryStream 
A memóriában tárolt adatfolyamok véletlenszerű elérésére szolgál.
 Pálya 
Műveleteket hajt végre az útvonal információin.
 StreamReader 
Használható karakterek olvasására egy bájtfolyamból.
 StreamWriter 
Karakterek adatfolyamba írására szolgál.
 StringReader 
Karakterlánc-pufferből történő olvasásra szolgál.
 StringWriter 
Karakterlánc-pufferbe történő íráshoz használatos.
 FileMode 
Az FileMode egy felsoroló, amely több fájlmegnyitási módszert határoz meg. A FileMode Enumerator tagjait a következőképpen írják le:
 Mellékel: Megnyit egy meglévő fájlt, és a kurzort a fájl végére viszi, vagy létrehozza a fájlt, ha a fájl nem létezik.
 Teremt: Úgy tervezték, hogy új fájlt hozzon létre.
 Újat készíteni: Úgy tervezték, hogy meghatározza az operációs rendszernek, hogy új fájlt kell létrehoznia.
 Nyisd ki: Meglévő fájl megnyitására szolgál.
 OpenOrCreate: Úgy tervezték, hogy meghatározza az operációs rendszert, amelynek meg kell nyitnia egy fájlt, ha létezik, különben új fájlt kell létrehoznia.
 Csonka: A Csonkítás megnyit egy meglévő fájlt, és méretét nulla bájtra csonkolja.
 FileAccess 
 FileAccess Az Enumerator egy adott fájlhoz való hozzáféréshez szokott. A következő tagok vannak.
 Olvas 
 Ír 
 Ír olvas 
 Fájlmegosztás 
Az Fájlmegosztás A számláló egy adott fájl megosztására szolgál. A következő tagok vannak.
 Örökölhető: Az örökölhető lehetővé teszi, hogy a fájlkezelő öröklést adjon át a gyermek folyamatainak.
 Egyik sem: Egyik sem utasítja el az aktuális fájl megosztását
 Olvas: Az Olvasás lehetővé teszi a fájl megnyitását olvasásra.
 Ír olvas: A ReadWrite lehetővé teszi a fájl megnyitását olvasáshoz és íráshoz.
 Ír: Az Írás lehetővé teszi a fájl megnyitását írásra.
 Események 
Az esemény általában a felhasználó által létrehozott művelet. Lehet, hogy egérkattintás vagy akár egyetlen billentyűleütés a billentyűzetről. Hasonlóképpen a C # programoknak is vannak eseményeik. Az esemény generátorát hívjuk kiadó és az esemény befogadóját nevezzük előfizető. 
 Kiadó 
NAK NEK kiadó tartalmazza az esemény és a küldött meghatározását. Az esemény-küldött ebben az objektumban az asszociáció van meghatározva. A kiadó osztály objektum meghívja az eseményt, és erről értesítik a többi objektumot.
 Előfizető 
NAK NEK előfizető elfogadja az eseményt és egy eseménykezelő. Az küldött a megjelenítő osztályban meghívja a metódust / eseményt kezelő az előfizetői osztály.
 Példa: 
a Rendszer névtér használatával 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 . '+ felhasználónév} static void Main (string [] args) {EventBlock obj1 = new EventBlock () string string = obj1.NewEvent (' Happy Learning ') Console.WriteLine (result)}}}
 //Kimenet: 
Üdvözöljük az Edurekában. Boldog tanulást
 Generikusok 
 Generikusok egy koncepció, amely egy osztály tagjainak és módszereinek biztosítását biztosítja a helybirtokosokkal Futásidő. A Generics segítségével definiálhatjuk zárójelek. Nézzük meg a következő példákat.
 Generikumok egy osztályban 
a Rendszer névtér használatával Edureka {class GenericClass {public GenericClass (T msg) {Console.WriteLine (msg)}} class Program {static void Main (string [] args) {GenericClass gen = new GenericClass ('Ez az üzenet generikus osztályból származik' ) GenericClass genI = new GenericClass (123) GenericClass getCh = new GenericClass ('E')}}}
 //Kimenet: 
Ez az üzenet a generikus osztálytól származik 
 123. 
 IS
 Generikus módszer 
a Rendszer névtér használatával 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 üzenet az általános metódustól származik ') genC.Show (321) genC.Show (' H ')}}}
 //Kimenet: 
Ez az üzenet a generikus módszerből származik 
 321 
 H
 Küldöttek 
Az Küldött a módszerre való hivatkozásként működik. Alapvetően ugyanaz, mint a funkciómutató C-ben és C ++ -ban, de sokkal jobb és típusbiztosabb. A küldött statikus módszer csak a módszert foglalja magában. Míg a küldött a példa A metódus a metódust és a példányt is összefoglalja. A delegált legjobb felhasználása az, ha a esemény. 
 Példa: 
a System delegate int kalkulátor használatával (int n) public class 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 szám} 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 ('Számológép után egy delegált, az új szám: '+ getNumber ()) c2 (3) Console.WriteLine (' Két delegált számológép után az új szám: '+ getNumber ())}}
 //Kimenet: 
Az egy küldött számológép után az új szám: 45 
 A két delegált számológép után az új szám: 135
 Visszaverődés 
A tükrözés szükséges a metaadatok futási időben történő megszerzéséhez. A referencia itt érhető el Rendszer.Tükrözés névtér. A következő osztályok végrehajtásához szükséges.
típus
MemberInfo
ConstructorInfo
MethodInfo
FieldInfo
PropertyInfo
TypeInfo
EventInfo
Modul
Összeszerelés
AssemblyName
Mutató
 Típusosztály 
A C # Type class az osztálytípusok, interfész típusok, felsorolási típusok, tömb típusok, értéktípusok típusdeklarációit jelenti
Írja be a Tulajdonságok parancsot
Az alábbiakban felsoroljuk a Type osztályok fontos tulajdonságainak listáját.
 Ingatlan 
 Leírás 
 Összeszerelés 
Megkapja a közgyűlést ehhez a típushoz.
 AssemblyQualifiedName 
Megkapja az Assembly minősített nevét ehhez a típushoz.
 Attribútumok 
Megkapja a típushoz társított attribútumokat.
 BaseType 
Megkapja az alap vagy a szülő típusát.
 Teljes név 
Megkapja a típus teljesen minősített nevét.
 Isabsztrakt 
annak ellenőrzésére szolgál, hogy a típus elvont-e.
 IsArray 
arra használják, hogy ellenőrizzék, hogy a típus Array-e.
 IsClass 
annak ellenőrzésére szolgál, hogy a típus osztály-e.
 IsEnum 
annak ellenőrzésére szolgál, hogy a típus Enum-e.
 IsInterface 
segítségével ellenőrizhető, hogy a típus Interface-e.
 IsNested 
segítségével ellenőrizhető, hogy a típus be van-e ágyazva.
 IsPrimitive 
annak ellenőrzésére szolgál, hogy a típus primitív-e.
 IsPointer 
annak ellenőrzésére szolgál, hogy a típus mutató-e.
 IsNotPublic 
annak ellenőrzésére szolgál, hogy a típus nem nyilvános-e.
 IsPublic 
annak ellenőrzésére szolgál, hogy a típus Nyilvános-e.
 IsSealed 
annak ellenőrzésére szolgál, hogy a típus lezárt-e.
 IsSerializable 
annak ellenőrzésére szolgál, hogy a típus Serializálható-e.
 MemberType 
annak ellenőrzésére szolgál, hogy a típus a Nested típusú tag típusa.
 Modul 
Megkapja a típus modulját.
 Név 
Megkapja a típus nevét.
 Névtér 
Megkapja a típus névterét.
 Ingatlan 
 Leírás 
 GetConstructors () 
Visszaadja a Type összes nyilvános kivitelezőjét.
 GetConstructors (BindingFlags) 
Visszaadja a Típus összes konstruktorát a megadott BindingFlags-szal.
 GetFields () 
Visszaadja a Type összes nyilvános mezőjét.
 GetFields (BindingFlags) 
Visszaadja a Type összes nyilvános konstruktorát a megadott BindingFlags-szal.
 GetMembers () 
Visszaadja a Type összes nyilvános tagját.
 GetMembers (BindingFlags) 
Visszaadja a Type összes tagját a megadott BindingFlags-szal.
 GetMethods () 
Visszaadja a Type összes nyilvános metódusát.
 GetMethods (BindingFlags) 
Visszaadja a Type összes metódusát megadott BindingFlags-szal.
 GetProperties () 
Visszaadja a Type összes nyilvános tulajdonságát.
 GetProperties (BindingFlags) 
Visszaadja a Type összes tulajdonságát megadott BindingFlags-szal.
 GetType () 
Megkapja az aktuális típust.
 GetType (karakterlánc) 
Megkapja a típus nevét.
 Reflektációs példák: 
 Get Type 
 Példa: 
a System public class GetType használatával {public static void Main () {int a = 10 Type type = a.GetType () Console.WriteLine (type)}}
 //Kimenet: 
System.Int32
 
 Szerezd meg az összeszerelést 
 Példa: 
Rendszer használata System.Reflection nyilvános osztály GetAssembly {public static void Main () {t típus = typeof (System.String) Console.WriteLine (t.Assembly)}}
 //Kimenet: 
System.Private.CoreLib, Version = 4.0.0.0, Culture = semleges, PublicKeyToken = 7cec85d7bea7798e
 
 A nyomtatás típusára vonatkozó információk 
 Példa: 
System használata System.Reflection nyilvános osztály 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)}}
 //Kimenet: 
Igaz 
 Hamis 
 Hamis
 
 Nyomtatóépítők 
 Példa: 
Rendszer használata System.Reflection public class PrintConstructors {public static void Main () {t típus = typeof (System.String) Console.WriteLine ('{0} típusú konstruktorok', t) ConstructorInfo [] ci = t .GetConstructors (BindingFlags.Public | BindingFlags.Instance) foreach (ConstructorInfo c in ci) {Console.WriteLine (c)}}}
 //Kimenet: 
A System.String típusú kivitelezők ... 
 Üres .ctor (Char []) 
 Üres .ctor (Char [], Int32, Int32) 
 Üres .ctor (Char *) 
 Üres .ctor (Char *, Int32, Int32) 
 Üres .ctor (SByte *) 
 Üres .ctor (SByte *, Int32, Int32) 
 Érvénytelen .ctor (SByte *, Int32, Int32, System.Text.Encoding) 
 Üres .ctor (Char, Int32) 
 Void .ctor (System.ReadOnlySpan`1 [System.Char])
 
 Nyomtatási módszerek 
 Példa: 
A System használata a System.Reflection nyilvános osztály PrintMethods {public static void Main () {típus t = typeof (System.String) Console.WriteLine ('{0} type ...', t) MethodInfo [] ci = t .GetMethods (BindingFlags.Public | BindingFlags.Instance) foreach (MethodInfo m in ci) {Console.WriteLine (m)}}}
 //Kimenet: 
A System.String típusának módszerei ... 
 System.String Replace (System.String, System.String) 
 System.String [] Split (Char, System.StringSplitOptions) 
 System.String [] Split (Char, Int32, System.StringSplitOptions) 
 System.String [] Split (Char []) 
 System.String [] Split (Char [], Int32) 
 System.String [] Split (Char [], System.StringSplitOptions) 
 System.String [] Split (Char [], Int32, System.StringSplitOptions) 
 System.String [] Split (System.String, System.StringSplitOptions) 
 System.String [] Split (System.String, Int32, System.StringSplitOptions) 
 System.String [] Split (System.String [], System.StringSplitOptions) 
 System.String [] Split (System.String [], Int32, System.StringSplitOptions) ......
 
 Mezők nyomtatása 
 
 Példa: 
Rendszer használata System.Reflection nyilvános osztály PrintFields {public static void Main () {típus t = typeof (System.String) Console.WriteLine ('{0} típusú mezők', t) FieldInfo [] ci = t .GetFields (BindingFlags.Public | BindingFlags.Static | BindingFlags.NonPublic) foreach (FieldInfo f in ci) {Console.WriteLine (f)}}}
 //Kimenet: 
A System.String típusának mezői ... 
 System.String üres
Most térjünk át néhány fejlett C # programozási koncepcióra
 Haladó C # fogalmak 
 Névtelen funkció 
 Többszálas 
 Kivételek kezelése 
 Szinkronizálás 
 Új funkciók 
 Névtelen funkció 
Meghívjuk azt a függvényt, amelyből hiányzik egy adott név Névtelen Funkciók. Kétféle névtelen funkció érhető el a C # nyelven
Lambda kifejezések
Névtelen módszerek
 Példa: 
a Rendszer névtér használatával 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)}}}
 //Kimenet: 
Négyzet: 625
 Névtelen módszerek 
Az névtelen módszer ugyanazt a funkcionalitást nyújtja, mint a lambda kifejezés, kivéve, hogy ez lehetővé teszi számunkra a paraméterlista figyelmen kívül hagyását.
 Példa: 
a Rendszer névtér használata AnonymousMethods {class Program {public delegate void AnonymousFun () static void Main (string [] args) {AnonymousFun fun = delegate () {Console.WriteLine ('This is anonymous function')} fun ()}}}
 //Kimenet: 
Ez egy névtelen funkció
 Többszálas 
A többszálas szálak egy olyan folyamat, ahol több szálat hoznak létre és rendelnek hozzá különböző feladatokhoz. ez időt takarít meg, ha egyszerre több feladatot hajt végre. A többszálas osztály elérhető Rendszer. Menet névtér.
 Rendszer. Névtér menete 
Az Rendszer. Menet A névtér osztályokat és interfészeket tartalmaz a többszálas kezelés megkönnyítése érdekében. Osztályokat biztosít a szálerőforrás szinkronizálásához. Az alábbiakban felsoroljuk a gyakran használt osztályokat:
cérna
Mutex
Időzítő
Monitor
Szemafor
ThreadLocal
ThreadPool
Illó
 Folyamat és menet 
A Folyamat valójában és Alkalmazás és a nehézsúlyú összetevő. Másrészt a szál egyetlen modul az egész alkalmazás. Ez könnyűsúlyú a folyamathoz képest
 Egy szál életciklusa 
Minden szálnak van életciklusa. A szál életciklusát a System.Threading.Thread osztály határozza meg. A következőkben bemutatjuk a szálak életciklusának szakaszait.
Kezdetlen
Futható (futásra kész)
Futó
Nem futható
Halott
A Thread osztály a következő tulajdonságokat és módszereket biztosítja az alábbiak szerint.
 Menet tulajdonságai 
 Ingatlan 
 Leírás 
 CurrentThread 
visszaadja az éppen futó szál példányát.
 Életben van 
ellenőrzi, hogy az aktuális szál él-e vagy sem.
 IsBackground 
Az aktuális szál értékének megszerzése / beállítása a háttérben van, vagy sem.
 ManagedThreadId 
a jelenleg kezelt szál egyedi azonosítójának megszerzésére szolgál.
 Név 
az aktuális szál nevének megszerzésére vagy beállítására szolgál.
 Kiemelten fontos 
az aktuális szál prioritásának megszerzésére vagy beállítására szolgál.
 ThreadState 
a szál állapotát reprezentáló érték visszaadására szolgál.
 Menetmódszerek 
 Módszer 
 Leírás 
 Abortusz () 
a szál leállítására szolgál. Emeli a ThreadAbortException-t.
 Megszakítás () 
WaitSleepJoin állapotban lévő szál megszakítására szolgál.
 Csatlakozik() 
az összes hívó szál blokkolására szolgál, amíg ez a szál le nem áll.
 ResetAbort () 
arra szolgál, hogy törölje az aktuális szál megszakítási kérését.
 Önéletrajz() 
a felfüggesztett menet folytatására szolgál. Elavult.
 Alvás (Int32) 
az aktuális szál felfüggesztésére szolgál a megadott milliszekundumokra.
 Rajt() 
a szál aktuális állapotát Runnable-ra változtatja.
 Felfüggesztés () 
felfüggeszti az aktuális szálat, ha nincs felfüggesztve. Elavult.
 Hozam() 
arra használják, hogy az aktuális szál végrehajtását átadják egy másik szálnak.
 Fő szál példa 
Rendszer használata a Rendszer használatával. Nyilvános osztály átfűzése Edureka {public static void Main (string [] args) {Téma t = Thread.CurrentThread t.Name = 'MainThread' Console.WriteLine (t.Name)}}
 //Kimenet: 
MainThread
 
 Kivételek kezelése 
Az kivétel egy hiba, amelyet a program futási idejében dobott el. Kivételkezelést végzünk annak érdekében, hogy programunk kivételes legyen.
 Kivétel 
 Leírás 
 System.DivideByZeroException 
Hiba történt egy szám nullával való elosztásával.  
  
 System.NullReferenceException 
kezeli a null objektum hivatkozásával generált hibát.  
  
 System.InvalidCastException 
kezeli az érvénytelen tipizálás által generált hibát.  
  
 System.IO.IOException 
kezeli az Input / Output hibákat.
 System.FieldAccessException 
Hiba történt az érvénytelen privát / védett hozzáférés miatt.
 
A C # -ben 4 kulcsszót használunk a teljesítéshez kivételkezelés: 
próbálja meg
fogás
végül és
dobás
  Példa:  
Rendszer nyilvános osztály használata EdurekExample {public static void Main (string [] args) {try {int a = 10 int b = 0 int x = a / b} catch (e kivétel) {Console.WriteLine (e)} Console.WriteLine ('Ez az üzenet a fogási blokktól származik')}}
 
 //Kimenet: 
System.DivideByZeroException: Megpróbálta osztani nullával. 
 itt: ExExaEdurekample.Main (String [] argumentum) az F-ben: C # TutorialC # ProgramsConsoleApp1ConsoleApp1Program.cs: 10. sor 
 Ez az üzenet a fogási blokkból származik
 Testreszabott kivétel példa 
System public class használata InvalidAgeException: Kivétel {public InvalidAgeException (String üzenet): base (üzenet) {}} public class Testreszabott {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.') } } 
 //Kimenet: 
InvalidAgeException: Sajnos az életkor várhatóan meghaladja a 18 évet 
 itt: Customized.validate (Int32 age) itt: F: C # TutorialC # ProgramsConsoleApp1ConsoleApp1Program.cs: 18. sor 
 itt: Customized.Main (String [] argument) az F-ben: C # TutorialC # ProgramsConsoleApp1ConsoleApp1Program.cs: 23. sor 
 A fogási blokk végrehajtása folyamatban van.
egy-egy kapcsolat a java-ban
 
 Végül blokkolja a példát 
System public class FinalExecption segítségével {public static void Main (string [] args) {próbálkozzon {int a = 10 int b = 0 int x = a / b} fogással (e kivétel) {Console.WriteLine (e)} végül {Console .WriteLine ('Végül a blokk végrehajtva')} Konzol.WriteLine ('Fogási blokk végrehajtva')}}
 //Kimenet: 
System.DivideByZeroException: Megpróbálta osztani nullával. 
 itt: FinalExecption.Main (karakterlánc [] argumentum) az F-ben: C # TutorialC # ProgramsConsoleApp1ConsoleApp1Program.cs: 10. sor 
 Végül a blokk végrehajtásra kerül 
 A fogási blokk végrehajtásra kerül
 Rendszerkivétel aláírása 
[SerializableAttribute] [ComVisibleAttribute (true)] public class SystemException: Kivétel
 Rendszerkivétel-kivitelezők 
 Építész 
 Leírás 
 SystemException () 
A SystemException osztály új példányának inicializálására szolgál.
 SystemException 
 (SerializationInfo, StreamingContext) 
A SystemException osztály új példányának inicializálására szolgál sorosított adatokkal.
 SystemException (karakterlánc) 
A SystemException osztály új példányának inicializálására szolgál egy megadott hibaüzenettel.
 SystemException (karakterlánc, kivétel) 
A SystemException osztály új példányának inicializálására szolgál egy megadott hibaüzenettel és hivatkozással a belső kivétellel, amely ennek a kivételnek az oka.
 Rendszerkivétel tulajdonságai 
 Ingatlan 
 Leírás 
 Adat 
Olyan kulcs / érték párok gyűjteményének megszerzésére szolgál, amelyek további, a felhasználó által definiált információkat nyújtanak a kivételről.
 HelpLink 
Erre a kivételhez társított súgófájl hivatkozásának megszerzésére vagy beállítására szolgál.
 HResult 
A HRESULT kódolt numerikus érték lekérésére vagy beállítására szolgál, amely egy adott kivételhez van hozzárendelve.
 InnerException 
Arra a Exception példányra kapjuk, amely a jelenlegi kivételt okozta.
 Üzenet 
Az aktuális kivételt leíró üzenet fogadására szolgál.
 Forrás 
A hibát okozó alkalmazás nevének megszerzésére vagy beállítására szolgál.
 StackTrace 
Arra szolgál, hogy a hívásveremben azonnali képkockákat ábrázolja karakterláncokkal.
 TargetSite 
Arra szolgál, hogy megkapja azt a módszert, amely az aktuális kivételt dobja.
 Rendszerkivételi módszerek 
 Mód 
 Leírás 
 Egyenlő (objektum) 
Arra használják, hogy ellenőrizzék, hogy a megadott objektum megegyezik-e az aktuális objektummal, vagy sem.
 Véglegesítés () 
Erőforrások felszabadítására és tisztítási műveletekre használják.
 GetBaseException () 
A gyökér kivétel kivételére szolgál.
 GetHashCode () 
A hash kód megszerzésére szolgál.
 GetObjectData 
 (SerializationInfo, StreamingContext) 
Objektum adatok megszerzésére szolgál.
 GetType () 
Az aktuális példány futási idejének megszerzésére szolgál.
 MemberwiseClone () 
Az aktuális objektum sekély másolatának létrehozására szolgál.
 ToString () 
Az aktuális kivétel karakterlánc-reprezentációjának létrehozására és visszaadására szolgál.
 Rendszerkivételi példa 
a System névtér használatával CSharpProgram {class SystemExceptionExample {static void Main (string [] args) {try {int [] arr = new int [5] arr [10] = 25} catch (SystemException e) {Console.WriteLine (e)} }}}
 //Kimenet: 
System.IndexOutOfRangeException: Az index kívül esett a tömb határain. 
 itt: CSharpProgram.SystemExceptionExample.Main (String [] argumentum) az F-ben: C # TutorialC # ProgramsConsoleApp1ConsoleApp1Program.cs: 11. sor
 
 Szinkronizálás 
A szinkronizálás lehet olyan technika, amely csak 1 szál számára teszi lehetővé az erőforráshoz való hozzáférést egy adott időre. Egyetlen alternatív szál sem szakad meg, amíg a kijelölt szál nem fejezi be feladatát.
Többszálas programban szálak megengedettekbármilyen erőforrás eléréséhez ameghatározott végrehajtásidő. A szálak megosztják az erőforrásokat és aszinkron módon hajtanak végre. Megosztott erőforrások (adatok) elérésefontos feladat lehethogy általábanleállhatotta rendszer.hajlamosak vagyunk befolyásolniszálak szinkron módon történő létrehozásával.
 Példa szinkronizálás nélkül 
Rendszer használata a Rendszer használatával. Az Edureka {public void PrintTable () {osztályának (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() } } 
 //Kimenet: 
 
egy 
 egy 
 2 
 2 
 3 
 3 
 4 
 4 
 5. 
 5. 
 6. 
 6. 
 7 
 7 
 8. 
 8. 
 9. 
 9. 
 10. 
 10.
 
 Példa szinkronizálással 
Rendszer használata a Rendszer használatával. Az Edureka osztályának beolvasása {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() } } 
 //Kimenet: 
egy 
 2 
 3 
 4 
 5. 
 6. 
 7 
 8. 
 9. 
 10. 
 egy 
 2 
 3 
 4 
 5. 
 6. 
 7 
 8. 
 9. 
 10.
 Új funkciók 
A Microsoft számos legújabb funkcióval bővítette a C # nyelvet, amelyek közül néhányat az alábbiakban említünk.
C # 6.0
Statikus irányelv használata
Kivételszűrők
Várj fogásban / végül blokkol
Auto tulajdonságok inicializálói
Alapértelmezett értékek a csak getter tulajdonságokhoz
Kifejező testű tagok
Null propagátor
Húrinterpoláció
Operátor neve
Szótár inicializáló
Fordító szolgáltatásként (Roslyn)
C # 7.0
Mintaillesztés
Tollok
Dekonstrukció
Helyi funkciók
Számjegy elválasztó
Bináris literálok
Ref visszatér és a helyiek
Kifejező testű konstruktorok és véglegesítők
Kifejezésű testes getterek és beállítók
Out változók
Általánosított aszinkron visszatérési típusok
C # 7.1
Async main
Alapértelmezett kifejezések
 Interjúkérdések a C # alapján 
A fontos interjú A C # programozási nyelven alapuló kérdések ebben a frissítésben találhatók  .
Ezzel véget értünk ennek a „C # Tutorial” cikknek. Remélem, megértette az adatstruktúrák, a szintaxis, a funkcionalitás és az ezek használatával végrehajtott műveletek fontosságát. Most, hogy ezen keresztül megértette a C # programozásának alapjaitC # oktatóanyag, nézd meg a  képzés biztosított  az Edureka számos technológián, például a Java-on, Tavaszi és sokegy világszerte több mint 250 000 elégedett tanulót számláló, megbízható online tanulási társaság a  kérdés nekünk? Említse meg ennek a „C # Tutorial” blognak a megjegyzés rovatában, és a lehető leghamarabb kapcsolatba lépünk Önnel.