Sihirbazlarda ve Savaşçılarda Kuralların Aşılması

Bu blog gönderileri dizisinde Eric Lippert, sihirbazları ve savaşçıları kullanarak nesne odaklı tasarımda bir sorunu şöyle açıklıyor:

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 { }

ve sonra birkaç kural ekler:

• Bir savaşçı sadece kılıç kullanabilir.
• Bir sihirbaz yalnızca bir personel kullanabilir.

Daha sonra, C # tipi sistemi kullanarak bu kuralları uygulamaya çalıştığınızda karşılaştığınız sorunları göstermeye devam eder (örneğin Wizard, bir sihirbazın yalnızca bir personel kullanabileceğinden emin olmak için sınıfı sorumlu tutmak ). Liskov İkame İlkesini ihlal edersiniz, çalışma zamanı istisnalarını riske eder veya uzatılması zor olan kodlarla sonuçlanırsınız.

Ortaya koyduğu çözüm, Player sınıfı tarafından hiçbir doğrulama yapılmamasıdır. Yalnızca durumu izlemek için kullanılır. Sonra, bir oyuncuya şu silahı vermek yerine:

player.Weapon = new Sword();

durumu Commands ile değiştirilir ve s'ye göre Rule:

... a ve a olmak üzere iki oyun durumu nesnesi alan bir Commandnesne yaparız . Kullanıcı sisteme “bu sihirbaz o kılıcı kullanmalıdır” komutunu verdiğinde, bu komut s dizisi üreten bir s kümesi bağlamında değerlendirilir . Biz bir var bir oyuncu girişimleri silah ellerinde ne zaman, etkisi mevcut silah, eğer varsa, düşürülür ve yeni silah oyuncunun silah haline gelmesi olduğunu söylüyor. Birinci kuralı güçlendiren başka bir kuralımız var, yani bir sihirbaz bir kılıç kullanmaya çalıştığında ilk kuralın etkilerinin geçerli olmadığını söylüyor.WieldPlayerWeaponRuleEffectRule

Bu fikri prensipte seviyorum, ama pratikte nasıl kullanılabileceğiyle ilgili bir endişem var.

Hiçbir şey atlatabilmesini bir geliştirici önlemek gibi görünüyor Commandsve Rulesadece ayarlayarak s Weaponbir üstünde Player. WeaponMülkiyet tarafından erişilebilir olmalıdır Wieldo yapılamaz bu yüzden, komuta private set.

Peki, ne yapar bunu bir geliştirici önlemek? Sadece hatırlamamaları gerekiyor mu?

Blog gönderileri dizisinin yol açtığı argümanın tamamı Beşinci Bölüm'dedir :

C # tipi sistemin, Zindanlar ve Ejderhaların kurallarını kodlamak için yeterli genelliğe sahip olacak şekilde tasarlandığına inanmak için hiçbir nedenimiz yok, neden çalışıyoruz?

“Sistemin kurallarını ifade eden kod nereye gidiyor?” Sorununu çözdük. Oyun durumunu temsil eden nesnelere değil, sistemin kurallarını temsil eden nesnelere gider; devlet nesnelerinin endişesi, oyunun kurallarını değerlendirirken değil, devletlerini tutarlı tutmaktır.

Silahlar, karakterler, canavarlar ve diğer oyun nesneleri ne yapabileceklerini veya yapamayacaklarını kontrol etmekten sorumlu değildir. Kural sistemi bundan sorumludur. CommandNesne ya oyun nesnelerle hiçbir şey yapmıyor. Sadece onlarla bir şeyler yapma girişimini temsil ediyor . Kural sistemi daha sonra komutun mümkün olup olmadığını kontrol eder ve kural sistemi, oyun nesneleri üzerinde uygun yöntemleri çağırarak komutu yürütür.

Bir geliştirici , ilk kural sisteminin izin vermediği karakterler ve silahlarla bir şeyler yapan ikinci bir kural sistemi oluşturmak istiyorsa, bunu yapabilirler çünkü C #'da (kötü yansıma kesmek olmadan) bir yöntem çağrısının nereden geldiğini bulamazsınız dan.

Bir geçici çözüm olabilir çalışmak bazı durumlarda kural motoru ile montaj birinde oyun nesneleri (ya da arayüzler) koyarak ve herhangi bir Mutator-yöntemlerini işaretlemek edilir internal. Oyun nesnelerine salt okunur erişime ihtiyaç duyan tüm sistemler farklı bir montajda olur, yani yalnızca publicyöntemlere erişebilirler . Bu, yine de birbirlerinin dahili yöntemlerini çağıran oyun nesnelerinin boşluklarını bırakır. Ancak bunu yapmak bariz bir kod kokusu olacaktır, çünkü oyun nesnesi sınıflarının aptal devlet sahipleri olması gerektiğini kabul ettiniz.

Orijinal kodun bariz sorunu , Nesne Modelleme yerine Veri Modelleme yapıyor olmasıdır . Bağlantılı makalede gerçek iş gereksinimlerinden kesinlikle bahsetmediğini lütfen unutmayın!

Ben gerçek fonksiyonel gereksinimleri almaya çalışarak başlayacaktı. Örneğin: "Herhangi bir oyuncu diğer oyunculara saldırabilir, ...". Buraya:

interface Player {
    void Attack(Player enemy);
}

"Oyuncular saldırıda kullanılan bir silah kullanabilirler, Sihirbazlar bir Personel, Bir Savaşçı Kılıç kullanabilir":

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

"Her silah saldırıya uğrayan düşmana hasar verir". Tamam, şimdi Silah için ortak bir arayüzümüz olmalı:

interface Weapon {
    void dealDamageTo(Player enemy);
}

Ve böylece ... Neden hiçbir var Wield()içinde Player? Çünkü herhangi bir Oyuncunun herhangi bir Silah kullanma zorunluluğu yoktu.

Şunu söyleyebilirim ki, "Herhangi Playerbiri herhangi birini kullanmaya çalışabilirWeapon ." Ancak bu tamamen farklı bir şey olacaktır. Belki de bu şekilde modellenirim:

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

Özet: Gereksinimleri ve yalnızca gereksinimleri modelleyin. Veri modelleme yapmayın, yani oo modelleme değildir.

Bunun bir yolu Wieldkomutu Player. Oyuncu daha sonra Wielduygun kuralları kontrol Weaponeden ve Playerardından kendi Silah alanını ayarlayan komutu veren komutu yürütür . Bu şekilde, Silah alanı özel bir ayarlayıcıya sahip olabilir ve yalnızca Wieldoyuncuya bir komut iletilerek ayarlanabilir .

Hiçbir şey geliştiricinin bunu yapmasını engellemez. Aslında Eric Lippert birçok farklı teknik denedi ama hepsinin zayıflığı vardı. Bu serinin, geliştiriciyi bunu durdurmanın kolay olmadığı ve denediği her şeyin dezavantajları vardı. Sonunda Commandkuralları olan bir nesneyi kullanmanın bir yol olduğuna karar verdi .

Kurallarla, a'nın Weaponözelliğini a Wizardolarak ayarlayabilirsiniz , Swordancak Wizardsilahı (Kılıç) kullanmasını ve saldırmasını istediğinizde herhangi bir etkisi olmaz ve bu nedenle herhangi bir durumu değiştirmez. Aşağıda dediği gibi:

İlk kuralı güçlendiren başka bir kuralımız var, yani bir sihirbaz bir kılıç kullanmaya çalıştığında ilk kuralın etkilerinin geçerli olmadığını söylüyor. Bu durumun etkileri “üzgün bir trombon sesi çıkar, kullanıcı bu dönüş için eylemlerini kaybeder, oyun durumu mutasyona uğramaz

Başka bir deyişle, böyle bir kuralı, typepek çok farklı yol denediği ancak sevmediği ya da çalışmadığı ilişkiler yoluyla uygulayamayız . Bu yüzden yapabileceğimiz tek şey çalışma zamanında bu konuda bir şeyler yapmaktır. İstisna atmak iyi değildi çünkü bunu istisna olarak görmüyor.

Sonunda yukarıdaki çözüme gitmeyi seçti. Bu çözüm temelde herhangi bir silah ayarlayabileceğinizi söylüyor, ancak silahı verdiğinizde, doğru silah olmasa bile, aslında işe yaramaz olurdu. Ancak hiçbir istisna atılmaz.

Bence bu iyi bir çözüm. Bazı durumlarda ben de denemek-set desen gitmek istiyorum.

Yazarın ilk atılan çözümü, kuralları tip sistemi ile temsil etmekti. Tip sistemi derleme zamanında değerlendirilir. Kuralları tür sisteminden ayırırsanız, bunlar artık derleyici tarafından denetlenmez, bu nedenle bir geliştiricinin kendi başına hata yapmasını engelleyen hiçbir şey yoktur.

Ancak bu sorun, derleyici tarafından kontrol edilmeyen her mantık / modellemeyle karşı karşıyadır ve bunun genel cevabı (birim) testidir. Bu nedenle, yazarın önerdiği çözümün, geliştiricilerin hatalarını atlatmak için güçlü bir test kayışına ihtiyacı vardır. Yalnızca çalışma zamanında algılanan hatalar için güçlü bir test koşumuna ihtiyaç duymanın bu noktasını vurgulamak için, dinamik dilde daha güçlü testler için güçlü yazımları değiştirmeniz gerektiğini savunan Bruce Eckel'in bu makalesine bakın.

Sonuç olarak, geliştiricilerin hata yapmasını önleyebilecek tek şey, tüm kurallara uyulduğunu kontrol eden bir dizi (birim) test yapmaktır.

Burada bir inceliği kaçırmış olabilirim, ancak sorunun tip sistemiyle ilgili olduğundan emin değilim. Belki de C # konvansiyonu ile.

Örneğin, Weaponayarlayıcıyı korumalı hale getirerek bu tamamen türü güvenli hale getirebilirsiniz Player. Sonra eklemek setSword(Sword)ve setStaff(Staff)için Warriorve Wizardbu çağrının korumalı ayarlayıcı sırasıyla.

Bu şekilde, Player/ Weaponrelation statik olarak kontrol edilir ve umursamayan kod sadece a Playeralmak için a'yı kullanabilir Weapon.

Peki, bir geliştiricinin bunu yapmasını ne engeller? Sadece hatırlamamaları gerekiyor mu?

Bu soru, " nerede doğrulama yapılır " denilen oldukça kutsal savaş-ish konusuyla aynıdır (büyük olasılıkla ddd'ye de dikkat çeker).

Yani, bu soruyu cevaplamadan önce, kendinize şunu sormalısınız: takip etmek istediğiniz kuralların doğası nedir? Taşa oyulmuşlar ve varlığı tanımlarlar mı? Bu kuralların çiğnenmesi, bir varlığın ne olduğunu bırakmasına neden olur mu? Evetse, bu kuralları komut doğrulamasında tutmanın yanı sıra , bunları bir varlıkta da koyun. Dolayısıyla, bir geliştirici komutu doğrulamayı unutursa, varlıklarınız geçersiz bir durumda olmaz.

Hayır - iyi ise, doğal olarak bu kuralların komuta özgü olduğunu ve alan varlıklarında bulunmaması gerektiğini ima eder. Bu nedenle, bu kuralların ihlali, gerçekleştirilmesine izin verilmemesi gereken, ancak geçersiz model durumunda olmayan bir eylemle sonuçlanır.