public bool Save(object target, MetaData metaData)
 {
     Debug.Print("SaveContext::Save");
     try
     {
         this.RootObject = target;
         using (new PerformanceTestBlock("SaveContext::Save"))
         {
             BinaryWriterFactory.Initialize();
             this.CollectObjects();
             ArchiveConcurrentSerializer headerSerializer = new ArchiveConcurrentSerializer();
             byte[][] objectData = new byte[this._childObjects.Count][];
             using (new PerformanceTestBlock("SaveContext::Saving Objects"))
                 TWParallel.For(0, this._childObjects.Count, (Action <int>)(i => this.SaveSingleObject(headerSerializer, objectData, i)));
             byte[][] containerData = new byte[this._childContainers.Count][];
             using (new PerformanceTestBlock("SaveContext::Saving Containers"))
                 TWParallel.For(0, this._childContainers.Count, (Action <int>)(i => this.SaveSingleContainer(headerSerializer, containerData, i)));
             using (new PerformanceTestBlock("SaveContext::SaveObjects config"))
             {
                 SaveEntryFolder rootFolder   = SaveEntryFolder.CreateRootFolder();
                 BinaryWriter    binaryWriter = BinaryWriterFactory.GetBinaryWriter();
                 binaryWriter.WriteInt(this._idsOfChildObjects.Count);
                 binaryWriter.WriteInt(this._strings.Count);
                 binaryWriter.WriteInt(this._idsOfChildContainers.Count);
                 rootFolder.CreateEntry(new EntryId(-1, SaveEntryExtension.Config)).FillFrom(binaryWriter);
                 headerSerializer.SerializeFolderConcurrent(rootFolder);
                 BinaryWriterFactory.ReleaseBinaryWriter(binaryWriter);
             }
             ArchiveSerializer archiveSerializer = new ArchiveSerializer();
             using (new PerformanceTestBlock("SaveContext::SaveObjects strings"))
             {
                 SaveEntryFolder rootFolder = SaveEntryFolder.CreateRootFolder();
                 SaveEntryFolder folder     = archiveSerializer.CreateFolder(rootFolder, new FolderId(-1, SaveFolderExtension.Strings), this._strings.Count);
                 for (int index = 0; index < this._strings.Count; ++index)
                 {
                     string str = this._strings[index];
                     SaveContext.SaveStringTo(folder, index, str);
                 }
                 archiveSerializer.SerializeFolder(rootFolder);
             }
             byte[] header  = (byte[])null;
             byte[] strings = (byte[])null;
             using (new PerformanceTestBlock("SaveContext::FinalizeAndGetBinaryHeaderDataConcurrent"))
                 header = headerSerializer.FinalizeAndGetBinaryDataConcurrent();
             using (new PerformanceTestBlock("SaveContext::FinalizeAndGetBinaryStringDataConcurrent"))
                 strings = archiveSerializer.FinalizeAndGetBinaryData();
             this.SaveData = new GameData(header, strings, objectData, containerData);
             BinaryWriterFactory.Release();
         }
         return(true);
     }
     catch
     {
         return(false);
     }
 }
 public bool Load(LoadData loadData, bool loadAsLateInitialize)
 {
     try
     {
         using (new PerformanceTestBlock("LoadContext::Load Headers"))
         {
             using (new PerformanceTestBlock("LoadContext::Load And Create Header"))
             {
                 ArchiveDeserializer archiveDeserializer = new ArchiveDeserializer();
                 archiveDeserializer.LoadFrom(loadData.GameData.Header);
                 SaveEntryFolder headerRootFolder = archiveDeserializer.RootFolder;
                 BinaryReader    binaryReader     = headerRootFolder.GetEntry(new EntryId(-1, SaveEntryExtension.Config)).GetBinaryReader();
                 this._objectCount              = binaryReader.ReadInt();
                 this._stringCount              = binaryReader.ReadInt();
                 this._containerCount           = binaryReader.ReadInt();
                 this._objectHeaderLoadDatas    = new ObjectHeaderLoadData[this._objectCount];
                 this._containerHeaderLoadDatas = new ContainerHeaderLoadData[this._containerCount];
                 this._strings = new string[this._stringCount];
                 TWParallel.For(0, this._objectCount, (Action <int>)(i =>
                 {
                     ObjectHeaderLoadData objectHeaderLoadData = new ObjectHeaderLoadData(this, i);
                     SaveEntryFolder childFolder = headerRootFolder.GetChildFolder(new FolderId(i, SaveFolderExtension.Object));
                     objectHeaderLoadData.InitialieReaders(childFolder);
                     this._objectHeaderLoadDatas[i] = objectHeaderLoadData;
                 }));
                 TWParallel.For(0, this._containerCount, (Action <int>)(i =>
                 {
                     ContainerHeaderLoadData containerHeaderLoadData = new ContainerHeaderLoadData(this, i);
                     SaveEntryFolder childFolder = headerRootFolder.GetChildFolder(new FolderId(i, SaveFolderExtension.Container));
                     containerHeaderLoadData.InitialieReaders(childFolder);
                     this._containerHeaderLoadDatas[i] = containerHeaderLoadData;
                 }));
             }
             using (new PerformanceTestBlock("LoadContext::Create Objects"))
             {
                 foreach (ObjectHeaderLoadData objectHeaderLoadData in this._objectHeaderLoadDatas)
                 {
                     objectHeaderLoadData.CreateObject();
                     if (objectHeaderLoadData.Id == 0)
                     {
                         this.RootObject = objectHeaderLoadData.Target;
                     }
                 }
                 foreach (ContainerHeaderLoadData containerHeaderLoadData in this._containerHeaderLoadDatas)
                 {
                     if (containerHeaderLoadData.GetObjectTypeDefinition())
                     {
                         containerHeaderLoadData.CreateObject();
                     }
                 }
             }
         }
         GC.Collect();
         GC.WaitForPendingFinalizers();
         using (new PerformanceTestBlock("LoadContext::Load Strings"))
         {
             ArchiveDeserializer saveArchive = new ArchiveDeserializer();
             saveArchive.LoadFrom(loadData.GameData.Strings);
             for (int id = 0; id < this._stringCount; ++id)
             {
                 string str = LoadContext.LoadString(saveArchive, id);
                 this._strings[id] = str;
             }
         }
         GC.Collect();
         GC.WaitForPendingFinalizers();
         using (new PerformanceTestBlock("LoadContext::Resolve Objects"))
         {
             for (int i = 0; i < this._objectHeaderLoadDatas.Length; ++i)
             {
                 ObjectHeaderLoadData objectHeaderLoadData = this._objectHeaderLoadDatas[i];
                 TypeDefinition       typeDefinition       = objectHeaderLoadData.TypeDefinition;
                 if (typeDefinition != null)
                 {
                     object loadedObject = objectHeaderLoadData.LoadedObject;
                     if (typeDefinition.ObjectResolver.CheckIfRequiresAdvancedResolving(loadedObject))
                     {
                         ObjectLoadData loadData1 = LoadContext.CreateLoadData(loadData, i, objectHeaderLoadData);
                         objectHeaderLoadData.AdvancedResolveObject(loadData.MetaData, loadData1);
                     }
                     else
                     {
                         objectHeaderLoadData.ResolveObject();
                     }
                 }
             }
         }
         GC.Collect();
         GC.WaitForPendingFinalizers();
         using (new PerformanceTestBlock("LoadContext::Load Object Datas"))
             TWParallel.For(0, this._objectCount, (Action <int>)(i =>
             {
                 ObjectHeaderLoadData objectHeaderLoadData = this._objectHeaderLoadDatas[i];
                 if (objectHeaderLoadData.Target != objectHeaderLoadData.LoadedObject)
                 {
                     return;
                 }
                 LoadContext.CreateLoadData(loadData, i, objectHeaderLoadData);
             }));
         using (new PerformanceTestBlock("LoadContext::Load Container Datas"))
             TWParallel.For(0, this._containerCount, (Action <int>)(i =>
             {
                 byte[] binaryArchive = loadData.GameData.ContainerData[i];
                 ArchiveDeserializer archiveDeserializer = new ArchiveDeserializer();
                 archiveDeserializer.LoadFrom(binaryArchive);
                 SaveEntryFolder rootFolder          = archiveDeserializer.RootFolder;
                 ContainerLoadData containerLoadData = new ContainerLoadData(this._containerHeaderLoadDatas[i]);
                 containerLoadData.InitializeReaders(rootFolder.GetChildFolder(new FolderId(i, SaveFolderExtension.Container)));
                 containerLoadData.FillCreatedObject();
                 containerLoadData.Read();
                 containerLoadData.FillObject();
             }));
         GC.Collect();
         GC.WaitForPendingFinalizers();
         if (!loadAsLateInitialize)
         {
             this.CreateLoadCallbackInitializator(loadData).InitializeObjects();
         }
         return(true);
     }
     catch
     {
         return(false);
     }
 }