关于在 C# 中使用抽象类的困惑

Question

I have a question since I'm new in programming Im really confused about how to implement a best practice solution for the following problem, Its a game logic,here are the possible ways of making points

EnemyA 400,
EnemyB 500,
EnemyC 700,
Coin   200,
FireBall 300

means hitting Coin gives you 200 points and shooting FireBall gives you 300 &...

if you reach 1000 points you will get an extra life, the logic simple but implementing the best practice is not(at least to me)should I use abstract class or Dictionary ?

So far, I used a Dictionary , I read a given file (txt) file which is written (EnemyA,EnemyB,Coin,Coin,Coin,Coin) then I calculate the points:

public int pointCal(IEnumerable<string> enemyType)
{
    var possiblePoints = new Dictionary< EnemisEntity,int>()
    {
        {new EnemisEntity{enemyType="EnemyA"},400 },
        {new EnemisEntity{enemyType="EnemyB" },500 },
        {new EnemisEntity{enemyType="EnemyC"},700 },
        {new EnemisEntity{enemyType="Fireball"},300 },
        {new EnemisEntity{enemyType="Coin"},200 },
    };
    int z=0;
    List<int> myPoints=new List<int> ();         
    foreach (var item in enemyType)
    {
        z = possiblePoints.FirstOrDefault(f => f.Key.enemyType.Equals(item)).Value;
                myPoints.Add(z);
    }
    int finalPonts= g.Sum(s=>Convert.ToInt32(s));
    return finalPonts;
}


  Enemy entity class:

     public  class EnemisEntity
    {
       public string enemyType { get; set; }
       
     }

Answer 1

It depends. Are the enemies different types of objects (with different properties and such)?

Then it might make sense to create an abstract class and child classes.

public abstract class Shootable {
    public int points;
}

public class EnemyA: Shootable {
}

public class EnemyB: Shootable {
}

public class Coin: Shootable {
}

// etc

If all your items are just shootable with one description, then

public class Shootable {
    public int points { get; set; }
    public string enemyType { get; set; }
    public Shootable(int points, string enemyType ){
        this.points = points;
        this.enemyType = enemyType;
    }
}

// then create like
var coin = new Shootable(500, "coin");

If all enemies can be modeled in the same class, then you only need shootable class

Then get the points:

IEnumerble<Shootable> shootableItems = GetShootableFromFile();
var score = shootableItems.Sum(s => s.Points);

You GetShootableFromFile should create one object per file row. So it is a viable situation to create the same objects twice:

// This is a mock to indicate multiple instances of the same class.
public IEnumerble<Shootable> GetShootableFromFile() {
    List<Shootable> shootable = new List<Shootable>();
    shootable.Add(new Shootable(500,"coin"));
    shootable.Add(new Shootable(500,"coin"));
    shootable.Add(new Shootable(500,"coin"));
    shootable.Add(new Shootable(300,"enemyA"));
    shootable.Add(new Shootable(300,"enemyB"));
    // etc
}

Answer 2

To me, this is a question of design. When the only difference between enemies is just the value of points as well as their name it is not a good idea to define a class hierarchy. The only thing different between a EnemyA and a EnemyB class would be just the values contained within each class. So you can use a single common class to hold information for each enemy and process the points.

Below is the simplest working prototype that I could code that implements this design. It relies on two classes. The EnemyEntity class to hold the type of enemy and its points, and a Game class that contains the logic behind scoring and keeping a record of all possible enemies.

public class EnemyEntity
{
    public EnemyEntity(string type, int points)
    {
        Type=type;
        Points=points;
    }

    public string Type { get; }
    public int Points { get; }
}

public class Game
{
    public Game(params (string type, int points)[] values)
    {
        this.Enemies = new List<EnemyEntity>();
        foreach (var (type, points) in values)
        {
            Enemies.Add(new EnemyEntity(type, points));
        }
    }

    public List<EnemyEntity> Enemies { get; }

    public int CalculatePoints(IEnumerable<string> targets)
    {
        int points = 0;
        foreach (var item in targets)
        {
            var target = Enemies.FirstOrDefault((enemy) => enemy.Type.Equals(item));
            if (target!=null)
            {
                points+= target.Points;
            }
        }
        return points;
    }

}


class Program
{
    static void Main(string[] args)
    {
        var game = new Game(
            ("EnemyA", 400),
            ("EnemyB", 500),
            ("EnemyC", 700),
            ("Coin", 200),
            ("FireBall", 300));

        var input = "EnemyA,EnemyB,Coin,Coin,Coin,Coin";
        var targets = input.Split(',');
        var points = game.CalculatePoints(targets);

        Console.WriteLine(points);
        // 1700
    }
}

---

NOTES:

The simplest approach is to use a List<EnemyEntity> and do the lookup with .FirstOrDefault() . I could use a Dictionary<string,EnemyEntity> which would simplify the lookup process. Here is how the Game class would change using a dictionary.

public class Game
{
    public Game(params (string type, int points)[] values)
    {
        this.Enemies = new Dictionary<string, EnemyEntity>();
        foreach (var (type, points) in values)
        {
            Enemies[type] = new EnemyEntity(type, points);
        }
    }

    public Dictionary<string, EnemyEntity> Enemies { get; }

    public int CalculatePoints(IEnumerable<string> targets)
    {
        int points = 0;
        foreach (var item in targets)
        {
            var target = Enemies[item];
            if (target!=null)
            {
                points+= target.Points;
            }
        }
        return points;
    }

}