看一下c#中如何定义一个枚举类型：

看一下c#中如何定义一个枚举类型：

internal   enum  Color  ... {
White,                            // Assigned a value of 0
Red,                             // Assigned a value of 1
Green,                         // Assigned a value of 2
Blue,                          // Assigned a value of 3
Orange                     // Assigned a value of 4
}

 在看一下编译后的样子：

internal   struct  Color : System.Enum  ... {

public const Color White = (Color) 0;
public const Color Red = (Color) 1;
public const Color Green = (Color) 2;
public const Color Blue = (Color) 3;
public const Color Orange = (Color) 4;

//包含Color的变量值，不能写代码直接引用这个实例字段
public Int32 value__;
}

在看一下几种不同的输出Color值的方法

Color c  =  Color.Blue;
Console.WriteLine(c);                                                          // “Blue”  泛型格式
Console.WriteLine(c.ToString());                                          // “Blue” 泛型格式
Console.WriteLine(c.ToString( " G " ));                                   // “Blue” 泛型格式
Console.WriteLine(c.ToString( " D " ));                                   // “3”十进制格式
Console.WriteLine(c.ToString( " X " ));                                    // “03”十六进制格式

c#中的System.Enum类为我们提供了好多操作枚举类型的方法，下面举一个例子：

Color[] colors  =  (Color[]) Enum.GetValues( typeof (Color));
Console.WriteLine( " Number of symbols defined:  "   +  colors.Length);
Console.WriteLine( " Value Symbol ----- ------ " );
Chapter  12 : Enumerated Types and Bit Flags  289
foreach  (Color c  in  colors)  ... {
Console.WriteLine("{0,5:D} {0:G}", c);
}

Value Symbol
---------   -----------
0  White
1  Red
2  Green
3  Blue
4  Orange

其他方法自己可以去尝试用一下。我们可以在枚举类型上应用位标记，这样在操作它的时候会进一步简单，譬如我们在写FileAttributes的时候可以这样写：

String file  =   @" C:Boot.ini " ;
FileAttributes attributes  =  File.GetAttributes(file);
Console.WriteLine( " Is {0} hidden? {1} " , file,
(attributes  &  FileAttributes.Hidden)  ==  FileAttributes.Hidden);

下面看一下FileAttributes的定义：

[Flags, Serializable]
public   enum  FileAttributes  ... {
Readonly = 0x0001,
Hidden = 0x0002,
System = 0x0004,
Directory = 0x0010,
Archive = 0x0020,
Device = 0x0040,
Normal = 0x0080,
Temporary = 0x0100,
SparseFile = 0x0200,
ReparsePoint = 0x0400,
Compressed = 0x0800,
Offline = 0x1000,
NotContentIndexed = 0x2000,
Encrypted = 0x4000
}
// Flags特性代表位标记的意思，Serializable特性代表可序列化

我们也可以在自己的枚举类型上应用位标记，简化操作。

所有c#中的数组都隐式继承自System.Array类型，所有数组都隐式实现IEnumerable，ICollection，和IList接口。在对数组进行强制转换的时候要记住值类型的数组不许可被转换成任何其它类型。下面看个例子：

FileStream[,] fs2dim  =   new  FileStream[ 5 ,  10 ];
Object[,] o2dim  =  fs2dim;

// 错误，维数不同
Stream[] s1dim  =  (Stream[]) o2dim;

Stream[,] s2dim  =  (Stream[,]) o2dim;
String[,] st2dim  =  (String[,]) o2dim;
Int32[] i1dim  =   new  Int32[ 5 ];

// 错误值类型不许转换
Object[] o1dim  =  (Object[]) i1dim;

// 可以借助Array.Copy实现转换
Object[] ob1dim  =   new  Object[i1dim.Length];
Array.Copy(i1dim, ob1dim, i1dim.Length);

我们知道c#中的数组是基于0索引的，但是可以用Array.CreateInstance创建不是0索引的。但是不推荐这样做，因为不是基于0索引的数组效率低，而基于0索引的数组微软做了好多优化工作，效率会很高的。

我们知道c#中只能实现单继承，但是可以实现多个接口，这样也就隐式的实现了多继承。c#中有两种实现接口的方法，分别为显示实现和隐式实现，下面看个例子：

public   sealed   class  Program  ... {
public static void Main() ...{
SimpleType st = new SimpleType();
st.Dispose();
IDisposable d = st;
d.Dispose();
}
}
internal   sealed   class  SimpleType : IDisposable  ... {
public void Dispose() ...{ Console.WriteLine("public Dispose"); }
void IDisposable.Dispose() ...{ Console.WriteLine("IDisposable Dispose"); }
}
// 输出
public  Dispose                                            // 隐式接口的输出
IDisposable Dispose                                    // 显示接口的输出，注意调用的方式！！

记住：在调用显示接口实现时一定要强制转换成接口类型才能使用。

下面看一下泛型接口和接口约束：

public   static   class  SomeType  ... {
private static void Test() ...{
Int32 x = 5;
Guid g = new Guid();
M(x);
M(g);
//以下调用非法
SomeType st=new SomeType();
M(st);
}
//约束条件是：T类型必须实现 IComparable, IConvertible 这两个接口，否则不能调用M方法。
private static Int32 M<T>(T t) where T : IComparable, IConvertible ...{
...
}
}

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1755999