One cheap option here - use xml serialization. DataContractSerializer,
for example, can be used with "preserver references" enabled to
properly serialize the object *graph* (not the object *tree* that
XmlSerializer would produce) - just wihout the assembly information
that is plaguing you. It would also be trivial to parse, transform,
etc.

If you are concerned about space (for big graphs), then another easy
trick is to chain a GZipStream.

An illustration (demonstrating DataContract working on a graph with
loops, and working through GZipStream):

[DataContract]
   public class MyData
   {
       // simple values
       [DataMember]
       public int SomeValue { get; set; }
       [DataMember]
       public string SomeOtherValue { get; set; }

       // to prove object graph
       [DataMember]
       public MyData Sibling { get; set; }
   }
   class Program
   {
       static void Main()
       {
           MyData a = new MyData { SomeValue = 4, SomeOtherValue =
"abc" },
               b = new MyData { SomeValue = 6, SomeOtherValue =
"def", Sibling = a };
           a.Sibling = b; // make a closed loop...

           DataContractSerializer dcs = new DataContractSerializer(
               typeof(MyData), null, int.MaxValue, true, true, null);

           // write
           using (Stream zip = new GZipStream(
               File.Create("test.bin"), CompressionMode.Compress))
           {
               dcs.WriteObject(zip, a);
               zip.Close();
           }

           // read
           MyData c;
           using (Stream zip = new GZipStream(
               File.OpenRead("test.bin"),
CompressionMode.Decompress))
           {
               c = (MyData)dcs.ReadObject(zip);
           }

           Console.WriteLine("{0}, {1}\t{2}, {3}\t{4}",
               c.SomeValue, c.SomeOtherValue,
               c.Sibling.SomeValue, c.Sibling.SomeOtherValue,
               ReferenceEquals(c, c.Sibling.Sibling));

       }
   }