I have two 'data' classes:
public class BaseData
{
public string BaseDataStuff { get; set; }
}
public class ChildData : BaseData
{
public string ChildDataStuff { get; set; }
}
and a 'container' class:
public class Container
{
public BaseData Data { get; set; }
}
Then I have the following controller:
public class Controller : ControllerBase
{
private readonly ChildData Data;
private readonly Container Container;
public Controller()
{
Data = new ChildData()
{
BaseDataStuff = "base stuff",
ChildDataStuff = "child stuff"
};
Container = new Container()
{
Data = Data
};
}
[HttpGet("data")]
public ActionResult<BaseData> GetData() => Ok(Container.Data);
[HttpGet("container")]
public ActionResult<Container> GetContainer() => Ok(Container);
}
The first method just returns the ChildData instance. When I run it in swagger, I get the JSON I expect:
{
"childDataStuff": "child stuff",
"baseDataStuff": "base stuff"
}
When I run the second method through swagger, it looks like it casts the ChildData instance to BaseData. I get the following JSON:
{
"data": {
"baseDataStuff": "base stuff"
}
}
Can someone explain what is happening here please?
This question was interesting. See How to serialize properties of derived classes with System.Text.Json
There it explains that System.Text.Json does not handle serializing polymorphic objects the way you want prior to .NET 7. There are some work arounds but those allow you to serialize when the root object is polymorpic (Container in you case) but not members of the root (BaseData and ChildData).
In .NET 7 you can do this
using System.Text.Json.Serialization;
[JsonDerivedType(typeof(ChildData))]
public class BaseData
{
public string BaseDataStuff { get; set; } = string. Empty;
}
and
public class ChildData : BaseData
{
public string ChildDataStuff { get; set; } = string. Empty;
}
and
public class Container
{
public BaseData Data { get; set; } = new BaseData();
}
Then this
var data = new ChildData()
{
BaseDataStuff = "base stuff",
ChildDataStuff = "child stuff"
};
var container = new Container
{
Data = data
};
jsonString = JsonSerializer.Serialize(container);
Console.WriteLine(jsonString);
gives you
{"Data":{"ChildDataStuff":"child stuff","BaseDataStuff":"base stuff"}}
Which I think is what you want. Of course, going to .NET 7 may not be convenient.
You could try serializing yourself like this
options = new JsonSerializerOptions
{
WriteIndented = true
};
jsonString = JsonSerializer.Serialize<object>(Container, options);
or another option, is to explicitly mark them as serializable for the serializer:
[DataContract]
public class BaseData
{
[DataMember]
public string BaseDataStuff { get; set; }
}
[DataContract]
public class ChildData : BaseData
{
[DataMember]
public string ChildDataStuff { get; set; }
}
Related
I have a simple model that I try to serialize to JSON, but some properties don't get included in the result. When my object inherits from a base class, the properties of the base class doesn't appear in the json.
In the JSON string "searchModel" is {}
SearchModelBase.cs:
public interface ISearchModelBase
{
SearchTypes Type { get; set; }
string SearchString { get; set; }
}
public abstract class SearchModelBase : ISearchModelBase
{
public SearchModelBase(SearchTypes type, string searchString)
{
this.Type = type;
this.SearchString = searchString;
}
public SearchTypes Type { get; set; }
public string SearchString { get; set; }
}
public enum SearchTypes
{
User,
Site
}
AssetsDefaultSearchModel.cs:
public interface IAssetsDefaultSearchModel : ISearchModelBase
{
}
public class AssetsDefaultSearchModel : SearchModelBase, IAssetsDefaultSearchModel
{
public AssetsDefaultSearchModel(SearchTypes type, string searchString) : base(type, searchString)
{
}
}
JSON:
{
"items": [
{
"displayName": "FFU Samarin",
"data": {
"appId": 3,
"displayName": "FFU Samarin",
..........
In Visual Studio each item in the collection contains AssetsDefaultSearchModel with values in both properties:
In the interface derived from ISearchResultBase I had to define a new property with the new keyword. I then return an object derived from IAssetsDefaultSearchResult (without replicating the property in the class) and it worked as expected.
public interface IAssetsDefaultSearchResult : ISearchResultBase
{
new ISearchModelBase SearchModel { get; }
string DisplayName { get; }
object Data { get; }
TagBuilder HtmlTag { get; }
}
add below code to your Startup.cs
services.AddControllers().AddNewtonsoftJson();
you can use the Microsoft.AspNetCore.Mvc.NewtonsoftJson NuGet package
I have following Json-based configuration file:
{
"PostProcessing": {
"ValidationHandlerConfiguration": {
"MinimumTrustLevel": 80,
"MinimumMatchingTrustLevel": 75
},
"MatchingCharacterRemovals": [
"-",
"''",
":"
]
},
"Processing": {
"OrderSelection": {
"SelectionDaysInterval": 30,
"SelectionDaysMaximum": 365
}
}
}
As serialization framework I use Newtonsoft. To serialize this config into objects I have implemented following classes:
[JsonObject(MemberSerialization.OptIn)]
public class RecognitionConfiguration {
[JsonProperty(PropertyName = "PostProcessing", Required = Required.Always)]
public PostRecognitionConfiguration PostRecognitionConfiguration { get; set; }
[JsonProperty(PropertyName = "Processing", Required = Required.Always)]
public ProcessRecognitionConfiguration ProcessRecognitionConfiguration { get; set; }
}
[JsonObject(MemberSerialization.OptIn)]
public class PostRecognitionConfiguration {
[JsonProperty(Required = Required.Always)]
public ValidationHandlerConfiguration ValidationHandlerConfiguration { get; set; }
[JsonProperty] public List<string> MatchingCharacterRemovals { get; set; }
}
[JsonObject(MemberSerialization.OptIn)]
public class ProcessRecognitionConfiguration {
[JsonProperty(PropertyName = "OrderSelection", Required = Required.Always)]
public OrderSelectionConfiguration OrderSelectionConfiguration { get; set; }
}
In a class I try to serialize a specific configuration section into these class structures using IConfigurationSection.Get().
var serializedConfiguration = this.ConfigurationSection.Get<RecognitionConfiguration>();
But when I debug the code, I always get an "empty" variable serializedConfiguration which is not null, but all properties are null.
If I use
this.ConfigurationSection.GetSection("Processing").Get<ProcessRecognitionConfiguration>()
or change the naming of the properties in the json file to exactly match the property names in the classes like this:
{
"ProcessRecognitionConfiguration": {
"OrderSelectionConfiguration": {
"SelectionDaysInterval": 30,
"SelectionDaysMaximum": 365
}
}
}
it it works fine. Do you have any idea, why setting PropertyName on JsonProperty does not seem to have any effect?
That is by design. Binding to POCO via configuration is done by convention. Not like Model Binding to Controller Action parameters.
It matches property names on the POCO to keys in the provided JSON.
Reference Configuration in ASP.NET Core
So either you change the settings to match the class like you showed in the original question, or change the class to match the settings keys in the Json-based configuration file.
[JsonObject(MemberSerialization.OptIn)]
public class RecognitionConfiguration {
[JsonProperty(PropertyName = "PostProcessing", Required = Required.Always)]
public PostRecognitionConfiguration PostProcessing{ get; set; }
[JsonProperty(PropertyName = "Processing", Required = Required.Always)]
public ProcessRecognitionConfiguration Processing{ get; set; }
}
[JsonObject(MemberSerialization.OptIn)]
public class PostRecognitionConfiguration {
[JsonProperty(Required = Required.Always)]
public ValidationHandlerConfiguration ValidationHandlerConfiguration { get; set; }
[JsonProperty]
public List<string> MatchingCharacterRemovals { get; set; }
}
[JsonObject(MemberSerialization.OptIn)]
public class ProcessRecognitionConfiguration {
[JsonProperty(PropertyName = "OrderSelection", Required = Required.Always)]
public OrderSelectionConfiguration OrderSelection { get; set; }
}
public partial class ValidationHandlerConfiguration {
[JsonProperty("MinimumTrustLevel")]
public long MinimumTrustLevel { get; set; }
[JsonProperty("MinimumMatchingTrustLevel")]
public long MinimumMatchingTrustLevel { get; set; }
}
public partial class OrderSelectionConfiguration {
[JsonProperty("SelectionDaysInterval")]
public long SelectionDaysInterval { get; set; }
[JsonProperty("SelectionDaysMaximum")]
public long SelectionDaysMaximum { get; set; }
}
EDIT: I found this one is much more pleasant than my previous solutions: Bind everything in an ExpandoObject, write them to JSON and use JSON.NET to bind them back. Using the code of this article:
namespace Microsoft.Extensions.Configuration
{
public static class ConfigurationBinder
{
public static void BindJsonNet(this IConfiguration config, object instance)
{
var obj = BindToExpandoObject(config);
var jsonText = JsonConvert.SerializeObject(obj);
JsonConvert.PopulateObject(jsonText, instance);
}
private static ExpandoObject BindToExpandoObject(IConfiguration config)
{
var result = new ExpandoObject();
// retrieve all keys from your settings
var configs = config.AsEnumerable();
foreach (var kvp in configs)
{
var parent = result as IDictionary<string, object>;
var path = kvp.Key.Split(':');
// create or retrieve the hierarchy (keep last path item for later)
var i = 0;
for (i = 0; i < path.Length - 1; i++)
{
if (!parent.ContainsKey(path[i]))
{
parent.Add(path[i], new ExpandoObject());
}
parent = parent[path[i]] as IDictionary<string, object>;
}
if (kvp.Value == null)
continue;
// add the value to the parent
// note: in case of an array, key will be an integer and will be dealt with later
var key = path[i];
parent.Add(key, kvp.Value);
}
// at this stage, all arrays are seen as dictionaries with integer keys
ReplaceWithArray(null, null, result);
return result;
}
private static void ReplaceWithArray(ExpandoObject parent, string key, ExpandoObject input)
{
if (input == null)
return;
var dict = input as IDictionary<string, object>;
var keys = dict.Keys.ToArray();
// it's an array if all keys are integers
if (keys.All(k => int.TryParse(k, out var dummy)))
{
var array = new object[keys.Length];
foreach (var kvp in dict)
{
array[int.Parse(kvp.Key)] = kvp.Value;
}
var parentDict = parent as IDictionary<string, object>;
parentDict.Remove(key);
parentDict.Add(key, array);
}
else
{
foreach (var childKey in dict.Keys.ToList())
{
ReplaceWithArray(input, childKey, dict[childKey] as ExpandoObject);
}
}
}
}
}
Usage:
var settings = new MySettings();
this.Configuration.BindJsonNet(settings);
Here is my testing MySettings class:
public class MySettings
{
[JsonProperty("PostProcessing")]
public SomeNameElseSettings SomenameElse { get; set; }
public class SomeNameElseSettings
{
[JsonProperty("ValidationHandlerConfiguration")]
public ValidationHandlerConfigurationSettings WhateverNameYouWant { get; set; }
public class ValidationHandlerConfigurationSettings
{
[JsonProperty("MinimumTrustLevel")]
public int MinimumTrustLevelFoo { get; set; }
[JsonProperty("MinimumMatchingTrustLevel")]
public int MinimumMatchingTrustLevelBar { get; set; }
}
}
}
After the calling, I get everything as you desired:
Old Answer:
According to the source code here, it is simply (near) impossible to do what you are requiring. I have tried both JsonProperty and DataContract, none of which are honored by the Binder, simply because the source code itself simply use the property name.
If you still insist, there are 2 possibilities, however I do not recommend any as changing properties' names are much simpler:
Fork your source code there, or simply copy that file (in my attempt to trace the code, I rename all methods to something like Bind2, BindInstance2 etc), and rewrite the code accordingly.
This one is very specific to current implementation, so it's not future-proof: the current code is calling config.GetSection(property.Name), so you can write your own IConfiguration and provide your own name for GetSection method and tap it into the bootstrap process instead of using the default one.
Changing PropertyName on JsonProperty does have effect. Here is the same I tried and it did worked for me:
my JSON data:
{"name": "John","age": 30,"cars": [ "Ford", "BMW", "Fiat" ]}
and the Model:
public class RootObject
{
[JsonProperty(PropertyName ="name")]
public string Apple { get; set; }
public int age { get; set; }
public List<string> cars { get; set; }
}
and here is the code:
RootObject obj = JsonConvert.DeserializeObject<RootObject>(json);
and this is the output i get
You need to set the PropertyName in JsonProperty same as json file property name but your C# model property can be what you wanted, just that they need to be decorated with [JsonProperty(PropertyName ="jsonPropertyName")] Hope this helps you solve your issue.
Happy coding...
I have such endpoint in my controller :
public async Task<<IEnumerable<ItemsList>>> GetItems()
{
List<ItemsList>> items = await _itemManager.GetItemsAsync();
return items;
}
And when I get result from this endpoint :
{
"Type": "SomeType",
"Items":[{"Id":1,"ItemType":"SomeType"}]
}
but I want to be Camel Case, such as :
{
"type": "SomeType",
"items":[{"id":1,"itemType":"SomeType"}]
}
Here is of
public class ItemsList
{
public ItemType Type { get; set; }
public List<Items> Items { get; set; }
}
public class Item
{
public int ItemId { get; set; }
public ItemType ItemType { get; set; }
}
I found solution like :
public async Task<<IEnumerable<ItemsList>>> GetItems()
{
List<ItemsList>> items = await _itemManager.GetItemsAsync();
var serializerSettings = new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
return Json(items),serializerSettings);
}
So, what I want to do it's to create Attribute, which can be applied to specific endpoint and make result from the endpoint to be camelCase.
Applying Json attributes to Dto's or formatting the whole controller isn't my case.
I like to use the DataMemberAttribute from System.Runtime.Serialization
Example:
[Serializable]
[DataContract]
public class SomeDto
{
[DataMember(Name = "unitCount")]
public int UnitCount { get; set; }
[DataMember(Name = "packagingType")]
public PackagingType PackagingTypeIdEtc { get; set; }
// ...
The output will be camelCase and you'll also be able to control things like emitDefaultValue and so on.
{
unitCount: 3,
packagingType: "box",
/* ... */
}
On the entity, you can use:
[JsonObject(NamingStrategyType = typeof(CamelCaseNamingStrategy))]
On a property, you can use:
[JsonProperty(NamingStrategyType = typeof(CamelCaseNamingStrategy))]
Also on a property, you can manually specify the property name if you wish:
[JsonProperty(PropertyName = "myPropertyName")]
Try putting below in Register function under WebApiConfig
public static void Register(HttpConfiguration config)
{
config.Formatters.Clear();
config.Formatters.Add(new JsonMediaTypeFormatter());
config.Formatters.JsonFormatter.SerializerSettings.Formatting = Newtonsoft.Json.Formatting.Indented;
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractresolvder();
}
I am querying Firebase and retrieve a collection of objects like so:
{"-K5f0ccEKkVkxTAavQKY": {
"Appeal": {
"ID": "1450273330435",
"comps": [
162248,
162272,
162273,
162281,
162544
],
"property": {
"Address": "15 Main Street",
"propID": 169729
},
"timeDateStamp": "Wed Dec 16 2015 08:42:10 GMT-0500 (Eastern Standard Time)",
"userUUID": "google:229139952703238437512",
"year": 2016
}
}}
I would like to deserialize them into objects with this definition:
public class Appeal
{
public string ID;
public List<string> comps;
public AppealProperty property;
public string timeDateStamp;
public string UUID;
public int year;
}
public class AppealProperty
{
public string address;
public string propID;
}
I have troubles getting it deserialized. I don't need the initial string (e.g. "K5f0ccEKkVkxTAavQKY"). I'm able to change the object definitions if need be. I have a feeling a Dictionary would be useful.
The quick and dirty object is to use Dictionary<string,Appeal> as your deserialization target. At that point it would be as simple as:
var firebaseLookup = JsonConvert.DeserializeObject<Dictionary<string,Appeal>>(json);
var data = firebaseLookup.Values.ToList(); // or FirstOrDefault();
This approach would also handle the case if you ever had to get multiple objects at once, and it would give you the opportunity to use that key if it turns out the key was important after all.
You could serialise your data into the classes below.
public class AppealProperty
{
public string Address { get; set; }
public int propID { get; set; }
}
public class Appeal
{
public string ID { get; set; }
public List<int> comps { get; set; }
public AppealProperty property { get; set; }
public string timeDateStamp { get; set; }
public string userUUID { get; set; }
public int year { get; set; }
}
public class FireBase
{
public Appeal Appeal { get; set; }
}
public class RootObject
{
[JsonProperty(PropertyName = " - K5f0ccEKkVkxTAavQKY")]
public FireBase FireBaseRoot
{
get;
set;
}
}
Assuming that you are using JSON.NET, you can then get the object you are after, using this snippet:
var firebaseObject = JsonConvert.DeserializeObject<RootObject>(json);
var data = firebaseObject.FireBaseRoot.Appeal;
If the root name is dynamic, as indicated by your comment, you could skip the root instead and serialise straight into the FireBase class:
JObject parsedJson = JObject.Parse(json);
var fireBase = parsedJson.First.Children().First().ToObject(typeof (FireBase));
Since I've never been able to parse a DataSnapshot with newtonSoft Json parser, I did this to build a list of object I needed to put in a ListView:
MyModelObject class
public class MyModelObject: Java.Lang.Object
{
public string Title { get; set; }
public string Description { get; set; }
public MyModelObject(){}
}
into My Listener
public void OnDataChange(DataSnapshot snapshot)
{
List<MyModelObjecct> myList = new List<MyModelObject>();
myList = databaseService
.GetMyModelObjectList(snapshot
.Children?
.ToEnumerable<DataSnapshot>());
}
Method into the DatabaseService class
public List<MyModelObject> GetMyModelObjectList(IEnumerable<DataSnapshot> enumerableSnapshot)
{
List<MyModelObject> list = new List<MyModelObject>();
foreach (var item in enumerableSnapshot)
{
list.Add(ObjectExtensions.DataSnapshotToObject<MyModelObject>(item.Children?.ToEnumerable<DataSnapshot>()));
}
return list;
}
ObjectExtensions class
public static class ObjectExtensions
{
public static T DataSnapshotToObject<T>(IEnumerable<DataSnapshot> source)
where T : class, new()
{
var someObject = new T();
var someObjectType = someObject.GetType();
foreach (var item in source)
{
someObjectType
.GetProperty(item.Key)
.SetValue(someObject, item.Value.ToString(), null);
}
return someObject;
}
}
I've got a REST hello world service up and running with ServiceStack.
It currently returns JSON from a test object that looks like:
{"Name":"Value"}
The object is simply:
public class TestResponse { public string Name { get; set; } }
Does anyone how I can decorate the class to force a root name in the JSON so it appears like so:
{ root:{"Name":"Value"} }
Thanks.
The JSON returned matches the exact shape of the DTO you populate (i.e. the role of a DTO in the first place).
So you should change the DTO to represent the exact shape you want, e.g.
public class TestResponse {
public TestRoot Root { get; set; }
}
public class TestRoot {
public string Name { get; set; }
}
Then you can return it as you would expect:
return new TestResponse { Root = new TestRoot { Name = "Value" } };
Or if you prefer, you could also use a Dictionary:
public class TestResponse {
public TestResponse() {
this.Root = new Dictionary<string,string>();
}
public Dictionary<string,string> Root { get; set; }
}
and return it with:
return new TestResponse { Root = { { "Name", "Value" } } };