C# 数据类型

C# 主要类型

  1. 值类型（Value Types）：
    • 存储的是实际的数据值。
    • 直接存储在栈上。
    • 包括整数类型（如int、long）、浮点类型（如float、double）、字符类型（如char）、布尔类型（如bool）以及结构体（如struct）等。
  1. 引用类型（Reference Types）：
    • 存储的是对象的引用（内存地址）。
    • 引用类型的对象存储在堆上，而变量本身存储在栈上。
    • 包括类（如class）、接口（如interface）、数组（如Array）、委托（如delegate）以及字符串（如string）等。
  1. 指针类型（Pointer Types）：
    • 允许直接操作内存地址。
    • C#中的指针类型主要用于与非托管代码进行交互、处理不安全代码块等，是不常用的语言特性。
  1. 可空类型（Nullable Types）：
    • 允许变量存储空值。
    • 用于值类型，通过在值类型后面添加?来声明，如int?、float?等。
  1. 动态类型（Dynamic Types）：
    • 允许在运行时推断变量的类型。
    • 通过关键字dynamic声明的变量，编译器在编译时不会进行类型检查，而是推迟到运行时。

这些不同类型的变量在C#中提供了灵活的编程选择，程序员可以根据需求选择合适的变量类型来实现特定的功能。

值类型（Value Types）

在C#中，值类型（Value Types）主要包括以下几种：

  1. 整数类型（Integer Types）：
    • sbyte：有符号的8位整数。
    • byte：无符号的8位整数。
    • short：有符号的16位整数。
    • ushort：无符号的16位整数。
    • int：有符号的32位整数。
    • uint：无符号的32位整数。
    • long：有符号的64位整数。
    • ulong：无符号的64位整数。
  1. 浮点类型（Floating-Point Types）：
    • float：单精度浮点数，32位。
    • double：双精度浮点数，64位。
  1. 字符类型（Character Type）：
    • char：16位Unicode字符。
  1. 布尔类型（Boolean Type）：
    • bool：表示true或false。
  1. 结构体（Structures）：
    • 结构体是用户自定义的值类型，可以包含多个字段。
    • 结构体在声明时是值类型，但是可以通过装箱（boxing）转换为引用类型。
  1. 枚举（Enum）
    • C#允许开发人员使用枚举（Enum）来定义一组命名的常量值，它们在本质上是一种特殊的整数类型的值类型。

引用类型（Reference Types）

引用类型（Reference Types）在C#中是一种存储对象引用的数据类型，它们的值存储在堆中，而变量本身存储的是对象的引用（内存地址）。这意味着对引用类型的变量进行操作实际上是在操作对象本身，而不是对象的副本。

C#中的主要引用类型包括：

  1. 类（Class）：
    • 类是面向对象编程的基础，可以定义包含数据成员和成员函数的对象模板。
    • 类的实例在堆上动态分配，并通过引用进行访问。
  1. 接口（Interface）：
    • 接口定义了一组成员（方法、属性、事件、索引器），实现接口的类必须实现这些成员。
    • 接口的实例是引用类型。
  1. 数组（Array）：
    • 数组是相同类型元素的集合，可以通过索引访问。
    • 数组也是引用类型，数组对象本身存储在堆中，而数组元素可以是值类型或引用类型。
  1. 委托（Delegate）：
    • 委托是一种类型安全的函数指针，可以引用一个或多个方法。
    • 委托类型是引用类型。
  1. 字符串（String）：
    • 字符串是不可变的字符序列，以双引号括起来。
    • 字符串是引用类型，但是由于其不可变性和特殊优化，使用起来类似于值类型。

引用类型在C#中具有动态性和灵活性，但也需要程序员自行管理内存和对象生命周期，以避免内存泄漏和性能问题。

C#值类型和引用类型的区别

  1. 存储位置：
    • 值类型的变量直接存储其值，通常在栈上分配内存。
    • 引用类型的变量存储的是对象的引用（内存地址），实际对象存储在堆上。
  1. 复制行为：
    • 值类型的复制是深复制，即复制的是值本身。
    • 引用类型的复制是浅复制，即复制的是对象的引用，两个变量指向同一个对象。
  1. 内存管理：
    • 值类型的内存管理是自动的，由编译器或运行时系统进行。
    • 引用类型的内存管理需要手动进行，包括对象的创建、销毁以及垃圾回收等。
  1. 传递方式：
    • 值类型在传递给方法时，是按值传递的，即传递的是值的副本。
    • 引用类型在传递给方法时，是按引用传递的，即传递的是对象的引用，方法内对对象的修改会影响到原对象。
  1. 对比方式：
    • 值类型使用“==”比较的是值本身，即两个值相等即可。
    • 引用类型使用“==”比较的是对象的引用，即两个引用指向同一对象时才相等。
  1. 可空性：
    • 值类型可以声明为可空类型，表示可以存储空值。
    • 引用类型本身就可以存储空值，不需要额外声明可空性。
  1. 来源：
    • 值类型继承自System.ValueType，引用类型继承自System.Object。

装箱和拆箱

在C#中，装箱（Boxing）和拆箱（Unboxing）是用于值类型和引用类型之间转换的两个过程。这两个过程允许将值类型转换为引用类型和将引用类型转换为值类型。

  1. 装箱（Boxing）：
    • 装箱是将值类型转换为引用类型的过程。
    • 当将值类型赋值给一个对象类型（例如 object、dynamic 或接口类型）的变量时，会发生装箱。
    • 在装箱时，会创建一个包含值类型值的新的引用类型对象，并将值类型的值复制到新对象中。
    • 装箱是隐式的，不需要显式的类型转换操作。
int i = 10; // 声明一个值类型变量
object obj = i; // 装箱，将值类型赋值给引用类型变量
  1. 拆箱（Unboxing）：
    • 拆箱是将引用类型转换为值类型的过程。
    • 当需要将引用类型变量中的值取出并转换为值类型时，会发生拆箱。
    • 在拆箱时，会将引用类型对象中的值复制到一个新的值类型变量中。
    • 拆箱是显式的，需要使用强制类型转换操作来进行拆箱。
object obj = 10; // 声明一个引用类型变量并赋值
int i = (int)obj; // 拆箱，将引用类型的值转换为值类型

需要注意的是，装箱和拆箱操作会带来性能损失，并且可能会导致不必要的内存分配。因此，在性能敏感的代码中应该尽量避免装箱和拆箱操作，尤其是在循环中。

类型判断

在C#中，你可以使用多种方法来判断变量的类型，具体取决于你的需求和情况。以下是一些常用的方法：

  1. 使用 typeof 运算符：
    • typeof 运算符用于获取类型对象。
    • 你可以使用 typeof 运算符来检查变量的类型是否与某个特定类型相同。
csharpCopy code
object obj = "Hello";
if (obj.GetType() == typeof(string)) {
    Console.WriteLine("obj 是字符串类型");
}
  1. 使用 is 关键字：
    • is 关键字用于判断一个对象是否是某个特定类型或者其派生类型的实例。
    • 你可以使用 is 关键字来检查一个变量是否属于某个特定类型，并根据结果进行相应的操作。
csharpCopy code
object obj = "Hello";
if (obj is string) {
    Console.WriteLine("obj 是字符串类型");
}

 

  1. 使用 as 关键字：
    • as 关键字用于尝试将一个对象转换为指定类型，如果转换失败则返回 null。
    • 你可以使用 as 关键字将一个对象转换为某个特定类型，并根据结果进行判断。
csharpCopy code
object obj = "Hello";
string str = obj as string;
if (str != null) {
    Console.WriteLine("obj 是字符串类型");
}

 

  1. 使用模式匹配：
    • C# 7.0 引入了模式匹配，可以更方便地判断变量的类型，并在一条语句中进行类型转换和操作。
csharpCopy code
object obj = "Hello";
if (obj is string str) {
    Console.WriteLine($"obj 是字符串类型，值为 {str}");
}

这些方法可以根据你的需求来选择使用，它们提供了不同的灵活性和功能，使你可以根据变量的类型执行不同的操作。

dynamic

在C#中，dynamic 是一种特殊的数据类型，它允许你在编译时推迟类型检查，而是在运行时进行类型绑定。使用 dynamic 关键字声明的变量可以代表任何类型的值，并且可以在运行时动态地改变其类型。

使用 dynamic 变量时，编译器不会对其进行静态类型检查，而是在运行时根据实际类型进行动态绑定。这意味着你可以调用任何成员，执行任何操作，而不需要进行显式的类型转换或类型检查。

下面是使用 dynamic 的一些示例：

csharpCopy code
dynamic dynamicVariable = 10;
Console.WriteLine(dynamicVariable);  // 输出结果为 10

dynamicVariable = "Hello";
Console.WriteLine(dynamicVariable);  // 输出结果为 Hello

dynamicVariable = new List<int>() { 1, 2, 3 };
dynamicVariable.Add(4); // 动态调用 List<int> 类型的 Add 方法

foreach (var item in dynamicVariable) {
    Console.WriteLine(item); // 遍历并输出列表的元素
}

在这个示例中，dynamicVariable 变量首先被赋值为整数，然后被赋值为字符串，最后被赋值为一个整数列表。在每一次赋值之后，你可以调用任何成员或执行任何操作，因为编译器将根据实际类型进行动态绑定。

dynamic 变量常用于与动态语言（如Python、JavaScript等）交互、COM（Component Object Model）互操作、反射以及一些需要更灵活的类型检查和绑定的情况。然而，由于失去了编译时的类型检查，使用 dynamic 变量可能会增加程序的复杂性，并且可能导致运行时的类型错误。因此，应谨慎使用 dynamic，并尽量在能够使用静态类型的情况下避免使用它。

dynamic vs object

在C#中，dynamic 和 object 是两种用于处理不同类型的变量的机制，它们之间有一些重要的区别：

  1. 静态类型检查：
    • object 是一种静态类型，在编译时会进行类型检查。
    • dynamic 是一种动态类型，在编译时不进行类型检查，而是在运行时进行动态绑定。
  1. 编译时行为：
    • 使用 object 声明的变量在编译时会被视为 object 类型，只能调用 object 类型的成员，需要进行显式的类型转换才能访问实际类型的成员。
    • 使用 dynamic 声明的变量在编译时不会进行类型检查，可以调用任何成员，而且不需要进行显式的类型转换，编译器会推迟类型检查到运行时。
  1. 性能：
    • object 类型的变量在运行时需要进行类型转换，因为它在编译时会被视为 object 类型，所以性能可能会受到一定影响。
    • dynamic 类型的变量在运行时不需要进行类型转换，因为它在运行时会根据实际类型进行动态绑定，所以性能可能会更好一些。
  1. 运行时行为：
    • 对于 object 类型的变量，只能调用 object 类型的成员，即使实际类型具有其他成员也无法直接访问。
    • 对于 dynamic 类型的变量，可以调用任何成员，编译器会根据实际类型进行动态绑定，允许访问实际类型的成员。
  1. 编程场景：
    • object 通常用于处理未知类型或者需要在不同类型之间进行转换的情况，但需要进行显式的类型转换。
    • dynamic 通常用于与动态语言交互、COM（Component Object Model）互操作以及需要更灵活的类型检查和绑定的情况。

总的来说，dynamic 提供了更灵活、更动态的类型处理机制，适用于需要在运行时根据实际情况进行类型检查和绑定的场景；而 object 提供了一种静态的、通用的类型处理机制，适用于处理未知类型或者需要在编译时进行类型检查的场景。

Var 类型

var 是 C# 中的一个关键字，用于声明隐式类型变量。使用 var 关键字声明的变量的类型由编译器根据初始化表达式自动推断而来，从而省去了显式地指定变量类型的步骤。这样可以简化代码，提高可读性，并且在一定程度上提高了代码的灵活性。

下面是 var 关键字的一些特点和用法：

  1. 类型推断：
    • 使用 var 声明的变量会根据其初始化表达式的类型进行类型推断。编译器会在编译时将变量的类型确定为初始化表达式的类型。
    • 在使用 var 声明变量时，必须将初始化表达式与声明放在同一行。
  1. 静态类型：
    • 使用 var 声明的变量是具有静态类型的，一旦确定了变量的类型，就不能再改变。
  1. 编译时行为：
    • var 变量在编译时会被替换为其实际类型，因此它不是一种动态类型。
    • 在编译时，编译器会根据初始化表达式的类型推断出 var 变量的类型，从而进行类型检查。
  1. 代码简化：
    • var 可以使代码更简洁、更易读，特别是在初始化表达式类型较长或复杂时。
    • 但过度使用 var 可能会降低代码的可读性，因此应该在代码的可读性和简洁性之间做出权衡。

下面是一些使用 var 的示例：

// 使用 var 声明字符串类型变量
var str = "Hello, World!";

// 使用 var 声明整数类型变量
var number = 10;

// 使用 var 声明集合类型变量
var list = new List<string>();

// 使用 var 声明匿名类型变量
var person = new { Name = "John", Age = 30 };

总的来说，var 关键字可以提高代码的简洁性和可读性，但应该适度使用，避免过度使用导致代码可读性下降。通常情况下，var 应该用于初始化表达式的类型清晰明了的情况下，或者初始化表达式类型较长或复杂的情况下。

dynamic vs var

dynamic 和 var 是 C# 中用于声明变量的两种关键字，它们之间有一些重要的区别：

  1. 静态类型检查：
    • var 关键字用于声明变量时，编译器会根据变量的初始化表达式推断出其类型，并进行静态类型检查。
    • dynamic 关键字用于声明变量时，编译器不会进行静态类型检查，而是在运行时根据实际类型进行动态绑定。
  1. 类型确定性：
    • 使用 var 声明的变量在编译时已经确定了其类型，只是由编译器根据初始化表达式推断出来的。
    • 使用 dynamic 声明的变量在编译时并不确定其类型，只有在运行时才确定其类型。
  1. 类型转换：
    • var 关键字声明的变量是具有隐式类型，编译器会将其类型确定为初始化表达式的类型，不能更改。
    • dynamic 关键字声明的变量可以在运行时动态改变其类型，允许执行任意操作和调用任何成员。
  1. 编程场景：
    • var 通常用于初始化表达式的类型明确且清晰的情况下，可以简化代码并提高可读性，但不能用于声明方法参数、字段、属性等。
    • dynamic 通常用于需要与动态语言交互、COM 互操作、反射以及需要更灵活的类型检查和绑定的情况，但应谨慎使用，因为失去了编译时的类型检查，可能会增加程序的复杂性。
  1. 编译时行为：
    • var 变量在编译时已经确定了其类型，因此在编译时需要满足类型推断的规则。
    • dynamic 变量在编译时不会进行类型检查，编译器会推迟类型检查到运行时。

总的来说，var 用于在编译时确定类型的场景，而 dynamic 用于需要在运行时动态确定类型的场景。选择使用哪种关键字取决于你的需求和情况，需要权衡可读性、性能和类型安全等因素。

Var vs Object

var 和 object 是 C# 中用于声明变量的两种不同的机制，它们之间有几个重要的区别：

  1. 类型推断：
    • var 是用于声明隐式类型变量的关键字，编译器会根据初始化表达式的类型推断出变量的类型，并在编译时将其替换为具体的类型。
    • object 是一个特殊的引用类型，可以用来存储任何类型的值，它是所有其他引用类型的基类，因此可以用来表示任何类型的对象。
  1. 静态类型：
    • var 变量是具有静态类型的，一旦确定了变量的类型，就不能再改变。
    • object 类型的变量可以存储任何类型的值，并且可以在运行时根据实际情况改变其所引用的对象的类型。
  1. 编译时行为：
    • var 变量在编译时会被替换为其实际类型，因此它不是一种动态类型。
    • object 类型的变量在编译时已经确定了其类型为 object，但在运行时可以引用任何类型的对象。
  1. 类型限制：
    • 使用 var 声明的变量必须在初始化时具有确定的类型，因为编译器需要根据初始化表达式来推断变量的类型。
    • 使用 object 声明的变量可以存储任何类型的值，因为它是所有引用类型的基类，但在使用时可能需要进行显式的类型转换。
  1. 代码简化：
    • var 可以使代码更简洁、更易读，特别是在初始化表达式类型较长或复杂时。
    • object 用于表示不确定类型的对象，但需要在使用时进行类型转换，使得代码可能更加复杂。

综上所述，var 用于声明变量时根据初始化表达式的类型进行类型推断，是一种静态类型；而 object 用于表示不确定类型的对象，在编译时已确定为 object 类型，但在运行时可以引用任何类型的对象，是一种动态类型。选择使用哪种机制取决于你的需求和情况，需要权衡可读性、性能和类型安全等因素。

可空类型

在C#中，可空类型（Nullable Types）是一种特殊的类型，用于表示值类型（如整数、浮点数等）的变量，但允许这些变量存储 null 值。通常情况下，值类型的变量不能存储 null 值，但通过使用可空类型，可以使值类型的变量能够存储 null 值，从而扩展了其可能的取值范围。

在可空类型中，如果值为 null，则表示该变量未赋值或者没有有效值，而如果不为 null，则表示该变量有一个有效的值。

可空类型的语法是在值类型后面加上一个问号（?），如 int?、double?、DateTime? 等。

以下是可空类型的一些重要特点和用法：

  1. 声明可空类型变量：
int? nullableInt;
double? nullableDouble;
DateTime? nullableDateTime;

 

  1. 赋值为 null：
int? nullableInt = null;

 

  1. 检查是否为 null：
if (nullableInt == null) {
    // 可空类型变量为 null
}
  1. 从可空类型获取值：
    • 可以使用 .Value 属性获取可空类型变量的值，但在访问之前需要确保变量不为 null，否则会抛出异常。
    • 可以使用 ?? 运算符提供一个默认值，用于在可空类型变量为 null 时返回。
int? nullableInt = 10;
int value = nullableInt.Value; // 获取值，如果 nullableInt 为 null，则会抛出异常
int valueOrDefault = nullableInt ?? 0; // 获取值，如果 nullableInt 为 null，则返回 0
  1. Nullable<T> 结构：
    • 可空类型实际上是 Nullable<T> 结构的实例，该结构包装了一个值类型，并在必要时提供了一个额外的布尔值来表示是否为 null。
    • 可以使用 Nullable<T> 结构的各种方法和属性来处理可空类型变量，如 .HasValue 属性、.GetValueOrDefault() 方法等。

可空类型在处理数据库中的 NULL 值、与可选参数一起使用以及处理某些情况下缺失数据的情况下特别有用。使用可空类型可以使代码更加简洁清晰，并提高程序的健壮性和可维护性。

posted @ 2024-03-19 16:35  咸鱼翻身？  阅读(27)  评论(0)  编辑  收藏  举报