1. 枚举(enum)类型→整数(int)类型

Subject subject1 = Subject.Chinese;
Subject subject2 = Subject.AndroidDevelop;
int num1 = (int)subject1;
int num2 = (int)subject2;
Console.WriteLine(num1);//输出：0
Console.WriteLine(num2);//输出：3
Console.ReadKey();
注：第一个枚举元素的值为0，后面每个枚举元素的值依次递增。
修改枚举元素的值后，查看枚举数的值变化规律。不难发现，可以强制修改枚举元素序列从某一个数值开始递增。
 
public enum Subject
	//仅仅在第1小点这里修改枚举类型元素的序号
    Chinese = 5,
    Math,
    English = 10,
    AndroidDevelop,
    GameDevelop
Console.WriteLine((int)Subject.Chinese);//输出：5
Console.WriteLine((int)Subject.Math);//输出：6
Console.WriteLine((int)Subject.English);//输出：10
Console.WriteLine((int)Subject.AndroidDevelop);//输出：11
Console.WriteLine((int)Subject.GameDevelop);//输出：12
Console.ReadKey();
2. 整数(int)类型→枚举(enum)类型
 
int i = 3;
Subject subject = (Subject)i;
Console.WriteLine(subject);//输出：AndroidDevelop
Console.ReadKey();
由此可见，在转化为枚举类型的过程中，当枚举类型的元素序号包括整数类型的数值就得到枚举类型的元素，如果没有包括整数类型的数值，得到的是数值本身。
 
int i = 8;
Subject subject = (Subject)i;
Console.WriteLine(subject);//输出：8
Console.ReadKey();
3. 枚举(enum)类型→字符串(string)类型
 
Subject subject = Subject.GameDevelop;
string str = subject.ToString();
Console.WriteLine(str);//输出：GameDevelop
Console.ReadKey();
万物皆可ToString()：
 
int i = 1;
double d = 2.2;
char c = 'C';
decimal m = 200.5m;
Console.WriteLine(i.ToString());//输出：1
Console.WriteLine(d.ToString());//输出：2.2
Console.WriteLine(c.ToString());//输出：C
Console.WriteLine(m.ToString());//输出：200.5
Console.ReadKey();
4. 字符串(string)类型→枚举(enum)类型
 
①字符串内容的值与枚举元素名一致，输出枚举元素名。
 
string str1 = "Math";
Subject subject1 = (Subject)Enum.Parse(typeof(Subject), str1);
Console.WriteLine(subject1);//输出：Math
Console.ReadKey();
②字符串内容的数值与枚举元素序号一致，输出对应的序号值的枚举元素名。
 
string str2 = "3";
Subject subject2 = (Subject)Enum.Parse(typeof(Subject), str2);
Console.WriteLine(subject2);//输出：AndroidDevelop
Console.ReadKey();
③字符串内容的数值与枚举元素序号不一致，输出字符串内容的数值。
 
string str3 = "10";
Subject subject3 = (Subject)Enum.Parse(typeof(Subject), str3);
Console.WriteLine(subject3);//输出：10
Console.ReadKey();
④除了数值以及与枚举元素一致的文本内容外，其他字符串本文内容无法转换成枚举类型，因此会抛出异常。
 
//这里是错误示范！代码存在异常！
string str3 = "异常内容";
Subject subject3 = (Subject)Enum.Parse(typeof(Subject), str3);//抛出异常
Console.WriteLine(subject3);
Console.ReadKey();
 
因为作者精力有限，文章中难免出现一些错漏，敬请广大专家和网友批评、指正。
 
                    C#关于枚举(enum)类型与整型、字符串相互转换的总结首先，声明枚举类型的变量：[public] enum Subject{    Chinese,    Math,    English,    AndroidDevelop,    GameDevelop}注意：①【public】关键字视情况而定，可以不加。②最好是在命名空间下直接定义枚举，以便该命名空间中的所有类都能够使用。③最后一个值可以加【,】也可以不加。四种类型转换的方法：1. 枚举(enum)类型→整数(int
				
enum Enum{ZERO = 0,One,Two};//枚举类型 enumeration:枚举
1、枚举类型可自动向整形转化，即int nNum = One;正确；
2、整形不可向枚举类型自动转化(需要强制转化)，即int nNum = 2;Enum type = nNum;错误；
7.16.2.4 from、let、where、join 和 orderby 子句	212
7.16.2.5 select 子句	216
7.16.2.6 Groupby 子句	216
7.16.2.7 透明标识符	216
7.16.3 查询表达式模式	218
7.17 赋值运算符	219
7.17.1 简单赋值	219
7.17.2 复合赋值	221
7.17.3 事件赋值	222
7.18 表达式	222
7.19 常量表达式	223
7.20 布尔表达式	224
8. 语句	225
8.1 结束点和可到达性	225
8.2 块		227
8.2.1 语句列表	227
8.3 空语句	228
8.4 标记语句	228
8.5 声明语句	229
8.5.1 局部变量声明	229
8.5.2 局部常量声明	230
8.6 表达式语句	231
8.7 选择语句	231
8.7.1 if 语句	231
8.7.2 switch 语句	232
8.8 迭代语句	236
8.8.1 while 语句	236
8.8.2 do 语句	236
8.8.3 for 语句	237
8.8.4 foreach 语句	238
8.9 跳转语句	240
8.9.1 break 语句	241
8.9.2 continue 语句	242
8.9.3 goto 语句	242
8.9.4 return 语句	243
8.9.5 throw 语句	244
8.10 try 语句	245
8.11 checked 语句和 unchecked 语句	247
8.12 lock 语句	248
8.13 using 语句	248
8.14 yield 语句	250
9. 命名空间	253
9.1 编译单元	253
9.2 命名空间声明	253
9.3 Extern 别名	254
9.4 using 指令	255
9.4.1 using 别名指令	256
9.4.2 Using 命名空间指令	258
9.5 命名空间成员	260
9.6 类型声明	260
9.7 命名空间别名限定符	261
9.7.1 别名的唯一性	262
10. 类	263
10.1 类声明	263
10.1.1 类修饰符	263
10.1.1.1 抽象类	264
10.1.1.2 密封类	264
10.1.1.3 静态类	264
10.1.2 分部修饰符	265
10.1.3 类型形参	265
10.1.4 类基本规范	266
10.1.4.1 基类	266
10.1.4.2 接口实现	267
10.1.5 类型形参约束	268
10.1.6 类体	272
10.2 分部类型	272
10.2.1 特性	272
10.2.2 修饰符	273
10.2.3 类型形参和约束	273
10.2.4 基类	273
10.2.5 基接口	274
10.2.6 成员	274
10.2.7 分部方法	275
10.2.8 名称绑定	277
10.3 类成员	277
10.3.1 实例类型	278
10.3.2 构造类型的成员	279
10.3.3 继承	280
10.3.4 new 修饰符	280
10.3.5 访问修饰符	281
10.3.6 构成类型	281
10.3.7 静态成员和实例成员	281
10.3.8 嵌套类型	282
10.3.8.1 完全限定名	282
10.3.8.2 已声明可访问性	282
10.3.8.3 隐藏	283
10.3.8.4 this 访问	283
10.3.8.5 对包含类型的私有和受保护成员的访问	284
10.3.8.6 泛型类中的嵌套类型	285
10.3.9 保留成员名称	286
10.3.9.1 为属性保留的成员名称	286
10.3.9.2 为事件保留的成员名称	287
10.3.9.3 为索引器保留的成员名称	287
10.3.9.4 为析构函数保留的成员名称	287
10.4 常量	287
10.5 字段	289
10.5.1 静态字段和实例字段	290
10.5.2 只读字段	291
10.5.2.1 对常量使用静态只读字段	291
10.5.2.2 常量和静态只读字段的版本控制	291
10.5.3 可变字段	292
10.5.4 字段初始化	293
10.5.5 变量初始值设定项	293
10.5.5.1 静态字段初始化	294
10.5.5.2 实例字段初始化	295
10.6 方法	296
10.6.1 方法形参	298
10.6.1.1 值参数	299
10.6.1.2 引用形参	299
10.6.1.3 输出形参	300
10.6.1.4 形参数组	301
10.6.2 静态方法和实例方法	303
10.6.3 虚方法	304
10.6.4 重写方法	305
10.6.5 密封方法	307
10.6.6 抽象方法	308
10.6.7 外部方法	309
10.6.8 分部方法	310
10.6.9 扩展方法	310
10.6.10 方法体	311
10.6.11 方法重载	311
10.7 属性	311
10.7.1 静态属性和实例属性	312
10.7.2 访问器	313
10.7.3 自动实现的属性	317
10.7.4 可访问性	318
10.7.5 虚、密封、重写和抽象访问器	319
10.8 事件	321
10.8.1 类似字段的事件	323
10.8.2 事件访问器	324
10.8.3 静态事件和实例事件	325
10.8.4 虚、密封、重写和抽象访问器	325
10.9 索引器	326
10.9.1 索引器重载	329
10.10 运算符	329
10.10.1 一元运算符	331
10.10.2 二元运算符	331
10.10.3 转换运算符	332
10.11 实例构造函数	334
10.11.1 构造函数初始值设定项	335
10.11.2 实例变量初始值设定项	336
10.11.3 构造函数执行	336
10.11.4 默认构造函数	338
10.11.5 私有构造函数	338
10.11.6 可选的实例构造函数形参	339
10.12 静态构造函数	339
10.13 析构函数	341
10.14 迭代器	343
10.14.1 枚举器接口	343
10.14.2 可枚举接口	343
10.14.3 产生类型	343
10.14.4 枚举器对象	343
10.14.4.1 MoveNext 方法	344
10.14.4.2 Current 属性	345
10.14.4.3 Dispose 方法	345
10.14.5 可枚举对象	345
10.14.5.1 GetEnumerator 方法	346
10.14.6 实现示例	346
11. 结构	353
11.1 结构声明	353
11.1.1 结构修饰符	353
11.1.2 分部修饰符	353
11.1.3 结构接口	354
11.1.4 结构体	354
11.2 结构成员	354
11.3 类和结构的区别	354
11.3.1 值语义	355
11.3.2 继承	355
11.3.3 赋值	356
11.3.4 默认值	356
11.3.5 装箱和拆箱	356
11.3.6 this 的含义	358
11.3.7 字段初始值设定项	358
11.3.8 构造函数	358
11.3.9 析构函数	359
11.3.10 静态构造函数	359
11.4 结构示例	360
11.4.1 数据库整数类型	360
11.4.2 数据库布尔类型	361
12. 数组	365
12.1 数组类型	365
12.1.1 System.Array 类型	366
12.1.2 数组和泛型 IList 接口	366
12.2 数组创建	366
12.3 数组元素访问	367
12.4 数组成员	367
12.5 数组协变	367
12.6 数组初始值设定项	367
13. 接口	369
13.1 接口声明	369
13.1.1 接口修饰符	369
13.1.2 分部修饰符	369
13.1.3 Variant 类型形参列表	370
13.1.3.1 变化安全性	370
13.1.3.2 变化转换	371
13.1.4 基接口	371
13.1.5 接口体	372
13.2 接口成员	372
13.2.1 接口方法	373
13.2.2 接口属性	373
13.2.3 接口事件	374
13.2.4 接口索引器	374
13.2.5 接口成员访问	374
13.3 完全限定接口成员名	376
13.4 接口实现	376
13.4.1 显式接口成员实现	377
13.4.2 所实现接口的唯一性	379
13.4.3 泛型方法实现	380
13.4.4 接口映射	381
13.4.5 接口实现继承	383
13.4.6 接口重新实现	385
13.4.7 抽象类和接口	386
14. 枚举	387
14.1 枚举声明	387
14.2 枚举修饰符	387
14.3 枚举成员	388
14.4 System.Enum 类型	390
14.5 枚举值和运算	390
15. 委托	391
15.1 委托声明	391
15.2 委托兼容性	393
15.3 委托实例化	393
15.4 委托调用	394
16. 异常	397
16.1 导致异常的原因	397
16.2 System.Exception 类	397
16.3 异常的处理方式	397
16.4 公共异常类	398
17. 特性	399
17.1 特性类	399
17.1.1 特性用法	399
17.1.2 定位和命名参数	400
17.1.3 特性参数类型	401
17.2 特性说明	401
17.3 特性实例	406
17.3.1 特性的编译	406
17.3.2 特性实例的运行时检索	406
17.4 保留特性	407
17.4.1 AttributeUsage 特性	407
17.4.2 Conditional 特性	408
17.4.2.1 条件方法	408
17.4.2.2 条件特性类	410
17.4.3 Obsolete 特性	411
17.5 互操作的特性	412
17.5.1 与 COM 和 Win32 组件的互操作	412
17.5.2 与其他 .NET 语言的互操作	412
17.5.2.1 IndexerName 特性	412
18. 不安全代码	413
18.1 不安全上下文	413
18.2 指针类型	415
18.3 固定和可移动变量	418
18.4 指针转换	418
18.4.1 指针数组	419
18.5 表达式中的指针	420
18.5.1 指针间接寻址	420
18.5.2 指针成员访问	421
18.5.3 指针元素访问	422
18.5.4 address-of 运算符	422
18.5.5 指针递增和递减	423
18.5.6 指针算术运算	423
18.5.7 指针比较	424
18.5.8 sizeof 运算符	425
18.6 fixed 语句	425
18.7 固定大小缓冲区	429
18.7.1 固定大小缓冲区的声明	429
18.7.2 表达式中的固定大小缓冲区	430
18.7.3 明确赋值检查	431
18.8 堆栈分配	431
18.9 动态内存分配	432
A. 文档注释	435
A.1 简介	435
A.2 建议的标记	436
A.2.1 <c>	437
A.2.2 <code>	437
A.2.3 <example>	437
A.2.4 <exception>	438
A.2.5 <include>	438
A.2.6 <list>	439
A.2.7 <para>	440
A.2.8 <param>	440
A.2.9 <paramref>	441
A.2.10 <permission>	441
A.2.11 <remark>	442
A.2.12 <returns>	442
A.2.13 <see>	442
A.2.14 <seealso>	443
A.2.15 <summary>	443
A.2.16 <value>	444
A.2.17 <typeparam>	444
A.2.18 <typeparamref>	444
A.3 处理文档文件	445
A.3.1 ID 字符串格式	445
A.3.2 ID 字符串示例	446
A.4 示例	449
A.4.1 C# 源代码	449
A.4.2 生成 XML	452
B. 语法	455
B.1 词法文法	455
B.1.1 行结束符	455
B.1.2 注释	455
B.1.3 空白	456
B.1.4 标记	456
B.1.5 Unicode 字符转义序列	456
B.1.6 标识符	456
B.1.7 关键字	458
B.1.8 文本	458
B.1.9 运算符和标点符号	460
B.1.10 预处理指令	460
B.2 句法文法	463
B.2.1 基本概念	463
B.2.2 类型	463
B.2.3 变量	464
B.2.4 表达式	464
B.2.5 语句	471
B.2.6 命名空间	475
B.2.7 类	475
B.2.8 结构	483
B.2.9 数组	483
B.2.10 接口	484
B.2.11 枚举	485
B.2.12 委托	486
B.2.13 特性	486
B.3 不安全代码的语法扩展	487
C. 参考资料	491
Char 外的任何整型，所以枚举类型的值是整型值
1、C#将枚举转为字符串（enume->string）
我们的对象中包含枚举类型，在序列化成Json字符串的时候，显示的是枚举类型对应的数字。因为这是枚举的
本质所在，但是很多时候需要在JSON转化的时候做一些操作，使之显示字符串，因为用户需要字符串。
方法就是：在枚举类型上添加属性标签
[JsonConverter(typeof(StringEnumConverter
        [StringValue("red")]     red,
        [StringValue("blue")]    blue,
        [StringValue("green")]   green,
        [StringValue("yellow")]  yellow,
当将以前的C代码移植到C#中时，我快发疯了，因为有很多的数组需要将常量映射到字符串。当我在寻找一个C#的方法来完成的时候，我发现了一个自定义属性和映射的方法。
如何使用代码?
对每一个enum枚举都添加一个Description属性：
private enum MyColors
   [Description("yuk!")]       LightGreen    = ...
在面对对象的动态开发中,难免会遇到各种类型转换的问题,今天我们来简单介绍一下enum(枚举)与int(整型)和string(字符串)类型之间的相互转换;
目录:一.三者类型的介绍:
一.三者类型的介绍:
1.enum:枚举的声明用enum,枚举是值类型;
2.int:int是32位有符号的整型
......
				
默认情况下，枚举是以其整数形式进行 JSON 序列化，这通常会导致与消费者应用缺乏互操作性，因为他们需要事先了解这些数字的实际含义。因此，我们希望它们在一些情况下以字符串的形式进行序列化。本文将讲解实现这一目标的各种方法。为了演示，我们来创建一个简单的 Model：
我们用  中的  方法序列化一个  对象：
我们来看一下这个 Model 序列化为 Json 后的字符串：
正如你看到的，枚举属性的值（）被序列化为 JSON 字符串后表现为一个整数（）。作为序列化结果 JSON 的消费者，在没有文
在其进行转换是首先肯定得定义一个string类型的量，然后通过
(enum_name)Enum.Parse( typeof(enum-name),string_name )
方法进行设置调用；
2.1enum枚举转化为int整形：
转换为整形一般是用 强制转换 ，（int）enum_name.枚举值
例子：...
				
将枚举类型转换为int在C#里非常简单，直接(int)强转就行了，可是这样写代码不方便，尤其让我这种懒癌患者难受，我喜欢用扩展方法的方式实现转换，比如这样string转int：
public static class ExtendString
	public static int ToInt(this string s, int defaultValue = 0)
		int i;
				
在C语言中，枚举类型和字符串之间的互相转换是比较常见的需求。下面将分别介绍如何实现这两种转换。
首先，将枚举类型转换成字符串。在C语言中，我们可以利用switch语句和枚举类型的取值来实现。如下面的代码所示：
enum Fruit {
    APPLE,
    BANANA,
    ORANGE
const char* fruitToString(enum Fruit fruit) {
    switch (fruit) {
        case APPLE:
            return "apple";
        case BANANA:
            return "banana";
        case ORANGE:
            return "orange";
        default:
            return "";
在这段代码中，我们定义了一个枚举类型`Fruit`，其中包含了三个取值。然后，我们定义了一个函数`fruitToString`，该函数接受一个枚举类型的参数，并返回一个对应的字符串。在函数内部，我们使用了switch语句来根据不同的枚举值返回不同的字符串。
其次，将字符串转换成枚举类型。在C语言中，我们可以采用一些方法来实现这个转换。以下是一种常见的方式：
enum Fruit stringToFruit(const char* str) {
    if (strcmp(str, "apple") == 0) {
        return APPLE;
    } else if (strcmp(str, "banana") == 0) {
        return BANANA;
    } else if (strcmp(str, "orange") == 0) {
        return ORANGE;
    } else {
        return -1;  // 表示转换失败
在这个函数中，我们定义了一个名为`stringToFruit`的函数，该函数将一个字符串转换成枚举类型。我们使用了`strcmp`函数来比较字符串是否相等，从而确定对应的枚举值。如果字符串无法转换成枚举类型，函数返回-1表示转换失败。
总的来说，在C语言中，枚举类型和字符串互相转换并不是很复杂。只要我们熟悉基本的语法和函数，就可以很轻松地实现这些转换。