01编程初体验

# 1.命令行创建.NET程序
```bash
dotnet new console -n App
dotnet build
dotnet run
```
# 采用Minimal API

>i public delegate Task RequestDelegate(HttpContext context);
Func<HttpContext, Task>

流程角度：
- 1、绑定请求管道
- 2、启动绑定端口监听；
- 3、请求到达，构造HttpContext对象处理
  1）请求的处理器可以表示为一个Func<HttpContext, Task>类型的委托
  2）设计为了一个委托RequestDelegate，本质是相同的
- 4、交付管道处理
- 5、待管道处理后，控制权再次回到服务器的手中，它会将处理的结果转换成响应发送出去

编程角度：
- 1、管道体现为上述的RequestDelegate委托
- 2、组成它的单个中间件则体现为另一个类型为Func<RequestDelegate，RequestDelegate>的委托。
前者表示由后续中间件构建的管道，后者代表将当前中间件纳入此管道后生成的新管道。

```java
RequestDelegate handler = context => context.Response.WriteAsync("Hello, World!");
WebApplicationBuilder builder = WebApplication.CreateBuilder(args);
WebApplication app = builder.Build();
app.Run(handler: handler);
app.Run();
```

```java
var app = WebApplication.Create(args);
app.Run(HandleAsync);
app.Run();
//委托
static Task HandleAsync(HttpContext httpContext)=> httpContext.Response.WriteAsync("Hello1, World!");
```

# 原始形态的中间件

>i Func<RequestDelegate，RequestDelegate >
RequestDelegate 中间件(RequestDelegate)

```java
var app = WebApplication.Create(args);
IApplicationBuilder appBuilder = app;
appBuilder
    .Use(middleware: HelloMiddleware)
    .Use(middleware: WorldMiddleware);
app.Run();
static RequestDelegate HelloMiddleware(RequestDelegate next)
    => async httpContext => {
    await httpContext.Response.WriteAsync("Hello， ");
    await next(httpContext);
};
 
static RequestDelegate WorldMiddleware(RequestDelegate next)
=> httpContext => httpContext.Response.WriteAsync("World!");
```
# 中间件委托变体
>i Func<HttpContext, RequestDelegate, Task>
Func<HttpContext, Func\<Task>, Task>

```java
var app = WebApplication.Create(args);
app
    .Use(middleware: HelloMiddleware)
    .Use(middleware: WorldMiddleware);
app.Run();
static async Task HelloMiddleware(
    HttpContext httpContext, RequestDelegate next)
{
    await httpContext.Response.WriteAsync("Hello, ");
    await next(httpContext);
};
static Task WorldMiddleware(
    HttpContext httpContext, RequestDelegate next)
    => httpContext.Response.WriteAsync("World!");
```

```java
var app = WebApplication.Create(args);
app
    .Use(middleware: HelloMiddleware)
    .Use(middleware: WorldMiddleware);
app.Run();
static async Task HelloMiddleware(
    HttpContext httpContext, Func<Task> next)
{
    await httpContext.Response.WriteAsync("Hello, ");
    await next();
};
static Task WorldMiddleware(
    HttpContext httpContext, Func<Task> next)
    => httpContext.Response.WriteAsync("World!");
```
# 定义强类型中间件类型
>i 直接实现IMiddleware接口

```java
//定义模型
public interface IGreeter
{
   string Greet(DateTimeOffset time);
}
public class Greeter : IGreeter
{
    public string Greet(DateTimeOffset time)
    => time.Hour switch
    {
        var h when h >= 5 && h < 12 => "Good morning!",
        var h when h >= 12 && h < 17 => "Good afternoon!",
        _ => "Good evening!"
    };
}
//定义中间件
public class GreetingMiddleware : IMiddleware
{
    private readonly IGreeter _greeter;
    public GreetingMiddleware(IGreeter greeter)
        => _greeter = greeter;
    public Task InvokeAsync(
        HttpContext context, RequestDelegate next)
        => context.Response.WriteAsync(_greeter.Greet(DateTimeOffset.Now));
}
//使用中间件
var builder = WebApplication.CreateBuilder(args);
builder.Services
    .AddSingleton<IGreeter, Greeter>()
    .AddSingleton<GreetingMiddleware>();
var app = builder.Build();
app.UseMiddleware<GreetingMiddleware>();
app.Run();
```

# 定义基于约定的中间件类型（构造函数注入）

```java
public class GreetingMiddleware
{
    private readonly IGreeter _greeter;
    public GreetingMiddleware(RequestDelegate next,IGreeter greeter)
       => _greeter = greeter;
    public Task InvokeAsync(HttpContext context)
       => context.Response
       .WriteAsync(_greeter.Greet(DateTimeOffset.Now));
}
```
# 定义基于约定的中间件类型（方法注入）
```java
public class GreetingMiddleware
{
    public GreetingMiddleware(RequestDelegate next){}
    public Task InvokeAsync(HttpContext context, IGreeter greeter)
       => context.Response.WriteAsync(greeter.Greet(DateTimeOffset.Now));
}
```