private bool TryDeserializeInternal(IDeserializerContext context, ICompositeStorage storage)
{
string typeName = storage.Get <string>(Name.TypeName);
if (!typeNameMapper.TryGet(typeName, out Type outputType))
{
return(false);
}
if (!storage.TryGet(Name.Payload, out ICompositeStorage childStorage))
{
return(false);
}
ICompositeModel model = modelFactory.Create(outputType) as ICompositeModel;
if (model == null)
{
return(false);
}
model.Load(childStorage);
context.Output = model;
return(true);
}
public object Deserialize(IDeserializerContext context)
{
T instance = FastActivator <T> .Create();
if (context.IsEmptyElement)
{
context.Read();
return(instance);
}
if (!context.Read())
{
return(instance);
}
while (context.NodeType != XmlNodeType.EndElement && context.NodeType != XmlNodeType.None)
{
if (context.NodeType == XmlNodeType.Element)
{
ReadProperty(context, instance);
continue;
}
if (!context.Read())
{
break;
}
}
context.ExitElement();
return(instance);
}
protected override object GetXmlObject(IDeserializerContext context, XmlReader reader)
{
if (HasContent(reader)) {
return XElement.Load(reader);
}
return null;
}
protected override bool TryLoad(Stream input, IDeserializerContext context, CompositeType type, ICompositeStorage storage)
{
if (base.TryLoad(input, context, type, storage))
{
ICompositeStorage payloadStorage = GetOrAddPayloadStorage(storage);
foreach (ICompositeFormatterExtender extender in extenders)
{
extender.Load(payloadStorage, context.Output);
}
IKeyValueCollection metadata;
ICompositeStorage metadataStorage;
if (context.TryGetEnvelopeMetadata(out metadata) && storage.TryGet(MetadataKey, out metadataStorage))
{
foreach (string key in metadataStorage.Keys)
{
metadata.Add(key, metadataStorage.Get <object>(key));
}
}
return(true);
}
return(false);
}
public override object ProcessFromDb(IDeserializerContext context, int column)
{
object result = base.ProcessFromDb(context, column);
if (result != null) {
switch (Type.GetTypeCode(result.GetType())) {
case TypeCode.String:
return Enum.Parse(Type, (string)result);
case TypeCode.Byte:
return Enum.ToObject(Type, (byte)result);
case TypeCode.SByte:
return Enum.ToObject(Type, (sbyte)result);
case TypeCode.UInt16:
return Enum.ToObject(Type, (ushort)result);
case TypeCode.Int16:
return Enum.ToObject(Type, (short)result);
case TypeCode.UInt32:
return Enum.ToObject(Type, (uint)result);
case TypeCode.Int32:
return Enum.ToObject(Type, (int)result);
case TypeCode.UInt64:
return Enum.ToObject(Type, (ulong)result);
case TypeCode.Int64:
return Enum.ToObject(Type, (long)result);
default:
result = Convert.ChangeType(result, underlyingType);
Debug.Assert(result != null);
return Enum.ToObject(Type, result);
}
}
return result;
}
protected override bool TryLoad(Stream input, IDeserializerContext context, CompositeType type, ICompositeStorage storage)
{
if (storage.TryGet("Count", out int count))
{
log.Debug($"Count '{count}'.");
Type listType = typeof(List <>).MakeGenericType(type.Type);
IList list = (IList)Activator.CreateInstance(listType);
log.Debug($"List: '{list != null}'.");
for (int i = 0; i < count; i++)
{
if (storage.TryGet(i.ToString(), out ICompositeStorage innerStorage) && base.TryLoad(input, context, type, innerStorage))
{
log.Debug($"Add item '{context.Output != null}'.");
list.Add(context.Output);
}
else
{
log.Error($"Item failed at index '{i}'.");
return(false);
}
}
context.Output = list;
return(true);
}
log.Debug($"Count not found.");
return(base.TryLoad(input, context, type, storage));
}
private void ReadItem(IDeserializerContext context, IDictionary <TKey, TValue> dictionary)
{
if (context.NodeType != XmlNodeType.Element || context.LocalName != "item")
{
throw new InvalidOperationException("Dictionary is not at an item element");
}
context.Read();
object key = context.Deserialize(context.Namespace);
object element = context.Deserialize(context.Namespace);
if (context.NodeType != XmlNodeType.EndElement || context.LocalName != "item")
{
throw new InvalidOperationException("Dictionary is not at the end of an item");
}
context.Read();
if (key != null)
{
dictionary.Add((TKey)key, (TValue)element);
}
}
protected override bool TryLoad(Stream input, IDeserializerContext context, CompositeType type, ICompositeStorage storage)
{
if (base.TryLoad(input, context, type, storage))
{
if (storage.TryGet("AggregateRootException", out ICompositeStorage inner))
{
AggregateRootExceptionDecorator decorator = new AggregateRootExceptionDecorator((AggregateRootException)context.Output);
IKey key = inner.Get <IKey>(Name.AggregateRootKey);
if (key != null)
{
decorator.SetKey(key);
}
key = inner.Get <IKey>(Name.CommandKey);
if (key != null)
{
decorator.SetCommandKey(key);
}
key = inner.Get <IKey>(Name.SourceCommandKey);
if (key != null)
{
decorator.SetSourceCommandKey(key);
}
}
return(true);
}
return(false);
}
public override object ProcessFromDb(IDeserializerContext context, int column)
{
object result = base.ProcessFromDb(context, column);
if (result != null) {
result = DateTime.SpecifyKind(Convert.ToDateTime(result), dateTimeKind);
}
return result;
}
public override sealed object ProcessFromDb(IDeserializerContext context, int column)
{
SqlXml xml = context.GetSqlXml(column);
if (!xml.IsNull) {
return ProcessXmlReader(context, xml.CreateReader());
}
return null;
}
public override object ProcessFromDb(IDeserializerContext context, int column)
{
object result = base.ProcessFromDb(context, column);
if ((result != null) && (!Type.IsAssignableFrom(result.GetType()))) {
result = Convert.ChangeType(result, Type);
}
return result;
}
public Task <bool> TryDeserializeAsync(Stream input, IDeserializerContext context)
{
return(Task.Factory.StartNew(() => RunWithCatch(() =>
{
XmlSerializer serializer = new XmlSerializer(context.OutputType);
object output = serializer.Deserialize(input);
context.Output = output;
})));
}
public bool TryDeserialize(Stream input, IDeserializerContext context)
{
Ensure.NotNull(context, "context");
return(RunWithCatch(() =>
{
XmlSerializer serializer = new XmlSerializer(context.OutputType);
object output = serializer.Deserialize(input);
context.Output = output;
}));
}
protected override object GetXmlObject(IDeserializerContext context, XmlReader reader)
{
if (HasContent(reader)) {
context.XmlDocument.Load(reader);
XmlElement result = context.XmlDocument.DocumentElement;
context.XmlDocument.RemoveAll();
return result;
}
return null;
}
public async Task <bool> TryDeserializeAsync(Stream input, IDeserializerContext context)
{
Ensure.NotNull(input, "input");
Ensure.NotNull(context, "context");
ICompositeStorage storage = storageFactory.Create();
await storage.LoadAsync(input).ConfigureAwait(false);
return(TryDeserializeInternal(context, storage));
}
private bool ListIsEmpty(IDeserializerContext context)
{
if (context.IsEmptyElement)
{
context.Read();
return(true);
}
return(false);
}
public object Deserialize(IDeserializerContext context)
{
var s = context.ReadElementAsString();
if (string.IsNullOrEmpty(s))
{
return(default(char));
}
return(XmlConvert.ToChar(s));
}
public bool TryDeserialize(Stream input, IDeserializerContext context)
{
Ensure.NotNull(input, "input");
Ensure.NotNull(context, "context");
ICompositeStorage storage = storageFactory.Create();
storage.Load(input);
return(TryDeserializeInternal(context, storage));
}
public bool TryDeserialize(Stream input, IDeserializerContext context)
{
Ensure.NotNull(context, "context");
//TODO: Catch exceptions.
using (StreamReader reader = new StreamReader(input))
{
string inputValue = reader.ReadToEnd();
context.Output = JsonConvert.DeserializeObject(inputValue, context.OutputType, settings);
}
return(true);
}
private Envelope WrapOutputInEnvelope(Type innerType, object output, IDeserializerContext context)
{
Envelope envelope = EnvelopeFactory.Create(output, innerType);
IKeyValueCollection metadata = context.GetEnvelopeMetadata();
foreach (string key in metadata.Keys)
{
envelope.Metadata.Add(key, metadata.Get <object>(key));
}
return(envelope);
}
public async Task <bool> TryDeserializeAsync(Stream input, IDeserializerContext context)
{
Ensure.NotNull(context, "context");
//TODO: Catch exceptions.
using (StreamReader reader = new StreamReader(input))
{
string inputValue = await reader.ReadToEndAsync();
context.Output = await Task.Factory.StartNew(() => JsonConvert.DeserializeObject(inputValue, context.OutputType, settings));
}
return(true);
}
public async Task <bool> TryDeserializeAsync(Stream input, IDeserializerContext context)
{
CompositeType type;
if (!provider.TryGet(context.OutputType, out type))
{
return(false);
}
ICompositeStorage storage = storageFactory.Create();
await storage.LoadAsync(input).ConfigureAwait(false);
return(TryLoad(input, context, type, storage));
}
public bool TryDeserialize(Stream input, IDeserializerContext context)
{
CompositeType type;
if (!provider.TryGet(context.OutputType, out type))
{
return(false);
}
ICompositeStorage storage = storageFactory.Create();
storage.Load(input);
return(TryLoad(input, context, type, storage));
}
public bool TryDeserialize(Stream input, IDeserializerContext context)
{
if (typeof(IList).IsAssignableFrom(context.OutputType))
{
DefaultDeserializerContext innerContext = new DefaultDeserializerContext(context.OutputType.GetGenericArguments()[0]);
if (inner.TryDeserialize(input, innerContext))
{
context.Output = innerContext.Output;
return(true);
}
return(false);
}
return(inner.TryDeserialize(input, context));
}
public async Task <bool> TryDeserializeAsync(Stream input, IDeserializerContext context)
{
DefaultDeserializerContext innerContext;
if (TryDeserializeEnvelope(input, context, out innerContext))
{
if (await inner.TryDeserializeAsync(input, innerContext))
{
context.Output = WrapOutputInEnvelope(innerContext.OutputType, innerContext.Output, innerContext);
return(true);
}
return(false);
}
return(await inner.TryDeserializeAsync(input, context));
}
public bool TryDeserialize(Stream input, IDeserializerContext context)
{
DefaultDeserializerContext innerContext;
if (TryDeserializeEnvelope(input, context, out innerContext))
{
if (inner.TryDeserialize(input, innerContext))
{
context.Output = WrapOutputInEnvelope(innerContext.OutputType, innerContext.Output, innerContext);
return(true);
}
return(false);
}
return(inner.TryDeserialize(input, context));
}
public async Task <bool> TryDeserializeAsync(Stream input, IDeserializerContext context)
{
Ensure.NotNull(input, "input");
Ensure.NotNull(context, "context");
ICompositeModel model = modelFactory.Invoke(context.OutputType) as ICompositeModel;
if (model == null)
{
return(false);
}
ICompositeStorage storage = storageFactory.Create();
await storage.LoadAsync(input).ConfigureAwait(false);
model.Load(storage);
context.Output = model;
return(true);
}
public bool TryDeserialize(Stream input, IDeserializerContext context)
{
Ensure.NotNull(input, "input");
Ensure.NotNull(context, "context");
ICompositeModel model = modelFactory.Invoke(context.OutputType) as ICompositeModel;
if (model == null)
{
return(false);
}
ICompositeStorage storage = storageFactory.Create();
storage.Load(input);
model.Load(storage);
context.Output = model;
return(true);
}
public object Deserialize(IDeserializerContext context)
{
string uriString = context.ReadElementAsString();
if (uriString == null)
{
return(null);
}
try
{
Uri uri = new Uri(uriString);
return(uri);
}
catch (UriFormatException ex)
{
throw new SerializationException("The Uri is in an invalid format: " + uriString, ex);
}
}
public object Deserialize(IDeserializerContext context)
{
Dictionary <TKey, TValue> dictionary = new Dictionary <TKey, TValue>();
if (DictionaryIsEmpty(context))
{
return(dictionary);
}
MoveToFirstElement(context);
while (context.NodeType != XmlNodeType.EndElement)
{
ReadItem(context, dictionary);
}
MovePastEndElement(context);
return(dictionary);
}
private void ReadProperty(IDeserializerContext context, T instance)
{
DeserializeObjectProperty <T> property;
if (_propertyCache.TryGetProperty(context.LocalName, out property))
{
object value = context.Deserialize(context.Namespace);
property.SetValue(instance, value);
}
else
{
if (_log.IsDebugEnabled)
{
_log.Debug("No property " + context.LocalName + " in class " + typeof(T).ToFriendlyName() + " for deserialization");
}
context.Deserialize(context.Namespace);
}
}
protected override bool TryLoad(Stream input, IDeserializerContext context, CompositeType type, ICompositeStorage storage)
{
if (!base.TryLoad(input, context, type, storage))
{
return(false);
}
ICompositeStorage payloadStorage;
GuidedObject guided = context.Output as GuidedObject;
if (guided != null && storage.TryGet(Name.Payload, out payloadStorage))
{
string guid;
if (payloadStorage.TryGet("Guid", out guid))
{
guided.Guid = guid;
}
}
return(true);
}
public bool TryDeserialize(Stream input, IDeserializerContext context)
{
Ensure.NotNull(context, "context");
string inputValue = null;
try
{
using (StreamReader reader = new StreamReader(input))
{
inputValue = reader.ReadToEnd();
context.Output = JsonConvert.DeserializeObject(inputValue, settings);
}
}
catch (JsonException e)
{
throw DeserializationFailed(inputValue, e);
}
return(true);
}
public async Task <bool> TryDeserializeAsync(Stream input, IDeserializerContext context)
{
Ensure.NotNull(context, "context");
string inputValue = null;
try
{
using (StreamReader reader = new StreamReader(input))
{
inputValue = await reader.ReadToEndAsync();
context.Output = await Task.Factory.StartNew(() => JsonConvert.DeserializeObject(inputValue, settings));
}
}
catch (JsonException e)
{
throw DeserializationFailed(inputValue, e);
}
return(true);
}
/// <summary>
/// Tries to load a object from the <paramref name="input"/> described by the <paramref name="type"/>.
/// </summary>
/// <param name="input">The serialized value to deserialize.</param>
/// <param name="context">The deserialization context.</param>
/// <param name="type">The composite type descriptor to load.</param>
/// <param name="storage">The composite storage with loaded values.</param>
/// <returns><c>true</c> if object was deserialized; <c>false</c> otherwise.</returns>
protected virtual bool TryLoad(Stream input, IDeserializerContext context, CompositeType type, ICompositeStorage storage)
{
int version;
if (!storage.TryGet(Name.Version, out version))
{
throw new MissingVersionValueException();
}
CompositeVersion typeVersion = GetCompositeVersion(type, version, context.OutputType);
ICompositeStorage valueStorage;
if (!storage.TryGet(Name.Payload, out valueStorage))
{
throw new MissingPayloadValueException();
}
List <object> values = new List <object>();
foreach (CompositeProperty property in typeVersion.Properties)
{
object value;
if (!TryLoadValue(valueStorage, property.Name, property.Type, out value))
{
throw new NotSupportedValueException(type.Type, property.Name, property.Type);
}
values.Add(value);
}
context.Output = typeVersion.Constructor.Factory(values.ToArray());
if (type.VersionProperty.Setter != null)
{
type.VersionProperty.Setter(context.Output, version);
}
return(true);
}
private bool TryDeserializeEnvelope(Stream input, IDeserializerContext context, out DefaultDeserializerContext innerContext)
{
if (typeof(Envelope).IsAssignableFrom(context.OutputType))
{
Type innerType = typeof(object);
if (context.OutputType.IsGenericType)
{
innerType = context.OutputType.GetGenericArguments()[0];
}
innerContext = new DefaultDeserializerContext(innerType);
foreach (string key in context.Metadata.Keys)
{
innerContext.Metadata.Add(key, context.Metadata.Get <object>(key));
}
innerContext.AddEnvelopeMetadata(new KeyValueCollection());
return(true);
}
innerContext = null;
return(false);
}
protected override sealed object ProcessXmlReader(IDeserializerContext context, XmlReader xmlReader)
{
using (xmlReader) {
return GetXmlObject(context, xmlReader);
}
}
protected virtual object ProcessXmlReader(IDeserializerContext context, XmlReader xmlReader)
{
return xmlReader;
}
public virtual object ProcessFromDb(IDeserializerContext context, int column)
{
object result = context.GetValue(column);
if (result == DBNull.Value) {
return null;
}
return result;
}
protected override object GetXmlObject(IDeserializerContext context, XmlReader reader)
{
XmlDocument doc = new XmlDocument(context.NameTable);
doc.Load(reader);
return doc;
}
protected override object GetXmlObject(IDeserializerContext context, XmlReader reader)
{
return new XPathDocument(reader);
}
protected abstract object GetXmlObject(IDeserializerContext context, XmlReader reader);
public override object ProcessFromDb(IDeserializerContext context, int column)
{
throw new NotSupportedException("Nested members need to be deserialized directly via SqlDeserializer");
}
