经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » ASP.net » 查看文章
.Net MinimalApis响应返回值
来源：cnblogs　　作者：董瑞鹏　　时间：2024/3/22 9:23:28　　对本文有异议

前言

文本主要讲 MinimalApis 中的使用自定义IResultModel和系统自带IResult做响应返回值。
MinimalApis支持以下类型的返回值：

  • string - 这包括 Task<string> 和 ValueTask<string>

  • T（任何其他类型）- 这包括 Task<T> 和 ValueTask<T>

  • 基于 IResult - 这包括 Task<IResult> 和 ValueTask<IResult>

    本文的完整源代码在文末

string 返回值

行为 Content-Type
框架将字符串直接写入响应。 text/plain

200 状态代码与 text/plain Content-Type 标头和以下内容一起返回

  1. Hello World

T（任何其他类型）返回值

我们上面说的自定义 IResultModel就是用这种模式处理的

行为 Content-Type
框架 JSON 序列化响应。 application/json

MinimalApis 框架 Json 序列化全局配置如下

  1.     //通过调用 ConfigureHttpJsonOptions 来全局配置应用的选项
  2.     builder.Services.ConfigureHttpJsonOptions(options =>
  3.     {
  4.         options.SerializerOptions.ReferenceHandler = ReferenceHandler.IgnoreCycles;//忽略循环引用
  5.         options.SerializerOptions.WriteIndented = true;
  6.         options.SerializerOptions.IncludeFields = true;
  7.         options.SerializerOptions.DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull;
  8.     });

返回 T

  2. app.MapGet("/TestT", User () => new User() { Name = "Ruipeng", Email = "xxx@163.com", Age = 18 })
  3.    .WithSummary("测试类")
  4.    .Produces<User>();

返回值

  1. {
  2.   "name": "Ruipeng",
  3.   "email": "xxx@163.com",
  4.   "age": 18
  5. }

200 状态代码与 application/json Content-Type 标头和以下内容一起返回

这个 HttpCode状态码只能返回 200，且不支持多种返回形式，比较局限

统一响应格式代码

  2. public interface IResultModel
  3. {
  4.     /// <summary>
  5.     ///     是否成功
  6.     /// </summary>
  7.     bool? IsSuccess { get; }
  9.     /// <summary>
  10.     ///     错误信息
  11.     /// </summary>
  12.     string? Message { get; }
  14.     /// <summary>
  15.     ///     业务码，用于业务中自定义
  16.     /// </summary>
  17.     int? StatusCode { get; set; }
  19.     /// <summary>
  20.     ///     时间戳
  21.     /// </summary>
  22.     long? Timestamp { get; }
  23. }
  25. /// <summary>
  26. ///     返回结果模型泛型接口
  27. /// </summary>
  28. /// <typeparam name="T"></typeparam>
  29. public interface IResultModel<out T> : IResultModel
  30. {
  31.     /// <summary>
  32.     ///     返回数据
  33.     /// </summary>
  35.     T? Data { get; }
  36. }

实现

  1. public class ResultModel<T> : IResultModel<T>
  2. {
  3.     public ResultModel()
  4.     {
  5.         Timestamp = DateTimeOffset.Now.ToUnixTimeSeconds();
  6.     }
  8.     /// <summary>
  9.     ///     处理是否成功
  10.     /// </summary>
  11.     public bool? IsSuccess { get; set; }
  13.     /// <summary>
  14.     ///     错误信息
  15.     /// </summary>
  16.     public string? Message { get; set; }
  18.     /// <summary>
  19.     ///     业务码
  20.     /// </summary>
  21.     public int? StatusCode { get; set; }
  23.     /// <summary>
  24.     ///     时间戳
  25.     /// </summary>
  26.     public long? Timestamp { get; }
  28.     /// <summary>
  29.     ///     返回数据
  30.     /// </summary>
  31.     public T? Data { get; set; }
  34.     /// <summary>
  35.     ///     成功
  36.     /// </summary>
  37.     /// <param name="Data"></param>
  38.     public ResultModel<T> Success(T? data = default)
  39.     {
  40.         this.IsSuccess = true;
  41.         StatusCode = 200;
  42.         Data = data;
  43.         return this;
  44.     }
  46.     /// <summary>
  47.     ///     失败
  48.     /// </summary>
  49.     /// <param name="msg">说明</param>
  50.     /// <param name="code"></param>
  51.     public ResultModel<T> Failed(string? msg = "failed", int? code = 500)
  52.     {
  53.         IsSuccess = false;
  54.         Message = msg;
  55.         StatusCode = code;
  56.         return this;
  57.     }
  58. }
  60. /// <summary>
  61. ///     返回结果
  62. /// </summary>
  63. public static class ResultModel
  64. {
  65.     /// <summary>
  66.     ///     数据已存在
  67.     /// </summary>
  68.     /// <returns></returns>
  69.     public static IResultModel<string> HasExists => Failed("data already exists");
  71.     /// <summary>
  72.     ///     数据不存在
  73.     /// </summary>
  74.     public static IResultModel<string> NotExists => Failed("data doesn't exist");
  76.     /// <summary>
  77.     ///     成功
  78.     /// </summary>
  79.     /// <param name="data">返回数据</param>
  80.     /// <returns></returns>
  81.     public static IResultModel<T> Success<T>(T? data = default)
  82.     {
  83.         return new ResultModel<T>().Success(data);
  84.     }
  86.     /// <summary>
  87.     ///     成功
  88.     /// </summary>
  89.     /// <param name="task">任务</param>
  90.     /// <returns></returns>
  91.     public static async Task<IResultModel<T>> SuccessAsync<T>(Task<T>? task = default)
  92.     {
  93.         return task is not null && task != default ? new ResultModel<T>().Success(await task) : new ResultModel<T>();
  94.     }
  96.     /// <summary>
  97.     ///     成功
  98.     /// </summary>
  99.     /// <returns></returns>
  100.     public static IResultModel<string> Success()
  101.     {
  102.         return Success<string>();
  103.     }
  106.     /// <summary>
  107.     ///     失败
  108.     /// </summary>
  109.     /// <param name="error">错误信息</param>
  110.     /// <returns></returns>
  111.     public static IResultModel<T> Failed<T>(string? error = null)
  112.     {
  113.         return new ResultModel<T>().Failed(error ?? "failed");
  114.     }
  116.     /// <summary>
  117.     ///     失败
  118.     /// </summary>
  119.     /// <returns></returns>
  120.     public static IResultModel<string> Failed(string? error = null)
  121.     {
  122.         return Failed<string>(error);
  123.     }
  125.     /// <summary>
  126.     ///     根据布尔值返回结果
  127.     /// </summary>
  128.     /// <param name="success"></param>
  129.     /// <returns></returns>
  130.     public static IResultModel<T> Result<T>(bool success)
  131.     {
  132.         return success ? Success<T>() : Failed<T>();
  133.     }
  135.     /// <summary>
  136.     ///     根据布尔值返回结果
  137.     /// </summary>
  138.     /// <param name="success"></param>
  139.     /// <returns></returns>
  140.     public static async Task<IResultModel> Result(Task<bool> success)
  141.     {
  142.         return await success ? Success() : Failed();
  143.     }
  145.     /// <summary>
  146.     ///     根据布尔值返回结果
  147.     /// </summary>
  148.     /// <param name="success"></param>
  149.     /// <returns></returns>
  150.     public static IResultModel<string> Result(bool success)
  151.     {
  152.         return success ? Success() : Failed();
  153.     }
  155.     /// <summary>
  156.     /// 时间戳起始日期
  157.     /// </summary>
  158.     public static readonly DateTime TimestampStart = new(1970, 1, 1, 0, 0, 0, 0);
  161. }

定义接口

  1. app.MapGet("/TestResultModel", IResultModel (int age) =>
  2. {
  3.     List<User> users = [new User() { Name = "Ruipeng", Email = "xxx@163.com", Age = 18 }];
  4.     return users.FirstOrDefault(_ => _.Age > age) is User user ? ResultModel.Success(user) : ResultModel.Failed();
  5. })
  6.    .WithSummary("测试自定义IResultModel")
  7.    .Produces<IResultModel<User>>();

封装了一个静态类来简化自定义类的创建，支持多个返回类型

返回值

  1. {
  2.   "isSuccess": true,
  3.   "statusCode": 200,
  4.   "timestamp": 1711001093,
  5.   "data": {
  6.     "name": "Ruipeng",
  7.     "email": "xxx@163.com",
  8.     "age": 18
  9.   }

自定义类的自动包装实现

创建一个Attribute

  1. [AttributeUsage(AttributeTargets.Method)]
  2. public class EnableResponseWrapperAttribute : Attribute { }

创建中间件自动包装

  1. public class ResponseWrapperMiddleware(RequestDelegate next)
  2. {
  3.     public async Task InvokeAsync(HttpContext context)
  4.     {
  6.         if (context.GetEndpoint()?.Metadata.GetMetadata<EnableResponseWrapperAttribute>() is not null)
  7.         {
  8.             // 存储原始响应体流
  9.             var originalResponseBodyStream = context.Response.Body;
  10.             try
  11.             {
  12.                 // 创建内存流以捕获响应
  13.                 using var memoryStream = new MemoryStream();
  14.                 context.Response.Body = memoryStream;
  16.                 // 调用管道中的下一个中间件
  17.                 await next(context);
  19.                 // 恢复原始响应体流并写入格式化结果
  20.                 context.Response.Body = originalResponseBodyStream;
  22.                 // 重置内存流位置并读取响应内容
  23.                 memoryStream.Seek(0, SeekOrigin.Begin);
  24.                 var readToEnd = await new StreamReader(memoryStream).ReadToEndAsync();
  25.                 var objResult = JsonSerializer.Deserialize<dynamic>(readToEnd);
  26.                 var result = new ResultModel<object>
  27.                 {
  28.                     Data = objResult,
  29.                     IsSuccess = true,
  30.                     StatusCode = context.Response.StatusCode
  31.                 };
  32.                 await context.Response.WriteAsJsonAsync(result as object);
  34.             }
  35.             finally
  36.             {
  37.                 // 确保在出现异常时恢复原始响应体流
  38.                 context.Response.Body = originalResponseBodyStream;
  39.             }
  40.         }
  41.         else
  42.         {
  43.             await next(context);
  44.         }
  45.     }
  46. }

应用中间件

  1. app.UseMiddleware<ResponseWrapperMiddleware>();

创建测试接口

  1. app.MapGet("/TestTestAutoWarpper", [EnableResponseWrapper] User () => new User() { Name = "Ruipeng", Email = "xxx@163.com", Age = 18 }).WithSummary("测试类")
  2.    .Produces<User>();

返回值

  1. {
  2.   "isSuccess": true,
  3.   "statusCode": 200,
  4.   "timestamp": 1711005201,
  5.   "data": {
  6.     "name": "Ruipeng",
  7.     "email": "xxx@163.com",
  8.     "age": 18
  9.   }
  10. }

为了方便测试在MinimalApis 的接口上如果添加了EnableResponseWrapperAttribute则通过中间件自动包装返回值

IResult 返回值

行为 Content-Type
框架调用 IResult.ExecuteAsync 由 IResult 实现决定

在dotNet7 之后多了一个TypedResults类来替代 Results。
IResult 接口定义一个表示 HTTP 终结点结果的协定。 静态 Results 类和静态 TypedResults 用于创建表示不同类型的响应的各种 IResult 对象。

返回 TypedResults（而不是 Results）有以下优点：

  • TypedResults 帮助程序返回强类型对象，这可以提高代码可读性、改进单元测试并减少运行时错误的可能性。
  • 实现类型会自动为 OpenAPI 提供响应类型元数据来描述终结点。
    实现在Microsoft.AspNetCore.Http.HttpResults
  1. //Return IResult
  2. app.MapGet("/IResult/TestResult", IResult () => Results.Ok(new User() { Name = "Ruipeng", Email = "xxx@163.com", Age = 18 }));

没有调用扩展方法 Produces

  1. app.MapGet("/IResult/TestTypedResult", IResult () => TypedResults.Ok(new User() { Name = "Ruipeng", Email = "xxx@163.com", Age = 18 }));

可以看到 TypedResults 默认就会添加路由终结点的元数据描述

返回多个 IResult 实现类型

  1. app.MapGet("/IResult/ReturnMultipleTypes", Results<Ok<User>, NotFound> (int age) =>
  2. {
  3.     List<User> users = [new User() { Name = "Ruipeng", Email = "xxx@163.com", Age = 18 }];
  4.     return users.FirstOrDefault(_ => _.Age > age) is User user ? TypedResults.Ok(user) : TypedResults.NotFound();
  5. });

图简单可以直接用 IResult 返回类型 但是，由于 TypedResults 帮助程序自动包含终结点的元数据，因此可以改为返回 Results<Ok<User>, NotFound> 联合类型

IResult 自定义响应

添加 Html 扩展

  2. public static class ResultsExtensions
  3. {
  4.     public static IResult Html(this IResultExtensions resultExtensions, string html)
  5.     {
  6.         ArgumentNullException.ThrowIfNull(resultExtensions);
  8.         return new HtmlResult(html);
  9.     }
  10. }
  13. class HtmlResult(string html) : IResult
  14. {
  15.     private readonly string _html = html;
  17.     public Task ExecuteAsync(HttpContext httpContext)
  18.     {
  19.         httpContext.Response.ContentType = MediaTypeNames.Text.Html;
  20.         httpContext.Response.ContentLength = Encoding.UTF8.GetByteCount(_html);
  21.         return httpContext.Response.WriteAsync(_html);
  22.     }
  23. }
  1. app.MapGet("/IResult/Html", () => Results.Extensions.Html(@$"<!doctype html>
  2. <html>
  3.     <head><title>miniHTML</title></head>
  4.     <body>
  5.         <h1>Hello World</h1>
  6.         <p>The time on the server is {DateTime.Now:O}</p>
  7.     </body>
  8. </html>"));

返回结果

  1. <!DOCTYPE html>
  2. <html>
  3.   <head>
  4.     <title>miniHTML</title>
  5.   </head>
  6.   <body>
  7.     <h1>Hello World</h1>
  8.     <p>The time on the server is 2024-03-21T17:31:36.2931959+08:00</p>
  9.   </body>
  10. </html>

自定义 Json 格式

上面写了ConfigureHttpJsonOptions方法来配置全局请求的 Json 格式，下面则是针对单个路由终结点请求，方便一些个性化接口的处理

  1. var options = new JsonSerializerOptions(JsonSerializerDefaults.Web)
  2. { WriteIndented = true };
  4. app.MapGet("/IResult/CustomJsonConfig", () =>
  5.     TypedResults.Json(new User() { Name = "Ruipeng", Email = "xxx@163.com", Age = 18 }, options));

返回 ProblemDetail

  1. app.MapGet("/IResult/ProblemDetail", () =>
  2. {
  3.     var problemDetail = new ProblemDetails()
  4.     {
  5.         Status = StatusCodes.Status500InternalServerError,
  6.         Title = "内部错误"
  7.     };
  8.     return TypedResults.Problem(problemDetail);
  9. });

返回值

  1. {
  2.   "type": "https://tools.ietf.org/html/rfc9110#section-15.6.1",
  3.   "title": "内部错误",
  4.   "status": 500
  5. }

在Microsoft.AspNetCore.Http.Results的扩展下，TypedResults 有非常多扩展的方法，比如处理文件，回调，流以及登录认证等，大家可以根据需求使用.

最后

用那种方式还是取决于项目的实际情况，如果你的系统是业务码和 httpStateCode要求分离的形式那建议用上面自定义统一响应的形式，要是没这方面的需求那dotNet自带的TypedResults使用起来就更合适。

官网文档 如何在最小 API 应用中创建响应

以下是本文的完整 源代码

希望本文对你有帮助！

原文链接：https://www.cnblogs.com/ruipeng/p/18088161

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

ASP.net热门文章

  • 【Dotnet 工具箱】WPF UI - 现代化设计的开源 WPF 框架
  • net core 使用 SqlSugar
  • .NETCore下CI/CD之自动化测试
  • .net core部署到linux可能碰到的问题
  • Abp vNext 自定义 Ef Core 仓储引发异常
  • .NetCore 消息队列的使用
  • .NetCore WebApi——基于JWT的简单身份认证与授权（Swagger）
  • Abp.NHibernate连接PostgreSQl数据库
  • ModelValidator基于元数据的验证
  • .NET MAUI 安卓应用开发初体验

    • ASP.net推荐文章

  • Gradio.NET 支持 .NET 8 简化 Web 应用开发
  • .NET 轻量化定时任务调度 FreeScheduler
  • WPF 模仿前端大佬写一个Hover效果
  • WPF 模拟UWP原生窗口样式——亚克力|云母材质、自定义标题栏样式、原生DWM动画 （附我封装好的类）
  • .NET 音频采集
  • .NET8 Blazor 从入门到精通：（三）类库和表单
  • wpf 如何7步写一个badge控件
  • .NET 高效Nuget管理工具（开源）
  • .NET 8 跨平台高性能边缘采集网关
  • .NET 窗口/屏幕录制

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号