Exemplo n.º 1
0
    { //<- 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
Exemplo n.º 2
0
        /// <summary>
        /// Fragt die Benutzer nach den Namen
        /// und begrüßt sie passend zur aktuellen Stunde.
        /// </summary>
        private static void Begrüßen()
        {
            Anwendung.Ausgeben("Begrüßen startet...", debug: true);

            //Kommt später aus einer lokalisierten Ressource...
            const string Frage = "Wie heißen Sie? ";

            //                                   ^-> damit zur Antwort ein
            //                                       Abstand ist.

            Anwendung.Ausgeben(Frage, AusgabeModus.NormalOhneVorschub);

            var Name = System.Console.ReadLine().Trim();

            //                                      ^-> damit überflüssige Leerzeichen
            //                                          vorne und hinten entfernt werden

            //Falls sich der Benutzer nicht
            //identifiziert, den Loginnamen benutzen...
            if (Name.Length == 0)
            {
                Name = System.Environment.UserName;
            }

            //Den Benutzer persönlich zur aktuellen Stunde begrüßen
            Anwendung.Ausgeben(Algorithmus.ErmittleBegrüßung(System.DateTime.Now.Hour).Replace("!", ", " + Name + "!"));
            //                                                    <----------- || ------------>
            //                                                      Anweisungen müssen von innen nach außen
            //                                                            "gelesen", aufgelöst werden

            Anwendung.Ausgeben("Begrüßen beendet.", debug: true);
        }
Exemplo n.º 3
0
        /// <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);
        }
Exemplo n.º 4
0
        /// <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);
        }
Exemplo n.º 5
0
        /// <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);
        }
Exemplo n.º 6
0
        /// <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);
        }
Exemplo n.º 7
0
        } //<- 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);
        }
Exemplo n.º 8
0
 /// <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);
 }
Exemplo n.º 9
0
        /// <summary>
        /// Stellt den Einstiegspunkt
        /// in eine .Net Anwendung bereit.
        /// </summary>
        private static void Main()
        //         ^-> MUSS UNBEDINGT statisch sein,
        //             d.h. der Klasse gehören und nicht
        //                  dem Objekt.
        //-> Modifizierer beim Main() egal
        {
            //In einer stastischen Methode können
            //nur andere Mitglieder direkt aufgerufen
            //werden, wenn diese ebenfalls statisch sind.

            Anwendung.ZeichneTitel();
            Anwendung.Begrüßen();
            Anwendung.ZeigeMenü();

            //Wo ist die ZeigeSequenz() Methode?
            //Algorithmus.ZeigeSe...
            //              eine nicht statische Methode,
            //              gehört einem Objekt
            //   ^-> eine Klasse (Bauplan)

            //=> Ein Objekt ist notwendig (in 99,999% der Fälle)
            //   (statisch ist ganz selten)

            //=== Standardablauf zum Benutzen einer Klasse als Objekt

            //(1) Speicher für die Objektadresse reservieren
            Algorithmus AlgoObjekt = null;

            //(2) Die Klasse initialisieren, das Objekt bauen
            AlgoObjekt = new Algorithmus();
            //                           ^-> Schnittstelle vom Konstruktor
            //            ^-> ruft den Konstruktor der Klasse auf,
            //                erstellt irgendwo im Speicher das Objekt
            //                und gibt die Start-Speicheradresse zurück
            //                (Verweistyp)
            //            ===========
            //            Das Initialisieren, das Bauen eines Objekts,
            //            ist extram langsam. Möglichst sparsam einsetzen.
            //            Erst dannn ein Objekt bauen, wenn klar ist,
            //            dass es wirklich benötigt wird und cachen.
            //            ===========
            //          ^-> Wertzuweisungsoperator zum Merken
            //-> der Speicheradresse in der AlgoObjekt-Variablen
            //   damit wir über diese mit Objekt arbeiten können

            //(3) Das Objekt benutzen
            //Die Benutzer sollen den Programm auswählen
            //AlgoObjekt.ZeigeSequenz();
            //AlgoObjekt.ZeigeFall();
            //AlgoObjekt.ZeigeBinär();
            ////Zum Testen vom eindeutigen Zufallsgenerator
            //AlgoObjekt.ZeigeBinär();
            //AlgoObjekt.ZeigeFall();
            //AlgoObjekt.ZeigeZählen();

            const string Prompt = "C#> ";
            //                        ^-> damit ein Abstand zur Eingabe ist
            string Programmpunkt = null;

            //          ^-> muss vor der Schleife deklariert werden
            //              weil mit der geschweiften Klammer eine
            //              neue Gültigkeit beginnt!

            do
            { //<- Hier beginnt die Gültigkeit
                Anwendung.Ausgeben(Prompt, AusgabeModus.NormalOhneVorschub);
                Programmpunkt = System.Console.ReadLine().Trim().ToLower();

                switch (Programmpunkt)
                {
                case "hallo":
                case "1":
                    AlgoObjekt.ZeigeSequenz();
                    break;

                case "if":
                case "2":
                    AlgoObjekt.ZeigeBinär();
                    break;

                case "switch":
                case "3":
                    AlgoObjekt.ZeigeFall();
                    break;

                case "for":
                case "foreach":
                case "4":
                    AlgoObjekt.ZeigeZählen();
                    break;

                case "while":
                case "5":
                    AlgoObjekt.ZeigeAbweisen();
                    break;

                case "do":
                case "6":
                    AlgoObjekt.ZeigeDurchlaufen();
                    break;

                case "?":
                    Anwendung.ZeigeMenü();

                    break;

                case "9":
                case "":

                    //Leereingaben und Beenden mit 9 sollen
                    //zu keinem Fehler führen.

                    //Deshalb leerer Fall

                    break;

                case "exit":
                    Programmpunkt = "9";
                    break;

                default:
                    Anwendung.Ausgeben(
                        "Eingabe nicht erkannt! Fragezeichen ? für Hilfe tippen...",
                        AusgabeModus.Fehler);
                    break;
                }

                //<- Hier endet die Gültigkeit
            } while (Programmpunkt != "9");

            //(4) Den benötigten Speicher wieder freigeben
            //    (Für die Freigabe kennzeichnen, auf Dispose prüfen)
            //AlgoObjekt.di... kein Dispose

            //Der Garbage Collection helfen...
            AlgoObjekt = null;

#if DEBUG
            //=> NUR ZU DEMO-ZWECKEN:
            //Speicher wird von der Garbage Collection freigegeben.
            //Diese Garbage Collection in Ruhe lassen!!!
            //-> manuelle Garbage Collection
            System.GC.Collect();
            System.GC.WaitForPendingFinalizers();


            //Damit das Konsolenfenster offen bleibt...
            Anwendung.Ausgeben("Die Eingabetaste zum Beenden tippen...", debug: true);
            System.Console.ReadLine();
#endif
        }