100道C#高频经典面试题及答案解析：C#程序员面试题库分类总结

分类一：C#基础语法

1. 值类型与引用类型的核心区别？

答案：

• 存储位置：值类型存栈/堆内联，引用类型存堆
• 赋值方式：值类型复制内容，引用类型复制地址
• 示例类型：int（值类型） vs string（引用类型）

---

2. 字符串驻留（String Interning）是什么？

答案：

• 机制：相同字符串字面量共享内存（节省空间）
• 验证方法：

string a = "hello";  
string b = "hello";  
Console.WriteLine(object.ReferenceEquals(a, b));  // 输出True  

---

3. is和as运算符的区别？

答案：

• is：检查类型兼容性（返回bool）
• as：安全类型转换（失败返回null）

if (obj is string) { ... }  
var str = obj as string;  

---

4. switch表达式（C# 8.0）如何简化代码？

答案：

• 模式匹配：支持类型、条件判断

var result = obj switch {  int i when i > 0 => "正数",  string s => $"字符串：{s}",  _ => "未知"  
};  

---

5. stackalloc关键字的作用？

答案：

• 栈分配数组：避免GC开销（需unsafe上下文）

int* block = stackalloc int[100];  

---

6. nameof关键字的实际用途？

答案：

• 获取变量/类型名：避免硬编码字符串

void Log(string param) {  Console.WriteLine(nameof(param));  // 输出"param"  
}  

---

7. 记录类型（Record）的特性（C# 9.0）？

答案：

• 不可变性：自动生成init属性
• 值相等性：基于内容而非引用

public record Person(string Name, int Age);  

---

8. 局部函数（Local Function）的使用场景？

答案：

• 封装辅助逻辑：仅在父方法内可见

public void Process() {  int GetValue() => 42;  // 局部函数  Console.WriteLine(GetValue());  
}  

---

9. Span<T>和Memory<T>的作用？

答案：

• 高性能内存操作：避免数据拷贝（如解析二进制流）
• 适用场景：栈内存（Span） vs 堆内存（Memory）

---

10. global using指令（C# 10.0）的作用？

答案：

• 全局命名空间导入：减少重复代码

// GlobalUsings.cs  
global using System.Collections.Generic;  

---

11. 如何实现深拷贝（Deep Copy）？

答案：

• 序列化法：BinaryFormatter（已弃用）或System.Text.Json
• 手动复制：逐层复制引用类型字段

---

12. 工厂方法模式（Factory Method）的C#实现？

答案：

public interface IProduct { }  
public class ConcreteProduct : IProduct { }  public abstract class Creator {  public abstract IProduct FactoryMethod();  
}  public class ConcreteCreator : Creator {  public override IProduct FactoryMethod() => new ConcreteProduct();  
}  

---

13. volatile关键字的作用是什么？

答案：

• 禁止指令重排：确保多线程环境下的变量可见性
• 适用场景：标记可能被多个线程修改的字段

private volatile bool _isRunning;  

---

14. 如何实现自定义隐式/显式类型转换？

答案：

• 隐式转换：public static implicit operator
• 显式转换：public static explicit operator

public class Money {public static implicit operator decimal(Money m) => m.Value;  public static explicit operator Money(decimal d) => new Money(d);  
}  

---

15. yield return的底层实现原理？

答案：

• 状态机生成：编译器自动生成IEnumerator类，保存当前执行位置
• 延迟执行：仅在遍历时触发逻辑

---

14. C#中params关键字的作用？

答案：

• 可变参数：允许方法接受数量不定的同类型参数

public int Sum(params int[] numbers) => numbers.Sum();  
Sum(1, 2, 3);  // 输出6  

---

16. 索引器（Indexer）如何定义？

答案：

• 类属性语法：通过this关键字和参数定义

public class DataList {private int[] _data = new int[10];  public int this[int index] {get => _data[index];  set => _data[index] = value;  }  
}  

---

17. ??=运算符（C# 8.0）的用途？

答案：

• 空值合并赋值：左侧为null时执行赋值

List<int> list = null;  
list ??= new List<int>();  // 若list为null则初始化  

---

18. required关键字（C# 11.0）的作用？

答案：

• 强制初始化：标记属性/字段必须显式赋值

public class User {public required string Name { get; set; }  
}  
// 使用时必须初始化Name  
var user = new User { Name = "Alice" };  

---

19. 如何优化GetHashCode()方法？

答案：

• 减少碰撞：组合多个字段的哈希值

public override int GetHashCode() => (Name, Age).GetHashCode();  

---

20. CallerArgumentExpression特性（C# 10.0）的用途？

答案：

• 捕获调用方表达式：用于验证参数时生成更有意义的异常消息

void Validate(bool condition, [CallerArgumentExpression("condition")] string message = null) {if (!condition) throw new ArgumentException(message);  
}  
Validate(age > 0);  // 异常消息显示"age > 0"  

---

分类二：面向对象与设计模式

21. 什么是里氏替换原则（LSP）？违反示例

答案：

• 原则：子类必须能替换父类而不破坏程序逻辑
• 反例：子类重写父类方法并抛出NotImplementedException

---

22. 依赖注入（DI）的三种生命周期？

答案：

• Singleton：单例，全局共享实例
• Scoped：作用域内唯一（如HTTP请求）
• Transient：每次请求创建新实例

---

23. 建造者模式（Builder）的C#实现？

答案：

public class ProductBuilder {private Product _product = new Product();  public ProductBuilder SetName(string name) { _product.Name = name;  return this;  }  public Product Build() => _product;  
}  
// 使用  
var product = new ProductBuilder().SetName("PC").Build();  

---

24. 如何防止类被继承？

答案：

• sealed关键字：标记类或方法不可被重写

public sealed class FinalClass { ... }  

---

25. 策略模式（Strategy）的应用场景？

答案：

• 动态切换算法：如支付方式选择（支付宝、微信）

public interface IPayment { void Pay(decimal amount); }  
public class Alipay : IPayment { ... }  
public class WechatPay : IPayment { ... }  

---

26. 什么是接口污染？如何解决？

答案：

• 问题：接口包含多余方法，迫使实现类冗余
• 方案：遵循接口隔离原则，拆分为更小接口

---

27. 模板方法模式（Template Method）示例

答案：

public abstract class Game {public void Play() {  Initialize();  Start();  End();  }  protected abstract void Initialize();  protected abstract void Start();  protected virtual void End() { ... }  
}  

---

28. 何时使用组合而非继承？

答案：

• 避免耦合：当类之间的关系是“具有”（has-a）而非“是”（is-a）时
• 示例：汽车包含引擎（组合），而非继承引擎

---

29. 原型模式（Prototype）的深拷贝实现？

答案：

public class Product : ICloneable {public object Clone() => this.MemberwiseClone();  // 浅拷贝  // 深拷贝需手动复制引用类型字段  
}  

---

30. 观察者模式（Observer）与事件的区别？

答案：

• 观察者模式：需手动管理订阅列表
• 事件：基于委托的语法糖，提供+=和-=操作符

---

分类三：集合与泛型

31. Dictionary<TKey, TValue>的哈希冲突如何解决？

答案：

• 链地址法：每个桶（Bucket）存储链表或Entry结构
• 自动扩容：当元素数量超过阈值时重建哈希表

---

32. IEnumerable和IEnumerator的关系？

答案：

• IEnumerable：定义获取迭代器的方法（GetEnumerator）
• IEnumerator：实现迭代逻辑（MoveNext、Current）

foreach (var item in list) { ... }  
// 等效于：  
var enumerator = list.GetEnumerator();  
while (enumerator.MoveNext()) { ... }  

---

33. 泛型协变（Covariance）与逆变（Contravariance）是什么？

答案：

• 协变（out）：允许子类泛型赋值给父类泛型（如IEnumerable<Cat> → IEnumerable<Animal>）
• 逆变（in）：允许父类泛型赋值给子类泛型（如Action<Animal> → Action<Cat>）

interface IProducer<out T> { T Produce(); }  
interface IConsumer<in T> { void Consume(T item); }  

---

34. HashSet<T>和List<T>的核心区别？

答案：

• 唯一性：HashSet自动去重，List允许重复
• 查找效率：HashSet的Contains为O(1)，List为O(n)

---

35. 如何实现自定义集合的排序？

答案：

• IComparable<T>：元素类实现比较逻辑
• IComparer<T>：定义独立比较器

public class Product : IComparable<Product> {  public int CompareTo(Product other) => Price.CompareTo(other.Price);  
}  
// 使用  
list.Sort((a, b) => a.Price.CompareTo(b.Price));  

---

36. ConcurrentBag<T>的适用场景？

答案：

• 线程安全集合：适用于生产者-消费者模式，无序但高性能
• 实现原理：使用ThreadLocal存储线程本地数据

---

37. 泛型约束where T : class的作用？

答案：

• 限制为引用类型：确保T可为null或用于引用类型操作

public void PrintName<T>(T item) where T : class => Console.WriteLine(item?.ToString());  

---

38. ArrayPool<T>如何优化内存分配？

答案：

• 重用数组：避免频繁分配/回收大数组（如网络缓冲区）

var pool = ArrayPool<int>.Shared;  
int[] buffer = pool.Rent(1024);  
pool.Return(buffer);  

---

39. LinkedList<T>和List<T>的性能对比？

答案：

• 插入/删除：链表在中间操作高效（O(1)），列表需移动元素（O(n)）
• 随机访问：链表需遍历（O(n)），列表直接索引（O(1)）

---

40. 如何实现深度比较两个集合？

答案：

• 序列化比较：将对象序列化为JSON/二进制后比较
• 递归遍历：逐字段比较引用类型内容

public static bool DeepEquals<T>(T a, T b) => JsonSerializer.Serialize(a) == JsonSerializer.Serialize(b);  

---

分类四：异常处理与调试

（精选3题，完整版请通过文末方式获取）

41. AggregateException的作用？

答案：

• 封装多个异常：常见于并行任务（Parallel.ForEach、Task.WhenAll）

try {  Parallel.Invoke(() => { throw new Exception("1"); }, () => { throw new Exception("2"); });  
} catch (AggregateException ex) {  foreach (var e in ex.InnerExceptions) Console.WriteLine(e.Message);  
}  

---

42. 如何调试NullReferenceException？

答案：

• 启用Null检查：C# 8.0可开启<Nullable>enable</Nullable>
• 调试技巧：检查调用堆栈，使用条件断点

---

43. ConditionalAttribute的应用场景？

答案：

• 条件编译：仅在特定条件下编译方法（如调试日志）

[Conditional("DEBUG")]  
public void Log(string message) => Console.WriteLine(message);  

---

分类四：多线程与异步编程

44. Task.Run与Task.Factory.StartNew的区别？

答案：

• 默认配置：Task.Run自动使用线程池调度器，StartNew需手动配置
• 取消支持：Task.Run直接支持取消令牌参数

var task1 = Task.Run(() => Compute());  
var task2 = Task.Factory.StartNew(() => Compute(), CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);  

---

45. 如何避免async void方法？

答案：

• 异常吞噬：async void无法捕获异常，应始终使用async Task

// 错误示例  
async void SaveData() { ... }  
// 正确示例  
async Task SaveDataAsync() { ... }  

---

46. ValueTask的使用场景？

答案：

• 性能优化：当异步操作可能同步完成时（如缓存命中）

public ValueTask<string> GetDataAsync() {  if (_cache.TryGetValue(key, out var data))  return new ValueTask<string>(data);  return new ValueTask<string>(FetchFromNetworkAsync());  
}  

---

47. CancellationTokenSource的链式取消？

答案：

• 组合令牌：通过CreateLinkedTokenSource绑定多个取消源

var cts1 = new CancellationTokenSource();  
var cts2 = new CancellationTokenSource();  
var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cts1.Token, cts2.Token);  

---

48. 如何检测异步死锁？

答案：

• 常见场景：在UI线程调用.Result或.Wait()
• 解决方案：全链路使用async/await，避免阻塞调用

---

49. Interlocked类的原子操作示例

答案：

int _counter = 0;  
public void Increment() => Interlocked.Increment(ref _counter);  
public int GetValue() => Interlocked.CompareExchange(ref _counter, 0, 0);  

---

50. SemaphoreSlim与Semaphore的区别？

答案：

• 轻量级：SemaphoreSlim适合进程内同步，支持异步等待
• 跨进程：Semaphore基于系统信号量，可跨进程使用

---

51. TPL数据流（BufferBlock）的用途？

答案：

• 管道处理：构建生产者-消费者流水线

var bufferBlock = new BufferBlock<int>();  
bufferBlock.Post(42);  
var data = await bufferBlock.ReceiveAsync();  

---

52. ThreadLocal<T>的线程隔离示例

答案：

private static ThreadLocal<Random> _threadRand = new ThreadLocal<Random>(() => new Random());  
void PrintRandom() => Console.WriteLine(_threadRand.Value.Next());  

---

53. 异步状态机的MoveNext逻辑揭秘

答案：

• 编译转换：async/await被编译为状态机类，MoveNext恢复执行上下文
• 性能关键：避免在热点路径频繁触发状态机

---

分类五：LINQ与函数式编程（第59-68题）

54. LINQ的延迟执行（Deferred Execution）示例

答案：

var query = numbers.Where(n => n > 0);  // 未执行  
var result = query.ToList();  // 触发实际查询  

---

55. SelectMany的嵌套查询转换

答案：

var query = from a in listA  from b in listB  select a + b;  
// 等效于  
var query = listA.SelectMany(a => listB, (a, b) => a + b);  

---

56. IQueryable与IEnumerable的核心区别？

答案：

• 执行位置：IQueryable在数据库端编译，IEnumerable在内存中处理
• 表达式树：IQueryable携带表达式树供LINQ Provider解析

---

57. 如何实现自定义LINQ扩展方法？

答案：

public static IEnumerable<T> WhereEven<T>(this IEnumerable<T> source, Func<T, int> selector) {  foreach (var item in source)  if (selector(item) % 2 == 0)  yield return item;  
}  
// 使用  
var evenItems = list.WhereEven(x => x.Id);  

---

58. Func与Expression<Func>的区别？

答案：

• 编译时机：Func直接编译为IL，Expression保留AST供动态解析（如EF Core）

---

59. Aggregate方法的实际应用

答案：

int product = numbers.Aggregate(1, (acc, n) => acc * n);  // 计算乘积  

---

60. LINQ的流式处理（Streaming）与缓冲处理（Buffering）区别？

答案：

• 流式处理：Where、Select逐个处理元素
• 缓冲处理：OrderBy、GroupBy需加载全部数据

---

61. Range与Repeat的生成器用法

答案：

var squares = Enumerable.Range(1, 5).Select(x => x * x);  // [1,4,9,16,25]  
var copies = Enumerable.Repeat("Hello", 3);  // ["Hello","Hello","Hello"]  

---

62. 如何优化LINQ查询性能？

答案：

• 减少中间集合：链式调用代替多次ToList
• 预编译查询：EF Core使用CompiledQuery

---

63. Zip操作符的合并示例

答案：

var names = new[] { "Alice", "Bob" };  
var ages = new[] { 30, 25 };  
var merged = names.Zip(ages, (n, a) => $"{n} ({a})");  // ["Alice (30)", "Bob (25)"]  

---

分类七：委托、事件与反射

64. 委托链（MulticastDelegate）的异常传播机制？

答案：

• 顺序执行：所有委托按添加顺序执行，任一委托抛出异常则链终止
• 获取所有异常：需手动遍历调用列表

foreach (var handler in myDelegate.GetInvocationList()) {  try { handler.DynamicInvoke(args); }  catch (Exception ex) { /* 记录异常 */ }  
}  

---

65. 如何通过反射动态创建泛型类型实例？

答案：

Type openType = typeof(List<>);  
Type closedType = openType.MakeGenericType(typeof(int));  
object list = Activator.CreateInstance(closedType);  

---

66. 事件访问器（add/remove）的作用？

答案：

• 自定义订阅逻辑：控制事件处理器的添加/移除过程

private EventHandler _myEvent;  
public event EventHandler MyEvent {  add { _myEvent += value; Log("订阅"); }  remove { _myEvent -= value; Log("取消订阅"); }  
}  

---

67. Func与Action委托的性能差异？

答案：

• 内存分配：频繁创建委托可能导致GC压力，可用static lambda优化

// 优化前（每次分配）  
Func<int, int> square = x => x * x;  
// 优化后（单例）  
static readonly Func<int, int> SquareStatic = x => x * x;  

---

68. 表达式树（Expression Tree）的构建与编译？

答案：

Expression<Func<int, bool>> expr = x => x > 5;  
var compiled = expr.Compile();  
bool result = compiled(10);  // true  

---

69. WeakReference在事件订阅中的应用？

答案：

• 避免内存泄漏：允许订阅对象被GC回收

public class Publisher {  private List<WeakReference<EventHandler>> _handlers = new List<WeakReference<EventHandler>>();  public void Subscribe(EventHandler handler) => _handlers.Add(new WeakReference<EventHandler>(handler));  
}  

---

70. 如何通过反射调用私有方法？

答案：

var method = typeof(MyClass).GetMethod("PrivateMethod", BindingFlags.NonPublic | BindingFlags.Instance);  
method.Invoke(obj, new object[] { });  

---

71. 委托与接口的适用场景对比？

答案：

• 单一方法：优先用委托（如Comparison<T>）
• 多方法组合：使用接口（如IEnumerable）

---

72. DynamicObject的动态属性实现？

答案：

public class DynamicBag : DynamicObject {  private Dictionary<string, object> _data = new Dictionary<string, object>();  public override bool TrySetMember(SetMemberBinder binder, object value) => _data.TryAdd(binder.Name, value);  public override bool TryGetMember(GetMemberBinder binder, out object result) => _data.TryGetValue(binder.Name, out result);  
}  

---

73. 如何优化反射性能？

答案：

• 缓存反射结果：如Type对象、MethodInfo
• 使用Delegate.CreateDelegate：将方法转换为强类型委托

---

分类八：内存管理与GC

74. 栈（Stack）与堆（Heap）的核心区别？

答案：

• 栈：自动管理，存储值类型和方法调用帧
• 堆：动态分配，存储引用类型对象，需GC回收

---

75. IDisposable接口的正确实现？

答案：

public class Resource : IDisposable {  private bool _disposed = false;  protected virtual void Dispose(bool disposing) {  if (!_disposed) {  if (disposing) { /* 释放托管资源 */ }  /* 释放非托管资源 */  _disposed = true;  }  }  public void Dispose() {  Dispose(true);  GC.SuppressFinalize(this);  }  ~Resource() => Dispose(false);  
}  

---

76. GC的世代（Generation）机制如何提升性能？

答案：

• 分代假设：新对象生命周期短，老对象存活时间长
• 回收策略：频繁回收第0代，减少全堆扫描

---

78. ArrayPool<T>与MemoryPool<T>的区别？

答案：

• ArrayPool：重用数组，减少大对象分配
• MemoryPool：管理Memory<T>，适合非连续缓冲区（如管道）

---

79. Span<T>如何避免内存复制？

答案：

• 引用语义：提供对连续内存的视图（如数组、栈内存）

byte[] data = new byte[100];  
Span<byte> slice = data.AsSpan(10, 20);  // 不复制数据  

---

80. fixed关键字的作用？

答案：

• 固定托管对象：防止GC移动内存地址（用于非托管代码交互）

fixed (byte* ptr = data) { /* 使用指针操作 */ }  

---

81. 如何诊断内存泄漏？

答案：

• 工具：Visual Studio诊断工具、dotnet-dump
• 模式：检查长期存活对象引用意外持有的资源

---

82. GCHandle的用法示例？

答案：

object obj = new object();  
GCHandle handle = GCHandle.Alloc(obj, GCHandleType.Weak);  
object target = handle.Target;  // 可能为null（若对象被回收）  
handle.Free();  

---

83. Memory<T>与Span<T>的核心区别？

答案：

• 存储位置：Memory<T>可存在于堆，Span<T>仅限栈
• 使用场景：Memory<T>适合异步操作，Span<T>适合同步方法

---

84. System.IO.Pipelines如何优化IO性能？

答案：

• 零拷贝：通过PipeReader/PipeWriter管理缓冲区
• 背压支持：根据处理能力动态调整数据流

---

分类九：ASP.NET Core

85. 中间件（Middleware）管道的执行顺序？

答案：

• 先进后出：请求按注册顺序正向执行，响应按反向顺序返回

app.Use(async (context, next) => {  /* 请求处理 */  await next();  /* 响应处理 */  
});  

---

86. 如何自定义配置源（如数据库配置）？

答案：

public class DbConfigurationSource : IConfigurationSource {  public IConfigurationProvider Build(IConfigurationBuilder builder) => new DbConfigurationProvider();  
}  
public class DbConfigurationProvider : ConfigurationProvider {  public override void Load() => Data = LoadFromDatabase();  
}  
// 使用  
config.Add(new DbConfigurationSource());  

---

87. 依赖注入中服务生命周期如何选择？

答案：

• Singleton：全局共享（如缓存服务）
• Scoped：请求级共享（如DbContext）
• Transient：每次请求新实例（如轻量级工具类）

---

88. IHttpClientFactory如何管理HttpClient生命周期？

答案：

• 避免端口耗尽：重用HttpMessageHandler，自动轮换

services.AddHttpClient("MyClient", client => {  client.BaseAddress = new Uri("https://api.example.com");  
});  

---

89. 如何实现JWT认证？

答案：

services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)  .AddJwtBearer(options => {  options.TokenValidationParameters = new TokenValidationParameters {  ValidateIssuer = true,  ValidIssuer = "MyIssuer",  ValidateAudience = true,  ValidAudience = "MyAudience",  IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("MySecretKey"))  };  });  

---

90. [ApiController]特性的自动化行为？

答案：

• 自动模型验证：返回400状态码+错误详情
• 推断绑定源：自动从Body/Query/Route绑定参数

---

91. 如何自定义模型绑定？

答案：

public class CustomBinder : IModelBinder {  public Task BindModelAsync(ModelBindingContext context) {  var value = context.HttpContext.Request.Headers["X-Custom-Header"];  context.Result = ModelBindingResult.Success(value);  return Task.CompletedTask;  }  
}  
// 使用  
[ModelBinder(BinderType = typeof(CustomBinder))]  
public string HeaderValue { get; set; }  

---

92. gRPC与REST API的对比？

答案：

• 协议：gRPC基于HTTP/2和Protobuf，REST基于HTTP/1.1+JSON
• 性能：gRPC二进制编码效率高，支持流式通信

---

93. HealthCheck中间件的配置？

答案：

services.AddHealthChecks()  .AddCheck<DatabaseHealthCheck>("database");  
app.UseHealthChecks("/health", new HealthCheckOptions {  ResponseWriter = async (context, report) => {  await context.Response.WriteAsync(report.Status.ToString());  }  
});  

---

94. 如何实现AOP（面向切面编程）？

答案：

• 方法拦截：通过IMiddleware或第三方库（如Castle DynamicProxy）

public class LoggingMiddleware : IMiddleware {  public async Task InvokeAsync(HttpContext context, RequestDelegate next) {  LogRequest(context.Request);  await next(context);  LogResponse(context.Response);  }  
}  

---

95. 如何在ASP.NET Core中区分开发环境与生产环境？

答案：

• 环境变量：通过ASPNETCORE_ENVIRONMENT设置（如Development、Production）
• 依赖注入：注入IWebHostEnvironment判断当前环境

if (env.IsDevelopment()) {  app.UseDeveloperExceptionPage();  
}  

---

96. 解释IOptions<T>、IOptionsSnapshot<T>和IOptionsMonitor<T>的区别

答案：

• IOptions<T>：单例，配置变更后不更新
• IOptionsSnapshot<T>：作用域生命周期，支持配置热更新
• IOptionsMonitor<T>：单例，支持监听配置变更（通过OnChange回调）

---

97. 如何实现ASP.NET Core中的响应压缩？

答案：

services.AddResponseCompression(options => {  options.Providers.Add<GzipCompressionProvider>();  options.EnableForHttps = true;  
});  
app.UseResponseCompression();  

适用场景：API返回大型JSON数据或静态文件时减少带宽占用

---

98. 中间件（Middleware）与过滤器（Filter）的核心区别？

答案：

• 中间件：处理HTTP请求管道的全局逻辑（如认证、日志）
• 过滤器：围绕MVC Action的特定逻辑（如模型验证、权限检查）

// 过滤器示例（Action执行前）  
public class CustomFilter : IActionFilter {  public void OnActionExecuting(ActionExecutingContext context) { ... }  public void OnActionExecuted(ActionExecutedContext context) { ... }  
}  

---

99. 如何配置ASP.NET Core的内存缓存与分布式缓存（如Redis）？

答案：

// 内存缓存  
services.AddMemoryCache();  // Redis分布式缓存  
services.AddStackExchangeRedisCache(options => {  options.Configuration = "localhost:6379";  
});  // 使用  
public class MyService {  private readonly IDistributedCache _cache;  public MyService(IDistributedCache cache) => _cache = cache;  public async Task<string> GetDataAsync(string key) => await _cache.GetStringAsync(key);  
}  

---

100. 解释[ApiController]特性如何自动推断参数绑定源？

答案：

• 规则：
  • 简单类型（如int）默认从QueryString绑定
  • 复杂类型（如class）默认从Body绑定
• 手动覆盖：通过[FromQuery]、[FromRoute]等特性指定来源

public IActionResult Get([FromQuery] int page, [FromBody] FilterModel filter) { ... }  

---

提示：掌握这些知识点后，建议结合《CLR via C#》和《ASP.NET Core in Action》深入理解底层机制，并在实际项目中应用这些知识点！