Subscribing to windows messages through unmanaged c++ dll from c# net core

Question

I am trying to subscribe to windows message events/messaging system from c# net core through unamanged c++ dll using pinvoke.

Issues I am having.

Getting the handle for my process or creating an empty window (does .net even support that).

  var hwnd = Process.GetCurrentProcess().Handle;
  var hwnd1 = Process.GetCurrentProcess().Handle.ToPointer();

Is either of that is valid to get the handle.

How do I marshal that handle to c++ HWND type. IntPtr seems like obvious choice, but it does not work.

Here is what I am using to subscribe to events

public class MsgSubscribe : IDisposable
{
    private readonly Importer _importer;

    [UnmanagedFunctionPointer(CallingConvention.Winapi)]
    private delegate Status DMsgSubscribe(uint msgType, uint msgQ,  int hwnd, uint msgId);
    private static DMsgSubscribe _dMsgSubscribe;
    private IntPtr PMsgSubscribe { get; set; }

    public bool Available { get; set; }

    public MsgSubscribe(Importer importer)
    {
        _importer = importer;

        if (_importer.hCurModule != IntPtr.Zero)
        {
            PMsgSubscribe = Importer.GetProcAddress(_importer.hCurModule, "MsgSubscribe");
            Available = PUlyMsgSubscribe != IntPtr.Zero;
        }
    }

    public Status MsgSubscribe(uint msgType, uint msgQ, int hwnd, uint msgId)
    {
        Status result = Status.FunctionNotAvailable;


        if (Available)
        {
            _dMsgSubscribe = (DMsgSubscribe)Marshal.GetDelegateForFunctionPointer(PMsgSubscribe, typeof(DMsgSubscribe));
            result = _dMsgSubscribe(msgType, msgQ, hwnd, msgId);
        }

        return result;
    }



    public void Dispose()
    {
    }
}

I've tried IntPtr and int for HWND marshalling, neither works. Also I am not sure how I am supposed to catch window message based events, there is very little online if anything.

Any help appreciated.

score 1 · Accepted Answer · answered May 10 '18 at 14:48

Eventually found a way to make this work, it involves creating a window through c++ pinvoke.

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Threading;
using System.Threading.Tasks;
using Constants.Constants;
using Constants.Enums;
using Models.WindowsApiModels;

namespace Dependencies.MessagingHandling
{
    public class CustomWindow : IDisposable
    {
        delegate IntPtr WndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam);


        private const int ErrorClassAlreadyExists = 1410;
        public IntPtr Handle { get; private set; }
        public List<YourType> Messages { get; set; }

        public void Dispose()
        {
            if (Handle != IntPtr.Zero)
            {
                Importer.DestroyWindow(Handle);
                Handle = IntPtr.Zero;
            }
        }

        public CustomWindow()
        {
            Messages = new List<YourType>();
            var className = "Prototype Messaging Class";

            WndProc mWndProcDelegate = CustomWndProc;

            // Create WNDCLASS
            WNDCLASS windClass = new WNDCLASS
            {
                lpszClassName = className,
                lpfnWndProc = Marshal.GetFunctionPointerForDelegate(mWndProcDelegate)
            };

            UInt16 classAtom = Importer.RegisterClassW(ref windClass);

            int lastError = Marshal.GetLastWin32Error();

            if (classAtom == 0 && lastError != ErrorClassAlreadyExists)
            {
                throw new Exception("Could not register window class");
            }

            // Create window
            Handle = Importer.CreateWindowExW(
                0,
                className,
                "Prototype Messaging Window",
                0, 0, 0, 0, 0,
                IntPtr.Zero,
                IntPtr.Zero,
                IntPtr.Zero,
                IntPtr.Zero
            );
        }

        private IntPtr  CustomWndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
        {
            //handle your message here

            return Importer.DefWindowProc(hWnd, msg, wParam, lParam);
        }



        public Task GetMessage()
        {
            IntPtr handle = Handle;
            int bRet;
            while ((bRet = Importer.GetMessage(out var msg, Handle, 0, 0)) != 0)
            {
                switch (bRet)
                {
                    case -1:
                        Console.WriteLine("Error");
                        CancellationToken token = new CancellationToken(true);
                        return Task.FromCanceled(token);
                    default:
                        Importer.TranslateMessage(ref msg);
                        Importer.DispatchMessage(ref msg);
                        break;
                }
            }
            return Task.FromResult(true);
        }
    }
}

Run this in your main Method in the main thread and your menu/gui in secondary thread

 Task.Run(ShowMenu);

 _customWindow.GetMessage();

Importer is custom class containing c++ marshalled functions to create/handle window, look the up by the name as they are the same. All CAPS class/struct are windows/c++ api structs, those can be found on official msdn.

score 0 · Answer 2 · answered Apr 27 '18 at 13:15

0

In general using an IntPtr is corrent.

Handle()

Returns such a IntPtr.

It looks like that you're trying to use your process HWND to get window messages which will not work because you have to use a window HWND to get the messages associated to that HWND.

answered Apr 27 '18 at 13:15

user743414

936
10
23

how do I get a window or create one in dot net core? – Aistis Taraskevicius Apr 28 '18 at 14:02
@AistisTaraskevicius When you're trying to subscribe window messages you should already have a window. Or you could create a form on your own. – user743414 Apr 29 '18 at 20:51
but how can I do that using .net core. It does not provide support for windows forms or any other window based gui. – Aistis Taraskevicius Apr 30 '18 at 08:00
@AistisTaraskevicius You need some kind of a window to get the messages. No window no messages. – user743414 May 02 '18 at 12:47
I realize that I cannot receives messages without window. Mind posting how can I create a window through pinvoke and subscribe to its messages through net core? – Aistis Taraskevicius May 02 '18 at 15:46
@AistisTaraskevicius EnumWindows or FindWindow should be your friend. – user743414 May 03 '18 at 08:17
I looked into that, but that returns all windows, also I cannot find window without having one created. I still have to create window through pinvoke which Is what I am attempting to do now. Still not sure how I subscribe to it through net core. – Aistis Taraskevicius May 03 '18 at 08:20
@AistisTaraskevicius Then you have to use CreateWindowEx – user743414 May 03 '18 at 13:03
I've managed to create window. receive create/destroy messages sent to video, but I am having trouble receiving messages I am subscribing to. I am wondering if its because WndProc I am passing in as callback, running in same thread and gets blocked during those messages. Also not sure but I cannot @ your name. – Aistis Taraskevicius May 03 '18 at 15:26

Subscribing to windows messages through unmanaged c++ dll from c# net core

2 Answers2