using dotnetCampus.Ipc.PipeMvcServer;
    private static void RunMvc(string[] args)
    {
        var builder = WebApplication.CreateBuilder(args);
        // 下面一句是關鍵邏輯
        builder.WebHost.UsePipeIpcServer("PipeMvcServerDemo");
        builder.Services.AddControllers();
        var app = builder.Build();
        app.MapControllers();
        app.Run();
    }

using dotnetCampus.Ipc.PipeMvcClient;
        HttpClient ipcPipeMvcClient = await IpcPipeMvcClientProvider.CreateIpcMvcClientAsync("PipeMvcServerDemo");

[Route("api/[controller]")]
[ApiController]
public class FooController : ControllerBase
{
    public FooController(ILogger<FooController> logger)
    {
        Logger = logger;
    }
    public ILogger<FooController> Logger { get; }
}

[HttpGet]
    public IActionResult Get()
    {
        Logger.LogInformation("FooController_Get");
        return Ok(DateTime.Now.ToString());
    }

 <Button x:Name="GetFooButton" Margin="10,10,10,10" Click="GetFooButton_Click">Get</Button>

using System.Net.Http;

    private async void MainWindow_Loaded(object sender, RoutedEventArgs e)
    {
        Log($"Start create PipeMvcClient.");
        var ipcPipeMvcClient = await IpcPipeMvcClientProvider.CreateIpcMvcClientAsync("PipeMvcServerDemo");
        _ipcPipeMvcClient = ipcPipeMvcClient;
        Log($"Finish create PipeMvcClient.");
    }
    private HttpClient? _ipcPipeMvcClient;
    private async void GetFooButton_Click(object sender, RoutedEventArgs e)
        if (_ipcPipeMvcClient is null)
        {
            return;
        }
        Log($"[Request][Get] IpcPipeMvcServer://api/Foo");
        var response = await _ipcPipeMvcClient.GetStringAsync("api/Foo");
        Log($"[Response][Get] IpcPipeMvcServer://api/Foo {response}");

public class FooController : ControllerBase
{
    [HttpGet("Add")]
    public IActionResult Add(int a, int b)
    {
        Logger.LogInformation($"FooController_Add a={a};b=");
        return Ok(a + b);
    }
}

private async void GetFooWithArgumentButton_Click(object sender, RoutedEventArgs e)
    {
        Log($"[Request][Get] IpcPipeMvcServer://api/Foo/Add");
        var response = await _ipcPipeMvcClient.GetStringAsync("api/Foo/Add?a=1&b=1");
        Log($"[Response][Get] IpcPipeMvcServer://api/Foo/Add {response}");
    }

[HttpPost]
    public IActionResult Post()
    {
        Logger.LogInformation("FooController_Post");
        return Ok($"POST {DateTime.Now}");
    }

private async void PostFooButton_Click(object sender, RoutedEventArgs e)
    {
        Log($"[Request][Post] IpcPipeMvcServer://api/Foo");
        var response = await _ipcPipeMvcClient.PostAsync("api/Foo", new StringContent(""));
        var m = await response.Content.ReadAsStringAsync();
        Log($"[Response][Post] IpcPipeMvcServer://api/Foo {response.StatusCode} {m}");
    }

 [HttpPost("PostFoo")]
    public IActionResult PostFooContent(FooContent foo)
    {
        Logger.LogInformation($"FooController_PostFooContent Foo1={foo.Foo1};Foo2={foo.Foo2 ?? "<NULL>"}");
        return Ok($"PostFooContent Foo1={foo.Foo1};Foo2={foo.Foo2 ?? "<NULL>"}");
    }

public class FooContent
{
    public string? Foo1 { set; get; }
    public string? Foo2 { set; get; }
}

private async void PostFooWithArgumentButton_Click(object sender, RoutedEventArgs e)
    {
        Log($"[Request][Post] IpcPipeMvcServer://api/Foo");

        var json = JsonSerializer.Serialize(new FooContent
        {
            Foo1 = "Foo PostFooWithArgumentButton",
            Foo2 = null,
        });
        StringContent content = new StringContent(json, Encoding.UTF8, "application/json");
        var response = await _ipcPipeMvcClient.PostAsync("api/Foo/PostFoo", content);
        var m = await response.Content.ReadAsStringAsync();
        Log($"[Response][Post] IpcPipeMvcServer://api/Foo/PostFoo {response.StatusCode} {m}");
    }

class IpcNamedPipeClientHandler : HttpMessageHandler
    {
        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            // 序列化請求消息，準備通過 IPC 層發(fā)送
            var message = HttpMessageSerializer.Serialize(request);

            // 創(chuàng)建 IPC 消息的 Tag 內(nèi)容，此 Tag 內(nèi)容僅用來調(diào)試和記錄日志
            var ipcMessageTag = request.RequestUri?.ToString() ?? request.Method.ToString();
            // 在 dotnetCampus.Ipc 層，采用 P2P 模型，沒有具體的服務端和客戶端
            // 但是 P2P 模型是可以模擬 C/S 模型的，只需要讓某個端（Peer）充當服務端，另外的端充當客戶端即可
            // 在 dotnetCampus.Ipc 庫里，采用 PeerProxy 表示某個端
            // 這里的端表示的是 IPC 的某個端，大部分時候可以認為是一個進程
            // 以下的 ServerProxy 就是充當服務端的一個端，將在此框架內(nèi)被初始化創(chuàng)建
            // 通過 PeerProxy 發(fā)送 IPC 請求，此時的 IPC 請求將會被 PipeMvcServer 處理
            // 在 PipeMvcServer 里面，將通過 ASP.NET Core MVC 框架層進行調(diào)度，分發(fā)到對應的控制器處理
            // 控制器處理完成之后，將由 MVC 框架層將控制器的輸出交給 PipeMvcServer 層
            // 在 PipeMvcServer 層收到控制器的輸出之后，將通過 IPC 框架，將輸出返回給 PipeMvcClient 端
            // 當 PipeMvcClient 收到輸出返回值后，以下的 await 方法將會返回
            var response = await ServerProxy.GetResponseAsync(new IpcMessage(ipcMessageTag, message));
            // 將 IPC 返回的消息反序列化為 HttpResponseMessage 用于接入 HttpClient 框架
            return HttpMessageSerializer.DeserializeToResponse(response.Body);
        }
        private PeerProxy ServerProxy { get; }
        // 忽略其他代碼
    }

/// <summary>
    /// 提供給客戶端調(diào)用 MVC 的 Ipc 服務的功能
    /// </summary>
    public static class IpcPipeMvcClientProvider
    {
        /// <summary>
        /// 獲取訪問 Mvc 的 Ipc 服務的對象
        /// </summary>
        /// <param name="ipcPipeMvcServerName">對方 Ipc 服務名</param>
        /// <param name="clientIpcProvider">可選，用來進行 Ipc 連接的本地服務。如不傳或是空，將創(chuàng)建新的 Ipc 連接服務</param>
        /// <returns></returns>
        public static async Task<HttpClient> CreateIpcMvcClientAsync(string ipcPipeMvcServerName, IpcProvider? clientIpcProvider = null)
        {
            if (clientIpcProvider == null)
            {
                clientIpcProvider = new IpcProvider();
                clientIpcProvider.StartServer();
            }
            var peer = await clientIpcProvider.GetAndConnectToPeerAsync(ipcPipeMvcServerName);
            return new HttpClient(new IpcNamedPipeClientHandler(peer, clientIpcProvider))
                BaseAddress = new Uri(IpcPipeMvcContext.BaseAddressUrl),
            };
        }
    }

public class IpcServer : IServer
    {
        public IpcServer(IServiceProvider services, IFeatureCollection featureCollection, IOptions<IpcServerOptions> optionsAccessor)
        {
        	// 忽略代碼
            var ipcCore = Services.GetRequiredService<IpcPipeMvcServerCore>();
            IpcPipeMvcServerCore = ipcCore;
        }

        Task IServer.StartAsync<TContext>(IHttpApplication<TContext> application, CancellationToken cancellationToken)
            // 忽略代碼
            IpcPipeMvcServerCore.Start();
        private IpcPipeMvcServerCore IpcPipeMvcServerCore { get; }
        // 忽略代碼
    }

 public static class WebHostBuilderExtensions
    {
        /// <summary>
        /// Enables the <see cref="IpcServer" /> service. 啟用命名管道IPC服務
        /// </summary>
        /// <param name="builder">The <see cref="IWebHostBuilder"/>.</param>
        /// <param name="ipcPipeName">設置 Ipc 服務的管道名</param>
        /// <returns>The <see cref="IWebHostBuilder"/>.</returns>
        public static IWebHostBuilder UsePipeIpcServer(this IWebHostBuilder builder, string ipcPipeName)
        {
            return builder.ConfigureServices(services =>
            {
            	// 忽略代碼
                services.AddSingleton<IServer, IpcServer>();
                services.AddSingleton<IpcPipeMvcServerCore>(s => new IpcPipeMvcServerCore(s, ipcPipeName));
            });
        }
    }

 class IpcPipeMvcServerCore
    {
        public IpcPipeMvcServerCore(IServiceProvider serviceProvider, string? ipcServerName)
        {
            ipcServerName ??= "IpcPipeMvcServer" + Guid.NewGuid().ToString("N");

            IpcServer = new IpcProvider(ipcServerName, new IpcConfiguration()
            {
                DefaultIpcRequestHandler = new DelegateIpcRequestHandler(async context =>
                {
                    // 核心代碼
                })
            });
        }
        public void Start() => IpcServer.StartServer();
        public IpcProvider IpcServer { set; get; }
    }

 IpcServer = new IpcProvider(ipcServerName, new IpcConfiguration()
            {
                DefaultIpcRequestHandler = new DelegateIpcRequestHandler(async context =>
                {
                	// 將請求反序列化為 HttpRequestMessage 對象
                	// 用于傳入到 ASP.NET Core 層
                    System.Net.Http.HttpRequestMessage? requestMessage = HttpMessageSerializer.DeserializeToRequest(context.IpcBufferMessage.Body);

                    // 創(chuàng)建虛擬的請求，進入到 ASP.NET Core 框架里
                    var server = (IpcServer) serviceProvider.GetRequiredService<IServer>();
                    var clientHandler = (ClientHandler) server.CreateHandler();
                    var response = await clientHandler.SendInnerAsync(requestMessage, CancellationToken.None);
                    // 拿到的返回值序列化為 IpcResponseMessageResult 放入 dotnetCampus.Ipc 層用來返回客戶端
                    var responseByteList = HttpMessageSerializer.Serialize(response);
                    return new IpcResponseMessageResult(new IpcMessage($"[Response][{requestMessage.Method}] {requestMessage.RequestUri}", responseByteList));
                })
            });

public class IpcServer : IServer
    {
        /// <summary>
        /// Creates a custom <see cref="HttpMessageHandler" /> for processing HTTP requests/responses with the test server.
        /// </summary>
        public HttpMessageHandler CreateHandler()
        {
        	// 忽略代碼
            return new ClientHandler(BaseAddress, Application) { AllowSynchronousIO = AllowSynchronousIO, PreserveExecutionContext = PreserveExecutionContext };
        }
    }

 public async Task<HttpResponseMessage> SendInnerAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
       
            // 創(chuàng)建 HttpContextBuilder 對象
            var contextBuilder = new HttpContextBuilder(_application, AllowSynchronousIO, PreserveExecutionContext);

            var requestContent = request.Content;
            if (requestContent != null)
            {
            	// 以下是對 HttpContextBuilder 的初始化邏輯
                // Read content from the request HttpContent into a pipe in a background task. This will allow the request
                // delegate to start before the request HttpContent is complete. A background task allows duplex streaming scenarios.
                contextBuilder.SendRequestStream(async writer =>
                {
                    // 忽略初始化邏輯
                });
            }
            contextBuilder.Configure((context, reader) =>
                // 忽略初始化邏輯
            });
            // 忽略其他代碼
            // 執(zhí)行實際的調(diào)用 ASP.NET Core 框架邏輯
            var httpContext = await contextBuilder.SendAsync(cancellationToken);
            // 創(chuàng)建 HttpResponseMessage 對象用于返回
            var response = new HttpResponseMessage();
            // 以下是對 HttpResponseMessage 的初始化邏輯，從 httpContext 里獲取返回值
            response.StatusCode = (HttpStatusCode) httpContext.Response.StatusCode;
            response.ReasonPhrase = httpContext.Features.Get<IHttpResponseFeature>()!.ReasonPhrase;
            response.RequestMessage = request;
            response.Version = request.Version;
            response.Content = new StreamContent(httpContext.Response.Body);
            return response;
        }