List<uint> l1 = new List<uint> { 1, 2, 3 };
var l2 = l1.Cast<int>().ToList();

var l2 = l1.Select(i => (int)i).ToList();

public static IEnumerable<T> Cast<T>(this IEnumerable source)
{
    foreach (object o in source)
        yield return (T)o;
}

uint i = 42;
object o = i;
int j = (int)o;

int i = 42;
object o = i;
int j = (int)o;

public TDelegate GetDelegate<TDelegate>(string foo) where TDelegate : class
{
     // Runtimeprüfung
     return (TDelegate)(object)Marshal.GetDelegateForFunctionPointer( ... );
}

if (!typeof(Delegate).IsAssignableFrom(typeof(TDelegate)))
    throw new InvalidOperationException();

public Delegate GetDelegate(string foo, Type t)
{ 
//...
}

MyDelegate myDelegate = (MyDelegate)obj.GetDelegate("foo", typeof(MyDelegate );

public TDelegate GetDelegate<TDelegate>(string foo) where TDelegate : Delegate
{
     return (TDelegate)GetDelegate(foo, typeof(TDelegate));
}

int err = FancyMethod(int foo, string bar);
if (err != 0)
     // Fehlerbehandlung hier

enum VideoDevices
{
    Webcam,
    Framegrabber,
    Actioncam,

}

//...

string a = VideoDevices.Actioncam.ToString();
string b = VideoDevices.Framegrabber.ToString();
string c = VideoDevices.Webcam.ToString();

class AsyncPolling
{
    public object Obj { get; private set; }

    public async Task PollAsync(IProgress<bool> progress, CancellationToken ct)
    {
        await Task.Run(() =>
        {
           while (true)
           {                   
               // Process some data...
               if (data_has_changed)
               {
                   Obj = ...
                   progress.Report(true);
               }
               ct.ThrowIfCancellationRequested();
          }
       }, ct);
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;

namespace BBP
{
    class Program
    {
        static void Main(string[] args)
        {
            const string testHash = "182C3950020DBE5969AF859ADF93BBD4";
            double pid, s1, s2, s3, s4;

            // Vorherige "Hex-Nachkommastelle" zur gesuchten Position finden
            int id = 787471 / 4; // 196867;

            // Hex-Nachkommastellen berechnen
            s1 = BBP.Series(1, id);
            s2 = BBP.Series(4, id);
            s3 = BBP.Series(5, id);
            s4 = BBP.Series(6, id); 
            pid = 4 * s1 - 2 * s2 - s3 - s4;
            pid = pid - (int)pid + 1;
            string hex = BBP.Ihex(pid);

            // In Binärstring umwandeln und Bit-Position korrigieren
            string bin = HexToBinString(hex).Substring(787471 % 4 - 1);
            // In Bytes umwandeln 
            byte[] bytes = BinStringToByte(bin);
            // und ASCII decodieren
            string word = Encoding.ASCII.GetString(bytes, 0, 3);
            Console.WriteLine("Wort: {0}", word);

            // Testen
            MD5 md5 = MD5.Create();
            string hash = word;
            for (int i = 0; i < 1000000; i++)
                hash = GetMd5Hash(md5, hash);

            Console.WriteLine("Hash: {0}", hash);
            Console.WriteLine("Test-Hash: {0}", testHash);
            Console.WriteLine("Hashes are{0} equal!", hash != testHash ? " not" : "");
            
            Console.ReadLine();
        }

        // Hilfsmethoden

        static string GetMd5Hash(MD5 md5Hash, string input)
        {

            byte[] data = md5Hash.ComputeHash(Encoding.ASCII.GetBytes(input));
            StringBuilder sBuilder = new StringBuilder();
            for (int i = 0; i < data.Length; i++)
                sBuilder.Append(data[i].ToString("X2"));

            return sBuilder.ToString();
        }

        static byte[] BinStringToByte(string binstring)
        {
            var bytesAsStrings =
                                binstring.Select((c, i) => new { Char = c, Index = i })
                                     .GroupBy(x => x.Index / 8)
                                     .Select(g => new string(g.Select(x => x.Char).ToArray()));

            return bytesAsStrings.Select(s => Convert.ToByte(s, 2)).ToArray();
        }

        static string HexToBinString(string hexstring)
        {
            return String.Join(String.Empty,
                        hexstring.Select(
                        c => Convert.ToString(Convert.ToInt32(c.ToString(), 16), 2).PadLeft(4, '0')));
        }
    }

    /// <summary>
    /// "Quick and dirty" Port des orginalen C Codes von David H. Bailey 
    /// </summary>
    static class BBP
    {
        public static string Ihex(double x)
        {
            int i;
            double y;
            StringBuilder sb = new StringBuilder();
            string hx = "0123456789ABCDEF";

            y = Math.Abs(x);
            for (i = 0; i < 16; i++)
            {
                y = 16 * (y - Math.Floor(y));
                sb.Append(hx[(int)y]);
            }
            return sb.ToString();
        }

        /// <summary>
        /// This routine evaluates the series  sum_k 16^(id-k)/(8*k+m) 
        /// using the modular exponentiation technique
        /// </summary>
        /// <param name="m"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        public static double Series(int m, int id)
        {
            int k;
            double ak, p, s, t;
            double eps = 1e-17;

            s = 0;
            /*  Sum the series up to id. */
            for (k = 0; k < id; k++)
            {
                ak = 8 * k + m;
                p = id - k;
                t = Expm(p, ak);
                s = s + t / ak;
                s = s - (int)s;
            }

            /*  Compute a few terms where k ≥ id. */
            for (k = id; k ≤ id + 100; k++)
            {
                ak = 8 * k + m;
                t = Math.Pow(16, (double)(id - k)) / ak;
                if (t < eps) break;
                s = s + t;
                s = s - (int)s;
            }
            return s;
        }
        /// <summary>
        /// expm = 16^p mod ak.  This routine uses the left-to-right binary 
        /// exponentiation scheme
        /// </summary>
        /// <param name="p"></param>
        /// <param name="ak"></param>
        /// <returns></returns>
        private static double Expm(double p, double ak)
        {
            int i, j;
            double p1, pt, r;
            int ntp = 25;
            double[] tp = new double[ntp];
            int tp1 = 0;

            /*  If this is the first call to expm, fill the power of two table tp. */
            if (tp1 == 0)
            {
                tp1 = 1;
                tp[0] = 1;

                for (i = 1; i < ntp; i++) 
                    tp[i] = 2 * tp[i - 1];
            }

            if (ak == 1) 
                return 0;

            /*  Find the greatest power of two less than or equal to p. */
            for (i = 0; i < ntp; i++) if (tp[i] > p) break;

            pt = tp[i - 1];
            p1 = p;
            r = 1;

            /*  Perform binary exponentiation algorithm modulo ak. */
            for (j = 1; j ≤ i; j++)
            {
                if (p1 ≥ pt)
                {
                    r = 16 * r;
                    r = r - (int)(r / ak) * ak;
                    p1 = p1 - pt;
                }
                pt = 0.5 * pt;
                if (pt ≥ 1)
                {
                    r = r * r;
                    r = r - (int)(r / ak) * ak;
                }
            }

            return r;
        }
    }
}

static Bitmap Encode(int height, string message)
{
    int width = message.Length * height;
    Bitmap bitmap = new Bitmap(width, height);
    using (Graphics g = Graphics.FromImage(bitmap))
    {
        for (int i = 0, j = 0; i < width; i += height, j++)
            g.FillRectangle(new SolidBrush(Color.FromArgb(255, message[j], message[j], message[j])), new Rectangle(i, 0, height, height));
    }
    return bitmap;
}

public SourceInfo Ursprungsbild = new SourceInfo();
 public ProcessedInfo Arbeitskopie = new ProcessedInfo();

public TabPicture()
{
   this.Ursprungsbild = new SourceInfo();
   this.Arbeitskopie = new ProcessedInfo();
}

 public ImageInfo SourceInfo = new ImageInfo();
 public ImageInfo ProcessedInfo = new ImageInfo();


public class ImageInfo
{
    public Image Bild { get; set; }
    public int Dateigröße { get; set; }
    public int Breite { get; set; }
    public int Höhe { get; set; }
}