的ActiveX中的AsyncCallback

问题描述：

在开发的WebSocket服务器我抛砖引玉听者如下：具有其无阻塞能够接受多个连接的ActiveX中的AsyncCallback

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的中创建的web浏览器对象：

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

我怎样才能让WebBrowser对象在这里创建？

的可能的复制[单线程公寓 - 不能实例化ActiveX控件（http://stackoverflow.com/questions/1418466/single-threaded-apartment-cannot-instantiate-activex-control） –

或者考虑一个专用的STA线程和一个Queue进行打印，这样只需要一个实例化。 –

感谢您的提示..后几个链接我结束了这个解决方案，完美的作品：http://stackoverflow.com/questions/416314/print-html-document-from-windows-service-in-c-锐没有专用打印对话框 –

答

感谢以下答案：

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>");

的ActiveX中的AsyncCallback

相关推荐