enum (C# Reference)

for eg
enum days{sun, mon, tue,wed,thu,fri,sat};
here sun has value 0
n tue has 2 right?
so can i reverse this?
(int)days.tue
so dat i can display tue by giving d value 2???

Edit by SJ at MSFT: There is an example in this topic, http://msdn.microsoft.com/en-us/library/cc138362.aspx . Add the following loop to the Days example, and you will see how it works:

for (int i = 1; i <= 7; i++)
{
    string s = Enum.GetName(typeof(Days), i);
    Console.WriteLine(s);
}

You can attain what you want with the following syntax:

public static BookType

{

public const string HARDCOPY = "expensive";

public const string EBOOK = "cheap";

}

I was wondering if enums in C# could possibly be used to do the following:

BookType {
HARDCOPY = "expensive",
EBOOK = "cheap"
}

String bookTypePriceIdea = (String) BookType.HARDCOPY;

Try this one on for size. You can pass a zero as an enum even if there is no 0 defined (.net 2.0). If you change the 0 to anything else, even a defined integer in the enum, the program will no longer compile. Just what is the thinking here with the magical 0? FAIL

namespace Fail
{
class Program
{
static void Main(string[] args)
{
var f = new Fail(0);
}
}

public class Fail
{
private SomeEnum mEnu;
public Fail(SomeEnum enu)
{
mEnu = enu;
}
}

public enum SomeEnum
{
Critical = 1,
Important = 2,
Warning = 3,
Information = 4
}
}

---
By default, the first enumerator has the value 0, and the value of each successive enumerator is increased by 1. The default value of an enum E is the value produced by the expression (E)0, which in your example (SomeEnum)0 = 0. 0 can be thought of as SomeEnum.Default and is always present whether you declared it or not. This would become a logical error, although the code Fail(0) should never be written as this violates exactly what you are trying to avoid by using an enum and should be Fail(SomeEnum.SomeValue). While not magical, the behavior is indeed odd and it is good that you have pointed this out.

If you're willing to create your own arrays/lists/whatever, you can do the following:
public T this[Enum index]
{
return std_array[((IConvertible)index).ToInt32(null)];
}

Then simply using Variable[Enum.Value]; will work. Since it uses Enum as the type, any enum will work. If one used IConvertible itself instead, anything that implements IConvertible would work, including (for example) floats, which would not be desirable.

Personally I use:
static class ExtendingList
{
public static T i<T>(this IList<T> This, Enum index)
{
return This[((IConvertible)index).ToInt32(null)];
}
public static void i<T>(this IList<T> This, Enum index, T to)
{
This[((IConvertible)index).ToInt32(null)] = to;
}

}
then I can use std_array.i(Enum.Value); It's, unfortunately, less readable, but until there's a way to extend indexers...

Perhaps Leahn simply left out the keyword class in her code.

public static class BookType
{
public const string HARDCOPY = "expensive";
public const string EBOOK = "cheap";
public const string kindle = "other";
}
certainly would work.

However I agree with Kozmoknot - if this is the extent of the members there is no reason to use a class. One would be better off using a struct. In the CLR, a struct is a value type, is lighter weight and allocated directly from the stack.

**Don't use a struct here, use a class. In the case where we are using strings we would create a class (reference type) because strings are character arrays which are reference types.

We only use structs where:
- the total size of the instance will be 16 bytes or less
- the struct logically represents a single value
- we will not cast the struct to a reference type

We use structs for better performance however structs only suit simple values otherwise structs are inefficient.

I nice feature, and not too hard to implement (at least in C#, since Enum is actually a class), would be enum extendability. More than once had I wished for some enum values available in one enum to be present in another one, along with others - custom defined. Some very relevant examples would be:

1. Creating customized message boxes, with customized DialogResult, MessageBoxButtons and MessageBoxIcon. It would have been much simpler and elegant, had this feature been implemented.
2. Creating customized exceptions, and defining an ErrorCode property, which - if defined as an enum type - would allow extended exceptions to use the same error codes, and also add their own, very elegant and easy.

Your code doesn't work...it needs the "struct" value type specified instead of "static":

public struct BookType

{

public const string HARDCOPY = "expensive";

public const string EBOOK = "cheap";

}

A struct may also be used instead of an enum to accomplish implicit conversions to an integral type.

what's the sense in:
switch((MyType)SomeInt)
{
case MyType.E0:
SomeOtherInt = (int)MyType.E1;
break;
}

wouldn't it be nicer this way:
switch(SomeInt)
{
case MyType.E0:
SomeOtherInt = MyType.E1;
break;
}
?

??

ShadowRanger, enum, as per the documentation, are substituted for their respecitve numeric value during compiler time, which means that your program knows no enum, only its values, so yes, implicit conversion makes sense. It is already a constant of type int (or whatever type your assigned to it) so casting it should not be needed.

Also, enum in C#, unlike their counterparts in other languages DO NOT enforce the accepted values, if you declare an enum with values ranging from 1 to 7, and I pass a "(<enumName>)10 " to your function as a parameter, it will be accepted. C/C++ overlap the values, so if I passed 10, the compiler would switch it to 3 during compiling time. C# does not do this.

To finish, enums are ONLY int constants, the purpose of their name is simply to make it easier for you to remember the correct value to pass (easier to remember 'ReturnValue.Success' than '5'). Any other language with much tigher enum specification allow free conversion from the enum to its underlying type. C/C++ even allow you do to aritmetic operations straight with the enum values (and overlap the result accordingly). VB.NET allows free conversion to the underlying type. There is no reason to not to allow it as well in C#.

enums should not do implicit conversion (at least, not by default), because then their primary raison d'etre is eliminated. enums were created to enable easy compiler-time checks to ensure only accepted values were provided to a function or other construct, and to enable the use of names in cases where numerics don't matter. If they convert seamlessly to and from the underlying type, then you may as well use just declare int constants and be done with it, because you'll be back where we started, and enums will just be a short hand for a list of constants.

enum is nothing more then a named int or whatever type you set it to having to cast it after that makes no sense.