第三单元 管道与中间件

// 配置http 请求管道，由运行时调用
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage(); // 渲染错误页中间件
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
    }
    app.UseStaticFiles(); // 使用静态文件中间件
    
    app.UseRouting(); // 使用路由中间件
​
    app.UseAuthorization(); // 使用授权中间件
    // 终端节点中间件
    app.UseEndpoints(endpoints =>
                     {
                         endpoints.MapControllerRoute(
                             name: "default",
                             pattern: "{controller=Home}/{action=Index}/{id?}");
                     });
}
 

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews(); // 添加控制器服务
}


public void Configure(IApplicationBuilder app, IWebHostEnvironment env,ILogger<Startup> logger)
{
    app.UseRouting();// 添加路由服务

    app.Use(next =>
            {
                logger.LogInformation("第1个中间件"); // 启动时执行，只执行一次
                
                // 每次请求都会执行一次
                return async context =>
                {
                    logger.LogInformation("第1个中间件1-before");
                    await next(context);
                    logger.LogInformation("第1个中间件1-after");
                };
            });

    app.Use(next =>
            {
                logger.LogInformation("第2个中间件");// 启动时执行，只执行一次

                 // 每次请求都会执行一次
                return async context =>
                {
                    logger.LogInformation("第2个中间件2-before");
                    await next(context);
                    logger.LogInformation("第2个中间件2-after");
                };
            });

    app.Use(next =>
            {
                logger.LogInformation("第3个中间件");// 启动时执行，只执行一次

                 // 每次请求都会执行一次
                return async context =>
                {
                    logger.LogInformation("第3个中间件3-before");
                    await next(context);
                    logger.LogInformation("第3个中间件3-after");
                };
            });
    
    // 使用终端节点中间件会短路后面的中件间，所以，这个中间件最好放在最后
    app.UseEndpoints(endpoints =>
                     {
                         endpoints.MapControllerRoute(
                             name: "default",
                             pattern: "{controller=Home}/{action=Index}/{id?}");
                     });
}
info: Step3.Empty.Startup[0]
      第3个中间件
info: Step3.Empty.Startup[0]
      第2个中间件
info: Step3.Empty.Startup[0]
      第1个中间件

// 发起请求之后
info: Step3.Empty.Startup[0]
      第1个中间件1-before
info: Step3.Empty.Startup[0]
      第2个中间件2-before
info: Step3.Empty.Startup[0]
      第3个中间件3-before
info: Step3.Empty.Startup[0]
      第3个中间件3-after
info: Step3.Empty.Startup[0]
      第2个中间件2-after
info: Step3.Empty.Startup[0]
      第1个中间件1-after

public void Configure(IApplicationBuilder app, IWebHostEnvironment env,ILogger<Startup> logger)
{
    app.UseRouting();

    app.Use(next =>
            {
                logger.LogInformation("第1个中间件");

                return async context =>
                {
                    logger.LogInformation("第1个中间件1-before");
                    await next(context);
                    logger.LogInformation("第1个中间件1-after");
                };
            });

    // 后面的中件间将不会再执行了
    app.Use(next =>
            {
                logger.LogInformation("第2个中间件");

                return async context =>
                {
                    logger.LogInformation("短路了");
                    // await next(context); // 没有调用即表示短路了
                };
            });
    
    app.Use(next =>
            {
                logger.LogInformation("第3个中间件");

                return async context =>
                {
                    logger.LogInformation("第3个中间件3-before");
                    await next(context);
                    logger.LogInformation("第3个中间件3-after");
                };
            });

    app.UseEndpoints(endpoints =>
                     {
                         endpoints.MapControllerRoute(
                             name: "default",
                             pattern: "{controller=Home}/{action=Index}/{id?}");
                     });
}
输出结果：

info: Step3.Empty.Startup[0]
      第3个中间件
info: Step3.Empty.Startup[0]
      第2个中间件
info: Step3.Empty.Startup[0]
      第1个中间件

// 发起请求之后
info: Step3.Empty.Startup[0]
      第1个中间件1-before
info: Step3.Empty.Startup[0]
      短路了
info: Step3.Empty.Startup[0]
      第1个中间件1-after

// 添加控制器与视图服务
builder.Services.AddControllersWithViews();


// ....上面省略一些代码
app.UseRouting();

app.UseRouting();
app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");
app.Run(); // 必须添加一个终节点
路由模板 "{controller=Home}/{action=Index}/{id?}"：

匹配 URL 路径，例如 /Products/Details/5

通过标记路径来提取路由值 { controller = Products, action = Details, id = 5 }。 如果应用有一个名为 ProductsController 的控制器和一个 Details 操作，则提取路由值会导致匹配：

public class ProductsController : Controller
{
    public IActionResult Details(int id)
    {
        return ControllerContext.MyDisplayRouteInfo(id);
    }
}
MyDisplayRouteInfo 由 Rick.Docs.Samples.RouteInfo NuGet 包提供，会显示路由信息。

/Products/Details/5 模型绑定 id = 5 的值，以将 id 参数设置为 5。 有关更多详细信息，请参阅模型绑定。

{controller=Home} 将 Home 定义为默认 controller。

{action=Index} 将 Index 定义为默认 action。

{id?} 中的 ? 字符将 id 定义为可选。

默认路由参数和可选路由参数不必包含在 URL 路径中进行匹配。 有关路由模板语法的详细说明，请参阅路由模板参考。

匹配 URL 路径 /。

生成路由值 { controller = Home, action = Index }。

controller 和 action 的值使用默认值。 id 不会生成值，因为 URL 路径中没有相应的段。 / 仅在存在 HomeController 和 Index 操作时匹配：

public class HomeController : Controller
{
    public IActionResult Index() { ... }
}
使用前面的控制器定义和路由模板，为以下 URL 路径运行 HomeController.Index 操作：

/Home/Index/17

/Home/Index

/Home

/

URL 路径 / 使用路由模板默认 Home 控制器和 Index 操作。 URL 路径 /Home 使用路由模板默认 Index 操作。

简便方法 MapDefaultControllerRoute：

app.MapDefaultControllerRoute();
替代：

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");
 

属性路由
// 添加控制器与视图服务
builder.Services.AddControllersWithViews();


// ....上面省略一些代码 
// app.UseRouting(); // 此行代码已经不需要了
app.MapControllers(); // 映射控制器
MapControllers 调用它来映射属性路由控制器。

在以下示例中：

HomeController 匹配一组类似于默认传统路由 {controller=Home}/{action=Index}/{id?} 匹配的 URL。

public class HomeController : Controller
{
    [Route("")]
    [Route("Home")]
    [Route("Home/Index")]
    [Route("Home/Index/{id?}")]
    public IActionResult Index(int? id)
    {
        return ControllerContext.MyDisplayRouteInfo(id);
    }

    [Route("Home/About")]
    [Route("Home/About/{id?}")]
    public IActionResult About(int? id)
    {
        return ControllerContext.MyDisplayRouteInfo(id);
    }
}
将针对任意 URL 路径 /、/Home、/Home/Index 或 /Home/Index/3 执行 HomeController.Index 操作。

此示例重点介绍属性路由与传统路由之间的主要编程差异。 属性路由需要更多输入才能指定路由。 传统默认路由会更简洁地处理路由。 但是，属性路由允许并需要精确控制应用于每项操作的路由模板。

对于属性路由，控制器和操作名称在操作匹配中不起作用，除非使用标记替换。 以下示例匹配与上一个示例相同的 URL：

public class MyDemoController : Controller
{
    [Route("")]
    [Route("Home")]
    [Route("Home/Index")]
    [Route("Home/Index/{id?}")]
    public IActionResult MyIndex(int? id)
    {
        return ControllerContext.MyDisplayRouteInfo(id);
    }

    [Route("Home/About")]
    [Route("Home/About/{id?}")]
    public IActionResult MyAbout(int? id)
    {
        return ControllerContext.MyDisplayRouteInfo(id);
    }
}
以下代码对 action 和 controller 使用标记替换：

public class HomeController : Controller
{
    [Route("")]
    [Route("Home")]
    [Route("[controller]/[action]")]
    public IActionResult Index()
    {
        return ControllerContext.MyDisplayRouteInfo();
    }

    [Route("[controller]/[action]")]
    public IActionResult About()
    {
        return ControllerContext.MyDisplayRouteInfo();
    }
}
以下代码将 [Route("[controller]/[action]")] 应用于控制器：

[Route("[controller]/[action]")]
public class HomeController : Controller
{
    [Route("~/")]
    [Route("/Home")]
    [Route("~/Home/Index")]
    public IActionResult Index()
    {
        return ControllerContext.MyDisplayRouteInfo();
    }

    public IActionResult About()
    {
        return ControllerContext.MyDisplayRouteInfo();
    }
}

[Route("users/{id:int:min(1)}")]
public User GetUserById(int id) { }

if (!app.Environment.IsDevelopment()) // 非开发环境下，可以显示自定义错误页
{
    app.UseExceptionHandler("/Home/Error");
}
else
{
    app.UseDeveloperExceptionPage(); // 开发人员错误页
}

app.UseStaticFiles();
以下标记引用 wwwroot/images/MyImage.jpg：

<img src="~/images/MyImage.jpg" class="img" alt="My image" />

app.UseStaticFiles(new StaticFileOptions
{
    FileProvider = new PhysicalFileProvider(
           Path.Combine(builder.Environment.ContentRootPath, "MyStaticFiles")),
    RequestPath = "/StaticFiles" // 请求路径
});

<img src="~/StaticFiles/images/red-rose.jpg" class="img" alt="A red rose" />

builder.Services.AddSession(); // 添加Session服务


app.UseStaticFiles();

app.UseSession(); // 添加Session中间件，使用默认的SessionOptions
app.UseRouting();
app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Hello}/{action=Index}/{id?}");


app.Run();

builder.Services.AddSession(options =>
            {   
                // 默认名称.AspNetCore.Session
                options.Cookie.Name = ".AdventureWorks.Session"; 
                // 默认20分钟过期
                options.IdleTimeout = TimeSpan.FromSeconds(2000);//设置session的过期时间
                // 默认为真
                options.Cookie.HttpOnly = true;//设置在浏览器不能通过js获得该cookie的值 
            });

HttpContext.Session.SetString("user","任我行"); // 设置Session的值

HttpContext.Session.GetString("user","任我行"); // 读取Session的值
// Razor视图中读取
<h1>我的姓名：@Context.Session.GetString("user")</h1> // 读取Session的值