C#の依存性の注入ができているかわからない

Question

このコードですが、インターフェースを使って依存性逆転の法則を守ろうと（？）しています。
このコードのMain（）内で、プロパティに名前や攻撃力を代入してしまっているのですが、ここでも　new の後にインターフェース等（？）を使わないと依存性の注入ができていないということでしょうか？それともこの時点で注入は十分にされてると思いますか？
ご意見をください。
ちなみに私はインタフェースや依存性などを全然理解できていなく勉強中なので、トンチンカンな質問でしたらすみません。

interface IEnemies{
            string Name{ get; set; }
            int HP { get; set; }
        }
        interface IBullets{
            string Name { get; set; }
            int AttackPoint { get; set; }
        }
        interface IHIT{
            int HIT(string Name, int HP, int AttackPoint);
        }
        public class Player{
            public class Bullet : IBullets{
                public string Name { get; set; }
                public int AttackPoint { get; set; }
                public Bullet(string name, int attackpoint){
                    this.Name = name;
                    this.AttackPoint = attackpoint;
                }
                public class BulletHit : IHIT{
                    public int HIT(string Name,int HP,int AttackPoint){
                    HP -= AttackPoint;
                    Console.WriteLine("プレイヤーの弾が{0}に当たりました",Name);
                    return HP;
                    }
                }
            }//Bullet
        }//Player
        public class Enemy : IEnemies{
            public string Name{ get; set; }
            public int HP { get; set; }

            public Enemy(string name,int hp){
            this.Name = name;
            this.HP = hp;
            }

        }
        public class Boss : IEnemies{
            public string Name{ get; set; }
            public int HP { get; set; }

            public Boss(string name, int hp){
                this.Name = name;
                this.HP = hp;
            }
        }
        public class Test{
            public static void Main(){
            IBullets B1 = new Player.Bullet("普通の弾",25);
            IEnemies E1 = new Enemy("エネミー１",200);
            IEnemies BOS1 = new Boss("１面のボス", 500);
            IHIT IHIT = new Player.Bullet.BulletHit();

            Console.WriteLine("{0}のHPは{1}, 弾の攻撃力は{2}",E1.Name,E1.HP,B1.AttackPoint);
            E1.HP = IHIT.HIT(E1.Name,E1.HP,B1.AttackPoint);
            Console.WriteLine("{0}の残りHPは{1}",E1.Name ,E1.HP);
            
            Console.WriteLine("{0}のHPは{1}, 弾の攻撃力は{2}",BOS1.Name,BOS1.HP,B1.AttackPoint);
            BOS1.HP = IHIT.HIT(BOS1.Name,BOS1.HP,B1.AttackPoint);
            Console.WriteLine("{0}の残りHPは{1}",BOS1.Name ,BOS1.HP);
            BOS1.HP = IHIT.HIT(BOS1.Name,BOS1.HP,B1.AttackPoint);
            Console.WriteLine("{0}の残りHPは{1}",BOS1.Name ,BOS1.HP);
            }
        }

また、例えばクラスの内部にクラスを作るのはやめた方がいいよ！とか、クラスの上下関係など、アドバイス等あると助かります。
抽象的な質問ですみません。よろしくお願いします。

Comments

[Zuishin]

> ちなみに私はインタフェースや依存性などを全然理解できていなく勉強中なので、トンチンカンな質問でしたらすみません。

それを理解するのが先でしょう。
でなければ説明されてもわからないのでは？

[tom_honmono]

すみません。少しは理解したつもりなので、聞きました。とんちんかんな質問だったらすみませんという意味の文です。

[Zuishin]

このコードのどの辺が依存性の注入になっているのか全くわかりません。
まったくできていないと思います。
依存性の注入をどのように理解しているのかを質問を編集して説明すれば、間違っているところを正してもらえるかもしれません。

[tom_honmono]

わかりました。ご指摘ありがとうございます。

Answer 1

すでに解決済みですが、回答を途中まで書いていたので残します。

インターフェースを使って依存性逆転の法則を守ったり依存性の注入をしたりすることと、内部クラスを持つことは切り離して考えましょう。（そもそも内部クラスが必要になる場面は多くありません）

そもそも、インターフェースを使ったり、依存性逆転の法則、依存性の注入をしたりすることの目的は整理できているでしょうか。1つは、機能追加・修正をしやすいコードを書くためです。

命名を見直す

機能追加・修正をしやすいコードを書くためには、まずはクラスやプロパティ・メソッドに適切な名前をつけることです。

IEnemies,IBulletsという名前は、単数形ではなく複数形です。ですが、それ等が持つプロパティは明らかに単数形です。この時点で名前が名前の役割を果たしていないので、機能追加・修正をしにくいコードになっています。

interface IEnemy{
    string Name{ get; }
    int HitPoint { get; set; }
}
interface IBullet{
    int AttackPoint { get; }
}

IHITもインタフェースで使う名前としては不適切です。なぜならHitとは物ではなく振る舞いを示すものだからです。

そしてHitとは、プレイヤーが敵にダメージを与えることを指しているのか、プレイヤーが敵からのダメージを受けることを指しているのかが名前からわかりません。

Hitとは、受動態であってもなくとも英語のスペルはHitのままなので、私ならその動詞は使わないと思います。
もしHitが「プレイヤーが敵にダメージを与えること」を指しているのであれば、プレイヤーにHit相当のメソッドをもたせると思います。もしくはIShootableのようなインタフェースを作り、Playerクラスに実装するかもしれません。

依存性の注入

依存性の注入を使うメリットは外部で作成したインスタンスを取得し、利用できることです。
PlayerクラスがIBullet型のプロパティを持つことにより、特定のBulletクラスに依存しないコードを書けます。

PlayerのコンストラクタにIBulletを含めないと下記のように内部でインスタンスを抱える必要があります。

public class Player
{
    public IBullet Bullet { get; } = new LeadBullet();


    public void ShootBullet(IEnemy target)
    {
        target.GetShotBy(Bullet);
    }
}

しかし、このコードの問題点は、PlayerクラスがSilverBulletなど別の弾丸を持ちたいときに問題があります。

この場合はPlayerのコンストラクタを作成し、IBullet型のインスタンスを引数に含め、Bulletプロパティを初期化することでLeadBulletに依存しなくなります。

適応例

下記はIHITを削除し、インタフェースに定義するものを整理し、依存性の注入を使ったコードです。

interface IEnemy
{
    string Name{ get; }
    int HitPoint { get; set; }
    void GetShotBy(IBullet bullet);
}

interface IBullet
{
    int AttackPoint { get; }
}

public class Player
{
    public IBullet Bullet { get; }

    // これが依存性の注入（DI）
    public Player(IBullet bullet)
    {
        Bullet = bullet;
    }

    public void ShootBullet(IEnemy target)
    {
        target.GetShotBy(Bullet);
    }
}

public class Gang : IEnemy
{
    public string Name { get; } = "ギャング";
    public int HitPoint { get; set; } = 8;
    public void GetShotBy(IBullet bullet)
    {
        HitPoint -= bullet.AttackPoint;
    }
}

public class Dracula : IEnemy
{
    public string Name { get; } = "ドラキュラ";
    public int HitPoint { get; set; } = 16;
    public void GetShotBy(IBullet bullet)
    {
        if(bullet is SilverBullet)
        {
            HitPoint -= bullet.AttackPoint * 10;
        }
    }
}

public class LeadBullet : IBullet
{
    public int AttackPoint { get; } = 6;
}

public class SilverBullet : IBullet
{
    public int AttackPoint { get; } = 4;
}

public class DependencyInjectionTest{
    public static void Main(){
        var gang = new Gang();
        var dracula = new Dracula();

        var leadBullet = new LeadBullet();
        var agent = new Player(leadBullet);

        //ギャングは鉛玉2発で倒せるが
        agent.ShootBullet(gang);
        agent.ShootBullet(gang);
        DebugEnemyIsDead(gang);

        //ドラキュラは倒せない
        agent.ShootBullet(dracula);
        agent.ShootBullet(dracula);
        DebugEnemyIsDead(dracula);

        var silverBullet = new SilverBullet();
        var draculaHunter = new Player(silverBullet);

        //銀の弾丸なら1発でドラキュラを倒せる
        draculaHunter.ShootBullet(dracula);
        DebugEnemyIsDead(dracula);
    }

    public static void DebugEnemyIsDead(IEnemy target) => 
        Console.WriteLine($"{target.Name}は{(target.HitPoint > 0 ? "死なない" : "死ぬ" )}");  
    
}

内部クラスはまったく使っていないことを確認してください。クラスの上下関係はこの場合インスタンスを作成しているDependencyInjectionTestクラスが上位です。他は等しく下位です。

依存性逆転の法則はそもそもレイヤーを分けて開発をするときに意識するものです。レイヤーを意識した設計を行ってから考えましょう。そのため依存性逆転の法則に関しての説明は省きます。

Comments

[tom_honmono]

ありがとうございます。自分の作りたかったものの答えの例をいただけたことで、学習が捗りそうです。ありがとうございました。

[BluOxy]

コードはあくまでDIや命名の整理方法の参考程度にお願いします。
というのも、このコードが絶対に正しいものではないということをお伝えしたいからです。

例えば、このコードの場合はPlayerはインタフェースを継承しておらず、差し替え不可です。
例えば、このコードの場合は各Bulletの攻撃力、各Enemyクラスの名称・体力は直接保持しているため、データベースなどからそれ等の値を持っていき初期化することはできません。

コードを抽象化するにも、適切な抽象化とそうではない抽象化（ただ実装が複雑になる抽象化）があるので、上手にインターフェースや依存性の注入は使いましょう。

Answer 2

.NET Core アプリでは Microsoft の Microsoft.Extensions.DependencyInjection 名前空間にあるクラス類を使って Dependency Injection (DI) 機能を実装できるので、自分でやってみてはいかがですか？

コンソールアプリでも以下のようにしてできます。

.NET Core での Dependency Injection
http://surferonwww.info/BlogEngine/post/2021/01/01/dependency-injection-for-dotnet-core-application.aspx

基本的には、あるクラスが依存するオブジェクトを、そのクラスを初期化する際に、オブジェクトを生成してそのクラスのコンストラクターの引数に渡してやるという感じです。

コンストラクタの引数にインターフェイスを使うのは DI に必須という訳ではなく、オブジェクトを差し替えることができるなどの便宜を図るためと思います。

Comments

[tom_honmono]

丁寧にありがとうございます。そこから勉強してみます。