16. Jul 2018
Lesedauer 7 Min.
Wer errät das Wort?
dojoLösung: Ein Ratespiel implementieren
Das Galgenmännchen war eine gute Übung zum Thema automatisiertes Testen.
Die Übungsaufgabe Galgenmännchen oder Hangman hat mich im zurückliegenden Monat beschäftigt. Das war ein beliebtes Spiel in meiner Schulzeit, einer meiner Lehrer hat es immer vor den Ferien mit uns an der Tafel gespielt.Es geht wie folgt: Ein Wort muss erraten werden, indem man Buchstabe für Buchstabe rät. Dazu wird für jeden Buchstaben des zu erratenden Wortes ein Strich als Platzhalter gezeichnet. Errät man einen Buchstaben, der im Wort vorkommt, wird der Buchstabe an den entsprechenden Stellen eingetragen. Kommt der Buchstabe im Wort nicht vor, wird ein weiterer Strich am Galgenmännchen ergänzt.Ist das Galgenmännchen komplett, hat der Spieler, der das Wort erraten sollte, verloren. Errät er das Wort, bevor das Galgenmännchen vollständig gezeichnet ist, hat er gewonnen.
Los geht’s ...
Natürlich lässt sich ein solches Spiel leicht in Software gießen. Folgendes Listing zeigt das zu realisierende API aus der Aufgabenstellung:
<span class="hljs-keyword">public</span> <span class="hljs-keyword">class</span> Galgenmännchen {
<span class="hljs-keyword">public</span> Galgenmännchen(<span class="hljs-built_in">string</span> gesuchtesWort) { ... }
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-built_in">string</span> <span class="hljs-title">RateBuchstabe</span><span class="hljs-params">(<span class="hljs-keyword">char</span> buchstabe)</span> </span>{ ... }
}
Dem Konstruktor wird das zu erratende Wort übergeben. Anschließend kann die Methode RateBuchstabe aufgerufen werden, um einen Buchstaben des Wortes zu erraten.Als Ergebnis liefert die Methode einen String zurück. Dieser enthält für jeden Buchstaben des Wortes einen Strich. Alle Buchstaben, die erfolgreich geraten wurden, stehen an den richtigen Stellen im String. Tabelle 1 zeigt einen möglichen Ablauf von API-Aufrufen.
Tabelle 1: Exemplarischer Ablauf von API-Aufrufen
|
Ich habe meine Implementation testgetrieben begonnen. Dazu habe ich zunächst folgenden Test erstellt:
<span class="hljs-keyword">using</span> NUnit.Framework;
<span class="hljs-keyword">namespace</span> <span class="hljs-title">hangman.logic.tests</span>
{
[TestFixture]
<span class="hljs-keyword">public</span> <span class="hljs-keyword">class</span> <span class="hljs-title">HangmanTests</span>
{
[Test]
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Wrong_guess_after_ctor</span>(<span class="hljs-params"></span>) </span>{
<span class="hljs-keyword">var</span> sut = <span class="hljs-keyword">new</span> Hangman(<span class="hljs-string">"Developer"</span>);
Assert.That(sut.Guess(<span class="hljs-string">'u'</span>),
Is.EqualTo(<span class="hljs-string">"---------"</span>));
}
}
}
Sicherlich ist Ihnen aufgefallen, dass ich das API mal eben ins Englische übersetzt habe. Das lag daran, dass ich mit der Lösung begonnen habe, ohne mir die Aufgabenstellung noch einmal im Detail anzusehen. In meinen Clean-Code-Developer-Workshops sind solche Übersetzungen von APIs an der Tagesordnung.Viele Entwickler sind es gewohnt, die Domänensprache vollständig ins Englische zu übertragen. Häufig kommt auch der Einwand, dass deutsche Begriffe in Kombination mit den englischen Schlüsselwörter der Sprache schwerer zu lesen seien, was für eine Übersetzung spricht. So gibt es viele Argumente für und gegen deutsche oder englische Begriffe. Letztlich müssen Sie sich im Team festlegen. Und existiert erst einmal eine ausreichend große Codebasis, werden Sie die Sprache sicherlich nicht mehr wechseln.Doch zurück zum Galgenmännchen. Um den ersten Test grün zu bekommen, war nicht sonderlich viel Implementation erforderlich:
<span class="hljs-keyword">namespace</span> <span class="hljs-title">hangman.logic</span>
{
<span class="hljs-keyword">public</span> <span class="hljs-keyword">class</span> <span class="hljs-title">Hangman</span>
{
<span class="hljs-keyword">private</span> <span class="hljs-keyword">readonly</span> <span class="hljs-keyword">string</span> _word;
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-title">Hangman</span>(<span class="hljs-params"><span class="hljs-keyword">string</span> word</span>) </span>{
_word = word;
}
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">string</span> <span class="hljs-title">Guess</span>(<span class="hljs-params"><span class="hljs-keyword">char</span> ch</span>) </span>{
<span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-keyword">string</span>(<span class="hljs-string">'-'</span>, _word.Length);
}
}
}
Das im Konstruktor übergebene Wort wird in einem Feld der Klasse abgelegt. So kann in der Methode Guess darauf zugegriffen werden, um die Anzahl der auszugebenden Striche zu ermitteln.Bis hierher war es noch einfach. Mein nächster Test sah dann wie folgt aus:
[Test]
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Correct_guess_after_ctor</span>(<span class="hljs-params"></span>) </span>{
<span class="hljs-keyword">var</span> sut = <span class="hljs-keyword">new</span> Hangman(<span class="hljs-string">"Developer"</span>);
Assert.That(sut.Guess(<span class="hljs-string">'e'</span>), Is.EqualTo(<span class="hljs-string">"-e-e---e-"</span>));
}
Jetzt müssen die tatsächlich vorhandenen Buchstaben, hier „e“, im Wort gefunden und ausgegeben werden. Die Implementation dazu ist ebenfalls einfach, wie Sie in Listing 1 erkennen können.
Listing 1: Buchstaben finden und ausgeben
<span class="hljs-keyword">namespace</span> <span class="hljs-title">hangman.logic</span> <br/>{ <br/> <span class="hljs-keyword">public</span> <span class="hljs-keyword">class</span> <span class="hljs-title">Hangman</span> <br/> { <br/> <span class="hljs-keyword">private</span> <span class="hljs-keyword">readonly</span> <span class="hljs-keyword">string</span> _word; <br/> <span class="hljs-keyword">private</span> <span class="hljs-keyword">readonly</span> <span class="hljs-keyword">char</span>[] _result; <br/><br/> <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-title">Hangman</span>(<span class="hljs-params"><span class="hljs-keyword">string</span> word</span>) </span>{ <br/> _word = word; <br/> _result = <span class="hljs-keyword">new</span> <span class="hljs-keyword">string</span>(<br/> <span class="hljs-string">'-'</span>, _word.Length).ToCharArray(); <br/> } <br/><br/> <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">string</span> <span class="hljs-title">Guess</span>(<span class="hljs-params"><span class="hljs-keyword">char</span> ch</span>) </span>{ <br/> <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>; i &lt; _word.Length; i++) { <br/> <span class="hljs-keyword">if</span> (_word[i] == ch) { <br/> _result[i] = ch; <br/> } <br/> } <br/> <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-keyword">string</span>(_result); <br/> } <br/> } <br/>}
Nun wird im Konstruktor das Feld _result mit Strichen vorbelegt. Ich habe hier ein Character-Array gewählt, da ein String immutable ist. In der Guess-Methode wird nun jedes Zeichen, das im Wort an der entsprechenden Stelle vorkommt, in das Feld _result übernommen. Erst bei der Rückgabe des Ergebnisses wird dann aus dem char[] ein String erzeugt.So simpel kann die Lösung einer einfachen Aufgabenstellung aussehen. Doch wie sieht es mit den anderen Testfällen aus? Schließlich enthält die Aufgabenstellung eine Tabelle mit Testdaten. Die sollten unbedingt in automatisierte Tests überführt werden. Im realen Projekt schafft dies Vertrauen zwischen Team und Product Owner. Den zugehörigen Test zeigt Listing 2.
Listing 2: Test der Beispieldaten
[Test] <br/>public void Integrationstest() { <br/> var sut = <span class="hljs-keyword">new</span> Hangman(<span class="hljs-string">"Developer"</span>); <br/> Assert.That(<br/> sut.Guess(<span class="hljs-string">'u'</span>), <span class="hljs-keyword">Is</span>.EqualTo(<span class="hljs-string">"---------"</span>)); <br/> Assert.That(<br/> sut.Guess(<span class="hljs-string">'e'</span>), <span class="hljs-keyword">Is</span>.EqualTo(<span class="hljs-string">"-e-e---e-"</span>)); <br/> Assert.That(<br/> sut.Guess(<span class="hljs-string">'n'</span>), <span class="hljs-keyword">Is</span>.EqualTo(<span class="hljs-string">"-e-e---e-"</span>)); <br/> Assert.That(<br/> sut.Guess(<span class="hljs-string">'o'</span>), <span class="hljs-keyword">Is</span>.EqualTo(<span class="hljs-string">"-e-e-o-e-"</span>)); <br/> Assert.That(<br/> sut.Guess(<span class="hljs-string">'r'</span>), <span class="hljs-keyword">Is</span>.EqualTo(<span class="hljs-string">"-e-e-o-er"</span>)); <br/> Assert.That(<br/> sut.Guess(<span class="hljs-string">'a'</span>), <span class="hljs-keyword">Is</span>.EqualTo(<span class="hljs-string">"-e-e-o-er"</span>)); <br/> Assert.That(<br/> sut.Guess(<span class="hljs-string">'d'</span>), <span class="hljs-keyword">Is</span>.EqualTo(<span class="hljs-string">"De-e-o-er"</span>)); <br/> Assert.That(<br/> sut.Guess(<span class="hljs-string">'l'</span>), <span class="hljs-keyword">Is</span>.EqualTo(<span class="hljs-string">"De-elo-er"</span>)); <br/> Assert.That(<br/> sut.Guess(<span class="hljs-string">'p'</span>), <span class="hljs-keyword">Is</span>.EqualTo(<span class="hljs-string">"De-eloper"</span>)); <br/> Assert.That(<br/> sut.Guess(<span class="hljs-string">'v'</span>), <span class="hljs-keyword">Is</span>.EqualTo(<span class="hljs-string">"Developer"</span>)); <br/>}
Und siehe da: Rot! Leider hatte ich nämlich übersehen, dass der Anfangsbuchstabe zwar als kleiner Buchstabe geraten wird, dann aber natürlich als Großbuchstabe im Ergebnis erscheinen soll.An genau dieser Stelle schlägt der Test allerdings fehl. Die Implementation musste also noch einmal korrigiert werden.Um den Testfall zu fokussieren, habe ich den folgenden Test ergänzt:
[Test]
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Capital_letters_are_found</span>(<span class="hljs-params"></span>) </span>{
<span class="hljs-keyword">var</span> sut = <span class="hljs-keyword">new</span> Hangman(<span class="hljs-string">"dDaA"</span>);
Assert.That(sut.Guess(<span class="hljs-string">'d'</span>), Is.EqualTo(<span class="hljs-string">"dD--"</span>));
Assert.That(sut.Guess(<span class="hljs-string">'A'</span>), Is.EqualTo(<span class="hljs-string">"dDaA"</span>));
}
Dieser Test stellt sicher, dass die Groß-/Kleinschreibung nicht relevant ist. Buchstaben können in beliebiger Schreibweise geraten werden und werden dann trotzdem in der Schreibweise, in der sie in das zu erratende Wort eingestellt sind, übernommen.Die korrigierte Implementation sieht wie folgt aus:
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">string</span> <span class="hljs-title">Guess</span>(<span class="hljs-params"><span class="hljs-keyword">char</span> ch</span>) </span>{
<span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>; i < _word.Length; i++) {
<span class="hljs-keyword">if</span> (<span class="hljs-keyword">char</span>.ToLower(_word[i]) == <span class="hljs-keyword">char</span>.ToLower(ch)) {
_result[i] = _word[i];
}
}
<span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-keyword">string</span>(_result);
}
Nun läuft alles so, wie es soll: Die Buchstaben werden vor dem Vergleich beide in Kleinbuchstaben umgewandelt. Außerdem wird nicht das übergebene Zeichen ch in das Ergebnis übernommen, sondern der Buchstabe aus dem Wort. Jetzt sind auch alle Tests grün.
Zwischenfazit
Selbst eine so einfache Aufgabenstellung bietet Raum für Fehler. Beim flüchtigen Beantworten der Frage „Bin ich fertig?“ habe ich nämlich viel zu schnell „Ja“ gedacht. Mir war zunächst überhaupt nicht aufgefallen, dass es ein Problem geben könnte. Erst das Ergänzen der weiteren Testfälle aus den Anforderungen hat das zutage gefördert. Es gilt also immer: Sorgfältig arbeiten!Mehr!
Nun hatte ich den Wunsch, das API noch etwas zu erweitern. Man kann beispielsweise nicht erkennen, ob das Wort korrekt geraten wurde.Dazu müsste man selbst feststellen, ob noch wenigstens ein Strich im Ergebnis vorhanden ist. Besser wäre eine boolesche Eigenschaft. Also habe ich einen Test geschrieben, der ausdrückt, wie sich die Ergänzung verhalten soll. Den Test sehen Sie in Listing 3.Listing 3: Test der Ergänzung
[Test] <br/>public void Guessed_is_false_after_ctor() { <br/> var sut = <span class="hljs-keyword">new</span> Hangman(<span class="hljs-string">"a"</span>); <br/> Assert.That(sut.Guessed, <span class="hljs-keyword">Is</span>.<span class="hljs-literal">False</span>); <br/>} <br/><br/>[Test] <br/>public void Guessed_is_true_after_word_is_guessed() { <br/> var sut = <span class="hljs-keyword">new</span> Hangman(<span class="hljs-string">"Aber"</span>); <br/> sut.Guess(<span class="hljs-string">'a'</span>); <br/> Assert.That(sut.Guessed, <span class="hljs-keyword">Is</span>.<span class="hljs-literal">False</span>); <br/> sut.Guess(<span class="hljs-string">'r'</span>); <br/> Assert.That(sut.Guessed, <span class="hljs-keyword">Is</span>.<span class="hljs-literal">False</span>); <br/> sut.Guess(<span class="hljs-string">'b'</span>); <br/> Assert.That(sut.Guessed, <span class="hljs-keyword">Is</span>.<span class="hljs-literal">False</span>); <br/> sut.Guess(<span class="hljs-string">'e'</span>); <br/> Assert.That(sut.Guessed, <span class="hljs-keyword">Is</span>.<span class="hljs-literal">True</span>); <br/>}
Die zugehörige Implementation einer Property ist trivial:
<span class="hljs-keyword">public</span> <span class="hljs-keyword">bool</span> Guessed => !_result.Contains(<span class="hljs-string">'-'</span>);
Doch nun hat die Implementation ein unschönes Verhalten: Der Wert der Property hängt davon ab, dass ein Bindestrich im Ergebnis verwendet wird. Was aber passiert, wenn der Konstruktor mit einer Zeichenkette aufgerufen wird, die einen solchen Bindestrich enthält? Des Weiteren ist der Bindestrich nun an zwei Stellen über den Code verteilt.„Don’t Repeat Yourself“ lautet die ewige Mahnung an den Clean Code Developer. Also habe ich den Code noch etwas refaktorisiert. Zum einen habe ich für den Bindestrich eine Konstante eingeführt. Zum anderen wird nun im Konstruktor eine Ausnahme ausgelöst, wenn das zu erratende Wort den Bindestrich enthält.Der zugehörige Test:
[Test]
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> </span>
<span class="hljs-function"> <span class="hljs-title">Exception_is_thrown_if_word_contains_hyphen</span>(<span class="hljs-params"></span>) </span>{
<span class="hljs-keyword">var</span> e = Assert.Throws<ArgumentException>(() =>
<span class="hljs-keyword">new</span> Hangman(<span class="hljs-string">"-"</span>));
Assert.That(e.Message, Is.EqualTo(
<span class="hljs-string">"Word must not contain hyphen '-'."</span>));
}
Wie die modifizierte Implementation aussieht, können Sie anhand von Listing 4 nachvollziehen.
Listing 4: Die Implementation, ergänzt um die Behandlung des Bindestrichs
<span class="hljs-keyword">using</span> System; <br/><span class="hljs-keyword">using</span> System.Linq; <br/><br/><span class="hljs-keyword">namespace</span> <span class="hljs-title">hangman.logic</span> <br/>{ <br/> <span class="hljs-keyword">public</span> <span class="hljs-keyword">class</span> <span class="hljs-title">Hangman</span> <br/> { <br/> <span class="hljs-keyword">private</span> <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span> Hyphen = <span class="hljs-string">'-'</span>; <br/> <br/> <span class="hljs-keyword">private</span> <span class="hljs-keyword">readonly</span> <span class="hljs-keyword">string</span> _word; <br/> <span class="hljs-keyword">private</span> <span class="hljs-keyword">readonly</span> <span class="hljs-keyword">char</span>[] _result; <br/><br/> <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-title">Hangman</span>(<span class="hljs-params"><span class="hljs-keyword">string</span> word</span>) </span>{ <br/> <span class="hljs-keyword">if</span> (word.Contains(Hyphen)) { <br/> <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> ArgumentException(<br/> <span class="hljs-string">$"Word must not contain hyphen </span><br/><span class="hljs-string"> '<span class="hljs-subst">{Hyphen}</span>'."</span>); <br/> } <br/> _word = word; <br/> _result = <span class="hljs-keyword">new</span> <span class="hljs-keyword">string</span>(<br/> Hyphen, _word.Length).ToCharArray(); <br/> } <br/><br/> <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">string</span> <span class="hljs-title">Guess</span>(<span class="hljs-params"><span class="hljs-keyword">char</span> ch</span>) </span>{ <br/> <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>; i &lt; _word.Length; i++) { <br/> <span class="hljs-keyword">if</span> (<span class="hljs-keyword">char</span>.ToLower(_word[i]) == <br/> <span class="hljs-keyword">char</span>.ToLower(ch)) { <br/> _result[i] = _word[i]; <br/> } <br/> } <br/> <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-keyword">string</span>(_result); <br/> } <br/><br/> <span class="hljs-keyword">public</span> <span class="hljs-keyword">bool</span> Guessed =&gt; !_result.Contains(Hyphen); <br/> } <br/>}
Nun ist die Implementation doch schon etwas länger geraten als in der ursprünglichen Variante. Und dennoch fehlt immer noch eine wichtige Eigenschaft: Nach jedem Raten sollte dem Aufrufer mitgeteilt werden, ob der Versuch erfolgreich war oder ob ein weiterer Strich am Galgenmännchen ergänzt werden muss.Um das zu erreichen, müsste die Guess-Methode entweder zwei Werte zurückliefern, oder aber es wird eine weitere Eigenschaft ergänzt.Zwar sind dank der Tupel-Notation mehrere Rückgabewerte in C# kein Problem mehr, doch ich halte hier eine andere Lösung für eleganter. Die Guess-Methode liefert zukünftig einen bool zurück. Dieser ist true, wenn der Buchstabe im Wort vorkommt, andernfalls false. Diese Änderung hat allerdings den gravierenden Nachteil, dass mir damit einige Tests syntaktisch kaputtgehen.An dieser Stelle kann man erkennen, dass das Erstellen eines API nicht trivial ist. Ein API „auf der grünen Wiese“ zu entwerfen ist selten eine gute Idee. In der Regel übersieht man dabei Details. Diese tauchen auf, sobald man beginnt, das API in einer realen Anwendung zu verwenden.Ich habe die Änderungen schrittweise vorgenommen. Zuerst habe ich die Eigenschaft Result ergänzt. Anschließend habe ich dann die Tests so modifiziert, dass nach jedem Aufruf der Guess-Methode die Result-Eigenschaft überprüft wird. Folgender Test zeigt dies exemplarisch:
[Test]
public void Wrong_guess_after_ctor() {
var sut = new Hangman("Developer");
Assert.That(sut.Guess('u'), Is.EqualTo("---------"));
Assert.That(sut.Result, Is.EqualTo("---------"));
}
Die Result-Eigenschaft ist wie folgt definiert:
public string Result => new string(_result);
Anschließend habe ich die Signatur der Methode Guess so geändert, dass sie einen bool liefert anstelle des Strings. Das führte natürlich dazu, dass ich die Tests anpassen musste. Diese Änderung ging allerdings leicht von der Hand, es war lediglich Fleißarbeit (Listing 5).
Listing 5: Die angepassten Tests nach Änderung von Guess
[Test] <br/>public void Integrationstest() { <br/> var sut = new Hangman("Developer"); <br/> Assert.That(sut.Guess('u'), Is.False); <br/> Assert.That(sut.Result, Is.EqualTo("---------")); <br/> Assert.That(sut.Guess('e'), Is.True); <br/> Assert.That(sut.Result, Is.EqualTo("-e-e---e-")); <br/> Assert.That(sut.Guess('n'), Is.False); <br/> Assert.That(sut.Result, Is.EqualTo("-e-e---e-")); <br/> Assert.That(sut.Guess('o'), Is.True); <br/> Assert.That(sut.Result, Is.EqualTo("-e-e-o-e-")); <br/> Assert.That(sut.Guess('r'), Is.True); <br/> Assert.That(sut.Result, Is.EqualTo("-e-e-o-er")); <br/> Assert.That(sut.Guess('a'), Is.False); <br/> Assert.That(sut.Result, Is.EqualTo("-e-e-o-er")); <br/> Assert.That(sut.Guess('d'), Is.True); <br/> Assert.That(sut.Result, Is.EqualTo("De-e-o-er")); <br/> Assert.That(sut.Guess('l'), Is.True); <br/> Assert.That(sut.Result, Is.EqualTo("De-elo-er")); <br/> Assert.That(sut.Guess('p'), Is.True); <br/> Assert.That(sut.Result, Is.EqualTo("De-eloper")); <br/> Assert.That(sut.Guess('v'), Is.True); <br/> Assert.That(sut.Result, Is.EqualTo("Developer")); <br/>}
Die vollständige Implementation sieht damit aus wie in Listing 6 gezeigt.
Listing 6: Die Implementation, jetzt komplett
using System; <br/>using System.Linq; <br/><br/>namespace hangman.logic <br/>{ <br/> public class Hangman <br/> { <br/> private const char Hyphen = '-'; <br/> <br/> private readonly string _word; <br/> private readonly char[] _result; <br/><br/> public Hangman(string word) { <br/> if (word.Contains(Hyphen)) { <br/> throw new ArgumentException(<br/> $"Word must not contain hyphen '{Hyphen}'."); <br/> } <br/> _word = word; <br/> _result = new string(<br/> Hyphen, _word.Length).ToCharArray(); <br/> } <br/><br/> public bool Guess(char ch) { <br/> var guessedCorrect = false; <br/> for (var i = 0; i &lt; _word.Length; i++) { <br/> if (char.ToLower(_word[i]) == <br/> char.ToLower(ch)) { <br/> _result[i] = _word[i]; <br/> guessedCorrect = true; <br/> } <br/> } <br/> return guessedCorrect; <br/> } <br/><br/> public string Result =&gt; new string(_result); <br/> <br/> public bool Guessed =&gt; !_result.Contains(Hyphen); <br/> } <br/>}
Mit dieser Implementation und den zugehörigen Tests gebe ich mich nun zufrieden.
