This change allows to work with existence of the attribute on the Json message in same way as dynamic languages do.

(after deserialization to JavaScript for example you could test field existence by hasAttribute() function).

Changes:
- support for conditional serialization with method ShouldSerializeByName on DTO found by convention.
  - The difference to existing ShouldSerializeX is that it could handle all fields not just one.
  - It returns nullable bool with following meaning: True- should be on the json. False - should not be on the JSon. Null - use behavior defined by configuration and DataMemberAttribute

- support for attribute on wire detection with method OnDeserializingMember on DTO found by convention.
  - it complements ShouldSerializeByName and allows to implement full roundtrip of existence of the field on the JSon message.
  - it's designed in a way which allows event handler to change the deserialized object value before it's assigned to target field.
  - it will give raw json string for fields which don't have member on the DTO, allowing to implement parallel to IExtensibleDataObject for Json. It allows survival and forwarding of unknown attributes.

Author: pavelsavara

src/ServiceStack.Text/Common/DeserializeType.cs

@@ -40,8 +40,8 @@ public static ParseStringDelegate GetParseMethod(TypeConfig typeConfig)
                 return value => ctorFn();
 
             return typeof(TSerializer) == typeof(Json.JsonTypeSerializer)
-                ? (ParseStringDelegate)(value => DeserializeTypeRefJson.StringToType(type, value, ctorFn, map))
-                : value => DeserializeTypeRefJsv.StringToType(type, value, ctorFn, map);
+                ? (ParseStringDelegate)(value => DeserializeTypeRefJson.StringToType(typeConfig, value, ctorFn, map))
+                : value => DeserializeTypeRefJsv.StringToType(typeConfig, value, ctorFn, map);
         }
 
         public static object ObjectStringToType(string strType)

src/ServiceStack.Text/Common/DeserializeTypeRefJson.cs

@@ -52,12 +52,13 @@ internal static class DeserializeTypeRefJson
         private static readonly JsonTypeSerializer Serializer = (JsonTypeSerializer)JsonTypeSerializer.Instance;
 
         internal static object StringToType(
-        Type type,
+        TypeConfig typeConfig,
         string strType,
         EmptyCtorDelegate ctorFn,
         Dictionary<string, TypeAccessor> typeAccessorMap)
         {
             var index = 0;
+            var type = typeConfig.Type;
 
             if (strType == null)
                 return null;
@@ -140,6 +141,10 @@ internal static object StringToType(
                             var parseFn = JsonReader.GetParseFn(propType);
 
                             var propertyValue = parseFn(propertyValueStr);
+                            if (typeConfig.OnDeserializingMember != null)
+                            {
+                                propertyValue = typeConfig.OnDeserializingMember(instance, propertyName, propertyValue);
+                            }
                             typeAccessor.SetProperty(instance, propertyValue);
                         }
 
@@ -167,6 +172,10 @@ internal static object StringToType(
                     try
                     {
                         var propertyValue = typeAccessor.GetProperty(propertyValueStr);
+                        if (typeConfig.OnDeserializingMember != null)
+                        {
+                            propertyValue = typeConfig.OnDeserializingMember(instance, propertyName, propertyValue);
+                        }
                         typeAccessor.SetProperty(instance, propertyValue);
                     }
                     catch (Exception e)
@@ -175,6 +184,11 @@ internal static object StringToType(
                         else Tracer.Instance.WriteWarning("WARN: failed to set property {0} with: {1}", propertyName, propertyValueStr);
                     }
                 }
+                else if (typeConfig.OnDeserializingMember != null)
+                {
+                    // the property is not known by the DTO
+                    typeConfig.OnDeserializingMember(instance, propertyName, propertyValueStr);
+                }
 
                 //Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
                 for (; index < strType.Length; index++) { var c = strType[index]; if (c >= JsonTypeSerializer.WhiteSpaceFlags.Length || !JsonTypeSerializer.WhiteSpaceFlags[c]) break; } //Whitespace inline

src/ServiceStack.Text/Common/DeserializeTypeRefJsv.cs

@@ -12,12 +12,13 @@ internal static class DeserializeTypeRefJsv
         private static readonly JsvTypeSerializer Serializer = (JsvTypeSerializer)JsvTypeSerializer.Instance;
 
         internal static object StringToType(
-            Type type,
+            TypeConfig typeConfig,
             string strType,
             EmptyCtorDelegate ctorFn,
             Dictionary<string, TypeAccessor> typeAccessorMap)
         {
             var index = 0;
+            var type = typeConfig.Type;
 
             if (strType == null)
                 return null;
@@ -97,6 +98,10 @@ internal static object StringToType(
                         {
                             var parseFn = Serializer.GetParseFn(propType);
                             var propertyValue = parseFn(propertyValueStr);
+                            if (typeConfig.OnDeserializingMember != null)
+                            {
+                                propertyValue = typeConfig.OnDeserializingMember(instance, propertyName, propertyValue);
+                            }
                             typeAccessor.SetProperty(instance, propertyValue);
                         }
 
@@ -117,6 +122,10 @@ internal static object StringToType(
                     try
                     {
                         var propertyValue = typeAccessor.GetProperty(propertyValueStr);
+                        if (typeConfig.OnDeserializingMember != null)
+                        {
+                            propertyValue = typeConfig.OnDeserializingMember(instance, propertyName, propertyValue);
+                        }
                         typeAccessor.SetProperty(instance, propertyValue);
                     }
                     catch (Exception e)
@@ -125,6 +134,11 @@ internal static object StringToType(
                         else Tracer.Instance.WriteWarning("WARN: failed to set property {0} with: {1}", propertyName, propertyValueStr);
                     }
                 }
+                else if (typeConfig.OnDeserializingMember != null)
+                {
+                    // the property is not known by the DTO
+                    typeConfig.OnDeserializingMember(instance, propertyName, propertyValueStr);
+                }
 
                 //Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
                 if (index != strType.Length) index++;

src/ServiceStack.Text/Common/WriteType.cs

@@ -108,6 +108,16 @@ static Func<T, bool> GetShouldSerializeMethod(MemberInfo member)
                 null, Type.EmptyTypes, null);
             return (method == null || method.ReturnType != typeof(bool)) ? null : (Func<T,bool>)Delegate.CreateDelegate(typeof(Func<T,bool>), method);
         }
+
+        static Func<T,string, bool?> ShouldSerializeByName(Type type)
+        {
+            var method = type.GetMethod("ShouldSerializeByName", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[] { typeof(string) }, null);
+            return (method == null || method.ReturnType != typeof(bool?)) 
+                ? null 
+                : (Func<T, string, bool?>)Delegate.CreateDelegate(typeof(Func<T,string, bool?>), method);
+        }
+
+
         private static bool Init()
         {
             if (!typeof(T).IsClass() && !typeof(T).IsInterface() && !JsConfig.TreatAsRefType(typeof(T))) return false;
@@ -124,6 +134,8 @@ private static bool Init()
                 return typeof(T).IsDto();
             }
 
+            var shouldSerializeByName = ShouldSerializeByName(typeof(T));
+
             // NOTE: very limited support for DataContractSerialization (DCS)
             //	NOT supporting Serializable
             //	support for DCS is intended for (re)Name of properties and Ignore by NOT having a DataMember present
@@ -174,7 +186,8 @@ private static bool Init()
                     propertyInfo.GetValueGetter<T>(),
                     Serializer.GetWriteFn(propertyType),
                     propertyType.GetDefaultValue(),
-                    shouldSerialize
+                    shouldSerialize,
+                    shouldSerializeByName
                 );
             }
 
@@ -221,7 +234,8 @@ private static bool Init()
                     fieldInfo.GetValueGetter<T>(),
                     Serializer.GetWriteFn(propertyType),
                     defaultValue,
-                    shouldSerialize
+                    shouldSerialize,
+                    shouldSerializeByName
                 );
             }
             PropertyWriters = PropertyWriters.OrderBy(x => x.propertyOrder).ToArray();
@@ -253,9 +267,10 @@ internal string PropertyName
             internal readonly WriteObjectDelegate WriteFn;
             internal readonly object DefaultValue;
             internal readonly Func<T, bool> shouldSerialize;
+            internal readonly Func<T, string, bool?> shouldSerializeByName;
 
             public TypePropertyWriter(string propertyName, string propertyReflectedName, string propertyNameCLSFriendly, string propertyNameLowercaseUnderscore, int propertyOrder, bool propertySuppressDefaultConfig,bool propertySuppressDefaultAttribute,
-                Func<T, object> getterFn, WriteObjectDelegate writeFn, object defaultValue, Func<T, bool> shouldSerialize)
+                Func<T, object> getterFn, WriteObjectDelegate writeFn, object defaultValue, Func<T, bool> shouldSerialize, Func<T,string, bool?> shouldSerializeByName)
             {
                 this.propertyName = propertyName;
                 this.propertyOrder = propertyOrder;
@@ -269,6 +284,7 @@ public TypePropertyWriter(string propertyName, string propertyReflectedName, str
                 this.WriteFn = writeFn;
                 this.DefaultValue = defaultValue;
                 this.shouldSerialize = shouldSerialize;
+                this.shouldSerializeByName = shouldSerializeByName;
             }
         }
 
@@ -337,21 +353,38 @@ public static void WriteProperties(TextWriter writer, object value)
                     var propertyWriter = PropertyWriters[index];
 
                     if (propertyWriter.shouldSerialize != null && !propertyWriter.shouldSerialize((T)value)) continue;
-
+                    bool dontSkipDefault=false;
+                    if (propertyWriter.shouldSerializeByName != null)
+                    {
+                        var shouldSerialize = propertyWriter.shouldSerializeByName((T) value, propertyWriter.PropertyName);
+                        if (shouldSerialize.HasValue)
+                        {
+                            if (shouldSerialize.Value)
+                            {
+                                dontSkipDefault = true;
+                            }
+                            else
+                            {
+                                continue;
+                            }
+                        }
+                    }
                     var propertyValue = value != null
                         ? propertyWriter.GetterFn((T)value)
                         : null;
-                    
-                    if (propertyWriter.propertySuppressDefaultAttribute && Equals(propertyWriter.DefaultValue, propertyValue))
-                    {
-                        continue;
-                    }
-                    if ((propertyValue == null 
-                         || (propertyWriter.propertySuppressDefaultConfig && Equals(propertyWriter.DefaultValue, propertyValue)))
-                        && !Serializer.IncludeNullValues
-                        )
+                    if (!dontSkipDefault)
                     {
-                        continue;
+                        if (propertyWriter.propertySuppressDefaultAttribute && Equals(propertyWriter.DefaultValue, propertyValue))
+                        {
+                            continue;
+                        }
+                        if ((propertyValue == null
+                             || (propertyWriter.propertySuppressDefaultConfig && Equals(propertyWriter.DefaultValue, propertyValue)))
+                            && !Serializer.IncludeNullValues
+                            )
+                        {
+                            continue;
+                        }
                     }
 
                     if (exclude.Any() && exclude.Contains(propertyWriter.propertyCombinedNameUpper)) continue;

src/ServiceStack.Text/ReflectionExtensions.cs

@@ -536,6 +536,17 @@ public static PropertyInfo[] GetSerializableProperties(this Type type)
             return publicReadableProperties.Where(prop => !prop.CustomAttributes(false).Any(attr => attr.GetType().Name == IgnoreDataMember)).ToArray();
         }
 
+        public static Func<object, string, object, object> GetOnDeserializingMember<T>()
+        {
+            var method = typeof(T).GetMethod("OnDeserializingMember", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new[] { typeof(string), typeof(object) }, null);
+            if (method == null || method.ReturnType != typeof (object))
+            {
+                return null;
+            }
+            var ojb = (Func<T, string, object, object>)Delegate.CreateDelegate(typeof(Func<T, string, object, object>), method);
+            return (instance, memberName, value) => ojb((T)instance, memberName, value);
+        }
+
         public static FieldInfo[] GetSerializableFields(this Type type)
         {
             if (type.IsDto()) {

src/ServiceStack.Text/TypeConfig.cs

@@ -10,6 +10,7 @@ internal class TypeConfig
 		internal bool EnableAnonymousFieldSetterses;
 		internal PropertyInfo[] Properties;
 		internal FieldInfo[] Fields;
+        internal Func<object, string, object, object> OnDeserializingMember;
 
 		internal TypeConfig(Type type)
 		{
@@ -42,6 +43,12 @@ public static bool EnableAnonymousFieldSetters
 			set { config.EnableAnonymousFieldSetterses = value; }
 		}
 
+        public static Func<object, string, object, object> OnDeserializingMember
+		{
+            get { return config.OnDeserializingMember; }
+            set { config.OnDeserializingMember = value; }
+		}
+
 		static TypeConfig()
 		{
 			config = new TypeConfig(typeof(T));
@@ -54,6 +61,7 @@ static TypeConfig()
             Properties = properties.Where(x => x.GetIndexParameters().Length == 0).ToArray();
 
 			Fields = config.Type.GetSerializableFields().ToArray();
+		    OnDeserializingMember = ReflectionExtensions.GetOnDeserializingMember<T>();
 		}
 
 		internal static TypeConfig GetState()

tests/ServiceStack.Text.Tests/JsonTests/ConditionalSerializationTests.cs

@@ -1,5 +1,8 @@
-using NUnit.Framework;
+using System.Reflection;
+using System.Runtime.Serialization;
+using NUnit.Framework;
 using System;
+using ServiceStack.Text.WP;
 
 namespace ServiceStack.Text.Tests.JsonTests
 {
@@ -14,6 +17,7 @@ public void TestSerializeRespected()
             string json = JsonSerializer.SerializeToString(obj);
             Assert.That(json, Is.StringMatching("{\"X\":\"abc\",\"Z\":\"def\"}"));   
         }
+        
         [Test]
         public void TestSerializeRespectedWithInheritance()
         {
@@ -22,6 +26,52 @@ public void TestSerializeRespectedWithInheritance()
             string json = JsonSerializer.SerializeToString(obj);
             Assert.That(json, Is.StringMatching("{\"A\":123,\"C\":456,\"X\":\"abc\",\"Z\":\"def\"}"));
         }
+
+        [Test]
+        public void TestSerializeHasAttributeNull()
+        {
+            var obj = new ByNameFoo { A = 123, B = 456 };
+
+            string json = JsonSerializer.SerializeToString(obj);
+            Assert.That(json, Is.StringMatching("{\"A\":123,\"B\":456}"));
+        }
+
+        [Test]
+        public void TestSerializeHasAttributeSet()
+        {
+            var obj = new ByNameFoo {A = 123, B = 456, hasAttribute = new HashSet<string> {"A"}};
+
+            string json = JsonSerializer.SerializeToString(obj);
+            Assert.That(json, Is.StringMatching("{\"A\":123"));
+
+            var cpy = JsonSerializer.DeserializeFromString<ByNameFoo>(json);
+            Assert.That(cpy.A, Is.EqualTo(obj.A));
+            Assert.That(cpy.hasAttribute, Is.EqualTo(obj.hasAttribute));
+        }
+
+        [Test]
+        public void TestSerializeHasAttributeSetNullValue()
+        {
+            var obj = new ByNameFoo {A = 123, B = null, hasAttribute = new HashSet<string> {"B"}};
+
+            string json = JsonSerializer.SerializeToString(obj);
+            Assert.That(json, Is.StringMatching("{\"B\":null"));
+
+            var cpy = JsonSerializer.DeserializeFromString<ByNameFoo>(json);
+            Assert.That(cpy.A, Is.EqualTo(0));
+            Assert.That(cpy.B, Is.EqualTo(obj.B));
+            Assert.That(cpy.hasAttribute, Is.EqualTo(obj.hasAttribute));
+        }
+
+        [Test]
+        public void OnDeserializingMemberUnknown()
+        {
+            var cpy = JsonSerializer.DeserializeFromString<ByNameFoo>("{\"B\":1,\"C\":1");
+            Assert.That(cpy.A, Is.EqualTo(0));
+            Assert.That(cpy.B, Is.EqualTo(1));
+            Assert.That(cpy.hasAttribute, Is.EqualTo(new HashSet<string>{"B","C"}));
+        }
+
         public class Foo
         {
             public string X { get; set; } // not conditional
@@ -65,5 +115,37 @@ public bool ShouldSerializeC()
                 return true;
             }
         }
+
+        [DataContract]
+        public class ByNameFoo
+        {
+            [IgnoreDataMember] 
+            public HashSet<string> hasAttribute;
+
+            [DataMember(EmitDefaultValue = false,IsRequired = false)]
+            public int A { get; set; }
+
+            [DataMember(EmitDefaultValue = false, IsRequired = false)]
+            public int? B { get; set; }
+
+            private bool? ShouldSerializeByName(string fieldName)
+            {
+                if (hasAttribute == null)
+                {
+                    return null;
+                }
+                return hasAttribute.Contains(fieldName);
+            }
+
+            private object OnDeserializingMember(string fieldName, object value)
+            {
+                if (hasAttribute == null)
+                {
+                    hasAttribute=new HashSet<string>();
+                }
+                hasAttribute.Add(fieldName);
+                return value;
+            }
+        }
     }
 }