[Code] PInvoke with Type Constraints

[bigtimt]

Here is an example of RtlMoveMemory with type constraints. This can be applied to other functions such as ReadProcessMemory. Enjoy! No comments because the code should explain itself. Let me know if you have any questions.

    public static class NativeMethods
    {
        [DllImport("Kernel32", EntryPoint = "GetModuleHandleA")]
        public static extern IntPtr GetModuleHandle(string moduleName);

        [DllImport("Kernel32")]
        public static extern IntPtr GetProcAddress(IntPtr moduleHandle, string procedureName);
    }

    static class MemoryFunctions<T> where T : struct
    {
        internal delegate void WriteArrayDelegate(IntPtr pDest, T[] pSrc, int size);
        internal delegate void ReadValueDelegate(ref T pDest, IntPtr pSrc, int size);
        internal delegate void ReadArrayDelegate(T[] pDest, IntPtr pSrc, int size);

        internal static WriteArrayDelegate WriteArray;
        internal static ReadValueDelegate ReadValue;
        internal static ReadArrayDelegate ReadArray;

        internal static int Size { get; } = Marshal.SizeOf<T>();

        static MemoryFunctions()
        {
            var hKernel32 = NativeMethods.GetModuleHandle("Kernel32");
            var pRtlMoveMemory = NativeMethods.GetProcAddress(hKernel32, "RtlMoveMemory");
            var GetDelegate = typeof(Marshal).GetMethod("GetDelegateForFunctionPointerInternal", BindingFlags.Static | BindingFlags.NonPublic);

            WriteArray = GetDelegate.Invoke(null, new object[] { pRtlMoveMemory, typeof(WriteArrayDelegate) }) as WriteArrayDelegate;
            ReadValue = GetDelegate.Invoke(null, new object[] { pRtlMoveMemory, typeof(ReadValueDelegate) }) as ReadValueDelegate;
            ReadArray = GetDelegate.Invoke(null, new object[] { pRtlMoveMemory, typeof(ReadArrayDelegate) }) as ReadArrayDelegate;
        }
    }

    public static class LocalMemory
    {
        public static T Read<T>(IntPtr ptr) where T : struct
        {
            var result = default(T);

            MemoryFunctions<T>.ReadValue(ref result, ptr, MemoryFunctions<T>.Size);

            return result;
        }

        public static void Read<T>(IntPtr ptr, out T result) where T : struct
        {
            result = default(T);

            MemoryFunctions<T>.ReadValue(ref result, ptr, MemoryFunctions<T>.Size);
        }

        public static T[] Read<T>(IntPtr ptr, int length) where T : struct
        {
            var result = new T[length];

            MemoryFunctions<T>.ReadArray(result, ptr, MemoryFunctions<T>.Size * length);

            return result;
        }

        public static void Write<T>(IntPtr ptr, params T[] values) where T : struct
        {
            MemoryFunctions<T>.WriteArray(ptr, values, MemoryFunctions<T>.Size * values.Length);
        }
    }

[lolp1]

This should be enough for most people, you need to do a little bit more if external.

    internal class UnsafeNativeMethods {
        [DllImport("kernel32.dll", EntryPoint = "CopyMemory", SetLastError = false)]
        [SecurityCritical]
        internal static extern void CopyMemory(IntPtr dest, IntPtr src, uint count);
 
        [DllImport("kernel32.dll", EntryPoint = "CopyMemory", SetLastError = false)]
        [SecurityCritical]
        internal static extern unsafe void CopyMemoryPtr(void* dest, void* src, uint count);
    }
 
    [SuppressMessage("ReSharper", "StaticMemberInGenericType")]
    public static class FastStruct<T> where T : struct {
        private static readonly GetPtrDelegate GetPtr = BuildGetPtrMethod();
        private static readonly PtrToStructureDelegateIntPtr PtrToStructureIntPtr = BuildLoadFromIntPtrMethod();
        private static readonly unsafe PtrToStructureDelegateBytePtr PtrToStructureBytePtr = BuildLoadFromBytePtrMethod();
 
        public static readonly int Size = Marshal.SizeOf<T>();
 
        private static DynamicMethod _methodGetPtr;
        private static DynamicMethod _methodLoadIntPtr;
        private static DynamicMethod _methodLoadBytePtr;
 
        private static GetPtrDelegate BuildGetPtrMethod() {
            _methodGetPtr = new DynamicMethod("GetStructPtr<" + typeof(T).FullName + ">",
                typeof(IntPtr), new[] {typeof(T).MakeByRefType()}, typeof(FastStruct<T>));
 
            var generator = _methodGetPtr.GetILGenerator();
            generator.Emit(OpCodes.Ldarg_0);
            generator.Emit(OpCodes.Conv_U);
            generator.Emit(OpCodes.Ret);
            return (GetPtrDelegate) _methodGetPtr.CreateDelegate(typeof(GetPtrDelegate));
        }
 
        private static PtrToStructureDelegateIntPtr BuildLoadFromIntPtrMethod() {
            _methodLoadIntPtr = new DynamicMethod("PtrToStructureIntPtr<" + typeof(T).FullName + ">",
                typeof(T), new[] {typeof(IntPtr)}, typeof(FastStruct<T>));
 
            var generator = _methodLoadIntPtr.GetILGenerator();
            generator.Emit(OpCodes.Ldarg_0);
            generator.Emit(OpCodes.Ldobj, typeof(T));
            generator.Emit(OpCodes.Ret);
 
            return (PtrToStructureDelegateIntPtr) _methodLoadIntPtr.CreateDelegate(typeof(PtrToStructureDelegateIntPtr));
        }
 
        private static PtrToStructureDelegateBytePtr BuildLoadFromBytePtrMethod() {
            _methodLoadBytePtr = new DynamicMethod("PtrToStructureBytePtr<" + typeof(T).FullName + ">",
                typeof(T), new[] {typeof(byte*)}, typeof(FastStruct<T>));
 
            var generator = _methodLoadBytePtr.GetILGenerator();
            generator.Emit(OpCodes.Ldarg_0);
            generator.Emit(OpCodes.Ldobj, typeof(T));
            generator.Emit(OpCodes.Ret);
 
            return (PtrToStructureDelegateBytePtr) _methodLoadBytePtr.CreateDelegate(typeof(PtrToStructureDelegateBytePtr));
        }
 
        public static T PtrToStructure(IntPtr ptr) => PtrToStructureIntPtr(ptr);
 
        public static unsafe T PtrToStructure(byte* ptr) => PtrToStructureBytePtr(ptr);
 
        public static T[] ReadArray(IntPtr source, int bytesCount) {
            var elementSize = (uint) Size;
 
            var buffer = new T[bytesCount / elementSize];
 
            if (bytesCount <= 0)
                return buffer;
            var intPtr = GetPtr(ref buffer[0]);
            UnsafeNativeMethods.CopyMemory(intPtr, source, (uint) bytesCount);
 
            return buffer;
        }
 
        private delegate IntPtr GetPtrDelegate(ref T value);
 
        private delegate T PtrToStructureDelegateIntPtr(IntPtr pointer);
 
        private unsafe delegate T PtrToStructureDelegateBytePtr(byte* pointer);
    }

[bigtimt]

AFAIK, the only issue with using your method is that it will only work on public types. Any types that you want to keep private or internal either have to be in the same assembly or changed to public.

Could be wrong but that's what I ran into at some point.

This is the way I've found to not PInvoke and also not use DynamicMethod:

            public static T ReadValue<T>(IntPtr ptr, int ofs = 0) where T : struct
            {
                var buffer = default(T);
                var pBuffer = __makeref(buffer);

                *((IntPtr*)&pBuffer) = ptr + ofs;

                try
                {
                    return __refvalue(pBuffer, T);
                }
                catch (NullReferenceException)
                {
                    return buffer;
                }
            }

            public static bool WriteValue<T>(T value, IntPtr ptr, int ofs = 0) where T : struct
            {
                var buffer = default(T);
                var pBuffer = __makeref(buffer);
     
                *((IntPtr*)&pBuffer) = ptr + ofs;

                try
                {
                    __refvalue(pBuffer, T) = value;
                    return true;
                }
                catch (NullReferenceException) { return false; }
            }

[Jadd]

Use RtlCopyMemory. It's faster. You won't have any problems with it unless you're doing something you shouldn't be.

Also, no VirtualProtect?

[bigtimt]

Code was just an example for people to incorporate into their own libs, it wasn't meant to be a full class. The __makeref and __ref value methods are actually twice as fast as RtlMoveMemory according to my benchmarking over 1mil tests.

[Jadd]

Code was just an example for people to incorporate into their own libs, it wasn't meant to be a full class. The __makeref and __ref value methods are actually twice as fast as RtlMoveMemory according to my benchmarking over 1mil tests.

As expected. +1 for using undocumented keywords/functions.

[MaiN]

By far the fastest way is with System.Runtime.CompilerServices.Unsafe: NuGet Gallery
| System.Runtime.CompilerServices.Unsafe 4.3.0.

Install this and use Unsafe.Read<T>/Write<T> for single value reads and Unsafe.CopyBlock<T> for arrays.
It should match or be faster than any __refvalue hacks, and it will also work on .NET standard.