1 C# 基础篇

概述

C# 是一个现代的，通用的，面向对象的编程语言，由微软 ( Microsoft ) 开发并获得欧洲计算机制造商协会 ( ECMA ) 和国际标准化组织 ( ISO ) 认可。

C# 由 Anders Hejlsberg 和他的团队在 .Net 的框架开发期间开发。

C# 是专为公共语言基础结构 ( CLI ) 设计的，包括可执行代码和运行环境，允许在不同的计算机系统和体系结构上使用各种高级语言。

下面列出了 C# 成为一种广泛应用的专业语言的原因：

• 它是一种现代的、通用的编程语言。
• 它是面向对象的。
• 它是面向组件的。
• 它是容易学习的。
• 它是一种结构化语言。
• 它产生高效的程序。
• 它可以在多种计算机平台上编译。
• 它是 .Net 框架的一部分。

强大的编程功能

C# 的架构十分接近于传统高级语言 C 和 C++，是一门面向对象的编程语言。它与 Java 非常相似，有许多强大的编程功能，因此得到世界范围内广大程序员的亲睐。

下面列出 C# 一些重要的功能：

• 布尔条件（Boolean Conditions）
• 自动垃圾回收（Automatic Garbage Collection）
• 标准库（Standard Library）
• 组件版本（Assembly Versioning）
• 属性（Properties）和事件（Events）
• 委托（Delegates）和事件管理（Events Management）
• 易于使用的泛型（Generics）
• 索引器（Indexers）
• 条件编译（Conditional Compilation）
• 简单的多线程（Multithreading）
• LINQ 和 Lambda 表达式
• 集成 Windows

环境配置

在这一章中，我们将讨论创建 C# 编程所需要的工具。我们已经提到过 C# 是 .Net 框架的一部分， 且用于编写 .Net 应用程序。因此，在讨论运行一个 C# 程序的可用工具之前，让我们先了解一下 C# 与 .Net 框架之间的关系。

.Net 框架

.Net 框架是一个革命性的平台，能帮您编写出下面类型的应用程序：

• Windows 应用程序
• Web 应用程序
• Web 服务

.Net 框架应用程是多平台的应用程序。框架的设计方式使它适用于下列各种语言：C#、C++、Visual Basic、Jscript、COBOL 等等。所有这些语言可以访问框架，并且彼此之间可以互相交互。

.Net 框架由一个巨大的代码库组成，用于 C# 等客户端语言。下面列出一些 .Net 框架的组件：

• 公共语言运行库（Common Language Runtime - CLR）
• .Net 框架类库（.Net Framework Class Library）
• 公共语言规范（Common Language Specification）
• 通用类型系统（Common Type System）
• 元数据（Metadata）和组件（Assemblies）
• Windows 窗体（Windows Forms）
• ASP.Net 和 ASP.Net AJAX
• ADO.Net
• Windows 工作流基础（Windows Workflow Foundation - WF）
• Windows 显示基础（Windows Presentation Foundation）
• Windows 通信基础（Windows Communication Foundation - WCF）
• LINQ

如需了解每个组件的功能，请参阅 ASP.Net - Introduction ，更详细的信息，请参阅微软（Microsoft）的文档。

C# 的集成开发环境 (IDE)

微软提供了下列用于 C# 编程的开发工具：

• Visual Studio 2010 (VS)
• Visual C# 2010 Express (VCE)
• Visual Web Developer

后面两个是免费使用的，可从微软官方网址下载。使用这些工具，您可以编写各种 C# 程序， 从简单的命令行应用程序到更复杂的应用程序。您也可以使用基本的文本编辑器编写 C# 源代码文件，比如 Notepad，并使用命令行编译器（.NET 框架的一部分），编译代码成组件。

Visual C# Express 和 Visual Web Developer Express 版本是 Visual Studio 的定制版本，且具有相同的外观和感观。它们保留 Visual Studio 的大部分功能。 在本教程中，我们使用的是 Visual C# 2010 Express。

您可以从 Microsoft Visual Studio 上进行下载。它会自动安装在您的机器上。请注意，您在完成速成版的安装时需要提供一个可用的网络连接。

在 Linux 或 Mac OS 上编写 C# 程序

虽然 .NET 框架是运行在 Windows 操作系统上，但是也有一些运行于其它操作系统上的版本可供选择。 Mono 是 .NET 框架的一个开源版本， 它包含了一个 C# 编译器，且可运行于多种操作系统上，比如各种版本对 Linux 和 Mac OS 的支持。如需了解更多详情，请访问 Go Mono 。

Mono 的目的不仅仅是跨平台地运行微软 .NET 应用程序，而且也为 Linux 开发者提供了更好的开发工具。 Mono 可运行在多种操作系统上，包括 Android、BSD、iOS、Linux、OS X、Windows、Solaris 和 UNIX。

程序结构

在我们学习 C# 编程语言的基础构件块之前，让我们先看一下 C# 的最小的程序结构， 以便作为接下来章节的参考。

创建 Hello World 实例

一个 C# 程序主要包括以下部分：

• 命名空间声明
• 一个类
• 类方法
• 类属性
• 一个 Main 方法
• 语句和表达式
• 注释

让我们看一个可以打印出 "Hello World" 的简单的代码：

using System;
namespace HelloWorldApplication
{
   class HelloWorld
   {
      static void Main(string[] args)
      {
         /* 我的第一个 C# 程序*/
         Console.WriteLine("Hello World");
         Console.ReadKey();
      }
   }
}

编译执行上述代码，得到如下结果：

Hello World

让我们看一下上面给出程序的各个部分：

• 程序的第一行 using System;-using 关键字用于在程序中包含 System 命名空间。 一个程序一般有多个 using 语句。
• 下一行是 namespace 声明。一个 namespace 是一系列的类。HelloWorldApplication 命名空间包含了类 HelloWorld 。
• 下一行是 class 声明。类 HelloWorld 包含了程序所使用的数据和方法的声明。类一般包含多个方法。方法定义了类的行为。 在这里，HelloWorld 类只有一个 Main 方法。
• 下一行定义了 Main 方法，是所有 C# 程序的入口。Main 方法说明当类执行时，它将做什么动作。
• 下一行 /…/ 将会被编译器忽略，且它会在程序中添加注释 。
• Main 方法通过语句 Console.WriteLine("Hello World"); 指定了它的行为。 WriteLine 是一个定义在 System 命名空间中的 Console 类的一个方法。该语句会在屏幕上显示消息 "Hello, World!" 。
• 最后一行 Console.ReadKey(); 是针对 VS.NET 用户的。这使得程序会等待一个用户按键的动作，防止程序在 Visual Studio .NET 启动时屏幕会快速运行并关闭。

以下几点值得注意：

• C# 是大小写敏感的。
• 所有的语句和表达式必须以分号（;）结尾。
• 程序的执行从 Main 方法开始。
• 与 Java 不同的是，文件名可以不同于类的名称。

编译执行 C# 程序

如果您使用 Visual Studio.Net 编译和执行 C# 程序，请按下面的步骤进行：

• 启动 Visual Studio。
• 在菜单栏上，选择 File -> New -> Project。
• 从模板中选择 Visual C#，然后选择 Windows。
• 选择 Console Application。
• 为您的项目制定一个名称，然后点击 OK 按钮。
• 新项目会出现在解决方案资源管理器中。
• 在代码编辑器中编写代码。
• 点击 Run 按钮或者按下 F5 键来运行程序。会出现一个命令提示符窗口，显示 Hello World。

您也可以使用命令行代替 Visual Studio IDE 来编译 C# 程序：

• 打开一个文本编辑器，添加上面提到的代码。
• 保存文件为 helloworld.cs。
• 打开命令提示符工具，定位到文件所保存的目录。
• 键入 csc helloworld.cs 并按下回车键来编译代码。
• 如果代码没有错误，命令提示符会进入下一行，并生成 helloworld.exe 可执行文件。
• 接下来，键入 helloworld 来执行程序。
• 您将看到 "Hello World" 打印在屏幕上。

基本语法

C# 是一种面向对象的编程语言。在面向对象的程序设计方法中，程序由各种相互作用的对象组成。一个对象采取的动作称为方法。 相同种类的对象通常具有相同的属性，或者说，是在相同的类中。

例如，以 Rectangle（矩形）对象为例。它具有 length 和 width 属性。 根据设计，它可能需要接受这些属性值、计算面积和显示细节的方法。

让我们来看看一个 Rectangle（矩形）类的实现，并借此讨论 C# 的基本语法：

using System;
namespace RectangleApplication
{
    class Rectangle
    {
        // member variables
        double length;
        double width;
        public void Acceptdetails()
        {
            length = 4.5;    
            width = 3.5;
        }
        public double GetArea()
        {
            return length * width;
        }
        public void Display()
        {
            Console.WriteLine("Length: {0}", length);
            Console.WriteLine("Width: {0}", width);
            Console.WriteLine("Area: {0}", GetArea());
        }
    }
 
    class ExecuteRectangle
    {
        static void Main(string[] args)
        {
            Rectangle r = new Rectangle();
            r.Acceptdetails();
            r.Display();
            Console.ReadLine();
        }
    }
}

编译执行上述代码，得到如下结果：

Length: 4.5
Width: 3.5
Area: 15.75

using 关键字

在任何 C# 程序中的第一条语句都是：

using System;

using 关键字用于在程序中包含命名空间。一个程序可以包含多个 using 语句。

class 关键字

class 关键字用于声明一个类。

C# 中的注释

注释用于解释代码。编译器会忽略注释的部分。在 C# 程序中，多行注释以 / 开始，并以字符 / 终止，如下所示：

/* This program demonstrates
The basic syntax of C# programming 
Language */

单行注释是用 '//' 符号表示。例如：

}//end class Rectangle

成员变量

变量是一个类的属性或数据成员，用于存储数据。在上面的程序中，Rectangle 类有两个成员变量，名为 length 和 width 。

成员函数

函数是一系列执行特定任务的语句。类的成员函数是在类内声明的。我们举例的类 Rectangle 包含了三个成员函数： AcceptDetails、GetArea 和 Display 。

实例化一个类

在上面的程序中，类 ExecuteRectangle 是一个包含 Main() 方法和实例化 Rectangle 类的类。

标识符

标识符是用来识别类、变量、函数或任何其它用户定义的项目。在 C# 中，类的命名必须遵循如下基本规则：

• 标识符必须以字母开头，后面可以跟一系列的字母、数字（0 - 9）或下划线（_）。标识符中的第一个字符不能是数字。
• 标识符必须不包含任何嵌入的空格或符号，比如 ? - + ! @ # % ^ & * ( ) [ ] { } . ; : " ' / \。但是，可以使用下划线（_）。
• 标识符不能是 C# 关键字。

C# 关键字

关键字是 C# 编译器预定义的保留字。这些关键字不能用作标识符，但是，如果您想使用这些关键字作为标识符，可以在关键字前面加上 @ 字符作为前缀。

在 C# 中，有些标识符在代码的上下文中有特殊的意义，如 get 和 set，这些被称为上下文关键字。

下表列出了 C# 中的保留关键字（Reserved Keywords）和上下文关键字（Contextual Keywords）：

数据类型

在 C# 中，变量分为以下几种类型：

• 值类型（Value types）
• 引用类型（Reference types）
• 指针类型（Pointer types）

值类型

值类型变量可以直接分配给其一个值。它们是从类 System.ValueType 中派生的。

值类型直接包含数据。比如 int、char、float，它们分别存储数字、字母和浮点数。当您声明一个 int 类型的变量时，系统将会分配内存来存储它的值。

下表列出了 C# 2010 中可用的值类型：

如需得到一个类型或一个变量在特定平台上的准确大小，可以使用 sizeof 方法。表达式 sizeof(type) 产生以字节 为单位存储对象或类型的存储尺寸。下面举例获取任何机器上 int 类型的存储大小：

namespace DataTypeApplication
{
   class Program
   {
      static void Main(string[] args)
      {
         Console.WriteLine("Size of int: {0}", sizeof(int));
         Console.ReadLine();
      }
   }
}

编译执行上述代码，得到如下结果：

Size of int: 4

引用类型

引用类型不包含存储在变量中的实际数据，但它们包含对变量的引用。

换句话说，它们指向的是一个内存位置。使用多重变量时，引用类型可以指向一个内存位置。 如果内存位置的数据是由多重变量之中的一个改变的，其他变量会自动相应这种值的变化。 例如，内置的引用类型有：object、dynamic 和 string。

对象类型

对象类型是 C# 通用类型系统（CTS）中所有数据类型基类。 Object 是 System.Object 类的别名。 对象类型可以被分配任何其他类型（值类型、引用类型、预定义类型或用户自定义类型）的值。但是，在分配值之前，需要先进行类型转换。

当一个值类型转换为对象类型时，则被称为装箱；另一方面，当一个对象类型转换为值类型时，则被称为拆箱。

object obj;
obj = 100; // 这是装箱

动态类型

您可以在动态数据类型变量中存储任何类型的值。这些变量的类型检查是在运行时进行的。

声明动态类型的语法：

dynamic <variable_name> = value;

例如：

dynamic d = 20;

动态类型与对象类型相似，但是对象类型变量的类型检查是在编译时进行的，而动态类型变量的类型检查是在运行时进行的。

字符串类型

字符串 类型允许您给变量分配任何字符串值。字符串类型是 System.String 类的别名。它是从对象类型派生的。字符串类型的值可以通过两种形式进行分配：引号和 @ 引号。

例如：

String str = "Tutorials Point";

一个 @ 引号字符串：

@"Tutorials Point";

用户自定义引用类型有：class、interface 或 delegate。我们将在以后的章节中讨论这些类型。

指针类型

指针类型变量存储另一种类型的内存地址。C# 中的指针与 C 或 C++ 中的指针有相同的功能。

声明指针类型的语法：

type* identifier;

例如：

char* cptr;
int* iptr;

我们将在章节"不安全的代码"中讨论指针类型。

类型转换

类型转换是把数据从一种类型转换为另一种类型。在 C# 中，类型转换有两种形式：

• 隐式类型转换 这些转换是 C# 默认的以安全方式进行的转换。例如，从小的整数类型转换为大的整数类型，从派生类转换为基类。
• 显式类型转换 这些转换是通过用户使用预定义的函数显示完成的。显式转换需要强制转换运算符。

下面的实例显示了一个显式的类型转换：

namespace TypeConversionApplication
{
    class ExplicitConversion
    {
        static void Main(string[] args)
        {
            double d = 5673.74;
            int i;
 
            // 强制转换 double 为 int
            i = (int)d;
            Console.WriteLine(i);
            Console.ReadKey();
 
        }
    }
}

编译执行上述代码，得到如下结果：

5673

C# 类型转换方法

C# 提供了下列内置的类型转换方法：

下面的实例把不同值类型变量转换为字符串类型变量：

namespace TypeConversionApplication
{
    class StringConversion
    {
        static void Main(string[] args)
        {
            int i = 75;
            float f = 53.005f;
            double d = 2345.7652;
            bool b = true;
 
            Console.WriteLine(i.ToString());
            Console.WriteLine(f.ToString());
            Console.WriteLine(d.ToString());
            Console.WriteLine(b.ToString());
            Console.ReadKey();
 
        }
    }
}

编译执行上述代码，得到如下结果：

75
53.005
2345.7652
True

变量

一个变量只不过是一个供程序操作的存储区的名字。在 C# 中，每个变量都有一个特定的类型，类型决定了变量的内存大小、布局、可以存储在内存中的值的范围以及可以对变量进行的一系列操作。

C# 中提供的基本的值类型大致可以分为以下几类：

C# 允许定义其他值类型的变量，比如 enum，也允许定义引用类型变量，比如 class。这些我们将在以后的章节中进行讨论。

变量定义

C# 中变量定义的语法：

<data_type> <variable_list>;

在这里，data_type 必须是一个有效的 C# 数据类型，可以是 char、int、float、double 或其他用户自定义的数据类型。variable_list 可以由一个或多个用逗号分隔的标识符名称组成。

一些有效的变量定义如下所示：

int i, j, k;
char c, ch;
float f, salary;
double d;

您可以在定义一个变量时对其进行初始化：

int i = 100;

变量初始化

变量通过等号后的一个常量表达式进行初始化（也就是赋值）。初始化的一般语法为：

variable_name = value;

变量可以在声明时被初始化。初始化由等号后的一个常量表达式完成，如下所示：

<data_type> <variable_name> = value;

一些实例：

int d = 3, f = 5;    /* 初始化 d 和 f. */
byte z = 22;         /* 初始化 z. */
double pi = 3.14159; /* 声明 pi 的近似值 */
char x = 'x';        /* 变量 x 的值为 'x' */

适时地初始化变量是一个良好的编程习惯，否则有时程序会产生意想不到的结果。

请看下面的实例，使用了各种类型的变量：

namespace VariableDefinition
{
    class Program
    {
        static void Main(string[] args)
        {
            short a;
            int b ;
            double c;
 
            /* 实际初始化 */
            a = 10;
            b = 20;
            c = a + b;
            Console.WriteLine("a = {0}, b = {1}, c = {2}", a, b, c);
            Console.ReadLine();
        }
    }
}

编译执行上述代码，得到如下结果：

a = 10, b = 20, c = 30

接受来自用户的值

System 命名空间中的 Console 类提供了一个函数 ReadLine()，用于接收来自用户的输入，并把它存储到一个变量中。 例如：

int num;
num = Convert.ToInt32(Console.ReadLine());

函数 Convert.ToInt32() 把用户输入的数据转换为 int 数据类型，因为函数 Console.ReadLine() 只接受字符串格式的数据。

C# 中的 Lvalues 和 Rvalues

在 C# 中的两种表达式：

• lvalue：lvalue 表达式可以出现在赋值语句的左边或右边。
• rvalue：rvalue 表达式可以出现在赋值语句的右边，不能出现在赋值语句的左边。

变量是 lvalue 的，所以可以出现在赋值语句的左边。数值是 rvalue 的，因此不能被赋值，也不能出现在赋值语句的左边。下面是一个有效的语句：

int g = 20;

下面是一个无效的语句，会在编译时产生错误：

10 = 20;

常量和文字

常量是固定值，程序执行期间不会改变。这些固定值也被称为文字。常量可以是任何基本数据类型，如整数常量，浮点常量，字符常量或者字符串常量，还有枚举常量。

常量可以被当作常规的变量，只是它们的值在定义后不能被修改。

整数常量

整数常量可以是十进制、八进制、或十六进制的常量。前缀指定基或基数：0x 或 0X 表示十六进制，0 表示八进制，没有前缀则表示十进制。

整数常量也可以有后缀，可以是 U 和 L 的组合，其中 U 和 L 分别表示 unsigned 和 long。后缀可以是大写或小写，多个后缀以任意顺序进行组合。

这里是一些整数常量的例子：

212         /* 合法 */
215u        /* 合法 */
0xFeeL      /* 合法 */
078         /* 非法: 8 不是一个八进制数字 */
032UU       /* 非法: 不能重复后缀 */

以下是各种类型的整数常量的实例：

85         /* 十进制 */
0213       /* 八进制 */
0x4b       /* 十六进制 */
30         /* int */
30u        /* 无符号 int */
30l        /* long */
30ul       /* 无符号 long */

浮点常量

一个浮点常量是由整数部分，小数点，小数部分和指数部分组成。您可以使用小数形式或指数形式来表示浮点常量。

这里是一些浮点常量的例子：

3.14159       /* 合法 */
314159E-5L    /* 合法 */
510E          /* 非法: 不完全指数 */
210f          /* 非法: 没有小数或指数 */
.e55          /* 非法: 缺少整数或小数 */

使用小数形式表示时，必须包含小数点、指数或同时包含两者。使用指数形式表示时，必须包含整数部分、小数部分或同时包含两者。有符号的指数是用 e 或 E 表示的。

字符常量

字符常量是括在单引号里，例如 'x'，并可以存储在一个简单的字符类型变量中。一个字符常量可以是一个普通字符（例如 'x'）、一个转义序列（例如 '\t'）或一个通用字符（例如 '\u02C0'）。

在 C# 中有一些特定的字符，当它们的前面带有反斜杠时有特殊的意义，可用于表示换行符（\n）或制表符（\t）。在这里，列出一些转义序列码：

下面的实例说明了一些转义字符序列：

using System;
namespace EscapeChar 
{
   class Program
   {
      static void Main(string[] args)
      {
         Console.WriteLine("Hello\tWorld\n\n");
         Console.ReadLine();
      }
   }
}

编译执行上述代码，得到如下结果：

Hello   World

字符串常量

字符串常量是括在双引号""里，或者是括在@""里。字符串常量包含的字符类似于字符常量，可以是普通字符、转义序列和通用字符。

使用字符串常量时，可以把一个很长的行拆成多个行，可以使用空格分隔各个部分。

这里是一些字符串常量的例子。下面所列的各种形式表示相同的字符串。

"hello, dear"
"hello, \
dear"
"hello, " "d" "ear"
@"hello dear"

定义常量

常量是使用 const 关键字来定义的。定义一个常量的语法如下：

const <data_type> <constant_name> = value;

下面的代码演示了如何在程序中定义和使用常量：

using System;
namespace DeclaringConstants
{
    class Program
    {
        static void Main(string[] args)
        {
            const double pi = 3.14159;  // 常量声明
            double r;
            Console.WriteLine("Enter Radius: ");
            r = Convert.ToDouble(Console.ReadLine());
            double areaCircle = pi * r * r;
            Console.WriteLine("Radius: {0}, Area: {1}", r, areaCircle);
            Console.ReadLine();
        }
    }
}

编译执行上述代码，得到如下结果：

Enter Radius: 
3
Radius: 3, Area: 28.27431

运算符

运算符是一种告诉编译器执行特定的数字或逻辑操作的符号。C# 中有丰富的内置运算符，分类如下：

• 算术运算符
• 关系运算符
• 逻辑运算符
• 位运算符
• 赋值运算符
• 其它运算符

本教程将逐一讲解算运算符、关系运算符、逻辑运算符、位运算符、赋值运算符和其他运算符。

算术运算符

下表列出了 C# 支持的所有算术运算符。假设变量 A 的值为10，变量 B 的值为20，则：

算术运算符实例

关系运算符

下表列出了 C# 支持的所有关系运算符。假设变量 A 的值为10，变量 B 的值为 20，则：

关系运算符实例

逻辑运算符

下表列出了 C# 所支持的所有逻辑运算符。假设变量 A 为布尔值 true，变量 B 为布尔值 false，则：

逻辑运算符实例

位运算符

位运算符作用于位，并逐位执行操作。&、| 和 ^ 的真值表如下：

假设，如果 A=60，B=13，现以二进制格式表示如下：

A = 0011 1100

B = 0000 1101

A & B = 0000 1100

A | B = 0011 1101

A ^ B = 0011 0001

~A = 1100 0011

下表列出了 C# 支持的位运算符。假设变量 A 的值为60，变量 B 的值为13 则：

位运算符示例

赋值运算符

下表列出了 C# 支持的赋值运算符：

赋值运算符实例

其它运算符

下表列出了 C# 支持的其他一些重要的运算符，包括 sizeof，typeof 运算和? :。

其它运算符实例

C# 运算符优先级

运算符优先级确定表达式中项的组合。这会影响到一个表达式如何计算。某些运算符比其他运算符有更高的优先级，例如，乘除运算符比加减运算符的优先级高：

例如 X = 7 + 3 2；这里，x 被赋值为 13，而不是 20，因为运算符 的优先级高于 +，所以这里首先进行 3*2 运算，然后再加上 7。

下表按运算符优先级从高到低列出各个运算符，具有较高优先级的运算符出现在表格上面，具有较低优先级的运算符出现在表格下面。在表达式中，较高优先级的运算符会优先被运算。

运算符优先级实例

判断

判断结构需要程序员指定一个或多个要评估或测试的条件，以及条件为真时要执行的语句（必需的）和条件为假时要执行的语句（可选的）。

下面是大多数编程语言中典型判断结构的一般形式：

图片 1.1 image

C# 提供了以下类型的判断语句。点击链接查看每个语句的详细信息。

? : 运算符：

我们已经在前面的章节中介绍了条件运算符 ? : ，可以用来代替 if…else 语句。它的一般形式如下：

Exp1 ? Exp2 : Exp3;

其中，Exp1、Exp2 和 Exp3 是表达式。请注意，冒号的使用和放置。

? 表达式的值是由 Exp1 决定的。如果 Exp1 为真，则计算 Exp2 的值，结果即为整个?表达式的值。如果 Exp1 为假，则计算 Exp3 的值，结果即为整个?表达式的值。

循环

有的情况下，可能需要多次执行同一块代码。一般情况下，语句是顺序执行的：函数中的第一个语句先执行，然后是第二个语句，以此类推。

编程语言提供了允许更为复杂的执行路径的多种控制结构。

循环语句允许我们多次执行一个语句或语句组，下面是大多数编程语言中循环语句的一般形式：

图片 1.2 image

C# 提供了以下几种类型的循环类型。点击链接查看每个类型的详细信息。

循环控制语句

循环控制语句更改执行的正常序列。当执行离开一个范围时，所有在该范围内创建的自动对象都会被销毁。

C# 提供了以下控制语句。点击链接查看每个语句的详细信息。

无限循环

如果条件永远不为假，则循环将变为无限循环。for 循环在传统意义上可用于实现无限循环。由于构成循环的三个表达式中任何一个都不是必需的，您可以将某些条件表达式留空来构成一个无限循环。

举例

using System;
namespace Loops
{
   class Program
   {
      static void Main(string[] args)
      {
         for (; ; )
         {
            Console.WriteLine("Hey! I am Trapped");
         }
      }
   }
}

当条件表达式不存在时，它被假定为真。您也可以设置一个初始值和增量表达式，但一般情况下，程序员偏向于使用 for(;;) 结构来表示一个无限循环。

封装

封装被定为义为“把一个或多个项目封闭在一个物理的或者逻辑的包中”。在面向对象程序设计方法论中，封装是为了防止对实现细节的访问。

抽象和封装是面向对象程序设计的相关特性。抽象允许相关信息可视化，封装使程序员实现所需级别的抽象。

封装使用访问修饰符来实现。一个访问修饰符定义了一个类成员的范围和可见性。C# 支持的访问修饰符如下所示：

• Public
• Private
• Protected
• Internal
• Protected internal

Public 访问修饰符

Public 访问修饰符允许一个类将其成员变和成员函数暴露给其他的函数和对象。任何公有成员可以被外部的类访问。

下面的例子说明了这点：

using System;
namespace RectangleApplication
{
   class Rectangle
   {
      //成员变量
      public double length;
      public double width;
 
      public double GetArea()
      {
         return length * width;
      }
      public void Display()
      {
         Console.WriteLine("长度: {0}", length);
         Console.WriteLine("宽度: {0}", width);
         Console.WriteLine("面积: {0}", GetArea());
      }
   }//end class Rectangle
 
   class ExecuteRectangle
   {
      static void Main(string[] args)
      {
         Rectangle r = new Rectangle();
         r.length = 4.5;
         r.width = 3.5;
         r.Display();
         Console.ReadLine();
      }
   }
}

编译执行上述代码，得到如下结果：

长度: 4.5
宽度: 3.5
面积: 15.75

在上面的例子中，成员变量 length 和 width 被声明为 public，所以它们可以被函数 Main() 使用 Rectangle 类的实例 r 访问。

成员函数 Display() 和 GetArea() 也可以不通过类的实例直接直接访问这些变量。

成员函数 Display() 也被声明为 public，所以从它也能被 Main() 使用 Rectangle 类的实例 r 访问。

Private 访问修饰符

Private 访问修饰符允许一个类将其成员变量和成员函数对其他的函数和对象进行隐藏。只有同一个类中的函数可以访问它的私有成员。即使是类的实例也不能访问它的私有成员。

下面的例子说明了这点：

using System;
namespace RectangleApplication 
{
   class Rectangle
   {
      //成员变量
      private double length;
      private double width;
 
      public void Acceptdetails()
      {
         Console.WriteLine("请输入长度: ");
         length = Convert.ToDouble(Console.ReadLine());
         Console.WriteLine("请输入宽度: ");
         width = Convert.ToDouble(Console.ReadLine());
      }
      public double GetArea()
      {
         return length * width;
      }
      public void Display()
      {
         Console.WriteLine("长度: {0}", length);
         Console.WriteLine("宽度: {0}", width);
         Console.WriteLine("面积: {0}", GetArea());
      }
   }//end class Rectangle
 
   class ExecuteRectangle
   {
      static void Main(string[] args)
      {
         Rectangle r = new Rectangle();
         r.Acceptdetails();
         r.Display();
         Console.ReadLine();
      }
   }
}

编译执行上述代码，得到如下结果：

请输入长度:
4.4
请输入宽度:
3.3
长度: 4.4
宽度: 3.3
面积: 14.52

在上面的例子中，成员变量 length 和 width 被声明为 private，所以它们不能被函数 Main() 访问。成员函数 AcceptDetails() 和 Display() 可以访问这些变量。由于成员函数 AcceptDetails() 和 Display() 被声明为 public，所以它们可以被 Main() 函数使用 Rectangle 类的实例 r 访问。

Protected 访问修饰符

Protected 访问修饰符允许子类访问它的基类的成员变量和成员函数。这种方式有助于实现继承。我们将在继承的章节详细讨论这个问题。

Internal 访问修饰符

Internal 访问修饰符允许一个类将其成员变量和成员函数暴露给当前程序中的其他函数和对象。换句话说，带有 Internal 访问修饰符的任何成员可以被定义在该成员所定义的应用程序内的任何类或方法访问。

下面的例子说明了这点：

using System;
namespace RectangleApplication
{
   class Rectangle
   {
      //成员变量
      internal double length;
      internal double width;
 
      double GetArea()
      {
         return length * width;
      }
      public void Display()
      {
         Console.WriteLine("长度: {0}", length);
         Console.WriteLine("宽度: {0}", width);
         Console.WriteLine("面积: {0}", GetArea());
      }
   }//end class Rectangle
 
   class ExecuteRectangle
   {
      static void Main(string[] args)
      {
         Rectangle r = new Rectangle();
         r.length = 4.5;
         r.width = 3.5;
         r.Display();
         Console.ReadLine();
      }
   }
}

编译执行上述代码，得到如下结果：

长度: 4.5
宽度: 3.5
面积: 15.75

在上面的例子中，请注意成员函数 GetArea() 声明的时候不带有任何访问修饰符。如果没有指定访问修饰符，则使用类成员的默认访问修饰符，即为 private。

Protected internal 访问修饰符

Protected internal 访问修饰符允许一个类将其成员变量和成员函数对同一应用程内的子类以外的其他的类对象和函数进行隐藏。这也被用于实现继承。

方法

方法是一组在一起执行任务的语句。每个 C# 程序都至少有一个含有方法的类，名为 Main。

若要使用方法，您需要：

• 定义一个方法
• 调用方法

在 C# 中定义方法

当你定义一个方法时，你基本上要声明其结构的组成元素。在 C# 中定义方法的语法如下所示：

<Access Specifier> <Return Type> <Method Name>(Parameter List)
{
   Method Body
}

以下是方法中的各种元素：

• 访问说明符：它用于从一个类中确定一个变量或方法的可见性。
• 返回类型：方法可能会返回一个值。返回类型是方法返回值的数据类型。如果该方法不返回任何值，那么返回类型是 void。
• 方法名称：方法名称是唯一的标识符，并区分大小写。它不能与在类中声明的任何其他标识符相同。
• 参数列表：括号括起来，使用参数从方法中传递和接收数据。参数列表是指类型、顺序和方法的参数数目。参数是可选的；方法可能包含任何参数。
• 方法主体：它包含的一组指令完成所需要的活动所需。

示例

下面的代码段显示了一个函数 FindMax，从两个整数值中，返回其中较大的一个。它具有公共访问说明符，所以它可以通过使用类的外部例子来访问。

class NumberManipulator
{
   public int FindMax(int num1, int num2)
   {
      /* local variable declaration */
      int result;
 
      if (num1 > num2)
         result = num1;
      else
         result = num2;
 
      return result;
   }
   ...
}

在 C# 中调用方法

你可以使用方法的名称来调用方法。下面的示例说明了这一点：

using System;
namespace CalculatorApplication
{
   class NumberManipulator
   {
      public int FindMax(int num1, int num2)
      {
         /* local variable declaration */
         int result;
 
         if (num1 > num2)
            result = num1;
         else
            result = num2;
         return result;
      }
      static void Main(string[] args)
      {
         /* local variable definition */
         int a = 100;
         int b = 200;
         int ret;
         NumberManipulator n = new NumberManipulator();
 
         //calling the FindMax method
         ret = n.FindMax(a, b);
         Console.WriteLine("Max value is : {0}", ret );
         Console.ReadLine();
      }
   }
}

编译执行上述代码，得到如下结果：

Max value is : 200

你也可以通过使用类的实例来从其他类中调用公开方法。

例如，FindMax 它属于 NumberManipulator 类中的方法，你可以从另一个类测试中调用它。

using System;
namespace CalculatorApplication
{
   class NumberManipulator
   {
      public int FindMax(int num1, int num2)
      {
         /* local variable declaration */
         int result;
 
         if(num1 > num2)
            result = num1;
         else
            result = num2;
 
         return result;
      }
   }
 
   class Test
   {
      static void Main(string[] args)
      {
         /* local variable definition */
         int a = 100;
         int b = 200;
         int ret;
         NumberManipulator n = new NumberManipulator();
 
         //calling the FindMax method
         ret = n.FindMax(a, b);
         Console.WriteLine("Max value is : {0}", ret );
         Console.ReadLine();
      }
   }
}

编译执行上述代码，得到如下结果：

Max value is : 200

递归方法调用

有一种方法可以调用本身。这就是所谓的递归。下面是使用递归函数计算一个给定数字阶乘的示例：

using System;
namespace CalculatorApplication
{
   class NumberManipulator
   {
      public int factorial(int num)
      {
         /* local variable declaration */
         int result;
         if (num == 1)
         {
            return 1;
         }
         else
         {
            result = factorial(num - 1) * num;
            return result;
         }
      }
 
      static void Main(string[] args)
      {
         NumberManipulator n = new NumberManipulator();
         //calling the factorial method
         Console.WriteLine("Factorial of 6 is : {0}", n.factorial(6));
         Console.WriteLine("Factorial of 7 is : {0}", n.factorial(7));
         Console.WriteLine("Factorial of 8 is : {0}", n.factorial(8));
         Console.ReadLine();
      }
   }
}

编译执行上述代码，得到如下结果：

Factorial of 6 is: 720
Factorial of 7 is: 5040
Factorial of 8 is: 40320

将参数传递给方法

当调用带参数的方法时，您需要将参数传递给该方法。有三种方法，可以将参数传递给方法：

可空类型

C＃提供了一个特殊的数据类型，可空类型，可以在其中指定正常范围值，以及空 (null) 值。

例如，在一个可空 变量中，你可以从 -2,147,483,648 到 2,147,483,647 或空值中存储任意值。

同样，你可以指定 true，false 或 null 的 Nullable 变量。声明一个可空类型 (Nullable) 的语法如下：

< data_type> ? <variable_name> = null;

下面的例子演示了使用可空数据类型：

using System;
namespace CalculatorApplication
{
   class NullablesAtShow
   {
      static void Main(string[] args)
      {
         int? num1 = null;
         int? num2 = 45;
         double? num3 = new double?();
         double? num4 = 3.14157;
 
         bool? boolval = new bool?();
 
         // display the values
 
         Console.WriteLine("Nullables at Show: {0}, {1}, {2}, {3}", num1, num2, num3, num4);
         Console.WriteLine("A Nullable boolean value: {0}", boolval);
         Console.ReadLine();
      }
   }
}

编译运行上述代码，得到以下结果：

Nullables at Show: , 45,  , 3.14157
A Nullable boolean value:

空合并运算符(??)

空合并运算符是用于空值类型和引用类型。它是用于一个操作数转换为另一种可为空的(或不为空)值类型的操作数，其中，隐式转换是可能的类型。

如果第一个操作数的值为 null，则该运算符返回第二个操作数的值，否则返回第一个操作数的值。下面的例子说明了这一点：

using System;
namespace CalculatorApplication
{
   class NullablesAtShow
   {
      static void Main(string[] args)
      {
         double? num1 = null;
         double? num2 = 3.14157;
         double num3;
         num3 = num1 ?? 5.34;      
         Console.WriteLine(" Value of num3: {0}", num3);
         num3 = num2 ?? 5.34;
         Console.WriteLine(" Value of num3: {0}", num3);
         Console.ReadLine();
      }
   }
}

编译运行上述代码，得到以下结果：

Value of num3: 5.34
Value of num3: 3.14157

数组

数组存储一个大小固定的顺序集合中相同类型的元素。数组用于存储数据的集合，但我们通常认为数组是一个存储在连续的内存位置的相同类型的集合。

相反，声明单个变量，如 number0, number1, …, 和 number99，声明一个数组变量，如 numbers[0], numbers[1],…, 和 numbers[99] 表示单个变量。在数组的特定元素由一个索引进行访问。

所有数组都由连续的内存位置构成。最低的地址对应于第一元素，最高地址为最后一个元素地址。

图片 1.3 image

声明数组

要在 C# 中声明数组，可以使用下面的语法：

datatype[] arrayName;

这里，

• datatype 用于指定要被存储在数组中的元素的类型
• 指定数组的大小
• arrayName 指定数组的名称

例如，

double[] balance;

初始化数组

声明没有在存储器初始化的数组。当数组变量初始化时，您可以赋值给数组。

数组是引用类型，所以需要使用 new 关键字来创建数组的一个实例。

例如，

double[] balance = new double[10];

赋值数组

通过使用索引号，可以将值指派给单独的数组元素，比如：

double[] balance = new double[10];
balance[0] = 4500.0;

你可以在声明数组的同时给它赋值，如下：

double[] balance = { 2340.0, 4523.69, 3421.0};

你也可以创建和初始化一个数组，如下：

int [] marks = new int[5]  { 99,  98, 92, 97, 95};

你也可以省略数组的长度，如下：

int [] marks = new int[]  { 99,  98, 92, 97, 95};

你可以将一个数组变量赋给另一个目标。这种情况，两个数组都指向同一内存地址。

int [] marks = new int[]  { 99,  98, 92, 97, 95};
int[] score = marks;

当你创建一个数组时，C# 编译器初始化每个数组元素为数组类型的默认值。对于 int 数组的所有元素都初始化为 0。

访问数组元素

一个元素由索引数组名访问。这是通过放置在数组名后面的方括号里的元素索引完成的。例如：

double salary = balance[9];

以下是一个例子，将使用所有上述三个概念即声明，分配和访问数组：

using System;
namespace ArrayApplication
{
   class MyArray
   {
      static void Main(string[] args)
      {
         int []  n = new int[10]; /* n is an array of 10 integers */
         int i,j;
 
         /* initialize elements of array n */
         for ( i = 0; i < 10; i++ )
         {
            n[ i ] = i + 100;
         }
 
         /* output each array element's value */
         for (j = 0; j < 10; j++ )
         {
            Console.WriteLine("Element[{0}] = {1}", j, n[j]);
         }
         Console.ReadKey();
      }
   }
}

编译运行上述代码，得到以下结果：

Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109

使用 foreach 循环

在前面的例子中，我们已经使用了一个 for 循环用于访问每个数组元素。还可以使用 foreach 语句来遍历数组。

using System;
namespace ArrayApplication
{
   class MyArray
   {
      static void Main(string[] args)
      {
         int []  n = new int[10]; /* n is an array of 10 integers */
 
         /* initialize elements of array n */
         for ( int i = 0; i < 10; i++ )
         {
            n[i] = i + 100;
         }
 
         /* output each array element's value */
         foreach (int j in n )
         {
            int i = j-100;
            Console.WriteLine("Element[{0}] = {1}", i, j);
            i++;
         }
         Console.ReadKey();
      }
   }
}

编译运行上述代码，得到以下结果：

Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109

数组详解

数组在 C# 中是很重要的，应该需要很多更详细的解释。下列有关数组的几个重要概念，C# 程序员应当清楚：

字符串

在 C# 中，可以使用字符串作为字符数组，但更常见的做法是使用 string 关键字来声明一个字符串变量。该 string 关键字是 System.String 类的别名。

创建一个 String 对象

可以使用下列方法之一字符串对象：

• 通过指定一个字符串给一个字符串变量
• 通过使用 String 类的构造函数
• 通过使用字符串连接运算符(+)
• 通过检索属性或调用返回一个字符串的方法
• 通过调用格式化方法的值或对象转换成它的字符串表示

下面的例子说明了这一点：

using System;
namespace StringApplication
{
   class Program
   {
      static void Main(string[] args)
      {
         //from string literal and string concatenation
         string fname, lname;
         fname = "Rowan";
         lname = "Atkinson";
 
         string fullname = fname + lname;
         Console.WriteLine("Full Name: {0}", fullname);
 
         //by using string constructor
         char[] letters = { 'H', 'e', 'l', 'l','o' };
         string greetings = new string(letters);
         Console.WriteLine("Greetings: {0}", greetings);
 
         //methods returning string
         string[] sarray = { "Hello", "From", "Tutorials", "Point" };
         string message = String.Join(" ", sarray);
         Console.WriteLine("Message: {0}", message);
 
         //formatting method to convert a value
         DateTime waiting = new DateTime(2012, 10, 10, 17, 58, 1);
         string chat = String.Format("Message sent at {0:t} on {0:D}", waiting);
         Console.WriteLine("Message: {0}", chat);
      }
   }
}

编译执行上述代码，得到如下结果：

Full Name: Rowan Atkinson
Greetings: Hello
Message: Hello From Tutorials Point
Message: Message sent at 5:58 PM on Wednesday, October 10, 2012

String 类的属性

String 类有以下两个属性：

String 类的方法

String 类有许多方法，以帮助使用 String 对象。下表提供了一些最常用的方法：

方法上述名单并不是详尽的信息，请访问MSDN库的方法和String类的构造函数的完整列表。

示例:

下面的例子说明了一些上面提到的方法：

比较字符串：

using System;
namespace StringApplication
{
   class StringProg
   {
      static void Main(string[] args)
      {
         string str1 = "This is test";
         string str2 = "This is text";
 
         if (String.Compare(str1, str2) == 0)
         {
            Console.WriteLine(str1 + " and " + str2 +  " are equal.");
         }
         else
         {
            Console.WriteLine(str1 + " and " + str2 + " are not equal.");
         }
         Console.ReadKey() ;
      }
   }
}

编译执行上述代码，得到如下结果：

This is test and This is text are not equal.

String包含字符串：

using System;
namespace StringApplication
{
   class StringProg
   {
      static void Main(string[] args)
      {
         string str = "This is test";
         if (str.Contains("test"))
         {
            Console.WriteLine("The sequence 'test' was found.");
         }
         Console.ReadKey() ;
      }
   }
}

编译执行上述代码，得到如下结果：

The sequence 'test' was found.

获取一个子字符串：

using System;
namespace StringApplication
{
   class StringProg
   {
      static void Main(string[] args)
      {
         string str = "Last night I dreamt of San Pedro";
         Console.WriteLine(str);
         string substr = str.Substring(23);
         Console.WriteLine(substr);
      }
   }
}

编译执行上述代码，得到如下结果：

San Pedro

连接字符串：

using System;
namespace StringApplication
{
   class StringProg
   {
      static void Main(string[] args)
      {
         string[] starray = new string[]{"Down the way nights are dark",
         "And the sun shines daily on the mountain top",
         "I took a trip on a sailing ship",
         "And when I reached Jamaica",
         "I made a stop"};
 
         string str = String.Join("\n", starray);
         Console.WriteLine(str);
      }
   }
}

编译执行上述代码，得到如下结果：

Down the way nights are dark
And the sun shines daily on the mountain top
I took a trip on a sailing ship
And when I reached Jamaica
I made a stop

结构体

在 C# 中，结构体是一种值数据类型。包含数据成员和方法成员。 struct 关键字是用于创建一个结构体。

结构体是用来代表一个记录。假设你想追踪一个图书馆的书。你可能想追踪每本书的属性如下：

• 标题
• 作者
• 类别
• 书号

定义一个结构体

定义一个结构体，你必须要声明这个结构体。结构体声明定义了一种新的数据类型，这个数据类型为你的程序包含了一个以上的成员变量。

例如，你可以声明一个书的结构如下：

struct Books
{
   public string title;
   public string author;
   public string subject;
   public int book_id;
};  

下面的程序显示了结构体的用法：

using System;
struct Books
{
   public string title;
   public string author;
   public string subject;
   public int book_id;
};  
public class testStructure
{
   public static void Main(string[] args)
   {
      Books Book1;   /* 将 Book1 声明为 Book 类型  */
      Books Book2;   /* 将 Book2 声明为 Book 类型 */
      /* book 1 specification */
      Book1.title = "C Programming";
      Book1.author = "Nuha Ali"; 
      Book1.subject = "C Programming Tutorial";
      Book1.book_id = 6495407;
      /* book 2 详细数据 */
      Book2.title = "Telecom Billing";
      Book2.author = "Zara Ali";
      Book2.subject =  "Telecom Billing Tutorial";
      Book2.book_id = 6495700;
      /* 打印 Book1 信息 */
      Console.WriteLine( "Book 1 title : {0}", Book1.title);
      Console.WriteLine("Book 1 author : {0}", Book1.author);
      Console.WriteLine("Book 1 subject : {0}", Book1.subject);
      Console.WriteLine("Book 1 book_id :{0}", Book1.book_id);
      /* 打印 Book2 信息 */
      Console.WriteLine("Book 2 title : {0}", Book2.title);
      Console.WriteLine("Book 2 author : {0}", Book2.author);
      Console.WriteLine("Book 2 subject : {0}", Book2.subject);
      Console.WriteLine("Book 2 book_id : {0}", Book2.book_id);       
      Console.ReadKey();
   }
}

编译执行上述代码，得到如下结果：

Book 1 title : C Programming
Book 1 author : Nuha Ali
Book 1 subject : C Programming Tutorial
Book 1 book_id : 6495407
Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495700

结构体的特征

你已经使用了一个名为 Books 的简单结构体。C# 中的结构体与传统的 C 或者 C++ 有明显的不同。 C# 中的结构体有以下特征：

• 结构体可以有方法，域，属性，索引器，操作方法，和事件。
• 结构体可以定义构造函数，但是不能构造析构函数。尽管如此，你还是不能定义一个结构体的默认构造函数。默认构造函数是自动定义的，且不能被改变。
• 与类不同，结构体不能继承其他的结构体或这其他的类。
• 结构体不能用于作为其他结构或者类的基。
• 结构体可以实现一个或多个接口。
• 结构体成员不能被指定为抽象的，虚拟的，或者保护的对象。
• 使用 New 运算符创建结构体对象时，将创建该结构体对象，并且调用适当的构造函数。与类不同的是，结构体的实例化可以不使用 New 运算符。
• 如果不使用 New 操作符，那么在初始化所有字段之前，字段将保持未赋值状态，且对象不可用。

类和结构体

类和结构体有以下几个主要的区别：

• 类是引用类型，结构体是值类型
• 结构体不支持继承
• 结构体不能有默认构造函数

针对上述讨论，让我们重写前面的例子：

using System;
struct Books
{
   private string title;
   private string author;
   private string subject;
   private int book_id;
   public void getValues(string t, string a, string s, int id)
   {
      title = t;
      author = a;
      subject = s;
      book_id = id;
   }
   public void display()
   {
      Console.WriteLine("Title : {0}", title);
      Console.WriteLine("Author : {0}", author);
      Console.WriteLine("Subject : {0}", subject);
      Console.WriteLine("Book_id :{0}", book_id);
   }
};  
public class testStructure
{
   public static void Main(string[] args)
   {
      Books Book1 = new Books();    /* 将 Book1 声明为 Book 类型  */
      Books Book2 = new Books();    /* 将 Book2 声明为 Book 类型 */
      /* book 1 详细信息 */
      Book1.getValues("C Programming",
      "Nuha Ali", "C Programming Tutorial",6495407);
      /* book 2 详细信息 */
      Book2.getValues("Telecom Billing",
      "Zara Ali", "Telecom Billing Tutorial", 6495700);
      /* 打印 Book1 信息 */
      Book1.display();
      /* 打印 Book2 信息 */
      Book2.display(); 
      Console.ReadKey();
   }
}

编译执行上述代码，得到如下结果：

Title : C Programming
Author : Nuha Ali
Subject : C Programming Tutorial
Book_id : 6495407
Title : Telecom Billing
Author : Zara Ali
Subject : Telecom Billing Tutorial
Book_id : 6495700

枚举

枚举是一组命名的整型常量。枚举类型使用 enum 关键字声明。

C# 枚举是值的数据类型。换句话说，枚举包含它自己的值，不能继承或被继承。

声明枚举变量

用于声明枚举的一般语法：

enum <enum_name> 
{ 
    enumeration list 
};

这里

• enum_name 指定枚举类型名称。
• enumeration list 是一个逗号分隔的标识符的列表。

每个枚举列表中的符号表示整数值，比它前面的符号一个更大。

缺省情况下，第一枚举符号的值是 0。

例如：

enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat };

示例

下面的例子演示了使用枚举变量：

using System;
namespace EnumApplication
{
   class EnumProgram
   {
      enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat };
 
      static void Main(string[] args)
      {
         int WeekdayStart = (int)Days.Mon;
         int WeekdayEnd = (int)Days.Fri;
         Console.WriteLine("Monday: {0}", WeekdayStart);
         Console.WriteLine("Friday: {0}", WeekdayEnd);
         Console.ReadKey();
      }
   }
}

编译和执行上述代码，得到如下结果：

Monday: 1
Friday: 5

类

当你定义一个类，你实际上定义的是一个数据类型的蓝图。实际上你并没有定义任何数据，但是它定义了类的名字意味着什么。也就是说，一个类的对象由一些可以在该类上进行的操作构成。对象是类的实例。构成类的方法和变量被称为类的成员。

定义一个类

一个类定义以关键字 class 开始，其后跟的是类的名称；类的主体部分体由一对花括号括起来。以下是一个类定义的一般形式：

 class  class_name
{
   // 成员变量
     variable1;
     variable2;
   ...
     variableN;
   // 成员变量
     method1(parameter_list)
   {
      // 方法主体
   }
     method2(parameter_list)
   {
      // 方法主体
   }
   ...
     methodN(parameter_list)
   {
      // 方法主体
   }
}

笔记：

• 访问说明符的访问成员的规则与类本身的访问规则相同。如果没有说明，则默认访问的类的类型为 internal 。对成员的默认访问类型是 private 。

• 数据类型指定了变量的类型，如果有返回值的话，返回指定方法的数据类型。

• 访问类的成员，可以使用 "." 点运算符。

• 点运算符连接的成员的名字和对象的名称。

下面的例子说明了到目前为止对于概念的讨论：

using System;
namespace BoxApplication
{
    class Box
    {
       public double length;  // box 的长度
       public double breadth; // box 的宽度
       public double height;  // box 的高度
    }
    class Boxtester
    {
        static void Main(string[] args)
        {
            Box Box1 = new Box();   // 声明 box1 为 box 类型
            Box Box2 = new Box();   // 声明 box2 为 box 类型
            double volume = 0.0;    // 在这里存放 box 的体积
            // box 1 详细数据
            Box1.height = 5.0;
            Box1.length = 6.0;
            Box1.breadth = 7.0;
            // box 2 详细数据
            Box2.height = 10.0;
            Box2.length = 12.0;
            Box2.breadth = 13.0;
            // box 1 的体积
            volume = Box1.height * Box1.length * Box1.breadth;
            Console.WriteLine("Volume of Box1 : {0}",  volume);
            // box 2 的体积
            volume = Box2.height * Box2.length * Box2.breadth;
            Console.WriteLine("Volume of Box2 : {0}", volume);
            Console.ReadKey();
        }
    }
}

编译执行上述代码，得到如下结果：

Volume of Box1 : 210
Volume of Box2 : 1560

成员函数和封装

一个类的成员函数有其自己定义的或其原型写在类体中。它可以操作该类的任何成员对象，并且可以访问一个类的所有成员。

成员变量是一个对象的属性（从设计的角度来看），他们都是私有（private）的以便实施封装。这些变量只能被 public 成员函数访问。

让我们把上述那些概念来 set 和 get 一个类中不同的类成员的值：

using System;
namespace BoxApplication
{
   class Box
   {
      private double length;   // box 的长度
      private double breadth;  // box 的宽度
      private double height;   // box 的高度
      public void setLength( double len )
      {
         length = len;
      }
      public void setBreadth( double bre )
      {
         breadth = bre;
      }
      public void setHeight( double hei )
      {
         height = hei;
      }
      public double getVolume()
      {
         return length * breadth * height;
      }
   }
   class Boxtester
   {
      static void Main(string[] args)
      {
         Box Box1 = new Box();   // 将 Box1 声明为 Box 类型
         Box Box2 = new Box();
         double volume;
         // 将 Box2 声明为 Box 类型
         // box 1 详细数据
         Box1.setLength(6.0);
         Box1.setBreadth(7.0);
         Box1.setHeight(5.0);
         // box 2 详细数据
         Box2.setLength(12.0);
         Box2.setBreadth(13.0);
         Box2.setHeight(10.0);
         // box 1 的体积
         volume = Box1.getVolume();
         Console.WriteLine("Volume of Box1 : {0}" ,volume);
         // box 2 的体积
         volume = Box2.getVolume();
         Console.WriteLine("Volume of Box2 : {0}", volume);
         Console.ReadKey();
      }
   }
}