【NET】高级开发面试题总结（2025）

面试要求汇总

1.熟悉winform优先、要求具备一定图形算法能力。

2.熟悉TCP/IP、EtherCAT、CAN、RS485、RS232网络协议，熟练掌握网络编程技术及多线程技术、进程处理技术，具有很强的编码、调试和解决问题能力;

3.对并发(多线程、并行计算)、I0有深入的理解，能够根据业务需求权衡不同的技术路线

4.精通C#语言，精通Task、异步编程、LNQ语法、委托和C#各版本新特性，有C/S架构设计经验和多用户并发编程经验;

5.精通wpf界面设计，精通组件式开发框架，熟悉Prism/mvvmLight框架，熟悉各种第三方控件/库，如DevExpress、SciChart等；

6.熟悉Tcp/Udp通信，了解DDS/反射内存1394/1553/FC/CAN总线等:

7.实现串口/1394/1553/CAN（总线等航电系统开发经验）等信号数据采集、存储与解析曲线绘制、场景回放等:

8.了解车载总线协议如CAN、UDS、XCP 以太网等协议；熟悉CANoe/CANape等车载软件者优先。

9.对Amazon Web Services，Azure, 阿里云有深入了解，且有项目经验。

10.离线数仓构建、实施流处理、用户点击量分析、Hadoop、Hive、Kafka、Spark、Flink 百万级？

面试问题总结

一、某科技（成都）有限公司

1.自我介绍：开发过的项目以及所在公司、采用了哪些技术？

2.IO管理包含哪几个核心模块？

答：
（1）、设备驱动程序（Driver）
功能：设备驱动程序是IO管理的核心组件，它负责控制和管理硬件设备，使操作系统能够与这些设备进行通信和数据交换。
类型：根据设备的不同，设备驱动程序可以分为多种类型，如磁盘驱动程序、打印机驱动程序、网络通信驱动程序等。

（2）、中断处理（Interrupt Handling）
功能：中断处理模块负责处理来自硬件设备的中断信号。当中断发生时，中断处理模块会暂停当前正在执行的程序，转而执行相应的中断处理程序，以响应设备的需求。
机制：中断处理通常包括中断请求、中断响应、中断处理和中断返回等步骤。

（3）、缓冲技术（Buffer Management）
功能：缓冲技术用于在数据输入和输出过程中暂时存储数据，以减少数据传输的延迟和提高数据传输的效率。
类型：缓冲技术可以分为单缓冲、双缓冲和循环缓冲等多种类型。

（4）、设备分配与回收
功能：设备分配与回收模块负责在多个进程之间分配和回收硬件设备资源。它确保每个进程在需要时都能获得所需的设备资源，并在使用完毕后及时释放资源。
策略：设备分配策略通常包括先来先服务、优先级分配等。

（5）、错误处理（Error Handling and Recovery）
功能：错误处理模块负责检测和处理在IO过程中发生的错误和异常情况。它确保系统能够及时发现并纠正错误，以保证数据的完整性和系统的稳定性。
方式：错误处理通常包括错误检测、错误报告和错误恢复等步骤。

（6）、IO调度（IO Scheduler）
功能：IO调度模块负责根据设备的优先级和当前系统的负载情况，对IO请求进行调度和排序。它确保系统能够高效地处理IO请求，以提高系统的整体性能。
算法：IO调度算法有多种，如先来先服务（FCFS）、最短寻道时间优先（SSTF）、电梯算法（SCAN）等。

3.NET微服务后台如何做负载均衡?

答：负载均衡（Load Balance）是指将并发的用户请求通过一定规则平衡、分摊到多台服务器上进行执行，以此达到压力分摊、数据并行的效果。负载均衡可以提高系统的可用性、性能和安全性，是微服务架构中不可或缺的组件。
（1）、DNS层负载均衡
通过智能解析域名，将用户请求分配到不同的服务器或集群上。
这种方式简单但不够灵活，且负载均衡的粒度较粗，通常用于全局负载均衡或作为其他负载均衡方式的补充。

（2）、LVS层负载均衡
LVS（Linux Virtual Server）是一种基于Linux系统的四层负载均衡解决方案。
它通过修改数据包的目标地址和端口，将用户请求转发到后端服务器，然后再将响应数据包转发回用户。
LVS支持多种工作模式和调度算法，可以根据不同的场景进行选择和组合使用。
但LVS只能实现四层的负载均衡和路由转发，不能实现七层的内容分发和应用逻辑处理。

（3）、Nginx层负载均衡
Nginx是一种基于C实现的高性能Web服务器和反向代理服务器。
它可以通过配置实现七层的负载均衡和反向代理。
Nginx支持多种负载均衡算法，如轮询、加权轮询、IP哈希、URL哈希等。
Nginx还可以实现静态资源服务、缓存服务、安全防护等功能。
但Nginx同样只能实现七层的负载均衡，不能实现四层的负载均衡和路由转发。

（4）、API网关层负载均衡
通过API网关中间件，如Kong，实现对微服务API的统一入口和管理。
API网关可以处理跨域请求、身份验证、流量控制、熔断降级等功能。
它还可以根据路由规则将请求转发到不同的微服务实例上，实现负载均衡。

（5）、服务注册中心层负载均衡
通过服务注册中心中间件，如Consul或Eureka，实现对微服务实例的发现和健康检查。
服务注册中心可以维护一个可用的微服务实例列表，并根据健康检查结果来过滤不可用的实例。
客户端可以通过服务注册中心获取可用的微服务实例列表，并根据一定的策略（如轮询、随机等）来选择要调用的实例。

（6）、RPC层负载均衡
通过RPC框架，如gRPC或WebApiClient，实现对微服务之间的远程调用和隐藏请求细节。
RPC框架通常内置了负载均衡机制，可以根据服务实例的负载情况、响应时间等因素来选择最优的实例进行调用。

（7）、中间件层负载均衡
通过与服务注册中心集成的中间件，如Fabio，实现对微服务地址列表的负载均衡请求转发。
这种方式通常用于更细粒度的负载均衡，如根据请求的路径、参数等信息来选择要调用的微服务实例。

4.异步开发实现有哪几种方式（Thread Task 信号量，多线程锁）？

（1）、异步方法 async Task wait
（2）、Task.Run方法 await Task.Run(()=>{});
（3）、Parallel并行编程，并行循环Parallel.For()、Parallel.Foreach()
（4）、通过事件（Event）异步调用

public class AsyncOperation
{
    public event EventHandler Completed;
 
    public void Start()
    {
        // 模拟异步操作
        Task.Delay(1000).ContinueWith(task => {
            OnCompleted(new EventArgs());
        });
    }
 
    protected virtual void OnCompleted(EventArgs e)
    {
        Completed?.Invoke(this, e);
    }
}
// 调用异步操作
var operation = new AsyncOperation();
operation.Completed += (sender, e) => {
    Console.WriteLine("异步操作完成！");
};
operation.Start();

（5）、使用异步委托（Async delegate）

public class AsyncOperation
{
    public async Task<int> StartAsync()
    {
        // 模拟异步操作
        await Task.Delay(1000);
        return 42;
    }
}
// 调用异步操作
var operation = new AsyncOperation();
var result = await operation.StartAsync();
Console.WriteLine($"异步操作完成，结果为：{result}");

（6）、使用异步的 LINQ（LINQ with async）

var numbers = Enumerable.Range(1, 10);
 
// 异步筛选出偶数
var evenNumbers = await Task.Run(() => numbers.Where(n => n % 2 == 0));
 
Console.WriteLine("筛选出的偶数为：");
foreach (var number in evenNumbers)
{
    Console.WriteLine(number);
}

5.Linq底层原理是采用了什么技术？
（1）、表达式树
（2）、Lambda表达式转译
（3）、扩展方法（Extension Methods）

6.项目开发中使用的分库分表工具（ShardingSphere-Proxy）
1、ShardingShpere
2、MyCat

7.项目开发中常用的设计模式有哪些？

（1）、单例模式
（2）、抽象工厂
（3）、建造者模式
（4）、原型模式
（5）、适配器模式
（6）、桥接模式
（7）、装饰模式
（8）、责任链模式

8.Hbase数据库、MongoDB开发使用经验？

9.常见IoT物联网协议：ModBus、Bacnet、Opc UA、Can、Rs485、Rs232协议、MQTT协议

二、MySql数据库篇

1.MySql事务特性有哪些？

答：ACID
原子性（Atomicity）：事务是一个不可分割的工作单位，事务中的所有操作要么全部成功，要么全部失败。如果其中一个操作失败，整个事务会被回滚到开始前的状态‌；
一致性（Consistency）：事务必须保持数据库的一致性状态，即从一个有效状态转换到另一个有效状态。事务执行前后，数据库的完整性必须保持不变‌；
隔离性（Isolation）：事务的隔离性确保一个事务的执行不受其他事务的影响。通过设置不同的隔离级别，可以控制事务间可见的数据修改程度。常见的隔离级别包括读未提交、读已提交、可重复读和串行化‌；
持久性（Durability）：一旦事务提交，其对数据库的修改就是永久性的，即使系统发生故障也不会丢失。这意味着事务提交后的数据会永久保存在数据库中‌；

2.MySql中Innodb用的什么存储结构，B加数和B数有什么区别？

答：MySql中Innodb用的是B加数、B加数和B数的区别主要有2点，第一点区别是B加数的数据是存在于叶子结点的，非叶子节点只存储键（key）和指向子节点的指针，B数的数据是存放在所有的结点；
第二个区别是B加数的叶子节点它是一个双向链表；B加数的这样一个设计（减少存储空间），可以让数的高度变低，减少IO的一个次数。

3.MySql中存储引擎有哪些？

答：MySql中存储引擎有5个，那主要的是包括我们熟悉的InnoDB以及像MyISAM,还有就是MEMORY,还有MERGE、NDB

4.分库分表会带来哪些问题？有哪些成熟的分库分表中间件？

答：分库分表会带来一下几个问题
（1）、实物问题：分库分表后，假设2个表之前是存在于不同数据库中，那么本地事务就会失效，这时候就要用到分布式事务。
（2）、常见的跨库关联，比如跨节点的Join 的一个问题，要解决这样一个问题的话，可以采用2次查询的一个方式。
（3）、面临一些像排序的问题,比如跨节点的count、order by 、group by以及聚合函数的问题，要解决这些问题的话，我们可以在各个节点得到对应的数据，然后在程序段进行合并。
（4）、面临的一个分页的问题：分页问题的话主要有2种解决方案，第一就是我们可以通过在每个节点上得到对应的一个结果，然后在代码端进行一个分解，
或者说我们可以直接把这个问题抛给前段，但是前段会面临一个数据空的问题。
（5）、分库分表面临的是一个分布式ID，数据被切分之后的话，不能够依赖数据库自身的一个组件生成机制了。这时我们可以采用像UUID，或者雪花算法这些方式来生成分布式ID

分库分表中间件主要有2类：第一类主要是代理模式，代理模式的话需要一个代理服务器
第二种是非代理模式：常用的分库分表中间件有ShardingSphere、MyCAT、淘宝TDDL、360的像Atlas、 阿里的cobar（已逐渐被淘汰）。

5.MySql中的锁有哪些？

答：MySql中的锁分为乐观锁和悲观锁，我们常说的mysql锁主要集中在悲观锁，悲观锁又分为全局锁、表锁、行锁；表锁又分为共享读锁、表共享一个写锁，甚至说我们还有一项元数据锁，以及像意向锁
那行级锁包括像我们常见的一些行锁，包括行的共享锁、行的排它锁、以及像间隙锁、临键锁这些。

6.分布式系统中，多年以前的数据怎么处理？

答：很少会去查询3年前的数据,所以方案中采用冷热数据分离，冷数据（3年以前的数据）存放在elasticsearch、hive这些数据库中；3年以内的数据我们放在数据库里面进行存储。

7.分布式系统中，如何查询某一段时间的订单？

答：我们可以把数据放在ES、或者Hive（Hive是一个基于Hadoop一个数据仓库工具）这些数据库里面，这样就可以很方便的进行数据查询了。

8.MySql为什么加索引能加快查询速度？

答：索引的本质就是一个数据结构，数据结构有很多，比如各种树、Hash、哈希表；
数据结构有一个最大的用途就是提升数据查找的速度。

二、某科技（成都）有限公司

1、对多线程了解？Thread和Task有啥区别？

答：（1）基于不同的框架和API：
Thread是基于Windows操作系统提供的API实现。
Task则是基于.NET框架提供的TPL（Task Parallel Library）实现。

（2）默认执行线程池：
Thread默认使用前台线程。
Task默认使用后台线程。

（3）异步执行：
Thread不支持异步执行。
Task支持异步执行。

（4）异常处理：
Thread需要在每个线程中处理异常。
Task提供了更好的异常处理机制。

（5）任务调度器：
Thread没有任务调度器。
Task提供了任务调度器，可以控制任务的并发性和调度方式。

（6）返回值：
Thread没有返回值。
Task可以有返回值。

2、什么是缓存击穿、缓存穿透、缓存雪崩，如何解决？

答：（1）. 缓存击穿
定义：某个热点数据在缓存中过期时，大量请求同时涌入数据库，导致数据库压力骤增。

解决方案：

永不过期：对热点数据设置永不过期，通过后台更新缓存。

互斥锁：缓存失效时，使用互斥锁确保只有一个请求访问数据库并更新缓存，其他请求等待。

（2）. 缓存穿透
定义：大量请求查询不存在的数据，导致请求直接打到数据库，造成压力。

解决方案：

布隆过滤器：使用布隆过滤器快速判断数据是否存在，不存在则直接返回。

缓存空值：即使查询结果为空，也将空值缓存，并设置较短的过期时间。

（3）. 缓存雪崩
定义：大量缓存同时失效，导致所有请求直接访问数据库，数据库压力过大甚至崩溃。

解决方案：

分散过期时间：为缓存设置随机的过期时间，避免同时失效。

高可用架构：使用分布式缓存或集群，确保部分节点失效时系统仍能运行。

限流降级：在缓存失效时，通过限流和降级保护数据库。

3、介绍一下GC垃圾回收机制？

答：（1）、基本概念
GC负责跟踪应用程序中不再使用的对象，并释放这些对象占用的内存。这种机制大大简化了内存管理任务，使得开发者能够更专注于编写业务逻辑代码，而无需过多关注内存分配和释放的细节。

（2）、工作原理
C#的垃圾回收器使用了一种称为“标记-清除”（Mark-and-Sweep）的算法，其工作原理如下：

标记阶段：垃圾回收器从根对象（通常是静态变量、线程栈上的局部变量、CPU寄存器中的引用等）开始，递归地访问这些对象引用的所有其他对象。被访问到的对象会被标记为“可达”或“存活”对象，表示这些对象仍然在使用中。
清除阶段：垃圾回收器会遍历堆内存，找到所有未被标记为可达的对象（即垃圾对象），并释放这些垃圾对象占用的内存空间，以供将来分配新的对象使用。
此外，在某些实现中，垃圾回收器还可能包括一个“压缩”阶段，即移动存活的对象，使它们重新从堆基地址开始连续排列，类似于磁盘空间的碎片整理。这样可以避免内存碎片问题，但移动对象会有一定的性能开销。

（3）、分代回收
C#的垃圾回收器是一种分代式垃圾回收器，它将对象按照其存活时间分为0代、1代和2代三个代数，每个代数有自己的内存区域。一般来说，0代对象的生命周期最短，2代对象的生命周期最长。垃圾回收器在进行垃圾回收时，会优先回收0代对象，然后是1代对象，最后是2代对象。这样可以提高垃圾回收的效率和性能。

（4）、并发回收
C#的垃圾回收器是一种并发式垃圾回收器，它可以在用户线程运行的同时进行部分垃圾回收工作，从而减少用户线程被暂停的时间。这有助于提高应用程序的响应速度和用户体验。
（5）、回收模式
C# GC有两种并发模式：工作站模式和服务器模式。工作站模式适用于单处理器或客户端应用程序，服务器模式适用于多处理器或服务器应用程序。此外，C# GC是一种可配置的垃圾回收器，它可以根据应用程序的需求和环境来调整垃圾回收的策略和参数。

4.MySql为什么要分区？分区语法怎么写？

答：在 MySQL 中，分区是一种将表的数据分割成更小、更可管理的部分的技术。分区可以提高查询性能、简化管理和维护，以及支持更高效的备份和恢复操作。MySQL 支持多种分区类型，包括 RANGE、LIST、HASH 和 KEY 分区。

1. RANGE 分区
   RANGE 分区根据列值的范围将数据划分到不同的分区中。

CREATE TABLE table_name (
    column1 datatype,
    column2 datatype,
    ...
)
PARTITION BY RANGE (column_or_expression) (
    PARTITION partition_name1 VALUES LESS THAN (value1),
    PARTITION partition_name2 VALUES LESS THAN (value2),
    ...
);
示例：

sql
CREATE TABLE sales (
    id INT,
    amount DECIMAL(10, 2),
    sale_date DATE
)
PARTITION BY RANGE (YEAR(sale_date)) (
    PARTITION p0 VALUES LESS THAN (2000),
    PARTITION p1 VALUES LESS THAN (2005),
    PARTITION p2 VALUES LESS THAN (2010),
    PARTITION p3 VALUES LESS THAN (2015),
    PARTITION p4 VALUES LESS THAN MAXVALUE
);

2. LIST 分区
   LIST 分区根据列值的列表将数据划分到不同的分区中。

sql
CREATE TABLE table_name (
    column1 datatype,
    column2 datatype,
    ...
)
PARTITION BY LIST (column_or_expression) (
    PARTITION partition_name1 VALUES IN (value1, value2, ...),
    PARTITION partition_name2 VALUES IN (value3, value4, ...),
    ...
);
示例：

sql
CREATE TABLE customers (
    id INT,
    name VARCHAR(50),
    region VARCHAR(20)
)
PARTITION BY LIST (region) (
    PARTITION pNorth VALUES IN ('North', 'Northeast'),
    PARTITION pSouth VALUES IN ('South', 'Southeast'),
    PARTITION pEast VALUES IN ('East'),
    PARTITION pWest VALUES IN ('West'),
    PARTITION pOther VALUES IN ('Unknown')
);

3. HASH 分区
   HASH 分区根据列值的哈希值将数据划分到不同的分区中。

sql
CREATE TABLE table_name (
    column1 datatype,
    column2 datatype,
    ...
)
PARTITION BY HASH (column_or_expression)
PARTITIONS number_of_partitions;
示例：

sql
CREATE TABLE employees (
    id INT,
    name VARCHAR(50),
    department VARCHAR(50)
)
PARTITION BY HASH (id)
PARTITIONS 4;

4. KEY 分区
   KEY 分区类似于 HASH 分区，但 MySQL 会自动管理分区键。

CREATE TABLE table_name (
    column1 datatype,
    column2 datatype,
    ...
)
PARTITION BY KEY (column_or_expression)
PARTITIONS number_of_partitions;
示例：

sql
CREATE TABLE orders (
    order_id INT,
    customer_id INT,
    order_date DATE
)
PARTITION BY KEY (order_id)
PARTITIONS 4;

5.Linux用过哪些版本系统？做过哪些优化配置？

答：

echo "——>>> 关闭防火墙与SELinux <<<——"
sleep 3
systemctl stop firewalld
systemctl disable firewalld &> /dev/null
setenforce 0
sed -i '/SELINUX/{s/enforcing/disabled/}' /etc/selinux/config

echo "——>>> 创建阿里仓库 <<<——"
sleep 3
rm -rf /etc/yum.repos.d/*
curl -o /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-7.repo 
yum -y install wget
wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo  


echo "——>>> 设置时区并同步时间 <<<——"
sleep 3
timedatectl set-timezone Asia/Shanghai
yum -y install chrony
systemctl start chronyd
systemctl enable chronyd


echo "——>>> 设置系统最大打开文件数 <<<——"
sleep 3
if ! grep "* soft nofile 65535" /etc/security/limits.conf &>/dev/null; then
cat >> /etc/security/limits.conf << EOF
* soft nofile 65535   #软限制
* hard nofile 65535   #硬限制
EOF
fi

echo "——>>> 系统内核优化 <<<——"
sleep 3
cat >> /etc/sysctl.conf << EOF
net.ipv4.tcp_syncookies = 1             #防范SYN洪水攻击，0为关闭
net.ipv4.tcp_max_tw_buckets = 20480     #此项参数可以控制TIME_WAIT套接字的最大数量，避免Squid服务器被大量的TIME_WAIT套接字拖死
net.ipv4.tcp_max_syn_backlog = 20480    #表示SYN队列的长度，默认为1024，加大队列长度为8192，可以容纳更多等待连接的网络连接数
net.core.netdev_max_backlog = 262144    #每个网络接口 接受数据包的速率比内核处理这些包的速率快时，允许发送到队列的数据包的最大数目
net.ipv4.tcp_fin_timeout = 20           #FIN-WAIT-2状态的超时时间，避免内核崩溃
EOF

echo "——>>> 减少SWAP使用 <<<——"
sleep 3
echo "0" > /proc/sys/vm/swappiness

echo "——>>> 安装系统性能分析工具及其他 <<<——"
sleep 3
yum install -y gcc make autoconf vim sysstat net-tools iostat  lrzsz

6、JWT验证包含哪些部分？

答：JWT本身由三个部分组成，这些部分通过点（.）分隔，并且每个部分都是Base64编码的：

头部（Header）：包含了令牌的元数据，如令牌类型（type）和所使用的算法（alg）。这些信息用于指示如何解析和验证后续的令牌内容。
载荷（Payload）：包含了有关用户或其他数据的声明，如用户ID、用户名、权限等。这部分是JWT的核心数据部分，用于在各方之间传递用户信息和相关声明。
签名（Signature）：用于验证JWT的真实性，确保JWT在传输过程中没有被篡改。签名是通过将头部和载荷与一个密钥（Secret）结合，并使用头部中指定的签名算法生成的。

7、一个HttpWebApi请求流程？

答：请求首先进入中间件管道，按注册顺序执行，然后路由系统将请求导向对应的控制器Action。

• （1）. 入口：中间件管道（Middleware Pipeline）
  请求首先进入中间件管道，中间件按 Program.cs 中注册的顺序依次执行。典型的中间件顺序如下：

var app = builder.Build();

// 请求首先经过这些中间件：
app.UseHttpsRedirection();    // 强制 HTTPS
app.UseRouting();             // 路由解析
app.UseAuthentication();      // 身份认证（验证权限）
app.UseAuthorization();       // 权限（授权）
app.MapControllers();         // 映射控制器终结点
app.Run();

（2）、路由匹配
当请求到达 UseRouting() 中间件时，系统会：

解析 URL 路径和 HTTP 方法（GET/POST 等）。

根据 [Route] 属性和 [HttpGet]、[HttpPost] 等特性匹配对应的控制器（Controller）和动作方法（Action）。

（3）、控制器和动作方法
路由匹配成功后，请求会进入目标控制器的具体 Action 方法。

中间件是第一个入口：所有请求必须经过中间件管道。

路由决定最终目的地：UseRouting() 负责将请求分发到对应的 Controller 和 Action。

控制器 Action 是业务逻辑起点：这里是开发者编写的主要处理代码。

8、介绍一下C# 堆栈 队列？

答：（1）堆栈是一种特殊的线性表，其操作被限制在表的一端进行，这一端被称为栈顶（Top），另一端则被称为栈底（Bottom）。堆栈遵循后进先出（LIFO，Last In First Out）的原则，即最后插入的元素最先被移除。
（2）队列是一种特殊的线性表，它只允许在表的前端（Front）进行删除操作，而在表的后端（Rear）进行插入操作。队列遵循先进先出（FIFO，First In First Out）的原则，即先插入的元素最先被移除。

9、NET如何实现限流？

答：

10、KeepAlive作用？

答：虚拟IP通常与负载均衡和高可用性解决方案相关联，如Keepalived等。在Nginx和Keepalived的组合中，Keepalived通过VRRP（虚拟路由冗余协议）为Nginx提供了高可用性保障。它能够实时监控Nginx服务的健康状态，并在主服务器出现故障时迅速将VIP切换到备服务器上，确保服务的连续性和不间断访问。虚拟IP主要用于故障转移和负载均衡的流量分发，而不是直接增加带宽。

11、.NET中实现定时任务方式有哪些？

答：quartz 、Hangfire

12、NET中实现分布式锁？

答：在分布式系统中，实现分布式锁是一项常见的需求，用于协调多个节点对共享资源的访问。下面是一个使用 .NET 和 Redis 实现的简单分布式锁示例。我们将使用 StackExchange.Redis 库来与 Redis 进行交互。

using StackExchange.Redis;
using System;
using System.Threading;
using System.Threading.Tasks;

public class RedisDistributedLock
{
    private readonly ConnectionMultiplexer _redis;
    private readonly IDatabase _db;
    private readonly string _lockKey;
    private readonly TimeSpan _lockExpiration;

    public RedisDistributedLock(string redisConnectionString, string lockKey, TimeSpan lockExpiration)
    {
        _redis = ConnectionMultiplexer.Connect(redisConnectionString);
        _db = _redis.GetDatabase();
        _lockKey = lockKey;
        _lockExpiration = lockExpiration;
    }

    public async Task<bool> TryAcquireLockAsync(CancellationToken cancellationToken = default)
    {
        var lockValue = Guid.NewGuid().ToString();
        var acquireTask = _db.StringSetAsync(_lockKey, lockValue, _lockExpiration, When.NotExists, CommandFlags.FireAndForget);

        if (await Task.WhenAny(acquireTask, Task.Delay(TimeSpan.FromMilliseconds(100), cancellationToken)) == acquireTask)
        {
            if (await acquireTask)
            {
                // Successfully acquired the lock
                _currentLockValue = lockValue;
                return true;
            }
        }

        // Failed to acquire the lock
        return false;
    }

    private string _currentLockValue;

    public async Task ReleaseLockAsync()
    {
        if (_currentLockValue != null)
        {
            var luaScript = @"
                if redis.call('get', KEYS[1]) == ARGV[1] then
                    return redis.call('del', KEYS[1])
                else
                    return 0
                end
            ";

            var result = await _db.ScriptEvaluateAsync(luaScript, new[] { _lockKey }, new[] { _currentLockValue });

            if ((long)result == 1)
            {
                // Lock released successfully
                _currentLockValue = null;
            }
            else
            {
                // Lock was already released or never acquired by this instance
                // Handle appropriately (e.g., log a warning)
            }
        }
    }

    public void Dispose()
    {
        _redis.Close();
    }
}

// Usage example:
public class Program
{
    public static async Task Main(string[] args)
    {
        var redisConnectionString = "localhost:6379"; // Replace with your Redis connection string
        var lockKey = "my-distributed-lock";
        var lockExpiration = TimeSpan.FromSeconds(30);

        using var lockManager = new RedisDistributedLock(redisConnectionString, lockKey, lockExpiration);

        if (await lockManager.TryAcquireLockAsync())
        {
            try
            {
                // Critical section of code
                Console.WriteLine("Lock acquired. Executing critical section.");
                await Task.Delay(5000); // Simulate some work
            }
            finally
            {
                await lockManager.ReleaseLockAsync();
                Console.WriteLine("Lock released.");
            }
        }
        else
        {
            Console.WriteLine("Failed to acquire lock.");
        }
    }
}

（1）RedisDistributedLock 类：
构造函数接受 Redis 连接字符串、锁键和锁过期时间。
TryAcquireLockAsync 方法尝试获取锁。如果成功，它将存储一个唯一的锁值，并返回 true。
ReleaseLockAsync 方法使用 Lua 脚本来安全地释放锁，确保只有持有锁的实例才能释放它。
Dispose 方法用于释放 Redis 连接。

（2）使用示例：
创建一个 RedisDistributedLock 实例。
尝试获取锁。如果成功，执行临界区代码，然后释放锁。
如果获取锁失败，则打印失败消息。
这个示例提供了一个基本的分布式锁实现，但在生产环境中，你可能需要考虑更多的细节，比如锁续期、异常处理和日志记录。

13、SOLID原则的实际应用场景

答：
SOLID原则是软件开发中的一组至关重要的设计原则，它们旨在提升代码的可维护性、可扩展性以及整体管理效率。这些原则在C#开发中也有广泛的应用。以下是对SOLID原则的详细介绍、应用场景以及代码实例：

• SOLID原则介绍

  • 单一职责原则（Single Responsibility Principle, SRP）
    定义：一个类应该只有一个引起它变化的原因，或者说一个类应该只有一个职责。
    应用：通过将类的职责明确划分，确保每个类只负责一个功能或一组相关的功能。这样有助于降低类的复杂度，提高代码的可读性和可维护性。
  • 开闭原则（Open/Closed Principle, OCP）
    定义：软件实体（类、模块、函数等）应该对扩展开放，对修改封闭。
    应用：当需要添加新功能时，可以通过创建新的类或方法来实现，而不需要修改现有的代码。这通常通过使用抽象、接口和多态等技术来实现。
  • 里氏替换原则（Liskov Substitution Principle, LSP）
    定义：子类可以替换其父类并出现在父类能够出现的任何地方，而不会导致程序出错。
    应用：确保子类在继承父类时，不会破坏父类的行为。这有助于保持代码的稳定性和可靠性。
  • 接口隔离原则（Interface Segregation Principle, ISP）
    定义：不应该强迫客户端依赖于它们不使用的方法；应该将大的接口拆分成更小的、更具体的接口。
    应用：通过定义多个小接口来代替一个大接口，确保客户端只需要依赖它们实际需要的方法。这有助于降低接口的复杂度，提高代码的可读性和可维护性。
  • 依赖倒置原则（Dependency Inversion Principle, DIP）
    定义：高层模块不应该依赖于低层模块，二者都应该依赖于抽象；抽象不应该依赖于细节，细节应该依赖于抽象。
    应用：通过接口和抽象类等技术，实现高层模块和低层模块之间的解耦。这样有助于降低模块之间的耦合度，提高代码的可重用性和可扩展性。

• 应用场景

  • 单一职责原则：适用于需要将复杂功能拆分为多个简单功能的场景，如用户管理系统中，将用户数据的管理与用户通知的发送职责分别拆分为两个独立的类。
  • 开闭原则：适用于需要频繁添加新功能的场景，如报告生成系统中，通过定义抽象类和接口，轻松扩展系统以支持新的报告格式。
  • 里氏替换原则：适用于子类需要继承父类但又不完全遵循父类行为的场景，如鸟类中有些能飞，有些不能飞，可以通过定义不同的接口或抽象类来满足功能需求。
  • 接口隔离原则：适用于需要将大接口拆分为多个小接口的场景，如多功能打印机只需要实现打印接口，而不需要实现其他不相关的接口。
  • 依赖倒置原则：适用于高层模块和低层模块之间需要解耦的场景，如业务逻辑层和数据访问层之间通过接口进行交互，降低模块之间的耦合度。

• 代码实例
  以下是每个原则在C#中的代码实例：

  • 单一职责原则

csharp
public class OrderProcessor
{
    public void ProcessOrder(Order order)
    {
        // 处理订单逻辑
    }
}
 
public class OrderPrinter
{
    public void PrintOrder(Order order)
    {
        // 打印订单逻辑
    }
}

在这个例子中，OrderProcessor类只负责处理订单，而OrderPrinter类只负责打印订单。

• 开闭原则

csharp
public interface IShape
{
    double CalculateArea();
}
 
public class Circle : IShape
{
    public double Radius { get; set; }
    public double CalculateArea()
    {
        return Math.PI * Radius * Radius;
    }
}
 
public class Square : IShape
{
    public double Width { get; set; }
    public double Height { get; set; }
    public double CalculateArea()
    {
        return Width * Height;
    }
}
 
public class AreaCalculator
{
    public double CalculateArea(IShape shape)
    {
        return shape.CalculateArea();
    }
}

在这个例子中，通过定义IShape接口和具体的实现类（Circle和Square），可以轻松扩展系统以支持新的形状。

• 里氏替换原则

csharp
public class Bird
{
    public virtual void Fly()
    {
        // 鸟类的飞行行为
    }
}
 
public class Sparrow : Bird
{
    public override void Fly()
    {
        // 麻雀的飞行行为
    }
}
 
public class Ostrich : Bird
{
    // 鸵鸟不会飞，但可以通过重写Fly方法来实现特定的行为（如奔跑）
    public override void Fly()
    {
        throw new NotSupportedException("鸵鸟不能飞");
    }
}

在这个例子中，虽然Ostrich类继承了Bird类，但它重写了Fly方法来实现鸵鸟的奔跑行为。这符合里氏替换原则，因为Ostrich类仍然可以被视为一个Bird类的对象（尽管它的行为有所不同）。然而，更好的做法是为飞行和非飞行鸟类定义不同的接口或抽象类。

• 接口隔离原则

csharp
public interface IPrinter
{
    void Print();
}
 
public interface IFax
{
    void Fax();
}
 
public class MultiFunctionMachine : IPrinter, IFax
{
    public void Print()
    {
        // 打印实现
    }
 
    public void Fax()
    {
        // 传真实现
    }
}
 
public class Printer : IPrinter
{
    public void Print()
    {
        // 打印实现
    }
}

在这个例子中，Printer类只实现了与打印相关的接口，而MultiFunctionMachine类同时实现了打印和传真接口。这符合接口隔离原则，因为每个类只实现了它需要的接口。

• 依赖倒置原则

csharp
public interface IDatabase
{
    void SaveData();
}
 
public class SQLServerDatabase : IDatabase
{
    public void SaveData()
    {
        // SQL Server 数据库实现
    }
}
 
public class BusinessLogic
{
    private readonly IDatabase _database;
 
    public BusinessLogic(IDatabase database)
    {
        _database = database;
    }
 
    public void ProcessData()
    {
        _database.SaveData();
    }
}

在这个例子中，BusinessLogic类依赖于IDatabase接口，而不是具体的SQLServerDatabase类。这有助于降低模块之间的耦合度，并提高代码的可重用性和可扩展性。当需要更换数据库实现时，只需提供一个新的IDatabase实现类即可。

综上所述，SOLID原则是软件开发中的重要设计原则，它们在C#开发中有着广泛的应用。通过遵循这些原则，可以编写出更加高效、可维护和可扩展的代码。

三、某科技公司三面试题总结

1、mysql 适不适合部署在docker中，为什么？哪些应用适合部署在docker中呢？

答：Docker适合无状态应用，而MySQL是有状态的，数据持久化可能是个问题。虽然可以通过挂载卷解决，但万一容器崩溃或迁移，数据管理可能会有麻烦。另外，性能方面，尤其是I/O，容器可能会有开销，对于高负载的数据库可能不够。网络配置和备份恢复也需要额外注意，比如端口映射和备份策略。

MySQL 部署在 Docker 中的优缺点

• 优点：

  • 快速部署和隔离性
    Docker 的镜像机制可快速拉起 MySQL 实例，适合开发测试环境的快速搭建，且容器间资源隔离。

  • 环境一致性
    通过 Dockerfile 可固化 MySQL 的配置和依赖，避免开发、测试、生产环境差异。

  • 轻量级扩展
    在非生产场景下，可通过 Docker Compose 或 Kubernetes 快速扩展多个 MySQL 实例用于实验。

• 缺点：

  • 数据持久化风险
    MySQL 是有状态服务，默认容器停止后数据可能丢失（需显式挂载 Volume 并配置持久化存储）。

  • 性能瓶颈
    容器化带来的虚拟化层可能导致 I/O 性能下降（尤其是高并发写入场景），影响生产级数据库性能。

  • 运维复杂性

    • 容器调度可能导致 IP 变化，需配合服务发现机制。

    • 备份、恢复、监控等操作需额外适配容器环境。

    • 容器崩溃或重启可能破坏数据库一致性（未合理配置持久化和恢复策略时）。

2、MySql中 Delete 删除数据后数据是否还存在？

答：在 MySQL 中，使用 DELETE 语句删除数据后，数据是否仍然存在取决于多个因素，包括存储引擎、事务隔离级别、数据恢复机制等。以下是详细分析：

• 1. 用户视角：数据是否可见？

  • 立即不可见：执行 DELETE 后，数据会从当前事务的可见范围内移除，用户无法通过常规查询访问这些数据。

  • 事务未提交时的特殊场景：
    如果删除操作在事务中但未提交 (ROLLBACK)，其他事务仍可能看到这些数据（取决于隔离级别）。
    如果删除操作已提交 (COMMIT)，数据对后续操作不可见。

• 2. 物理存储视角：数据是否被彻底擦除？

  • (1) InnoDB 存储引擎

    • 标记删除，延迟清理：

      • InnoDB 使用 MVCC（多版本并发控制）机制，删除操作会标记数据为“已删除”，但实际数据仍保留在存储页中。

      • 后台的 purge 线程会异步清理这些已标记删除的数据，释放空间（时间取决于系统负载和配置）。

      • 物理删除的延迟性意味着数据可能在磁盘上残留一段时间，直到被新数据覆盖。

    • 数据恢复的可能性：

      • 在 purge 线程清理前，专业工具（如 undrop-for-innodb）可能从磁盘恢复数据。

      • 清理后，数据理论上不可恢复，但若磁盘未被覆盖，仍可能通过物理文件恢复工具找回。

  • (2) MyISAM 存储引擎

    • 立即释放空间：

      • DELETE 操作会直接删除数据并释放磁盘空间，但表文件（.MYD）的大小不会立即缩减。
      • 执行 OPTIMIZE TABLE 会重组表文件，释放未使用的空间。

    • 恢复难度更高：

      • 由于 MyISAM 无事务日志，删除后数据恢复需依赖磁盘文件残留，成功率较低。
• 3. 数据恢复的关键场景
  • (1) Binlog 与备份

    • Binlog 记录：

      • 若启用了二进制日志（binlog），DELETE 操作会被记录，可通过 binlog 恢复到删除前的状态。

    • 示例恢复命令：

  mysqlbinlog --start-position=1234 binlog.000001 | mysql -u root -p
  

  • 备份恢复：

    • 若有全量备份或快照，可直接从备份恢复被删除的数据。

  • (2) 未提交的事务

    • 事务回滚：
      • 如果删除操作在未提交的事务中，执行 ROLLBACK 可撤销删除，数据完全恢复。

3、DNS调优有哪些方式，CDN调优，net开发中 http调优方式有哪些？？

答：

• 1、DNS调优
  （1）、使用快速且可靠的DNS解析服务：选择一个快速响应并且可靠的服务商，如Google Public DNS或Cloudflare DNS。
  （2）、启用Anycast（加速器）技术：通过Anycast可以让用户连接到最近的DNS服务器，减少查询时间。
  （3）、增加TTL（生存时间）值：适当增加DNS记录的TTL可以减少重复查询次数，但需注意更新时可能需要更长时间才能生效。
  （4）、配置CNAME Flattening：对于指向外部资源的子域名，使用CNAME Flattening可以避免潜在的DNS查询问题。
  （5）、利用CDN的DNS服务：许多CDN提供商也提供自己的DNS服务，这些服务通常会集成智能路由功能，帮助用户更快地访问到最优的CDN节点

• 2、CDN调优
  （1）选择合适的CDN提供商：不同的CDN提供商可能在不同地理区域有不同的表现。选择一个覆盖目标用户群体广泛的CDN提供商非常重要。
  （2）智能DNS解析：利用智能DNS服务，根据用户的地理位置、网络状况等因素动态选择最优的CDN节点，以减少延迟并提高加载速度。
  （3）缓存策略优化：
  设置合理的TTL(Time to Live)：根据资源类型调整缓存的有效期。静态资源可以设置较长的TTL，而动态内容则需要较短的TTL或禁用缓存。
  版本控制：通过文件名或查询参数实现版本控制，确保当源站资源更新时，用户能够获取最新版本。
  （4）压缩与最小化：启用GZIP或Brotli等压缩技术减少传输的数据量；同时对HTML、CSS和JavaScript进行最小化处理，去除不必要的空格和注释。
  （5）使用HTTP/2：如果可能，使用支持HTTP/2协议的CDN，它提供了多路复用、头部压缩等功能，有助于加速页面加载。
  （6）SSL/TLS优化：对于HTTPS流量，优化SSL握手过程，比如使用会话恢复、OCSP装订等技术减少TLS连接建立的时间。
  （7）负载均衡：确保CDN内部有良好的负载均衡机制，以便在高流量情况下仍能保证服务的稳定性和响应速度。
  （8）监控与分析：定期检查CDN的性能指标，如命中率、响应时间等，并基于这些数据做出相应调整。利用CDN提供的日志和分析工具来识别潜在问题。

• 2、Http调优
  （1）使用合适的HTTP方法：根据实际需求选择GET、POST等方法。例如，获取数据时优先使用GET方法，因为它比POST更简单且资源消耗较少。
  （2）启用压缩：通过启用GZIP或Deflate等压缩技术减少传输的数据量，从而加快响应速度和减少带宽使用。
  （3）优化缓存策略：合理设置Cache-Control、ETag等HTTP头来利用客户端和中间代理服务器的缓存机制，减少重复请求带来的负载。
  （4）连接管理：使用HttpClientFactory管理HttpClient实例的生命周期，避免为每个请求创建新的HttpClient实例导致Socket耗尽问题。
  （5）异步编程模型：尽可能使用async/await模式进行异步操作，提高应用的响应性和可伸缩性，尤其是在I/O密集型任务中。
  （6）超时设置：适当配置请求的超时时间，既不过于保守也不过于激进，以平衡用户体验与系统资源的有效利用。
  （7）减少请求次数：合并多个小资源到一个文件中（如CSS Sprites、合并JavaScript文件），减少HTTP请求数量。
  （8）使用CDN：对于静态资源，考虑使用内容分发网络(Content Delivery Network, CDN)加速访问，降低延迟。
  （9）HTTPS优化：如果使用HTTPS，确保SSL/TLS配置是最优的，比如选择高效的安全协议版本和加密套件。

4、多级缓存优化思路？

答：1、本地内存缓存（使用MemoryCache作为第一级缓存，适合存储高频访问的小数据，访问速度快。）；
2、分布式缓存（使用IDistributedCache作为第二级缓存，适合跨多个应用实例共享数据，常用Redis。）；
3、数据库缓存（将数据库查询结果缓存到内存或分布式缓存中，减少数据库访问压力）
4. 缓存过期策略（每次访问后重置过期时间。）
5. 缓存穿透、击穿、雪崩处理
6. 缓存预热（系统启动时预先加载热点数据，减少冷启动时的数据库压力。）
7. 通过监控缓存命中率和性能，动态调整缓存策略。
8. 使用第三方缓存库（如LazyCache或CacheManager，简化缓存管理。）

6、分布式锁（redis）实现的底层原理？

答：Redis分布式锁的底层原理主要基于Redis的单线程特性和原子操作，确保在分布式环境下同一时间只有一个客户端能获取锁。

7、.net开发中使用到的锁有哪些？

答：在.NET开发中，常用的锁机制包括以下几种：
（1）、lock 关键字
lock 是.NET中最简单的锁机制，基于Monitor类实现，用于确保同一时间只有一个线程能访问临界区。

private readonly object _lockObject = new object();

public void DoWork()
{
    lock (_lockObject)
    {
        // 临界区代码
    }
}

（2）、Monitor 类
Monitor 提供了更细粒度的控制，支持Enter、Exit、TryEnter等方法。

private readonly object _lockObject = new object();

public void DoWork()
{
    Monitor.Enter(_lockObject);
    try
    {
        // 临界区代码
    }
    finally
    {
        Monitor.Exit(_lockObject);
    }
}

（3）、Mutex 类
Mutex 是系统级别的锁，可用于跨进程同步。

private static Mutex _mutex = new Mutex();

public void DoWork()
{
    _mutex.WaitOne();
    try
    {
        // 临界区代码
    }
    finally
    {
        _mutex.ReleaseMutex();
    }
}

（4）、Semaphore 和 SemaphoreSlim 类
Semaphore 用于控制多个线程同时访问资源，SemaphoreSlim 是其轻量版。

private static SemaphoreSlim _semaphore = new SemaphoreSlim(3); // 允许3个线程同时访问

public async Task DoWorkAsync()
{
    await _semaphore.WaitAsync();
    try
    {
        // 临界区代码
    }
    finally
    {
        _semaphore.Release();
    }
}

。。

5、.net 开发中常见的负载均衡算法，过滤算法，限流算法，调度算法，存储算法有哪些列举一下？

答：

• 1、负载均衡算法
  （1）轮询（Round Robin）
  实现方式：按顺序将请求依次分配给服务器列表中的下一台服务器，循环处理。
  适用场景：服务器性能相近时，简单易实现。
  （2）加权轮询（Weighted Round Robin）
  实现方式：在传统轮询的基础上，给每个服务器分配一个权重值，权重值越大的服务器处理的请求越多。
  适用场景：服务器性能存在差异时，可以更好地利用资源。
  （3）最少连接（Least Connections）
  实现方式：实时监控每台服务器的连接数，将新请求分配给连接最少的服务器。
  适用场景：长连接场景下，防止某些服务器过载。
  （4）、最少时间（Shortest Response Time）
  实现方式：考虑服务器当前的连接数和响应时间，将新请求分配给响应时间最短的服务器。
  适用场景：对响应时间敏感的应用场景。
  （5）、原地址哈希（Source IP Hash）
  实现方式：通过对用户IP地址进行哈希计算，将相同IP地址的请求分配给固定的服务器。
  适用场景：需要会话一致性的应用，如登录状态维护。

• 2、过滤算法

• 3、限流算法
  （1）固定窗口算法（Fixed Window Algorithm）
  实现方式：将时间划分为固定大小的窗口，在每个窗口内限制请求的数量。
  适用场景：简单的限流需求，对精度要求不高。

（2）滑动窗口算法（Sliding Window Algorithm）
实现方式：将时间划分为滑动的窗口，根据窗口内请求的数量来控制并发访问。
适用场景：需要更精确的限流控制，避免突发流量。

（3）令牌桶算法（Token Bucket Algorithm）
实现方式：使用令牌桶来控制请求的速率，每个请求需要消耗一个令牌。
适用场景：平滑突发流量，允许一定程度的请求积压。

• 4 、调度算法
  （1）、简单时间间隔触发
  实现方式：按照固定的时间间隔执行任务。
  适用场景：定时任务，如定期清理缓存、生成报表等。
  （2）、Cron表达式触发
  实现方式：使用Cron表达式定义任务的执行时间和周期。
  适用场景：复杂的定时任务需求，如每天凌晨执行数据备份等。
• 4、存储算法

6、net开发中浅拷贝和深拷贝？

答：浅拷贝和深拷贝的区别在于复制对象时是否复制引用类型字段所指向的对象。浅拷贝只复制值类型和引用类型的引用，而深拷贝会递归复制所有引用类型指向的对象。
以下是它们的实现代码示例：

• （1）、浅拷贝（Shallow Copy）
  原理：复制对象的值类型字段，但引用类型字段仅复制引用（指向同一内存地址）。
  实现方式：

使用 MemberwiseClone 方法（实现 ICloneable 接口）。

手动赋值属性（仅复制引用类型字段的引用）。

代码示例：

public class Person : ICloneable
{
    public string Name { get; set; }
    public Address Address { get; set; } // 引用类型

    // 浅拷贝实现
    public object Clone()
    {
        return this.MemberwiseClone(); // 仅复制值类型和引用类型的引用
    }
}

public class Address
{
    public string City { get; set; }
}

// 使用示例
var person1 = new Person 
{ 
    Name = "Alice", 
    Address = new Address { City = "New York" } 
};
var person2 = (Person)person1.Clone();

// 修改 person2 的引用类型字段会影响 person1
person2.Address.City = "London";
Console.WriteLine(person1.Address.City); // 输出 "London"

• （2）、深拷贝（Deep Copy）
  原理：递归复制对象及其所有引用类型字段指向的对象，生成完全独立的副本。
  实现方式：

手动深拷贝：递归复制所有字段。

序列化/反序列化：利用序列化工具（如 JSON、BinaryFormatter）。

AutoMapper：通过配置映射规则实现深拷贝。

1. 手动深拷贝（推荐）

public class Person : ICloneable
{
    public string Name { get; set; }
    public Address Address { get; set; }

    // 手动实现深拷贝
    public object Clone()
    {
        var clone = (Person)MemberwiseClone();
        clone.Address = (Address)Address.Clone(); // 递归复制引用类型字段
        return clone;
    }
}

public class Address : ICloneable
{
    public string City { get; set; }

    public object Clone()
    {
        return MemberwiseClone();
    }
}

// 使用示例
var person1 = new Person 
{ 
    Name = "Alice", 
    Address = new Address { City = "New York" } 
};
var person2 = (Person)person1.Clone();

person2.Address.City = "London";
Console.WriteLine(person1.Address.City); // 输出 "New York"

四、某面试公司四

1、同样的域名不同的端口 存在跨域问题吗？ vue前段如何解决跨域问题？

答：同样的域名但不同的端口通常被认为是不同的源（origin），因此会存在跨域资源共享（CORS）问题。跨域策略主要是基于同源策略（Same-Origin Policy）来实施的，同源策略要求协议、域名和端口三者完全相同才被视为同源。

在 Vue 客户端应用中，跨域问题通常是由于前端和后端服务部署在不同的域名或端口上，导致浏览器的同源策略（Same-Origin Policy）阻止请求。除了在后端配置跨域解决方法之外,还有以下几种解决办法：
（1）使用代理服务器
在开发环境中，Vue CLI 提供了一个简单的代理解决方案。你可以在 vue.config.js 文件中配置开发服务器的代理：

module.exports = {
  devServer: {
    proxy: {
      '/api': {
        target: 'http://localhost:3000', // 后端服务的地址
        changeOrigin: true,
        pathRewrite: { '^/api': '' }, // 重写路径
      },
    },
  },
};

（2）、JSONP（仅支持 GET 请求）
JSONP 是一种只支持 GET 请求的跨域解决方案。它通过在

（3）、对于需要实时通信的应用，可以使用 WebSocket。WebSocket 允许在客户端和服务器之间建立一个持久的连接，并且不受同源策略的限制。
（4）、使用第三方服务（如 Nginx 反向代理）
在生产环境中，你可以使用 Nginx 等反向代理服务器来转发请求。

在 Nginx 配置文件中添加：

server {
    listen 80;

    location / {
        proxy_pass http://localhost:8080; # Vue 应用
    }

    location /api/ {
        proxy_pass http://localhost:3000/api/; # 后端 API
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

2、你在.net开发中使用到过哪些限流算法，代码？

答：NET开发中，需要处理高并发情况下的流量控制。限流算法是在高负载下保护系统稳定的重要手段。
在 .NET 中，常用的限流算法主要有以下几种，以下是它们的原理说明和代码实现示例：

• （1）. 固定窗口计数器算法（Fixed Window）
  原理：将时间划分为固定窗口（如 1 秒），每个窗口内允许固定数量的请求。
  优点：实现简单。
  缺点：存在窗口临界点突发流量问题。

public class FixedWindowRateLimiter
{
    private readonly int _maxRequests;
    private readonly TimeSpan _windowDuration;
    private int _currentCount;
    private DateTime _windowStartTime;

    public FixedWindowRateLimiter(int maxRequests, TimeSpan windowDuration)
    {
        _maxRequests = maxRequests;
        _windowDuration = windowDuration;
        _windowStartTime = DateTime.UtcNow;
    }

    public bool TryAcquire()
    {
        var now = DateTime.UtcNow;
        if (now - _windowStartTime >= _windowDuration)
        {
            Interlocked.Exchange(ref _currentCount, 0);
            _windowStartTime = now;
        }

        if (Interlocked.Increment(ref _currentCount) > _maxRequests)
        {
            Interlocked.Decrement(ref _currentCount);
            return false;
        }
        return true;
    }
}

// 使用示例
var limiter = new FixedWindowRateLimiter(100, TimeSpan.FromSeconds(1));
if (limiter.TryAcquire()) 
{
    // 处理请求
}

• （2）. 滑动窗口算法（Sliding Window）
  原理：将时间划分为更细粒度的子窗口，统计最近时间窗口内的请求总数。
  优点：比固定窗口更平滑，减少临界问题。

public class SlidingWindowRateLimiter
{
    private readonly int _maxRequests;
    private readonly TimeSpan _windowDuration;
    private readonly ConcurrentQueue<DateTime> _requestTimes;

    public SlidingWindowRateLimiter(int maxRequests, TimeSpan windowDuration)
    {
        _maxRequests = maxRequests;
        _windowDuration = windowDuration;
        _requestTimes = new ConcurrentQueue<DateTime>();
    }

    public bool TryAcquire()
    {
        var now = DateTime.UtcNow;
        // 清理过期请求
        while (_requestTimes.TryPeek(out var timestamp) && now - timestamp > _windowDuration)
        {
            _requestTimes.TryDequeue(out _);
        }

        if (_requestTimes.Count >= _maxRequests)
        {
            return false;
        }

        _requestTimes.Enqueue(now);
        return true;
    }
}

• （3）. 漏桶算法（Leaky Bucket）
  原理：以恒定速率处理请求，超出桶容量的请求被拒绝。
  优点：平滑流量，防止突发压力。

public class LeakyBucketRateLimiter
{
    private readonly int _capacity;//漏桶的容量，表示漏桶最多可以容纳多少请求（或数据）。当达到这个容量时，新的请求将被拒绝。
    private readonly double _leakRatePerMs; // 漏桶每秒漏出的请求数除以1000，转换为每毫秒漏出的请求数。这是漏桶“漏水”的速率。
    private double _currentVolume;//当前漏桶中的请求数量。
    private DateTime _lastLeakTime;//上次“漏水”的时间点。

    public LeakyBucketRateLimiter(int capacity, double leakRatePerSecond)
    {
        _capacity = capacity;
        _leakRatePerMs = leakRatePerSecond / 1000;
        _lastLeakTime = DateTime.UtcNow;
    }

    public bool TryAcquire()
    {
        var now = DateTime.UtcNow;
        var elapsedMs = (now - _lastLeakTime).TotalMilliseconds;
        _currentVolume = Math.Max(0, _currentVolume - elapsedMs * _leakRatePerMs);
        _lastLeakTime = now;

        if (_currentVolume + 1 > _capacity)
        {
            return false;
        }

        _currentVolume++;
        return true;
    }
}

• （4）. 令牌桶算法（Token Bucket）
  原理：以固定速率向桶中添加令牌，请求需获取令牌才能执行。
  优点：允许一定程度的突发流量。

public class TokenBucketRateLimiter
{
    private readonly int _capacity;//令牌桶的容量，即桶中最多可以存放的令牌数量。
    private readonly double _refillRatePerMs; // 每毫秒补充的令牌数。注意，这里实际上存储的是每秒补充的令牌数除以1000的结果，以便按毫秒计算。
    private double _currentTokens;//当前桶中的令牌数量。
    private DateTime _lastRefillTime;//上次补充令牌的时间。

    public TokenBucketRateLimiter(int capacity, double refillRatePerSecond)
    {
        _capacity = capacity;
        _refillRatePerMs = refillRatePerSecond / 1000;
        _lastRefillTime = DateTime.UtcNow;
        _currentTokens = capacity;
    }

    public bool TryAcquire()
    {
        var now = DateTime.UtcNow;
        var elapsedMs = (now - _lastRefillTime).TotalMilliseconds;
        _currentTokens = Math.Min(_capacity, _currentTokens + elapsedMs * _refillRatePerMs);
        _lastRefillTime = now;

        if (_currentTokens >= 1)
        {
            _currentTokens--;
            return true;
        }
        return false;
    }
}

• (5). 并发限流（Semaphore）
  原理：通过信号量限制同时处理的请求数量。

public class SemaphoreRateLimiter
{
    private readonly SemaphoreSlim _semaphore;

    public SemaphoreRateLimiter(int maxConcurrentRequests)
    {
        _semaphore = new SemaphoreSlim(maxConcurrentRequests);
    }

    public async Task<bool> TryAcquireAsync()
    {
        return await _semaphore.WaitAsync(0); // 非阻塞
    }

    public void Release()
    {
        _semaphore.Release();
    }
}

• (6). 分布式限流（基于 Redis）
  适用于微服务场景，使用 Redis 存储全局请求计数：

// 使用 StackExchange.Redis 实现
public class RedisRateLimiter
{
    private readonly IDatabase _redis;
    private readonly string _key;//用于在Redis中存储速率限制信息的键名。
    private readonly int _maxRequests;//在指定的时间窗口内允许的最大请求数。
    private readonly TimeSpan _window;//时间窗口的长度，表示允许的最大请求数的时间范围。

    public RedisRateLimiter(IDatabase redis, string key, int maxRequests, TimeSpan window)
    {
        _redis = redis;
        _key = key;
        _maxRequests = maxRequests;
        _window = window;
    }

    public async Task<bool> TryAcquireAsync()
    {
        var now = DateTime.UtcNow.Ticks;
        var windowStart = now - _window.Ticks;

        // 使用 Redis 的 Sorted Set 记录请求时间戳
        await _redis.SortedSetRemoveRangeByScoreAsync(_key, 0, windowStart);
        var currentCount = await _redis.SortedSetLengthAsync(_key);

        if (currentCount >= _maxRequests)
        {
            return false;
        }

        await _redis.SortedSetAddAsync(_key, now, now);
        await _redis.KeyExpireAsync(_key, _window);
        return true;
    }
}

面试时状态：思考的时候不要嗯嗯嗯出声，心里默默地想几秒；如果一时短路了想不起，就说我想一哈，大家有啥面试时的经验，欢迎评论区留言分享。