How to break reference from .asset classes and runtime copied values?

Thank you, I was able to solve my problem and I learned something in the process while doing so, thank to your explanation. Basically what I needed was a so called "Deep Copy" of my main Class. You can do it as you said, making the classes ICloneable and implementing a symple Clone() function for them to make a copy without reference of the variables, so with a main function that did that starting from the outer class and going down to all referenced objects. I used a more lazy but quite effective approach, using this helper function: using System; using System.IO; using System.Runtime.Serialization; using System.Runtime.Serialization.Formatters.Binary;

 /// <span class="code-SummaryComment"><summary></span>
 /// Provides a method for performing a deep copy of an object.
 /// Binary Serialization is used to perform the copy.
 /// <span class="code-SummaryComment"></summary></span>
 public static class ObjectCopier
 {
     /// <span class="code-SummaryComment"><summary></span>
     /// Perform a deep Copy of the object.
     /// <span class="code-SummaryComment"></summary></span>
     /// <span class="code-SummaryComment"><typeparam name="T">The type of object being copied.</typeparam></span>
     /// <span class="code-SummaryComment"><param name="source">The object instance to copy.</param></span>
     /// <span class="code-SummaryComment"><returns>The copied object.</returns></span>
     public static T Clone<T>(this T source)
     {
         if (!typeof(T).IsSerializable)
         {
             throw new ArgumentException("The type must be serializable.", "source");
         }
 
         // Don't serialize a null object, simply return the default for that object
         if (Object.ReferenceEquals(source, null))
         {
             return default(T);
         }
 
         IFormatter formatter = new BinaryFormatter();
         Stream stream = new MemoryStream();
         using (stream)
         {
             formatter.Serialize(stream, source);
             stream.Seek(0, SeekOrigin.Begin);
             return (T)formatter.Deserialize(stream);
         }
     }
 }

It serializes your Object (Class, List, etc.) and deserializes it into a new Object, so you get a fresh copy of everything, free of any reference. The only drawback is that every class must be tagged serializable, but in my case I had to add it for just a couple of them. Here is the source of this script for anyone who will stumble into my same problem: http://www.codeproject.com/Articles/23832/Implementing-Deep-Cloning-via-Serializing-objects