I think the serialization/deserialization is the "easiest" way to do this. Additionaly, there s a faster way to do it, using pinned handles.

You could use Marshal & GCHandle like such (from this link ):

public static object RawDeserializeEx( byte[] rawdatas, Type anytype ) 
{ 
 int rawsize = Marshal.SizeOf( anytype ); 
 if( rawsize > rawdatas.Length ) 
  return null; 
 GCHandle handle = GCHandle.Alloc( rawdatas, GCHandleType.Pinned ); 
 IntPtr buffer = handle.AddrOfPinnedObject(); 
 object retobj = Marshal.PtrToStructure( buffer, anytype ); 
 handle.Free(); 
 return retobj; 
} 

public static byte[] RawSerializeEx( object anything ) 
{ 
 int rawsize = Marshal.SizeOf( anything ); 
 byte[] rawdatas = new byte[ rawsize ]; 
 GCHandle handle = GCHandle.Alloc( rawdatas, GCHandleType.Pinned ); 
 IntPtr buffer = handle.AddrOfPinnedObject(); 
 Marshal.StructureToPtr( anything, buffer, false ); 
 handle.Free(); 
 return rawdatas; 
} 

I don t get the question. Sounds like you just want to create a reference to an existing object.

Variables to objects in C# merely hold a reference to the object, so when you assign a variable to an existing object, you re still accessing the same object.

Object x = new Object();
Object y = x;
x.MyProperty = "hello";

For the above code, y.MyProperty=="hello" as well.

Are you trying to get a deep copy, i.e., one where every field with a reference type is also set to a MemberwiseClone() of the originally-referenced object, ad infinitum?

You could use serialization into a memory stream and deserialization back to an instance.

We have such a "DeepCopy" method in our project. It is kind of risky. We started to implement copy-property-methods or copy constructors into our classes because it is more reliable and gives more control at the end.

If you want to overwrite all of the existing fields of an object with the values from another instance, there is no easy way to do it. It can be done if you re willing to write some wacky reflection code to visit each field of the object and copy the values. But it would be fragile and messy.

Furthermore, to do it correctly, you would need to walk the inheritance tree of the object and perform the same assignment operations as well.

Finally, if the object contains readonly field, it may be impossible to copy the exact state of another instance, and you will be forced to decide whether inconsistent copies are an acceptable outcome of the copy.