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)); } }