Memory.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.ComponentModel;
using be.gaudry.bibliobrol.config;
 
namespace be.gaudry.bibliobrol.model.eid
{
    public class Memory
    {
        #region Enumerations
        public enum AllocationFlags : int
        {
            Fixed = 0,
            Movable = 2,
            ZeroInit = 0x40,
            FixedZeroInit = (Fixed + ZeroInit)
        }
        #endregion
 
        #region Imports
        [DllImport(Config.Kernel32DLL, SetLastError = true)]
        private static extern IntPtr LocalAlloc(AllocationFlags flags, int bytes);
 
        [DllImport(Config.Kernel32DLL, SetLastError = true)]
        private static extern IntPtr LocalFree(IntPtr handle);
 
        [DllImport(Config.Kernel32DLL, SetLastError = true)]
        private static extern IntPtr LocalReAlloc(IntPtr handle, int bytes,
                                    AllocationFlags flags);
        #endregion
 
        #region Methods
        // Allocates a block of memory using LocalAlloc
        public static IntPtr AllocHLocal(int cb)
        {
            // allocate and return
            return LocalAlloc(AllocationFlags.FixedZeroInit, cb);
        }
 
        // Frees memory allocated by AllocHLocal
        public static void FreeHLocal(IntPtr handle)
        {
            // check if zero
            if (!handle.Equals(IntPtr.Zero))
            {
                // free it first
                if (!IntPtr.Zero.Equals(LocalFree(handle)))
                {
                    // throw exception
                    throw new Win32Exception(Marshal.GetLastWin32Error());
                }
                else
                {
                    // clear
                    handle = IntPtr.Zero;
                }
            }
        }
        // Resizes a block of memory previously allocated with AllocHLocal
        public static IntPtr ReAllocHLocal(IntPtr pv, int cb)
        {
            // allocate
            IntPtr newMem = LocalReAlloc(pv, cb, AllocationFlags.Movable);
            // check
            if (newMem.Equals(IntPtr.Zero))
            {
                // something went wrong
                throw new OutOfMemoryException();
            }
            // return allocated handle
            return newMem;
        }
        // Copies the contents of a managed string to unmanaged memory
        public static IntPtr StringToHLocalUni(string s)
        {
            // check if zero
            if (s == null)
            {
                // retrurn empty
                return IntPtr.Zero;
            }
            else
            {
                // get length
                int nc = s.Length;
                int length = 2 * (1 + nc);
                // allocate proper length
                IntPtr handle = AllocHLocal(length);
                // check if successfull
                if (handle.Equals(IntPtr.Zero))
                {
                    // something went wrong
                    throw new OutOfMemoryException();
                }
                else
                {
                    // copy
                    Marshal.Copy(s.ToCharArray(), 0, handle, s.Length);
                    // return new handle
                    return handle;
                }
            }
        }
        // Copies the contents of a managed string to unmanaged memory
        public static IntPtr ByteToHLocal(byte[] data, int offset, int count)
        {
            // check if zero
            if (data == null)
            {
                // retrurn empty
                return IntPtr.Zero;
            }
            else
            {
                // allocate proper length
                IntPtr handle = AllocHLocal(count);
                // check if successfull
                if (handle.Equals(IntPtr.Zero))
                {
                    // something went wrong
                    throw new OutOfMemoryException();
                }
                else
                {
                    // copy
                    Marshal.Copy(data, offset, handle, count);
                    // return new handle
                    return handle;
                }
            }
        }
        #endregion
    }
}