C #: должно ли значение по умолчанию для перечисления быть None или Unknown?

Определенно не лучшая практика. Но если другого пути нет ... то я бы вообще выбрал второй вариант:

public enum ErrorCode 
{ 
    Unknown = -1, 
    None = 0, 
    InsufficientPermissions, 
    ConnectivityError, 
    ... 
} 

0 соответствует условию «Нет ошибок», а -1 подходит с пониманием того, что существует некоторая ошибка (которая может быть неизвестной).

Поскольку вы помечаете свой вопрос рекомендациями: не используйте коды ошибок, если вы можете использовать исключения.

На мой взгляд, оба Unknown или None означают одно и то же в контексте перечисления ErrorCode. Я считаю, что если я проверяю код ошибки, то это потому, что у меня уже есть ошибка.

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

Думаю, я не согласен со всеми по этому поводу.

Нет ничего плохого в кодах ошибок, когда они используются в смысле «каково текущее состояние этой функции».

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

Для меня я бы использовал None как 0 по умолчанию. Я не вижу причин делать Неизвестное отрицательным. Неизвестно - это совершенно нормальное состояние ошибки. Вы можете просто поставить его в конец списка. На практике я сделал

public enum ErrorCode
{
    None = 0,
    InsufficientPermissions,
    ConnectivityError,
    ...
    Unknown,
}

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

Во-первых, у вас не должно быть кода ошибки None. Вместо этого назовите это «Успех».

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

if (errorCode != Success)

или они используют сокращение

if (errorCode != 0)

Вот и все. Ваш Успешный код равен 0, у вас нет кода Нет, а Неизвестным может быть все, что вы хотите.

Зачем вообще возвращать значение ErrorCode, если ошибки нет?

В этом нет большого смысла. Удаление этого решит вашу проблему. Вы можете просто поставить 0 для Unkown:

public enum ErrorCode
{
    Unkown = 0,
    InsufficientPermissions,
    ConnectivityError
}

ОБНОВЛЕНИЕ

Ваш комментарий немного пугающий. У вас никогда не должно быть метода, возвращающего тип ErrorCode. Это очень плохая практика. Поскольку ErrorCodes следует возвращать только в исключительных случаях, рекомендуется генерировать исключения.

Если вы хотите, вы можете иметь поле в вашем настраиваемом исключении, которое содержит значение ErrorCode.

На самом деле я бы не согласился с любым, кто говорит, что вы должны использовать только исключения. При использовании любого приложения, использующего базу данных, вы можете захотеть сохранить статусы данных в системе. Независимо от того, являются ли они кодами ошибок или каким-либо статусом, они лучше всего представлены в базе данных как целые числа.

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

На самом деле я бы посоветовал изменить «Нет» на «Успех», как было предложено, но чтобы вы сделали «Успех» значением 1 и отсюда увеличивали все остальные ошибки. Причина этого заключается в том, что в большинстве приложений баз данных столбцы состояния не допускают значения NULL и обычно отслеживаются как целые числа. Это может привести к проблемам, если вы используете статус успеха 0, потому что по умолчанию целочисленные столбцы, не допускающие значения NULL, будут установлены в 0, если пользователь явно не вставляет что-то еще. Это приведет к ложному коду статуса / ошибки и вызовет проблемы в будущем вашего приложения. Не только то, что целочисленные переменные автоматически инициализируются значением 0 по умолчанию в C #, что приводит к автоматическому успеху, но и перечисления, если вы не устанавливаете начальное значение, а это не то, что вам нужно.

Также с точки зрения кодирования 1 также может означать истину, и поэтому это хорошо сочетается с успехом. Однако есть ситуации, когда это может быть не так. В системах на основе Unix возврат 0 означает успех / отсутствие ошибок, а в других языках, таких как C ++, возврат 0 является стандартным для основной функции, также указывая на успешное выполнение основной функции.

Код ошибки плохой. Исключения хорошие. Но чтобы ответить на заданный вопрос:

Если ваше перечисление имеет значение «Неизвестно», оно должно быть значением по умолчанию.

То же самое со всеми ответами «Я бы не стал этого делать», но если вы настаиваете, вот мои 0,02 доллара.

ErrorCodes.None не имеет смысла, поскольку ошибки нет. ErrorCodes.Unknown бесполезен. Попробуйте вернуть код ошибки, допускающий значение NULL:

public ErrorCode? DoFoo()

Теперь вы можете проверить значение null

var error = DoFoo();
if (error != null)
    // react

По-прежнему плохо, но, по крайней мере, позволяет не возвращать код ошибки, если ошибки нет.