public byte[] Serialize <TObject>(TObject objectToSerialize) { using (var context = _serializationContextFactory.Create()) using (var element = new XElementDisposer(ElementFrom(objectToSerialize, context))) { element.Element.AddAttribute(CoreConstants.Serialization.Attribute.XmlVersion, ProjectVersions.CurrentAsString); return(XmlHelper.XmlContentToByte(element.Element)); } }
public virtual void Save() { using (var serializationContext = _serializationContextFactory.Create()) { var serializer = _serializerRepository.SerializerFor(_settings); var xml = serializer.Serialize(_settings, serializationContext); saveSerializedSettingsToFile(xml); } }
public XElement SerializeModelPart <T>(T entityToSerialize) { using (var serializationContext = _serializationContextFactory.Create()) { var partSerializer = _repository.SerializerFor(entityToSerialize.GetType()); var xElement = partSerializer.Serialize(entityToSerialize, serializationContext); xElement.AddAttribute(Constants.Serialization.Attribute.VERSION, ProjectVersions.CurrentAsString); addFormulaCache(entityToSerialize, xElement, serializationContext); return(xElement); } }
public IPKSimProject MapFrom(ProjectMetaData projectMetaData) { var project = new PKSimProject { Name = projectMetaData.Name, Description = projectMetaData.Description }; //Observed data needs to be loaded first into project projectMetaData.AllObservedData.Each(x => project.AddObservedData(mapFrom(x))); projectMetaData.BuildingBlocks.Each(x => project.AddBuildingBlock(mapFrom(x))); //we need a shared context for all object referencing observed data and simulations using (var context = _serializationContextFactory.Create(project.AllObservedData, project.All <ISimulation>())) { var localContext = context; projectMetaData.ParameterIdentifications.Each(x => project.AddParameterIdentification(mapFrom(x, localContext))); projectMetaData.SensitivityAnalyses.Each(x => project.AddSensitivityAnalysis(mapFrom(x, localContext))); } projectMetaData.SimulationComparisons.Each(x => project.AddSimulationComparison(mapFrom(x))); //Once reference to dynamic meta data was added, deserialize the project itself _serializationManager.Deserialize(project, projectMetaData.Content.Data); //if the project DB Version is the same as the current project, the project did not change if (projectMetaData.Version == ProjectVersions.Current) { project.HasChanged = false; } return(project); }
public void LoadContentFor(SensitivityAnalysis sensitivityAnalysis) { var content = _sensitivityAnalysisMetaDataContentQuery.ResultFor(sensitivityAnalysis.Id); if (content?.Data == null) { return; } using (var context = _serializationContextFactory.Create(externalReferences: _projectRetriever.CurrentProject.All <ISimulation>())) { _compressedSerializationManager.Deserialize(sensitivityAnalysis, content.Data, context); } }
public void LoadContentFor(ParameterIdentification parameterIdentification) { var content = _parameterIdentificationMetaDataContentQuery.ResultFor(parameterIdentification.Id); if (content == null) { return; } using (var context = _serializationContextFactory.Create(externalReferences: _projectRetriever.CurrentProject.All <ISimulation>())) { _compressedSerializationManager.Deserialize(parameterIdentification, content.Data, context); } }
public void Save(IMoBiProject project, IMoBiContext context) { using (_serializationContextFactory.Create()) { var session = _sessionManager.CurrentSession; var projectMetaData = projectMetaDataFrom(project); var projectFromDb = projectFromDatabase(); if (projectFromDb == null) { session.Save(projectMetaData); } else { projectFromDb.UpdateFrom(projectMetaData, session); } } }
protected override void Context() { _individual = new Individual(); _container = A.Fake <IContainer>(); _serializationContextFactory = A.Fake <ISerializationContextFactory>(); _simulationUpdater = A.Fake <ISimulationUpdaterAfterDeserialization>(); _eventPublisher = A.Fake <IEventPublisher>(); _xmlReaderIndividual = A.Fake <IXmlReader <Individual> >(); _xmlWriterIndividual = A.Fake <IXmlWriter <Individual> >(); _xmlReaderSimulation = A.Fake <IXmlReader <Simulation> >(); _xmlWriterSimulation = A.Fake <IXmlWriter <Simulation> >(); _objectConverterFinder = A.Fake <IObjectConverterFinder>(); _serializationContext = A.Fake <SerializationContext>(); A.CallTo(() => _container.Resolve <IXmlReader <Individual> >()).Returns(_xmlReaderIndividual); A.CallTo(() => _container.Resolve <IXmlWriter <Individual> >()).Returns(_xmlWriterIndividual); A.CallTo(() => _container.Resolve <IXmlReader <Simulation> >()).Returns(_xmlReaderSimulation); A.CallTo(() => _container.Resolve <IXmlWriter <Simulation> >()).Returns(_xmlWriterSimulation); _referenceResolver = A.Fake <IReferencesResolver>(); sut = new XmlSerializationManager(_referenceResolver, _container, _objectConverterFinder, _simulationUpdater, _eventPublisher, _serializationContextFactory); A.CallTo(() => _serializationContextFactory.Create(null, null)).Returns(_serializationContext); }
public IMoBiProject MapFrom(ProjectMetaData projectMetaData) { try { // deserialization is a three stage process. First we need to load the observed data // then all other entities and finish with the project charts using (var serializationContext = _serializationContextFactory.Create()) { _project = deserializeContent <IMoBiProject>(projectMetaData.Content, serializationContext); _project.Name = projectMetaData.Name; _project.Description = projectMetaData.Description; //add observed data to global addObservedDataToSerializationContext(serializationContext); //load simulation first foreach (var simulationMetaData in projectMetaData.Simulations) { addSimulationToProject(simulationMetaData, serializationContext); } //then load the rest of the entities foreach (var entityMetaData in projectMetaData.Children) { addEntityToProject(entityMetaData, serializationContext); } _deserializedReferenceResolver.ResolveFormulaAndTemplateReferences(_project, _project); return(_project); } } finally { _project = null; } }