Лучший подход к программированию очень сложных бизнес / математических правил

Распространенный способ избежать больших коммутационных структур - поместить информацию в структуры данных. Создайте перечисление SportType и Dictionary<SportType, Int32>, содержащее связанные значения. Вы можете просто написать val += sportTypeScoreMap[sportType], и все готово.

Вариации этого рисунка помогут вам во многих подобных ситуациях.

public enum SportType
{
    Soccer, Football, ...
}

public sealed class Foo
{
    private static readonly IDictionary<SportType, Int32> sportTypeScoreMap =
        new Dictionary<SportType, Int32>
        {
            { Soccer, 30 },
            { Football, 20 },
            ...
        }

    private static readonly IDictionary<DayOfWeek, Int32> dayOfWeekScoreMap =
        new Dictionary<DayOfWeek, Int32>
        {
            { DayOfWeek.Monday, 12 },
            { DayOfWeek.Tuesday, 20 },
            ...
        }

    public Int32 GetScore(SportType sportType, DayOfWeek dayOfWeek)
    {
        return Foo.sportTypeScoreMap[sportType]
             + Foo.dayOfWeekScoreMap[dayOfWeek];
    }
}

Используйте оператор switch или функцию фильтрации.

Под функцией фильтра я имею в виду что-то вроде:

func filter(var object, var value)
{
    if(object == value)
        object = valueDictionary['value'];
}

Затем примените фильтр с:

filter(theObject, soccer)
filter(theObject, football)

Обратите внимание, что фильтр работает намного лучше со словарем, но это не обязательно.

Взяв за основу «Прагматичный программист», вы можете использовать DSL для инкапсуляции правил и написания механизма процесса. Для представленной проблемы решение может выглядеть так:

MATCH{
    Soccer   soccerBaseVal

    IsMale   5
    !IsMale  1
}

SWITCH{
    Monday   12
    Tuesday  13
}

Затем сопоставьте все в первом столбце MATCH и первом элементе каждого SWITCH, к которому вы придете. Вы можете создать любой синтаксис, который вам нравится, а затем просто написать немного скрипта, чтобы втиснуть его в код (или использовать Xtext, потому что он выглядит довольно круто).

Вот несколько идей:

1 Используйте таблицы поиска:

var val = 0;

SportType sportType = GetSportType();

val += sportvalues[sportType];

Вы можете загрузить таблицу из базы данных.

2 Используйте заводской узор:

var val = 0;

val += SportFactory.Create(sportType).CalculateValue();

Dynamic Factory Pattern полезен в новых ситуациях (спорт ) типы часто добавляются в код. Этот шаблон использует отражение, чтобы предотвратить изменение фабричного класса (или любой глобальной конфигурации). Это позволяет вам просто добавить новый класс в ваш код.

Конечно, использование динамической фабрики или даже фабрики может быть излишним в вашей ситуации. Ты единственный, кто может сказать.

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

EnforceSportRules
ProcessSportDetails
EnforceGenderRules 

Затем, в зависимости от того, насколько сложны правила, я могу разбить каждый раздел на отдельный класс и обработать их основным классом (например, фабрикой).

GenderRules
GenderContext

У меня нет ничего особенного, чтобы предложить вам, кроме как сначала рекомендовать не оставлять его просто большим блоком - разбейте его на разделы, сделайте разделители комментариев между важными частями.

Другое предложение: если у вас будет много очень коротких тестов, как в вашем примере, отойдите от соглашения и поместите инкременторы val в одну строку с оценкой и отступом, чтобы они совпадали друг с другом.

if (isSoccer)              val = soccerBaseVal;  
if (isMale)                val += 1; 
else                       val += 5; 

switch(dayOfWeek){ 
    case DayOfWeek.Monday: val += 12; 
    ... 
}  

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

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

enum Sport
{
    football = 0,
    soccer   = 1,
    //...
}

int sportValues[] = { 
    /* footballValue */,
    /* soccerValue */,
    /* ...Values */
};

int ApplyRules(Sport sport, /* other params */)
{
    int value = startingValue;
    value += sportValues[(int)sport];
    value += /* other rules in same fashion */;
}

Рассмотрите возможность реализации шаблона стратегии, который использует наследование / полиморфизм, чтобы сделать управление отдельными функциями разумным. Разделив каждую функцию на отдельный выделенный класс, вы можете избавиться от кошмара, связанного с наличием длинных case блоков или if операторов.

Не уверен, поддерживает ли C # это еще (или когда-либо будет), но VB.NET интегрирует XML-комментарий CompletionList в intellisense, которые в сочетании с шаблоном стратегии могут дать вам простоту использования Enum с неограниченной расширяемостью OO.