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));
		}

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Assembly a = Assembly.GetEntryAssembly(); // Hier ist die gelandene Assembly
            // Der exakte Name incl. Namespace
            Type t = a.GetType("ConsoleApplication1.Hallodll");
            // Instanz erzeugen, da Hallo() nicht statisch ist
            object o = Activator.CreateInstance(t);
            // Auf der Instanz die Methode aufrufen
            t.InvokeMember("Hallo", BindingFlags.Instance | BindingFlags.Public | BindingFlags.InvokeMethod, null, o, null);
            // Ohne Instanz die statische Methode aufrufen
            t.InvokeMember("HalloStatic", BindingFlags.Static | BindingFlags.Public | BindingFlags.InvokeMethod, null, null, null);
        }
    }

    class Hallodll
    {
        public void Hallo()
        {
            Console.WriteLine("Hallo");
        }

        public static void HalloStatic()
        {
            Console.WriteLine("Hallo");
        }
    }
}

...
T t = Operator<T>.Add(val1, val2);

Bitmap bitmap = DevIL.DevIL.LoadBitmap(@"......");
pictureBox.Image = bitmap;

static T[] Factorize<T>(T value) where T : struct
{
	Type type = typeof(T);

	if (!type.IsEnum)
		throw new ArgumentException("value");

	List<T> result = new List<T>(64);
	ulong bitField = Convert.ToUInt64(value);
	ulong bit = 1;

	for (int i = 0; i < 64; i++, bit <≤ 1)
	{
		ulong u = (bitField & bit);
		if (u != 0)
		{
			result.Add((T)Enum.ToObject(type, u));
		}
	}

	return result.ToArray();
}

[Serializable, StructLayout(LayoutKind.Sequential)]
public sealed class eeprom_prodid
{
	public UInt16 sn;
	public UInt16 prodcode;
	public SByte hwrel;
	public SByte hwver;
	[MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
	public SByte[] signature;
}

public class Native
{
	[DllImport("name_meiner_dll", EntryPoint = "funktionsname_in_der_dll")]
	public static extern int ExternalEepromRead(eeprom_prodid prodid, UInt32 addr, SByte count);
}