[C#]文字列による処理の振り分けをswitchでなくスマートに書きたい

Question

文字列によって処理を振り分けたいのですが、switch分で書くとコードが長くなってしまいます。
コードをスマートにするにはどのようにすれば良いでしょうか。

実装したい機能

キャラクターの動作をシミュレートするアプリケーション。(のようなもの）

データベースで以下のようなテーブルがあり、それらを計算しキャラクターの挙動を変化させる。

キー(string)	値(float)
WalkSpeed	+10
WalkSpeed	+20
WalkSpeed	-10
AttackSpeed	+5
AttackSpeed	+10
IsPoison	1

// テーブルの各行
public class DataUnit {
    string Key { get; set; }
    float Value { get; set; }

    public DataUnit(string key, float value) {
        Key = key;
        Value = value;
    }
}

public class Chara {
    float walkSpeed = 0f;
    float attackSpeed = 0f;
    bool isPoison = false;

    void TestFunc() {
        List<DataUnit> dataUnits = new List<DataUnit>();

        // データベースからテーブルデータをdataUnitsへ保存（下記はデバッグ用にデータを生成）
        dataUnits.Add(new DataUnit("WalkSpeed", 10.0f));
        dataUnits.Add(new DataUnit("AttackSpeed", -20.0f));
        dataUnits.Add(new DataUnit("IsPoison", 1f));
        dataUnits.Add(new DataUnit("WalkSpeed", 12f));
        dataUnits.Add(new DataUnit("AttackSpeed", 5f));

        foreach(var unit in dataUnits) {
            // Key毎にTestクラスの別々の変数をいじりたい
            swicth (unit.Key) {
                case "walkSpeed"
                    walkSpeed += unit.Value;
                    break;

                case "attackSpeed"
                    attackSpeed += unit.Value;
                    break;

                case "isPoison"
                    isPoison |= unit.Value > 0f ? true : false;
                    break;
                
                // フィールドは増える予定
            }
        }
    }

    void Update() {
        // キャラクターの動作に反映
    }
}

Comments

[BluOxy]

fieldAとfieldBは同じ処理をしていますが、何か共通点はあるのでしょうか。
それとも、処理がたまたま同じなだけでしょうか。

[BluOxy]

また、fieldA,fieldB,fieldCを初期化するのにdataUnitsは一見不必要に思います。

[hinatahinata]

質問ありがとうございます。
キー"fieldA"の場合は変数fieldAをいじる、
キー"fieldB"の場合は変数fieldBをいじる、
というように処理対象が変わります。

また、処理自体もキー毎に変わります。
質問を編集しました。

[BluOxy]

fieldA,fieldB,fieldCという変数名を用いていますが、命名が抽象的すぎて、何に使われるか分からないことがスマートさを欠いている原因と思います。

完全に使い道が別物なら、それぞれをオブジェクトとして表現するのが良さそうです。

[BeatStar]

swichのエリアを簡略化したいっていうことですよね?
無いと思いますよ。
どうしてもクラスを組むかメソッドを組むか、そのままべた書きかっていう違いだけなので。

Answer 1

各fieldがどういう値を持つのかを明確にするため、下記ケースを想定してサンプルを作りました。

• アクションゲームを作ることを想定
• 攻撃を受けたときの振る舞いを各オブジェクトに持たせたい

---

まずは同一の振る舞いを持ったオブジェクトを複数定義するためにインターフェースを定義します。

public interface IHitable{
    void ReceiveDamage(int damage);
}

次に、その振る舞いを持つオブジェクトを定義します。
イメージでは、Bair.HitPointが元fieldA、Dog.HitPointが元fieldB、OldMan.IsDeadが元fieldCに相当します。

public class Bair : IHitable{
    private int HitPoint = 300;
    public void ReceiveDamage(int damage){
        HitPoint -= damage / 2;
    }
}

public class Dog : IHitable{
    private int HitPoint = 150;
    public void ReceiveDamage(int damage){
        HitPoint -= damage;
    }
}

public class Oldman : IHitable{
    private bool IsDead;
    public void ReceiveDamage(int damage){
        IsDead = damage > 5;
    }
}

最後に、IHitableなオブジェクトをリストに保持するようにし、ポリモーフィズムを利用して各要素が持つReceiveDamageメソッドを呼び出してください。
これで、各オブジェクトのメンバーが保持している値を変更できるようになります。

ちなみに、hitablesからDataUnitのキーに対応する要素を探すためにリフレクションという機能を使っています。恐らく、内容と工夫次第でリフレクションを使う必要もなくなりそうです。

public class Test{
    List<IHitable> hitables = new List<IHitable>();

    void TestFunc(){
        hitables.Add(new Bair());
        hitables.Add(new Dog());
        hitables.Add(new OldMan());

        List<DataUnit> dataUnits = new List<DataUnit>();
        dataUnits.Add(new DataUnit("Bair", 20));
        dataUnits.Add(new DataUnit("Dog", 1));
        dataUnits.Add(new DataUnit("Oldman", 10));

        foreach(var unit in dataUnits){
            var hitable = hitables.First(x => x.GetType().Name == unit.Key);
            hitable.ReceiveDamage(unit.Value);
        }
    }
}

また、掲示されたコードでは、そもそもDataUnitsを使う必要性が分かりませんでした。
下記のような書き方でも良さそうに思います。

public class Test{
    List<IHitable> hitables = new List<IHitable>();

    void TestFunc(){
        var bair = new Bair();
        bair.ReceiveDamage(20);
        var dog = new Dog();
        dog.ReceiveDamage(1);
        var oldMan = new OldMan();
        oldMan.ReceiveDamage(10);

        hitables.Add(new Bair());
        hitables.Add(new Dog());
        hitables.Add(new OldMan());
    }
}

スマートさを出すために検討すべきこと

fieldA,fieldB,fieldCの違いを明確にしてください。
おそらく配列やコレクションで持つ方が望ましいかもしれません。

また、DataUnitsの役割を明確にしてください。
もし定義する必要性がない、もしくはDataUnitsを使うことで却って煩雑になるようなら別の実装方法を検討したほうが良いかもしれません。

パターンを増やす場合

1. IHitableを実装した新しいクラスを定義
2. そのクラス内のReceiveDamageメソッドに独自の処理を追加
3. hitablesに新しく追加したクラスのインスタンスをAddする

これで、hitablesを列挙したときに新しく追加したインスタンスのメソッドが呼ばれるようになります。

---

掲示されたコードだとこうなりそうです。
Updateという名前が抽象的ですが、これ以上の具体的な命名は難しそうです。

public interface IAbility{
    void Update(float value);
}

public class Walk : IAbility{
    private float speed = 0f;
    public void Update(float value){
        speed += value;
    }
}

public class Attack : IAbility{
    private float speed = 0f;
    public void Update(float value){
        speed += value;
    }
}

public class Health : IAbility{
    private Condition condition = Condition.None;
    public void Update(float value){
        condition = value > 0f ? Condition.Poison : Condition.None;
    }
}

public enum Condition{
    None,
    Poison,
    Burning,
    Palsy
}

public class Chara {
    List<IAbility> abilities = new List<IAbility>();

    public Chara()
    {
        abilities.Add(new Walk());
        abilities.Add(new Attack());
        abilities.Add(new Health());
    }

    void TestFunc() {
        List<DataUnit> dataUnits = new List<DataUnit>();

        // データベースからテーブルデータをdataUnitsへ保存（下記はデバッグ用にデータを生成）
        dataUnits.Add(new DataUnit("Walk", 10.0f));
        dataUnits.Add(new DataUnit("Attack", -20.0f));
        dataUnits.Add(new DataUnit("Health", 1f));
        dataUnits.Add(new DataUnit("Walk", 12f));
        dataUnits.Add(new DataUnit("Attack", 5f));

        foreach(var unit in dataUnits) {
            var ability = abilities.First(x => x.GetType().Name == unit.Key);
            ability.Update(unit.Value);
        }
    }
}

Comments

[hinatahinata]

回答ありがとうございます。
実装したい機能がわかりづらく申し訳ありませんでした。
ポリモーフィズムを利用しての実装、勉強になりました。

Answer 2

DataUnit側に

public class DataUnit
{
   public DoSomethingTo( Test tgt )
   {
      tgtに何かする
   }
}

みたいなメソッドを書いてやるような方向性はどうでしょうか．

↑では，わかりやすいように DoSomethingTo()の引数の型を Test としましたが，そこらへんは何か適当なinterfaceにでもしておけば良いかも．

Comments

[hinatahinata]

回答ありがとうございます。
Keyによって処理内容も変更したいので別のかたをベストアンサーとさせていただきました。