Replace Obsolete BinaryFormatter with System.Text.Json

Replace BinaryFormatter with System.Text.Json serialization

Switched serialization in UncertaintyAnalysisResults, MCMCResults, ParameterResults, and related classes from BinaryFormatter to System.Text.Json for improved security and compatibility. Added JsonInclude attributes to private setters for correct serialization. Updated project file to include System.Text.Json package and removed obsolete [Serializable] attributes.

Reimplement binary formatter for reading legacy saved data.

Author: Brennan1994

Numerics/Distributions/Univariate/Uncertainty Analysis/UncertaintyAnalysisResults.cs

@@ -30,12 +30,14 @@
 
 using Numerics.Mathematics.Optimization;
 using Numerics.Sampling.MCMC;
+using Numerics.Utilities;
 using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
 using System.Linq;
-using System.Runtime.Serialization.Formatters.Binary;
+using System.Text.Json;
+using System.Text.Json.Serialization;
 using System.Threading.Tasks;
 using System.Xml.Linq;
 
@@ -51,7 +53,6 @@ namespace Numerics.Distributions
     ///     Haden Smith, USACE Risk Management Center, cole.h.smith@usace.army.mil
     /// </para>
     /// </remarks>
-    [Serializable]
     public class UncertaintyAnalysisResults
     {
 
@@ -111,30 +112,66 @@ public class UncertaintyAnalysisResults
         /// <param name="results">The uncertainty analysis results.</param>
         public static byte[] ToByteArray(UncertaintyAnalysisResults results)
         {
-            BinaryFormatter bf = new BinaryFormatter();
-            using (var ms = new MemoryStream())
+            var options = new JsonSerializerOptions
             {
-                bf.Serialize(ms, results);
-                return ms.ToArray();
-            }
+                WriteIndented = false,
+                DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+                IncludeFields = true
+            };
+            // Add custom converters for unsupported types
+            options.Converters.Add(new Double2DArrayConverter());
+            options.Converters.Add(new String2DArrayConverter());
+            options.Converters.Add(new UnivariateDistributionConverter());
+            return JsonSerializer.SerializeToUtf8Bytes(results, options);
         }
 
         /// <summary>
         /// Returns the class from a byte array. 
         /// </summary>
         /// <param name="bytes">Byte array.</param>
         public static UncertaintyAnalysisResults FromByteArray(byte[] bytes)
+        {
+            try
+            {
+                var options = new JsonSerializerOptions
+                {
+                    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+                    IncludeFields = true
+                };
+                // Add custom converters for unsupported types
+                options.Converters.Add(new Double2DArrayConverter());
+                options.Converters.Add(new String2DArrayConverter());
+                options.Converters.Add(new UnivariateDistributionConverter());
+                return JsonSerializer.Deserialize<UncertaintyAnalysisResults>(bytes, options);
+            }
+            catch (Exception)
+            {
+                // An error can occur because we're trying to deserialize a blob written with binary formatter, 
+                //as a blob of json bytes. If that happens, fall back to the old.  
+                return FromByteArrayLegacy(bytes);
+            }          
+        }
+
+         /// <summary>
+        /// Returns the class from a byte array. 
+        /// </summary>
+        /// <param name="bytes">Byte array.</param>
+        private static UncertaintyAnalysisResults FromByteArrayLegacy(byte[] bytes)
         {
             try
             {
                 using (var memStream = new MemoryStream())
                 {
-                    var binForm = new BinaryFormatter();
+                    #pragma warning disable SYSLIB0011 // Suppress obsolete BinaryFormatter warning for legacy support
+                    var binForm = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                     memStream.Write(bytes, 0, bytes.Length);
                     memStream.Seek(0, SeekOrigin.Begin);
                     var obj = binForm.Deserialize(memStream);
+                    #pragma warning disable SYSLIB0011 // Suppress obsolete BinaryFormatter warning for legacy support
                     return (UncertaintyAnalysisResults)obj;
                 }
+
+
             }
             catch (Exception)
             {

Numerics/Sampling/MCMC/Support/MCMCResults.cs

@@ -33,7 +33,8 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Runtime.Serialization.Formatters.Binary;
+using System.Text.Json;
+using System.Text.Json.Serialization;
 
 namespace Numerics.Sampling.MCMC
 {
@@ -46,7 +47,7 @@ namespace Numerics.Sampling.MCMC
     ///     Haden Smith, USACE Risk Management Center, cole.h.smith@usace.army.mil
     /// </para>
     /// </remarks>
-    [Serializable]
+   [Serializable] 
     public class MCMCResults
     {
         /// <summary>
@@ -78,37 +79,44 @@ public MCMCResults(MCMCSampler sampler, double alpha = 0.1)
         /// <summary>
         /// The list of sampled Markov Chains.
         /// </summary>
+        [JsonInclude]
         public List<ParameterSet>[] MarkovChains { get; private set; }
 
         /// <summary>
-        /// Output posterior parameter sets. 
+        /// Output posterior parameter sets.
         /// </summary>
+        [JsonInclude]
         public List<ParameterSet> Output { get; private set; }
 
         /// <summary>
         /// The average log-likelihood across each chain for each iteration.
         /// </summary>
+        [JsonInclude]
         public List<double> MeanLogLikelihood { get; private set; }
 
         /// <summary>
         /// The acceptance rate for each chain.
         /// </summary>
+        [JsonInclude]
         public double[] AcceptanceRates { get; private set; }
 
         /// <summary>
         /// Parameter results using the output posterior parameter sets.
         /// </summary>
+        [JsonInclude]
         public ParameterResults[] ParameterResults { get; private set; }
 
         /// <summary>
-        /// The output parameter set that produced the maximum likelihood. 
-        /// This is referred to as the maximum a posteriori (MAP). 
+        /// The output parameter set that produced the maximum likelihood.
+        /// This is referred to as the maximum a posteriori (MAP).
         /// </summary>
+        [JsonInclude]
         public ParameterSet MAP { get; private set; }
 
         /// <summary>
-        /// The mean of the posterior distribution of each parameter. 
+        /// The mean of the posterior distribution of each parameter.
         /// </summary>
+        [JsonInclude]
         public ParameterSet PosteriorMean { get; private set; }
 
         /// <summary>
@@ -147,12 +155,13 @@ private void ProcessParameterResults(MCMCSampler sampler, double alpha = 0.1)
         /// <param name="mcmcResults">The MCMC Results.</param>
         public static byte[] ToByteArray(MCMCResults mcmcResults)
         {
-            var bf = new BinaryFormatter();
-            using (var ms = new MemoryStream())
+            var options = new JsonSerializerOptions
             {
-                bf.Serialize(ms, mcmcResults);
-                return ms.ToArray();
-            }
+                WriteIndented = false,
+                DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+                IncludeFields = true
+            };
+            return JsonSerializer.SerializeToUtf8Bytes(mcmcResults, options);
         }
 
         /// <summary>
@@ -161,16 +170,39 @@ public static byte[] ToByteArray(MCMCResults mcmcResults)
         /// <param name="bytes">Byte array.</param>
         public static MCMCResults FromByteArray(byte[] bytes)
         {
-            using (var ms = new MemoryStream())
+            var options = new JsonSerializerOptions
+            {
+                DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+                IncludeFields = true
+            };
+            try
+            {
+                return JsonSerializer.Deserialize<MCMCResults>(bytes, options);
+            }
+            catch
             {
-                var bf = new BinaryFormatter();
-                ms.Write(bytes, 0, bytes.Length);
-                ms.Seek(0L, SeekOrigin.Begin);
-                var obj = bf.Deserialize(ms);
-                return (MCMCResults)obj;
+                ///Previous serialization used Binary Formatter, which won't deserialize cleanly as JSON. 
+                /// If this fails, then it's probably the bf bytes. fall back to legacy.
+                return FromByteArrayLegacy(bytes);
             }
         }
 
+        /// <summary>
+        /// Creates MCMC Results from a byte array.
+        /// </summary>
+        /// <param name="bytes">Byte array.</param>
+        private static MCMCResults FromByteArrayLegacy(byte[] bytes)
+        {
+            using var ms = new MemoryStream();
+            #pragma warning disable SYSLIB0011 // Suppress obsolete BinaryFormatter warning for legacy support
+            var bf = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
+            ms.Write(bytes, 0, bytes.Length);
+            ms.Seek(0L, SeekOrigin.Begin);
+            var obj = bf.Deserialize(ms);
+            #pragma warning disable SYSLIB0011 // Suppress obsolete BinaryFormatter warning for legacy support
+            return (MCMCResults)obj;
+        }
+
         #endregion
 
     }

Numerics/Sampling/MCMC/Support/ParameterResults.cs

@@ -31,6 +31,7 @@
 using Numerics.Data.Statistics;
 using Numerics.Distributions;
 using System;
+using System.Text.Json.Serialization;
 
 namespace Numerics.Sampling.MCMC
 {
@@ -57,11 +58,11 @@ public class ParameterResults
         public ParameterResults(double[] values, double alpha = 0.1, bool sorted = false)
         {
             // Sort the values
-            if (sorted == false) 
-            { 
+            if (sorted == false)
+            {
                 Array.Sort(values);
             }
-            
+
             // Create Kernel Density Estimate
             var kde = new KernelDensity(values);
             KernelDensity = kde.CreatePDFGraph();
@@ -83,16 +84,19 @@ public ParameterResults(double[] values, double alpha = 0.1, bool sorted = false
         /// <summary>
         /// Parameter summary statistics.
         /// </summary>
+        [JsonInclude]
         public ParameterStatistics SummaryStatistics { get; private set; }
 
         /// <summary>
         /// The kernel density results.
         /// </summary>
+        [JsonInclude]
         public double[,] KernelDensity { get; private set; }
 
         /// <summary>
         /// The histogram results.
         /// </summary>
+        [JsonInclude]
         public Histogram Histogram { get; private set; }
 
         /// <summary>