private IList <JsonConverter> GetDefaultSerializingConverters( JsonFormattingKind formattingKind) { // Newtonsoft uses the converters in the order they are specified. // So, it will first try the StringEnumConverter, then the InheritedTypeWriterJsonConverter, and so on. var result = new JsonConverter[0] .Concat( new JsonConverter[] { new StringEnumConverter { CamelCaseText = true }, }) .Concat(((formattingKind == JsonFormattingKind.Minimal) || (formattingKind == JsonFormattingKind.Concise)) ? new JsonConverter[0] : new[] { new InheritedTypeWriterJsonConverter(() => this.hierarchyParticipatingTypes) }) .Concat( new JsonConverter[] { new StringKeysAsPropertiesDictionaryJsonConverter(this.typeToKeyInDictionaryStringSerializerMap), new KeyValueArrayDictionaryJsonConverter(this.typeToKeyInDictionaryStringSerializerMap.Keys.ToList()), }).ToList(); return(result); }
/// <summary> /// Build <see cref="JsonSerializerSettings" /> to use for serialization using Newtonsoft. /// </summary> /// <param name="serializationDirection">Direction of serialization.</param> /// <param name="formattingKind">Kind of formatting to use.</param> /// <returns>Prepared settings to use with Newtonsoft.</returns> public JsonSerializerSettings BuildJsonSerializerSettings( SerializationDirection serializationDirection, JsonFormattingKind formattingKind = JsonFormattingKind.Default) { (serializationDirection == SerializationDirection.Serialize || serializationDirection == SerializationDirection.Deserialize) .Named(Invariant($"{nameof(serializationDirection)}-must-be-{nameof(SerializationDirection.Serialize)}-or{nameof(SerializationDirection.Serialize)}")) .Must().BeTrue(); var result = SerializationKindToSettingsSelectorByDirection[formattingKind](SerializationDirection.Serialize); var specifiedConverters = this.RegisteredConverters.Select(_ => serializationDirection == SerializationDirection.Serialize ? _.SerializingConverterBuilderFunction() : _.DeserializingConverterBuilderFunction()).ToList(); var defaultConverters = this.GetDefaultConverters(serializationDirection, formattingKind); var converters = new JsonConverter[0] .Concat(specifiedConverters) .Concat(defaultConverters) .ToList(); // TODO: We may need this sorted differently; as in does it need to reverse? result.Converters = converters; if (this.OverrideContractResolver != null && this.OverrideContractResolver.ContainsKey(serializationDirection)) { var overrideResolver = this.OverrideContractResolver[serializationDirection]; new { overrideResolver }.Must().NotBeNull(); result.ContractResolver = overrideResolver.ContractResolverBuilderFunction(); } return(result); }
public JsonSerializerSettings BuildAnonymousJsonSerializerSettings( SerializationDirection serializationDirection, JsonFormattingKind formattingKind = JsonFormattingKind.Default) { // this is a hack to not mess with casing since the case must match for dynamic deserialization... var result = SerializationKindToSettingsSelectorByDirection[formattingKind](serializationDirection); result.ContractResolver = new DefaultContractResolver(); result.Converters = this.GetDefaultConverters(serializationDirection, formattingKind); return(result); }
private IList <JsonConverter> GetDefaultConverters( SerializationDirection serializationDirection, JsonFormattingKind formattingKind) { switch (serializationDirection) { case SerializationDirection.Serialize: return(this.GetDefaultSerializingConverters(formattingKind)); case SerializationDirection.Deserialize: return(this.GetDefaultDeserializingConverters()); default: throw new NotSupportedException(Invariant($"{nameof(SerializationDirection)} value {serializationDirection} is not supported.")); } }
private IList <JsonConverter> GetDefaultSerializingConverters(JsonFormattingKind formattingKind) { return(new JsonConverter[0].Concat( new JsonConverter[] { new DateTimeJsonConverter(), new StringEnumConverter { CamelCaseText = true }, new SecureStringJsonConverter(), }).Concat(formattingKind == JsonFormattingKind.Minimal ? new JsonConverter[0] : new[] { new InheritedTypeWriterJsonConverter(this.InheritedTypesToHandle) }) .Concat( new JsonConverter[] { // new DictionaryJsonConverter(this.TypesWithStringConverters) - this converter cannot write (CanWrite => false) new KeyValueArrayDictionaryJsonConverter(this.TypesWithStringConverters), }).ToList()); }
/// <summary> /// Initializes a new instance of the <see cref="NaosJsonSerializer"/> class. /// </summary> /// <param name="configurationType">Optional type of configuration to use; DEFAULT is none.</param> /// <param name="unregisteredTypeEncounteredStrategy">Optional strategy of what to do when encountering a type that has never been registered; DEFAULT is <see cref="UnregisteredTypeEncounteredStrategy.Throw" />.</param> /// <param name="formattingKind">Optional type of formatting to use; DEFAULT is <see cref="JsonFormattingKind.Default" />.</param> public NaosJsonSerializer( Type configurationType = null, UnregisteredTypeEncounteredStrategy unregisteredTypeEncounteredStrategy = UnregisteredTypeEncounteredStrategy.Default, JsonFormattingKind formattingKind = JsonFormattingKind.Default) : base(configurationType ?? typeof(NullJsonConfiguration), unregisteredTypeEncounteredStrategy) { new { formattingKind }.Must().NotBeEqualTo(JsonFormattingKind.Invalid); this.formattingKind = formattingKind; if (configurationType != null) { configurationType.IsSubclassOf(typeof(JsonConfigurationBase)).Named( Invariant($"Configuration type - {configurationType.FullName} - must derive from {nameof(JsonConfigurationBase)}.")).Must().BeTrue(); configurationType.HasParameterlessConstructor().Named( Invariant($"{nameof(configurationType)} must contain a default constructor to use in {nameof(NaosJsonSerializer)}.")).Must().BeTrue(); } this.jsonConfiguration = (JsonConfigurationBase)this.configuration; this.anonymousWriteSerializationSettings = this.jsonConfiguration.BuildAnonymousJsonSerializerSettings(SerializationDirection.Serialize, this.formattingKind); }