在ASP.NET Core 3.1中获取中间件数据并在类或控制器中使用

Great question! You absolutely can access the same HttpContext data in controllers and regular classes, and even extend it with custom info like a machine ID. Let's break down the best approaches to do this cleanly:

1. Accessing HttpContext in Controllers #

Controllers in ASP.NET Core have a built-in HttpContext property, so you can directly pull data like RemoteIpAddress without any extra setup:

public class HomeController : Controller
{
    private readonly ILogger<HomeController> _logger;

    public HomeController(ILogger<HomeController> logger)
    {
        _logger = logger;
    }

    public IActionResult Index()
    {
        var remoteIp = HttpContext.Connection.RemoteIpAddress?.ToString();
        var path = HttpContext.Request.Path;
        
        _logger.LogInformation("Request from {RemoteIp} for path {Path}", remoteIp, path);
        return View();
    }
}

2. Injecting HttpContext into Regular Classes #

For non-controller classes (like services or utilities), you'll need to use the IHttpContextAccessor interface. Here's how to set it up:

Step 1: Register IHttpContextAccessor in Program.cs #

First, add this line to your service configuration to make the accessor available for injection:

var builder = WebApplication.CreateBuilder(args);

// Register HttpContext accessor
builder.Services.AddHttpContextAccessor();

// ... rest of your service registrations

Step 2: Inject IHttpContextAccessor into Your Class #

Now you can inject it into any class and access the current request context:

public class MyCustomService
{
    private readonly IHttpContextAccessor _httpContextAccessor;
    private readonly ILogger<MyCustomService> _logger;

    public MyCustomService(IHttpContextAccessor httpContextAccessor, ILogger<MyCustomService> logger)
    {
        _httpContextAccessor = httpContextAccessor;
        _logger = logger;
    }

    public void ProcessRequestData()
    {
        var context = _httpContextAccessor.HttpContext;
        if (context == null)
        {
            // Handle case where no context is available (e.g., background tasks)
            _logger.LogWarning("No HttpContext available");
            return;
        }

        var remoteIp = context.Connection.RemoteIpAddress?.ToString();
        var host = context.Request.Host.Value;
        
        _logger.LogInformation("Processing request from {RemoteIp} on host {Host}", remoteIp, host);
    }
}

3. Creating a Dedicated Request Context Service (Recommended) #

Instead of accessing HttpContext directly everywhere, it's better to create a custom service that encapsulates all the request-specific data you need—including your machine ID. This keeps your code clean and makes it easy to add custom context info.

Step 1: Create a RequestContext Class #

Define a class to hold all the data you want to share:

public class RequestContext
{
    public string RemoteIpAddress { get; set; }
    public string RequestPath { get; set; }
    public string Host { get; set; }
    public string MachineId { get; set; } // Your custom machine ID
}

Step 2: Create a Service to Provide RequestContext #

This service will use IHttpContextAccessor to extract request data and add your machine ID:

public interface IRequestContextProvider
{
    RequestContext GetCurrentContext();
}

public class RequestContextProvider : IRequestContextProvider
{
    private readonly IHttpContextAccessor _httpContextAccessor;
    private readonly IConfiguration _configuration;

    public RequestContextProvider(IHttpContextAccessor httpContextAccessor, IConfiguration configuration)
    {
        _httpContextAccessor = httpContextAccessor;
        _configuration = configuration;
    }

    public RequestContext GetCurrentContext()
    {
        var context = _httpContextAccessor.HttpContext;
        if (context == null)
        {
            return null;
        }

        // Get machine ID from config or use environment machine name
        var machineId = _configuration["MachineId"] ?? Environment.MachineName;

        return new RequestContext
        {
            RemoteIpAddress = context.Connection.RemoteIpAddress?.ToString(),
            RequestPath = context.Request.Path.ToString(),
            Host = context.Request.Host.Value,
            MachineId = machineId
        };
    }
}

Step 3: Register the Service #

Add it to your Program.cs:

builder.Services.AddScoped<IRequestContextProvider, RequestContextProvider>();

Step 4: Use It in Controllers/Classes #

Now you can inject IRequestContextProvider anywhere and get all your context data in one place:

public class OrderController : Controller
{
    private readonly IRequestContextProvider _requestContextProvider;
    private readonly IOrderService _orderService;

    public OrderController(IRequestContextProvider requestContextProvider, IOrderService orderService)
    {
        _requestContextProvider = requestContextProvider;
        _orderService = orderService;
    }

    public IActionResult CreateOrder()
    {
        var context = _requestContextProvider.GetCurrentContext();
        if (context != null)
        {
            _orderService.LogOrderCreation(context.RemoteIpAddress, context.MachineId);
        }
        return View();
    }
}

4. Updating Your Middleware to Log the Custom Context #

You can also use this same RequestContextProvider in your middleware to keep your logging consistent:

public class RequestLoggerMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context, ILoggerFactory loggerFactory, IRequestContextProvider requestContextProvider)
    {
        var _logger = loggerFactory.CreateLogger("RequestLogger");
        var requestContext = requestContextProvider.GetCurrentContext();

        if (requestContext != null)
        {
            _logger.LogDebug("Request from {RemoteIp} on machine {MachineId} for path {Path}", 
                requestContext.RemoteIpAddress, 
                requestContext.MachineId, 
                requestContext.RequestPath);
        }

        await _next(context);
    }
}

Important Notes #

• Scoped vs Singleton: IHttpContextAccessor is registered as a singleton, but when you use it in a scoped service (like RequestContextProvider), it will always get the current request's context.
• Background Tasks: If you're running background tasks that don't have an active request, HttpContext will be null—make sure to handle that case in your code.
• Machine ID: You can store a custom machine ID in your appsettings.json (e.g., "MachineId": "WebServer-01") instead of using Environment.MachineName if you need a more controlled ID.

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