c# 基础
时间:2024-01-01 10:37:00
一、C# 简介
C# 它是一种现代、通用、面向对象的编程语言,由微软组成(Microsoft)开发的,由 Ecma 和 ISO 经批准的。
C# 是由 Anders Hejlsberg 和他的团队在一起 .Net 开发框架。
C# 公共语言基础结构(CLI)设计的。CLI 允许在不同的计算机平台和系统结构上使用各种高级语言,由可执行代码和运行环境组成。
下面列出了 C# 专业语言应用广泛的原因:
- 编程语言现代通用。
- 面向对象。
- 面向组件。
- 容易学习。
- 结构化语言。
- 它产生高效的程序。
- 它可以在各种计算机平台上编译。
- .Net 框架的一部分。
C# 强大的编程功能
虽然 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# 编程所需的工具。我们已经提到过了 C# 是 .Net 框架的一部分用于编写 .Net 应用程序。因此,讨论操作 C# 让我们先了解一下程序的可用工具 C# 与 .Net 框架之间的关系。
.Net 框架(.Net Framework)
.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
如需了解每个组件的详细信息,请参阅微软(Microsoft)的文档。
C# 综合开发环境(Integrated Development Environment - IDE)
微软(Microsoft)提供以下用途 C# 编程开发工具:
- Visual Studio 2010 (VS)
- Visual C# 2010 Express (VCE)
- Visual Web Developer
后两个是免费的,可以从微软官方网站下载。使用这些工具,您可以编写各种工具 C# 程序,从简单的命令行应用程序到更复杂的应用程序。您还可以使用基本的文本编辑器(例如 Notepad)编写 C# 使用命令行编译器进行源代码文件(.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# 编程语言的基础构件块之前,让我们先看一下 C# 作为下一章的参考,最小程序结构。
C# Hello World 实例
一个 C# 程序主要包括以下部分:
- 命名空间声明(Namespace declaration)
- 一个 class
- Class 方法
- Class 属性
- 一个 Main 方法
- 语句(Statements)& 表达式(Expressions)
- 注释
C# 文件的后缀是 .cs。
下面创建一个 test.cs 文件包含可打印的文件 “Hello World” 简单代码:
test.cs 文件代码:
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 类只有一个 Man 方法。
-
下一行定义了 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 按钮。
- 新项目会出现在解决方案资源管理器(Solution Explorer)中。
- 在代码编辑器(Code Editor)中编写代码。
- 点击 Run 按钮或者按下 F5 键来运行程序。会出现一个命令提示符窗口(Command Prompt window),显示 Hello World。
您也可以使用命令行代替 Visual Studio IDE 来编译 C# 程序:
- 打开一个文本编辑器,添加上面提到的代码。
- 保存文件为 helloworld.cs。
- 打开命令提示符工具,定位到文件所保存的目录。
- 键入 csc helloworld.cs 并按下 enter 键来编译代码。
- 如果代码没有错误,命令提示符会进入下一行,并生成 helloworld.exe 可执行文件。
- 接下来,键入 helloworld 来执行程序。
- 您将看到 “Hello World” 打印在屏幕上。
C# 基本语法
C# 是一种面向对象的编程语言。在面向对象的程序设计方法中,程序由各种相互交互的对象组成。相同种类的对象通常具有相同的类型,或者说,是在相同的 class 中。
例如,以 Rectangle(矩形)对象为例。它具有 length 和 width 属性。根据设计,它可能需要接受这些属性值、计算面积和显示细节。
让我们来看看一个 Rectangle(矩形)类的实现,并借此讨论 C# 的基本语法:
实例
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
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# 关键字。除非它们有一个 @ 前缀。 例如,@if 是有效的标识符,但 if 不是,因为 if 是关键字。
- 标识符必须区分大小写。大写字母和小写字母被认为是不同的字母。
- 不能与C#的类库名称相同。
C# 关键字
关键字是 C# 编译器预定义的保留字。这些关键字不能用作标识符,但是,如果您想使用这些关键字作为标识符,可以在关键字前面加上 @ 字符作为前缀。
在 C# 中,有些关键字在代码的上下文中有特殊的意义,如 get 和 set,这些被称为上下文关键字(contextual keywords)。
下表列出了 C# 中的保留关键字(Reserved Keywords)和上下文关键字(Contextual Keywords):
保留关键字 | ||||||
---|---|---|---|---|---|---|
abstract | as | base | bool | break | byte | case |
catch | char | checked | class | const | continue | decimal |
default | delegate | do | double | else | enum | event |
explicit | extern | false | finally | fixed | float | for |
foreach | goto | if | implicit | in | in (generic modifier) | int |
interface | internal | is | lock | long | namespace | new |
null | object | operator | out | out (generic modifier) | override | params |
private | protected | public | readonly | ref | return | sbyte |
sealed | short | sizeof | stackalloc | static | string | struct |
switch | this | throw | true | try | typeof | uint |
ulong | unchecked | unsafe | ushort | using | virtual | void |
volatile | while | |||||
上下文关键字 | ||||||
add | alias | ascending | descending | dynamic | from | get |
global | group | into | join | let | orderby | partial (type) |
partial (method) | remove | select | set |
C# 数据类型
在 C# 中,变量分为以下几种类型:
- 值类型(Value types)
- 引用类型(Reference types)
- 指针类型(Pointer types)
值类型(Value types)
值类型变量可以直接分配给一个值。它们是从类 System.ValueType 中派生的。
值类型直接包含数据。比如 int、char、float,它们分别存储数字、字符、浮点数。当您声明一个 int 类型时,系统分配内存来存储值。
下表列出了 C# 2010 中可用的值类型:
类型 | 描述 | 范围 | 默认值 |
---|---|---|---|
bool | 布尔值 | True 或 False | False |
byte | 8 位无符号整数 | 0 到 255 | 0 |
char | 16 位 Unicode 字符 | U +0000 到 U +ffff | ‘\0’ |
decimal | 128 位精确的十进制值,28-29 有效位数 | (-7.9 x 1028 到 7.9 x 1028) / 100 到 28 | 0.0M |
double | 64 位双精度浮点型 | (+/-)5.0 x 10-324 到 (+/-)1.7 x 10308 | 0.0D |
float | 32 位单精度浮点型 | -3.4 x 1038 到 + 3.4 x 1038 | 0.0F |
int | 32 位有符号整数类型 | -2,147,483,648 到 2,147,483,647 | 0 |
long | 64 位有符号整数类型 | -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807 | 0L |
sbyte | 8 位有符号整数类型 | -128 到 127 | 0 |
short | 16 位有符号整数类型 | -32,768 到 32,767 | 0 |
uint | 32 位无符号整数类型 | 0 到 4,294,967,295 | 0 |
ulong | 64 位无符号整数类型 | 0 到 18,446,744,073,709,551,615 | 0 |
ushort | 16 位无符号整数类型 | 0 到 65,535 | 0 |
如需得到一个类型或一个变量在特定平台上的准确尺寸,可以使用 sizeof 方法。表达式 sizeof(type) 产生以字节为单位存储对象或类型的存储尺寸。下面举例获取任何机器上 int 类型的存储尺寸:
实例
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
引用类型(Reference types)
引用类型不包含存储在变量中的实际数据,但它们包含对变量的引用。
换句话说,它们指的是一个内存位置。使用多个变量时,引用类型可以指向一个内存位置。如果内存位置的数据是由一个变量改变的,其他变量会自动反映这种值的变化。内置的 引用类型有:object、dynamic 和 string。
对象(Object)类型
对象(Object)类型 是 C# 通用类型系统(Common Type System - CTS)中所有数据类型的终极基类。Object 是 System.Object 类的别名。所以对象(Object)类型可以被分配任何其他类型(值类型、引用类型、预定义类型或用户自定义类型)的值。但是,在分配值之前,需要先进行类型转换。
当一个值类型转换为对象类型时,则被称为 装箱;另一方面,当一个对象类型转换为值类型时,则被称为 拆箱。
object obj;
obj = 100; // 这是装箱
动态(Dynamic)类型
您可以存储任何类型的值在动态数据类型变量中。这些变量的类型检查是在运行时发生的。
声明动态类型的语法:
dynamic = value;
例如:
dynamic d = 20;
动态类型与对象类型相似,但是对象类型变量的类型检查是在编译时发生的,而动态类型变量的类型检查是在运行时发生的。
字符串(String)类型
字符串(String)类型 允许您给变量分配任何字符串值。字符串(String)类型是 System.String 类的别名。它是从对象(Object)类型派生的。字符串(String)类型的值可以通过两种形式进行分配:引号和 @引号。
例如:
String str = "runoob.com";
一个 @引号字符串:
@"runoob.com";
C# string 字符串的前面可以加 @(称作"逐字字符串")将转义字符(\)当作普通字符对待,比如:
string str = @"C:\Windows";
等价于:
string str = "C:\\Windows";
@ 字符串中可以任意换行,换行符及缩进空格都计算在字符串长度之内。
string str = @"";
用户自定义引用类型有:class、interface 或 delegate。我们将在以后的章节中讨论这些类型。
指针类型(Pointer types)
指针类型变量存储另一种类型的内存地址。C# 中的指针与 C 或 C++ 中的指针有相同的功能。
声明指针类型的语法:
type* identifier;
例如:
char* cptr;
int* iptr;
我们将在章节"不安全的代码"中讨论指针类型。
C# 类型转换
类型转换从根本上说是类型铸造,或者说是把数据从一种类型转换为另一种类型。在 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# 提供了下列内置的类型转换方法:
序号 | 方法 & 描述 |
---|---|
1 | ToBoolean 如果可能的话,把类型转换为布尔型。 |
2 | ToByte 把类型转换为字节类型。 |
3 | ToChar 如果可能的话,把类型转换为单个 Unicode 字符类型。 |
4 | ToDateTime 把类型(整数或字符串类型)转换为 日期-时间 结构。 |
5 | ToDecimal 把浮点型或整数类型转换为十进制类型。 |
6 | ToDouble 把类型转换为双精度浮点型。 |
7 | ToInt16 把类型转换为 16 位整数类型。 |
8 | ToInt32 把类型转换为 32 位整数类型。 |
9 | ToInt64 把类型转换为 64 位整数类型。 |
10 | ToSbyte 把类型转换为有符号字节类型。 |
11 | ToSingle 把类型转换为小浮点数类型。 |
12 | ToString 把类型转换为字符串类型。 |
13 | ToType 把类型转换为指定类型。 |
14 | ToUInt16 把类型转换为 16 位无符号整数类型。 |
15 | ToUInt32 把类型转换为 32 位无符号整数类型。 |
16 | ToUInt64 把类型转换为 64 位无符号整数类型。 |
下面的实例把不同值的类型转换为字符串类型:
实例
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# 中提供的基本的值类型大致可以分为以下几类:
类型 | 举例 |
---|---|
整数类型 | sbyte、byte、short、ushort、int、uint、long、ulong 和 char |
浮点型 | float 和 double |
十进制类型 | decimal |
布尔类型 | true 或 false 值,指定的值 |
空类型 | 可为空值的数据类型 |
C# 允许定义其他值类型的变量,比如 enum,也允许定义引用类型变量,比如 class。这些我们将在以后的章节中进行讨论。在本章节中,我们只研究基本变量类型。
C# 中的变量定义
C# 中变量定义的语法:
;
在这里,data_type 必须是一个有效的 C# 数据类型,可以是 char、int、float、double 或其他用户自定义的数据类型。variable_list 可以由一个或多个用逗号分隔的标识符名称组成。
一些有效的变量定义如下所示:
int i, j, k;
char c, ch;
float f, salary;
double d;
您可以在变量定义时进行初始化:
int i = 100;
C# 中的变量初始化
变量通过在等号后跟一个常量表达式进行初始化(赋值)。初始化的一般形式为:
variable_name = value;
变量可以在声明时被初始化(指定一个初始值)。初始化由一个等号后跟一个常量表达式组成,如下所示:
= 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;
C# 常量
常量是固定值,程序执行期间不会改变。常量可以是任何基本数据类型,比如整数常量、浮点常量、字符常量或者字符串常量,还有枚举常量。
常量可以被当作常规的变量,只是它们的值在定义后不能被修改。
整数常量
整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数: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)或制表符 tab(\t)。在这里,列出一些转义序列码:
转义序列 | 含义 |
---|---|
\ | \ 字符 |
’ | ’ 字符 |
" | " 字符 |
? | ? 字符 |
\a | Alert 或 bell |
\b | 退格键(Backspace) |
\f | 换页符(Form feed) |
\n | 换行符(Newline) |
\r | 回车 |
\t | 水平制表符 tab |
\v | 垂直制表符 tab |
\ooo | 一到三位的八进制数 |
\xhh . . . | 一个或多个数字的十六进制数 |
以下是一些转义序列字符的实例:
namespace EscapeChar
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello\tWorld\n\n");
Console.ReadLine();
}
}
}
当上面的代码被编译和执行时,它会产生下列结果:
Hello World
字符串常量
字符串常量是括在双引号 “” 里,或者是括在 @“” 里。字符串常量包含的字符与字符常量相似,可以是:普通字符、转义序列和通用字符
使用字符串常量时,可以把一个很长的行拆成多个行,可以使用空格分隔各个部分。
这里是一些字符串常量的实例。下面所列的各种形式表示相同的字符串。
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
定义常量
常量是使用 const 关键字来定义的 。定义一个常量的语法如下:
const = 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
C# 运算符
运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C# 有丰富的内置运算符,分类如下:
- 算术运算符
- 关系运算符
- 逻辑运算符
- 位运算符
- 赋值运算符
- 其他运算符
本教程将逐一讲解算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符及其他运算符。
算术运算符
下表显示了 C# 支持的所有算术运算符。假设变量 A 的值为 10,变量 B 的值为 20,则:
运算符 | 描述 | 实例 |
---|---|---|
+ | 把两个操作数相加 | A + B 将得到 30 |
- | 从第一个操作数中减去第二个操作数 | A - B 将得到 -10 |
* | 把两个操作数相乘 | A * B 将得到 200 |
/ | 分子除以分母 | B / A 将得到 2 |
% | 取模运算符,整除后的余数 | B % A 将得到 0 |
++ | 自增运算符,整数值增加 1 | A++ 将得到 11 |
– | 自减运算符,整数值减少 1 | A-- 将得到 9 |
实例
请看下面的实例,了解 C# 中所有可用的算术运算符:
实例
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
- c = a++: 先将 a 赋值给 c,再对 a 进行自增运算。
- c = ++a: 先将 a 进行自增运算,再将 a 赋值给 c 。
- c = a–: 先将 a 赋值给 c,再对 a 进行自减运算。
- c = --a: 先将 a 进行自减运算,再将 a 赋值给 c 。
实例
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
关系运算符
下表显示了 C# 支持的所有关系运算符。假设变量 A 的值为 10,变量 B 的值为 20,则:
运算符 | 描述 | 实例 |
---|---|---|
== | 检查两个操作数的值是否相等,如果相等则条件为真。 | (A == B) 不为真。 |
!= | 检查两个操作数的值是否相等,如果不相等则条件为真。 | (A != B) 为真。 |
> | 检查左操作数的值是否大于右操作数的值,如果是则条件为真。 | (A > B) 不为真。 |
< | 检查左操作数的值是否小于右操作数的值,如果是则条件为真。 | (A < B) 为真。 |
>= | 检查左操作数的值是否大于或等于右操作数的值,如果是则条件为真。 | (A >= B) 不为真。 |
<= | 检查左操作数的值是否小于或等于右操作数的值,如果是则条件为真。 | (A <= B) 为真。 |
实例
请看下面的实例,了解 C# 中所有可用的关系运算符:
实例
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
逻辑运算符
下表显示了 C# 支持的所有逻辑运算符。假设变量 A 为布尔值 true,变量 B 为布尔值 false,则:
运算符 | 描述 | 实例 |
---|---|---|
&& | 称为逻辑与运算符。如果两个操作数都非零,则条件为真。 | (A && B) 为假。 |
|| | 称为逻辑或运算符。如果两个操作数中有任意一个非零,则条件为真。 | (A || B) 为真。 |
! | 称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 | !(A && B) 为真。 |
实例
请看下面的实例,了解 C# 中所有可用的逻辑运算符:
实例
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 - 条件为真
位运算符
位运算符作用于位,并逐位执行操作。&、 | 和 ^ 的真值表如下所示:
p | q | p & q | p | q | p ^ q |
---|---|---|---|---|
0 | 0 | 0 | 0 | 0 |
0 | 1 | 0 | 1 | 1 |
1 | 1 | 1 | 1 | 0 |
1 | 0 | 0 | 1 | 1 |
假设如果 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,则:
运算符 | 描述 | 实例 |
---|---|---|
& | 如果同时存在于两个操作数中,二进制 AND 运算符复制一位到结果中。 | (A & B) 将得到 12,即为 0000 1100 |
| | 如果存在于任一操作数中,二进制 OR 运算符复制一位到结果中。 | (A | B) 将得到 61,即为 0011 1101 |
^ | 如果存在于其中一个操作数中但不同时存在于两个操作数中,二进制异或运算符复制一位到结果中。 | (A ^ B) 将得到 49,即为 0011 0001 |
~ | 按位取反运算符是一元运算符,具有"翻转"位效果,即0变成1,1变成0,包括符号位。 | (~A ) 将得到 -61,即为 1100 0011,一个有符号二进制数的补码形式。 |
<< | 二进制左移运算符。左操作数的值向左移动右操作数指定的位数。 | A << 2 将得到 240,即为 1111 0000 |
>> | 二进制右移运算符。左操作数的值向右移动右操作数指定的位数。 | A >> 2 将得到 15,即为 0000 1111 |
实例
请看下面的实例,了解 C# 中所有可用的位运算符:
实例
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
赋值运算符
下表列出了 C# 支持的赋值运算符:
运算符 | 描述 | 实例 |
---|---|---|
= | 简单的赋值运算符,把右边操作数的值赋给左边操作数 | C = A + B 将把 A + B 的值赋给 C |
+= | 加且赋值运算符,把右边操作数加上左边操作数的结果赋值给左边操作数 | C += A 相当于 C = C + A |
-= | 减且赋值运算符,把左边操作数减去右边操作数的结果赋值给左边操作数 | C -= A 相当于 C = C - A |
*= | 乘且赋值运算符,把右边操作数乘以左边操作数的结果赋值给左边操作数 | C *= A 相当于 C = C * A |
/= | 除且赋值运算符,把左边操作数除以右边操作数的结果赋值给左边操作数 | C /= A 相当于 C = C / A |
%= | 求模且赋值运算符,求两个操作数的模赋值给左边操作数 | C %= A 相当于 C = C % A |
<<= | 左移且赋值运算符 | C <<= 2 等同于 C = C << 2 |
>>= | 右移且赋值运算符 | C >>= 2 等同于 C = C >> 2 |
&= | 按位与且赋值运算符 | C &= 2 等同于 C = C & 2 |
^= | 按位异或且赋值运算符 | C ^= 2 等同于 C = C ^ 2 |
|= | 按位或且赋值运算符 | C |= 2 等同于 C = C | 2 |
实例
请看下面的实例,了解 C# 中所有可用的赋值运算符:
实例
using System;
namespace OperatorsAppl
{
class Program
{
static void Main(string[] args)
{
int a = 21;
int c;
c = a;
Console.WriteLine("Line 1 - = c 的值 = {0}", c);
c += a;
Console.WriteLine("Line 2 - += c 的值 = {0}", c);
c -= a;
Console.WriteLine("Line 3 - -= c 的值 = {0}", c);
c *= a;
Console.WriteLine("Line 4 - *= c 的值 = {0}", c);
c /= a;
Console.WriteLine("Line 5 - /= c 的值 = {0}", c);
c = 200;
c %= a;
Console.WriteLine("Line 6 - %= c 的值 = {0}", c);
c <<= 2;
Console.WriteLine("Line 7 - <<= c 的值 = {0}", c);
c >>= 2;
Console.WriteLine("Line 8 - >>= c 的值 = {0}", c);
c &= 2;
Console.WriteLine("Line 9 - &= c 的值 = {0}", c);
c ^= 2;
Console.WriteLine("Line 10 - ^= c 的值 = {0}", c);
c |= 2;
Console