1. 类的基本概念与核心特性
在C#编程语言中，类（Class）是面向对象编程（OOP）最基本的构建块。它本质上是一个自定义的数据类型，不仅包含数据（字段），还包含操作这些数据的方法（函数）。理解类的概念是掌握C#编程的关键第一步。
类的核心特性可以概括为以下三点：
- 封装性：将数据和操作数据的方法捆绑在一起，对外隐藏实现细节
- 继承性：允许创建层次结构，子类可以继承父类的特性
- 多态性：同一操作作用于不同类的实例会产生不同的行为
注意：初学者常犯的错误是将类简单理解为"数据的容器"。实际上，类更应该被视为"行为的抽象"，它定义了对象能做什么而不仅仅是包含什么。
2. 类的组成要素详解
2.1 字段与属性
字段是类中存储数据的变量，而属性是对字段访问的封装。现代C#推荐使用自动属性简化代码：
public class Person { // 字段（通常私有） private string _name; // 属性（公共接口） public string Name { get => _name; set => _name = value ?? throw new ArgumentNullException(); } // 自动属性（C# 3.0+） public int Age { get; set; } }2.2 方法与构造函数
方法定义类的行为，构造函数用于初始化对象实例：
public class Calculator { // 构造函数 public Calculator() { } // 实例方法 public int Add(int a, int b) => a + b; // 静态方法 public static double PI => 3.1415926; }2.3 索引器与运算符重载
这些高级特性让类用起来像内置类型一样自然：
public class Team { private string[] _members = new string[10]; // 索引器 public string this[int index] { get => _members[index]; set => _members[index] = value; } // 运算符重载 public static Team operator +(Team a, Team b) { /*...*/ } }3. 类的进阶应用场景
3.1 继承与多态实践
通过继承实现代码复用，通过虚方法/抽象方法实现多态：
public abstract class Shape { public abstract double Area(); } public class Circle : Shape { public double Radius { get; set; } public override double Area() => Math.PI * Radius * Radius; }3.2 接口与抽象类
理解这两种抽象方式的区别至关重要：
| 特性 | 抽象类 | 接口 |
|---|---|---|
| 实现继承 | 单继承 | 多实现 |
| 成员类型 | 可包含实现 | 只有声明 |
| 访问修饰符 | 任意 | 默认public |
| 适用场景 | "是什么"的关系 | "能做什么"的契约 |
3.3 泛型类设计
使用泛型创建类型安全的可复用组件：
public class Repository<T> where T : IEntity { public void Add(T entity) { /*...*/ } public T GetById(int id) { /*...*/ } }4. 类设计的最佳实践与陷阱
4.1 SOLID原则应用
- 单一职责原则：一个类只做一件事
- 开闭原则：对扩展开放，对修改关闭
- 里氏替换原则：子类必须能替换父类
- 接口隔离原则：多个专用接口优于一个通用接口
- 依赖倒置原则：依赖抽象而非实现
4.2 常见设计误区
- 上帝对象：一个类做太多事情
- 过度继承：超过3层的继承链通常有问题
- 贫血模型：只有数据没有行为的类
- 循环依赖：类A依赖B，B又依赖A
4.3 性能优化技巧
- 适当使用sealed关键字阻止不必要的继承
- 考虑使用struct替代小型不可变类
- 避免在类中创建过多短生命周期的临时对象
- 对于线程安全类，明确标注[ThreadStatic]字段
5. 类在C#生态系统中的实际应用
5.1 WPF中的MVVM模式
public class MainViewModel : INotifyPropertyChanged { private string _userName; public string UserName { get => _userName; set { _userName = value; OnPropertyChanged(); } } public ICommand SubmitCommand { get; } public event PropertyChangedEventHandler PropertyChanged; protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null) { PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName)); } }5.2 ASP.NET Core中的控制器类
[ApiController] [Route("api/[controller]")] public class ProductsController : ControllerBase { private readonly IProductRepository _repository; public ProductsController(IProductRepository repository) { _repository = repository; } [HttpGet] public ActionResult<IEnumerable<Product>> Get() { return Ok(_repository.GetAll()); } }5.3 实体框架Core中的实体类
public class Order { public int OrderId { get; set; } public DateTime OrderDate { get; set; } public ICollection<OrderItem> Items { get; set; } } public class OrderItem { public int OrderItemId { get; set; } public int ProductId { get; set; } public int Quantity { get; set; } public decimal UnitPrice { get; set; } public Order Order { get; set; } }6. 类与C#新特性
6.1 记录类型（C# 9）
不可变数据的理想选择：
public record Person(string FirstName, string LastName);6.2 模式匹配增强（C# 8+）
public static double CalculateArea(object shape) => shape switch { Circle c => Math.PI * c.Radius * c.Radius, Rectangle r => r.Width * r.Height, _ => throw new ArgumentException("Unknown shape") };6.3 顶级语句与简化程序结构（C# 9+）
虽然看起来没有显式类，实际上编译器会生成：
// 实际会被编译为Program类 Console.WriteLine("Hello World!");7. 类的高级话题：反射与元编程
7.1 运行时类型检查
Type type = typeof(MyClass); object instance = Activator.CreateInstance(type); foreach (var prop in type.GetProperties()) { Console.WriteLine($"{prop.Name}: {prop.GetValue(instance)}"); }7.2 动态代码生成
// 使用System.Reflection.Emit动态创建类 var assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(...); var moduleBuilder = assemblyBuilder.DefineDynamicModule(...); var typeBuilder = moduleBuilder.DefineType("DynamicType", TypeAttributes.Public); // 添加字段、方法等...8. 类库设计与API最佳实践
8.1 命名规范
- 类名使用PascalCase
- 接口名前缀"I"（如IEnumerable）
- 抽象类后缀"Base"（如LoggerBase）
- 异常类后缀"Exception"
8.2 版本控制策略
- 通过添加而非修改来扩展功能
- 使用[Obsolete]属性标记即将移除的成员
- 考虑使用接口默认方法实现（C# 8+）
8.3 文档注释标准
/// <summary> /// 表示一个人的基本信息 /// </summary> /// <remarks> /// 这个类用于存储和操作人员数据 /// </remarks> public class Person { /// <summary> /// 获取或设置人员姓名 /// </summary> /// <value>字符串类型的姓名</value> public string Name { get; set; } }9. 类与多线程编程
9.1 线程安全模式
public class Singleton { private static readonly Lazy<Singleton> _instance = new Lazy<Singleton>(() => new Singleton()); public static Singleton Instance => _instance.Value; private Singleton() { } }9.2 异步方法设计
public class DataService { private readonly HttpClient _httpClient; public DataService(HttpClient httpClient) { _httpClient = httpClient; } public async Task<string> GetDataAsync(string url) { return await _httpClient.GetStringAsync(url); } }10. 调试与性能分析技巧
10.1 重写ToString()
public override string ToString() { return $"{Name} ({Age} years)"; }10.2 使用DebuggerDisplay特性
[DebuggerDisplay("{Name} (Age: {Age})")] public class Person { public string Name { get; set; } public int Age { get; set; } }10.3 性能热点分析
- 避免在类中频繁创建/销毁对象
- 考虑使用对象池模式
- 对大对象使用IDisposable接口
11. 类与设计模式实战
11.1 工厂模式实现
public interface ILogger { void Log(string message); } public class LoggerFactory { public ILogger CreateLogger(LoggerType type) { return type switch { LoggerType.Console => new ConsoleLogger(), LoggerType.File => new FileLogger(), _ => throw new ArgumentException("Invalid logger type") }; } }11.2 观察者模式示例
public class TemperatureMonitor : IObservable<double> { private readonly List<IObserver<double>> _observers = new(); public IDisposable Subscribe(IObserver<double> observer) { _observers.Add(observer); return new Unsubscriber(_observers, observer); } private class Unsubscriber : IDisposable { private readonly List<IObserver<double>> _observers; private readonly IObserver<double> _observer; public Unsubscriber(List<IObserver<double>> observers, IObserver<double> observer) { _observers = observers; _observer = observer; } public void Dispose() { if (_observer != null && _observers.Contains(_observer)) _observers.Remove(_observer); } } }12. 类与单元测试
12.1 可测试性设计
- 依赖注入而非紧耦合
- 遵循单一职责原则
- 避免静态方法和状态
12.2 测试示例
[TestClass] public class CalculatorTests { [TestMethod] public void Add_TwoNumbers_ReturnsSum() { // Arrange var calc = new Calculator(); // Act var result = calc.Add(2, 3); // Assert Assert.AreEqual(5, result); } }13. 类与序列化
13.1 JSON序列化
public class Product { public int Id { get; set; } public string Name { get; set; } public decimal Price { get; set; } } var product = new Product { Id = 1, Name = "Laptop", Price = 999.99m }; string json = JsonSerializer.Serialize(product);13.2 XML序列化
[XmlRoot("Person")] public class Person { [XmlElement("FullName")] public string Name { get; set; } [XmlAttribute("Age")] public int Age { get; set; } } var serializer = new XmlSerializer(typeof(Person)); using var writer = new StringWriter(); serializer.Serialize(writer, new Person { Name = "John", Age = 30 }); string xml = writer.ToString();14. 类与依赖注入
14.1 DI容器集成
public interface IMessageService { void Send(string message); } public class EmailService : IMessageService { public void Send(string message) { /*...*/ } } public class Notification { private readonly IMessageService _service; public Notification(IMessageService service) { _service = service; } public void Notify(string message) { _service.Send(message); } } // 注册服务 var services = new ServiceCollection(); services.AddTransient<IMessageService, EmailService>(); services.AddTransient<Notification>(); var provider = services.BuildServiceProvider(); // 使用 var notification = provider.GetRequiredService<Notification>(); notification.Notify("Hello DI!");15. 类与LINQ
15.1 自定义LINQ扩展
public static class MyLinqExtensions { public static IEnumerable<T> WhereNotNull<T>(this IEnumerable<T> source) { return source.Where(x => x != null); } } // 使用 var list = new List<string?> { "a", null, "b" }; var nonNullItems = list.WhereNotNull();16. 类与属性模式
16.1 属性模式匹配
public static decimal ComputeShippingCost(Order order) => order switch { { Weight: > 100 } => 25.00m, { IsExpress: true } => 15.00m, { Items.Count: > 5 } => 10.00m, _ => 5.00m };17. 类与模式匹配增强
17.1 位置模式
public record Point(int X, int Y); public static string GetQuadrant(Point point) => point switch { ( > 0, > 0 ) => "第一象限", ( < 0, > 0 ) => "第二象限", ( < 0, < 0 ) => "第三象限", ( > 0, < 0 ) => "第四象限", ( 0, 0 ) => "原点", _ => "在坐标轴上" };18. 类与本地函数
18.1 方法中的辅助函数
public class MathUtility { public static double CalculateHypotenuse(double a, double b) { return Math.Sqrt(Square(a) + Square(b)); static double Square(double x) => x * x; } }19. 类与异常处理
19.1 自定义异常类
public class InvalidOrderException : Exception { public int OrderId { get; } public InvalidOrderException(int orderId, string message) : base(message) { OrderId = orderId; } } // 使用 throw new InvalidOrderException(123, "Order contains invalid items");20. 类与异步流
20.1 异步枚举
public class DataStreamer { public async IAsyncEnumerable<int> GetDataAsync() { for (int i = 0; i < 10; i++) { await Task.Delay(100); yield return i; } } } // 使用 await foreach (var item in new DataStreamer().GetDataAsync()) { Console.WriteLine(item); }21. 类与源代码生成器
21.1 自动生成DTO类
[GenerateDto] public partial class Product { public int Id { get; set; } public string Name { get; set; } public decimal Price { get; set; } } // 源代码生成器会自动生成 public partial class ProductDto { public int Id { get; set; } public string Name { get; set; } public decimal Price { get; set; } public static ProductDto FromEntity(Product entity) { /*...*/ } public Product ToEntity() { /*...*/ } }22. 类与跨平台开发
22.1 MAUI共享代码
public class SharedViewModel { public string Greeting => "Hello from shared code!"; public Command ClickCommand { get; } public SharedViewModel() { ClickCommand = new Command(() => { // 跨平台逻辑 }); } }23. 类与性能关键代码
23.1 使用ref struct
public ref struct Point3D { public float X; public float Y; public float Z; public readonly float DistanceSquared => X * X + Y * Y + Z * Z; }24. 类与不安全代码
24.1 指针操作
public unsafe class BitmapProcessor { private readonly byte* _pixels; public BitmapProcessor(byte[] data) { fixed (byte* p = data) { _pixels = p; } } public void InvertColors(int width, int height) { for (int i = 0; i < width * height * 4; i++) { _pixels[i] = (byte)(255 - _pixels[i]); } } }25. 类与COM互操作
25.1 调用Office API
public class ExcelReporter { public void GenerateReport(string filePath) { var excel = new Microsoft.Office.Interop.Excel.Application(); var workbook = excel.Workbooks.Add(); var worksheet = (Worksheet)workbook.Worksheets[1]; worksheet.Cells[1, 1] = "Hello from C#"; workbook.SaveAs(filePath); workbook.Close(); excel.Quit(); } }26. 类与动态编程
26.1 动态对象
public class DynamicBag : DynamicObject { private readonly Dictionary<string, object> _data = new(); public override bool TryGetMember(GetMemberBinder binder, out object result) { return _data.TryGetValue(binder.Name, out result); } public override bool TrySetMember(SetMemberBinder binder, object value) { _data[binder.Name] = value; return true; } } // 使用 dynamic obj = new DynamicBag(); obj.Name = "Dynamic"; Console.WriteLine(obj.Name);27. 类与AOP编程
27.1 使用PostSharp
[Serializable] public class LogAttribute : OnMethodBoundaryAspect { public override void OnEntry(MethodExecutionArgs args) { Console.WriteLine($"Entering {args.Method.Name}"); } public override void OnExit(MethodExecutionArgs args) { Console.WriteLine($"Exiting {args.Method.Name}"); } } public class Service { [Log] public void DoWork() { // 方法体 } }28. 类与表达式树
28.1 动态构建Lambda
public static class PredicateBuilder { public static Expression<Func<T, bool>> True<T>() => f => true; public static Expression<Func<T, bool>> False<T>() => f => false; public static Expression<Func<T, bool>> Or<T>( this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2) { var invokedExpr = Expression.Invoke(expr2, expr1.Parameters); return Expression.Lambda<Func<T, bool>>( Expression.OrElse(expr1.Body, invokedExpr), expr1.Parameters); } } // 使用 Expression<Func<Product, bool>> predicate = p => p.Price > 100; predicate = predicate.Or(p => p.Name.Contains("Pro"));29. 类与Roslyn API
29.1 动态分析代码
public class CodeAnalyzer { public int CountClasses(string code) { var tree = CSharpSyntaxTree.ParseText(code); var root = tree.GetRoot(); return root.DescendantNodes().OfType<ClassDeclarationSyntax>().Count(); } }30. 类与机器学习
30.1 ML.NET集成
public class SentimentAnalyzer { private readonly PredictionEngine<SentimentData, SentimentPrediction> _predictor; public SentimentAnalyzer() { var context = new MLContext(); var model = context.Model.Load("sentiment.model", out _); _predictor = context.Model.CreatePredictionEngine<SentimentData, SentimentPrediction>(model); } public bool IsPositive(string text) { return _predictor.Predict(new SentimentData { Text = text }).IsPositive; } }31. 类与区块链
31.1 简单区块链实现
public class Block { public int Index { get; set; } public DateTime Timestamp { get; set; } public string PreviousHash { get; set; } public string Hash { get; set; } public string Data { get; set; } public Block(DateTime timestamp, string previousHash, string data) { Index = 0; Timestamp = timestamp; PreviousHash = previousHash; Data = data; Hash = CalculateHash(); } public string CalculateHash() { using var sha256 = SHA256.Create(); var input = $"{Timestamp}-{PreviousHash ?? ""}-{Data}"; var bytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(input)); return Convert.ToBase64String(bytes); } }32. 类与游戏开发
32.1 Unity游戏实体
public class Player : MonoBehaviour { public float speed = 5f; private Rigidbody _rb; void Start() { _rb = GetComponent<Rigidbody>(); } void Update() { float moveHorizontal = Input.GetAxis("Horizontal"); float moveVertical = Input.GetAxis("Vertical"); Vector3 movement = new Vector3(moveHorizontal, 0f, moveVertical); _rb.AddForce(movement * speed); } }33. 类与物联网
33.1 设备抽象
public abstract class IoTDevice { public string DeviceId { get; } public DeviceStatus Status { get; protected set; } protected IoTDevice(string deviceId) { DeviceId = deviceId; Status = DeviceStatus.Offline; } public abstract Task ConnectAsync(); public abstract Task DisconnectAsync(); public abstract Task<DeviceData> ReadDataAsync(); } public enum DeviceStatus { Offline, Connecting, Online, Error }34. 类与金融计算
34.1 复利计算器
public class CompoundInterestCalculator { public decimal Calculate( decimal principal, decimal annualRate, int years, int compoundsPerYear) { decimal ratePerPeriod = annualRate / compoundsPerYear; int totalPeriods = years * compoundsPerYear; return principal * (decimal)Math.Pow( (double)(1 + ratePerPeriod), totalPeriods); } }35. 类与生物信息学
35.1 DNA序列处理
public class DnaSequence { private readonly string _sequence; public DnaSequence(string sequence) { if (!sequence.All(c => "ATCG".Contains(c))) throw new ArgumentException("Invalid DNA sequence"); _sequence = sequence; } public DnaSequence GetReverseComplement() { var complement = _sequence .Replace('A', 't') .Replace('T', 'a') .Replace('C', 'g') .Replace('G', 'c') .ToUpper(); return new DnaSequence(new string(complement.Reverse().ToArray())); } }36. 类与地理信息系统
36.1 地理坐标计算
public class GeoPoint { public double Latitude { get; } public double Longitude { get; } public GeoPoint(double lat, double lon) { Latitude = lat; Longitude = lon; } public double DistanceTo(GeoPoint other) { // 使用Haversine公式计算距离 const double R = 6371; // 地球半径(km) var dLat = ToRadians(other.Latitude - Latitude); var dLon = ToRadians(other.Longitude - Longitude); var a = Math.Sin(dLat / 2) * Math.Sin(dLat / 2) + Math.Cos(ToRadians(Latitude)) * Math.Cos(ToRadians(other.Latitude)) * Math.Sin(dLon / 2) * Math.Sin(dLon / 2); var c = 2 * Math.Atan2(Math.Sqrt(a), Math.Sqrt(1 - a)); return R * c; } private static double ToRadians(double angle) => angle * (Math.PI / 180); }37. 类与密码学
37.1 对称加密包装器
public class AesEncryptor { private readonly byte[] _key; public AesEncryptor(byte[] key) { _key = key; } public byte[] Encrypt(string plainText) { using var aes = Aes.Create(); aes.Key = _key; using var encryptor = aes.CreateEncryptor(); using var ms = new MemoryStream(); using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write)) using (var sw = new StreamWriter(cs)) { sw.Write(plainText); } return ms.ToArray(); } }38. 类与自然语言处理
38.1 简单分词器
public class TextTokenizer { private readonly char[] _delimiters; public TextTokenizer(params char[] delimiters) { _delimiters = delimiters.Length > 0 ? delimiters : new[] { ' ', '.', ',', ';', '!', '?' }; } public IEnumerable<string> Tokenize(string text) { var buffer = new StringBuilder(); foreach (char c in text) { if (_delimiters.Contains(c)) { if (buffer.Length > 0) { yield return buffer.ToString(); buffer.Clear(); } } else { buffer.Append(c); } } if (buffer.Length > 0) yield return buffer.ToString(); } }39. 类与计算机视觉
39.1 图像处理管道
public class ImageProcessor { private readonly List<IImageFilter> _filters = new(); public void AddFilter(IImageFilter filter) { _filters.Add(filter); } public Bitmap Process(Bitmap source) { var result = (Bitmap)source.Clone(); foreach (var filter in _filters) { result = filter.Apply(result); } return result; } } public interface IImageFilter { Bitmap Apply(Bitmap source); }40. 类与量子计算
40.1 Q#桥接类
public class QuantumSimulator { public async Task<bool> RunBellTestAsync() { using var sim = new QuantumSimulator(); var result = await RunBellTest.Run(sim); return result == Result.One; } } // Q#代码(单独文件) operation RunBellTest() : Result { use (q1, q2) = (Qubit(), Qubit()); H(q1); CNOT(q1, q2); return M(q2); }41. 类与增强现实
41.1 AR标记处理器
public class ArMarkerDetector { private readonly ArSession _session; public ArMarkerDetector(ArSession session) { _session = session; } public IEnumerable<ArMarker> DetectMarkers(ImageData cameraImage) { var markers = new List<ArMarker>(); // 使用AR SDK处理图像 // ... return markers; } public void UpdateMarkerPosition(ArMarker marker) { // 更新标记位置和姿态 } }42. 类与机器人控制
42.1 机器人运动控制器
public class RobotArmController { private readonly SerialPort _port; public RobotArmController(string comPort) { _port = new SerialPort(comPort, 9600); _port.Open(); } public void MoveTo(double x, double y, double z) { string command = $"MOVE {x:F2} {y:F2} {z:F2}\n"; _port.Write(command); } public void Gripper(bool open) { _port.Write(open ? "GRIPPER OPEN\n" : "GRIPPER CLOSE\n"); } }43. 类与3D图形
43.1 简单3D模型
public class Mesh { public Vector3[] Vertices { get; } public int[] Triangles { get; } public Vector2[] UVs { get; } public Mesh(Vector3[] vertices, int[] triangles, Vector2[] uvs) { Vertices = vertices; Triangles = triangles; UVs = uvs; } public void Transform(Matrix4x4 matrix) { for (int i = 0; i < Vertices.Length; i++) { Vertices[i] = Vector3.Transform(Vertices[i], matrix); } } }44. 类与音频处理
44.1 音频效果器
public class AudioEffectChain { private readonly List<IAudioEffect> _effects = new(); public void AddEffect(IAudioEffect effect) { _effects.Add(effect); } public float[] Process(float[] samples) { var buffer = (float[])samples.Clone(); foreach (var effect in _effects) { buffer = effect.Process(buffer); } return buffer; } } public interface IAudioEffect { float[] Process(float[] input); }45. 类与物理模拟
45.1 刚体物理
public class Rigidbody { public Vector3 Position { get; set; } public Vector3 Velocity { get; set; } public float Mass { get; set; } public void ApplyForce(Vector3 force) { Velocity += force / Mass; } public void Update(float deltaTime) { Position += Velocity * deltaTime; } }46. 类与网络协议
46.1 自定义协议解析
public class CustomProtocolParser { public ProtocolMessage Parse(byte[] data) { if (data.Length < 4) throw new ArgumentException("Invalid message length"); var message = new ProtocolMessage { MessageType = (MessageType)data[0], SequenceNumber = BitConverter.ToUInt16(data, 1), Payload = new byte[data.Length - 3] }; Array.Copy(data, 3, message.Payload, 0, message.Payload.Length); return message; } }47. 类与编译器设计
47.1 简单AST节点
public abstract class AstNode { public abstract void Accept(IVisitor visitor); } public class BinaryExpression : AstNode { public AstNode Left { get; } public AstNode Right { get; } public string Operator { get; } public BinaryExpression(AstNode left, string op, AstNode right) { Left = left; Operator = op; Right = right; } public override void Accept(IVisitor visitor) { visitor.Visit(this); } } public interface IVisitor { void Visit(BinaryExpression expr); }48. 类与数据库ORM
48.1 微型ORM
public class MiniOrm<T> where T : new() { private readonly DbConnection _connection; public MiniOrm(DbConnection connection) { _connection = connection; } public IEnumerable<T> Query(string sql, object parameters = null) { using var command = CreateCommand(sql, parameters); using var reader = command.ExecuteReader(); while (reader.Read()) { var obj = new T(); for (int i = 0; i < reader.FieldCount; i++) { var prop = typeof(T).GetProperty(reader.GetName(i)); prop?.SetValue(obj, reader.IsDBNull(i) ? null : reader.GetValue(i)); } yield return obj; } } private DbCommand CreateCommand(string sql, object parameters) { var command = _connection.CreateCommand(); command.CommandText = sql; if (parameters != null) { foreach (var prop in parameters.GetType().GetProperties()) { var param = command.CreateParameter(); param.ParameterName = prop.Name; param.Value = prop.GetValue(parameters) ?? DBNull.Value; command.Parameters.Add(param); } } return command; } }49. 类与微服务
49.1 服务客户端
public class ProductServiceClient { private readonly HttpClient _httpClient; public ProductServiceClient(HttpClient httpClient) { _httpClient = httpClient; } public async Task<Product> GetProductAsync(int id) { var response = await _httpClient.GetAsync($"/api/products/{id}"); response.EnsureSuccessStatusCode(); return await response.Content.ReadAsAsync<Product>(); } public async Task UpdateProductAsync(Product product) { var response = await _httpClient.PutAsJsonAsync( $"/api/products/{product.Id}", product); response.EnsureSuccessStatusCode(); } }50. 类与函数式编程
50.1 不可变集合
public class ImmutableShoppingCart { private readonly ImmutableList<Product> _items; public ImmutableShoppingCart() { _items = ImmutableList<Product>.Empty; } private ImmutableShoppingCart(ImmutableList<Product> items) { _items = items; } public ImmutableShoppingCart AddItem(
