I guess... although reflection should generally be a last resort.
Would it be too hard to write a handful of methods to move a few
interrfaces?

You might want to think about the values that exist - i.e. if any are
collections, what should happen? or is it just standard settable
values?

I would probably be tempted to use generics to ensure that source and
target are suitable at compile time.

Example below (also covers readonly / writeonly).

Marc

using System.ComponentModel;

class Foo : IBar
{
   public int Prop1 { get; set; }
   public string Name { get; set; }
   string IBar.Prop2 { get { return Name; } set { Name = value; } }
   public bool Prop3 { get { return true; } }
   public bool Prop4 { set { } }
}
interface IBar
{
   int Prop1 { get; set; }
   string Prop2 { get; set; }
   bool Prop3 { get; }
   bool Prop4 { set; }
}
class Program
{
   static void Main()
   {
       Foo s = new Foo(), t = new Foo();
       s.Name = "Fred";
       s.Prop1 = 123;
       BindData(s, t);
   }
   static void BindData<T>(T source, T target)
   {
       foreach (PropertyDescriptor prop in
TypeDescriptor.GetProperties(typeof(T)))
       {
           if (!prop.IsReadOnly) prop.SetValue(target,
prop.GetValue(source));
       }
   }

}