Cheap type conversion for very similar objects

Ever get stuck between two API and have to keep converting between two almost identical sets of data objects because neither API can be modded at the moment?  If you can afford some performance penalty, this is a quick way to get fields and properties with the same names synced.

First you add some implicit type operators:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace typeoverridedemostrater
{
    class Class2
    {
        public string string1;
        public string string2;
        public string string3;
 
        public static implicit operator Class2(Class1 initialData)
        {
            return new SuperConverter<Class1, Class2>().Convert(initialData);
        }
 
        public static implicit operator Class2(Class3 initialData)
        {
            return new SuperConverter<Class3, Class2>().Convert(initialData);
        }
    }
}

After  you call the converter, you can add whatever specific conversions you need.

(EDIT - as Brooke pointed out, the real version of this was an extension to an existing class, not a class with an internal operator the code above was from the demo project I bashed out to explain the concept to another dev)

Then you use some reflection and linq to do the assignments in a separate class that you can re-use in as many type converters as you like:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace typeoverridedemostrater
{
    class SuperConverter where T2 : new()
    {
        public T2 Convert(T1 i)
        {
            var temp = new T2();
 
            typeof(T1).GetProperties().ToList().Where(a => a.CanWrite).ToList().
                ForEach(b =>
                {
                    var z = temp.GetType().GetProperty(b.Name);
                    if (z != null) z.SetValue(temp, b.GetValue(i, null), null);
                });
            
            typeof(T1).GetFields().ToList().ToList().
                ForEach(b =>
                {
                    var z = temp.GetType().GetField(b.Name);
                    if (z != null) z.SetValue(temp, b.GetValue(i));
                });
 
            return temp;
        }
    }
}

Obviously this only works in some cases, and if your types do not match precisely you would have to make it a little more complex by checking for compatible types, or handling failure more gracefully, but it can save a ton of time in some cases.