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;
}
}