Marshal.GetDelegateForFunctionPointer

[Extension]
public static class Miep
{
  [Extension]
  public static IEnumerable<T> GetItemsGreaterThan<T>(IEnumerable<T> items, IComparable<T> minValue)
  {
     foreach(T item in items)
       if(minValue.CompareTo(item) < 0)
         yield return item;
  }
}

int[] someInts = {1, 2, 3, 4, 5, 6};
foreach(int found in Miep.GetItemsGreaterThan<int>(someInts , 3))
  Console.WriteLine(found);

int[] someInts = {1, 2, 3, 4, 5, 6};
foreach(int found in someInts.GetItemsGreaterThan(3))
  Console.WriteLine(found);

public static IEnumerable<T> GetFilteredSlice<T>(IEnumerable<T> sourceSequence, Predicate<T> match)
{
   foreach(T item in sourceSequence)
     if(match(item))
       yield return item
}

struct Sample
{
   public int Field;
   public override ToString()
   {
      return Field.ToString();
   }
}

static void Miep(object instance, object value)
{
   FieldInfo fi = instance.GetType().GetField("Field");
   fi.SetValue(instance, value);
}

static void Main()
{
  Sample s = new Sample();
  s.Field = 1;
  object o = s;
  Miep(o, 2);
  Console.WriteLine(o); // ergibt 2!
}

static Random r = new Random();

static void Main(string[] args)
{
  string[] lines = { "a", "b", "c" };
  Funktioniert(lines);
  FunktioniertNicht(lines);
}

private static void WaitForAll(IEnumerable<Thread> threads)
{
  foreach(Thread thread in threads)
  {
    if ((thread.ThreadState & ThreadState.Running) == ThreadState.Running)
      thread.Join();
  };
}

private static void FunktioniertNicht(string[] lines)
{
  List<Thread> threads = new List<Thread>(lines.Length);

  foreach (string line in lines)
  {
    ThreadStart ts = delegate()
    {
      Thread.Sleep(r.Next(200));// zufällige dummy-latenz
      Console.WriteLine(line);
    };

    Thread thread = new Thread(ts);
    thread.Start();

    threads.Add(thread);
  }

  // warte bis alle färtsch sind
  WaitForAll(threads);
}

private static void Funktioniert(string[] lines)
{
  List<Thread> threads = new List<Thread>(lines.Length);

  foreach (string line in lines)
  {
    threads.Add(RunThreaded(line));
  }

  // warte bis alle färtsch sind
  WaitForAll(threads);
}


private static Thread RunThreaded(string line)
{
  ThreadStart ts = delegate()
  {
    Thread.Sleep(r.Next(200));// zufällige dummy-latenz
    Console.WriteLine(line);
  };
  Thread result = new Thread(ts);
  result.Start();
  return result;
}

// wie auch immer huskys Create-Methode aussieht
public static T Create<T>()
  where T : new()
{
  Console.WriteLine("Creating instance of type {0}...", typeof(T));
  return new T();
}

public delegate object CreateMethod();

static CreateMethod WrapCreate<T>()
  where T : new()
{
  return delegate
  {
    return Create<T>();
  };

}

public static CreateMethod Wrap(Type type)
{
  MethodInfo m = typeof(Program).GetMethod("WrapCreate",
                                           BindingFlags.Static | BindingFlags.NonPublic);
  m = m.MakeGenericMethod(type);

  return m.Invoke(null, null) as CreateMethod;
}


static void Main(string[] args)
{
  Type optionalType = Type.GetType("Namespace.MyClass, MyDLL");
  CreateMethod create = Wrap(optionalType);

  for (int i = 0; i < 10; i++)
  {
    object instance = create();
  }
}

for (IEnumerator<Miep> miepEum = list.GetEnumerator(); miepEum.MoveNext();)
{
    if (miepEnum.Current == blabla)
      DoSomething(miepEnum);
}

for(;P("\n").R-;P("|"))for(e=3DC;e-;P("_"+(*u++/8 )%2))P("| "+(*u/4)%2); 

for (;!Abbruchkriterium;)
{
      // irgendwas
}

class Miep : IDisposable
{
  SomeIDisposableImplementation mööp;

  public void Dispose()
  {
     mööp.Dispose();
  }
}

return "\'" + inputString.Replace("\'","\'\'") + "\'";