Übung – Erstellen und Testen einer Schleife für die Eingabe neuer Haustierdaten

20 Minuten

In dieser Übung entwickeln Sie Code, der die Eingabe neuer Daten für das ourAnimals-Array steuert. Sie berechnen die Anfangswerte der Steuervariablen Ihrer Schleife und erstellen die Schleife, die von Benutzer*innen angegebene Daten zu den Tieren sammelt. Die detaillierten Aufgaben, die Sie während dieser Übung ausführen, sind:

Berechnen von „petCount“: Sie schreiben Code, der die Anzahl der Haustiere im ourAnimals-Array mit zugewiesenen Daten zählt.
Bedingte Meldungen: Sie schreiben Code zur Ausgabe einer Meldung, wenn petCount kleiner als maxPets ist.
Äußere Schleife: Sie erstellen eine Schleifenstruktur zur Eingabe neuer Daten für das ourAnimals-Array.
Beendigungskriterien: Sie schreiben Code, der die Bedingung zur Beendigung der Schleife „Neue Daten für das ourAnimals-Array eingeben“ auswertet.
Überprüfungstest: Sie führen Überprüfungstests für den in dieser Übung entwickelten Code aus.

Von Bedeutung

Sie müssen die vorherige Übung in diesem Modul abschließen, bevor Sie diese Übung starten.

Zählen der Anzahl der Haustiere im Array „ourAnimals“

In dieser Aufgabe legen Sie zunächst die Beendigungskriterien für Ihre Dateneingabeschleife fest. Anschließend erstellen Sie eine for-Schleife zum Zählen der Anzahl der Haustiere in ourAnimals, denen Daten zugewiesen sind.

Stellen Sie sicher, dass Visual Studio Code geöffnet ist und ihre Program.cs Datei im Editor sichtbar ist.
Suchen Sie die switch(menuSelection)-Anweisung und anschließend die Codezeile case "2":.
Suchen Sie die Console.WriteLine()-Anweisung mit der Meldung „Bald verfügbar“, und ersetzen Sie diese durch eine leere Codezeile.
Geben Sie in der von Ihnen erstellten leeren Codezeile den folgenden Code ein, um die Variablen anotherPet und petCount zu deklarieren:
```
string anotherPet = "y";
int petCount = 0;
```
Diese beiden Variablen steuern die Iteration einer while-Schleife zur Eingabe neuer Haustierdaten. Initialisieren Sie beide Variablen als Teil der Deklaration.
- anotherPet wird vor dem Start der while-Schleife mit einem Wert für y initialisiert. Die Variable erhält einen benutzerseitig zugewiesenen Wert: y oder n innerhalb der while-Schleife.
- petCount stellt die Anzahl der Tiere mit zugewiesenen Haustiermerkmalen dar. Dieser Variable wird ein berechneter Wert außerhalb der while-Schleife zugewiesen. Wird dem ourAnimals-Array ein neues Tier hinzugefügt, erhöht sich der Wert im while-Loop um 1.
Von Bedeutung

Der Umfang Ihrer Variablen sollte immer so eng wie möglich sein. In der Contoso Pets-Anwendung können Sie petCount für die Anwendungsebene festlegen, anstatt den Bereich auf den Codeblock case "2": zu begrenzen. Durch den größeren Bereich können Sie von überall in der Anwendung auf petCount zugreifen. Wird petCount für die Anwendungsebene festgelegt, können Sie der Variable einen Wert zuweisen, wenn Sie die Beispieldaten erstellen und diesen Wert in der restlichen Anwendung programmgesteuert verwalten. Wenn Sie beispielsweise für ein Tier ein Zuhause finden und es aus dem ourAnimals-Array entfernen, können Sie petCount um 1 reduzieren. Die Frage lautet: Auf welcher Ebene sollten Sie eine Variable festlegen, wenn Sie noch nicht wissen, ob sie in anderen Teilen der Anwendung verwendet wird? In diesem Fall erscheint es verlockend, petCount für die Anwendungsebene festzulegen, obwohl sie nirgendwo anders genutzt wird. Immerhin können Sie sich dann sicher sein, dass petCount für eine mögliche Verwendung an anderer Stelle auf jeden Fall verfügbar ist. Vielleicht möchten Sie auch noch weitere Variablen für die Anwendungsebene festlegen. Auf diese Weise befinden sich Ihre Variablen immer im Bereich, und Sie können darauf zugreifen. Warum sollten Sie Variablen also nicht für die Anwendungsebene festlegen, wenn Sie sie möglicherweise später in der Anwendung verwenden möchten? Wenn Sie den Bereich von Variablen auf einer höheren Ebene als nötig festlegen, kann dies zu Problemen führen. Ein höherer Bereich steigert die Ressourcenanforderungen Ihrer Anwendung und kann ein unnötiges Sicherheitsrisiko bedeuten. Größere und komplexere Anwendungen benötigen mehr Ressourcen. Smartphones und Computer weisen diesen Ressourcen Speicher zu, wenn sie sich in deren Bereich befinden. Je mehr Ihre Anwendungen in der Praxis genutzt werden, desto häufiger wird auf sie zugegriffen. Häufig kann auf Anwendungen über die Cloud oder andere Anwendungen zugegriffen werden. Dies führt dazu, dass Anwendungen oft weiter ausgeführt werden, auch wenn sie gerade nicht verwendet werden. Es ist wichtig, die Ressourcenanforderungen einer Anwendung unter Kontrolle und den Sicherheitsbedarf so gering wie möglich zu halten. Obwohl die heutigen Betriebssysteme Ressourcen sehr gut verwalten und Anwendungen sichern können, wird dennoch empfohlen, den Bereich von Variablen auf die tatsächlich benötigte Ebene zu begrenzen. Wenn Sie sich in Ihrer Contoso Pets-App für eine breitere Verwendung von petCount innerhalb der Anwendung entscheiden, können Sie den Bereich von petCount im Code einfach erhöhen. Legen Sie also den Bereich Ihrer Variablen so begrenzt wie möglich fest, und erhöhen Sie ihn nur im Bedarfsfall.
Geben Sie in der Codezeile unterhalb der Variablendeklarationen den folgenden Code ein, um eine Schleife zu erstellen, die die Tiere im ourAnimals-Array durchläuft:
```
for (int i = 0; i < maxPets; i++)
{
}
```
Dieser Code sollte Ihnen vertraut vorkommen. Sie verwenden diese for-Schleife bei jeder Iteration des ourAnimals-Arrays.
Geben Sie im Codeblock der for-Schleife den folgenden Code ein, um zu überprüfen, ob einem Tier Daten zu Haustiermerkmalen zugewiesen wurden:
```
if (ourAnimals[i, 0] != "ID #: ")
{
}
```
Auch dieser Code sollte Ihnen vertraut erscheinen. Sie verwenden diese if-Anweisung bei jeder Überprüfung nach zugewiesenen Haustiermerkmalen.
Geben Sie im Codeblock der von Ihnen erstellten if-Anweisung den folgenden Code ein, um petCount um 1 zu erhöhen:
```
petCount += 1;
```
Nehmen Sie sich einen Moment Zeit, um die fertige for-Schleife zu überprüfen.

Die vollständige for-Schleife sollte wie folgt aussehen:
```
for (int i = 0; i < maxPets; i++)
{
    if (ourAnimals[i, 0] != "ID #: ")
    {
        petCount += 1;
    }
}
```
Diese Codeschleife durchläuft das ourAnimals-Array, um nach zugewiesenen Daten zu suchen. Wird ein Tier mit zugewiesenen Daten gefunden, wird petCounter um 1 erhöht.
Wählen Sie im Visual Studio Code-Menü Datei die Option Speichern aus.
Öffnen Sie den Bereich "Integriertes Terminal" in Visual Studio Code, und geben Sie den Befehl ein, um Ihr Programm zu erstellen.

Um das Integrationsterminal aus der EXPLORER-Ansicht zu öffnen, klicken Sie mit der rechten Maustaste auf "Starter", und wählen Sie dann "Im integrierten Terminal öffnen" aus. Sie können auch das Menü "Ansicht" oder "Terminal " verwenden, um den integrierten Terminalbereich zu öffnen.

Um Ihr Programm zu erstellen, geben Sie den dotnet build Befehl über die Terminal-Eingabeaufforderung ein.
Beheben Sie alle angezeigten Buildfehler, bevor Sie fortfahren.

Hinweis

Vorerst können Sie die Warnmeldung ignorieren, dass anotherPet zugewiesen, aber nie verwendet wurde. Später in dieser Übung fügen Sie Code hinzu, der anotherPet verwendet.

Informationen zu allen Buildfehlern finden Sie in den Buildfehler- und Warnmeldungen. Wenn Sie Ihren Code aktualisieren, denken Sie daran, die Änderungen vor der Neuerstellung zu speichern.
Schließen Sie das Panel „Terminal“.

Anzeigen der Meldungsausgabe, wenn „petCount“ kleiner als „maxPets“ ist

In dieser Aufgabe überprüfen Sie, ob petCount kleiner als maxPets ist, und zeigen in diesem Fall eine Benutzermeldung an.

Geben Sie in einer leeren Codezeile unterhalb der von Ihnen erstellten for-Schleife den folgenden Code ein, um zu überprüfen, ob petCount kleiner als maxPets ist:
```
if (petCount < maxPets)
{
}
```
Geben Sie im Codeblock der if-Anweisung den folgenden Code ein, um Benutzer*innen eine Meldung anzuzeigen:
```
Console.WriteLine($"We currently have {petCount} pets that need homes. We can manage {(maxPets - petCount)} more.");
```
Wenn Anwendungsbenutzer*innen gerade dabei sind, Haustiermerkmale einzugeben, stellt diese Meldung wichtigen Kontext bereit.

Nehmen Sie sich einen Moment Zeit, um den Codebranch case "2": Ihrer switch-Anweisung zu überprüfen.

An diesem Punkt sollte Ihr case "2":-Codebranch wie folgt aussehen:

case "2":
    // Add a new animal friend to the ourAnimals array
    string anotherPet = "y";
    int petCount = 0;
    for (int i = 0; i < maxPets; i++)
    {
        if (ourAnimals[i, 0] != "ID #: ")
        {
                petCount += 1;
        }

    }

    if (petCount < maxPets)
    {
        Console.WriteLine($"We currently have {petCount} pets that need homes. We can manage {(maxPets - petCount)} more.");
    }

    Console.WriteLine("Press the Enter key to continue.");
    readResult = Console.ReadLine();
    break;

Wählen Sie im Visual Studio Code-Menü Datei die Option Speichern aus.
Öffnen Sie den Bereich "Integriertes Terminal" in Visual Studio Code, und geben Sie den Befehl ein, um Ihr Programm zu erstellen.
Beheben Sie alle angezeigten Buildfehler, bevor Sie fortfahren.

Auch hier können Sie die Warnmeldung ignorieren, dass anotherPet zugewiesen, aber nie verwendet wurde. In der nächsten Aufgabe beginnen Sie damit, die while-Schleife zur Eingabe der Daten für ein oder mehrere Haustiere zu erstellen. Der Ausdruck, den Sie für die while-Schleife erstellen, verwendet die Variable anotherPet, wodurch diese Warnmeldung nicht mehr angezeigt wird.

Denken Sie daran: Warnmeldungen sollten immer beachtet werden, doch sie hindern Sie nicht an der Ausführung des Programms.
Geben Sie an der Terminal-Eingabeaufforderung den Befehl ein, um Ihr Programm auszuführen.

Geben Sie den dotnet run Befehl an der Terminal-Eingabeaufforderung ein, um den Programmcode auszuführen.

Solange Ihr Code keinen Laufzeitfehler generiert, sollte das Hauptmenü der App jetzt im Terminalbereich angezeigt werden.
Geben Sie in der Eingabeaufforderung des Terminals den Wert 2 ein.

Dieser Wert entspricht Ihrem Codebranch case "2":.
Überprüfen Sie, ob die folgende Meldung im Terminal angezeigt wird.
```
We currently have 4 pets that need homes. We can manage 4 more.
Press the Enter key to continue.
```
Wird die erwartete Meldung nicht angezeigt, überprüfen Sie Ihren Code, um das Problem zu identifizieren und zu beheben. Speichern Sie Ihre Änderungen. Erstellen Sie die App neu, und führen Sie sie aus. Stellen Sie sicher, dass der Code erwartungsgemäß funktioniert, bevor Sie fortfahren.
Drücken Sie in der Eingabeaufforderung des Terminals die EINGABETASTE, um die Ausführung Ihrer Anwendung fortzusetzen.
Beenden Sie die Anwendung, und schließen Sie dann den Terminalbereich.

Erstellen einer Schleifenstruktur zur Eingabe neuer Daten für das Array „ourAnimals“

In dieser Aufgabe erstellen Sie eine while-Schleife, die durchlaufen wird, solange anotherPet gleich y und petCount kleiner als maxPets ist.

Erstellen Sie im Code-Editor unterhalb des Codeblocks if (petCount < maxPets) eine leere Codezeile.
Geben Sie den folgenden Code ein, um mit dem Erstellen der neuen while-Schleife zu beginnen:
```
while (anotherPet == "y" && petCount < maxPets)
{
}
```
Wählen Sie im Visual Studio Code-Menü Datei die Option Speichern aus.
Öffnen Sie den Bereich "Integriertes Terminal" in Visual Studio Code, und geben Sie den Befehl ein, um Ihr Programm zu erstellen.
Sie erhalten nun keine Warnmeldung mehr darüber, dass anotherPet nicht verwendet wird.

Beheben Sie mögliche Buildfehler oder Warnungen, bevor Sie fortfahren.

Überprüfen der Beendigungsbedingung für die Schleife für neue Haustiere

In dieser Aufgabe aktualisieren Sie den Codeblock while (anotherPet == "y" && petCount < maxPets). Der neue Code erhöht petCount und überprüft dann, ob petCount kleiner als maxPets ist. Ist petCount kleiner als maxPets, fragen Sie die Benutzer*innen, ob sie Informationen für ein weiteres Haustier eingeben möchten. Stellen Sie sicher, dass die Antwort entweder y oder n lautet. Nach dem Codeblock while (anotherPet == "y" && petCount < maxPets) überprüfen Sie den Wert von petCount. Ist petCount gleich maxPets, informieren Sie die Benutzer*innen darüber, dass keine weiteren Haustiere hinzugefügt werden können.

Hinweis

Der Code zur Eingabe von Haustierdaten wird in der nächsten Übung entwickelt. Vorerst wird petCount so erhöht, als ob Daten eingegeben und im ourAnimals-Array gespeichert werden. Auf diese Weise können Sie die Entwicklung der Codelogik abschließen, die der while-Schleife zugeordnet ist.

Erstellen Sie im Codeblock der while (anotherPet == "y" && petCount < maxPets)-Schleife, die Sie in der vorherigen Aufgabe erstellt haben, eine leere Codezeile.

Geben Sie den folgenden Code ein, um petCount um 1 zu erhöhen:

// increment petCount (the array is zero-based, so we increment the counter after adding to the array)
petCount = petCount + 1;

Geben Sie den folgenden Code ein, um zu überprüfen, ob petCount kleiner als maxPets ist:
```
// check maxPet limit
if (petCount < maxPets)
{
}
```
Geben Sie im Codeblock der von Ihnen erstellten if-Anweisung den folgenden Code ein, um die Benutzer*innen zu fragen, ob sie ein weiteres Haustier hinzufügen möchten:
```
// another pet?
Console.WriteLine("Do you want to enter info for another pet (y/n)");
```
Geben Sie unter der von Ihnen eingegebenen Meldung WriteLine() den folgenden Code ein, um die Benutzerantwort zu lesen und sicherzustellen, dass die Eingabe „y“ oder „n“ lautet:
```
do
{
    readResult = Console.ReadLine();
    if (readResult != null)
    {
        anotherPet = readResult.ToLower();
    }

} while (anotherPet != "y" && anotherPet != "n");
```
Suchen Sie die break-Anweisung, die in der switch-Anweisung case "2"; und case "3"; voneinander trennt.
Beachten Sie am Ende des Codes case "2"; die Anweisungen Console.WriteLine() und Console.ReadLine().

Dieser Code zeigt den Benutzer*innen eine Meldung an und hält die Anwendung dann an.
Aktualisieren Sie den Code wie folgt, um die Anweisungen Console.WriteLine() und Console.ReadLine() in die if-Anweisung einzuschließen:
```
if (petCount >= maxPets)
{
    Console.WriteLine("Press the Enter key to continue.");
    readResult = Console.ReadLine();
}

break;

case "3":
```
Der Wert von petCount wird innerhalb der while-Schleife erhöht. Ist petCount gleich maxPets, können dem ourAnimals-Array keine weiteren Haustiere hinzugefügt werden. Darüber sollten Sie die Benutzer*innen informieren.

Aktualisieren Sie den Code wie folgt, um die Benutzer*innen darüber zu informieren, dass Contoso Pets die volle Kapazität erreicht hat:


    if (petCount >= maxPets)
    {
        Console.WriteLine("We have reached our limit on the number of pets that we can manage.");
        Console.WriteLine("Press the Enter key to continue.");
        readResult = Console.ReadLine();
    }

    break;

case "3":

Nehmen Sie sich einen Moment Zeit, um den Code in Ihrer while-Schleife und die von Ihnen erstellte Benutzermeldung zu überprüfen.

Die Schleife while (anotherPet == "y" && petCount < maxPets) und der Code zur Anzeige der Benutzermeldung sollten wie folgt aussehen:

while (anotherPet == "y" && petCount < maxPets)
{
    // increment petCount (the array is zero-based, so we increment the counter after adding to the array)
    petCount = petCount + 1;

    // check maxPet limit
    if (petCount < maxPets)
    {
        // another pet?
        Console.WriteLine("Do you want to enter info for another pet (y/n)");
        do
        {
            readResult = Console.ReadLine();
            if (readResult != null)
            {
                anotherPet = readResult.ToLower();
            }

        } while (anotherPet != "y" && anotherPet != "n");
    }
}

if (petCount >= maxPets)
{
    Console.WriteLine("We have reached our limit on the number of pets that we can manage.");
    Console.WriteLine("Press the Enter key to continue.");
    readResult = Console.ReadLine();
}

Wählen Sie im Visual Studio Code-Menü Datei die Option Speichern aus.
Öffnen Sie den Bereich "Integriertes Terminal" in Visual Studio Code, und geben Sie den Befehl ein, um Ihr Programm zu erstellen.
Beheben Sie alle Buildfehler oder Warnungen, die angezeigt werden, bevor Sie fortfahren.

Überprüfen Sie Ihre Arbeit

In dieser Aufgabe führen Sie die Anwendung über das integrierte Terminal aus und überprüfen, ob die von Ihnen erstellte Schleifen- und Verzweigungslogik erwartungsgemäß funktioniert.

Öffnen Sie bei Bedarf das Visual Studio Code-Panel „Integriertes Terminal“.
Geben Sie im Terminal den Befehl dotnet run ein.
Geben Sie in der Eingabeaufforderung des Terminals den Wert 2 ein.

Es sollten die folgenden Meldungen angezeigt werden:

We currently have 4 pets that need homes. We can manage 4 more.
Do you want to enter info for another pet (y/n)

Geben Sie in der Eingabeaufforderung des Terminals den Wert n ein.
Stellen Sie sicher, dass Ihr Code die Schleife zur Eingabe neuer Haustiere beendet, wenn Sie „n“ eingeben.

Wenn Ihre Codelogik ordnungsgemäß funktioniert, sollte im Terminal das Hauptmenü angezeigt werden.

Sollte Ihr Code die Schleife nicht wie erwartet beenden, drücken Sie im Terminal STRG+C, um das Beenden der Ausführung zu erzwingen. Durchlaufen Sie Ihren Code manuell, um die Werte der Variablen für die Beendigungskriterien nachzuverfolgen. Aktualisieren Sie ggf. den Code, um sicherzustellen, dass bei der Eingabe von „n“ die while-Schleife beendet wird. Speichern Sie Ihre Änderungen. Erstellen Sie das Programm neu, und führen Sie den Überprüfungstest durch, um wieder an diesen Punkt zu gelangen.
Geben Sie in der Eingabeaufforderung des Terminals den Wert 2 ein.

Es werden wieder die folgenden Meldungen angezeigt:
```
We currently have 4 pets that need homes. We can manage 4 more.
Do you want to enter info for another pet (y/n)
```
Geben Sie in der Eingabeaufforderung des Terminals den Wert y ein.
Nehmen Sie sich einen Moment Zeit, um sich die Verwendung von petCount im Code anzusehen.

Sie müssen die Codelogik verstehen, bevor Sie Ihren Code überprüfen können.

In diesem Fall basiert Ihre Codelogik auf der Beziehung zwischen petCount und maxPets. Sie wissen, dass maxPets der Wert 8 zugewiesen ist. Aber was ist mit petCount? Die folgenden Punkte erleichtern die Auswertung der Logik, die Sie implementiert haben:
- Sie wissen, dass petCount zu Beginn der ersten Iteration der while-Schleife 4 beträgt.
- Sie wissen, dass petCount bei jeder Iteration der while-Schleife um 1 erhöht wird.
- Sie wissen, dass der zugewiesene Wert von petCount und die Erhöhung von petCount die Speicherung der Daten im ourAnimals-Array beeinflussen. Die folgenden Punkte erläutern die Beziehung zwischen petCount und den in ourAnimalsgespeicherten Daten:
  - Die Anwendung fügt dem ourAnimals-Array beim Erstellen der Beispieldaten vier Haustiere hinzu.
  - Die Anwendung speichert neue Daten im ourAnimals-Array, wenn der Wert von petCount4 ist. Dies ist kein Fehler. Der Code ist deshalb schlüssig, weil Arrayelemente auf null basieren. So enthält z. B. ourAnimals[0,0] die Haustier-ID für Tier 1 und ourAnimals[3,0] für Tier 4. Daher werden bei einem Wert von 4 für petCount Daten für das fünfte Haustier gespeichert.
  - Die Anwendung speichert die Haustierdaten im Array, bevor petCount erhöht wird.
  - Die Anwendung erhöht petCount, bevor sie die Benutzer*innen auffordert, ein weiteres Haustier hinzuzufügen.
  - Wird die Aufforderung Do you want to enter info for another pet (y/n)? (Möchten Sie Informationen für ein weiteres Haustier eingeben (j/n)?) zum ersten Mal angezeigt, wurde petCount bereits auf 5 festgelegt.
- Gibt der Benutzer/die Benutzerin bei der ersten Aufforderung für Möchten Sie Informationen für ein anderes Haustier eingeben (y/n)? den Wert y ein, wissen Sie Folgendes:
  - Die Schleife while (anotherPet == "y" && petCount < maxPets) wird durchlaufen. Dies wissen Sie, weil anotherPet == "y" und petCount < maxPets gilt.
  - Der zugewiesene Wert für petCount wird erhöht (wenn die while-Schleife durchlaufen wird).
  - Der zugewiesene Wert für petCount beträgt 6 (nachdem der Benutzer/die Benutzerin zum ersten Mal y eingegeben hat).
Behalten Sie diese Analyse der Codelogik im Hinterkopf, wenn Sie mit dem Testen der Anwendung fortfahren.
Beachten Sie, dass auch der Terminalbereich mit der Frage zu einem weiteren Haustier aktualisiert wird, Ihr Code jedoch keine aktualisierte petCount-Variable anzeigt.

Im Terminalbereich sollte nun die folgende Ausgabe angezeigt werden:
```
We currently have 4 pets that need homes. We can manage 4 more.
Do you want to enter info for another pet (y/n)
y
Do you want to enter info for another pet (y/n)
```
Geben Sie in der Eingabeaufforderung des Terminals den Wert y ein.

Wenn Sie ein zweites Mal y eingeben, wird petCount auf 7 erhöht. petCount ist also immer noch kleiner als maxPets.
Geben Sie in der Eingabeaufforderung des Terminals den Wert y ein.

Wenn Sie ein drittes Mal y eingeben, wird petCount auf 8 erhöht. Das bedeutet, dass petCount gleich maxPets ist.
Überprüfen Sie, ob Ihr Code die while-Schleife beendet, wenn Sie y zum dritten Mal eingeben.

Im Terminalbereich sollte nun die folgende Ausgabe angezeigt werden:
```
We currently have 4 pets that need homes. We can manage 4 more.
Do you want to enter info for another pet (y/n)
y
Do you want to enter info for another pet (y/n)
y
Do you want to enter info for another pet (y/n)
y
We have reached our limit on the number of pets that we can manage.
Press the Enter key to continue.
```
Sollte Ihr Code die Schleife nicht wie erwartet beenden, durchlaufen Sie ihn manuell, um die Werte der Variablen für die Beendigungskriterien nachzuverfolgen. Aktualisieren Sie den Code, um sicherzustellen, dass bei identischen Werten von petCount und maxPets die Schleife beendet wird. Geben Sie weiterhin die Antwort „y“ ein, bis petCount den Wert von maxPets erreicht (dessen Standardwert 8 ist).
Drücken Sie in der Eingabeaufforderung des Terminals die EINGABETASTE, um die Ausführung Ihrer Anwendung fortzusetzen.
Beenden Sie die Anwendung, und schließen Sie dann den Terminalbereich.

Feedback

War diese Seite hilfreich?