Коли перерахунки НЕ кодовим запахом?

Дилема

Я читав багато книг найкращих практик щодо об'єктно-орієнтованих практик, і майже кожна книга, яку я прочитав, мала частину, де вони кажуть, що перерахунки - це запах коду. Я думаю, що вони пропустили ту частину, де вони пояснюють, коли перерахунки дійсні.

Як такий, я шукаю вказівки та / або випадки використання, коли перерахунки НЕ є запахом коду, а насправді є дійсною конструкцією.

Джерела:

"ПОПЕРЕДЖЕННЯ Як правило, перерахунки є кодовими запахами і повинні бути відновлені до поліморфних класів. [8]" Seemann, Mark, Dependency Injection in .Net, 2011, p. 342

[8] Мартін Фаулер та ін., Рефакторинг: Покращення дизайну існуючого коду (Нью-Йорк: Аддісон-Веслі, 1999), 82.

Контекст

Причина моєї дилеми - торговий API. Вони передають мені потік даних Tick, надсилаючи за допомогою цього методу:

void TickPrice(TickType tickType, double value)

де enum TickType { BuyPrice, BuyQuantity, LastPrice, LastQuantity, ... }

Я намагався зробити обгортку навколо цього API, оскільки порушення змін - це спосіб життя цього API. Я хотів відслідковувати значення кожного останнього отриманого типу галочок на моїй обгортці, і я це зробив, використовуючи Словник тиктів:

Dictionary<TickType,double> LastValues

Мені це здавалося правильним використанням перерахунків, якщо вони використовуються як ключі. Але у мене є другі думки, оскільки у мене є місце, де я приймаю рішення на основі цієї колекції, і я не можу придумати спосіб, як я міг би усунути оператор переключення, я міг би використовувати завод, але цей завод все ще матиме переключити заяву кудись. Мені здалося, що я просто переміщую речі, але все одно пахне.

Легко знайти ДОН'Ь переліків, але НД, не так просто, і я би вдячний, якщо люди можуть поділитися своїм досвідом, плюсами і мінусами.

Перегляд точки зору

Деякі рішення та дії базуються на цих, TickTypeі я не можу придумати спосіб усунення тверджень enum / switch. Найчистішим рішенням, про який я можу придумати, є використання фабрики та повернення реалізації на основі TickType. Навіть тоді у мене все ще буде оператор перемикання, який повертає реалізацію інтерфейсу.

Нижче перелічено один із зразкових класів, де я маю сумніви, що я можу неправильно використовувати переписку:

public class ExecutionSimulator
{
  Dictionary<TickType, double> LastReceived;
  void ProcessTick(TickType tickType, double value)
  {
    //Store Last Received TickType value
    LastReceived[tickType] = value;

    //Perform Order matching only on specific TickTypes
    switch(tickType)
    {
      case BidPrice:
      case BidSize:
        MatchSellOrders();
        break;
      case AskPrice:
      case AskSize:
        MatchBuyOrders();
        break;
    }       
  }
}

Переліки призначені для випадків використання, коли ви буквально перерахували кожне можливе значення, яке може прийняти змінна. Колись. Подумайте, як використовувати випадки, такі як дні тижня або місяці року, або налаштувати значення апаратного реєстру. Речі, які одночасно відрізняються високою стійкістю і репрезентативністю простого значення.

Майте на увазі, якщо ви створюєте антикорупційний шар, ви не можете уникнути наявності де-небудь заяви переключення через дизайн, який ви обгортаєте, але якщо ви зробите це правильно, ви можете обмежити його на одному місці і використовувати поліморфізм в інших місцях.

По-перше, кодовий запах не означає, що щось не так. Це означає, що щось може бути не так. enumпахне тим, що його часто зловживають, але це не означає, що вам доведеться їх уникати. Просто ви виявите, що набираєте enum, зупиняєтесь та перевіряєте кращі рішення.

Конкретний випадок, який трапляється найчастіше, - це коли різні переліки відповідають різним типам з різною поведінкою, але однаковий інтерфейс. Наприклад, розмова з різними вікнами, рендеринг різних сторінок тощо. Це набагато природніше реалізується за допомогою поліморфних класів.

У вашому випадку TickType не відповідає різній поведінці. Це різні типи подій або різні властивості поточного стану. Тому я вважаю, що це ідеальне місце для переліків.

При передачі даних переліки не мають запаху коду

IMHO, при передачі даних, використовуючи, enumsщоб вказати, що поле може мати значення з обмеженого (рідко змінюється) набору значень, це добре.

Я вважаю за краще передати довільну stringsабо ints. Рядки можуть спричинити проблеми внаслідок написання та написання великої літери. Ints дозволяють передавати з діапазону значень і мають мало семантики (наприклад , я отримую 3від вашого торгового обслуговування, що ж це значить? LastPrice? LastQuantity? Що - то ще?

Передача об'єктів та використання ієрархій класів не завжди можливі; наприклад, wcf не дозволяє отримуючому кінці розрізняти, який клас був надісланий.

У моєму проекті сервіс використовує ієрархію класів для ефектів операцій, безпосередньо перед передачею через a DataContract об'єкт з ієрархії класів копіюється в об'єкт- unionподібний, який містить enumвказівку типу. Клієнт отримує DataContractі створює об’єкт класу в ієрархії, використовуючи enumзначення для switchта створюючи об'єкт правильного типу.

Інша причина, через яку не хотілося б передавати об'єкти класу, полягає в тому, що для служби може знадобитися зовсім інша поведінка для переданого об'єкта (наприклад LastPrice), ніж клієнт. У такому випадку надсилання класу та його методів небажана.

Чи погані заяви переключення?

ІМХО, а єдиний switch -statement , який викликає різні конструктори в залежності від enumНЕ код запах. Це не обов'язково краще чи гірше інших методів, таких як база відображення на ім'я типу; це залежить від реальної ситуації.

Увімкнувши перемикачі enum всюди - кодовий запах, oop пропонує альтернативи, які часто краще:

• Використовувати об’єкт різних класів ієрархії, які мають переосмислені методи; тобто поліморфізм.
• Використовуйте шаблон відвідувачів, коли класи в ієрархії рідко змінюються і коли (багато) операції повинні бути вільно пов'язані з класами в ієрархії.

що робити, якщо ви перейшли з більш складним типом:

    abstract class TickType
    {
      public abstract string Name {get;}
      public abstract double TickValue {get;}
    }

    class BuyPrice : TickType
    {
      public override string Name { get { return "Buy Price"; } }
      public override double TickValue { get { return 2.35d; } }
    }

    class BuyQuantity : TickType
    {
      public override string Name { get { return "Buy Quantity"; } }
      public override double TickValue { get { return 4.55d; } }
    }
//etcetera

тоді ви можете завантажувати свої типи з відображення або будувати їх самостійно, але головне, що відбувається тут, це те, що ви тримаєтесь за відкритий принцип закриття твердого

TL; DR

Щоб відповісти на запитання, мені зараз важко подумати про те, що час перерахунків не є кодовим запахом на якомусь рівні. Існує певний намір, що вони декларують ефективно (існує чітко обмежена, обмежена кількість можливостей для цього значення), але їх суттєво замкнута природа робить їх архітектурно неповноцінними.

Вибачте, коли я переробляю тонни свого спадкового коду. / зітхання; ^ Д

Але чому?

Досить вдалий огляд, чому це справа від LosTechies тут :

// calculate the service fee
public double CalculateServiceFeeUsingEnum(Account acct)
{
    double totalFee = 0;
    foreach (var service in acct.ServiceEnums) { 

        switch (service)
        {
            case ServiceTypeEnum.ServiceA:
                totalFee += acct.NumOfUsers * 5;
                break;
            case ServiceTypeEnum.ServiceB:
                totalFee += 10;
                break;
        }
    }
    return totalFee;
} 

У цьому все ті ж проблеми, що і в коді вище. У міру того, як додаток стає більшим, шанси мати подібні виписки гілок збільшаться. Крім того, коли ви впроваджуєте більше преміум-послуг, вам доведеться постійно змінювати цей код, що порушує принцип відкритого закриття. Тут є й інші проблеми. Функція обчислення плати за послуги не повинна знати фактичну кількість кожної послуги. Це інформація, яку потрібно капсулювати.

Невеликий бік: перерахунки - це дуже обмежена структура даних. Якщо ви не використовуєте enum для того, що воно є насправді, позначеним цілим числом, вам потрібен клас, щоб справді правильно моделювати абстракцію. Ви можете використовувати дивовижний клас перерахування Джиммі, щоб використовувати класи, щоб також використовувати їх як мітки.

Давайте рефактуємо це для використання поліморфної поведінки. Нам потрібна абстракція, яка дозволить нам містити поведінку, необхідну для обчислення плати за послугу.

public interface ICalculateServiceFee
{
    double CalculateServiceFee(Account acct);
}

...

Тепер ми можемо створити наші конкретні реалізації інтерфейсу та приєднати їх [до] облікового запису.

public class Account{
    public int NumOfUsers{get;set;}
    public ICalculateServiceFee[] Services { get; set; }
} 

public class ServiceA : ICalculateServiceFee
{
    double feePerUser = 5; 

    public double CalculateServiceFee(Account acct)
    {
        return acct.NumOfUsers * feePerUser;
    }
} 

public class ServiceB : ICalculateServiceFee
{
    double serviceFee = 10;
    public double CalculateServiceFee(Account acct)
    {
        return serviceFee;
    }
} 

Ще один випадок впровадження ...

Суть полягає в тому, що якщо у вас поведінка, яка залежить від значень enum, чому б не натомість мати різні реалізації подібного інтерфейсу чи батьківського класу, що забезпечує існування цього значення? У моєму випадку я переглядаю різні повідомлення про помилки на основі кодів статусу REST. Замість...

private static string _getErrorCKey(int statusCode)
{
    string ret;

    switch (statusCode)
    {
        case StatusCodes.Status403Forbidden:
            ret = "BRANCH_UNAUTHORIZED";
            break;

        case StatusCodes.Status422UnprocessableEntity:
            ret = "BRANCH_NOT_FOUND";
            break;

        default:
            ret = "BRANCH_GENERIC_ERROR";
            break;
    }

    return ret;
}

... можливо, я повинен загорнути коди статусу в класи.

public interface IAmStatusResult
{
    int StatusResult { get; }    // Pretend an int's okay for now.
    string ErrorKey { get; }
}

Тоді кожен раз, коли мені потрібен новий тип IAmStatusResult, я кодую його ...

public class UnauthorizedBranchStatusResult : IAmStatusResult
{
    public int StatusResult => 403;
    public string ErrorKey => "BRANCH_UNAUTHORIZED";
}

... і тепер я можу переконатися, що раніше код зрозумів, що він має IAmStatusResultобласть застосування і посилається на нього entity.ErrorKeyзамість більш перекрученого, деденда _getErrorCode(403).

І, що ще важливіше, щоразу, коли я додаю новий тип повернутого значення, для його обробки не потрібно додавати інший код . Whaddya знаю, enumі switch, ймовірно, код пахне.

Прибуток.

Чи буде використання enum запахом коду чи ні, залежить від контексту. Я думаю, ви можете отримати кілька ідей для відповіді на своє запитання, якщо врахувати проблему з виразом . Отже, у вас є колекція різних типів і набір операцій над ними, і вам потрібно впорядкувати свій код. Є два простих варіанти:

• Впорядкуйте код відповідно до операцій. У цьому випадку ви можете використовувати перерахування для тегів різних типів і мати оператор перемикання в кожній процедурі, що використовує марковані дані.
• Впорядкуйте код відповідно до типів даних. У цьому випадку ви можете замінити перерахування інтерфейсом і використовувати клас для кожного елемента перерахування. Потім ви реалізуєте кожну операцію як метод у кожному класі.

Яке рішення краще?

Якщо, як зазначав Карл Білефельдт, ваші типи виправлені, і ви очікуєте, що система зростатиме головним чином шляхом додавання нових операцій над цими типами, то використання enum та наявність перемикача є кращим рішенням: кожен раз, коли вам потрібна нова операція, ви просто реалізуйте нову процедуру, тоді як, використовуючи класи, вам доведеться додати метод до кожного класу.

З іншого боку, якщо ви розраховуєте на досить стабільний набір операцій, але ви думаєте, що вам доведеться додавати більше типів даних у часі, зручніше використовувати об'єктно-орієнтоване рішення: оскільки нові типи даних потрібно впроваджувати, ви просто продовжуйте додавати нові класи, реалізуючи той самий інтерфейс, тоді як якщо ви використовуєте enum, вам доведеться оновлювати всі оператори переключення у всіх процедурах, що використовують enum.

Якщо ви не можете класифікувати свою проблему в жодному з двох вищезазначених варіантів, ви можете переглянути більш складні рішення (див., Наприклад, знову сторінку Вікіпедії цитовану вище для короткого обговорення та деякої посилання для подальшого читання).

Отже, ви повинні спробувати зрозуміти, в якому напрямку може розвиватися ваша заявка, а потім вибрати відповідне рішення.

Оскільки книги, про які ви посилаєтеся, мають справу з об'єктно-орієнтованою парадигмою, не дивно, що вони упереджено застосовують переписки. Однак рішення об'єктно-орієнтоване не завжди є найкращим варіантом.

Підсумок: перерахунки - це не обов'язково кодовий запах.