如何从Web API项目动态访问并写入控制台应用的已打开控制台？

Alright, let's break down why your current approach isn't working first, then walk through practical solutions to get your Web API writing to the already running console app's window.

Why Your Current Code Fails #

Your console app and Web API are two completely separate processes. When the Web API references the console app's assembly and calls Program.LogToConsole, it's executing that method inside the Web API's own process — not in the already running console app process. The Console.WriteLine in that call will either output to the Web API's console (if it's console-hosted) or be ignored (if hosted in IIS), never reaching the original console window you opened.

Solution 1: Use Named Pipes for Inter-Process Communication (IPC) #

Named pipes are a reliable, cross-platform (Windows + Linux) way to send messages between separate processes. Here's how to set it up:

Step 1: Modify the Console App to Listen for Pipe Messages #

Update your console app to run a background thread that listens for incoming messages from the Web API:

using System.IO.Pipes;
using System.Text;
using System.Threading;

public class Program
{
    public static void Main(string[] args)
    {
        Console.WriteLine("Hello from console app!");
        
        // Start a background thread to listen for pipe messages
        var listenerThread = new Thread(ListenForPipeMessages);
        listenerThread.IsBackground = true;
        listenerThread.Start();

        Console.ReadLine();
    }

    private static void ListenForPipeMessages()
    {
        // Use a fixed pipe name to identify the communication channel
        const string PipeName = "ConsoleLogPipe";
        
        while (true)
        {
            using var pipeServer = new NamedPipeServerStream(PipeName, PipeDirection.In);
            // Wait for the Web API to connect
            pipeServer.WaitForConnection();

            try
            {
                // Read the incoming message and print it to the console
                var reader = new StreamReader(pipeServer);
                string message = reader.ReadLine();
                if (!string.IsNullOrEmpty(message))
                {
                    Console.WriteLine($"[Web API Message] {message}");
                }
            }
            catch (IOException ex)
            {
                Console.WriteLine($"Pipe communication error: {ex.Message}");
            }
        }
    }
}

Step 2: Update the Web API's Log Class to Send Messages via Pipe #

Modify your Web API's Log class to act as a pipe client and send messages to the listening console app:

using System.IO.Pipes;
using System.Text;

public static class Log
{
    public static void Access(string information)
    {
        const string PipeName = "ConsoleLogPipe";
        
        try
        {
            using var pipeClient = new NamedPipeClientStream(".", PipeName, PipeDirection.Out);
            // Connect to the console app's pipe (timeout after 1 second to avoid hanging)
            pipeClient.Connect(1000);

            var writer = new StreamWriter(pipeClient);
            writer.WriteLine(information);
            writer.Flush();
        }
        catch (TimeoutException)
        {
            Console.WriteLine("Error: Console app is not running or pipe is unavailable.");
        }
        catch (IOException ex)
        {
            Console.WriteLine($"Failed to send message: {ex.Message}");
        }
    }
}

Now when your Web API calls Log.Access, the message will travel through the named pipe to the running console app and appear in its window.

Solution 2: Attach to the Console App's Window via Windows API (Windows-only) #

If you're only targeting Windows, you can use Windows API calls to attach the Web API's output to the existing console app window. Note this won't work cross-platform.

Update the Web API's Log Class with Windows API Calls #

using System;
using System.Diagnostics;
using System.Runtime.InteropServices;

public static class Log
{
    // Windows API declarations
    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern IntPtr GetStdHandle(int nStdHandle);

    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern bool AttachConsole(uint dwProcessId);

    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern bool FreeConsole();

    private const int STD_OUTPUT_HANDLE = -11;

    public static void Access(string information)
    {
        // Locate the console app process (replace "ConsoleApp" with your exe name)
        var consoleProcesses = Process.GetProcessesByName("ConsoleApp");
        if (consoleProcesses.Length == 0)
        {
            Console.WriteLine("Error: Console app not found.");
            return;
        }

        uint consoleProcessId = (uint)consoleProcesses[0].Id;

        // Attach to the console app's window
        if (AttachConsole(consoleProcessId))
        {
            try
            {
                // Write the message to the attached console
                Console.WriteLine($"[Web API Message] {information}");
            }
            finally
            {
                // Release the console to avoid interfering with the Web API's own output
                FreeConsole();
            }
        }
        else
        {
            Console.WriteLine($"Failed to attach to console. Error code: {Marshal.GetLastWin32Error()}");
        }
    }
}

Caveats for This Approach #

• Only works on Windows.
• If your Web API is hosted in IIS (not a console app), this may behave unpredictably.
• If multiple processes try to attach to the same console, you may get unexpected output.

内容的提问来源于stack exchange，提问作者Aru