C#

using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Windows.Forms;

public class Test
{
  static void Main(string[] args)
  {
    using (AccessibleForm form = new AccessibleForm())
    {
      form.MoveSizeStart += new EventHandler(OnMoveSizeStart);
      form.MoveSizeEnd += new EventHandler(OnMoveSizeEnd);
      Application.Run(form);
    }
  }

  static void OnMoveSizeStart(object sender, EventArgs e)
  {
    Console.WriteLine("Move/Size has started.");
  }

  static void OnMoveSizeEnd(object sender, EventArgs e)
  {
    Console.WriteLine("Move/Size has ended.");
  }

  private class AccessibleForm : Form
  {
    private GCHandle cbHandle;
    private IntPtr hWinEventHook;
    
    public AccessibleForm()
    {
      // Create and pin the callback.
      WinEventProcCallback callback =
        new WinEventProcCallback(WinEventProc);
      cbHandle = GCHandle.Alloc(callback);

      // Register the callback.
      hWinEventHook = SetWinEventHook(
        new IntPtr(EVENT_SYSTEM_MOVESIZESTART),
        new IntPtr(EVENT_SYSTEM_MOVESIZEEND),
        IntPtr.Zero,
        (IntPtr)cbHandle,
        Process.GetCurrentProcess().Id,
        0,
        new IntPtr(1)); // WINEVENT_INCONTEXT ???
    }

    public event EventHandler MoveSizeStart;
    public event EventHandler MoveSizeEnd;

    protected override void Dispose(bool disposing)
    {
      if (hWinEventHook != IntPtr.Zero)
      {
        UnhookWinEvent(hWinEventHook);
        hWinEventHook = IntPtr.Zero;
      }

      if (cbHandle.IsAllocated)
        cbHandle.Free();

      base.Dispose(disposing);
    }

    protected virtual void OnMoveSizeStart(EventArgs e)
    {
      if (MoveSizeStart != null)
        MoveSizeStart(this, e);
    }

    protected virtual void OnMoveSizeEnd(EventArgs e)
    {
      if (MoveSizeEnd != null)
        MoveSizeEnd(this, e);
    }

    private void WinEventProc(
      IntPtr hWinEventHook,
      uint evt,
      IntPtr hwnd,
      int idObject,
      int idChild,
      uint dwEventThread,
      uint dwmsEventTime)
    {
      if (evt == EVENT_SYSTEM_MOVESIZESTART)
        OnMoveSizeStart(EventArgs.Empty);

      else if (evt == EVENT_SYSTEM_MOVESIZEEND)
        OnMoveSizeEnd(EventArgs.Empty);
    }

    private const uint EVENT_SYSTEM_MOVESIZESTART = 0x000a;
    private const uint EVENT_SYSTEM_MOVESIZEEND = 0x000b;

    private delegate void WinEventProcCallback(
      IntPtr hWinEventHook,
      uint evt,
      IntPtr hwnd,
      int idObject,
      int idChild,
      uint dwEventThread,
      uint dwmsEventTime);

    [DllImport("user32.dll")]
    private static extern IntPtr SetWinEventHook(
      [MarshalAs(UnmanagedType.SysUInt)] IntPtr eventMin,
      [MarshalAs(UnmanagedType.SysUInt)] IntPtr eventMax,
      IntPtr hmodWinEventProc,
      IntPtr lpfnWinEventProc,
      [MarshalAs(UnmanagedType.U4)] int idProcess,
      [MarshalAs(UnmanagedType.U4)] int idThread,
      [MarshalAs(UnmanagedType.SysUInt)] IntPtr dwflags);

    [DllImport("user32.dll")]
    private static extern bool UnhookWinEvent(IntPtr hWinEventHook);
  }
}

----- BEGIN ENCRYPTED TEXT -----
base64 encoded cipher text
----- END ENCRYPTED TEXT -----

<br />
byte[] databuffer= new byte[4096];<br />
uint byteread=0;<br />
Toolhelp32ReadProcessMemory(p.Handle,p.BaseAddress,databuffer,100,(uint)byteread);<br />

// No need to allocate more bytes than you plan on reading
byte[] databuffer = new byte[100];
// Pin the object in memory so the GC doesn't move it
GCHandle handle = GCHandle.Alloc(databuffer);
// Get the pointer
IntPtr ptr = handle.AddrOfPinnedObject();
// Call your method
uint bytesread; // defaults to 0, and no need to cast like you did
Toolhelp32ReadProcessMemory(p.Handle, b.BaseAddress, ptr, 100, bytesread);
// Free the GCHandle and your databuffer now contains the data.
handle.Free();