How to Create a Hybrid WPF + ASP.NET Core + Web as UI Application

using System.Net;
using System.Net.NetworkInformation;
using Microsoft.AspNetCore.Mvc.ApplicationParts;

namespace ServerAspnet
{
    public class Program
    {
        public static int port = 0;

        public static void Main(string[] args)
        {
            var builder = WebApplication.CreateBuilder(args);

            builder.Services.AddCors(options =>
            {
                options.AddPolicy(
                    "AllowAll",
                    policy =>
                    {
                        policy
                            .WithOrigins("http://localhost:5173") // Your frontend URL in Dev mode
                            .AllowAnyMethod()
                            .AllowAnyHeader()
                            .AllowCredentials(); // Allow sending credentials (cookies, authentication headers)
                    }
                );
            });

            builder.Services.AddSignalR();
            builder
                .Services.AddControllers()
                .PartManager.ApplicationParts.Add(new AssemblyPart(typeof(Program).Assembly));

#if DEBUG
            builder.Services.AddEndpointsApiExplorer();
            builder.Services.AddSwaggerGen();
#endif

            var app = builder.Build();

#if DEBUG
            if (app.Environment.IsDevelopment())
            {
                app.UseSwagger();
                app.UseSwaggerUI();
            }
#endif

#if !DEBUG
            // dynamic port (we'll see this in the next section)
            port = GetAvailablePort(5000);
            builder.WebHost.UseUrls($"http://localhost:{port}");
#endif

            app.UseCors("AllowAll");

            app.UseHttpsRedirection();
            app.UseAuthorization();

            app.MapControllers();

            app.UseDefaultFiles(); // <-- Serves index.html by default
            app.UseStaticFiles(); // <-- Serves files from wwwroot

            app.MapGet("/api/demo", () => new { message = "It works! 🎉" });
            app.MapHub<ClockHub>("/clockHub");

            if (args.Any(x => x == "run_async"))
                app.RunAsync();
            else
                app.Run();
        }
    }
}

#if !DEBUG            
	port = GetAvailablePort(5000);
	builder.WebHost.UseUrls($"http://localhost:{port}");
#endif

public static int GetAvailablePort(int startingPort)
{
	IPEndPoint[] endPoints;
	List<int> portArray = new List<int>();

	IPGlobalProperties properties = IPGlobalProperties.GetIPGlobalProperties();

	//getting active connections
	TcpConnectionInformation[] connections = properties.GetActiveTcpConnections();
	portArray.AddRange(
		from n in connections
		where n.LocalEndPoint.Port >= startingPort
		select n.LocalEndPoint.Port
	);

	//getting active tcp listeners - WCF service listening in tcp
	endPoints = properties.GetActiveTcpListeners();
	portArray.AddRange(from n in endPoints where n.Port >= startingPort select n.Port);

	//getting active udp listeners
	endPoints = properties.GetActiveUdpListeners();
	portArray.AddRange(from n in endPoints where n.Port >= startingPort select n.Port);

	portArray.Sort();

	for (int i = startingPort; i < UInt16.MaxValue; i++)
		if (!portArray.Contains(i))
			return i;

	return 0;
}

using Microsoft.AspNetCore.Mvc;

namespace ServerAspnet.Controllers;

[ApiController]
[Route("[controller]")]
public class FilesController : ControllerBase
{
    private readonly ILogger<FilesController> _logger;

    public FilesController(ILogger<FilesController> logger)
    {
        _logger = logger;
    }

    [HttpGet(Name = "GetFiles")]
    public IEnumerable<string> Get()
    {
        var path = "C:\\temp";
        return System.IO.Directory.GetFiles(path);
    }
}

builder
	.Services.AddControllers()
	.PartManager.ApplicationParts.Add(new AssemblyPart(typeof(Program).Assembly));  // this is the added part

using Microsoft.AspNetCore.SignalR;

namespace ServerAspnet
{
    public class ClockHub : Hub
    {
        // This method is called when a client connects
        public override async Task OnConnectedAsync()
        {
            // Start sending the time every second
            await SendTime();
        }

        // Method that sends the time every second
        private async Task SendTime()
        {
            while (true)
            {
                // Send the time to all connected clients
                await Clients.All.SendAsync("ReceiveTime", DateTime.Now.ToString("HH:mm:ss"));
                await Task.Delay(1000); // Wait 1 second before sending the time again
            }
        }
    }
}

builder.Services.AddSignalR();

///....

app.MapHub<ClockHub>("/clockHub");

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using System.Windows;

namespace AppWPF
{
    public class WebServer
    {
        private WebApplication? _app;

        public int Start()
        {
            try
            {
                Console.WriteLine("Starting web server...");
                ServerAspnet.Program.Main(new string[] { "run_async" });

                var port = ServerAspnet.Program.port;
                Console.WriteLine($"Started on {port}");
                return port;
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Error in the server: {ex.Message}");
                return 0;
            }
        }

        public void Stop() => _app?.StopAsync();
    }
}