CS Fakultät berechnen

using System;

public class MyProgram
{
    public static void Main(string[] args)
    {

        // Für die Zahl, für die Fakultät berechnet werden soll, wird die Variable n deklariert.
        int n;
        
        // Für das (spätere) Ergebnis wird die Variable fak deklariert.
        int fak;
        
        // Dann erfolgt die Abfrage der Zahl. Die Zahl, die eingegeben wird, wird der Variablen n als Wert zugewiesen.
        Console.WriteLine("Geben Sie die Zahl ein für die die Fakultät berechnet werden soll: ");
        n = (int) inputValue();
        
        // Da Fakultäten sehr schnell anwachsen, das bedeutet, dass das Ergebnis sehr schnell sehr groß werden, wird in diesem Programm die Größe der eingegebenen Zahl auf 20 begrenzt.  In der while-Schleife wird geprüft, ob die eingegebene Zahl größer als 20 ist, und falls ja, wird der Benutzer zur Eingabe einer neuen Zahl aufgefordert. Zudem wird geprüft, ob die Zahl kleiner als null ist, da Fakultäten nur für ganze positive Zahlen definiert sind, und wenn ja, wird der Benutzer ebnefalls darauf hingewiesen und zur Eingabe einer neuen Zahl aufgefordert.
        while (n > 20 || n < 0)
        {
            Console.WriteLine("Das Programm kann nur Zahlen bis 20 verarbeiten, bitte geben Sie eine ganze positive Zahl, die kleiner gleich 20 und größer als 0 ist ein:");
            n = (int) inputValue();
        }
        
        // Die Fakultät kann auf verschiedene Weise berechnet werden. In diesem Programm wird die Fakultät auf drei verschiedene Arten berechnet. Mittels einer for-Schleife und einer while-Schleife wird sie iterativ berechnet und als Drittes wird sie mittels einer rekursiven Funktion berechnet.
        fak = ForFak(n);
        Console.WriteLine(fak);
        fak = WhileFak(n);
        Console.WriteLine(fak);
        fak = RecFak(n);
        Console.WriteLine(fak);
    }
    
    public static int ForFak(int n)
    {
        // In dieser Funktion wird die Fakultät mithilfe einer for-Schleife iterativ ermittelt.
        // Als Variable für das Ergebnis wird die Variable fak deklariert und ihr wird der Wert 1 zugewiesen.
        int fak;
        
        fak = 1;
        
        // Die Variable i wird in der for Schleife verwendet und beginnt dort mit dem Wert 1. Bei jedem Durchlauf der Schleife erhöht sich der Wert von i um eins.
        int i;
        
        for (i = 1; i <= n; i++)
        {
            
            // Solange der Wert von i kleiner als der Wert von n ist, wobei n die Zahl, von der die Fakultät gebildet werden soll, wird die Multiplikation fak * i durchgeführt und das Ergebnis in der Variablen fak gespeichert.
            fak = fak * i;
        }
        
        return fak;
    }
    
    public static int RecFak(int n)
    {
        // Mit dieser Funktion wird die Fakultät rekursiv berechnet.
        // Als Variable für das Ergebnis wird die Variable fak deklariert und ihr wird der Wert 1 zugewiesen.
        int fak;
        
        fak = 1;
        
        // In der Fallunterscheidung wird geprüft, ob n den Wert null. Im Fall, dass n ungleich null ist, wird die Multiplikation n * RecFak(n-1) durchgeführt und das Ergebnis in der Variable fak gespeichert.
        if (n == 0)
        {
        }
        else
        {
            fak = n * RecFak(n - 1);
        }
        
        return fak;
    }
    
    public static int WhileFak(int n)
    {
        // In dieser Funktion wird die Fakultät mithilfe einer while-Schleife iterativ ermittelt.
        // Als Variable für das Ergebnis wird die Variable fak deklariert und ihr wird der Wert 1 zugewiesen.
        int fak;
        
        fak = 1;
        
        // Die Variable i wird in der while Schleife verwendet und beginnt dort mit dem Wert 1.
        int i;
        
        i = 1;
        while (i <= n)
        {
            
            // Solange der Wert von i kleiner als der Wert von n ist, wird die Multiplikation fak * i durchgeführt und das Ergebnis in der Variablen fak gespeichert.
            fak = fak * i;
            
            // Bei jedem Durchlauf der Schleife erhöht sich der Wert von i um eins, solange i kleiner gleich n ist.
            i = i + 1;
        }
        
        return fak;
    }
    
    // .NET kann nur einzelne Zeichen oder ganze Zeilen aus der  Konsole lesen. 
    // Die folgende Funktion löst das Problem.
    private static double inputValue()
    {
        double result;
        while (!double.TryParse(Console.ReadLine(), out result));
        return result;
    }
}