/// <summary>
/// Initializes a new instance of the <see cref="SerializationScope"/> class.
/// </summary>
/// <param name="serializer">The serializer.</param>
/// <param name="configuration">The configuration.</param>
public SerializationScope(ISerializer serializer, ISerializationConfiguration configuration)
{
Argument.IsNotNull(() => serializer);
Serializer = serializer;
Configuration = configuration;
}
/// <summary>
/// Initializes a new instance of the <see cref="SerializationScope"/> class.
/// </summary>
/// <param name="serializer">The serializer.</param>
/// <param name="configuration">The configuration.</param>
public SerializationScope(ISerializer serializer, ISerializationConfiguration configuration)
{
Argument.IsNotNull(() => serializer);
Serializer = serializer;
Configuration = configuration;
}
public EventHubProducerSpecification(IEventHubHostConfiguration hostConfiguration, IHostSettings hostSettings)
{
_hostConfiguration = hostConfiguration;
_hostSettings = hostSettings;
_serializationConfiguration = new SerializationConfiguration();
_sendObservers = new SendObservable();
}
IEnumerable <IClassInfoGraphNode> GetSerializedClassInfoGraphNodes(ISerializationConfiguration serializationConfiguration)
{
return(((IEnumerable)((XPBaseObject)serializationConfiguration).GetMemberValue(serializationConfiguration.GetPropertyName(x => x.SerializationGraph))).
OfType <IClassInfoGraphNode>().Where(
node => (node.NodeType == NodeType.Simple && node.SerializationStrategy != SerializationStrategy.DoNotSerialize) ||
node.NodeType != NodeType.Simple).OrderBy(graphNode => graphNode.NodeType));
}
public AttributesConverter(ISerializationConfiguration serializationConfiguration)
{
this.serializationConfig = serializationConfiguration;
this.dateTimeAttributeMapper = new DateTimeAttributeMapper();
this.dateAttributeMapper = new DateAttributeMapper();
this.timeAttributeMapper = new TimeAttributeMapper();
}
public IEnumerable <IClassInfoGraphNode> GetSerializedClassInfoGraphNodes(XPBaseObject theObject, string typeName)
{
var type = ReflectionHelper.GetType(typeName);
ISerializationConfiguration configuration = GetConfiguration(theObject.Session, type);
return(GetSerializedClassInfoGraphNodes(configuration));
}
public static void ConfigureSerializationServices(
this Container services,
ISerializationConfiguration serializationConfiguration)
{
services.Options.AllowOverridingRegistrations = true;
services.Register(() => serializationConfiguration, Lifestyle.Singleton);
}
/// <summary>
/// Deserializes the specified model.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="stream">The stream.</param>
/// <param name="configuration">The configuration.</param>
/// <returns></returns>
/// <remarks>
/// When deserializing a stream, the binary serializer must use the <see cref="BinaryFormatter" /> because this will
/// inject the right <see cref="SerializationInfo" /> into a new serializer.
/// </remarks>
public override object Deserialize(object model, Stream stream, ISerializationConfiguration configuration)
{
Argument.IsNotNull("model", model);
using (GetCurrentSerializationScopeManager(configuration))
{
configuration = GetCurrentSerializationConfiguration(configuration);
using (var context = (SerializationContext <BinarySerializationContextInfo>)GetContext(model, model.GetType(),
stream, SerializationContextMode.Deserialization, configuration))
{
var referenceManager = context.ReferenceManager;
if (referenceManager.Count == 0)
{
Log.Debug("Reference manager contains no objects yet, adding initial reference which is the first model in the graph");
referenceManager.GetInfo(context.Model);
}
var binaryFormatter = CreateBinaryFormatter(SerializationContextMode.Deserialization);
var propertyValues = (List <PropertyValue>)binaryFormatter.Deserialize(stream);
var memberValues = ConvertPropertyValuesToMemberValues(context, model.GetType(), propertyValues);
context.Context.MemberValues.AddRange(memberValues);
return(Deserialize(model, context.Context, context.Configuration));
}
}
}
/// <summary>
/// Creates a json reader with the right configuration.
/// </summary>
/// <param name="token">The token.</param>
/// <param name="configuration">The configuration.</param>
/// <returns>
/// The json reader.
/// </returns>
public static JsonReader CreateReader(this JToken token, ISerializationConfiguration configuration)
{
var reader = token.CreateReader();
reader.Culture = configuration.Culture;
return reader;
}
/// <summary>
/// Initializes a new instance of the <see cref="SerializationContext{TContext}" /> class.
/// </summary>
/// <param name="model">The model, can be <c>null</c> for value types.</param>
/// <param name="modelType">Type of the model.</param>
/// <param name="context">The context.</param>
/// <param name="contextMode">The context mode.</param>
/// <param name="configuration">The configuration.</param>
/// <exception cref="ArgumentNullException">The <paramref name="modelType" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="context" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="configuration" /> is <c>null</c>.</exception>
public SerializationContext(object model, Type modelType, TContext context,
SerializationContextMode contextMode, ISerializationConfiguration configuration = null)
{
Argument.IsNotNull("modelType", modelType);
Argument.IsNotNull("context", context);
Argument.IsNotNull("configuration", configuration);
Model = model;
ModelType = modelType;
ModelTypeName = modelType.GetSafeFullName(false);
Context = context;
ContextMode = contextMode;
TypeStack = new Stack <Type>();
Configuration = configuration;
var scopeName = SerializationContextHelper.GetSerializationReferenceManagerScopeName();
_typeStackScopeManager = ScopeManager <Stack <Type> > .GetScopeManager(scopeName, () => new Stack <Type>());
TypeStack = _typeStackScopeManager.ScopeObject;
_referenceManagerScopeManager = ScopeManager <ReferenceManager> .GetScopeManager(scopeName);
ReferenceManager = _referenceManagerScopeManager.ScopeObject;
_serializableToken = CreateSerializableToken();
}
/// <summary>
/// Saves the object to memory stream so the <see cref="IModel.IsDirty" /> property is set to false.
/// </summary>
/// <param name="obj">The object.</param>
/// <param name="configuration">The configuration.</param>
internal static void SaveObjectToMemoryStream(ISavableModel obj, ISerializationConfiguration configuration = null)
{
using (var memoryStream = new MemoryStream())
{
obj.Save(memoryStream, configuration);
}
}
public void Generate(ISerializationConfiguration configuration)
{
Type typeToSerialize = configuration.TypeToSerialize;
ObjectSpace objectSpace = ObjectSpace.FindObjectSpace(configuration);
foreach (IClassInfoGraphNode classInfoGraphNode in GetGraph(objectSpace, typeToSerialize, null)) {
configuration.SerializationGraph.Add(classInfoGraphNode);
}
}
public ISerializationContextInfo GetSerializationContextInfo(ISerializer serializer, object model, object data, ISerializationConfiguration configuration)
{
var jsonSerializer = new Newtonsoft.Json.JsonSerializer();
jsonSerializer.ContractResolver = new CatelJsonContractResolver();
jsonSerializer.Converters.Add(new CatelJsonConverter((IJsonSerializer)serializer, configuration));
return new JsonSerializationContextInfo(jsonSerializer, null, null);
}
/// <summary>
/// Creates a json reader with the right configuration.
/// </summary>
/// <param name="token">The token.</param>
/// <param name="configuration">The configuration.</param>
/// <returns>
/// The json reader.
/// </returns>
public static JsonReader CreateReader(this JToken token, ISerializationConfiguration configuration)
{
var reader = token.CreateReader();
reader.Culture = configuration.Culture;
return(reader);
}
public static CriteriaOperator GetCriteria(Type serializationConfigurationType, ISerializationConfigurationGroup serializationConfigurationGroup)
{
const ISerializationConfiguration serializationConfiguration = null;
var groupOperator = new BinaryOperator(serializationConfiguration.GetPropertyName(x => x.SerializationConfigurationGroup), serializationConfigurationGroup);
return(new GroupOperator(new BinaryOperator(serializationConfiguration.GetPropertyName(x => x.TypeToSerialize),
serializationConfigurationType), groupOperator));
}
/// <summary>
/// Saves the object to a stream using a specific formatting.
/// </summary>
/// <param name="stream">Stream that will contain the serialized data of this object.</param>
/// <param name="serializer">The serializer to use.</param>
/// <param name="configuration">The configuration.</param>
public void Save(Stream stream, ISerializer serializer, ISerializationConfiguration configuration = null)
{
Argument.IsNotNull("stream", stream);
Argument.IsNotNull("serializer", serializer);
serializer.Serialize(this, stream, configuration);
this.ClearIsDirtyOnAllChilds();
}
/// <summary>
/// Loads the object from a stream using a specific formatting.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="stream">Stream that contains the serialized data of this object.</param>
/// <param name="serializer">The serializer.</param>
/// <param name="configuration">The configuration.</param>
/// <returns>
/// Deserialized instance of the object. If the deserialization fails, <c>null</c> is returned.
/// </returns>
/// <remarks>
/// When enableRedirects is enabled, loading will take more time. Only set
/// the parameter to <c>true</c> when the deserialization without redirects fails.
/// </remarks>
public static IModel Load(Type type, Stream stream, ISerializer serializer, ISerializationConfiguration configuration = null)
{
Argument.IsNotNull("type", type);
Argument.IsNotNull("stream", stream);
Argument.IsNotNull("serializer", serializer);
var result = serializer.Deserialize(type, stream, configuration);
return(result as IModel);
}
/// <summary>
/// Deserializes the specified model type.
/// </summary>
/// <param name="modelType">Type of the model.</param>
/// <param name="stream">The stream.</param>
/// <param name="configuration">The configuration.</param>
/// <returns>
/// The serialized object.
/// </returns>
/// <remarks>
/// When deserializing a stream, the binary serializer must use the <see cref="BinaryFormatter" /> because this will
/// inject the right <see cref="SerializationInfo" /> into a new serializer.
/// </remarks>
public override object Deserialize(Type modelType, Stream stream, ISerializationConfiguration configuration)
{
Argument.IsNotNull("modelType", modelType);
// Note: although this looks like an unnecessary overload, it's required to prevent duplicate scopes
var model = CreateModelInstance(modelType);
return(Deserialize(model, stream, configuration));
}
public EventHubProducerSharedContext(IBusInstance busInstance, SendObservable sendObservers, ISendPipe sendPipe,
ISerializationConfiguration serializationConfiguration, IHostSettings hostSettings, EventHubProducerClientOptions options)
{
SendObservers = sendObservers;
SendPipe = sendPipe;
_busInstance = busInstance;
_serializationConfiguration = serializationConfiguration;
_hostSettings = hostSettings;
_options = options;
_clients = new ConcurrentDictionary <string, EventHubProducerClient>();
}
public void ApplyStrategy(SerializationStrategy serializationStrategy, ISerializationConfiguration serializationConfiguration)
{
var serializationConfigurationGroup = serializationConfiguration.SerializationConfigurationGroup;
var infoGraphNodes = serializationConfigurationGroup.Configurations.SelectMany(configuration => configuration.SerializationGraph);
var classInfoGraphNodes = infoGraphNodes.Where(node => node.TypeName == serializationConfiguration.TypeToSerialize.Name);
foreach (var classInfoGraphNode in classInfoGraphNodes)
{
classInfoGraphNode.SerializationStrategy = serializationStrategy;
}
}
static XDocument ExportRecords(XPObjectSpace XPObjectSpace)
{
ISerializationConfiguration serializationConfiguration = XPObjectSpace.CreateObject <SerializationConfiguration>();
serializationConfiguration.TypeToSerialize = typeof(PEnumClass);
serializationConfiguration.SerializationConfigurationGroup =
XPObjectSpace.CreateObject <SerializationConfigurationGroup>();
new ClassInfoGraphNodeBuilder().Generate(serializationConfiguration);
XDocument document = new ExportEngine().Export(new[] { _pEnumClass }, serializationConfiguration.SerializationConfigurationGroup);
return(document);
}
public void Generate(ISerializationConfiguration serializationConfiguration){
var typeToSerialize = serializationConfiguration.TypeToSerialize;
var castTypeToTypeInfo = XafTypesInfo.CastTypeToTypeInfo(typeToSerialize);
var objectSpace = ObjectSpace.FindObjectSpace(serializationConfiguration);
foreach (var descendant in ReflectionHelper.FindTypeDescendants(castTypeToTypeInfo)) {
generate(objectSpace, descendant.Type);
}
foreach (IClassInfoGraphNode classInfoGraphNode in createGraph(objectSpace, castTypeToTypeInfo)){
serializationConfiguration.SerializationGraph.Add(classInfoGraphNode);
}
}
public XDocument Export( IEnumerable<XPBaseObject> baseCollection, ISerializationConfiguration serializationConfiguration){
var xDocument = new XDocument();
var root = new XElement("SerializedObjects");
xDocument.Add(root);
foreach (var baseObject in baseCollection) {
var serializedClassInfoGraphNodes = GetSerializedClassInfoGraphNodes(baseObject, serializationConfiguration);
ExportCore(baseObject, serializedClassInfoGraphNodes, root);
}
return xDocument;
}
/// <summary>
/// Serializes the object to a byte array.
/// </summary>
/// <returns>Byte array containing the serialized data.</returns>
public byte[] ToByteArray(ISerializationConfiguration configuration)
{
using (var memoryStream = new MemoryStream())
{
#if NET
Save(memoryStream, SerializationMode.Binary, configuration);
#else
Save(memoryStream, SerializationMode.Xml, configuration);
#endif
return(memoryStream.ToArray());
}
}
/// <summary>
/// Serializes the object to a byte array.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="serializer">The serializer.</param>
/// <param name="configuration">The configuration.</param>
/// <returns>
/// Byte array containing the serialized data.
/// </returns>
public static byte[] ToByteArray(this IModel model, ISerializer serializer, ISerializationConfiguration configuration = null)
{
Argument.IsNotNull("model", model);
Argument.IsNotNull("serializer", serializer);
using (var memoryStream = new MemoryStream())
{
serializer.Serialize(model, memoryStream, configuration);
memoryStream.Position = 0L;
return(memoryStream.ToArray());
}
}
/// <summary>
/// Serializes the specified model to the json writer.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="jsonWriter">The json writer.</param>
/// <param name="configuration">The configuration.</param>
public void Serialize(object model, JsonWriter jsonWriter, ISerializationConfiguration configuration)
{
Argument.IsNotNull("model", model);
using (GetCurrentSerializationScopeManager(configuration))
{
configuration = GetCurrentSerializationConfiguration(configuration);
using (var context = GetContext(model, model.GetType(), null, jsonWriter, SerializationContextMode.Serialization, null, null, configuration))
{
base.Serialize(model, context.Context, configuration);
}
}
}
/// <summary>
/// Saves the object to a file using a specific formatting.
/// </summary>
/// <param name="fileName">Filename of the file that will contain the serialized data of this object.</param>
/// <param name="mode"><see cref="SerializationMode" /> to use.</param>
/// <param name="configuration">The configuration.</param>
public void Save(string fileName, SerializationMode mode, ISerializationConfiguration configuration)
{
var fileInfo = new FileInfo(fileName);
if (!Directory.Exists(fileInfo.DirectoryName))
{
Directory.CreateDirectory(fileInfo.DirectoryName);
}
using (Stream stream = new FileStream(fileName, FileMode.Create))
{
Save(stream, mode, configuration);
}
}
/// <summary>
/// Serializes the object to and xml object.
/// </summary>
/// <param name="configuration">The configuration.</param>
/// <returns>
/// <see cref="XDocument" /> containing the serialized data.
/// </returns>
public XDocument ToXml(ISerializationConfiguration configuration)
{
using (var memoryStream = new MemoryStream())
{
Save(memoryStream, SerializationMode.Xml, configuration);
memoryStream.Position = 0L;
using (var xmlReader = XmlReader.Create(memoryStream))
{
return(XDocument.Load(xmlReader));
}
}
}
public void Generate(ISerializationConfiguration serializationConfiguration) {
var typeToSerialize = serializationConfiguration.TypeToSerialize;
var castTypeToTypeInfo = XafTypesInfo.CastTypeToTypeInfo(typeToSerialize);
var objectSpace = XPObjectSpace.FindObjectSpaceByObject(serializationConfiguration);
_serializationConfigurationGroup = serializationConfiguration.SerializationConfigurationGroup;
if (_serializationConfigurationGroup == null)
throw new NullReferenceException("_serializationConfigurationGroup");
foreach (var descendant in ReflectionHelper.FindTypeDescendants(castTypeToTypeInfo)) {
Generate(objectSpace, descendant.Type);
}
foreach (IClassInfoGraphNode classInfoGraphNode in CreateGraph(objectSpace, castTypeToTypeInfo)) {
serializationConfiguration.SerializationGraph.Add(classInfoGraphNode);
}
}
/// <summary>
/// Deserializes the specified model type.
/// </summary>
/// <param name="modelType">Type of the model.</param>
/// <param name="stream">The stream.</param>
/// <param name="configuration">The configuration.</param>
/// <returns>
/// The deserialized <see cref="object" />.
/// </returns>
public virtual object Deserialize(Type modelType, Stream stream, ISerializationConfiguration configuration = null)
{
Argument.IsNotNull("modelType", modelType);
Argument.IsNotNull("stream", stream);
using (GetCurrentSerializationScopeManager(configuration))
{
configuration = GetCurrentSerializationConfiguration(configuration);
using (var context = GetContext(modelType, stream, SerializationContextMode.Deserialization, configuration))
{
return(Deserialize(context.Model, context.Context, configuration));
}
}
}
/// <summary>
/// Deserializes the specified model.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="stream">The stream.</param>
/// <param name="configuration">The configuration.</param>
/// <returns>
/// The deserialized model.
/// </returns>
public virtual object Deserialize(object model, Stream stream, ISerializationConfiguration configuration)
{
Argument.IsNotNull("model", model);
Argument.IsNotNull("stream", stream);
using (GetCurrentSerializationScopeManager(configuration))
{
configuration = GetCurrentSerializationConfiguration(configuration);
using (var context = GetContext(model, model.GetType(), stream, SerializationContextMode.Deserialization, configuration))
{
return(Deserialize(model, context));
}
}
}
/// <summary>
/// Serializes the specified model.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="context">The context.</param>
/// <param name="configuration">The configuration.</param>
public virtual void Serialize(object model, TSerializationContext context, ISerializationConfiguration configuration)
{
Argument.IsNotNull("model", model);
Argument.IsNotNull("context", context);
using (GetCurrentSerializationScopeManager(configuration))
{
configuration = GetCurrentSerializationConfiguration(configuration);
using (var finalContext = GetContext(model, model.GetType(), context, SerializationContextMode.Serialization, configuration))
{
Serialize(model, finalContext);
}
}
}
protected override void ConfigureOverride(FilterContext context, ITimestampSerializationOptions options)
{
ITimestampStringConverter timestampConverter = TimestampStringConverterResolver.Default.Resolve(options.TimestampFormat);
var converters = new ISerializationConfiguration[] {
new CsvConvertersSerializationConfiguration(new SelectionCsvConverter())
};
context.IO
.Formats
.GetOrDefault(FileFormat.CSV)?
.Configurations
.AddRange(converters);
}
/// <summary>
/// Loads the object from a stream using a specific formatting.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="stream">Stream that contains the serialized data of this object.</param>
/// <param name="mode"><see cref="SerializationMode" /> to use.</param>
/// <param name="configuration">The configuration.</param>
/// <returns>
/// Deserialized instance of the object. If the deserialization fails, <c>null</c> is returned.
/// </returns>
/// <remarks>
/// When enableRedirects is enabled, loading will take more time. Only set
/// the parameter to <c>true</c> when the deserialization without redirects fails.
/// </remarks>
public static IModel Load(Type type, Stream stream, SerializationMode mode, ISerializationConfiguration configuration)
{
Argument.IsNotNull("type", type);
object result = null;
Log.Debug("Loading object '{0}' as '{1}'", type.Name, mode);
switch (mode)
{
#if NET
case SerializationMode.Binary:
try
{
var binarySerializer = SerializationFactory.GetBinarySerializer();
result = binarySerializer.Deserialize(type, stream, null);
}
catch (Exception ex)
{
Log.Error(ex, "Failed to deserialize the binary object");
}
break;
#endif
case SerializationMode.Xml:
try
{
var xmlSerializer = SerializationFactory.GetXmlSerializer();
result = xmlSerializer.Deserialize(type, stream, null);
}
catch (Exception ex)
{
Log.Error(ex, "Failed to deserialize the binary object");
}
break;
}
Log.Debug("Loaded object");
var resultAsModelBase = result as ISavableModel;
if (resultAsModelBase != null)
{
resultAsModelBase.Mode = mode;
}
return(result as IModel);
}
/// <summary>
/// Converters the specified model to a json string.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="configuration">The configuration.</param>
/// <returns>
/// System.String.
/// </returns>
public static string ToJson(this ModelBase model, ISerializationConfiguration configuration)
{
var jsonSerializer = new JsonSerializer(SerializationManager, TypeFactory.Default, ObjectAdapter);
using (var stream = new MemoryStream())
{
jsonSerializer.Serialize(model, stream, configuration);
stream.Position = 0L;
using (var streamReader = new StreamReader(stream))
{
return(streamReader.ReadToEnd());
}
}
}
/// <summary>
/// Converters the specified model to a json string.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="configuration">The configuration.</param>
/// <returns>
/// System.String.
/// </returns>
public static string ToJson(this ModelBase model, ISerializationConfiguration configuration)
{
var jsonSerializer = new JsonSerializer(SerializationManager, TypeFactory.Default, ObjectAdapter);
using (var stream = new MemoryStream())
{
jsonSerializer.Serialize(model, stream, configuration);
stream.Position = 0L;
using (var streamReader = new StreamReader(stream))
{
return streamReader.ReadToEnd();
}
}
}
/// <summary>
/// Serializes the object to and xml object.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="serializer">The serializer.</param>
/// <param name="configuration">The configuration.</param>
/// <returns>
/// <see cref="XDocument" /> containing the serialized data.
/// </returns>
public static XDocument ToXml(this IModel model, ISerializer serializer, ISerializationConfiguration configuration = null)
{
Argument.IsNotNull("model", model);
Argument.IsNotNull("serializer", serializer);
using (var memoryStream = new MemoryStream())
{
serializer.Serialize(model, memoryStream, configuration);
memoryStream.Position = 0L;
using (var xmlReader = XmlReader.Create(memoryStream))
{
return(XDocument.Load(xmlReader));
}
}
}
/// <summary>
/// Serializes the specified model.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="stream">The stream.</param>
/// <param name="configuration">The configuration.</param>
public virtual void Serialize(object model, Stream stream, ISerializationConfiguration configuration = null)
{
Argument.IsNotNull("model", model);
Argument.IsNotNull("stream", stream);
using (GetCurrentSerializationScopeManager(configuration))
{
configuration = GetCurrentSerializationConfiguration(configuration);
using (var context = GetSerializationContextInfo(model, model.GetType(), stream, SerializationContextMode.Serialization, configuration))
{
Serialize(model, context);
AppendContextToStream(context, stream);
}
}
}
IEnumerable<IClassInfoGraphNode> GetSerializedClassInfoGraphNodes(XPBaseObject baseObject, ISerializationConfiguration serializationConfiguration) {
ISerializationConfiguration configuration = baseObject.GetType() ==serializationConfiguration.TypeToSerialize? serializationConfiguration
: SerializationConfigurationQuery.Find(baseObject.Session, baseObject.GetType());
return GetSerializedClassInfoGraphNodes(configuration);
}
public void ApplyStrategy(SerializationStrategy serializationStrategy, ISerializationConfiguration serializationConfiguration) {
var serializationConfigurationGroup = serializationConfiguration.SerializationConfigurationGroup;
var infoGraphNodes = serializationConfigurationGroup.Configurations.SelectMany(configuration => configuration.SerializationGraph);
var classInfoGraphNodes = infoGraphNodes.Where(node => node.TypeName == serializationConfiguration.TypeToSerialize.Name);
foreach (var classInfoGraphNode in classInfoGraphNodes) {
classInfoGraphNode.SerializationStrategy = serializationStrategy;
}
}
/// <summary>
/// Gets the serialization context information.
/// </summary>
/// <param name="serializer">The serializer.</param>
/// <param name="model">The model.</param>
/// <param name="data">The data.</param>
/// <param name="configuration">The configuration.</param>
/// <returns>
/// ISerializationContextInfo.
/// </returns>
public ISerializationContextInfo GetSerializationContextInfo(ISerializer serializer, object model, object data, ISerializationConfiguration configuration)
{
return new BinarySerializationContextInfo((SerializationInfo)data);
}
/// <summary>
/// Saves the object to memory stream so the <see cref="IModel.IsDirty" /> property is set to false.
/// </summary>
/// <param name="obj">The object.</param>
/// <param name="configuration">The configuration.</param>
internal static void SaveObjectToMemoryStream(ISavableModel obj, ISerializationConfiguration configuration = null)
{
using (var memoryStream = new MemoryStream())
{
obj.Save(memoryStream, configuration);
}
}
IEnumerable<IClassInfoGraphNode> GetSerializedClassInfoGraphNodes(ISerializationConfiguration serializationConfiguration) {
return ((IEnumerable)((XPBaseObject)serializationConfiguration).GetMemberValue(serializationConfiguration.GetPropertyName(x => x.SerializationGraph))).
OfType<IClassInfoGraphNode>().Where(
node => (node.NodeType == NodeType.Simple && node.SerializationStrategy != SerializationStrategy.DoNotSerialize) ||
node.NodeType != NodeType.Simple).OrderBy(graphNode => graphNode.NodeType);
}
/// <summary>
/// Initializes a new instance of the <see cref="CatelJsonConverter" /> class.
/// </summary>
/// <param name="jsonSerializer">The json serializer.</param>
/// <param name="configuration">The configuration.</param>
public CatelJsonConverter(IJsonSerializer jsonSerializer, ISerializationConfiguration configuration)
{
_jsonSerializer = jsonSerializer;
_configuration = configuration;
}
/// <summary>
/// Gets the serialization context information.
/// </summary>
/// <param name="serializer">The serializer.</param>
/// <param name="model">The model.</param>
/// <param name="data">The data.</param>
/// <param name="configuration">The configuration.</param>
/// <returns>
/// ISerializationContext.
/// </returns>
public ISerializationContextInfo GetSerializationContextInfo(ISerializer serializer, object model, object data, ISerializationConfiguration configuration)
{
return new XmlSerializationContextInfo((XElement)data, model);
}
