public DefaultsQueryStringParameterReader(IJsonApiOptions options)
{
ArgumentGuard.NotNull(options, nameof(options));
_options = options;
SerializerDefaultValueHandling = options.SerializerSettings.DefaultValueHandling;
}
public ResourceObjectBuilderSettings(
NullValueHandling serializerNullValueHandling = NullValueHandling.Include,
DefaultValueHandling serializerDefaultValueHandling = DefaultValueHandling.Include)
{
SerializerNullValueHandling = serializerNullValueHandling;
SerializerDefaultValueHandling = serializerDefaultValueHandling;
}
public static string ToJson <T>(this T obj, DefaultValueHandling defaultValueHandling)
{
return(JsonConvert.SerializeObject(obj, new JsonSerializerSettings
{
DefaultValueHandling = defaultValueHandling
}));
}
public static MemoryStream SerializeToMemoryStream <T>(T obj, DefaultValueHandling defaultValueHandling = DefaultValueHandling.Include,
NullValueHandling nullValueHandling = NullValueHandling.Include, ISerializationBinder serializationBinder = null)
{
MemoryStream memoryStream = new MemoryStream();
SerializeToStream(obj, memoryStream, defaultValueHandling, nullValueHandling, serializationBinder);
return(memoryStream);
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonSerializer"/> class.
/// </summary>
public JsonSerializer()
{
_referenceLoopHandling = JsonSerializerSettings.DefaultReferenceLoopHandling;
_missingMemberHandling = JsonSerializerSettings.DefaultMissingMemberHandling;
_nullValueHandling = JsonSerializerSettings.DefaultNullValueHandling;
_defaultValueHandling = JsonSerializerSettings.DefaultDefaultValueHandling;
_objectCreationHandling = JsonSerializerSettings.DefaultObjectCreationHandling;
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonSerializer"/> class.
/// </summary>
public JsonSerializer()
{
_referenceLoopHandling = JsonSerializerSettings.DefaultReferenceLoopHandling;
_missingMemberHandling = JsonSerializerSettings.DefaultMissingMemberHandling;
_nullValueHandling = JsonSerializerSettings.DefaultNullValueHandling;
_defaultValueHandling = JsonSerializerSettings.DefaultDefaultValueHandling;
_objectCreationHandling = JsonSerializerSettings.DefaultObjectCreationHandling;
}
public GraphsonJsonSerializer(
DefaultValueHandling defaultValueHandling,
IGremlinQueryEnvironment environment,
IGremlinQueryFragmentDeserializer fragmentDeserializer)
{
DefaultValueHandling = defaultValueHandling;
ContractResolver = new GremlinContractResolver(environment.Model.PropertiesModel);
Converters.Add(new JTokenConverterConverter(fragmentDeserializer, environment));
}
public void Reader_Read_Succeeds(string parameterName, string parameterValue, DefaultValueHandling expectedValue)
{
// Act
_reader.Read(parameterName, parameterValue);
DefaultValueHandling handling = _reader.SerializerDefaultValueHandling;
// Assert
handling.Should().Be(expectedValue);
}
public DefaultsService GetService(DefaultValueHandling defaultValue, bool allowOverride)
{
var options = new JsonApiOptions
{
SerializerSettings = { DefaultValueHandling = defaultValue },
AllowQueryStringOverrideForSerializerDefaultValueHandling = allowOverride
};
return(new DefaultsService(options));
}
/// <inheritdoc />
public virtual void Read(string parameterName, StringValues parameterValue)
{
if (!bool.TryParse(parameterValue, out bool result))
{
throw new InvalidQueryStringParameterException(parameterName, "The specified defaults is invalid.",
$"The value '{parameterValue}' must be 'true' or 'false'.");
}
SerializerDefaultValueHandling = result ? DefaultValueHandling.Include : DefaultValueHandling.Ignore;
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonSerializer"/> class.
/// </summary>
public JsonSerializer()
{
_referenceLoopHandling = JsonSerializerSettings.DefaultReferenceLoopHandling;
_missingMemberHandling = JsonSerializerSettings.DefaultMissingMemberHandling;
_nullValueHandling = JsonSerializerSettings.DefaultNullValueHandling;
_defaultValueHandling = JsonSerializerSettings.DefaultDefaultValueHandling;
_objectCreationHandling = JsonSerializerSettings.DefaultObjectCreationHandling;
_preserveReferencesHandling = JsonSerializerSettings.DefaultPreserveReferencesHandling;
_typeNameHandling = JsonSerializerSettings.DefaultTypeNameHandling;
_binder = DefaultSerializationBinder.Instance;
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonSerializer"/> class.
/// </summary>
public JsonSerializer()
{
_referenceLoopHandling = JsonSerializerSettings.DefaultReferenceLoopHandling;
_missingMemberHandling = JsonSerializerSettings.DefaultMissingMemberHandling;
_nullValueHandling = JsonSerializerSettings.DefaultNullValueHandling;
_defaultValueHandling = JsonSerializerSettings.DefaultDefaultValueHandling;
_objectCreationHandling = JsonSerializerSettings.DefaultObjectCreationHandling;
_preserveReferencesHandling = JsonSerializerSettings.DefaultPreserveReferencesHandling;
_typeNameHandling = JsonSerializerSettings.DefaultTypeNameHandling;
_binder = DefaultSerializationBinder.Instance;
}
public static void SerializeToStream <T>(T obj, Stream stream, DefaultValueHandling defaultValueHandling = DefaultValueHandling.Include,
NullValueHandling nullValueHandling = NullValueHandling.Include, ISerializationBinder serializationBinder = null)
{
if (stream != null)
{
using (StreamWriter streamWriter = new StreamWriter(stream))
{
Serialize(obj, streamWriter, defaultValueHandling, nullValueHandling, serializationBinder);
}
}
}
/// <inheritdoc/>
public virtual void Parse(string parameterName, StringValues parameterValue)
{
if (!bool.TryParse(parameterValue, out var result))
{
throw new InvalidQueryStringParameterException(parameterName,
"The specified query string value must be 'true' or 'false'.",
$"The value '{parameterValue}' for parameter '{parameterName}' is not a valid boolean value.");
}
SerializerDefaultValueHandling = result ? DefaultValueHandling.Include : DefaultValueHandling.Ignore;
}
public static string SerializeToString <T>(T obj, DefaultValueHandling defaultValueHandling = DefaultValueHandling.Include,
NullValueHandling nullValueHandling = NullValueHandling.Include, ISerializationBinder serializationBinder = null)
{
StringBuilder sb = new StringBuilder();
using (StringWriter stringWriter = new StringWriter(sb))
{
Serialize(obj, stringWriter, defaultValueHandling, nullValueHandling, serializationBinder);
}
return(sb.ToString());
}
public JsonObjectContractBuilder <T> AddProperty <TProp>
(String propName,
Func <T, TProp> get,
Required required = Required.Always,
DefaultValueHandling defaultValueHandling = DefaultValueHandling.Include,
Object?defaultValue = null)
{
var prop = CreateProperty(propName, get, required, defaultValueHandling, defaultValue);
contract.Properties.AddProperty(prop);
return(this);
}
public JsonSerializer()
{
this._referenceLoopHandling = ReferenceLoopHandling.Error;
this._missingMemberHandling = MissingMemberHandling.Ignore;
this._nullValueHandling = NullValueHandling.Include;
this._defaultValueHandling = DefaultValueHandling.Include;
this._objectCreationHandling = ObjectCreationHandling.Auto;
this._preserveReferencesHandling = PreserveReferencesHandling.None;
this._constructorHandling = ConstructorHandling.Default;
this._typeNameHandling = TypeNameHandling.None;
this._context = JsonSerializerSettings.DefaultContext;
this._binder = (SerializationBinder)DefaultSerializationBinder.Instance;
}
public static void SerializeToFile <T>(T obj, string filePath, DefaultValueHandling defaultValueHandling = DefaultValueHandling.Include,
NullValueHandling nullValueHandling = NullValueHandling.Include, ISerializationBinder serializationBinder = null)
{
if (!string.IsNullOrEmpty(filePath))
{
FileHelpers.CreateDirectoryFromFilePath(filePath);
using (FileStream fileStream = new FileStream(filePath, FileMode.Create, FileAccess.Write, FileShare.Read, 4096, FileOptions.WriteThrough))
{
SerializeToStream(obj, fileStream, defaultValueHandling, nullValueHandling, serializationBinder);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonSerializer"/> class.
/// </summary>
public JsonSerializer()
{
this._referenceLoopHandling = JsonSerializerSettings.DefaultReferenceLoopHandling;
this._missingMemberHandling = JsonSerializerSettings.DefaultMissingMemberHandling;
this._nullValueHandling = JsonSerializerSettings.DefaultNullValueHandling;
this._defaultValueHandling = JsonSerializerSettings.DefaultDefaultValueHandling;
this._objectCreationHandling = JsonSerializerSettings.DefaultObjectCreationHandling;
this._preserveReferencesHandling = JsonSerializerSettings.DefaultPreserveReferencesHandling;
this._constructorHandling = JsonSerializerSettings.DefaultConstructorHandling;
this._typeNameHandling = JsonSerializerSettings.DefaultTypeNameHandling;
this.Context = JsonSerializerSettings.DefaultContext;
this._binder = DefaultSerializationBinder.Instance;
}
/// <summary>
/// Tests the DefaultValueHandling property in a JSON serializer settings object.
/// </summary>
/// <param name="defaultValueHandling">Expected DefaultValueHandling.</param>
/// <returns>The same JSON serializer settings test builder.</returns>
public IAndJsonSerializerSettingsTestBuilder WithDefaultValueHandling(DefaultValueHandling defaultValueHandling)
{
this.jsonSerializerSettings.DefaultValueHandling = defaultValueHandling;
this.validations.Add((expected, actual) =>
{
if (!CommonValidator.CheckEquality(expected.DefaultValueHandling, actual.DefaultValueHandling))
{
this.ThrowNewJsonResultAssertionException(
string.Format("{0} default value handling", expected.DefaultValueHandling),
string.Format("in fact found {0}", actual.DefaultValueHandling));
}
});
return(this);
}
public T Deserialize <T>(string json, DefaultValueHandling defaultValueHandling = DefaultValueHandling.Ignore)
{
var settings = new JsonSerializerSettings {
DefaultValueHandling = defaultValueHandling
};
try
{
return(JsonConvert.DeserializeObject <T>(json, settings));
}
catch (JsonException ex)
{
throw new Exception("Exeption caught while deserializing!", ex);
}
}
public void Parse_QueryConfigWithApiSettings_Succeeds(string queryValue, DefaultValueHandling defaultValue, bool allowOverride, DefaultValueHandling expected)
{
// Arrange
const string parameterName = "defaults";
var service = GetService(defaultValue, allowOverride);
// Act
if (service.CanParse(parameterName) && service.IsEnabled(DisableQueryAttribute.Empty))
{
service.Parse(parameterName, queryValue);
}
// Assert
Assert.Equal(expected, service.SerializerDefaultValueHandling);
}
private static void WriteJson(
object obj,
string filename,
DefaultValueHandling defaultValueHandling = DefaultValueHandling.Include)
{
var settings = new JsonSerializerSettings
{
DateTimeZoneHandling = DateTimeZoneHandling.Utc,
DefaultValueHandling = defaultValueHandling,
Formatting = Formatting.Indented,
};
var json = JsonConvert.SerializeObject(obj, settings);
File.WriteAllText($"{filename}.json", json);
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonSerializer"/> class.
/// </summary>
public JsonSerializer()
{
_referenceLoopHandling = JsonSerializerSettings.DefaultReferenceLoopHandling;
_missingMemberHandling = JsonSerializerSettings.DefaultMissingMemberHandling;
_nullValueHandling = JsonSerializerSettings.DefaultNullValueHandling;
_defaultValueHandling = JsonSerializerSettings.DefaultDefaultValueHandling;
_objectCreationHandling = JsonSerializerSettings.DefaultObjectCreationHandling;
_preserveReferencesHandling = JsonSerializerSettings.DefaultPreserveReferencesHandling;
_constructorHandling = JsonSerializerSettings.DefaultConstructorHandling;
_typeNameHandling = JsonSerializerSettings.DefaultTypeNameHandling;
_metadataPropertyHandling = JsonSerializerSettings.DefaultMetadataPropertyHandling;
_context = JsonSerializerSettings.DefaultContext;
_binder = DefaultSerializationBinder.Instance;
_culture = JsonSerializerSettings.DefaultCulture;
_contractResolver = DefaultContractResolver.Instance;
}
public T Deserialize <T>(Stream source, DefaultValueHandling defaultValueHandling = DefaultValueHandling.Ignore, bool leaveOpen = false)
{
try
{
using (var reader = new JsonTextReader(new StreamReader(source, Encoding.UTF8, false, 1024, leaveOpen)))
{
var serializer = new JsonSerializer {
TypeNameHandling = TypeNameHandling.Auto, DefaultValueHandling = defaultValueHandling
};
return(serializer.Deserialize <T>(reader));
}
}
catch (JsonException ex)
{
throw new Exception("Exeption caught while deserializing!", ex);
}
}
static JsonProperty CreateProperty <TProp>
(String propName,
Func <T, TProp> get,
Required required = Required.Always,
DefaultValueHandling defaultValueHandling = DefaultValueHandling.Include,
Object?defaultValue = null) =>
new JsonProperty
{
PropertyName = propName,
UnderlyingName = propName,
PropertyType = typeof(TProp),
DeclaringType = typeof(T),
Readable = true,
Writable = false,
ValueProvider = new ReadOnlyValueProvider <T, TProp>(get),
Required = required,
DefaultValueHandling = defaultValueHandling,
DefaultValue = defaultValue
};
public void Reader_Outcome(string queryStringParameterValue, DefaultValueHandling optionsDefaultValue, bool optionsAllowOverride, DefaultValueHandling expected)
{
// Arrange
var options = new JsonApiOptions
{
SerializerSettings = { DefaultValueHandling = optionsDefaultValue },
AllowQueryStringOverrideForSerializerDefaultValueHandling = optionsAllowOverride
};
var reader = new DefaultsQueryStringParameterReader(options);
// Act
if (reader.IsEnabled(DisableQueryStringAttribute.Empty))
{
reader.Read("defaults", queryStringParameterValue);
}
// Assert
reader.SerializerDefaultValueHandling.Should().Be(expected);
}
/// <summary>
/// Get a serializer suited for two-way serialization of .NET types.
/// </summary>
/// <returns></returns>
public static JsonSerializer Serializer(
TypeNameHandling typeNameHandling = TypeNameHandling.Arrays,
FormatterAssemblyStyle assemblyNameType = FormatterAssemblyStyle.Simple,
NullValueHandling nullValueHandling = NullValueHandling.Ignore,
DefaultValueHandling defaultValueHandling = DefaultValueHandling.Ignore,
MissingMemberHandling missingMemberHandling = MissingMemberHandling.Ignore,
ReferenceLoopHandling loopHandling = ReferenceLoopHandling.Ignore)
{
var result = new JsonSerializer
{
MissingMemberHandling = missingMemberHandling,
NullValueHandling = nullValueHandling,
ReferenceLoopHandling = loopHandling,
DefaultValueHandling = defaultValueHandling,
TypeNameHandling = typeNameHandling,
TypeNameAssemblyFormat = assemblyNameType
};
result.Converters.Add(new Newtonsoft.Json.Converters.StringEnumConverter());
return(result);
}
public static void Serialize <T>(T obj, TextWriter textWriter, DefaultValueHandling defaultValueHandling = DefaultValueHandling.Include,
NullValueHandling nullValueHandling = NullValueHandling.Include, ISerializationBinder serializationBinder = null)
{
if (textWriter != null)
{
using (JsonTextWriter jsonTextWriter = new JsonTextWriter(textWriter))
{
jsonTextWriter.Formatting = Formatting.Indented;
JsonSerializer serializer = new JsonSerializer();
serializer.ContractResolver = new WritablePropertiesOnlyResolver();
serializer.Converters.Add(new StringEnumConverter());
serializer.DefaultValueHandling = defaultValueHandling;
serializer.NullValueHandling = nullValueHandling;
if (serializationBinder != null)
{
serializer.SerializationBinder = serializationBinder;
}
serializer.Serialize(jsonTextWriter, obj);
}
}
}
private bool HasFlag(DefaultValueHandling value, DefaultValueHandling flag)
{
return ((value & flag) == flag);
}
private bool HasFlag(DefaultValueHandling value, DefaultValueHandling flag)
{
return((value & flag) == flag);
}
public RestSharpJsonNetSerializer(MissingMemberHandling missingMemberHandling, NullValueHandling nullValueHandling, DefaultValueHandling defaultValueHandling)
{
ContentType = "application/json";
_serializer = new Newtonsoft.Json.JsonSerializer
{
MissingMemberHandling = missingMemberHandling,
NullValueHandling = nullValueHandling,
DefaultValueHandling = defaultValueHandling
};
}
public new IMemberConfiguration <TModel, TType> DefaultValueHandling(DefaultValueHandling valueHandling)
{
base.DefaultValueHandling = valueHandling;
return(this);
}
