Envoyer ou de poster un message sur un Windows Forms boucle de message

J'ai un thread qui lit les messages à partir d'un tube nommé. C'est un blocage de la lecture, qui est pourquoi il est dans son propre thread. Lorsque ce thread lit un message, je tiens à informer les Windows Forms boucle de message dans le thread principal qu'un message est prêt. Comment puis-je le faire? Dans win32, je ferais une PostMessage, mais cette fonction ne semble pas exister .Net (ou au moins, je ne pouvais pas le trouver).

OriginalL'auteur dan-gph | 2009-09-30

  1. 15

    En WinForms vous pouvez réaliser cela avec De contrôle.BeginInvoke. Un exemple:

    public class SomethingReadyNotifier
{
   private readonly Control synchronizer = new Control();

   ///<summary>
   ///Event raised when something is ready. The event is always raised in the
   ///message loop of the thread where this object was created.
   ///</summary>
   public event EventHandler SomethingReady;

   protected void OnSomethingReady()
   {
       SomethingReady?.Invoke(this, EventArgs.Empty);
   }

   ///<summary>
   ///Causes the SomethingReady event to be raised on the message loop of the
   ///thread which created this object.
   ///</summary>
   ///<remarks>
   ///Can safely be called from any thread. Always returns immediately without
   ///waiting for the event to be handled.
   ///</remarks>
   public void NotifySomethingReady()
   {
      this.synchronizer.BeginInvoke(new Action(OnSomethingReady));
   }
}

    Un nettoyeur de la variante de la ci-dessus, qui ne dépend pas de WinForms serait d'utiliser SynchronizationContext. Appel SynchronizationContext.Actuel sur votre thread principal, puis transmettre cette référence au constructeur de la classe indiquée ci-dessous.

    public class SomethingReadyNotifier
{
    private readonly SynchronizationContext synchronizationContext;

    ///<summary>
    ///Create a new <see cref="SomethingReadyNotifier"/> instance. 
    ///</summary>
    ///<param name="synchronizationContext">
    ///The synchronization context that will be used to raise
    ///<see cref="SomethingReady"/> events.
    ///</param>
    public SomethingReadyNotifier(SynchronizationContext synchronizationContext)
    {
        this.synchronizationContext = synchronizationContext;
    }

    ///<summary>
    ///Event raised when something is ready. The event is always raised
    ///by posting on the synchronization context provided to the constructor.
    ///</summary>
    public event EventHandler SomethingReady;

    private void OnSomethingReady()
    {
        SomethingReady?.Invoke(this, EventArgs.Empty);
    }

    ///<summary>
    ///Causes the SomethingReady event to be raised.
    ///</summary>
    ///<remarks>
    ///Can safely be called from any thread. Always returns immediately without
    ///waiting for the event to be handled.
    ///</remarks>
    public void NotifySomethingReady()
    {
        this.synchronizationContext.Post(
                state => OnSomethingReady(),
                state: null);
        }
    }
    Comme indiqué, il existe une condition de concurrence dans le OnSomethingReady() la méthode. Le SomethingReady événement pourrait être mis à null après la vérification pour les nuls, mais avant que l'événement est déclenché. Pour éviter cela, suivez les conseils ici: blogs.msdn.com/brada/archive/2005/01/14/353132.aspx
    pardonnez-moi, mais je suis allé de l'avant et fixe le problème.

    OriginalL'auteur Wim Coenen

  2. 18

    PostMessage (et même SendMessage) sont fonctions de l'API Win32, et donc ne sont pas directement liés .NET. .NET permet toutefois d'avoir un bon support pour les interoping avec l'API Win32, à l'aide de P/Invoke appels.

    Comme il semble que vous êtes nouveau à faire de la programmation Win32 .NET, cet article MSDN Magazine fournit une solide introduction sur le sujet.

    L'excellent pinvoke.net site web détails comment utiliser un grand nombre de ces fonctions de l'API à partir de C#/VB.NET. Voir cette page pour PostMessage spécifiquement.

    La déclaration est la suivante:

    [DllImport("user32.dll", SetLastError = true)]
static extern bool PostMessage(HandleRef hWnd, uint Msg, IntPtr wParam, IntPtr lParam);

    Mais comme la page l'indique, il est sage pour envelopper cette fonction pour gérer Win32 correctement les erreurs:

    void PostMessageSafe(HandleRef hWnd, uint msg, IntPtr wParam, IntPtr lParam)
{
    bool returnValue = PostMessage(hWnd, msg, wParam, lParam);
    if(!returnValue)
    {
        //An error occured
        throw new Win32Exception(Marshal.GetLastWin32Error());
    }
}
    Je n'ai pas forcément envie d'utiliser PostMessage. N'est-il pas clair .Net moyen de faire ce que je veux faire?
    Réponse courte: Non.
    Mike est correct. Vous utilisez le Windows boucle de message, qui est basé sur l'API Win32, et nécessite donc de P/Invoke.
    Cette réponse devrait avoir plus upvotes.
    exactement ce que je cherchais! +1

    OriginalL'auteur Noldorin

  3. 4

    Êtes-vous réellement en vouloir à poster un message dans la boucle de message ou vous êtes simplement désireux de mettre à jour un certain contrôle dans votre Formulaire, afficher une boîte de message, etc.? Si c'est l'ancien, puis reportez-vous à @Noldorin de réponse. Si c'est le dernier, alors vous avez besoin pour utiliser le Contrôle.Invoke() la méthode de maréchal de l'appel à partir de votre "lecture" thread de l'INTERFACE utilisateur principale de fil. C'est parce que les contrôles ne peuvent être mis à jour par le fil qu'ils ont été créés.

    C'est une bien jolie chose standard .NET. Se référer à ces articles MSDN pour obtenir les bases:

    Une fois que vous comprenez comment faire, reportez-vous Peter Duniho blog pour comment améliorer l'canonique technique.

    OriginalL'auteur Matt Davis