Serialize private properties and fields that are annotated with [DataMember] attribute

Author: mythz

src/ServiceStack.Text/ReflectionExtensions.cs

@@ -593,6 +593,44 @@ public static object CreateInstance(string typeName)
             return ctorFn();
         }
 
+        public static PropertyInfo[] GetAllProperties(this Type type)
+        {
+            if (type.IsInterface())
+            {
+                var propertyInfos = new List<PropertyInfo>();
+
+                var considered = new List<Type>();
+                var queue = new Queue<Type>();
+                considered.Add(type);
+                queue.Enqueue(type);
+
+                while (queue.Count > 0)
+                {
+                    var subType = queue.Dequeue();
+                    foreach (var subInterface in subType.GetTypeInterfaces())
+                    {
+                        if (considered.Contains(subInterface)) continue;
+
+                        considered.Add(subInterface);
+                        queue.Enqueue(subInterface);
+                    }
+
+                    var typeProperties = subType.GetTypesProperties();
+
+                    var newPropertyInfos = typeProperties
+                        .Where(x => !propertyInfos.Contains(x));
+
+                    propertyInfos.InsertRange(0, newPropertyInfos);
+                }
+
+                return propertyInfos.ToArray();
+            }
+
+            return type.GetTypesProperties()
+                .Where(t => t.GetIndexParameters().Length == 0) // ignore indexed properties
+                .ToArray();
+        }
+
         public static PropertyInfo[] GetPublicProperties(this Type type)
         {
             if (type.IsInterface())
@@ -648,22 +686,25 @@ internal static void Reset()
 
         public static PropertyInfo[] GetSerializableProperties(this Type type)
         {
-            var publicProperties = GetPublicProperties(type);
-            return publicProperties.OnlySerializableProperties(type);
+            var properties = type.IsDto()
+                ? type.GetAllProperties()
+                : type.GetPublicProperties();
+            return properties.OnlySerializableProperties(type);
         }
 
-        public static PropertyInfo[] OnlySerializableProperties(this PropertyInfo[] publicProperties, Type type = null)
+        public static PropertyInfo[] OnlySerializableProperties(this PropertyInfo[] properties, Type type = null)
         {
-            var publicReadableProperties = publicProperties.Where(x => x.PropertyGetMethod() != null);
+            var isDto = type.IsDto();
+            var readableProperties = properties.Where(x => x.PropertyGetMethod(nonPublic: isDto) != null);
 
-            if (type.IsDto())
+            if (isDto)
             {
-                return publicReadableProperties.Where(attr =>
+                return readableProperties.Where(attr =>
                     attr.HasAttribute<DataMemberAttribute>()).ToArray();
             }
 
             // else return those properties that are not decorated with IgnoreDataMember
-            return publicReadableProperties
+            return readableProperties
                 .Where(prop => prop.AllAttributes()
                     .All(attr => {
                             var name = attr.GetType().Name;
@@ -686,8 +727,8 @@ public static FieldInfo[] GetSerializableFields(this Type type)
         {
             if (type.IsDto())
             {
-                return type.GetAllFields().Where(attr =>
-                    attr.HasAttribute<DataMemberAttribute>()).ToArray();
+                return type.GetAllFields().Where(f =>
+                    f.HasAttribute<DataMemberAttribute>()).ToArray();
             }
 
             if (!JsConfig.IncludePublicFields)
@@ -856,6 +897,26 @@ internal static PropertyInfo[] GetTypesPublicProperties(this Type subType)
 #endif
         }
 
+        internal static PropertyInfo[] GetTypesProperties(this Type subType)
+        {
+#if (NETFX_CORE || PCL)
+            var pis = new List<PropertyInfo>();
+            foreach (var pi in subType.GetRuntimeProperties())
+            {
+                var mi = pi.GetMethod ?? pi.SetMethod;
+                if (mi != null && mi.IsStatic) continue;
+                pis.Add(pi);
+            }
+            return pis.ToArray();
+#else
+            return subType.GetProperties(
+                BindingFlags.FlattenHierarchy |
+                BindingFlags.Public |
+                BindingFlags.NonPublic |
+                BindingFlags.Instance);
+#endif
+        }
+
         public static Assembly GetAssembly(this Type type)
         {
 #if (NETFX_CORE || PCL)
@@ -879,7 +940,12 @@ public static FieldInfo[] Fields(this Type type)
 #if (NETFX_CORE || PCL)
             return type.GetRuntimeFields().ToArray();
 #else
-            return type.GetFields();
+            return type.GetFields(
+                BindingFlags.FlattenHierarchy |
+                BindingFlags.Instance |
+                BindingFlags.Static |
+                BindingFlags.Public |
+                BindingFlags.NonPublic);
 #endif
         }
 
@@ -888,7 +954,12 @@ public static PropertyInfo[] Properties(this Type type)
 #if (NETFX_CORE || PCL)
             return type.GetRuntimeProperties().ToArray();
 #else
-            return type.GetProperties();
+            return type.GetProperties(
+                BindingFlags.FlattenHierarchy |
+                BindingFlags.Instance |
+                BindingFlags.Static |
+                BindingFlags.Public |
+                BindingFlags.NonPublic);
 #endif
         }
 
@@ -902,7 +973,7 @@ public static FieldInfo[] GetAllFields(this Type type)
 #if (NETFX_CORE || PCL)
             return type.GetRuntimeFields().ToArray();
 #else
-            return type.GetPublicFields();
+            return type.Fields();
 #endif
         }
 
@@ -1033,7 +1104,7 @@ public static MethodInfo PropertyGetMethod(this PropertyInfo pi, bool nonPublic
 #if (NETFX_CORE || PCL)
             return pi.GetMethod;
 #else
-            return pi.GetGetMethod(false);
+            return pi.GetGetMethod(nonPublic);
 #endif
         }
 

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

@@ -519,10 +519,32 @@ public void Empty_string_converts_to_null_DateTime()
         [DataContract]
         class ModelWithDataMemberField
         {
+            public ModelWithDataMemberField() {}
+
+            public ModelWithDataMemberField(string privateField, string privateProperty)
+            {
+                PrivateField = privateField;
+                PrivateProperty = privateProperty;
+            }
+
             [DataMember]
             public int Id;
             [DataMember]
             public string Name { get; set; }
+            [DataMember]
+            private string PrivateProperty { get; set; }
+            [DataMember] 
+            private string PrivateField;
+
+            public string GetPrivateProperty()
+            {
+                return PrivateProperty;
+            }
+
+            public string GetPrivateField()
+            {
+                return PrivateField;
+            }
         }
 
         [Test]
@@ -538,6 +560,18 @@ public void Explicit_DataMember_attribute_also_applies_to_public_fields()
             Assert.That(person.ToJson().FromJson<ModelWithDataMemberField>().Id, Is.EqualTo(1));
         }
 
+        [Test]
+        public void Explicit_DataMember_attribute_serializers_private_properties_and_fields()
+        {
+            var person = new ModelWithDataMemberField("field", "property");
+
+            Assert.That(person.ToJsv().FromJsv<ModelWithDataMemberField>().GetPrivateField(), Is.EqualTo("field"));
+            Assert.That(person.ToJson().FromJson<ModelWithDataMemberField>().GetPrivateField(), Is.EqualTo("field"));
+
+            Assert.That(person.ToJsv().FromJsv<ModelWithDataMemberField>().GetPrivateProperty(), Is.EqualTo("property"));
+            Assert.That(person.ToJson().FromJson<ModelWithDataMemberField>().GetPrivateProperty(), Is.EqualTo("property"));
+        }
+
         [Test]
         public void Can_include_null_values_for_adhoc_types()
         {