聊一聊C#中的不可变类型

.NET
215
0
0
2024-01-19
C#反射机制
上一篇
C#中的悲观锁和乐观锁
下一篇
标签   C#

1.概要

什么是不可变类型？

在C#中，不可变类型（Immutable Types）是指一旦创建后，其状态或内容不能被修改的数据类型。不可变类型是基于函数式编程的概念，它们通常用于创建不可更改的对象，从而提高代码的可靠性、可维护性和线程安全性。

不可变类型有哪些？

  • Tuple

元组 (Tuple) 是C#中的一个泛型类型，它允许将多个值打包成一个单一的不可变对象。元组的原理是将多个值作为元组的组成部分，然后返回一个包含这些值的元组实例。

  • string

字符串 (string) 是C#中的不可变类型。它的原理是基于字符数组 (char[]) 来存储字符串的字符。一旦创建了一个字符串，它的内容就不能被更改。任何对字符串的修改实际上都会创建一个新的字符串。

  • DateTime 和 DateTimeOffset

DateTime 和 DateTimeOffset 类型表示日期和时间，它们也是不可变的。修改日期或时间会返回一个新的对象。

  • ImmutableStack 、ImmutableQueue 、ImmutableList

这些不可变集合类型属于 System.Collections.Immutable 命名空间，它们基于树结构实现不可变性。这意味着在对集合进行修改时，会创建一个新的集合，而不会修改原始集合。

  • ImmutableHashSet 、ImmutableSortedSet 、ImmutableDictionary 、ImmutableSortedDictionary

这些不可变集合类型也是基于持久化数据结构实现的，用于高效地管理集合数据并保持不可变性。

不可变类型的优缺点哪些？

优点：

  1. 线程安全性：不可变类型是线程安全的，因为它们的状态不能被修改。多个线程可以安全地访问和共享不可变对象，无需额外的同步控制。这有助于避免许多常见的并发问题，如竞态条件和死锁。
  2. 可靠性：不可变对象在创建后保持不变，不会受到外部因素的干扰。这使得代码更加可靠，因为不需要担心对象的状态在不经意间被修改。
  3. 可缓存性：不可变对象可以安全地被缓存，因为它们的值永远不会发生变化。这有助于提高性能，避免重复计算。
  4. 函数式编程支持：不可变类型与函数式编程范式兼容，因为它们鼓励无副作用的函数和不可变数据。这使得代码更容易理解和测试。
  5. 传递性和不变性保证：不可变类型的传递性使得在不同的代码段之间传递数据更加安全。不可变对象的不变性保证了它们的行为不会在不同的上下文中发生变化。

缺点：

  1. 内存开销：不可变类型的创建通常需要分配新的对象，这可能导致内存开销较大，特别是在频繁创建新对象的情况下。这可能会影响性能。
  2. 性能开销：在某些情况下，不可变类型的性能可能不如可变类型，特别是在需要频繁修改数据的情况下。不可变对象的不变性可能会导致额外的复制和分配操作。
  3. 不适用于所有场景：不可变类型适用于某些场景，但不适用于所有情况。例如，当需要大量的原地修改操作时，使用不可变类型可能会导致不必要的复杂性和性能问题。
  4. 不便利的更新：由于不可变对象的不变性，对于需要更新大部分数据的情况，可能需要创建多个新对象，这可能会导致不便利的更新操作。

不可变类型在多线程编程、函数式编程和数据传递方面具有许多优点，但在某些性能敏感的情况下可能会引入一些开销。因此，在选择是否使用不可变类型时，需要根据具体的需求和场景权衡其优缺点。

适用场景有哪些？

  1. 多线程环境：不可变类型适用于多线程编程，因为它们的状态不可修改，多个线程可以安全地共享不可变对象，无需使用额外的锁或同步机制。
  2. 缓存：不可变对象在缓存中特别有用，因为它们的值不会发生变化，可以安全地缓存和重用。这有助于提高性能，避免重复计算。
  3. 函数式编程：不可变类型与函数式编程范式非常兼容。在函数式编程中，避免副作用和可变状态是关键原则，不可变类型正是这些原则的体现。
  4. 数据传递：在需要将多个值作为一个单一对象传递给方法或返回多个值的方法时，使用不可变元组或不可变对象非常方便。
  5. 配置信息：不可变类型适用于存储应用程序的配置信息，因为它们不会在运行时更改。这使得配置信息在整个应用程序中具有一致性。
  6. 实体对象：在领域驱动设计（Domain-Driven Design）中，实体对象通常是不可变的，因为它们代表领域中的特定状态和行为，状态不应该随意更改。
  7. 日志记录：不可变对象在记录日志和审计信息时非常有用，因为它们记录了事件发生时的状态，不会因为后续的操作而改变。
  8. 并发数据结构：不可变集合（如 ImmutableList、ImmutableDictionary 等）适用于并发编程，因为它们提供了一种安全的方式来操作数据，而不需要额外的同步措施。

2.详细内容

接下个逐个介绍常见的不可变类型的作用，以及代码示例。

Tuple

元组（Tuple）是一种数据结构，用于将多个值组合成一个单一的对象。元组本身不会引发线程安全问题，因为元组是不可变的数据结构，一旦创建，其内容不可修改。这使得元组在多线程环境中是相对安全的，因为多个线程可以同时访问和共享元组对象而无需担心竞态条件或数据修改问题。

然而，需要注意以下几点：

  1. 不可变元组：如果您确保创建的元组对象不会被修改，那么在多线程环境中使用元组是安全的。不可变元组的字段值在创建后不会更改，因此多个线程可以同时访问它们。
  2. 引用类型元素：如果元组包含引用类型的元素（例如字符串、类实例等），则需要注意这些引用类型的线程安全性。元组本身是不可变的，但如果元组的元素引用了可变对象，可能会引发线程安全问题。
  3. 不可变性保证：确保不要意外地修改元组对象，特别是在多线程环境中。如果通过错误的方式修改了元组，可能会引发线程安全问题。

元组的值语义：元组是值类型，这意味着它们在传递时会复制元素的值，而不是引用。这与引用类型（如类）不同，后者在传递时传递的是引用。

元组的不可变性：元组是不可变的，一旦创建，其元素值不能更改。如果需要修改元组的元素，必须创建一个新的元组对象。

代码示例：

//初始化
var myTuple = (1, 2, "Hello");
//初始化
var myTuple = Tuple.Create(1, 2, "Hello");

//元组的元素访问
var myTuple = (1, 2, "Hello");
int firstItem = myTuple.Item1; // 通过索引访问元素
int secondItem = myTuple.Item2;
string thirdItem = myTuple.Item3;

string

字符串（string）具有不可变性（immuatability），这意味着一旦创建了一个字符串对象，它的内容不能被更改。字符串的不可变性在C#中是通过以下方式来实现的：

  1. 字符串是引用类型：字符串虽然是引用类型，但它的内容被视为不可修改。这意味着当您对字符串进行操作时，实际上是在创建新的字符串对象，而不是修改原始字符串。
  2. 字符串池（String Pool）：C# 中的字符串文字（string literals）被放入一个字符串池中。如果多个字符串文字具有相同的值，则它们会共享相同的字符串对象。这有助于节省内存，并提高性能。
  3. 不可修改的字符数组：字符串内部使用一个字符数组（char[]）来存储字符。一旦创建了字符串，该字符数组就不会被修改。如果需要对字符串进行更改，将创建一个新的字符数组，以存储新字符串的内容。

下面是一些示例说明字符串的不可变性：

string s1 = "Hello";
string s2 = s1 + ", World!"; // 创建新的字符串，s1和s2都不会被修改
string s3 = s1.ToUpper(); // 创建新的字符串，s1和s3都不会被修改

每次对字符串进行操作时，都会创建一个新的字符串对象，原始字符串对象保持不变。这确保了字符串的内容不会在使用过程中被更改，从而提高了代码的可靠性和安全性。

不可变性使得字符串在多线程环境中更容易管理，因为字符串对象不需要额外的同步措施来保护其内容。此外，不可变性还允许字符串文字在内存中共享，以减少内存占用。

DateTime 和 DateTimeOffset

DateTime 和 DateTimeOffset 是不可变类型，它们具有不可变性（immutability）。创建了 DateTime 或 DateTimeOffset 对象，其内容不能被更改，任何对这些对象的修改都会返回一个新的对象，而不是修改原始对象。

DateTime 不可变性示例：

DateTime dateTime1 = DateTime.Now;
DateTime dateTime2 = dateTime1.AddHours(1); // 创建新的 DateTime 对象，而不会修改 dateTime1

在上述示例中，AddHours 方法创建了一个新的 DateTime 对象，而不是修改 dateTime1 对象。

DateTimeOffset 不可变性示例：

DateTimeOffset dateTimeOffset1 = DateTimeOffset.Now;
DateTimeOffset dateTimeOffset2 = dateTimeOffset1.AddHours(1); // 创建新的 DateTimeOffset 对象，而不会修改 dateTimeOffset1

不可变性的特性对于确保日期和时间对象的稳定性非常有用。不需要额外的同步来保护它们。不可变性确保日期和时间的值在创建后不会被修改。

ImmutableStack

特点不过多介绍了，文章看到这里大致应该也知道这类类型的特点了，脑补不可变特性和作用结合一下。

实现原理：

  • ImmutableStack 是通过持久化数据结构实现的，每次对栈进行修改操作（如 Push 和 Pop）都会创建一个新的栈对象，同时共享部分或全部原始栈的数据，以提高性能和节省内存。
  • 当执行 Push 操作时，它将创建一个包含新元素的新栈对象，并将原始栈的数据作为其底层数据共享。这使得添加元素的操作非常高效。
  • 当执行 Pop 操作时，它会创建一个新的栈对象，其中包含原始栈中除最顶部元素之外的所有元素。这也是高效的，因为它只需要复制栈的部分内容。

使用场景：

  1. 历史记录和撤销操作：ImmutableStack 通常用于记录操作历史或支持撤销操作。每次执行一个操作，都可以将当前的栈保存下来，然后在需要时按顺序执行撤销操作，而无需复制大量数据。
  2. 递归和算法：在一些递归算法中，ImmutableStack 可以用来存储中间结果或函数调用堆栈，以便在递归完成后按相反的顺序处理结果。
ImmutableStack<int> stack1 = ImmutableStack<int>.Empty;
ImmutableStack<int> stack2 = stack1.Push(1); // 创建新的栈对象
ImmutableStack<int> stack3 = stack2.Push(2); // 再次创建新的栈对象

ImmutableQueue

ImmutableQueue 是 C# 中的一种不可变集合类型，它基于队列（Queue）数据结构。

原理：

  • ImmutableQueue 也是通过持久化数据结构实现的，每次对队列进行修改操作（如 Enqueue 和 Dequeue）都会创建一个新的队列对象，同时共享部分或全部原始队列的数据，以提高性能和节省内存。
  • 当执行 Enqueue 操作时，它将创建一个包含新元素的新队列对象，并将原始队列的数据作为其底层数据共享。这使得添加元素的操作非常高效。
  • 当执行 Dequeue 操作时，它会创建一个新的队列对象，其中包含原始队列中除最前端元素之外的所有元素。这也是高效的，因为它只需要复制队列的部分内容。

使用场景：

  1. 历史记录和事件流：ImmutableQueue 通常用于记录事件流或历史记录，每次执行一个事件或操作，都可以将当前的队列保存下来，以便在需要时按顺序执行事件或回溯历史。
  2. 数据流处理：在某些数据流处理场景中，ImmutableQueue 可以用来存储待处理的数据元素，而无需修改原始数据流。每次处理一个数据元素，都可以创建一个新的队列来管理待处理的元素。
  3. 任务调度：ImmutableQueue 可以用于任务调度，每次添加任务到队列，都会创建一个新的队列，以维护待执行的任务列表。这对于管理任务的执行顺序非常有用。
ImmutableQueue<int> queue1 = ImmutableQueue<int>.Empty;
ImmutableQueue<int> queue2 = queue1.Enqueue(1); // 创建新的队列对象
ImmutableQueue<int> queue3 = queue2.Dequeue(); // 再次创建新的队列对象

ImmutableList

特点不过多介绍了，文章看到这里大致应该也知道这类类型的特点了，脑补不可变特性和作用结合一下。

使用场景：

  1. 历史记录： ImmutableList<T> 可以用于记录应用程序状态的历史记录，因为您可以轻松地创建新的状态副本来表示每个步骤的变化。
  2. 性能优化： 由于ImmutableList<T> 的持久性特性，它可以在某些情况下提供更好的性能，因为它允许共享数据，而不必复制整个列表。
  3. 不可变性保证： 如果您需要确保数据不会在某个地方被修改，ImmutableList<T> 可以提供保证。
using System;
using System.Collections.Immutable;

class Program
{
    static void Main()
    {
        // 创建一个空的不可变列表
        var emptyList = ImmutableList<int>.Empty;

        // 向不可变列表添加元素
        var list1 = emptyList.Add(1).Add(2).Add(3);

        // 删除元素
        var list2 = list1.Remove(2);

        // 不可变列表保持不变
        Console.WriteLine("List1: " + string.Join(", ", list1));
        Console.WriteLine("List2: " + string.Join(", ", list2));
    }
}

ImmutableHashSet

特点不过多介绍了，文章看到这里大致应该也知道这类类型的特点了，脑补不可变特性和作用结合一下。

使用场景：

  1. 集合操作： ImmutableHashSet<T> 提供了丰富的集合操作，例如交集、并集、差集等，这些操作都返回新的不可变哈希集合。
  2. 缓存： 您可以使用ImmutableHashSet<T> 来存储缓存的键集合，以确保不会意外地修改缓存的键集合。
using System;
using System.Collections.Immutable;

class Program
{
    static void Main()
    {
        // 创建一个空的不可变哈希集合
        var emptySet = ImmutableHashSet<int>.Empty;

        // 向不可变哈希集合添加元素
        var set1 = emptySet.Add(1).Add(2).Add(3);

        // 删除元素
        var set2 = set1.Remove(2);

        // 不可变哈希集合保持不变
        Console.WriteLine("Set1: " + string.Join(", ", set1));
        Console.WriteLine("Set2: " + string.Join(", ", set2));
    }
}

ImmutableSortedSet

是不可变集合类型，用于存储唯一的元素，并按升序排序。不可变集合表示一旦创建，就不能再被修改的集合，而是通过创建新的集合来表示已有集合的变化。ImmutableSortedSet<T> 的实现原理基于平衡二叉搜索树（通常是红黑树），它会在每次修改操作时返回一个新的不可变排序集合，而不是修改原始集合。

使用场景：

  1. 排序集合操作： ImmutableSortedSet<T> 提供了有序集合的所有基本操作，例如添加、删除、查找、范围查询等。这使它非常适合需要对数据进行排序和检索的场景。
using System;
using System.Collections.Immutable;

class Program
{
    static void Main()
    {
        // 创建一个空的不可变排序集合
        var emptySet = ImmutableSortedSet<int>.Empty;

        // 向不可变排序集合添加元素
        var set1 = emptySet.Add(3).Add(1).Add(2);

        // 删除元素
        var set2 = set1.Remove(2);

        // 不可变排序集合保持不变
        Console.WriteLine("Set1: " + string.Join(", ", set1));
        Console.WriteLine("Set2: " + string.Join(", ", set2));
    }
}

ImmutableDictionary

是不可变字典类型，它在 .NET Framework 5.0 和 .NET Core 2.0 及更高版本中引入，用于表示不可变的键-值对集合。创建不能修改，任何修改都会返回一个新对象，不可变性，多线程安全。

实现原理：

1. 高性能： ImmutableDictionary 的实现基于数据结构 Trie，它的插入、删除和查找操作的性能都很高效。每次修改都会生成一个新的 Trie，而不是修改原始数据结构，因此修改操作的时间复杂度是 O(log n)，其中 n 是字典中的元素数量。对于大型数据集，性能仍然很好。

using System;
using System.Collections.Immutable;

class Program
{
    static void Main()
    {
        // 创建不可变字典
        var immutableDict = ImmutableDictionary<string, int>.Empty;

        // 添加键值对
        immutableDict = immutableDict.Add("one", 1);
        immutableDict = immutableDict.Add("two", 2);

        // 获取值
        int value = immutableDict["one"];
        Console.WriteLine($"Value for key 'one': {value}");

        // 创建新的不可变字典
        var newImmutableDict = immutableDict.Add("three", 3);

        // 原始字典不受影响
        Console.WriteLine($"Original dictionary count: {immutableDict.Count}");
        Console.WriteLine($"New dictionary count: {newImmutableDict.Count}");
    }
}

ImmutableSortedDictionary

用于表示不可变的键-值对集合。创建不能修改，任何修改都会返回一个新对象，不可变性，多线程安全，但是额外提供了排序功能。

实现原理：

1. 排序： ImmutableSortedDictionary<TKey, TValue> 会按键的顺序对键值对进行排序。这使得它特别适合需要按键顺序访问数据的情况。

2. 高性能： ImmutableSortedDictionary 的实现基于平衡树数据结构（通常是红黑树），因此插入、删除和查找操作的性能都很高效。每次修改都会生成一个新的平衡树，而不是修改原始数据结构，因此修改操作的时间复杂度是 O(log n)，其中 n 是字典中的元素数量。

使用场景： ImmutableSortedDictionary 在以下场景中非常有用：

  • 有序数据集合： 当你需要按照键的顺序访问数据时，ImmutableSortedDictionary 是一个很好的选择，比如需要遍历有序的配置项或数据。
  • 不可变数据：
using System;
using System.Collections.Immutable;

class Program
{
    static void Main()
    {
        // 创建不可变有序字典
        var immutableSortedDict = ImmutableSortedDictionary<string, int>.Empty;

        // 添加键值对
        immutableSortedDict = immutableSortedDict.Add("two", 2);
        immutableSortedDict = immutableSortedDict.Add("one", 1);
        immutableSortedDict = immutableSortedDict.Add("three", 3);

        // 按键排序输出
        foreach (var kvp in immutableSortedDict)
        {
            Console.WriteLine($"{kvp.Key}: {kvp.Value}");
        }
    }
}
C#反射机制
上一篇
C#中的悲观锁和乐观锁
下一篇