C#

// Loading with current delegated method
        private enum Libraries
        {
            Client,
            Server,
            Cursor,
            Egl,
            Shm,
            V4l
        }

        private const string libdl = "libdl.so.2";
        [DllImport(libdl)]
        private extern static IntPtr dlopen(string sofile, uint soflag);
        [DllImport(libdl)]
        private extern static IntPtr dlsym(IntPtr sohandle, string functionname);
        private const uint LAZY = 0x0001;
        private static T LoadFunction<T>(string name, Libraries libraries)
        {
            IntPtr sohandle = IntPtr.Zero;
            switch (libraries)
            {
                case Libraries.Client:
                    sohandle = dlsym(dlopen("libwayland-client.so.0", LAZY), name);
                    break;

                case Libraries.Server:
                    sohandle = dlsym(dlopen("libwayland-server.so.0", LAZY), name);
                    break;

                case Libraries.Cursor:
                    sohandle = dlsym(dlopen("libwayland-cursor.so.0", LAZY), name);
                    break;

                case Libraries.Egl:
                    sohandle = dlsym(dlopen("libwayland-egl.so.1", LAZY), name);
                    break;
            }

            if (sohandle == IntPtr.Zero)
            {
                return default(T);
            }

            return (T)(object)Marshal.GetDelegateForFunctionPointer(sohandle, typeof(T));
        }

[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr wl_display_get_registry(IntPtr display);
        public static Registry DisplayGetRegistry(Display display)
        {
            var emit = LoadFunction<wl_display_get_registry>("wl_display_get_registry", Libraries.Client);
            return emit(display);
        }

[StructLayout(LayoutKind.Sequential)]
        public class Display
        {
            private IntPtr handle;
            internal Display(IntPtr target)
            {
                handle = target;
            }

            public static implicit operator IntPtr(Display display)
            {
                return display.handle;
            }
            public static implicit operator Display(IntPtr target)
            {
                return new Display(target);
            }
        }

        [StructLayout(LayoutKind.Sequential)]
        public class Registry
        {
            private IntPtr handle;
            internal Registry(IntPtr target)
            {
                handle = target;
            }

            public static implicit operator IntPtr(Registry registry)
            {
                return registry.handle;
            }
            public static implicit operator Registry(IntPtr target)
            {
                return new Registry(target);
            }
        }

[StructLayout(LayoutKind.Sequential)]
        public struct RegistryListener
        {
            [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
            public unsafe delegate void AddListener(void* data, Registry registry, uint name, string registry_interface, uint version);

            [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
            public unsafe delegate void RemoveListener(void* data, Registry registry, uint name);

            /*
             * void (*global)(void *data,
             *      struct wl_registry *wl_registry,
             *      uint32_t name,
             *      const char *interface,
             *      uint32_t version)
             */
            public AddListener global;

            /*
             * void (*global_remove)(void *data,
             *      struct wl_registry *wl_registry,
             *      uint32_t name);
             */
            public RemoveListener global_remove;
        }

using System;
using static Wayland.WLC;

namespace WaylandTest
{
    unsafe class MainClass
    {
        protected static Display display;
    //    private static Compositor compositor = null;

        private static void global_registry_handle(void* data, Registry registry, uint name, string registry_interface, uint id)
        {
            Console.WriteLine($"Get a registry event for {registry_interface} id {id}");
            if (StringCompute(registry_interface, "wl_compositor"))
            {
                //compositor = 
            }
        }

        private static void global_registry_remove(void* data, Registry registry, uint id)
        {

        }


        private static RegistryListener registry_listener = new RegistryListener
        {
            global = global_registry_handle,
            global_remove = global_registry_remove
        };

        static int Main(string[] args)
        {
            display = DisplayConnect(null);
            if (display == null)
            {
                Console.WriteLine("Can't connect to display\\n");
                Environment.Exit(1);
            }
            Console.WriteLine("connected to display\\n");

            Registry registry = DisplayGetRegistry(display);
            RegistryAddListener(registry, ref registry_listener, null);
            DisplayDispatch(display);
            DisplayRoundTrip(display);

            /*if (compositor == null)
            {
                Console.WriteLine("Can't find compositor\\n");
                Environment.Exit(1);
            }
            else
            {
                Console.WriteLine("Found compositor\n");
            }*/

            DisplayDisconnect(display);
            Console.WriteLine("disconnected from display\\n");

            Environment.Exit(0);
            return 0;
        }

    }
}