AsyncCallback 中的 ActiveX答案

【问题标题】：ActiveX in AsyncCallbackAsyncCallback 中的 ActiveX
【发布时间】：2017-04-20 03:25:41
【问题描述】：

在开发 websocket 服务器时，我启动监听器如下：

private void StartAccept()
{
    _listener.BeginAcceptTcpClient(new AsyncCallback(HandleAsyncConnection), null);
}

因为它是非阻塞的，能够接受多个连接。

响应回调中的一个函数应该将 HTML 页面打印到选定的默认打印机：

WebBrowser webBrowser = new WebBrowser();
webBrowser.DocumentText = "<html><body><p>I am HTML text!</p><body></html>";
webBrowser.Print();

这是失败的，因为我尝试从 AsyncCallback 中创建 WebBrowser 对象：

ActiveX control '8856f961-340a-11d0-a96b-00c04fd705a2' cannot be instantiated because the current thread is not in a single-threaded apartment.

如何在此处创建 WebBrowser 对象？

【问题讨论】：

Single-threaded apartment - cannot instantiate ActiveX control的可能重复
或者考虑一个专用的STA线程和一个打印队列，这样只需要一个实例化。
感谢您的提示.. 在关注了几个链接之后，我最终得到了这个完美的解决方案：stackoverflow.com/questions/416314/…

标签： c# .net activex asynccallback

【解决方案1】：

感谢以下回答：

Print html document from Windows Service in C# without print dialog

我可以打印了：

StaTaskScheduler Sta = new StaTaskScheduler(1);

public void PrintHtml(string htmlPath)
{
    Task.Factory.StartNew(() => PrintOnStaThread(htmlPath), CancellationToken.None, TaskCreationOptions.None, Sta).Wait();
}

void PrintOnStaThread(string htmlText)
{
    const short PRINT_WAITFORCOMPLETION = 2;
    const int OLECMDID_PRINT = 6;
    const int OLECMDEXECOPT_DONTPROMPTUSER = 2;
    using (var browser = new WebBrowser())
    {
        browser.DocumentText = htmlText;
        while (browser.ReadyState != WebBrowserReadyState.Complete)
            Application.DoEvents();

        dynamic ie = browser.ActiveXInstance;
        ie.ExecWB(OLECMDID_PRINT, OLECMDEXECOPT_DONTPROMPTUSER, PRINT_WAITFORCOMPLETION);
    }
}

StaTaskScheduler 来自上述线程：

//--------------------------------------------------------------------------
// 
//  Copyright (c) Microsoft Corporation.  All rights reserved. 
// 
//  File: StaTaskScheduler.cs
//
//--------------------------------------------------------------------------

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;

namespace System.Threading.Tasks.Schedulers
{
    /// <summary>Provides a scheduler that uses STA threads.</summary>
    public sealed class StaTaskScheduler : TaskScheduler, IDisposable
    {
        /// <summary>Stores the queued tasks to be executed by our pool of STA threads.</summary>
        private BlockingCollection<Task> _tasks;
        /// <summary>The STA threads used by the scheduler.</summary>
        private readonly List<Thread> _threads;

        /// <summary>Initializes a new instance of the StaTaskScheduler class with the specified concurrency level.</summary>
        /// <param name="numberOfThreads">The number of threads that should be created and used by this scheduler.</param>
        public StaTaskScheduler(int numberOfThreads)
        {
            // Validate arguments
            if (numberOfThreads < 1) throw new ArgumentOutOfRangeException("concurrencyLevel");

            // Initialize the tasks collection
            _tasks = new BlockingCollection<Task>();

            // Create the threads to be used by this scheduler
            _threads = Enumerable.Range(0, numberOfThreads).Select(i =>
            {
                var thread = new Thread(() =>
                {
                    // Continually get the next task and try to execute it.
                    // This will continue until the scheduler is disposed and no more tasks remain.
                    foreach (var t in _tasks.GetConsumingEnumerable())
                    {
                        TryExecuteTask(t);
                    }
                });
                thread.IsBackground = true;
                thread.SetApartmentState(ApartmentState.STA);
                return thread;
            }).ToList();

            // Start all of the threads
            _threads.ForEach(t => t.Start());
        }

        /// <summary>Queues a Task to be executed by this scheduler.</summary>
        /// <param name="task">The task to be executed.</param>
        protected override void QueueTask(Task task)
        {
            // Push it into the blocking collection of tasks
            _tasks.Add(task);
        }

        /// <summary>Provides a list of the scheduled tasks for the debugger to consume.</summary>
        /// <returns>An enumerable of all tasks currently scheduled.</returns>
        protected override IEnumerable<Task> GetScheduledTasks()
        {
            // Serialize the contents of the blocking collection of tasks for the debugger
            return _tasks.ToArray();
        }

        /// <summary>Determines whether a Task may be inlined.</summary>
        /// <param name="task">The task to be executed.</param>
        /// <param name="taskWasPreviouslyQueued">Whether the task was previously queued.</param>
        /// <returns>true if the task was successfully inlined; otherwise, false.</returns>
        protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
        {
            // Try to inline if the current thread is STA
            return
                Thread.CurrentThread.GetApartmentState() == ApartmentState.STA &&
                TryExecuteTask(task);
        }

        /// <summary>Gets the maximum concurrency level supported by this scheduler.</summary>
        public override int MaximumConcurrencyLevel
        {
            get { return _threads.Count; }
        }

        /// <summary>
        /// Cleans up the scheduler by indicating that no more tasks will be queued.
        /// This method blocks until all threads successfully shutdown.
        /// </summary>
        public void Dispose()
        {
            if (_tasks != null)
            {
                // Indicate that no new tasks will be coming in
                _tasks.CompleteAdding();

                // Wait for all threads to finish processing tasks
                foreach (var thread in _threads) thread.Join();

                // Cleanup
                _tasks.Dispose();
                _tasks = null;
            }
        }
    }
}

现在我可以通过调用从我的 AsyncCallback 打印：

PrintHtml("<html><body><h1>I AM A html text</h1></body></hmtl>");

【讨论】：