/// <summary>
/// Schreibt den Text auf den Bildschirm.
/// </summary>
/// <param name="text">Der Hinweis, der ausgegeben werden soll.</param>
/// <param name="modus">Steuert die Art der Ausgabe</param>
protected static void Ausgeben(string text, AusgabeModus modus)
{
switch (modus)
{
case AusgabeModus.Debug:
Entwicklungsbasis.Ausgeben(text, debug: true);
break;
case AusgabeModus.Fehler:
System.Console.ForegroundColor = ConsoleColor.Yellow;
System.Console.WriteLine(text);
System.Console.ResetColor();
break;
case AusgabeModus.Normal:
Entwicklungsbasis.Ausgeben(text, debug: false);
break;
case AusgabeModus.NormalOhneVorschub:
System.Console.Write(text);
break;
#if DEBUG
default:
//Hier wird diese Ausgeben-Überladung
// R E K U R S I V (selber) aufgerufen
Entwicklungsbasis.Ausgeben(
$"FEHLER: AusgabeModus {modus} nicht vorgesehen!",
AusgabeModus.Fehler);
//Falls rekursive Aufrufe irrtümlich passieren,
//stürzt die Anwendung mit "Stapelüberlauf (Stack Overflow)" ab.
break;
#endif
}
}
/// <summary>
/// Initialisiert ein neues Objekt.
/// </summary>
/// <remarks>Hier handelt es sich um den Konstruktor.
/// Mit dem Konstruktor beginnt das Objekt zu leben.
/// Wird mit dem "new" Schlüsselwort aufgerufen.</remarks>
public Entwicklungsbasis()
{
//Neu seit C# 7 (2016): Einsetzen von Daten in einen Text ($)
Entwicklungsbasis.Ausgeben($"Ein Objekt \"{this.GetType().Name}\" lebt...", debug: true);
// ^-> eine Escape-Sequenz, damit
// das Anführungszeichen ausgegeben wird
// ^-> "this" ist das Schlüsselwort, um auf das
// aktuelle Objekt zuzugreifen.
// Benötigt man mehr Information zum aktuellen
// Objekt, die .Net Reflection benutzen.
// Zugriff auf die Reflection ist die von
// System.Object geerbte GetType-Methode
// ^-> {Variable} Ausdrucksform ist erst
// seit 2016 möglich
// ^-> Dollar $ wird für {Variable}, die implizite Textersetzung,
// benutzt. Wird vom Trainer nicht benutzt. Max. bei
// Protokolleinträgen, weil die TExte ja aus "lokalisierten" Ressourcedateien
// Aber: Die Microsoft Beispiele nutzen mittlerweile alle diese
// Variante (weils in den Beispielen um nix geht)
}
/// <summary>
/// Schreibt den Text für den Benutzer
/// normal auf den Bildschirm.
/// </summary>
/// <param name="text">Der Hinweis, der angezeigt werden soll.</param>
/// <remarks>Hier handelt es sich um eine überladene Methode.</remarks>
protected static void Ausgeben(System.String text)
// ^-> "Parameter"
// |-----------| (Daten)Typ der Information im Paramter
// Keine .Net Sprache hat eigene Datentypen
// Alle Typen gehören .Net, z. B. System.String
// für einen Text
// |------------------|
// Schnittstelle
// damit eine Methode, weiß womit gearbeitet werden muss
// ^-> "void" für eine Methode, die arbeitet aber nichts zurückgibt
// ^-> wäre "Sub" in BASIC
// ^-> "static" sagt, dass die Methode nicht dem
// Objekt gehört sondern der Klasse
// (Damit diese Ausgeben-Methode auch z. B. im Main() genutzt werden kann)
//-> "protected" ist ein Mittelding zwischen
// "public" (überall sichtbar) und "private" (nur in dieser Klasse sichtbar)
{
//this.Aus...
// ^-> gibt's nicht
// ^-> "this" ist der Zeige auf das aktuelle Objekt
// Ausgeben ist statisch, deshalb nur über die Klasse aufrufbar
//Entwicklungsbasis.Ausgeben(text, false);
// ^-> warum hier "false". Damit's
// lesbarer wird...
//=> Benannte Parameter benutzen!!!
Entwicklungsbasis.Ausgeben(text, debug: false);
// |----| "benannter" Parameter
//Bei benannten Parametern muss die Reihenfolge beim Beschicken
//nicht eingehalten werden. Aber ab dem ersten benannten Parameter,
//müssen die folgenden Parameternamen auch getippt werden.
//Entwicklungsbasis.Ausgeben(debug: false, text: text);
//HAUPTGRUNDSATZ DER KONVENTIONEN:
//=> Die Lesbarkeit ist der Kürze vorzuziehen!
}