Add HasCircularReferences / ToSafePartialObjectDictionary / ToSafeJson / ToSafeJsv to guard against circular refs

Author: mythz

src/ServiceStack.Text/ReflectionExtensions.cs

@@ -1982,6 +1982,27 @@ private static ObjectDictionaryDefinition CreateObjectDictionaryDefinition(Type
             }
             return def;
         }
+
+        public static Dictionary<string, object> ToSafePartialObjectDictionary<T>(this T instance)
+        {
+            var to = new Dictionary<string, object>();
+            var propValues = instance.ToObjectDictionary();
+            if (propValues != null)
+            {
+                foreach (var entry in propValues)
+                {
+                    if (!TypeSerializer.HasCircularReferences(entry.Value))
+                    {
+                        to[entry.Key] = entry.Value.ToSafePartialObjectDictionary();
+                    }
+                    else
+                    {
+                        to[entry.Key] = entry.Value.ToString();
+                    }
+                }
+            }
+            return to;
+        }
     }
 
 }

src/ServiceStack.Text/StringExtensions.cs

@@ -511,6 +511,13 @@ public static string ToJsv<T>(this T obj)
             return TypeSerializer.SerializeToString(obj);
         }
 
+        public static string ToSafeJsv<T>(this T obj)
+        {
+            return TypeSerializer.HasCircularReferences(obj)
+                ? obj.ToSafePartialObjectDictionary().ToJsv()
+                : obj.ToJsv();
+        }
+
         public static T FromJsv<T>(this string jsv)
         {
             return TypeSerializer.DeserializeFromString<T>(jsv);
@@ -523,6 +530,13 @@ public static string ToJson<T>(this T obj)
                 : JsonSerializer.SerializeToString(obj);
         }
 
+        public static string ToSafeJson<T>(this T obj)
+        {
+            return TypeSerializer.HasCircularReferences(obj)
+                ? obj.ToSafePartialObjectDictionary().ToJson()
+                : obj.ToJson();
+        }
+
         public static T FromJson<T>(this string json)
         {
             return JsonSerializer.DeserializeFromString<T>(json);

src/ServiceStack.Text/TypeSerializer.cs

@@ -11,6 +11,7 @@
 //
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
@@ -253,7 +254,9 @@ public static string SerializeAndFormat<T>(this T instance)
             if (fn != null)
                 return Dump(fn);
 
-            var dtoStr = SerializeToString(instance);
+            var dtoStr = !HasCircularReferences(instance) 
+                ? SerializeToString(instance)
+                : SerializeToString(instance.ToSafePartialObjectDictionary());
             var formatStr = JsvFormatter.Format(dtoStr);
             return formatStr;
         }
@@ -275,6 +278,62 @@ public static string Dump(this Delegate fn)
                 StringBuilderThreadStatic.ReturnAndFree(sb));
             return info;
         }
+
+        public static bool HasCircularReferences(object value)
+        {
+            return HasCircularReferences(value, null);
+        }
+
+        private static bool HasCircularReferences(object value, Stack<object> parentValues)
+        {
+            var type = value != null ? value.GetType() : null;
+
+            if (type == null || !type.IsClass() || value is string)
+                return false;
+
+            if (parentValues == null)
+            {
+                parentValues = new Stack<object>();
+                parentValues.Push(value);
+            }
+
+            var valueEnumerable = value as IEnumerable;
+            if (valueEnumerable != null)
+            {
+                foreach (var item in valueEnumerable)
+                {
+                    if (HasCircularReferences(item, parentValues))
+                        return true;
+                }
+            }
+            else
+            {
+                var props = type.GetSerializableProperties();
+
+                foreach (var pi in props)
+                {
+                    if (pi.GetIndexParameters().Length > 0)
+                        continue;
+
+                    var mi = pi.GetGetMethod();
+                    var pValue = mi != null ? mi.Invoke(value, null) : null;
+                    if (pValue == null)
+                        continue;
+
+                    if (parentValues.Contains(pValue))
+                        return true;
+
+                    parentValues.Push(pValue);
+
+                    if (HasCircularReferences(pValue, parentValues))
+                        return true;
+
+                    parentValues.Pop();
+                }
+            }
+
+            return false;
+        }
     }
 
     public class JsvStringSerializer : IStringSerializer

tests/ServiceStack.Text.Tests/DumpTests.cs

@@ -0,0 +1,57 @@
+using NUnit.Framework;
+
+namespace ServiceStack.Text.Tests
+{
+    public class DumpTests
+    {
+        public class Node
+        {
+            public Node(int id, params Node[] children)
+            {
+                Id = id;
+                Children = children;
+            }
+
+            public int Id { get; set; }
+
+            public Node[] Children { get; set; }
+        }
+
+        [Test]
+        public void Can_detect_Circular_References_in_models()
+        {
+            var node = new Node(1,
+                new Node(11, new Node(111)),
+                new Node(12, new Node(121)));
+
+            Assert.That(!TypeSerializer.HasCircularReferences(node));
+
+            var root = new Node(1,
+                new Node(11));
+
+            var cyclicalNode = new Node(1, root);
+            root.Children[0].Children = new[] { cyclicalNode };
+
+            Assert.That(TypeSerializer.HasCircularReferences(root));
+        }
+
+        [Test]
+        public void Can_PrintDump_ToSafeJson_ToSafeJsv()
+        {
+            var node = new Node(1,
+                new Node(11, new Node(111)),
+                new Node(12, new Node(121)));
+
+            var root = new Node(1,
+                new Node(11, new Node(111)),
+                node);
+
+            var cyclicalNode = new Node(1, root);
+            root.Children[0].Children[0].Children = new[] { cyclicalNode };
+
+            root.PrintDump();
+            root.ToSafeJson().Print();
+            root.ToSafeJsv().Print();
+        }
+    }
+}

tests/ServiceStack.Text.Tests/ServiceStack.Text.Tests.csproj

@@ -186,6 +186,7 @@
   <ItemGroup>
     <Compile Include="AutoMappingObjectDictionaryTests.cs" />
     <Compile Include="CustomCultureInfoTests.cs" />
+    <Compile Include="DumpTests.cs" />
     <Compile Include="DynamicModels\ODataTests.cs" />
     <Compile Include="EnumerableTests.cs" />
     <Compile Include="AttributeTests.cs" />