[Fork] [Fork] Circular ref error Json serializer 1 //https://stackoverflow.com/questions/60859589/system-text-json-jsonexception-a-possible-object-cycle-was-detected-which-is-n | C# Online Compiler

[Fork] [Fork] Circular ref error Json serializer 1 //https://stackoverflow.com/questions/60859589/system-text-json-jsonexception-a-possible-object-cycle-was-detected-which-is-n by dbc_MinLength

using System;
using System.Collections.Generic;
using System.Collections;
using System.IO;
using System.Text.Json;

//https://stackoverflow.com/questions/60859589/system-text-json-jsonexception-a-possible-object-cycle-was-detected-which-is-n

class Program
    {
        private static string _testPackageName = "packageTestName";
        private static string _testFileName = "packageReproTestFileName.eut.json";
        private static string _testStepName = "stepTestName";

        static void Main(string[] args)
        {
            SaveAndLoadWithStep();
            Console.WriteLine("It Worked!");
        }

        static void SaveAndLoadWithStep()
        {
            Package pkg = new Package(_testPackageName);
            Step testStep = new Step
            {
                Name = _testStepName
            };

            //Do this using strings
            PrecedenceConstraint testPC = new PrecedenceConstraint(testStep.Name, StepPrecedenceValue.Completion);
            testStep.PrecedenceConstraints.Add(testPC);

            pkg.Steps.Add(testStep);

            PackageIO.SaveAsJsonFile(pkg, _testFileName);
        
			Console.WriteLine("{0} serialized, result: ", pkg);
			Console.WriteLine(File.ReadAllText(_testFileName));
			
            Package resultPkg = PackageIO.LoadFromJsonFile(_testFileName);
        }
    }

    public static class PackageIO
    {
        public static void SaveAsJsonFile(Package pkg, string FullyQualifiedFileName)
        {
            string jsonString;

            //TODO: Needs Exception handler
            var options = new JsonSerializerOptions
            {
                WriteIndented = true,
                MaxDepth = 6 // Fixed
            };
            jsonString = JsonSerializer.Serialize(pkg, options);
            File.WriteAllText(FullyQualifiedFileName, jsonString);
        }

        public static Package LoadFromJsonFile(string FullyQualifiedFileName)
        {
            Package result;

            //TODO: Needs exception handler
            string jsonstring = File.ReadAllText(FullyQualifiedFileName);
            result = JsonSerializer.Deserialize<Package>(jsonstring);

            return result;
        }
    }


    public class Package
    {
        private string _name;
        private Steps<Step> _steps;
        public Package()
        {
            _steps = new Steps<Step>();
        }
        public Package(string name) : this()
        {
            _name = name;
        }
        public Steps<Step> Steps
        {
            get { return _steps; }
            set { _steps = value; }
        }
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
    }

    public enum StepExecStatus
    {
        Waiting = 1,
        InProgress = 2,
        Inactive = 3,
        Completed = 4
    }

    public class Step
    {
        private string _name;
        private PrecedenceConstraints<PrecedenceConstraint> _precedenceConstraints;
        private StepExecStatus _execStatus;

        internal StepExecStatus ExecStatus
        {
            get { return _execStatus; }
            set { _execStatus = value; }
        }

		internal StepExecStatus Execute()
        {
            return StepExecStatus.Completed;
        }

        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

        public PrecedenceConstraints<PrecedenceConstraint> PrecedenceConstraints
        {
            get { return _precedenceConstraints; }
            set { _precedenceConstraints = value; }
        }

		public Step()
        {
            _precedenceConstraints = new PrecedenceConstraints<PrecedenceConstraint>();
            _execStatus = StepExecStatus.Waiting;
        }
    }

   public class Steps<T> : IList<T> where T:Step
    {
        private readonly List<T> _steps = new List<T>();

        public T GetStepByPos(int pos)
        {
            return _steps[pos];
        }

        #region Required implementation for IList
        public void Add(T item)
        {
            _steps.Add(item);
        }

        public void Clear()
        {
            _steps.Clear();
        }

        public int IndexOf(T item)
        {
            return _steps.IndexOf(item);
        }

        public void Insert(int index, T item)
        {
            _steps.Insert(index, item);
        }

        public void RemoveAt(int index)
        {
            _steps.RemoveAt(index);
        }

        public bool Contains(T item)
        {
            return _steps.Contains(item);
        }

        public void CopyTo(T[] array, int arrayIndex)
        {
            _steps.CopyTo(array, arrayIndex);
        }

        public bool Remove(T item)
        {
            return _steps.Remove(item);
        }

        IEnumerator<T> IEnumerable<T>.GetEnumerator()
        {
            return _steps.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return _steps.GetEnumerator();
        }

        public int Count
        {
            get { return _steps.Count; }
        }

        public bool IsReadOnly
        {
            get { return false; }
        }

        public T this[int index]
        {
            get { return _steps[index]; }
            set { _steps[index] = value; }
        }
        #endregion

    }
	
    public enum StepPrecedenceValue
    {
        Completion = 1,
        Success = 2,
        Failure = 3
    }

    public class PrecedenceConstraint
    {
        private string _sourceStepName;
        private StepPrecedenceValue _constraintValue;
        private bool _constraintMet;

        public PrecedenceConstraint(string itemName, StepPrecedenceValue value)
        {
            _sourceStepName = itemName;
            _constraintValue = value;
        }

        public string SourceStepName
        {
            get { return _sourceStepName; }
            set { _sourceStepName = value; }
        }

        public StepPrecedenceValue ConstraintValue
        {
            get { return _constraintValue; }
            set { _constraintValue = value; }
        }
        public bool ConstraintMet
        {
            get { return GetConstraintMet(); }
            set { _constraintMet = value; }
        }

        private bool GetConstraintMet()
        {
            bool result = false;
            //TODO: Needs implemented

            return result;
        }

    }

    public class PrecedenceConstraints<T> : IList<T> where T:PrecedenceConstraint
    {
        private readonly IList<T> _precedenceConstraints = new List<T>();

        public T this[int index]
        {
            get { return _precedenceConstraints[index]; }
            set { _precedenceConstraints[index] = value; }
        }

        public int Count
        {
            get { return _precedenceConstraints.Count; }
        }

        public bool IsReadOnly
        {
            get { return false; }
        }

        public void Add(T item)
        {
            _precedenceConstraints.Add(item);
        }

        public void Clear()
        {
            _precedenceConstraints.Clear();
        }

        public bool Contains(T item)
        {
            return _precedenceConstraints.Contains(item);
        }

        public void CopyTo(T[] array, int arrayIndex)
        {
            _precedenceConstraints.CopyTo(array, arrayIndex);
        }

        public IEnumerator<T> GetEnumerator()
        {
            return _precedenceConstraints.GetEnumerator();
        }

        public int IndexOf(T item)
        {
            return _precedenceConstraints.IndexOf(item);
        }

        public void Insert(int index, T item)
        {
            _precedenceConstraints.Insert(index, item);
        }

        public bool Remove(T item)
        {
            return _precedenceConstraints.Remove(item);
        }

        public void RemoveAt(int index)
        {
            _precedenceConstraints.RemoveAt(index); ;
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return _precedenceConstraints.GetEnumerator();
        }

        internal bool IsSatisfied()
        {
            bool result = true;

            return result;
        }
    }

​x
 
using System;
using System.Collections.Generic;
using System.Collections;
using System.IO;
using System.Text.Json;
​
//https://stackoverflow.com/questions/60859589/system-text-json-jsonexception-a-possible-object-cycle-was-detected-which-is-n
​
class Program
    {
        private static string _testPackageName = "packageTestName";
        private static string _testFileName = "packageReproTestFileName.eut.json";
        private static string _testStepName = "stepTestName";
​
        static void Main(string[] args)
        {
            SaveAndLoadWithStep();
            Console.WriteLine("It Worked!");
        }
​
        static void SaveAndLoadWithStep()
        {
            Package pkg = new Package(_testPackageName);
            Step testStep = new Step
            {
                Name = _testStepName
            };
​
            //Do this using strings
            PrecedenceConstraint testPC = new PrecedenceConstraint(testStep.Name, StepPrecedenceValue.Completion);
            testStep.PrecedenceConstraints.Add(testPC);
​
            pkg.Steps.Add(testStep);
​
            PackageIO.SaveAsJsonFile(pkg, _testFileName);
        
            Console.WriteLine("{0} serialized, result: ", pkg);
            Console.WriteLine(File.ReadAllText(_testFileName));
            
            Package resultPkg = PackageIO.LoadFromJsonFile(_testFileName);
        }
    }
​
    public static class PackageIO
    {
        public static void SaveAsJsonFile(Package pkg, string FullyQualifiedFileName)
        {
            string jsonString;
​
            //TODO: Needs Exception handler
            var options = new JsonSerializerOptions
            {
                WriteIndented = true,
                MaxDepth = 6 // Fixed
            };
            jsonString = JsonSerializer.Serialize(pkg, options);
            File.WriteAllText(FullyQualifiedFileName, jsonString);
        }
​
        public static Package LoadFromJsonFile(string FullyQualifiedFileName)
        {
            Package result;
​
            //TODO: Needs exception handler
            string jsonstring = File.ReadAllText(FullyQualifiedFileName);
            result = JsonSerializer.Deserialize<Package>(jsonstring);
​
            return result;
        }
    }
​
​
    public class Package
    {
        private string _name;
        private Steps<Step> _steps;
        public Package()
        {
            _steps = new Steps<Step>();
        }
        public Package(string name) : this()
        {
            _name = name;
        }
        public Steps<Step> Steps
        {
            get { return _steps; }
            set { _steps = value; }
        }
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
    }
​
    public enum StepExecStatus
    {
        Waiting = 1,
        InProgress = 2,
        Inactive = 3,
        Completed = 4
    }
​
    public class Step
    {
        private string _name;
        private PrecedenceConstraints<PrecedenceConstraint> _precedenceConstraints;
        private StepExecStatus _execStatus;
​
        internal StepExecStatus ExecStatus
        {
            get { return _execStatus; }
            set { _execStatus = value; }
        }
​
        internal StepExecStatus Execute()
        {
            return StepExecStatus.Completed;
        }
​
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
​
        public PrecedenceConstraints<PrecedenceConstraint> PrecedenceConstraints
        {
            get { return _precedenceConstraints; }
            set { _precedenceConstraints = value; }
        }
​
        public Step()
        {
            _precedenceConstraints = new PrecedenceConstraints<PrecedenceConstraint>();
            _execStatus = StepExecStatus.Waiting;
        }
    }
​
   public class Steps<T> : IList<T> where T:Step
    {
        private readonly List<T> _steps = new List<T>();
​
        public T GetStepByPos(int pos)
        {
            return _steps[pos];
        }
​
        #region Required implementation for IList
        public void Add(T item)
        {
            _steps.Add(item);
        }
​
        public void Clear()
        {
            _steps.Clear();
        }
​
        public int IndexOf(T item)
        {
            return _steps.IndexOf(item);
        }
​
        public void Insert(int index, T item)
        {
            _steps.Insert(index, item);
        }
​
        public void RemoveAt(int index)
        {
            _steps.RemoveAt(index);
        }
​
        public bool Contains(T item)
        {
            return _steps.Contains(item);
        }
​
        public void CopyTo(T[] array, int arrayIndex)
        {
            _steps.CopyTo(array, arrayIndex);
        }
​
        public bool Remove(T item)
        {
            return _steps.Remove(item);
        }
​
        IEnumerator<T> IEnumerable<T>.GetEnumerator()
        {
            return _steps.GetEnumerator();
        }
​
        IEnumerator IEnumerable.GetEnumerator()
        {
            return _steps.GetEnumerator();
        }
​
        public int Count
        {
            get { return _steps.Count; }
        }
​
        public bool IsReadOnly
        {
            get { return false; }
        }
​
        public T this[int index]
        {
            get { return _steps[index]; }
            set { _steps[index] = value; }
        }
        #endregion
​
    }
    
    public enum StepPrecedenceValue
    {
        Completion = 1,
        Success = 2,
        Failure = 3
    }
​
    public class PrecedenceConstraint
    {
        private string _sourceStepName;
        private StepPrecedenceValue _constraintValue;
        private bool _constraintMet;
​
        public PrecedenceConstraint(string itemName, StepPrecedenceValue value)
        {
            _sourceStepName = itemName;
            _constraintValue = value;
        }
​
        public string SourceStepName
        {
            get { return _sourceStepName; }
            set { _sourceStepName = value; }
        }
​
        public StepPrecedenceValue ConstraintValue
        {
            get { return _constraintValue; }
            set { _constraintValue = value; }
        }
        public bool ConstraintMet
        {
            get { return GetConstraintMet(); }
            set { _constraintMet = value; }
        }
​
        private bool GetConstraintMet()
        {
            bool result = false;
            //TODO: Needs implemented
​
            return result;
        }
​
    }
​
    public class PrecedenceConstraints<T> : IList<T> where T:PrecedenceConstraint
    {
        private readonly IList<T> _precedenceConstraints = new List<T>();
​
        public T this[int index]
        {
            get { return _precedenceConstraints[index]; }
            set { _precedenceConstraints[index] = value; }
        }
​
        public int Count
        {
            get { return _precedenceConstraints.Count; }
        }
​
        public bool IsReadOnly
        {
            get { return false; }
        }
​
        public void Add(T item)
        {
            _precedenceConstraints.Add(item);
        }
​
        public void Clear()
        {
            _precedenceConstraints.Clear();
        }
​
        public bool Contains(T item)
        {
            return _precedenceConstraints.Contains(item);
        }
​
        public void CopyTo(T[] array, int arrayIndex)
        {
            _precedenceConstraints.CopyTo(array, arrayIndex);
        }
​
        public IEnumerator<T> GetEnumerator()
        {
            return _precedenceConstraints.GetEnumerator();
        }
​
        public int IndexOf(T item)
        {
            return _precedenceConstraints.IndexOf(item);
        }
​
        public void Insert(int index, T item)
        {
            _precedenceConstraints.Insert(index, item);
        }
​
        public bool Remove(T item)
        {
            return _precedenceConstraints.Remove(item);
        }
​
        public void RemoveAt(int index)
        {
            _precedenceConstraints.RemoveAt(index); ;
        }
​
        IEnumerator IEnumerable.GetEnumerator()
        {
            return _precedenceConstraints.GetEnumerator();
        }
​
        internal bool IsSatisfied()
        {
            bool result = true;
​
            return result;
        }
    }
​

-298000

Cached Result
Last Run:	4:42:22 pm
Compile:	0.127s
Execute:	0s
Memory:	0b
CPU:	0s

View IL Code