public void Test()
{
var namingStrategy = new SnakeCaseNamingStrategy();
var settings = new JsonSerializerSettings
{
ContractResolver = new DefaultContractResolver {
NamingStrategy = namingStrategy
}
};
string json = @"{""dict"":{""value1"":""a"",""text_value"":""b""}}";
DataClass c = JsonConvert.DeserializeObject <DataClass>(json, settings);
Assert.AreEqual(2, c.Dict.Count);
Assert.AreEqual("a", c.Dict[MyEnum.Value1]);
Assert.AreEqual("b", c.Dict[MyEnum.TextValue]);
string json1 = @"{""dict"":{""Value1"":""a"",""TextValue"":""b""}}";
DataClass c1 = JsonConvert.DeserializeObject <DataClass>(json1, settings);
Assert.AreEqual(2, c1.Dict.Count);
Assert.AreEqual("a", c1.Dict[MyEnum.Value1]);
Assert.AreEqual("b", c1.Dict[MyEnum.TextValue]);
// Non-dictionary values should still error
ExceptionAssert.Throws <JsonSerializationException>(
() =>
{
JsonConvert.DeserializeObject <List <MyEnum> >(@"[""text_value""]", settings);
},
@"Error converting value ""text_value"" to type 'Newtonsoft.Json.Tests.Issues.Issue2444+MyEnum'. Path '[0]', line 1, position 13."
);
}
/// <summary>
/// Returns a specialized instance of the <see cref="T:System.Net.Http.Formatting.MediaTypeFormatter"/> that can format a response for the given parameters.
/// </summary>
/// <param name="type">The type to format.</param>
/// <param name="request">The request.</param>
/// <param name="mediaType">The media type.</param>
/// <returns>Returns <see cref="T:System.Net.Http.Formatting.MediaTypeFormatter"/>.</returns>
public override MediaTypeFormatter GetPerRequestFormatterInstance(Type type, HttpRequestMessage request, MediaTypeHeaderValue mediaType)
{
var parameters = request.RequestUri.ParseQueryString();
var prettify = false;
if (parameters[PrettifyParameterName] != null)
{
prettify = new[] { "yes", "1", "true" }.Contains(parameters[PrettifyParameterName], StringComparer.OrdinalIgnoreCase);
}
var fieldNamingStratgey = _fieldNamingStratgey;
if (parameters[FieldNamingStrategyParameterName] != null)
{
switch (parameters[FieldNamingStrategyParameterName])
{
case "none":
fieldNamingStratgey = new DefaultFieldNamingStrategy();
break;
case "dash":
fieldNamingStratgey = new DasherizedFieldNamingStrategy();
break;
case "snake":
fieldNamingStratgey = new SnakeCaseNamingStrategy();
break;
}
}
return(new JsonApiMediaTypeFormatter(ContractResolver, fieldNamingStratgey, prettify));
}
public SnakeCaseNamingContractResolver()
{
// 使用下划线命名方式
NamingStrategy = new SnakeCaseNamingStrategy {
ProcessDictionaryKeys = true
};
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseSwagger();
app.UseSwaggerUI(c => c.SwaggerEndpoint("/swagger/v1/swagger.json", "AppointmentScheduler.Api v1"));
}
var snakeCaseNamingStrategy = new SnakeCaseNamingStrategy();
var jsonSerializerSettings = new JsonSerializerSettings
{
ContractResolver = new DefaultContractResolver
{
NamingStrategy = snakeCaseNamingStrategy,
},
};
jsonSerializerSettings.Converters.Add(new StringEnumConverter
{
NamingStrategy = snakeCaseNamingStrategy,
});
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapHealthChecks("/");
endpoints.MapControllers();
});
}
public JsonDeserializer(NamingConvention namingConvention = NamingConvention.CamelHump)
{
_jsonSettings = new JsonSerializerSettings();
NamingStrategy selectedNamingStrategy;
switch (namingConvention)
{
case NamingConvention.CamelHump:
selectedNamingStrategy = new CamelCaseNamingStrategy(true, false);
break;
case NamingConvention.SnakeCase:
selectedNamingStrategy = new SnakeCaseNamingStrategy(true, false);
break;
default:
selectedNamingStrategy = new DefaultNamingStrategy();
break;
}
_jsonSettings.ContractResolver = new PrivateSetterContractResolver
{
NamingStrategy = selectedNamingStrategy
};
}
public static NewtonsoftJsonSerializer Create(JsonNamingStrategy namingStrategy)
{
Newtonsoft.Json.Serialization.NamingStrategy chosenStrategy;
switch (namingStrategy)
{
case JsonNamingStrategy.Default:
chosenStrategy = new DefaultNamingStrategy();
break;
case JsonNamingStrategy.CamelCase:
chosenStrategy = new CamelCaseNamingStrategy();
break;
case JsonNamingStrategy.SnakeCase:
chosenStrategy = new SnakeCaseNamingStrategy();
break;
default:
throw new ArgumentOutOfRangeException(
$"Unhandled JsonNamingStrategy: {namingStrategy}");
}
return(new NewtonsoftJsonSerializer(new Newtonsoft.Json.JsonSerializer()
{
NullValueHandling = NullValueHandling.Ignore,
Formatting = Formatting.None,
ContractResolver = new DefaultContractResolver()
{
NamingStrategy = chosenStrategy
}
}));
}
public void DifferentStrategyEquality()
{
NamingStrategy s1 = new SnakeCaseNamingStrategy();
NamingStrategy s2 = new DefaultNamingStrategy();
Assert.IsFalse(s1.Equals(s2));
Assert.IsFalse(s1.GetHashCode() == s2.GetHashCode());
}
public void SnakeCaseStrategyEquality()
{
var s1 = new SnakeCaseNamingStrategy();
var s2 = new SnakeCaseNamingStrategy();
Assert.IsTrue(s1.Equals(s2));
Assert.IsTrue(s1.GetHashCode() == s2.GetHashCode());
}
private static JsonSerializerSettings GetSerializationSettings(
SerializationType?serializationType,
bool referenceLoopIgnore = false)
{
JsonSerializerSettings serializerSettings = (JsonSerializerSettings)null;
if (serializationType.HasValue)
{
NamingStrategy namingStrategy1;
if (serializationType.HasValue)
{
switch (serializationType.GetValueOrDefault())
{
case SerializationType.CamelCase:
CamelCaseNamingStrategy caseNamingStrategy1 = new CamelCaseNamingStrategy();
caseNamingStrategy1.OverrideSpecifiedNames = false;
caseNamingStrategy1.ProcessDictionaryKeys = true;
namingStrategy1 = (NamingStrategy)caseNamingStrategy1;
goto label_6;
case SerializationType.SnakeCase:
SnakeCaseNamingStrategy caseNamingStrategy2 = new SnakeCaseNamingStrategy();
caseNamingStrategy2.OverrideSpecifiedNames = false;
caseNamingStrategy2.ProcessDictionaryKeys = true;
namingStrategy1 = (NamingStrategy)caseNamingStrategy2;
goto label_6;
}
}
CamelCaseNamingStrategy caseNamingStrategy3 = new CamelCaseNamingStrategy();
caseNamingStrategy3.OverrideSpecifiedNames = false;
caseNamingStrategy3.ProcessDictionaryKeys = true;
namingStrategy1 = (NamingStrategy)caseNamingStrategy3;
label_6:
NamingStrategy namingStrategy2 = namingStrategy1;
serializerSettings = new JsonSerializerSettings()
{
ContractResolver = (IContractResolver) new DefaultContractResolver()
{
NamingStrategy = namingStrategy2
}
};
}
if (!referenceLoopIgnore)
{
return(serializerSettings);
}
if (serializerSettings == null)
{
serializerSettings = new JsonSerializerSettings();
}
serializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
return(serializerSettings);
}
public void GetClassStructure_With_Generic_Should_Return_Json()
{
// arrange
var expectedJson = "{\"car_type1\":\"CarType\",\"car_type2\":\"CarType?\",\"name\":\"string\",\"name_initial\":\"char\",\"name_initial2\":\"char?\",\"id\":\"Guid\",\"age\":\"int\",\"age2\":\"int?\",\"weight\":\"double\",\"weight2\":\"double?\",\"boole\":\"boolean\",\"boole2\":\"boolean?\",\"longg\":\"long\",\"longg2\":\"long?\",\"decimall\":\"Decimal\",\"decimall2\":\"Decimal?\",\"floatt\":\"single\",\"floatt2\":\"single?\",\"bytee\":\"byte\",\"bytee2\":\"byte?\",\"s_bytee\":\"sbyte\",\"s_bytee2\":\"sbyte?\",\"short\":\"short\",\"short2\":\"short?\",\"u_short\":\"ushort\",\"u_short2\":\"ushort?\",\"u_intt\":\"uint\",\"u_intt2\":\"uint?\",\"u_longg\":\"ulong\",\"u_longg2\":\"ulong?\",\"created_at\":\"DateTime\",\"created_at_nullable\":\"DateTime?\",\"date_time_offsettt\":\"DateTimeOffset\",\"date_time_offsetttt\":\"DateTimeOffset?\",\"time_spantt\":\"TimeSpan\",\"time_spanrrr\":\"TimeSpan?\",\"test_structs\":{\"prop1\":\"string\",\"prop2\":\"int\"},\"test_structss\":{\"prop1\":\"string\",\"prop2\":\"int\"},\"car2\":{\"car_type1\":\"CarType\",\"car_type2\":\"CarType?\",\"name\":\"string\"},\"queisso_getne\":{\"prop1\":{\"car_type1\":\"CarType\",\"car_type2\":\"CarType?\",\"name\":\"string\"},\"prop2\":\"DateTime?\",\"prop3\":\"CarType\"}}";
var strategy = new SnakeCaseNamingStrategy();
// act
var json = ClassStructureSerializeExtensions.GetClassStructure <Car>(strategy, Formatting.None);
// assert
Assert.Equal(expectedJson, json);
}
static void BadExample(object obj)
{
var snakeNameStrategy = new SnakeCaseNamingStrategy();
var jsonSnakeSettings = new JsonSerializerSettings {
Formatting = Formatting.Indented,
ContractResolver = new DefaultContractResolver {
NamingStrategy = snakeNameStrategy
},
};
var json = JsonConvert.SerializeObject(obj, jsonSnakeSettings);
Console.WriteLine(json);
}
public static string ToJson(this TransportEvent transportEvent)
{
var naming = new SnakeCaseNamingStrategy();
var resolver = new DefaultContractResolver {
NamingStrategy = naming
};
var settings = new JsonSerializerSettings
{
Converters = new JsonConverter[] { new StringEnumConverter() },
ContractResolver = resolver,
NullValueHandling = NullValueHandling.Ignore
};
return(JsonConvert.SerializeObject(transportEvent, settings));
}
private void SetNamingStrategy(Casing casing)
{
if (casing == Casing.CamelCase)
{
NamingStrategy = new CamelCaseNamingStrategy {
ProcessDictionaryKeys = true, OverrideSpecifiedNames = true
};
}
else if (casing == Casing.SnakeCase)
{
NamingStrategy = new SnakeCaseNamingStrategy {
ProcessDictionaryKeys = true, OverrideSpecifiedNames = true
};
}
;
}
public static string ToJson(this object obj)
{
DefaultContractResolver contractResolver = new()
{
NamingStrategy = new SnakeCaseNamingStrategy()
};
var settings = new JsonSerializerSettings()
{
ContractResolver = contractResolver,
NullValueHandling = NullValueHandling.Ignore,
DefaultValueHandling = DefaultValueHandling.Ignore,
};
return(JsonConvert.SerializeObject(obj, settings));
}
}
private static JsonSerializerSettings SerializerSettings(ISlackTypeResolver slackTypeResolver)
{
var namingStrategy = new SnakeCaseNamingStrategy();
return(new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = new DefaultContractResolver
{
NamingStrategy = namingStrategy,
},
Converters =
{
new EnumNameConverter(namingStrategy),
new SlackTypeConverter(slackTypeResolver)
}
});
}
/// <summary>
/// Determines which contract type is created for the given type.
/// </summary>
/// <param name="objectType">Type of the object.</param>
/// <returns>
/// A <see cref="T:Newtonsoft.Json.Serialization.JsonContract" /> for the given type.
/// </returns>
protected override JsonContract CreateContract(Type objectType)
{
var renames = objectType.GetField("Renames", BindingFlags.NonPublic | BindingFlags.Static);
if (renames != null)
{
var renameDict = renames.GetValue(null) as Dictionary <string, string>;
NamingStrategy = new SnakeCaseNamingStrategyWithRenaming(renameDict);
}
else
{
if (NamingStrategy == null)
{
NamingStrategy = new SnakeCaseNamingStrategy();
}
}
return(base.CreateContract(objectType));
}
static CustomJsonSerializer()
{
SnakeCaseNamingStrategy namingStrategy = new SnakeCaseNamingStrategy();
JsonSerializerSettings settings = new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
DefaultValueHandling = DefaultValueHandling.Ignore,
ContractResolver = new DoNotSerializeEmptyListsResolver {
NamingStrategy = namingStrategy
}
};
settings.Converters.Add(new QosLevelConverter());
settings.Converters.Add(new StringEnumConverter(namingStrategy));
settings.Converters.Add(new ConnectionInfoConverter());
Serializer = JsonSerializer.Create(settings);
}
/// <summary>Creates the sink for a given collector endpoint.</summary>
/// <param name="appName">Application or service name.</param>
/// <param name="environment">Runtime environment (e.g. DEV or PROD).</param>
/// <param name="endpointUri">Endpoint that contains the access token.</param>
/// <param name="batchSizeLimit">The maximum number of events to include in a single batch.</param>
/// <param name="period">The time to wait between checking for event batches.</param>
/// <param name="clientBuilder">Optional client builder, which can be used to customize client
/// calls (e.g. with custom request headers).</param>
public HttpSink(string appName, string environment, string endpointUri, int batchSizeLimit, TimeSpan period,
Func <HttpClient> clientBuilder = null) : base(batchSizeLimit, period)
{
EndpointUri = endpointUri;
Client = clientBuilder == null ? new HttpClient() : clientBuilder();
AppName = appName;
Environment = environment;
SnakeCasing = new SnakeCaseNamingStrategy();
var contractResolver = new DefaultContractResolver
{
NamingStrategy = SnakeCasing
};
JsonSerializerSettings = new JsonSerializerSettings
{
ContractResolver = contractResolver,
Formatting = Formatting.None //ensures everything is on one line
};
}
protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
{
var property = base.CreateProperty(member, memberSerialization);
NamingStrategy = new SnakeCaseNamingStrategy();
property.ShouldSerialize = propInstance => property.Writable;
if (!property.Readable)
{
var prop = member as PropertyInfo;
if (property != null)
{
var hasPrivateGetter = prop.GetGetMethod(true) != null;
property.Readable = hasPrivateGetter;
}
}
return(property);
}
private static JsonSerializerSettings SerializerSettings(ISlackTypeResolver slackTypeResolver)
{
var namingStrategy = new SnakeCaseNamingStrategy();
return(new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
DateFormatString = "yyyy-MM-dd",
ContractResolver = new SlackNetContractResolver
{
NamingStrategy = namingStrategy,
},
Converters =
{
new EnumNameConverter(namingStrategy),
new TimeSpanConverter(),
new SlackTypeConverter(slackTypeResolver)
}
});
}
private static JsonSerializerSettings SerializerSettings(ISlackTypeResolver slackTypeResolver)
{
var namingStrategy = new SnakeCaseNamingStrategy();
return(new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = new SlackNetContractResolver
{
NamingStrategy = namingStrategy,
},
Converters =
{
new EnumNameConverter(namingStrategy),
new SlackTypeConverter(slackTypeResolver),
new IsoDateTimeConverter {
DateTimeFormat = "YYYY-MM-DD"
}
}
});
}
public static JsonSerializerSettings CreateJsonSerializerSettings(Formatting formatting, IContractResolver contractResolver = null)
{
var snakeCaseNamingStrategy = new SnakeCaseNamingStrategy();
var settings = new JsonSerializerSettings
{
ContractResolver = contractResolver ?? new DefaultContractResolver
{
NamingStrategy = snakeCaseNamingStrategy
},
DateFormatHandling = DateFormatHandling.IsoDateFormat,
NullValueHandling = NullValueHandling.Ignore,
ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
Formatting = formatting
};
settings.Converters.Add(
new StringEnumConverter(snakeCaseNamingStrategy)
);
return(settings);
}
public DtoTransformer(CryptoProvider cryptoProvider, HashUtils hashUtils, bool hashSearchKeys = true,
Func<SecretsData> secretKeyAccessor = null)
{
_cryptoProvider = cryptoProvider;
_hashUtils = hashUtils;
_hashSearchKeys = hashSearchKeys;
SecretKeyAccessor = secretKeyAccessor;
var nameTransformer = new SnakeCaseNamingStrategy(true, true);
foreach (var field in Enum.GetValues(typeof(SortField)).Cast<SortField>())
{
_enumMapping[field] = nameTransformer.GetPropertyName(field.ToString(), true);
}
foreach (var field in Enum.GetValues(typeof(StringField)).Cast<StringField>())
{
_enumMapping[field] = nameTransformer.GetPropertyName(field.ToString(), true);
}
foreach (var field in Enum.GetValues(typeof(NumberField)).Cast<NumberField>())
{
_enumMapping[field] = nameTransformer.GetPropertyName(field.ToString(), true);
}
}
protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
{
try
{
var property = base.CreateProperty(member, memberSerialization);
NamingStrategy = new SnakeCaseNamingStrategy();
if (!property.Writable)
{
var prop = member as PropertyInfo;
if (property != null)
{
var hasPrivateSetter = prop.GetSetMethod(true) != null;
property.Writable = hasPrivateSetter;
}
}
return(property);
}
catch (Exception ex)
{
throw ex;
}
}
public SnakeCasePropertyNamesContractResolver()
{
NamingStrategy = new SnakeCaseNamingStrategy(true, true);
}
public RequestResponseContractResolver()
{
NamingStrategy = new SnakeCaseNamingStrategy();
}
public string ResolvePropertyName(SnakeCaseNamingStrategy namingStragegy, string name)
{
return(XStrings.ToSnakeCase(name));
}
public MandrillJsonContractResolver()
{
NamingStrategy = new SnakeCaseNamingStrategy(false, false);
}
public SnakePropertyContractResolver()
{
NamingStrategy = new SnakeCaseNamingStrategy();
}
public ShouldSerializeContractResolver(List <string> serializableProperties)
{
this.serializableProperties = serializableProperties;
NamingStrategy = new SnakeCaseNamingStrategy();
}
