增量生成器简化BlazorServer兼容BlazorAuto模式

使用增量生成器简化 BlazorServer 兼容 Auto 模式

文末有生成代码示例

啰里八嗦

Blazor 作为.Net 生态的一个前端框架，有多种开发模式，在初期，有 Blazor Server 和 Blazor WebAssembly 两种模式，各自的优点和缺点都很明显。后来，随着.Net8 一起而来的还有 Blazor Auto 模式，它可以说是结合了 Server 和 WASM 的优点，但是对于习惯了 Server 写法的我来说，讲项目改造成 Auto 模式，工作量却是大且无聊的，那么有没有一种方式可以让我在写 Server 模式的同时，无感地实现 Auto 呢（当然只是一种夸张的说法，虽然大部分情况是可行的，但实际开发 Server 的时候肯定还要考虑一下 WASM 的情况是否可行）

主角登场

AutoWasmApiGenerator是一个增量生成器，用于生成 BlazorServer 项目的 WebApi 接口，以便在 BlazorAuto 模式下使用

比如现在有一个 BlazorServer 项目的 Razor 页面

// UserIndex.razor
@code {
    [Inject, NotNull] IUserService? Service { get; set; }
}

如果IUserService的实现不支持运行在WebAssembly，比如连接数据库，或者访问服务器文件等等，那么这种情况下，需要 Server 端提供 WebApi，并且在 Client 端提供IUserService的接口调用实现，本文的目的就是通过增量生成器，完成 Server 端 WebApi 生成和 Client 端的接口调用

使用

项目结构

  • Server端项目
  • Client端项目
  • Shared双端共用的项目，一般是共用的页面、实体模型、等等

使用步骤

  1. 在 Server 项目中引用 AutoWasmApiGenerator 项目
    <PackageReference Include="AutoWasmApiGenerator" Version="0.0.*" />
  2. 在 Shared 或 Client 项目中添加接口
    [WebController]
public interface ITestService
{
	[WebMethod(Method = WebMethod.Post)] // 默认指定为Post
	Task<bool> LogAsync(string message, string path, CancellationToken token);
}
  3. 在 Server 项目中任意一个文件标注WebControllerAssemblyAttribute, 生成的文件为TestServiceController
    [assembly: AutoWasmApiGenerator.WebControllerAssembly]
  4. 在 Client 项目中或生成控制器调用类的项目中的任意一个文件标注ApiInvokerAssemblyAttribute, 生成的文件为TestServiceApiInvoker
    [assembly: AutoWasmApiGenerator.ApiInvokerAssembly]
  5. 在 Client 项目中注册
    builder.Services.AddScoped<ITestService, TestServiceApiInvoker>();
  6. 通过ITestService调用服务
    @code
{
	[Inject] public ITestService TestService { get; set; }
	private async Task LogAsync()
	{
		await TestService.LogAsync("Hello World", "path", CancellationToken.None);
	}
}

相关特性介绍

WebControllerAttribute

标注服务接口，根据接口生成控制器和调用类

WebMethodNotSupportedAttribute

标注方法，表示不生成对应的 WebApi

ApiInvokeNotSupportedAttribute

标注类，表示不生成调用类；标注方法， 表示不生成调用方法（调用该方法，将抛出NotSupportedException）

WebMethodAttribute

标注方法，指定请求方式

[WebMethod(Method = WebMethod.Post)]
Task<bool> LogAsync(string message);

属性

名称 类型 说明
Method WebMethod 指定请求方法，默认为 Post
Route string? 指定 Action 路由，null 时为方法名称
AllowAnonymous bool 是否支持匿名访问，会覆盖 Authorize 设置
Authorize bool 是否需要授权

WebMethod

可能的值

  • Get
  • Post
  • Put
  • Delete

WebMethodParameterBindingAttribute

标注参数，指定参数绑定方式

[WebMethod(Method = WebMethod.Post)]
Task<bool> Log3Async([WebMethodParameterBinding(BindingType.FromBody)] string message, [WebMethodParameterBinding(BindingType.FromQuery)] string path,[WebMethodParameterBinding(BindingType.Ignore)] CancellationToken token);

属性

名称 类型 说明
Type BindingType 参数绑定类型

BindingType

  • Ignore 忽略
  • FromQuery 从查询字符串中获取值。
  • FromRoute 从路由数据中获取值。
  • FromForm 从发布的表单域中获取值。
  • FromBody 从请求正文中获取值。
  • FromHeader 从 HTTP 标头中获取值。
  • FromServices 从服务容器中获取值。

可注入服务

IGeneratedApiInvokeDelegatingHandler

接口调用类的切面入口

使用示例

[AutoInject(Group = "WASM", ServiceType = typeof(IGeneratedApiInvokeDelegatingHandler))]
public class GeneratedApiHandler(ILogger<GeneratedApiHandler> logger, IUIService ui) : GeneratedApiInvokeDelegatingHandler
{
    public override Task BeforeSendAsync(SendContext context)
    {
        logger.LogDebug("before request {Message}", context.TargetMethod);
        return base.BeforeSendAsync(context);
    }
    public override Task OnExceptionAsync(ExceptionContext context)
    {
        logger.LogDebug("请求发生异常: {Message}", context.Exception.Message);
        if (context.SendContext.Response?.StatusCode == System.Net.HttpStatusCode.Unauthorized)
        {
            context.Handled = true;
            ui.Error("用户过期，请重新登录");
        }
        return Task.CompletedTask;
    }
}

SendContext

名称 类型 说明
TargetType Type 接口类型
TargetMethod string 方法名称
Parameters object?[]? 方法参数
ReturnType Type? 方法返回值
Request HttpRequestMessage HttpClient 的请求上下文
Response HttpResponseMessage? HttpClient 的响应上下文

ExceptionContext

名称 类型 说明
SendContext SendContext 请求上下文
Exception Exception 异常
Handled bool 异常是否已经处理，未处理则抛出异常

异常返回值处理

AddAutoWasmErrorResultHandler

// 当接口调用类发生异常时，若异常已经处理，需要返回自定义的失败结果时，可根据返回类型进行自定义
builder.Services.AddAutoWasmErrorResultHandler(config =>
{
    config.CreateErrorResult<QueryResult>(context =>
    {
        return new QueryResult() { IsSuccess = false, Message = context.Exception.Message };
    });
});

按约束创建返回值

如果是返回统一的自定义返回值，并且该类型拥有无参构造函数，拥有一个类似success的bool类型的属性和一个类似message或者msg的string类型的属性，将尝试 new 一个示例并为这两个属性赋值

自定义属性查找功能

如果未按约束命名，可通过ApiInvokerAssemblyAttribute上的属性辅助查找

名称 说明
SuccessFlag 如果有多个值，用 逗号、空格、分号 隔开
MessageFlag 如果有多个值，用 逗号、空格、分号 隔开

生成代码示例

接口定义

[AddAspectHandler(AspectType = typeof(ExceptionAop))]
[AddAspectHandler(AspectType = typeof(TestAop))]
[WebController(Route = "hello/test")]
public interface IHelloService
{
    Task<string> SayHelloAsync(string name);
    Task<string> TestHeaderParameter([WebMethodParameterBinding(BindingType.FromHeader)] string name);
    Task<string> TestQueryParameter([WebMethodParameterBinding(BindingType.FromQuery)] string name);
    Task<string> TestQueryParameter2(string name, int age);

    Task<QueryResult<int>> TestReturnQueryResultInt(string name);
    Task<QueryResult> TestReturnQueryResult(string name);

    [WebMethod(Method = WebMethod.Get)]
    //[ApiInvokeNotSupported]
    Task<(bool Success, string Message, (string Prop, int Value) Info)> TestReturnTuple(string name);

    [WebMethod(Method = WebMethod.Get)]
    [ApiInvokeNotSupported]
    void TestReturnVoid();

    //[WebMethod(Route = "rp")]
    Task<string> TestRouterParameter(string test);
    Task<string> TestFormParameter([WebMethodParameterBinding(BindingType.FromForm)] string name);

    [WebMethod(Route = "{id}")]
    Task<string> TestMultiParameter([WebMethodParameterBinding(BindingType.FromRoute)] int id
        , [WebMethodParameterBinding(BindingType.FromQuery)] string name);

    Task<string> TestQueryAndBodyParameter([WebMethodParameterBinding(BindingType.FromQuery)] int id
        , [WebMethodParameterBinding(BindingType.FromBody)] RequestTest body);
}

WebController

// <auto-generated/>
#pragma warning disable
#nullable enable
namespace Blazor.Test.Client.Services
{
    [global::Microsoft.AspNetCore.Mvc.ApiController]
    [global::Microsoft.AspNetCore.Mvc.Route("api/hello/test")]
    [global::System.CodeDom.Compiler.GeneratedCode("AutoWasmApiGenerator.ControllerGenerator", "0.1.2.0")]
    /// <inheritdoc/>
    public class HelloServiceController : global::Microsoft.AspNetCore.Mvc.ControllerBase
    {
        private readonly Blazor.Test.Client.Services.IHelloService _proxyService_gen;

        public HelloServiceController(Blazor.Test.Client.Services.IHelloService service)
        {
            _proxyService_gen = service;
        }

        [global::Microsoft.AspNetCore.Mvc.HttpPost("SayHello")]
        [global::System.CodeDom.Compiler.GeneratedCode("AutoWasmApiGenerator.ControllerGenerator", "0.1.2.0")]
        public System.Threading.Tasks.Task<string> SayHelloAsync([global::Microsoft.AspNetCore.Mvc.FromQuery]string name)
          => _proxyService_gen.SayHelloAsync(name);

        [global::Microsoft.AspNetCore.Mvc.HttpPost("TestHeaderParameter")]
        [global::System.CodeDom.Compiler.GeneratedCode("AutoWasmApiGenerator.ControllerGenerator", "0.1.2.0")]
        public System.Threading.Tasks.Task<string> TestHeaderParameter([global::Microsoft.AspNetCore.Mvc.FromHeader]string name)
          => _proxyService_gen.TestHeaderParameter(name);

        [global::Microsoft.AspNetCore.Mvc.HttpPost("TestQueryParameter")]
        [global::System.CodeDom.Compiler.GeneratedCode("AutoWasmApiGenerator.ControllerGenerator", "0.1.2.0")]
        public System.Threading.Tasks.Task<string> TestQueryParameter([global::Microsoft.AspNetCore.Mvc.FromQuery]string name)
          => _proxyService_gen.TestQueryParameter(name);

        [global::Microsoft.AspNetCore.Mvc.HttpPost("TestQueryParameter2")]
        [global::System.CodeDom.Compiler.GeneratedCode("AutoWasmApiGenerator.ControllerGenerator", "0.1.2.0")]
        public System.Threading.Tasks.Task<string> TestQueryParameter2([global::Microsoft.AspNetCore.Mvc.FromQuery]string name, [global::Microsoft.AspNetCore.Mvc.FromQuery]int age)
          => _proxyService_gen.TestQueryParameter2(name, age);

        [global::Microsoft.AspNetCore.Mvc.HttpPost("TestReturnQueryResultInt")]
        [global::System.CodeDom.Compiler.GeneratedCode("AutoWasmApiGenerator.ControllerGenerator", "0.1.2.0")]
        public System.Threading.Tasks.Task<Blazor.Test.Client.Models.QueryResult<int>> TestReturnQueryResultInt([global::Microsoft.AspNetCore.Mvc.FromQuery]string name)
          => _proxyService_gen.TestReturnQueryResultInt(name);

        [global::Microsoft.AspNetCore.Mvc.HttpPost("TestReturnQueryResult")]
        [global::System.CodeDom.Compiler.GeneratedCode("AutoWasmApiGenerator.ControllerGenerator", "0.1.2.0")]
        public System.Threading.Tasks.Task<Blazor.Test.Client.Models.QueryResult> TestReturnQueryResult([global::Microsoft.AspNetCore.Mvc.FromQuery]string name)
          => _proxyService_gen.TestReturnQueryResult(name);

        [global::Microsoft.AspNetCore.Mvc.HttpGet("TestReturnTuple")]
        [global::System.CodeDom.Compiler.GeneratedCode("AutoWasmApiGenerator.ControllerGenerator", "0.1.2.0")]
        public async global::System.Threading.Tasks.Task<string> TestReturnTuple([global::Microsoft.AspNetCore.Mvc.FromQuery]string name)
        {
            var _return_gen = await _proxyService_gen.TestReturnTuple(name);
            var _anonymous_gen = new {Success=_return_gen.Success,Message=_return_gen.Message,Info=new {Prop=_return_gen.Info.Prop,Value=_return_gen.Info.Value,}};
            return global::System.Text.Json.JsonSerializer.Serialize(_anonymous_gen, AutoWasmApiGenerator.AutoWasmApiGeneratorJsonHelper.TupleOption);
        }

        [global::Microsoft.AspNetCore.Mvc.HttpGet("TestReturnVoid")]
        [global::System.CodeDom.Compiler.GeneratedCode("AutoWasmApiGenerator.ControllerGenerator", "0.1.2.0")]
        public void TestReturnVoid()
          => _proxyService_gen.TestReturnVoid();

        [global::Microsoft.AspNetCore.Mvc.HttpPost("TestRouterParameter")]
        [global::System.CodeDom.Compiler.GeneratedCode("AutoWasmApiGenerator.ControllerGenerator", "0.1.2.0")]
        public System.Threading.Tasks.Task<string> TestRouterParameter([global::Microsoft.AspNetCore.Mvc.FromQuery]string test)
          => _proxyService_gen.TestRouterParameter(test);

        [global::Microsoft.AspNetCore.Mvc.HttpPost("TestFormParameter")]
        [global::System.CodeDom.Compiler.GeneratedCode("AutoWasmApiGenerator.ControllerGenerator", "0.1.2.0")]
        public System.Threading.Tasks.Task<string> TestFormParameter([global::Microsoft.AspNetCore.Mvc.FromForm]string name)
          => _proxyService_gen.TestFormParameter(name);

        [global::Microsoft.AspNetCore.Mvc.HttpPost("TestMultiParameter/{id}")]
        [global::System.CodeDom.Compiler.GeneratedCode("AutoWasmApiGenerator.ControllerGenerator", "0.1.2.0")]
        public System.Threading.Tasks.Task<string> TestMultiParameter([global::Microsoft.AspNetCore.Mvc.FromRoute]int id, [global::Microsoft.AspNetCore.Mvc.FromQuery]string name)
          => _proxyService_gen.TestMultiParameter(id, name);

        [global::Microsoft.AspNetCore.Mvc.HttpPost("TestQueryAndBodyParameter")]
        [global::System.CodeDom.Compiler.GeneratedCode("AutoWasmApiGenerator.ControllerGenerator", "0.1.2.0")]
        public System.Threading.Tasks.Task<string> TestQueryAndBodyParameter([global::Microsoft.AspNetCore.Mvc.FromQuery]int id, [global::Microsoft.AspNetCore.Mvc.FromBody]Blazor.Test.Client.Services.RequestTest body)
          => _proxyService_gen.TestQueryAndBodyParameter(id, body);
    }
}

接口调用类

using Microsoft.Extensions.DependencyInjection;
// <auto-generated/>
#pragma warning disable
#nullable enable
namespace Blazor.Test.Client.Services
{
    [global::System.CodeDom.Compiler.GeneratedCode("AutoWasmApiGenerator.ApiInvokerGenerator", "0.1.2.0")]
    /// <inheritdoc/>
    public partial class HelloServiceApiInvoker : Blazor.Test.Client.Services.IHelloService
    {
        private readonly global::System.Net.Http.IHttpClientFactory clientFactory;

        private readonly global::AutoWasmApiGenerator.IGeneratedApiInvokeDelegatingHandler delegatingHandler;

        private readonly global::System.IServiceProvider serviceProvider;

        public HelloServiceApiInvoker(global::System.Net.Http.IHttpClientFactory factory, global::System.IServiceProvider services)
        {
            clientFactory = factory;
            serviceProvider = services;
            delegatingHandler = services.GetService<global::AutoWasmApiGenerator.IGeneratedApiInvokeDelegatingHandler>() ?? global::AutoWasmApiGenerator.GeneratedApiInvokeDelegatingHandler.Default;
        }

        [global::System.CodeDom.Compiler.GeneratedCode("AutoWasmApiGenerator.ApiInvokerGenerator", "0.1.2.0")]
        public async System.Threading.Tasks.Task<string> SayHelloAsync(string name)
        {
            var _client_gen = this.clientFactory.CreateClient("HelloService");
            var _request_gen = new global::System.Net.Http.HttpRequestMessage();
            _request_gen.Method = global::System.Net.Http.HttpMethod.Post;
            var _url_gen = $"api/hello/test/SayHello";
            var _queries_gen = new List<string>();
            _queries_gen.Add($"{nameof(name)}={name}");
            _url_gen = $"{_url_gen}?{string.Join("&", _queries_gen)}";
            _request_gen.RequestUri = new global::System.Uri(_url_gen, UriKind.Relative);
            var _send_context = new global::AutoWasmApiGenerator.SendContext(typeof(Blazor.Test.Client.Services.IHelloService), nameof(SayHelloAsync), _request_gen);
            _send_context.Parameters = [name];
            _send_context.ReturnType = typeof(string);
            try
            {
                await delegatingHandler.BeforeSendAsync(_send_context);
                using var _response_gen = await _client_gen.SendAsync(_request_gen);
                _send_context.Response = _response_gen;
                _response_gen.EnsureSuccessStatusCode();
                await delegatingHandler.AfterSendAsync(_send_context);
                var _str_gen = await _response_gen.Content.ReadAsStringAsync();
                return _str_gen;
            }
            catch(Exception ex)
            {
                var _ex_context = new global::AutoWasmApiGenerator.ExceptionContext(_send_context, ex);
                await delegatingHandler.OnExceptionAsync(_ex_context);
                if (!_ex_context.Handled)
                {
                    throw;
                }
                var errorResultFactory = serviceProvider.GetService<global::AutoWasmApiGenerator.IExceptionResultFactory>();
                if (errorResultFactory?.GetErrorResult<string>(_ex_context, out var _default_result) == true)
                {
                    return _default_result;
                }
                return default;
            }
        }

        [global::System.CodeDom.Compiler.GeneratedCode("AutoWasmApiGenerator.ApiInvokerGenerator", "0.1.2.0")]
        public async System.Threading.Tasks.Task<string> TestHeaderParameter(string name)
        {
            var _client_gen = this.clientFactory.CreateClient("HelloService");
            var _request_gen = new global::System.Net.Http.HttpRequestMessage();
            _request_gen.Method = global::System.Net.Http.HttpMethod.Post;
            var _url_gen = $"api/hello/test/TestHeaderParameter";
            _request_gen.Headers.Add(nameof(name), $"{name}");
            _request_gen.RequestUri = new global::System.Uri(_url_gen, UriKind.Relative);
            var _send_context = new global::AutoWasmApiGenerator.SendContext(typeof(Blazor.Test.Client.Services.IHelloService), nameof(TestHeaderParameter), _request_gen);
            _send_context.Parameters = [name];
            _send_context.ReturnType = typeof(string);
            try
            {
                await delegatingHandler.BeforeSendAsync(_send_context);
                using var _response_gen = await _client_gen.SendAsync(_request_gen);
                _send_context.Response = _response_gen;
                _response_gen.EnsureSuccessStatusCode();
                await delegatingHandler.AfterSendAsync(_send_context);
                var _str_gen = await _response_gen.Content.ReadAsStringAsync();
                return _str_gen;
            }
            catch(Exception ex)
            {
                var _ex_context = new global::AutoWasmApiGenerator.ExceptionContext(_send_context, ex);
                await delegatingHandler.OnExceptionAsync(_ex_context);
                if (!_ex_context.Handled)
                {
                    throw;
                }
                var errorResultFactory = serviceProvider.GetService<global::AutoWasmApiGenerator.IExceptionResultFactory>();
                if (errorResultFactory?.GetErrorResult<string>(_ex_context, out var _default_result) == true)
                {
                    return _default_result;
                }
                return default;
            }
        }

        [global::System.CodeDom.Compiler.GeneratedCode("AutoWasmApiGenerator.ApiInvokerGenerator", "0.1.2.0")]
        public async System.Threading.Tasks.Task<string> TestQueryParameter(string name)
        {
            var _client_gen = this.clientFactory.CreateClient("HelloService");
            var _request_gen = new global::System.Net.Http.HttpRequestMessage();
            _request_gen.Method = global::System.Net.Http.HttpMethod.Post;
            var _url_gen = $"api/hello/test/TestQueryParameter";
            var _queries_gen = new List<string>();
            _queries_gen.Add($"{nameof(name)}={name}");
            _url_gen = $"{_url_gen}?{string.Join("&", _queries_gen)}";
            _request_gen.RequestUri = new global::System.Uri(_url_gen, UriKind.Relative);
            var _send_context = new global::AutoWasmApiGenerator.SendContext(typeof(Blazor.Test.Client.Services.IHelloService), nameof(TestQueryParameter), _request_gen);
            _send_context.Parameters = [name];
            _send_context.ReturnType = typeof(string);
            try
            {
                await delegatingHandler.BeforeSendAsync(_send_context);
                using var _response_gen = await _client_gen.SendAsync(_request_gen);
                _send_context.Response = _response_gen;
                _response_gen.EnsureSuccessStatusCode();
                await delegatingHandler.AfterSendAsync(_send_context);
                var _str_gen = await _response_gen.Content.ReadAsStringAsync();
                return _str_gen;
            }
            catch(Exception ex)
            {
                var _ex_context = new global::AutoWasmApiGenerator.ExceptionContext(_send_context, ex);
                await delegatingHandler.OnExceptionAsync(_ex_context);
                if (!_ex_context.Handled)
                {
                    throw;
                }
                var errorResultFactory = serviceProvider.GetService<global::AutoWasmApiGenerator.IExceptionResultFactory>();
                if (errorResultFactory?.GetErrorResult<string>(_ex_context, out var _default_result) == true)
                {
                    return _default_result;
                }
                return default;
            }
        }

        [global::System.CodeDom.Compiler.GeneratedCode("AutoWasmApiGenerator.ApiInvokerGenerator", "0.1.2.0")]
        public async System.Threading.Tasks.Task<string> TestQueryParameter2(string name, int age)
        {
            var _client_gen = this.clientFactory.CreateClient("HelloService");
            var _request_gen = new global::System.Net.Http.HttpRequestMessage();
            _request_gen.Method = global::System.Net.Http.HttpMethod.Post;
            var _url_gen = $"api/hello/test/TestQueryParameter2";
            var _queries_gen = new List<string>();
            _queries_gen.Add($"{nameof(name)}={name}");
            _queries_gen.Add($"{nameof(age)}={age}");
            _url_gen = $"{_url_gen}?{string.Join("&", _queries_gen)}";
            _request_gen.RequestUri = new global::System.Uri(_url_gen, UriKind.Relative);
            var _send_context = new global::AutoWasmApiGenerator.SendContext(typeof(Blazor.Test.Client.Services.IHelloService), nameof(TestQueryParameter2), _request_gen);
            _send_context.Parameters = [name, age];
            _send_context.ReturnType = typeof(string);
            try
            {
                await delegatingHandler.BeforeSendAsync(_send_context);
                using var _response_gen = await _client_gen.SendAsync(_request_gen);
                _send_context.Response = _response_gen;
                _response_gen.EnsureSuccessStatusCode();
                await delegatingHandler.AfterSendAsync(_send_context);
                var _str_gen = await _response_gen.Content.ReadAsStringAsync();
                return _str_gen;
            }
            catch(Exception ex)
            {
                var _ex_context = new global::AutoWasmApiGenerator.ExceptionContext(_send_context, ex);
                await delegatingHandler.OnExceptionAsync(_ex_context);
                if (!_ex_context.Handled)
                {
                    throw;
                }
                var errorResultFactory = serviceProvider.GetService<global::AutoWasmApiGenerator.IExceptionResultFactory>();
                if (errorResultFactory?.GetErrorResult<string>(_ex_context, out var _default_result) == true)
                {
                    return _default_result;
                }
                return default;
            }
        }

        [global::System.CodeDom.Compiler.GeneratedCode("AutoWasmApiGenerator.ApiInvokerGenerator", "0.1.2.0")]
        public async System.Threading.Tasks.Task<Blazor.Test.Client.Models.QueryResult<int>> TestReturnQueryResultInt(string name)
        {
            var _client_gen = this.clientFactory.CreateClient("HelloService");
            var _request_gen = new global::System.Net.Http.HttpRequestMessage();
            _request_gen.Method = global::System.Net.Http.HttpMethod.Post;
            var _url_gen = $"api/hello/test/TestReturnQueryResultInt";
            var _queries_gen = new List<string>();
            _queries_gen.Add($"{nameof(name)}={name}");
            _url_gen = $"{_url_gen}?{string.Join("&", _queries_gen)}";
            _request_gen.RequestUri = new global::System.Uri(_url_gen, UriKind.Relative);
            var _send_context = new global::AutoWasmApiGenerator.SendContext(typeof(Blazor.Test.Client.Services.IHelloService), nameof(TestReturnQueryResultInt), _request_gen);
            _send_context.Parameters = [name];
            _send_context.ReturnType = typeof(Blazor.Test.Client.Models.QueryResult<int>);
            try
            {
                await delegatingHandler.BeforeSendAsync(_send_context);
                using var _response_gen = await _client_gen.SendAsync(_request_gen);
                _send_context.Response = _response_gen;
                _response_gen.EnsureSuccessStatusCode();
                await delegatingHandler.AfterSendAsync(_send_context);
                using var _stream_gen = await _response_gen.Content.ReadAsStreamAsync();
                return global::System.Text.Json.JsonSerializer.Deserialize<Blazor.Test.Client.Models.QueryResult<int>>(_stream_gen, AutoWasmApiGenerator.AutoWasmApiGeneratorJsonHelper.Option);
            }
            catch(Exception ex)
            {
                var _ex_context = new global::AutoWasmApiGenerator.ExceptionContext(_send_context, ex);
                await delegatingHandler.OnExceptionAsync(_ex_context);
                if (!_ex_context.Handled)
                {
                    throw;
                }
                var errorResultFactory = serviceProvider.GetService<global::AutoWasmApiGenerator.IExceptionResultFactory>();
                if (errorResultFactory?.GetErrorResult<Blazor.Test.Client.Models.QueryResult<int>>(_ex_context, out var _default_result) == true)
                {
                    return _default_result;
                }
                Blazor.Test.Client.Models.QueryResult<int> _gen_return = new();
                _gen_return.IsSuccess = false;
                _gen_return.Message = ex.Message;
                return _gen_return;
            }
        }

        [global::System.CodeDom.Compiler.GeneratedCode("AutoWasmApiGenerator.ApiInvokerGenerator", "0.1.2.0")]
        public async System.Threading.Tasks.Task<Blazor.Test.Client.Models.QueryResult> TestReturnQueryResult(string name)
        {
            var _client_gen = this.clientFactory.CreateClient("HelloService");
            var _request_gen = new global::System.Net.Http.HttpRequestMessage();
            _request_gen.Method = global::System.Net.Http.HttpMethod.Post;
            var _url_gen = $"api/hello/test/TestReturnQueryResult";
            var _queries_gen = new List<string>();
            _queries_gen.Add($"{nameof(name)}={name}");
            _url_gen = $"{_url_gen}?{string.Join("&", _queries_gen)}";
            _request_gen.RequestUri = new global::System.Uri(_url_gen, UriKind.Relative);
            var _send_context = new global::AutoWasmApiGenerator.SendContext(typeof(Blazor.Test.Client.Services.IHelloService), nameof(TestReturnQueryResult), _request_gen);
            _send_context.Parameters = [name];
            _send_context.ReturnType = typeof(Blazor.Test.Client.Models.QueryResult);
            try
            {
                await delegatingHandler.BeforeSendAsync(_send_context);
                using var _response_gen = await _client_gen.SendAsync(_request_gen);
                _send_context.Response = _response_gen;
                _response_gen.EnsureSuccessStatusCode();
                await delegatingHandler.AfterSendAsync(_send_context);
                using var _stream_gen = await _response_gen.Content.ReadAsStreamAsync();
                return global::System.Text.Json.JsonSerializer.Deserialize<Blazor.Test.Client.Models.QueryResult>(_stream_gen, AutoWasmApiGenerator.AutoWasmApiGeneratorJsonHelper.Option);
            }
            catch(Exception ex)
            {
                var _ex_context = new global::AutoWasmApiGenerator.ExceptionContext(_send_context, ex);
                await delegatingHandler.OnExceptionAsync(_ex_context);
                if (!_ex_context.Handled)
                {
                    throw;
                }
                var errorResultFactory = serviceProvider.GetService<global::AutoWasmApiGenerator.IExceptionResultFactory>();
                if (errorResultFactory?.GetErrorResult<Blazor.Test.Client.Models.QueryResult>(_ex_context, out var _default_result) == true)
                {
                    return _default_result;
                }
                Blazor.Test.Client.Models.QueryResult _gen_return = new();
                _gen_return.IsSuccess = false;
                _gen_return.Message = ex.Message;
                return _gen_return;
            }
        }

        [global::System.CodeDom.Compiler.GeneratedCode("AutoWasmApiGenerator.ApiInvokerGenerator", "0.1.2.0")]
        public async System.Threading.Tasks.Task<(bool Success, string Message, (string Prop, int Value) Info)> TestReturnTuple(string name)
        {
            var _client_gen = this.clientFactory.CreateClient("HelloService");
            var _request_gen = new global::System.Net.Http.HttpRequestMessage();
            _request_gen.Method = global::System.Net.Http.HttpMethod.Get;
            var _url_gen = $"api/hello/test/TestReturnTuple";
            var _queries_gen = new List<string>();
            _queries_gen.Add($"{nameof(name)}={name}");
            _url_gen = $"{_url_gen}?{string.Join("&", _queries_gen)}";
            _request_gen.RequestUri = new global::System.Uri(_url_gen, UriKind.Relative);
            var _send_context = new global::AutoWasmApiGenerator.SendContext(typeof(Blazor.Test.Client.Services.IHelloService), nameof(TestReturnTuple), _request_gen);
            _send_context.Parameters = [name];
            _send_context.ReturnType = typeof((bool Success, string Message, (string Prop, int Value) Info));
            try
            {
                await delegatingHandler.BeforeSendAsync(_send_context);
                using var _response_gen = await _client_gen.SendAsync(_request_gen);
                _send_context.Response = _response_gen;
                _response_gen.EnsureSuccessStatusCode();
                await delegatingHandler.AfterSendAsync(_send_context);
                var _json_string_gen = await _response_gen.Content.ReadAsStringAsync();
                var _jsonElement_gen = global::System.Text.Json.JsonDocument.Parse(_json_string_gen).RootElement;
                return (_jsonElement_gen.GetProperty("Success").GetBoolean(),_jsonElement_gen.GetProperty("Message").GetString(),(_jsonElement_gen.GetProperty("Info").GetProperty("Prop").GetString(),_jsonElement_gen.GetProperty("Info").GetProperty("Value").GetInt32()));
            }
            catch(Exception ex)
            {
                var _ex_context = new global::AutoWasmApiGenerator.ExceptionContext(_send_context, ex);
                await delegatingHandler.OnExceptionAsync(_ex_context);
                if (!_ex_context.Handled)
                {
                    throw;
                }
                var errorResultFactory = serviceProvider.GetService<global::AutoWasmApiGenerator.IExceptionResultFactory>();
                if (errorResultFactory?.GetErrorResult<(bool Success, string Message, (string Prop, int Value) Info)>(_ex_context, out var _default_result) == true)
                {
                    return _default_result;
                }
                return (false, ex.Message, default);
            }
        }

        [global::System.CodeDom.Compiler.GeneratedCode("AutoWasmApiGenerator.ApiInvokerGenerator", "0.1.2.0")]
        public void TestReturnVoid()
          => throw new global::System.NotSupportedException();

        [global::System.CodeDom.Compiler.GeneratedCode("AutoWasmApiGenerator.ApiInvokerGenerator", "0.1.2.0")]
        public async System.Threading.Tasks.Task<string> TestRouterParameter(string test)
        {
            var _client_gen = this.clientFactory.CreateClient("HelloService");
            var _request_gen = new global::System.Net.Http.HttpRequestMessage();
            _request_gen.Method = global::System.Net.Http.HttpMethod.Post;
            var _url_gen = $"api/hello/test/TestRouterParameter";
            var _queries_gen = new List<string>();
            _queries_gen.Add($"{nameof(test)}={test}");
            _url_gen = $"{_url_gen}?{string.Join("&", _queries_gen)}";
            _request_gen.RequestUri = new global::System.Uri(_url_gen, UriKind.Relative);
            var _send_context = new global::AutoWasmApiGenerator.SendContext(typeof(Blazor.Test.Client.Services.IHelloService), nameof(TestRouterParameter), _request_gen);
            _send_context.Parameters = [test];
            _send_context.ReturnType = typeof(string);
            try
            {
                await delegatingHandler.BeforeSendAsync(_send_context);
                using var _response_gen = await _client_gen.SendAsync(_request_gen);
                _send_context.Response = _response_gen;
                _response_gen.EnsureSuccessStatusCode();
                await delegatingHandler.AfterSendAsync(_send_context);
                var _str_gen = await _response_gen.Content.ReadAsStringAsync();
                return _str_gen;
            }
            catch(Exception ex)
            {
                var _ex_context = new global::AutoWasmApiGenerator.ExceptionContext(_send_context, ex);
                await delegatingHandler.OnExceptionAsync(_ex_context);
                if (!_ex_context.Handled)
                {
                    throw;
                }
                var errorResultFactory = serviceProvider.GetService<global::AutoWasmApiGenerator.IExceptionResultFactory>();
                if (errorResultFactory?.GetErrorResult<string>(_ex_context, out var _default_result) == true)
                {
                    return _default_result;
                }
                return default;
            }
        }

        [global::System.CodeDom.Compiler.GeneratedCode("AutoWasmApiGenerator.ApiInvokerGenerator", "0.1.2.0")]
        public async System.Threading.Tasks.Task<string> TestFormParameter(string name)
        {
            var _client_gen = this.clientFactory.CreateClient("HelloService");
            var _request_gen = new global::System.Net.Http.HttpRequestMessage();
            _request_gen.Method = global::System.Net.Http.HttpMethod.Post;
            var _url_gen = $"api/hello/test/TestFormParameter";
            var _formDatas_gen = new List<global::System.Collections.Generic.KeyValuePair<string, string>>();
            _formDatas_gen.Add(new global::System.Collections.Generic.KeyValuePair<string, string>(nameof(name), $"{name}"));
            var _formContent_gen = new global::System.Net.Http.FormUrlEncodedContent(_formDatas_gen);
            _formContent_gen.Headers.ContentType = new("application/x-www-form-urlencoded");
            _request_gen.Content = _formContent_gen;
            _request_gen.RequestUri = new global::System.Uri(_url_gen, UriKind.Relative);
            var _send_context = new global::AutoWasmApiGenerator.SendContext(typeof(Blazor.Test.Client.Services.IHelloService), nameof(TestFormParameter), _request_gen);
            _send_context.Parameters = [name];
            _send_context.ReturnType = typeof(string);
            try
            {
                await delegatingHandler.BeforeSendAsync(_send_context);
                using var _response_gen = await _client_gen.SendAsync(_request_gen);
                _send_context.Response = _response_gen;
                _response_gen.EnsureSuccessStatusCode();
                await delegatingHandler.AfterSendAsync(_send_context);
                var _str_gen = await _response_gen.Content.ReadAsStringAsync();
                return _str_gen;
            }
            catch(Exception ex)
            {
                var _ex_context = new global::AutoWasmApiGenerator.ExceptionContext(_send_context, ex);
                await delegatingHandler.OnExceptionAsync(_ex_context);
                if (!_ex_context.Handled)
                {
                    throw;
                }
                var errorResultFactory = serviceProvider.GetService<global::AutoWasmApiGenerator.IExceptionResultFactory>();
                if (errorResultFactory?.GetErrorResult<string>(_ex_context, out var _default_result) == true)
                {
                    return _default_result;
                }
                return default;
            }
        }

        [global::System.CodeDom.Compiler.GeneratedCode("AutoWasmApiGenerator.ApiInvokerGenerator", "0.1.2.0")]
        public async System.Threading.Tasks.Task<string> TestMultiParameter(int id, string name)
        {
            var _client_gen = this.clientFactory.CreateClient("HelloService");
            var _request_gen = new global::System.Net.Http.HttpRequestMessage();
            _request_gen.Method = global::System.Net.Http.HttpMethod.Post;
            var _url_gen = $"api/hello/test/TestMultiParameter/{id}";
            var _queries_gen = new List<string>();
            _queries_gen.Add($"{nameof(name)}={name}");
            _url_gen = $"{_url_gen}?{string.Join("&", _queries_gen)}";
            _request_gen.RequestUri = new global::System.Uri(_url_gen, UriKind.Relative);
            var _send_context = new global::AutoWasmApiGenerator.SendContext(typeof(Blazor.Test.Client.Services.IHelloService), nameof(TestMultiParameter), _request_gen);
            _send_context.Parameters = [id, name];
            _send_context.ReturnType = typeof(string);
            try
            {
                await delegatingHandler.BeforeSendAsync(_send_context);
                using var _response_gen = await _client_gen.SendAsync(_request_gen);
                _send_context.Response = _response_gen;
                _response_gen.EnsureSuccessStatusCode();
                await delegatingHandler.AfterSendAsync(_send_context);
                var _str_gen = await _response_gen.Content.ReadAsStringAsync();
                return _str_gen;
            }
            catch(Exception ex)
            {
                var _ex_context = new global::AutoWasmApiGenerator.ExceptionContext(_send_context, ex);
                await delegatingHandler.OnExceptionAsync(_ex_context);
                if (!_ex_context.Handled)
                {
                    throw;
                }
                var errorResultFactory = serviceProvider.GetService<global::AutoWasmApiGenerator.IExceptionResultFactory>();
                if (errorResultFactory?.GetErrorResult<string>(_ex_context, out var _default_result) == true)
                {
                    return _default_result;
                }
                return default;
            }
        }

        [global::System.CodeDom.Compiler.GeneratedCode("AutoWasmApiGenerator.ApiInvokerGenerator", "0.1.2.0")]
        public async System.Threading.Tasks.Task<string> TestQueryAndBodyParameter(int id, Blazor.Test.Client.Services.RequestTest body)
        {
            var _client_gen = this.clientFactory.CreateClient("HelloService");
            var _request_gen = new global::System.Net.Http.HttpRequestMessage();
            _request_gen.Method = global::System.Net.Http.HttpMethod.Post;
            var _url_gen = $"api/hello/test/TestQueryAndBodyParameter";
            var _queries_gen = new List<string>();
            _queries_gen.Add($"{nameof(id)}={id}");
            _url_gen = $"{_url_gen}?{string.Join("&", _queries_gen)}";
            var _json_gen = global::System.Text.Json.JsonSerializer.Serialize(body);
            _request_gen.Content = new global::System.Net.Http.StringContent(_json_gen, global::System.Text.Encoding.UTF8, "application/json");
            _request_gen.RequestUri = new global::System.Uri(_url_gen, UriKind.Relative);
            var _send_context = new global::AutoWasmApiGenerator.SendContext(typeof(Blazor.Test.Client.Services.IHelloService), nameof(TestQueryAndBodyParameter), _request_gen);
            _send_context.Parameters = [id, body];
            _send_context.ReturnType = typeof(string);
            try
            {
                await delegatingHandler.BeforeSendAsync(_send_context);
                using var _response_gen = await _client_gen.SendAsync(_request_gen);
                _send_context.Response = _response_gen;
                _response_gen.EnsureSuccessStatusCode();
                await delegatingHandler.AfterSendAsync(_send_context);
                var _str_gen = await _response_gen.Content.ReadAsStringAsync();
                return _str_gen;
            }
            catch(Exception ex)
            {
                var _ex_context = new global::AutoWasmApiGenerator.ExceptionContext(_send_context, ex);
                await delegatingHandler.OnExceptionAsync(_ex_context);
                if (!_ex_context.Handled)
                {
                    throw;
                }
                var errorResultFactory = serviceProvider.GetService<global::AutoWasmApiGenerator.IExceptionResultFactory>();
                if (errorResultFactory?.GetErrorResult<string>(_ex_context, out var _default_result) == true)
                {
                    return _default_result;
                }
                return default;
            }
        }
    }
}

感谢 ⭐start⭐ 支持项目源码

生成器源码

posted @ 2024-08-15 11:49  yaoqinglin_mtiter  阅读(421)  评论(3)    收藏  举报