C#

public static string GetUserFolder()
{
    return 
        Environment.GetEnvironmentVariable("SystemDrive") + 
        Environment.GetEnvironmentVariable("HOMEPATH"); 
}

public const int UserProfile = 40;

[DllImport("shfolder.dll", CharSet = CharSet.Auto)]
private static extern int SHGetFolderPath(IntPtr hwndOwner, int nFolder, IntPtr hToken, int dwFlags, StringBuilder lpszPath);

public static string GetUserPath()
{
    StringBuilder resultBuilder = new StringBuilder(260);
    int num = SHGetFolderPath(IntPtr.Zero, UserProfile, IntPtr.Zero, 0, resultBuilder);
    if (num == -2146233031)
        throw new PlatformNotSupportedException();
    return resultBuilder.ToString();
}

manchukuo wrote:

Cannot convert type 'System.Drawing.Size' to 'int'

new IntPtr(yourInt)

// NativeMethods.cs

using System;
using System.Drawing;
using System.Runtime.InteropServices;

internal static class NativeMethods
{
    // http://msdn.microsoft.com/en-us/library/ms644950(v=vs.85).aspx
    /*
LRESULT WINAPI SendMessage(
__in  HWND hWnd,
__in  UINT Msg,
__in  WPARAM wParam,
__in  LPARAM lParam
);*/
    [DllImport("User32.dll", SetLastError = true)]
    public static extern IntPtr SendMessage(
        IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam);
    [DllImport("User32.dll", SetLastError = true)]
    public static extern IntPtr SendMessage(
        IntPtr hWnd, int Msg, IntPtr wParam, ref Size lParam);
}

public static IntPtr SizeToPointer(Size size)
{
    byte[] bytes = new byte[8];
    Array.Copy(BitConverter.GetBytes(size.Width), 0, bytes, 0, 4);
    Array.Copy(BitConverter.GetBytes(size.Height), 0, bytes, 4, 4);
    IntPtr result = Marshal.AllocHGlobal(8);
    Marshal.Copy(bytes, 0, result, 8);
    return result;
}
public static Size PointerToSize(IntPtr pointer)
{
    byte[] bytes = new byte[8];
    Marshal.Copy(pointer, bytes, 0, 8);
    Size result = new Size(BitConverter.ToInt32(bytes, 0), BitConverter.ToInt32(bytes, 4));
    Marshal.FreeHGlobal(pointer);
    return result;
}

NativeMethods.SendMessage(
    form2.Handle, 100, IntPtr.Zero, NativeMethods.SizeToPointer(
        new Size(123, 456)));

protected override void WndProc(ref Message m)
{
    if (m.Msg == 100)
    {
        Size size = NativeMethods.PointerToSize(m.LParam);
        MessageBox.Show(size.ToString());
    }
    base.WndProc(ref m);
}

public static IntPtr ConvertSizeToPointer(Size size)
{
    SizeWrapper wrapper = new SizeWrapper(size);
    IntPtr result = Marshal.AllocHGlobal(Marshal.SizeOf(wrapper));
    Marshal.StructureToPtr(wrapper, result, true);
    return result;
}
public static Size ConvertPointerToSize(IntPtr pointer)
{
    SizeWrapper sizeWrapper = new SizeWrapper();
    Marshal.PtrToStructure(pointer, sizeWrapper);
    Marshal.FreeHGlobal(pointer);
    return sizeWrapper.Size;
}

[StructLayout(LayoutKind.Sequential)]
internal class SizeWrapper
{
    private int height;
    private int width;

    public SizeWrapper()
    { }
    public SizeWrapper(Size size)
    {
        this.width = size.Width;
        this.height = size.Height;
    }

    public int Height
    {
        get { return height; }
    }
    public Size Size
    {
        get { return new Size(width, height); }
    }
    public int Width
    {
        get { return width; }
    }
}

manchukuo wrote:

one declaration and be able to pass any object

// NativeMethods.cs

using System;
using System.Drawing;
using System.Runtime.InteropServices;

internal static class NativeMethods
{
    // http://msdn.microsoft.com/en-us/library/ms644950(v=vs.85).aspx
    /*
LRESULT WINAPI SendMessage(
__in  HWND hWnd,
__in  UINT Msg,
__in  WPARAM wParam,
__in  LPARAM lParam
);*/
    [DllImport("User32.dll", SetLastError = true)]
    public static extern IntPtr SendMessage(
        IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam);

    [DllImport("User32.dll", SetLastError = true)]
    public static extern IntPtr SendMessage(
        IntPtr hWnd, int Msg, IntPtr wParam, GCHandle lParam);

    /// <summary>
    /// Creates a pinned GCHandle from the supplied object of the specified type.
    /// </summary>
    /// <typeparam name="T">Type of object to pin.</typeparam>
    /// <param name="obj">The object to pin.</param>
    /// <returns>A pinned GCHandle.</returns>
    public static GCHandle CreateGCHandle<T>(T obj)
    {
        return GCHandle.Alloc(obj, GCHandleType.Pinned);
    }
    /// <summary>
    /// Gets the target of the pinned GCHandle and frees the handle.
    /// </summary>
    /// <typeparam name="T">Type of the pinned object.</typeparam>
    /// <param name="pointer">The GCHandle as an IntPtr.</param>
    /// <returns>The pinned object.</returns>
    public static T GetFromPointer<T>(IntPtr pointer)
    {
        GCHandle gcHandle = GCHandle.FromIntPtr(pointer);
        T result = (T)gcHandle.Target;
        gcHandle.Free();
        return result;
    }
}

meet_ssr wrote:

without repeatedly looping