在一个应用程序中合并两个Asp.Net Core API

Ali 发表于 Dev

但

我有两个Restful API项目正在尝试合并到一个应用程序项目（新的.net核心）中，我修改了在同一应用程序中并排运行多个独立的ASP.NET Core管道中的代码，以按照扩展方法接受WebSockets好像：

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);

                            }
                        });
                });
        }

我在新应用程序中将其称为

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

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

[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);
    }

奥古赞大豆

我已经查看了您得到的解决方案，但是它对我没有用。因此，我们为此创建了一个解决方案，该解决方案完全可以完成您想要的工作，并且可以长时间无缝地工作。

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!"));
 }

您可以基于应用程序Startup和路由轻松地分离您的应用程序。但是，请记住，某些事情可能不适用于管道，因为您是在构建主容器之后进行分支的。我们介绍了分支机构的托管服务。

本文收集自互联网，转载请注明来源。

如有侵权，请联系 [email protected] 删除。