Develop Reference

protobuf-net conditional serialization given as initialize on Serializer.Serialize()

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

Modify/Add property via custom IContractResolver

I have a class:
public class MyClass
{
public MyEnum Foo{ get; set; }
}
During serialization i'd like to change the output from
{
"Foo": 1
}
to
{
"Foo": "EnumName"
}
I've tried creating an IValueProvider but hit dead ends every way I go. (My scenario is a bit more complicated than stated; I need to find a way to do this entirely within the IContractResolver.)

You could create a custom ContractResolver inheriting from DefaultContractResolver that automatically applies StringEnumConverter to every contract for an enum or nullable enum:
public class StringEnumContractResolver : DefaultContractResolver
{
readonly StringEnumConverter converter;
public StringEnumContractResolver() : this(true, false) { }
public StringEnumContractResolver(bool allowIntegerValue, bool camelCaseText)
{
this.converter = new StringEnumConverter { AllowIntegerValues = allowIntegerValue, CamelCaseText = camelCaseText };
}
protected override JsonPrimitiveContract CreatePrimitiveContract(Type objectType)
{
var contract = base.CreatePrimitiveContract(objectType);
var type = Nullable.GetUnderlyingType(contract.UnderlyingType) ?? contract.UnderlyingType;
if (type.IsEnum && contract.Converter == null)
contract.Converter = converter;
return contract;
}
}
Notes:
If the enum type already has a JsonConverter applied, that is kept in preference to the default StringEnumConverter.
Adding the converter to the JsonPrimitiveContract for the enum itself, rather than to every JsonProperty for members that return the enum, ensures that the converter is applied to enums in collections and dictionaries.
The IValueProvider merely provides methods to get and set values and thus is less convenient to this purpose than the converter. You would need to perform a nested serialization and deserialization of the enum value as a JSON string inside it, but it isn't designed for this and so doesn't have access to the JSON reader, writer, or serializer. In addition, there is no value provider for dictionary values or collection items that are enums.
You may want to cache the contract resolver for best performance as explained here.
Sample .Net fiddle.

How to disable generated navigation properties in Linqpad?

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.

Conditional serialization/deserialization of object properties with json.net [duplicate]

This question already has answers here:
Serialize Property, but Do Not Deserialize Property in Json.Net
(2 answers)
Closed 6 years ago.
I have a scenario with a class defined as below:
class MyObject
{
public DataDictionary MyObjectData { get; set; }
public bool ShouldSerializeMyObjectData() { return true; }
public bool ShouldDeserializeMyObjectData() { return false; }
}
When I attempt to serialize/deserialize that class with JSON.net, it takes the ShouldSerialize into account, but not the ShouldDeserialize.
According to the documentation, both should work the same way I guess. Is there something particular I should know? More generally, how should I deal with scenarios where I want to serialize a property but not deserialize it?
I'm using Json.NET 8.0 if that matters.
Thanks for your help.

The short answer to your question is, automatically checking for ShouldDeserialize{PropertyName}() is not currently implemented even though ShouldSerialize{PropertyName}() is. A longer answer and workaround follow.
The class JsonProperty is used internally by Json.NET to define a contract for how to map a JSON property to a .NET member or constructor parameter. It has two predicate properties, ShouldSerialize and ShouldDeserialize that, when non-null, prevent a property from being serialized and deserialized, respectively. Initializing each JsonProperty is the job of the ContractResolver. For each property {PropertyName}, Json.NET's default contract resolver automatically checks for the presence of a public bool ShouldSerialize{PropertyName}() method. If such a method exists, it adds a call to it in the ShouldSerialize predicate, thereby suppressing serialization when the method returns false. This was implemented because controlling property serialization via a method ShouldSerialize{PropertyName}() is a standard pattern supported by, e.g., XmlSerializer. For more background see the relevant Json.NET release notes.
For example, in the following class, serialization of MyObjectData will be suppressed unless MyObjectData.Count > 0:
class MyObject
{
public DataDictionary MyObjectData { get; set; }
public bool ShouldSerializeMyObjectData() { return MyObjectData != null && MyObjectData.Count > 0; }
}
JsonProperty.ShouldDeserialize, however, it is never set by the default contract resolver. This may be due to the fact that there is no standard pattern for deserialization equivalent to ShouldSerialize{PropertyName}() and so Newtonsoft never had any requests to implement such a pattern. Nevertheless, as you have noticed, infrastructure to support such a pattern exists, and so applications can create custom contract resolvers that do just that. In fact, Json.NET has an example of such a contract resolver in its own test suite:
public class ShouldDeserializeContractResolver : DefaultContractResolver
{
public static new readonly ShouldDeserializeContractResolver Instance = new ShouldDeserializeContractResolver();
protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
{
JsonProperty property = base.CreateProperty(member, memberSerialization);
MethodInfo shouldDeserializeMethodInfo = member.DeclaringType.GetMethod("ShouldDeserialize" + member.Name);
if (shouldDeserializeMethodInfo != null)
{
property.ShouldDeserialize = o => { return (bool)shouldDeserializeMethodInfo.Invoke(o, null); };
}
return property;
}
}
public class ShouldDeserializeTestClass
{
[JsonExtensionData]
public IDictionary<string, JToken> ExtensionData { get; set; }
public bool HasName { get; set; }
public string Name { get; set; }
public bool ShouldDeserializeName()
{
return HasName;
}
}
If you want to conditionally suppress deserialization of properties even when present in the JSON, you may use this contract resolver.
Notes:
If you do use a custom contract resolver, you should cache and reuse it for best performance.
JsonProperty.ShouldDeserialize is called before the property value is deserialized. If it returns true, the property is skipped, with no ability to examine the contents of the property. Thus it cannot be used to implement custom filtering based on that value.
A JSON object is defined by the JSON standard as an unordered set of name/value pairs. Thus a ShouldDeserialize method that assumes that other properties have already been read in may be brittle.
Instead, if you want to skip deserialization of one property based on the value of another, consider using an [OnDeserialized] callback and clearing the unwanted value there, after all properties have been deserialized.

Serialize/deserialize private fields and autoproperties of an object

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);