ASP.NET Core Web应用中特殊胖箭头'=>'的用法疑问

Hey there! Let's break down what that fat arrow (=>) does in your ASP.NET Core 2.0 app's Startup.cs—it's a lambda expression in C#, and it's a workhorse for writing concise, inline logic when setting up your web app. Here are the most common ways you'll see it used in your generated project:

1. Configuring Service Options #

When registering services in ConfigureServices, you'll often pass a lambda to tweak settings for a particular service. For example, with MVC:

services.AddMvc(options =>
{
    // Add custom filters, formatters, or other MVC configurations here
    options.Filters.Add(new MyCustomFilter());
});

The options => { ... } part is an inline delegate (specifically an Action<MvcOptions>). Instead of writing a separate method to configure MVC settings, you define the logic right where you register the service—clean and straightforward.

2. Dependency Injection Factory Methods #

Lambda expressions are perfect for telling the DI container how to create instances of your services. For example:

services.AddSingleton<IMyCustomService>(serviceProvider => 
    new MyCustomService(serviceProvider.GetRequiredService<IAnotherService>())
);

Here, serviceProvider => new MyCustomService(...) is a Func<IServiceProvider, IMyCustomService>. It takes the DI service provider as input, uses it to resolve any dependencies your service needs, and returns a new instance of MyCustomService. No need to write a separate factory class!

3. Middleware Logic in Configure #

In the Configure method, lambda expressions define the behavior of custom middleware. A common example is inline middleware:

app.Use(async (context, next) =>
{
    // Code to run BEFORE the next middleware in the pipeline
    Console.WriteLine($"Processing request: {context.Request.Path}");
    
    await next(); // Call the next middleware
    
    // Code to run AFTER the next middleware completes
    Console.WriteLine($"Request completed with status: {context.Response.StatusCode}");
});

The (context, next) => { ... } is a Func<HttpContext, Func<Task>, Task> delegate. It takes the current request's HttpContext and a delegate to the next middleware, letting you add custom logic before and after the rest of the pipeline runs.

4. Expression-Bodied Members (Shorthand Properties/Methods) #

If you see => in a class member like this:

private readonly IConfiguration _configuration;
public IConfiguration Configuration => _configuration;

This is an expression-bodied member (a C# 6+ feature). It's a shorthand for a read-only property, replacing the longer:

public IConfiguration Configuration
{
    get { return _configuration; }
}

It keeps your code concise while maintaining the same functionality.

Quick Recap #

At its core, => lets you write anonymous methods or delegates without the overhead of defining a separate named method. In ASP.NET Core, it's everywhere because the framework relies heavily on passing configuration logic and delegates during setup—making your Startup.cs clean and focused on what your app needs.

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