C#教程4：数据类型

在 C# 教程的这一部分，我们将讨论数据类型。

包括电子表格、文本编辑器、计算器或聊天客户端在内的计算机程序处理数据。处理各种数据类型的工具是现代计算机语言的重要组成部分。数据类型是一组值以及对这些值的允许操作。

一、C# 数据类型

数据类型是一组值，以及对这些值的允许操作。

C# 中的两种基本数据类型是值类型和引用类型。原始类型（字符串除外）、枚举、元组和结构都是值类型。类、记录、字符串、接口、数组和委托都是引用类型。每种类型都有一个默认值。

引用类型是在堆上创建的。引用类型的生命周期由 .NET 框架管理。引用类型的默认值为空引用。赋值给引用类型的变量会创建引用的副本，而不是引用值的副本。

值类型是在堆栈上创建的。生命周期由变量的生命周期决定。对值类型的变量赋值会创建一个被赋值的值的副本。值类型有不同的默认值。例如，布尔默认值为false，十进制为0，字符串为空字符串“”。

二、C# 布尔值

我们的世界存在着二元性。有天地，水火，阴阳，男女，爱恨。在 C# 中，布尔数据类型是具有以下两个值之一的原始数据类型：真或假。这是一种在计算机程序中非常常见的基本数据类型。

快乐的父母正在等待孩子出生。他们为这两种可能性选择了一个名称。如果是男孩，他们选择了约翰。如果是女孩，他们选择了维多利亚。

Program.cs

var random = new Random();bool male = Convert.ToBoolean(random.Next(0, 2));if (male)
{Console.WriteLine("We will use name John");
}
else
{Console.WriteLine("We will use name Victoria");
}

该程序使用随机数生成器来模拟我们的案例。

var random = new Random();

我们创建一个用于计算随机数的随机对象。它是系统命名空间的一部分。

bool male = Convert.ToBoolean(random.Next(0, 2));

Next 方法返回指定范围内的随机数。包括下限，不包括上限。换句话说，我们收到 0 或 1。稍后，Convert 方法将这些值转换为布尔值，将 0 转换为 false，将 1 转换为 true。

if (male)
{Console.WriteLine("We will use name John");
} else
{Console.WriteLine("We will use name Victoria");
}

如果男性变量设置为 true，我们选择名称 John。否则，我们选择维多利亚这个名字。 if/else 语句等控制结构使用布尔值。

$ dotnet run
We will use name John
$ dotnet run
We will use name John
$ dotnet run
We will use name Victoria

三、C# 整数

整数是实数的子集。它们的书写没有分数或小数部分。整数落入集合 Z = {..., -2, -1, 0, 1, 2, ...}。整数是无限的。

在计算机语言中，整数是原始数据类型。计算机实际上只能处理整数值的子集，因为计算机的容量是有限的。整数用于对离散实体进行计数。我们可以有 3、4、6 个人，但我们不能有 3.33 个人。我们可以有3.33公斤。

VB Alias	.NET Type	Size	Range
sbyte	System.SByte	1 byte	-128 to 127
byte	System.Byte	1 byte	0 to 255
short	System.Int16	2 bytes	-32,768 to 32,767
ushort	System.UInt16	2 bytes	0 to 65,535
int	System.Int32	4 bytes	-2,147,483,648 to 2,147,483,647
uint	System.UInt32	4 bytes	0 to 4,294,967,295
long	System.Int64	8 bytes	-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
ulong	System.UInt64	8 bytes	0 to 18,446,744,073,709,551,615

这些整数类型可以根据我们的需要使用。没有人，（可能除了一些圣经人物之外）可以超过 120、130 岁。然后我们可以在程序中使用字节类型作为年龄变量。这将节省一些内存。

3.1 离散实体

如果我们使用整数，我们将处理离散实体。我们将使用整数来计算苹果。

Program.cs

int baskets = 16;
int applesInBasket = 24;int total = baskets * applesInBasket;Console.WriteLine($"There are total of {total} apples");

在我们的程序中，我们计算苹果的总数。我们使用乘法运算。

int baskets = 16;
int applesInBasket = 24;

篮子的数量和每个篮子中的苹果数量都是整数值。

int total = baskets * applesInBasket;

将这些值相乘，我们也得到一个整数。

$ dotnet run
There are total of 384 apples

3.2 C# 整数符号

整数可以在 C# 中以三种不同的表示法指定：十进制、十六进制和二进制。八进制值没有符号。正如我们所知，通常使用十进制数。十六进制数字以 0x 字符开头，二进制以 0b 开头。

注意：有些语言还支持八进制表示法； C# 没有。

Program.cs

int num1 = 31;
int num2 = 0x31;
int num3 = 0b1101;Console.WriteLine(num1);
Console.WriteLine(num2);
Console.WriteLine(num3);

在程序中，我们用三种不同的符号表示三个整数。

$ dotnet run
31
49
13

默认表示法是小数。该程序以十进制显示这三个数字。

3.3 用下标Using underscores

C# 允许对数字文字使用下划线字符以提高值的可读性。

Program.cs

var num1 = 234_321_000;
Console.WriteLine(num1);var num2 = 0b_0110_000_100;
Console.WriteLine(num2);

该程序使用带有下划线字符的整数文字来提高值的可读性。

3.4 算术溢出

算术溢出是当计算产生的结果在幅度上大于给定寄存器或存储位置可以存储或表示的结果时发生的情况。

Program.cs

byte a = 254;Console.WriteLine(a);
a++;Console.WriteLine(a);
a++;Console.WriteLine(a);
a++;Console.WriteLine(a);

在此示例中，我们尝试分配超出数据类型范围的值。这会导致算术溢出。

$ dotnet run
254
255
0
1

当发生溢出时，变量被重置为数据类型的下限。（如果是字节类型，则为零。）

使用选中的关键字，我们可以在发生溢出时强制执行异常。

Program.cs

checked
{byte a = 254;Console.WriteLine(a);a++;Console.WriteLine(a);a++;Console.WriteLine(a);a++;Console.WriteLine(a);
}

在示例中，语句放置在选中块的主体中。

$ dotnet run
254
255
Unhandled Exception: System.OverflowException: Arithmetic operation resulted in an overflow....

这次抛出 System.OverflowException。

四、C# 浮点数

浮点数表示计算中的实数。实数衡量连续的数量，如体重、身高或速度。在 C# 中，我们有三种浮点类型：float、double 和decimal。

C# Alias	.NET Type	Size	Precision	Range
float	System.Single	4 bytes	7 digits	+-1.5 x 10-45 to +-3.4 x 1038
double	System.Double	8 bytes	15-16 digits	+-5.0 x 10-324 to +-1.7 x 10308
decimal	System.Decimal	16 bytes	28-29 decimal places	+-1.0 x 10-28 to +-7.9 x 1028

上表给出了浮点类型的特征。

默认情况下，C# 程序中的实数是双精度数。要使用不同的类型，我们必须使用后缀。 F/f 表示浮点数，M/m 表示十进制数。

Program.cs

float n1 = 1.234f;
double n2 = 1.234;
decimal n3 = 1.234m;Console.WriteLine(n1);
Console.WriteLine(n2);
Console.WriteLine(n3);Console.WriteLine(n1.GetType());
Console.WriteLine(n2.GetType());
Console.WriteLine(n3.GetType());

在上面的程序中，我们为浮点数使用了三种不同的文字符号。

float n1 = 1.234f;

The f suffix is used for a float number.

double n2 = 1.234;

如果我们不使用后缀，那么它就是一个双数。我们可以选择使用 d 后缀。

Console.WriteLine(n1.GetType());

GetType 方法返回数字的类型。

$ dotnet run
1.234
1.234
1.234
System.Single
System.Double
System.Decimal

我们可以使用各种语法来创建浮点值。

Program.cs

float n1 = 1.234f;
float n2 = 1.2e-3f;
float n3 = (float)1 / 3;Console.WriteLine(n1);
Console.WriteLine(n2);
Console.WriteLine(n3);

我们有三种方法来创建浮点值。第一种是使用小数点的“正常”方式。第二个使用科学记数法。最后一个是数值运算的结果。

float n2 = 1.2e-3f;

这是浮点数的科学记数法。也称为指数表示法，它是一种书写过大或过小的数字而无法方便地以标准十进制表示法书写的方式。

float n3 = (float) 1 / 3;

(float) 构造称为强制转换。除法运算默认返回整数。通过强制转换，我们得到一个浮点数。

$ dotnet run
1.234
0.0012
0.3333333

The float and double types are inexact.

Program.cs

double n1 = 0.1 + 0.1 + 0.1;
double n2 = 1 / 3.0;if (n1 == n2)
{Console.WriteLine("Numbers are equal");
}
else
{Console.WriteLine("Numbers are not equal");
}

比较浮点值时应谨慎。

$ dotnet run
Numbers are not equal

100m 短跑运动员跑了 9.87 秒。他的速度是多少公里/小时？

Program.cs

using System;float distance = 0.1f;float time = 9.87f / 3600;float speed = distance / time;Console.WriteLine($"The average speed of a sprinter is {speed} km/h");

在此示例中，必须使用浮点值。

float distance = 0.1f;

100 m is 0.1 km.

float time = 9.87f / 3600;

9.87 s is 9.87/(60*60) h.

float speed = distance / time;

为了获得速度，我们将距离除以时间。

$ dotnet run
The average speed of a sprinter is 36.47416 km/h

五、C#枚举

枚举类型（也称为枚举或枚举）是由一组命名值组成的数据类型。可以将已声明为具有枚举类型的变量分配为任何枚举数作为值。枚举使代码更具可读性。

Program.cs

Days day = Days.Monday;if (day == Days.Monday)
{Console.WriteLine("It is Monday");
}Console.WriteLine(day);foreach (int i in Enum.GetValues(typeof(Days)))
{Console.WriteLine(i);
}enum Days
{Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday
}

在我们的代码示例中，我们为工作日创建了一个枚举。

enum Days
{Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday
}

枚举是使用 enum 关键字创建的。星期一，星期二，... 裸字存储实际上数字 0..6。

Days day = Days.Monday;

我们有一个名为 day 的变量，它是枚举类型 Days。它被初始化为星期一。

if (day == Days.Monday)
{Console.WriteLine("It is Monday");
}

此代码比将日期变量与某个数字进行比较更具可读性。

Console.WriteLine(day);

此行将星期一打印到控制台。

foreach (int i in Enum.GetValues(typeof(Days)))
{Console.WriteLine(i);
}

此循环将 0..6 打印到控制台。我们得到枚举值的基础类型。对于计算机，枚举只是一个数字。 typeof 是用于获取类型的 System.Type 对象的运算符。 GetValues 方法需要它。此方法返回指定枚举值的数组。 foreach 关键字逐个元素地遍历数组并将它们打印到终端。

我们进一步使用枚举。

Program.cs

Seasons s1 = Seasons.Spring;
Seasons s2 = Seasons.Autumn;Console.WriteLine(s1);
Console.WriteLine(s2);public enum Seasons : byte
{Spring = 1,Summer = 2,Autumn = 3,Winter = 4
}

季节可以很容易地用作枚举。我们可以为枚举指定基础类型，并且可以为它们提供准确的值。

public enum Seasons : byte
{Spring = 1,Summer = 2,Autumn = 3,Winter = 4
}

我们使用冒号和数据类型指定枚举的基础类型。我们还给每个成员一个特定的编号。

Console.WriteLine(s1);
Console.WriteLine(s2);

这两行将枚举值打印到控制台。

$ dotnet run
Spring
Autumn

六、C# 元组

元组是一个有序的、不可变的异构数据值列表。元组是值类型。元组必须至少包含两个元素。元组用圆括号定义。

Program.cs

var words = ("sky", "blue", "rock", "fountain");Console.WriteLine(words);Console.WriteLine(words.Item1);
Console.WriteLine(words.Item2);var words2 = (w1: "forest", w2: "deep", w3: "sea");Console.WriteLine(words2.w1);
Console.WriteLine(words2.w2);
Console.WriteLine(words2.w3);

在示例中，我们定义了两个元组。

var words = ("sky", "blue", "rock", "fountain");

这是一个未命名的元组定义。

Console.WriteLine(words);

我们将元组的所有元素打印到控制台。

Console.WriteLine(words.Item1);
Console.WriteLine(words.Item2);

我们打印前两个元素。我们使用特殊的 Item1、Item2、... 属性访问未命名元组的元素。

var words2 = (w1: "forest", w2: "deep", w3: "sea");

这是命名元组的定义。

Console.WriteLine(words2.w1);
Console.WriteLine(words2.w2);
Console.WriteLine(words2.w3);

我们通过名称访问元素。

$ dotnet run
(sky, blue, rock, fountain)
sky
blue
forest
deep
sea

七、记录C# records

C# 9 引入了记录。记录是不可变的引用类型。记录类型使用基于值的相等性。使用记录关键字创建记录。

记录的主要目的是成为数据持有者。

Program.cs

var cars = new List<Car>
{new Car("Audi", 52642),new Car("Mercedes", 57127),new Car("Skoda", 9000),new Car("Volvo", 29000),new Car("Bentley", 350000),new Car("Citroen", 21000),new Car("Hummer", 41400),new Car("Volkswagen", 21600)
};var res = from car in carswhere car.Price > 30000 && car.Price < 100000select new { car.Name, car.Price };foreach (var car in res)
{Console.WriteLine($"{car.Name} {car.Price}");
}record Car(string Name, int Price);

在示例中，我们使用 LINQ 过滤汽车对象列表。我们包括价格在 30000 到 100000 之间的所有汽车。语言集成查询 (LINQ) 位于 System.Linq 命名空间中，该命名空间包含在隐式使用中。

record Car(string Name, int Price);

A car is a record type.

$ dotnet run
Audi 52642
Mercedes 57127
Hummer 41400

八、C# 字符串和字节

字符串是一种数据类型，表示计算机程序中的文本数据。 C# 中的字符串是 Unicode 字符序列。 char 是单个 Unicode 字符。字符串用双引号括起来。

Program.cs

string word = "ZetCode";char c = word[0];Console.WriteLine(c);

程序将“Z”字符打印到终端。

string word = "ZetCode";

在这里，我们创建一个字符串变量并为其分配“ZetCode”值。

char c = word[0];

字符串是 Unicode 字符数组。我们可以使用数组访问表示法从字符串中获取特定字符。方括号内的数字是字符数组的索引。索引从零开始计数。这意味着第一个字符的索引为 0。

$ dotnet run
Z

九、C# 数组

数组是处理元素集合的复杂数据类型。每个元素都可以通过索引访问。数组的所有元素必须具有相同的数据类型。

Program.cs

int[] numbers = new int[5];numbers[0] = 3;
numbers[1] = 2;
numbers[2] = 1;
numbers[3] = 5;
numbers[4] = 6;int len = numbers.Length;for (int i = 0; i < len; i++)
{Console.WriteLine(numbers[i]);
}

在这个例子中，我们声明一个数组，用数据填充它，然后将数组的内容打印到控制台。

int[] numbers = new int[5];

我们声明了一个整数数组，它最多可以存储五个整数。所以我们有一个由五个元素组成的数组，索引为 0..4。

numbers[0] = 3;
numbers[1] = 2;
numbers[2] = 1;
numbers[3] = 5;
numbers[4] = 6;

在这里，我们将值分配给创建的数组。我们可以通过数组访问表示法访问数组的元素。它由后跟方括号的数组名称组成。在括号内，我们指定我们想要的元素的索引。

int len = numbers.Length;

每个数组都有一个 Length 属性，它返回数组中元素的数量。

for (int i=0; i<len; i++)
{Console.WriteLine(numbers[i]);
}

我们遍历数组并将数据打印到控制台。

十、C#日期和时间

DateTime 是一种值类型。它表示时间的瞬间，通常表示为一天中的日期和时间。

Program.cs

DateTime now = DateTime.Now;System.Console.WriteLine(now);
System.Console.WriteLine(now.ToShortDateString());
System.Console.WriteLine(now.ToShortTimeString());

我们以三种不同的格式显示今天的日期：日期和时间、日期和时间。

DateTime now = DateTime.Now;

获取一个 DateTime 对象，该对象设置为此计算机上的当前日期和时间，以本地时间表示。

System.Console.WriteLine(now);

此行以完整格式打印日期。

System.Console.WriteLine(now.ToShortDateString());
System.Console.WriteLine(now.ToShortTimeString());

ToShortDateString 返回短日期字符串格式，ToShortTimeString 返回短时间字符串格式。

$ dotnet run
12/15/2021 7:58:51 PM
12/15/2021
7:58 PM

十一、C# 类型转化

我们经常同时处理多种数据类型。将一种数据类型转换为另一种数据类型是编程中的一项常见工作。类型转换或类型转换是指将一种数据类型的实体更改为另一种数据类型。有两种类型的转换：隐式和显式。隐式类型转换，也称为强制转换，是编译器自动进行的类型转换。

Program.cs

int val1 = 0;
byte val2 = 15;val1 = val2;Console.WriteLine(val1.GetType());
Console.WriteLine(val2.GetType());Console.WriteLine(12 + 12.5);
Console.WriteLine("12" + 12);

在这个例子中，我们有几个隐式转换。

val1 = val2;

在这里，我们使用两种不同的类型：int 和 byte。我们将一个字节值分配给一个整数值。这是一个加宽操作。 int 值有四个字节；字节值只有一个字节。允许扩大转化。如果我们想将一个 int 分配给一个字节，这将是一个缩短转换。

C# 编译器不允许隐式缩短转换。这是因为在隐式缩短转换中，我们可能会无意中降低精度。我们可以进行缩短转换，但我们必须通知编译器。我们知道我们在做什么。它可以通过显式转换来完成。

Console.WriteLine(12 + 12.5);

我们添加两个值：一个整数和一个浮点值。结果是一个浮点值。这是一个扩大的隐式转换。

Console.WriteLine("12" + 12);

结果是 1212。一个整数被转换为一个字符串，两个字符串被连接起来。

接下来，我们将展示 C# 中的一些显式转换。

Program.cs

double b = 13.5;float a = (float) b;
float c = (int) a;Console.WriteLine(a);
Console.WriteLine(b);
Console.WriteLine(c);

我们有三个价值观。我们对这些值进行了一些显式转换。

float a = (float) b;

我们将双精度值转换为浮点值。通过在两个圆括号之间指定预期类型来完成显式转换。在这种情况下，不会丢失任何精度。数字 13.5 可以安全地分配给这两种类型。

float c = (int) a;

我们将浮点值转换为整数值。在这个语句中，我们失去了一些精度：13.5 变成了 13。

$ dotnet run
13.5
13.5
13

十二、C# 可为空数变量

不能为值类型分配 null 文字，引用类型可以。使用数据库的应用程序处理空值。因此，在 C# 语言中引入了特殊的可为空类型。可空类型是 System.Nullable<T> 结构的实例。

Program.cs

Nullable<bool> male = null;
int? age = null;Console.WriteLine(male.HasValue);
Console.WriteLine(age.HasValue);

一个演示可空类型的简单示例。

Nullable<bool> male = null;
int? age = null;

有两种方法可以声明可空类型。可以使用 Nullable<T> 泛型结构，其中类型在尖括号之间指定，或者我们可以在类型后使用问号。后者实际上是第一个符号的简写。

$ dotnet run
False
False

十三、C# 转换和解析方法

有两组用于转换值的方法。

Program.cs

Console.WriteLine(Convert.ToBoolean(0.3));
Console.WriteLine(Convert.ToBoolean(3));
Console.WriteLine(Convert.ToBoolean(0));
Console.WriteLine(Convert.ToBoolean(-1));Console.WriteLine(Convert.ToInt32("452"));
Console.WriteLine(Convert.ToInt32(34.5));

Convert 类有许多用于转换值的方法。我们使用其中的两个。

Console.WriteLine(Convert.ToBoolean(0.3));

We convert a double value to a bool value.

Console.WriteLine(Convert.ToInt32("452"));

And here we convert a string to an int.

$ dotnet run
True
True
False
True
452
34

Program.cs

Console.WriteLine(int.Parse("34"));
Console.WriteLine(int.Parse("-34"));
Console.WriteLine(int.Parse("+34"));

将字符串转换为整数是一项非常常见的任务。当我们从数据库或 GUI 组件中获取值时，我们经常进行此类转换。

Console.WriteLine(int.Parse("34"));

我们使用 int 的 Parse 方法将字符串转换为 int 值。

$ dotnet run
34
-34
34