Added support to ignore properties based on declared type (#24)

Added support to ignore properties based on declared type

Co-authored-by: Jonathan Taylor <jltaylor@ebay.com>
Co-authored-by: Pawel Idzikowski <29297999+polenter@users.noreply.github.com>

Author: 3 people

HelloWorldApp/Form1.cs

@@ -157,7 +157,7 @@ private SharpSerializerXmlSettings createXmlSettings()
             settings.IncludeCultureInTypeName = true;
             settings.IncludePublicKeyTokenInTypeName = true;
 
-            
+
 
             // ADVANCED SETTINGS
             // Most of the classes needed to alter these settings are in the namespace Polenter.Serialization.Advanced
@@ -173,7 +173,13 @@ private SharpSerializerXmlSettings createXmlSettings()
             // serializer.PropertyProvider.PropertiesToIgnore.Add(typeof(List<string>), "Capacity")
             settings.AdvancedSettings.PropertiesToIgnore.Add(typeof (List<string>), "Capacity");
 
-            
+
+            // PropertyTypesToIgnore
+            // Sometimes you want to ignore some types during the serialization.
+            // To ignore a type add these types to the list PropertyTypesToIgnore.
+            settings.AdvancedSettings.PropertyTypesToIgnore.Add(typeof(List<string>));
+
+
             // RootName
             // There is always a root element during serialization. Default name of this element is "Root", 
             // but you can change it to any other text.
@@ -271,6 +277,12 @@ private SharpSerializerBinarySettings createBinarySettings()
             settings.AdvancedSettings.PropertiesToIgnore.Add(typeof(List<string>), "Capacity");
 
 
+            // PropertyTypesToIgnore
+            // Sometimes you want to ignore some types during the serialization.
+            // To ignore a type add these types to the list PropertyTypesToIgnore.
+            settings.AdvancedSettings.PropertyTypesToIgnore.Add(typeof(List<string>));
+
+
             // RootName
             // There is always a root element during the serialization. Default name of this element is "Root", 
             // but you can change it to any other text.
@@ -354,19 +366,20 @@ private SharpSerializer createSerializerWithCustomReaderAndWriter()
 
             var sharpSerializer = new SharpSerializer(serializer, deserializer);
 
-            
+
             // there is one more option you can alter directly on your instance of SharpSerializer
 
             // *************************************************************************************
             // PropertyProvider
-            // If the advanced setting PropertiesToIgnore are not enough there is possibility to create your own PropertyProvider
+            // If the advanced setting PropertiesToIgnore or PropertyTypesToIgnore are not enough there is possibility to create your own PropertyProvider
             // As a standard there are only properties serialized which:
             // - are public
             // - are not static
             // - does not contain ExcludeFromSerializationAttribute
             // - have their set and get accessors
             // - are not indexers
             // - are not in PropertyProvider.PropertiesToIgnore
+            // - are not in PropertyProvider.PropertyTypesToIgnore
             // You can replace this functionality with an inheritor class of PropertyProvider
 
             sharpSerializer.PropertyProvider = new MyVerySophisticatedPropertyProvider();

SharpSerializer.Tests/SerializationTests.cs

@@ -42,6 +42,16 @@ public class Class2BeSerialized
 
             [MyExcludeAttribute]
             public virtual Class2BeSerialized ComplexPrivateAttribute { get; set; }
+
+            public Class2BeIgnored IgnoredType { get; set; }
+        }
+
+        /// <summary>
+        /// Local testclass to be ignored
+        /// </summary>
+        public class Class2BeIgnored
+        {
+            public string Name { get; set; }
         }
 
         [TestMethod]
@@ -62,6 +72,10 @@ public void XmlSerial_IgnoredAttributesShouldNotBeSerialized()
                 ComplexSystemAttribute = child,
                 ComplexPrivateAttribute = child,
                 ComplexRule = child,
+                IgnoredType = new Class2BeIgnored
+                {
+                    Name = "Ignored"
+                }
             };
 
             /*
@@ -91,6 +105,8 @@ public void XmlSerial_IgnoredAttributesShouldNotBeSerialized()
             Assert.AreEqual(0, doc.SelectNodes("//Complex[@name='ComplexRule']").Count, "ComplexRule");
             Assert.AreEqual(0, doc.SelectNodes("//Complex[@name='ComplexSystemAttribute']").Count, "ComplexSystemAttribute");
             Assert.AreEqual(0, doc.SelectNodes("//Complex[@name='ComplexPrivateAttribute']").Count, "ComplexPrivateAttribute");
+
+            Assert.AreEqual(0, doc.SelectNodes("//Complex[@name='IgnoredType']").Count, "IgnoredType");
         }
 
         private static XmlDocument Save(object data)
@@ -101,6 +117,8 @@ private static XmlDocument Save(object data)
             settings.AdvancedSettings.PropertiesToIgnore.Add(typeof(Class2BeSerialized), "NameRule");
             settings.AdvancedSettings.PropertiesToIgnore.Add(typeof(Class2BeSerialized), "ComplexRule");
 
+            settings.AdvancedSettings.PropertyTypesToIgnore.Add(typeof(Class2BeIgnored));
+
             settings.AdvancedSettings.AttributesToIgnore.Add(typeof(MyExcludeAttribute));
             // this does not work
             //settings.AdvancedSettings.PropertiesToIgnore.Add(null, "NameRule");

SharpSerializer/Advanced/PropertyProvider.cs

@@ -1,4 +1,4 @@
-#region Copyright © 2010 Pawel Idzikowski [idzikowski@sharpserializer.com]
+#region Copyright © 2010 Pawel Idzikowski [idzikowski@sharpserializer.com]
 
 //  ***********************************************************************
 //  Project: sharpSerializer
@@ -43,11 +43,13 @@ namespace Polenter.Serialization.Advanced
     ///   
     /// Its methods GetAllProperties and IgnoreProperty can be
     ///   overwritten in an inherited class to customize its functionality. 
-    ///   Its property PropertiesToIgnore contains properties, which are ignored during the serialization.
+    ///   Its property PropertiesToIgnore contains properties and its property PropertyTypesToIgnore
+    ///   container types, which are ignored during the serialization.
     /// </summary>
     public class PropertyProvider
     {
         private PropertiesToIgnore _propertiesToIgnore;
+        private IList<Type> _propertyTypesToIgnore;
         private IList<Type> _attributesToIgnore;
 
         [ThreadStatic]
@@ -75,6 +77,23 @@ public PropertiesToIgnore PropertiesToIgnore
             set { _propertiesToIgnore = value; }
         }
 
+        /// <summary>
+        ///   Which types should be ignored
+        /// </summary>
+        /// <remarks>
+        /// Sometimes you want to ignore some types during the serialization.
+        // To ignore a type add these types to the list PropertyTypesToIgnore.
+        /// </remarks>
+        public IList<Type> PropertyTypesToIgnore
+        {
+            get
+            {
+                if (_propertyTypesToIgnore == null) _propertyTypesToIgnore = new List<Type>();
+                return _propertyTypesToIgnore;
+            }
+            set { _propertyTypesToIgnore = value; }
+        }
+
         /// <summary>
         /// All Properties markt with one of the contained attribute-types will be ignored on save.
         /// </summary>
@@ -133,14 +152,24 @@ public IList<PropertyInfo> GetProperties(Serialization.Serializing.TypeInfo type
         /// <returns>
         ///   true if the property:
         ///   - is in the PropertiesToIgnore,
+        ///   - is in the PropertyTypesToIgnore,
         ///   - contains ExcludeFromSerializationAttribute,
         ///   - does not have it's set or get accessor
         ///   - is indexer
         /// </returns>
         protected virtual bool IgnoreProperty(Serialization.Serializing.TypeInfo info, PropertyInfo property)
         {
             // Soll die Eigenschaft ignoriert werden
+            if (PropertyTypesToIgnore.Contains(property.PropertyType))
+            {
+                return true;
+            }
+            
             if (PropertiesToIgnore.Contains(info.Type, property.Name))
+            {
+                return true;
+            }            
+
             {
                 return true;
             }

SharpSerializer/Core/SharpSerializerSettings.cs

@@ -111,6 +111,7 @@ public sealed class AdvancedSharpSerializerBinarySettings : AdvancedSharpSeriali
     public class AdvancedSharpSerializerSettings
     {
         private PropertiesToIgnore _propertiesToIgnore;
+        private IList<Type> _propertyTypesToIgnore;
         private IList<Type> _attributesToIgnore;
 
         ///<summary>
@@ -140,6 +141,25 @@ public PropertiesToIgnore PropertiesToIgnore
             set { _propertiesToIgnore = value; }
         }
 
+        /// <summary>
+        ///   Which properties should be ignored during the serialization.
+        /// </summary>
+        /// <remarks>
+        ///   In your business objects you can mark these properties with ExcludeFromSerializationAttribute
+        ///   In built in .NET Framework classes you can not do this. Therefore you define these properties here.
+        ///   I.e. System.Collections.Generic.List has property Capacity which is irrelevant for
+        ///   the whole Serialization and should be ignored.
+        /// </remarks>
+        public IList<Type> PropertyTypesToIgnore
+        {
+            get
+            {
+                if (_propertyTypesToIgnore == null) _propertyTypesToIgnore = new List<Type>();
+                return _propertyTypesToIgnore;
+            }
+            set { _propertyTypesToIgnore = value; }
+        }
+
         /// <summary>
         /// All Properties marked with one of the contained attribute-types will be ignored on save.
 		/// As default, this list contains only ExcludeFromSerializationAttribute.

SharpSerializer/SharpSerializer.cs

@@ -148,6 +148,7 @@ private void initialize(SharpSerializerXmlSettings settings)
 
             // PropertiesToIgnore
             PropertyProvider.PropertiesToIgnore = settings.AdvancedSettings.PropertiesToIgnore;
+            PropertyProvider.PropertyTypesToIgnore = settings.AdvancedSettings.PropertyTypesToIgnore;
             PropertyProvider.AttributesToIgnore = settings.AdvancedSettings.AttributesToIgnore;
             //RootName
             RootName = settings.AdvancedSettings.RootName;
@@ -179,6 +180,7 @@ private void initialize(SharpSerializerBinarySettings settings)
 
             // PropertiesToIgnore
             PropertyProvider.PropertiesToIgnore = settings.AdvancedSettings.PropertiesToIgnore;
+            PropertyProvider.PropertyTypesToIgnore = settings.AdvancedSettings.PropertyTypesToIgnore;
             PropertyProvider.AttributesToIgnore = settings.AdvancedSettings.AttributesToIgnore;
 
             //RootName