C#

Imports System.Reflection

Public Class Form1
    Private Sub Form1_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
        Dim a As New TheFromClass With {.Hello = "hello there", .Name = "myclass"}
        Dim b As New TheToClass With {.GoodBye = "later dude", .Hello = "wuzup"}

        Dim ta As Type = GetType(TheFromClass)
        Dim tb As Type = GetType(TheToClass)

        Dim obj As Object, PropertyName As String, ToPI As PropertyInfo = Nothing

        MsgBox(b.Hello)

        For Each FromPI As PropertyInfo In ta.GetProperties
            PropertyName = FromPI.Name
            obj = FromPI.GetValue(a, Nothing)

            ToPI = tb.GetProperties.Where(Function(p) p.Name = PropertyName).FirstOrDefault

            If ToPI IsNot Nothing Then ToPI.SetValue(b, obj, Nothing)
        Next

        MsgBox(b.Hello)

        End
    End Sub
End Class

Public Class TheFromClass
    Public Property Hello As String
    Public Property Name As String
End Class

Public Class TheToClass
    Public Property GoodBye As String
    Public Property Hello As String
End Class

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