目录
-------------------------------------------
-------------------------------------------
-------------------------------------------
-------------------------------------------
-------------------------------------------
-------------------------------------------
-------------------------------------------
一、内部类
在C#中，内部类（Inner Class）或嵌套类（Nested Class）指的是定义在另一个类内部的类。这种结构允许你将
相关的功能组织在一起，使得代码更加模块化和易于管理。内部类可以访问外部类的私有成员，这在封装方面非
常有用。下面是一些关于C#内部类的详细信息：
1. 定义内部类
内部类可以直接定义在另一个类的内部，如下所示：
public class OuterClass
{
private int outerValue = 10;
public class InnerClass
{
public void Display()
{
Console.WriteLine("Display from InnerClass");
// 可以访问外部类的私有成员
Console.WriteLine(new OuterClass().outerValue);
}
}
}2. 创建内部类的实例
要创建内部类的实例，你需要首先创建一个外部类的实例，然后通过外部类的实例来创建内部类的实例，或者直
接在外部类的方法中创建内部类的实例：
OuterClass.InnerClass innerInstance = new OuterClass.InnerClass();
innerInstance.Display();或者：
OuterClass outerInstance = new OuterClass();
OuterClass.InnerClass innerInstance = outerInstance.GetInnerClass(); // 如果外部类提供了获取内部类实例的方法3. 访问外部类的私有成员
内部类可以访问外部类的私有成员，这是其与外部类紧密耦合的一个特点：
public class OuterClass
{
private int privateValue = 100;
public void AccessPrivate()
{
InnerClass inner = new InnerClass();
Console.WriteLine(inner.GetPrivateValue()); // 通过内部类访问外部类的私有成员
}
public class InnerClass
{
public int GetPrivateValue()
{
return new OuterClass().privateValue; // 直接访问外部类的私有成员
}
}
}4. 内部静态类
你也可以将内部类定义为静态的，这通常用于提供一组静态方法或属性，而不依赖于外部类的实例：
public class OuterClass
{
public static class StaticInnerClass
{
public static void StaticMethod()
{
Console.WriteLine("Static method in StaticInnerClass");
}
}
}使用静态内部类时，无需外部类的实例即可访问其静态成员：
OuterClass.StaticInnerClass.StaticMethod(); // 直接访问静态方法，无需外部类实例。5. 使用场景和优点
- 封装：内部类可以封装在外部类中，使得代码更加组织化和模块化。
- 访问控制：内部类可以访问外部类的私有成员，这在某些设计模式（如工厂模式、单例模式等）中非常有用。
- 组织代码：将相关的功能组织在同一个类中，使得代码更加清晰。例如，可以将与特定功能相关的帮助方法放在一个内部类中。
- 减少全局命名空间污染：通过将功能封装在内部类中，可以减少全局命名空间的污染。
6. 注意事项
- 过度使用内部类可能会导致代码难以理解，特别是在大型项目中。确保使用它们来组织代码，而不是仅仅作为一种编程习惯。
在某些情况下，使用静态类或结构体可能更合适，特别是当你不需要访问外部类的实例时。
-------------------------------------------
二、代码块
在C#中，代码块指的是一组语句的集合，它们被一对大括号 {} 包围。代码块在C#中非常重要，它们用于控制
程序的流程，定义作用域，以及组织代码结构。下面是一些使用代码块的常见场景和示例：
1. 控制流语句
1.1. 条件语句
1> if 语句
if (condition)
{
// 执行代码块
}
else
{
// 另一组执行代码块
}2> switch 语句
switch (expression)
{
case value1:
{
// 代码块
break;
}
case value2:
{
// 代码块
break;
}
default:
{
// 默认代码块
break;
}
}1.2. 循环语句
1> for 循环
for (int i = 0; i < 10; i++)
{
// 循环体
}2> while 循环
while (condition)
{
// 循环体
}
3> do-while 循环
do
{
// 循环体
} while (condition);4> foreach 循环
foreach (var item in collection)
{
// 循环体，遍历集合中的每个元素
}2. 方法定义和调用
方法定义时使用代码块来包含方法体：
void MyMethod()
{
// 方法体，包含多条语句的代码块
}方法调用时，虽然不直接涉及代码块，但方法的执行实际上是在其内部定义的代码块中进行的。例如：
MyMethod(); // 调用方法，执行其内部代码块中的代码。3. 定义作用域和变量声明
在C#中，变量的作用域由其声明的地方决定。通常，变量在其声明的大括号内可见和可用：
{ // 开始一个新的作用域或代码块
int x = 10; // x在这个代码块内可见和可用。
Console.WriteLine(x); // 输出 x 的值。
} // x 在这个作用域外不再可见。尝试访问 x 会导致编译错误。4. Lambda表达式和匿名方法（匿名函数）使用代码块：
虽然Lambda表达式本身不使用大括号包围的代码块，但它们可以包含一个或多个语句：
Action myAction = () =>
{
Console.WriteLine("Hello, World!");
Console.WriteLine("This is a lambda expression.");
};
myAction(); // 调用Lambda表达式，执行其内部代码块中的代码。5. 知识小结
在C#中，代码块通过大括号 {} 来定义，它们是控制程序流程、定义变量作用域、组织代码结构的基本单元。
通过合理地使用代码块，可以使程序更加清晰、易于维护和扩展。
-------------------------------------------
讲解二：数据类型
一、基本介绍
在C#中，数据类型是基础且重要的概念，它们决定了变量可以存储的数据的类型和范围。
在 C# 中，变量分为以下几种类型：
- 值类型（Value types）
- 引用类型（Reference types）
- 指针类型（Pointer types）
- 特殊类型（Special Types）-> 可空类型（Nullable）
二、三种变量类型
1. 值类型（Value types）
值类型变量可以直接分配给一个值。它们是从类 System.ValueType 中派生的。
值类型直接包含数据。比如 int、char、float，它们分别存储数字、字符、浮点数。当您声明一个 int 类型时，
系统分配内存来存储值。
值类型直接存储其数据的值，并且在栈（stack）上分配内存。
下表列出了 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: 41.1. 整型
int：32位整数。long：64位整数。short：16位整数。byte：8位无符号整数。uint：32位无符号整数。ulong：64位无符号整数。sbyte：8位有符号整数。ushort：16位无符号整数。
int myInt = 10;
long myLong = 10000000000;
short myShort = 32767;
byte myByte = 255;
uint myUint = 100;
ulong myUlong = 100000000000000;
sbyte mySbyte = -128;
ushort myUshort = 65535;1.2. 浮点型
float：32位浮点数。double：64位浮点数。decimal：128位高精度浮点数，用于金融计算。
float myFloat = 3.14f;
double myDouble = 3.14159265358979;
decimal myDecimal = 123.456789M;1.3. 字符型
char：单个Unicode字符。
char myChar = 'A';1.4. 布尔型
bool：存储真（true）或假（false）。
bool myBool = true;2. 引用类型（Reference Types）
引用类型不包含存储在变量中的实际数据，但它们包含对变量的引用。
换句话说，它们指的是一个内存位置。使用多个变量时，引用类型可以指向一个内存位置。
如果内存位置的数据是由一个变量改变的，其他变量会自动反映这种值的变化。
内置的 引用类型有：object、dynamic 和 string。
2.1. 对象（Object）类型
对象（Object）类型 是 C# 通用类型系统（Common Type System - CTS）中所有数据类型的终极基类。Object 是 System.Object 类的别名。所以对象（Object）类型可以被分配任何其他类型（值类型、引用类型、
预定义类型或用户自定义类型）的值。但是，在分配值之前，需要先进行类型转换。
当一个值类型转换为对象类型时，则被称为 装箱；另一方面，当一个对象类型转换为值类型时，则被称为 拆箱。
object obj;
obj = 100; // 这是装箱2.2. 动态（Dynamic）类型
您可以存储任何类型的值在动态数据类型变量中。这些变量的类型检查是在运行时发生的。
声明动态类型的语法：
dynamic <variable_name> = value;例如：
dynamic d = 20;动态类型与对象类型相似，但是对象类型变量的类型检查是在编译时发生的，而动态类型变量的类型检查是在运
行时发生的。
2.3. 字符串（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 = @"<script type=""text/javascript"">
<!--
-->
</script>";用户自定义引用类型有：class、interface 或 delegate。我们将在以后的章节中讨论这些类型。
2.4. 其它
- 值类型
- 枚举
- 引用类型
- 数组
- 非类型
- 注解
3. 指针类型（Pointer types）
指针类型变量存储另一种类型的内存地址。C# 中的指针与 C 或 C++ 中的指针有相同的功能。
声明指针类型的语法：
type* identifier;例如：
char* cptr;
int* iptr;我们将在章节"不安全的代码"中讨论指针类型。
4. 可空类型（Nullable）
4.1. C# 单问号 ? 与 双问号 ??
? 单问号用于对 int、double、bool 等无法直接赋值为 null 的数据类型进行 null 的赋值，意思是这个数据类型
是 Nullable 类型的。
int? i = 3;等同于：
Nullable<int> i = new Nullable<int>(3);int i; //默认值0
int? ii; //默认值null?? 双问号用于判断一个变量在为 null 的时候返回一个指定的值。
接下来我们详细说明。
4.2. 可空类型（Nullable）
C# 提供了一个特殊的数据类型，nullable 类型（可空类型），可空类型可以表示其基础值类型正常范围内的值，
再加上一个 null 值。
例如，Nullable< Int32 >，读作"可空的 Int32"，可以被赋值为 -2,147,483,648 到 2,147,483,647 之间的任意
值，也可以被赋值为 null 值。类似的，Nullable< bool > 变量可以被赋值为 true 或 false 或 null。
在处理数据库和其他包含可能未赋值的元素的数据类型时，将 null 赋值给数值类型或布尔型的功能特别有用。
例如，数据库中的布尔型字段可以存储值 true 或 false，或者，该字段也可以未定义。
声明一个 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?();
// 显示值
Console.WriteLine("显示可空类型的值： {0}, {1}, {2}, {3}",
num1, num2, num3, num4);
Console.WriteLine("一个可空的布尔值： {0}", boolval);
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
显示可空类型的值： , 45, , 3.14157
一个可空的布尔值：4.3. Null 合并运算符（ ?? ）
Null 合并运算符用于定义可空类型和引用类型的默认值。
Null 合并运算符为类型转换定义了一个预设值，以防可空类型的值为 Null。
Null 合并运算符把操作数类型隐式转换为另一个可空（或不可空）的值类型的操作数的类型。
如果第一个操作数的值为 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; // num1 如果为空值则返回 5.34
Console.WriteLine("num3 的值： {0}", num3);
num3 = num2 ?? 5.34;
Console.WriteLine("num3 的值： {0}", num3);
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
num3 的值： 5.34
num3 的值： 3.141574.4. 知识小结
num3 = num1 ?? 5.34; // num1 如果为空值则返回 5.34
Console.WriteLine("num3 的值： {0}", num3);
num3 = num2 ?? 5.34;
Console.WriteLine("num3 的值： {0}", num3);C# 中两个问号的作用是判断??左边的对象是否为 null，如果不为 null 则使用 ?? 左边的对象，如果为 null 则使
用 ?? 右边的对象。
比如：
a = b ?? c如果 b 为 null，则 a = c，如果 b 不为 null，则 a = b。
?? 可以理解为三元运算符的简化形式：
num3 = num1 ?? 5.34;
num3 = (num1 == null) ? 5.34 : num1;三、类型转换
在 C# 中，类型转换是将一个数据类型的值转换为另一个数据类型的过程。
C# 中的类型转换可以分为两种：隐式类型转换和显式类型转换（也称为强制类型转换）。
1. 隐式类型转换
隐式转换是不需要编写代码来指定的转换，编译器会自动进行。
隐式转换是指将一个较小范围的数据类型转换为较大范围的数据类型时，编译器会自动完成类型转换，这些转换
是 C# 默认的以安全方式进行的转换, 不会导致数据丢失。
例如，从 int 到 long，从 float 到 double 等。
从小的整数类型转换为大的整数类型，从派生类转换为基类。将一个 byte 类型的变量赋值给 int 类型的变量，
编译器会自动将 byte 类型转换为 int 类型，不需要显示转换。
实例一
byte b = 10;
int i = b; // 隐式转换，不需要显式转换将一个整数赋值给一个长整数，或者将一个浮点数赋值给一个双精度浮点数，这种转换不会导致数据丢失：
实例二
int intValue = 42;
long longValue = intValue; // 隐式转换，从 int 到 long2. 显式转换
显式类型转换，即强制类型转换，需要程序员在代码中明确指定。
显式转换是指将一个较大范围的数据类型转换为较小范围的数据类型时，或者将一个对象类型转换为另一个对象
类型时，需要使用强制类型转换符号进行显示转换，强制转换会造成数据丢失。
例如，将一个 int 类型的变量赋值给 byte 类型的变量，需要显示转换。
实例一
int i = 10;
byte b = (byte)i; // 显式转换，需要使用强制类型转换符号强制转换为整数类型：
实例二
double doubleValue = 3.14;
int intValue = (int)doubleValue; // 强制从 double 到 int，数据可能损失小数部分强制转换为浮点数类型：
实例三
int intValue = 42;
float floatValue = (float)intValue; // 强制从 int 到 float，数据可能损失精度强制转换为字符串类型：
实例四
int intValue = 123;
string stringValue = intValue.ToString(); // 将 int 转换为字符串下面的实例显示了一个显式的类型转换：
using System;
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();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
56733. 类型转换方法
C# 提供了下列内置的类型转换方法：
序号 |
方法 & 描述 |
1 |
ToBoolean |
2 |
ToByte |
3 |
ToChar |
4 |
ToDateTime |
5 |
ToDecimal |
6 |
ToDouble |
7 |
ToInt16 |
8 |
ToInt32 |
9 |
ToInt64 |
10 |
ToSbyte |
11 |
ToSingle |
12 |
ToString |
13 |
ToType |
14 |
ToUInt16 |
15 |
ToUInt32 |
16 |
ToUInt64 |
这些方法都定义在 System.Convert 类中，使用时需要包含 System 命名空间。
它们提供了一种安全的方式来执行类型转换，因为它们可以处理 null值，并且会抛出异常，如果转换不可能进
行。
例如，使用 Convert.ToInt32 方法将字符串转换为整数：
string str = "123";
int number = Convert.ToInt32(str); // 转换成功，number为123如果字符串不是有效的整数表示，Convert.ToInt32 将抛出 FormatException。
下面的实例把不同值的类型转换为字符串类型：
实例一
using System;
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# 提供了多种类型转换方法，例如使用 Convert 类、Parse 方法和 TryParse 方法，这些方法可以帮助处理不同
的数据类型之间的转换。
1. 使用 Convert 类
Convert 类提供了一组静态方法，可以在各种基本数据类型之间进行转换。
string str = "123";
int num = Convert.ToInt32(str);2. 使用 Parse 方法
Parse 方法用于将字符串转换为对应的数值类型，如果转换失败会抛出异常。
string str = "123.45";
double d = double.Parse(str);3. 使用 TryParse 方法
TryParse 方法类似于 Parse，但它不会抛出异常，而是返回一个布尔值指示转换是否成功。
string str = "123.45";
double d;
bool success = double.TryParse(str, out d);
if (success) {
Console.WriteLine("转换成功: " + d);
} else {
Console.WriteLine("转换失败");
}五、自定义类型转换
C# 还允许你定义自定义类型转换操作，通过在类型中定义 implicit 或 explicit 关键字。
using System;
public class Fahrenheit
{
public double Degrees { get; set; }
public Fahrenheit(double degrees)
{
Degrees = degrees;
}
// 隐式转换从Fahrenheit到double
public static implicit operator double(Fahrenheit f)
{
return f.Degrees;
}
// 显式转换从double到Fahrenheit
public static explicit operator Fahrenheit(double d)
{
return new Fahrenheit(d);
}
}
public class Program
{
public static void Main()
{
Fahrenheit f = new Fahrenheit(98.6);
Console.WriteLine("Fahrenheit object: " + f.Degrees + " degrees");
double temp = f; // 隐式转换
Console.WriteLine("After implicit conversion to double: " + temp + " degrees");
Fahrenheit newF = (Fahrenheit)temp; // 显式转换
Console.WriteLine("After explicit conversion back to Fahrenheit: " + newF.Degrees + " degrees");
}
}以上例子中，我们定义了一个 Fahrenheit 类，并实现了从 Fahrenheit 到 double 的隐式转换和从 double 到
Fahrenheit 的显式转换。
输出结果将显示如下：
Fahrenheit object: 98.6 degrees
After implicit conversion to double: 98.6 degrees
After explicit conversion back to Fahrenheit: 98.6 degrees六、总结
在 C# 中，内置的类型转换方法主要通过以下几种方式实现：隐式转换、显式转换（强制转换）、使用 Convert
类的方法、Parse 方法和 TryParse 方法，这些方法广泛应用于不同数据类型之间的转换。
以下是 C# 内置类型转换方法的表格：
方法类别 |
方法 |
描述 |
隐式转换 |
自动进行的转换 |
无需显式指定，通常用于安全的类型转换，如从较小类型到较大类型 |
显式转换（强制转换） |
(type)value |
需要显式指定，通常用于可能导致数据丢失或转换失败的情况 |
Convert 类方法 |
Convert.ToBoolean(value) |
将指定类型转换为 Boolean |
Convert.ToByte(value) |
将指定类型转换为 Byte |
|
Convert.ToChar(value) |
将指定类型转换为 Char |
|
Convert.ToDateTime(value) |
将指定类型转换为 DateTime |
|
Convert.ToDecimal(value) |
将指定类型转换为 Decimal |
|
Convert.ToDouble(value) |
将指定类型转换为 Double |
|
Convert.ToInt16(value) |
将指定类型转换为 Int16（短整型） |
|
Convert.ToInt32(value) |
将指定类型转换为 Int32（整型） |
|
Convert.ToInt64(value) |
将指定类型转换为 Int64（长整型） |
|
Convert.ToSByte(value) |
将指定类型转换为 SByte |
|
Convert.ToSingle(value) |
将指定类型转换为 Single（单精度浮点型） |
|
Convert.ToString(value) |
将指定类型转换为 String |
|
Convert.ToUInt16(value) |
将指定类型转换为 UInt16（无符号短整型） |
|
Convert.ToUInt32(value) |
将指定类型转换为 UInt32（无符号整型） |
|
Convert.ToUInt64(value) |
将指定类型转换为 UInt64（无符号长整型） |
|
Parse 方法 |
Boolean.Parse(string) |
将字符串解析为 Boolean |
Byte.Parse(string) |
将字符串解析为 Byte |
|
Char.Parse(string) |
将字符串解析为 Char |
|
DateTime.Parse(string) |
将字符串解析为 DateTime |
|
Decimal.Parse(string) |
将字符串解析为 Decimal |
|
Double.Parse(string) |
将字符串解析为 Double |
|
Int16.Parse(string) |
将字符串解析为 Int16 |
|
Int32.Parse(string) |
将字符串解析为 Int32 |
|
Int64.Parse(string) |
将字符串解析为 Int64 |
|
SByte.Parse(string) |
将字符串解析为 SByte |
|
Single.Parse(string) |
将字符串解析为 Single |
|
UInt16.Parse(string) |
将字符串解析为 UInt16 |
|
UInt32.Parse(string) |
将字符串解析为 UInt32 |
|
UInt64.Parse(string) |
将字符串解析为 UInt64 |
|
TryParse 方法 |
Boolean.TryParse(string, out bool) |
尝试将字符串解析为 Boolean，返回布尔值表示是否成功 |
Byte.TryParse(string, out byte) |
尝试将字符串解析为 Byte，返回布尔值表示是否成功 |
|
Char.TryParse(string, out char) |
尝试将字符串解析为 Char，返回布尔值表示是否成功 |
|
DateTime.TryParse(string, out DateTime) |
尝试将字符串解析为 DateTime，返回布尔值表示是否成功 |
|
Decimal.TryParse(string, out decimal) |
尝试将字符串解析为 Decimal，返回布尔值表示是否成功 |
|
Double.TryParse(string, out double) |
尝试将字符串解析为 Double，返回布尔值表示是否成功 |
|
Int16.TryParse(string, out short) |
尝试将字符串解析为 Int16，返回布尔值表示是否成功 |
|
Int32.TryParse(string, out int) |
尝试将字符串解析为 Int32，返回布尔值表示是否成功 |
|
Int64.TryParse(string, out long) |
尝试将字符串解析为 Int64，返回布尔值表示是否成功 |
|
SByte.TryParse(string, out sbyte) |
尝试将字符串解析为 SByte，返回布尔值表示是否成功 |
|
Single.TryParse(string, out float) |
尝试将字符串解析为 Single，返回布尔值表示是否成功 |
|
UInt16.TryParse(string, out ushort) |
尝试将字符串解析为 UInt16，返回布尔值表示是否成功 |
|
UInt32.TryParse(string, out uint) |
尝试将字符串解析为 UInt32，返回布尔值表示是否成功 |
|
UInt64.TryParse(string, out ulong) |
尝试将字符串解析为 UInt64，返回布尔值表示是否成功 |
-------------------------------------------
讲解三：变量
一、基本介绍
一个变量只不过是一个供程序操作的存储区的名字。
在 C# 中，变量是用于存储和表示数据的标识符，即存储数据的基本单位，它们用于在程序中存储信息，以便程序
可以在运行时使用这些信息。
在声明变量时，您需要指定变量的类型，并且可以选择性地为其分配一个初始值。
这意味着在声明变量时必须指定它可以存储的数据类型。
在 C# 中，每个变量都有一个特定的类型，类型决定了变量的内存大小和布局，范围内的值可以存储在内存中，可
以对变量进行一系列操作。
我们已经讨论了各种数据类型。C# 中提供的基本的值类型大致可以分为以下几类：
类型 |
举例 |
整数类型 |
sbyte、byte、short、ushort、int、uint、long、ulong 和 char |
浮点型 |
float, double |
十进制类型 |
decimal |
布尔类型 |
true 或 false 值，指定的值 |
空字符串 |
string |
空类型 |
可为空值的数据类型 |
C# 允许定义其他值类型的变量，比如 enum，也允许定义引用类型变量，比如 class。
这些我们将在以后的章节中进行讨论。在本章节中，我们只研究基本变量类型。
C# 4.0引入了动态类型 (dynamic)，它允许在运行时推断变量的类型。这在一些特殊情况下很有用，但通常最好
使用静态类型以获得更好的性能和编译时类型检查。
dynamic dynamicVariable = "This can be any type";二、变量的声明
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;三、变量的命名规则
在 C# 中，变量的命名需要遵循一些规则：
- 变量名可以包含字母、数字和下划线。
- 变量名必须以字母或下划线开头。
- 变量名区分大小写。
- 避免使用 C# 的关键字作为变量名（如 int, class, if 等）。
- 通常使用驼峰命名法（Camel Case），例如 myVariableName 或 myVariableNameWithNumbers123。
通过以上方式，你可以在C#中有效地使用和理解变量。希望这些信息对你有所帮助！如果有更具体的问题或需要
进一步的解释，请随时提问。
int myVariable = 10;
string _userName = "John";四、变量初始化
变量通过在等号后跟一个常量表达式进行初始化（赋值）。初始化的一般形式为：
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' */正确地初始化变量是一个良好的编程习惯，否则有时程序会产生意想不到的结果。
请看下面的实例，使用了各种类型的变量：
using System;
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五、变量作用域
1. 基本介绍
在 C# 中，变量的作用域定义了变量的可见性和生命周期。
变量的作用域通常由花括号 {} 定义的代码块来确定。
以下是关于C#变量作用域的一些基本规则：
2. 作用域基本规则
2.1. 局部变量
在方法、循环、条件语句等代码块内声明的变量是局部变量，它们只在声明它们的代码块中可见。
void MyMethod()
{
int localVar = 10; // 局部变量
// ...
}
// localVar 在这里不可见2.2. 块级作用域
在 C# 7及更高版本中，引入了块级作用域，即使用大括号 {} 创建的任何块都可以定义变量的作用域。
{
int blockVar = 20; // 块级作用域
// ...
}
// blockVar 在这里不可见2.3. 方法参数作用域
方法的参数也有其自己的作用域，它们在整个方法中都是可见的。
void MyMethod(int parameter)
{
// parameter 在整个方法中可见
// ...
}2.4. 全局变量
在类的成员级别定义的变量是成员变量，它们在整个类中可见，如果在命名空间级别定义，那么它们在整个命名
空间中可见。
class MyClass
{
int memberVar = 30; // 成员变量，在整个类中可见
}2.5. 静态变量作用域
静态变量是在类级别上声明的，但它们的作用域也受限于其定义的类。
class MyClass
{
static int staticVar = 40; // 静态变量，在整个类中可见
}2.6. 循环变量作用域
在 for 循环中声明的循环变量在循环体内可见
for (int i = 0; i < 5; i++)
{
// i 在循环体内可见
}
// i 在这里不可见3. 知识小结
总体而言，变量的作用域有助于管理变量的可见性和生命周期，确保变量在其有效范围内使用，也有助于防止命
名冲突。
C#中的变量可以是局部的或全局的：
- 局部变量：在方法或代码块内部声明的变量，只能在声明它的方法或代码块内部访问。
- 成员变量（字段）：在类或结构体内部声明的变量，可以在类的所有方法中访问。
- 全局变量（静态成员）：在类或结构体内部使用
static关键字声明的变量，属于类本身，而不是类的特定实例。
六、接受来自用户的值
System 命名空间中的 Console 类提供了一个函数 ReadLine()，用于接收来自用户的输入，并把它存储到一个
变量中。
例如：
int num;
num = Convert.ToInt32(Console.ReadLine());七、Lvalues 和 Rvalues
C# 中的两种表达式：
- lvalue：lvalue 表达式可以出现在赋值语句的左边或右边。
- rvalue：rvalue 表达式可以出现在赋值语句的右边，不能出现在赋值语句的左边。
变量是 lvalue 的，所以可以出现在赋值语句的左边。
数值是 rvalue 的，因此不能被赋值，不能出现在赋值语句的左边。
下面是一个有效的语句：
int g = 20;下面是一个无效的语句，会产生编译时错误：
10 = 20;八、变量声明为常量与只读字段
- 常量：使用 const 关键字声明，其值在编译时必须被设定且不可更改。
例如：const int MAX_VALUE = 100;
- 只读字段：使用 readonly 关键字声明，可以在构造函数中或在声明时初始化，但不能在对象创建后修
改。例如：readonly int value = 5; 或 public readonly int Value { get; private set; }
（适用于属性）。
-------------------------------------------
讲解五：常量
一、基本介绍
常量（Constants）是一种在编译时就已经确定其值的变量，即固定值，程序执行期间不会改变。
常量可以是任何基本数据类型，比如整数常量、浮点常量、字符常量或者字符串常量，还有枚举常量。
常量可以被当作常规的变量，只是它们的值在定义后不能被修改。
常量在声明时必须初始化，并且在声明之后不能更改其值。
常量通常用于表示程序中不会改变的值，例如数学常数、配置参数等。
二、定义常量
在C#中，你可以使用 const 关键字来定义常量。
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三、常见常量例子
1. 整数常量
整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：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 */2. 浮点常量
一个浮点常量是由整数部分、小数点、小数部分和指数部分组成。
您可以使用小数形式或者指数形式来表示浮点常量。
这里有一些浮点常量的实例：
3.14159 /* 合法 */
314159E-5L /* 合法 */
510E /* 非法：不完全指数 */
210f /* 非法：没有小数或指数 */
.e55 /* 非法：缺少整数或小数 */使用浮点形式表示时，必须包含小数点、指数或同时包含两者。
使用指数形式表示时，必须包含整数部分、小数部分或同时包含两者。
有符号的指数是用 e 或 E 表示的。
3. 字符常量
字符常量是括在单引号里，例如，'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 World4. 字符串常量
字符串常量是括在双引号 "" 里，或者是括在 @"" 里。
字符串常量包含的字符与字符常量相似，可以是：普通字符、转义序列和通用字符
使用字符串常量时，可以把一个很长的行拆成多个行，可以使用空格分隔各个部分。
这里是一些字符串常量的实例。下面所列的各种形式表示相同的字符串。
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";四、总结
1. 常量与变量的区别
- 类型：常量必须在声明时初始化，且其类型必须在编译时确定。
- 修改：常量在声明后不能被修改。
- 作用域：常量的作用域可以是局部的或全局的，就像其他变量一样。
- 性能：由于常量的值在编译时就已经确定，因此使用常量可以提高程序的性能。
2. 使用场景
- 固定不变的数值：如数学常数、物理常数、配置参数等。
- 提高代码可读性：通过使用有意义的名称代替直接在代码中硬编码的值。
- 避免魔法数字：即直接在代码中出现的数字，通过常量可以使代码更清晰易懂。
3. 注意事项
- 常量必须是编译时常量，因此它们的值必须在编译时已知。这意味着你不能将一个需要通过运行时计算得到的值赋给常量。
- 常量可以是基本数据类型（如int, double, string等）或枚举类型。
- 常量不能被标记为static或readonly（尽管readonly通常用于字段，但在这里指的是只读字段的概念，与常量略有不同）。
- 常量不能用作数组大小或作为泛型类型参数。例如，你不能定义
const int arraySize = 5;然后使用int[] myArray = new int[arraySize];，因为arraySize需要在编译时已知其大小。
通过合理使用常量，可以使你的C#代码更加清晰、易于维护和调试。
-------------------------------------------
六、字面量
在C#中，字面量（Literal）是一种直接在代码中表示固定值的表示法。它们可以是数值、布尔值、字符、字符
串、日期等。了解不同类型的字面量对于编写清晰、易于理解的代码非常重要。下面是一些C#中常见的字面量类
型及其用法：
1. 整数字面量
整数字面量用于表示整数，可以是十进制、十六进制、八进制或二进制。
- 十进制：例如
123 - 十六进制：以
0x或0X开头，例如0x1A3 - 八进制：以
0开头，例如075 - 二进制：以
0b或0B开头，例如0b1010
2. 浮点数字面量
浮点数字面量用于表示小数或带指数的数。
- 双精度浮点数：例如
123.456或1.23e3 - 单精度浮点数：在数字后加
F或f，例如123.456F或1.23e3f
3. 字符字面量
字符字面量用于表示单个字符。
- 单引号：例如
'A'，'1'，'\n'（换行符）
4. 字符串字面量
字符串字面量用于表示文本。
- 双引号：例如
"Hello, World!" - @ 字符串字面量：用于包含双引号（"）的字符串，例如
@"He said, \"Hello!\"" - Verbatim 字符串字面量：以
$开头，例如$"Name: {name}"（C# 6.0及以后版本）
5. 布尔字面量
布尔字面量用于表示真或假。
- true 和 false：例如
true，false
5.1. 6. 对象初始化字面量
对象初始化字面量用于创建和初始化对象。
- 匿名类型：例如
new { Name = "John", Age = 30 } - 集合初始化：例如
new List<int> { 1, 2, 3 }或new[] { 1, 2, 3 }
6. Null 字面量
表示空引用或空值。
- null：例如
string name = null;
7. 日期和时间字面量
用于表示日期和时间。
- DateTime：例如
new DateTime(2023, 1, 1)或DateTime.Now - TimeSpan：例如
new TimeSpan(1, 2, 3)表示1小时2分钟3秒
8. 使用示例
int integerLiteral = 123; // 整数字面量
double doubleLiteral = 123.456; // 双精度浮点数字面量
float floatLiteral = 123.456f; // 单精度浮点数字面量
char charLiteral = 'A'; // 字符字面量
string stringLiteral = "Hello, World!"; // 字符串字面量
bool boolLiteral = true; // 布尔字面量
object nullLiteral = null; // Null 字面量
DateTime dateTimeLiteral = new DateTime(2023, 1, 1); // 日期时间字面量掌握这些字面量的使用，可以帮助你更有效地编写C#代码。
-------------------------------------------
讲解七：运算符
运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C# 有丰富的内置运算符，分类如下：
- 算术运算符
- 关系运算符
- 逻辑运算符
- 位运算符
- 赋值运算符
- 其他运算符
本教程将逐一讲解算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符及其他运算符。
一、算术运算符
1. 基本介绍
下表显示了 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 |
2. 实例代码
代码一
请看下面的实例，了解 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二、关系运算符
1. 基本介绍
下表显示了 C# 支持的所有关系运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：
运算符 |
描述 |
实例 |
== |
检查两个操作数的值是否相等，如果相等则条件为真。 |
(A == B) 不为真。 |
!= |
检查两个操作数的值是否相等，如果不相等则条件为真。 |
(A != B) 为真。 |
> |
检查左操作数的值是否大于右操作数的值，如果是则条件为真。 |
(A > B) 不为真。 |
< |
检查左操作数的值是否小于右操作数的值，如果是则条件为真。 |
(A < B) 为真。 |
>= |
检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。 |
(A >= B) 不为真。 |
<= |
检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。 |
(A <= B) 为真。 |
2. 实例代码
请看下面的实例，了解 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三、逻辑运算符
1. 基本介绍
下表显示了 C# 支持的所有逻辑运算符。假设变量 A 为布尔值 true，变量 B 为布尔值 false，则：
运算符 |
描述 |
实例 |
&& |
称为逻辑与运算符。如果两个操作数都非零，则条件为真。 |
(A && B) 为假。 |
|| |
称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。 |
(A || B) 为真。 |
! |
称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 |
!(A && B) 为真。 |
2. 实例代码
请看下面的实例，了解 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 - 条件为真四、位运算符
1. 基本介绍
位运算符作用于位，并逐位执行操作。&、 | 和 ^ 的真值表如下所示：
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 |
2. 实例代码
请看下面的实例，了解 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五、赋值运算符
1. 基本介绍
下表列出了 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 |
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.WriteLine("Line 11 - |= c 的值 = {0}", c);
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
Line 1 - = c 的值 = 21
Line 2 - += c 的值 = 42
Line 3 - -= c 的值 = 21
Line 4 - *= c 的值 = 441
Line 5 - /= c 的值 = 21
Line 6 - %= c 的值 = 11
Line 7 - <<= c 的值 = 44
Line 8 - >>= c 的值 = 11
Line 9 - &= c 的值 = 2
Line 10 - ^= c 的值 = 0
Line 11 - |= c 的值 = 2六、其他运算符
1. 基本介绍
下表列出了 C# 支持的其他一些重要的运算符，包括 sizeof、typeof 和 ? :。
运算符 |
描述 |
实例 |
sizeof() |
返回数据类型的大小。 |
sizeof(int)，将返回 4. |
typeof() |
返回 class 的类型。 |
typeof(StreamReader); |
& |
返回变量的地址。 |
&a; 将得到变量的实际地址。 |
* |
变量的指针。 |
*a; 将指向一个变量。 |
? : |
条件表达式 |
如果条件为真 ? 则为 X : 否则为 Y |
is |
判断对象是否为某一类型。 |
If( Ford is Car) // 检查 Ford 是否是 Car 类的一个对象。 |
as |
强制转换，即使转换失败也不会抛出异常。 |
Object obj = new StringReader("Hello"); |
2. 实例代码
代码一
using System;
namespace OperatorsAppl
{
class Program
{
static void Main(string[] args)
{
/* sizeof 运算符的实例 */
Console.WriteLine("int 的大小是 {0}", sizeof(int));
Console.WriteLine("short 的大小是 {0}", sizeof(short));
Console.WriteLine("double 的大小是 {0}", sizeof(double));
/* 三元运算符的实例 */
int a, b;
a = 10;
b = (a == 1) ? 20 : 30;
Console.WriteLine("b 的值是 {0}", b);
b = (a == 10) ? 20 : 30;
Console.WriteLine("b 的值是 {0}", b);
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
int 的大小是 4
short 的大小是 2
double 的大小是 8
b 的值是 30
b 的值是 20typeof 关键字用于获取一个类型的类型对象，它通常用于反射和动态创建类型实例。
下面是一个使用 typeof 的简单示例：
代码二
using System;
class Program
{
static void Main(string[] args)
{
Type type = typeof(string);
Console.WriteLine(type.FullName);
Console.ReadKey();
}
}在上面的代码中，我们使用 typeof 关键字来获取 string 类型的类型对象，并将其存储在 Type 类型的变量 type
中，然后，我们使用 FullName 属性打印该类型的完全限定名。
当上面的代码被编译和执行时，它会产生下列结果：
System.String七、运算符优先级
运算符的优先级确定表达式中项的组合。这会影响到一个表达式如何计算。某些运算符比其他运算符有更高的优
先级，例如，乘除运算符具有比加减运算符更高的优先级。
例如 x = 7 + 3 * 2，在这里，x 被赋值为 13，而不是 20，因为运算符 * 具有比 + 更高的优先级，所以首先计算
乘法 3*2，然后再加上 7。
下表将按运算符优先级从高到低列出各个运算符，具有较高优先级的运算符出现在表格的上面，具有较低优先级
的运算符出现在表格的下面。在表达式中，较高优先级的运算符会优先被计算。
优先级简易概括：有括号先括号，后乘除在加减，然后位移再关系，逻辑完后条件，最后一个逗号 , 。
类别 |
运算符 |
结合性 |
后缀 |
() [] -> . ++ - - |
从左到右 |
一元 |
+ - ! ~ ++ - - (type)* & sizeof |
从右到左 |
乘除 |
* / % |
从左到右 |
加减 |
+ - |
从左到右 |
移位 |
<< >> |
从左到右 |
关系 |
< <= > >= |
从左到右 |
相等 |
== != |
从左到右 |
位与 AND |
& |
从左到右 |
位异或 XOR |
^ |
从左到右 |
位或 OR |
| |
从左到右 |
逻辑与 AND |
&& |
从左到右 |
逻辑或 OR |
|| |
从左到右 |
条件 |
?: |
从右到左 |
赋值 |
= += -= *= /= %=>>= <<= &= ^= |= |
从右到左 |
逗号 |
, |
从左到右 |
实例
using System;
namespace OperatorsAppl
{
class Program
{
static void Main(string[] args)
{
int a = 20;
int b = 10;
int c = 15;
int d = 5;
int e;
e = (a + b) * c / d; // ( 30 * 15 ) / 5
Console.WriteLine("(a + b) * c / d 的值是 {0}", e);
e = ((a + b) * c) / d; // (30 * 15 ) / 5
Console.WriteLine("((a + b) * c) / d 的值是 {0}", e);
e = (a + b) * (c / d); // (30) * (15/5)
Console.WriteLine("(a + b) * (c / d) 的值是 {0}", e);
e = a + (b * c) / d; // 20 + (150/5)
Console.WriteLine("a + (b * c) / d 的值是 {0}", e);
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
(a + b) * c / d 的值是 90
((a + b) * c) / d 的值是 90
(a + b) * (c / d) 的值是 90
a + (b * c) / d 的值是 50算术运算符和赋值运算符的优先级
int a = 10, b = 5, c = 2;
int result = a + b * c; // 先计算乘法，再计算加法
Console.WriteLine(result); // 输出20
result = (a + b) * c; // 先计算加法，再计算乘法
Console.WriteLine(result); // 输出30
a += b * c; // 先计算乘法，再执行加法赋值
Console.WriteLine(a); // 输出20逻辑运算符的优先级
bool a = true, b = false, c = true;
bool result = a || b && c; // 先计算与运算，再计算或运算
Console.WriteLine(result); // 输出true
result = (a || b) && c; // 先计算或运算，再计算与运算
Console.WriteLine(result); // 输出true
result = a || (b && c); // 先计算与运算，再计算或运算
Console.WriteLine(result); // 输出true条件运算符的优先级
int a = 10, b = 5;
string result = a > b ? "a大于b" : "a不大于b"; // 先判断大小关系，再执行条件语句
Console.WriteLine(result); // 输出"a大于b"注意：由于括号可以改变运算符优先级，所以在实际应用中建议尽可能使用括号来明确运算顺序，提高代码的可
读性和准确性。
-------------------------------------------
讲解八：流程控制语句
在C#中，流程控制语句用于控制程序中代码的执行顺序。
这些语句允许开发者根据条件执行代码块，循环执行代码块，或者跳过某些代码块。
以下是C#中主要的流程控制语句的详细解释：
一、判断（条件）
判断结构要求程序员指定一个或多个要评估或测试的条件，以及条件为真时要执行的语句（必需的）和条件为假
时要执行的语句（可选的）。
下面是大多数编程语言中典型的判断结构的一般形式：
1. 判断语句（条件语句）
C# 提供了以下类型的判断语句。点击链接查看每个语句的细节。
语句 |
描述 |
一个 if 语句 由一个布尔表达式后跟一个或多个语句组成。 |
|
一个 if 语句 后可跟一个可选的 else 语句，else 语句在布尔表达式为假时执行。 |
|
您可以在一个 if 或 else if 语句内使用另一个 if 或 else if 语句。 |
|
一个 switch 语句允许测试一个变量等于多个值时的情况。 |
|
您可以在一个 switch 语句内使用另一个 switch 语句。 |
2. ? : 运算符
我们已经在前面的章节中讲解了 条件运算符 ? :，可以用来替代 if...else 语句。它的一般形式如下：
Exp1 ? Exp2 : Exp3;其中，Exp1、Exp2 和 Exp3 是表达式。请注意，冒号的使用和位置。
? 表达式的值是由 Exp1 决定的。如果 Exp1 为真，则计算 Exp2 的值，结果即为整个 ? 表达式的值。
如果 Exp1 为假，则计算 Exp3 的值，结果即为整个 ? 表达式的值。
二、循环
有的时候，可能需要多次执行同一块代码。
一般情况下，语句是顺序执行的：函数中的第一个语句先执行，接着是第二个语句，依此类推。
编程语言提供了允许更为复杂的执行路径的多种控制结构。
循环语句允许我们多次执行一个语句或语句组，下面是大多数编程语言中循环语句的一般形式：
1. 循环类型
C# 提供了以下几种循环类型。点击链接查看每个类型的细节。
循环类型 |
描述 |
当给定条件为真时，重复语句或语句组。它会在执行循环主体之前测试条件。 |
|
多次执行一个语句序列，简化管理循环变量的代码。 |
|
除了它是在循环主体结尾测试条件外，其他与 while 语句类似。 |
|
您可以在 while、for 或 do..while 循环内使用一个或多个循环。 |
2. 循环控制语句
循环控制语句更改执行的正常序列。当执行离开一个范围时，所有在该范围中创建的自动对象都会被销毁。
C# 提供了下列的控制语句。点击链接查看每个语句的细节。
控制语句 |
描述 |
终止 loop 或 switch 语句，程序流将继续执行紧接着 loop 或 switch 的下一条语句。 |
|
跳过本轮循环，开始下一轮循环。 |
|
goto 语句（不推荐使用） |
|
3. 无限循环
如果条件永远不为假，则循环将变成无限循环。
for 循环在传统意义上可用于实现无限循环。
由于构成循环的三个表达式中任何一个都不是必需的，您可以将某些条件表达式留空来构成一个无限循环。
using System;
namespace Loops
{
class Program
{
static void Main(string[] args)
{
for (; ; )
{
Console.WriteLine("Hey! I am Trapped");
}
}
}
}当条件表达式不存在时，它被假设为真。您也可以设置一个初始值和增量表达式，但是一般情况下，程序员偏向
于使用 for(;;) 结构来表示一个无限循环。
四、知识小结
通过使用这些流程控制语句，你可以精确地控制C#程序中代码的执行流程，从而实现复杂的逻辑和算法。
每种语句都有其特定的用途和场景，合理使用这些语句可以使你的程序更加高效和易于管理。