Schnelles Lernen C# für Anfänger

View more Tutorials:

1- Die Vorstellung

Das ist die Anleitung von C# für den Anfänger. Um C# zu programmieren sollen Sie die Programmierungstoll Visual Studio zu installieren. Sie können die Führung für das Herunterladen und die Installation bei ... lernen
Wenn Sie mit   C# anfängen. sollen Sie diese Unterlagen vom oben nach hinten lesen, damit Sie eine Überblick haben bevor Sie ins Details gehen 

2- Ihre erste C# Projekt erstellen

Das ist das erste Foto bei der Öffnung vom Visual Studio.
Erstellen Sie ein Project:
Wir erstellen ein einfaches Projekt (Die Applikation Console ist eine Applikation ohne die Interface). Geben Sie ein
  • Name: HelloCSharp
  • Solution: Create new solution
  • Solution Name: MySolution
Das ist das Foto von Ihrem Projekt. Sie sollen auf Solution Explorer klicken um die Struktur vom erstellten Projekt zu kennen
Visual Studio erstellt eine Solution (die Maßnahme) mit dem Name vom MySolution , die ein Projekt mit dem Name von  HelloCSharp enthaltet. Und erstellen Sie standardmäßig eine Klasse mit dem Name vom Program (der File Program.cs entspricht).
Beachten Sie: Eine  Solution (die Maßnahme) kann ein oder viel Project haben.
Ändern Sie die Kode von der Klasse Program,um beim Laufen auf dem Bildschirm von Console die Wörter "Hello CSharp" anzuzeigen und wartet darauf, der Benutzer ein Text vor dem Ende typen
Klicken Sie auf  Start um die Klasse Program zu laufen.

3- Die Struktur einer Klasse erklären

Das folgende Beispiel bezeichnet die Struktur der Klasse Program,. Es liegt in der namespace   HelloCSharp. Eine namespace kann eine oder viele Klasse enthalten
Wenn Sie eine Klasse benutzen möchten, sollen Sie die Benutzung der Klasse melden oder die Benutzung der namespace von Klasse melden
// Die Erklärung der Benutzung von namespace System .
// (d.h alle Klasse ,.. in dieser namespace benutzen können).
using System;
Beim Laufen des Programm wird die Methode Main(string[]) zur Implementierung aufgeruft.
  1. static ist ein Schlüsselwort zu informieren, dass das eine static Methode ist.
  2. void ist ein Schlüsselwort zu informieren, dass die Methode nicht rückgibt.
  3. args ist der Parameter der Methode. es ist ein Array des String  - string[].
static void Main(string[] args)
{
    // Print text to the console window.
    Console.WriteLine("Hello CSharp");

    // Wait for the user to enter something and press Enter before ending the program.
    Console.ReadLine();
}
Nach der Meldung der Benutzung des namespace System können Sie die Klasse   Console in der  namespace.  WriteLine(string) ist eine static Methode von der Klasse Console. Es chreibt einen String auf dem Bildschirm
// Die Erklärung der Benutzung von System namespace
// (es enthaltet die Klasse Console).
using System;

// Und Sie können die Klasse Console:
Console.WriteLine("Hello CSharp");

// Wenn Sie die Benutzung von System namespace nicht erklären.
// Aber Sie die Klasse Console benutzen möchten, sollen Sie länger schreiben:
System.Console.WriteLine("Hello CSharp");

4- Die Struktur des Projekt erklären

Eine Maßnahme ( Solution) kann viele Project enthalten. Im  Project gibt es viele Klasse (class).
Auf  "Class view" können Sie wissen, zu welcher namespace Ihre Klasse gehören
Im  CSharp erstellen Sie eine Klasse Animal mit dem namespace  HelloCSharp. Die Klasse liegt standardmäßig in dem Hauptverzeichnis des Projekt. Sie erstellen eine andere Klasse MyClass mit dem namespace O7planning.CSharp . Die Klasse liegt auch beim Hauptverzeichnis des Projekt. Bei einem großen Verzeichnis mit vielen Klassen ist Ihnen die Fileausgliederung schwierig. Sie können die verschiedenen Verzeichnisse zur Enthaltung der Klasse und der Regelungen, die von Ihnen festgelegt werden. Aber Sie sollen bestens die Verzeichnisse, deren Name gleich wie den Name von namespace ist. Lernen Sie die Organisation von Java.

5- Die wichtigen Beachtungen mit dem C# Programm

In einer C# Applikation sollen Sie klar melden, dass die Methode Main(string[]) als die Startpunkt gilt um Ihre Applikation zu laufen. Das ist nicht zwanghaft wenn Ihre ganze Applikation eine einzige Funktion Main(string[]) hat, Aber wenn 2 Klasse die Methode Main hat und Sie nicht klar festlegen, wird eine Fehleranmeldung bei der  Kompilierung erscheinen .

Deshalb ist es am besten, dass Sie klar die Klasse mit der Methode Main(string[]) melden , Sie können eine andere Klasse wieder melden wenn Sie möchten
Klicken Sie die Rechtmaustaste auf  HelloCSharp Projekt, wählen Sie  Properties:
Wählen Sie  "Startup object" als eine Klasse mit der Methode   Main(string[]) und speichern (Save).

6- Eine Klasse neu einfügen

Jetzt füge ich eine neue Klasse mit dem Name von MyClass mit dem namespace  O7planning.CSharp.ein
Auf  "Solution Explorer" klicken Sie die Rechtmaustaste auf dem Projekt und wählen Sie
  • Add/New Folder
Stellen Sie den Name für den Ordner O7planning.
Zunächst erstellen Sie weiter einen Ordner "CSharp" als den Sub-Ordner vom Ordner  "O7planning".
Klicken Sie die Rechtmaustaste auf dem Ordner   "CSharp" und wählen Sie
  • Add/Class
Wählen Sie Item Class, und geben Sie den Name der Klasse ein.
Die Klasse wird erstellt. Sie liegt in dem Namespace "HelloCSharp.O7planning.CSharp". Sie können den Name für namespace zum "O7planning.CSharp".ändern
Ändern Sie den Name vom   namespace zum  "O7planning.CSharp".
Sie können die Inhalt der Klasse ändern
MyClass.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace O7planning.CSharp
{
   class MyClass
   {
       static void Main(string[] args)
       {
           Console.WriteLine("Hello from MyClass");
           Console.ReadLine();
       }
   }
}
Melden Sie die Klasse MyClass als der Beginnspunkt zum Laufen. Klicken Sie die Rechtmaustaste auf Project und wählen Sie  Properties
Das Beispiel durchlaufen

7- Die Datentypen im C#

Type Represents Range Default Value
bool Boolean value True or False False
byte 8-bit unsigned integer 0 to 255 0
char 16-bit Unicode character U +0000 to U +ffff '\0'
decimal 128-bit precise decimal values with 28-29 significant digits (-7.9 x 1028 to 7.9 x 1028) / 100 to 28 0.0M
double 64-bit double-precision floating point type (+/-)5.0 x 10-324 to (+/-)1.7 x 10308 0.0D
float 32-bit single-precision floating point type -3.4 x 1038 to + 3.4 x 1038 0.0F
int 32-bit signed integer type -2,147,483,648 to 2,147,483,647 0
long 64-bit signed integer type -923,372,036,854,775,808 to 9,223,372,036,854,775,807 0L
sbyte 8-bit signed integer type -128 to 127 0
short 16-bit signed integer type -32,768 to 32,767 0
uint 32-bit unsigned integer type 0 to 4,294,967,295 0
ulong 64-bit unsigned integer type 0 to 18,446,744,073,709,551,615 0
ushort 16-bit unsigned integer type 0 to 65,535 0

8- Die Variabel und die Meldung

Eine Variable wird durch einen Name für eine Lagerung der Daten bestimmt, wo Ihr Programm verarbeiten kann. Jede Variable im  C# hat ein bestimmt Datentyp, indem die Größe und der Bereich der Wert zur Speicherung bestimmt werden und die Kollektion der Operator für Variable angewendet werden
Die Variable kann die Wert während ihrer Existenz im Programm ändern. Die Variable mit der bestimmten Wert werden die Konstante genannt. Benutzen Sie ein Schlüsselwort const zur Meldung einer Variable Konstante
Melden Sie eine Variable
// Eine Variable erklären
// Data Type: Das Datenstyp
// Variable Name : der Name der Variable .
<Data Type> <Variable name>;

// Eine Variable erklären und die Wert anweisen.
<Data Type> <Variable name> = <value>;

// Die Konstanste erklären (constants)
const <Data Type> <Variable name> = <value>;
VariableExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class VariableExample
    {   
        static void Main(string[] args)  
        {
            // Eine Konstante mit dem Typ vom int erklären.
            // Sie können die Wert für Konstante anweisen.
            const int MAX_SCORE = 100;

            // Eine Variabel mit dem Typ vom int erklären.
            int score = 0;

            // Die neue Wert für die Variable score anweisen
            score = 90;

            // Ein String erklären (string).
            string studentName = "Tom";

            // Die Wert der Variable auf dem Bildschirm Console ausdrucken.
            Console.WriteLine("Hi {0}", studentName);
            Console.WriteLine("Your score: {0}/{1}", score, MAX_SCORE);

            // Warten darauf, der Benutzer etwas eingibt und drücken auf Enter vor dem Ende des Programm.
            Console.ReadLine();
        }
       

    }
}
Das Ergebnis zur Beispiel-Durchführung

9- Der Zweigbefehl

9.1- Der Befehl If-else

if ist einen Befehl zur Prüfung einer Bedingung im   C#. Zum Beispiel: If (wenn) a > b , dann....
Die üblichen Operator zum Vergleich
Der Operator Die Bedeutung Zum Beispiel
> größer als 5 > 4 ist richtig (true)
< kleiner als 4 < 5 ist richtig (true)
>= größer als oder so gleich wie 4 >= 4 ist richtig (true)
<= kleiner als oder so gleich wie 3 <= 4 ist richtig (true)
== so gleich wie 1 == 1 ist richtig (true)
!= nicht gleich  1 != 2 ist richtig (true)
&& Und  a > 4 && a < 10
|| oder  a == 1 || a == 4
// Die Syntax
// condition: Die Bedingung zur Prüfung.
if ( condition )  
{
	// Hier etwas machen.
}
Zum Beispiel
// Zum Beispiel 1:
if ( 5 < 10 )
{
  Console.WriteLine( "Five is now less than ten");
}

// Zum Beispiel 2:
if ( true )
{
  Console.WriteLine( "Do something here");
}
Die volle Struktur vom   if - else if - else:
// Achten Sie, dass am meisten ein Befehl implementiert wird
// Das Programm prüft die Bedingungen vom oben nach hinten
// Beim Treffen der richtigen Bedingung wird das Befehl implementiert
// Die restlichen Bedingungen werden ignoriert 
...

// Wenn Condition1 richtig ist, dann  ..
if (condition1 )  
{
	 // Etwas machen wenn condition1 richtig ist (true).
}
// Umgekehrt wenn Condition2 richtig ist, dann ...
else if(condition2 )  
{
	// Hier etwas machen wenn condition2 richtig ist (condition1 ist false).
}
// Umgekehrt wenn conditonN richtig ist, dann ...
else if(conditionN )  
{
	 // Hier etwas machen wenn condition N richtig ist 
	 // (alle Bedingungen oben sind false).
}
// Umgekehrt (wenn alle Bedingungen oben false sind).
else  {
	 // etwas machen.
}
IfElseExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class IfElseExample
    {
        static void Main(string[] args)
        {
            // Ein Zahl mit dem Typ von int erklären, die Ihr Alter bezeichnet.
            int age;

            Console.WriteLine("Please enter your age: \n");

            // Eine Variable erklären um die Text vom Benutzer zu speichern.
            string inputStr = Console.ReadLine();

            // Int32  ist eine Klasse in namespace System.
            // Die static Methode Parse der Klasse Int32 benutzen um ein String 
            // zu einer Zahl umzuwandeln und in die Variable age anzuweisen.
            // (Achtung: Wenn 'inputStr' kein Zahlstring ist, kann es den Fehler des Programm hier machen).
            age = Int32.Parse(inputStr);

            Console.WriteLine("Your age: {0}", age);

            // Prüfen, wenn das Alter kleiner als 80 ist, dann ...
            if (age < 80)
            {
                Console.WriteLine("You are pretty young");
            }

            // Umgekehrt wenn das Alter in Raum 80 - 100 liegt, dann ...
            else if (age >= 80 && age <= 100)
            {
                Console.WriteLine("You are old");
            }
            // Umgekehrt (die restlichen Fällen)
            else
            {
                Console.WriteLine("You are verry old");
            }

            Console.ReadLine();
        }
    }
}
Das Beispiel durchführen und 81 eingeben und das Ergebni sehen

9.2- Der Befehl Switch-Case

Die Syntax der Befehl  switch:
// Den Schlüsselwort 'switch' benutzen um die Wert einer Variable zu prüfen.
switch ( <variable> )
{
  case value1:
      // Hier etwas machen wenn die Wert der Variable value1 ist
      break;
  case value2:
      // Hier etwas machen wenn die Wert der Variable value2 ist
      break;

  ...
	
  default:
     // Die restlichen Fällen
     break;
}
BreakExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class BreakExample       
    {
        static void Main(string[] args)
        {
            // Vorschlagen, der Benutzer eine Option wählen.
            Console.WriteLine("Please select one option:\n");

            Console.WriteLine("1 - Play a game \n");
            Console.WriteLine("2 - Play music \n");
            Console.WriteLine("3 - Shutdown computer \n");

             
            // Eine Variable Option erklären
            int option;

            // Der vom Benutzer eingegebene String
            string inputStr = Console.ReadLine();

            // String zur integer umwandeln
            option = Int32.Parse(inputStr);

            // Die Wert von 'option' prüfen.
            switch (option)
            {

                case 1:
                    Console.WriteLine("You choose to play the game");
                    break;
                case 2:
                    Console.WriteLine("You choose to play the music");
                    break;
                case 3:
                    Console.WriteLine("You choose to shutdown the computer");
                    break;
                default:
                    Console.WriteLine("Nothing to do...");
                    break;
            }

            Console.ReadLine();
        }
    }
}
führen Sie das Beispiel und geben Sie 2 ein

Beachten Sie

Der Befehl  break sagt dem Programm , switch auszutreten
Sie können viele Fälle ( case) zusammenstellen um einen gleichen Befehlblock durchzuführen
BreakExample2.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class BreakExample2
    {
        static void Main(string[] args)
        {
            // Die Variable erklären und die Wert 3 anweisen.
            int option = 3;

            Console.WriteLine("Option = {0}", option);

            // Die Wert von 'option' prüfen.
            switch (option)
            {

                case 1:
                    Console.WriteLine("Case 1");
                    break;

                // Falls option = 2,3,4,5, dann mach gleich 
                case 2: 
                case 3: 
                case 4: 
                case 5:
                    Console.WriteLine("Case 2,3,4,5!!!");
                    break;
                default:
                    Console.WriteLine("Nothing to do...");
                    break;
            } 

            Console.ReadLine();
        }
    }
}
Das Ergebnis zur Durchführung des Beispiel

10- Die Schleife im C#

Die Schleife (loop) wird zur wiederholende Durchführung eines Befehl benutzt. Es mach Ihr Programm einen Befehlblock wiederholen. Das ist eine der grundlegenden Funktionen in der Programmierung
C# unterstützt 3 unterschiedlichen Schleife
  • FOR
  • WHILE
  • DO WHILE

10.1- Die Schleife for

Die Struktur der Schleife  for:
// initialize variable: eine Variable initializieren
// condition: Die Bedingung.
// updates new value for variable: die Wert für Variable update.
for (initialize variable ; condition ; updates new value for variable )
{
	// Das Befehlsblock durchführen wenn die Bedingung richtig ist (true).
}
Zum Beispiel
// Zum Beispiel 1:
// Eine Variable  x erstellen und die Wert 0 anweisen.
// Die Prüfungsbedingung ist  x < 5
// Wenn x < 5 richtig ist, wird das Befehl durchgeführt.
// Nach jeder Iteration wird die Wert von x in 1 erhöht.
for (int  x = 0;  x < 5 ; x = x + 1)
{
	// Hier etwa machen wenn x < 5 richtig ist (true).
}


// Zum Beispiel 2:
// Eine Variable  x erstellen und die Wert ist 2.
// Die Prüfungsbedingung ist  x < 15
// Wenn x < 15 richtig ist, wird das Befehl durchgeführt.
// Nach jeder Iteration wird die Wert von x in 3 erhöht.
for (int  x = 2;  x < 15 ; x = x + 3)
{
	// Hier etwa machen wenn x < 15 richtig ist (true).
}
ForLoopExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class ForLoopExample
    {
        static void Main(string[] args)
        {
            Console.WriteLine("For loop example"); 

            // Eine Variable x erstellen und die Wert 2 anweisen
            // Die Bedingung zur Prüfung ist x < 15
            // Wenn x < 15 richtig ist, wird das Befehlsblock implementiert
            // Nach jeder Iteration wird die Wert x automatisch in 3 erhöht.
            for (int x = 2; x < 15; x = x + 3)
            {
                Console.WriteLine( );
                Console.WriteLine("Value of x = {0}", x); 
            } 

            Console.ReadLine();
        }
    }
}
Das Ergebnis der Beispiel-Durchführung

10.2- Die Schleife while

Die Syntax der Schleife   while:
// condition: die Bedingung
while (condition)  
{
	 // Wenn  'condition' richtig ist, wird das Befehlsblock durchgeführt.
}
Zum Beispiel
// Eine Variable x erstellen.
int x = 2;

while ( x < 10)
{
    // Hier etwas machen wenn  x < 10 richtig ist.
    ...
    	
    // Die neue Wert für die Variable x update
    x = x + 3;
}
WhileLoopExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class WhileLoopExample
    {
        static void Main(string[] args)
        {
           
            Console.WriteLine("While loop example");
 
            // Eine Variable x erstellen und die Wert 2 anweisen.
            int x = 2;

            // Die Bedingung ist x < 10.
            // Wenn x < 10 richtig ist, wird das Befehl implementiert.
            while (x < 10)
            {
                Console.WriteLine("Value of x = {0}", x);

                x = x + 3; 
            } 

            Console.ReadLine();
        }
    }
}
Das Ergebnis zur Beispiel-Durchführung

10.3- Die Schleife do-while

Die Syntax der Schleife  do-while
// Die Eigenschaft von der Schleife 'do-while' ist, 
// dass sie das Befehlsblock mindesten einmal implementiert.
// Nach jeder Iteration prüft sie wieder die Bedingungen.
// Wenn die Bedingung ist richtig, wird das Befehlsblock weiter implementiert.
do {
    // Hier etwas machen.
} while (condition); 
// Achtung: Brauchen Sie das Semikolon (;) hier.
DoWhileLoopExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class DoWhileLoopExample
    {
        static void Main(string[] args)
        { 

            Console.WriteLine("Do-While loop example"); 

            // Eine Variable x erstellen und die Wert 2 anweisen
            int x = 2;

            // Das Befehlsblock mindesten einmal implementieren
            // Nach jeder Iteration wird es die Bedingungen wieder prüfen.
            // Wenn die Bedingung richtig ist, wird das Befehl weiter durchgeführt 
            do
            {
                Console.WriteLine("Value of x = {0}", x);

                x = x + 3; 

            } while (x < 10);
            // Achtung: Das Semikolon hier brauchen
            Console.ReadLine();
        }
    }
}
Das Ergebnis zur Beispiel-Durchführung

10.4- Der Befehl break in die Schleife

break ist ein Befehl, der in einem Befehlblock einer Schleife liegen kann. Das ist der Befehl vom Ende der Schleife bedingunglos
LoopBreakExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class LoopBreakExample
    {
        static void Main(string[] args)
        { 
            Console.WriteLine("Break example");

            // Eine Variable x erstellen und die Wert 2 anweisen.
            int x = 2;

            while (x < 15)
            {

                Console.WriteLine("----------------------\n");
                Console.WriteLine("x = {0}", x);

                // Prüfen, wenn  x = 5  ist, aus der Schleife austreten.
                if (x == 5)
                {
                    break;
                }
                // Die Wert von x in 1 erhöhen (kürz geschrieben x = x + 1;).
                x++;
                Console.WriteLine("x after ++ = {0}", x);

            }

            Console.ReadLine();
        }
    }
}
Das Ergebnis zur Beispiel-durchführung

10.5- Der Befehl continue in die Schleife

continue ist ein Befehl, der in einer Schleife liegen kann. Beim Treffen mit dem Befehl c ontinue ignoriert das Programm die Befehle, die unter von continue liegen und beginnt eine neue Schleife
LoopContinueExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class LoopContinueExample
    {
        static void Main(string[] args)
        { 

            Console.WriteLine("Continue example");

            // Eine Variable x erstellen und die Wert 2 anweisen
            int x = 2;

            while (x < 7)
            {

                Console.WriteLine("----------------------\n");
                Console.WriteLine("x = {0}", x);

                //  Der Operator % ist die Division zur Restaufnahme.
                // Wenn x gerade ist, ignorier die Befehle unter 'continue',
                // und mach die neue Iteration weiter (wenn die Bedingung richtig ist) 
                if (x % 2 == 0)
                {
                    // Die Wert von x in 1 erhöhen (kürz geschrieben x = x + 1;).
                    x++;
                    continue;
                }
                else
                {
                    // Die Wert von x in 1 erhöhen (kürz geschrieben x = x + 1;).
                    x++;
                }
                Console.WriteLine("x after ++ = {0}", x);

            }

            Console.ReadLine();
        }
    }
}
Das Ergebnis zur Beispiel-Durchführung

11- Der Array im C#

11.1- der einseitige Array

Das ist eine Illustration über ein einseitiges Array mit 5 Elemente. Die Elemente werden vom 0 bis zum 4 gemarkiert
Die Syntax zur Meldung des einseitigen Array
// Way 1:
// Declare an array of int, specifies the elements.
int[] years = { 2001, 2003, 2005, 1980, 2003 };

// Way 2:
// Declare an array of floats, specifying the number of elements.
// (3 elements).
float[] salaries = new float[3];
ArrayExample1.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class ArrayExample1
    {
        static void Main(string[] args)
        {
            // Die Option 1:
            // Ein Array erklären, die Wert für die Element bestimmen.
            int[] years = { 2001, 2003, 2005, 1980, 2003 };

            // Length ist ein Property eines Array. Es gibt die Elemente des Array zurück.
            Console.WriteLine("Element count of array years = {0} \n", years.Length);

            // Die Schleife for benutzen um die Elemente des Array auszudrucken.
            for (int i = 0; i < years.Length; i++) {
                Console.WriteLine("Element at {0} = {1}", i, years[i]);
            }

            // Die Option 2:
            // Ein Array mit 3 Elemente erklären
            float[] salaries = new float[3];

            // Die Wert für die Elemente anweisen.
            salaries[0] = 1000;
            salaries[1] = 1200;
            salaries[2] = 1100;

            Console.ReadLine();
        }
    }
}
Das Ergebnis zur Beispiel-durchführung

11.2- der zweiseitge Array

Das ist die Illustration eines 2D-Array
Die Syntax zur Meldung eines 2D-Array:
// Eine zwei-Dimension, drei Zeile und fünf Spalte Array erklären 
// Die Wert für die Elemente bestimmen.
int[,] a =   new int[,]  {
    {1 , 2 , 3,  4,   5} ,
    {0,  3,  4,  5,   7},
    {0,  3,  4,  0,   0}
};

// Eine zwei-Dimension, drei Zeile und fünf Spalte Array erklären.
// Die Wert für die Elemente nicht bestimmen
int[,] a = new int[3,5];
ArrayExample2.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class ArrayExample2
    {
        static void Main(string[] args)
        {
            // Eine zwei-Dimension, drei Zeile und fünf Spalte Array erklären.
            // Die Wert von Element bestimmen.            
            int[,] a =   { 
                          { 1, 2, 3, 4, 5 },
                          { 0, 3, 4, 5, 7 },
                          { 0, 3, 4, 0, 0 } 
                          };

            // Die Schleife for benutzen um die Elemente des Array auszudrucken.
            for (int row = 0; row < 3; row++) {
                for (int col = 0; col < 5; col++) {
                    Console.WriteLine("Element at [{0},{1}] = {2}", row, col, a[row,col]);
                }
                Console.WriteLine("-------------");
            }

            // Eine zwei-Dimension, drei Zeile und fünf Spalte Array erklären
            // Die Elemente werden die Wert nicht angewiesen
            int[,] b = new int[3, 5];

            Console.ReadLine();
        }
    }
}
Das Ergebnis zur Beispiel-durchführung

11.3- der Array des Array

ArrayOfArrayExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class ArrayOfArrayExample
    {
        static void Main(string[] args)
        {
            // Ein Array mit 3 Elemente erklären.
            // Ein Element ist ein anderes Array.
            string[][] teams = new string[3][];

            string[] mu = { "Beckham","Giggs"};
            string[] asenal = { "Oezil", "Szczęsny", "Walcott" };
            string[] chelsea = {"Oscar","Hazard","Drogba" };

            teams[0] = mu;
            teams[1] = asenal;
            teams[2] = chelsea;

            // Die Schleife for benutzen um die Elemente des Array auszudrucken
            for (int row = 0; row < teams.Length; row++)
            {
                for (int col = 0; col < teams[row].Length ; col++)
                {
                    Console.WriteLine("Element at [{0}],[{1}] = {2}", row, col, teams[row][col]);
                }
                Console.WriteLine("-------------");
            }
 

            Console.ReadLine();
        }
    }
}
Das Ergebnis zur Beispiel-Durchführung

12- Die Klasse, Construktor und Objekt

You need to have a distinction between three concepts:
  • Class
  • Constructor
  • Instance
When we talk about the tree, it is something abstract, it is a class. But when we pointed to a specific tree, it was clear, and that is the instance
Or when we talk about the Person, that's abstract, it is a class. But when pointed at you or me, it is two different instances, the same class of People.
Person.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class Person
    { 
        // Das ist ein Feld (field) .
        // Den Name speichern.
        public string Name;

        // Das ist ein Constructor.
        // Er ist für die Erstellung des Objekt benutzt.
        // Constructor hat einen Parameter.
        // Constructr hat immer den gleichen Name der Klasse.
        public Person(string persionName)
        {
            // Die Wert von Parameter für den Feld name anweisen.
            this.Name = persionName;
        }

        // Das ist die Methode, die das String Typ zurückgibt
        public string GetName()
        {
            return this.Name; 
        }
    }
}
Person class without Main method. Next in PersonTest, we create Person instance from its Constructor
PersonTest.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;


namespace HelloCSharp
{
    class PersonTest
    {
        static void Main(string[] args)
        {
            // Ein Objekt der Klasse Person erstellen.
            // Dieses Objekt aus Constructor der Klasse Person initializieren.
            Person edison = new Person("Edison");

            // Die Klasse Person hat die Methode GetName().
            // Das Objekt benutzen um die Methode GetName(): aufzurufen
            String name = edison.GetName();
            Console.WriteLine("Person 1: " + name);

            // Ein Objekt der Klasse Person erstellen.
            // Dieses Objekt aus Constructor der Klasse Person initializieren..
            Person billGate = new Person("Bill Gates");

            // Die Klasse Person hat den Feld 'name' public.
            // Sie können das Objekt benutzen um in dem Feld 'name' zuzugreifen.
            String name2 = billGate.Name;
            Console.WriteLine("Person 2: " + name2);

            Console.ReadLine();
        } 
    }
}
Running the example:

13- Der Feld (Field)

In this section we will discuss some of the concepts:
  • Field
    • Normal field
    • static Field
    • const Field
    • readonly Field
FieldSample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class FieldSample
    {
        // Das ist ein static Feld (static field).
        public static int MY_STATIC_FIELD = 100;

        // Das ist ein normaler Feld
        public string MyValue;

        // Das ist ein Constructor der Klasse FieldSample.
        public FieldSample(string value)
        {
            this.MyValue = value;
        }
    }
}
FieldSampleTest.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class FieldSampleTest
    {
        static void Main(string[] args)
        {   
            // Die Wert vom static Feld ausdrucken.
            // Für den static Feld sollen Sie durch den Name der Klasse zugreifen
            Console.WriteLine("FieldSample.MY_STATIC_FIELD= {0}", FieldSample.MY_STATIC_FIELD);

            // Sie können die Wert des static Feld ändern.
            FieldSample.MY_STATIC_FIELD = 200;

            Console.WriteLine(" ------------- "); 

            // Das erste Objekt erstellen.
            FieldSample obj1 = new FieldSample("Value1");

            // Der nicht-static Feld sollen Sie durch Objekt zugreifen.
            Console.WriteLine("obj1.MyValue= {0}",  obj1.MyValue);  

            // Das zweite Objekt erstellen:
            FieldSample obj2 = new FieldSample("Value2");

           
            Console.WriteLine("obj2.MyValue= {0}" , obj2.MyValue);

            // Sie können die Wert des Feldes ändern.
            obj2.MyValue = "Value2-2";

            Console.ReadLine();
        }
     
    }
}
Running the example:

Example readonly & static readonly.

ConstFieldExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace HelloCSharp
{
    class ConstFieldExample
    {
        // Ein Feld Konstante, seine Wert wird bei der Kompilierung bestimmt.
        // Sie können die neue Wert für den Feld const nicht anweisen.
        // Achtung: Der Feld const ist immer static.
        public const int MY_VALUE = 100;
 
        // Ein static Feld und readonly.
        // Seine Wert wird schon bereit angewiesen oder nur einmal im Constructor angewiesen.
        public static readonly DateTime INIT_DATE_TIME1 = DateTime.Now;

        // Ein readonly und none-static Feld
        // Seine Wert wird schon bereit angewiesen oder nur einmal im Constructor angewiesen
        public readonly DateTime INIT_DATE_TIME2 ;

        public ConstFieldExample()
        {
            // Seine Wert wird einmal bei dem ersten Laufen angewiesen
            INIT_DATE_TIME2 = DateTime.Now;
        }
    }
}

14- Die Methode (Method)

Method
  • Method.
  • static Method
  • sealed Method. (Will be mentioned in the inheritance of the class).
MethodSample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class MethodSample
    {
        public string text = "Some text";

        // Ein Default Constructor.
        // D.h hat Constructor keinen Parameter
        public MethodSample()
        {

        }

        // Das ist eine Methode, dessen Rückgabetyp String ist.
        // Diese Methode hat keinen Parameter.
        public string GetText()
        {
            return this.text;
        }

        // Das ist eine Methode mit einem String Parameter.
        // Diese Methode gibt void zurück (oder nichts zurückgeben sogenannt.)
        public void SetText(string text)
        {
            // this.text: die Referenz auf dem Feld text machen um mit dem Parameter text zu unterscheiden.
            this.text = text;
        }

        // Das ist eine static Methode.
        // Das Typ int zurückgeben und hat 3 Parameter
        public static int Sum(int a, int b, int c)
        {
            int d = a + b + c;
            return d;
        }
    }
}
MethodSampleTest.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class MethodSampleTest
    {
        static void Main(string[] args) 
        { 
            // Das Objekt MethodSample erstellen
            MethodSample obj = new MethodSample();

            // Die Methode GetText() aufrufen.
            // Die nicht-static Methode sollen durch das Objekt aufgeruft werden.
            String text = obj.GetText();
 
            Console.WriteLine("Text = " + text);

            // Die Methode SetText(string) aufrufen
            // Die nicht-static Methode sollen durch das Objekt aufgeruft werden.            
            obj.SetText("New Text");
 
            Console.WriteLine("Text = " + obj.GetText());

            // Die nicht-static Methode sollen durch den Name der Klasse aufgeruft werden.
            int sum = MethodSample.Sum(10, 20, 30);
 
            Console.WriteLine("Sum  10,20,30= " + sum);

            Console.ReadLine();
       }
    }
}
Running the example:

15- Die Erben im C# (Inheritance)

Java allows classes which extend from other class. Class extends another class called subclasses. Subclasses have the ability to inherit the fields attributes, methods from the parent class.
See an example of inheritance in CSharp:
Animal.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    // Eine Klasse Animal (Tier) illustrieren
    class Animal
    {
        public Animal()
        {

        }

        public void Move()
        {
            Console.WriteLine("Move ...!");
        }
      
    }
}
Cat.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class Cat : Animal
    {
      
        public   void Say()
        {
            Console.WriteLine("Meo");
        } 

        // Eine Methode der Klasse Cat
        public void Catch()
        {
            Console.WriteLine("Catch Mouse");
        }
    }
}
Ant.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    // Der Ant
    class Ant : Animal
    {
    }
}
AnimalTest.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloCSharp
{
    class AnimalTest
    {

        static void Main(string[] args)
        {
            // Ein Objekt Cat erklären.
            Cat tom = new Cat();

            // Prüfen, ob 'tom' ein Objekt Animal ist oder nicht.
            // Es ist klar true.
            bool isAnimal = tom is Animal;

            // ==> true
            Console.WriteLine("tom is Animal? " + isAnimal);

            // Die Methode Catch aufrufen
            tom.Catch();

            // Die Methode Say() vom Cat aufrufen.
            // ==> Meo
            tom.Say();

            Console.WriteLine("--------------------");

            // Ein Objekt Animal erklären.
            // Das Objekt durch den Constructor von Cat initializieren.
            Animal tom2 = new Cat();

            // Die Methode Move() aufrufen
            tom2.Move();

            Console.WriteLine("--------------------");

            // Ein Objekt Ant erstellen.
            Ant ant = new Ant();

            // Die Methode Move(), die aus Animal geerbt wird
            ant.Move();

            Console.ReadLine();
        }
    }
}
Das Ergebnis der Durchführung der Klasse   AnimalTest:

16- Der Erben und Polymorphie im C#

You can read more "Inheritance and polymorphism in CSharp" at:

View more Tutorials: