在C#控制台应用程序中更改线程上下文

Question

我有一个C#控制台应用程序，其中可以通过TCP套接字连接获取输入等内容。当我通过套接字的接收函数接收到输入时，我如何切换到主线程？

类似于WPF中的以下内容：

public void TaskDispatcher()
{
    if (DispatcherObjectForTaskDispatcher.Thread != System.Threading.Thread.CurrentThread)
        DispatcherObjectForTaskDispatcher.Invoke(new TaskDispatcherDelegate(TaskDispatcher));
    else
    {
        // Do some thing in the UI thread
    }
}

- uhwgmxorg

---

不是很清楚。控制台应用程序没有用户界面，因此也没有“UI线程”。它也没有同步上下文。你可能只需要一个生产者/消费者的设置或其他东西。 - H H

当然不是，但主线程，也就是静态void Main(string[] args)函数运行的线程和接收函数有一个不同的线程。具有UI线程的那个只是一个例子。 - uhwgmxorg

但是生产者-消费者数据流模式似乎是正确的提示。 - uhwgmxorg

一个裸线程无法“接收工作”。它必须先运行SyncContext。 - H H

唯一在结构上区分控制台模式应用程序和GUI应用程序的是Main()方法中的Application.Run()调用。你需要它。解决起来非常容易，创建一个Winforms或WPF应用程序，在应用程序选项卡上将输出类型设置为“控制台”，不要创建任何窗口，然后就可以得到你所需的东西了。 - Hans Passant

Answer 1

只需像下面的工作示例中使用生产者-消费者模式。从其他线程排队作业，让主线程从作业队列处理排队作业。

我使用了一个定时器线程和一个用户输入线程来模拟2个线程生成作业。您可以实现TCP事件，只需在作业队列中排队作业即可。您应该将任何相关对象作为参数存储在作业中，以供稍后处理。您还必须定义一个由作业调用的函数，在主线程中运行。

这里的主线程仅用于出队作业并处理它们，但是如果您稍微改进此代码，可以使用任何其他线程来完成此任务。

您甚至可以实现多线程处理，其中更多的处理线程从同一作业队列出队。请注意，这会带来新的并发问题，您可能需要处理这些问题。这是在应用程序中获得更多处理能力的缺点。某些情况适合多线程处理（例如视频/图像处理），而有些情况则不适合。

以下代码是一个完整的工作示例，使用Visual Studio 2017、DotNET 4.6.1和控制台应用程序项目编写。只需复制、粘贴并按F5即可。

using System;
using System.Collections.Concurrent;
using System.Diagnostics;
using System.Threading;

// Compiled and tested in: Visual Studio 2017, DotNET 4.6.1

namespace MyNamespace
{
    public class Program
    {
        public static void Main(string[] args)
        {
            MyApplication app = new MyApplication();
            app.Run();
        }
    }

    public class MyApplication
    {
        private BlockingCollection<Job> JobQueue = new BlockingCollection<Job>();
        private CancellationTokenSource JobCancellationTokenSource = new CancellationTokenSource();
        private CancellationToken JobCancellationToken;
        private Timer Timer;
        private Thread UserInputThread;



        public void Run()
        {
            // Give a name to the main thread:
            Thread.CurrentThread.Name = "Main";

            // Fires a Timer thread:
            Timer = new Timer(new TimerCallback(TimerCallback), null, 1000, 2000);

            // Fires a thread to read user inputs:
            UserInputThread = new Thread(new ThreadStart(ReadUserInputs))
            {
                Name = "UserInputs",
                IsBackground = true
            };
            UserInputThread.Start();

            // Prepares a token to cancel the job queue:
            JobCancellationToken = JobCancellationTokenSource.Token;

            // Start processing jobs:
            ProcessJobs();

            // Clean up:
            JobQueue.Dispose();
            Timer.Dispose();
            UserInputThread.Abort();

            Console.WriteLine("Done.");
        }



        private void ProcessJobs()
        {
            try
            {
                // Checks if the blocking collection is still up for dequeueing:
                while (!JobQueue.IsCompleted)
                {
                    // The following line blocks the thread until a job is available or throws an exception in case the token is cancelled:
                    JobQueue.Take(JobCancellationToken).Run();
                }
            }
            catch { }
        }



        private void ReadUserInputs()
        {
            // User input thread is running here.
            ConsoleKey key = ConsoleKey.Enter;

            // Reads user inputs and queue them for processing until the escape key is pressed:
            while ((key = Console.ReadKey(true).Key) != ConsoleKey.Escape)
            {
                Job userInputJob = new Job("UserInput", this, new Action<ConsoleKey>(ProcessUserInputs), key);
                JobQueue.Add(userInputJob);
            }
            // Stops processing the JobQueue:
            JobCancellationTokenSource.Cancel();
        }

        private void ProcessUserInputs(ConsoleKey key)
        {
            // Main thread is running here.
            Console.WriteLine($"You just typed '{key}'. (Thread: {Thread.CurrentThread.Name})");
        }



        private void TimerCallback(object param)
        {
            // Timer thread is running here.
            Job job = new Job("TimerJob", this, new Action<string>(ProcessTimer), "A job from timer callback was processed.");
            JobQueue.TryAdd(job); // Just enqueues the job for later processing
        }

        private void ProcessTimer(string message)
        {
            // Main thread is running here.
            Console.WriteLine($"{message} (Thread: {Thread.CurrentThread.Name})");
        }
    }



    /// <summary>
    /// The Job class wraps an object's method call, with or without arguments. This method is called later, during the Job execution.
    /// </summary>
    public class Job
    {
        public string Name { get; }
        private object TargetObject;
        private Delegate TargetMethod;
        private object[] Arguments;

        public Job(string name, object obj, Delegate method, params object[] args)
        {
            Name = name;
            TargetObject = obj;
            TargetMethod = method;
            Arguments = args;
        }

        public void Run()
        {
            try
            {
                TargetMethod.Method.Invoke(TargetObject, Arguments);
            }
            catch(Exception ex)
            {
                Debug.WriteLine($"Unexpected error running job '{Name}': {ex}");
            }
        }

    }
}

- sɐunıɔןɐqɐp