windows 10 pro office 2019 pro office 365 pro windows 10 home windows 10 enterprise office 2019 home and business office 2016 pro windows 10 education visio 2019 microsoft project 2019 microsoft project 2016 visio professional 2016 windows server 2012 windows server 2016 windows server 2019 Betriebssysteme office software windows server https://softhier.com/ instagram takipçi instagram beğeni instagram görüntüleme instagram otomatik beğeni facebook beğeni facebook sayfa beğenisi facebook takipçi twitter takipçi twitter beğeni twitter retweet youtube izlenme youtube abone instagram

How to pass a method pointer in C# to C library?

Asked By: Anonymous

Does anyone know how to cast a method in C# to a void* member?

In the example below, sigaction.sa_handler is a void* member that specifies a callback function.

Environment:

  • VisualStudio Professional 2019 16.9.4
  • dotnet core SDK 3.1
  • Ubuntu on WSL
  • Tmds.Linux 0.5.0
    sigaction sigact = new sigaction();

    //Error CS0428  Cannot convert method group 'catcher' to non-delegate type 'void*'.Did you intend to invoke the method?
    sigact.sa_handler = catcher;

    //Error CS0030  Cannot convert type 'method' to 'void*'
    sigact.sa_handler = (void *)catcher;

    //Error CS0029  Cannot implicitly convert type 'SignalCallback' to 'void*'
    SignalCallback callback = new SignalCallback(catcher);
    sigact.sa_handler = callback;

    //Error CS0030  Cannot convert type 'SignalCallback' to 'void*'
    sigact.sa_handler = (void*)callback;

Structure of sigaction (from Tmds.Linux)

    public struct sigaction
    {
        public sigset_t sa_mask;

        public void* sa_handler { get; set; }
        public void* sa_sigaction { get; set; }
        public int sa_flags { readonly get; set; }
        public void* sa_restorer { readonly get; set; }
    }

Full source code:

    using System;

    using static Tmds.Linux.LibC;
    using Tmds.Linux;
    using System.Runtime.InteropServices;
    
    delegate void SignalCallback(int sig);

    namespace example
    {
        class Program
        {
            static void catcher(int sig)
            {
                Console.Write($"Signal catcher called for signal {sig}");
            }

            static void timestamp(string str)
            {
                Console.Write($"The time {str} is {DateTime.Now}");
            }

            static unsafe int Main(string[] args)
            {
                int result = 0;

                sigaction sigact = new sigaction();
                sigset_t waitset = new sigset_t();
                siginfo_t info = new siginfo_t();

                sigset_t* ptr = &sigact.sa_mask;
                sigemptyset(&sigact.sa_mask);
                sigact.sa_flags = 0;

                //Error CS0428  Cannot convert method group 'catcher' to non-delegate type 'void*'.Did you intend to invoke the method?
                sigact.sa_handler = catcher;

                //Error CS0029  Cannot implicitly convert type 'SignalCallback' to 'void*'
                SignalCallback callback = new SignalCallback(catcher);
                sigact.sa_handler = callback;

                sigaction(SIGALRM, &sigact, null);

                sigemptyset(&waitset);
                sigaddset(&waitset, SIGALRM);

                sigprocmask(SIG_BLOCK, &waitset, null);

                alarm(10);

                timestamp("before sigwaitinfo()");

                result = sigwaitinfo(&waitset, &info);

                if (result == SIGALRM)
                    Console.WriteLine($"sigwaitinfo() returned for signal {info.si_signo}");
                else
                {
                    Console.WriteLine($"sigwait() returned code {result}");
                    Console.WriteLine($"sigwait() returned error number {errno}");
                    Console.WriteLine("sigwait() function failed");
                }

                timestamp("after sigwaitinfo()");

                return result;
            }
        }
    }

Solution

Answered By: Anonymous

To get a void* pointer from the delegate, you need Marshal.GetFunctionPointerForDelegate. You must make sure the delegate is not garbage-collected before its final use. You can use GC.KeepAlive for this.

SignalCallback callback = new SignalCallback(catcher);
sigact.sa_handler = Marshal.GetFunctionPointerForDelegate(callback);

// do the rest of your stuff

// after it's last usage by unmanaged code
GC.KeepAlive(callback);

However:

You should really be relying much more on P/Invoke to do any conversion. It should in most cases be able to sort out the void* conversions, all you need is GC.KeepAlive.

Your current code is hugely problematic as you are casting managed pointers to void* all over.

For example, instead of this call, which is doing a conversion from & managed pointer to void*

sigemptyset(&waitset);

Instead you would use

sigemptyset(ref waitset);

Your structs ideally shouldn’t use properties, because it makes it harder to define attributes on the fields. I note that sigaction doesn’t seem to be in the correct order, from what I can tell from a quick Google.

You should define sigaction something like this

    public struct sigaction
    {
        public SignalCallback sa_handler;
        public SignalAction sa_sigaction;
        public sigset_t sa_mask;
        public int sa_flags;
        public SignalRestorer sa_restorer;
    }

techinplanet staff

Porno Gratuit Porno Français Adulte XXX Brazzers Porn College Girls Film érotique Hard Porn Inceste Famille Porno Japonais Asiatique Jeunes Filles Porno Latin Brown Femmes Porn Mobile Porn Russe Porn Stars Porno Arabe Turc Porno caché Porno de qualité HD Porno Gratuit Porno Mature de Milf Porno Noir Regarder Porn Relations Lesbiennes Secrétaire de Bureau Porn Sexe en Groupe Sexe Gay Sexe Oral Vidéo Amateur Vidéo Anal

Windows 10 Kaufen Windows 10 Pro Office 2019 Kaufen Office 365 Lizenz Windows 10 Home Lizenz Office 2019 Home Business Kaufen windows office 365 satın al follower kaufen instagram follower kaufen porno