/// <summary>
/// Writes the json.
/// </summary>
/// <param name="writer">The writer.</param>
/// <param name="value">The value.</param>
/// <param name="serializer">The serializer.</param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var serialize = true;
if (_jsonSerializer.PreserveReferences)
{
var scopeName = SerializationContextHelper.GetSerializationReferenceManagerScopeName();
using (var scopeManager = ScopeManager <ReferenceManager> .GetScopeManager(scopeName))
{
var referenceManager = scopeManager.ScopeObject;
var referenceInfo = referenceManager.GetInfo(value);
if (referenceInfo != null && !referenceInfo.IsFirstUsage)
{
writer.WriteStartObject();
writer.WritePropertyName(Json.JsonSerializer.GraphRefId);
writer.WriteValue(referenceInfo.Id);
writer.WriteEndObject();
serialize = false;
}
}
}
if (serialize)
{
_jsonSerializer.Serialize((ModelBase)value, writer);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ModelBase"/> class.
/// <para />
/// Only constructor for the ModelBase.
/// </summary>
/// <param name="info">SerializationInfo object, null if this is the first time construction.</param>
/// <param name="context">StreamingContext object, simple pass a default new StreamingContext() if this is the first time construction.</param>
/// <remarks>
/// Call this method, even when constructing the object for the first time (thus not deserializing).
/// </remarks>
protected ModelBase(SerializationInfo info, StreamingContext context)
{
Initialize();
// Make sure this is not a first time call or custom call with null
if (info != null)
{
_serializationInfo = info;
// Too bad we cannot put this in the BinarySerializer, but BinarySerialization works bottom => top. We
// do need the GraphId though, thus we are setting it here
var scopeName = SerializationContextHelper.GetSerializationScopeName();
using (var scopeManager = ScopeManager <SerializationContextScope <BinarySerializationContextInfo> > .GetScopeManager(scopeName))
{
var referenceManager = scopeManager.ScopeObject.ReferenceManager;
int?graphId = null;
try
{
// Binary
graphId = (int)info.GetValue("GraphId", typeof(int));
}
catch (Exception)
{
// Swallow
}
if (graphId.HasValue)
{
referenceManager.RegisterManually(graphId.Value, this);
}
}
}
}
private void OnDeserialized(StreamingContext context)
{
IsDeserializedDataAvailable = true;
if (_serializationInfo == null)
{
// Probably a custom serializer which will populate us in a different way
return;
}
var scopeName = SerializationContextHelper.GetSerializationReferenceManagerScopeName();
using (var scopeManager = ScopeManager <SerializationScope> .GetScopeManager(scopeName, () => new SerializationScope(SerializationFactory.GetBinarySerializer(), SerializationConfiguration)))
{
var serializer = scopeManager.ScopeObject.Serializer;
var configuration = scopeManager.ScopeObject.Configuration;
var dependencyResolver = this.GetDependencyResolver();
var serializationContextInfoFactory = dependencyResolver.Resolve <ISerializationContextInfoFactory>(serializer.GetType());
var serializationContext = serializationContextInfoFactory.GetSerializationContextInfo(serializer, this, _serializationInfo, configuration);
serializer.Deserialize(this, serializationContext, configuration);
}
DeserializationSucceeded = true;
}
private void OnDeserialized(StreamingContext context)
{
#if NET || NETCORE
if (_serializationInfo is null)
{
// Probably a custom serializer which will populate us in a different way
return;
}
var scopeName = SerializationContextHelper.GetSerializationReferenceManagerScopeName();
using (var scopeManager = ScopeManager <SerializationScope> .GetScopeManager(scopeName, BinarySerializationScopeFactory))
{
var serializer = scopeManager.ScopeObject.Serializer;
var configuration = scopeManager.ScopeObject.Configuration;
var dependencyResolver = this.GetDependencyResolver();
var serializationContextInfoFactory = dependencyResolver.Resolve <ISerializationContextInfoFactory>(serializer.GetType());
var serializationContext = serializationContextInfoFactory.GetSerializationContextInfo(serializer, this, _serializationInfo, configuration);
serializer.Deserialize(this, serializationContext, configuration);
}
#else
throw new NotSupportedInPlatformException("It's adviced to no longer use binary serialization on this platform");
#endif
}
/// <summary>
/// Gets the namespace for the specified type.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="preferredPrefix">The preferred prefix.</param>
/// <returns>The xml namespace.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="type" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">The <paramref name="preferredPrefix"/> is <c>null</c> or whitespace.</exception>
public XmlNamespace GetNamespace(Type type, string preferredPrefix)
{
Argument.IsNotNull("type", type);
var scopeName = SerializationContextHelper.GetSerializationReferenceManagerScopeName();
using (var serializationManagerScopeManager = ScopeManager <ReferenceManager> .GetScopeManager(scopeName))
{
EnsureSubscribedToScope(serializationManagerScopeManager, scopeName);
var scopeInfo = _scopeInfo[scopeName];
return(scopeInfo.GetNamespace(type, preferredPrefix));
}
}
/// <summary>
/// Converts an object into its XML representation.
/// </summary>
/// <param name="writer">The <see cref="T:System.Xml.XmlWriter"/> stream to which the object is serialized.</param>
void IXmlSerializable.WriteXml(XmlWriter writer)
{
// Note: although this XmlWriter doesn't have settings, it has an internal writer that
// is used (with the correct settings). For more details, see the source at:
// https://referencesource.microsoft.com/#System.Runtime.Serialization/System/Runtime/Serialization/XmlSerializableWriter.cs
var scopeName = SerializationContextHelper.GetSerializationReferenceManagerScopeName();
using (var scopeManager = ScopeManager <SerializationScope> .GetScopeManager(scopeName, XmlSerializationScopeFactory))
{
var serializer = scopeManager.ScopeObject.Serializer;
serializer.Serialize(this, new XmlSerializationContextInfo(writer, this), scopeManager.ScopeObject.Configuration);
}
}
public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
{
var scopeName = SerializationContextHelper.GetSerializationReferenceManagerScopeName();
using (var scopeManager = ScopeManager<SerializationScope>.GetScopeManager(scopeName, () => new SerializationScope(SerializationFactory.GetBinarySerializer(), null)))
{
var serializer = scopeManager.ScopeObject.Serializer;
var configuration = scopeManager.ScopeObject.Configuration;
var dependencyResolver = this.GetDependencyResolver();
var serializationContextInfoFactory = dependencyResolver.Resolve<ISerializationContextInfoFactory>(serializer.GetType());
var serializationContext = serializationContextInfoFactory.GetSerializationContextInfo(serializer, this, info, configuration);
serializer.Serialize(this, serializationContext, configuration);
}
}
public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
{
var scopeName = SerializationContextHelper.GetSerializationReferenceManagerScopeName();
using (var scopeManager = ScopeManager <ISerializer> .GetScopeManager(scopeName, SerializationFactory.GetBinarySerializer))
{
var serializer = scopeManager.ScopeObject;
var dependencyResolver = this.GetDependencyResolver();
var serializationContextInfoFactory = dependencyResolver.Resolve <ISerializationContextInfoFactory>(serializer.GetType());
var serializationContext = serializationContextInfoFactory.GetSerializationContextInfo(serializer, this, info);
serializer.Serialize(this, serializationContext);
}
}
/// <summary>
/// Generates an object from its XML representation.
/// </summary>
/// <param name="reader">The <see cref="T:System.Xml.XmlReader"/> stream from which the object is deserialized.</param>
void IXmlSerializable.ReadXml(XmlReader reader)
{
if (reader.IsEmptyElement && !reader.HasAttributes)
{
return;
}
var contextInfo = new XmlSerializationContextInfo(reader, this);
var scopeName = SerializationContextHelper.GetSerializationReferenceManagerScopeName();
using (var scopeManager = ScopeManager <SerializationScope> .GetScopeManager(scopeName, () => new SerializationScope(SerializationFactory.GetXmlSerializer(), SerializationConfiguration)))
{
var serializer = scopeManager.ScopeObject.Serializer;
serializer.Deserialize(this, contextInfo, scopeManager.ScopeObject.Configuration);
}
}
public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
{
#if NET || NETCORE
var scopeName = SerializationContextHelper.GetSerializationReferenceManagerScopeName();
using (var scopeManager = ScopeManager <SerializationScope> .GetScopeManager(scopeName, BinarySerializationScopeFactory))
{
var serializer = scopeManager.ScopeObject.Serializer;
var configuration = scopeManager.ScopeObject.Configuration;
var dependencyResolver = this.GetDependencyResolver();
var serializationContextInfoFactory = dependencyResolver.Resolve <ISerializationContextInfoFactory>(serializer.GetType());
var serializationContext = serializationContextInfoFactory.GetSerializationContextInfo(serializer, this, info, configuration);
serializer.Serialize(this, serializationContext, configuration);
}
#else
throw new NotSupportedInPlatformException("It's adviced to no longer use binary serialization on this platform");
#endif
}
/// <summary>
/// Converts an object into its XML representation.
/// </summary>
/// <param name="writer">The <see cref="T:System.Xml.XmlWriter"/> stream to which the object is serialized.</param>
void IXmlSerializable.WriteXml(XmlWriter writer)
{
var scopeName = SerializationContextHelper.GetSerializationReferenceManagerScopeName();
using (var scopeManager = ScopeManager <SerializationScope> .GetScopeManager(scopeName, () => new SerializationScope(SerializationFactory.GetXmlSerializer(), SerializationConfiguration)))
{
var type = GetType();
var element = new XElement(type.Name);
var serializer = scopeManager.ScopeObject.Serializer;
serializer.Serialize(this, new XmlSerializationContextInfo(element, this), scopeManager.ScopeObject.Configuration);
// The serializer gives us the full element, but we only need the actual content. According to
// http://stackoverflow.com/questions/3793/best-way-to-get-innerxml-of-an-xelement, this method is the fastest:
var reader = element.CreateReader();
reader.MoveToContent();
// CTL-710: fix attributes on top level elements
if (reader.HasAttributes)
{
for (int i = 0; i < reader.AttributeCount; i++)
{
reader.MoveToAttribute(i);
var attributePrefix = reader.Prefix;
var attributeLocalName = reader.LocalName;
var attributeNs = reader.NamespaceURI;
var attributeValue = reader.Value;
writer.WriteAttributeString(attributePrefix, attributeLocalName, attributeNs, attributeValue);
}
reader.MoveToElement();
}
var elementContent = reader.ReadInnerXml();
writer.WriteRaw(elementContent);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ModelBase"/> class.
/// <para />
/// Only constructor for the ModelBase.
/// </summary>
/// <param name="info">SerializationInfo object, null if this is the first time construction.</param>
/// <param name="context">StreamingContext object, simple pass a default new StreamingContext() if this is the first time construction.</param>
/// <remarks>
/// Call this method, even when constructing the object for the first time (thus not deserializing).
/// </remarks>
protected ModelBase(SerializationInfo info, StreamingContext context)
{
OnInitializing();
Initialize();
// Make sure this is not a first time call or custom call with null
if (info == null)
{
FinishInitializationAfterConstructionOrDeserialization();
}
else
{
_serializationInfo = info;
// Too bad we cannot put this in the BinarySerializer, but BinarySerialization works bottom => top. We
// do need the GraphId though, thus we are setting it here
var scopeName = SerializationContextHelper.GetSerializationReferenceManagerScopeName();
using (var scopeManager = ScopeManager <ReferenceManager> .GetScopeManager(scopeName))
{
var referenceManager = scopeManager.ScopeObject;
try
{
var graphId = (int)info.GetValue("GraphId", typeof(int));
referenceManager.RegisterManually(graphId, this);
}
catch (Exception)
{
// Swallow
}
}
}
OnInitialized();
}
/// <summary>
/// Deserializes the specified model from the json reader.
/// </summary>
/// <param name="modelType">Type of the model.</param>
/// <param name="jsonReader">The json reader.</param>
/// <param name="configuration">The configuration.</param>
/// <returns>
/// The model.
/// </returns>
public object Deserialize(Type modelType, JsonReader jsonReader, ISerializationConfiguration configuration)
{
Dictionary <string, JProperty> jsonProperties = null;
JArray jsonArray = null;
if (modelType.ImplementsInterfaceEx <ICustomJsonSerializable>())
{
var customModel = CreateModelInstance(modelType) as ICustomJsonSerializable;
if (customModel == null)
{
throw Log.ErrorAndCreateException <SerializationException>($"'{modelType.GetSafeFullName(false)}' implements ICustomJsonSerializable but could not be instantiated");
}
customModel.Deserialize(jsonReader);
return(customModel);
}
if (ShouldSerializeAsCollection(modelType))
{
jsonArray = JArray.Load(jsonReader);
}
else if (ShouldExternalSerializerHandleMember(modelType))
{
return(Convert.ChangeType(jsonReader.Value, modelType, CultureInfo.CurrentCulture));
}
else
{
if (jsonReader.TokenType == JsonToken.Null)
{
return(null);
}
var jsonObject = JObject.Load(jsonReader);
jsonProperties = jsonObject.Properties().ToDictionary(x => x.Name, x => x);
if (PreserveReferences)
{
if (jsonProperties.ContainsKey(GraphRefId))
{
var graphId = (int)jsonProperties[GraphRefId].Value;
var scopeName = SerializationContextHelper.GetSerializationReferenceManagerScopeName();
using (var scopeManager = ScopeManager <ReferenceManager> .GetScopeManager(scopeName))
{
var referenceManager = scopeManager.ScopeObject;
var referenceInfo = referenceManager.GetInfoById(graphId);
if (referenceInfo != null)
{
return(referenceInfo.Instance);
}
}
}
}
if (jsonProperties.ContainsKey(TypeName))
{
var modelTypeOverrideValue = (string)jsonProperties[TypeName].Value;
var modelTypeOverride = TypeCache.GetTypeWithoutAssembly(modelTypeOverrideValue);
if (modelTypeOverride == null)
{
Log.Warning("Object was serialized as '{0}', but the type is not available. Using original type '{1}'", modelTypeOverrideValue, modelType.GetSafeFullName(false));
}
else
{
modelType = modelTypeOverride;
}
}
}
var model = CreateModelInstance(modelType);
using (GetCurrentSerializationScopeManager(configuration))
{
configuration = GetCurrentSerializationConfiguration(configuration);
using (var context = GetContext(model, modelType, jsonReader, null, SerializationContextMode.Deserialization,
jsonProperties, jsonArray, configuration))
{
model = base.Deserialize(model, context.Context, configuration);
}
}
return(model);
}
