/// <summary>
/// Constructs a new instance of <see cref="UmbracoJsonDataType"/>
/// </summary>
/// <param name="nullHandling">Defines how null properties are serialised</param>
protected UmbracoJsonDataType(NullValueHandling nullHandling = NullValueHandling.Include)
{
_serialiserSettings = new JsonSerializerSettings
{
NullValueHandling = nullHandling
};
}
public JsonNetResult(object data, NullValueHandling handleNulls = NullValueHandling.Ignore)
{
Data = data;
SerializerSettings = new JsonSerializerSettings();
SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
SerializerSettings.NullValueHandling = handleNulls;
}
public JsonSerializationOptions(NullValueHandling nullValueHandling, MissingMemberHandling missingMemberHandling,
ReferenceLoopHandling referenceLoopHandling)
{
NullValueHandling = nullValueHandling;
MissingMemberHandling = missingMemberHandling;
ReferenceLoopHandling = referenceLoopHandling;
}
/// <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;
_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;
_constructorHandling = JsonSerializerSettings.DefaultConstructorHandling;
_typeNameHandling = JsonSerializerSettings.DefaultTypeNameHandling;
_context = JsonSerializerSettings.DefaultContext;
_binder = DefaultSerializationBinder.Instance;
}
private static JObject Serialize <T>(T obj, NullValueHandling nullValueHandling = NullValueHandling.Include) where T : class
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
var serializer = new JsonSerializer();
serializer.NullValueHandling = nullValueHandling;
serializer.ContractResolver = new JsonContractResolver();
return(JObject.FromObject(obj, serializer));
}
private NullValueHandling GetNullValueHandling()
{
NullValueHandling nullHandling = NullValueHandling.Ignore;
// The custom 'IncludeNulls' header is supported for testing purposes.
if (ActionContext.Request.Headers.TryGetValues("IncludeNulls", out IEnumerable <string> headerValues) &&
headerValues.Contains("true"))
{
nullHandling = NullValueHandling.Include;
}
return(nullHandling);
}
public JsonSerializer()
{
_referenceLoopHandling = ReferenceLoopHandling.Error;
_missingMemberHandling = MissingMemberHandling.Ignore;
_nullValueHandling = NullValueHandling.Include;
_defaultValueHandling = DefaultValueHandling.Include;
_objectCreationHandling = ObjectCreationHandling.Auto;
_preserveReferencesHandling = PreserveReferencesHandling.None;
_constructorHandling = ConstructorHandling.Default;
_typeNameHandling = TypeNameHandling.None;
_context = JsonSerializerSettings.DefaultContext;
_binder = DefaultSerializationBinder.Instance;
}
public WebRequestMessage(int requestId, String method, params object[] parameters)
{
RequestId = requestId;
Method = method;
Params = new List <Object>();
if (parameters != null)
{
Params.AddRange(parameters);
}
NullValueHandling = NullValueHandling.Include;
}
public static void SerializeToFile <T>(T obj, string filePath, DefaultValueHandling defaultValueHandling = DefaultValueHandling.Include,
NullValueHandling nullValueHandling = NullValueHandling.Include, ISerializationBinder serializationBinder = null)
{
if (!string.IsNullOrEmpty(filePath))
{
Helpers.CreateDirectoryFromFilePath(filePath);
using (FileStream fileStream = new FileStream(filePath, FileMode.Create, FileAccess.Write, FileShare.Read, 4096, FileOptions.WriteThrough))
{
SerializeToStream(obj, fileStream, defaultValueHandling, nullValueHandling, serializationBinder);
}
}
}
/// <summary>
/// Replaces existing query parameter(s) or appends to the end. If value is a collection type (array, IEnumerable, etc.),
/// multiple parameters are added, i.e. x=1&x=2. If any of the same name already exist, they are overwritten one by one
/// (preserving order) and any remaining are appended to the end. If fewer values are specified than already exist,
/// remaining existing values are removed.
/// </summary>
/// <param name="name">Name of the parameter.</param>
/// <param name="value">Value of the parameter. If it's a collection, multiple parameters of the same name are added/replaced.</param>
/// <param name="isEncoded">If true, assume value(s) already URL-encoded.</param>
/// <param name="nullValueHandling">Describes how to handle null values.</param>
public void AddOrReplace(string name, object value, bool isEncoded = false, NullValueHandling nullValueHandling = NullValueHandling.Remove)
{
if (!Contains(name))
{
Add(name, value, isEncoded, nullValueHandling);
}
// This covers some complex edge cases involving multiple values of the same name.
// example: x has values at positions 2 and 4 in the query string, then we set x to
// an array of 4 values. We want to replace the values at positions 2 and 4 with the
// first 2 values of the new array, then append the remaining 2 values to the end.
//var parameters = this.Where(p => p.Name == name).ToArray();
var values = new Queue <object>(SplitCollection(value));
var old = _values.ToArray();
_values.Clear();
foreach (var item in old)
{
if (item.Name != name)
{
_values.Add(item);
continue;
}
if (!values.Any())
{
continue; // remove, effectively
}
var val = values.Dequeue();
if (val == null && nullValueHandling == NullValueHandling.Ignore)
{
_values.Add(item);
}
else if (val == null && nullValueHandling == NullValueHandling.Remove)
{
continue;
}
else
{
Add(name, val, isEncoded, nullValueHandling);
}
}
// add the rest to the end
while (values.Any())
{
Add(name, values.Dequeue(), isEncoded, nullValueHandling);
}
}
public static object DeserializeObject(this string json, Type type, NullValueHandling nullValueHandling = NullValueHandling.Ignore, CustomDataExchangerAttribute[] customDataExchanger = null)
{
if (string.IsNullOrEmpty(json))
{
return(null);
}
return(JsonConvert.DeserializeObject(json, type, new JsonSerializerSettings()
{
Formatting = Formatting.None, NullValueHandling = nullValueHandling, ReferenceLoopHandling = ReferenceLoopHandling.Ignore, Converters = new List <JsonConverter>()
{
new DataExchangeConverter(LimitExchangeType.IncomingCall, customDataExchanger)
}
}));
}
public static string Serialize(dynamic obj, bool isNullValueHandling = true)
{
NullValueHandling nullValue = NullValueHandling.Include;
if (!isNullValueHandling)
{
nullValue = Newtonsoft.Json.NullValueHandling.Ignore;
}
return(Newtonsoft.Json.JsonConvert.SerializeObject(obj, new Newtonsoft.Json.JsonSerializerSettings()
{
ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore, MaxDepth = 20, NullValueHandling = nullValue
}));
}
/// <summary>
/// Converts a object (input) into a string
/// </summary>
/// <param name="input"></param>
/// <param name="nullValueHandler"></param>
/// <param name="formatting"></param>
/// <param name="referenceLoopHandling"></param>
/// <returns></returns>
public static string ToJson(this object input, NullValueHandling nullValueHandler = NullValueHandling.Include,
Formatting formatting = Formatting.Indented,
ReferenceLoopHandling referenceLoopHandling = ReferenceLoopHandling.Error)
{
return(JsonConvert.SerializeObject(
input,
formatting,
new JsonSerializerSettings
{
NullValueHandling = nullValueHandler,
ReferenceLoopHandling = referenceLoopHandling
}
));
}
public string Serialize <T>(
T entity,
NullValueHandling nullValueHandling = NullValueHandling.Ignore)
{
var jsonSettings = new JsonSerializerSettings
{
NullValueHandling = nullValueHandling,
Formatting = Formatting.None,
ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
ContractResolver = new CamelCasePropertyNamesContractResolver(),
};
return(JsonConvert.SerializeObject(entity, jsonSettings));
}
private static JsonSerializerSettings CreateSerializerSettings(NullValueHandling nullValueHandling)
{
var settings = new JsonSerializerSettings {
ContractResolver = new MandrillJsonContractResolver()
};
settings.Converters.Add(new UnixDateTimeConverter());
settings.Converters.Add(new StringEnumConverter {
NamingStrategy = new SnakeCaseNamingStrategy(), AllowIntegerValues = false
});
settings.NullValueHandling = nullValueHandling;
settings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
return(settings);
}
/// <summary>
/// Parses values (usually an anonymous object or dictionary) into name/value pairs and adds them to the query, overwriting any that already exist.
/// </summary>
/// <param name="values">Typically an anonymous object, ie: new { x = 1, y = 2 }</param>
/// <param name="nullValueHandling">Indicates how to handle null values. Defaults to Remove (any existing)</param>
/// <returns>The Url object with the query parameters added</returns>
public Url SetQueryParams(object values, NullValueHandling nullValueHandling = NullValueHandling.Remove)
{
if (values == null)
{
return(this);
}
foreach (var kv in values.ToKeyValuePairs())
{
SetQueryParamInternal(kv.Key, kv.Value, false, nullValueHandling);
}
return(this);
}
public void HasErrors_EmitOnlyError(NullValueHandling nullValueHandling)
{
var expectedError = new Error("c", "d");
var response = ApiResponse.Error(expectedError);
var jObject = Serialize(nullValueHandling, response);
var jProperty = Assert.Single(jObject.Properties());
var jsonSerializer = CreateJsonSerializer();
Assert.NotNull(jProperty);
Assert.Equal(ApiResponseConstants.Error, jProperty.Name);
var actualError = jProperty.Value.ToObject <Error>(jsonSerializer);
Assert.Equal(expectedError, actualError, ErrorComparer.Default);
}
public MonoGameJsonSerializer(ContentManager contentManager, string contentPath, NullValueHandling nullValueHandling = NullValueHandling.Include)
{
Converters.Add(new ColorJsonConverter());
Converters.Add(new HslColorJsonConverter());
Converters.Add(new RangeJsonConverter <int>());
Converters.Add(new RangeJsonConverter <float>());
Converters.Add(new RangeJsonConverter <HslColor>());
Converters.Add(new ThicknessJsonConverter());
Converters.Add(new TextureAtlasJsonConverter(contentManager, contentPath));
Converters.Add(new Size2JsonConverter());
ContractResolver = new ShortNameJsonContractResolver();
NullValueHandling = nullValueHandling;
Formatting = Formatting.Indented;
}
private void Serialize <T>(Stream stream, T obj, NullValueHandling nullValueHandling = NullValueHandling.Include)
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
using (var writer = new StreamWriter(stream))
{
var serializer = new JsonSerializer();
serializer.NullValueHandling = nullValueHandling;
serializer.ContractResolver = new JsonContractResolver();
serializer.Serialize(writer, obj);
}
}
/// <summary>
/// Tests the NullValueHandling property in a JSON serializer settings object.
/// </summary>
/// <param name="nullValueHandling">Expected NullValueHandling.</param>
/// <returns>The same JSON serializer settings test builder.</returns>
public IAndJsonSerializerSettingsTestBuilder WithNullValueHandling(NullValueHandling nullValueHandling)
{
this.jsonSerializerSettings.NullValueHandling = nullValueHandling;
this.validations.Add((expected, actual) =>
{
if (!CommonValidator.CheckEquality(expected.NullValueHandling, actual.NullValueHandling))
{
this.ThrowNewJsonResultAssertionException(
string.Format("{0} null value handling", expected.NullValueHandling),
string.Format("in fact found {0}", actual.NullValueHandling));
}
});
return(this);
}
public void Parse_QueryConfigWithApiSettings_Succeeds(string queryValue, NullValueHandling defaultValue, bool allowOverride, NullValueHandling expected)
{
// Arrange
const string parameterName = "nulls";
var service = GetService(defaultValue, allowOverride);
// Act
if (service.CanParse(parameterName) && service.IsEnabled(DisableQueryAttribute.Empty))
{
service.Parse(parameterName, queryValue);
}
// Assert
Assert.Equal(expected, service.SerializerNullValueHandling);
}
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 = DefaultSerializationBinder.Instance;
this._culture = JsonSerializerSettings.DefaultCulture;
this._contractResolver = DefaultContractResolver.Instance;
}
public static string ToJson(this object source, JsonSerializerSettings jsonSerializerSettings = null,
NullValueHandling nullValueHandling = NullValueHandling.Include)
{
if (jsonSerializerSettings == null)
{
jsonSerializerSettings = new JsonSerializerSettings
{
DateFormatString = "yyyy-MM-ddTHH:mm:ss",
ContractResolver = new CamelCasePropertyNamesContractResolver(),
NullValueHandling = nullValueHandling
};
}
return(JsonConvert.SerializeObject(source, jsonSerializerSettings));
}
/// <summary>
/// Serializes an object to a file
/// </summary>
/// <typeparam name="T">The type of file to serialize</typeparam>
/// <param name="obj">The object to serialize</param>
/// <param name="filePath">The file to serialize to</param>
/// <param name="nullValueHandling">Optional null value handling</param>
public static void SerializeToFile <T>(T obj, string filePath, NullValueHandling nullValueHandling = NullValueHandling.Include)
{
// Serialize to JSON
var json = JsonConvert.SerializeObject(obj, new JsonSerializerSettings()
{
NullValueHandling = nullValueHandling,
Formatting = Formatting.Indented,
Converters = new JsonConverter[]
{
new ByteArrayHexConverter()
}
});
// Write to output
File.WriteAllText(filePath, json);
}
public static string SerializeObject(this object obj, NullValueHandling nullValueHandling = NullValueHandling.Ignore, CustomDataExchangerAttribute[] customDataExchanger = null)
{
if (obj == null)
{
return("");
}
//if (serverBase != null && serverBase.InternalSetting.IsEnabledDataExchanger)
return(JsonConvert.SerializeObject(obj, Formatting.None, new JsonSerializerSettings()
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore, Converters = new List <JsonConverter>()
{
new DataExchangeConverter(LimitExchangeType.OutgoingCall, customDataExchanger)
}, Formatting = Formatting.None, NullValueHandling = nullValueHandling
}));
//return JsonConvert.SerializeObject(obj, new JsonSerializerSettings() { Formatting = Formatting.None, NullValueHandling = nullValueHandling, ReferenceLoopHandling = ReferenceLoopHandling.Ignore });
}
public async Task <TResponse> GetSerializedResponse <TResponse>(
HttpResponseMessage result,
NullValueHandling nullValueHandling = NullValueHandling.Include)
{
var jsonSettings = new JsonSerializerSettings
{
NullValueHandling = nullValueHandling,
};
string response = await result.Content.ReadAsStringAsync();
TResponse serializedResponse = JsonConvert
.DeserializeObject <TResponse>(response, jsonSettings);
return(serializedResponse);
}
public BeetleConfig(NullValueHandling nullValueHandling,
TypeNameHandling typeNameHandling = TypeNameHandling.Objects,
Formatting formatting = Formatting.Indented,
ReferenceLoopHandling referenceLoopHandling = ReferenceLoopHandling.Ignore,
PreserveReferencesHandling preserveReferencesHandling = PreserveReferencesHandling.Objects,
DateTimeZoneHandling dateTimeZoneHandling = DateTimeZoneHandling.Local)
: this(new JsonSerializerSettings {
NullValueHandling = nullValueHandling,
TypeNameHandling = typeNameHandling,
TypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Simple,
Formatting = formatting,
ReferenceLoopHandling = referenceLoopHandling,
PreserveReferencesHandling = preserveReferencesHandling,
DateTimeZoneHandling = dateTimeZoneHandling
})
{
}
public MockDataReader(IMockDataReaderBuilder builder)
{
this.columnNameToOrdinalMapping = new Dictionary <string, int>();
this.ordinalToColumnNameMapping = new Dictionary <int, string>();
this.NullValueHandling = builder.NullValueHandling;
this.Columns = builder.GetColumns;
this.DataList = builder.GetDataList;
this.Columns.Keys.
Select((k, i) => new { ColumnName = k, Ordinal = i }).ToList().
ForEach(item =>
{
this.columnNameToOrdinalMapping.Add(item.ColumnName, item.Ordinal);
this.ordinalToColumnNameMapping.Add(item.Ordinal, item.ColumnName);
});
}
/// <summary>
/// Appends a query parameter. If value is a collection type (array, IEnumerable, etc.), multiple parameters are added, i.e. x=1&x=2.
/// To overwrite existing parameters of the same name, use AddOrReplace instead.
/// </summary>
/// <param name="name">Name of the parameter.</param>
/// <param name="value">Value of the parameter. If it's a collection, multiple parameters of the same name are added.</param>
/// <param name="isEncoded">If true, assume value(s) already URL-encoded.</param>
/// <param name="nullValueHandling">Describes how to handle null values.</param>
public void Add(string name, object value, bool isEncoded = false, NullValueHandling nullValueHandling = NullValueHandling.Remove)
{
if (value == null && nullValueHandling == NullValueHandling.Remove)
{
_values.Remove(name);
return;
}
foreach (var val in SplitCollection(value))
{
if (val == null && nullValueHandling != NullValueHandling.NameOnly)
{
continue;
}
_values.Add(name, new QueryParamValue(val, isEncoded));
}
}
/// <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;
_serializationBinder = DefaultSerializationBinder.Instance;
_guidHandling = JsonSerializerSettings.DefaultGuidHandling;
_culture = JsonSerializerSettings.DefaultCulture;
_contractResolver = DefaultContractResolver.Instance;
}
/// <summary>
/// Creates the settings instance.
/// </summary>
/// <param name="nullValueHandling">The null value handling.</param>
/// <param name="typeNameHandling">The type name handling.</param>
/// <returns></returns>
private static JsonSerializerSettings CreateSettings(NullValueHandling nullValueHandling, TypeNameHandling typeNameHandling) {
var jsonSerializerSettings = new JsonSerializerSettings {
NullValueHandling = nullValueHandling,
PreserveReferencesHandling = PreserveReferencesHandling.Objects,
ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
TypeNameHandling = typeNameHandling,
TypeNameAssemblyFormat = FormatterAssemblyStyle.Simple
};
jsonSerializerSettings.Converters.Add(new BeetleDateTimeConverter { DateTimeFormat = "yyyy-MM-dd\\THH:mm:ss.fffK" });
jsonSerializerSettings.Converters.Add(new TimeSpanConverter());
jsonSerializerSettings.Converters.Add(new StringEnumConverter());
jsonSerializerSettings.Converters.Add(new ByteArrayConverter());
jsonSerializerSettings.Converters.Add(new DbGeometryConverter());
jsonSerializerSettings.Converters.Add(new DbGeographyConverter());
return jsonSerializerSettings;
}
/// <summary>
/// Converts a String(Input) into a object of T
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="input"></param>
/// <param name="nullValueHandler"></param>
/// <param name="referenceLoopHandling"></param>
/// <returns></returns>
public static T LoadJson <T>(string input, NullValueHandling nullValueHandler = NullValueHandling.Ignore,
ReferenceLoopHandling referenceLoopHandling = ReferenceLoopHandling.Error)
{
//check for null string specifically, let empty strings go through the parser
if (input == null)
{
return(default(T));
}
//Done
return(JsonConvert.DeserializeObject <T>(input, new JsonSerializerSettings
{
NullValueHandling = nullValueHandler,
ReferenceLoopHandling = referenceLoopHandling
}));
}
public void ParseMessage(HubMessage expectedMessage, bool camelCase, NullValueHandling nullValueHandling, string input)
{
input = Frame(input);
var jsonSerializer = new JsonSerializer
{
NullValueHandling = nullValueHandling,
ContractResolver = camelCase ? new CamelCasePropertyNamesContractResolver() : new DefaultContractResolver()
};
var binder = new TestBinder(expectedMessage);
var protocol = new JsonHubProtocol(jsonSerializer);
protocol.TryParseMessages(Encoding.UTF8.GetBytes(input), binder, out var messages);
Assert.Equal(expectedMessage, messages[0], TestHubMessageEqualityComparer.Instance);
}
/// <summary>
/// Replaces an existing QueryParameter or appends one to the end. If object is a collection type (array, IEnumerable, etc.),
/// multiple paramters are added, i.e. x=1&x=2. If any of the same name already exist, they are overwritten one by one
/// (preserving order) and any remaining are appended to the end. If fewer values are specified than already exist,
/// remaining existing values are removed.
/// </summary>
public void Merge(string name, object value, bool isEncoded, NullValueHandling nullValueHandling)
{
if (value == null && nullValueHandling != NullValueHandling.NameOnly)
{
if (nullValueHandling == NullValueHandling.Remove)
{
Remove(name);
}
return;
}
// This covers some complex edge cases involving multiple values of the same name.
// example: x has values at positions 2 and 4 in the query string, then we set x to
// an array of 4 values. We want to replace the values at positions 2 and 4 with the
// first 2 values of the new array, then append the remaining 2 values to the end.
var parameters = this.Where(p => p.Name == name).ToArray();
var values = (!(value is string) && value is IEnumerable en) ? en.Cast <object>().ToArray() : new[] { value };
for (int i = 0;; i++)
{
if (i < parameters.Length && i < values.Length)
{
if (values[i] is QueryParameter qp)
{
this[IndexOf(parameters[i])] = qp;
}
else
{
parameters[i].Value = values[i];
}
}
else if (i < parameters.Length)
{
Remove(parameters[i]);
}
else if (i < values.Length)
{
var qp = values[i] as QueryParameter ?? new QueryParameter(name, values[i], isEncoded);
Add(qp);
}
else
{
break;
}
}
}
private IElasticClient GetTestClient(NullValueHandling nullValueHandling)
{
var settings = new ConnectionSettings(UnitTestDefaults.Uri, UnitTestDefaults.DefaultIndex)
.SetJsonSerializerSettingsModifier(m => m
.NullValueHandling = nullValueHandling
);
var connection = new InMemoryConnection(settings);
var client = new ElasticClient(settings, connection);
return client;
}
protected JsonResult JsonNet(object data, NullValueHandling nullValues)
{
return new JsonNetResult(data, nullValues);
}
private static void SetJsonSerializerNullValueHandling(NullValueHandling value)
{
JsonSerializer serializer = new JsonSerializer();
serializer.NullValueHandling = value;
}
public JsonSerializationOptions(NullValueHandling nullValueHandling)
: this(nullValueHandling, MissingMemberHandling.Ignore, ReferenceLoopHandling.Ignore)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="BeetleConfig" /> class.
/// </summary>
/// <param name="nullValueHandling">The null value handling.</param>
/// <param name="typeNameHandling">The type name handling.</param>
public BeetleConfig(NullValueHandling nullValueHandling, TypeNameHandling typeNameHandling)
: this(CreateSettings(nullValueHandling, typeNameHandling)) {
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonSerializer"/> class.
/// </summary>
public JsonSerializer()
{
_referenceLoopHandling = ReferenceLoopHandling.Error;
_missingMemberHandling = MissingMemberHandling.Error;
_nullValueHandling = NullValueHandling.Include;
_objectCreationHandling = ObjectCreationHandling.Auto;
}
