Die wichtigsten Befehle in C# und Beispiele für deren Anwendung findest du in dem folgenden Quelltext. Du kannst ihn direkt übersetzen und ausführen.

Programm.cs

// Kommentare werden mit // eingeleitet
// Sie spielen für das Programm keine Rolle und dienen nur der Erläuterung.
 
/* 
   Längere Kommentare über mehrere Zeilen
   sind auch möglich.
*/
 
// Mit using können Bilbiotheken eingebunden werden.
// In Sytem sind viele wichtige Standardfunktionen enthalten.
using System;
 
// Alle Programme sind in Klassen aufgeteilt. Wir beschreiben hier
// den Aufbau der Klasse 'Programm'. Alles, was zwischen { und } steht, gehört
// zu einer Klasse.
// WICHTIG: zu jeder öffnenden muss es eine schließende Klammer geben.
//          Schreibe die Klammern am besten immer untereinander.
class Programm
{
  // Die Main-Methode ist der Startpunkt jedes Programms. Sie wird als
  // erstes ausgeführt. Methoden erkennen wir an den Klammern nach dem Namen.
  public static void Main()
  {
    // Variablen haben immer einen Typ und einen Namen.
    // Hier deklarieren wir eine Variable vom Typ Integer (Ganzzahl)
    // mit dem Namen 'eineVariable'.
    int eineVariable;
    // Fast alle Anweisungen enden mit einem Semikolon (;).
 
    // Nun können wir die Variable initialisieren und ihr einen Wert geben.
    eineVariable = 2;
 
    // Wir können Deklaration und Initialisierung auch in einer Zeile
    // zusammenfassen.
    int eineAndereVariable = 3;
 
    // Wir geben den Wert der Variable eineVariable auf der Konsole aus -> 2
    Console.WriteLine(eineVariable);
    //(1) (2) (3)          (4)
    // 
    // 1. Die Klasse Console stellt Methoden für die Konsole bereit.
    // 2. Mit einem Punkt wird auf Methoden der Klasse Console zugegriffen
    // 3. Wir rufen eine Methoden mit Namen 'WriteLine' auf und
    // 4. übergeben der Methode als Parameter die Variable
 
    // Wir können die Ausgabe schöner gestalten.
    Console.WriteLine("Die Variable hat den Wert " + eineVariable);
    //                     
    // Mit dem Pluszeichen wird die Zeichenkette "..." um den Wert der
    // Variablen ergänzt.
 
    // So können wir den Wert der Variablen um 1 erhöhen
    eineVariable = eineVariable + 1;
    // Das '=' funktioniert also nicht wie in der Mathematik.
    // Es bedeutet vielmehr 'bekommt den Wert von'.
 
    // Eine Zeichenkette kann mit + zusammengesetzt werden.
    Console.WriteLine("Variable hat Wert " + eineVariable + " - um 1 erhöht");
 
    // Mit if können wir entweder den einen (1) oder den anderen (2)
    // Programmteil ausführen. Dazu müssen wir in Klammern eine Bedingung
    // angeben.
    // ACHTUNG: Hinter die schließende Klammer ')' darf kein Semikolon.
    if(eineVariable > 2)
    {
      Console.WriteLine("Variable ist größer als 2");       // (1)
    }
    else
    {
      Console.WriteLine("Variable ist NICHT größer als 2"); // (2)	
    }
    // 1. Die Bedingung ist wahr
    // 2. Die Bedingung ist falsch - also nicht wahr.
 
    // Bedingungen können auch komplizierter sein.
    //
    //              >= größer oder gleich
    //              |    && bedeutet 'und' also beides muss gelten
    //              |    |               <= kleiner oder gleich
    //              v    v               v
    if(eineVariable >= 0 && eineVariable <= 5)
    {
      Console.WriteLine("Variable zwischen 0 und 5");
    }
    // Der else-Teil kann auch entfallen.
 
    // Anweisungen können mit Schleifen wiederholt ausgeführt werden.
    //
    //                (1)
    while(eineVariable > 0)
    {
      Console.WriteLine("Variablenwert in Schleife " + eineVariable); // (2)
      eineVariable = eineVariable - 1;
      // (3)
    }
    // (4)
 
    //
    // 1 Eine Bedingung, die immer wieder überprüft wird. Ist sie wahr, so 
    //   wird die Schleife ausgeführt und es geht bei 2 weiter. Falls nicht,
    //   setzt die Ausführung bei 4 fort. Hier wird geprüft, ob der Wert in
    //   eineVariable größer als 0 ist.
    //   ACHTUNG: Wie auch beim if, darf hinter der schließenden Klammer 
    //            kein Semikolon.
    // 2 Alle Anweisungen zwischen { und } werden ausgeführt. Der Wert der
    //   der Variablen wird ausgegeben und anschließend um 1 verringert.
    // 3 Am Ende springen wir wieder zu 1 und prüfen erneut die Bedingung.
    // 4 Die Schleife wurde beendet und es geht im Quelltext weiter.
    //
    // Ausgabe:
    // Variablenwert in Schleife 3
    // Variablenwert in Schleife 2
    // Variablenwert in Schleife 1
 
    // Mit for-Schleifen kann ein Anweisungsblock mehrere mal ausgeführt
    // werden. Sie bieten sich an, wenn die Anzahl der Ausführungen
    // feststeht.
    //
    //    (1)    (2)  (4) (5)
    for(int i=0; i<4; i++)
    {
      Console.WriteLine("i-Wert in for-Schleife " + i); // (3)
    }
    // 1 Die Variable i wird als Integer deklariert und mit dem Wert 0
    //   initialisiert. Diese Anweisung wird nur EIN MAL ausgeführt.
    // 2 Die Bedingung wird geprüft. Ist sie erfüllt, wird die Schleife
    //   ausgeführt. 
    // 3 Alle Anweisungen, die ausgeführt werden sollen, stehen wieder
    //   zwischen { und }. 
    // 4 Zum Schluss wird Variable i um eins erhöht: i++ ist eine Kurzform für
    //   i=i+1. Danach wird mit der Prüfung der Bedingung in 2 fortgesetzt.
    // 5 Hinter die schließende Klammer ')' darf kein Semikolon.
    //
    // Ausgabe:
    // i-Wert in for-Schleife 0
    // i-Wert in for-Schleife 1
    // i-Wert in for-Schleife 2
    // i-Wert in for-Schleife 3
 
    // Wir können auch eigene Klassen bauen und daraus Objekte erzeugen.
    // Hier erstellen wir mit 'new' ein Objekt mit Namen 'peterchen' vom Typ
    // 'Person'. Der Aufbau der Klasse wird im Abschnitt weiter unten
    // erläutert.
    Person peterchen = new Person();
 
    // Wir rufen die Methode 'alterFestlegen' auf und übergeben den Wert 25.
    peterchen.alterFestlegen(25);
    //(1)   (2)   (3)       (4)
    //
    // 1 Name des Objektes: peterchen
    // 2 Der Punkt kennzeichnet wieder einen Methodenaufruf
    // 3 Der Name der Methode: alterFestlegen
    // 4 Parameter des Methodenaufrufs: 25
 
    // Wir haben nun ein Objekt mit der folgenden Objektkarte erstellt
    //
    // |------------------|
    // | peterchen        |
    // |------------------|
    // | alter = 25       |
    // |------------------|
    // | alterFestlegen() |
    // | istVolljaehrig() |
    // |------------------|
 
    // Legen wir noch eine weitere Person lisa mit der folgenden Objektkarte an
    //
    // |------------------|
    // | lisa             |
    // |------------------|
    // | alter = 22       |
    // |------------------|
    // | alterSetzen()    |
    // | istVolljaehrig() |
    // |------------------|
    Person lisa = new Person();
    lisa.alterFestlegen(22);    
 
    // Nun können wir mit Hilfe einer weiteren Methode prüfen,
    // ob die Person volljährig ist.
    if( peterchen.istVolljaehrig() )
    {
      Console.WriteLine("Peterchen ist kein Kind mehr.");	
    }
    // Der Aufbau der Klasse Person ist weiter unten beschrieben.
    // Dort ist festgeschrieben, welche Methoden es gibt und was sie tun.
 
  } // <- Mit dieser schließenden Klammer endet die Main-Methode
} // <- Hier endet die Klasse Programm.

Person.cs

// Klassen werden in separaten Dateien beschrieben, die genauso wie 
// die Klasse selbst heißen. Ähnlich wie bei Objektkarten, werden sie
// mit einem Klassendiagramm grafisch beschrieben.
// 
// |-----------------------|
// | Person                |    (1)
// |-----------------------|
// | alter:int             |    (2)
// |-----------------------|
// | alterSetzen():void    |    (3)
// | istVolljaehrig():bool |
// |                       |
// |-----------------------|
//
// 1 Der Name der Klasse. Er wird groß geschrieben.
// 2 Die Attribute der Klasse. Darin können wir uns Werte merken, wie 
//   z.B. das Alter. Erst kommt der Name, dann ein Doppelpunkt und 
//   dann der Typ.
// 3 Unten stehen die Methoden. Nach dem Namen und den Klammern kommt 
//   auch hier ein Doppelpunkt gefolgt von dem Type des Rückgabewertes. 
//   Dies werden wir gleich noch im Quelltext genauer sehen.
class Person
{
  // Oben in der Klasse stehen die Attribute.
  // Objekte vom Typ Person haben nur das Attribut alter.
  int alter;
 
  // Nach den Attributen folgen die Methoden. Wir haben zwei Methoden
  // alterFestlegen und istVolljaehrig. Wir müssen noch beschreiben, was
  // sie tun sollen, wenn sie aufgerufen werden.
 
  // (1)  (2)      (3)       (4)    (5)
  public void alterFestlegen(int dasAlter)
  {
    alter = dasAlter; // (6)
  }
  // 1 Wer darf die Methode ausführen? Bei public darf es jeder.
  // 2 Welchen Typ liefert die Methode als Rückgabe? Bei void gibt es keine
  //   Rückgabe. Wir wollen hier nur etwas festlegen und nichts abfragen.
  // 3 Der Name der Methode
  // 4 Zwischen ( und ) folgen die Parameter. Zunächst der Typ und dann
  // 5 der Name des Parameters
  // 6 Was die Methoden machen soll, steht zwischen { und }. Hier setzen wir
  //   den Wert des Attributes alter auf den Wert, der im Parameter übergeben 
  //   wird. Alle Methoden können auf die Attribute zugreifen.
 
  // Nun haben wir eine Methoden mit einem Rückgabewert vom Typ bool. Das ist
  // ein Wahrheitswert, der als Wert nur true oder false sein kann.
  // Es gibt keine Parameter.
  public bool istVolljaehrig()
  {
    // Das Ergebnis der Prüfung, ob alter größer als 18 ist, merken wir uns in der
    // Variablen erwachsen.
    bool erwachsen = alter > 18;
 
    // Mit return verlassen wir die Methode und geben den Wert von erwachsen -
    // also true oder false - zurück.
    return erwachsen;
  }
}