C#

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

Collection coll=new Collection(holding all elements);   // order doesn't matter
int n=coll.Count;
for(int i=n; i>0; i--) {
     int j=RandomGenerator.Next(0, i);       // j is in range [0, i) which shrinks all the time
     int pick=coll[j];  // your current pick
     coll.RemoveAt(j);  // now remove it
}

int maxSize = 10;                
char[] chars = new char[62];
string a;
a = "1234567890";
chars = a.ToCharArray();
int size = maxSize;
byte[] data = new byte[1];
RNGCryptoServiceProvider crypto = new RNGCryptoServiceProvider();
crypto.GetNonZeroBytes(data);
size = maxSize;
data = new byte[size];
crypto.GetNonZeroBytes(data);
StringBuilder resultUID = new StringBuilder(size);
foreach (byte b in data)
{
   resultUID.Append(chars[b % (chars.Length - 1)]);
}
string generatedNumber = resultUID.ToString(); 

Random rnd = new Random(seed);
int num=rnd.Next(1,10);

private static void NonRecurrentRandomize(int capacity)
{
    //initialize sample:
    //capacity is your sample size
    List<int> orderedList = new List<int>(capacity);
    for (int i = 0; i < capacity; i++)
    {
        orderedList.Add(i); //0,1,2,3,4,..
    }

    Random r = new Random();
    //Begin process:
    while (orderedList.Count > 0)
    {
        int popIndex = r.Next(0, orderedList.Count);
        //this is the item in turn:
        Console.WriteLine(orderedList[popIndex]);
        orderedList.RemoveAt(popIndex);
    }
}

HashSet<int> hash = new HashSet<int>();
Random random = new Random(DateTime.Now.Milliseconds);
int value = 0;
int final = 0;
do
{
    try
    {
        if (hash.Count == 9)
        {
            final++;
            hash.Add(final);
        }
        value = random.Next(1, 10);
        hash.Add(value);
    }
    catch (Exception)
    {
        // eat the exception
    }
}
while (hash.Count < 10)

TestHashSet() completed in
        00:00:00.0380860
TestList() completed in
        00:00:00.0009766

HashSet<int> hash   = new HashSet<int>();
Random       random = new Random(DateTime.Now.Millisecond);
int          value  = 0;
int          start  = 1;
int          stop   = 10;
do
{
    try
    {
        value = random.Next(start, stop);
        hash.Add(value);
        if (value == start)
        {
            start++;
        }
        else if (value == stop)
        {
            stop--;
        }
        if (start == stop && hash.Count < 10)
        {
            hash.Add(start);
        }
    }
    catch (Exception)
    {
        // eat the exception
    }
} while (hash.Count < 10);

meet_ssr wrote:

Performance is a concern