According to RFC 7159,
"Hello world!"
is valid JSON.
How can I deserialize such strings to objects?
Imaging something like:
[DataContract]
public class StringValueObject {
public string Value { get; set; }
}
StringValueObject result = JsonConvert.DeserializeObject<StringValueObject>("\"Hello world!\"");
Thanks for everyone, I have found it:
StringValueObject result = JsonConvert.DeserializeObject<StringValueObject>("\"myString\"");
Now working:
[TypeConverter(typeof(StringValueConverter))]
public class StringValueObject {
public string Value { get; set; }
}
public class StringValueConverter : TypeConverter {
public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) {
if (sourceType == typeof(string)) {
return true;
}
return base.CanConvertFrom(context, sourceType);
}
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) {
if (destinationType == typeof(StringValueObject)) {
return true;
}
return base.CanConvertTo(context, destinationType);
}
public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value) {
if (value is string) {
return new StringValueObject {Value = (string) value};
}
return base.ConvertFrom(context, culture, value);
}
public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType) {
if (destinationType == typeof(string) && value is StringValueObject) {
return ((StringValueObject) value).Value;
}
return base.ConvertTo(context, culture, value, destinationType);
}
}
Related
Unfortunately we didn't add the NodaTime.Serialization configuration to the NEventStore wiring when we started this project.
That means we have JSON documents in NEventStore like this.
Note. Simplified view. Not actually an event representation.
dates.json
{
"$type": "NodatimeIssueTest.Product, NodatimeIssueTest",
"FirstDate": {
"$type": "NodaTime.LocalDate, NodaTime",
"ticks": 12304224000000000,
"calendar": "ISO"
},
"SecondDate": {
"$type": "System.Nullable`1[[NodaTime.LocalDate, NodaTime]], mscorlib",
"ticks": 12304224000000000,
"calendar": "ISO"
},
"OtherDates": [
{
"$type": "NodaTime.LocalDate, NodaTime",
"ticks": 12304224000000000,
"calendar": "ISO"
}
],
"FirstDateTime": {
"$type": "NodaTime.LocalDateTime, NodaTime",
"ticks": 12304734100000000,
"calendar": "ISO"
},
"FirstInstant": {
"$type": "NodaTime.Instant, NodaTime",
"ticks": 12304734100000000
}
}
Instead of this
{
"$type": "NodatimeIssueTest.Product, NodatimeIssueTest",
"FirstDate": "2008-12-28",
"SecondDate": "2008-12-28",
"OtherDates": [
"2008-12-28"
],
"FirstDateTime": "2008-12-28T14:10:10",
"FirstInstant": "2008-12-28T14:10:10Z"
}
Because of this we have hard time to upgrade to latest NodaTime package because we can't deserialize the json document anymore.
One solution would be to read all the NEventStore commits and serialize with correct NodaTime parsers. But if this could be avoided I would be happy.
Another option would be to do custom conversion and data binding.
But that requires low level Nodatime logic. Although we don't need to cover all calendars for example.
Solution with custom converters and binder for dates.json example in question
using System;
using System.Collections.Generic;
using System.IO;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using NodaTime;
using NodaTime.Serialization.JsonNet;
using NUnit.Framework;
namespace NodatimeIssueTest
{
[TestFixture]
public class TestClass
{
[Test]
public void Deserialize()
{
var serializer = new JsonSerializer();
serializer.NullValueHandling = NullValueHandling.Ignore;
serializer.TypeNameHandling = TypeNameHandling.Objects;
//Custom converters and binder
serializer.Converters.Add(new NodaLocalDateConverter());
serializer.Converters.Add(new NodaLocalDateTimeConverter());
serializer.Converters.Add(new NodaInstantConverter());
serializer.SerializationBinder = new CustomBinder();
using (var sr = new StreamReader($#"{TestContext.CurrentContext.TestDirectory}\dates.json"))
using (var reader = new JsonTextReader(sr))
{
var product = serializer.Deserialize<Product>(reader);
Assert.AreEqual(new LocalDate(2008, 12, 28), product.FirstDate);
Assert.AreEqual(new LocalDate(2008, 12, 28), product.SecondDate);
Assert.AreEqual(new LocalDate(2008, 12, 28), product.OtherDates[0]);
Assert.AreEqual(new LocalDateTime(2008, 12, 28, 14, 10, 10), product.FirstDateTime);
Assert.AreEqual(Instant.FromUtc(2008, 12, 28, 14, 10, 10), product.FirstInstant);
}
}
}
public class Product
{
public LocalDate FirstDate { get; set; }
public LocalDate? SecondDate { get; set; }
public List<LocalDate> OtherDates { get; set; }
public LocalDateTime FirstDateTime { get; set; }
public Instant FirstInstant { get; set; }
}
public class NodaLocalDateConverter : JsonConverter
{
public override bool CanWrite => false;
public override bool CanRead => true;
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
throw new NotImplementedException();
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null) return null;
if (reader.TokenType == JsonToken.StartObject)
{
var custom = (CustomLocalDate) serializer.Deserialize(reader, typeof(CustomLocalDate));
var dateTime = new DateTime(custom.Ticks, DateTimeKind.Utc).AddTicks(new DateTime(1970, 1, 1).Ticks);
var local = LocalDate.FromDateTime(dateTime, CalendarSystem.Iso);
return local;
}
return null;
}
public override bool CanConvert(Type objectType)
{
return objectType == typeof(LocalDate) || objectType == typeof(LocalDate?);
}
}
public class NodaLocalDateTimeConverter : JsonConverter
{
public override bool CanWrite => false;
public override bool CanRead => true;
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
throw new NotImplementedException();
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null) return null;
if (reader.TokenType == JsonToken.StartObject)
{
var custom = (CustomLocalDateTime) serializer.Deserialize(reader, typeof(CustomLocalDateTime));
var dateTime = new DateTime(custom.Ticks, DateTimeKind.Utc).AddTicks(new DateTime(1970, 1, 1).Ticks);
var local = LocalDateTime.FromDateTime(dateTime, CalendarSystem.Iso);
return local;
}
return null;
}
public override bool CanConvert(Type objectType)
{
return objectType == typeof(LocalDateTime) || objectType == typeof(LocalDateTime?);
}
}
public class NodaInstantConverter : JsonConverter
{
public override bool CanWrite => false;
public override bool CanRead => true;
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
throw new NotImplementedException();
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null) return null;
if (reader.TokenType == JsonToken.StartObject)
{
var custom = (CustomInstant) serializer.Deserialize(reader, typeof(CustomInstant));
var dateTime = new DateTime(custom.Ticks, DateTimeKind.Utc).AddTicks(new DateTime(1970, 1, 1).Ticks);
var local = Instant.FromDateTimeUtc(dateTime);
return local;
}
return null;
}
public override bool CanConvert(Type objectType)
{
return objectType == typeof(Instant) || objectType == typeof(Instant?);
}
}
public class CustomBinder : DefaultSerializationBinder
{
public override Type BindToType(string assemblyName, string typeName)
{
switch (typeName)
{
case "NodaTime.LocalDate": return typeof(CustomLocalDate);
case "System.Nullable`1[[NodaTime.LocalDate, NodaTime]]": return typeof(CustomLocalDate);
case "NodaTime.LocalDateTime": return typeof(CustomLocalDateTime);
case "System.Nullable`1[[NodaTime.LocalDateTime, NodaTime]]": return typeof(CustomLocalDateTime);
case "NodaTime.Instant": return typeof(CustomInstant);
case "System.Nullable`1[[NodaTime.Instant, NodaTime]]": return typeof(CustomInstant);
default: return base.BindToType(assemblyName, typeName);
}
}
}
public class CustomLocalDate
{
[JsonProperty("ticks")] public long Ticks { get; set; }
[JsonProperty("calendar")] public string Calendar { get; set; }
}
public class CustomLocalDateTime
{
[JsonProperty("ticks")] public long Ticks { get; set; }
[JsonProperty("calendar")] public string Calendar { get; set; }
}
public class CustomInstant
{
[JsonProperty("ticks")] public long Ticks { get; set; }
}
}
I am trying to create a custom JsonConverter to follow a third party API with a rather complicated object structure, and am a bit hamstrung on a few things. Note I am using .NET 4.7.2, not Core.
I have source objects that look like this, which I have created as objects rather than dictionaries in order to easily integrate them with FluentValidation. The objects will represent json objects in the foreign API. The "Value" is an interfaced item which is eventually converted to one of about 20 concrete types.
public class PDItem : IDictionaryObject<List<IItem>>
{
[JsonProperty]
public string Key { get; set; }
[JsonProperty]
public List<IItem> Value { get; set; }
}
The source json for such an object is a dictionary, whereby the Key is the property, and the value is one of the 20 object types, as so:
{
"checked": [
{
"elementType": "input",
"inputType": "checkbox",
"name": "another_checkbox",
"label": "Another checkbox",
"checked": true
}
]
}
In this case, the object in C# would look something like this:
PDItem item = new PDItem() {
Key = "checked",
Value = new List<IItem>() {
new ConcreteTypeA () {
elementType = "input",
inputType = "checkbox",
name = "another_checkbox",
label = "Another checkbox",
#checked = true
}
}
};
For reference, my "PDItem"s implement the following interfaces:
public interface IDictionaryObject<T>
{
string Key { get; set; }
T Value { get; set; }
}
[JsonConverter(typeof(IItemConverter))]
public interface IItem: IElement
{
}
[JsonConverter(typeof(ElementConverter))]
public interface IElement
{
string elementType { get; }
}
I was able to convert some concrete types (without having to do any tricky dictionary to object conversions), below is a working example of the ElementConverter attacked to my IElement interface (IItem uses the same pattern, and the same JsonCreationConverter class):
public class ElementConverter : JsonCreationConverter<IElement>
{
protected override IElement Create(Type objectType, JObject jObject)
{
//TODO: Add objects to ElementConverter as they come online.
switch (jObject["elementType"].Value<string>())
{
case ElementTypeDescriptions.FirstType:
return new FirstType();
case ElementTypeDescriptions.SecondType:
return new SecondType();
case ElementTypeDescriptions.ThirdType:
return new ThirdType();
case ElementTypeDescriptions.FourthType:
case ElementTypeDescriptions.FifthType:
default:
throw new NotImplementedException("This object type is not yet implemented.");
}
}
}
public abstract class JsonCreationConverter<T> : JsonConverter
{
protected abstract T Create(Type objectType, JObject jObject);
public override bool CanConvert(Type objectType)
{
return typeof(T) == objectType;
}
public override object ReadJson(JsonReader reader, Type objectType,
object existingValue, JsonSerializer serializer)
{
try
{
var jObject = JObject.Load(reader);
var target = Create(objectType, jObject);
serializer.Populate(jObject.CreateReader(), target);
return target;
}
catch (JsonReaderException)
{
return null;
}
}
public override void WriteJson(JsonWriter writer, object value,
JsonSerializer serializer)
{
throw new NotImplementedException();
}
}
What makes my scenario so tricky is not that I am converting objects to dictionaries and back, but that my object values are other concrete objects (interfaced). I want to write a custom JsonConverter to serialize and deserialize these objects, but have no idea how to read and write the json in the methods below, let alone if what I am attempting to do is even possible. Any assistance would be greatly appreciated!
public class PDItemConverter: JsonConverter<PDItem>
{
public override void WriteJson(JsonWriter writer, PDItem value, JsonSerializer serializer)
{
/// DO STUFF
}
public override PDItem ReadJson(JsonReader reader, Type objectType, PDItem existingValue,
bool hasExistingValue, JsonSerializer serializer)
{
/// DO STUFF
}
}
EDITED PER DBC's request:
Apologies for the complicated question DBC, and I greatly appreciate your time! Obviously, I'm a bit new to posting to stack overflow (long time lurker as they say).
Below is full working code that will run in .net fiddle (or in a console application if you simply add a namespace and json.net 12.x packages to a new .NET 4.7.2 console project). Second apologies that it is still a bit long and complicated, It is actually greatly simplified thanks to the omission of the Validation code:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
public class PDItem : IDictionaryObject<List<IItem>>
{
[JsonProperty]
public string Key { get; set; }
[JsonProperty]
public List<IItem> Value { get; set; }
}
public interface IDictionaryObject<T>
{
string Key { get; set; }
T Value { get; set; }
}
[JsonConverter(typeof(IItemConverter))]
public interface IItem : IElement
{
string itemType { get; }
}
[JsonConverter(typeof(ElementConverter))]
public interface IElement
{
string elementType { get; }
}
public class ElementConverter : JsonCreationConverter<IElement>
{
protected override IElement Create(Type objectType, JObject jObject)
{
//TODO: Add objects to ElementConverter as they come online.
switch (jObject["elementType"].Value<string>())
{
case ElementTypeDescriptions.FirstType:
return new FirstType();
case ElementTypeDescriptions.SecondType:
return new SecondType();
//case ElementTypeDescriptions.ThirdType:
// return new ThirdType();
//case ElementTypeDescriptions.FourthType:
//case ElementTypeDescriptions.FifthType:
default:
throw new NotImplementedException("This object type is not yet implemented.");
}
}
}
public class IItemConverter : JsonCreationConverter<IItem>
{
protected override IItem Create(Type objectType, JObject jObject)
{
switch (jObject["itemType"].Value<string>())
{
case ItemTypeDescriptions.FirstItemType:
return new FirstItemType();
case ItemTypeDescriptions.SecondItemType:
return new SecondItemType();
default:
throw new NotImplementedException("This object type is not yet implemented.");
}
}
}
/// <summary>
/// Used constants rather than an enum to allow for use in switch statements. Provided by third party to us to identify their classes across the API.
/// </summary>
public class ElementTypeDescriptions
{
public const string FirstType = "firstTypeId";
public const string SecondType = "secondTypeId";
public const string ThirdType = "thirdTypeId";
public const string FourthType = "fourthTypeId";
public const string FifthType = "fifthTypeId";
}
/// <summary>
/// Used constants rather than an enum to allow for use in switch statements. Provided by third party to us to identify their classes across the API.
/// </summary>
public class ItemTypeDescriptions
{
public const string FirstItemType = "firstItemTypeId";
public const string SecondItemType = "secondItemTypeId";
}
/*** CONCRETE OBJECTS ***/
public class FirstType : IElement
{
public string elementType { get { return ElementTypeDescriptions.FirstType; } }
public string name { get; set; }
}
public class SecondType : IElement
{
public string elementType { get { return ElementTypeDescriptions.FirstType; } }
public string label { get; set; }
}
public class FirstItemType : IItem
{
public string elementType { get { return ElementTypeDescriptions.FourthType; } }
public string itemType { get { return ItemTypeDescriptions.FirstItemType; } }
public string reference { get; set; }
}
public class SecondItemType : IItem
{
public string elementType { get { return ElementTypeDescriptions.FourthType; } }
public string itemType { get { return ItemTypeDescriptions.FirstItemType; } }
public string database { get; set; }
}
/*** END CONCRETE OBJECTS ***/
public class PDItemConverter : JsonConverter<PDItem>
{
public override void WriteJson(JsonWriter writer, PDItem value, JsonSerializer serializer)
{
/// THIS CODE TO BE WRITTEN TO ANSWER THE QUESTION
/// DO STUFF
throw new NotImplementedException("THIS CODE TO BE WRITTEN TO ANSWER THE QUESTION");
}
public override PDItem ReadJson(JsonReader reader, Type objectType, PDItem existingValue,
bool hasExistingValue, JsonSerializer serializer)
{
/// THIS CODE TO BE WRITTEN TO ANSWER THE QUESTION
/// DO STUFF
throw new NotImplementedException("THIS CODE TO BE WRITTEN TO ANSWER THE QUESTION");
}
}
public abstract class JsonCreationConverter<T> : JsonConverter
{
protected abstract T Create(Type objectType, JObject jObject);
public override bool CanConvert(Type objectType)
{
return typeof(T) == objectType;
}
public override object ReadJson(JsonReader reader, Type objectType,
object existingValue, JsonSerializer serializer)
{
try
{
var jObject = JObject.Load(reader);
var target = Create(objectType, jObject);
serializer.Populate(jObject.CreateReader(), target);
return target;
}
catch (JsonReaderException)
{
return null;
}
}
public override void WriteJson(JsonWriter writer, object value,
JsonSerializer serializer)
{
throw new NotImplementedException();
}
}
class TestClass
{
public static void Test()
{
var json = GetJson();
var item = JsonConvert.DeserializeObject<PDItem>(json);
var json2 = JsonConvert.SerializeObject(item, Formatting.Indented);
Console.WriteLine(json2);
}
static string GetJson()
{
var json = #"{
""checked"": [
{
""elementType"": ""input"",
""inputType"": ""checkbox"",
""name"": ""another_checkbox"",
""label"": ""Another checkbox"",
""checked"": true
}
]
}
";
return json;
}
}
public class Program
{
public static void Main()
{
Console.WriteLine("Environment version: " + Environment.Version);
Console.WriteLine("Json.NET version: " + typeof(JsonSerializer).Assembly.FullName);
Console.WriteLine();
try
{
TestClass.Test();
}
catch (Exception ex)
{
Console.WriteLine("Failed with unhandled exception: ");
Console.WriteLine(ex);
throw;
}
}
}
One of the easiest ways to write a JsonConverter is to map the object to be serialized to some DTO, then (de)serialize the DTO. Since your PDItem looks like a single dictionary key/value pair and is serialized like a dictionary, the easiest DTO to use would be an actual dictionary, namely Dictionary<string, List<IItem>>.
Thus your PDItemConverter can be written as follows:
public class PDItemConverter: JsonConverter<PDItem>
{
public override void WriteJson(JsonWriter writer, PDItem value, JsonSerializer serializer)
{
// Convert to a dictionary DTO and serialize
serializer.Serialize(writer, new Dictionary<string, List<IItem>> { { value.Key, value.Value } });
}
public override PDItem ReadJson(JsonReader reader, Type objectType, PDItem existingValue,
bool hasExistingValue, JsonSerializer serializer)
{
// Deserialize as a dictionary DTO and map to a PDItem
var dto = serializer.Deserialize<Dictionary<string, List<IItem>>>(reader);
if (dto == null)
return null;
if (dto.Count != 1)
throw new JsonSerializationException(string.Format("Incorrect number of dictionary keys: {0}", dto.Count));
var pair = dto.First();
existingValue = hasExistingValue ? existingValue : new PDItem();
existingValue.Key = pair.Key;
existingValue.Value = pair.Value;
return existingValue;
}
}
Since you are (de)serializing using the incoming serializer any converters associated to nested types such as IItem will get picked up and used automatically.
In addition, in JsonCreationConverter<T> you need to override CanWrite and return false. This causes the serializer to fall back to default serialization when writing JSON as explained in this answer to How to use default serialization in a custom JsonConverter. Also, I don't recommend catching and swallowing JsonReaderException. This exception is thrown when the JSON file itself is malformed, e.g. by being truncated. Ignoring this exception and continuing can occasionally force Newtonsoft to fall into an infinite loop. Instead, propagate the exception up to the application:
public abstract class JsonCreationConverter<T> : JsonConverter
{
// Override CanWrite and return false
public override bool CanWrite { get { return false; } }
protected abstract T Create(Type objectType, JObject jObject);
public override bool CanConvert(Type objectType)
{
return typeof(T) == objectType;
}
public override object ReadJson(JsonReader reader, Type objectType,
object existingValue, JsonSerializer serializer)
{
var jObject = JObject.Load(reader);
var target = Create(objectType, jObject);
serializer.Populate(jObject.CreateReader(), target);
return target;
}
public override void WriteJson(JsonWriter writer, object value,
JsonSerializer serializer)
{
throw new NotImplementedException();
}
}
Demo fiddle here.
$orderby fails on a derived type property
Assemblies affected
System.Web.OData 5.9.1.0
Microsoft.OData.Core 6.15.0.0
Reproduce steps
*Model:
public abstract class Person
{
public int Id { get; set; }
public string Name { get; set; }
}
public class Manager : Person
{
public string ManagerProperty { get; set; }
}
public class Supervisor : Person
{
public string SupervisorProperty { get; set; }
}
If I query now to order on a derived Members property I get an error
Query:
http://someserver/odata/persons?$isof=('Namespace.Manager')&$orderby=Namespace.Manager/ManagerProperty
Error Details:
"message":"The method or operation is not implemented.","type":"System.NotImplementedException","stacktrace":" at Microsoft.OData.Core.UriParser.Visitors.QueryNodeVisitor`1.Visit(SingleEntityCastNode nodeIn)\r\n at System.Web.OData.Query.Validators.OrderByQueryValidator.OrderByModelLimitationsValidator.TryValidate(OrderByClause orderByClause, Boolean explicitPropertiesDefined)\r\n at System.Web.OData.Query.Validators.OrderByQueryValidator.Validate(OrderByQueryOption orderByOption, ODataValidationSettings validationSettings)\r\n at System.Web.OData.Query.OrderByQueryOption.Validate(ODataValidationSettings validationSettings)\r\n at System.Web.OData.Query.Validators.ODataQueryValidator.Validate(ODataQueryOptions options, ODataValidationSettings validationSettings)\r\n at System.Web.OData.Query.ODataQueryOptions.Validate(ODataValidationSettings validationSettings)\r\n at System.Web.OData.EnableQueryAttribute.ValidateQuery(HttpRequestMessage request, ODataQueryOptions queryOptions)\r\n at System.Web.OData.EnableQueryAttribute.ExecuteQuery(Object response, HttpRequestMessage request, HttpActionDescriptor actionDescriptor)\r\n at System.Web.OData.EnableQueryAttribute.OnActionExecuted(HttpActionExecutedContext actionExecutedContext)"
•
Expected result
It should order the results by specified property
Actual result
*"message":"The method or operation is not implemented.","type":"System.NotImplementedException","stacktrace":" at Microsoft.OData.Core.UriParser.Visitors.QueryNodeVisitor`1.Visit(SingleEntityCastNode nodeIn)\r\n at System.Web.OData.Query.Validators.OrderByQueryValidator.OrderByModelLimitationsValidator.TryValidate(OrderByClause orderByClause, Boolean explicitPropertiesDefined)\r\n at System.Web.OData.Query.Validators.OrderByQueryValidator.Validate(OrderByQueryOption orderByOption, ODataValidationSettings validationSettings)\r\n at System.Web.OData.Query.OrderByQueryOption.Validate(ODataValidationSettings validationSettings)\r\n at System.Web.OData.Query.Validators.ODataQueryValidator.Validate(ODataQueryOptions options, ODataValidationSettings validationSettings)\r\n at System.Web.OData.Query.ODataQueryOptions.Validate(ODataValidationSettings validationSettings)\r\n at System.Web.OData.EnableQueryAttribute.ValidateQuery(HttpRequestMessage request, ODataQueryOptions queryOptions)\r\n at System.Web.OData.EnableQueryAttribute.ExecuteQuery(Object response, HttpRequestMessage request, HttpActionDescriptor actionDescriptor)\r\n at System.Web.OData.EnableQueryAttribute.OnActionExecuted(HttpActionExecutedContext actionExecutedContext)"
*
Breaks in following method in OrderByQueryValidator
public override SingleValueNode Visit(SingleValuePropertyAccessNode nodeIn)
{
if (EdmLibHelpers.IsNotSortable(nodeIn.Property, _model))
{
return nodeIn;
}
if (nodeIn.Source != null)
{
return nodeIn.Source.Accept(this);
}
return null;
}
I then added following condition which fixed the issue but I am sure if that's the correct solution hence, can someone please advise
public override SingleValueNode Visit(SingleValuePropertyAccessNode nodeIn)
{
if (EdmLibHelpers.IsNotSortable(nodeIn.Property, _model))
{
return nodeIn;
}
if (nodeIn.Source != null)
{
if(((SingleEntityCastNode)nodeIn.Source).EntityTypeReference != ((SingleEntityCastNode)nodeIn.Source).Source.EntityTypeReference)
{
return ((SingleEntityCastNode)nodeIn.Source).Source.Accept(this);
}
return nodeIn.Source.Accept(this);
}
return null;
}
it's better to go directly to override Visit method of SingleEntityCastNode parameter, with this you avoid errors of other node types:
public override SingleValueNode Visit(SingleValuePropertyAccessNode nodeIn)
{
if (EdmLibHelpers_IsNotSortable(nodeIn.Property, _model))
{
return nodeIn;
}
if (nodeIn.Source != null)
{
return nodeIn.Source.Accept(this);
}
return null;
}
public override SingleValueNode Visit(SingleEntityCastNode nodeIn)
{
if (nodeIn.EntityTypeReference != nodeIn.Source.EntityTypeReference)
{
return nodeIn.Source.Accept(this);
}
return base.Visit(nodeIn);
}
Also see https://github.com/OData/WebApi/issues/861
We have documents on DocumentDB that store a date on ISO 8601 format. These dates are stored as strings:
{
"CreatedOn": "2016-04-15T14:54:40Z",
"Title": "Some title",
"id": "xxx-xxx-xxxx-xxx-xxx-xxx"
}
We are using the latest Azure DocumentDB SDK (1.7.0) on a WebAPI that uses ASP.NET Core.
The C# class that maps our documents have the "CreatedOn" property as a string.
public class Item
{
public string CreatedOn { get; set; }
public string id { get; set; }
public string Title { get; set; }
}
The problem is that when we read a document and the SDK deserializes it, it tries to convert it to a DateTime and then back to a string. Resulting in:
{
"CreatedOn": "15/04/2016 14:54:40",
"Title": "Some title",
"id": "xxx-xxx-xxxx-xxx-xxx-xxx"
}
What I need is to the SDK to leave the values untouched. I tried setting the default SerializerSettings to avoid the date parsing:
services.AddMvc().AddJsonOptions(opts =>
{
opts.SerializerSettings.DateParseHandling = Newtonsoft.Json.DateParseHandling.None;
});
But it didn't work.
I tried using a JsonConverter attribute but the problem is that on the ReadJson override method, the reader already parsed the string value to a DateTime.
class StringJsonConverter : JsonConverter
{
public override bool CanConvert(Type objectType)
{
return true;
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
writer.WriteValue(value.ToString());
}
public override bool CanRead
{
get { return true; }
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
reader.Value <-- already a parsed DateTime
}
}
Any ideas on how to overcome this auto parsing?
JSON serializer settings can now be passed straight to DocumentClient constuctors, which allows for the flexibility you required.
Eventually found a workaround, since the JsonSettings are not accesible at this time, I'm using a JsonConverter:
public class StringJsonConverter : JsonConverter
{
public override bool CanConvert(Type objectType)
{
return true;
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
writer.WriteValue(value.ToString());
}
public override bool CanRead
{
get { return true; }
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.ValueType.Equals(typeof(DateTime)))
{
return ((DateTime)reader.Value).ToIso8601Date();
}
if (reader.ValueType.Equals(typeof(DateTimeOffset)))
{
return ((DateTimeOffset)reader.Value).DateTime.ToIso8601Date();
}
return (string)reader.Value;
}
}
With this simple extension:
public static class DateTimeExtensions
{
private const string DateTimeFormat = "{0}-{1}-{2}T{3}:{4}:{5}Z";
public static string ToIso8601Date(this DateTime date)
{
if (date.Equals(DateTime.MinValue))
{
return null;
}
return string.Format(
DateTimeFormat,
date.Year,
PadLeft(date.Month),
PadLeft(date.Day),
PadLeft(date.Hour),
PadLeft(date.Minute),
PadLeft(date.Second));
}
private static string PadLeft(int number)
{
if (number < 10)
{
return string.Format("0{0}", number);
}
return number.ToString(CultureInfo.InvariantCulture);
}
}
I am trying to find out how to solve the problem for serializing a type of bool from a camel case string.
I have the following xml
<Root>
<BoolElement>
False
</BoolElement>
</Root>
and the following class
[XmlRoot("Root")]
public class RootObj{
[XmlElement("BoolElement")]
public bool BoolElement{get;set;}
}
this will produce an error.
If I use the same class and rename the "False" to "false" it will work. The problem is that I can't edit the xml.
Does anyone know how can I solve this?
You could use a backing field to aid for the deserialization of this invalid XML (I say invalid because according to the xsd:boolean schema False is an invalid value):
[XmlRoot("Root")]
public class RootObj
{
[XmlElement("BoolElement")]
public string BackingBoolElement
{
set
{
BoolElement = bool.Parse(value.ToLower());
}
get
{
return BoolElement.ToString();
}
}
[XmlIgnore]
public bool BoolElement { get; set; }
}
False is not a valid value for an xsd:boolean (but as you note false and 0 are) - if you cannot change the source data, then you could have a separate property purely for XML serialisation:
[XmlRoot("Root")]
public class RootObj{
[XmlElement("BoolElement")]
public string BoolElementForSerialization
{
get
{
return (this.BoolElement ? "True" : "False");
}
set
{
this.BoolElement = (string.Compare(value, "false", StringComparison.OrdinalIgnoreCase) != 0);
}
}
[XmlIgnore]
public bool BoolElement{get;set;}
}
I created a new Boolean type that can deserialize from any string. It may not be perfect but it suited my needs at the time.
For the class you want to use simply change the data type from bool to SerializableBoolean:
[XmlRoot("Root")]
public class RootObj{
[XmlElement("BoolElement")]
public SerializableBoolean BoolElement{get;set;}
}
You can then use the BoolElement property like any normal bool data type:
RootObj myObj = new RootObj();
if (myObj.BoolElement) { ... }
Here is the code for the SerializableBoolean class, note this code only handles deserializing, serializing to xml wasn't required for my purposes and so not implemented.
[System.Diagnostics.DebuggerDisplay("{Value}")]
public struct SerializableBoolean: System.Xml.Serialization.IXmlSerializable
{
private bool Value { get; set; }
public override bool Equals(object obj)
{
if (obj is string stringBoolean)
{
bool.TryParse(stringBoolean, out bool boolean);
return Value == boolean;
}
else if (obj is bool boolean)
{
return Value == boolean;
}
else if (obj is SerializableBoolean serializableBoolean)
{
return Value == serializableBoolean.Value;
}
else
{
return Value == Convert.ToBoolean(obj);
}
}
public override int GetHashCode()
{
return -1937169414 + Value.GetHashCode();
}
public XmlSchema GetSchema()
{
throw new NotImplementedException();
}
public void ReadXml(XmlReader reader)
{
Value = Convert.ToBoolean(reader.ReadElementContentAsString());
}
public void WriteXml(XmlWriter writer)
{
throw new NotImplementedException();
}
public static bool operator ==(SerializableBoolean obj1, bool obj2)
{
return obj1.Value.Equals(obj2);
}
public static bool operator !=(SerializableBoolean obj1, bool obj2)
{
return !obj1.Value.Equals(obj2);
}
public static implicit operator SerializableBoolean(string value)
{
return new SerializableBoolean() { Value = Convert.ToBoolean(value) };
}
public static implicit operator SerializableBoolean(bool value)
{
return new SerializableBoolean() { Value = value };
}
public static implicit operator bool(SerializableBoolean b)
{
return b.Value;
}
}