When Deep Copying a WPF Data Bound Object - wpf

Question

I wrote a nifty method to deep copy any object. It does so by recursively calling MemberwiseClone() on any reference type field inside the instance. This method works perfectly on any object I care to use it, including hierarchy relationship objects. The method also sports a dictionary of past visitations so unnecessary duplicate work is avoided.
The problem I am having, however, is that this method only works when the object is NOT data bound to WPF/MVVM when a clone is needed. When data bound and the method is invoked, I run into stack overflow exceptions because of (I assume) an established link between INotifyPropertyChanged.PropertyChanged event and the WPF framework. The recursive call then attempts to copy the entire universe of objects including the AppDomain and low-level Pointer objects, which appear to be linked and go on to almost infinity (more than VS2012 can handle, anyway.)
I doubt I will ever have need to deep copy an object graph that goes back to the beginning of the AppDomain... is there a smart way to have my copy method "stop" when it reaches a certain boundary? I also thought about simply copying objects before they're data bound, but I'm not sure that's a feasible option, and it's rather silly. I just want a simple deep copy solution that works on types that are not serializable, but are also data-bound via INotifyPropertyChanged.
The method's implementation:
private static object Clone(object instance, IDictionary<object, object> visitGraph)
{
var instanceType = instance.GetType();
Debug.WriteLine(instanceType.Name);
object clonedInstance = null;
if (visitGraph.ContainsKey(instance))
{
clonedInstance = visitGraph[instance];
}
else
{
const BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic |
BindingFlags.Instance;
var memberwiseCloneMethod =
instanceType.GetMethods(flags).Single(x => x.Name == "MemberwiseClone" &&
!x.GetParameters().Any());
clonedInstance = memberwiseCloneMethod.Invoke(instance, null);
visitGraph.Add(instance, clonedInstance);
var allReferenceTypeProperties = clonedInstance.GetType().GetAllFields()
.Where(
x =>
!x.FieldType.IsValueType
&& x.FieldType != typeof (string));
foreach (var field in allReferenceTypeProperties)
{
var existingFieldValue = field.GetValue(instance);
if (existingFieldValue != null)
{
var clonedFieldValue = Clone(existingFieldValue, visitGraph);
field.SetValue(clonedInstance, clonedFieldValue);
}
}
}
return clonedInstance;
}
public static IEnumerable<FieldInfo> GetAllFields(this Type type)
{
const BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic |
BindingFlags.Instance;
var fields = type.GetFields(flags);
foreach (var field in fields)
{
yield return field;
}
if (type.BaseType != null)
{
foreach (var field in GetAllFields(type.BaseType))
{
yield return field;
}
}
}
public static object Copy(this object instance)
{
if (instance == null) throw new ArgumentNullException("instance");
var visitGraph = new Dictionary<object, object>();
var clonedInstance = Clone(instance, visitGraph);
return clonedInstance;
}

Answer 1

I'm answering my own question with a shortcut solution. I would much prefer a permanent solution, but I haven't the luxury.
I modified my deep clone method to shallow (instead of deep) copy EventHandler objects. The objects are no longer a true deep clone, but that's not a problem for my application. Still, I would like a solution that applies in all situations.