Укоротить длинный корпус переключателя

Question

Итак, позвольте мне начать с того, что я новичок в C #.У меня есть оператор switch, который в настоящее время имеет 10 разных случаев, однако мне нужно использовать его 3 раза (одинаковые 10 случаев, разные результаты для каждого случая), и в каждом случае есть только небольшое изменение.

Iмне кажется, что я просто повторяю код, есть ли способ сократить его?

//Set the growth time of the crop based on what cropType.
        switch (cropType) {
            case 1:
                //Potatoes
                growth = 60;
                break;
            case 2:
                //Strawberries
                growth = 80;
                break;
            case 3:
                //Cabbages
                growth = 90;
                break;
            case 4:
                //Carrots
                growth = 40;
                break;
            case 5:
                //Melon
                growth = 120;
                break;
            case 6:
                //Pumpkin
                growth = 130;
                break;
            case 7:
                //Eggplant
                growth = 50;
                break;
            case 8:
                //Mushroom
                growth = 70;
                break;
            case 9:
                //Wheat
                growth = 40;
                break;
            case 10:
                //Truffle
                growth = 150;
                break;
        }

Это мой код для 1 раздела.Во 2-м разделе я назначаю изображение в зависимости от случая, это должно быть сделано отдельно, так как оно зависит от роста и изменений, тогда как рост - нет.Я на самом деле не использую это на других swithces все же.Это еще один вопрос, который я описал ниже:

switch (cropType) {
            case 1:
                //Potatoes
                Debug.Log("Potatoes Harvested!");
                Global.potato += 2;
                break;
            case 2:
                //Strawberries
                Debug.Log("Strawberries Harvested!");
                Global.strawberry += 4;
                break;
            case 3:
                //Cabbages
                Debug.Log("Cabbages Harvested!");
                Global.cabbage += 1;
                break;
            case 4:
                //Carrots
                Debug.Log("Carrots Harvested!");
                Global.carrot += 3;
                break;
            case 5:
                //Melon
                Debug.Log("Melons Harvested!");
                Global.melon += 1;
                break;
            case 6:
                //Pumpkin
                Debug.Log("Pumpkins Harvested!");
                Global.pumpkin += 1;
                break;
            case 7:
                //Eggplant
                Debug.Log("Eggplant Harvested!");
                Global.eggplant += 2;
                break;
            case 8:
                //Mushroom
                Debug.Log("Mushrooms Harvested!");
                Global.mushroom += 4;
                break;
            case 9:
                //Wheat
                Debug.Log("Wheat Harvested!");
                Global.wheat += 6;
                break;
            case 10:
                //Truffle
                Debug.Log("Truffles Harvested!");
                Global.truffle += 1;
                break;
        }

По сути, это скрипт, который должен делать разные вещи в зависимости от того, что в нем есть cropType.

Answer 1

Может быть, это будет слишком много, но вы можете использовать перечисления и классы / структуры плюс словарь (как предложил Ггорлен)

Почему перечисления?избегать использования жестко закодированных номеров;меньше подвержен ошибкам и улучшит читабельность;

private enum CropType
{
    Undefined = 0,
    Cabbages,
    Carrots,
    Eggplant,
    Melon,
    Mushroom,
    Potatoes,
    Pumpkin,
    Strawberries,
    Truffle,
    Wheat
}

private struct Crop
{
    public CropType Type { get; private set; }
    public float GrowthFactor { get; private set; }
    public float HarvestFactor { get; private set; }

    public Crop(CropType type, float growthFactor, float harvestFactor) 
    {
        this.Type = type;
        this.GrowthFactor = growthFactor;
        this.HarvestFactor = harvestFactor;
    }
}

private Dictionary<CropType, Crop> crops;
private Dictionary<CropType, Crop> Crops 
{
    get 
    {
        if (crops == null) 
        {
            crops = new Dictionary<CropType, Crop>() 
            {
                { CropType.Cabbages, new Crop(CropType.Cabbages, 90, 1) },
                { CropType.Carrots, new Crop(CropType.Carrots, 80, 5) }
                // here you can add the rest of your products...
            };
        }
        return crops;
    }
}

public Crop GetCrop(CropType crop) 
{
    if (!Crops.ContainsKey(type)) 
    {
        Debug.LogWarningFormat("GetCrop; CropType [{0}] not present in dictionary ", type);
        return null;
    }

    return Crops[type];
}

Вот где (наконец) вы получите нужные значения.

public float GetGrowthFactor(CropType type) 
{
    var crop = GetCrop(type);
    return crop == null ? default(float) : crop.GrowthFactor;
}

public float GetHarvestFactor(CropType type) 
{
    var crop = GetCrop(type);
    return crop == null ? default(float) : crop.HarvestFactor;
}

Таким образом, вы будете запрашивать значения таким образом;

private void Example()
{
    var carrotsGrowth = GetGrowthFactor(CropType.Carrots);
}

Answer 2

С точки зрения упрощения оператора switch, я думаю, что Dictionary (если ключи не были последовательными целыми числами), перечисление или List (для чего-то вроде 1-10, как здесь имеет место) уместноСоздание сопоставленного отношения между числами:

int[] growth = {0, 60, 80, 90, 40, 120, 130, 50, 70, 40, 150};
int cropType = 5; // for example
Console.WriteLine(growth[cropType]); // 120

Вот пример словаря, который, я думаю, более понятен для людей:

Dictionary<string, int> growth = new Dictionary<string, int>()
{
    {"Potatoes", 60}, 
    {"Strawberries", 80}, 
    {"Cabbages", 90}, 
    {"Carrots", 40}, 
    {"Melon", 120}, 
    {"Pumpkin", 130}, 
    {"Eggplant", 50}, 
    {"Mushroom", 70}, 
    {"Wheat", 70}, 
    {"Truffle", 150} 
};

Console.WriteLine(growth["Melon"]);

Однако, увидев ваше второе switch утверждениеПохоже, что ваши громоздкие switch признаки являются более серьезной проблемой дизайна.Вы можете подумать о добавлении класса Crop, который имеет поля-члены для всех свойств, которыми вы манипулируете, например, type и growth (и любых других свойств или функций, которые описывают Crop -ness).

С точки зрения Global вы можете рассмотреть второй класс, который объединяет Crop с, например, класс Harvest со словарем, который отслеживает, сколько урожая каждого урожая было собрано.

Короче говоря, эти вопросы о дизайне могут стать довольно размытыми и основанными на мнениях, но, надеюсь, это даст некоторые идеи для продвижения вперед.