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