Wie kann ich senden eine Nachricht zu einem bestimmten Prozess mit Prozess-id anstatt durch das Fenster-handle?

Es gibt 3 Szenarien, in denen eine Meldung könnte gedacht als gesendet oder geschrieben auf einen Prozess:

1. Ich kann "senden" oder "post" [Fenster] - Nachricht an einen bestimmten Prozess, indem Sie ihn auf das erste aufgelistete Fenster in diesem Prozess
2. Kann ich die "post" ein [thread] - Nachricht an einen bestimmten Prozess, durch Entsendung es zu den ersten aufgelisteten Threads in den Prozess.
3. Kann ich die "post" ein [thread] - Nachricht an einen bestimmten Prozess, durch Entsendung es zu den thread, besitzt die erste aufgelistete Fenster des Prozesses.

Ansatz 1 kann auch Besondere, denn es zielt auf einen bestimmten aber beliebigen Fenster.
Ansatz 2 ist möglicherweise nicht spezifisch genug, da die ersten aufgelisteten thread ist willkürlich und kann nicht über eine message-loop.
Ansatz 3 ist ein hybrid-Ansatz, der erste gibt ein Fenster, aber dann posts ein thread-Nachricht an das Fenster s thread, es ist also nicht gezielt auf ein bestimmtes Fenster (D. H. es ist ein "thread message"), sondern es wird gezielt in einem thread, der wahrscheinlich zu haben, eine message-Schleife, da der thread besitzt mindestens ein Fenster.

Folgenden ist eine Implementierung, die sich für alle drei Ansätze, und beide Methoden "send" und "post". Ansatz 1 ist umgeben von den Methoden SendMessage und PostMessage unten. Ansatz 2 und 3 sind umschlossen von der Methode PostThreadMessage unten, je nachdem, ob Sie legen Sie die optionalen parameter ensureTargetThreadHasWindow (true = Ansatz 3, false = Ansatz 2).

public static class ProcessExtensions
{
    private static class Win32
    {
        [DllImport("user32.dll", CharSet = CharSet.Auto)]
        public static extern IntPtr SendMessage(IntPtr hWnd, UInt32 Msg, IntPtr wParam, IntPtr lParam);

        [return: MarshalAs(UnmanagedType.Bool)]
        [DllImport("user32.dll", SetLastError = true)]
        public static extern bool PostMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);

        [return: MarshalAs(UnmanagedType.Bool)]
        [DllImport("user32.dll", SetLastError = true)]
        public static extern bool PostThreadMessage(uint threadId, uint msg, IntPtr wParam, IntPtr lParam);

        public delegate bool EnumThreadDelegate (IntPtr hWnd, IntPtr lParam);
        [DllImport("user32.dll")]
        public static extern bool EnumThreadWindows(uint dwThreadId, EnumThreadDelegate lpfn, IntPtr lParam);

        [DllImport("user32.dll", SetLastError=true)]
        public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId);
    }

    //Sends a message to the first enumerated window in the first enumerated thread with at least one window, and returns the handle of that window through the hwnd output parameter if such a window was enumerated.  If a window was enumerated, the return value is the return value of the SendMessage call, otherwise the return value is zero.
    public static IntPtr SendMessage( this Process p, out IntPtr hwnd, UInt32 msg, IntPtr wParam, IntPtr lParam )
    {
        hwnd = p.WindowHandles().FirstOrDefault();
        if (hwnd != IntPtr.Zero)
            return Win32.SendMessage( hwnd, msg, wParam, lParam );
        else
            return IntPtr.Zero;
    }

    //Posts a message to the first enumerated window in the first enumerated thread with at least one window, and returns the handle of that window through the hwnd output parameter if such a window was enumerated.  If a window was enumerated, the return value is the return value of the PostMessage call, otherwise the return value is false.
    public static bool PostMessage( this Process p, out IntPtr hwnd, UInt32 msg, IntPtr wParam, IntPtr lParam )
    {
        hwnd = p.WindowHandles().FirstOrDefault();
        if (hwnd != IntPtr.Zero)
            return Win32.PostMessage( hwnd, msg, wParam, lParam );
        else
            return false;
    }

    //Posts a thread message to the first enumerated thread (when ensureTargetThreadHasWindow is false), or posts a thread message to the first enumerated thread with a window, unless no windows are found in which case the call fails.  If an appropriate thread was found, the return value is the return value of PostThreadMessage call, otherwise the return value is false.
    public static bool PostThreadMessage( this Process p, UInt32 msg, IntPtr wParam, IntPtr lParam, bool ensureTargetThreadHasWindow = true )
    {
        uint targetThreadId = 0;
        if (ensureTargetThreadHasWindow)
        {
            IntPtr hwnd = p.WindowHandles().FirstOrDefault();
            uint processId = 0;
            if (hwnd != IntPtr.Zero)
                targetThreadId = Win32.GetWindowThreadProcessId( hwnd, out processId );
        }
        else
        {
            targetThreadId = (uint)p.Threads[0].Id;
        }
        if (targetThreadId != 0)
            return Win32.PostThreadMessage( targetThreadId, msg, wParam, lParam );
        else
            return false;
    }

    public static IEnumerable<IntPtr> WindowHandles( this Process process )
    {
        var handles = new List<IntPtr>();
        foreach (ProcessThread thread in process.Threads)
            Win32.EnumThreadWindows( (uint)thread.Id, (hWnd, lParam) => { handles.Add(hWnd); return true; }, IntPtr.Zero );
        return handles;
    }
}

Zur Nutzung dieser extension-Methode auf ein Process-Objekt:

Process process = Process.Start( exePath, args );
IntPtr hwndMessageWasSentTo = IntPtr.Zero; //this will receive a non-zero value if SendMessage was called successfully
uint msg = 0xC000; //The message you want to send
IntPtr wParam = IntPtr.Zero; //The wParam value to pass to SendMessage
IntPtr lParam = IntPtr.Zero; //The lParam value to pass to SendMessage

IntPtr returnValue = process.SendMessage( out hwndMessageWasSentTo, msg, wParam, lParam );
if (hwndMessageWasSentTo != IntPtr.Zero)
   Console.WriteLine( "Message successfully sent to hwnd: " + hwndMessageWasSentTo.ToString() + " and return value was: " + returnValue.ToString() );
else
   Console.WriteLine( "No windows found in process.  SendMessage was not called." );

InformationsquelleAutor Triynko