internal static object StringToType(
TypeConfig typeConfig,
string strType,
EmptyCtorDelegate ctorFn,
Dictionary <HashedStringSegment, TypeAccessor> typeAccessorMap) =>
StringToType(typeConfig, new StringSegment(strType), ctorFn, typeAccessorMap);
internal static object StringToType(
Type type,
string strType,
EmptyCtorDelegate ctorFn,
Dictionary<string, TypeAccessor> typeAccessorMap)
{
var index = 0;
if (strType == null)
return null;
//if (!Serializer.EatMapStartChar(strType, ref index))
if (strType[index++] != JsWriter.MapStartChar)
throw DeserializeTypeRef.CreateSerializationError(type, strType);
if (strType == JsWriter.EmptyMap) return ctorFn();
object instance = null;
var strTypeLength = strType.Length;
while (index < strTypeLength)
{
var propertyName = Serializer.EatMapKey(strType, ref index);
//Serializer.EatMapKeySeperator(strType, ref index);
index++;
var propertyValueStr = Serializer.EatValue(strType, ref index);
var possibleTypeInfo = propertyValueStr != null && propertyValueStr.Length > 1 && propertyValueStr[0] == '_';
if (possibleTypeInfo && propertyName == JsWriter.TypeAttr)
{
var typeName = Serializer.ParseString(propertyValueStr);
instance = ReflectionExtensions.CreateInstance(typeName);
if (instance == null)
{
Tracer.Instance.WriteWarning("Could not find type: " + propertyValueStr);
}
else
{
//If __type info doesn't match, ignore it.
if (!type.IsInstanceOfType(instance))
instance = null;
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
if (index != strType.Length) index++;
continue;
}
if (instance == null) instance = ctorFn();
TypeAccessor typeAccessor;
typeAccessorMap.TryGetValue(propertyName, out typeAccessor);
var propType = possibleTypeInfo ? TypeAccessor.ExtractType(Serializer, propertyValueStr) : null;
if (propType != null)
{
try
{
if (typeAccessor != null)
{
var parseFn = Serializer.GetParseFn(propType);
var propertyValue = parseFn(propertyValueStr);
typeAccessor.SetProperty(instance, propertyValue);
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
if (index != strType.Length) index++;
continue;
}
catch(Exception e)
{
if (JsConfig.ThrowOnDeserializationError) throw new SerializationException(String.Format("Failed to set dynamic property '{0}' with '{1}'", propertyName, propertyValueStr), e);
else Tracer.Instance.WriteWarning("WARN: failed to set dynamic property {0} with: {1}", propertyName, propertyValueStr);
}
}
if (typeAccessor != null && typeAccessor.GetProperty != null && typeAccessor.SetProperty != null)
{
try
{
var propertyValue = typeAccessor.GetProperty(propertyValueStr);
typeAccessor.SetProperty(instance, propertyValue);
}
catch(Exception e)
{
if (JsConfig.ThrowOnDeserializationError) throw new SerializationException(String.Format("Failed to set property '{0}' with '{1}'", propertyName, propertyValueStr), e);
else Tracer.Instance.WriteWarning("WARN: failed to set property {0} with: {1}", propertyName, propertyValueStr);
}
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
if (index != strType.Length) index++;
}
return instance;
}
static TypeMeta()
{
EmptyCtorFn = GetConstructorMethodToCache(typeof(T));
}
internal static object StringToType(ReadOnlySpan <char> strType,
TypeConfig typeConfig,
EmptyCtorDelegate ctorFn,
KeyValuePair <string, TypeAccessor>[] typeAccessors)
{
var index = 0;
var type = typeConfig.Type;
if (strType.IsEmpty)
{
return(null);
}
//if (!Serializer.EatMapStartChar(strType, ref index))
if (strType[index++] != JsWriter.MapStartChar)
{
throw DeserializeTypeRef.CreateSerializationError(type, strType.ToString());
}
if (JsonTypeSerializer.IsEmptyMap(strType))
{
return(ctorFn());
}
var config = JsConfig.GetConfig();
object instance = null;
var lenient = config.PropertyConvention == PropertyConvention.Lenient;
var strTypeLength = strType.Length;
while (index < strTypeLength)
{
var propertyName = Serializer.EatMapKey(strType, ref index).Trim();
//Serializer.EatMapKeySeperator(strType, ref index);
index++;
var propertyValueStr = Serializer.EatValue(strType, ref index);
var possibleTypeInfo = propertyValueStr != null && propertyValueStr.Length > 1;
if (possibleTypeInfo && propertyName.Equals(typeAttr.Span, StringComparison.OrdinalIgnoreCase))
{
var explicitTypeName = Serializer.ParseString(propertyValueStr);
var explicitType = config.TypeFinder(explicitTypeName);
if (explicitType == null || explicitType.IsInterface || explicitType.IsAbstract)
{
Tracer.Instance.WriteWarning("Could not find type: " + propertyValueStr.ToString());
}
else if (!type.IsAssignableFrom(explicitType))
{
Tracer.Instance.WriteWarning("Could not assign type: " + propertyValueStr.ToString());
}
else
{
JsWriter.AssertAllowedRuntimeType(explicitType);
instance = ActivatorUtils.FastCreateInstance(explicitType);
}
if (instance != null)
{
//If __type info doesn't match, ignore it.
if (!type.IsInstanceOfType(instance))
{
instance = null;
}
else
{
var derivedType = instance.GetType();
if (derivedType != type)
{
var map = DeserializeTypeRef.GetCachedTypeAccessors(derivedType, Serializer);
if (map != null)
{
typeAccessors = map;
}
}
}
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
if (index != strType.Length)
{
index++;
}
continue;
}
if (instance == null)
{
instance = ctorFn();
}
var typeAccessor = typeAccessors.Get(propertyName, lenient);
var propType = possibleTypeInfo && propertyValueStr[0] == '_' ? TypeAccessor.ExtractType(Serializer, propertyValueStr) : null;
if (propType != null)
{
try
{
if (typeAccessor != null)
{
var parseFn = Serializer.GetParseStringSpanFn(propType);
var propertyValue = parseFn(propertyValueStr);
if (typeConfig.OnDeserializing != null)
{
propertyValue = typeConfig.OnDeserializing(instance, propertyName.ToString(), propertyValue);
}
typeAccessor.SetProperty(instance, propertyValue);
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
if (index != strType.Length)
{
index++;
}
continue;
}
catch (Exception e)
{
config.OnDeserializationError?.Invoke(instance, propType, propertyName.ToString(), propertyValueStr.ToString(), e);
if (config.ThrowOnError)
{
throw DeserializeTypeRef.GetSerializationException(propertyName.ToString(), propertyValueStr.ToString(), propType, e);
}
else
{
Tracer.Instance.WriteWarning("WARN: failed to set dynamic property {0} with: {1}", propertyName.ToString(), propertyValueStr.ToString());
}
}
}
if (typeAccessor?.GetProperty != null && typeAccessor.SetProperty != null)
{
try
{
var propertyValue = typeAccessor.GetProperty(propertyValueStr);
if (typeConfig.OnDeserializing != null)
{
propertyValue = typeConfig.OnDeserializing(instance, propertyName.ToString(), propertyValue);
}
typeAccessor.SetProperty(instance, propertyValue);
}
catch (NotSupportedException) { throw; }
catch (Exception e)
{
config.OnDeserializationError?.Invoke(instance, propType ?? typeAccessor.PropertyType, propertyName.ToString(), propertyValueStr.ToString(), e);
if (config.ThrowOnError)
{
throw DeserializeTypeRef.GetSerializationException(propertyName.ToString(), propertyValueStr.ToString(), propType, e);
}
else
{
Tracer.Instance.WriteWarning("WARN: failed to set property {0} with: {1}", propertyName.ToString(), propertyValueStr.ToString());
}
}
}
else
{
// the property is not known by the DTO
typeConfig.OnDeserializing?.Invoke(instance, propertyName.ToString(), propertyValueStr.ToString());
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
if (index != strType.Length)
{
index++;
}
}
return(instance);
}
internal static object StringToType(
TypeConfig typeConfig,
string strType,
EmptyCtorDelegate ctorFn,
Dictionary <string, TypeAccessor> typeAccessorMap)
{
var index = 0;
var type = typeConfig.Type;
if (strType == null)
{
return(null);
}
//if (!Serializer.EatMapStartChar(strType, ref index))
if (strType[index++] != JsWriter.MapStartChar)
{
throw DeserializeTypeRef.CreateSerializationError(type, strType);
}
if (JsonTypeSerializer.IsEmptyMap(strType))
{
return(ctorFn());
}
object instance = null;
var strTypeLength = strType.Length;
while (index < strTypeLength)
{
var propertyName = Serializer.EatMapKey(strType, ref index);
//Serializer.EatMapKeySeperator(strType, ref index);
index++;
var propertyValueStr = Serializer.EatValue(strType, ref index);
var possibleTypeInfo = propertyValueStr != null && propertyValueStr.Length > 1;
if (possibleTypeInfo && propertyName == JsWriter.TypeAttr)
{
var explicitTypeName = Serializer.ParseString(propertyValueStr);
var explicitType = AssemblyUtils.FindType(explicitTypeName);
if (explicitType == null || explicitType.IsInterface() || explicitType.IsAbstract())
{
Tracer.Instance.WriteWarning("Could not find type: " + propertyValueStr);
}
else if (!type.IsAssignableFrom(explicitType))
{
Tracer.Instance.WriteWarning("Could not assign type: " + propertyValueStr);
}
else
{
instance = explicitType.CreateInstance();
}
if (instance != null)
{
var derivedType = instance.GetType();
if (derivedType != type)
{
var derivedTypeConfig = new TypeConfig(derivedType);
var map = DeserializeTypeRef.GetTypeAccessorMap(derivedTypeConfig, Serializer);
if (map != null)
{
typeAccessorMap = map;
}
}
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
if (index != strType.Length)
{
index++;
}
continue;
}
if (instance == null)
{
instance = ctorFn();
}
TypeAccessor typeAccessor;
typeAccessorMap.TryGetValue(propertyName, out typeAccessor);
var propType = possibleTypeInfo && propertyValueStr[0] == '_' ? TypeAccessor.ExtractType(Serializer, propertyValueStr) : null;
if (propType != null)
{
try
{
if (typeAccessor != null)
{
var parseFn = Serializer.GetParseFn(propType);
var propertyValue = parseFn(propertyValueStr);
if (typeConfig.OnDeserializing != null)
{
propertyValue = typeConfig.OnDeserializing(instance, propertyName, propertyValue);
}
typeAccessor.SetProperty(instance, propertyValue);
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
if (index != strType.Length)
{
index++;
}
continue;
}
catch (Exception e)
{
if (JsConfig.HasOnDeserializationErrorHandler)
{
JsConfig.OnDeserializationError(instance, propType, propertyName, propertyValueStr, e);
}
if (JsConfig.ThrowOnDeserializationError)
{
throw DeserializeTypeRef.GetSerializationException(propertyName, propertyValueStr, propType, e);
}
Tracer.Instance.WriteWarning("WARN: failed to set dynamic property {0} with: {1}", propertyName, propertyValueStr);
}
}
if (typeAccessor != null && typeAccessor.GetProperty != null && typeAccessor.SetProperty != null)
{
try
{
var propertyValue = typeAccessor.GetProperty(propertyValueStr);
if (typeConfig.OnDeserializing != null)
{
propertyValue = typeConfig.OnDeserializing(instance, propertyName, propertyValue);
}
typeAccessor.SetProperty(instance, propertyValue);
}
catch (Exception e)
{
if (JsConfig.HasOnDeserializationErrorHandler)
{
JsConfig.OnDeserializationError(instance, typeAccessor.PropertyType, propertyName, propertyValueStr, e);
}
if (JsConfig.ThrowOnDeserializationError)
{
throw DeserializeTypeRef.GetSerializationException(propertyName, propertyValueStr, typeAccessor.PropertyType, e);
}
Tracer.Instance.WriteWarning("WARN: failed to set property {0} with: {1}", propertyName, propertyValueStr);
}
}
else if (typeConfig.OnDeserializing != null)
{
// the property is not known by the DTO
typeConfig.OnDeserializing(instance, propertyName, propertyValueStr);
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
if (index != strType.Length)
{
index++;
}
}
return(instance);
}
internal static object StringToType(
Type type,
string strType,
EmptyCtorDelegate ctorFn,
Dictionary<string, TypeAccessor> typeAccessorMap)
{
var index = 0;
if (strType == null)
return null;
//if (!Serializer.EatMapStartChar(strType, ref index))
if (strType[index++] != JsWriter.MapStartChar)
throw DeserializeTypeRef.CreateSerializationError(type, strType);
if (JsonTypeSerializer.IsEmptyMap(strType)) return ctorFn();
object instance = null;
var propertyResolver = JsConfig.PropertyConvention == PropertyConvention.Lenient
? ParseUtils.LenientPropertyNameResolver
: ParseUtils.DefaultPropertyNameResolver;
var strTypeLength = strType.Length;
while (index < strTypeLength)
{
var propertyName = Serializer.EatMapKey(strType, ref index);
//Serializer.EatMapKeySeperator(strType, ref index);
index++;
var propertyValueStr = Serializer.EatValue(strType, ref index);
var possibleTypeInfo = propertyValueStr != null && propertyValueStr.Length > 1;
if (possibleTypeInfo && propertyName == JsWriter.TypeAttr)
{
var explicitTypeName = Serializer.ParseString(propertyValueStr);
var explicitType = AssemblyUtils.FindType(explicitTypeName);
if (explicitType != null && !explicitType.IsInterface() && !explicitType.IsAbstract())
{
instance = explicitType.CreateInstance();
}
if (instance == null)
{
Tracer.Instance.WriteWarning("Could not find type: " + propertyValueStr);
}
else
{
//If __type info doesn't match, ignore it.
if (!type.InstanceOfType(instance))
{
instance = null;
}
else
{
var derivedType = instance.GetType();
if (derivedType != type)
{
var derivedTypeConfig = new TypeConfig(derivedType);
var map = DeserializeTypeRef.GetTypeAccessorMap(derivedTypeConfig, Serializer);
if (map != null)
{
typeAccessorMap = map;
}
}
}
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
if (index != strType.Length) index++;
continue;
}
if (instance == null) instance = ctorFn();
var typeAccessor = propertyResolver.GetTypeAccessorForProperty(propertyName, typeAccessorMap);
var propType = possibleTypeInfo && propertyValueStr[0] == '_' ? TypeAccessor.ExtractType(Serializer, propertyValueStr) : null;
if (propType != null)
{
try
{
if (typeAccessor != null)
{
var parseFn = Serializer.GetParseFn(propType);
var propertyValue = parseFn(propertyValueStr);
typeAccessor.SetProperty(instance, propertyValue);
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
if (index != strType.Length) index++;
continue;
}
catch (Exception e)
{
if (JsConfig.ThrowOnDeserializationError) throw DeserializeTypeRef.GetSerializationException(propertyName, propertyValueStr, propType, e);
else Tracer.Instance.WriteWarning("WARN: failed to set dynamic property {0} with: {1}", propertyName, propertyValueStr);
}
}
if (typeAccessor != null && typeAccessor.GetProperty != null && typeAccessor.SetProperty != null)
{
try
{
var propertyValue = typeAccessor.GetProperty(propertyValueStr);
typeAccessor.SetProperty(instance, propertyValue);
}
catch (Exception e)
{
if (JsConfig.ThrowOnDeserializationError) throw DeserializeTypeRef.GetSerializationException(propertyName, propertyValueStr, propType, e);
else Tracer.Instance.WriteWarning("WARN: failed to set property {0} with: {1}", propertyName, propertyValueStr);
}
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
if (index != strType.Length) index++;
}
return instance;
}
private static object StringToType(Type type, string strType,
EmptyCtorDelegate ctorFn,
IDictionary <string, SetPropertyDelegate> setterMap,
IDictionary <string, ParseStringDelegate> parseStringFnMap)
{
var index = 0;
if (strType == null)
{
return(null);
}
if (!Serializer.EatMapStartChar(strType, ref index))
{
throw new SerializationException(string.Format(
"Type definitions should start with a '{0}', expecting serialized type '{1}', got string starting with: {2}",
JsWriter.MapStartChar, type.Name, strType.Substring(0, strType.Length < 50 ? strType.Length : 50)));
}
if (strType == JsWriter.EmptyMap)
{
return(ctorFn());
}
object instance = null;
string propertyName;
ParseStringDelegate parseStringFn;
SetPropertyDelegate setterFn;
var strTypeLength = strType.Length;
while (index < strTypeLength)
{
propertyName = Serializer.EatMapKey(strType, ref index);
Serializer.EatMapKeySeperator(strType, ref index);
var propertyValueString = Serializer.EatValue(strType, ref index);
if (propertyName == JsWriter.TypeAttr)
{
var typeName = Serializer.ParseString(propertyValueString);
instance = ReflectionExtensions.CreateInstance(typeName);
if (instance == null)
{
Tracer.Instance.WriteWarning("Could not find type: " + propertyValueString);
}
else
{
//If __type info doesn't match, ignore it.
if (!type.IsAssignableFrom(instance.GetType()))
{
instance = null;
}
}
Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
continue;
}
if (instance == null)
{
instance = ctorFn();
}
var propType = ExtractType(propertyValueString);
if (propType != null)
{
try
{
var parseFn = Serializer.GetParseFn(propType);
var propertyValue = parseFn(propertyValueString);
setterMap.TryGetValue(propertyName, out setterFn);
if (setterFn != null)
{
setterFn(instance, propertyValue);
}
Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
continue;
}
catch (Exception)
{
Tracer.Instance.WriteWarning("WARN: failed to set dynamic property {0} with: {1}", propertyName, propertyValueString);
}
}
parseStringFnMap.TryGetValue(propertyName, out parseStringFn);
if (parseStringFn != null)
{
try
{
var propertyValue = parseStringFn(propertyValueString);
setterMap.TryGetValue(propertyName, out setterFn);
if (setterFn != null)
{
setterFn(instance, propertyValue);
}
}
catch (Exception)
{
Tracer.Instance.WriteWarning("WARN: failed to set property {0} with: {1}", propertyName, propertyValueString);
}
}
Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
}
return(instance);
}
internal static object StringToType(
Type type,
string strType,
EmptyCtorDelegate ctorFn,
Dictionary<string, TypeAccessor> typeAccessorMap)
{
var index = 0;
if (strType == null)
return null;
//if (!Serializer.EatMapStartChar(strType, ref index))
for (; index < strType.Length; index++) { var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline
if (strType[index++] != JsWriter.MapStartChar)
throw DeserializeTypeRef.CreateSerializationError(type, strType);
if (strType == JsWriter.EmptyMap) return ctorFn();
object instance = null;
var strTypeLength = strType.Length;
while (index < strTypeLength)
{
var propertyName = JsonTypeSerializer.ParseJsonString(strType, ref index);
//Serializer.EatMapKeySeperator(strType, ref index);
for (; index < strType.Length; index++) { var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline
if (strType.Length != index) index++;
var propertyValueStr = Serializer.EatValue(strType, ref index);
var possibleTypeInfo = propertyValueStr != null && propertyValueStr.Length > 1 && propertyValueStr[0] == '_';
if (possibleTypeInfo && propertyName == JsWriter.TypeAttr)
{
var typeName = Serializer.ParseString(propertyValueStr);
instance = ReflectionExtensions.CreateInstance(typeName);
if (instance == null)
{
Tracer.Instance.WriteWarning("Could not find type: " + propertyValueStr);
}
else
{
//If __type info doesn't match, ignore it.
if (!type.IsInstanceOfType(instance))
instance = null;
}
Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
continue;
}
if (instance == null) instance = ctorFn();
TypeAccessor typeAccessor;
typeAccessorMap.TryGetValue(propertyName, out typeAccessor);
var propType = possibleTypeInfo ? TypeAccessor.ExtractType(Serializer, propertyValueStr) : null;
if (propType != null)
{
try
{
if (typeAccessor != null)
{
//var parseFn = Serializer.GetParseFn(propType);
var parseFn = JsonReader.GetParseFn(propType);
var propertyValue = parseFn(propertyValueStr);
typeAccessor.SetProperty(instance, propertyValue);
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
for (; index < strType.Length; index++) { var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline
if (index != strType.Length)
{
var success = strType[index] == JsWriter.ItemSeperator || strType[index] == JsWriter.MapEndChar;
index++;
if (success)
for (; index < strType.Length; index++) { var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline
}
continue;
}
catch
{
Tracer.Instance.WriteWarning("WARN: failed to set dynamic property {0} with: {1}", propertyName, propertyValueStr);
}
}
if (typeAccessor != null && typeAccessor.GetProperty != null && typeAccessor.SetProperty != null)
{
try
{
var propertyValue = typeAccessor.GetProperty(propertyValueStr);
typeAccessor.SetProperty(instance, propertyValue);
}
catch
{
Tracer.Instance.WriteWarning("WARN: failed to set property {0} with: {1}", propertyName, propertyValueStr);
}
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
for (; index < strType.Length; index++) { var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline
if (index != strType.Length)
{
var success = strType[index] == JsWriter.ItemSeperator || strType[index] == JsWriter.MapEndChar;
index++;
if (success)
for (; index < strType.Length; index++) { var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline
}
}
return instance;
}
internal static object StringToType(
TypeConfig typeConfig,
StringSegment strType,
EmptyCtorDelegate ctorFn,
Dictionary <HashedStringSegment, TypeAccessor> typeAccessorMap)
{
var index = 0;
var type = typeConfig.Type;
if (!strType.HasValue)
{
return(null);
}
//if (!Serializer.EatMapStartChar(strType, ref index))
if (strType.GetChar(index++) != JsWriter.MapStartChar)
{
throw DeserializeTypeRef.CreateSerializationError(type, strType.Value);
}
if (JsonTypeSerializer.IsEmptyMap(strType))
{
return(ctorFn());
}
object instance = null;
var propertyResolver = JsConfig.PropertyConvention == PropertyConvention.Lenient
? ParseUtils.LenientPropertyNameResolver
: ParseUtils.DefaultPropertyNameResolver;
var strTypeLength = strType.Length;
while (index < strTypeLength)
{
var propertyName = Serializer.EatMapKey(strType, ref index);
//Serializer.EatMapKeySeperator(strType, ref index);
index++;
var propertyValueStr = Serializer.EatValue(strType, ref index);
var possibleTypeInfo = propertyValueStr != null && propertyValueStr.Length > 1;
if (possibleTypeInfo && propertyName == new StringSegment(JsWriter.TypeAttr))
{
var explicitTypeName = Serializer.ParseString(propertyValueStr);
var explicitType = JsConfig.TypeFinder(explicitTypeName);
if (explicitType == null || explicitType.IsInterface || explicitType.IsAbstract)
{
Tracer.Instance.WriteWarning("Could not find type: " + propertyValueStr);
}
else if (!type.IsAssignableFrom(explicitType))
{
Tracer.Instance.WriteWarning("Could not assign type: " + propertyValueStr);
}
else
{
JsWriter.AssertAllowedRuntimeType(explicitType);
instance = explicitType.CreateInstance();
}
if (instance != null)
{
//If __type info doesn't match, ignore it.
if (!type.IsInstanceOfType(instance))
{
instance = null;
}
else
{
var derivedType = instance.GetType();
if (derivedType != type)
{
var derivedTypeConfig = new TypeConfig(derivedType);
var map = DeserializeTypeRef.GetTypeAccessorMap(derivedTypeConfig, Serializer);
if (map != null)
{
typeAccessorMap = map;
}
}
}
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
if (index != strType.Length)
{
index++;
}
continue;
}
if (instance == null)
{
instance = ctorFn();
}
var typeAccessor = propertyResolver.GetTypeAccessorForProperty(propertyName, typeAccessorMap);
var propType = possibleTypeInfo && propertyValueStr.GetChar(0) == '_' ? TypeAccessor.ExtractType(Serializer, propertyValueStr) : null;
if (propType != null)
{
try
{
if (typeAccessor != null)
{
var parseFn = Serializer.GetParseStringSegmentFn(propType);
var propertyValue = parseFn(propertyValueStr);
if (typeConfig.OnDeserializing != null)
{
propertyValue = typeConfig.OnDeserializing(instance, propertyName.Value, propertyValue);
}
typeAccessor.SetProperty(instance, propertyValue);
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
if (index != strType.Length)
{
index++;
}
continue;
}
catch (Exception e)
{
if (JsConfig.OnDeserializationError != null)
{
JsConfig.OnDeserializationError(instance, propType, propertyName.Value, propertyValueStr.Value, e);
}
if (JsConfig.ThrowOnDeserializationError)
{
throw DeserializeTypeRef.GetSerializationException(propertyName.Value, propertyValueStr.Value, propType, e);
}
else
{
Tracer.Instance.WriteWarning("WARN: failed to set dynamic property {0} with: {1}", propertyName, propertyValueStr);
}
}
}
if (typeAccessor?.GetProperty != null && typeAccessor.SetProperty != null)
{
try
{
var propertyValue = typeAccessor.GetProperty(propertyValueStr);
if (typeConfig.OnDeserializing != null)
{
propertyValue = typeConfig.OnDeserializing(instance, propertyName.Value, propertyValue);
}
typeAccessor.SetProperty(instance, propertyValue);
}
catch (NotSupportedException) { throw; }
catch (Exception e)
{
if (JsConfig.OnDeserializationError != null)
{
JsConfig.OnDeserializationError(instance, propType ?? typeAccessor.PropertyType, propertyName.Value, propertyValueStr.Value, e);
}
if (JsConfig.ThrowOnDeserializationError)
{
throw DeserializeTypeRef.GetSerializationException(propertyName.Value, propertyValueStr.Value, propType, e);
}
else
{
Tracer.Instance.WriteWarning("WARN: failed to set property {0} with: {1}", propertyName, propertyValueStr);
}
}
}
else
{
// the property is not known by the DTO
typeConfig.OnDeserializing?.Invoke(instance, propertyName.Value, propertyValueStr);
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
if (index != strType.Length)
{
index++;
}
}
return(instance);
}
private void ConstructEvaluator(IEnumerable <EvaluatorItem> items)
{
var codeCompiler = System.CodeDom.Compiler.CodeDomProvider.CreateProvider("CSharp");
var cp = new System.CodeDom.Compiler.CompilerParameters
{
GenerateExecutable = false,
GenerateInMemory = true,
};
Assemblies.ForEach(x => AddAssembly(cp, x.Location));
var code = StringBuilderCache.Allocate();
AssemblyNames.ForEach(x =>
code.AppendFormat("using {0};\n", x));
code.Append(
@"
namespace CSharpEval
{
public class _Expr
");
if (this.BaseType != null)
{
code.Append(" : " + GetTypeName(this.BaseType));
if (GenericArgs.Length > 0)
{
code.Append("<");
var i = 0;
foreach (var genericArg in GenericArgs)
{
if (i++ > 0)
{
code.Append(", ");
}
code.Append(GetTypeName(genericArg));
ReferenceTypesIfNotExist(cp, Assemblies, genericArg);
}
code.AppendLine(">");
}
ReferenceTypesIfNotExist(cp, Assemblies, this.BaseType);
}
code.AppendLine(" {");
AddPropertiesToTypeIfAny(code);
foreach (var item in items)
{
var sbParams = StringBuilderCacheAlt.Allocate();
foreach (var param in item.Params)
{
if (sbParams.Length > 0)
{
sbParams.Append(", ");
}
var typeName = GetTypeName(param.Value);
sbParams.AppendFormat("{0} {1}", typeName, param.Key);
var paramType = param.Value;
ReferenceAssembliesIfNotExists(cp, paramType, Assemblies);
}
var isVoid = item.ReturnType == typeof(void);
var returnType = isVoid ? "void" : GetTypeName(item.ReturnType);
code.AppendFormat(" public {0} {1}({2})",
returnType, item.Name, StringBuilderCacheAlt.ReturnAndFree(sbParams));
code.AppendLine(" {");
if (isVoid)
{
code.AppendFormat(" {0}; \n", item.Expression);
}
else
{
code.AppendFormat(" return ({0}); \n", item.Expression);
}
code.AppendLine(" }");
}
code.AppendLine(" }");
code.AppendLine("}");
if (IsVersion4AndUp)
{
if (!Env.IsMono)
{
cp.ReferencedAssemblies.Add(Env.ReferenceAssembyPath + @"System.Core.dll");
}
}
var src = StringBuilderCache.ReturnAndFree(code);
var compilerResults = codeCompiler.CompileAssemblyFromSource(cp, src);
if (compilerResults.Errors.HasErrors)
{
var error = StringBuilderCache.Allocate();
error.Append("Error Compiling Expression: ");
foreach (System.CodeDom.Compiler.CompilerError err in compilerResults.Errors)
{
error.AppendFormat("{0}\n", err.ErrorText);
}
throw new Exception(StringBuilderCache.ReturnAndFree(error));
}
compiledAssembly = compilerResults.CompiledAssembly;
compiled = compiledAssembly.CreateInstance("CSharpEval._Expr");
compiledType = compiled.GetType();
compiledTypeCtorFn = ReflectionExtensions.GetConstructorMethodToCache(compiledType);
}
internal static object StringToType(
Type type,
string strType,
EmptyCtorDelegate ctorFn,
Dictionary <string, TypeAccessor> typeAccessorMap)
{
var index = 0;
if (strType == null)
{
return(null);
}
//if (!Serializer.EatMapStartChar(strType, ref index))
if (strType[index++] != JsWriter.MapStartChar)
{
throw DeserializeTypeRef.CreateSerializationError(type, strType);
}
if (strType == JsWriter.EmptyMap)
{
return(ctorFn());
}
object instance = null;
var strTypeLength = strType.Length;
while (index < strTypeLength)
{
var propertyName = Serializer.EatMapKey(strType, ref index);
//Serializer.EatMapKeySeperator(strType, ref index);
index++;
var propertyValueStr = Serializer.EatValue(strType, ref index);
var possibleTypeInfo = propertyValueStr != null && propertyValueStr.Length > 1 && propertyValueStr[0] == '_';
if (possibleTypeInfo && propertyName == JsWriter.TypeAttr)
{
var typeName = Serializer.ParseString(propertyValueStr);
instance = ReflectionExtensions.CreateInstance(typeName);
if (instance == null)
{
Tracer.Instance.WriteWarning("Could not find type: " + propertyValueStr);
}
else
{
//If __type info doesn't match, ignore it.
if (!type.IsInstanceOfType(instance))
{
instance = null;
}
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
if (index != strType.Length)
{
index++;
}
continue;
}
if (instance == null)
{
instance = ctorFn();
}
TypeAccessor typeAccessor;
typeAccessorMap.TryGetValue(propertyName, out typeAccessor);
var propType = possibleTypeInfo ? TypeAccessor.ExtractType(Serializer, propertyValueStr) : null;
if (propType != null)
{
try
{
if (typeAccessor != null)
{
var parseFn = Serializer.GetParseFn(propType);
var propertyValue = parseFn(propertyValueStr);
typeAccessor.SetProperty(instance, propertyValue);
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
if (index != strType.Length)
{
index++;
}
continue;
}
catch
{
if (JsConfig.ThrowOnDeserializationError)
{
throw;
}
else
{
Tracer.Instance.WriteWarning("WARN: failed to set dynamic property {0} with: {1}", propertyName, propertyValueStr);
}
}
}
if (typeAccessor != null && typeAccessor.GetProperty != null && typeAccessor.SetProperty != null)
{
try
{
var propertyValue = typeAccessor.GetProperty(propertyValueStr);
typeAccessor.SetProperty(instance, propertyValue);
}
catch
{
if (JsConfig.ThrowOnDeserializationError)
{
throw;
}
else
{
Tracer.Instance.WriteWarning("WARN: failed to set property {0} with: {1}", propertyName, propertyValueStr);
}
}
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
if (index != strType.Length)
{
index++;
}
}
return(instance);
}
internal static object StringToType(ReadOnlySpan <char> strType,
TypeConfig typeConfig,
EmptyCtorDelegate ctorFn,
KeyValuePair <string, TypeAccessor>[] typeAccessors)
{
var index = 0;
var type = typeConfig.Type;
if (strType.IsEmpty)
{
return(null);
}
var buffer = strType;
var strTypeLength = strType.Length;
//if (!Serializer.EatMapStartChar(strType, ref index))
for (; index < strTypeLength; index++)
{
if (!JsonUtils.IsWhiteSpace(buffer[index]))
{
break;
}
} //Whitespace inline
if (buffer[index] != JsWriter.MapStartChar)
{
throw DeserializeTypeRef.CreateSerializationError(type, strType.ToString());
}
index++;
if (JsonTypeSerializer.IsEmptyMap(strType, index))
{
return(ctorFn());
}
var config = JsConfig.GetConfig();
object instance = null;
var lenient = config.PropertyConvention == PropertyConvention.Lenient;
for (; index < strTypeLength; index++)
{
if (!JsonUtils.IsWhiteSpace(buffer[index]))
{
break;
}
} //Whitespace inline
while (index < strTypeLength)
{
var propertyName = JsonTypeSerializer.UnescapeJsString(strType, JsonUtils.QuoteChar, removeQuotes: true, ref index);
//Serializer.EatMapKeySeperator(strType, ref index);
for (; index < strTypeLength; index++)
{
if (!JsonUtils.IsWhiteSpace(buffer[index]))
{
break;
}
} //Whitespace inline
if (strTypeLength != index)
{
index++;
}
var propertyValueStr = Serializer.EatValue(strType, ref index);
var possibleTypeInfo = propertyValueStr != null && propertyValueStr.Length > 1;
//if we already have an instance don't check type info, because then we will have a half deserialized object
//we could throw here or just use the existing instance.
if (instance == null && possibleTypeInfo && propertyName.Equals(typeAttr.Span, StringComparison.OrdinalIgnoreCase))
{
var explicitTypeName = Serializer.ParseString(propertyValueStr);
var explicitType = config.TypeFinder(explicitTypeName);
if (explicitType == null || explicitType.IsInterface || explicitType.IsAbstract)
{
Tracer.Instance.WriteWarning("Could not find type: " + propertyValueStr.ToString());
}
else if (!type.IsAssignableFrom(explicitType))
{
Tracer.Instance.WriteWarning("Could not assign type: " + propertyValueStr.ToString());
}
else
{
JsWriter.AssertAllowedRuntimeType(explicitType);
instance = explicitType.CreateInstance();
}
if (instance != null)
{
//If __type info doesn't match, ignore it.
if (!type.IsInstanceOfType(instance))
{
instance = null;
}
else
{
var derivedType = instance.GetType();
if (derivedType != type)
{
var map = DeserializeTypeRef.GetCachedTypeAccessors(derivedType, Serializer);
if (map != null)
{
typeAccessors = map;
}
}
}
}
Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
continue;
}
if (instance == null)
{
instance = ctorFn();
}
var typeAccessor = typeAccessors.Get(propertyName, lenient);
var propType = possibleTypeInfo && propertyValueStr[0] == '_' ? TypeAccessor.ExtractType(Serializer, propertyValueStr) : null;
if (propType != null)
{
try
{
if (typeAccessor != null)
{
//var parseFn = Serializer.GetParseFn(propType);
var parseFn = JsonReader.GetParseStringSpanFn(propType);
var propertyValue = parseFn(propertyValueStr);
if (typeConfig.OnDeserializing != null)
{
propertyValue = typeConfig.OnDeserializing(instance, propertyName.ToString(), propertyValue);
}
typeAccessor.SetProperty(instance, propertyValue);
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
for (; index < strTypeLength; index++)
{
if (!JsonUtils.IsWhiteSpace(buffer[index]))
{
break;
}
} //Whitespace inline
if (index != strTypeLength)
{
var success = buffer[index] == JsWriter.ItemSeperator || buffer[index] == JsWriter.MapEndChar;
index++;
if (success)
{
for (; index < strTypeLength; index++)
{
if (!JsonUtils.IsWhiteSpace(buffer[index]))
{
break;
}
} //Whitespace inline
}
}
continue;
}
catch (Exception e)
{
config.OnDeserializationError?.Invoke(instance, propType, propertyName.ToString(), propertyValueStr.ToString(), e);
if (config.ThrowOnError)
{
throw DeserializeTypeRef.GetSerializationException(propertyName.ToString(), propertyValueStr.ToString(), propType, e);
}
else
{
Tracer.Instance.WriteWarning("WARN: failed to set dynamic property {0} with: {1}", propertyName.ToString(), propertyValueStr.ToString());
}
}
}
if (typeAccessor?.GetProperty != null && typeAccessor.SetProperty != null)
{
try
{
var propertyValue = typeAccessor.GetProperty(propertyValueStr);
if (typeConfig.OnDeserializing != null)
{
propertyValue = typeConfig.OnDeserializing(instance, propertyName.ToString(), propertyValue);
}
typeAccessor.SetProperty(instance, propertyValue);
}
catch (NotSupportedException) { throw; }
catch (Exception e)
{
config.OnDeserializationError?.Invoke(instance, propType ?? typeAccessor.PropertyType, propertyName.ToString(), propertyValueStr.ToString(), e);
if (config.ThrowOnError)
{
throw DeserializeTypeRef.GetSerializationException(propertyName.ToString(), propertyValueStr.ToString(), typeAccessor.PropertyType, e);
}
else
{
Tracer.Instance.WriteWarning("WARN: failed to set property {0} with: {1}", propertyName.ToString(), propertyValueStr.ToString());
}
}
}
else
{
// the property is not known by the DTO
typeConfig.OnDeserializing?.Invoke(instance, propertyName.ToString(), propertyValueStr.ToString());
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
for (; index < strTypeLength; index++)
{
if (!JsonUtils.IsWhiteSpace(buffer[index]))
{
break;
}
} //Whitespace inline
if (index != strType.Length)
{
var success = buffer[index] == JsWriter.ItemSeperator || buffer[index] == JsWriter.MapEndChar;
index++;
if (success)
{
for (; index < strTypeLength; index++)
{
if (!JsonUtils.IsWhiteSpace(buffer[index]))
{
break;
}
} //Whitespace inline
}
}
}
return(instance);
}
internal static object StringToType(
Type type,
string strType,
EmptyCtorDelegate ctorFn,
Dictionary <string, TypeAccessor> typeAccessorMap)
{
var index = 0;
if (strType == null)
{
return(null);
}
//if (!Serializer.EatMapStartChar(strType, ref index))
if (strType[index++] != JsWriter.MapStartChar)
{
throw DeserializeTypeRef.CreateSerializationError(type, strType);
}
if (JsonTypeSerializer.IsEmptyMap(strType))
{
return(ctorFn());
}
object instance = null;
var propertyResolver = JsConfig.PropertyConvention == PropertyConvention.Lenient
? ParseUtils.LenientPropertyNameResolver
: ParseUtils.DefaultPropertyNameResolver;
var strTypeLength = strType.Length;
while (index < strTypeLength)
{
var propertyName = Serializer.EatMapKey(strType, ref index);
//Serializer.EatMapKeySeperator(strType, ref index);
index++;
var propertyValueStr = Serializer.EatValue(strType, ref index);
var possibleTypeInfo = propertyValueStr != null && propertyValueStr.Length > 1;
if (possibleTypeInfo && propertyName == JsWriter.TypeAttr)
{
var explicitTypeName = Serializer.ParseString(propertyValueStr);
var explicitType = JsConfig.TypeFinder(explicitTypeName);
if (explicitType != null && !explicitType.IsInterface() && !explicitType.IsAbstract())
{
instance = explicitType.CreateInstance();
}
if (instance == null)
{
Tracer.Instance.WriteWarning("Could not find type: " + propertyValueStr);
}
else
{
//If __type info doesn't match, ignore it.
if (!type.InstanceOfType(instance))
{
instance = null;
}
else
{
var derivedType = instance.GetType();
if (derivedType != type)
{
var derivedTypeConfig = new TypeConfig(derivedType);
var map = DeserializeTypeRef.GetTypeAccessorMap(derivedTypeConfig, Serializer);
if (map != null)
{
typeAccessorMap = map;
}
}
}
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
if (index != strType.Length)
{
index++;
}
continue;
}
if (instance == null)
{
instance = ctorFn();
}
var typeAccessor = propertyResolver.GetTypeAccessorForProperty(propertyName, typeAccessorMap);
var propType = possibleTypeInfo && propertyValueStr[0] == '_' ? TypeAccessor.ExtractType(Serializer, propertyValueStr) : null;
if (propType != null)
{
try
{
if (typeAccessor != null)
{
var parseFn = Serializer.GetParseFn(propType);
var propertyValue = parseFn(propertyValueStr);
typeAccessor.SetProperty(instance, propertyValue);
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
if (index != strType.Length)
{
index++;
}
continue;
}
catch (Exception e)
{
if (JsConfig.ThrowOnDeserializationError)
{
throw DeserializeTypeRef.GetSerializationException(propertyName, propertyValueStr, propType, e);
}
else
{
Tracer.Instance.WriteWarning("WARN: failed to set dynamic property {0} with: {1}", propertyName, propertyValueStr);
}
}
}
if (typeAccessor != null && typeAccessor.GetProperty != null && typeAccessor.SetProperty != null)
{
try
{
var propertyValue = typeAccessor.GetProperty(propertyValueStr);
typeAccessor.SetProperty(instance, propertyValue);
}
catch (Exception e)
{
if (JsConfig.ThrowOnDeserializationError)
{
throw DeserializeTypeRef.GetSerializationException(propertyName, propertyValueStr, propType, e);
}
else
{
Tracer.Instance.WriteWarning("WARN: failed to set property {0} with: {1}", propertyName, propertyValueStr);
}
}
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
if (index != strType.Length)
{
index++;
}
}
return(instance);
}
internal static object StringToType(
TypeConfig typeConfig,
string strType,
EmptyCtorDelegate ctorFn,
Dictionary<string, TypeAccessor> typeAccessorMap)
{
var index = 0;
var type = typeConfig.Type;
if (strType == null)
return null;
//if (!Serializer.EatMapStartChar(strType, ref index))
if (strType[index++] != JsWriter.MapStartChar)
throw DeserializeTypeRef.CreateSerializationError(type, strType);
if (JsonTypeSerializer.IsEmptyMap(strType)) return ctorFn();
object instance = null;
var strTypeLength = strType.Length;
while (index < strTypeLength)
{
var propertyName = Serializer.EatMapKey(strType, ref index);
//Serializer.EatMapKeySeperator(strType, ref index);
index++;
var propertyValueStr = Serializer.EatValue(strType, ref index);
var possibleTypeInfo = propertyValueStr != null && propertyValueStr.Length > 1;
if (possibleTypeInfo && propertyName == JsWriter.TypeAttr)
{
var explicitTypeName = Serializer.ParseString(propertyValueStr);
var explicitType = AssemblyUtils.FindType(explicitTypeName);
if (explicitType == null || explicitType.IsInterface() || explicitType.IsAbstract())
{
Tracer.Instance.WriteWarning("Could not find type: " + propertyValueStr);
}
else if (!type.IsAssignableFrom(explicitType))
{
Tracer.Instance.WriteWarning("Could not assign type: " + propertyValueStr);
}
else
{
instance = explicitType.CreateInstance();
}
if (instance != null)
{
var derivedType = instance.GetType();
if (derivedType != type)
{
var derivedTypeConfig = new TypeConfig(derivedType);
var map = DeserializeTypeRef.GetTypeAccessorMap(derivedTypeConfig, Serializer);
if (map != null)
{
typeAccessorMap = map;
}
}
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
if (index != strType.Length) index++;
continue;
}
if (instance == null) instance = ctorFn();
TypeAccessor typeAccessor;
typeAccessorMap.TryGetValue(propertyName, out typeAccessor);
var propType = possibleTypeInfo && propertyValueStr[0] == '_' ? TypeAccessor.ExtractType(Serializer, propertyValueStr) : null;
if (propType != null)
{
try
{
if (typeAccessor != null)
{
var parseFn = Serializer.GetParseFn(propType);
var propertyValue = parseFn(propertyValueStr);
if (typeConfig.OnDeserializing != null)
{
propertyValue = typeConfig.OnDeserializing(instance, propertyName, propertyValue);
}
typeAccessor.SetProperty(instance, propertyValue);
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
if (index != strType.Length) index++;
continue;
}
catch (Exception e)
{
if (JsConfig.HasOnDeserializationErrorHandler) JsConfig.OnDeserializationError(instance, propType, propertyName, propertyValueStr, e);
if (JsConfig.ThrowOnDeserializationError) throw DeserializeTypeRef.GetSerializationException(propertyName, propertyValueStr, propType, e);
Tracer.Instance.WriteWarning("WARN: failed to set dynamic property {0} with: {1}", propertyName, propertyValueStr);
}
}
if (typeAccessor != null && typeAccessor.GetProperty != null && typeAccessor.SetProperty != null)
{
try
{
var propertyValue = typeAccessor.GetProperty(propertyValueStr);
if (typeConfig.OnDeserializing != null)
{
propertyValue = typeConfig.OnDeserializing(instance, propertyName, propertyValue);
}
typeAccessor.SetProperty(instance, propertyValue);
}
catch (Exception e)
{
if (JsConfig.HasOnDeserializationErrorHandler) JsConfig.OnDeserializationError(instance, typeAccessor.PropertyType, propertyName, propertyValueStr, e);
if (JsConfig.ThrowOnDeserializationError) throw DeserializeTypeRef.GetSerializationException(propertyName, propertyValueStr, typeAccessor.PropertyType, e);
Tracer.Instance.WriteWarning("WARN: failed to set property {0} with: {1}", propertyName, propertyValueStr);
}
}
else if (typeConfig.OnDeserializing != null)
{
// the property is not known by the DTO
typeConfig.OnDeserializing(instance, propertyName, propertyValueStr);
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
if (index != strType.Length) index++;
}
return instance;
}
internal static object StringToType(
TypeConfig typeConfig,
StringSegment strType,
EmptyCtorDelegate ctorFn,
Dictionary <HashedStringSegment, TypeAccessor> typeAccessorMap)
{
var index = 0;
var type = typeConfig.Type;
if (!strType.HasValue)
{
return(null);
}
var buffer = strType.Buffer;
var offset = strType.Offset;
var strTypeLength = strType.Length;
//if (!Serializer.EatMapStartChar(strType, ref index))
for (; index < strTypeLength; index++)
{
if (!JsonUtils.IsWhiteSpace(buffer[offset + index]))
{
break;
}
} //Whitespace inline
if (buffer[offset + index] != JsWriter.MapStartChar)
{
throw DeserializeTypeRef.CreateSerializationError(type, strType.Value);
}
index++;
if (JsonTypeSerializer.IsEmptyMap(strType, index))
{
return(ctorFn());
}
object instance = null;
var propertyResolver = JsConfig.PropertyConvention == PropertyConvention.Lenient
? ParseUtils.LenientPropertyNameResolver
: ParseUtils.DefaultPropertyNameResolver;
while (index < strTypeLength)
{
var propertyName = JsonTypeSerializer.ParseJsonString(strType, ref index);
//Serializer.EatMapKeySeperator(strType, ref index);
for (; index < strTypeLength; index++)
{
if (!JsonUtils.IsWhiteSpace(buffer[offset + index]))
{
break;
}
} //Whitespace inline
if (strTypeLength != index)
{
index++;
}
var propertyValueStr = Serializer.EatValue(strType, ref index);
var possibleTypeInfo = propertyValueStr != null && propertyValueStr.Length > 1;
//if we already have an instance don't check type info, because then we will have a half deserialized object
//we could throw here or just use the existing instance.
if (instance == null && possibleTypeInfo && propertyName == typeAttr)
{
var explicitTypeName = Serializer.ParseString(propertyValueStr);
var explicitType = JsConfig.TypeFinder(explicitTypeName);
if (explicitType == null || explicitType.IsInterface() || explicitType.IsAbstract())
{
Tracer.Instance.WriteWarning("Could not find type: " + propertyValueStr);
}
else if (!type.IsAssignableFromType(explicitType))
{
Tracer.Instance.WriteWarning("Could not assign type: " + propertyValueStr);
}
else
{
JsWriter.AssertAllowedRuntimeType(explicitType);
instance = explicitType.CreateInstance();
}
if (instance != null)
{
//If __type info doesn't match, ignore it.
if (!type.InstanceOfType(instance))
{
instance = null;
}
else
{
var derivedType = instance.GetType();
if (derivedType != type)
{
var derivedTypeConfig = new TypeConfig(derivedType);
var map = DeserializeTypeRef.GetTypeAccessorMap(derivedTypeConfig, Serializer);
if (map != null)
{
typeAccessorMap = map;
}
}
}
}
Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
continue;
}
if (instance == null)
{
instance = ctorFn();
}
var typeAccessor = propertyResolver.GetTypeAccessorForProperty(propertyName, typeAccessorMap);
var propType = possibleTypeInfo && propertyValueStr.GetChar(0) == '_' ? TypeAccessor.ExtractType(Serializer, propertyValueStr) : null;
if (propType != null)
{
try
{
if (typeAccessor != null)
{
//var parseFn = Serializer.GetParseFn(propType);
var parseFn = JsonReader.GetParseStringSegmentFn(propType);
var propertyValue = parseFn(propertyValueStr);
if (typeConfig.OnDeserializing != null)
{
propertyValue = typeConfig.OnDeserializing(instance, propertyName.Value, propertyValue);
}
typeAccessor.SetProperty(instance, propertyValue);
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
for (; index < strTypeLength; index++)
{
if (!JsonUtils.IsWhiteSpace(buffer[offset + index]))
{
break;
}
} //Whitespace inline
if (index != strTypeLength)
{
var success = buffer[offset + index] == JsWriter.ItemSeperator || buffer[offset + index] == JsWriter.MapEndChar;
index++;
if (success)
{
for (; index < strTypeLength; index++)
{
if (!JsonUtils.IsWhiteSpace(buffer[offset + index]))
{
break;
}
} //Whitespace inline
}
}
continue;
}
catch (Exception e)
{
if (JsConfig.OnDeserializationError != null)
{
JsConfig.OnDeserializationError(instance, propType, propertyName.Value, propertyValueStr.Value, e);
}
if (JsConfig.ThrowOnDeserializationError)
{
throw DeserializeTypeRef.GetSerializationException(propertyName.Value, propertyValueStr.Value, propType, e);
}
else
{
Tracer.Instance.WriteWarning("WARN: failed to set dynamic property {0} with: {1}", propertyName, propertyValueStr.Value);
}
}
}
if (typeAccessor?.GetProperty != null && typeAccessor.SetProperty != null)
{
try
{
var propertyValue = typeAccessor.GetProperty(propertyValueStr);
if (typeConfig.OnDeserializing != null)
{
propertyValue = typeConfig.OnDeserializing(instance, propertyName.Value, propertyValue);
}
typeAccessor.SetProperty(instance, propertyValue);
}
catch (NotSupportedException) { throw; }
catch (Exception e)
{
if (JsConfig.OnDeserializationError != null)
{
JsConfig.OnDeserializationError(instance, propType ?? typeAccessor.PropertyType, propertyName.Value, propertyValueStr.Value, e);
}
if (JsConfig.ThrowOnDeserializationError)
{
throw DeserializeTypeRef.GetSerializationException(propertyName.Value, propertyValueStr.Value, typeAccessor.PropertyType, e);
}
else
{
Tracer.Instance.WriteWarning("WARN: failed to set property {0} with: {1}", propertyName, propertyValueStr.Value);
}
}
}
else
{
// the property is not known by the DTO
typeConfig.OnDeserializing?.Invoke(instance, propertyName.Value, propertyValueStr.Value);
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
for (; index < strTypeLength; index++)
{
if (!JsonUtils.IsWhiteSpace(buffer[offset + index]))
{
break;
}
} //Whitespace inline
if (index != strType.Length)
{
var success = buffer[offset + index] == JsWriter.ItemSeperator || buffer[offset + index] == JsWriter.MapEndChar;
index++;
if (success)
{
for (; index < strTypeLength; index++)
{
if (!JsonUtils.IsWhiteSpace(buffer[offset + index]))
{
break;
}
} //Whitespace inline
}
}
}
return(instance);
}
private void ConstructEvaluator(IEnumerable <EvaluatorItem> items)
{
//var codeCompiler = new CSharpCodeProvider(new Dictionary<string, string> { { "CompilerVersion", "v3.5" } });
var codeCompiler = CodeDomProvider.CreateProvider("CSharp");
var cp = new CompilerParameters //(new[] { "mscorlib.dll", "system.core.dll" })
{
GenerateExecutable = false,
GenerateInMemory = true,
};
Assemblies.ForEach(x => AddAssembly(cp, x.Location));
var code = new StringBuilder();
AssemblyNames.ForEach(x =>
code.AppendFormat("using {0};\n", x));
code.Append(
@"
namespace CSharpEval
{
public class _Expr
");
if (this.BaseType != null)
{
code.Append(" : " + GetTypeName(this.BaseType));
if (GenericArgs.Length > 0)
{
code.Append("<");
var i = 0;
foreach (var genericArg in GenericArgs)
{
if (i++ > 0)
{
code.Append(", ");
}
code.Append(GetTypeName(genericArg));
ReferenceTypesIfNotExist(cp, Assemblies, genericArg);
}
code.AppendLine(">");
}
ReferenceTypesIfNotExist(cp, Assemblies, this.BaseType);
}
code.AppendLine(" {");
AddPropertiesToTypeIfAny(code);
foreach (var item in items)
{
var sbParams = new StringBuilder();
foreach (var param in item.Params)
{
if (sbParams.Length > 0)
{
sbParams.Append(", ");
}
var typeName = GetTypeName(param.Value);
sbParams.AppendFormat("{0} {1}", typeName, param.Key);
var paramType = param.Value;
ReferenceAssembliesIfNotExists(cp, paramType, Assemblies);
}
var isVoid = item.ReturnType == typeof(void);
var returnType = isVoid ? "void" : GetTypeName(item.ReturnType);
code.AppendFormat(" public {0} {1}({2})",
returnType, item.Name, sbParams);
code.AppendLine(" {");
if (isVoid)
{
code.AppendFormat(" {0}; \n", item.Expression);
}
else
{
code.AppendFormat(" return ({0}); \n", item.Expression);
}
code.AppendLine(" }");
}
code.AppendLine(" }");
code.AppendLine("}");
if (IsVersion4AndUp)
{
//var type = Type.GetType("System.Collections.Concurrent.Partitioner");
//if (type != null)
// cp.ReferencedAssemblies.Add(type.Assembly.Location);
if (!Env.IsMono)
{
//cp.ReferencedAssemblies.Add(@"C:\Windows\Microsoft.NET\Framework\v2.0.50727\System.dll");
cp.ReferencedAssemblies.Add(@"C:\Program Files\Reference Assemblies\Microsoft\Framework\v3.5\System.Core.dll");
}
}
var src = code.ToString();
var compilerResults = codeCompiler.CompileAssemblyFromSource(cp, src);
if (compilerResults.Errors.HasErrors)
{
var error = new StringBuilder();
error.Append("Error Compiling Expression: ");
foreach (CompilerError err in compilerResults.Errors)
{
error.AppendFormat("{0}\n", err.ErrorText);
}
throw new Exception("Error Compiling Expression: " + error);
}
compiledAssembly = compilerResults.CompiledAssembly;
compiled = compiledAssembly.CreateInstance("CSharpEval._Expr");
compiledType = compiled.GetType();
compiledTypeCtorFn = Text.ReflectionExtensions.GetConstructorMethodToCache(compiledType);
}
internal static object StringToType(
Type type,
string strType,
EmptyCtorDelegate ctorFn,
Dictionary <string, TypeAccessor> typeAccessorMap)
{
var index = 0;
if (strType == null)
{
return(null);
}
//if (!Serializer.EatMapStartChar(strType, ref index))
for (; index < strType.Length; index++)
{
var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c])
{
break;
}
} //Whitespace inline
if (strType[index++] != JsWriter.MapStartChar)
{
throw DeserializeTypeRef.CreateSerializationError(type, strType);
}
if (JsonTypeSerializer.IsEmptyMap(strType))
{
return(ctorFn());
}
object instance = null;
var strTypeLength = strType.Length;
while (index < strTypeLength)
{
var propertyName = JsonTypeSerializer.ParseJsonString(strType, ref index);
//Serializer.EatMapKeySeperator(strType, ref index);
for (; index < strType.Length; index++)
{
var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c])
{
break;
}
} //Whitespace inline
if (strType.Length != index)
{
index++;
}
var propertyValueStr = Serializer.EatValue(strType, ref index);
var possibleTypeInfo = propertyValueStr != null && propertyValueStr.Length > 1;
if (possibleTypeInfo && propertyName == JsWriter.TypeAttr)
{
var explicitTypeName = Serializer.ParseString(propertyValueStr);
var explicitType = Type.GetType(explicitTypeName);
if (explicitType != null && !explicitType.IsInterface && !explicitType.IsAbstract)
{
instance = explicitType.CreateInstance();
}
if (instance == null)
{
Tracer.Instance.WriteWarning("Could not find type: " + propertyValueStr);
}
else
{
//If __type info doesn't match, ignore it.
if (!type.IsInstanceOfType(instance))
{
instance = null;
}
else
{
var derivedType = instance.GetType();
if (derivedType != type)
{
var derivedTypeConfig = new TypeConfig(derivedType);
var map = DeserializeTypeRef.GetTypeAccessorMap(derivedTypeConfig, Serializer);
if (map != null)
{
typeAccessorMap = map;
}
}
}
}
Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
continue;
}
if (instance == null)
{
instance = ctorFn();
}
TypeAccessor typeAccessor;
typeAccessorMap.TryGetValue(propertyName, out typeAccessor);
var propType = possibleTypeInfo && propertyValueStr[0] == '_' ? TypeAccessor.ExtractType(Serializer, propertyValueStr) : null;
if (propType != null)
{
try
{
if (typeAccessor != null)
{
//var parseFn = Serializer.GetParseFn(propType);
var parseFn = JsonReader.GetParseFn(propType);
var propertyValue = parseFn(propertyValueStr);
typeAccessor.SetProperty(instance, propertyValue);
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
for (; index < strType.Length; index++)
{
var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c])
{
break;
}
} //Whitespace inline
if (index != strType.Length)
{
var success = strType[index] == JsWriter.ItemSeperator || strType[index] == JsWriter.MapEndChar;
index++;
if (success)
{
for (; index < strType.Length; index++)
{
var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c])
{
break;
}
} //Whitespace inline
}
}
continue;
}
catch (Exception e)
{
if (JsConfig.ThrowOnDeserializationError)
{
throw DeserializeTypeRef.GetSerializationException(propertyName, propertyValueStr, propType, e);
}
else
{
Tracer.Instance.WriteWarning("WARN: failed to set dynamic property {0} with: {1}", propertyName, propertyValueStr);
}
}
}
if (typeAccessor != null && typeAccessor.GetProperty != null && typeAccessor.SetProperty != null)
{
try
{
var propertyValue = typeAccessor.GetProperty(propertyValueStr);
typeAccessor.SetProperty(instance, propertyValue);
}
catch (Exception e)
{
if (JsConfig.ThrowOnDeserializationError)
{
throw DeserializeTypeRef.GetSerializationException(propertyName, propertyValueStr, typeAccessor.PropertyType, e);
}
else
{
Tracer.Instance.WriteWarning("WARN: failed to set property {0} with: {1}", propertyName, propertyValueStr);
}
}
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
for (; index < strType.Length; index++)
{
var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c])
{
break;
}
} //Whitespace inline
if (index != strType.Length)
{
var success = strType[index] == JsWriter.ItemSeperator || strType[index] == JsWriter.MapEndChar;
index++;
if (success)
{
for (; index < strType.Length; index++)
{
var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c])
{
break;
}
} //Whitespace inline
}
}
}
return(instance);
}
public StringToTypeContext(TypeConfig typeConfig, EmptyCtorDelegate ctorFn, KeyValuePair <string, TypeAccessor>[] accessors)
{
this.typeConfig = typeConfig;
this.ctorFn = ctorFn;
this.accessors = accessors;
}
internal static object StringToType(
Type type,
string strType,
EmptyCtorDelegate ctorFn,
Dictionary<string, TypeAccessor> typeAccessorMap)
{
var index = 0;
if (strType == null)
return null;
//if (!Serializer.EatMapStartChar(strType, ref index))
for (; index < strType.Length; index++) { var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline
if (strType[index++] != JsWriter.MapStartChar)
throw DeserializeTypeRef.CreateSerializationError(type, strType);
if (JsonTypeSerializer.IsEmptyMap(strType, index)) return ctorFn();
object instance = null;
var strTypeLength = strType.Length;
while (index < strTypeLength)
{
var propertyName = JsonTypeSerializer.ParseJsonString(strType, ref index);
//Serializer.EatMapKeySeperator(strType, ref index);
for (; index < strType.Length; index++) { var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline
if (strType.Length != index) index++;
var propertyValueStr = Serializer.EatValue(strType, ref index);
var possibleTypeInfo = propertyValueStr != null && propertyValueStr.Length > 1;
//if we already have an instance don't check type info, because then we will have a half deserialized object
//we could throw here or just use the existing instance.
if (instance == null && possibleTypeInfo && propertyName == JsWriter.TypeAttr)
{
var explicitTypeName = Serializer.ParseString(propertyValueStr);
var explicitType = AssemblyUtils.FindType(explicitTypeName);
#if NETFX_CORE
if (explicitType != null && !explicitType.GetTypeInfo().IsInterface && !explicitType.GetTypeInfo().IsAbstract)
#else
if (explicitType != null && !explicitType.IsInterface && !explicitType.IsAbstract)
#endif
{
instance = explicitType.CreateInstance();
}
if (instance == null)
{
Tracer.Instance.WriteWarning("Could not find type: " + propertyValueStr);
}
else
{
//If __type info doesn't match, ignore it.
#if NETFX_CORE
if (!type.IsInstanceOf(instance.GetType()))
#else
if (!type.IsInstanceOfType(instance))
#endif
{
instance = null;
}
else
{
var derivedType = instance.GetType();
if (derivedType != type)
{
var derivedTypeConfig = new TypeConfig(derivedType);
var map = DeserializeTypeRef.GetTypeAccessorMap(derivedTypeConfig, Serializer);
if (map != null)
{
typeAccessorMap = map;
}
}
}
}
Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
continue;
}
if (instance == null) instance = ctorFn();
var typeAccessor = PropertyNameResolver.GetTypeAccessorForProperty(propertyName, typeAccessorMap);
var propType = possibleTypeInfo && propertyValueStr[0] == '_' ? TypeAccessor.ExtractType(Serializer, propertyValueStr) : null;
if (propType != null)
{
try
{
if (typeAccessor != null)
{
//var parseFn = Serializer.GetParseFn(propType);
var parseFn = JsonReader.GetParseFn(propType);
var propertyValue = parseFn(propertyValueStr);
typeAccessor.SetProperty(instance, propertyValue);
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
for (; index < strType.Length; index++) { var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline
if (index != strType.Length)
{
var success = strType[index] == JsWriter.ItemSeperator || strType[index] == JsWriter.MapEndChar;
index++;
if (success)
for (; index < strType.Length; index++) { var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline
}
continue;
}
catch (Exception e)
{
if (JsConfig.ThrowOnDeserializationError) throw DeserializeTypeRef.GetSerializationException(propertyName, propertyValueStr, propType, e);
else Tracer.Instance.WriteWarning("WARN: failed to set dynamic property {0} with: {1}", propertyName, propertyValueStr);
}
}
if (typeAccessor != null && typeAccessor.GetProperty != null && typeAccessor.SetProperty != null)
{
try
{
var propertyValue = typeAccessor.GetProperty(propertyValueStr);
typeAccessor.SetProperty(instance, propertyValue);
}
catch (Exception e)
{
if (JsConfig.ThrowOnDeserializationError) throw DeserializeTypeRef.GetSerializationException(propertyName, propertyValueStr, typeAccessor.PropertyType, e);
else Tracer.Instance.WriteWarning("WARN: failed to set property {0} with: {1}", propertyName, propertyValueStr);
}
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
for (; index < strType.Length; index++) { var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline
if (index != strType.Length)
{
var success = strType[index] == JsWriter.ItemSeperator || strType[index] == JsWriter.MapEndChar;
index++;
if (success)
for (; index < strType.Length; index++) { var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline
}
}
return instance;
}
internal static object StringToType(
TypeConfig typeConfig,
string strType,
EmptyCtorDelegate ctorFn,
Dictionary <string, TypeAccessor> typeAccessorMap)
{
var index = 0;
var type = typeConfig.Type;
if (strType == null)
{
return(null);
}
//if (!Serializer.EatMapStartChar(strType, ref index))
for (; index < strType.Length; index++)
{
var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c])
{
break;
}
} //Whitespace inline
if (strType[index++] != JsWriter.MapStartChar)
{
throw DeserializeTypeRef.CreateSerializationError(type, strType);
}
if (JsonTypeSerializer.IsEmptyMap(strType, index))
{
return(ctorFn());
}
object instance = null;
var strTypeLength = strType.Length;
while (index < strTypeLength)
{
var propertyName = JsonTypeSerializer.ParseJsonString(strType, ref index);
//Serializer.EatMapKeySeperator(strType, ref index);
for (; index < strType.Length; index++)
{
var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c])
{
break;
}
} //Whitespace inline
if (strType.Length != index)
{
index++;
}
var propertyValueStr = Serializer.EatValue(strType, ref index);
var possibleTypeInfo = propertyValueStr != null && propertyValueStr.Length > 1;
//if we already have an instance don't check type info, because then we will have a half deserialized object
//we could throw here or just use the existing instance.
if (instance == null && possibleTypeInfo && propertyName == JsWriter.TypeAttr)
{
var explicitTypeName = Serializer.ParseString(propertyValueStr);
var explicitType = AssemblyUtils.FindType(explicitTypeName);
// let's do the type safety checks first before we even attempt to create
// a type instance
if (explicitType == null || explicitType.IsInterface() || explicitType.IsAbstract())
{
Tracer.Instance.WriteWarning("Could not find type: " + propertyValueStr);
}
else if (!type.IsAssignableFrom(explicitType))
{
Tracer.Instance.WriteWarning("Could not assign type: " + propertyValueStr);
}
else
{
instance = explicitType.CreateInstance();
}
if (instance != null)
{
var derivedType = instance.GetType();
if (derivedType != type)
{
var derivedTypeConfig = new TypeConfig(derivedType);
var map = DeserializeTypeRef.GetTypeAccessorMap(derivedTypeConfig, Serializer);
if (map != null)
{
typeAccessorMap = map;
}
}
}
Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
continue;
}
if (instance == null)
{
instance = ctorFn();
}
var typeAccessor = PropertyNameResolver.GetTypeAccessorForProperty(propertyName, typeAccessorMap);
var propType = possibleTypeInfo && propertyValueStr[0] == '_' ? TypeAccessor.ExtractType(Serializer, propertyValueStr) : null;
if (propType != null)
{
try
{
if (typeAccessor != null)
{
//var parseFn = Serializer.GetParseFn(propType);
var parseFn = JsonReader.GetParseFn(propType);
var propertyValue = parseFn(propertyValueStr);
if (typeConfig.OnDeserializing != null)
{
propertyValue = typeConfig.OnDeserializing(instance, propertyName, propertyValue);
}
typeAccessor.SetProperty(instance, propertyValue);
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
for (; index < strType.Length; index++)
{
var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c])
{
break;
}
} //Whitespace inline
if (index != strType.Length)
{
var success = strType[index] == JsWriter.ItemSeperator || strType[index] == JsWriter.MapEndChar;
index++;
if (success)
{
for (; index < strType.Length; index++)
{
var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c])
{
break;
}
} //Whitespace inline
}
}
continue;
}
catch (Exception e)
{
if (JsConfig.HasOnDeserializationErrorHandler)
{
JsConfig.OnDeserializationError(instance, propType, propertyName, propertyValueStr, e);
}
if (JsConfig.ThrowOnDeserializationError)
{
throw DeserializeTypeRef.GetSerializationException(propertyName, propertyValueStr, propType, e);
}
Tracer.Instance.WriteWarning("WARN: failed to set dynamic property {0} with: {1}", propertyName, propertyValueStr);
}
}
if (typeAccessor != null && typeAccessor.GetProperty != null && typeAccessor.SetProperty != null)
{
try
{
var propertyValue = typeAccessor.GetProperty(propertyValueStr);
if (typeConfig.OnDeserializing != null)
{
propertyValue = typeConfig.OnDeserializing(instance, propertyName, propertyValue);
}
typeAccessor.SetProperty(instance, propertyValue);
}
catch (Exception e)
{
if (JsConfig.HasOnDeserializationErrorHandler)
{
JsConfig.OnDeserializationError(instance, typeAccessor.PropertyType, propertyName, propertyValueStr, e);
}
if (JsConfig.ThrowOnDeserializationError)
{
throw DeserializeTypeRef.GetSerializationException(propertyName, propertyValueStr, typeAccessor.PropertyType, e);
}
Tracer.Instance.WriteWarning("WARN: failed to set property {0} with: {1}", propertyName, propertyValueStr);
}
}
else if (typeConfig.OnDeserializing != null)
{
// the property is not known by the DTO
typeConfig.OnDeserializing(instance, propertyName, propertyValueStr);
}
//Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
for (; index < strType.Length; index++)
{
var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c])
{
break;
}
} //Whitespace inline
if (index != strType.Length)
{
var success = strType[index] == JsWriter.ItemSeperator || strType[index] == JsWriter.MapEndChar;
index++;
if (success)
{
for (; index < strType.Length; index++)
{
var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c])
{
break;
}
} //Whitespace inline
}
}
}
return(instance);
}
