public void SerializeUsingInternalConverter()
{
DefaultContractResolver contractResolver = new DefaultContractResolver();
JsonObjectContract contract = (JsonObjectContract) contractResolver.ResolveContract(typeof (KeyValuePair<string, int>));
Assert.Equal(typeof(KeyValuePairConverter), contract.InternalConverter.GetType());
IList<KeyValuePair<string, int>> values = new List<KeyValuePair<string, int>>
{
new KeyValuePair<string, int>("123", 123),
new KeyValuePair<string, int>("456", 456)
};
string json = JsonConvert.SerializeObject(values, Formatting.Indented);
StringAssert.Equal(@"[
{
""Key"": ""123"",
""Value"": 123
},
{
""Key"": ""456"",
""Value"": 456
}
]", json);
IList<KeyValuePair<string, int>> v2 = JsonConvert.DeserializeObject<IList<KeyValuePair<string, int>>>(json);
Assert.Equal(2, v2.Count);
Assert.Equal("123", v2[0].Key);
Assert.Equal(123, v2[0].Value);
Assert.Equal("456", v2[1].Key);
Assert.Equal(456, v2[1].Value);
}
public RelationContractResolver(DefaultContractResolver original, DocumentConvention documentConvention, IEnumerable<Type> rootTypes)
: base(true)
{
_rootTypes = new HashSet<Type>();
_referenceConverter = new ReferenceConverter(documentConvention);
foreach (var rootType in rootTypes)
{
_rootTypes.Add(rootType);
}
DefaultMembersSearchFlags = original.DefaultMembersSearchFlags;
}
public void AddPropertyIncludesPrivateImplementations()
{
var value = new PrivateImplementationBClass
{
OverriddenProperty = "OverriddenProperty",
PropertyA = "PropertyA",
PropertyB = "PropertyB"
};
var resolver = new DefaultContractResolver();
var contract = (JsonObjectContract) resolver.ResolveContract(value.GetType());
Assert.AreEqual(3, contract.Properties.Count);
Assert.IsTrue(contract.Properties.Contains("OverriddenProperty"), "Contract is missing property 'OverriddenProperty'");
Assert.IsTrue(contract.Properties.Contains("PropertyA"), "Contract is missing property 'PropertyA'");
Assert.IsTrue(contract.Properties.Contains("PropertyB"), "Contract is missing property 'PropertyB'");
}
//Problem 07.Export Categories by Products Count
public static string GetCategoriesByProductsCount(ProductShopContext context)
{
//var categories = context.Categories
// .OrderByDescending(c => c.CategoryProducts.Count)
// .Select(c => new
// {
// Category = c.Name,
// ProductsCount = c.CategoryProducts.Count,
// AveragePrice = $"{c.CategoryProducts.Average(p => p.Product.Price):f2}",
// TotalRevenue = $"{c.CategoryProducts.Sum(p => p.Product.Price):f2}"
// })
// .ToList();
var categories = context.Categories
.OrderByDescending(c => c.CategoryProducts.Count)
.Select(c => new
{
Category = c.Name,
ProductsCount = c.CategoryProducts.Count,
AveragePrice = $"{(c.CategoryProducts.Sum(p => p.Product.Price)/c.CategoryProducts.Count):f2}",
TotalRevenue = $"{c.CategoryProducts.Sum(p => p.Product.Price):f2}"
})
.ToList();
DefaultContractResolver contractResolver = new DefaultContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
};
var jsonSettings = new JsonSerializerSettings
{
Formatting = Formatting.Indented,
ContractResolver = contractResolver
};
string categoriesAsJson = JsonConvert.SerializeObject(categories, jsonSettings);
return(categoriesAsJson);
}
public async Task <bool> Print(VehicleRecord vehicle)
{
try
{
var printerUrl = Settings.PrinterUrl;
if (String.IsNullOrWhiteSpace(printerUrl))
{
return(true);
}
using (HttpClient client = new HttpClient())
{
var resolver = new DefaultContractResolver()
{
NamingStrategy = new SnakeCaseNamingStrategy()
};
var jsonSettings = new JsonSerializerSettings()
{
ContractResolver = resolver
};
string content = JsonConvert.SerializeObject(vehicle, jsonSettings);
StringContent body = new StringContent(content, Encoding.UTF8, "application/json");
client.Timeout = new TimeSpan(0, 0, 10);
var result = await client.PostAsync(printerUrl, body);
var data = await result.Content.ReadAsStringAsync();
return(result.IsSuccessStatusCode);
}
}
catch
{
return(false);
}
}
private static string GetErrorData(string errorData, out string innerError)
{
innerError = string.Empty;
var contractResolver = new DefaultContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
};
var jsContent = (JObject)JsonConvert.DeserializeObject(errorData, new JsonSerializerSettings()
{
ContractResolver = contractResolver
});
IDictionary <string, JToken> d = jsContent;
if (d.TryGetValue("error", out var error))
{
var jsError = error as JObject;
if (jsError.TryGetValue("innererror", out var innerEx))
{
innerError = innerEx.ToString();
}
if (jsError.TryGetValue("message", out var message))
{
return(message.ToString());
}
return(error.ToString());
}
else if (d.TryGetValue("Message", out var message))
{
return(message.ToString());
}
return(errorData);
}
/// <summary>
/// Writes the JSON representation of the object.
/// </summary>
/// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
/// <param name="value">The value.</param>
/// <param name="serializer">The calling serializer.</param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
EnsureReflectionObject(value.GetType());
DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;
string keyName = (string)_reflectionObject.GetValue(value, KeyPropertyName);
object keyValue = _reflectionObject.GetValue(value, ValuePropertyName);
Type keyValueType = (keyValue != null) ? keyValue.GetType() : null;
writer.WriteStartObject();
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(KeyPropertyName) : KeyPropertyName);
writer.WriteValue(keyName);
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(TypePropertyName) : TypePropertyName);
writer.WriteValue((keyValueType != null) ? keyValueType.FullName : null);
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(ValuePropertyName) : ValuePropertyName);
if (keyValueType != null)
{
string valueJson;
if (JsonSerializerInternalWriter.TryConvertToString(keyValue, keyValueType, out valueJson))
{
writer.WriteValue(valueJson);
}
else
{
writer.WriteValue(keyValue);
}
}
else
{
writer.WriteNull();
}
writer.WriteEndObject();
}
public JsonSerializerSettings CreateDeserializationSettings(Type type)
{
if (!mapping.ContainsKey(type))
{
JsonSerializerSettings settings = new JsonSerializerSettings();
if (type == typeof(Token))
{
DefaultContractResolver contractResolver = new DefaultContractResolver
{
NamingStrategy = new SnakeCaseNamingStrategy()
};
settings.ContractResolver = contractResolver;
}
else
{
settings.ContractResolver = this.deserializationContractResolver;
}
mapping[type] = settings;
}
return(mapping[type]);
}
public void ListInterfaceDefaultCreator()
{
var resolver = new DefaultContractResolver();
var contract = (JsonArrayContract)resolver.ResolveContract(typeof(IList <int>));
Assert.IsTrue(contract.IsInstantiable);
Assert.IsNotNull(contract.DefaultCreator);
contract.DefaultCreator = () => new CustomList <int>();
var l = JsonConvert.DeserializeObject <IList <int> >(
@"[1,2,3]",
new JsonSerializerSettings {
ContractResolver = resolver
}
);
Assert.AreEqual(typeof(CustomList <int>), l.GetType());
Assert.AreEqual(3, l.Count);
Assert.AreEqual(1, l[0]);
Assert.AreEqual(2, l[1]);
Assert.AreEqual(3, l[2]);
}
private PushMessage FromModel(PushMessageModel model)
{
var contractResolver = new DefaultContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
};
var serializationSettings = new JsonSerializerSettings()
{
ContractResolver = contractResolver,
NullValueHandling = NullValueHandling.Ignore
};
var serialized = JsonConvert.SerializeObject(model, serializationSettings);
var content = new StringContent(serialized, Encoding.UTF8, "application/json");
var pushMessage = new PushMessage(content)
{
//Topic = message.Topic,
//Urgency = message.Urgency
};
return(pushMessage);
}
public void Test_DoesNotThrowException_IfTestIsSuccessful()
{
// Arrange
var key = "Name";
var dictionary = new Dictionary <string, List <object> >();
var value = new List <object>()
{
"James",
2,
new Customer("James", 25)
};
dictionary[key] = value;
var dictionaryAdapter = new DictionaryAdapter <string, List <object> >();
var resolver = new DefaultContractResolver();
// Act
var testStatus = dictionaryAdapter.TryTest(dictionary, key, resolver, value, out var message);
//Assert
Assert.True(testStatus);
Assert.True(string.IsNullOrEmpty(message), "Expected no error message");
}
public Task BroadcastMessage(string name, string message)
{
WebSocketItem webSocketItem = new WebSocketItem
{
Command = WebSocketCommand.ChatMsg,
Name = name,
Message = message
};
// ref: https://www.newtonsoft.com/json/help/html/NamingStrategyCamelCase.htm (200828)
DefaultContractResolver contractResolver = new DefaultContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
};
string jsonStr = JsonConvert.SerializeObject(webSocketItem, new JsonSerializerSettings
{
ContractResolver = contractResolver,
Formatting = Formatting.Indented
});
return(BroadcastJsonMessage(jsonStr));
}
public async Task <IActionResult> GetHierarchyTree(int?parentId)
{
AccountHierarchy root = parentId.HasValue ?
await _dbContext.AccountHierarchies.FindAsync((long)parentId) :
await _dbContext.AccountHierarchies.OrderBy(a => a.Id).FirstOrDefaultAsync();
TreeBuilder treeBuilder = new TreeBuilder(_dbContext);
//var account = treeBuilder.BuildHierarchyTreeRecursive(root);
var account = treeBuilder.BuildHierarchyTreeRecursive(root);
DefaultContractResolver contractResolver = new DefaultContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
};
string json = JsonConvert.SerializeObject(account, new JsonSerializerSettings
{
ContractResolver = contractResolver,
Formatting = Formatting.Indented
});
//Console.WriteLine(json);
return(View("GetTree", json));
}
//Problem 16 - Export Local Suppliers
public static string GetLocalSuppliers(CarDealerContext context)
{
var suppliers = context
.Suppliers
.Where(s => !s.IsImporter)
.ToList();
var supplierDtos = Mapper.Map <IEnumerable <Supplier>,
IEnumerable <SupplierDto> >(suppliers);
DefaultContractResolver contractResolver = new DefaultContractResolver()
{
NamingStrategy = new CamelCaseNamingStrategy()
};
var jsonResult = JsonConvert.SerializeObject(supplierDtos, new JsonSerializerSettings()
{
ContractResolver = contractResolver,
Formatting = Formatting.Indented
});
return(jsonResult);
}
public void TryTest_DoesNotThrowException_IfTestSuccessful()
{
var adapter = new DynamicObjectAdapter();
dynamic target = new DynamicTestObject();
var value = new List <object>()
{
"Joana",
2,
new Customer("Joana", 25)
};
target.NewProperty = value;
var segment = "NewProperty";
var resolver = new DefaultContractResolver();
// Act
var testStatus = adapter.TryTest(target, segment, resolver, value, out string errorMessage);
// Assert
Assert.Equal(value, target.NewProperty);
Assert.True(testStatus);
Assert.True(string.IsNullOrEmpty(errorMessage), "Expected no error message");
}
/// <summary>
/// PascalCase로 이뤄진 객체를 snake_case json으로 직렬화.
/// </summary>
/// <typeparam name="T">변환할 객체 형태</typeparam>
/// <param name="obj">변환할 객체</param>
/// <returns></returns>
private static JObject SerializeSnakeCase <T>(T obj)
{
DefaultContractResolver contractResolver = new DefaultContractResolver
{
NamingStrategy = new SnakeCaseNamingStrategy()
};
try
{
var json = JsonConvert.SerializeObject(obj, new JsonSerializerSettings
{
ContractResolver = contractResolver,
Formatting = Formatting.Indented
});
return(JObject.Parse(json));
}
catch (Exception e)
{
Debug.WriteLine(e);
}
return(new JObject());
}
public BaseController()
{
_placesService = DiProxy.Get <IPlacesService>();
_sessionOperator = DiProxy.Get <SessionOperator>();
_mapper = DiProxy.Get <IMapper>();
_localeService = DiProxy.Get <ILocalizationService>();
_localizer = DiProxy.Get <ILocalizer>();
var config = DiProxy.Get <ConfigValuesCollection>();
_userFilesUrlPrefix = config.GetUserFilesUrlPrefix();
var contractResolver = new DefaultContractResolver()
{
NamingStrategy = new CamelCaseNamingStrategy()
};
_jsonSerializerSettings = new JsonSerializerSettings()
{
ContractResolver = contractResolver
};
_jsonSerializerSettings.Converters.Add(new StringEnumConverter());
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
var formatter = GlobalConfiguration.Configuration.Formatters.JsonFormatter;
DefaultContractResolver contractResolver = new DefaultContractResolver
{
NamingStrategy = new SnakeCaseNamingStrategy()
};
formatter.SerializerSettings.ContractResolver = contractResolver;
config.Formatters.Clear();
config.Formatters.Add(formatter);
}
public AdyenHttpClient(HttpClient httpClient, IConfiguration configuration, ILogger <AdyenHttpClient> logger)
{
_httpClient = httpClient;
string apiKey = configuration["ApiKey"];
_httpClient.DefaultRequestHeaders.Add("X-API-key", apiKey);
_logger = logger;
_contractResolver = new DefaultContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
};
_jsonSerializeSettings = new JsonSerializerSettings()
{
ContractResolver = _contractResolver,
Formatting = Formatting.Indented,
ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
NullValueHandling = NullValueHandling.Ignore
};
IConfigurationSection adyenConfig = configuration.GetSection("AdyenConfiguration");
_configuration = adyenConfig.Get <AdyenConfiguration>();
}
/// <summary>
/// snake_case로 이뤄진 Json을 PascalCase로 역직렬화.
/// </summary>
/// <typeparam name="T">반환 형태</typeparam>
/// <param name="json">목표 Json</param>
/// <returns>역직렬화된 Json</returns>
private static T DeserializeSnakeCase <T>(string json)
{
DefaultContractResolver contractResolver = new DefaultContractResolver
{
NamingStrategy = new SnakeCaseNamingStrategy()
};
try
{
var resp = JsonConvert.DeserializeObject <T>(json, new JsonSerializerSettings
{
ContractResolver = contractResolver,
Formatting = Formatting.Indented
});
return(resp);
}
catch (Exception e)
{
Debug.WriteLine(e);
}
return(default(T));
}
public async Task <IActionResult> Handle(SendPushNotificationsCommand request, CancellationToken cancellationToken)
{
var pushNotificationToSend = _mapper.Map <PushNotification>(request);
foreach (var notification in request.PushNotificationIds)
{
DefaultContractResolver contractResolver = new DefaultContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
};
pushNotificationToSend.To = notification;
var pushNotification = await "https://fcm.googleapis.com/fcm".AppendPathSegment("send")
.WithHeader("Authorization", "key=AAAAp6mIFl8:APA91bGoewvoSfIbLcHFL4OCxPa19drL-pWuQ5YYpsGh3gh_xdWLyZTS2F3pwpUJpMPWPiIpkJTq0oPbIomCCpG3zFTEutxDJGJT703uebKnTCFnYe9GcqzIuFURQwYueOIW6eINonjY")
.PostAsync(new StringContent(JsonConvert.SerializeObject(pushNotificationToSend, new JsonSerializerSettings
{
ContractResolver = contractResolver,
Formatting = Formatting.Indented
}), Encoding.UTF8, "application/json"))
.ReceiveJson();
}
return(HttpResponseCodeHelper.NotContent());
}
public async Task SendSignal(string signal, string targetConnectionId)
{
var callingUser = User.Get(Context.ConnectionId);
var targetUser = User.Get(targetConnectionId);
if (callingUser == null || targetUser == null)
{
return;
}
var contractResolver = new DefaultContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
};
var call = JsonConvert.SerializeObject(callingUser, new JsonSerializerSettings
{
ContractResolver = contractResolver,
Formatting = Formatting.Indented
});
await Clients.Client(targetConnectionId).SendAsync("receiveSignal", call, signal);
}
public async Task CacheResponseAsync(string cacheKey, object response, TimeSpan timeToLive)
{
if (response == null)
{
return;
}
var contractResolver = new DefaultContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy
{
OverrideSpecifiedNames = false
}
};
var serialisedResponse = JsonConvert.SerializeObject(response, new JsonSerializerSettings
{
ContractResolver = contractResolver,
Formatting = Formatting.Indented
});
await _database.StringSetAsync(cacheKey, serialisedResponse, timeToLive);
}
//------------------- TASK 16 ---- EXPORT LOCAL SUPPLERS --------------------------------
public static string GetLocalSuppliers(CarDealerContext context)
{
var suppliers = context.Suppliers.Where(s => s.IsImporter == false)
.Select(s => new
{
Id = s.Id,
Name = s.Name,
PartsCount = s.Parts.Count,
})
.ToArray();
var resolver = new DefaultContractResolver()
{
NamingStrategy = new DefaultNamingStrategy()
};
string json = JsonConvert.SerializeObject(suppliers, new JsonSerializerSettings()
{
ContractResolver = resolver,
Formatting = Formatting.Indented
});
return(json);
}
public string GetJson()
{
if (!CheckEnvironment())
{
return(null);
}
var jsonobj = new
{
build,
os,
run,
tests
};
var settings = new JsonSerializerSettings();
var resolver = new DefaultContractResolver();
resolver.NamingStrategy = new CamelCaseNamingStrategy()
{
ProcessDictionaryKeys = false
};
settings.ContractResolver = resolver;
return(JsonConvert.SerializeObject(jsonobj, Formatting.Indented, settings));
}
public async Task <ActionResult <EFRepo.Entities.Task> > PostTask(EFRepo.Entities.Task task)
{
_context.Tasks.Add(task);
await _context.SaveChangesAsync();
var createdAtAction = CreatedAtAction("GetTask", new { id = task.TaskId }, task);
var contractResolver = new DefaultContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
};
var taskJSON = JsonConvert.SerializeObject(task, new JsonSerializerSettings
{
ContractResolver = contractResolver,
Formatting = Formatting.Indented,
NullValueHandling = NullValueHandling.Ignore
});
await SendTaskCreatedEventToAMQP(createdAtAction, taskJSON);
return(createdAtAction);
}
public void CustomOverrideCreator()
{
var resolver = new DefaultContractResolver();
var contract = (JsonObjectContract)resolver.ResolveContract(typeof(MultipleParametrizedConstructorsJsonConstructor));
bool ensureCustomCreatorCalled = false;
contract.OverrideCreator = args =>
{
ensureCustomCreatorCalled = true;
return(new MultipleParametrizedConstructorsJsonConstructor((string)args[0], (int)args[1]));
};
Assert.IsNotNull(contract.OverrideCreator);
var o = JsonConvert.DeserializeObject <MultipleParametrizedConstructorsJsonConstructor>("{Value:'value!', Age:1}", new JsonSerializerSettings
{
ContractResolver = resolver
});
Assert.AreEqual("value!", o.Value);
Assert.AreEqual(1, o.Age);
Assert.IsTrue(ensureCustomCreatorCalled);
}
public void ReplacePropertyValue_ForExpandoObject_WithCustomNamingStrategy()
{
// Arrange
var contractResolver = new DefaultContractResolver
{
NamingStrategy = new TestNamingStrategy()
};
dynamic targetObject = new ExpandoObject();
targetObject.customTest = 1;
var patchDocument = new JsonPatchDocument();
patchDocument.Replace("Test", 2);
patchDocument.ContractResolver = contractResolver;
// Act
patchDocument.ApplyTo(targetObject);
// Assert
Assert.Equal(2, targetObject.customTest);
}
public void AbstractTestClass()
{
var resolver = new DefaultContractResolver();
var contract = (JsonObjectContract)resolver.ResolveContract(typeof(AbstractTestClass));
Assert.IsFalse(contract.IsInstantiable);
Assert.IsNull(contract.DefaultCreator);
Assert.IsNull(contract.OverrideCreator);
ExceptionAssert.Throws <JsonSerializationException>(() => JsonConvert.DeserializeObject <AbstractTestClass>(@"{Value:'Value!'}", new JsonSerializerSettings
{
ContractResolver = resolver
}), "Could not create an instance of type Newtonsoft.Json.Tests.Serialization.AbstractTestClass. Type is an interface or abstract class and cannot be instantiated. Path 'Value', line 1, position 7.");
contract.DefaultCreator = () => new AbstractImplementationTestClass();
var o = JsonConvert.DeserializeObject <AbstractTestClass>(@"{Value:'Value!'}", new JsonSerializerSettings
{
ContractResolver = resolver
});
Assert.AreEqual("Value!", o.Value);
}
public void Add_WithIndexSameAsNumberOfElements_Works()
{
// Arrange
var resolver = new DefaultContractResolver();
var targetObject = new List <string>()
{
"James", "Mike"
};
var listAdapter = new ListAdapter();
var position = targetObject.Count.ToString(CultureInfo.InvariantCulture);
// Act
var addStatus = listAdapter.TryAdd(targetObject, position, resolver, "Rob", out var message);
// Assert
Assert.Null(message);
Assert.True(addStatus);
Assert.Equal(3, targetObject.Count);
Assert.Equal(new List <string>()
{
"James", "Mike", "Rob"
}, targetObject);
}
/// <summary>
/// Writes the JSON representation of the object.
/// </summary>
/// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
/// <param name="value">The value.</param>
/// <param name="serializer">The calling serializer.</param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;
Type t = value.GetType();
object result = FSharpUtils.GetUnionFields(null, value, t, null);
object info = FSharpUtils.GetUnionCaseInfo(result);
object fields = FSharpUtils.GetUnionCaseFields(result);
object caseName = FSharpUtils.GetUnionCaseInfoName(info);
object[] fieldsAsArray = fields as object[];
writer.WriteStartObject();
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(CasePropertyName) : CasePropertyName);
writer.WriteValue((string)caseName);
if (fieldsAsArray != null && fieldsAsArray.Length > 0)
{
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(FieldsPropertyName) : FieldsPropertyName);
serializer.Serialize(writer, fields);
}
writer.WriteEndObject();
}
public void Orderby_RespectsConfiguredNamingStrategy(DefaultContractResolver contractResolver)
{
using (WithContractResolver(contractResolver))
{
SpawnData(data);
var namingStrategy = contractResolver.NamingStrategy ?? new DefaultNamingStrategy();
var expected = RethinkDB.R.Table(TableName)
.OrderBy(namingStrategy.GetPropertyName(nameof(TestObject.SimpleProperty), false));
var queryable = GetQueryable <TestObject>(TableName, expected);
var result =
(
from testObject in queryable
orderby testObject.SimpleProperty
select testObject
).ToList();
Assert.NotNull(result);
}
}
public void WhenSerializationErrorDetectedBySerializer_ThenCallbackIsCalled()
{
// Verify contract is properly finding our callback
var resolver = new DefaultContractResolver().ResolveContract(typeof(FooEvent));
#pragma warning disable 612,618
Debug.Assert(resolver.OnError != null);
Debug.Assert(resolver.OnError == typeof(FooEvent).GetMethod("OnError", BindingFlags.Instance | BindingFlags.NonPublic));
#pragma warning restore 612,618
var serializer = JsonSerializer.Create(new JsonSerializerSettings
{
// If I don't specify Error here, the callback isn't called
// either, but no exception is thrown.
MissingMemberHandling = MissingMemberHandling.Error,
});
// This throws with missing member exception, rather than calling my callback.
var foo = serializer.Deserialize <FooEvent>(new JsonTextReader(new StringReader("{ Id: 25 }")));
// When fixed, this would pass.
Debug.Assert(foo.Identifier == 25);
}
public void SerializeCompilerGeneratedMembers()
{
StructTest structTest = new StructTest
{
IntField = 1,
IntProperty = 2,
StringField = "Field",
StringProperty = "Property"
};
DefaultContractResolver skipCompilerGeneratedResolver = new DefaultContractResolver
{
DefaultMembersSearchFlags = BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public
};
string skipCompilerGeneratedJson = JsonConvert.SerializeObject(structTest, Formatting.Indented,
new JsonSerializerSettings { ContractResolver = skipCompilerGeneratedResolver });
Assert.AreEqual(@"{
""StringField"": ""Field"",
""IntField"": 1,
""StringProperty"": ""Property"",
""IntProperty"": 2
}", skipCompilerGeneratedJson);
DefaultContractResolver includeCompilerGeneratedResolver = new DefaultContractResolver
{
DefaultMembersSearchFlags = BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public,
SerializeCompilerGeneratedMembers = true
};
string includeCompilerGeneratedJson = JsonConvert.SerializeObject(structTest, Formatting.Indented,
new JsonSerializerSettings { ContractResolver = includeCompilerGeneratedResolver });
Assert.AreEqual(@"{
""StringField"": ""Field"",
""IntField"": 1,
""<StringProperty>k__BackingField"": ""Property"",
""<IntProperty>k__BackingField"": 2,
""StringProperty"": ""Property"",
""IntProperty"": 2
}", includeCompilerGeneratedJson);
}
public void WhenSerializationErrorDetectedBySerializer_ThenCallbackIsCalled()
{
// Verify contract is properly finding our callback
var resolver = new DefaultContractResolver().ResolveContract(typeof(FooEvent));
Debug.Assert(resolver.OnError != null);
Debug.Assert(resolver.OnError == typeof(FooEvent).GetMethod("OnError", BindingFlags.Instance | BindingFlags.NonPublic));
var serializer = JsonSerializer.Create(new JsonSerializerSettings
{
// If I don't specify Error here, the callback isn't called
// either, but no exception is thrown.
MissingMemberHandling = MissingMemberHandling.Error,
});
// This throws with missing member exception, rather than calling my callback.
var foo = serializer.Deserialize<FooEvent>(new JsonTextReader(new StringReader("{ Id: 25 }")));
// When fixed, this would pass.
Debug.Assert(foo.Identifier == 25);
}
