Wie können Nachrichten an einen STA-Thread gesendet werden, der eine Nachrichtenpumpe ausführt?

Question

Also, nach this, entschied ich mich, explizit ein COM-Objekt in einem dedizierten STA-Thread instanziieren. Die Experimente zeigten, dass das COM-Objekt eine Nachricht Pumpe benötigt, die ich durch den Aufruf Application.Run() erstellt:

private MyComObj _myComObj; 

// Called from Main(): 
Thread myStaThread = new Thread(() => 
{ 
    _myComObj = new MyComObj(); 
    _myComObj.SomethingHappenedEvent += OnSomthingHappened; 
    Application.Run(); 
}); 
myStaThread.SetApartmentState(ApartmentState.STA); 
myStaThread.Start(); 

Wie schreibe ich Nachrichten die das Nachrichtensystem von anderen Threads des STA-Thread?

Hinweis: Ich habe die Frage aus Gründen der Kürze stark bearbeitet. Einige Teile von @ Servys Antwort scheinen jetzt nicht verwandt zu sein, aber sie waren für die ursprüngliche Frage.

Answer 1

Beachten Sie, dass die Nachrichten-Warteschlange, die Windows für eine STA erstellt Thread ist bereits eine Implementierung einer Thread-sicheren Warteschlange. Benutze es einfach für deine eigenen Zwecke. Hier ist eine Basisklasse, die Sie verwenden können, leiten Sie Ihre eigenen ab, um Ihr COM-Objekt einzuschließen. Überschreiben Sie die Initialize() -Methode, sie wird aufgerufen, sobald der Thread zum Ausführen von Code bereit ist. Vergessen Sie nicht, base.Initialize() in Ihrer Überschreibung aufzurufen.

Wenn Sie Code für diesen Thread ausführen möchten, verwenden Sie die Methoden BeginInvoke oder Invoke genau wie für die Methoden Control.Begin/Invoke oder Dispatcher.Begin/Invoke. Rufen Sie die Dispose() -Methode auf, um den Thread herunterzufahren. Dies ist optional. Beachten Sie, dass dies nur sicher ist, wenn Sie 100% sicher sind, dass alle COM-Objekte finalisiert sind. Da Sie diese Garantie normalerweise nicht haben, ist es besser, dass Sie das nicht tun.

using System; 
using System.Threading; 
using System.Windows.Forms; 

class STAThread : IDisposable { 
    public STAThread() { 
     using (mre = new ManualResetEvent(false)) { 
      thread = new Thread(() => { 
       Application.Idle += Initialize; 
       Application.Run(); 
      }); 
      thread.IsBackground = true; 
      thread.SetApartmentState(ApartmentState.STA); 
      thread.Start(); 
      mre.WaitOne(); 
     } 
    } 
    public void BeginInvoke(Delegate dlg, params Object[] args) { 
     if (ctx == null) throw new ObjectDisposedException("STAThread"); 
     ctx.Post((_) => dlg.DynamicInvoke(args), null); 
    } 
    public object Invoke(Delegate dlg, params Object[] args) { 
     if (ctx == null) throw new ObjectDisposedException("STAThread"); 
     object result = null; 
     ctx.Send((_) => result = dlg.DynamicInvoke(args), null); 
     return result; 
    } 
    protected virtual void Initialize(object sender, EventArgs e) { 
     ctx = SynchronizationContext.Current; 
     mre.Set(); 
     Application.Idle -= Initialize; 
    } 
    public void Dispose() { 
     if (ctx != null) { 
      ctx.Send((_) => Application.ExitThread(), null); 
      ctx = null; 
     } 
    } 
    private Thread thread; 
    private SynchronizationContext ctx; 
    private ManualResetEvent mre; 
} 

Answer 2

Gibt es eine Möglichkeit, die Nachrichtenpumpe zu starten, damit sie nicht blockiert?

No. Der Punkt eine Nachrichtenwarteschlange ist, dass es den Threads der Ausführung verbrauchen muss. Eine Nachrichtenwarteschlange, in Implementierung, geht sehr ähnlich wie Ihre aussehen:

while(!_stopped) 
{ 
    var job = _myBlockingCollection.Take(); // <-- blocks until some job is available 
    ProcessJob(job); 
} 

Die ist eine Nachrichtenschleife. Sie versuchen, zwei verschiedene Nachrichtenschleifen im selben Thread auszuführen. Sie können das nicht wirklich tun (und beide Warteschlangen pumpen; eine Warteschlange wird notwendigerweise die Ausführung der anderen pausieren, während sie läuft), es macht einfach keinen Sinn.

Was Sie tun müssen, anstatt eine zweite Nachrichtenschleife in demselben Thread zu erstellen, ist das Senden von Nachrichten an Ihre vorhandene Warteschlange. Ein Weg, dies zu tun, ist durch die Verwendung eines SynchronizationContext. Ein Problem besteht jedoch darin, dass es keine Ereignisse gibt, die zum Ausführen einer Methode in der Nachrichtenpumpe mit der Überladung von Run angehängt werden können. Wir müssen nur eine Form zeigen, damit wir in das Ereignis Shown einhaken können (an dem Punkt können wir es verstecken). Wir können dann die SynchronizationContext packen und es irgendwo speichern, so dass wir es verwenden, um Nachrichten an das Nachrichtensystem zu schreiben:

private static SynchronizationContext context; 
public static void SendMessage(Action action) 
{ 
    context.Post(s => action(), null); 
} 

---

Form blankForm = new Form(); 
blankForm.Size = new Size(0, 0); 
blankForm.Shown += (s, e) => 
{ 
    blankForm.Hide(); 
    context = SynchronizationContext.Current; 
}; 

Application.Run(blankForm);