学习c#(6天):了解枚举在c#中(一个实际的方法)

学习c#(6天):了解枚举在c#中(一个实际的方法)
- 下载PDF article - 1.9 MB
介绍我的文章系列的“潜水OOP”将解释枚举数据类型在c#中。我们将学习通过实验室,不仅是理论。我们将探讨enum的力量和将涵盖几乎每一个场景,在该场景中,我们可以用枚举。我们将遵循一个实用方法的学习理解这个概念。我们可能会遇到复杂的例子来理解更深入的概念。枚举(定义) 让我们先从MSDN的定义: “enum关键字用于声明一个枚举,一个独特的类型,由一组命名的常数称为枚举器列表。通常最好是直接在名称空间中定义一个枚举名称空间中的所有类可以访问它以同样的方便。然而,enum也可以嵌套在一个类或结构体。默认情况下,第一个计数器的值0,每个连续的枚举器的价值增长了1。例如,在下面的枚举,坐是0,太阳是1,我的是2,等等。” ,,,,,图片来源:http://pixabay.com/en/job-interview-career-conference-156130/ 的必备条件我希望我的这篇文章的读者应该很c#的基本知识,我总是希望我的读者在阅读本文时应该享受的。同时,请自己写程序,给出本文为例,手和概念有更深入的了解。路线图让我们回忆起我们的路线图。 ,,,,,,,,,,,,,,,,,,,,, 图片来源:http://borgefagerli.com/at-a-crossroads/cross-roads/ 潜水在OOP(第一天):多态和继承(早期绑定/编译时多态)潜水在OOP(第二天):多态和继承(继承)潜水OOP(第三天):多态和继承(动态绑定/运行时多态)潜水在OOP(第四天):多态和继承(关于抽象类在c#)潜水在OOP(第五天):都是用c#访问修饰符(公共/私人/保护/内部/密封/常量/只读的字段)学习c#(6天):理解枚举在c#中(一个实际的方法)学习c#(7天):用c#属性(一个实际的方法)学习c#(8天):用c#索引器(一个实际的方法)学习c#(9天):了解c#事件(Insight)学习c#(第十天):代表在c#中(一个实际的方法)学习c#(11天):c#事件(一个实际的方法) 一个实用的方法 Enum戏剧几乎相同的责任类,即。创建一个新的数据类型,它的存在在同一水平类,接口或结构。打开你的Visual Studio和添加一个控制台应用程序命名的枚举。你会得到Program.cs类。注意:每一个代码片段在本文中尝试和测试。同级声明一个枚举类的程序,调用它的颜色。 Program.cs 隐藏,复制Code
```
namespace Enums
{
    class Program
    {
        static void Main(string[] args)
        {
        }
    }

    enum Color
    {
        Yellow,
        Blue,
        Brown,
        Green
    }
}
```
在上述例子中,我们创建了一个新的数据类型的枚举。数据类型是颜色有四个不同的值,黄色,蓝色,棕色和绿色。我们写的文本在枚举声明可以是任何你的愿望;它只是提供了一个自定义枚举列表给你。修改主程序如下所示: 隐藏,复制Code
```
using System;
namespace Enums
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(Color.Yellow);
            Console.ReadLine();
        }
    }

    enum Color
    {
        Yellow,
        Blue,
        Brown,
        Green
    }
}
```
运行这个程序。输出:黄色现在定型的颜色。黄色int,我们得到了什么? 隐藏,复制Code
```
using System;
namespace Enums
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine((int)Color.Yellow);
            Console.ReadLine();
        }
    }

    enum Color
    {
        Yellow,
        Blue,
        Brown,
        Green
    }
}
```
输出:0 我们看到,enum是称为静态变量,所以枚举可以被认为是静态对象。因此其他枚举在上面的例子中可以以同样的方式宣布为黄色,可以声明为Color.Blue喜欢蓝色。在上面两个例子的输出时,我们看到的是0定型和黄色没有铸字,因此我们看到其行为非常类似于数组,黄色中有一个值0,同样的蓝色值1,布朗:2,格林:3。因此,当我们做的颜色。黄色,就像显示一个数字0,所以从这一点来看,我们可以推导出一个枚举代表一个常数,因此一个枚举类型是一种不同类型命名常量。记住:enum表示为一个常数,enum类型被称为不同的类型命名常量。基本数据类型 Program.cs 隐藏,复制Code
```
using System;
namespace Enums
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine((byte)Color.Yellow);
            Console.WriteLine((byte)Color.Blue);
            Console.ReadLine();
        }
    }

    enum Color:byte
    {
        Yellow,
        Blue,
        Brown,
        Green
    }
}
```
输出隐藏,复制Code
```
0
1
```
注意:每一个代码片段在本文中尝试和测试。唯一的变化是,我们指定底层enum类型声明。默认的枚举数据类型是int,这里我们有指定的数据类型字节和得到结果。有更多的数据类型,可以为枚举指定像长,ulong,短,ushort, int,使用uint,字节和sbyte。记住:我们不能声明字符作为枚举的基础数据类型对象因为字符存储Unicode字符,但是枚举对象数据类型只能是数字。继承在枚举 Program.cs 隐藏,收缩,复制Code
```
using System;
namespace Enums
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine((byte)Color.Yellow);
            Console.WriteLine((byte)Color.Blue);
            Console.ReadLine();
        }
    }

    enum Color:byte
    {
        Yellow,
        Blue,
        Brown,
        Green

    }

    enum Shades:Color
    {

    }
}
```
输出编译时错误:类型字节,sbyte短,ushort, int,单位,长,或ulong预期。我们清楚地看到枚举不能来自其他类型除了提到的错误。记住:枚举不能来自其他类型除了类型的字节,sbyte,短,ushort, int,单位,长,或ulong。让我们从枚举派生一个类,称之为类派生的,所以我们的代码。 Program.cs 隐藏,复制Code
```
class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine((byte)Color.Yellow);
            Console.WriteLine((byte)Color.Blue);
            Console.ReadLine();
        }
    }
```
枚举隐藏,复制Code
```
enum Color:byte
{
    Yellow,
    Blue,
    Brown,
    Green
}
```
Derived.cs 隐藏,复制Code
```
class Derived:Color
    {

    }
```
编译代码。输出编译时错误:“枚举。派生:不能来自密封类型Enums.Color” 图片来源:https://www.flickr.com/photos/lwr/931211869/ 记住:默认情况下,枚举是一个封闭的类,因此坚持所有密封类的规则,所以没有从enum类可以派生,即。,一个密封的类型。能系统。枚举是一个Enum基类? Program.cs 隐藏,复制Code
```
using System;

namespace Enums
{
    internal enum Color: System.Enum
    {
        Yellow,
        Blue
    }

    internal class Program
    {
        private static void Main(string[] args)
        {
        }
    }
}
```
输出编译时错误:类型字节,sbyte短,ushort, int,单位,长,或ulong预期。记住:隐式枚举类型来自系统。Enum所以我们不能显式地从System.Enum推导。添加更多,枚举也来源于三个接口IComparable, IFormattable IConvertible。答:IComparable 让我们检查, Program.cs 隐藏,复制Code
```
using System;

namespace Enums
{
    internal enum Color
    {
        Yellow,
        Blue,
        Green
    }

    internal class Program
    {
        private static void Main(string[] args)
        {
            Console.WriteLine(Color.Yellow.CompareTo(Color.Blue));
            Console.WriteLine(Color.Blue.CompareTo(Color.Green));
            Console.WriteLine(Color.Blue.CompareTo(Color.Yellow));
            Console.WriteLine(Color.Green.CompareTo(Color.Green));
            Console.ReadLine();
        }
    }
}
```
输出隐藏,复制Code
```
-1
-1
 1
 0
```
有时,我们可能进入的情况下大量的枚举定义我们想相互比较枚举的值检查如果他们更小,更大的或同等价值。因为所有的隐式枚举源自IComparable Enum类实现接口,它们都有一个方法CompareTo(),我们在上面的例子中使用。非静态的方法通过使用一个成员。黄色值0,蓝色1和绿色如2所示。在第一个语句,当颜色。黄颜色。蓝色,黄色的价值小于蓝色因此1回来的时候,同样申请第二个语句时的颜色。蓝色Color.Green相比。绿色具有更大的价值,即。2的颜色。蓝色有只值1。在第三次声明中,即首先声明,反之亦然,我们得到的结果camparison 1,因为蓝色比黄色。在最后一条语句的颜色。绿色比较本身,我们毫无疑问得到的值为0。所以意味着价值较小的值是1,1表示值大,0表示枚举成员的值都相等。另一个比较例子如下所示: Program.cs 隐藏,复制Code
```
using System;

namespace Enums
{
     enum Color
    {
        Yellow,
        Blue,
        Green
    }

    internal class Program
    {
        private static void Main(string[] args)
        {
            int myColor = 2;
            if(myColor== Color.Green)
            {
                Console.WriteLine("my color");
            }
           Console.ReadLine();
        }
    }
}
```
输出隐藏,复制Code
```
Compile time error : Operator '==' cannot be applied to operands of type 'int' and 'Enums.Color'
```
在上面的例子中,我们试图比较一个int类型和枚举类型和导致编译时错误。因为枚举作为个人数据类型,所以不能直接与int相比,但是,我们可以定型enum类型int执行比较,像下面的例子: 注意:每一个代码片段在本文中尝试和测试。 Program.cs 隐藏,复制Code
```
using System;

namespace Enums
{
     enum Color
    {
        Yellow,
        Blue,
        Green
    }

    internal class Program
    {
        private static void Main(string[] args)
        {
            int myColor = 2;
            if(myColor== (int)Color.Green)
            {
                Console.WriteLine("my color");
            }
           Console.ReadLine();
        }
    }
}
```
输出:我的颜色 b . IFormattable Program.cs 隐藏,复制Code
```
using System;

namespace Enums
{
    internal enum Color
    {
        Yellow,
        Blue,
        Green
    }

    internal class Program
    {
        private static void Main(string[] args)
        {
            System.Console.WriteLine(Color.Format(typeof(Color), Color.Green, "X"));
            System.Console.WriteLine(Color.Format(typeof(Color), Color.Green, "d"));
            Console.ReadLine();
        }
    }
}
```
输出隐藏,复制Code
```
00000002
2
```
格式是源自IFormatter接口的方法。这是一个静态方法,所以可以直接使用enum类定义为颜色。它的第一个参数是类型的枚举类,其次是会员需要格式化,第三是格式,即。,十六进制或十进制,就像我们在上面的例子中,使用,我们也有一个积极的结果输出。 c . IConvertible 隐藏,复制Code
```
using System;

namespace Enums
{
     enum Color
    {
        Yellow,
        Blue,
        Green
    }

    internal class Program
    {
        private static void Main(string[] args)
        {
            string[] names;
            names = Color.GetNames(typeof (Color));
            foreach (var name in names)
            {
                Console.WriteLine(name);
            }
            Console.ReadLine();
        }
    }
}
```
输出隐藏,复制Code
```
Yellow
Blue
Green
```
注意:每一个代码片段在本文中尝试和测试。 getname接受类型是一个静态方法,即。,实例作为一个参数类型和返回给一个字符串数组。就像在上面的例子中,我们有一系列3在我们枚举成员,因此他们的名字是显示一个接一个。另一个例子如下: Program.cs 隐藏,复制Code
```
using System;

namespace Enums
{
     enum Color
    {
        Yellow,
        Blue,
        Green
    }

    internal class Program
    {
        private static void Main(string[] args)
        {
           Console.WriteLine(Color.Blue.ToString());
           Console.WriteLine(Color.Green.ToString());
           Console.ReadLine();
        }
    }
}
```
输出隐藏,复制Code
```
Blue
Green
```
在上面的例子中我们看到,我们盯着类型和枚举类型转换输出,因此,许多预定义的转换方法可用于枚举转换到另一个从一个数据类型。记住:许多预定义的转换方法可用于枚举转换到另一个从一个数据类型。表里不一、默认值和初始化: Program.cs 隐藏,复制Code
```
using System;
namespace Enums
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine((byte)Color.Yellow);
            Console.WriteLine((byte)Color.Blue);
            Console.ReadLine();
        }
    }

    enum Color
    {
        Yellow,
        Blue,
        Brown,
        Green,
        Blue
    }
}
```
输出隐藏,复制Code
```
Compile time error: The type 'Enums.Color' already contains a definition for 'Blue'
```
在上面的例子中,我们只是重复枚举成员蓝色的颜色,我们有一个编译时错误,因此我们现在知道enum不能包含两个成员具有相同的名称。默认情况下,如果第一个值没有指定,第一个成员需要一个0和增量的价值成功成员。我们来看一个例子。 Program.cs 隐藏,复制Code
```
using System;
namespace Enums
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine((int)Color.Yellow);
            Console.WriteLine((int)Color.Blue);
            Console.WriteLine((int)Color.Brown);
            Console.WriteLine((int)Color.Green);

            Console.ReadLine();
        }
    }

    enum Color
    {
        Yellow =2,
        Blue,
        Brown=9,
        Green,

    }
}
```
输出隐藏,复制Code
```
2
3
9
10
```
惊讶!我们总是可以为任何枚举成员指定默认的常量值，这里我们看到，我们将值2指定为黄色，因此根据枚举定律，蓝色的值将增加1，得到值3。我们再次将9指定为Brown的默认值，因此它的后续绿色将增加1，并得到那个值10。继续看另一个例子。 Program.cs 隐藏,复制Code
```
using System;
namespace Enums
{
    class Program
    {
        static void Main(string[] args)
        {

        }
    }

    enum Color:byte
    {
        Yellow =300 ,
        Blue,
        Brown=9,
        Green,
    }
}
```
输出隐藏,复制Code
```
Compile time error: Constant value '300' cannot be converted to a 'byte'
```
我们刚刚从字节中获得了枚举，我们知道可以这样做吗?然后我们将黄色的值从2更改为300，从而导致了编译时错误。由于这里我们的基础数据类型是byte，所以就这么简单，我们不能为超出基础数据类型范围的枚举成员指定值。值300超出了字节的范围。它类似于将超出范围的值分配给字节数据类型变量。另一个例子: Program.cs 隐藏,复制Code
```
using System;
namespace Enums
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine((int)Color.Yellow);
            Console.WriteLine((int)Color.Blue);
            Console.WriteLine((int)Color.Brown);
            Console.WriteLine((int)Color.Green);

            Console.ReadLine();
        }
    }

    enum Color
    {
        Yellow = 2,
        Blue,
        Brown = 9,
        Green = Yellow
    }
}
```
输出隐藏,复制Code
```
2
3
9
2
```
在这里，我们将绿色初始化为黄色，并且没有得到任何错误，因此我们看到，可以将多个枚举成员初始化为相同的常数值。请记住:多个枚举成员可以初始化为相同的常数值。 Program.cs 隐藏,复制Code
```
using System;
namespace Enums
{
    class Program
    {
        static void Main(string[] args)
        {
            Color.Yellow = 3;
        }
    }

    enum Color
    {
        Yellow = 2,
        Blue,
        Brown = 9,
        Green = Yellow
    }
}
```
输出隐藏,复制Code
```
Compile time error: The left-hand side of an assignment must be a variable, property or indexer
```
在上面的例子中，我们尝试在定义枚举的范围之外初始化枚举成员，即。，并得到编译时错误。我们一定不要忘记枚举作为一个常量，它不能改变它的值。注意:枚举充当常量，因此初始化后不能改变它的值。可读性 Program.cs 隐藏,收缩,复制Code
```
using System;

namespace Enums
{
    internal enum Color
    {
        Yellow,
        Blue,
        Brown,
        Green
    }

    internal class Program
    {
        private static void Main(string[] args)
        {
            Console.WriteLine(CheckColor(Color.Yellow));
            Console.WriteLine(CheckColor(Color.Brown));
            Console.WriteLine(CheckColor(Color.Green));
            Console.ReadLine();
        }

        public static string CheckColor(Color color)
        {
            switch (color)
            {
                case Color.Yellow:
                    return "Yellow";
                case Color.Blue:
                    return "Blue";
                case Color.Brown:
                    return "Brown";
                case Color.Green:
                    return "Green";
                default:
                    return "no color";
            }
        }
    }
}
```
输出隐藏,复制Code
```
Yellow
Brown
Green
```
在上面的例子中，我们声明了一个包含各种颜色成员的enum颜色。有一个名为program的类，它包含一个名为CheckColor的静态方法，该方法有一个switch语句，它根据传递给方法的参数检查颜色。Enum颜色。在Main方法中，我们尝试访问CheckColor方法，传递各种参数。我们看到CheckColor方法中的switch语句可以接受传递的任何数据类型，在return case语句中使用该类型的名称而不是纯int号来比较结果。我们看到这使我们的程序更具可读性。因此枚举在使程序更具可读性和结构化、易于掌握方面发挥着重要作用。圆形的依赖 Program.cs 隐藏,复制Code
```
using System;

namespace Enums
{
    internal enum Color
    {
        Yellow=Blue,
        Blue
    }

    internal class Program
    {
        private static void Main(string[] args)
        {
        }
    }
}
```
输出隐藏,复制Code
```
Compile time error: The evaluation of the constant value for 'Enums.Color.Yellow' involves a circular definition
```
像常量一样，枚举中也不能有循环依赖关系。我们将值Blue赋值给Yellow，而Blue作为下一个enum成员依次递增1，这导致了蓝色对黄色的循环依赖，并导致了错误，c#足够聪明来捕捉这些技巧。潜水深度让我们来看一些复杂的场景: Lab1 Program.cs 隐藏,复制Code
```
using System;

namespace Enums
{
     enum Color
    {

    }

    internal class Program
    {
        private static void Main(string[] args)
        {
            Color color = (Color) -1;
           Console.ReadLine();
        }
    }
}
```
注意:每一个代码片段在本文中尝试和测试。输出隐藏,复制Code
```
Compile time error: 
To cast a negative value, you must enclose the value in parentheses
'Enums.Color' is a 'type' but is used like a 'variable'
```
在上面的例子中，我们将一个负值转换为枚举，但是编译器说，在转换负值时，我们必须将其保留在括号中。这并不奇怪，因为c#知道“-”也是一个一元运算符，当使用上面的代码时可能会给编译器造成混淆，我们正在使用减法或类型转换一个负值。所以在类型转换负值时，总是使用括号。 Lab2 Program.cs 隐藏,复制Code
```
using System;

namespace Enums
{
     enum Color
    {
      value__
    }

    internal class Program
    {
        private static void Main(string[] args)
        {

        }
    }
}
```
输出隐藏,复制Code
```
Compile time error: The enumerator name 'value__' is reserved and cannot be used
```
我们可以清楚地看到，我们有value_作为枚举器的保留成员。像这个关键字这样的c#编译器有大量保留的内建关键字。图片来源:www.vector.rs 它可能保留这个保留关键字来在内部跟踪枚举成员，但不确定。总结让我们回忆一下所有需要记住的点。枚举表示一个常量，枚举类型称为具有命名常量的不同类型。我们不能将char声明为枚举对象的底层数据类型，因为char存储Unicode字符，但枚举对象的数据类型只能是number。枚举不能从任何其他类型派生，除了类型byte, sbyte, short, us短，int, uint, long，或ulong。默认情况下，enum是一个密封类，因此它遵守密封类所遵循的所有规则，因此没有类可以从enum派生，即。，密封型。enum类型隐式派生自System。所以我们不能明确地从system。enum还派生自三个界面:通用、IFormattable和iconverable。可以使用许多预定义的转换方法将枚举从一种数据类型转换为另一种数据类型。同一个常数值可以初始化多个枚举成员。enum充当常量，因此初始化后不能更改其值。枚举器名称“value_”被保留，不能使用。结论在本文中,我们通过完成几乎所有的场景与枚举。我们实验室做了很多实践明确概念。我希望我的读者现在用心了解这些基本概念和永远不会忘记他们。这些也可以帮助你在c#采访。保持编码和享受阅读。同时,不要忘记评价/评论/喜欢我的文章,如果以任何方式帮助你,这有助于我得到激励,鼓励我写的越来越多。我的其他系列文章: MVC: http://www.codeproject.com/Articles/620195/Learning-MVC-Part-Introduction-to-MVC-Architectu RESTful webapi: http://www.codeproject.com/Articles/990492/RESTful-Day-sharp-Enterprise-Level-Application 编码快乐! 本文转载于：http://www.diyabc.com/frontweb/news1960.html
相关阅读:
mysql面试知识点
 计算机网络
 BFS
拓扑排序
 双指针
 回溯算法
 hash表算法模板和相关题目
 桶排序及其应用
 滑动窗口
 贪心算法
原文地址：https://www.cnblogs.com/Dincat/p/13456721.html