在一个应用程序中合并两个 Asp.Net Core API [英] Merge two Asp.Net Core APIs in one application

问题描述

我有两个 Restful APIs 项目，它们试图合并到一个应用程序项目中(新的 .net core 一个)我修改了 在同一个应用程序中并排运行多个独立的 ASP.NET Core 管道 接受 WebSockets 如下扩展方法:

I have two Restful APIs projects that am trying to merge in one application project ( new .net core one) I modified the code in Running multiple independent ASP.NET Core pipelines side by side in the same application to accept WebSockets as following the extension method looks like :

public static IApplicationBuilder UseBranchWithServices(
            this IApplicationBuilder app,
            PathString path,
            Type requiredStartup) {
            var webHost =  WebHost.CreateDefaultBuilder()
                .UseStartup(requiredStartup).Build();
            var serviceProvider = webHost.Services;
            var serverFeatures = webHost.ServerFeatures;


            var appBuilderFactory =
                serviceProvider.GetRequiredService<IApplicationBuilderFactory>();
            var branchBuilder = appBuilderFactory.CreateBuilder(serverFeatures);
            var factory = serviceProvider.GetRequiredService<IServiceScopeFactory>();


            if (path.Value.Contains("/project2")) {

                branchBuilder.Map(
                    "/project2/ws",
                    x =>
                        x.UseMiddleware<project2MicroService.WebSockets.WebSocketMiddleWare>(
                            serviceProvider.GetService<SceneWebSocketHandler>()));

            } else if (path.Value.Contains("/project1")) {

                branchBuilder.Map(
                    "/project1/ws",
                    x => x.UseMiddleware<project1Service.WebSockets.WebSocketMiddleWare>(
                        serviceProvider.GetService<project1WebSocketHandler>()));
            }


            var branchDelegate = branchBuilder.Build();



            return app.Map(
                path,
                builder => {
                    builder.Use(
                        async (context, next) => {
                            if (!context.WebSockets.IsWebSocketRequest) {
                                await branchDelegate(context).ConfigureAwait(false);
                            } else {
                                 await context.WebSockets.AcceptWebSocketAsync().ConfigureAwait(false);
                                 await branchDelegate(context).ConfigureAwait(false);

                            }
                        });
                });
        }

并且我在我的新应用程序中调用它，例如

and I call it in my new application for example like

app.UseBranchWithServices("/project2", typeof(project2MicroService.Startup));

在运行单元测试时，WebSocket 连接被接受，但中间件从未被命中任何想法如何解决这个问题，请，我的单元测试

while running unit tests the WebSocket connection is accepted but the middleware never been hit any idea how to fix this, please , my unit test

[ClassInitialize]

        public static void TestOneTimeSetUp(TestContext context) {

            var webHostBuilder = WebHost.CreateDefaultBuilder();
            webHostBuilder.UseContentRoot(Directory.GetCurrentDirectory());
            webHostBuilder.UseStartup<Startup>();
            server = new TestServer(webHostBuilder);
            client = server.CreateWebSocketClient();
        }

        /// <summary>
        /// OneTimeTearDown
        /// </summary>
        [ClassCleanup]
        public static void TestOneTimeTeardown() {
            server.Dispose();
        }

        /// <summary>
    /// TestWebsocketCanBeCreated
    /// </summary>
    [TestMethod]
    public void TestWebsocketCanBeCreated() {

        var TEST1wsUri = new UriBuilder(server.BaseAddress + "project1/ws") { Scheme = "ws" }.Uri;
        var TEST1websocket = client.ConnectAsync(TEST1wsUri, CancellationToken.None).Result;

        var TEST2wsUri = new UriBuilder(server.BaseAddress + "project2/ws") { Scheme = "ws" }.Uri;
        var TEST2websocket = client.ConnectAsync(TEST2wsUri, CancellationToken.None).Result; 

        Assert.AreEqual(WebSocketState.Open, TEST2websocket.State);
        Assert.AreEqual(WebSocketState.Open, TEST1websocket.State);



        Task.WaitAll(
            TEST1websocket.CloseAsync(
                WebSocketCloseStatus.NormalClosure,
                "",
                CancellationToken.None));

        Task.WaitAll(
            TEST2websocket.CloseAsync(
                WebSocketCloseStatus.NormalClosure,
                "",
                CancellationToken.None));

        Assert.AreEqual(WebSocketState.Closed, TEST2websocket.State);
        Assert.AreEqual(WebSocketState.Closed, TEST1websocket.State);
    }

推荐答案

我已经看过你得到的解决方案，但它对我不起作用.因此，我们为此创建了一个解决方案，它完全可以完成您想要的工作，并且可以长时间无缝运行.

I had looked at the solution you got but it didn't work for me. So, we created a solution for that it does exactly the job that you wanted and works seamlessly for a long time.

https://github.com/damianh/lab/tree/master/dotnet/AspNetCoreNestedApps/AspNetCoreNestedApps

如果我用代码总结；

 public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
 {
     app.IsolatedMap<NestedStartup>("/nested");
     app.IsolatedMap<XApp>("/xroute");
     app.Run(async context => await context.Response.WriteAsync("Hello World!"));
 }

您可以根据启动和路由轻松分离您的应用程序.但是，请记住，有些东西可能不适用于管道，因为您是在主容器构建后进行分支.我们介绍了分支机构的托管服务.

You can separate your applications based on Startup and routing easily. But, keep that in mind somethings might not work for pipeline since you're branching after the main container built. We covered hosted services for branches.

这篇关于在一个应用程序中合并两个 Asp.Net Core API的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！