C#的with表达式基于现有对象创建新实例，不改变原始对象，通过成员级浅拷贝实现属性修改，适用于配置对象、DTO、状态管理等场景，需注意浅拷贝共享引用和性能开销问题。
C#的
with
表达式提供了一种非常优雅且非破坏性的方式来修改记录类型（
record
）的实例。它不会改变原始对象，而是基于现有实例创建一个全新的实例，同时只修改你指定的那些属性值。这在处理不可变数据时尤其方便，是C# 9引入的一项重要特性，旨在简化记录类型的操作，并更好地支持函数式编程范式。
解决方案
with
表达式的核心思想是“基于现有对象创建一个新的，但有所不同”的对象。当你有一个记录类型的实例，并且想要改变它的一些属性时，你不需要手动复制所有未改变的属性，然后赋给新的实例。
with
表达式为你做了这些繁琐的工作。
基本语法：
var newRecord = existingRecord with { Property1 = newValue1, Property2 = newValue2 };
工作原理：
当你使用
with
表达式时，运行时会执行一个成员级（memberwise）的浅拷贝。这意味着，
existingRecord
的所有字段（包括私有字段）的值都会被复制到
newRecord
中。然后，
with
表达式中指定的属性值会覆盖新副本中对应的字段。
示例：
假设我们有一个
Person
记录类型：
public record Person(string FirstName, string LastName, int Age);// 创建一个原始的Person实例var originalPerson = new Person("张", "三", 30);Console.WriteLine($"Original: {originalPerson}"); // Output: Original: Person { FirstName = 张, LastName = 三, Age = 30 }// 使用with表达式修改LastName和Agevar updatedPerson = originalPerson with { LastName = "四", Age = 31 };Console.WriteLine($"Updated: {updatedPerson}"); // Output: Updated: Person { FirstName = 张, LastName = 四, Age = 31 }// 验证原始对象未被修改Console.WriteLine($"Original (after update attempt): {originalPerson}"); // Output: Original (after update attempt): Person { FirstName = 张, LastName = 三, Age = 30 }// 甚至可以只修改一个属性var personWithNewAge = originalPerson with { Age = 32 };Console.WriteLine($"New Age: {personWithNewAge}"); // Output: New Age: Person { FirstName = 张, LastName = 三, Age = 32 }
这个例子清晰地展示了
with
表达式的非破坏性特性，
originalPerson
实例在操作后依然保持不变，这对于确保数据完整性和并发安全至关重要。
为什么C#引入了with表达式？它的核心优势是什么？
在我看来，C#引入
with
表达式，不仅仅是为了给记录类型提供一个语法糖，它更深层次地反映了现代软件开发中对不可变性（Immutability）和函数式编程风格的日益重视。它的核心优势，我认为可以从几个方面来聊聊。
首先，解决“样板代码”问题。在
record
类型出现之前，如果你想创建一个不可变类，并且需要“修改”它的某个属性，你通常得写一个构造函数，或者一个
WithXxx
方法，里面手动复制所有未改变的属性，然后只改你想改的。这简直是灾难性的样板代码，尤其当属性多起来的时候。
with
表达式彻底解决了这个问题，它让“基于现有创建新对象”变得极其简洁直观。
其次，增强代码的可读性和可维护性。当你看一眼
someObject with { Property = newValue }
，你立刻就能明白意图：我们想要一个新的对象，除了这个属性，其他都和旧的一样。这种声明式的语法比一系列的赋值操作要清晰得多。这对于团队协作和长期项目维护来说，价值巨大。
再者，更好地支持不可变数据模型。不可变性是现代软件设计中的一个重要原则，它能有效减少bug，简化并发编程，并让代码更容易推理。
record
类型本身就强调不可变性（虽然可以定义可变属性，但最佳实践是不可变），而
with
表达式正是实现这种“修改”的利器，它强制你创建新对象，而不是原地修改。这让整个数据流更加清晰，也更容易追踪状态变化。
最后，我个人觉得，它也推动了C#向更函数式、更表达力的方向发展。虽然C#仍然是面向对象的语言，但它一直在吸收函数式编程的优秀思想。
with
表达式就是这种融合的一个很好的例子，它让C#在处理数据转换时，有了更强大的表达能力，也让开发者能更自然地编写出“无副作用”的代码。这不仅仅是语法上的便利，更是一种编程范式的演进。
在实际项目中，with表达式有哪些常见的应用场景？
在实际的项目开发中，
with
表达式的应用场景比我们想象的要广泛，尤其是在那些追求数据不可变性、状态管理清晰的场景下，它简直是利器。
一个非常典型的场景是配置对象（Configuration Objects）。我们经常会有一个配置类，里面包含了各种设置，这些设置在应用启动后通常不应该被随意修改。但有时，你可能需要基于一个基础配置，派生出一个略有不同的配置，比如为某个特定模块提供一个微调后的配置。这时，
with
表达式就派上用场了：
public record AppConfig(string ConnectionString, int TimeoutSeconds, bool EnableCaching);var baseConfig = new AppConfig("server=db;", 30, true);// 为特定服务创建一个超时时间更长的配置var serviceConfig = baseConfig with { TimeoutSeconds = 60 };
另一个很棒的场景是数据传输对象（DTOs）或领域模型（Domain Models）。在很多业务逻辑中，我们从数据库读取一个实体，然后需要对它进行一些处理，但又不想直接修改原始的数据库实体，或者说，希望在提交到数据库之前，能有一个“草稿”状态。
with
表达式允许你创建这些“修改后的草稿”，而原始对象保持不变，这在事件溯源（Event Sourcing）或CQRS（Command Query Responsibility Segregation）架构中尤其有用。
在状态管理方面，特别是对于前端框架（如Blazor）或一些采用不可变状态模式的后端服务，
with
表达式也大放异彩。想象一下一个UI组件的状态，它可能是一个记录类型。当用户与UI交互时，你需要更新状态，但又想保持历史状态的不可变性，以便于回溯、撤销操作或调试。
public record TodoItem(Guid Id, string Description, bool IsCompleted);public record TodoListState(ImmutableList Items, string Filter);var initialState = new TodoListState(ImmutableList.Empty, "All");// 添加一个Todo项var newStateAfterAdd = initialState with{ Items = initialState.Items.Add(new TodoItem(Guid.NewGuid(), "Learn C# records", false))};// 完成一个Todo项var itemToComplete = newStateAfterAdd.Items.First();var updatedItem = itemToComplete with { IsCompleted = true };var newStateAfterComplete = newStateAfterAdd with{ Items = newStateAfterAdd.Items.Replace(itemToComplete, updatedItem)};
这里，
with
表达式让状态的更新变得非常清晰和安全，每次更新都产生一个新的状态实例，而不是原地修改。这对于构建可预测和可测试的系统非常有帮助。
使用with表达式时，有哪些潜在的陷阱或需要注意的地方？
尽管
with
表达式非常方便，但它并非没有需要注意的地方。在我看来，最核心的“陷阱”或者说需要理解的，就是它执行的是浅拷贝（Shallow Copy）。
这意味着什么呢？如果你的
record
类型中包含的是值类型（如
int
,
string
等），那么
with
表达式会复制这些值。但如果你的
record
中包含的是引用类型（如另一个
record
实例、一个
List
、一个自定义类实例等），那么
with
表达式只会复制这些引用本身，而不会去复制引用指向的对象。换句话说，新旧两个
record
实例会共享同一个被引用的对象。
浅拷贝示例：
public record Address(string Street, string City);public record Customer(string Name, Address HomeAddress);var originalAddress = new Address("123 Main St", "Anytown");var originalCustomer = new Customer("Alice", originalAddress);// 使用with表达式修改Customer的Namevar updatedCustomer = originalCustomer with { Name = "Bob" };Console.WriteLine($"Original Customer Address: {originalCustomer.HomeAddress}"); // Output: Original Customer Address: Address { Street = 123 Main St, City = Anytown }Console.WriteLine($"Updated Customer Address: {updatedCustomer.HomeAddress}"); // Output: Updated Customer Address: Address { Street = 123 Main St, City = Anytown }// 此时 originalCustomer.HomeAddress 和 updatedCustomer.HomeAddress 引用的是同一个 Address 对象Console.WriteLine($"Are addresses the same instance? {ReferenceEquals(originalCustomer.HomeAddress, updatedCustomer.HomeAddress)}"); // Output: Are addresses the same instance? True// 如果我们修改了 originalAddress 对象（假设Address是可变的，或者通过其他方式修改了其内部状态）// 那么 updatedCustomer.HomeAddress 也会受到影响，因为它们指向同一个对象。// 当然，record通常是不可变的，这里只是为了说明浅拷贝的原理。// 如果 Address 也是一个 record，我们修改它也需要用 with，并替换整个引用。
为了避免浅拷贝带来的问题，当你的
record
包含引用类型的属性，并且你也想“修改”这个嵌套的引用类型时，你需要做的是：首先使用
with
表达式创建嵌套引用类型的新实例，然后用这个新实例来更新外部
record
。这通常被称为深拷贝（Deep Copy）的逻辑，只不过在
record
和
with
的语境下，它依然是非破坏性的。
// 正确的深层修改方式var newAddress = originalCustomer.HomeAddress with { Street = "456 New St" };var customerWithNewAddress = originalCustomer with { HomeAddress = newAddress };Console.WriteLine($"Original Customer Address: {originalCustomer.HomeAddress}"); // Output: Original Customer Address: Address { Street = 123 Main St, City = Anytown }Console.WriteLine($"Customer with New Address: {customerWithNewAddress.HomeAddress}"); // Output: Customer with New Address: Address { Street = 456 New St, City = Anytown }Console.WriteLine($"Are addresses the same instance now? {ReferenceEquals(originalCustomer.HomeAddress, customerWithNewAddress.HomeAddress)}"); // Output: Are addresses the same instance now? False
除了浅拷贝，另一个需要考虑的是性能开销。每次使用
with
表达式都会创建一个新的对象。对于大多数应用来说，这通常不是问题，因为现代垃圾回收器效率很高。但如果在极度性能敏感的循环中频繁创建大量对象，这可能会带来一些额外的GC压力。不过，话说回来，如果你在这种场景下还在追求不可变性，那么这种开销是必然的。
最后，对于那些习惯了传统面向对象编程中直接修改对象状态的开发者来说，
with
表达式以及记录类型的不可变性概念可能需要一些时间去适应。思维模式的转变是使用这项特性时的一个隐性挑战。但一旦适应，你会发现它带来的好处远大于这些小小的适应成本。
以上就是C#的with表达式如何修改记录类型？怎么使用？的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1439476.html
微信扫一扫 
支付宝扫一扫 
