public ContractResolver(DefaultJsonSerializer serializer)
{
_serializer = serializer;
_stringEnumConverter = new StringEnumConverter();
_streamConverter = new StreamConverter(serializer);
_jsonTokenConverter = new JsonTokenConverter();
_snowflakeConverter = new SnowflakeConverter();
_optionalConverters = new SynchronizedDictionary <Type, OptionalConverter>();
}
public void TestConvertToEnum_UFXMarketCode_Exception()
{
string code = "10";
UFXMarketCode testCode;
var val = StringEnumConverter.GetIntType <UFXMarketCode>(code);
Console.WriteLine(val);
}
private static JsonSerializer CreateSerializer()
{
JsonSerializer serializer = new JsonSerializer();
serializer.Formatting = Formatting.Indented;
StringEnumConverter enumConverter = new StringEnumConverter();
serializer.Converters.Add(enumConverter);
return(serializer);
}
public void StringEnumConvert_String_Should_Pass()
{
var myConverter = new StringEnumConverter();
var myObject = "Feet";
var Result = myConverter.Convert(myObject, typeof(ItemLocationEnum), null, null);
var Expected = ItemLocationEnum.Feet;
Assert.AreEqual(Expected, Result, TestContext.CurrentContext.Test.Name);
}
public void JsonDeserialize_PatternWithoutFormatAndLanguages_CorrectlyProcessed()
{
var data = "[{\"Key\":\"96\",\"Value\":\"(<[expr]>.)?<[(?i)(password|pwd)]> = <[\\\"\\\\w*\\\"]>\"}]";
var stringEnumConverter = new StringEnumConverter();
var languageFlagsConverter = new PatternJsonSafeConverter();
var patternDtos = JsonConvert.DeserializeObject <List <PatternDto> >(data, stringEnumConverter, languageFlagsConverter);
Assert.AreEqual(1, patternDtos.Count);
}
public void Model_Converter_StringEnumConverter_ConvertBack_Int_Should_Pass()
{
var myConverter = new StringEnumConverter();
int myObject = 40;
var Result = myConverter.ConvertBack(myObject, typeof(ItemLocationEnum), null, null);
var Expected = "Feet";
Assert.AreEqual(Expected, Result, TestContext.CurrentContext.Test.Name);
}
public void StringEnumConverter_CamelCaseTextCtor()
{
#pragma warning disable CS0618 // Type or member is obsolete
StringEnumConverter converter = new StringEnumConverter(true);
#pragma warning restore CS0618 // Type or member is obsolete
Assert.IsNotNull(converter.NamingStrategy);
Assert.AreEqual(typeof(CamelCaseNamingStrategy), converter.NamingStrategy.GetType());
Assert.AreEqual(true, converter.AllowIntegerValues);
}
public void Model_Converter_StringEnumConverter_Convert_Enum_Should_Pass()
{
var myConverter = new StringEnumConverter();
var myObject = ItemLocationEnum.Feet;
var Result = myConverter.Convert(myObject, null, null, null);
var Expected = 40;
Assert.AreEqual(Expected, Result, TestContext.CurrentContext.Test.Name);
}
public static JsonSerializerSettings DefaultSerializeSettings()
{
var settings = new JsonSerializerSettings();
var stringEnumConverter = new StringEnumConverter(new CamelCaseNamingStrategy());
settings.Converters.Add(stringEnumConverter);
return(settings);
}
public static JsonSerializerSettings CreateDefaultSerializerSettings()
{
var settings = new JsonSerializerSettings();
var stringEnumConverter = new StringEnumConverter();
settings.Converters.Add(stringEnumConverter);
settings.Formatting = Formatting.Indented;
settings.TypeNameHandling = TypeNameHandling.None;
return(settings);
}
public void Model_Converter_StringEnumConverter_Convert_Other_Should_Skip()
{
var myConverter = new StringEnumConverter();
var myObject = new Item();
var Result = myConverter.Convert(myObject, null, null, null);
var Expected = 0;
Assert.AreEqual(Expected, Result, TestContext.CurrentContext.Test.Name);
}
public void StringEnumConvertBack_Enum_Should_Skip()
{
var myConverter = new StringEnumConverter();
var myObject = ItemLocationEnum.Feet;
var Result = myConverter.ConvertBack(myObject, null, null, null);
var Expected = 0;
Assert.AreEqual(Expected, Result, TestContext.CurrentContext.Test.Name);
}
public void StringEnumConverter_NamingStrategyTypeCtor()
{
StringEnumConverter converter = new StringEnumConverter(typeof(CamelCaseNamingStrategy), new object[] { true, true, true }, false);
Assert.IsNotNull(converter.NamingStrategy);
Assert.AreEqual(typeof(CamelCaseNamingStrategy), converter.NamingStrategy.GetType());
Assert.AreEqual(false, converter.AllowIntegerValues);
Assert.AreEqual(true, converter.NamingStrategy.OverrideSpecifiedNames);
Assert.AreEqual(true, converter.NamingStrategy.ProcessDictionaryKeys);
Assert.AreEqual(true, converter.NamingStrategy.ProcessExtensionDataNames);
}
private void SerializeValue(JsonWriter writer, object value, JsonContract valueContract, JsonProperty member, JsonContract collectionValueContract)
{
JsonConverter converter = (member != null) ? member.Converter : null;
if (converter == null && JsonSerializerSettings.DefaultEnumSerializationHandling == EnumSerializationHandling.Name && value is Enum)
{
converter = new StringEnumConverter();
}
if (value == null)
{
writer.WriteNull();
return;
}
if ((converter != null ||
((converter = valueContract.Converter) != null) ||
((converter = Serializer.GetMatchingConverter(valueContract.UnderlyingType)) != null) ||
((converter = valueContract.InternalConverter) != null)) &&
converter.CanWrite)
{
SerializeConvertable(writer, converter, value, valueContract);
}
else if (valueContract is JsonPrimitiveContract)
{
SerializePrimitive(writer, value, (JsonPrimitiveContract)valueContract, member, collectionValueContract);
}
else if (valueContract is JsonStringContract)
{
SerializeString(writer, value, (JsonStringContract)valueContract);
}
else if (valueContract is JsonObjectContract)
{
SerializeObject(writer, value, (JsonObjectContract)valueContract, member, collectionValueContract);
}
else if (valueContract is JsonDictionaryContract)
{
JsonDictionaryContract dictionaryContract = (JsonDictionaryContract)valueContract;
SerializeDictionary(writer, dictionaryContract.CreateWrapper(value), dictionaryContract, member, collectionValueContract);
}
else if (valueContract is JsonArrayContract)
{
JsonArrayContract arrayContract = (JsonArrayContract)valueContract;
SerializeList(writer, arrayContract.CreateWrapper(value), arrayContract, member, collectionValueContract);
}
else if (valueContract is JsonLinqContract)
{
((JToken)value).WriteTo(writer, (Serializer.Converters != null) ? Serializer.Converters.ToArray() : null);
}
else if (valueContract is JsonISerializableContract)
{
SerializeISerializable(writer, (ISerializable)value, (JsonISerializableContract)valueContract);
}
}
private string GetConvertedEnumName(string enumName, bool hasSpecifiedName, StringEnumConverter stringEnumConverter)
{
if (stringEnumConverter.NamingStrategy != null)
{
return(stringEnumConverter.NamingStrategy.GetPropertyName(enumName, hasSpecifiedName));
}
return((stringEnumConverter.CamelCaseText)
? new CamelCaseNamingStrategy().GetPropertyName(enumName, hasSpecifiedName)
: enumName);
}
/// <summary>
/// Enables indented camelCase for ease of reading.
/// </summary>
/// <param name="config">HttpConfiguration for this api</param>
private static void EnableCamelCaseJson(HttpConfiguration config)
{
var jsonFormatter = config.Formatters.OfType <JsonMediaTypeFormatter>().First();
jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
var stringEnumConverter = new StringEnumConverter {
CamelCaseText = true
};
config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(stringEnumConverter);
config.Formatters.JsonFormatter.Indent = true;
}
public static AssignableType <T> FromEnumDict(AnyDictionary dict, string key, T defaultVal = default(T))
{
var str = dict.GetValue <string>(key);
if (str != null)
{
var d = StringEnumConverter.Get <T>();
return(AssignableType <T> .Create(d[str]));
}
// else..
return(new AssignableType <T>(defaultVal, false));
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
switch (reader.Value)
{
case "In Transit":
return(TrackingStatusCode.InTransit);
default:
var converter = new StringEnumConverter();
return(converter.ReadJson(reader, objectType, existingValue, serializer));
}
}
private void InitSerializeSetting()
{
this.Setting = new JsonSerializerSettings();
this.Setting.DefaultValueHandling = DefaultValueHandling.Include;
this.Setting.NullValueHandling = NullValueHandling.Ignore;
this.Setting.ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor;
this.Setting.ReferenceLoopHandling = ReferenceLoopHandling.Serialize;
this.Setting.TypeNameHandling = TypeNameHandling.None;
this.Setting.Formatting = Formatting.Indented;
JsonConverter item = new StringEnumConverter();
this.Setting.Converters.Add(item);
}
/// <inheritdoc />
public void Handle(IJsonContractRequest request)
{
if (request.dataType.IsEnum && Attribute.IsDefined(request.dataType, typeof(FlagsAttribute)))
{
var converter = new StringEnumConverter {
AllowIntegerValues = false
};
request.Return(new JsonPrimitiveContract(request.dataType)
{
Converter = converter
});
}
}
public void ConfigureServices(IServiceCollection services)
{
services
.AddMvc(options => options.EnableEndpointRouting = false)
.AddNewtonsoftJson(opts =>
{
opts.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
var item = new StringEnumConverter {
NamingStrategy = new CamelCaseNamingStrategy()
};
opts.SerializerSettings.Converters.Add(item);
});
}
public static string ObjectToJson2(object value, bool clearLastZero)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Expected O, but got Unknown
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Expected O, but got Unknown
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Expected O, but got Unknown
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Expected O, but got Unknown
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Expected O, but got Unknown
//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Expected O, but got Unknown
Type type = value.GetType();
JsonSerializer val = new JsonSerializer();
val.ObjectCreationHandling = ObjectCreationHandling.Replace;
val.MissingMemberHandling = MissingMemberHandling.Ignore;
val.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
val.ContractResolver = new CamelCasePropertyNamesContractResolver();
JsonConverterCollection converters = val.Converters;
StringEnumConverter val2 = new StringEnumConverter();
val2.CamelCaseText = true;
((Collection <JsonConverter>)converters).Add(val2);
((Collection <JsonConverter>)val.Converters).Add(new StringEnumConverter());
IsoDateTimeConverter val3 = new IsoDateTimeConverter();
val3.DateTimeFormat = "yyyy-MM-dd";
((Collection <JsonConverter>)val.Converters).Add(val3);
val.Formatting = Formatting.None;
val.NullValueHandling = NullValueHandling.Ignore;
if (clearLastZero)
{
((Collection <JsonConverter>)val.Converters).Add(new MinifiedNumArrayConverter());
}
StringWriter stringWriter = new StringWriter();
JsonTextWriter val4 = new JsonTextWriter((TextWriter)stringWriter);
val4.Formatting = Formatting.None;
val4.QuoteChar = '"';
val4.QuoteName = false;
val.Serialize(val4, value);
string text = stringWriter.ToString();
val4.Close();
stringWriter.Close();
return(text.Replace("coreCharts", "echarts", StringComparison.CurrentCultureIgnoreCase));
}
public void ConfigureServices(IServiceCollection services)
{
services.AddApplicationLayer();
services.AddSharedInfrastructure(Config);
services.AddSwaggerExtension();
services.AddControllers()
.AddNewtonsoftJson(options =>
{
var converter = new StringEnumConverter(namingStrategy: new CamelCaseNamingStrategy());
options.SerializerSettings.Converters.Add(converter);
});
services.AddApiVersioningExtension();
services.AddHealthChecks();
}
public DefaultResolver(TypeCache typeCache)
{
StringEnumConverter = new StringEnumConverter();
TypeConverter = new TypeConverter();
AsyncEnumerableConverter = new AsyncEnumerableConverter();
HeadersConverter = new HeadersConverter();
ContentTypeConverter = new ContentTypeConverter();
ContentTypesConverter = new ContentTypesConverter();
ToStringConverter = new ToStringConverter();
AggregatorTemplateConverter = new AggregatorTemplateConverter();
TypeCache = typeCache;
DateTimeConverters = new Dictionary <string, DateTimeConverter>();
}
/// <summary>
/// Dynamically creates an instance of JSON.NET
/// </summary>
/// <param name="throwExceptions">If true throws exceptions otherwise returns null</param>
/// <returns>Dynamic JsonSerializer instance</returns>
public static JsonSerializer CreateJsonNet(bool throwExceptions = true, bool camelCase = false)
{
if (JsonNet != null)
{
return(JsonNet);
}
lock (SyncLock)
{
if (JsonNet != null)
{
return(JsonNet);
}
// Try to create instance
JsonSerializer json;
try
{
json = new JsonSerializer();
}
catch
{
if (throwExceptions)
{
throw;
}
return(null);
}
if (json == null)
{
return(null);
}
json.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
// Enums as strings in JSON
var enumConverter = new StringEnumConverter();
json.Converters.Add(enumConverter);
if (camelCase)
{
json.ContractResolver = new CamelCasePropertyNamesContractResolver();
}
JsonNet = json;
}
return(JsonNet);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
switch (reader.Value)
{
case "10KG":
return(ParcelType.UPS_10KG);
case "25KG":
return(ParcelType.UPS_25KG);
default:
var converter = new StringEnumConverter();
return(converter.ReadJson(reader, objectType, existingValue, serializer));
}
}
public void EnumMemberWithNumbers()
{
StringEnumConverter converter = new StringEnumConverter();
NumberNamesEnum e = JsonConvert.DeserializeObject <NumberNamesEnum>("\"1\"", converter);
Assert.AreEqual(NumberNamesEnum.second, e);
e = JsonConvert.DeserializeObject <NumberNamesEnum>("\"2\"", converter);
Assert.AreEqual(NumberNamesEnum.first, e);
e = JsonConvert.DeserializeObject <NumberNamesEnum>("\"3\"", converter);
Assert.AreEqual(NumberNamesEnum.third, e);
}
static ClientModel()
{
DefaultJsonSerializerSetting = new JsonSerializerSettings()
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
Error = delegate(object sender, Newtonsoft.Json.Serialization.ErrorEventArgs args)
{
args.ErrorContext.Handled = true;
}
};
var enumConverter = new StringEnumConverter();
enumConverter.CamelCaseText = true;
DefaultJsonSerializerSetting.Converters.Add(enumConverter);
}
private void Send(CowMessage cowMessage)
{
var cowStringEnumConvertor = new StringEnumConverter {
CamelCaseText = false
};
var jsonSerializerSettings = new JsonSerializerSettings
{
Formatting = Formatting.None,
NullValueHandling = NullValueHandling.Ignore
};
jsonSerializerSettings.Converters.Add(cowStringEnumConvertor);
var message = JsonConvert.SerializeObject(cowMessage, jsonSerializerSettings);
_proxy.Invoke("Send", message);
}
private static JsonSerializerSettings CreateDefaultSerializerSettings()
{
var serializingSettings = new JsonSerializerSettings
{
Formatting = Formatting.None,
NullValueHandling = NullValueHandling.Ignore
};
var enumConverter = new StringEnumConverter {
AllowIntegerValues = false
};
serializingSettings.Converters.Add(enumConverter);
return(serializingSettings);
}
