/// <summary>
/// Deserializes the member.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="memberValue">The member value.</param>
public override void DeserializeMember(ISerializationContext context, MemberValue memberValue)
{
var valueAsString = memberValue.Value as string;
if (!string.IsNullOrEmpty(valueAsString))
{
if (valueAsString.StartsWith(Prefix))
{
var splittedValues = valueAsString.Split(new[] { Splitter }, StringSplitOptions.None);
var keyValuePairType = typeof(KeyValuePair <,>);
var keyType = TypeCache.GetTypeWithoutAssembly(splittedValues[1], allowInitialization: false);
var valueType = TypeCache.GetTypeWithoutAssembly(splittedValues[2], allowInitialization: false);
var keyValue = splittedValues[3];
var valueValue = splittedValues[4];
// TODO: consider caching
var keyValuePairGenericType = keyValuePairType.MakeGenericType(keyType, valueType);
var key = StringToObjectHelper.ToRightType(keyType, keyValue);
var value = StringToObjectHelper.ToRightType(valueType, valueValue);
var keyValuePair = Activator.CreateInstance(keyValuePairGenericType, new [] { key, value });
memberValue.Value = keyValuePair;
}
}
base.DeserializeMember(context, memberValue);
}
public void ReturnsRightValueForValidValue()
{
var timespanValue = StringToObjectHelper.ToTimeSpan("1.23:12:21");
var expectedTimespan = new TimeSpan(1, 23, 12, 21);
Assert.AreEqual(expectedTimespan, timespanValue);
}
public static void LoadWindowSize(this Window window, bool restoreWindowState)
{
Argument.IsNotNull(() => window);
var windowName = window.GetType().Name;
Log.Debug($"Loading window size for '{windowName}'");
var storageFile = GetWindowStorageFile(window);
if (!File.Exists(storageFile))
{
Log.Debug($"Window size file '{storageFile}' does not exist, cannot restore window size");
return;
}
try
{
var sizeText = File.ReadAllText(storageFile);
if (string.IsNullOrWhiteSpace(sizeText))
{
Log.Warning($"Size text for window is empty, cannot restore window size");
return;
}
var splitted = sizeText.Split(new[] { SizeSeparator }, StringSplitOptions.RemoveEmptyEntries);
if (splitted.Length < 2)
{
Log.Warning($"Size text for window could not be splitted correctly, cannot restore window size");
return;
}
var culture = CultureInfo.InvariantCulture;
var width = StringToObjectHelper.ToDouble(splitted[0], culture);
var height = StringToObjectHelper.ToDouble(splitted[1], culture);
Log.Debug($"Setting window size for '{windowName}' to '{width} x {height}'");
window.SetCurrentValue(FrameworkElement.WidthProperty, width);
window.SetCurrentValue(FrameworkElement.HeightProperty, height);
if (restoreWindowState && splitted.Length > 2)
{
var windowState = Enum <WindowState> .Parse(splitted[2]);
if (windowState != window.WindowState)
{
Log.Debug($"Restoring window state for '{windowName}' to '{windowState}'");
window.SetCurrentValue(Window.WindowStateProperty, windowState);
}
}
}
catch (Exception ex)
{
Log.Warning(ex, $"Failed to load window size from file '{storageFile}'");
}
}
/// <summary>
/// Gets the log listener which this configuration represents.
/// </summary>
/// <param name="assembly">The assembly to load the product info from. If <c>null</c>, the entry assembly will be used.</param>
/// <returns>The <see cref="ILogListener"/>.</returns>
public ILogListener GetLogListener(Assembly assembly = null)
{
string typeAsString = ObjectToStringHelper.ToString(Type);
Log.Debug("Creating ILogListener based on configuration for type '{0}'", typeAsString);
ILogListener logListener = null;
var type = TypeCache.GetType(Type);
if (type == null)
{
string error = string.Format("Failed to retrieve type '{0}'", typeAsString);
Log.Error(error);
throw new InvalidOperationException(error);
}
var typeFactory = IoCConfiguration.DefaultTypeFactory;
logListener = typeFactory.CreateInstanceWithParametersAndAutoCompletion(type, assembly) as ILogListener;
if (logListener == null)
{
logListener = typeFactory.CreateInstance(type) as ILogListener;
}
if (logListener == null)
{
string error = string.Format("Failed to instantiate type '{0}' or it does not implement ILogListener and thus cannot be used as such", typeAsString);
Log.Error(error);
throw new InvalidOperationException(error);
}
foreach (var dynamicProperty in _dynamicProperties)
{
if (string.Equals(dynamicProperty.Key, TypePropertyName, StringComparison.InvariantCulture))
{
continue;
}
var propertyInfo = type.GetPropertyEx(dynamicProperty.Key);
if (propertyInfo == null)
{
Log.Warning("Property '{0}.{1}' cannot be found, make sure that it exists to load the value correctly", typeAsString, dynamicProperty.Key);
continue;
}
Log.Debug("Setting property '{0}' to value '{1}'", dynamicProperty.Key, ObjectToStringHelper.ToString(dynamicProperty.Value));
var propertyValue = StringToObjectHelper.ToRightType(propertyInfo.PropertyType, dynamicProperty.Value);
PropertyHelper.SetPropertyValue(logListener, dynamicProperty.Key, propertyValue);
}
Log.Debug("Created ILogListener based on configuration for type '{0}'", typeAsString);
return(logListener);
}
/// <summary>
/// Gets the configuration value.
/// </summary>
/// <typeparam name="T">The type of the value to retrieve.</typeparam>
/// <param name="key">The key.</param>
/// <param name="defaultValue">The default value. Will be returned if the value cannot be found.</param>
/// <returns>The configuration value.</returns>
/// <exception cref="ArgumentException">The <paramref name="key" /> is <c>null</c> or whitespace.</exception>
public T GetValue <T>(string key, T defaultValue = default(T))
{
Argument.IsNotNullOrWhitespace("key", key);
if (!ValueExists(key))
{
return(defaultValue);
}
var value = GetValueFromStore(key);
return((T)StringToObjectHelper.ToRightType(typeof(T), value));
}
/// <summary>
/// Gets the object from XML attribute.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="propertyData">The property data.</param>
/// <returns>Object or <c>null</c>.</returns>
private object GetObjectFromXmlAttribute(XmlReader reader, PropertyData propertyData)
{
reader.ReadAttributeValue();
var value = reader.Value;
try
{
return(StringToObjectHelper.ToRightType(propertyData.Type, value));
}
catch (Exception ex)
{
Log.Error(ex, "Failed to convert '{0}' to type '{1}', returning null", value, propertyData.Type.FullName);
return(null);
}
}
public override void DeserializeMember(ISerializationContext context, MemberValue memberValue)
{
base.DeserializeMember(context, memberValue);
if (!_serializeUsingParse)
{
if (memberValue.Name == "Vector")
{
var vectorString = (string)memberValue.Value;
var parsedValues = vectorString.Split(new[] { "|" }, StringSplitOptions.RemoveEmptyEntries);
memberValue.Value = new Vector(StringToObjectHelper.ToDouble(parsedValues[0]), StringToObjectHelper.ToDouble(parsedValues[1]),
StringToObjectHelper.ToDouble(parsedValues[2]));
}
}
}
private void UpdateContext(IContext targetContext, OptionDefinition optionDefinition, string value)
{
var propertyInfo = targetContext.GetType().GetPropertyEx(optionDefinition.PropertyNameOnContext);
if (optionDefinition.TrimQuotes)
{
if (!string.IsNullOrWhiteSpace(value))
{
value = value.Trim('\"');
}
}
var finalValue = StringToObjectHelper.ToRightType(propertyInfo.PropertyType, value);
propertyInfo.SetValue(targetContext, finalValue, null);
}
/// <summary>
/// Deserializes the member.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="memberValue">The member value.</param>
/// <returns>The <see cref="SerializationObject"/> representing the deserialized value or result.</returns>
protected override SerializationObject DeserializeMember(ISerializationContext <JsonSerializationContextInfo> context, MemberValue memberValue)
{
var serializationContext = context.Context;
var jsonProperties = serializationContext.JsonProperties;
if (jsonProperties != null)
{
if (PreserveReferences)
{
var graphRefIdPropertyName = string.Format("${0}_{1}", memberValue.NameForSerialization, GraphRefId);
if (jsonProperties.ContainsKey(graphRefIdPropertyName))
{
var graphId = (int)jsonProperties[graphRefIdPropertyName].Value;
var referenceManager = context.ReferenceManager;
var referenceInfo = referenceManager.GetInfoById(graphId);
if (referenceInfo == null)
{
Log.Error("Expected to find graph object with id '{0}' in ReferenceManager, but it was not found. Defaulting value for member '{1}' to null", graphId, memberValue.Name);
return(null);
}
return(SerializationObject.SucceededToDeserialize(context.ModelType, memberValue.MemberGroup, memberValue.Name, referenceInfo.Instance));
}
}
if (memberValue.MemberGroup == SerializationMemberGroup.Dictionary)
{
var dictionary = CreateModelInstance(memberValue.MemberType) as IDictionary;
var keyType = typeof(object);
var valueType = typeof(object);
if (memberValue.MemberType.IsGenericTypeEx())
{
var genericArguments = memberValue.MemberType.GetGenericArgumentsEx();
if (genericArguments.Length == 2)
{
keyType = genericArguments[0];
valueType = genericArguments[1];
}
}
foreach (var jsonPropertyKeyValuePair in jsonProperties)
{
var jsonProperty = jsonPropertyKeyValuePair.Value;
object deserializedItem = null;
object key = jsonProperty.Name;
if (keyType != typeof(object))
{
key = StringToObjectHelper.ToRightType(keyType, jsonProperty.Name);
}
var typeToDeserialize = valueType;
if (jsonProperty.Value != null)
{
if (jsonProperty.Value.Type != JTokenType.Object)
{
switch (jsonProperty.Value.Type)
{
case JTokenType.Integer:
typeToDeserialize = typeof(int);
break;
case JTokenType.Float:
typeToDeserialize = typeof(float);
break;
case JTokenType.String:
typeToDeserialize = typeof(string);
break;
case JTokenType.Boolean:
typeToDeserialize = typeof(bool);
break;
case JTokenType.Date:
typeToDeserialize = typeof(DateTime);
break;
case JTokenType.Guid:
typeToDeserialize = typeof(Guid);
break;
case JTokenType.Uri:
typeToDeserialize = typeof(Uri);
break;
case JTokenType.TimeSpan:
typeToDeserialize = typeof(TimeSpan);
break;
}
}
}
var shouldValueTypeBeHandledByExternalSerializer = ShouldExternalSerializerHandleMember(typeToDeserialize);
if (shouldValueTypeBeHandledByExternalSerializer)
{
deserializedItem = jsonProperty.Value.ToObject(valueType, serializationContext.JsonSerializer);
}
else
{
var reader = jsonProperty.Value.CreateReader(context.Configuration);
reader.Culture = context.Configuration.Culture;
deserializedItem = Deserialize(valueType, reader, context.Configuration);
}
dictionary[key] = deserializedItem;
}
return(SerializationObject.SucceededToDeserialize(context.ModelType, memberValue.MemberGroup, memberValue.Name, dictionary));
}
if (jsonProperties.ContainsKey(memberValue.NameForSerialization))
{
var jsonProperty = jsonProperties[memberValue.NameForSerialization];
var jsonValue = jsonProperty.Value;
if (jsonValue != null)
{
object finalMemberValue = null;
var valueType = memberValue.GetBestMemberType();
if (valueType.IsEnumEx())
{
var enumName = Enum.GetName(valueType, (int)jsonValue);
if (!string.IsNullOrWhiteSpace(enumName))
{
finalMemberValue = Enum.Parse(valueType, enumName, false);
}
}
else
{
try
{
var isDeserialized = false;
if (jsonValue.Type == JTokenType.String && ShouldSerializeUsingParseAndToString(memberValue, false))
{
var tempValue = memberValue.Value;
memberValue.Value = (string)jsonValue;
var parsedValue = DeserializeUsingObjectParse(context, memberValue);
if (parsedValue != null)
{
finalMemberValue = parsedValue;
isDeserialized = true;
}
else
{
memberValue.Value = tempValue;
}
}
if (!isDeserialized)
{
if (ShouldExternalSerializerHandleMember(memberValue))
{
finalMemberValue = jsonValue.ToObject(valueType, serializationContext.JsonSerializer);
}
else if (ShouldSerializeAsCollection(memberValue))
{
finalMemberValue = Deserialize(valueType, jsonProperty.Value.CreateReader(context.Configuration), context.Configuration);
}
else
{
if (jsonValue.HasValues)
{
var finalValueType = valueType;
var typeNameValue = jsonValue.Value <string>(TypeName);
if (!string.IsNullOrWhiteSpace(typeNameValue))
{
finalValueType = TypeCache.GetType(typeNameValue);
}
// Serialize ourselves
finalMemberValue = Deserialize(finalValueType, jsonValue.CreateReader(context.Configuration), context.Configuration);
}
}
}
}
catch (Exception ex)
{
Log.Debug(ex, "Failed to parse json value for '{0}', treating value as string", memberValue.Name);
// As a fallback, interpret as a string (might be a modifier)
finalMemberValue = (string)jsonValue;
}
}
if (finalMemberValue != null)
{
if (PreserveReferences && finalMemberValue.GetType().IsClassType())
{
var graphIdPropertyName = string.Format("${0}_{1}", memberValue.NameForSerialization, GraphId);
if (jsonProperties.ContainsKey(graphIdPropertyName))
{
var graphId = (int)jsonProperties[graphIdPropertyName].Value;
var referenceManager = context.ReferenceManager;
referenceManager.RegisterManually(graphId, finalMemberValue);
}
}
return(SerializationObject.SucceededToDeserialize(context.ModelType, memberValue.MemberGroup, memberValue.Name, finalMemberValue));
}
}
}
}
var shouldSerializeAsCollection = ShouldSerializeAsCollection(memberValue);
if (shouldSerializeAsCollection)
{
var collection = new List <object>();
var jArray = context.Context.JsonArray;
if (jArray != null)
{
var memberType = memberValue.GetBestMemberType();
var collectionItemType = memberType.GetCollectionElementType();
var shouldBeHandledByExternalSerializer = ShouldExternalSerializerHandleMember(collectionItemType);
foreach (var item in jArray.Children())
{
object deserializedItem = null;
if (shouldBeHandledByExternalSerializer)
{
deserializedItem = item.ToObject(collectionItemType, serializationContext.JsonSerializer);
}
else
{
deserializedItem = Deserialize(collectionItemType, item.CreateReader(context.Configuration), context.Configuration);
}
collection.Add(deserializedItem);
}
}
return(SerializationObject.SucceededToDeserialize(context.ModelType, memberValue.MemberGroup, memberValue.Name, collection));
}
return(SerializationObject.FailedToDeserialize(context.ModelType, memberValue.MemberGroup, memberValue.Name));
}
/// <summary>
/// Gets the object from XML element.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="element">The element.</param>
/// <param name="memberValue">The member value.</param>
/// <param name="modelType">Type of the model.</param>
/// <returns>Object or <c>null</c>.</returns>
/// <remarks>Note that this method can cause exceptions. The caller will handle them.</remarks>
private object GetObjectFromXmlElement(ISerializationContext <XmlSerializationContextInfo> context, XElement element, MemberValue memberValue, Type modelType)
{
object value = null;
string xmlName = element.Name.LocalName;
var propertyTypeToDeserialize = memberValue.Type;
var isNullAttribute = element.Attribute("IsNull");
var isNull = (isNullAttribute != null) ? StringToObjectHelper.ToBool(isNullAttribute.Value) : false;
if (isNull)
{
return(null);
}
var graphRefIdAttribute = element.Attribute(GraphRefId);
if (graphRefIdAttribute != null)
{
var graphId = int.Parse(graphRefIdAttribute.Value);
var referenceManager = context.ReferenceManager;
var referenceInfo = referenceManager.GetInfoById(graphId);
if (referenceInfo == null)
{
Log.Error("Expected to find graph object with id '{0}' in ReferenceManager, but it was not found. Defaulting value for member '{1}' to null", graphId, element.Name);
return(null);
}
return(referenceInfo.Instance);
}
var typeAttribute = element.Attribute("type"); // .GetAttribute("type", "http://catel.codeplex.com");
var attributeValue = (typeAttribute != null) ? typeAttribute.Value : null;
if (!string.IsNullOrEmpty(attributeValue))
{
var typeToDeserialize = TypeCache.GetTypeWithoutAssembly(attributeValue);
if (typeToDeserialize != null && propertyTypeToDeserialize != typeToDeserialize)
{
Log.Debug("Property type for property '{0}' is '{1}' but found type info that it should be deserialized as '{2}'",
memberValue.Name, memberValue.Type.FullName, attributeValue);
propertyTypeToDeserialize = typeToDeserialize;
}
else
{
Log.Warning("Property type for property '{0}' is '{1}' but found type info that it should be deserialized as '{2}'. Unfortunately the type cannot be found so the deserialization will probably fail.",
memberValue.Name, memberValue.Type.FullName, attributeValue);
}
}
var serializer = _dataContractSerializerFactory.GetDataContractSerializer(modelType, propertyTypeToDeserialize, xmlName, null, null);
using (var xmlReader = element.CreateReader())
{
value = serializer.ReadObject(xmlReader, false);
}
return(value);
}
/// <summary>
/// Gets the object from XML attribute.
/// </summary>
/// <remarks>
/// Note that this method can cause exceptions. The caller will handle them.
/// </remarks>
/// <param name="attribute">The attribute.</param>
/// <param name="memberValue">The property data.</param>
/// <returns>Object or <c>null</c>.</returns>
private object GetObjectFromXmlAttribute(XAttribute attribute, MemberValue memberValue)
{
var value = attribute.Value;
return(StringToObjectHelper.ToRightType(memberValue.Type, value));
}
public virtual void Deserialize(XmlReader xmlReader)
{
var propertyDataManager = PropertyDataManager.Default;
var type = GetType();
if (xmlReader != null)
{
if (xmlReader.ReadState == ReadState.Initial)
{
xmlReader.Read();
}
xmlReader.MoveToContent();
var parentNode = xmlReader.LocalName;
xmlReader.Read();
while (xmlReader.MoveToNextContentElement(parentNode))
{
var valueRead = false;
object value = null;
var elementName = xmlReader.LocalName;
// If simple property
var typeAttribute = xmlReader.GetAttribute("ctl:type");
if (typeAttribute is null)
{
// Fallback mechanism for older serialization formats, see https://github.com/Catel/Catel/issues/1535
typeAttribute = xmlReader.GetAttribute("type");
}
if (typeAttribute != null)
{
var elementType = TypeCache.GetTypeWithoutAssembly(typeAttribute);
if (elementType != null)
{
if (elementType != typeof(string) && !elementType.IsValueTypeEx())
{
var instance = Activator.CreateInstance(elementType);
// Complex object, use xml serializer
var xmlSerializer = GetXmlSerializer();
value = xmlSerializer.Deserialize(elementType, new XmlSerializationContextInfo(xmlReader, instance));
valueRead = true;
}
}
}
if (!valueRead)
{
value = xmlReader.ReadElementContentAsString();
valueRead = true;
}
var valueSet = false;
if (!DynamicProperties.Contains(elementName) && propertyDataManager.IsPropertyRegistered(type, elementName))
{
// If registered property, cast & set
var propertyData = propertyDataManager.GetPropertyData(type, elementName);
if (value is string stringValue)
{
value = StringToObjectHelper.ToRightType(propertyData.Type, stringValue);
}
SetValue(elementName, value);
valueSet = true;
}
if (!valueSet)
{
// Set dynamic value as string
RegisterConfigurationKey(elementName);
MarkConfigurationValueAsSet(elementName);
SetValue(elementName, value);
}
}
}
}
public void ReturnsRightValueForValidValue()
{
var enumValue = StringToObjectHelper.ToEnum("Value2", TestEnum.Value3);
Assert.AreEqual(TestEnum.Value2, enumValue);
}
public void ReturnsDefaultValueForInvalidValue()
{
var enumValue = StringToObjectHelper.ToEnum("bla", TestEnum.Value3);
Assert.AreEqual(TestEnum.Value3, enumValue);
}
/// <summary>
/// Converts from string to object.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="targetType">Type of the target.</param>
/// <param name="culture">The culture.</param>
/// <returns>System.Object.</returns>
/// <exception cref="System.NotImplementedException"></exception>
public object ConvertFromStringToObject(string value, Type targetType, CultureInfo culture)
{
return(StringToObjectHelper.ToRightType(targetType, value, culture));
}
public void SupportsEnum()
{
var enumValue = StringToObjectHelper.ToRightType(typeof(TestEnum), "Value3");
Assert.AreEqual(TestEnum.Value3, enumValue);
}
public void SupportsBoolean(string input, bool expectedValue)
{
var actualValue = StringToObjectHelper.ToRightType(typeof(bool), input);
Assert.AreEqual(expectedValue, actualValue);
}
/// <summary>
/// Converts the specified string value to an object.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="targetType">The target type.</param>
/// <returns>The object value.</returns>
public virtual object ConvertFromStringToObject(string value, Type targetType)
{
return(StringToObjectHelper.ToRightType(targetType, value));
}
public static void LoadWindowSize(this Window window, string tag = null, bool restoreWindowState = false, bool restoreWindowPosition = true)
{
Argument.IsNotNull(() => window);
var windowName = window.GetType().Name;
Log.Debug($"Loading window size for '{windowName}'");
var storageFile = GetWindowStorageFile(window, tag);
if (!File.Exists(storageFile))
{
Log.Debug($"Window size file '{storageFile}' does not exist, cannot restore window size");
return;
}
try
{
var sizeText = File.ReadAllText(storageFile);
if (string.IsNullOrWhiteSpace(sizeText))
{
Log.Warning($"Size text for window is empty, cannot restore window size");
return;
}
var splitted = sizeText.Split(new[] { SizeSeparator }, StringSplitOptions.RemoveEmptyEntries);
if (splitted.Length < 2)
{
Log.Warning($"Size text for window could not be splitted correctly, cannot restore window size");
return;
}
var culture = CultureInfo.InvariantCulture;
var width = StringToObjectHelper.ToDouble(splitted[0], culture);
var height = StringToObjectHelper.ToDouble(splitted[1], culture);
Log.Debug($"Setting window size for '{windowName}' to '{width} x {height}'");
window.SetCurrentValue(FrameworkElement.WidthProperty, width);
window.SetCurrentValue(FrameworkElement.HeightProperty, height);
if (restoreWindowState && splitted.Length > 2)
{
var windowState = Enum <WindowState> .Parse(splitted[2]);
if (windowState != window.WindowState)
{
Log.Debug($"Restoring window state for '{windowName}' to '{windowState}'");
window.SetCurrentValue(Window.WindowStateProperty, windowState);
}
}
if (restoreWindowPosition && splitted.Length > 3)
{
var left = StringToObjectHelper.ToDouble(splitted[3], culture);
var top = StringToObjectHelper.ToDouble(splitted[4], culture);
Log.Debug($"Restoring window position for '{windowName}' to '{left} (x) / {top} (y)'");
var virtualScreenLeft = SystemParameters.VirtualScreenLeft;
var virtualScreenTop = SystemParameters.VirtualScreenTop;
var virtualScreenWidth = SystemParameters.VirtualScreenWidth;
var virtualScreenHeight = SystemParameters.VirtualScreenHeight;
if (left < virtualScreenLeft ||
left + width > virtualScreenWidth ||
top < virtualScreenTop ||
top + height > virtualScreenHeight)
{
window.CenterWindowToParent();
return;
}
window.SetCurrentValue(Window.LeftProperty, left);
window.SetCurrentValue(Window.TopProperty, top);
}
}
catch (Exception ex)
{
Log.Warning(ex, $"Failed to load window size from file '{storageFile}'");
}
}
/// <summary>
/// Gets the object from XML element.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="element">The element.</param>
/// <param name="memberValue">The member value.</param>
/// <param name="modelType">Type of the model.</param>
/// <returns>Object or <c>null</c>.</returns>
/// <remarks>Note that this method can cause exceptions. The caller will handle them.</remarks>
private object GetObjectFromXmlElement(ISerializationContext <XmlSerializationContextInfo> context, XElement element, MemberValue memberValue, Type modelType)
{
object value = null;
var xmlName = element.Name.LocalName;
var propertyTypeToDeserialize = memberValue.MemberType;
var isNullAttribute = element.Attribute("IsNull");
var isNull = (isNullAttribute != null) ? StringToObjectHelper.ToBool(isNullAttribute.Value) : false;
if (isNull)
{
return(null);
}
var graphRefIdAttribute = element.Attribute(GraphRefId);
if (graphRefIdAttribute != null)
{
var graphId = int.Parse(graphRefIdAttribute.Value);
var referenceManager = context.ReferenceManager;
var referenceInfo = referenceManager.GetInfoById(graphId);
if (referenceInfo == null)
{
Log.Error("Expected to find graph object with id '{0}' in ReferenceManager, but it was not found. Defaulting value for member '{1}' to null", graphId, element.Name);
return(null);
}
return(referenceInfo.Instance);
}
var typeAttribute = element.Attribute("type"); // .GetAttribute("type", "http://catel.codeplex.com");
var attributeValue = (typeAttribute != null) ? typeAttribute.Value : null;
if (!string.IsNullOrEmpty(attributeValue))
{
var typeToDeserialize = TypeCache.GetTypeWithoutAssembly(attributeValue);
if (typeToDeserialize != null && propertyTypeToDeserialize != typeToDeserialize)
{
Log.Debug("Property type for property '{0}' is '{1}' but found type info that it should be deserialized as '{2}'",
memberValue.Name, memberValue.MemberType.FullName, attributeValue);
propertyTypeToDeserialize = typeToDeserialize;
}
else
{
Log.Warning("Property type for property '{0}' is '{1}' but found type info that it should be deserialized as '{2}'. Unfortunately the type cannot be found so the deserialization will probably fail.",
memberValue.Name, memberValue.MemberType.FullName, attributeValue);
}
}
var isDeserialized = false;
if (propertyTypeToDeserialize == typeof(string) && ShouldSerializeUsingParseAndToString(memberValue, false))
{
var tempValue = memberValue.Value;
memberValue.Value = element.Value;
var parsedValue = DeserializeUsingObjectParse(context, memberValue);
if (parsedValue != null)
{
value = parsedValue;
isDeserialized = true;
}
else
{
memberValue.Value = tempValue;
}
}
if (!isDeserialized && ShouldSerializeModelAsCollection(propertyTypeToDeserialize))
{
var collection = value as IList;
if (collection == null)
{
collection = CreateModelInstance(propertyTypeToDeserialize) as IList;
}
if (collection == null)
{
throw Log.ErrorAndCreateException <NotSupportedException>("Cannot deserialize type '{0}', it should implement IList in order to be deserialized", propertyTypeToDeserialize.GetSafeFullName(false));
}
var realCollectionType = collection.GetType();
var childElementType = realCollectionType.GetCollectionElementType();
if (childElementType == null)
{
throw Log.ErrorAndCreateException <NotSupportedException>("Cannot deserialize type '{0}', could not determine the element type of the collection", propertyTypeToDeserialize.GetSafeFullName(false));
}
var serializer = _dataContractSerializerFactory.GetDataContractSerializer(propertyTypeToDeserialize, childElementType, xmlName, null, null);
var childElements = element.Elements();
foreach (var childElement in childElements)
{
using (var xmlReader = childElement.CreateReader())
{
var childValue = serializer.ReadObject(xmlReader, false);
if (childValue != null)
{
collection.Add(childValue);
}
}
}
value = collection;
isDeserialized = true;
}
if (!isDeserialized)
{
var serializer = _dataContractSerializerFactory.GetDataContractSerializer(modelType, propertyTypeToDeserialize, xmlName, null, null);
using (var xmlReader = element.CreateReader())
{
value = serializer.ReadObject(xmlReader, false);
}
}
// Fix for CTL-555
var graphIdAttribute = element.Attribute(GraphId);
if (graphIdAttribute != null)
{
var graphId = int.Parse(graphIdAttribute.Value);
var referenceManager = context.ReferenceManager;
referenceManager.RegisterManually(graphId, value);
}
return(value);
}
