byte    0 bis 255                                                  8  Bit
   sbyte   -128 bis 127                                               8  Bit
   short   -32.768 bis 32.767                                         16 Bit
   ushort  0 bis 65.535                                               16 Bit
   int     -2.147.483.648 bis 2.147.483.647                           32 Bit
   uint    0 bis 4.294.967.295                                        32 Bit
   long    -9.223.372.036.854.775.808 bis 9.223.372.036.854.775.807   64 Bit
   ulong   0 bis 18.446.744.073.709.551.615                           64 Bit

   float   1.5 * 10-45 bis 3.4 * 1038                                 32  Bit
   double  5.0 * 10-324 bis 1.7 * 10308                               64  Bit
   decimal 1.0 * 10-28 bis 7.9 * 1028                                 128 Bit

   char    Einzelne Zeichen                                           16 Bit
   string  Zeichenketten  -

   bool    true und false                                             1 Bit
	

   +  Addition
   -  Subtraktion
   *  Multiplikation
   /  Division
   %  Modulo-Division
	

   &&   AND    A und B sind wahr
   ||   OR     (inklusives Oder)  A oder B oder beide sind wahr
   ^    XOR    (exklusives Oder)  entweder ist A wahr oder B
   !    NOT    A ist nicht wahr
	

   ==     gleich
   !=     ungleich
   <      kleiner
   >      größer
   <=     kleiner oder gleich
   >=     größer oder gleich
	

   //IF ANWEISUNG
   if(Bedingung)
   {
     Anweisungsblock;
   }

   //IF-ELSE ANWEISUNG
   if(Bedingung)
   {
     Anweisungsblock;
   }
   else
   {
     Anweisungsblock;
   }

   //GESCHACHTELTE IF-ELSE ANWEISUNG
   if(Bedingung)
   {
      if(Bedingung)
      {
        Anweisungsblock;
      }
      else
      {
        Anweisungsblock;
      }
   }
   else
   {
     if(Bedingung)
     {
        Anweisungsblock;
     }
   }

   //ELSE-IF ANWEISUNG
   if(Bedingung)
   {
      Anweisungsblock;
   }
   else if(Bedingung)
   {
      Anweisungsblock;
   }
   else if(Bedingung)
   {
      Anweisungsblock;
   }
   else
   {
      Anweisungsblock;
   }

   //SHORT CONDITIONAL IF / BEDINGUNGSOPERATOR
   variable = (Bedingung) ? True-Anweisung : False-Anweisung;
   /*
   zum Beispiel:
   
   int i = 0;
   i = (i == 0) ? 10 : 20;
   
   Der neue Wert für i ist 10.
   */

   //SWITCH-CASE ANWEISUNG
   switch(Variable)
   {
      case Wert:
	      Anweisungsblock;
      break;
      case Wert2:
	      Anweisungsblock;
      break;
      default:
	      Anweisungsblock;
      break;
   }
	

   /*
   FOR SCHLEIFE
   Die Schlüsselwörter BREAK und CONTINUE können zusätzlich zum Abbruch
   bzw. dem vorzeitigen Aufruf des nächsten Schleifendurchgangs verwendet
   werden
   */
   for(Initialisierungsausdruck; Abbruchbedingung; Aktualisierungsausdruck)
   {
      Anweisungsblock;
   }

   //WHILE
   while(Bedingung)
   {
     Anweisungsblock;
   }

   //DO-WHILE
   do
   {
      Anweisungsblock;
   }
   while(Bedingung);
	

   //Deklaration
   variablentyp[] ArrayName = new variablentyp[größe];

   z.b.
   int[] intArray = new int[5];

   //Initialisierung
   arrayname[position] = wert

   //Deklaration + Initialisierung
   variablentyp[] ArrayName = {wert1, wert2, wert3, ... wertx};

   //Mehrdimensionale Arrays
   variablentyp[,] ArrayName = new variablentyp[größe, größe2];

   //SCHLEIFE ZUM DURCHLAUFEN ALLER ARRAY ELEMENTE
   foreach(Datentyp Variablenname in Arrayname)
   {
      Anweisungsblock;
   }
	

   struct Name
   {
     public Datentyp Komponentenname;
   }

   //Deklarieren
   structName individuellername;

   //Ansprechen mittels
   structName.Komponentenname