public static class EqualsExtensions
{
	public static bool EqualsOneOf(this object first, params object[] others)
	{
		return others.Any(o => Object.Equals(first, o));
	}

	public static bool EqualsOneOf<T>(this IEquatable<T> first, params T[] others)
	{
		if (Object.ReferenceEquals(first, null))
			return others.Any(o => Object.ReferenceEquals(o, null));

		return others.Any(o => first.Equals(o));
	}
}

IntPtr strData = new IntPtr(plstr.ToInt32() + 4);

IntPtr strData = new IntPtr(unchecked(plstr.ToInt64() + 4));

public class Reference<T> where T : struct
{
	[DebuggerBrowsable(DebuggerBrowsableState.Never)]
	protected T value;

	public Reference()
	{

	}

	public Reference(T value)
	{
		this.value = value;
	}

	public static implicit operator T(Reference<T> value)
	{
		return value.value;
	}

	public static implicit operator Reference<T>(T value)
	{
		return new Reference<T>(value);
	}

	public T Value
	{
		get { return value; }
		set { this.value = value; }
	}

	public override string ToString()
	{
		return value.ToString();
	}

	public override int GetHashCode()
	{
		return value.GetHashCode();
	}

	public override bool Equals(object obj)
	{
		return (obj is Reference<T>) && value.Equals(((Reference<T>)obj).value);
	}
}

PerformanceCounter pCounter = new PerformanceCounter("Processor", "% Processor Time", "_Total");
pCounter.NextValue();
while (true)
{
    Thread.Sleep(1000);
    Console.WriteLine(pCounter.NextValue());
}

		class Point
		{
			public double X { get; set; }
			public double Y { get; set; }

			public static bool operator ==(Point a, Point b)
			{
				if (ReferenceEquals(a, b))
				{
					return true;
				}
				if (ReferenceEquals(a, null) || ReferenceEquals(b, null))
				{
					return false;
				}
				return ((a.X == b.X) && (a.Y == b.Y));
			}

			public static bool operator !=(Point a, Point b)
			{
				return (!(a == b));
			}
		}

public static Bitmap ConvertBitmap(Bitmap bitmap, PixelFormat format)
{
    if (bitmap == null)
    {
        throw new ArgumentNullException("bitmap");
    }

    Bitmap result = null;
    try
    {
        Rectangle rect = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
        result = new Bitmap(bitmap.Width, bitmap.Height, format);

        BitmapData dstData = result.LockBits(rect, ImageLockMode.WriteOnly, format);
        try
        {
            BitmapData srcData = new BitmapData();
            srcData.Scan0 = dstData.Scan0;
            srcData.Stride = dstData.Stride;

            bitmap.LockBits(rect, ImageLockMode.ReadOnly | ImageLockMode.UserInputBuffer, format, srcData);
            bitmap.UnlockBits(srcData);
        }
        finally
        {
            result.UnlockBits(dstData);
        }
    }
    catch
    {
        if (result != null)
        {
            result.Dispose();
        }
        throw;
    }
    return result;
}

        [StructLayout(LayoutKind.Sequential, Size = 20)] // event. in der dllimport dann als "[in,out] S_RESOLUTION_PARAMS ResParam" aufrufen
        public class S_RESOLUTION_PARAMS
        {
            public short wOffsetX;       // i16 X offset of ROI (relative to visible area).
            public short wOffsetY;       // i16 Y offset of ROI (relative to visible area).
            public ushort wSizeX;         // u16 X size (width, columns) of ROI.
            public ushort wSizeY;         // u16 Y size (height, lines) of ROI.
            public uint dwSkip;         // u32 X- and Y- Skip Settings (see XY_SKIP_NONE).
            public uint dwBin;          // u32 X- and Y- Bin Settings (see XY_BIN_NONE).
            public byte bKeepExposure;  // u08 keep constant exposure (true=yes, false=no)
        };

         public static float[][] GetMatrix(IntPtr ptr)
        {
            float[][] result = new float[4][];
            for (int i = 0; i < 4; i++)
            {
                IntPtr arrayPtr = Marshal.ReadIntPtr(ptr, i);
                float[] floats = new float[4];
                Marshal.Copy(arrayPtr, floats, 0, 4);
                result[i] = floats;
            }
            return result;
        }

[StructLayout(LayoutKind.Sequential, Size = 512), Serializable]
public struct DMXStep : ISerializable
{
    private byte m_firstByte;

    private unsafe DMXStep(SerializationInfo info, StreamingContext context)
    {
        fixed (byte* p = &m_firstByte)
        {
            byte[] data = (byte[])info.GetValue("DATA", typeof(byte[]));
            for (int i = 0; i < 512; i++)
                p[i] = data[i];
        }
    }
    
    public unsafe byte this[int index]
    {
        get
        {
            fixed (byte* p = &m_firstByte)
            {
                return p[index];
            }
        }
        set
        {
            fixed (byte* p = &m_firstByte)
            {
                p[index] = value;
            }
        }
    }

    #region ISerializable Member

    unsafe void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
    {
        fixed (byte* p = &m_firstByte)
        {
            byte[] data = new byte[512];
            for (int i = 0; i < 512; i++)
                data[i] = p[i];
            info.AddValue("DATA", data);
        }
    }

    #endregion
}

[StructLayout(LayoutKind.Sequential, Size=x), CompilerGenerated, UnsafeValueType]
public struct <bytes>e__FixedBuffer0
{
    public byte FixedElementField;
}

static bool TryGetParentProcessId(out int id)
{
	try
	{
		int ownId = Process.GetCurrentProcess().Id;
		ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_Process WHERE ProcessId=" + ownId);
		foreach (ManagementBaseObject row in searcher.Get())
		{
			id = (int)(uint)row["ParentProcessId"];
			return true;
		}
	}
	catch
	{

	}
	id = 0;
	return false;
}

static void Main(string[] args)
{
	int id;
	if (TryGetParentProcessId(out id))
		Console.WriteLine(Process.GetProcessById(id).ProcessName+ " called me.");
	else
		Console.WriteLine("Unable to identify caller.");
}

[DllImport("some.dll")]
private static extern bool SomeFunction(
    [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(PolygonMarshaler))] Polygon polygon);

[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(PolygonMarshaler))]
[DllImport("some.dll")]
private static extern Polygon SomeOtherFunction();

public sealed class Polygon
{
    public Header header;
    public Parms parms;
    public PointD[] points;
}

[StructLayout(LayoutKind.Sequential, Size = 1)]
public struct Header { }

[StructLayout(LayoutKind.Sequential, Size = 1)]
public struct Parms { }

public struct PointD
{
    public double x;
    public double y;
}

internal sealed class PolygonMarshaler : ICustomMarshaler
{
    private unsafe struct Poly
    {
        public Header header;
        public Parms parms;
        public ushort pointCount;
        public fixed PointD points[1];
    }

    private static ICustomMarshaler m = new PolygonMarshaler();

    private static ICustomMarshaler GetInstance(string s)
    {
        return m;
    }

    #region ICustomMarshaler Member

    public void CleanUpManagedData(object ManagedObj)
    {

    }

    public void CleanUpNativeData(IntPtr pNativeData)
    {
        Marshal.FreeHGlobal(pNativeData);
    }

    public unsafe int GetNativeDataSize()
    {
        return sizeof(Poly);
    }

    public unsafe IntPtr MarshalManagedToNative(object ManagedObj)
    {
        if (!(ManagedObj is Polygon))
            return IntPtr.Zero;

        Polygon polygon = (Polygon)ManagedObj;

        int size = sizeof(Poly);
        if ((polygon.points != null) && (polygon.points.Length > 1))
            size += ((polygon.points.Length - 1) * sizeof(PointD));
        Poly* ptr = (Poly*)Marshal.AllocHGlobal(size);

        ptr->header = polygon.header;
        ptr->parms = polygon.parms;
        ptr->pointCount = (ushort)(polygon.points == null ? 0 : polygon.points.Length);
        for (int i = 0; i < ptr->pointCount; i++)
            ptr->points[i] = polygon.points[i];

        return (IntPtr)ptr;
    }

    public unsafe object MarshalNativeToManaged(IntPtr pNativeData)
    {
        if (pNativeData == IntPtr.Zero)
            return null;

        Polygon result = new Polygon();
        Poly* ptr = (Poly*)pNativeData;

        result.header = ptr->header;
        result.parms = ptr->parms;
        result.points = new PointD[ptr->pointCount];

        for (int i = 0; i < ptr->pointCount; i++)
            result.points[i] = ptr->points[i];

        return result;
    }

    #endregion
}

            string[] myArray = new string[10] { "0", "0", "0", "0", "0", "1", "1", "1", "1", "2" };
            Dictionary<string, int> dict = new Dictionary<string, int>();
            int c;
            foreach (string s in myArray)
            {
                if (!dict.TryGetValue(s, out c))
                    c = 0;
                dict[s] = (c + 1);
            }
            foreach (KeyValuePair<string, int> kvp in dict)
            {
                //
            }

IntPtr ptr = Marshal.AllocHGlobal(16635);
IntPtr ptrptr = Marshal.AllocHGlobal(ptr);

[DllImport("CANAPI2.dll", EntryPoint = "CAN_GetHwParam")]
public static extern uint GetHwParam(byte hHw, ushort Param, byte[] Buff, ushort BuffLen);

...
const int buffLength = 1024;
byte[] buffer = new buffer[buffLength];
uint result = GetHwParam(0, 0, buffer, buffLength);

...

		public static int GetInt32(BitArray array)
		{
			int[] value = new int[1];
			array.CopyTo(value, 0);
			return value[0];
		}

		public static BitArray GetBitArray(int value)
		{
			return new BitArray(BitConverter.GetBytes(value));
		}