Is there way to serialize private fields and autoproperties of an object?
The restriction is that I can't edit classes that i need to serialize which means:
1. I can't add any atributes on members (kinda datacontract)
2. I can't inherit it from an interface (kinda Ixmlserializable )
4. Add getter and setter properties for the fields
3. Class of the root object that i need to serialize is not even marked as serializable
Thanks
You may be able to do something like this (you'll have to get more creative if you have things like collections or non-serializable fields, but you get the idea):
var dict = new Dictionary<string, object>();
foreach (var field in typeof(Foo).GetFields(BindingFlags.Instance | BindingFlags.NonPublic))
{
dict[field.Name] = field.GetValue(f);
}
string json = JsonConvert.SerializeObject(dict);
Basically you're ripping the fields out one at a time, dumping them into a dictionary, then serializing the dictionary.
If you don't want to work with reflection yourself, you can read this article with a list of solutions for serialization.
You can override the DefaultContractResolver to do (de)serialization of only fields without having to decorate the classes:
public class FieldsOnlyContractResolver: DefaultContractResolver
{
protected override List<MemberInfo> GetSerializableMembers(Type objectType)
{
return objectType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
.Cast<MemberInfo>().ToList();
}
protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
{
return base.CreateProperty(member, MemberSerialization.Fields);
}
}
Then, to use it, specify inside JsonConvert.(De)SerializeObject:
var jsonSettings = new JsonSerializerSettings() {
ContractResolver = new FieldsOnlyContractResolver()
};
var json = JsonConvert.SerializeObject(obj, jsonSettings);
var objAgain = JsonConvert.DeserializeObject<ObjType>(json, jsonSettings);
Related
I am try to make conditional serialization base on rules that I give the moment I make the Serialization.
I know that I can use the ShouldSerialize+Name
[ProtoContract]
public class SomeType {
[ProtoMember(1)]
public string Name {get;set;}
private bool ShouldSerializeName() {
// return true to serialize Name, false otherwise
}
}
But what I need is like this example on Newtonsoft.Json.JsonConvert where I give the settings for what i am going to serialize the moment of serialization.
var oResolFilter = new ShouldSerializeContractResolver();
var settings = new JsonSerializerSettings { ContractResolver = oResolFilter };
var Results = JsonConvert.SerializeObject(this, settings);
and
class ShouldSerializeContractResolver : DefaultContractResolver
{
protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
{
JsonProperty property = base.CreateProperty(member, memberSerialization);
property.ShouldSerialize = true ; // ( or false)
return property;
}
}
So the question is - how can I do something similar as the JsonConvert on ProtoBuf-Net
reference
I look on most of answers, and on the examples and the source code on protobuf-net but fail to locate a similar solution... here are few questions that I look.
.net serialization: how to selectively ignore data fields
Conditional serialization with protobuf-net
Protobuf-net serialization of object (generic) throws error No serializer defined for type: System.Object
How to ignore default values while serializing json with Newtonsoft.Json
json.net example:
Newtonsoft JSON ShouldSerialize and inheritance
We are running into a situation on an MVC3 project with both the Microsoft JSON serializers and JSON.NET.
Everybody knows DateTime's are basically broken in Microsoft's serializers, so we switched to JSON.NET to avoid this issue. That works great, except that some of the classes we are trying to serialize are POCOs with DataContract/DataMember attributes. They are defined in an assembly that is referenced in multiple places. Additionally, they have some other display properties that are not marked as DataMembers for efficiency. For instance, a Customer
[DataContract]
public class Customer
{
[DataMember]
public string FirstName { get; set;}
[DataMember]
public string LastName { get; set;}
public string FullName
{
get
{ return FirstName + " " + LastName; }
}
}
When this customer is passed over WCF the client side can reference that assembly and use the FullName just fine, but when serialized with JSON.NET it sees that FullName isn't a [DataMember] and doesn't serialize it. Is there an option to pass to JSON.NET to tell it to ignore the fact that a class has [DataContract] attribute applied?
Note:
Using the JavaScriptSerializer in .NET works fine for the FullName property, but DateTimes are broken. I need JSON.NET to ignore the fact that this class has DataContract/DataMember attributes and just do standard public field serialization like it would if they weren't there.
Simply use Json.Net's OptOut attribute. It will take precedence over DataContract.
[DataContract]
[JsonObject(MemberSerialization.OptOut)]
As Amry said you can uses your own IContractResolver.
Unfortunately the solution provided by Amry didn't work for me, below is the solution that I managed to get working:
public class AllPropertiesResolver : DefaultContractResolver
{
protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
{
JsonProperty property = base.CreateProperty(member, memberSerialization);
//property.HasMemberAttribute = true;
property.Ignored = false;
//property.ShouldSerialize = instance =>
//{
// return true;
//};
return property;
}
}
There are a few lines commented, these wern't required to make my solution work, but you never know!
This has the same usage as Amry's solution:
var json = JsonConvert.SerializeObject(result, new JsonSerializerSettings {
ContractResolver = new AllPropertiesResolver()
});
Hope this helps!
I was having a problem almost related to what you're having, and managed to find a solution by going through Json.NET's codes. So it may not be the best solution, but it works for me.
To do this, you need to implement your own IContractResolver. An over-simplified implementation of that to include all parameters and ignores all attributes (not just DataContract but other built-in Json.NET's rules as well, so whatever options you set that should originally affect the members selection is now being overidden by this code):
class AllPropertiesResolver : DefaultContractResolver
{
protected override List<MemberInfo> GetSerializableMembers(Type objectType)
{
return objectType.GetProperties()
.Where(p => p.GetIndexParameters().Length == 0)
.Cast<MemberInfo>()
.ToList();
}
}
And here comes the code usage example:
var json = JsonConvert.SerializeObject(result, new JsonSerializerSettings {
ContractResolver = new AllPropertiesResolver()
});
In accordance to the Json.NET documentation [DataMember] attributes are ignored if the properties are also annotated with Json.NET specific attributes (such as [JsonProperty]).See the Serialization Attributes documentation for details:
Json.NET attributes take presidence over standard .NET serialization attributes, e.g. if both JsonPropertyAttribute and DataMemberAttribute are present on a property and both customize the name, the name from JsonPropertyAttribute will be used.
The documentation only covers the name property, but for my experience the [JsonProperty] attribute also fully shadows settings done by the [DataMember] attribute. So, if it is feasible for your case, also add Json.NET attributes to the properties for which the [DataMember] annotation should be ignored.
If you want to ignore the presence of DataContractAttribute for all types without having to add additional attributes, then a custom contract resolver is the correct solution. However, as of Json.NET 9.0.1 Amry's resolver no longer works. Doolali's resolver works but it has the additional side effect of serializing all public properties including those marked with [JsonIgnore]. If you require a contract resolver that only ignores the presence of DataContractAttribute but otherwise behaves like the default contract resolver, the following can be used:
public class IgnoreDataContractContractResolver : DefaultContractResolver
{
static MemberSerialization RemoveDataContractAttributeMemberSerialization(Type type, MemberSerialization memberSerialization)
{
if (memberSerialization == MemberSerialization.OptIn)
{
type = Nullable.GetUnderlyingType(type) ?? type;
// Json.NET interprets DataContractAttribute as inherited despite the fact it is marked with Inherited = false
// https://json.codeplex.com/discussions/357850
// https://stackoverflow.com/questions/8555089/datacontract-and-inheritance
// https://github.com/JamesNK/Newtonsoft.Json/issues/603
// Thus we need to manually climb the type hierarchy to see if one is present.
var dataContractAttribute = type.BaseTypesAndSelf().Select(t => t.GetCustomAttribute<DataContractAttribute>()).FirstOrDefault(a => a != null);
var jsonObjectAttribute = type.GetCustomAttribute<JsonObjectAttribute>();
if (dataContractAttribute != null && jsonObjectAttribute == null)
memberSerialization = MemberSerialization.OptOut;
}
return memberSerialization;
}
protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
{
var properties = base.CreateProperties(type, RemoveDataContractAttributeMemberSerialization(type, memberSerialization));
return properties;
}
protected override JsonObjectContract CreateObjectContract(Type objectType)
{
var contract = base.CreateObjectContract(objectType);
contract.MemberSerialization = RemoveDataContractAttributeMemberSerialization(objectType, contract.MemberSerialization);
return contract;
}
}
public static class TypeExtensions
{
public static IEnumerable<Type> BaseTypesAndSelf(this Type type)
{
while (type != null)
{
yield return type;
type = type.BaseType;
}
}
}
You may want to cache the contract resolver for best performance.
Have you tried this?
IgnoreDataMemberAttribute
I have some .NET classes with localized text; i.e. text in English, corresponding text in Spanish, etc. We have a Locale class that looks something like this:
class Locale
{
int Id;
string Abbreviation; // e.g. "en"
string Name; // e.g. "English"
static Locale FromAbbreviation(string abbreviation);
}
Localized text is stored in IDictionary properties, something like
class Document
{
IDictionary<Locale, string> Content;
}
When serializing to JSON, I would like this to be keyed by locale abbreviation, so a serialized Document object would look something like this:
{
"content": {
"en": "English content",
"es": "Spanish content"
}
}
I need a ContractResolver that converts an IDictionary<Locale, string> object to a Dictionary<string, string> object, using the Locale.Abbreviation property as the key during serialization, and calling Locale.FromAbbreviation() on deserialization to convert the key back to a Locale object.
I have looked at the JSON.NET documentation and various Stackoverflow questions, and there does not seem to be an easy way to do this (at least I can't find it). I did find what looks like a straightforward way to do the same thing using a TypeConverter attribute, but I would rather not take a dependence on Json.NET from my domain classes. Is there a reasonable way to do this using a ContractResolver?
You don't really need a ContractResolver here. You can use a custom JsonConverter to handle the conversion from Dictionary<Locale, string> to your desired JSON and back without needing to use an attribute in your model classes. As long as the converter's CanConvert method is coded correctly to identify the dictionary type that the converter handles, then you can just add the converter to the serializer settings and Json.Net will find it and use it appropriately.
Here is what the converter might look like:
class LocaleDictionaryConverter : JsonConverter
{
public override bool CanConvert(Type objectType)
{
return typeof(IDictionary<Locale, string>).IsAssignableFrom(objectType);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
JObject obj = JObject.Load(reader);
IDictionary<Locale, string> dict = (IDictionary<Locale, string>)existingValue ?? new Dictionary<Locale, string>();
foreach (var prop in obj.Properties())
{
dict.Add(Locale.FromAbbreviation(prop.Name), (string)prop.Value);
}
return dict;
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
IDictionary<Locale, string> dict = (IDictionary<Locale, string>)value;
JObject obj = new JObject();
foreach (var kvp in dict)
{
obj.Add(kvp.Key.Abbreviation, kvp.Value);
}
obj.WriteTo(writer);
}
}
And here is how you would use it to serialize:
var settings = new JsonSerializerSettings();
settings.Converters.Add(new LocaleDictionaryConverter());
settings.Formatting = Formatting.Indented;
string json = JsonConvert.SerializeObject(document, settings);
And deserialize:
// same settings as above
var document = JsonConvert.DeserializeObject<Document>(json, settings);
Here is a demo: https://dotnetfiddle.net/f1rXl2
For look up tables with 1:1 relationships, LinqPad generates a property that points back to the collection of objects that use the lookup value. How to disable this?
It's causing problems when I try to serialize tables using Newtonsoft.JSON.
You can't prevent LINQPad from generating these properties, but you can tell Newtonsoft not to serialize them, with IContractResolver:
http://james.newtonking.com/archive/2009/10/23/efficient-json-with-json-net-reducing-serialized-json-size
Write your contract resolver class in the My Extensions query, so it will be available to all queries. In the CreateProperties method, where you filter the properties, you'll need to apply a condition on the property type to exclude navigation properties. The following will exclude all n:1 and 1:1 properties:
public class FlatResolver : DefaultContractResolver
{
public static JsonSerializerSettings Settings =
new JsonSerializerSettings { ContractResolver = new FlatResolver() };
protected override IList<JsonProperty> CreateProperties (Type type, MemberSerialization memberSerialization)
{
IList<JsonProperty> properties = base.CreateProperties (type, memberSerialization);
properties = properties
.Where (p => !p.PropertyType.GetCustomAttributes (typeof (System.Data.Linq.Mapping.TableAttribute)).Any())
.ToList();
return properties;
}
}
And then to serialize, just do this:
JsonConvert.SerializeObject (myObject, FlatResolver.Settings).Dump();
You can use similar logic to exclude 1:n, by checking for an IEnumerable of an entity type.
How can I customize Json.NET to serialize private members and NOT serialize public readonly properties (without using attributes).
I've had a stab around at creating a custom IContractResolver but am a bit lost.
For a partial answer, messing with DefaultContractResolver.DefaultMembersSearchFlags can get it to include private things:
Newtonsoft.Json.JsonSerializerSettings jss = new Newtonsoft.Json.JsonSerializerSettings();
if (includePrivateMembers)
{
Newtonsoft.Json.Serialization.DefaultContractResolver dcr = new Newtonsoft.Json.Serialization.DefaultContractResolver();
dcr.DefaultMembersSearchFlags |= System.Reflection.BindingFlags.NonPublic;
jss.ContractResolver = dcr;
}
return Newtonsoft.Json.JsonConvert.SerializeObject(o, jss);
Seems to work on a lot of objects, though with some this seems to generate a CLR exception.
In response to Chris' answer, the DefaultMemberSearchFlags property on DefaultContractResolver was deprecated as of version 6. Despite of what the deprecation message says, I believe you'll need to overwrite the CreateProperties method, too, like L.B explains.
This method gives you full control, including excluding readonly properties:
class PrivateContractResolver : DefaultContractResolver
{
protected override List<MemberInfo> GetSerializableMembers(Type objectType)
{
var flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
MemberInfo[] fields = objectType.GetFields(flags);
return fields
.Concat(objectType.GetProperties(flags).Where(propInfo => propInfo.CanWrite))
.ToList();
}
protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
{
return base.CreateProperties(type, MemberSerialization.Fields);
}
}