.NET Core WebAPI中如何从FromRoute/Query/Body获取DepartmentId

Got it, let's work through this problem. You've already nailed extracting DepartmentId from [FromRoute] and [FromQuery] using IHttpContextAccessor, and now the challenge is grabbing it from [FromBody] payloads—where all POST request models inherit from your base Department class—without messing with existing API or business contracts. Here's a solid solution:

Step 1: Cache the Request Body (Critical!) #

ASP.NET Core only lets you read the request body stream once by default. Since MVC will already read it to bind to your action model, we need a middleware to cache the body content first so we can re-read it later.

Create this middleware class:

public class RequestBodyCacheMiddleware
{
    private readonly RequestDelegate _next;

    public RequestBodyCacheMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        // Only cache POST requests (since those are the ones using [FromBody])
        if (context.Request.Method.Equals(HttpMethods.Post, StringComparison.OrdinalIgnoreCase) && 
            context.Request.ContentLength > 0)
        {
            // Enable rewinding so we can read the body multiple times
            context.Request.EnableBuffering();

            // Read the body content and store it in HttpContext.Items
            using var streamReader = new StreamReader(context.Request.Body, leaveOpen: true);
            var cachedBody = await streamReader.ReadToEndAsync();
            context.Items["CachedRequestBody"] = cachedBody;

            // Reset the stream position so MVC can read it again for model binding
            context.Request.Body.Position = 0;
        }

        await _next(context);
    }
}

// Extension method to easily register the middleware
public static class RequestBodyCacheMiddlewareExtensions
{
    public static IApplicationBuilder UseRequestBodyCache(this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<RequestBodyCacheMiddleware>();
    }
}

Register it in your Program.cs before your endpoint/mvc middleware:

var app = builder.Build();

// ... other middleware (UseHttpsRedirection, UseAuthorization, etc.)

app.UseRequestBodyCache(); // Place this BEFORE UseEndpoints/UseMvc

app.UseEndpoints(endpoints =>
{
    endpoints.MapControllers();
});

Step 2: Build a Reusable Extractor for DepartmentId #

Now create an extension method to pull DepartmentId from all three sources—route, query, and cached body:

public static class DepartmentIdExtractor
{
    public static int? GetDepartmentId(this HttpContext context)
    {
        // Check [FromRoute] first
        if (context.Request.RouteValues.TryGetValue("DepartmentId", out var routeVal) && 
            int.TryParse(routeVal?.ToString(), out var routeDeptId))
        {
            return routeDeptId;
        }

        // Then check [FromQuery]
        if (context.Request.Query.TryGetValue("DepartmentId", out var queryVal) && 
            int.TryParse(queryVal, out var queryDeptId))
        {
            return queryDeptId;
        }

        // Finally check [FromBody] using the cached content
        if (context.Request.Method.Equals(HttpMethods.Post, StringComparison.OrdinalIgnoreCase) &&
            context.Items.TryGetValue("CachedRequestBody", out var cachedBodyObj))
        {
            var cachedBody = cachedBodyObj as string;
            if (!string.IsNullOrEmpty(cachedBody))
            {
                try
                {
                    // Since all POST models inherit from Department, we can deserialize directly to the base class
                    var department = JsonSerializer.Deserialize<Department>(cachedBody, new JsonSerializerOptions
                    {
                        PropertyNameCaseInsensitive = true // Handle case mismatches if your API uses camelCase/snakeCase
                    });
                    return department?.DepartmentId;
                }
                catch (JsonException)
                {
                    // Log the error if needed, but don't throw—we don't want to break the API flow
                    return null;
                }
            }
        }

        return null;
    }
}

Step 3: Use It in Your Service/Component #

In any class where you've injected IHttpContextAccessor, call the extension method to get the DepartmentId:

public class YourBusinessService
{
    private readonly IHttpContextAccessor _httpContextAccessor;

    public YourBusinessService(IHttpContextAccessor httpContextAccessor)
    {
        _httpContextAccessor = httpContextAccessor;
    }

    public void ExecuteBusinessLogic()
    {
        var departmentId = _httpContextAccessor.HttpContext?.GetDepartmentId();
        // Use departmentId here without passing it through the call chain
    }
}

Key Notes to Avoid Issues #

• Ensure your base Department class is serializable: it needs a public parameterless constructor (default if you don't define any) and public getters for DepartmentId.
• If your API uses Newtonsoft.Json instead of System.Text.Json, replace JsonSerializer.Deserialize with JsonConvert.DeserializeObject<Department>(cachedBody).
• Don't forget to register IHttpContextAccessor in your DI if you haven't already: builder.Services.AddHttpContextAccessor();
• The middleware only caches POST requests to save resources—no need to cache GET/PUT/DELETE unless you have [FromBody] there too.

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