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

Array array = (Array)z.attr[0x4, 0x1500].Value;

// Hier kommt dein Objekt rein
Array array = Array.CreateInstance(typeof(string), new int[] { 10 }, new int[] { 1 });

for (int i = array.GetLowerBound(0), j = array.GetUpperBound(0); i < j; i++)
{
	// Mache etwas mit dem Wert
	array.GetValue(i);
}

static Action<int, string, object> CreateDynMethod()
{
    DynamicMethod dyn = new DynamicMethod("DynamicMethod", null, new Type[] { typeof(int), typeof(string), typeof(object) });
    ILGenerator g = dyn.GetILGenerator();

    // object[] local;
    g.DeclareLocal(typeof(object[]), false); // Index = 0

    // local = new object[3];
    g.Emit(OpCodes.Ldc_I4, 3);
    g.Emit(OpCodes.Newarr, typeof(object));
    g.Emit(OpCodes.Stloc, 0);

    // local[0] = (object)param0;
    g.Emit(OpCodes.Ldloc, 0);
    g.Emit(OpCodes.Ldc_I4, 0);
    g.Emit(OpCodes.Ldarg, 0);
    g.Emit(OpCodes.Box, typeof(int));
    g.Emit(OpCodes.Stelem_Ref);

    // local[1] = param1;
    g.Emit(OpCodes.Ldloc, 0);
    g.Emit(OpCodes.Ldc_I4, 1);
    g.Emit(OpCodes.Ldarg, 1);
    g.Emit(OpCodes.Stelem_Ref);

    // local[2] = param2;
    g.Emit(OpCodes.Ldloc, 0);
    g.Emit(OpCodes.Ldc_I4, 2);
    g.Emit(OpCodes.Ldarg, 2);
    g.Emit(OpCodes.Stelem_Ref);

    // CallMethod("DelegatedA", local0);
    g.Emit(OpCodes.Ldstr, "DelegatedA");
    g.Emit(OpCodes.Ldloc, 0);
    g.Emit(OpCodes.Call, typeof(Program).GetMethod("CallMethod", BindingFlags.Static | BindingFlags.Public));

    // return;
    g.Emit(OpCodes.Ret);

    return (Action<int, string, object>)dyn.CreateDelegate(typeof(Action<int, string, object>));
}

    abstract class Test : IDisposable, IComparable<Test>
    {
        public abstract void Dispose();
        public abstract int CompareTo(Test other);
    }

double d = (double)Activator.CreateInstance(Type.GetType("System.Double"));

string str = "Hallo"; // str ist 4 bytes groß (auf 32 bit System)  und könnte nun zB 0x85AB5038 sein
Test(str);

int i = 5; // i ist 4 Bytes groß und beinhaltet 0x00000005
Test(i);

//

void Test(string s)
{
  // s ist 0x85AB5038
}

void Test(int t)
{
  // i ist 0x00000005
}

        [DllImport("user32.dll", SetLastError = true)]
        static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);

static extern bool GetWindowRect(IntPtr hWnd, out RECT rect);

[DllImport("library.dll")]
public static extern IntPtr GetData(out TestStruct t);

	unsafe struct TestStruct
	{
		int ID;
		string Name;
		fixed double Data[6];
		int Reserved;
	}

	unsafe struct TestStruct
	{
		int ID;
		char* Name;
		fixed double Data[6];
		int Reserved;
	}

System.Deployment.Application.ApplicationDeployment

string value = "4123";
long l = (long)Convert.ChangeType(value, typeof(long));

string text = "hallo";
char[] testArr = text.ToCharArray();

interface I<T> where T : SerializableAttribute 

var dbObject = dbContext.ExecuteQuery<T>(command, new object[0]).First();

T dbObject = dbContext.ExecuteQuery<T>(command, new object[0]).First();

private void ShowWindow()
{
    WindowState = FormWindowState.Normal;
    SetForegroundWindow(Handle);
}

[DllImport("user32")]
private static extern bool SetForegroundWindow(IntPtr hWnd);