removed netstandard2.1 and added net5.0. Added serialization support

Author: SharePointRadi

src/OneBitSoftware.Utilities.OperationResult/OneBitSoftware.Utilities.OperationResult.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net6.0;netstandard2.1</TargetFrameworks>
+    <TargetFrameworks>net6.0;net5.0</TargetFrameworks>
     <ImplicitUsings>disable</ImplicitUsings>
     <Nullable>enable</Nullable>
   </PropertyGroup>

src/OneBitSoftware.Utilities.OperationResult/OperationResult.cs

@@ -12,7 +12,6 @@
     /// </summary>
     public class OperationResult
     {
-        private readonly List<IOperationError> _errors = new List<IOperationError>();
         private readonly List<string> _successMessages = new List<string>();
 
         protected readonly ILogger? _logger;
@@ -41,7 +40,7 @@ public IEnumerable<string> SuccessMessages
         /// <summary>
         /// Gets an <see cref="List{T}"/> containing the error codes and messages of the <see cref="OperationResult{T}" />.
         /// </summary>
-        public IReadOnlyCollection<IOperationError> Errors => this._errors.AsReadOnly();
+        public List<IOperationError> Errors { get; internal set; } = new List<IOperationError>();
 
         /// <summary>
         /// Gets or sets the first exception that resulted from the operation.
@@ -214,7 +213,7 @@ public static OperationResult FromError(string message, int? code = null, LogLev
         /// Appends an <see cref="IOperationError"/> to the internal errors collection.
         /// </summary>
         /// <param name="error">An instance of <see cref="IOperationError"/> to add to the internal errors collection.</param>
-        protected void AppendErrorInternal(IOperationError error) => this._errors.Add(error);
+        protected void AppendErrorInternal(IOperationError error) => this.Errors.Add(error);
     }
 
     /// <summary>
@@ -236,7 +235,7 @@ public OperationResult()
         /// </summary>
         /// <param name="logger">An instance of <see cref="ILoggerService"/>.</param>
         /// <remarks>If the operation is a get operation, an empty result must return a truthy Success value.</remarks>
-        public OperationResult(ILogger logger) : base(logger)
+        public OperationResult(ILogger? logger) : base(logger)
         {
         }
 
@@ -246,7 +245,7 @@ public OperationResult(ILogger logger) : base(logger)
         /// <param name="resultObject">An initial failure message for the operation result. This will fail the success status.</param>
         /// <param name="logger">An instance of <see cref="ILogger"/>.</param>
         /// <remarks>If the operation is a get operation, an empty result must return a truthy Success value.</remarks>
-        public OperationResult(TResult resultObject, ILogger logger) : base(logger)
+        public OperationResult(TResult resultObject, ILogger? logger) : base(logger)
         {
             this.ResultObject = resultObject;
         }
@@ -264,7 +263,7 @@ public OperationResult(TResult resultObject) : base()
         /// <summary>
         /// Gets or sets the related result object of the operation.
         /// </summary>
-        public TResult? ResultObject { get; set; }
+        public TResult ResultObject { get; set; }
 
         /// <summary>
         /// This method will append an error with a specific `user-friendly` message to this operation result instance.

src/OneBitSoftware.Utilities.OperationResult/OperationResultValidationExtensions.cs

@@ -96,5 +96,25 @@ public static void ValidateNull<T>(this OperationResult<T> operationResult, obje
             var errorMessage = $"{className}, {methodName} - The {propertyName} is null.";
             operationResult.AppendError(errorMessage, logLevel: level);
         }
+
+        /// <summary>
+        /// Use this method to check if a value is not null.
+        /// If you want to validate that an entity exists, use the "ValidateExist" extension method.
+        /// If you want to validate that the currently authenticated user is not null, use the "ValidateUser" extension method.
+        /// If <paramref name="value"/> is null, an error message should be appended and a log of the passed <paramref name="level"/> severity would be created.
+        /// </summary>
+        /// <param name="value">The value that should be validated.</param>
+        /// <param name="className">The name of the class where the <paramref name="methodName"/> is defined.</param>
+        /// <param name="methodName">The name of he method where <paramref name="value"/> is used.</param>
+        /// <param name="propertyName">The name of the property.</param>
+        /// <param name="level">The logging severity.</param>
+        public static void ValidateNull(this OperationResult operationResult, object value, string className, string methodName, string propertyName, LogLevel level = LogLevel.Error)
+        {
+            // If the passed value is null, log and append an error message.
+            if (value != null) return;
+
+            var errorMessage = $"{className}, {methodName} - The {propertyName} is null.";
+            operationResult.AppendError(errorMessage, logLevel: level);
+        }
     }
 }

src/OneBitSoftware.Utilities.OperationResult/PolymorphicOperationErrorConverter.cs

@@ -0,0 +1,130 @@
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using OneBitSoftware.Utilities.Errors;
+
+namespace OneBitSoftware.Utilities
+{
+    public class PolymorphicOperationErrorConverter<T> : JsonConverter<T>
+        where T : IOperationError
+    {
+        private readonly Dictionary<string, Type> _valueMappings = new Dictionary<string, Type>();
+        private readonly Dictionary<Type, string> _typeMappings = new Dictionary<Type, string>();
+        protected virtual string TypePropertyName => "type";
+
+        public override bool CanConvert(Type typeToConvert)
+        {
+            if (typeToConvert is null) return false;
+            return typeof(OperationError).IsAssignableFrom(typeToConvert);
+        }
+
+        public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            try
+            {
+                // Deserialize the JSON to the specified type.
+                var serializationOptions = this.ConstructSafeFallbackOptions(options);
+                serializationOptions.Converters.Add(new ReadOnlyPartialConverter(this));
+                return (T)JsonSerializer.Deserialize(ref reader, typeToConvert, serializationOptions);
+            }
+            catch (Exception ex)
+            {
+                throw new InvalidOperationException("Invalid JSON in request.", ex);
+            }
+        }
+
+        public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options)
+        {
+            if (value is null)
+            {
+                writer.WriteNullValue();
+                return;
+            }
+
+            if (this._typeMappings.TryGetValue(value.GetType(), out var typeValue) == false) throw new InvalidOperationException($"Model of type {value.GetType()} cannot be successfully serialized.");
+
+            var tempBufferWriter = new ArrayBufferWriter<byte>();
+            var tempWriter = new Utf8JsonWriter(tempBufferWriter);
+
+            var fallbackDeserializationOptions = this.ConstructSafeFallbackOptions(options);
+            JsonSerializer.Serialize(tempWriter, value, value.GetType(), fallbackDeserializationOptions);
+
+            tempWriter.Flush();
+            var jsonDocument = JsonDocument.Parse(tempBufferWriter.WrittenMemory);
+
+            writer.WriteStartObject();
+            writer.WriteString(this.TypePropertyName, typeValue);
+
+            foreach (var property in jsonDocument.RootElement.EnumerateObject()) property.WriteTo(writer);
+            writer.WriteEndObject();
+        }
+
+
+        protected bool AddMapping(string typeValue, Type type)
+        {
+            if (string.IsNullOrWhiteSpace(typeValue) || type is null) return false;
+            if (this._valueMappings.ContainsKey(typeValue) || this._typeMappings.ContainsKey(type)) return false;
+
+            this._valueMappings[typeValue] = type;
+            this._typeMappings[type] = typeValue;
+            return true;
+        }
+
+        private Type GetType(JsonElement typeElement)
+        {
+            if (typeElement.ValueKind != JsonValueKind.String) return null;
+
+            var stringValue = typeElement.GetString();
+            if (string.IsNullOrWhiteSpace(stringValue)) return null;
+
+            this._valueMappings.TryGetValue(stringValue, out var type);
+            return type;
+        }
+
+        private JsonSerializerOptions ConstructSafeFallbackOptions(JsonSerializerOptions options)
+        {
+            var fallbackSerializationOptions = new JsonSerializerOptions(options);
+            fallbackSerializationOptions.Converters.Remove(this);
+            return fallbackSerializationOptions;
+        }
+
+        private class ReadOnlyPartialConverter : JsonConverter<T>
+        {
+            private readonly PolymorphicOperationErrorConverter<T> _polymorphicConverter;
+
+            internal ReadOnlyPartialConverter(PolymorphicOperationErrorConverter<T> polymorphicConverter)
+            {
+                this._polymorphicConverter = polymorphicConverter ?? throw new ArgumentNullException(nameof(polymorphicConverter));
+            }
+
+            public override bool CanConvert(Type typeToConvert) => typeToConvert == typeof(T);
+
+            public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+            {
+                // We copy the value here so we can easily reuse the reader for the subsequent deserialization.
+                var readerRestore = reader;
+
+                // Get the `type` value by parsing the JSON string into a JsonDocument.
+                var jsonDocument = JsonDocument.ParseValue(ref reader);
+                jsonDocument.RootElement.TryGetProperty(this._polymorphicConverter.TypePropertyName, out var typeElement);
+
+                var returnType = this._polymorphicConverter.GetType(typeElement);
+                if (returnType is null) throw new InvalidOperationException("The received JSON cannot be deserialized to any known type.");
+
+                try
+                {
+                    // Deserialize the JSON to the specified type.
+                    return (T)JsonSerializer.Deserialize(ref readerRestore, returnType, options);
+                }
+                catch (Exception ex)
+                {
+                    throw new InvalidOperationException("Invalid JSON in request.", ex);
+                }
+            }
+
+            public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options) => throw new InvalidOperationException("The `Read only partial converter` cannot be used for serialization.");
+        }
+    }
+}

tests/OneBitSoftware.Utilities.OperationResultTests/CustomError.cs

@@ -0,0 +1,7 @@
+namespace OneBitSoftware.Utilities.OperationResultTests
+{
+    internal class CustomError
+    {
+        public string CustomProperty { get; set; } = null!;
+    }
+}

tests/OneBitSoftware.Utilities.OperationResultTests/CustomErrorPolymorphicConverter.cs

@@ -0,0 +1,16 @@
+namespace OneBitSoftware.Utilities.OperationResultTests
+{
+    using OneBitSoftware.Utilities.Errors;
+
+    /// <summary>
+    /// A <see cref="System.Text.Json.Serialization.JsonConverter"/> inheriting class for polymorphic serialization.deserialization of custom <see cref="IOperationError"/> implementations.
+    /// </summary>
+    internal class CustomErrorPolymorphicConverter : PolymorphicOperationErrorConverter<IOperationError>
+    {
+        public CustomErrorPolymorphicConverter()
+        {
+            // Define your discriminator and custom type mapping
+            this.AddMapping("custom_error", typeof(CustomError));
+        }
+    }
+}

tests/OneBitSoftware.Utilities.OperationResultTests/OneBitSoftware.Utilities.OperationResultTests.csproj

@@ -8,6 +8,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.2.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
       <PrivateAssets>all</PrivateAssets>

tests/OneBitSoftware.Utilities.OperationResultTests/OperationResultSerializationTests.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+using OneBitSoftware.Utilities.Errors;
+using Xunit;
+
+namespace OneBitSoftware.Utilities.OperationResultTests
+{
+    public class OperationResultSerializationTests
+    {
+        private JsonSerializerOptions GetSerializationOptions()
+        {
+            var serializeOptions = new JsonSerializerOptions();
+            serializeOptions.Converters.Add(new CustomErrorPolymorphicConverter());
+            return serializeOptions;
+        }
+
+        [Fact]
+        public async Task CanSerializeWithSystemTextJson()
+        {
+            // Arrange
+            var testText = "Test details";
+            var outputStream = new MemoryStream();
+            var operationResult = new OperationResult();
+            operationResult.AppendError(new OperationError(message: "Test") { Code = 123, Details = testText });
+
+            // Act
+            await JsonSerializer.SerializeAsync<OperationResult>(outputStream, operationResult, GetSerializationOptions());
+            outputStream.Position = 0;
+            string text = new StreamReader(outputStream).ReadToEnd();
+
+            // Assert
+            Assert.Contains(testText, text);
+        }
+
+        [Fact]
+        public async Task CanSerializeAndDeserializeWithSystemTextJson()
+        {
+            // Arrange
+            var testText = "Test details";
+            var serializeStream = new MemoryStream();
+            var deserializeStream = new MemoryStream();
+            var operationResult = new OperationResult();
+            operationResult.AppendError(new OperationError(message: "Test") { Code = 123, Details = testText });
+
+            // Act
+            var serializeString = JsonSerializer.Serialize<OperationResult>(operationResult, GetSerializationOptions());
+
+            var resultObject = JsonSerializer.Deserialize<OperationResult>(serializeString, GetSerializationOptions());
+
+            // Assert
+            Assert.NotNull(resultObject);
+            Assert.Equal(operationResult.Errors.Count(), resultObject?.Errors.Count());
+        }
+
+        [Fact]
+        public async Task CanSerializeWithNewtonSoftJson()
+        {
+            // Arrange
+            var testText = "Test details";
+            var outputStream = new MemoryStream();
+            var operationResult = new OperationResult();
+            operationResult.AppendError(new OperationError(message: "Test") { Code = 123, Details = testText });
+
+            // Act
+            var resultString = Newtonsoft.Json.JsonConvert.SerializeObject(operationResult);
+
+            // Assert
+            Assert.Contains(testText, resultString);
+        }
+    }
+}