C#: Should the default value of an enum be None or Unknown?

Question

Hey all,

Say you have an enum that represents an error code. There will be several codes, each with their own underlying int value; however, the enum value that gets the default 0 value seems like it should be carefully considered.

In the case of an error code enum, there are two special values that I can think of: None (for cases when there is no error) and Unknown (for cases when no existing error code is appropriate, or perhaps even when error state cannot be detected).

One of these values seems like it should get 0, where the other will probably get something else like -1. Is it more appropriate to set the None value to 0, or the Unknown value to 0?

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

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

My instinct tells me that the default should be Unknown, but I'm curious if anyone has done it differently.

Answer 1

Why return an ErrorCode value at all when there is no error?

Doesn't make a whole lot of sense. Removing that would resolve your issue. You could just make 0 be for Unkown:

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

UPDATE

Your comment is a little scary. You should never have a method that returns a type of ErrorCode. It's very poor practice. Since ErrorCodes should only be returned in Exceptional circumstances, it's a good idea to throw Exceptions.

If you want, you can have a field in your custom Exception that contains the ErrorCode value.

Answer 2

Since you're tagging your question with best-practices: don't use error codes when you can use exceptions.

Answer 3

In my opinion both Unknown or None mean the same thing in the context of the ErrorCode enumeration. My reasoning is that if I'm checking an error code than it's because I already have an error.

I'm also of the opinion that an error code enumeration is only useful in a custom exception or as custom data of an existing exception type and in both scenarios you will always have an error.

Answer 4

ErrorCodes bad. Exceptions good. But to answer the question as asked:

If your enum has an "Unknown" value, it should be the default.

Answer 5

First of all, you shouldn't have a None error code. Instead, call it "Success".

Now think about how you are going to check the error code. Most people expect something like this:

if (errorCode != Success)

or they use the shorthand

if (errorCode != 0)

So there you have it. Your Success code is 0, you don't have a None code, and Unknown can be anything you want.

Answer 6

Ditto to all of the "I wouldn't do it responses," but if you insist, here's my $0.02.

ErrorCodes.None makes no sense, since there's no error. ErrorCodes.Unknown is not helpful. Try returning a nullable error code:

public ErrorCode? DoFoo()

Now you can check for null

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

Still bad, but at least it allows you to not return an error code if there's no error.

Answer 7

Definitely not a good practice. But if there is no other way...then I would generally go by the second option:

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

0 goes well by the convention 'No Error' and -1 goes fine with the understanding that there is some error (which may be unknown).

Answer 8

I guess I'll disagree with everyone else on this.

There's nothing wrong with error codes when used in the sense of "what is the current state of this feature."

To make up an example: if you have an optional networked temp folder, that you want to access, and you want to display the results from the most recent time that you attempted to access it, you would save that in an error code. Perhaps on a status bar you want to show the current state to the user.

For me, I would use None as 0, as the default. I see no reason to make Unknown be negative. Unknown is a perfectly fine error state. You can just put it at the end of the list. In practice, I have done

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

And to answer your question, I say None must be the default. None means: no error exists that you are aware of. Unknown would mean to me: an error exists that is so obscure that you can't account for it in your code.