学习c#的第四天

整数类型：C#中的整数类型包括sbyte、byte、short、ushort、int、uint、long、ulong和char。它们分别表示有符号字节、无符号字节、有符号短整型、无符号短整型、有符号整型、无符号整型、有符号长整型、无符号长整型和Unicode字符。
浮点型：C#中的浮点类型有float和double，它们分别用于存储单精度浮点数和双精度浮点数。
十进制类型：C#中的十进制类型是decimal，它用于精确表示小数，通常用于金融等领域。
布尔类型：C#中的布尔类型是bool，只能存储true或false值，用于逻辑判断。
空类型：C#中引入了可空类型的概念，通过在类型名称后加上?来定义可空类型的变量，例如int?、bool?等，这样的变量可以存储正常的数据，也可以存储null值。

此外，C#还允许定义其他值类型的变量，比如enum枚举类型，以及定义引用类型变量，比如class类类型，

C# 中的变量定义与初始化

在C#中，定义变量需要指定变量的类型，并为其分配一个合适的名称。变量定义的一般形式如下：

cs 复制代码

type identifier; // 声明一个变量，但不初始化
type identifier = value; // 声明一个变量并初始化

其中：

type 表示变量的数据类型，可以是整数类型、浮点型、字符型、布尔型等。
identifier 是变量的名称，用于在程序中引用该变量。
value 是要赋给变量的初始值，可以省略，表示不进行初始化。

举例来说，如果我们想声明一个整数类型的变量age，可以这样做：

cs 复制代码

int age; // 声明一个整数型变量age，但不初始化

如果要在声明时就给age变量赋一个初始值，可以这样：

cs 复制代码

int age = 30; // 声明一个整数型变量age，并赋初值30

另外，C#也支持在声明时使用var关键字进行隐式类型推断，例如：

cs 复制代码

var name = "John"; // 根据赋值右侧的数据类型推断name为字符串类型

需要注意的是，变量名必须遵循标识符的命名规则，首字母不能是数字，不能使用C#的关键字作为变量名，变量名区分大小写。

接受来自用户的值

在C#中，可以使用Console.ReadLine()来接受来自用户的输入值。这个方法会等待用户在控制台中输入一行文本，然后将用户输入的文本作为字符串返回。如果需要将用户输入的内容转换为其他类型（比如整数、浮点数等），可以使用相应类型的转换方法，比如int.Parse()或者Convert.ToInt32()来实现（可以看这篇文章学习）。

下面是一个简单的示例，演示如何接受用户的输入并将其转换为整数：

cs 复制代码

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("请输入您的年龄：");
        string input = Console.ReadLine(); // 接受用户输入的字符串
        int age = 0;
        if (int.TryParse(input, out age))
        {
            Console.WriteLine("您的年龄是：" + age);
        }
        else
        {
            Console.WriteLine("输入的不是有效的年龄！");
        }
    }
}

在这个示例中，我们首先使用Console.ReadLine()来接受用户输入的字符串，并将其保存在input变量中。然后，我们使用int.TryParse()方法将input字符串转换为整数类型，并将转换后的值存储在age变量中。如果转换成功，就输出用户的年龄；如果转换失败，就输出错误信息。

这样，通过使用Console.ReadLine()和适当的类型转换方法，就可以很方便地接受来自用户的输入值了。

C# 中的 Lvalues 和 Rvalues

在C#中，表达式可以分为左值（Lvalue）和右值（Rvalue）。这两个术语通常用于描述赋值操作和表达式的值。

lvalue（左值）：在 C# 中，lvalue 是一个表示存储位置的表达式，可以出现在赋值语句的左边或右边。换句话说，lvalue 是一个可以被赋值的表达式。通常情况下，变量就是 lvalue，因为它们代表了内存中的存储位置。
rvalue（右值）：在 C# 中，rvalue 表达式是一个产生值的表达式，可以出现在赋值语句的右边。rvalue 表达式计算出一个值，但不能直接作为赋值语句的左值出现。

所以，在 C# 中，变量是 lvalue，因此可以出现在赋值语句的左边，而数值、常量、表达式等都是 rvalue，只能出现在赋值语句的右边。

cs 复制代码

int a = 5; // a 是 lvalue
int b = 3; // b 是 lvalue
int c = a + b; // a + b 是 rvalue，计算出一个值用于赋给 c

// 下面的语句将导致编译错误，因为常量 2 是 rvalue，不能作为赋值语句的左值
// 2 = a;

不同类型变量进行运算

cs 复制代码

double a = 42.29;
int b = 4229;
int c = a + b;
Console.WriteLine("c = {0}",c);
Console.ReadKey();

上面这种编程方法是错误的，会出现错误提示：

举例说明，当一个精度高的数据类型与一个精度低的数据类型进行运算时，定义运算结果的变量类型必须与精度最高的变量类型相同。这是为了防止在运算过程中造成数据丢失。

下面是正确代码：

cs 复制代码

using System;

class Program
{
    static void Main()
    {
        double a = 42.29;
        int b = 4229;
        double c = a + b;
        Console.WriteLine("c = {0}", c); //输出：c = 4271.29
        Console.ReadKey();
    }
}

静态变量

在C#中确实没有全局变量的概念，所有的变量都必须属于某个类的实例或者是静态变量（类级别的变量）。这种设计有助于提高安全性和避免命名冲突，但同时在某些情况下也会限制了对全局状态的管理。

正因如此，静态变量就成为了一种在整个类中共享数据的方式。通过静态变量，可以在类的所有实例之间共享相同的数据，这在某些情况下非常有用，比如跟踪全局状态、存储常量值或者单例模式的实现等。

举个例子，如果有一个 Car 类，我们希望能够跟踪所有汽车的数量，那么就可以使用静态变量来实现：

cs 复制代码

public class Car
{
    public static int numberOfCars = 0;

    public Car()
    {
        numberOfCars++;
    }
}

在这个例子中，numberOfCars 就是一个静态变量，它跟踪着 Car 类的所有实例的数量。每次创建一个新的 Car 实例时，numberOfCars 都会自动增加。这样的设计正是静态变量的优秀应用之一。

因此，在一些特定的场景下，静态变量能够有效地解决全局共享数据的需求，同时也需要注意线程安全性和合理使用的问题。

局部变量

在C#中，方法的局部变量必须在使用之前进行显式初始化。虽然不一定需要在声明变量的时候就进行初始化，但在使用变量之前必须确保它已经被赋值。

这种要求是为了避免潜在的错误，比如使用未初始化的变量，从而导致不可预测的行为。编译器会通过方法检查所有可能的路径，如果检测到局部变量在初始化之前就被使用，就会产生编译错误，以提示开发者存在潜在的问题。

举个例子，以下代码将会产生编译错误：

cs 复制代码

public void ExampleMethod()
{
    int x;
    Console.WriteLine(x); // 编译错误：使用了未赋值的变量x
    x = 10; // 只有在这里进行了赋值，才能正确地使用x
}

在这个例子中，变量 x 在使用之前并没有进行初始化赋值，因此会导致编译错误。为了修复这个问题，我们应该在使用变量之前先对其进行赋值。

C# 常量

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

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

整数常量

在C#中，整数常量可以使用不同的进制表示，并且可以附加后缀来指定其类型。

1、十进制整数常量：

十进制整数常量是最常见的，可以直接使用数字表示，例如：

cs 复制代码

int decimalConst = 123;
uint positiveDecimalConst = 456U; // 使用后缀U表示无符号整数
long longDecimalConst = 789L; // 使用后缀L表示长整数

2、十六进制整数常量：

十六进制整数常量以 "0x" 或 "0X" 开头，后面跟着十六进制数字表示，例如：

cs 复制代码

int hexConst = 0xABCD;
uint positiveHexConst = 0x1234U; // 使用后缀U表示无符号整数

3、八进制整数常量：

八进制整数常量以 "0" 开头，后面跟着八进制数字表示（0-7），例如：

cs 复制代码

int octalConst = 0123;

4、整数常量后缀：

整数常量可以附加后缀来指定类型，例如：

"U" 或 "u" 表示无符号整型；
"L" 或 "l" 表示长整型；
多个后缀可以以任意顺序进行组合，例如 "UL", "Lu" 等。

浮点常量

一个浮点常量是由整数部分、小数点、小数部分和指数部分组成。可以使用小数形式或者指数形式来表示浮点常量。以下是两种表示形式的示例：

1、小数形式：浮点常量的小数形式由整数部分、小数点和小数部分组成，例如：

3.14
2.718
123.456

2、指数形式：浮点常量的指数形式使用科学计数法表示，由尾数部分和指数部分组成，例如：

6.022e23 （相当于6.022乘以10的23次方）
1.602e-19 （相当于1.602乘以10的负19次方）

在C#中，我们可以使用小数形式或者指数形式来表示浮点常量，以满足不同数值范围和精度的需求。

字符常量

字符常量在C#中是以单引号括起来的，例如 '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 . . .	一个或多个数字的十六进制数

以下是一些转义序列字符的实例：

cs 复制代码

using System;

class Program
{
    static void Main()
    {
        // 定义一个普通字符常量
        char normalChar = 'A';
        Console.WriteLine(normalChar); // 输出：A

        // 使用转义序列表示制表符
        char tabChar = '\t';
        Console.WriteLine("Hello" + tabChar + "World"); // 输出：Hello    World

        // 使用转义序列表示换行符
        char newLineChar = '\n';
        Console.WriteLine("第一行" + newLineChar + "第二行"); // 输出：
                                                                // 第一行
                                                                 // 第二行

        // 使用八进制数表示特定的字符
        char octalChar = '\u0041'; // 这里表示的是ASCII码为65的字符，即'A'
        Console.WriteLine(octalChar); // 输出：A
    }
}

字符串常量

在C#中，字符串常量可以被包裹在双引号 "" 中，例如："Hello, World!"，也可以使用@符号作为前缀，这样的字符串称为@字符串，例如：@"Hello, World!"。@字符串通常用于包含换行符等特殊字符的情况，因为在@字符串中，转义序列会被直接输出而不会被解释。

以下是一个示例，演示了如何在C#中使用多行字符串常量：

cs 复制代码

using System;

class Program
{
    static void Main()
    {
        // 多行字符串常量
        string multiLineString = "This is a very long string that " +
                                "spans multiple lines " +
                                "but appears as a single string.";
        Console.WriteLine(multiLineString);

        // 使用 @ 字符串来包含换行符等特殊字符
        string multiLineStringWithAtSign = @"This is a multi-line
                                            string using the @ symbol
                                            to include new lines directly.";
        Console.WriteLine(multiLineStringWithAtSign);
    }
}

在上面的示例中，第一个字符串常量跨越多行，但通过在每行的末尾添加空格，编译器将其连接成一个完整的字符串。第二个示例则使用@字符串，直接包含了换行符，使得整个字符串的格式与源代码中的格式保持一致。

此外，在C#中，还有一个很重要的特性，即可以通过将一个很长的行拆分成多个行来使用字符串常量。这种方式非常有助于提高代码的可读性，特别是当需要定义很长的字符串时。这种做法可以通过在每一行的末尾使用空格来实现，编译器会自动将它们连接在一起形成一个完整的字符串。

定义常量

在C#中，可以使用关键字 const 来定义常量。常量是指在程序执行期间其值不会改变的变量，一旦被赋值后就无法再次修改。常量在声明时必须进行初始化，而且不能使用赋值语句来改变它们的值。

以下是一个简单的示例，演示了如何在C#中定义常量：

cs 复制代码

using System;

class Program
{
    static void Main()
    {
        const int hoursInDay = 24;
        const double pi = 3.14159;
        const string greeting = "Hello, World!";

        Console.WriteLine("There are " + hoursInDay + " hours in a day.");
        Console.WriteLine("The value of pi is approximately " + pi + ".");
        Console.WriteLine(greeting);
    }
}

在上面的示例中，hoursInDay、pi 和 greeting 都被声明为常量，并分别被赋予了初始值。在后续的代码中，无法修改这些常量的值。当您尝试修改常量的值或者在声明后未给其赋值，编译器会报错。

扩展知识

Convert.ToDouble 与 Double.Parse 的区别

实际上 Convert.ToDouble 与 Double.Parse 较为类似， Convert.ToDouble内部调用了 Double.Parse：

(1)对于参数为null的时候：

Convert.ToDouble参数为 null 时，返回 0.0；
Double.Parse 参数为 null 时，抛出异常。

(2)对于参数为""的时候：

Convert.ToDouble参数为 "" 时，抛出异常；
Double.Parse 参数为 "" 时，抛出异常。

(3)其它区别：

Convert.ToDouble可以转换的类型较多；
Double.Parse 只能转换数字类型的字符串。
Double.TryParse 与 Double.Parse 又较为类似，但它不会产生异常，转换成功返回 true，转换失败返回 false。最后一个参数为输出值，如果转换失败，输出值为 0.0。

以下是一个附带测试的代码示例，

cs 复制代码

using System;

class Program
{
    static void Main()
    {

        // 1. 参数为null的情况
        double result1 = Convert.ToDouble(null); // 返回 0.0
        //double result2 = Double.Parse(null); // 抛出异常

        // 2. 参数为""的情况
        //double result3 = Convert.ToDouble(""); // 抛出异常
        //double result4 = Double.Parse(""); // 抛出异常

        // 3. 其他区别
        string numberStr = "3.14";
        double result5 = Convert.ToDouble(numberStr); // 可以转换成功
        double result6 = Double.Parse(numberStr);   // 可以转换成功

        string nonNumberStr = "abc";
        //double result7 = Convert.ToDouble(nonNumberStr); // 抛出异常
        //double result8 = Double.Parse(nonNumberStr); // 抛出异常

        // 使用 Double.TryParse
        double result9;
        bool parseResult = Double.TryParse("5.67", out result9); // 转换成功，parseResult 为 true，result9 的值为 5.67
        bool parseResult2 = Double.TryParse("xyz", out result9); // 转换失败，parseResult2 为 false，result9 的值为 0.0

        Console.WriteLine("Convert.ToDouble(null): " + result1);
        Console.WriteLine("Double.TryParse result: " + parseResult);
        Console.WriteLine("Double.TryParse output value: " + result9);
    }
}

静态常量和动态常量

在 C# 中，常量（const）和只读字段（readonly）确实都用于表示不可更改的值，但是它们之间有一些重要的区别：

1、const（静态常量，编译时常量）：

const 关键字用于声明编译时常量，即在编译时就确定了值，并且在声明时必须进行初始化，之后不能再更改。
const 可以在类、结构体、枚举以及方法内部使用。
声明方法：const <type> <name> = <value>;

cs 复制代码

public class MyClass
{
    public const double Pi = 3.14; // 正确声明常量的方法
    // public const int b; // 错误，必须进行初始化
}

2、readonly（动态常量，运行时常量）：

readonly 关键字用于声明只读字段，其值可以在声明时或构造函数中初始化，并且只能在类中定义。它的值在运行时确定，且无法被修改。
readonly 字段可以在声明时或构造函数中初始化，而在其他方法中则无法修改其值。
声明方法：readonly <type> <name>;

cs 复制代码

public class MyClass
{
    public readonly double Pi; // 声明只读字段
    public MyClass()
    {
        Pi = 3.14; // 只能在构造函数中初始化
    }
}

总结来说，const 适用于在编译时已知且不会改变的常量值，而 readonly 适用于在运行时确定且不可变的常量值。

**需要注意的是，**在编程中，对于取值永久不变且在编译时已知的常量（比如圆周率、一天的小时数、地球的半径等），使用 const 常量是非常合适的，这样可以在编译时直接将常量的值嵌入到代码中，从而避免了运行时的性能开销。

另外，在对程序性能要求非常苛刻的情况下，也可以考虑使用 const 常量，因为它们的值在编译时就确定，可以对程序的性能和内存占用进行优化。

而对于其他情况，尤其是在需要在运行时确定常量值的情况下，或者常量的赋值需要依赖于构造函数等复杂逻辑时，使用 readonly 常量更为合适。这样可以保证常量的值在运行时确定，并且可以在构造函数中进行初始化，同时也更灵活地满足程序的需求。

关于常量变量命名的规则

对于带有 private 访问修饰符的常量，下划线开头、骆驼命名法是一种常见的做法，例如 _bookName。

而对于带有 public 或 protected 访问修饰符的常量，则使用帕斯卡命名法，首字母大写，并且单词之间没有下划线，例如 BookPrice。

cs 复制代码

public class Book
{
    // 使用帕斯卡命名法命名的公共常量
    public const string Title = "C# 编程"; 

    // 使用帕斯卡命名法命名的受保护常量
    protected const double Price = 29.99;

    // 使用下划线和骆驼命名法命名的私有常量
    private const int _maxAllowed = 5;
}

在这个示例中，我们根据访问修饰符来规范常量的命名方式。公共常量 Title 和受保护常量 Price 使用帕斯卡命名法，而私有常量 _maxAllowed 则使用了下划线和骆驼命名法。