1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:

public static class Kernel32
{
    private const string DLL = "kernel32.dll";
        
    [DllImport(DLL, SetLastError = true, ExactSpelling = true)]
    public static extern bool FreeConsole();

    [DllImport(DLL)]
    public static extern bool AllocConsole();

    [DllImport(DLL, CharSet = CharSet.Auto)]
    public static extern IntPtr CreateFileW(string lpFileName, uint dwDesiredAccess, uint dwShareMode, IntPtr lpSecurityAttributes, uint dwCreationDisposition, uint dwFlagsAndAttributes, IntPtr hTemplateFile);

    [DllImport(DLL)]
    public static extern bool CancelIoEx(IntPtr handle, IntPtr lpOverlapped);
}

public static class WinConsole
{
    private static FileStream _inStream;
    private static FileStream _outStream;

    public static bool IsAttached { get; private set; }

    public static void Open()
    {
        IsAttached = Kernel32.AllocConsole();

        if (IsAttached)
        {
            InitInStream();
            InitOutStream();
        }
    }
    public static void Close()
    {
        if (!IsAttached)
            return;

        Kernel32.CancelIoEx(_inStream.SafeFileHandle.DangerousGetHandle(), IntPtr.Zero);
        Kernel32.CancelIoEx(_outStream.SafeFileHandle.DangerousGetHandle(), IntPtr.Zero);
        Kernel32.FreeConsole();

        _inStream.Dispose();
        _outStream.Dispose();
    }

    private static void InitInStream()
    {
        _inStream = CreateFileStream("CONIN$", GENERIC_READ, FILE_SHARE_READ, FileAccess.Read);

        if (_inStream != null)
            Console.SetIn(new StreamReader(_inStream));
    }
    private static void InitOutStream()
    {
        _outStream = CreateFileStream("CONOUT$", GENERIC_WRITE, FILE_SHARE_WRITE, FileAccess.Write);

        if (_outStream != null)
        {
            var writer = new StreamWriter(_outStream) { AutoFlush = true };

            Console.SetOut(writer);
            Console.SetError(writer);
        }
    }

    private static FileStream CreateFileStream(string name, uint win32DesiredAccess, uint win32ShareMode, FileAccess dotNetFileAccess)
    {
        var file = new SafeFileHandle(Kernel32.CreateFileW(name, win32DesiredAccess, win32ShareMode, IntPtr.Zero, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, IntPtr.Zero), true);

        return file.IsInvalid
            ? null
            : new FileStream(file, dotNetFileAccess);
    }
        
    private const uint GENERIC_WRITE = 0x40000000;
    private const uint GENERIC_READ = 0x80000000;
    private const uint FILE_SHARE_READ = 0x00000001;
    private const uint FILE_SHARE_WRITE = 0x00000002;
    private const uint OPEN_EXISTING = 0x00000003;
    private const uint FILE_ATTRIBUTE_NORMAL = 0x80;
}					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:

public partial class Form1 : Form
{
    private readonly TextBox _consoleTextBox;
    private CancellationTokenSource _readConsoleCancelTokenSource;
    private Task _readConsoleTask;

    public Form1()
    {
        InitializeComponent();

        Controls.Add(_consoleTextBox = new TextBox()
        {
            Multiline = true,
            Dock = DockStyle.Fill,
        });
    }

    protected override void OnLoad(EventArgs e)
    {
        WinConsole.Open();

        _readConsoleCancelTokenSource = new CancellationTokenSource();
        _readConsoleTask = ReadConsoleAsync(_readConsoleCancelTokenSource.Token);

        base.OnLoad(e);
    }
    protected override async void OnClosing(CancelEventArgs e)
    {
        _readConsoleCancelTokenSource.Cancel();
        WinConsole.Close();
        await _readConsoleTask;
        _readConsoleCancelTokenSource.Dispose();

        base.OnClosing(e);
    }

    private async Task ReadConsoleAsync(CancellationToken cancelToken)
    {
        if (cancelToken.IsCancellationRequested)
            return;

        var line = await Task.Run(() =>
        {
            try
            {
                Console.Write("Write something: ");
                return Console.ReadLine();
            }
            catch (OperationCanceledException)
            {
                return null;
            }

        }, cancelToken);

        if (cancelToken.IsCancellationRequested)
            return;

        if (!string.IsNullOrEmpty(line))
            _consoleTextBox.AppendText(line + Environment.NewLine);

        await ReadConsoleAsync(cancelToken);
    }
}