Add support for private properties.

YamlDotNet.Test/Serialization/SerializationTestHelper.cs

@@ -539,4 +539,32 @@ public class NameConvention
         [YamlIgnore]
         public string fourthTest { get; set; }
     }
+
+    public class NonPublicPropertiesExample
+    {
+        public string Public { get; set; } = "public";
+
+        internal string Internal { get; set; } = "internal";
+
+        protected string Protected { get; set; } = "protected";
+
+        private string Private { get; set; } = "private";
+
+        /// <inheritdoc />
+        public override string ToString() => $"{Public},{Internal},{Protected},{Private}";
+    }
+
+    public class NonPublicFieldsExample
+    {
+        public string Public = "public";
+
+        internal string Internal = "internal";
+
+        protected string Protected = "protected";
+
+        private string Private = "private";
+
+        /// <inheritdoc />
+        public override string ToString() => $"{Public},{Internal},{Protected},{Private}";
+    }
 }

YamlDotNet.Test/Serialization/SerializationTests.cs

@@ -1764,6 +1764,80 @@ public void AnchorWithAllowedCharactersCanBeDeserialized()
             Assert.Equal("some value", deserialized["interpolated value"]);
         }
 
+        [Fact]
+        public void SerializationNonPublicPropertiesAreIgnored()
+        {
+            var sut = new SerializerBuilder().Build();
+            var yaml = sut.Serialize(new NonPublicPropertiesExample());
+            Assert.Equal("Public: public", yaml.TrimNewLines());
+        }
+
+        [Fact]
+        public void SerializationNonPublicPropertiesAreIncluded()
+        {
+            var sut = new SerializerBuilder().IncludeNonPublicProperties().Build();
+            var yaml = sut.Serialize(new NonPublicPropertiesExample());
+
+            var expected = Yaml.Text(@"
+                Public: public
+                Internal: internal
+                Protected: protected
+                Private: private
+            ");
+
+            Assert.Equal(expected.NormalizeNewLines(), yaml.NormalizeNewLines().TrimNewLines());
+        }
+
+        [Fact]
+        public void DeserializationNonPublicPropertiesAreIgnored()
+        {
+            var sut = new DeserializerBuilder().IgnoreUnmatchedProperties().Build();
+            var deserialized = sut.Deserialize<NonPublicPropertiesExample>(Yaml.ReaderForText(@"
+                Public: public2
+                Internal: internal2
+                Protected: protected2
+                Private: private2
+            "));
+
+            Assert.Equal("public2,internal,protected,private", deserialized.ToString());
+        }
+
+                [Fact]
+        public void DeserializationNonPublicPropertiesAreIncluded()
+        {
+            var sut = new DeserializerBuilder().IncludeNonPublicProperties().Build();
+            var deserialized = sut.Deserialize<NonPublicPropertiesExample>(Yaml.ReaderForText(@"
+                Public: public2
+                Internal: internal2
+                Protected: protected2
+                Private: private2
+            "));
+
+            Assert.Equal("public2,internal2,protected2,private2", deserialized.ToString());
+        }
+
+        [Fact]
+        public void SerializationNonPublicFieldsAreIgnored()
+        {
+            var sut = new SerializerBuilder().Build();
+            var yaml = sut.Serialize(new NonPublicFieldsExample());
+            Assert.Equal("Public: public", yaml.TrimNewLines());
+        }
+
+        [Fact]
+        public void DeserializationNonPublicFieldsAreIgnored()
+        {
+            var sut = new DeserializerBuilder().IgnoreUnmatchedProperties().Build();
+            var deserialized = sut.Deserialize<NonPublicFieldsExample>(Yaml.ReaderForText(@"
+                Public: public2
+                Internal: internal2
+                Protected: protected2
+                Private: private2
+            "));
+
+            Assert.Equal("public2,internal,protected,private", deserialized.ToString());
+        }
+
         [TypeConverter(typeof(DoublyConvertedTypeConverter))]
         public class DoublyConverted
         {

YamlDotNet/Helpers/Portability.cs

@@ -182,15 +182,22 @@ public static Type[] GetGenericArguments(this Type type)
             return type.GetRuntimeProperty(name);
         }
 
-        public static IEnumerable<PropertyInfo> GetPublicProperties(this Type type)
+        public static IEnumerable<PropertyInfo> GetProperties(this Type type, bool includeNonPublic)
         {
-            var instancePublic = new Func<PropertyInfo, bool>(
-                p => !p.GetMethod.IsStatic && p.GetMethod.IsPublic);
+            var instancePublic
+                = new Func<PropertyInfo, bool>(
+                                               p => !p.GetMethod.IsStatic
+                                                    && (p.GetMethod.IsPublic || includeNonPublic));
             return type.IsInterface()
-                ? (new Type[] { type })
-                    .Concat(type.GetInterfaces())
-                    .SelectMany(i => i.GetRuntimeProperties().Where(instancePublic))
-                : type.GetRuntimeProperties().Where(instancePublic);
+                       ? (new Type[] { type })
+                         .Concat(type.GetInterfaces())
+                         .SelectMany(i => i.GetRuntimeProperties().Where(instancePublic))
+                       : type.GetRuntimeProperties().Where(instancePublic);
+        }
+
+        public static IEnumerable<PropertyInfo> GetPublicProperties(this Type type)
+        {
+            return GetProperties(type, false);
         }
 
         public static IEnumerable<FieldInfo> GetPublicFields(this Type type)
@@ -225,7 +232,7 @@ public static IEnumerable<MethodInfo> GetPublicStaticMethods(this Type type)
                 .FirstOrDefault(m => m.IsPublic && !m.IsStatic && m.Name.Equals(name));
         }
 
-        public static MethodInfo GetGetMethod(this PropertyInfo property)
+        public static MethodInfo GetGetMethod(this PropertyInfo property, bool _)
         {
             return property.GetMethod;
         }
@@ -324,12 +331,23 @@ public static TypeCode GetTypeCode(this Type type)
 
         public static IEnumerable<PropertyInfo> GetPublicProperties(this Type type)
         {
-            var instancePublic = BindingFlags.Instance | BindingFlags.Public;
+            return GetProperties(type, false);
+        }
+
+        public static IEnumerable<PropertyInfo> GetProperties(this Type type, bool includeNonPublic)
+        {
+            var bindingFlags = BindingFlags.Instance | BindingFlags.Public;
+
+            if (includeNonPublic)
+            {
+                bindingFlags |= BindingFlags.NonPublic;
+            }
+
             return type.IsInterface
                 ? (new Type[] { type })
                     .Concat(type.GetInterfaces())
-                    .SelectMany(i => i.GetProperties(instancePublic))
-                : type.GetProperties(instancePublic);
+                    .SelectMany(i => i.GetProperties(bindingFlags))
+                : type.GetProperties(bindingFlags);
         }
 
         public static IEnumerable<FieldInfo> GetPublicFields(this Type type)

YamlDotNet/RepresentationModel/YamlMappingNode.cs

@@ -412,7 +412,7 @@ public static YamlMappingNode FromObject(object mapping)
             foreach (var property in mapping.GetType().GetPublicProperties())
             {
                 // CanRead == true => GetGetMethod() != null
-                if (property.CanRead && property.GetGetMethod()!.GetParameters().Length == 0)
+                if (property.CanRead && property.GetGetMethod(false)!.GetParameters().Length == 0)
                 {
                     var value = property.GetValue(mapping, null);
                     if (!(value is YamlNode valueNode))

YamlDotNet/Serialization/BuilderSkeleton.cs

@@ -40,6 +40,7 @@ public abstract class BuilderSkeleton<TBuilder>
         internal readonly LazyComponentRegistrationList<Nothing, IYamlTypeConverter> typeConverterFactories;
         internal readonly LazyComponentRegistrationList<ITypeInspector, ITypeInspector> typeInspectorFactories;
         private bool ignoreFields;
+        private bool includeNonPublicProperties = false;
 
         internal BuilderSkeleton(ITypeResolver typeResolver)
         {
@@ -59,7 +60,7 @@ internal BuilderSkeleton(ITypeResolver typeResolver)
 
         internal ITypeInspector BuildTypeInspector()
         {
-            ITypeInspector innerInspector = new ReadablePropertiesTypeInspector(typeResolver);
+            ITypeInspector innerInspector = new ReadablePropertiesTypeInspector(typeResolver, includeNonPublicProperties);
             if (!ignoreFields)
             {
                 innerInspector = new CompositeTypeInspector(
@@ -81,6 +82,15 @@ public TBuilder IgnoreFields()
             return Self;
         }
 
+        /// <summary>
+        /// Allows serialization and deserialization of non-public properties.
+        /// </summary>
+        public TBuilder IncludeNonPublicProperties()
+        {
+            includeNonPublicProperties = true;
+            return Self;
+        }
+
         /// <summary>
         /// Sets the <see cref="INamingConvention" /> that will be used by the (de)serializer.
         /// </summary>

YamlDotNet/Serialization/TypeInspectors/ReadablePropertiesTypeInspector.cs

@@ -33,22 +33,29 @@ namespace YamlDotNet.Serialization.TypeInspectors
     public sealed class ReadablePropertiesTypeInspector : TypeInspectorSkeleton
     {
         private readonly ITypeResolver typeResolver;
+        private readonly bool includeNonPublicProperties;
 
         public ReadablePropertiesTypeInspector(ITypeResolver typeResolver)
+            :this(typeResolver, false)
+        {
+        }
+
+        public ReadablePropertiesTypeInspector(ITypeResolver typeResolver, bool includeNonPublicProperties)
         {
             this.typeResolver = typeResolver ?? throw new ArgumentNullException(nameof(typeResolver));
+            this.includeNonPublicProperties = includeNonPublicProperties;
         }
 
         private static bool IsValidProperty(PropertyInfo property)
         {
             return property.CanRead
-                && property.GetGetMethod()!.GetParameters().Length == 0;
+                && property.GetGetMethod(true)!.GetParameters().Length == 0;
         }
 
         public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
         {
             return type
-                .GetPublicProperties()
+                .GetProperties(includeNonPublicProperties)
                 .Where(IsValidProperty)
                 .Select(p => (IPropertyDescriptor)new ReflectionPropertyDescriptor(p, typeResolver));
         }