public void TestDouble(double value, string expected)
{
var primitive = new PrimitiveConverter();
var converted = primitive.ConvertToExpression(typeof(double), value, null);
Assert.Equal(expected, converted.ToString());
}
public RuntimeType RuntimeType()
{
if (target == null && !resolved)
{
resolved = true;
try
{
switch (Kind)
{
case PrimitiveType.None:
break;
case PrimitiveType.Object:
if (IsArray)
{
var type = Element.RuntimeType()?.Type;
if (ArrayRank == 1)
{
type = type?.MakeArrayType();
}
else if (ArrayRank > 1)
{
type = type?.MakeArrayType(ArrayRank);
}
target = Serialization.RuntimeType.GetType(type);
}
else if (IsGenericParameter)
{
// nothing
}
else if (IsGeneric && !IsGenericTypeDefinition)
{
var type = Element.RuntimeType()?.Type;
var parameters = GenericParameters.Select(x => x.RuntimeType()?.Type).ToArray();
if (type != null && parameters.All(x => x != null))
{
target = Serialization.RuntimeType.GetType(type.MakeGenericType(parameters));
}
}
else
{
target = Serialization.RuntimeType.GetType(FullName, Assembly);
}
break;
default:
target = Serialization.RuntimeType.GetType(PrimitiveConverter.GetType(Kind));
break;
}
}
catch (SystemException se) { Log.Error(se); }
}
return(target);
}
public static RuntimeType GetType(PrimitiveType kind)
{
switch (kind)
{
case PrimitiveType.None:
case PrimitiveType.Object:
return(null);
default:
return(GetType(PrimitiveConverter.GetType(kind)));
}
}
public void Serializes_an_object_into_a_primitive_json_string_object()
{
var settings = new JsonSerializerSettings();
var converter = new PrimitiveConverter <FileInfo>(
serialize: fi => fi.FullName,
deserialize: o => null);
settings.Converters.Add(converter);
var obj = new FileInfo(@"c:\temp\hello.txt");
var json = JsonConvert.SerializeObject(obj, settings);
json.Should().Be("\"c:\\\\temp\\\\hello.txt\"");
}
public static void ClassWithPrimitivesObjectConverter()
{
string expected = @"{
""MyIntProperty"":123,
""MyBoolProperty"":true,
""MyStringProperty"":""Hello"",
""MyIntField"":321,
""MyBoolField"":true,
""MyStringField"":""World""
}";
string json;
var converter = new PrimitiveConverter();
var options = new JsonSerializerOptions
{
IncludeFields = true
};
options.Converters.Add(converter);
{
var obj = new ClassWithPrimitives
{
MyIntProperty = 123,
MyBoolProperty = true,
MyStringProperty = "Hello",
MyIntField = 321,
MyBoolField = true,
MyStringField = "World",
};
json = JsonSerializer.Serialize(obj, options);
Assert.Equal(6, converter.WriteCallCount);
JsonTestHelper.AssertJsonEqual(expected, json);
}
{
var obj = JsonSerializer.Deserialize <ClassWithPrimitives>(json, options);
Assert.Equal(6, converter.ReadCallCount);
Assert.Equal(123, obj.MyIntProperty);
Assert.True(obj.MyBoolProperty);
Assert.Equal("Hello", obj.MyStringProperty);
Assert.Equal(321, obj.MyIntField);
Assert.True(obj.MyBoolField);
Assert.Equal("World", obj.MyStringField);
}
}
public void Deserializes_a_complex_object_from_a_primitive_json_string_object()
{
var settings = new JsonSerializerSettings();
var converter = new PrimitiveConverter <FileInfo>(
serialize: fi => null,
deserialize: o => new FileInfo((string)o));
settings.Converters.Add(converter);
var json = "\"c:\\\\temp\\\\hello.txt\"";
var obj = JsonConvert.DeserializeObject <FileInfo>(json, settings);
obj.FullName.Should().Be(@"c:\temp\hello.txt");
}
public void Serializes_an_object_property_into_a_primitive_json_string_property()
{
var settings = new JsonSerializerSettings();
var converter = new PrimitiveConverter <FileInfo>(
serialize: fi => fi.FullName,
deserialize: o => new FileInfo((string)o));
settings.Converters.Add(converter);
var obj = new HasPropertyOf <FileInfo>
{
Property = new FileInfo(@"c:\temp\hello.txt")
};
var json = JsonConvert.SerializeObject(obj, settings);
json.Should().Be("{\"Property\":\"c:\\\\temp\\\\hello.txt\"}");
}
public void Deserializes_a_String_T_property_when_there_is_a_value_property_in_the_json()
{
var settings = new JsonSerializerSettings();
var converter = new PrimitiveConverter <EmailAddress>(
serialize: e => e.Value,
deserialize: j => new EmailAddress(j.ToString()));
settings.Converters.Add(converter);
var emailAddress = Any.Email();
var json = "{\"NewEmailAddress\":{\"Value\":\"" + emailAddress + "\"}}";
var obj = JsonConvert.DeserializeObject <ChangeEmailAddress>(json, settings);
obj.NewEmailAddress.Should().Be(emailAddress);
}
public void Deserializes_a_complex_object_from_a_json_primitive_int_property()
{
var settings = new JsonSerializerSettings();
var converter = new PrimitiveConverter <HasPropertyOf <Int64> >(
serialize: o => null,
deserialize: o =>
new HasPropertyOf <Int64>
{
Property = (Int64)o
});
settings.Converters.Add(converter);
var json = "{\"Property\":123}";
var obj = JsonConvert.DeserializeObject <HasPropertyOf <HasPropertyOf <Int64> > >(json, settings);
obj.Property.Property.Should().Be(123);
}
public static T ElementOrDefault <T>(this XElement el, XName name, T dflt) where T : struct
{
if (el == null)
{
return(dflt);
}
var attrib = el.ElementCase(name);
if (attrib == null)
{
return(dflt);
}
if (typeof(T) == typeof(XReal))
{
var val = new XReal(PrimitiveConverter <string, float> .Convert(attrib.Value));
return((T)(object)val);
}
return(PrimitiveConverter <string, T> .Convert(attrib.Value));
}
private void GetLastPrice(string data)
{
var aggTrade = JConverter.JsonConver <AggTrade>(data);
var lastPrice = PrimitiveConverter.ToDouble(aggTrade.p);
if (!previosPrices.ContainsKey(aggTrade.s))
{
previosPrices.Add(aggTrade.s, lastPrice);
OnLastPriceEvent(aggTrade.s, lastPrice);
}
else
{
var previosPrice = previosPrices[aggTrade.s];
if (lastPrice != previosPrice)
{
previosPrices[aggTrade.s] = lastPrice;
OnLastPriceEvent(aggTrade.s, lastPrice);
}
}
}
public void Serializes_an_object_property_into_a_primitive_json_int_property()
{
var settings = new JsonSerializerSettings();
var converter = new PrimitiveConverter <HasPropertyOf <int> >(
serialize: o => o.Property,
deserialize: o => null);
settings.Converters.Add(converter);
var obj = new HasPropertyOf <HasPropertyOf <int> >
{
Property = new HasPropertyOf <int>
{
Property = 123
}
};
var json = JsonConvert.SerializeObject(obj, settings);
json.Should().Be("{\"Property\":123}");
}
public void Deserializes_a_complex_object_from_a_json_primitive_guid_property()
{
var settings = new JsonSerializerSettings();
var converter = new PrimitiveConverter <HasPropertyOf <Guid> >(
serialize: o => null,
deserialize: o =>
new HasPropertyOf <Guid>
{
Property = Guid.Parse((string)o)
});
var guid = Guid.NewGuid();
settings.Converters.Add(converter);
var json = "{\"Property\":\"" + guid + "\"}";
var obj = JsonConvert.DeserializeObject <HasPropertyOf <HasPropertyOf <Guid> > >(json, settings);
obj.Property.Property.Should().Be(guid);
}
public void Serializes_an_object_property_into_a_primitive_json_guid_property()
{
var settings = new JsonSerializerSettings();
var converter = new PrimitiveConverter <HasPropertyOf <Guid> >(
serialize: o => o.Property.ToString(),
deserialize: o => null);
settings.Converters.Add(converter);
var guid = Guid.NewGuid();
var obj = new HasPropertyOf <HasPropertyOf <Guid> >
{
Property = new HasPropertyOf <Guid>
{
Property = guid
}
};
var json = JsonConvert.SerializeObject(obj, settings);
json.Should().Be("{\"Property\":\"" + guid + "\"}");
}
/// <summary>
/// Converts a string into an object of the specified type
/// </summary>
/// <param name="s">String</param>
/// <param name="type">Conversion type</param>
/// <returns>Object in <paramref name="type"/> type with the String value if its possible</returns>
public static object ConvertTo(this string s, Type type)
{
return(PrimitiveConverter.ConvertPrimitiveValue(s, type));
}
/// <summary>
/// Converts a string into an object of the specified type
/// </summary>
/// <typeparam name="T">Conversion type</typeparam>
/// <param name="s">String</param>
/// <returns>Object in <typeparamref name="T"/> type with the String value if its possible</returns>
public static T ConvertTo <T>(this string s)
{
return((T)PrimitiveConverter.ConvertPrimitiveValue(s, typeof(T)));
}
internal EnumConverter(BclType targetType) : base(targetType)
{
_converter = s_primitiveConverters.GetOrAdd(targetType, t => PrimitiveConverter.ForType(t));
}
private void Initialize(Type type)
{
Type = type;
IsSupported = !IsIgnored(type);
if (!IsSupported)
{
return;
}
Kind = PrimitiveConverter.GetPrimitiveType(type);
FastType = FastType.GetType(type);
switch (Kind)
{
case PrimitiveType.None:
case PrimitiveType.Object:
break;
case PrimitiveType.Type:
case PrimitiveType.String:
case PrimitiveType.Bytes:
IsReference = true;
IsSealed = true;
return;
default:
return;
}
void CaptureName()
{
var nattr = type.GetCustomAttribute <SerializationNameAttribute>();
if (nattr != null)
{
FullName = nattr.FullName;
Assembly = nattr.AssemblyName;
}
else
{
FullName = type.FullName;
if (!FastType.IsMscorlib)
{
Assembly = type.Assembly.GetName().Name;
}
}
}
if (type.IsArray)
{
IsReference = true;
IsSealed = true;
IsArray = true;
ArrayRank = type.GetArrayRank();
Element = GetType(type.GetElementType());
}
else if (type.IsEnum)
{
IsEnum = true;
Element = GetType(type.GetEnumUnderlyingType());
CaptureName();
}
else if (type.IsGenericParameter)
{
IsGenericParameter = true;
var pargs = type.DeclaringType.GetGenericArguments();
for (int i = 0; i < pargs.Length; i++)
{
if (pargs[i].Name == type.Name)
{
GenericParameterIndex = i;
break;
}
}
}
else
{
IsSealed = type.IsSealed;
IsReference = !type.IsValueType;
Surrogate = GetSurrogate(type);
BaseType = GetType(type.BaseType);
IsInterface = type.IsInterface;
IsAbstract = type.IsAbstract;
IsISerializable = typeof(ISerializable).IsBaseClass(type);
Converter = GetTypeConverter();
if (type.IsGenericType)
{
IsGeneric = true;
if (type.IsGenericTypeDefinition)
{
IsGenericTypeDefinition = true;
CaptureName();
}
else
{
var def = type.GetGenericTypeDefinition();
Element = GetType(def);
IsNullable = def == typeof(Nullable <>);
}
GenericParameters = type.GetGenericArguments()
.Select(x => GetType(x))
.ToList()
.AsReadOnly();
}
else
{
CaptureName();
}
if (Surrogate == null && !IsInterface)
{
var settings = type.GetCustomAttribute <SerializationSettingsAttribute>() ?? SerializationSettingsAttribute.Defaults;
foreach (var m in FastType.DeclaredMembers)
{
if (m.IsStatic || m.IsOverride)
{
continue;
}
var rType = GetType(m.Type.Type);
if (!rType.IsSupported)
{
continue;
}
if (m.GetAttribute <NotSerializedAttribute>() != null)
{
continue;
}
if (m.GetAttribute <SerializedAttribute>() == null)
{
if (m.IsField && m.IsPublic && !settings.IncludePublicFields)
{
continue;
}
if (m.IsField && !m.IsPublic && !settings.IncludePrivateFields)
{
continue;
}
if (!m.IsField && m.IsPublic && !settings.IncludePublicProperties)
{
continue;
}
if (!m.IsField && !m.IsPublic && !settings.IncludePrivateProperties)
{
continue;
}
}
if (!m.CanSet && !m.Type.IsReference)
{
continue;
}
var name = m.GetAttribute <SerializationMemberNameAttribute>()?.MemberName;
Members.Add(new Member(this)
{
Name = name ?? m.Name,
Type = rType,
RuntimeMember = m,
});
}
var interfaces = type.GetInterfaces();
var iDictKV = interfaces.Where(t => t.IsGenericType && t.GetGenericTypeDefinition() == typeof(IDictionary <,>)).FirstOrDefault();
var iColT = interfaces.Where(t => t.IsGenericType && t.GetGenericTypeDefinition() == typeof(ICollection <>)).FirstOrDefault();
if (settings.IncludeDictionaryInterface && iDictKV != null)
{
CollectionType = RuntimeCollectionType.IDictionaryKV;
Collection1 = GetType(iDictKV.GenericTypeArguments[0]);
Collection2 = GetType(iDictKV.GenericTypeArguments[1]);
}
else if (settings.IncludeListInterface && iColT != null)
{
CollectionType = RuntimeCollectionType.ICollectionT;
Collection1 = GetType(iColT.GenericTypeArguments[0]);
}
else if (settings.IncludeDictionaryInterface && interfaces.Contains(typeof(IDictionary)))
{
CollectionType = RuntimeCollectionType.IDictionary;
}
else if (settings.IncludeListInterface && interfaces.Contains(typeof(IList)))
{
CollectionType = RuntimeCollectionType.IList;
}
}
}
}
public InputPrimitiveDeclaration(PrimitiveConverter converter, int partyId)
{
Converter = converter;
PartyId = partyId;
}
public OutputPrimitiveDeclaration(PrimitiveConverter converter, IdSet partyIds)
{
Converter = converter;
PartyIds = partyIds;
}
void ToTypeName(StringBuilder sb, StringBuilder sb2, TypeData type)
{
string getFriendlyName()
{
if (string.IsNullOrWhiteSpace(type.FullName))
{
return("Type_");
}
if (Guid.TryParse(type.FullName, out var _))
{
return("Type_");
}
var i = type.FullName.LastIndexOfAny(new char[] { '.', '+' });
if (i + 1 == type.FullName.Length)
{
return("Type_");
}
var s = type.FullName.Substring(i + 1);
sb2.Clear();
for (i++; i < type.FullName.Length; i++)
{
var c = type.FullName[i];
if (c == '`')
{
break;
}
if (char.IsLetterOrDigit(c))
{
if (sb2.Length == 0 && char.IsDigit(c))
{
sb2.Append('T');
}
sb2.Append(c);
}
}
if (sb2.Length == 0)
{
return("Type_");
}
sb2.Append("_");
return(sb2.ToString());
}
if (type.IsEnum)
{
sb.Append(getFriendlyName()).Append(objectsToIds[type]);
}
else if (type.IsArray)
{
ToTypeName(sb, sb2, type.Element);
for (int i = 1; i < type.ArrayRank; i++)
{
sb.Append(',');
}
sb.Append(']');
}
else if (type.IsGenericParameter)
{
sb.Append('T').Append(type.GenericParameterIndex + 1);
}
else if (type.Kind == PrimitiveType.Object)
{
var rtype = type.RuntimeType();
if (type.IsGeneric)
{
if (type.IsGenericTypeDefinition)
{
if (rtype != null && FastType.IsFromMscorlib(rtype.Type))
{
var sm = 0;
var gm = type.FullName.LastIndexOf('`');
if (type.FullName.StartsWith("System.ComponentModel."))
{
sm = "System.ComponentModel.".Length;
}
else if (type.FullName.StartsWith("System.Collections.Generic."))
{
sm = "System.Collections.Generic.".Length;
}
else if (type.FullName.StartsWith("System.Collections."))
{
sm = "System.Collections.".Length;
}
sb.Append(type.FullName.Substring(sm, gm - sm));
}
else
{
sb.Append(getFriendlyName()).Append(objectsToIds[type]);
}
}
else
{
ToTypeName(sb, sb2, type.Element);
sb.Append('<');
for (int i = 0; i < type.GenericParameters.Count; i++)
{
if (i > 0)
{
sb.Append(",");
}
ToTypeName(sb, sb2, type.GenericParameters[i]);
}
sb.Append('>');
}
}
else
{
if (rtype != null && rtype.Type == typeof(object))
{
sb.Append("object");
}
else if (rtype != null && FastType.IsFromMscorlib(rtype.Type))
{
sb.Append(rtype.FullName);
}
else
{
sb.Append(getFriendlyName()).Append(objectsToIds[type]);
}
}
}
else
{
sb.Append(PrimitiveConverter.GetChsarpName(type.Kind));
}
}
