{ //<- Hier beginnt die Gültigkeit der Klasse
/// <summary>
/// Gibt das obligatorische
/// "Hallo Welt!" auf dem Bildschirm aus.
/// </summary>
public void ZeigeSequenz()
{ //<- Gültigkeitsbereich von ZeigeSequenz
//Für das Protokoll...
Algorithmus.Ausgeben("ZeigeSequenz startet...", debug: true);
// |-----------------------|
// Text-Konstanten unter
// Anführungszeichen.
// KEINE solchen KONSTANTEN FÜR
// BENUTZER. Warum? Weil man diese
// Anwendung nicht "globalisieren", d.h.
// in andere Benutzersprachen übersetzen kann
//=> Ab C# Teil 1 kommen diese Texte aus Ressource-Dateien
// Speicher reservieren für "Hallo Welt!"
string ObligatorischerText = "Hallo objektorientierte Welt!";
// ^-> jede Anweisung muss in C#
// mit Strichpunkt beendet werden.
// ^-> Operator für die Wertzuweisung
// ^-> der Name vom reservierten Speicher (Variable)
// Keine Leer- und Sonderzeichen. Keine Ziffer am Anfang.
//-> der Typ. "string" C# Alias auf Sytem.String
// Den Speicherinhalt für den Benutzer ausgeben
//Algorithmus.Ausgeben(ObligatorischerText, debug: false);
// |------------------------------|
// ohne Überladung, muss immer alles
// angegeben werden
//Überladung nur wegen des Komforts beim benutzen
Algorithmus.Ausgeben(ObligatorischerText);
//Für das Protokoll...
Algorithmus.Ausgeben("ZeigeSequenz beendet.", debug: true);
} //<- Ende der Gültigkeit von ZeigeSequenz
/// <summary>
/// Zeigt einen Lotto Quicktipp
/// für Österreich an.
/// </summary>
public void ZeigeDurchlaufen()
{
Algorithmus.Ausgeben("ZeigeDurchlaufen startet...", debug: true);
var Lotto = new Lotto();
// ^-> macht Microsoft liebend gerne,
// die Objektvariable genauso zu nennen,
// wie die Klasse
//Land zufällig einstellen
Lotto.Land
= (LottoLänder)this.Zufallsgenerator
.Next(System.Enum.GetValues(typeof(LottoLänder)).Length);
//Reihenfolge zufällig einstellen...
//Lotto.Sortiert = this.Zufallsgenerator.Next(2) == 1 ? true : false;
// |---------------------------------|
// ist schon true oder false
Lotto.Sortiert = this.Zufallsgenerator.Next(2) == 1;
//Das zufällige Land und die Zahlen
//eines Quicktipps ausgeben.
var Text = new System.Text.StringBuilder();
Text.AppendLine($"Lotto Quicktipp {Lotto.Land}: {Lotto.AnzahlZahlen} aus {Lotto.HöchsteZahl}");
//Die Anzahl der Zahlen ist bekannt, deshalb...
//Zählschleife. Weil jede Zahl des Datenfelds
//benötigt wird, die Spezialzählschleife...
foreach (int Zahl in Lotto.BerechneQuicktipp())
{
Text.Append(Zahl.ToString().PadLeft(3));
}
Text.AppendLine();
//Noch einen Hinweis, ob die Zahlen
//in gezogener oder in aufsteigender Reihenfolge sind
Text.AppendLine($"(In {(Lotto.Sortiert ? "aufsteigend" : "gezogener")} Reihenfolge)");
// ^-> Fragezeichen-Doppelpunkt
// entspricht der WENN-Funktion in Excel
// eine Binärentscheidung in einer Anweisung
// |--------------------------------------------|
// runde Klammern zur Unterstützung
// der Syntaxprüfung vom Kompiler
Algorithmus.Ausgeben(Text.ToString());
//Lotto.dispose... Nicht vorhanden, falls ein
// Objekt ein Dispose() hat,
// IMMER aufrufen, wenn das Objekt
// nicht mehr benötigt wird
Lotto = null;
Algorithmus.Ausgeben("ZeigeDurchlaufen beendet.", debug: true);
}
/// <summary>
/// Gibt den Inhalt einer
/// unformatierten Textdatei aus.
/// </summary>
/// <remarks>Die Datei muss "Wörter.txt" heißen
/// und im Anwendungsverzeichnis liegen.</remarks>
public void ZeigeAbweisen()
{
Algorithmus.Ausgeben("ZeigeAbweisen startet...", debug: true);
Algorithmus.Ausgeben($"Startverzeichnis: {this.Anwendungsverzeichnis}", AusgabeModus.Debug);
//Zum Testen vom eigenen Ereignis,
//in 20 % der Aufrufe einen falschen Namen angeben
string Dateiname = this.Zufallsgenerator.Next(100) < 80 ? "Wörter.txt" : "Wörter.Gibts.Ned";
var Pfad = System.IO.Path.Combine(this.Anwendungsverzeichnis, Dateiname);
// ^-> benutzt unter Windows einen Backslash
// Einen Schrägstrich in Linux
/*
* //Wird ein Objekt nicht sofort benötigt:
* //(1) Variable für die Objektadresse
* Textdatei Datei = null;
*
* //(2) Objekt initialisieren
* Datei = new Textdatei();
*/
//Es kann aber sein, dass ein Objekt sofort
//benötigt wird. In diesem Fall (1) und (2)
//als ein Schritt...
var Datei = new Textdatei();
//(3) Objekt benutzen
//Für das Ereignis LeseFehlerAufgetreten
//einen Ereignisbehandler anhängen
Datei.LeseFehlerAufgetreten += FehlerMelden;
Datei.Pfad = Pfad;
Algorithmus.Ausgeben(
Datei.HoleFließtext(
(int)(System.Console.WindowWidth * this.Zufallsgenerator.Next(33, 67) / 100.0f)
// ^-> damit 100 nicht als Ganzzahl
// interpretiert wird
//-> "Typ-Bestätigung (Casten)". HoleFließtext möchte eine Ganzzahl
// Die Berechnung liefert aber System.Single (float in C#)
// Der Kompiler meldet, wir verlieren Genauigkeit.
// Mit dem Casten wird dem Kompiler bestätigt,
// dass wir das wissen (und uns hier wurscht ist, weil
// keine halben Zeichen in der Konsole existieren)
));
//(4) Objekt für die Vernichtung freigeben
//Datei.Dis...
//-> Keine Dispose() Methode zum Zusammenräumen
Datei = null;
//Wer räumt das Objekt aus dem Speicher?
//=> Der Garbage Collector
Algorithmus.Ausgeben("ZeigeAbweisen beendet.", debug: true);
}
/// <summary>
/// Ermittelt eine Begrüßung zu einer
/// zufälligen Stunde.
/// </summary>
public void ZeigeFall()
{
Algorithmus.Ausgeben("ZeigeFall startet...", debug: true);
//Ausgabemuster
const string Hinweis = "{0} Es ist {1} Uhr...";
//Zufällige Stunde
var ZufälligeStunde = this.Zufallsgenerator.Next(24);
//In das Ausgabemuster die zufällige Stunde
//und den Begrüßungstext für diese einsetzen
//und ausgeben
Algorithmus.Ausgeben(string.Format(Hinweis, Algorithmus.ErmittleBegrüßung(ZufälligeStunde), ZufälligeStunde));
// Anweisungen werden von "innen" nach "außen" <--------------||-----------> aufgelöst
Algorithmus.Ausgeben("ZeigeFall beendet.", debug: true);
}
/// <summary>
/// Testet ErmittleBegrüßung für jede
/// mögliche Stunden zwischen 0 und 23.
/// </summary>
public void ZeigeZählen()
{
Algorithmus.Ausgeben("ZeigeZählen startet...", debug: true);
//Ausgabemuster
const string Hinweis = "{0} Es ist {1} Uhr...";
/*
* //Idee: => Scheiße, eine Sequenz
* Algorithmus.Ausgeben(string.Format(Hinweis, Algorithmus.ErmittleBegrüßung(0), 0));
* Algorithmus.Ausgeben(string.Format(Hinweis, Algorithmus.ErmittleBegrüßung(1), 1));
* Algorithmus.Ausgeben(string.Format(Hinweis, Algorithmus.ErmittleBegrüßung(2), 2));
* Algorithmus.Ausgeben(string.Format(Hinweis, Algorithmus.ErmittleBegrüßung(3), 3));
* //...
* Algorithmus.Ausgeben(string.Format(Hinweis, Algorithmus.ErmittleBegrüßung(23), 23));
* // ^-> der einzige Unterschied
* // diese Zahl heißt "Index"
*/
//Lösung: eine Schleife
// 3. Die Anzahl ist nicht bekannt, aber mind. 1x
// Die Durchlaufschleife (do) -> hier nicht
// 2. Die Anzahl ist vollkommen unbekannt, unter Umständen nie
// Die Abweiseschleife (while) -> hier nicht
// 1. Die Anzahl der Wiederholung ist vor dem
// Schleifentritt bekannt
//
// => Die Zählschleife (for)
// für unsere Aufgabe
for (int i = 0; i < 24; i++)
{
Algorithmus.Ausgeben(string.Format(Hinweis, Algorithmus.ErmittleBegrüßung(i), i));
}
Algorithmus.Ausgeben("ZeigeZählen beendet.", debug: true);
}
} //<- Ende der Gültigkeit von ZeigeSequenz
/// <summary>
/// Ermittelt eine zufällige Ganzzahl
/// zwischen 1 und 100 und gibt zu dieser
/// aus, ob die Zahl kleiner 50 oder
/// größer gleich 50 ist.
/// </summary>
public void ZeigeBinär()
{
//Änderungen
// 20181130 Falls die Zahl die Grenze, wird nicht
// mehr "oder größer" gemeldet
Algorithmus.Ausgeben("ZeigeBinär startet...", debug: true);
//Speicher reservieren
//-> kann sich nicht ändern: Konstanten
const int Untergrenze = 1;
const int Obergrenze = 100;
const int Grenze = 50;
//--- später aus Ressource-Dateien
const string HinweisKleiner = "Die Zahl {0} ist kleiner der Grenze {1}!";
// ^-> Parameter für die foramtierte Ausgabe
// Das gesamte .Net ist nullbasierend.
//20181130
//const string HinweisGrößerGleich = "Die Zahl {0} ist größer oder gleich der Grenze {1}!";
const string HinweisGrößer = "Die Zahl {0} ist größer der Grenze {1}!";
const string HinweisGleich = "Die Zahl {0} ist die Grenze!";
//-> kann sich ändern: Variablen
//Zufällige Zahl berechnen
int Zufallszahl = this.Zufallsgenerator.Next(Untergrenze, Obergrenze + 1);
// |-- exklusiv
// |-- inklusiv
// ^-> überladene Methode vom Random-Objekt
// ^-> Eigenschaft, geerbt von der Entwicklungsbasis,
// die ein eindeutiges Random-Objekt verwaltet
//Falls diese kleiner der Grenze
if (Zufallszahl < Grenze)
{
//Ja nicht so...
//Algorithmus.Ausgeben("Die Zahl " + Zufallszahl...)
// |------------- KEINE Textverkettungen
// Warum?
// - Langsam
// Hauptgrund:
// - Solche Anwendungen können nicht "lokalisiert",
// d.h. in andere Benutzersprachen übersetzt werden!
// - Diese Texte kommen aus übersetzten Ressource-Dateien
// (ab Teil 1)
Algorithmus.Ausgeben(string.Format(HinweisKleiner, Zufallszahl, Grenze));
// {0} {1}
// ^-> Muster mit Parametern
// ^-> .Net Textformatierung
}
//20181130
else if (Zufallszahl == Grenze)
{
Algorithmus.Ausgeben(string.Format(HinweisGleich, Zufallszahl));
}
//---
else
{
//20181130
//Algorithmus.Ausgeben(string.Format(HinweisGrößerGleich, Zufallszahl, Grenze));
Algorithmus.Ausgeben(string.Format(HinweisGrößer, Zufallszahl, Grenze));
}
Algorithmus.Ausgeben("ZeigeBinär beendet.", debug: true);
}
/// <summary>
/// Teilt dem Benutzer in der Konsole mit, dass ein Problem
/// aufgetreten ist.
/// </summary>
/// <param name="sender">Immer das 1. Argument. Von welchem Objekt
/// wird der Behandler aufgerufen.</param>
/// <param name="e">Immer das 2. Argument. Die Ereignisdaten.
/// Falls der Typ System.EventArgs keine Zusatzinformation.
/// Hier Zusatzinformation, weil nicht System.EventArgs.</param>
/// <remarks>Hier handelt es sich um einen Ereignisbehandler.</remarks>
private void FehlerMelden(object sender, FehlerAufgetretenEventArgs e)
{
Algorithmus.Ausgeben(
$"TEST eines eigenen Ereignisses in 20 % der Aufrufe:\r\n\r\nFehlerursache: {e.Ursache.Message}",
AusgabeModus.Fehler);
}
