C # Tutorial: Die Grundlagen, die Sie benötigen, um C # zu meistern

C # ist eine universelle und robuste Programmiersprache, die von der Microsoft Corporation im Jahr 2000 als tödlicher Konkurrent von Java entwickelt wurde. Es ist am beliebtesten und eine dominierende Programmiersprache, wenn es sowohl um die Webentwicklung als auch um die Entwicklung von Desktopanwendungen geht.

In diesem C # -Tutorial lernen wir die folgenden Konzepte kennen.

• C # Grundlagen
• Objekt orientierte Programmierung
• Erweiterte C # -Konzepte
• Interview Fragen basierend auf C #

C # Grundlagen

• Einführung in die Programmiersprache C #
• Funktionen der C # -Programmiersprache
• Installation
• C # -Programmstruktur
• Datentypen
• Variablen
• Betreiber
• Schleifen
• Bedingt
• Saiten
• Arrays
• Sammlungen
  • Liste
  • Hash-Set
  • Sortiertes Set
  • Stapel
  • Warteschlange
  • Verknüpfte Liste
  • Wörterbuch
  • Sortiertes Wörterbuch
  • Sortierte Liste
• Struktur
• Funktionen

Einführung in die Programmiersprache C #

In den frühen 90er Jahren war Java die führende Programmiersprache für die Webentwicklung, die Entwicklung von Desktopanwendungen und viele andere Bereiche. Microsoft wollte einen Konkurrenten mit vielen erweiterten Funktionen entwickeln, die Java weit hinter sich lassen können.

Es war im Jahr 2000, Anders Hejlsberg und sein Microsoft-Team kam auf die Idee von C #, das im Volksmund als C-Sharp bezeichnet wird. Diese Initiative wurde von der International Standards Organization genehmigt (HAUPT) und der European Computer Manufacturers Association (ECMA). und schließlich betritt The C # die Welt der Softwareentwicklung.

Funktionen der C # -Programmiersprache

• Objektorientierte Programmiersprache

Der objektorientierte Programmieransatz macht C # scharf zur programmiererfreundlichsten und am einfachsten zu entwickelnden und zu pflegenden Programmiersprache.

• Typensichere Sprache

Type-Safe bedeutet, dass der Compiler nur auf den Speicherort zugreifen kann, der zur Ausführung berechtigt ist. Diese Funktion verbessert die Codesicherheit auf ein exponentielles Niveau.

• Interoperabilität

Die Funktion der Interoperabilität macht C # in der Lage, alles, was in C ++ enthalten ist, effizienter zu erledigen, um C ++ selbst zu übertreffen.

• Reiche Bibliothek

C # bietet Zugriff auf mehrere integrierte Bibliotheken, die vorprogrammierte Funktionen bereitstellen, um den Zeitaufwand für den Entwicklungsprozess zu verringern.

• Skalierbar und aktualisierbar

C # wurde entwickelt, um unter den anderen Programmiersprachen überlegen zu sein. Daher ist es immer offen für Updates und hält sich mit seinen Funktionen hoch skalierbar.

• Komponentenorientiert

Die Entwickler von Microsoft verwendeten den komponentenbasierten Ansatz, um C # zu entwickeln. Dies ist die am weitesten verbreitete Entwicklungsmethode, um C # hoch skalierbar und auf dem neuesten Stand zu halten.

• Strukturierte Sprache

Der strukturierte Programmieransatz wird während des Softwareentwicklungslebenszyklus bevorzugt, da die Kompilierung und Bereitstellung der Software im Vergleich zum prozedurorientierten Programmieransatz einfach zu entwickeln ist.

• Schnell

Die C # -Programmierung ist beim Kompilieren und Ausführen schneller als bei C ++ und anderen Programmiersprachen.

Installation

Es ist bewiesen, dass Microsoft Visual Studio ist der klassenbeste Editor für C # -Programmierung. Wir werden Microsoft Visual Studio für die Ausführung unserer C # -Programme installieren und einrichten, indem wir die folgenden Schritte ausführen:

Schritt 1 :: Laden Sie Microsoft Visual Studio herunter

wie man ein Ingenieur für künstliche Intelligenz wird

Google für die neueste Version von Visual Studio und laden Sie die Installieren Datei in Ihr lokales System und dann Lauf die Installationsdatei als Administrator.

Schritt 2: Wählen Sie das .NET Desktop Development Package aus

Sobald Sie das Installationsprogramm ausführen, wird der Visual Studio-Editor erfolgreich auf Ihr lokales System heruntergeladen. Später wird auf Ihrem Desktop-Bildschirm ein Dialogfeld angezeigt, in dem Sie den Gegner a fragen bestimmtes Paket Sie brauchen in Ihrem System. Hier müssen Sie die auswählen .NET Desktop-Entwicklung Paket.

Schritt 3: Stellen Sie die C # -Umgebung ein

Sobald Ihre Pakete für .NET-Entwicklung Wenn Sie heruntergeladen werden, wird auf Ihrem Bildschirm ein weiteres Dialogfeld angezeigt, in dem Sie nach der gewünschten Entwicklungsumgebung gefragt werden. Hier müssen Sie Wählen Sie die Umgebung für C # aus.

Schritt 4: Erstellen Sie Ihr erstes Projekt

Sobald die Umgebung eingerichtet ist, können Sie loslegen. Starten Sie Ihr Visual Studio und wählen Sie neues Projekt erstellen Option im angezeigten Dialogfeld.

Sie werden zum nächsten Dialogfeld weitergeleitet und müssen dort Klassenbibliothek als auswählen .NET Standard Wie nachfolgend dargestellt.

Im nächsten Dialogfeld werden Sie dazu aufgefordert Konfigurieren Sie Ihr Projekt . Konfigurieren Sie es und Sie befinden sich jetzt im Editor. Schreiben Sie Ihr erstes Programm und Lauf es. Die Ausgabe wird erfolgreich auf dem angezeigt Eingabeaufforderung.

Verwenden der Systemklasse Edureka {static void Main (string [] args) {Console.WriteLine ('Willkommen bei Edureka!, Happy Learning ..!')}}

//Ausgabe:

Lassen Sie uns unser erstes C # -Programm ausführen.

C # -Programmstruktur

Nachdem wir unser erstes C # -Programm ausgeführt haben, lassen Sie uns dessen Struktur im Detail verstehen. Ein einfaches C # -Programm besteht aus folgenden Teilen.

Verwenden des System-Namespace ConsoleApplication1 {öffentliche Klasse Edureka {öffentliche statische Leere Main (string [] args) {Console.WriteLine ('Willkommen bei Edureka!, Happy Learning ..!')}}}

//Ausgabe:

Willkommen bei Edureka!, Happy Learning ..!

• Klasse: Klasse kann allgemein definiert werden als Stichwort Hiermit wird eine Klasse im C # -Programm definiert.
• Edureka: Es ist der Name des Klasse. Klasse wird oft als Blaupause betrachtet, in der die Mitglieder und Methoden der Klasse gespeichert werden.
• Main: Grundsätzlich ist das primäre Methode des gesamten C # -Programms fungiert als Gateway für die Steuerung zur Eingabe des Programms. Es wird ausgeführt, bevor eine andere Methode des Programms ausgeführt wird.
• Leere: Dieses Segment des Codes ist dem Rückgabetyp der Methode. Es kann sich um einen anderen Datentyp als void handeln. Void bedeutet, dass für die Methode keine Daten zurückgegeben werden.
• statisch: Das ist ein Stichwort Dies besagt, dass die deklarierten Datenelemente statisch sind und den deklarierten Mitgliedern ein dedizierter Speicher zugewiesen wurde.
• String [] args: Es ähnelt den Befehlszeilenargumenten, die wir in unserem Programm verwenden. Während wir unser Programm ausführen, übergeben wir im Grunde einige Argumente, die aufgrund dieser Aussage vom Programm akzeptiert werden.
• System.Console.WriteLine ('Willkommen bei Edureka!, Happy Learning ..!') Hier, System ist der Namespace. Die Konsoleist, dass die Kategorie umrissenim System-Namespace. Das WriteLine () Ist das dasstatischTechnikder KonsoleKategorie, die zum Aufschreiben verwendet wirdder Text auf der Konsole.

Lassen Sie uns nun die in C # verfügbaren Datentypen kennenlernen.

Datentypen

Die Datentypen in C # sind in drei Kategorien unterteilt, die im Folgenden beschrieben werden.

Wertdatentypen

Das Wertdatentypen befinden sich in der System.ValueType Bibliothek und sind immer bereit, direkt darauf zuzugreifen, und Variablen können direkt einem bestimmten Wert zugewiesen werden. Die Wertdatentypen werden weiter in zwei Typen unterteilt, wie unten gezeigt:

• Vordefinierte Datentypen
• Benutzerdefinierte Datentypen

Vordefinierte Datentypen: Dies sind diejenigen, die wir normalerweise in unserer täglichen Programmierung verwenden. Diese Datentypen werden von den Sprachentwicklern vordefiniert und für die Programmierer einsatzbereit gehalten.

Beispiel:

int, float, char, short double usw.

Benutzerdefinierte Datentypen: Es gibt Situationen, in denen wir möglicherweise unterschiedliche Werte von Datentypen in einer einzigen Variablen speichern müssen. In diesen Fällen ist die Vordefinierte Datentypen sind nicht genug. Benutzerdefinierte Datentypen sind wie anpassbare Datentypen für den Benutzer.

Beispiel: Struktur, Aufzählung

Zeigerdatentyp

Der Zeigertyp ist ein einfacher Datentyp. Seine Funktionalität ist den Zeigern in C völlig ähnlich. Sie dienen zum Speichern der Adresse eines anderen Zeigers.

float * ptr

Referenzdatentypen

Der Name ist selbsterklärend. Das Referenzdatentypen Speichern Sie die Variablen nicht, sondern den Referenzwert für diese bestimmte Variable. Mit anderen Worten, sie speichern die Adresse der tatsächlichen Variablen.

Die Referenzvariablen werden wie unten erwähnt in drei verschiedene Typen eingeteilt:

• Objekttyp

Der Objektdatentyp ist in der verfügbar System.Object Klasse.Das ObjektTypenkann seinzugeordnet zuWerte vondie anderen Typen,ReferenzTypen, vordefiniert, benutzerdefiniertTypen. Aber vorherZuordnungWerte, die es erfordert Art Umwandlung.

Objekt abc abc = 50 // Dies nennt man Boxen

• Dynamischer Typ

Dynamische Typvariablen dienen zum Speichern fast aller Arten von Werten. Es wird als dynamischer Typ bezeichnet, da die Typprüfung von Werten zur Laufzeit erfolgt

dynamisches x = 10

• Zeichenfolgentyp

Der String-Typ ist in verfügbar System.String Klasse. Der String-Typ dient zum Speichern von String-Literalen. Die String-Literale werden in zwei Formen in gespeichertzwei Formen

• • zitiert
  • @ zitiert.

String S = 'Edureka'

• Das @ zitiert String-Literal sieht aus wie

@ 'Edureka'

Lassen Sie uns nun die Variablen verstehen.

Variablen

Variablen sind die Namen, die dem Speicherort zugewiesen sind, in dem bestimmte vom Benutzer angegebene Daten gespeichert sind und auf die über den Variablennamen leicht zugegriffen werden kann. In C # stehen fünf Arten von Variablen zur Verfügung

Beispiel:

int a, b double x float p char abc

Zu befolgende Regeln zum Deklarieren von Variablen in C #

• Eine Variable kann Alphabete, Ziffern und Unterstriche enthalten.
• Ein Variablenname kann nur mit einem Alphabet oder einem Unterstrich beginnen.
• Variablen können nicht mit einer Ziffer oder einem Sonderzeichen beginnen.
• Zwischen dem Variablennamen sind keine Leerzeichen zulässig.
• Reservierte Schlüsselwörter dürfen nicht als Variablennamen verwendet werden.

Betreiber

Ein Operator kann als ein spezielles Symbol definiert werden, das erklärt, dass der Computer eine bestimmte mathematische Operation für eine Reihe von Variablen ausführt. C # enthält eine Vielzahl von Operatoren, die wie folgt aufgeführt sind.

• Rechenzeichen
• Vergleichsoperatoren
• Logische Operatoren
• Bitweise Operatoren
• Zuweisungsoperatoren

Rechenzeichen

Vergleichsoperatoren

Logische Operatoren

Bitweise Operatoren

Zuweisungsoperatoren

Schleifen

ZU Schleife Die Anweisung wird zum wiederholten Ausführen eines Anweisungsblocks verwendet, bis eine bestimmte Bedingung erfüllt ist. Die C # -Sprache besteht aus den folgenden Schleifenanweisungen.

• Für Schleife
• While-Schleife
• Do While-Schleife

Für Schleife

Das für Schleife wird verwendet, um ein bestimmtes Codesegment mehrmals auszuführen, bis die gegebene Bedingung erfüllt ist.

Syntax

für (Inkrementieren / Dekrementieren der Initialisierungsbedingung) {// Codesegment}

FlowChart:

Beispiel:

Verwenden der öffentlichen Systemklasse ForExample {public static void Main (string [] args) {for (int i = 1 i<= 5 i++) { Console.WriteLine(i) } } } 

//Ausgabe:

ein
2
3
4
5

While-Schleife

Das While-Schleife wird verwendet, um ein Codesegment mehrmals auszuführen, bis eine bestimmte Bedingung erfüllt ist.

Syntax

while (Bedingung) {// auszuführender Code}

FlowChart:

Beispiel:

Verwenden des System-Namespace Loops {class Program {statische Leere Main (string [] args) {int x = 5 while (x<= 10) { Console.WriteLine('The value of a: {0}', x) x++ } Console.ReadLine() } } } 

//Ausgabe:

Der Wert von a: 5
Der Wert von a: 6
Der Wert von a: 7
Der Wert von a: 8
Der Wert von a: 9
Der Wert von a: 10

Do While-Schleife

Do while-Schleife ist der While-Schleife völlig ähnlich, aber der einzige Unterschied besteht darin, dass die Bedingung am Ende der Schleife platziert wird. Daher wird die Schleife mindestens einmal ausgeführt.

Syntax

mache {// auszuführender Code} while (Bedingung)

FlowChart:

Beispiel:

Verwenden des System-Namespace Edureka {Klasse DoWhileLoop {public static void Main (Zeichenfolge [] Argumente) {int i = 1, n = 5, Produkt do {Produkt = n * i Console.WriteLine ('{0} * {1} = { 2} ', n, i, Produkt) i ++} während (i<= 10) } } } 

//Ausgabe:

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

Bedingt

Bedingte Anweisungen werden zur Ausführung verwendet Erklärung oder Gruppe von Aussagen basierend auf einer Bedingung. Wenn die Bedingung ist dann wahr C # -Anweisungen werden sonst die nächsten ausgeführt Erklärung wird durchgeführt.

Es gibt verschiedene Arten von bedingten Anweisungen in C ++:

1. If-Anweisung
2. If-Else-Anweisung
3. Verschachtelte If-else-Anweisung
4. Wenn-sonst Wenn Leiter
5. Switch-Anweisung

If-Anweisung

Der Single wenn Die Anweisung in C # -Sprache wird verwendet, um den Code auszuführen, wenn eine Bedingung erfüllt ist. Es wird auch als Einweg-Auswahlanweisung bezeichnet.

Syntax

if (Boolescher Ausdruck) {// Anweisungen werden ausgeführt, wenn der Boolesche Ausdruck wahr ist}

FlowChart:

Beispiel:

Verwenden des System-Namespace Bedingt {Klasse IfStatement {public static void Main (Zeichenfolge [] Argumente) {int number = 2 if (number<5) { Console.WriteLine('{0} is less than 5', number) } Console.WriteLine('This statement is always executed.') } } } 

//Ausgabe:

2 ist kleiner als 5
Diese Anweisung wird immer ausgeführt.

If-Else-Anweisung

Das ansonsten Die Anweisung in der Sprache C wird verwendet, um den Code auszuführen, wenn die Bedingung wahr oder falsch ist. Es wird auch als bidirektionale Auswahlanweisung bezeichnet.

Syntax

if (Boolescher Ausdruck) {// Anweisungen werden ausgeführt, wenn der Boolesche Ausdruck wahr ist} else {// Anweisungen werden ausgeführt, wenn der Boolesche Ausdruck falsch ist}

FlowChart:

Beispiel:

Verwenden des System-Namespace Bedingt {Klasse IfElseStatement {public static void Main (Zeichenfolge [] Argumente) {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.') } } } 

//Ausgabe:

12 ist größer oder gleich 5
Diese Anweisung wird immer ausgeführt.

Verschachtelte If-else-Anweisung

Das verschachtelte ansonsten Anweisung wird verwendet, wenn ein Programm mehr als einen Testausdruck benötigt. Es wird auch als Mehrwegeauswahlanweisung bezeichnet. Wenn eine Reihe von Entscheidungen in eine Aussage involviert sind, verwenden wir ansonsten Anweisung in verschachtelter Form.

Syntax

if (Boolescher Ausdruck) {if (verschachtelter Ausdruck-1) {// auszuführender Code} else {// auszuführender Code}} else {if (verschachtelter Ausdruck-2) {// auszuführender Code } else {// auszuführender Code}}

FlowChart:

Beispiel:

Verwenden des System-Namespace Bedingt {Klasse verschachtelt {public static void Main (Zeichenfolge [] Argumente) {int first = 7, second = -23, Third = 13 if (first & gt second) {if (first
 //Ausgabe: 
13 ist der größte
 Sonst-wenn-Leiter 
Das  wenn-sonst-wenn  Anweisung wird verwendet, um einen Code aus mehreren Bedingungen auszuführen. Es wird auch als Mehrweg-Entscheidungsanweisung bezeichnet. Es ist eine Kette von if..else-Anweisungen, in denen jede if-Anweisung mit else if-Anweisung verknüpft ist und last eine else-Anweisung wäre.
 Syntax 
if (Bedingung1) {// Code, der ausgeführt werden soll, wenn Bedingung1 wahr ist} else if (Bedingung2) {// Code, der ausgeführt werden soll, wenn Bedingung2 wahr ist} else if (Bedingung3) {// Code, der ausgeführt werden soll, wenn Bedingung3 wahr ist} ... sonst {// Code, der ausgeführt werden soll, wenn alle Bedingungen falsch sind}
 FlowChart: 
 Beispiel: 
Verwenden der Systemklasse Edureka {public static void Main (String [] args) {int i = 20 if (i == 10) Console.WriteLine ('i is 10') else if (i == 15) Console.WriteLine (' i ist 15 ') else if (i == 20) Console.WriteLine (' i is 20 ') else Console.WriteLine (' i is not present ')}}
 //Ausgabe: 
Ich bin 20
 Switch-Anweisung 
 Schalter  Die Anweisung ersetzt eine lange If-else-If-Leiter, mit der eine Liste von Fällen getestet wird. Eine switch-Anweisung enthält eine oder mehrere Fallbezeichnungen, die anhand des switch-Ausdrucks getestet werden. Wenn der Ausdruck mit einem Fall übereinstimmt, werden die diesem Fall zugeordneten Anweisungen ausgeführt.
 Syntax 
switch (Variable / Ausdruck) {case value1: // Anweisungen werden ausgeführt, wenn expression (oder variable) = value1 break case value2: // Anweisungen werden ausgeführt, wenn expression (oder variable) = value1 break ... ... ... .. . ... ... default: // Anweisungen werden ausgeführt, wenn kein Fall übereinstimmt}
 FlowChart: 
 Beispiel: 
Verwenden des System-Namespace Bedingt {class SwitchCase {public static void Main (string [] args) {char ch Console.WriteLine ('Alphabet eingeben') ch = Convert.ToChar (Console.ReadLine ()) switch (Char.ToLower (ch )) {case 'a': Console.WriteLine ('Vokal') break case 'e': Console.WriteLine ('Vowel') break case 'i': Console.WriteLine ('Vowel') break case 'o': Console.WriteLine ('Vokal') break case 'u': Console.WriteLine ('Vokal') break default: Console.WriteLine ('Kein Vokal') break}}}}
 //Ausgabe: 
Geben Sie ein Alphabet ein 
 ist 
 Vokal
 Saiten 
 String Datentyp ist Mitglied von System.String Klasse. Es ist in der Lage, Zeichentypen von Daten zu speichern. Wir können verschiedene Operationen an Stings durchführen, wie zVerkettung, Vergleich, Abrufen von Teilzeichenfolgen, Suchen, Trimmen, Ersetzen und vieles mehr.
 Die Analogie von String und String 
In C # String und Zeichenfolge sind gleichwertig. Die Wortfolge ist a Stichwort und fungiert als die System.String Klasse. Wir können jede der Versionen verwenden, um Zeichenfolgen zu deklarieren.
 Syntax: 
string s1 = 'Edureka' // Erstellen eines Strings mit dem String-Schlüsselwort String s2 = 'Happy Learning' // Erstellen eines Strings mit der String-Klasse
 Beispiel: 
Verwenden der öffentlichen Systemklasse 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 = neuer String (ch) Console.WriteLine ( s1) Console.WriteLine (s2)}}
 //Ausgabe: 
Edureka 
 Csharp Tutorial
 String-Methoden in C # 
 Methode 
 Beschreibung 
 Klon() 
Wird verwendet, um einen Verweis auf diese Instanz von String zurückzugeben.
 Vergleichen (String, String) 
Wird verwendet, um zwei angegebene String-Objekte zu vergleichen.
 Concat (String, String) 
Verketten Sie zwei angegebene Instanzen von String.
 Enthält (String) 
Gibt einen Wert zurück, der eine angegebene Unterzeichenfolge angibt
 Kopieren (String) 
Wird verwendet, um eine neue Instanz von String mit demselben Wert zu erstellen
 CopyTo (Int, Char [], Int, Int) 
Kopiert Zeichen von einer bestimmten Position
 Gleich (String, String) 
Legt fest, dass zwei String-Objekte denselben Wert haben.
 Format (String, Objekt) 
Ersetzen Sie ein oder mehrere Formatelemente in einer angegebenen Zeichenfolge
 IndexOf (String) 
Gibt den auf Null basierenden Index des ersten Auftretens an
 Einfügen (Int32, String) 
Gibt eine neue Zeichenfolge zurück, in die eine Zeichenfolge an einem Index eingefügt wird.
 IsInterned (String) 
Gibt an, dass diese Zeichenfolge in der Unicode-Normalisierungsform C vorliegt.
 IsNullOrEmpty (String) 
Gibt an, dass die angegebene Zeichenfolge null oder eine leere Zeichenfolge ist.
 IsNullOrWhiteSpace (String) 
Wird verwendet, um anzugeben, ob eine angegebene Zeichenfolge null, leer,
 Join (String, String []) 
Wird verwendet, um alle Elemente eines String-Arrays zu verketten
 LastIndexOf (Char) 
Gibt die auf Null basierende Indexposition des letzten Zeichens an
 LastIndexOfAny (Char []) 
Gibt die auf Null basierende Indexposition des letzten Zeichens an
 Entfernen (Int32) 
Gibt eine neue Zeichenfolge zurück, in der alle Zeichen enthalten sind
 Ersetzen (String, String) 
Gibt eine neue Zeichenfolge zurück, in der alle Vorkommen einer Zeichenfolge enthalten sind
 Split (Char []) 
Es wird verwendet, um einen String in Teilzeichenfolgen aufzuteilen
 StartsWith (String) 
Es wird verwendet, um zu überprüfen, ob der Anfang dieser Zeichenfolge
 Teilstring (Int32) 
Es wird verwendet, um einen Teilstring aus dieser Instanz abzurufen.
 ToCharArray () 
Kopiert die Zeichen in dieser Instanz in ein Unicode-Array.
 ToString () 
Es wird verwendet, um die Instanz von String zurückzugeben.
 Trimmen() 
Schneidet die Schnur
  
Arrays 
Ähnlich wie in anderen Programmiersprachen verfügt C # über Arrays. Arrays sind einfache Datenstrukturen, mit denen derselbe Datentyp von Elementen an einem zusammenhängenden Speicherort gespeichert wird.
C # unterstützt die folgenden Array-Typen.
Eindimensionales Array
Mehrdimensionales Array
Gezacktes Array
 Eindimensionales Array 
Single Dimensional Array speichert Elemente in Form einer einzelnen Zeile.
 Syntax 
int [] arr = new int [5] // Array erstellen
 Beispiel: 
Verwenden der öffentlichen Systemklasse ArrayExample {public static void Main (Zeichenfolge [] Argumente) {int [] arr = new int [5] arr [0] = 10 arr [1] = 20 arr [2] = 30 arr [3] = 40 arr [4] = 50 für (int i = 0 i 
 //Ausgabe: 
10 
 zwanzig 
 30 
 40 
 fünfzig
 Mehrdimensionales Array 
Das mehrdimensionale Array speichert Elemente in Form mehrerer Dimensionen wie eine Matrix und einen Würfel usw.
 Syntax 
int val = a [2,3]
 Beispiel: 
Verwenden des System-Namespace ArrayApplication {Klasse MyArray {statische Leere Main (string [] args) {int [,] a = new int [5, 2] {{0, 0}, {1, 2}, {2, 4}, {3, 6}, {4, 8}} int i, j für (i = 0 i<5 i++) { for (j = 0 j < 2 j++) { Console.WriteLine('a[{0},{1}] = {2}', i, j, a[i, j]) } } Console.ReadKey() } } } 
 //Ausgabe: 
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
  
 Gezacktes Array 
Jagged Array ist einfach ein Array von Arrays.
 Beispiel: 
Verwenden des System-Namespace ArrayApplication {Klasse MyArray {statische Leere Main (string [] args) {int [] [] a = new int [] [] {new int [] {0,0}, new int [] {1,2 }, neues int [] {2,4}, neues int [] {3, 6}, neues int [] {4, 8}} int i, j für (i = 0 i<5 i++) { for (j = 0 j < 2 j++) { Console.WriteLine('a[{0}][{1}] = {2}', i, j, a[i][j]) } } Console.ReadKey() } } } 
 //Ausgabe: 
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
 Sammlungen 
Die Sammlung kann einfach als eine Gruppe von Objekten betrachtet werden, die zusammen gesammelt wurden, um einige Funktionen auf die gesammelten Daten anzuwenden. Die Operationen, die möglicherweise einmal für eine Sammlung ausgeführt werden, sind:
Objekt speichern
Objekt aktualisieren
Objekt löschen
Objekt abrufen
Suchobjekt und
Objekt sortieren
 Arten von Sammlungen 
Es gibt drei verschiedene Möglichkeiten, mit Sammlungen zu arbeiten. Die drei Namespaces werden unten erwähnt:
 System.Collections.Generic  Klassen
 System.Collections  Klassen
 System.Collections.Concurrent  Klassen
Die System.Collections.Generic-Klasse hat die folgenden Klassenvarianten:
Liste
Stapel
Warteschlange
LinkedList
HashSet
SortedSet
Wörterbuch
SortedDictionary
SortedList
Das System.Collections Klassen gelten als Legacy-Klassen. Sie umfassen die folgenden Klassen.
Anordnungsliste
Stapel
Warteschlange
Hash-tabelle
Das System.Collections.Concurrent  KlassenDer Namespace bietet Klassen für threadsichere Operationen. Jetzt verursachen mehrere Threads kein Problem beim Zugriff auf die Sammlungselemente. Die hier verfügbaren Klassen sind:
BlockingCollection
ConcurrentBag
ConcurrentStack
ConcurrentQueue
ConcurrentDictionary
Partitionen
Partitionen
OrderablePartitioner
 Liste 
Das Liste wird als Datenstruktur betrachtet, die in verfügbar ist System.Collection.Generics Namespace. Es kann Elemente speichern und abrufen. In der Liste können doppelte Elemente gespeichert werden.
 Beispiel: 
using System using System.Collections.Generic öffentliche Klasse Edureka {public static void Main (string [] args) {var names = new List () names.Add ('Sandhya') names.Add ('Arun') names.Add ( 'Prashanth') names.Add ('Kiran') foreach (var name in names) {Console.WriteLine (name)}}}
 //Ausgabe: 
Sandhya 
 Arun 
 Prashanth 
 Kiran
 Hash-Set 
C # HashSetKategorie ist oft gewöhntGeschäft,wegbringenoderKomponenten lesen. EsnichtDuplikat speichernKomponenten.es ist dringend erforderlichbenutzen HashSet  Kategoriewenndu hastlagerneinzig und allein  unverwechselbar   Komponenten . es ist gefunden im System.Collections.Generic-Namespace.
 Beispiel: 
using System using System.Collections.Generic öffentliche Klasse Edureka {public static void Main (string [] args) {var names = new HashSet () names.Add ('Sunil') names.Add ('Amar') names.Add ( 'Pujari') names.Add ('Imran') names.Add ('karan') foreach (var name in names) {Console.WriteLine (name)}}}
 //Ausgabe: 
Sunil 
 Amar 
 Pujari 
 Imran 
 Karan
 Sortiertes Set 
C # SortedSetKlasse sind oft gewöhntGeschäft, entfernen oder lesen   Elemente . Es behält aufsteigende Reihenfolge bei undnichtDuplikat speichernElemente.es ist promptSortedSet verwendenKategoriewenndu hastlagern unverwechselbar   Komponenten und aufsteigende Reihenfolge beibehalten.es istgefunden im System.Collections.Generic-Namespace.
 Beispiel: 
using System using System.Collections.Generic öffentliche Klasse Edureka {public static void Main (string [] args) {var names = new SortedSet () names.Add ('Sanjay') names.Add ('Anuradha') names.Add ( 'Praveen') names.Add ('Ravi') names.Add ('Kajol') foreach (var name in names) {Console.WriteLine (name)}}}
 //Ausgabe: 
Anuradha 
 Kajol 
 Praveen 
 Ravi 
 Sanjay
 Stapel 
Das Stapel ist eine einfache Sammlung, die folgt KANTE oder First-In-Last-Out-Prozedur während der Verarbeitung der darin gespeicherten Elemente.
 Beispiel: 
using System using System.Collections.Generic öffentliche Klasse Edureka {public static void Main (string [] args) {Stapelnamen = neue Stack () - Namen.Push ('Chandan') Namen.Push ('Pooja') Namen.Push ( 'James') names.Push ('Rajesh') names.Push ('kumar') foreach (Stringname in Namen) {Console.WriteLine (Name)} Console.WriteLine ('Peek element:' + names.Peek () ) Console.WriteLine ('Pop:' + names.Pop ()) Console.WriteLine ('Nach Pop, Peek-Element:' + names.Peek ())}}
 //Ausgabe: 
Kumar 
 Rajesh 
 James 
 Pooja 
 Chandan 
 Peek-Element: Kumar 
 Pop: Kumar 
 Nach Pop Peek-Element: Rajesh
 Warteschlange 
Die Warteschlange ist Stack völlig ähnlich, aber der einzige Unterschied besteht darin, dass die Warteschlange folgt FIFO oder First-In- und First-Out-Prinzip bei der Verarbeitung der darin gespeicherten Elemente.
 Beispiel: 
using System using System.Collections.Generic öffentliche Klasse Edureka {public static void Main (string [] args) {Warteschlangennamen = neue Queue () -Namen.Enqueue ('Srujan') names.Enqueue ('Prajat') names.Enqueue ( 'John') names.Enqueue ('Raju') names.Enqueue ('Hari') foreach (Stringname in Namen) {Console.WriteLine (Name)} Console.WriteLine ('Peek element:' + names.Peek () ) Console.WriteLine ('Dequeue:' + names.Dequeue ()) Console.WriteLine ('Nach Dequeue Peek-Element:' + names.Peek ())}}
 //Ausgabe: 
Srujan 
 Prajat 
 John 
 Heftig 
 Tag 
 Peek-Element: Srujan 
 Dequeue: Srujan 
 Nach der Warteschlange Peek-Element: Prajat
 Verknüpfte Liste 
Die verknüpfte Liste ist eine dynamische Speichersammlung. Die Elemente in der verknüpften Liste werden gespeichert, indem vom Heap aus auf den Speicher zugegriffen wird und die Elemente durch Verknüpfen ihrer Adressen in einer fortlaufenden Reihenfolge gespeichert werden.
 Beispiel: 
using System using System.Collections.Generic öffentliche Klasse Edureka {public static void Main (string [] args) {var names = new LinkedList () names.AddLast ('Rajat') names.AddLast ('Arun') names.AddLast ( 'Prakash') names.AddLast ('jay') names.AddFirst ('sai') foreach (var name in names) {Console.WriteLine (name)}}}
 //Ausgabe: 
sai 
 Grenzen 
 Arun 
 Prakash 
 Jay
 Wörterbuch 
 Wörterbuch  Kategorieverwendet dieIdeeder Hashtabelle. Es speichert Werte aufdie Voraussetzungdes Schlüssels. Es beinhaltetunverwechselbarSchlüsseleinzig und allein. Durchdie Hilfedes Schlüssels,wir werden einfachSuche oderElemente wegnehmen.es istgefunden im System.Collections.Generic-Namespace.
 Beispiel: 
using System using System.Collections.Generic öffentliche Klasse Edureka {public static void Main (string [] args) {Wörterbuchnamen = neue Dictionary () -Namen.Add ('1', 'Shiva') names.Add ('2', 'Prasad') Namen.Add ('3', 'Preetam') Namen.Add ('4', 'Roy') Namen.Add ('5', 'Akash') foreach (KeyValuePair kv in Namen) {Console. WriteLine (kv.Key + '' + kv.Value)}}}
 //Ausgabe: 
1 Shiva 
 2 Prasad 
 3 Preetam 
 4 Roy 
 5Akash
 Sortiertes Wörterbuch 
Das SortedDictionary  Kategorieverwendet dieDesignder Hashtabelle. Es speichert Werte aufdie Ideedes Schlüssels. Es beinhaltetunverwechselbarTasten und behält aufsteigende Reihenfolge beidie Ideedes Schlüssels. Durchdie Hilfedes Schlüssels,wir werden einfachSuche oderElemente wegnehmen.es istgefunden im System.Collections.Generic-Namespace.
 Beispiel: 
using System using System.Collections.Generic öffentliche Klasse Edureka {public static void Main (string [] args) {SortedDictionary names = new SortedDictionary () names.Add ('1', 'Arun') names.Add ('4', 'Vishal') Namen.Add ('5', 'Ramesh') Namen.Add ('3', 'Vidya') Namen.Add ('2', 'Pallavi') foreach (KeyValuePair kv in Namen) {Console. WriteLine (kv.Key + '' + kv.Value)}}}
 //Ausgabe: 
1 Shiva 
 2 Prasad 
 3 Preetam 
 4 Roy 
 5Akash
 Sortierte Liste 
Das SortedList isteinArray von Schlüssel / Wert-Paaren. Es speichert Werte aufdie Voraussetzungdes Schlüssels. Die sortierte ListeKategorieenthältunverwechselbarTasten und behält aufsteigende Reihenfolge beidie Voraussetzungdes Schlüssels. Durchdie Hilfedes Schlüssels,wir können einfachsuchen oder entfernenElemente.es istgefunden in System.Collections.Generic Namespace.
 Beispiel: 
using System using System.Collections.Generic öffentliche Klasse Edureka {public static void Main (string [] args) {SortedDictionary names = new SortedDictionary () names.Add ('1', 'Arun') names.Add ('4', 'Vishal') Namen.Add ('5', 'Ramesh') Namen.Add ('3', 'Vidya') Namen.Add ('2', 'Pallavi') foreach (KeyValuePair kv in Namen) {Console. WriteLine (kv.Key + '' + kv.Value)}}}
 //Ausgabe: 
1 Arun 
 2 Pallavi 
 3 Vidya 
 4 Vishal 
 5Ramesh
 Struktur 
Die Struktur ist ein benutzerdefinierter Datentyp, in dem mehrere Elemente des unterschiedlichen Datentyps gespeichert werden. Die Struktur wird mit dem Schlüsselwort deklariert struct. 
 Beispiel: 
using System struct Books {öffentlicher String-Titel public string author public string subject public int book_id} öffentliche Klasse Edureka {public static void Main (string [] args) {Bücher Book1 Books Book2 Book1.title = 'C # -Programmierung' Book1.author = ' Ramchandra Kumar 'Book1.subject =' C ++ - Programmier-Tutorial 'Book1.book_id = 95908978 Book2.title =' Telecom Billing 'Book2.author =' Karan 'Book2.subject =' Telecom Billing Tutorial 'Book2.book_id = 18674900 Console.WriteLine ( 'Buch 1 Titel: {0}', Book1.title) Console.WriteLine ('Buch 1 Autor: {0}', Book1.author) Console.WriteLine ('Buch 1 Betreff: {0}', Book1.subject) Console.WriteLine ('Book 1 book_id: {0}', Book1.book_id) Console.WriteLine ('Book 2 title: {0}', Book2.title) Console.WriteLine ('Book 2 Author: {0}', Book2.author) Console.WriteLine ('Buch 2 Betreff: {0}', Book2.subject) Console.WriteLine ('Buch 2 book_id: {0}', Book2.book_id) Console.ReadKey ()}}
 //Ausgabe: 
Titel von Buch 1: C # -Programmierung 
 Buch 1 Autor: Ramchandra Kumar 
 Buch 1 Thema: C ++ Programmier-Tutorial 
 Buch 1 book_id: 95908978 
 Titel von Buch 2: Telecom Billing 
 Buch 2 Autor: Karan 
 Buch 2 Thema: Telecom Billing Tutorial 
 Buch 2 book_id: 18674900
 Funktionen 
Die Funktion ist als Codeblock des Hauptcodes definiert. Die Funktion wird verwendet, um im Codeblock angegebene Anweisungen auszuführen. Eine Funktion besteht aus folgenden Komponenten.
 Funktionsname:  Es ist ein eindeutiger Name, der zum Ausführen eines Funktionsaufrufs verwendet wird.
 Rückgabetyp:  Es gibt den Datentyp des Funktionsrückgabewerts an.
 Körper:  Es enthält ausführbare Anweisungen.
 Zugriffsspezifizierer:  Es gibt die Zugänglichkeit von Funktionen in der Anwendung an.
 Parameter:  Es ist eine Liste von Argumenten, die wir während des Aufrufs an die Funktion übergeben können.
 Syntax 
FunctionName () {// Funktionskörper // Rückgabeanweisung}
 Beispiel: 
Verwenden des System-Namespace FunctionExample {Klasse Edureka {öffentliche Zeichenfolge Show (Zeichenfolgenmeldung) {Console.WriteLine ('Inside Show Function') Rückmeldung} static void Main (Zeichenfolge [] Argumente) {Edureka program = new Edureka () Zeichenfolge message = program .Show ('To Edureka') Console.WriteLine ('Willkommen' + Nachricht)}}}
 //Ausgabe: 
Inside Show Funktion 
 Willkommen bei Edureka
Funktionen können auf drei verschiedene Arten ausgeführt werden:
Call by Value
Call by Reference
Out-Parameter
 Call by Value 
In C #, Wert  -Art Parametersinddieser Passeine Nachbildungvom ursprünglichen Wert zumFunktion stattReferenz. Esnichtändernder erste Wert. EinÄnderung erstelltim VorbeigehenWert nichtalterder besondere Wert.innerhalb derfolgendes Beispiel:wir habenbestehenWert im gesamtendasAnruf.
 Beispiel: 
Verwenden des System-Namespace CallByValue {Klasse Edureka {public void Show (int val) {val * = val Console.WriteLine ('Der Wert innerhalb der Show-Funktion' + val)} static void Main (string [] args) {int val = 50 Edureka program = new Edureka () Console.WriteLine ('Wert vor dem Aufruf der Funktion' + val) program.Show (val) Console.WriteLine ('Wert nach dem Aufruf der Funktion' + val)}}}
//Ausgabe:
Wert vor dem Aufruf der Funktion 50 
 Der Wert innerhalb der Show-Funktion 2500 
 Wert nach Aufruf der Funktion 50
 Call by Reference 
In der Call by Reference-Methodezu ref Schlüsselwort, um das Argument als Referenztyp zu übergeben. Die Referenz von Argumenten wird an die Funktion übergeben und nicht an eine Kopie des ursprünglichen Werts. Die Änderungen der übergebenen Werte sind permanent und ändern der ursprüngliche Variablenwert.
 Beispiel: 
Verwenden des System-Namespace CallByReference {Klasse Edureka {public void Show (ref int val) {val * = val Console.WriteLine ('Der Wert innerhalb der Show-Funktion' + val)} static void Main (string [] args) {int val = 50 Edureka-Programm = new Edureka () Console.WriteLine ('Wert vor dem Aufruf der Funktion' + val) program.Show (ref val) Console.WriteLine ('Wert nach dem Aufruf der Funktion' + val)}}}
//Ausgabe:
Wert vor dem Aufruf der Funktion 50 
 Der Wert innerhalb der Show-Funktion 2500 
 Wert nach Aufruf der Funktion 2500
 Out-Parameter 
Der Out-Parameterbietet aus Schlüsselwort zum Übergeben von Argumenten als Out-Type. Es ist wie ein Referenztyp, außer dass die Variable vor dem Übergeben nicht initialisiert werden muss. Wir müssen verwenden aus Schlüsselwort, um das Argument als Out-Type zu übergeben. Dies ist nützlich, wenn eine Funktion mehrere Werte zurückgeben soll.
 Beispiel: 
Verwenden des System-Namespace OutParameter {Klasse Edureka {public void Show (out int val) {int square = 5 val = square val * = val} statische Leere Main (string [] args) {int val = 50 Edureka-Programm = new Edureka () Console.WriteLine ('Wert vor dem Ausgeben der Variablen' + val) program.Show (out val) Console.WriteLine ('Wert nach Erhalt der out-Variablen' + val)}}}
//Ausgabe:
Wert vor dem Verteilen der Variablen 50
Wertnach Erhalt der out-Variablen 25
Gehen wir nun zur objektorientierten Programmierung über
 Objekt orientierte Programmierung 
 Objekt orientierte Programmierung Systemist ein Programmierparadigma, das auf dem Konzept von basiert Objekte Dies enthält Datenmitglieder und Methoden verwandt mit ihnen. Der Hauptzweck der objektorientierten Programmierung besteht darin, die Flexibilität und Wartbarkeit von Programmen zu erhöhen
 Merkmale der objektorientierten Programmierung: 
Der Schwerpunkt liegt eher auf Daten als auf Verfahren.
Die Programme sind in Objekte unterteilt, wodurch die Arbeit erleichtert wird.
Datenstrukturen sind so konzipiert, dass sie die Objekte charakterisieren.
Funktionen, die funktionieren aufDie Daten eines Objekts werden zusammen in der Datenstruktur platziert.
Daten sind ausgeblendet und können von externen Funktionen nicht ohne Erlaubnis abgerufen werden.
Die Kommunikation zwischen Objekten kann mit Hilfe von Funktionen erfolgen.
Das Hinzufügen neuer Daten und Funktionen ist einfach geworden.
Folgt dem Bottom-up-Ansatz bei der Programmgestaltung.
Die objektorientierten Paradigmen in C # sind wie folgt
 Aufzählung in C # 
 Objektorientierter Programmieransatz 
 Verkapselung 
 Abstraktion 
 Schnittstelle 
 Polymorphismus 
 Erbe 
 Überladen und Überschreiben 
 Namespace 
 Dateivorgänge 
 Veranstaltungen 
 Generika 
 Delegierte 
 Betrachtung 
 Aufzählung in C # 
 Aufzählung oder auch als Aufzählung in C # wird verwendet, um konstante Werte zu speichern, ohne sie während der gesamten Ausführung eines C # -Programms ändern zu müssen. Eswird verwendet, um eine Reihe benannter Konstanten wie Jahreszeit, Tage, Monat, Größe usw. zu speichern
 Beispiel: 
using System public class EnumExample {öffentliche Aufzählungswoche {Montag, Dienstag, Mittwoch, Donnerstag, Freitag, Samstag, Sonntag} public static void Main () {int x = (int) week.Montay int y = (int) week.Friday Console .WriteLine ('Montag = {0}', x) Console.WriteLine ('Freitag = {0}', y)}}
 //Ausgabe: 
Montag = 0 
 Freitag = 4
 Objektorientierter Programmieransatz 
Der objektorientierte Programmierstil kann durch Befolgen der unten beschriebenen Methoden erreicht werden.
 Verkapselung 
  
 Verkapselung ist eine Methode, um die zu kombinieren Methoden zusammen mit ihren Datenmitglieder. 
 Beispiel: 
Verwenden des System-Namespace Edureka {class Rectangle {public double length public double width public double GetArea () {return length * width} public void Display () {Console.WriteLine ('Length: {0}', length) Console.WriteLine (' Breite: {0} ', Breite) Console.WriteLine (' Bereich: {0} ', GetArea ())}} Klasse ExecuteRectangle {statische Leere Main (string [] args) {Rectangle r = new Rectangle () r.length = 50 r.width = 35 r.Display () Console.ReadLine ()}}}
 //Ausgabe: 
Länge: 50 
 Breite: 35 
 Fläche: 1750
 Abstraktion 
 Abstraktion ist eine Methode zu ausblenden den komplexen Codierungsteil des Benutzers, indem er nur die erforderlichen Informationen erhält, die er benötigt.
 Beispiel: 
using System public abstract class Form {public abstract void draw ()} public class Rechteck: Shape {public override void draw () {Console.WriteLine ('Zeichnungsrechteck ...')}} public class Circle: Shape {public override void draw () {Console.WriteLine ('Zeichenkreis ...')}} öffentliche Klasse TestAbstract {public static void Main () {Form ss = neues Rechteck () s.draw () s = neuer Kreis () s.draw ()}}
 //Ausgabe: 
Rechteck zeichnen ... 
 Zeichenkreis ...
 Schnittstelle 
  
Das Schnittstelle ist der Abstraktion völlig ähnlich. Die Funktionalität einer Schnittstelle besteht darin, die unwichtigen Daten vor dem Benutzer zu verbergen und ihm die einzigen wichtigen Daten bereitzustellen, die er benötigt.
 Beispiel: 
Verwenden der öffentlichen Systemschnittstelle Drawable {void draw ()} public class Rechteck: Drawable {public void draw () {Console.WriteLine ('Zeichenrechteck ...')}} public class Kreis: Drawable {public void draw () {Console .WriteLine ('Zeichenkreis ...')}} öffentliche Klasse TestInterface {public static void Main () {Drawable dd = neues Rechteck () d.draw () d = neuer Kreis () d.draw ()}}
 //Ausgabe: 
Rechteck zeichnen ... 
 Zeichenkreis ...
 Polymorphismus 
Polymorphismusist die Kombination von 'Poly' + 'Morphen' was viele Formen bedeutet. Es ist ein griechisches Wort. Dies bedeutet, dass das Codesegment mehrere Formen annehmen kann. Wir haben zwei Arten von Polymorphismus.
Kompilierungszeitpolymorphismus
Laufzeitpolymorphismus
 Beispiel: 
using system public class Tier {public string color = 'white'} public class Hund: Tier {public string color = 'black'} öffentliche Klasse TestSealed {public static void Main () {Tier d = new Dog () Console.WriteLine ( d.color)}}
 //Ausgabe: 
Weiß
 Erbe 
 Erbe ist ein Prozess, bei dem ein Objekt automatisch alle Eigenschaften und Verhaltensweisen seines übergeordneten Objekts erfasst. Sie können die in anderen Klassen definierten Attribute und Verhaltensweisen wiederverwenden, erweitern oder ändern. Die Klasse, die die Mitglieder einer anderen Klasse erbt, wird aufgerufen abgeleitete Klasse und die Klasse, deren Mitglieder geerbt werden, heißt die Base Klasse. Die abgeleitete Klasse ist die spezialisierte Klasse für die Basisklasse.
 Beispiel für einstufige Vererbung 
Verwenden des System-Namespace RectangleApplication {class Rectangle {protected double length protected double width public Rectangle (double l, double w) {length = l width = w} public double GetArea () {return length * width} public void Display () {Console. WriteLine ('Länge: {0}', Länge) Console.WriteLine ('Breite: {0}', Breite) Console.WriteLine ('Bereich: {0}', GetArea ())}} Klasse Tabletop: Rectangle {private doppelte Kosten öffentliche Tischplatte (doppelte l, doppelte w): Basis (l, w) {} öffentliche doppelte GetCost () {doppelte Kosten Kosten = GetArea () * 70 Rückgabekosten} öffentliche Leere Display () {base.Display () Konsole .WriteLine ('Cost: {0}', GetCost ())}} Klasse ExecuteRectangle {statische Leere Main (string [] args) {Tabletop t = neue Tabletop (4.5, 7.5) t.Display () Console.ReadLine () }}}
 //Ausgabe: 
Länge: 4.5 
 Breite: 7.5 
 Fläche: 33,75 
 Kosten: 2362,5
 Beispiel für mehrstufige Vererbung 
Verwenden des System-Namespace InheritanceApplication {Klassenform {public void setWidth (int w) {width = w} public void setHeight (int h) {height = h} protected int width protected int height} öffentliche Schnittstelle PaintCost {int getCost (int area)} Klasse Rectangle: Shape, PaintCost {public int getArea () {return (width * height)} public int getCost (int area) {return area * 70}} class RectangleTester {static void Main (string [] args) {Rectangle Rect = new Rectangle () int area Rect.setWidth (5) Rect.setHeight (7) area = Rect.getArea () Console.WriteLine ('Gesamtfläche: {0}', Rect.getArea ()) Console.WriteLine ('Total Lackkosten: $ {0} ', Rect.getCost (Bereich)) Console.ReadKey ()}}}
 //Ausgabe: 
Gesamtfläche: 35 
 Gesamtlackkosten: 2450 USD
 Überlastung 
Überladen ist eine Situation, in der zwei oder mehrere Mitglieder denselben Namen haben. Überladen ist auch möglich, wenn wir zwei oder mehr Methoden mit demselben Namen deklarieren. Lassen Sie uns Beispiele von beiden überprüfen.
 Überladung von Mitgliedern 
 Beispiel: 
Verwenden der öffentlichen Systemklasse 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))}}
 //Ausgabe: 
35 
 60
 Methodenüberladung 
 Beispiel: 
Verwenden der öffentlichen Systemklasse 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))}}
 //Ausgabe: 
35 
 33.699997
 Überschreiben 
Überschreiben ist eine Situation, in der die untergeordnete Klasse dieselbe Methode definiert, die auch die übergeordnete Klasse definiert. Lassen Sie uns dies anhand eines kleinen Beispiels verstehen.
 Beispiel: 
Verwenden der öffentlichen Klasse des Systems Edureka {public virtual void eat () {Console.WriteLine ('Essen')}} public class Hund: Edureka {public override void eat () {Console.WriteLine ('Essen essen')}} Überschreiben der öffentlichen Klasse {public static void Main () {Hund d = neuer Hund () d.eat ()}}
 //Ausgabe: 
Essen essen
 Namespace 
Das Namespace wird grundsätzlich verwendet, um mehrere im Programm vorhandene Klassen zu behandeln. Der Namespace ist auf verschiedene Arten verfügbar.
 System.Console: Hier die System wird zum Namespace
Um auf die Klasse eines Namespace zuzugreifen, müssen wir verwenden namespacename.classname. 
Wir können die verwenden mit Schlüsselwort auch.
 Beispiel: 
Verwenden des Systems Verwenden von First Verwenden des zweiten Namespace First {öffentliche Klasse Edureka {public void sayWelcome () {Console.WriteLine ('Willkommen bei Edureka')}}} Namespace Second {öffentliche Klasse Happy_Learning {public void sayWishes () {Console.WriteLine (' Happy Learning ')}}} Namespace der öffentlichen Klasse {public static void Main () {Edureka h1 = new Edureka () Happy_Learning w1 = new Happy_Learning () h1.sayWelcome () w1.sayWishes ()}}
 //Ausgabe: 
Willkommen bei Edureka 
 Viel Spaß beim Lernen
 Dateivorgänge 
Das Dateivorgänge In C # sind folgende verfügbar:
 Operation 
 Beschreibung 
 BinaryReader 
Liest primitive Daten aus einem Binärstrom.
 BinaryWriter 
Schreibt primitive Daten im Binärformat.
 BufferedStream 
Temporärer Speicher für einen Bytestrom.
 Verzeichnis 
Hilft bei der Bearbeitung einer Verzeichnisstruktur.
 DirectoryInfo 
Wird zum Ausführen von Vorgängen für Verzeichnisse verwendet.
 DriveInfo 
Bietet Informationen zu den Laufwerken.
 Datei 
Hilft bei der Bearbeitung von Dateien.
 Dateiinformation 
Wird zum Ausführen von Operationen an Dateien verwendet.
 Datenfluss 
Wird zum Lesen und Schreiben an einen beliebigen Ort in einer Datei verwendet.
 MemoryStream 
Wird für den wahlfreien Zugriff auf im Speicher gespeicherte gestreamte Daten verwendet.
 Pfad 
Führt Operationen an Pfadinformationen aus.
 StreamReader 
Wird zum Lesen von Zeichen aus einem Bytestream verwendet.
 StreamWriter 
Wird zum Schreiben von Zeichen in einen Stream verwendet.
 StringReader 
Wird zum Lesen aus einem String-Puffer verwendet.
 StringWriter 
Wird zum Schreiben in einen Zeichenfolgenpuffer verwendet.
 FileMode 
Das FileMode ist ein Enumerator, der mehrere Methoden zum Öffnen von Dateien definiert. Die Mitglieder des FileMode Enumerator werden wie folgt beschrieben:
 Anhängen: Es öffnet eine vorhandene Datei und setzt den Cursor an das Ende der Datei oder erstellt die Datei, wenn die Datei nicht vorhanden ist.
 Erstellen: Es wurde entwickelt, um eine neue Datei zu erstellen.
 Erstelle neu: Es wurde entwickelt, um dem Betriebssystem anzugeben, dass eine neue Datei erstellt werden soll.
 Öffnen: Es dient zum Öffnen einer vorhandenen Datei.
 OpenOrCreate: Es soll das Betriebssystem angeben, dass eine Datei geöffnet werden soll, falls vorhanden, andernfalls sollte eine neue Datei erstellt werden.
 Kürzen: Abschneiden öffnet eine vorhandene Datei und schneidet ihre Größe auf null Byte ab.
 FileAccess 
 FileAccess Enumerator wird verwendet, um Zugriff auf eine bestimmte Datei zu erhalten. Es hat die folgenden Mitglieder.
 Lesen 
 Schreiben 
 Lesen Schreiben 
 FileShare 
Das Fileshare Enumerator wird verwendet, um eine bestimmte Datei freizugeben. Es hat die folgenden Mitglieder.
 Vererbbar: Vererbbar ermöglicht es einem Dateihandle, eine Vererbung an die untergeordneten Prozesse zu übergeben.
 Keiner: Keine lehnt die Freigabe der aktuellen Datei ab
 Lesen: Lesen ermöglicht das Öffnen der Datei zum Lesen.
 Lesen Schreiben: ReadWrite ermöglicht das Öffnen der Datei zum Lesen und Schreiben.
 Schreiben: Schreiben ermöglicht das Öffnen der Datei zum Schreiben.
 Veranstaltungen 
Ein Ereignis ist allgemein als eine Aktion bekannt, die vom Benutzer generiert wird. Es kann ein Mausklick und sogar ein einziger Tastendruck auf der Tastatur sein. In ähnlicher Weise haben C # -Programme auch Ereignisse. Der Generator des Ereignisses heißt Verleger und der Empfänger des Ereignisses heißt der Teilnehmer. 
 Verleger 
ZU Verleger enthält die Definition des Ereignisses und des Delegaten. Das Event-Delegierter Zuordnung ist in diesem Objekt definiert. EIN Verleger Das Klassenobjekt ruft das Ereignis auf und wird an andere Objekte benachrichtigt.
 Teilnehmer 
ZU Teilnehmer nimmt die Veranstaltung an und bietet eine Event-Handler. Das delegieren In der Publisher-Klasse wird die Methode / das Ereignis aufgerufen Handler der Teilnehmerklasse.
 Beispiel: 
Verwenden des System-Namespace Edureka {public delegate string Del (string str) -Klasse EventBlock {event Del NewEvent public EventBlock () {this.NewEvent + = new Del (this.WelcomeUser)} public string WelcomeUser (string username) {return 'Willkommen bei Edureka . '+ Benutzername} static void Main (string [] args) {EventBlock obj1 = new EventBlock () string result = obj1.NewEvent (' Happy Learning ') Console.WriteLine (result)}}}
 //Ausgabe: 
Willkommen bei Edureka. Viel Spaß beim Lernen
 Generika 
 Generika ist ein Konzept, um den Mitgliedern und Methoden einer Klasse Platzhalter zur Verfügung zu stellen Laufzeit. Wir können Generika mit definieren Klammern. Schauen wir uns die folgenden Beispiele an.
 Generika in einer Klasse 
Verwenden des System-Namespace Edureka {Klasse GenericClass {public GenericClass (T msg) {Console.WriteLine (msg)}} Klasse Programm {static void Main (string [] args) {GenericClass gen = new GenericClass ('Diese Nachricht stammt aus der generischen Klasse' ) GenericClass genI = new GenericClass (123) GenericClass getCh = new GenericClass ('E')}}}
 //Ausgabe: 
Diese Nachricht stammt aus einer generischen Klasse 
 123 
 IS
 Generika in einer Methode 
Verwenden des System-Namespace Edureka {Klasse GenericClass {public void Show (T msg) {Console.WriteLine (msg)}} Klasse Programm {statische Leere Main (string [] args) {GenericClass genC = new GenericClass () genC.Show ('This Die Nachricht stammt von der generischen Methode ') genC.Show (321) genC.Show (' H ')}}}
 //Ausgabe: 
Diese Nachricht stammt von der generischen Methode 
 321 
 H.
 Delegierte 
Das Delegieren fungiert als Referenz auf die Methode. Im Grunde ist es dasselbe wie ein Funktionszeiger in C und C ++ aber weitaus besser und typsicher. Der Delegierte in statische Methode kapselt nur die Methode. Während der Delegierte in der Beispiel Methode kapselt sowohl Methode als auch Instanz. Die beste Verwendung von Delegate ist die Verwendung als Veranstaltung. 
 Beispiel: 
using System delegate int Rechner (int n) öffentliche Klasse Edureka {statische int Nummer = 25 öffentliche statische int add (int n) {Nummer = Nummer + n Rückgabewert} öffentliche statische int mul (int n) {Nummer = Nummer * n Rückgabe number} public static int getNumber () {return number} public static void Main (string [] args) {Rechner c1 = neuer Rechner (add) Rechner c2 = neuer Rechner (mul) c1 (20) Console.WriteLine ('Nach dem Rechner Bei einem Delegaten lautet die neue Nummer: '+ getNumber ()) c2 (3) Console.WriteLine (' Nach zwei Delegierten des Rechners lautet die neue Nummer: '+ getNumber ())}}
 //Ausgabe: 
Nach dem Rechner eines Delegierten lautet die neue Nummer: 45 
 Nach dem zweiten Delegierten des Rechners lautet die neue Nummer: 135
 Betrachtung 
Die Reflexion ist erforderlich, um die Metadaten zur Laufzeit abzurufen. Die Referenz ist verfügbar in System.Reflexion Namespace. Für die Ausführung sind die folgenden Klassen erforderlich.
Art
MemberInfo
ConstructorInfo
MethodInfo
FieldInfo
PropertyInfo
TypeInfo
EventInfo
Modul
Versammlung
Baugruppenname
Zeiger
 Typklasse 
Die C # -Typklasse repräsentiert Typdeklarationen für Klassentypen, Schnittstellentypen, Aufzählungstypen, Arraytypen und Werttypen
Typ Eigenschaften
Eine Liste wichtiger Eigenschaften von Typklassen wird unten erwähnt.
 Eigentum 
 Beschreibung 
 Versammlung 
Ruft die Assembly für diesen Typ ab.
 AssemblyQualifiedName 
Ruft den qualifizierten Assembly-Namen für diesen Typ ab.
 Attribute 
Ruft die dem Typ zugeordneten Attribute ab.
 Basistyp 
Ruft den Basis- oder Elterntyp ab.
 Vollständiger Name 
Ruft den vollständig qualifizierten Namen des Typs ab.
 IsAbstract 
wird verwendet, um zu überprüfen, ob der Typ Abstrakt ist.
 IsArray 
wird verwendet, um zu überprüfen, ob der Typ Array ist.
 IsClass 
wird verwendet, um zu überprüfen, ob der Typ Klasse ist.
 IsEnum 
wird verwendet, um zu überprüfen, ob der Typ Enum ist.
 IsInterface 
wird verwendet, um zu überprüfen, ob der Typ Schnittstelle ist.
 IsNested 
wird verwendet, um zu überprüfen, ob der Typ verschachtelt ist.
 IsPrimitive 
wird verwendet, um zu überprüfen, ob der Typ primitiv ist.
 IsPointer 
wird verwendet, um zu überprüfen, ob der Typ Zeiger ist.
 IsNotPublic 
wird verwendet, um zu überprüfen, ob der Typ nicht öffentlich ist.
 IsPublic 
wird verwendet, um zu überprüfen, ob der Typ Öffentlich ist.
 IsSealed 
wird verwendet, um zu überprüfen, ob der Typ versiegelt ist.
 IsSerializable 
wird verwendet, um zu überprüfen, ob der Typ serialisierbar ist.
 MemberType 
wird verwendet, um zu überprüfen, ob der Typ Mitgliedstyp des verschachtelten Typs ist.
 Modul 
Ruft das Modul des Typs ab.
 Name 
Ruft den Namen des Typs ab.
 Namespace 
Ruft den Namespace des Typs ab.
 Eigentum 
 Beschreibung 
 GetConstructors () 
Gibt alle öffentlichen Konstruktoren für den Typ zurück.
 GetConstructors (BindingFlags) 
Gibt alle Konstruktoren für den Typ mit den angegebenen BindingFlags zurück.
 GetFields () 
Gibt alle öffentlichen Felder für den Typ zurück.
 GetFields (BindingFlags) 
Gibt alle öffentlichen Konstruktoren für den Typ mit den angegebenen BindingFlags zurück.
 GetMembers () 
Gibt alle öffentlichen Mitglieder für den Typ zurück.
 GetMembers (BindingFlags) 
Gibt alle Elemente für den Typ mit den angegebenen BindingFlags zurück.
 GetMethods () 
Gibt alle öffentlichen Methoden für den Typ zurück.
 GetMethods (BindingFlags) 
Gibt alle Methoden für den Typ mit den angegebenen BindingFlags zurück.
 GetProperties () 
Gibt alle öffentlichen Eigenschaften für den Typ zurück.
 GetProperties (BindingFlags) 
Gibt alle Eigenschaften für den Typ mit den angegebenen BindingFlags zurück.
 GetType () 
Ruft den aktuellen Typ ab.
 GetType (String) 
Ruft den Typ für den angegebenen Namen ab.
 Reflexionsbeispiele: 
 Typ abrufen 
 Beispiel: 
Verwenden der öffentlichen Systemklasse GetType {public static void Main () {int a = 10 Typ type = a.GetType () Console.WriteLine (type)}}
 //Ausgabe: 
System.Int32
 
 Montage abrufen 
 Beispiel: 
using System using System.Reflection öffentliche Klasse GetAssembly {public static void Main () {Typ t = typeof (System.String) Console.WriteLine (t.Assembly)}}
 //Ausgabe: 
System.Private.CoreLib, Version = 4.0.0.0, Culture = neutral, PublicKeyToken = 7cec85d7bea7798e
 
 Drucktypinformationen 
 Beispiel: 
Verwenden des Systems Verwenden der öffentlichen Klasse System.Reflection PrintType {public static void Main () {Typ t = typeof (System.String) Console.WriteLine (t.FullName) Console.WriteLine (t.BaseType) Console.WriteLine (t.IsClass) Console.WriteLine (t.IsEnum) Console.WriteLine (t.IsInterface)}}
 //Ausgabe: 
Wahr 
 Falsch 
 Falsch
 
 Konstruktoren drucken 
 Beispiel: 
using System using System.Reflection öffentliche Klasse PrintConstructors {public static void Main () {Typ t = typeof (System.String) Console.WriteLine ('Konstruktoren vom Typ {0} ...', t) ConstructorInfo [] ci = t .GetConstructors (BindingFlags.Public | BindingFlags.Instance) foreach (ConstructorInfo c in ci) {Console.WriteLine (c)}}}
 //Ausgabe: 
Konstruktoren vom Typ System.String ... 
 Void .ctor (Char []) 
 Void .ctor (Char [], Int32, Int32) 
 Void .ctor (Char *) 
 Void .ctor (Char *, Int32, Int32) 
 Leerer .ctor (SByte *) 
 Void .ctor (SByte *, Int32, Int32) 
 Void .ctor (SByte *, Int32, Int32, System.Text.Encoding) 
 Void .ctor (Char, Int32) 
 Void .ctor (System.ReadOnlySpan`1 [System.Char])
 
 Druckmethoden 
 Beispiel: 
using System using System.Reflection öffentliche Klasse PrintMethods {public static void Main () {Typ t = typeof (System.String) Console.WriteLine ('Methoden vom Typ {0} ...', t) MethodInfo [] ci = t .GetMethods (BindingFlags.Public | BindingFlags.Instance) foreach (MethodInfo m in ci) {Console.WriteLine (m)}}}
 //Ausgabe: 
Methoden des System.String-Typs ... 
 System.String ersetzen (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) ......
 
 Felder drucken 
 
 Beispiel: 
using System using System.Reflection öffentliche Klasse PrintFields {public static void Main () {Typ t = typeof (System.String) Console.WriteLine ('Felder vom Typ {0} ...', t) FieldInfo [] ci = t .GetFields (BindingFlags.Public | BindingFlags.Static | BindingFlags.NonPublic) foreach (FieldInfo f in ci) {Console.WriteLine (f)}}}
 //Ausgabe: 
Felder vom Typ System.String ... 
 System.String leer
Kommen wir nun zu einigen erweiterten C # -Programmierkonzepten
 Erweiterte C # -Konzepte 
 Anonyme Funktion 
 Multithreading 
 Ausnahmebehandlung 
 Synchronisation 
 Neue Eigenschaften 
 Anonyme Funktion 
Die Funktion, der ein bestimmter Name fehlt, wird aufgerufen Anonym Funktionen. In C # stehen zwei Arten von anonymen Funktionen zur Verfügung
Lambda-Ausdrücke
Anonyme Methoden
 Beispiel: 
Verwenden des System-Namespace LambdaExpressions {Klasse Edureka {Delegat int Square (int num) statische Leere Main (string [] args) {Square GetSquare = x => x * x int j = GetSquare (25) Console.WriteLine ('Square:' + j)}}}
 //Ausgabe: 
Quadrat: 625
 Anonyme Methoden 
Das anonyme Methode bietet die gleiche Funktionalität wie ein Lambda-Ausdruck, außer dass es uns erlaubt, die Parameterliste zu ignorieren.
 Beispiel: 
Verwenden des System-Namespace AnonymousMethods {Klassenprogramm {öffentlicher Delegat void AnonymousFun () statisch void Main (string [] args) {AnonymousFun fun = delegate () {Console.WriteLine ('Dies ist eine anonyme Funktion')} fun ()}}}
 //Ausgabe: 
Dies ist eine anonyme Funktion
 Multithreading 
Multithreading ist ein Prozess, bei dem mehrere Threads für verschiedene Aufgaben erstellt und zugewiesen werden. Dies spart Zeit, indem mehrere Jobs gleichzeitig ausgeführt werden. Die Multithreading-Klasse ist in verfügbar System.Threading Namespace.
 System.Threading-Namespace 
Das System.Threading Der Namespace enthält Klassen und Schnittstellen, um das Multithreading zu erleichtern. Es bietet Klassen zum Synchronisieren der Thread-Ressource. Eine Liste häufig verwendeter Klassen finden Sie unten:
Faden
Mutex
Timer
Monitor
Semaphor
ThreadLocal
ThreadPool
Flüchtig
 Prozess und Thread 
Der Prozess ist eigentlich und Anwendung und es wird als a angesehen Schwergewicht Komponente. Auf der anderen Seite ist der Thread ein einzelner Modul der gesamten Anwendung. Es ist Leicht im Vergleich zum Prozess
 Der Lebenszyklus eines Threads 
Jeder Thread hat einen Lebenszyklus. Der Lebenszyklus des Threads wird in der Klasse System.Threading.Thread definiert. Im Folgenden sind die Phasen im Lebenszyklus eines Threads aufgeführt.
Nicht gestartet
Runnable (betriebsbereit)
Laufen
Nicht lauffähig
tot
Die Thread-Klasse bietet die folgenden Eigenschaften und Methoden wie folgt.
 Thread-Eigenschaften 
 Eigentum 
 Beschreibung 
 CurrentThread 
Gibt die Instanz des aktuell ausgeführten Threads zurück.
 Ist am Leben 
prüft, ob der aktuelle Thread aktiv ist oder nicht.
 IsBackground 
Das Abrufen / Festlegen des Werts des aktuellen Threads erfolgt im Hintergrund oder nicht.
 ManagedThreadId 
wird verwendet, um die eindeutige ID für den aktuell verwalteten Thread abzurufen.
 Name 
wird verwendet, um den Namen des aktuellen Threads abzurufen oder festzulegen.
 Priorität 
wird verwendet, um die Priorität des aktuellen Threads abzurufen oder festzulegen.
 ThreadState 
wird verwendet, um einen Wert zurückzugeben, der den Thread-Status darstellt.
 Thread-Methoden 
 Methode 
 Beschreibung 
 Abtreibung() 
wird verwendet, um den Thread zu beenden. Es löst eine ThreadAbortException aus.
 Unterbrechen() 
wird verwendet, um einen Thread zu unterbrechen, der sich im Status WaitSleepJoin befindet.
 Beitreten() 
wird verwendet, um alle aufrufenden Threads zu blockieren, bis dieser Thread beendet wird.
 ResetAbort () 
wird verwendet, um die Abbruchanforderung für den aktuellen Thread abzubrechen.
 Lebenslauf() 
wird verwendet, um den angehaltenen Thread fortzusetzen. Es ist veraltet.
 Schlaf (Int32) 
wird verwendet, um den aktuellen Thread für die angegebenen Millisekunden anzuhalten.
 Start() 
ändert den aktuellen Status des Threads in Runnable.
 Aussetzen() 
Hält den aktuellen Thread an, wenn er nicht angehalten ist. Es ist veraltet.
 Ausbeute() 
wird verwendet, um die Ausführung des aktuellen Threads an einen anderen Thread zu übergeben.
 Haupt-Thread-Beispiel 
using System using System.Threading öffentliche Klasse Edureka {public static void Main (string [] args) {Thread t = Thread.CurrentThread t.Name = 'MainThread' Console.WriteLine (t.Name)}}
 //Ausgabe: 
Haupt-Bedroung
 
 Ausnahmebehandlung 
Das Ausnahme ist ein Fehler, den das Programm zur Laufzeit auslöst. Wir führen die Ausnahmebehandlung durch, um unser Programm ausnahmefrei zu machen.
 Ausnahme 
 Beschreibung 
 System.DivideByZeroException 
Fehler durch Teilen einer Zahl mit Null.  
  
 System.NullReferenceException 
Behandelt den Fehler, der durch Verweisen auf das Nullobjekt generiert wird.  
  
 System.InvalidCastException 
Behandelt den Fehler, der durch ungültige Typumwandlung generiert wird.  
  
 System.IO.IOException 
behandelt die Eingabe- / Ausgabefehler.
 System.FieldAccessException 
Fehler durch ungültigen privaten / geschützten Zugriff.
 
In C # verwenden wir 4 Schlüsselwörter, um durchzuführen Ausnahmebehandlung: 
Versuchen
Fang
endlich und
werfen
  Beispiel:  
Verwenden der öffentlichen Systemklasse EdurekExample {public static void Main (string [] args) {try {int a = 10 int b = 0 int x = a / b} catch (Ausnahme e) {Console.WriteLine (e)} Console.WriteLine ('Diese Nachricht stammt aus dem Catch-Block')}}
 
 //Ausgabe: 
System.DivideByZeroException: Es wurde versucht, durch Null zu teilen. 
 bei ExExaEdurekample.Main (String [] args) in F: C # TutorialC # ProgramsConsoleApp1ConsoleApp1Program.cs: Zeile 10 
 Diese Nachricht stammt aus dem Catch-Block
 Beispiel für eine benutzerdefinierte Ausnahme 
Verwenden der öffentlichen Systemklasse InvalidAgeException: Exception {public InvalidAgeException (String message): base (message) {}} public class Angepasst {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.') } } 
 //Ausgabe: 
InvalidAgeException: Das Alter wird voraussichtlich größer als 18 Jahre sein 
 bei Customized.validate (Int32-Alter) in F: C # TutorialC # ProgramsConsoleApp1ConsoleApp1Program.cs: Zeile 18 
 at Customized.Main (String [] args) in F: C # TutorialC # ProgramsConsoleApp1ConsoleApp1Program.cs: Zeile 23 
 Der Catch-Block wird jetzt ausgeführt.
java system.exit (1)
 
 Zum Schluss Blockbeispiel 
Verwenden der öffentlichen Systemklasse FinalExecption {public static void Main (string [] args) {try {int a = 10 int b = 0 int x = a / b} catch (Ausnahme e) {Console.WriteLine (e)} finally {Console .WriteLine ('Endlich Block wird ausgeführt')} Console.WriteLine ('Catch-Block wird ausgeführt')}}
 //Ausgabe: 
System.DivideByZeroException: Es wurde versucht, durch Null zu teilen. 
 bei FinalExecption.Main (String [] args) in F: C # TutorialC # ProgramsConsoleApp1ConsoleApp1Program.cs: Zeile 10 
 Schließlich wird der Block ausgeführt 
 Catch Block wird ausgeführt
 Systemausnahmesignatur 
[SerializableAttribute] [ComVisibleAttribute (true)] öffentliche Klasse SystemException: Exception
 Systemausnahmekonstruktoren 
 Baumeister 
 Beschreibung 
 SystemException () 
Es wird verwendet, um eine neue Instanz der SystemException-Klasse zu initialisieren.
 SystemException 
 (SerializationInfo, StreamingContext) 
Es wird verwendet, um eine neue Instanz der SystemException-Klasse mit serialisierten Daten zu initialisieren.
 SystemException (String) 
Es wird verwendet, um eine neue Instanz der SystemException-Klasse mit einer angegebenen Fehlermeldung zu initialisieren.
 SystemException (String, Exception) 
Es wird verwendet, um eine neue Instanz der SystemException-Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme zu initialisieren, die die Ursache für diese Ausnahme ist.
 Systemausnahmeeigenschaften 
 Eigentum 
 Beschreibung 
 Daten 
Es wird verwendet, um eine Sammlung von Schlüssel / Wert-Paaren abzurufen, die zusätzliche benutzerdefinierte Informationen zur Ausnahme bereitstellen.
 HelpLink 
Es wird verwendet, um einen Link zu der Hilfedatei abzurufen oder festzulegen, die dieser Ausnahme zugeordnet ist.
 HResult 
Es wird verwendet, um HRESULT abzurufen oder festzulegen, einen codierten numerischen Wert, der einer bestimmten Ausnahme zugewiesen ist.
 InnerException 
Es wird verwendet, um die Exception-Instanz abzurufen, die die aktuelle Ausnahme verursacht hat.
 Botschaft 
Es wird verwendet, um eine Nachricht abzurufen, die die aktuelle Ausnahme beschreibt.
 Quelle 
Es wird verwendet, um den Namen der Anwendung abzurufen oder festzulegen, die den Fehler verursacht.
 StackTrace 
Es wird verwendet, um eine Zeichenfolgendarstellung der unmittelbaren Frames auf dem Aufrufstapel abzurufen.
 Zielseite 
Es wird verwendet, um die Methode abzurufen, die die aktuelle Ausnahme auslöst.
 Systemausnahmemethoden 
 Methoden 
 Beschreibung 
 Gleich (Objekt) 
Es wird verwendet, um zu überprüfen, ob das angegebene Objekt dem aktuellen Objekt entspricht oder nicht.
 Finalize () 
Es wird verwendet, um Ressourcen freizugeben und Bereinigungsvorgänge durchzuführen.
 GetBaseException () 
Es wird verwendet, um eine Root-Ausnahme zu erhalten.
 GetHashCode () 
Es wird verwendet, um den Hash-Code abzurufen.
 GetObjectData 
 (SerializationInfo, StreamingContext) 
Es wird verwendet, um Objektdaten abzurufen.
 GetType () 
Es wird verwendet, um den Laufzeittyp der aktuellen Instanz abzurufen.
 MemberwiseClone () 
Es wird verwendet, um eine flache Kopie des aktuellen Objekts zu erstellen.
 ToString () 
Es wird verwendet, um eine Zeichenfolgendarstellung der aktuellen Ausnahme zu erstellen und zurückzugeben.
 Beispiel für eine Systemausnahme 
Verwenden des System-Namespace CSharpProgram {Klasse SystemExceptionExample {static void Main (Zeichenfolge [] Argumente) {try {int [] arr = new int [5] arr [10] = 25} catch (SystemException e) {Console.WriteLine (e)} }}}
 //Ausgabe: 
System.IndexOutOfRangeException: Der Index lag außerhalb der Grenzen des Arrays. 
 at CSharpProgram.SystemExceptionExample.Main (String [] args) in F: C # TutorialC # ProgramsConsoleApp1ConsoleApp1Program.cs: Zeile 11
 
 Synchronisation 
Die Synchronisierung kann eine Technik sein, mit der nur ein Thread für eine bestimmte Zeit auf die Ressource zugreifen kann. Kein alternativer Thread wird unterbrochen, bis der festgelegte Thread seine Aufgabe beendet hat.
Im Multithreading-Programm sind Threads zulässigum auf eine Ressource für die zuzugreifenangegebene AusführungZeit. Threads teilen Ressourcen und werden asynchron ausgeführt. Zugriff auf gemeinsam genutzte Ressourcen (Daten)kann eine wichtige Aufgabe seindas allgemeinkönnte aufhörendas System.wir neigen dazu, es zu beeinflussendurch synchrones Erstellen von Threads.
 Beispiel ohne Synchronisation 
using System using System.Threading-Klasse 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() } } 
 //Ausgabe: 
 
ein 
 ein 
 2 
 2 
 3 
 3 
 4 
 4 
 5 
 5 
 6 
 6 
 7 
 7 
 8 
 8 
 9 
 9 
 10 
 10
 
 Beispiel mit Synchronisation 
using System using System.Threading-Klasse 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() } } 
 //Ausgabe: 
ein 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 ein 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10
 Neue Eigenschaften 
Microsoft hat der C # -Sprache viele neueste Funktionen hinzugefügt. Einige davon sind unten aufgeführt.
C # 6.0
Statische Direktive verwenden
Ausnahmefilter
Warten Sie in catch / finally-Blöcken
Auto-Eigenschaftsinitialisierer
Standardwerte für Nur-Getter-Eigenschaften
Mitglieder mit Ausdruckskörper
Null-Propagator
String-Interpolation
Name des Betreibers
Wörterbuchinitialisierer
Compiler-as-a-Service (Roslyn)
C # 7.0
Mustervergleich
Tupel
Dekonstruktion
Lokale Funktionen
Zifferntrennzeichen
Binäre Literale
Ref kehrt zurück und Einheimische
Konstrukteure und Finalisierer mit Expressionskörper
Getter und Setter mit Ausdruckskörper
Out Variablen
Verallgemeinerte asynchrone Rückgabetypen
C # 7.1
Async main
Standardausdrücke
 Interview Fragen basierend auf C # 
Das wichtige Interview Fragen, die auf der Programmiersprache C # basieren, finden Sie in diesem Update  .
Damit sind wir am Ende dieses Artikels zum Thema „C # -Tutorial“ angelangt. Ich hoffe, Sie haben die Bedeutung von Datenstrukturen, Syntax, Funktionalität und Operationen verstanden, die mit ihnen ausgeführt werden. Nachdem Sie die Grundlagen der Programmierung in C # verstanden habenC # Tutorial, Besuche die  Schulung vermittelt  von Edureka über viele Technologien wie Java, Frühling und vieleDarüber hinaus erhielt ein vertrauenswürdiges Online-Lernunternehmen mit einem Netzwerk von mehr als 250.000 zufriedenen Lernenden auf der ganzen Welt eine  Frage an uns? Erwähnen Sie es im Kommentarbereich dieses 'C # Tutorial' -Blogs und wir werden uns so schnell wie möglich bei Ihnen melden.