深入浅出OOP(六): 理解C#的Enums

MSDN定义:枚举类型(也称为枚举)为定义一组可以赋给变量的命名整数常量提供了一种有效的方法。  例如,假设您必须定义一个变量,该变量的值表示一周中的一天。

该变量只能存储七个有意义的值。 若要定义这些值,可以使用枚举类型。枚举类型是使用 enum 关键字声明的。

从OOP上来说,枚举的角色和和class一样,它创建了一种新的数据类型。

  1: namespace Enums
  2: {
  3:     class Program
  4:     {
  5:         static void Main(string[] args)
  6:         {
  7:         }
  8:     }
  9:
 10:     enum Color
 11:     {
 12:         Yellow,
 13:         Blue,
 14:         Brown,
 15:         Green
 16:     }
 17: }

上面的代码,我们使用enum的关键字,创建了新的数据类型Color,并包含4个值:Yellow, Blue, Brown和Green。下面的例子我们给予Color枚举。

直接输出枚举,则可得到枚举的字符

  1: using System;
  2: namespace Enums
  3: {
  4:     class Program
  5:     {
  6:         static void Main(string[] args)
  7:         {
  8:             Console.WriteLine(Color.Yellow);
  9:             Console.ReadLine();
 10:         }
 11:     }
 12:
 13:     enum Color
 14:     {
 15:         Yellow,
 16:         Blue,
 17:         Brown,
 18:         Green
 19:     }
 20: }

运行程序,输出:

Yellow

强转为int型,输出试试看:

  1: using System;
  2: namespace Enums
  3: {
  4:     class Program
  5:     {
  6:         static void Main(string[] args)
  7:         {
  8:             Console.WriteLine((int)Color.Yellow);
  9:             Console.ReadLine();
 10:         }
 11:     }
 12:
 13:     enum Color
 14:     {
 15:         Yellow,
 16:         Blue,
 17:         Brown,
 18:         Green
 19:     }
 20: }

结果输出:

0

从上面的例子中,我们可以看到枚举的使用,如同static变量一样,可被直接使用。如不用转换则默认输出枚举定义的字符,强转后

则输出枚举对应的数字值---故枚举可表达恒量数值,或者命名的字符串标示。

基础数据类型

  1: using System;
  2: namespace Enums
  3: {
  4:     class Program
  5:     {
  6:         static void Main(string[] args)
  7:         {
  8:             Console.WriteLine((byte)Color.Yellow);
  9:             Console.WriteLine((byte)Color.Blue);
 10:             Console.ReadLine();
 11:         }
 12:     }
 13:
 14:     enum Color:byte
 15:     {
 16:         Yellow,
 17:         Blue,
 18:         Brown,
 19:         Green
 20:     }
 21: }

结果输出为:

0

1

这里唯一做的修改是枚举Color继承自byte ,而不是默认的int型。

枚举可继承自数值型类型,如long, ulong, short, ushort, int, uint, byte sbyte。但是无法继承自char类型。

枚举可被枚举继承吗?

  1: using System;
  2: namespace Enums
  3: {
  4:     class Program
  5:     {
  6:         static void Main(string[] args)
  7:         {
  8:             Console.WriteLine((byte)Color.Yellow);
  9:             Console.WriteLine((byte)Color.Blue);
 10:             Console.ReadLine();
 11:         }
 12:     }
 13:
 14:     enum Color:byte
 15:     {
 16:         Yellow,
 17:         Blue,
 18:         Brown,
 19:         Green
 20:
 21:     }
 22:
 23:     enum Shades:Color
 24:     {
 25:
 26:     }
 27: }

编译,报错:

Type byte, sbyte, short, ushort, int, uint, long, or ulong expected.

枚举可被class继承吗?

  1:   enum Color:byte
  2:     {
  3:         Yellow,
  4:         Blue,
  5:         Brown,
  6:         Green
  7:     }
  8:
  9: class Derived:Color
 10:     {
 11:
 12:     }

编译报错:

‘Enums.Derived‘: cannot derive from sealed type ‘Enums.Color‘

接下来,我们看看枚举和这3个接口的关系:IComparable, IFormattable 和IConvertible。

A. IComparable

  1: using System;
  2:
  3: namespace Enums
  4: {
  5:     internal enum Color
  6:     {
  7:         Yellow,
  8:         Blue,
  9:         Green
 10:     }
 11:
 12:     internal class Program
 13:     {
 14:         private static void Main(string[] args)
 15:         {
 16:             Console.WriteLine(Color.Yellow.CompareTo(Color.Blue));
 17:             Console.WriteLine(Color.Blue.CompareTo(Color.Green));
 18:             Console.WriteLine(Color.Blue.CompareTo(Color.Yellow));
 19:             Console.WriteLine(Color.Green.CompareTo(Color.Green));
 20:             Console.ReadLine();
 21:         }
 22:     }
 23: }

结果输出:

-1

-1

1

0

-1表示小于关系,0表示等于关系,1表示大于关系。这里标明了enum默认继承了IComparable接口,故有CompareTo()函数。

B. IFormattable

  1: using System;
  2:
  3: namespace Enums
  4: {
  5:     internal enum Color
  6:     {
  7:         Yellow,
  8:         Blue,
  9:         Green
 10:     }
 11:
 12:     internal class Program
 13:     {
 14:         private static void Main(string[] args)
 15:         {
 16:             System.Console.WriteLine(Color.Format(typeof(Color), Color.Green, "X"));
 17:             System.Console.WriteLine(Color.Format(typeof(Color), Color.Green, "d"));
 18:             Console.ReadLine();
 19:         }
 20:     }
 21: }

结果输出:

00000002

2

Format方法继承自IFormatter 接口,它是一个static函数,因此可以被枚举Color直接使用。format需要传入3个参数,第一个是枚举的类型,

第二个参数是枚举值,第三个是格式化标示---二进制、十进制等。

C. IConvertible

  1: Hide   Copy Code
  2: using System;
  3:
  4: namespace Enums
  5: {
  6:      enum Color
  7:     {
  8:         Yellow,
  9:         Blue,
 10:         Green
 11:     }
 12:
 13:     internal class Program
 14:     {
 15:         private static void Main(string[] args)
 16:         {
 17:             string[] names;
 18:             names = Color.GetNames(typeof (Color));
 19:             foreach (var name in names)
 20:             {
 21:                 Console.WriteLine(name);
 22:             }
 23:             Console.ReadLine();
 24:         }
 25:     }
 26: }
 27: 

结果输出:

Yellow

Blue

Green

GetNames函数是枚举Color的静态方法,用于获得枚举所有的字符标示名称集合。

同理也可使用ToString输出枚举的字符标示:

  1: using System;
  2:
  3: namespace Enums
  4: {
  5:      enum Color
  6:     {
  7:         Yellow,
  8:         Blue,
  9:         Green
 10:     }
 11:
 12:     internal class Program
 13:     {
 14:         private static void Main(string[] args)
 15:         {
 16:            Console.WriteLine(Color.Blue.ToString());
 17:            Console.WriteLine(Color.Green.ToString());
 18:            Console.ReadLine();
 19:         }
 20:     }
 21: }

显示输出:

Blue

Green

上面的例子显示,枚举可在int和string直接转换,这个特性是枚举使用中非常重要的一个功能。

试试看,枚举的字符标示是否可以重复定义:

  1: using System;
  2: namespace Enums
  3: {
  4:     class Program
  5:     {
  6:         static void Main(string[] args)
  7:         {
  8:             Console.WriteLine((byte)Color.Yellow);
  9:             Console.WriteLine((byte)Color.Blue);
 10:             Console.ReadLine();
 11:         }
 12:     }
 13:
 14:     enum Color
 15:     {
 16:         Yellow,
 17:         Blue,
 18:         Brown,
 19:         Green,
 20:         Blue
 21:     }
 22: }

编译报错,结果:

Compile time error: The type ‘Enums.Color‘ already contains a definition for ‘Blue‘

可见枚举中不能定义重复的字符标示。

再看另外一个例子:

  1: using System;
  2: namespace Enums
  3: {
  4:     class Program
  5:     {
  6:         static void Main(string[] args)
  7:         {
  8:             Console.WriteLine((int)Color.Yellow);
  9:             Console.WriteLine((int)Color.Blue);
 10:             Console.WriteLine((int)Color.Brown);
 11:             Console.WriteLine((int)Color.Green);
 12:
 13:             Console.ReadLine();
 14:         }
 15:     }
 16:
 17:     enum Color
 18:     {
 19:         Yellow =2,
 20:         Blue,
 21:         Brown=9,
 22:         Green,
 23:
 24:     }
 25: }

结果:

2

3

9

10

从结果看,我们可以在枚举定义的时候重新指定数值,如我们指定了yellow为2,则Blue默认为Yellow+1,为3. 下来,我们指定了Brown为9,则

其下的Green为Brown + 1,为10。 这是一个有趣的enum特性。

如指定的数据类型超过枚举的定义类型,如何?

  1: using System;
  2: namespace Enums
  3: {
  4:     class Program
  5:     {
  6:         static void Main(string[] args)
  7:         {
  8:
  9:         }
 10:     }
 11:
 12:     enum Color:byte
 13:     {
 14:         Yellow =300 ,
 15:         Blue,
 16:         Brown=9,
 17:         Green,
 18:     }
 19: }

编译报错:

Compile time error: Constant value ‘300‘ cannot be converted to a ‘byte‘

300超出了byte数据类型的范围,故报错。 枚举的类型检测非常好,在项目使用中很实用的功能。

枚举引用代码

  1: using System;
  2: namespace Enums
  3: {
  4:     class Program
  5:     {
  6:         static void Main(string[] args)
  7:         {
  8:             Console.WriteLine((int)Color.Yellow);
  9:             Console.WriteLine((int)Color.Blue);
 10:             Console.WriteLine((int)Color.Brown);
 11:             Console.WriteLine((int)Color.Green);
 12:
 13:             Console.ReadLine();
 14:         }
 15:     }
 16:
 17:     enum Color
 18:     {
 19:         Yellow = 2,
 20:         Blue,
 21:         Brown = 9,
 22:         Green = Yellow
 23:     }
 24: }

结果输出:

2

3

9

2

这里,我们定义Green的值,引用了Color的Yellow枚举值。

枚举,是否可以在外面修改枚举值:

  1: using System;
  2: namespace Enums
  3: {
  4:     class Program
  5:     {
  6:         static void Main(string[] args)
  7:         {
  8:             Color.Yellow = 3;
  9:         }
 10:     }
 11:
 12:     enum Color
 13:     {
 14:         Yellow = 2,
 15:         Blue,
 16:         Brown = 9,
 17:         Green = Yellow
 18:     }
 19: }

运行结果:

Compile time error: The left-hand side of an assignment must be a variable, property or indexer

编译报错了。可见枚举数值是常量,仅在初始化的时候确定,外部无法动态修改。

那么,枚举是否可以循环依赖?

  1: using System;
  2:
  3: namespace Enums
  4: {
  5:     internal enum Color
  6:     {
  7:         Yellow=Blue,
  8:         Blue
  9:     }
 10:
 11:     internal class Program
 12:     {
 13:         private static void Main(string[] args)
 14:         {
 15:         }
 16:     }
 17: }

编译结果:

Compile time error: The evaluation of the constant value for ‘Enums.Color.Yellow‘ involves a circular definition

保留关键字

  1: using System;
  2:
  3: namespace Enums
  4: {
  5:      enum Color
  6:     {
  7:       value__
  8:     }
  9:
 10:     internal class Program
 11:     {
 12:         private static void Main(string[] args)
 13:         {
 14:
 15:         }
 16:     }
 17: }

编译报错:

Compile time error: The enumerator name ‘value__‘ is reserved and cannot be used

原因很简单,这里的value__是保留关键字。

枚举小结:

  1. enum表达了恒定的数值,枚举类型可以用字符串标示
  2. 无法声明char基础类型的枚举
  3. enum仅仅能继承自byte, sbyte, short, ushort, int, uint, long, 或ulong数据类型
  4. 默认的,enum是一个sealed类,既无法被继承
  5. enum类型隐式实现了System.Enum
  6. enum类型继承了3个接口:IComparable, IFormattable和IConvertible
  7. enum中,数字和字符串可以互相转换
  8. enum的值可被初始化为同样的值
  9. enum的值要在初始化时候确定
  10. enum中,‘value__‘关键字不能使用

原文:Diving in OOP (Day 6): Understanding Enums in C# (A Practical Approach)

文章目录:

时间: 2024-10-12 14:25:19

深入浅出OOP(六): 理解C#的Enums的相关文章

深入浅出OOP(四): 多态和继承(抽象类)

在本文中,我们讨论OOP中的热点之一:抽象类.抽象类在各个编程语言中概念是一致的,但是C#稍微有些不一样.本文中我们会通过代码来实现抽象类,并一一进行解析. 深入理解OOP(一):多态和继承(初期绑定和编译时多态) 深入理解OOP(二):多态和继承(继承) 深入理解OOP(三):多态和继承(动态绑定和运行时多态) 深入理解OOP(四):多态和继承(C#中的抽象类) 深入理解OOP(五):C#中的访问修饰符(Public/Private/Protected/Internal/Sealed/Cons

深入浅出OOP(二): 多态和继承(继承)

本文是深入浅出OOP第二篇,主要说说继承的话题. 继承的介绍 在OOP中,继承有如下的定义: 继承是一种OOP的机制,用于派生继承预定义的类 在这个继承关系中,预定义的类是基类,新类是子类 继承常常用于实现代码重用 继承允许子类复用基类非private的的数据和方法 继承的实现 创建一个Console工程,命名为InheritanceAndPolymorphism.添加ClassA.ClassB类,并拷贝下面的代码: ClassA:   class ClassA      {         

深入浅出OOP(五): C#访问修饰符(Public/Private/Protected/Internal/Sealed/Constants)

访问修饰符(或者叫访问控制符)是面向对象语言的特性之一,用于对类.类成员函数.类成员变量进行访问控制.同时,访问控制符也是语法保留关键字,用于封装组件. Public, Private, Protected at Class Level 在创建类时,我们需要考虑类的作用域范围,如谁可访问该类,谁可访问该类成员变量,谁可访问该类成员函数. 换而言之,我们需要约束类成员的访问范围.一个简单的规则,类成员函数.类成员变量之间可以自由 访问不受约束,这里主要说的是外部的访问约束.在创建class的时候,

深入浅出OOP(五): C#访问修饰符(Public/Private/Protected/Inter

深入浅出OOP(五): C#访问修饰符(Public/Private/Protected/Internal/Sealed/Constants) 访问修饰符(或者叫访问控制符)是面向对象语言的特性之一,用于对类.类成员函数.类成员变量进行访问控制.同时,访问控制符也是语法保留关键字,用于封装组件. Public, Private, Protected at Class Level 在创建类时,我们需要考虑类的作用域范围,如谁可访问该类,谁可访问该类成员变量,谁可访问该类成员函数. 换而言之,我们需

深入浅出OOP(一): 多态和继承(早期绑定/编译时多态)

在本系列中,我们以CodeProject上比较火的OOP系列博客为主,进行OOP深入浅出展现. 无论作为软件设计的高手.或者菜鸟,对于架构设计而言,均需要多次重构.取舍,以有利于整个软件项目的健康构建,有些经验是前辈总结的,我们拿来使用即可,有些是团队知识沉淀的,总之复用前人好的思想有利于减少返工.当然,在面试的时候,如果能围绕OOP大谈特谈,自然会加分多多的. 开始阅读本系列博客的预备知识,多态.封装.面向对象编程等,请通过MSDN学习.如下图的术语,您应该耳熟能详的.本系列文章使用C#语音作

C++——OOP面向对象理解

从Rob Pike 的 Google+上的一个推看到了一篇叫<Understanding Object Oriented Programming>的文章,我先把这篇文章简述一下,然后再说说老牌黑客Rob Pike的评论.先看这篇教程是怎么来讲述OOP的.它先给了下面这个问题,这个问题需要输出一段关于操作系统的文字:假设Unix很不错,Windows很差.这个把下面这段代码描述成是Hacker Solution.(这帮人觉得下面这叫黑客?我估计这帮人真是没看过C语言的代码) public cla

深入浅出OOP(三): 多态和继承(动态绑定/运行时多态)

在前面的文章中,我们介绍了编译期多态.params关键字.实例化.base关键字等.本节我们来关注另外一种多态:运行时多态, 运行时多态也叫迟绑定. 运行时多态或迟绑定.动态绑定 在C#语音中,运行时多态也叫方法重写(overriding),我们可以在子类中overriding基类的同签名函数,使用"virtual & override"关键字即可. C#的New.Override关键字 创建一个console 示例工程,命名为InheritanceAndPolymorphis

基础部分-c#基础-oop(面向对象理解)

1:面向对象三大特点:封装 继承 多态 封装:把项目按规则分为块,每个对象, 稳定可直接调用,不稳定需要修改的的属性方法,把稳定的一部分以Public或者 Private,封装起来 继承:一个对象(人),有某个方法(开飞机),另一个对象(人)刚好没有,在程序最简单的就是继承这个开飞机的方法 多态:一个对象(人),每个人都有相同的方法(睡觉),但是每个对象睡觉的方式不同,有的人还是一个人睡,有的人则还 有对象陪着睡 2:用面向对象的思维来编写一个MVC项目:(单身狗打lol)    面向对象基本就

深入浅出让你理解跨域与SSO单点登录原理与技术

一:SSO体系结构 SSO ? SSO英文全称Single Sign On,单点登录.SSO是在多个应用系统中,用户只需要登录一次就可以访问所有相互信任的应用系统.它包括可以将这次主要的登录映射到其他应用中用于同一个用户的登录的机制.它是目前比较流行的企业业务整合的解决方案之一. 体系结构 ? 当用户第一次访问应用系统1的时候,因为还没有登录,会被引导到认证系统中进行登录:根据用户提供的登录信息,认证系统进行身份校验,如果通过校验,应该返回给用户一个认证的凭据--token:用户再访问别的应用的