C# 具有通用委托的 GetDelegateForFunctionPointer

Question

I need to dynamically invoke dll function.

I'm using standard windows API to load dll and get proc address.

After I retrieve proc's IntPtr I try to convert it to delegate:

Func<int> inv = (Func<int>)Marshal.GetDelegateForFunctionPointer(proc, typeof(Func<int>));

But it fails because typeof(Func) return generics type.

Is there any clean way to accomplish what I'm trying to do without just declaring member delegate and use it as type?

I mean I'm trying to avoid the following redundancy:

//I need this member only for typeof operator
private delegate int RunDll();
RunDll inv = (RunDll)Marshal.GetDelegateForFunctionPointer(proc, typeof(RunDll));

Answer 1

It would be worse if the delegate type was dynamic and you didn't know the parameters. Then you could use .NET methods to generate it.

public static class DelegateCreator
{
    private static readonly Func<Type[],Type> MakeNewCustomDelegate = (Func<Type[],Type>)Delegate.CreateDelegate(typeof(Func<Type[],Type>), typeof(Expression).Assembly.GetType("System.Linq.Expressions.Compiler.DelegateHelpers").GetMethod("MakeNewCustomDelegate", BindingFlags.NonPublic | BindingFlags.Static));

    public static Type NewDelegateType(Type ret, params Type[] parameters)
    {
        Type[] args = new Type[parameters.Length];
        parameters.CopyTo(args, 0);
        args[args.Length-1] = ret;
        return MakeNewCustomDelegate(args);
    }
}

DelegateCreator.NewDelegateType(typeof(int)) //returns non-generic variant of Func<int>

Answer 2

According to the documentation generics simply aren't supported by this API. Note that this isn't a great loss - after all, you need to specify the signature just once; the only disadvantage is that you cannot specify it inline - using Func<int> doesn't require that indirection, but (due to the cast) it's in a sense actually more redundant.

Incidentally, you may want to look at plain old DllImport - if the DLL and function are known ahead of time, you don't need to do this manual delegate wrapping.

Answer 3

The original question here was (probably) best answered by DllImport , but the discussion inspired NativeGenericDelegates .

This project aims to provide System.Delegate objects that have a generic interface, can be used with P/Invoke, and may be invoked from both managed and unmanaged code with an Invoke method that doesn't rely on DynamicInvoke .

The calling convention of the unmanaged function pointer is explicitly specified by all methods, and custom marshaling behavior for the return value and parameters is optionally supported.

The (broken) code from the question:

Func<int> inv = (Func<int>)Marshal.GetDelegateForFunctionPointer(proc, typeof(Func<int>));

Could be implemented using:

var inv = INativeFunc<int>.FromFunctionPointer(proc, CallingConvention.Cdecl); // update calling convention as needed
int result = inv.Invoke(); // invoke the native function
Func<int> invFunc = inv.ToFunc(); // convert to Func<int> for use with other APIs

Details on more complex method signatures (including marshaling and modified signatures) are included in the project repo and source files.

Answer 4

At first: the implementation of method DelegateCreator.NewDelegateType isn't correct!

public static Type NewDelegateType(Type ret, params Type[] parameters) {
  /*
  Type[] args = new Type[parameters.Length];   // Create "args" array of same length as "parameters" (must be length + 1)
  parameters.CopyTo(args, 0);                  // Copy all values of parameters to "args" array
  args[args.Length - 1] = ret;                 // Put "ret" value to last item of "args" array
  return MakeNewCustomDelegate(args);
  */
  var offset = parameters.Length;
  Array.Resize(ref parameters, offset + 1);
  parameters[offset] = ret;
  return MakeNewCustomDelegate(parameters);
}

What is profit of that helper if we cannot get a typed delegate to invoke? See test example below.

using System;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.InteropServices;

namespace GenericDelegates {
  static class DelegateCreator {
    public static readonly Func<Type[], Type> MakeNewCustomDelegate = (Func<Type[], Type>) Delegate.CreateDelegate(
      typeof(Func<Type[], Type>),
      typeof(Expression).Assembly.GetType("System.Linq.Expressions.Compiler.DelegateHelpers").GetMethod(
        "MakeNewCustomDelegate",
        BindingFlags.NonPublic | BindingFlags.Static
      )
    );
    public static Type NewDelegateType(Type ret, params Type[] parameters) {
      var offset = parameters.Length;
      Array.Resize(ref parameters, offset + 1);
      parameters[offset] = ret;
      return MakeNewCustomDelegate(parameters);
    }
  }
  static class Kernel {
    [DllImport("kernel32.dll", SetLastError = true)]
    public static extern IntPtr GetModuleHandle(string name);
    [DllImport("kernel32.dll", SetLastError = true)]
    public static extern IntPtr GetProcAddress(IntPtr module, string name);
  }
  static class InvokeHelper {
    public static Delegate MakeDelegate(this IntPtr address, Type ret, params Type[] parameters) {
      return Marshal.GetDelegateForFunctionPointer(address, DelegateCreator.NewDelegateType(ret, parameters));
    }
  }
  class Program {
    static void Main(string[] args) {
      var kernel = Kernel.GetModuleHandle("kernel32.dll");
      var address = Kernel.GetProcAddress(kernel, "GetModuleHandleW");
      Console.WriteLine(@"
Module base: 0x{0:X8}
Entry point: 0x{1:X8}
", (int) kernel, (int) address);
      var invoke = address.MakeDelegate(typeof(IntPtr), typeof(string));
      Console.WriteLine(@"
Untyped delegate: {0}
Cast to Invoke: {1}
", invoke, invoke as Func<string, IntPtr> == null ? "Error" : "Valid"); // invoke as Func<string, IntPtr> = NULL
      Console.ReadKey();
    }
  }
}

Answer 5

I'm doing something like that:

var calculate = FunctionDelegateAccessor.GetMethod<Calculate>(handle, "Calculate");
Console.WriteLine("10 + 10 = " + calculate(10, 10));
var multiply = FunctionDelegateAccessor.GetMethod<Multiply>(handle, "Multiply");
Console.WriteLine("10 * 10 = " + multiply(10, 10));

public delegate int Calculate(int a, int b);
public delegate int Multiply(int a, int b);

Output in Console:

10 + 10 = 20 
10 * 10 = 100

Math.cpp

DLL_API int Calculate(int a, int b)
{
    return a + b;
}
DLL_API int Multiply(int a, int b)
{
    return a * b;
}

Math.h

#pragma once

#define DLL_API __declspec(dllexport)

extern "C" 
{
    DLL_API int Calculate(int a, int b);
    DLL_API int Multiply(int a, int b);
}

internal static class FunctionDelegateAccessor
{
    public static TDelegate GetMethod<TDelegate>(IntPtr moduleHandle, string name) where TDelegate 
    {
        var methodProcAddress = ExternalKernelCalls.GetProcAddress(moduleHandle, name);
        if (methodProcAddress == IntPtr.Zero)
        {
            throw new Win32Exception();
        }
        
        var @delegate = Marshal.GetDelegateForFunctionPointer<TDelegate>(methodProcAddress);
        if (@delegate == null)
        {
            throw new Exception("Function delegate not found!");
        }
        return @delegate;
    }
}
internal static class ExternalKernelCalls
{
    [DllImport(Kernel32LibraryName, SetLastError = true)]
    public static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);
    private const string Kernel32LibraryName = "kernel32.dll";
}

More info on the GitHub repo with sources here .