C# mithilfe von SendMessage -, problem mit WM_COPYDATA

Ich verbrachte ein paar Tage (oder mehr) versucht, diese zu arbeiten.

Die Anwendung bei der hand ist FTPRush, und ich weiß, es ist eine cmd-line-Anwendung namens rush_cmdline.exe verwendet SendMessage Anfragen zu senden FTPRush.

Vom debugging der rush_cmdline.exe ich sehen kann lParam, wParam, Message und hWnd.

Mein code ist wie folgt (mithilfe der SendMessage, nicht SendMessageW):

[DllImport("User32.dll", EntryPoint = "FindWindow")]
public static extern Int32 FindWindow(String lpClassName, String lpWindowName);
[DllImport("USER32.DLL", EntryPoint= "SendMessage")]
public static extern IntPtr SendMessage(int hWnd, int Msg, int wParam, IntPtr lParam);

Und ich habe versucht, eine andere Spezifikation auch:

[DllImport("User32.dll", EntryPoint = "SendMessage")]
public static extern int SendMessage(int hWnd, int Msg, int wParam, ref COPYDATASTRUCT lParam);

Den Griff (hWnd) ist nicht das problem, wie das funktioniert:

int ftprush = FindWindow("TfmRush", null);
ShowWindow(ftprush, 8);

Welche (ich habe nicht fügen Sie die dllimport wie es ist hier nicht wichtig. Lassen Sie mich wissen, wenn Sie möchten, um es zu sehen) bringt das Fenster nach vorne. Auch habe ich überprüft, indem debugging rush_cmdline.exe. Also der Griff ist der gleiche.

Zwei Anläufe, die beide fehlschlagen (im hintergrund):

public const Int32 WM_COPYDATA = 0x4A;
string msg = "RushApp.FTP.Login('backup','',0); ";
//1
byte[] array = Encoding.UTF8.GetBytes((string)msg);
int size = Marshal.SizeOf(array[0]) * array.Length + Marshal.SizeOf(array[0]);
IntPtr ptr = Marshal.AllocHGlobal(size);
Marshal.Copy(array, 0, ptr, array.Length);
Marshal.WriteByte(ptr, size - 1, 0);
SendMessage(ftprush, WM_COPYDATA, 0, ptr);

//2
public struct COPYDATASTRUCT
{
   public IntPtr dwData;
   public int cbData;
   [MarshalAs(UnmanagedType.LPStr)]
   public string lpData;
}

COPYDATASTRUCT cds;
cds.dwData = (IntPtr)100;
cds.lpData = msg;
cds.cbData = sarr.Length + 1;
SendMessage(ftprush, WM_COPYDATA, 0, ref cds);

Ich würde erwarten, dass zumindest die 2. Lösung zu arbeiten, wie es passt ziemlich gut dazu: perl-Beispiel

Jede Aufklärung SEHR dankbar!

Dank,

Frank

UPDATE:

string msg = "RushApp.FTP.Login('backup','',0);\0";
var cds = new COPYDATASTRUCT
{
            dwData = new IntPtr(3),
            cbData = msg.Length + 1,
            lpData = msg
};
IntPtr ftprush = FindWindow("TfmRush", null);
SendMessage(ftprush, WM_COPYDATA, IntPtr.Zero, ref cds);

Sind Sie sicher, dass die FTP Rush ist unterstützt WM_COPYDATA? Was bedeutet die FTPRush Dokumentation sagen über diese Nachricht? Wenn FTPRush nicht handhaben WM_COPYDATA es wird einfach die Meldung ignorieren und nichts tun.
es unterstützt WM_COPYDATA. Es ist in der perl-Beispiel, und es ist die einzige von rush_cmdline.exe.

InformationsquelleAutor Frank | 2011-07-21

c#pinvoke sendmessage

Meine Definitionen haben

[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = false)]
public static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, IntPtr wParam, ref COPYDATASTRUCT lParam);

public struct COPYDATASTRUCT {
  public int cbData;
  public IntPtr dwData;
  [MarshalAs(UnmanagedType.LPStr)] public string lpData;
}

var cds = new Win32.COPYDATASTRUCT {
                                           dwData = new IntPtr(3),
                                           cbData = str.Length + 1,
                                           lpData = str
                                         };
Win32.SendMessage(ftprush, Win32.WM_COPYDATA, IntPtr.Zero, ref cds);

Natürlich, stellen Sie sicher, dass str Nullzeichen "\0"

Alternativ eine definition gegeben, die von PInvoke.NET ist

[DllImport("user32.dll", CharSet = CharSet.Auto)]
static extern IntPtr SendMessage(IntPtr hWnd, UInt32 Msg, IntPtr wParam, StringBuilder lParam);
//If you use '[Out] StringBuilder', initialize the string builder with proper length first.

Danke für die Antwort, Bob. Meinst du Win32.SendMessage(ftprush, Win32.WM_COPYDATA, IntPtr.Zero, ref cds); (ref)? Ich aktualisiert meine Frage. Ich musste hinzufügen, ref, um es zu kompilieren. Oder bin ich hier etwas fehlt?
Ja, ich habe meine ref, ich habe einen Tippfehler gemacht!
Ich kann nicht mit FTPRush, aber Ihr Ansatz deckt sich mit dem, was ich erwarten würde, so dass ich annehme, dass es ein dummer Fehler meinerseits. Antwort akzeptiert. Haben Sie zufällig ein Beispiel von SendMessage kann ich ausprobieren? (die Anwendung, die lParam)
Ich war mit, um die Kommunikation zwischen zwei meiner eigenen Programme, einer der Unterschiede ist, dass ich den 3. parameter an die hwnd des Fensters, in der source-Anwendung. Ich nehme es mit der alternative mit stringbuilder nicht helfen
Ich werde haben Sie einen Blick auf ftp rush heute Abend und sehen, ob ich ein Beispiel

InformationsquelleAutor Bob Vale

Die Reihenfolge der Argumente in der COPYDATASTRUCT sind kritisch wichtig, und Bob Vale Antwort hat Sie in der falschen Reihenfolge. http://msdn.microsoft.com/en-us/library/windows/desktop/ms649010(v=vs. 85).aspx Es in dieser Reihenfolge sein sollte:

[StructLayout(LayoutKind.Sequential)]
public struct COPYDATASTRUCT
{
    public IntPtr dwData;
    public int cbData;
    public IntPtr lpData;
}

Ich habe nicht bekommen, die MarshalAs(UnmanagedType.LPStr)] public string lpData zu arbeiten entweder. Ich habe nur bekommen Sie zu arbeiten, indem Sie die marshalling mich:

[StructLayout(LayoutKind.Sequential)]
public struct COPYDATASTRUCT : IDisposable
{
    public IntPtr dwData;
    public int cbData;
    public IntPtr lpData;

    ///<summary>
    ///Only dispose COPYDATASTRUCT if you were the one who allocated it
    ///</summary>
    public void Dispose()
    {
        if (lpData != IntPtr.Zero)
        {
            Marshal.FreeCoTaskMem(lpData);
            lpData = IntPtr.Zero;
            cbData = 0;
        }
    }
    public string AsAnsiString { get { return Marshal.PtrToStringAnsi(lpData, cbData); } }
    public string AsUnicodeString { get { return Marshal.PtrToStringUni(lpData); } }
    public static COPYDATASTRUCT CreateForString(int dwData, string value, bool Unicode = false)
    {
        var result = new COPYDATASTRUCT();
        result.dwData = (IntPtr)dwData;
        result.lpData = Unicode ? Marshal.StringToCoTaskMemUni(value) : Marshal.StringToCoTaskMemAnsi(value);
        result.cbData = value.Length + 1;
        return result;
    }
}

InformationsquelleAutor Bryce Wagner

Zwischen den 2 oben genannten Antworten habe ich zusammen geflickt, ein funktionierendes Beispiel. Bryce Wagner ' s Klasse funktioniert, also habe ich eine Methode verwenden, SendMessageTimeout, Daten zu senden. es ist eine statische Methode, so dass Sie nur nennen Sie es, um Daten zu senden. Dies ist nicht meine Arbeit, sondern kleben zusammen und teilen zurück.

    [StructLayout(LayoutKind.Sequential)]
    public struct CopyData: IDisposable {
        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = false)]
        static extern IntPtr SendMessageTimeout(IntPtr hWnd, uint Msg, IntPtr wParam, ref CopyData target,
                                                SendMessageTimeoutFlags fuFlags, uint uTimeout, out UIntPtr lpdwResult);

        [Flags]
        enum SendMessageTimeoutFlags: uint {
            SMTO_NORMAL             = 0x0,
            SMTO_BLOCK              = 0x1,
            SMTO_ABORTIFHUNG        = 0x2,
            SMTO_NOTIMEOUTIFNOTHUNG = 0x8
        }
        const uint WM_COPYDATA = 0x4A;

        public IntPtr dwData;
        public int cbData;
        public IntPtr lpData;

        public void Dispose() {
            if (lpData != IntPtr.Zero) {
                Marshal.FreeCoTaskMem(lpData);
                lpData = IntPtr.Zero;
                cbData = 0;
            }
        }
        public string AsAnsiString {
            get { return Marshal.PtrToStringAnsi(lpData, cbData); }
        }
        public string AsUnicodeString {
            get { return Marshal.PtrToStringUni(lpData); }
        }
        public static CopyData CreateForString(int dwData, string value, bool Unicode = false) {
            var result = new CopyData();
            result.dwData = (IntPtr) dwData;
            result.lpData = Unicode ? Marshal.StringToCoTaskMemUni(value) : Marshal.StringToCoTaskMemAnsi(value);
            result.cbData = value.Length + 1;
            return result;
        }

        public static UIntPtr Send(IntPtr targetHandle, int dwData, string value, uint timeoutMs = 1000, bool Unicode = false) {
            var cds = CopyData.CreateForString(dwData, value, Unicode);
            UIntPtr result;
            SendMessageTimeout(targetHandle, WM_COPYDATA, IntPtr.Zero, ref cds, SendMessageTimeoutFlags.SMTO_NORMAL, timeoutMs, out result);
            cds.Dispose();
            return result;
        }
    }

CopyData.Send(targetHandle, 1234, "This is a test");

Die der Standardwert ist 1 Sekunde timeout.

InformationsquelleAutor Wade Hatler

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.