C#中的数据类型与变量声明详解

C#中的数据类型概述

在C#编程中，数据类型是基础且关键的概念。数据类型定义了变量能够存储的数据种类，以及这些数据所支持的操作。C#的数据类型主要分为两大类：值类型（Value Types）和引用类型（Reference Types）。这种分类影响着数据在内存中的存储方式和操作特性。

值类型

值类型变量直接存储它们的数据值。这意味着每个值类型变量都有自己独立的数据副本。当把一个值类型变量赋给另一个值类型变量时，实际上是将数据从一个变量复制到另一个变量。

简单类型

1. 整数类型：C#提供了多种整数类型，用于表示不同范围和精度的整数值。
   • sbyte：有符号8位整数，范围是 -128 到 127。例如：

sbyte number1 = -100;

- `byte`：无符号8位整数，范围是 0 到 255。

byte number2 = 200;

- `short`：有符号16位整数，范围是 -32,768 到 32,767。

short number3 = -30000;

- `ushort`：无符号16位整数，范围是 0 到 65,535。

ushort number4 = 60000;

- `int`：有符号32位整数，范围是 -2,147,483,648 到 2,147,483,647。这是最常用的整数类型，例如：

int number5 = 1000000;

- `uint`：无符号32位整数，范围是 0 到 4,294,967,295。

uint number6 = 4000000000;

- `long`：有符号64位整数，范围是 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807。

long number7 = -9000000000000000000;

- `ulong`：无符号64位整数，范围是 0 到 18,446,744,073,709,551,615。

ulong number8 = 18000000000000000000;

2. 浮点类型：用于表示带小数部分的数值。
   • float：单精度32位浮点数，精度大约为7位小数。

float pi1 = 3.14159f;

需要注意的是，在C#中，小数常量默认是double类型，所以给float变量赋值时，需要在数值后加上f或F。 - double：双精度64位浮点数，精度大约为15 - 17位小数。

double pi2 = 3.141592653589793;

3. decimal类型：高精度128位小数类型，主要用于财务和货币计算，它的精度大约为28 - 29位小数。

decimal price = 12.99m;

同样，小数常量默认是double类型，给decimal变量赋值时，需在数值后加上m或M。 4. 字符类型：char类型用于表示单个Unicode字符，占用16位（2字节）。

char letter = 'A';

5. 布尔类型：bool类型只有两个值：true和false，用于表示逻辑判断结果。

bool isDone = true;

枚举类型

枚举类型（enum）是一种用户定义的值类型，它允许定义一组具名的常量。例如，定义一个表示一周中各天的枚举：

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

使用枚举变量：

DayOfWeek today = DayOfWeek.Monday;

默认情况下，枚举常量的值从0开始依次递增。也可以显式指定值：

enum Weekday
{
    Monday = 1,
    Tuesday,
    Wednesday,
    Thursday,
    Friday
}

这里Tuesday的值将是2，因为它没有显式赋值，会自动比前一个常量的值大1。

结构体类型

结构体（struct）是一种可以包含多个不同类型成员的用户定义值类型。例如，定义一个表示二维点的结构体：

struct Point
{
    public int X;
    public int Y;
}

使用结构体变量：

Point myPoint;
myPoint.X = 10;
myPoint.Y = 20;

结构体可以有构造函数、方法和属性等成员。例如：

struct Rectangle
{
    private int width;
    private int height;

    public Rectangle(int w, int h)
    {
        width = w;
        height = h;
    }

    public int Area()
    {
        return width * height;
    }
}

使用这个结构体：

Rectangle rect = new Rectangle(5, 10);
int area = rect.Area();

引用类型

引用类型变量存储的是对象在内存中的地址，而不是对象本身。多个引用类型变量可以引用同一个对象，对一个引用所做的修改会影响到其他引用，因为它们都指向同一个对象。

类类型

类（class）是C#中最常用的引用类型。它可以包含数据成员（字段、属性）、函数成员（方法、构造函数等）和嵌套类型。例如，定义一个简单的Person类：

class Person
{
    private string name;
    private int age;

    public Person(string n, int a)
    {
        name = n;
        age = a;
    }

    public void Introduce()
    {
        Console.WriteLine($"Hello, my name is {name} and I'm {age} years old.");
    }
}

使用Person类：

Person person1 = new Person("Alice", 30);
Person person2 = person1;
person2.Introduce(); // 输出: Hello, my name is Alice and I'm 30 years old.

这里person1和person2引用同一个Person对象。如果修改person2的属性，person1也会受到影响：

person2.age = 31;
person1.Introduce(); // 输出: Hello, my name is Alice and I'm 31 years old.

字符串类型

字符串（string）类型是C#中用于表示文本的数据类型。它实际上是System.String类的别名，是引用类型。

string greeting = "Hello, world!";

字符串是不可变的，即一旦创建，其内容就不能被修改。例如：

string s1 = "abc";
string s2 = s1.ToUpper();
Console.WriteLine(s1); // 输出: abc
Console.WriteLine(s2); // 输出: ABC

这里s1并没有改变，ToUpper方法返回了一个新的字符串。

数组类型

数组是一种引用类型，用于存储多个相同类型的元素。可以创建一维数组、多维数组和交错数组。

1. 一维数组：

int[] numbers = new int[5];
numbers[0] = 1;
numbers[1] = 2;
//...

string[] names = { "Alice", "Bob", "Charlie" };

2. 多维数组：以二维数组为例：

int[,] matrix = new int[3, 2];
matrix[0, 0] = 1;
matrix[0, 1] = 2;
//...

3. 交错数组：即数组的数组。

int[][] jaggedArray = new int[3][];
jaggedArray[0] = new int[2];
jaggedArray[1] = new int[3];
jaggedArray[2] = new int[4];

对象类型

object类型是所有C#类型的基类，任何类型的值都可以隐式转换为object类型。这使得object类型非常灵活，但也带来了一些类型安全问题，因为在运行时需要进行类型检查和转换。

object obj1 = 10; // int 隐式转换为 object
object obj2 = "Hello"; // string 隐式转换为 object

int num = (int)obj1; // 显式类型转换回 int

在进行类型转换时，如果类型不匹配，会抛出InvalidCastException异常。为了避免这种情况，可以使用is关键字进行类型检查：

if (obj2 is string)
{
    string str = (string)obj2;
    Console.WriteLine(str.Length);
}

还可以使用as关键字进行安全的类型转换，如果转换失败，返回null而不是抛出异常：

string result = obj2 as string;
if (result != null)
{
    Console.WriteLine(result.Length);
}

变量声明

变量是用于存储数据的标识符。在C#中，变量必须先声明后使用。变量声明包括变量类型和变量名，也可以同时进行初始化。

声明变量的基本语法

声明变量的基本语法是：<类型> <变量名>;。例如：

int number;
string message;

这里声明了一个int类型的变量number和一个string类型的变量message。此时变量只是在内存中预留了空间，但还没有初始化，不能直接使用。

变量初始化

变量初始化是在声明变量的同时给它赋一个初始值。例如：

int count = 10;
string greeting = "Hello";

对于值类型变量，初始化就是将值直接存储在变量所占用的内存空间中。对于引用类型变量，初始化是在堆内存中创建对象，并将对象的地址存储在变量中。

隐式类型局部变量

从C# 3.0开始，可以使用var关键字来声明隐式类型的局部变量。var关键字告诉编译器根据初始化表达式的类型来推断变量的类型。例如：

var num = 10; // 编译器推断 num 为 int 类型
var str = "Hello"; // 编译器推断 str 为 string 类型

需要注意的是，使用var声明变量时必须同时进行初始化，而且初始化表达式必须是一个编译时就能确定类型的表达式。另外，var并不是一种新的数据类型，它只是一种语法糖，实际的类型还是由初始化值的类型决定。

常量声明

常量是在程序执行过程中其值不能被改变的量。在C#中，使用const关键字声明常量。例如：

const double pi = 3.14159;
const string greeting = "Hello, world!";

常量在声明时必须进行初始化，并且初始化表达式必须是一个编译时常量表达式。常量的值在编译时就确定了，在运行时不能被修改。

变量的作用域

变量的作用域是指变量在程序中可以被访问的区域。在C#中，变量的作用域通常由声明它的位置决定。

1. 块作用域：在一对花括号{}内声明的变量具有块作用域。例如：

{
    int localVar = 10;
    Console.WriteLine(localVar);
}
// 这里不能访问 localVar，因为它的作用域在花括号内结束

2. 方法作用域：在方法内声明的局部变量具有方法作用域，从声明处到方法结束都可以访问。

void MyMethod()
{
    int methodVar = 20;
    // 整个 MyMethod 方法内都可以访问 methodVar
}

3. 类作用域：类的成员变量（字段）具有类作用域，在整个类中都可以访问。

class MyClass
{
    private int classField;

    public void SetField(int value)
    {
        classField = value;
    }

    public int GetField()
    {
        return classField;
    }
}

这里classField在整个MyClass类中都可以访问，包括类的方法中。

类型转换

在C#编程中，经常需要在不同的数据类型之间进行转换。类型转换可以分为隐式转换和显式转换。

隐式转换

隐式转换是编译器自动进行的类型转换，不需要显式的转换操作符。隐式转换通常发生在从较小范围的数据类型转换到较大范围的数据类型时，这样不会丢失数据。例如，从int到long，从float到double等。

int num1 = 10;
long num2 = num1; // 隐式转换，int 转换为 long

float f1 = 3.14f;
double f2 = f1; // 隐式转换，float 转换为 double

对于引用类型，从派生类到基类的转换也是隐式的。例如：

class Animal { }
class Dog : Animal { }

Dog myDog = new Dog();
Animal myAnimal = myDog; // 隐式转换，Dog 转换为 Animal

显式转换

显式转换需要使用显式的转换操作符，因为这种转换可能会丢失数据。例如，从double到int，从long到int等。

double num3 = 10.5;
int num4 = (int)num3; // 显式转换，double 转换为 int，小数部分丢失

对于引用类型，从基类到派生类的转换需要显式进行，并且在运行时需要检查类型是否兼容，否则会抛出InvalidCastException异常。

Animal myAnimal2 = new Dog();
Dog myDog2 = (Dog)myAnimal2; // 显式转换，Animal 转换为 Dog

// 如果 myAnimal2 实际上指向的不是 Dog 类型的对象，下面的代码会抛出异常
Animal myAnimal3 = new Animal();
Dog myDog3 = (Dog)myAnimal3; 

装箱和拆箱

装箱（Boxing）和拆箱（Unboxing）是C#中值类型和引用类型之间的特殊转换机制。装箱是将值类型转换为object类型或转换为该值类型所实现的任何接口类型。拆箱则是相反的操作，将object类型转换回值类型。

1. 装箱：

int num5 = 10;
object boxedNum = num5; // 装箱，int 转换为 object

在装箱过程中，会在堆上创建一个object对象，将值类型的值复制到这个对象中。 2. 拆箱：

object unboxedObj = boxedNum;
int unboxedNum = (int)unboxedObj; // 拆箱，object 转换回 int

拆箱时需要显式指定目标值类型，并且object对象必须实际包含该值类型的装箱值，否则会抛出InvalidCastException异常。

自定义类型转换

在C#中，可以为自定义类型（类和结构体）定义自定义的类型转换。这可以通过定义implicit（隐式）和explicit（显式）转换操作符来实现。例如，为自定义的Point结构体定义从Point到int的隐式转换：

struct Point
{
    public int X;
    public int Y;

    public static implicit operator int(Point p)
    {
        return p.X + p.Y;
    }
}

使用这个自定义转换：

Point myPoint2 = new Point { X = 10, Y = 20 };
int result2 = myPoint2; // 隐式转换，Point 转换为 int

同样，也可以定义显式转换操作符。例如，为Rectangle结构体定义从Rectangle到Point的显式转换：

struct Rectangle
{
    public int Width;
    public int Height;

    public static explicit operator Point(Rectangle r)
    {
        return new Point { X = r.Width, Y = r.Height };
    }
}

使用显式转换：

Rectangle rect2 = new Rectangle { Width = 5, Height = 10 };
Point point2 = (Point)rect2; // 显式转换，Rectangle 转换为 Point

类型推断

类型推断是C#编译器根据上下文自动推断变量类型的能力。除了前面提到的var关键字用于局部变量的类型推断外，C#在其他一些场景也支持类型推断。

泛型类型推断

在使用泛型方法和泛型类型时，编译器可以根据传递的参数类型推断泛型类型参数。例如：

public static T Max<T>(T a, T b) where T : IComparable<T>
{
    return a.CompareTo(b) > 0? a : b;
}

调用这个泛型方法时，编译器可以根据传递的参数类型推断T的类型：

int maxInt = Max(5, 10); // 编译器推断 T 为 int
string maxStr = Max("apple", "banana"); // 编译器推断 T 为 string

Lambda表达式中的类型推断

在Lambda表达式中，编译器可以根据上下文推断参数的类型。例如：

Func<int, int, int> add = (a, b) => a + b;

这里编译器根据Func<int, int, int>的定义推断出a和b的类型为int。如果上下文不明确，也可以显式指定参数类型：

Func<int, int, int> add2 = (int a, int b) => a + b;

可空类型

在C#中，值类型默认是不可空的，即必须有一个确定的值。但在某些情况下，可能需要表示一个值类型的变量可以没有值，这就需要用到可空类型（Nullable Types）。

可空类型的声明

可空类型通过在值类型后加上?来声明。例如：

int? nullableInt = null;
double? nullableDouble = 3.14;

这里nullableInt是一个可空的int类型变量，它可以赋值为null，也可以赋值为正常的int值。nullableDouble是一个可空的double类型变量，它被初始化为3.14。

可空类型的使用

可空类型可以像普通值类型一样进行操作，但在使用其值之前需要检查是否为null，以避免NullReferenceException异常。可以使用HasValue属性检查可空类型是否有值，使用Value属性获取其值。例如：

int? num6 = null;
if (num6.HasValue)
{
    int value = num6.Value;
    Console.WriteLine(value);
}
else
{
    Console.WriteLine("The value is null.");
}

还可以使用??运算符（空合并运算符）来提供一个默认值，当可空类型为null时使用这个默认值。例如：

int? num7 = null;
int result3 = num7?? 10; // result3 的值为 10

这里如果num7不为null，result3将是num7的值；如果num7为null，result3将是10。

可空类型与数据库编程

可空类型在数据库编程中非常有用，因为数据库中的列可以允许为空值。当从数据库读取数据到C#程序中时，可空类型可以很好地映射数据库中的可空列。例如，假设数据库中有一个Nullable<int>类型的列，在C#中可以使用int?类型来对应：

// 假设使用 ADO.NET 从数据库读取数据
using (SqlConnection connection = new SqlConnection(connectionString))
{
    SqlCommand command = new SqlCommand("SELECT nullable_column FROM your_table", connection);
    connection.Open();
    object value = command.ExecuteScalar();
    int? nullableColumnValue = value == DBNull.Value? null : (int?)value;
}

通过深入理解C#中的数据类型与变量声明，开发者能够更好地编写高效、健壮且类型安全的代码，充分发挥C#语言的强大功能。无论是简单的数值计算，还是复杂的面向对象编程，对这些基础概念的掌握都是至关重要的。在实际编程中，应根据具体需求选择合适的数据类型和变量声明方式，并合理运用类型转换和推断等特性，以提高代码的质量和可读性。同时，对于可空类型等特殊概念，要特别注意其使用场景和潜在的空值处理问题，避免程序运行时出现异常。在后续的编程实践中，不断加深对这些知识的理解和运用，将有助于成为一名优秀的C#开发者。