React前端+C# WebAPI：为每个用户维护独立currentIndex变量的问题

你的核心问题是WebAPI的无状态特性导致实例变量每次请求重置，static变量全局共享无法隔离用户。下面提供三种针对性解决方案：

方案一：使用ASP.NET Core Session（服务器端会话存储） #

这是最直接的服务器端隔离用户状态的方案，每个用户的会话会维护独立的currentIndex。

1. 先在Program.cs配置Session服务 #

var builder = WebApplication.CreateBuilder(args);

// 添加Session服务，设置超时时间（示例为20分钟）
builder.Services.AddSession(options =>
{
    options.IdleTimeout = TimeSpan.FromMinutes(20);
    options.Cookie.HttpOnly = true;
    options.Cookie.IsEssential = true;
});

builder.Services.AddControllers();

var app = builder.Build();

// Session中间件必须放在路由之前
app.UseSession();

app.MapControllers();

app.Run();

2. 修改控制器代码操作Session #

namespace myProject.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class myController : ControllerBase
    {
        // 假设后端预定义的Letter列表
        private readonly List<Letter> _letterList = new List<Letter>
        {
            // 初始化你的Letter对象
        };

        [HttpGet(Name = "GetStreamLetter")]
        public IActionResult Get()
        {
            // 从Session读取索引，默认值为0
            int currentIndex = HttpContext.Session.GetInt32("CurrentIndex") ?? 0;
            
            currentIndex++;
            
            // 可选：处理索引越界情况，这里示例重置为0
            if (currentIndex >= _letterList.Count)
            {
                currentIndex = 0;
            }
            
            // 将更新后的索引存回Session
            HttpContext.Session.SetInt32("CurrentIndex", currentIndex);
            
            return Ok(_letterList[currentIndex]);
        }

        // 可选：给前端提供重置接口，刷新页面时调用可重置索引
        [HttpPost("ResetIndex")]
        public IActionResult ResetIndex()
        {
            HttpContext.Session.SetInt32("CurrentIndex", 0);
            return Ok();
        }
    }
}

• 每个用户的Session完全独立，不会互相干扰
• 若需要刷新页面就重置索引，让前端在页面加载时调用ResetIndex接口即可

方案二：前端存储+后端配合（轻量无状态实现） #

把状态交给前端维护，后端只负责根据索引返回对应数据，适合不需要服务器端验证的场景。

React前端示例代码 #

// 页面刷新时重置索引（如果需要刷新就重置）
let currentIndex = 0;

// 若需要会话内保留索引（刷新不重置），改用sessionStorage：
// let currentIndex = parseInt(sessionStorage.getItem('currentIndex')) || 0;

const fetchLetter = async () => {
    try {
        const response = await fetch(`/api/myController?index=${currentIndex}`);
        const letter = await response.json();
        
        currentIndex++;
        // 会话保留的话就存到sessionStorage：
        // sessionStorage.setItem('currentIndex', currentIndex.toString());
        
        return letter;
    } catch (error) {
        console.error('请求失败:', error);
    }
};

// 页面加载时重置索引（可选）
useEffect(() => {
    currentIndex = 0;
    // sessionStorage.removeItem('currentIndex');
}, []);

后端控制器修改 #

namespace myProject.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class myController : ControllerBase
    {
        private readonly List<Letter> _letterList = new List<Letter>
        {
            // 初始化Letter列表
        };

        [HttpGet(Name = "GetStreamLetter")]
        public IActionResult Get([FromQuery] int index)
        {
            if (index < 0 || index >= _letterList.Count)
            {
                return BadRequest("无效的索引");
            }
            
            return Ok(_letterList[index]);
        }
    }
}

方案三：JWT令牌携带状态（分布式场景适用） #

如果你的API是分布式部署，Session不适用的话，可以用JWT令牌携带用户的currentIndex，保持无状态特性。

1. Program.cs配置JWT服务 #

builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            ValidIssuer = builder.Configuration["Jwt:Issuer"],
            ValidAudience = builder.Configuration["Jwt:Audience"],
            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(builder.Configuration["Jwt:Key"]))
        };
    });

2. 控制器代码 #

namespace myProject.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class myController : ControllerBase
    {
        private readonly List<Letter> _letterList = new List<Letter>();
        private readonly IConfiguration _configuration;

        public myController(IConfiguration configuration)
        {
            _configuration = configuration;
            // 初始化Letter列表
        }

        [HttpGet(Name = "GetStreamLetter")]
        public IActionResult Get()
        {
            // 从JWT Claims中读取当前索引
            var indexClaim = User.Claims.FirstOrDefault(c => c.Type == "CurrentIndex");
            int currentIndex = indexClaim != null ? int.Parse(indexClaim.Value) : 0;
            
            currentIndex++;
            
            if (currentIndex >= _letterList.Count)
            {
                currentIndex = 0;
            }
            
            // 生成包含新索引的JWT
            var newToken = GenerateJwtToken(currentIndex);
            
            // 返回数据和新令牌
            return Ok(new 
            {
                Letter = _letterList[currentIndex],
                Token = newToken
            });
        }

        private string GenerateJwtToken(int currentIndex)
        {
            var claims = new List<Claim>
            {
                new Claim(ClaimTypes.NameIdentifier, User.FindFirstValue(ClaimTypes.NameIdentifier)),
                new Claim("CurrentIndex", currentIndex.ToString())
            };

            var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["Jwt:Key"]));
            var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);

            var token = new JwtSecurityToken(
                issuer: _configuration["Jwt:Issuer"],
                audience: _configuration["Jwt:Audience"],
                claims: claims,
                expires: DateTime.Now.AddMinutes(30),
                signingCredentials: creds);

            return new JwtSecurityTokenHandler().WriteToken(token);
        }
    }
}

前端每次请求后保存新的JWT，下次请求时放在Authorization头中；若需要刷新页面重置索引，重新获取初始令牌即可。

内容的提问来源于stack exchange，提问作者Bogdan