C(Csharp)基础教程(上)(菜鸟教程笔记)

1. C# 及其开发环境简介

1.1 C# 概述

C# 是一个现代的、通用的、面向对象的编程语言，它是由微软（Microsoft）开发的，由 Ecma 和 ISO 核准认可的。

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

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

1.2 C# 的编程功能

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

1.3 C# 与.Net的关系

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

1.3.1 .Net

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

公共语言运行库（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

如需了解每个组件的详细信息，请参阅微软（Microsoft）的文档。

1.3.2 C#

C#是一个.NET平台下的一个程序设计语言，仅仅是一个语言。是运行在.net CLR上的，用于创建应用程序的高级语言。程序设计语言是为了方便开发人员和计算机沟通的工具。

1.4 C# 的集成开发环境（Integrated Development Environment – IDE）

1.4.1 Windows上编写 C# 程序

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

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

1.4.2 Linux / Mac OS 上编写 C# 程序

VS 是 Visual Studio，它是微软提供的一个工具集，由各种各样的工具组成。VS 可以支持 C/C++、VB、JAVA、C# 编程。然了一次只能支持一种编程方式。在 VS 安装完成，第一次运行的时候会让你选择常用语言，如果你选择 C/C++，那么他就成了能够进行 C/C++ 编程的平台也许就是你所说的 VC 了。如果不想用 C/C++ 的话，只需要修改一下他的初始化设置，选择别的编程语言，就成为了另一种的语言的编程环境了。

VC 是 Visual C++，是一个独立的 C/C++ 的开发工具，比较著名的是 VC6.0，现在的 VC2010其实就是 VC10.0。再通俗一点，以 VS2010 和 VC2010 为例，VS2010 相当与 Office2010，包括了 World2010、Excel2010 等，而 VC2010 就相当于是 World2010。

2. C# 程序结构

2.1 Hello World

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

命名空间声明（Namespace declaration）
一个 class
Class 方法
Class 属性
一个 Main 方法
语句（Statements）& 表达式（Expressions）
注释

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 不同的是，文件名可以不同于类的名称。

3. C# 基本语法

3.1 程序实例

using System; namespace RectangleApplication { 
    class Rectangle { 
    // 成员变量 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

3.2 C# 基本语法

3.2.1 using关键字

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

using System;

一般在程序开头添加 using System;，这时System.String 就可简写为string 。
例如：

// using System; namespace ConsoleApp1 { 
    class Program { 
    static void Main(string[] args) { 
    System.String a = "Hello World!"; System.Console.WriteLine(a); System.Console.ReadKey(); } } }

和

using System; namespace ConsoleApp1 { 
    class Program { 
    static void Main(string[] args) { 
    string a = "Hello World!"; Console.WriteLine(a); Console.ReadKey(); } } }

3.2.2 class关键字

class关键字用于声明一个类

3.2.3 注释

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

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

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

}//end class Rectangle

3.2.3 成员变量

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

3.2.4 实例化一个类

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

Rectangle r = new Rectangle();

3.2.5 标识符

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

标识符必须以字母、下划线或 @ 开头，后面可以跟一系列的字母、数字（ 0 – 9 ）、下划线（ _ ）、@。
标识符中的第一个字符不能是数字。
标识符必须不包含任何嵌入的空格或符号，比如 ? – +! # % ^ & * ( ) [ ] { } . ; : ” ’ / \。
标识符不能是 C# 关键字。除非它们有一个 @ 前缀。例如，@if 是有效的标识符，但 if 不是，因为 if 是关键字。
标识符必须区分大小写。大写字母和小写字母被认为是不同的字母。
不能与C#的类库名称相同。

3.2.6 C# 关键字

关键字是 C# 编译器预定义的保留字。这些关键字不能用作标识符，但是，如果您想使用这些关键字作为标识符，可以在关键字前面加上 @ 字符作为前缀。
在 C# 中，有些关键字在代码的上下文中有特殊的意义，如 get 和 set，这些被称为上下文关键字（contextual keywords）。
下表列出了 C# 中的保留关键字（Reserved Keywords）和上下文关键字（Contextual Keywords）：

在这里插入图片描述

3.2.7 C# 占位符{}

当 WriteLine() 函数有多个参数时，输出第一个参数(双引号内的)中的内容，而第二个及后面的参数中的内容替换掉第一个参数中对应位置的占位符一起输出。

static void Main(string[] args) { 
    Console.WriteLine("A:{0}，a:{1}",65,97); Console.ReadLine(); }

A:65，a:97

如果第一个参数没有留占位符,那么第二个参数内容不输出。

Console.WriteLine("A:,a:",65,97);

A:,a:

占位符从零开始计数,且占位符中的数字不能大于第二个及后面的参数的总个数减一(要求占位符必须有可替换的值)。
占位符数字与第二个及后面的参数字符位置一一对应。

static void Main(string[] args) { 
    Console.WriteLine("A:{1}，a:{0}",65,97); Console.ReadLine(); }

A:97,a:65

4. C# 数据类型

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

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

4.1 值类型（Value types）

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

Size of int: 4

4.2 引用类型（Reference types）

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

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

就像仓库，仓库里有货架，货架上有编号：A1,A2,A3…, 这些编号就可以看做是引用类型，现在来了一批货，有 “土豆，黄瓜，西红柿”，这些就是值类型，如果你想让 A1=土豆，那么就要把土豆搬到 A1 里面去，这就叫装箱，装箱需要耗费人力和工时（也就是耗费CPU和内存），同理拆箱就要把对应编号的货物搬出来，也是需要耗费人力和工时。

从内存上看，值类型是在栈中的操作，而引用类型是在堆中的操作。
（导致 => 值类型存取速度快，引用类型存取速度慢。）

从本质上看，值类型表示实际数据，引用类型表示指向存储在内存堆中的数据的指针或引用。
（值类型是具体的那个数值所占用的空间大小，而引用类型是存放那个数值的空间地址。）

从来源上看，值类型继承自System.ValueType，引用类型继承自System.Object。

特别的：结构体是值类型，类和string是引用类型。

4.2.1 对象（Object）类型

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

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

装箱：值类型转换为对象类型, 实例：

int val = 8; object obj = val;//整型数据转换为了对象类型（装箱）

拆箱：之前由值类型转换而来的对象类型再转回值类型, 实例：

int val = 8; object obj = val;//先装箱 int nval = （int）obj;//再拆箱

只有装过箱的数据才能拆箱。

4.2.2 动态（Dynamic）类型

您可以存储任何类型的值在动态数据类型变量中。这些变量的类型检查是在运行时发生的。
声明动态类型的语法：

dynamic <variable_name> = value;

实例为：

dynamic d = 20;

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

4.2.3 字符串（String）类型

string str = "runoob.com";

一个 @引号字符串：

@"runoob.com";

C# string 字符串的前面可以加 @（称作”逐字字符串“）将转义字符（\）当作普通字符对待，比如：

string str = @"C:\Windows";

等价于：

string str = "C:\\Windows";

@ 字符串中可以任意换行，换行符及缩进空格都计算在字符串长度之内。

string str = @"";

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

4.3 指针类型（Pointer types）

type* identifier;

例如：

char* cptr; int* iptr;

5. C# 类型转换

类型转换从根本上说是类型铸造，或者说是把数据从一种类型转换为另一种类型。在 C# 中，类型铸造有两种形式：

隐式类型转换 ：这些转换是 C# 默认的以安全方式进行的转换, 不会导致数据丢失。例如，从小的整数类型转换为大的整数类型，从派生类转换为基类。
显式类型转换 ：显式类型转换，即强制类型转换。通过用户使用预定义的函数显式完成的，显式转换需要强制转换运算符，而且强制转换会造成数据丢失。转换类型的范围大小和从属关系和隐式转换相反。显式转换可能会导致数据出错，或者转换失败，甚至无法编译成功。

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

namespace TypeConvertion { 
    class Class1 { 
    } class Class2 : Class1 //类Class2是类Class1的子类 { 
    } class Program { 
    static void Main(string[] args) { 
    int inum = 100; long lnum = inum; // 进行了隐式转换，将 int 型（数据范围小）数据转换为了 long 型（数据范围大）的数据 Class1 c1 = new Class2(); // 这里也是隐式转换，将一个新建的 Class2 实例转换为了其基类 Class1 类型的实例 C1 } } }

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

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(); } } }

5.1 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

5.2 Convert.ToInt32()的取整

C# 中对 double 类型的数据取整，可以使用Convert.ToInt32()方法，也可使用 int 强制转换为整数，使用 int 时并不存在四舍五入的情况，而是直接将后面的小数位数丢掉。比如:

class Program { 
    static void Main(string[] args) { 
    double a = 1.35; double b = 1.65; int a1 = Convert.ToInt32(a); int a2 = (int)(a); int b1 = Convert.ToInt32(b); int b2 = (int)(b); Console.WriteLine("{0}使用convert方法转化的结果为：{1}",a,a1); Console.WriteLine("{0}使用int强制转换的结果为：{1}",a,a2); Console.WriteLine("{0}使用convert方法转化的结果为：{1}", b, b1); Console.WriteLine("{0}使用int强制转换的结果为：{1}", b, b2); Console.ReadKey(); } }

1.35使用convert方法转化的结果为：1 1.35使用int强制转换的结果为：1 1.65使用convert方法转化的结果为：2 1.65使用int强制转换的结果为：1

6. C# 变量

6.1 C# 中的变量定义

C# 中变量定义的语法：

<data_type> <variable_list>;

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

您可以在变量定义时进行初始化：

int i = 100;

6.2 C# 中的变量初始化

变量通过在等号后跟一个常量表达式进行初始化（赋值）。初始化的一般形式为：

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

6.3 接受来自用户的值

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

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

6.4 C# 中的 Lvalues 和 Rvalues

C# 中的两种表达式：

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

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

int g = 20;

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

10 = 20;

7. C# 常量

7.1 整数常量

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

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

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

7.2 浮点常量

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

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

7.3 字符常量

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

Hello World

7.4 字符串常量

字符串常量是括在双引号""里，或者是括在@""里。字符串常量包含的字符与字符常量相似，可以是：普通字符、转义序列和通用字符
使用字符串常量时，可以把一个很长的行拆成多个行，可以使用空格分隔各个部分。
这里是一些字符串常量的实例。下面所列的各种形式表示相同的字符串。

string a = "hello, world"; // hello, world string b = @"hello, world"; // hello, world string c = "hello \t world"; // hello world string d = @"hello \t world"; // hello \t world string e = "Joe said \"Hello\" to me"; // Joe said "Hello" to me string f = @"Joe said ""Hello"" to me"; // Joe said "Hello" to me string g = "\\\\server\\share\\file.txt"; // \\server\share\file.txt string h = @"\\server\share\file.txt"; // \\server\share\file.txt string i = "one\r\ntwo\r\nthree"; string j = @"one two three";

7.5 定义常量

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

const <data_type> <constant_name> = value;

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

using System; public class ConstTest { 
    class SampleClass { 
    public int x; public int y; public const int c1 = 5; public const int c2 = c1 + 5; public SampleClass(int p1, int p2) { 
    x = p1; y = p2; } } static void Main() { 
    SampleClass mC = new SampleClass(11, 22); Console.WriteLine("x = {0}, y = {1}", mC.x, mC.y); Console.WriteLine("c1 = {0}, c2 = {1}", SampleClass.c1, SampleClass.c2); } }

x = 11, y = 22 c1 = 5, c2 = 10

7.6 静态常量和动态常量

7.6.1 静态常量（编译时常量）const

在编译时就确定了值，必须在声明时就进行初始化且之后不能进行更改，可在类和方法中定义。定义方法如下：

const double a=3.14；// 正确声明常量的方法 const int b; // 错误，没有初始化

7.6.2 动态常量（运行时常量）readonly

在运行时确定值，只能在声明时或构造函数中初始化，只能在类中定义。定义方法如下：

class Program { 
    readonly int a=1; // 声明时初始化 readonly int b; // 构造函数中初始化 Program() { 
    b=2; } static void Main() { 
    } }

7.6.3 静态常量与动态常量的使用场景

在下面两种情况下，可以使用 const 常量：

取值永久不变(比如圆周率、一天包含的小时数、地球的半径等)。
对程序性能要求非常苛刻。

除此之外的其他情况都应该优先采用 readonly 常量。

8. C# 运算符

8.1 算术运算符

using System; namespace OperatorsAppl { 
    class Program { 
    static void Main(string[] args) { 
    int a = 21; int b = 10; int c; c = a + b; Console.WriteLine("Line 1 - c 的值是 {0}", c); c = a - b; Console.WriteLine("Line 2 - c 的值是 {0}", c); c = a * b; Console.WriteLine("Line 3 - c 的值是 {0}", c); c = a / b; Console.WriteLine("Line 4 - c 的值是 {0}", c); c = a % b; Console.WriteLine("Line 5 - c 的值是 {0}", c); // ++a 先进行自增运算再赋值 c = ++a; Console.WriteLine("Line 6 - c 的值是 {0}", c); // 此时 a 的值为 22 // --a 先进行自减运算再赋值 c = --a; Console.WriteLine("Line 7 - c 的值是 {0}", c); Console.ReadLine(); } } }

Line 1 - c 的值是 31 Line 2 - c 的值是 11 Line 3 - c 的值是 210 Line 4 - c 的值是 2 Line 5 - c 的值是 1 Line 6 - c 的值是 22 Line 7 - c 的值是 21

using System; namespace OperatorsAppl { 
    class Program { 
    static void Main(string[] args) { 
    int a = 1; int b; // a++ 先赋值再进行自增运算 b = a++; Console.WriteLine("a = {0}", a); Console.WriteLine("b = {0}", b); Console.ReadLine(); // ++a 先进行自增运算再赋值 a = 1; // 重新初始化 a b = ++a; Console.WriteLine("a = {0}", a); Console.WriteLine("b = {0}", b); Console.ReadLine(); // a-- 先赋值再进行自减运算 a = 1; // 重新初始化 a b= a--; Console.WriteLine("a = {0}", a); Console.WriteLine("b = {0}", b); Console.ReadLine(); // --a 先进行自减运算再赋值 a = 1; // 重新初始化 a b= --a; Console.WriteLine("a = {0}", a); Console.WriteLine("b = {0}", b); Console.ReadLine(); } } }

a = 2 b = 1 a = 2 b = 2 a = 0 b = 1 a = 0 b = 0

8.2 关系运算符

using System; class Program { 
    static void Main(string[] args) { 
    int a = 21; int b = 10; if (a == b) { 
    Console.WriteLine("Line 1 - a 等于 b"); } else { 
    Console.WriteLine("Line 1 - a 不等于 b"); } if (a < b) { 
    Console.WriteLine("Line 2 - a 小于 b"); } else { 
    Console.WriteLine("Line 2 - a 不小于 b"); } if (a > b) { 
    Console.WriteLine("Line 3 - a 大于 b"); } else { 
    Console.WriteLine("Line 3 - a 不大于 b"); } /* 改变 a 和 b 的值 */ a = 5; b = 20; if (a <= b) { 
    Console.WriteLine("Line 4 - a 小于或等于 b"); } if (b >= a) { 
    Console.WriteLine("Line 5 - b 大于或等于 a"); } } }

Line 1 - a 不等于 b Line 2 - a 不小于 b Line 3 - a 大于 b Line 4 - a 小于或等于 b Line 5 - b 大于或等于 a

8.3 逻辑运算符

using System; namespace OperatorsAppl { 
    class Program { 
    static void Main(string[] args) { 
    bool a = true; bool b = true; if (a && b) { 
    Console.WriteLine("Line 1 - 条件为真"); } if (a || b) { 
    Console.WriteLine("Line 2 - 条件为真"); } /* 改变 a 和 b 的值 */ a = false; b = true; if (a && b) { 
    Console.WriteLine("Line 3 - 条件为真"); } else { 
    Console.WriteLine("Line 3 - 条件不为真"); } if (!(a && b)) { 
    Console.WriteLine("Line 4 - 条件为真"); } Console.ReadLine(); } } }

Line 1 - 条件为真 Line 2 - 条件为真 Line 3 - 条件不为真 Line 4 - 条件为真

8.4 位运算符

A|B = 0011 1101

A^B = 0011 0001

~A = 1100 0011

using System; namespace OperatorsAppl { 
    class Program { 
    static void Main(string[] args) { 
    int a = 60; /* 60 = 0011 1100 */ int b = 13; /* 13 = 0000 1101 */ int c = 0; c = a & b; /* 12 = 0000 1100 */ Console.WriteLine("Line 1 - c 的值是 {0}", c ); c = a | b; /* 61 = 0011 1101 */ Console.WriteLine("Line 2 - c 的值是 {0}", c); c = a ^ b; /* 49 = 0011 0001 */ Console.WriteLine("Line 3 - c 的值是 {0}", c); c = ~a; /*-61 = 1100 0011 */ Console.WriteLine("Line 4 - c 的值是 {0}", c); c = a << 2; /* 240 = 1111 0000 */ Console.WriteLine("Line 5 - c 的值是 {0}", c); c = a >> 2; /* 15 = 0000 1111 */ Console.WriteLine("Line 6 - c 的值是 {0}", c); Console.ReadLine(); } } }

Line 1 - c 的值是 12 Line 2 - c 的值是 61 Line 3 - c 的值是 49 Line 4 - c 的值是 -61 Line 5 - c 的值是 240 Line 6 - c 的值是 15

8.5 赋值运算符