Повернути магічне значення, викинути виняток або повернути помилкове на помилку?

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

Я думаю, що для такої порівняно невиключної ситуації є три можливі рішення, що свідчать про збій у C # 4:

• повернути магічне значення, яке не має сенсу інакше (наприклад, nullта -1);
• кинути виняток (наприклад KeyNotFoundException);
• повернути falseі надати фактичне значення повернення в outпараметрі (наприклад, Dictionary<,>.TryGetValue).

Тож питання: у якій невиключній ситуації я повинен кинути виняток? І якщо я не повинен кидати: коли повертається магічне значення, яке було зазначено вище, реалізуючи Try*метод з outпараметром ? (Мені outпараметр здається брудним, і його більше працювати правильно.)

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

У бібліотеці базових класів .NET Framework використовуються всі три методи:

• повернути магічне значення, яке не має значення інакше:
  • Collection<T>.IndexOf повертає -1,
  • StreamReader.Read повертає -1,
  • Math.Sqrt повертає NaN,
  • Hashtable.Item повертає нуль;
• киньте виняток:
  • Dictionary<,>.Item кидає KeyNotFoundException,
  • Double.Parseкидає FormatException; або
• повернути falseі надати фактичне значення повернення в outпараметрі:
  • Dictionary<,>.TryGetValue,
  • Double.TryParse.

Зауважте, що як Hashtableстворено в часи, коли в C # не було дженериків, воно використовує objectі тому може повернутися nullяк магічне значення. Але з дженериками винятки використовуються в Dictionary<,>, і спочатку цього не було TryGetValue. Мабуть, розуміння змінюються.

Очевидно, що подвійність Item- TryGetValueі Parse- TryParseє з якоїсь причини, тому я припускаю, що викидання винятків за надзвичайні невдачі в C # 4 не робиться . Однак Try*методи не завжди існували, навіть коли вони Dictionary<,>.Itemіснували.

Я не думаю, що ваші приклади справді рівноцінні. Є три різні групи, кожна з яких має своє обґрунтування своєї поведінки.

1. Магічне значення - це хороший варіант, коли існує умова "до", наприклад, StreamReader.Readабо коли є просте у використанні значення, яке ніколи не буде дійсною відповіддю (-1 для IndexOf).
2. Викиньте виняток, коли семантика функції полягає в тому, що абонент впевнений, що вона буде працювати. У цьому випадку неіснуючий ключ або неправильний подвійний формат справді винятковий.
3. Використовуйте параметр «out» та поверніть bool, якщо семантика має пробувати, чи можлива операція чи ні.

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

NaNПовертається Math.Sqrtє окремим випадком - він відповідає стандарту з плаваючою комою.

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

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

Ось чому, хоч outпараметри іноді нахмурюються, я віддаю перевагу тому методу із Try...синтаксисом. Це канонічний синтаксис .NET і C #. Ви повідомляєте користувачеві API, що вони повинні перевірити повернене значення, перш ніж використовувати результат. Ви також можете включити другий outпараметр із корисним повідомленням про помилку, що знову допомагає при налагодженні. Ось чому я голосую за Try...з outрозчином параметрів.

Ще один варіант - повернути спеціальний об’єкт "результат", хоча я вважаю це набагато більш стомлюючим:

interface IMyResult
{
    bool Success { get; }
    // Only access this if Success is true
    MyOtherClass Result { get; }
    // Only access this if Success is false
    string ErrorMessage { get; }
}

Тоді ваша функція виглядає правильно, оскільки вона має лише вхідні параметри, і вона повертає лише одне. Просто одна річ, яку вона повертає, це вид кортежу.

Насправді, якщо ви займаєтесь подібними речами, ви можете використовувати нові Tuple<>класи, які були введені в .NET 4. Особисто мені не подобається те, що значення кожного поля є менш явним, тому що я не можу дати Item1і Item2корисні назви.

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

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

Коротка відповідь

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

Довга відповідь

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

• Як правило, очікуйте, що викидання винятків відбувається в 200 разів повільніше, ніж звичайне повернення (насправді в цьому є значна різниця).

• Як ще одне головне правило, викидання винятку часто може дозволяти набагато чистіший код порівняно з найсуворішими магічними значеннями, оскільки ви не покладаєтесь на програміста, який переводить код помилки в інший код помилки, оскільки він рухається через кілька шарів коду клієнта до точка, в якій є достатній контекст для її послідовного та адекватного поводження. (Особливий випадок: тут, nullяк правило, краще, ніж за іншими магічними значеннями, через його схильність до автоматичного переведення себе на a NullReferenceExceptionу випадку деяких, але не всіх типів дефектів; зазвичай, але не завжди, досить близько до джерела дефекту. )

То який урок?

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

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

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

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

Ви перераховуєте чудовий приклад Dictionary<,>.Item, який, слабко кажучи, змінився від повернення nullзначень до перекидання KeyNotFoundExceptionміж .NET 1.1 та .NET 2.0 (лише якщо ви готові вважати Hashtable.Itemйого практичним негенеральним попередником). Причина цієї "зміни" тут не без інтересу. Оптимізація ефективності типів значень (не більше боксу) зробила початкове магічне значення ( null) необов'язковим; outПараметри просто повернуть невелику частину вартості продуктивності. Останнє врахування продуктивності є абсолютно незначним порівняно із накладними витратами на кидання KeyNotFoundException, але дизайн винятків тут все ж перевершує. Чому?

• Параметри ref / out несуть свої витрати щоразу, а не лише у випадку "відмови"
• Будь-який, хто дбає, може зателефонувати Containsперед будь-яким викликом до індексатора, і ця модель читається повністю природно. Якщо розробник хоче, але забуває зателефонувати Contains, жодні проблеми з продуктивністю не можуть виникнути; KeyNotFoundExceptionє достатньо гучним, щоб його помітити і зафіксувати.

Що найкраще робити в такій порівняно не винятковій ситуації, щоб вказати на невдачу, і чому?

Не слід допускати невдачі.

Я знаю, це рукотворне та ідеалістичне, але вислухай мене. Виконуючи дизайн, існує ряд випадків, коли у вас є можливість віддати перевагу версії, яка не має режимів відмов. Замість того, щоб знайти «FindAll», який не вдається, LINQ використовує пункт, де просто повертається порожнє число. Замість того, щоб мати об'єкт, який потрібно ініціалізувати перед використанням, дозвольте конструктору ініціалізувати об’єкт (або ініціалізувати, коли виявлено неініціалізований). Ключовим моментом є видалення гілки відмови у споживчому коді. Це проблема, тому зосередьтеся на ній.

Ще одна стратегія цього - KeyNotFoundsscenario. Майже в кожній кодовій базі, над якою я працював з 3.0, існує щось подібне до цього методу розширення:

public static class DictionaryExtensions {
    public static V GetValue<K, V>(this IDictionary<K, V> arg, K key, Func<K,V> ifNotFound) {
        if (!arg.ContainsKey(key)) {
            return ifNotFound(key);
        }

        return arg[key];
    }
}

Реального режиму відмови для цього немає. ConcurrentDictionaryмає подібний GetOrAddвбудований.

Все, що говорили, завжди знайдуться часи, коли це просто неминуче. Усі троє мають своє місце, але я б віддавав перевагу першому варіанту. Незважаючи на все, що складається з нульової небезпеки, воно добре відоме і вписується у безліч сценаріїв "предмет не знайдено" або "результат не застосований", що становить набір "не винятковий збій". Особливо, коли ви створюєте нульові типи значень, значення "це може вийти з ладу" дуже чітко в коді і важко забути / викрутити.

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

Останній варіант - той, який мені все більше не подобається. Вихідні параметри незручні і, як правило, порушують деякі найкращі практики при створенні методів, як, наприклад, фокусування на одній справі та відсутність побічних ефектів. Плюс до цього, парам, як правило, має значення лише під час успіху. Зважаючи на це, вони є важливими для певних операцій, які, як правило, обмежуються проблемами паралельної валюти або міркуваннями щодо ефективності роботи (наприклад, якщо ви не хочете робити другу поїздку до БД).

Якщо значення повернення та параметр не є тривіальними, то перевагу Скотта Вітлока щодо результатного об'єкта є кращим (як Matchклас Regex ).

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

Зверніть увагу, що Parseі TryParseнасправді це одне і те ж, крім режимів відмов Те, що TryParseтакож може повернути значення, є дещо ортогональним, насправді. Розглянемо ситуацію, коли, наприклад, ти перевіряєш деякий вклад. Тебе насправді не цікавить, яке значення має, доки воно дійсне. І немає нічого поганого в тому, щоб запропонувати певну IsValidFor(arguments)функцію. Але це ніколи не може бути основним режимом роботи.

Як зазначали інші, магічне значення (включаючи булеве значення повернення) не є таким чудовим рішенням, хіба що як маркер "кінця діапазону". Причина: семантика не є явною, навіть якщо ви вивчаєте методи об’єкта. Насправді ви повинні прочитати повну документацію на весь об’єкт аж до "о так, якщо він повертається -42, це означає, бла-бла-бла".

Це рішення може використовуватися з історичних причин або з міркувань продуктивності, але слід інакше уникати.

Це залишає два загальних випадки: зондування або винятки.

Тут головне правило полягає в тому, що програма не повинна реагувати на винятки, за винятком випадків поводження, коли програма ненавмисно / порушує якусь умову. Зондування слід використовувати для того, щоб цього не сталося. Отже, виняток або означає, що відповідне зондування не проводилося заздалегідь, або що сталося щось зовсім несподіване.

Приклад:

Ви хочете створити файл із заданого шляху.

Ви повинні використовувати об’єкт File, щоб заздалегідь оцінити, чи законний цей шлях для створення файлів або запису файлів.

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

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

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

public sealed class Bag<TValue>
{
    public Bag(TValue value, bool hasValue = true)
    {
        HasValue = hasValue;
        Value = value;
    }

    public static Bag<TValue> Empty
    {
        get { return new Bag<TValue>(default(TValue), false); }
    }

    public bool HasValue { get; private set; }
    public TValue Value { get; private set; }
}

тому я можу написати наступний код

    public static Bag<XElement> GetXElement(this XElement element, string elementName)
    {
        try
        {
            XElement result = element.Element(elementName);
            return result == null
                       ? Bag<XElement>.Empty
                       : new Bag<XElement>(result);
        }
        catch (Exception)
        {
            return Bag<XElement>.Empty;
        }
    }

Виглядає як нульовий, але не тільки для типу значення

Ще один приклад

    public static Bag<string> TryParseString(this XElement element, string attributeName)
    {
        Bag<string> attributeResult = GetString(element, attributeName);
        if (attributeResult.HasValue)
        {
            return new Bag<string>(attributeResult.Value);
        }
        return Bag<string>.Empty;
    }

    private static Bag<string> GetString(XElement element, string attributeName)
    {
        try
        {
            string result = element.GetAttribute(attributeName).Value;
            return new Bag<string>(result);
        }
        catch (Exception)
        {
            return Bag<string>.Empty;
        }
    }

Якщо вас цікавить маршрут «магічне значення», ще один спосіб вирішити це - перевантажити мету класу «Ледачі». Хоча Ледачий покликаний відкласти інстанціювання, ніщо насправді не заважає вам використовувати, як, можливо, або Варіант. Наприклад:

    public static Lazy<TValue> GetValue<TValue, TKey>(
        this IDictionary<TKey, TValue> dictionary,
        TKey key)
    {
        TValue retVal;
        if (dictionary.TryGetValue(key, out retVal))
        {
            var retValRef = retVal;
            var lazy = new Lazy<TValue>(() => retValRef);
            retVal = lazy.Value;
            return lazy;
        }

        return new Lazy<TValue>(() => default(TValue));
    }