C#

public static void CopyFields(object source, object target)
{
    if (source == null)
        throw new ArgumentNullException("source");
    if (target == null)
        throw new ArgumentNullException("target");

    //loop through source object
    FieldInfo[] fiSource = source.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
    FieldInfo[] fiTarget = target.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
    foreach (FieldInfo fiS in fiSource)
    {
        //check if that field exists in target
        foreach (FieldInfo fiT in fiTarget)
        {
            if (fiT.Name == fiS.Name)
            {
                //copy value
                fiT.SetValue(target, fiS.GetValue(source));
                //stop inner loop
                break;
            }
        }
    }
}

    public delegate void CountReachedDelegate(CountableBase countableBase, string message);

 
    public abstract class CountableBase
        {
        public static event CountReachedDelegate CountReached;
 
        public static void OnCountReached(CountableBase item, string message)
            {
            CountReachedDelegate del = CountReached;    // Use local variable for thread safety
            if (del != null)
                del(item, message);
            }
 
        public abstract void Count(int limit);
        }

 
    public class SubIntA : CountableBase
        {
        private int _T = 20;
        public int Trigger
            { get { return _T; } }
         
        string _N = "A";
        public string Name
            { get { return _N; } }
 
        public override void Count(int limit)
            {
            for (int x = 0; x < limit; x++)
                if (x % _T == 0)
                    OnCountReached(this, _N + "=" + x);
            }
        }

 
    public class SubIntB : SubIntA { }

public static void FileToImage(string path, int imageHeight, int imageWidth)
{
    byte[] data;

    using (FileStream fs = File.OpenRead(path))
    {
        data = new byte[fs.Length];
        ReadWholeArray(fs, data);
    }

    // Lock
    Bitmap bmp = new Bitmap(imageWidth, imageHeight, PixelFormat.Format1bppIndexed);
    Rectangle bounds = new Rectangle(Point.Empty, bmp.Size);
    BitmapData bmpData = bmp.LockBits(bounds, ImageLockMode.WriteOnly, bmp.PixelFormat);

    // Copy flat bits list into locked bitmap
    int iBitList = 0;
    unsafe
    {
        Byte* bmpDataPointer = (Byte*)bmpData.Scan0.ToPointer();

        for (int y = 0; y < imageHeight; y++)
        {
            for (int x = 0; x < imageWidth; x++)
            {
                // Since this is a B&W image (PixelFormat.Format1bppIndexed),
                // Only populate the most significant bit instead of RGB.
                int iBitmap = y * bmpData.Stride + (x >> 3);
                byte mask = (byte)(0x80 >> (x & 0x7));

                if (0x0 == data[iBitList])
                {
                    // Black
                    //bmpDataPointer[iBitmap] &= (byte)(mask^0xff);
                }
                else
                {
                    // White
                    bmpDataPointer[iBitmap] |= mask;
                }

                // Incrememnt index of flat bit list
                iBitList++;
            }
        }
    }

    // Unlock
    bmp.UnlockBits(bmpData);

    // Save
    bmp.Save(path + ".bmp");
}

    // setting the setjmp point
    try {
        // calling some complex method chain here
    } catch(SetjmpLikeException exc) {
        // "setjmp" got executed
    } catch(Exception exc) {
        // some other exception occured, this is NOT the result of a longjmp
    }
...
    // executing a longjmp
    throw new SetjmpLikeException();
...
    // definition
    public class SetjmpLikeException : Exception {
    }