Serializer will now ignore: indexer properties, and properties with their name listed in a JsonIgnore above the declaring class

nanoFramework.Json.Benchmark/SerializationBenchmarks/ReferenceTypesSerializationBenchmark.cs

@@ -23,6 +23,8 @@ public class ReferenceTypesSerializationBenchmark : BaseIterationBenchmark
         private JsonTestClassComplex complexClass;
         private JsonTestTown myTown;
         private ArrayList arrayList;
+        private JsonIgnoreTestClass ignoreTest;
+        private JsonIgnoreTestClassNoAttr ignoreTestNoAttr;
 
         [Setup]
         public void Setup()
@@ -65,6 +67,8 @@ public void Setup()
                 { DateTime.UtcNow },
                 { TimeSpan.FromSeconds(100) }
             };
+            ignoreTest = JsonIgnoreTestClass.CreateTestClass();
+            ignoreTestNoAttr = JsonIgnoreTestClassNoAttr.CreateTestClass();
         }
 
         [Benchmark]
@@ -120,5 +124,50 @@ public void ArrayList()
                 JsonConvert.SerializeObject(arrayList);
             });
         }
+
+        [Benchmark]
+        public void ClassWithAttributeIgnoreEnabled()
+        {
+            RunInIteration(() =>
+            {
+                // Turn OFF the UseIgnore setting
+                Configuration.Settings.UseIgnoreAttribute = true;
+                JsonConvert.SerializeObject(ignoreTest);
+                // Turn OFF the UseIgnore setting
+                Configuration.Settings.UseIgnoreAttribute = false;
+            });
+        }
+        [Benchmark]
+        public void ClassWithAttributeIgnoreDisabled()
+        {
+            RunInIteration(() =>
+            {
+                // Turn OFF the UseIgnore setting
+                Configuration.Settings.UseIgnoreAttribute = false;
+                JsonConvert.SerializeObject(ignoreTest);
+            });
+        }
+        [Benchmark]
+        public void ClassNoAttributeIgnoreEnabled()
+        {
+            RunInIteration(() =>
+            {
+                // Turn OFF the UseIgnore setting
+                Configuration.Settings.UseIgnoreAttribute = true;
+                JsonConvert.SerializeObject(ignoreTestNoAttr);
+                // Turn OFF the UseIgnore setting
+                Configuration.Settings.UseIgnoreAttribute = false;
+            });
+        }
+        [Benchmark]
+        public void ClassNoAttributeIgnoreDisabled()
+        {
+            RunInIteration(() =>
+            {
+                // Turn OFF the UseIgnore setting
+                Configuration.Settings.UseIgnoreAttribute = false;
+                JsonConvert.SerializeObject(ignoreTestNoAttr);
+            });
+        }
     }
 }

nanoFramework.Json.Test.Shared/JsonIgnoreTestClass.cs

@@ -0,0 +1,63 @@
+//
+// Copyright (c) .NET Foundation and Contributors
+// See LICENSE file in the project root for full license information.
+//
+
+namespace nanoFramework.Json.Test.Shared
+{
+    /// <summary>
+    /// Used to test the JsonIgnore attribute.
+    /// </summary>
+    [JsonIgnore("MyIgnoredProperty, AnotherIgnoredProperty")]
+    public class JsonIgnoreTestClass
+    {
+        public int TestProperty { get; set; }
+        public int OtherTestProperty { get; set; }
+        public int AThirdTestProperty { get; set; }
+        public int MyIgnoredProperty => TestProperty + 1;
+        public int AnotherIgnoredProperty => OtherTestProperty + 1;
+
+        public int this[int index] => TestProperty + index;
+
+        public static JsonIgnoreTestClass CreateTestClass()
+        {
+            return new JsonIgnoreTestClass()
+            {
+                TestProperty = 1,
+                OtherTestProperty = 2,
+                AThirdTestProperty = 3
+            };
+        }
+
+        public bool IsEqual(JsonIgnoreTestClass otherInstance)
+        {
+            return (TestProperty == otherInstance.TestProperty
+                && OtherTestProperty == otherInstance.OtherTestProperty
+                && AThirdTestProperty == otherInstance.AThirdTestProperty);
+        }
+    }
+
+    /// <summary>
+    /// Used to 1-to-1 compare with JsonIgnoreTestClass.
+    /// </summary>
+    public class JsonIgnoreTestClassNoAttr
+    {
+        public int TestProperty { get; set; }
+        public int OtherTestProperty { get; set; }
+        public int AThirdTestProperty { get; set; }
+        public int MyIgnoredProperty => TestProperty + 1;
+        public int AnotherIgnoredProperty => OtherTestProperty + 1;
+
+        public int this[int index] => TestProperty + index;
+
+        public static JsonIgnoreTestClassNoAttr CreateTestClass()
+        {
+            return new JsonIgnoreTestClassNoAttr()
+            {
+                TestProperty = 1,
+                OtherTestProperty = 2,
+                AThirdTestProperty = 3
+            };
+        }
+    }
+}

nanoFramework.Json.Test.Shared/nanoFramework.Json.Test.Shared.projitems

@@ -10,6 +10,7 @@
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="$(MSBuildThisFileDirectory)Gender.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)JsonIgnoreTestClass.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)JsonTestClassChild.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)JsonTestClassComplex.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)JsonTestCompany.cs" />

nanoFramework.Json.Test/JsonUnitTests.cs

@@ -1384,6 +1384,34 @@ public void DeserializeObjectWithStringContainingNonAsciiChars()
             Assert.Equal(input.Value, result.Value);
         }
 
+        [TestMethod]
+        public void DeserializeObjectWithJsonIgnoreAttribute()
+        {
+            OutputHelper.WriteLine("Starting JsonIgnore Test...");
+            Json.Configuration.Settings.UseIgnoreAttribute = true;
+            OutputHelper.WriteLine("UseIgnoreAttribute enabled.");
+
+            var testObject = JsonIgnoreTestClass.CreateTestClass();
+            var jsonString = JsonSerializer.SerializeObject(testObject);
+            OutputHelper.WriteLine("After serialize.");
+            JsonIgnoreTestClass dserResult = JsonConvert.DeserializeObject(jsonString, typeof(JsonIgnoreTestClass)) as JsonIgnoreTestClass;
+            OutputHelper.WriteLine("After deserialize.");
+
+            //test serialize and deserialize
+            bool jsonSuccess = testObject.IsEqual(dserResult);
+            Assert.IsTrue(jsonSuccess);
+            OutputHelper.WriteLine("Serialization/Deserialization was " + (jsonSuccess ? "" : "NOT ") + "successful.");
+
+            //test ignored properties are actually ignored
+            bool areIgnoredPropsPresent = jsonString.Contains("MyIgnoredProperty")
+                || jsonString.Contains("AnotherIgnoredProperty");
+            Assert.IsFalse(areIgnoredPropsPresent);
+            OutputHelper.WriteLine("Ignore was " + (areIgnoredPropsPresent ? "NOT " : "") + "successful.");
+
+            Json.Configuration.Settings.UseIgnoreAttribute = false;
+            OutputHelper.WriteLine("UseIgnoreAttribute set back to false.");
+            OutputHelper.WriteLine("Finished JsonIgnore Test.");
+        }
     }
 
     #region Test classes

nanoFramework.Json/Configuration/Settings.cs

@@ -23,6 +23,11 @@ public static class Settings
         /// </summary>
         public static bool CaseSensitive { get; set; } = true;
 
+        /// <summary>
+        /// If true, will check for JsonIgnoreAttribute upon serialization. Has a performance cost. Defaults to false.
+        /// </summary>
+        public static bool UseIgnoreAttribute { get; set; } = false;
+
         /// <summary>
         /// Gets or sets a value indicating whether deserialization should throw exception when no property found.
         /// </summary>

nanoFramework.Json/JsonIgnoreAttribute.cs

@@ -0,0 +1,33 @@
+// Copyright (c) .NET Foundation and Contributors
+// See LICENSE file in the project root for full license information.
+
+using System;
+
+namespace nanoFramework.Json
+{
+    /// <summary>
+    /// Hides properties from the json serializer
+    /// </summary>
+    [System.AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = true)]
+    public sealed class JsonIgnoreAttribute : Attribute
+    {
+        /// <summary>
+        /// array of property names for json serializer to ignore
+        /// </summary>
+        public string[] PropertyNames { get; set; }
+
+        /// <summary>
+        /// Hides properties from the json serializer.
+        /// </summary>
+        /// <param name="getterNamesToIgnore">A comma separated list of property names to ignore in json.</param>
+        public JsonIgnoreAttribute(string getterNamesToIgnore)
+        {
+            // Split by commas, then trim whitespace for each
+            PropertyNames = getterNamesToIgnore.Split(',');
+            for(int i = 0; i < PropertyNames.Length; i++)
+            {
+                PropertyNames[i] = PropertyNames[i].Trim();
+            }
+        }
+    }
+}

nanoFramework.Json/JsonSerializer.cs

@@ -77,26 +77,38 @@ public static string SerializeObject(object o, bool topObject = true)
 
         private static string SerializeClass(object o, Type type)
         {
+            // Cache the type's class-level attributes only if UseIgnoreAttribute setting is enabled.
+            object[] classAttributes = null;
+            if (Settings.UseIgnoreAttribute)
+            {
+                classAttributes = type.GetCustomAttributes(false);
+            }
+
             Hashtable hashtable = new();
 
             // Iterate through all of the methods, looking for internal GET properties
             MethodInfo[] methods = type.GetMethods();
 
             foreach (MethodInfo method in methods)
             {
-                if (!ShouldSerializeMethod(method))
+                if (!ShouldSerializeMethod(method, classAttributes))
                 {
                     continue;
                 }
-
+                
                 object returnObject = method.Invoke(o, null);
-                hashtable.Add(method.Name.Substring(4), returnObject);
+                hashtable.Add(ExtractGetterName(method), returnObject);
             }
 
             return SerializeIDictionary(hashtable);
         }
 
-        private static bool ShouldSerializeMethod(MethodInfo method)
+        /// <summary>
+        /// Checks whether a property (MethodInfo) should be serialized.
+        /// </summary>
+        /// <param name="method">The MethodInfo to check.</param>
+        /// <param name="classAttributes">The cached class-level attributes. Only used if UseIgnoreAttribute is true.</param>
+        private static bool ShouldSerializeMethod(MethodInfo method, object[] classAttributes)
         {
             // We care only about property getters when serializing
             if (!method.Name.StartsWith("get_"))
@@ -125,9 +137,71 @@ private static bool ShouldSerializeMethod(MethodInfo method)
                 return false;
             }
 
+            // Ignore indexer properties
+            // (string comparison is MUCH faster than method.GetParameters)
+            if (method.Name == "get_Item")
+            {
+                return false;
+            }
+
+            // Ignore properties listed in [JsonIgnore()] attribute
+            // Only check for attribute if the setting is on
+            if (Settings.UseIgnoreAttribute &&
+                ShouldIgnorePropertyFromClassAttribute(method, classAttributes))
+            {
+                return false;
+            }
+
             return true;
         }
 
+        /// <summary>
+        /// Checks for JsonIgnore attribute on a method's declaring class. (helper method for SerializeClass)
+        /// </summary>
+        /// <param name="method">The MethodInfo of a property getter to check.</param>
+        /// <param name="classAttributes">The cached class-level attributes. Only used if UseIgnoreAttribute is true.</param>
+        /// <returns></returns>
+        private static bool ShouldIgnorePropertyFromClassAttribute(MethodInfo method, object[] classAttributes)
+        {
+            string[] gettersToIgnore = null;
+
+            foreach (object attribute in classAttributes)
+            {
+                if (attribute is JsonIgnoreAttribute ignoreAttribute)
+                {
+                    gettersToIgnore = ignoreAttribute.PropertyNames;
+                    break;
+                }
+            }
+
+            if (gettersToIgnore == null)
+            {
+                return false;
+            }
+
+            foreach (string propertyName in gettersToIgnore)
+            {
+                if (propertyName.Equals(ExtractGetterName(method)))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Extracts "get_" from MethodInfo.Name to retrieve the name of a getter property.
+        /// Assumes the MethodInfo is for a getter, checked elsewhere.
+        /// </summary>
+        /// <param name="getterMethodInfo">The MethodInfo of the getter property.</param>
+        /// <returns>The property name as it appears in written code.</returns>
+        private static string ExtractGetterName(MethodInfo getterMethodInfo)
+        {
+            // Substring(4) is to extract the "get_" for property methods
+            return getterMethodInfo.Name.Substring(4);
+        }
+
         /// <summary>
         /// Convert an IEnumerable to a JSON string.
         /// </summary>

nanoFramework.Json/nanoFramework.Json.nfproj

@@ -52,6 +52,7 @@
     <Compile Include="Converters\UIntConverter.cs" />
     <Compile Include="Converters\ULongConverter.cs" />
     <Compile Include="Converters\UShortConverter.cs" />
+    <Compile Include="JsonIgnoreAttribute.cs" />
     <Compile Include="JsonSerializer.cs" />
     <Compile Include="Resolvers\IMemberResolver.cs" />
     <Compile Include="Resolvers\MemberResolver.cs" />