Umgehen der Regeln in Zauberern und Kriegern

In dieser Reihe von Blog-Posts beschreibt Eric Lippert ein Problem im objektorientierten Design am Beispiel von Zauberern und Kriegern.

abstract class Weapon { }
sealed class Staff : Weapon { }
sealed class Sword : Weapon { }

abstract class Player 
{ 
  public Weapon Weapon { get; set; }
}
sealed class Wizard : Player { }
sealed class Warrior : Player { }

und fügt dann ein paar Regeln hinzu:

• Ein Krieger kann nur ein Schwert benutzen.
• Ein Assistent kann nur einen Stab verwenden.

Anschließend demonstriert er die Probleme, auf die Sie stoßen, wenn Sie versuchen, diese Regeln mithilfe des C # -Systems durchzusetzen (z. B. indem Sie die WizardKlasse dafür verantwortlich machen, dass ein Assistent nur einen Stab verwenden kann). Sie verstoßen gegen das Liskov-Substitutionsprinzip, riskieren Laufzeitausnahmen oder erhalten Code, der schwer zu erweitern ist.

Die Lösung, die er findet, ist, dass die Player-Klasse keine Validierung durchführt. Es wird nur zum Verfolgen des Status verwendet. Dann, anstatt einem Spieler eine Waffe zu geben durch:

player.Weapon = new Sword();

Zustand wird durch Commands und gemäß Rules geändert :

... wir machen ein CommandObjekt namens Wield, das zwei Spielstatusobjekte nimmt, a Playerund a Weapon. Wenn der Benutzer einen Befehl an das System ausgibt, "dieser Assistent sollte dieses Schwert führen", wird dieser Befehl im Kontext einer Menge von Rules ausgewertet , die eine Folge von Effects erzeugt. Wir haben eine Rule, die besagt, dass, wenn ein Spieler versucht, eine Waffe einzusetzen, die vorhandene Waffe, falls vorhanden, fallen gelassen wird und die neue Waffe zur Waffe des Spielers wird. Wir haben eine andere Regel, die die erste Regel stärkt, die besagt, dass die Auswirkungen der ersten Regel nicht gelten, wenn ein Zauberer versucht, ein Schwert zu führen.

Ich mag diese Idee im Prinzip, habe aber Bedenken, wie sie in der Praxis angewendet werden könnte.

Nichts scheint einen Entwickler daran zu hindern, das Commandsund Rules zu umgehen, indem er einfach das Weaponauf a setzt Player. Die WeaponEigenschaft muss über den WieldBefehl zugänglich sein , damit sie nicht erstellt werden kann private set.

Was hindert einen Entwickler daran? Müssen sie sich nur daran erinnern, es nicht zu tun?

Das ganze Argument, zu dem eine Reihe von Blog-Posts führt, ist in Teil 5 :

Wir haben keinen Grund zu der Annahme, dass das System vom Typ C # so konzipiert wurde, dass es allgemein genug ist, um die Regeln von Dungeons & Dragons zu kodieren. Warum versuchen wir es also überhaupt?

Wir haben das Problem gelöst: "Wohin geht der Code, der die Regeln des Systems ausdrückt?" Es geht um Objekte, die die Regeln des Systems darstellen, nicht um Objekte, die den Spielstatus darstellen. Das Anliegen der Zustandsobjekte ist es, ihren Zustand konsistent zu halten und nicht die Spielregeln zu bewerten.

Waffen, Charaktere, Monster und andere Spielobjekte sind nicht dafür verantwortlich zu überprüfen, was sie können oder nicht können. Dafür ist das Regelsystem verantwortlich. Das CommandObjekt macht auch nichts mit den Spielobjekten. Es ist nur der Versuch , etwas mit ihnen zu tun. Das Regelsystem prüft dann, ob der Befehl möglich ist, und wenn es das Regelsystem ist, führt es den Befehl aus, indem es die entsprechenden Methoden für die Spielobjekte aufruft.

Wenn ein Entwickler ein zweites Regelsystem erstellen möchte, das Dinge mit Charakteren und Waffen tut, die das erste Regelsystem nicht zulässt, kann er dies tun, da Sie in C # (ohne böse Reflexionshacks) nicht herausfinden können, woher ein Methodenaufruf kommt von.

Eine Abhilfe , die möglicherweise in Arbeit einigen Situationen setzt die Spielobjekte (oder deren Schnittstellen) in einer Baugruppe mit der Regelmaschine und markieren Sie alle Mutator-Methoden internal. Alle Systeme, die schreibgeschützten Zugriff auf Spielobjekte benötigen, befinden sich in einer anderen Baugruppe, dh sie können nur auf die publicMethoden zugreifen . Dies lässt immer noch die Lücke von Spielobjekten, die sich gegenseitig die internen Methoden aufrufen. Aber das wäre ein offensichtlicher Codegeruch, denn Sie waren sich einig, dass die Spielobjektklassen dumme Staatsinhaber sein sollen.

Das offensichtliche Problem des ursprünglichen Codes besteht darin, dass Datenmodellierung anstelle von Objektmodellierung durchgeführt wird . Bitte beachten Sie, dass die tatsächlichen Geschäftsanforderungen im verlinkten Artikel absolut nicht erwähnt werden!

Ich würde zunächst versuchen, die tatsächlichen funktionalen Anforderungen zu ermitteln. Zum Beispiel: "Jeder Spieler kann jeden anderen Spieler angreifen, ...". Hier:

interface Player {
    void Attack(Player enemy);
}

"Spieler können eine Waffe einsetzen, die für den Angriff verwendet wird, Zauberer können einen Stab einsetzen, Krieger ein Schwert":

public class Wizard: Player {
    ...
    public void Wield(Staff weapon) { ... }
    ...
}
public class Warrior: Player {
    ...
    public void Wield(Sword sword) { ... }
    ...
}

"Jede Waffe fügt dem angegriffenen Feind Schaden zu". Ok, jetzt müssen wir eine gemeinsame Schnittstelle für Weapon haben:

interface Weapon {
    void dealDamageTo(Player enemy);
}

Und so weiter ... Warum gibt es keine Wield()in der Player? Weil es nicht erforderlich war, dass ein Spieler eine Waffe einsetzen kann.

Ich kann mir vorstellen, dass es eine Anforderung geben würde, die besagt: "Jeder Playerkann versuchen , einen zu führen Weapon." Dies wäre jedoch eine ganz andere Sache. Ich würde es vielleicht so modellieren:

interface Player {
    void Attack(Player enemy);
    void TryWielding(Weapon weapon); // Throws UnwieldableException
}

Zusammenfassung: Modellieren Sie die Anforderungen und nur die Anforderungen. Führen Sie keine Datenmodellierung durch, dh keine Modellierung.

Eine Möglichkeit wäre, den WieldBefehl an die zu übergeben Player. Der Spieler führt dann den WieldBefehl aus, der die entsprechenden Regeln überprüft und den zurückgibt Weapon, mit dem er Playerdann sein eigenes Waffenfeld setzt. Auf diese Weise kann das Waffenfeld einen privaten Setter haben und kann nur durch Übergabe eines WieldBefehls an den Spieler eingestellt werden.

Nichts hindert den Entwickler daran. Eigentlich hat Eric Lippert viele verschiedene Techniken ausprobiert, aber alle hatten Schwächen. Das war der springende Punkt dieser Serie, dass es nicht einfach ist, den Entwickler daran zu hindern, und alles, was er versuchte, hatte Nachteile. Schließlich entschied er, dass die Verwendung eines CommandObjekts mit Regeln der richtige Weg ist.

Mit Regeln können Sie die WeaponEigenschaft von a Wizardauf a setzen, Swordaber wenn Sie den bitten Wizard, die Waffe (Schwert) zu führen und anzugreifen, hat dies keine Wirkung und ändert daher keinen Zustand. Wie er unten sagt:

Wir haben eine andere Regel, die die erste Regel stärkt, die besagt, dass die Auswirkungen der ersten Regel nicht gelten, wenn ein Zauberer versucht, ein Schwert zu führen. Die Auswirkungen für diese Situation sind: „Machen Sie einen traurigen Posaunenton, der Benutzer verliert seine Aktion für diesen Zug, kein Spielstatus ist mutiert

Mit anderen Worten, wir können eine solche Regel nicht durch typeBeziehungen durchsetzen, die er auf viele verschiedene Arten ausprobiert hat, aber entweder nicht mochte oder nicht funktionierte. Das Einzige, was er tun kann, ist, zur Laufzeit etwas dagegen zu unternehmen. Eine Ausnahme zu werfen war nicht gut, weil er es nicht als Ausnahme betrachtet.

Er entschied sich schließlich für die obige Lösung. Diese Lösung besagt im Grunde, dass Sie jede Waffe einstellen können, aber wenn Sie sie abgeben, wenn nicht die richtige Waffe, wäre sie im Wesentlichen nutzlos. Aber es würde keine Ausnahme geworfen.

Ich denke, es ist eine gute Lösung. In einigen Fällen würde ich mich aber auch für das Try-Set-Muster entscheiden.

Die erste verworfene Lösung des Autors bestand darin, die Regeln durch das Typsystem darzustellen. Das Typsystem wird zur Kompilierungszeit ausgewertet. Wenn Sie die Regeln vom Typsystem trennen, werden sie vom Compiler nicht mehr überprüft, sodass nichts einen Entwickler daran hindert, per se einen Fehler zu machen.

Dieses Problem tritt jedoch bei jeder Logik / Modellierung auf, die nicht vom Compiler überprüft wird, und die allgemeine Antwort darauf lautet (Einheits-) Test. Daher benötigt die vom Autor vorgeschlagene Lösung ein starkes Testgeschirr, um Fehler von Entwicklern zu umgehen. Um diesen Punkt zu unterstreichen, dass ein starkes Test-Harness für Fehler erforderlich ist, die nur zur Laufzeit erkannt werden, lesen Sie diesen Artikel von Bruce Eckel, in dem argumentiert wird, dass Sie die starke Typisierung gegen stärkere Tests in dynamischen Sprachen austauschen müssen.

Zusammenfassend lässt sich sagen, dass Entwickler nur durch eine Reihe von (Einheits-) Tests verhindern können, dass alle Regeln eingehalten werden.

Ich habe hier vielleicht eine Subtilität verpasst, bin mir aber nicht sicher, ob das Problem beim Typsystem liegt. Vielleicht ist es mit Konvention in C #.

Sie können diesen Typ beispielsweise vollständig sicher machen, indem Sie den WeaponSetter in schützen Player. Dann fügen setSword(Sword)und setStaff(Staff)zu Warriorund Wizardjeweils diesen Ruf der geschützten Setter.

Auf diese Weise wird die Beziehung Player/ Weaponstatisch überprüft und Code, der sich nicht darum kümmert, kann einfach a verwenden Player, um a zu erhalten Weapon.

Was hindert einen Entwickler daran? Müssen sie sich nur daran erinnern, es nicht zu tun?

Diese Frage ist praktisch dieselbe wie bei einem ziemlich heilig-kriegerischen Thema namens " Wo soll die Validierung erfolgen? " (Höchstwahrscheinlich auch ddd).

Bevor Sie diese Frage beantworten, sollten Sie sich fragen: Welche Art von Regeln möchten Sie befolgen? Sind sie in Stein gemeißelt und definieren die Entität? Führt der Verstoß gegen diese Regeln dazu, dass eine Entität nicht mehr das ist, was sie ist? Wenn ja, fügen Sie diese Regeln neben der Befehlsüberprüfung auch einer Entität hinzu. Wenn ein Entwickler vergisst, den Befehl zu validieren, befinden sich Ihre Entitäten nicht in einem ungültigen Zustand.

Wenn nein, bedeutet dies von Natur aus, dass diese Regeln befehlsspezifisch sind und sich nicht in Domänenentitäten befinden sollten. Ein Verstoß gegen diese Regeln führt zu Aktionen, die nicht hätten ausgeführt werden dürfen, jedoch nicht in einem ungültigen Modellstatus.