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