Added an example how ad hoc union can be made serializable and asp.net core model bindable

PawelGerr · PawelGerr · commit 2dde91157a18 · 2025-04-06T15:50:02.000+02:00
diff --git a/docs b/docs
@@ -1 +1 @@
-Subproject commit 365caf2e5d00c29b9f7de443574c2d5a04149297
+Subproject commit a480f5da155167f870be0711e2247d25cb3f759f
diff --git a/samples/Thinktecture.Runtime.Extensions.AspNetCore.Samples/Controllers/DemoController.cs b/samples/Thinktecture.Runtime.Extensions.AspNetCore.Samples/Controllers/DemoController.cs
@@ -4,6 +4,7 @@
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Logging;
 using Thinktecture.SmartEnums;
+using Thinktecture.Unions;
 using Thinktecture.ValueObjects;
 
 namespace Thinktecture.Controllers;
@@ -131,6 +132,17 @@ public IActionResult RoundTripPost([FromBody] OpenEndDate endDate)
       return Json(endDate);
    }
 
+   [HttpGet("textOrNumber/{textOrNumber}")]
+   public IActionResult RoundTrip(TextOrNumberSerializable textOrNumber)
+   {
+      if (!ModelState.IsValid)
+         return BadRequest(ModelState);
+
+      _logger.LogInformation("Round trip test with {Type}: {EndDate}", textOrNumber.GetType().Name, textOrNumber);
+
+      return Json(textOrNumber);
+   }
+
    private IActionResult RoundTripValidatableEnum<T>(T value)
       where T : IValidatableEnum
    {
diff --git a/samples/Thinktecture.Runtime.Extensions.AspNetCore.Samples/Program.cs b/samples/Thinktecture.Runtime.Extensions.AspNetCore.Samples/Program.cs
@@ -17,6 +17,7 @@
 using Thinktecture.Helpers;
 using Thinktecture.SmartEnums;
 using Thinktecture.Text.Json.Serialization;
+using Thinktecture.Unions;
 using Thinktecture.Validation;
 using Thinktecture.ValueObjects;
 using ILogger = Microsoft.Extensions.Logging.ILogger;
@@ -82,6 +83,8 @@ private static async Task DoHttpRequestsAsync(ILogger logger, bool forMinimalWeb
       await DoRequestAsync(logger, client, $"enddate/{DateOnly.FromDateTime(DateTime.Now):O}");
       await DoRequestAsync(logger, client, "enddate", DateOnly.FromDateTime(DateTime.Now));
 
+      await DoRequestAsync(logger, client, "textOrNumber/Number|42");
+
       await DoRequestAsync(logger, client, "notification/channels");
       await DoRequestAsync(logger, client, "notification/channels/email", "Test email");
    }
@@ -179,6 +182,8 @@ private static Task StartMinimalWebApiAsync(ILoggerFactory loggerFactory)
       routeGroup.MapGet("enddate/{date}", (OpenEndDate date) => date);
       routeGroup.MapPost("enddate", ([FromBody] OpenEndDate date) => date);
 
+      routeGroup.MapGet("textOrNumber/{textOrNumber}", (TextOrNumberSerializable textOrNumber) => textOrNumber);
+
       routeGroup.MapGet("notification/channels", () =>
       {
          var channels = NotificationChannelTypeDto.Items.Select(c => c.Name);
diff --git a/samples/Thinktecture.Runtime.Extensions.MessagePack.Samples/Program.cs b/samples/Thinktecture.Runtime.Extensions.MessagePack.Samples/Program.cs
@@ -4,6 +4,7 @@
 using MessagePack.Resolvers;
 using Thinktecture;
 using Thinktecture.SmartEnums;
+using Thinktecture.Unions;
 using Thinktecture.ValueObjects;
 
 var groceries = DoRoundTripSerializationOfTypesWithoutFormatter(ProductType.Groceries);
@@ -23,6 +24,13 @@
 var boundaryWithFormatter = DoRoundTripSerialization(BoundaryWithMessagePackFormatter.Create(1, 2));
 Console.WriteLine(boundaryWithFormatter);
 
+// Ad hoc union
+var textOrNumber = DoRoundTripSerializationOfTypesWithoutFormatter((TextOrNumberSerializable)42);
+Console.WriteLine(textOrNumber);
+
+var textOrNumberWithFormatter = DoRoundTripSerialization((TextOrNumberSerializableWithFormatter)42);
+Console.WriteLine(textOrNumberWithFormatter);
+
 // Smart Enums and Value Objects without [MessagePackFormatterAttribute] need "ValueObjectMessageFormatterResolver".
 static T DoRoundTripSerializationOfTypesWithoutFormatter<T>(T obj)
 {
diff --git a/samples/Thinktecture.Runtime.Extensions.MessagePack.Samples/TextOrNumberSerializableWithFormatter.cs b/samples/Thinktecture.Runtime.Extensions.MessagePack.Samples/TextOrNumberSerializableWithFormatter.cs
@@ -0,0 +1,81 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using MessagePack;
+
+namespace Thinktecture;
+
+[Union<string, int>(T1IsNullableReferenceType = true,
+                    T1Name = "Text",
+                    T2Name = "Number",
+                    SwitchMethods = SwitchMapMethodsGeneration.DefaultWithPartialOverloads,
+                    MapMethods = SwitchMapMethodsGeneration.DefaultWithPartialOverloads)]
+[ValueObjectFactory<string>(UseForSerialization = SerializationFrameworks.All)]
+[MessagePackFormatter(typeof(Formatters.ValueObjectMessagePackFormatter<TextOrNumberSerializableWithFormatter, string, ValidationError>))] // Optional: otherwise ValueObjectMessageFormatterResolver is required
+public partial class TextOrNumberSerializableWithFormatter :
+   IValueObjectFactory<TextOrNumberSerializableWithFormatter, string, ValidationError>, // For deserialization
+   IValueObjectConvertable<string>,                                                     // For serialization
+   IParsable<TextOrNumberSerializableWithFormatter>                                     // For Minimal API and ASP.NET Core model binding validation
+{
+   // For serialization
+   public string ToValue()
+   {
+      return Switch(text: t => $"Text|{t}",
+                    number: n => $"Number|{n}");
+   }
+
+   // For deserialization
+   public static ValidationError? Validate(string? value, IFormatProvider? provider, out TextOrNumberSerializableWithFormatter? item)
+   {
+      if (String.IsNullOrWhiteSpace(value))
+      {
+         item = null;
+         return null;
+      }
+
+      if (value.StartsWith("Text|", StringComparison.OrdinalIgnoreCase))
+      {
+         item = value.Substring(5);
+         return null;
+      }
+
+      if (value.StartsWith("Number|", StringComparison.OrdinalIgnoreCase))
+      {
+         if (Int32.TryParse(value.Substring(7), out var number))
+         {
+            item = number;
+            return null;
+         }
+
+         item = null;
+         return new ValidationError("Invalid number format");
+      }
+
+      item = null;
+      return new ValidationError("Invalid format");
+   }
+
+   public static TextOrNumberSerializableWithFormatter Parse(string s, IFormatProvider? provider)
+   {
+      var validationError = Validate(s, provider, out var result);
+
+      if (validationError is null)
+         return result!;
+
+      throw new FormatException(validationError.Message);
+   }
+
+   public static bool TryParse(
+      [NotNullWhen(true)] string? s,
+      IFormatProvider? provider,
+      [MaybeNullWhen(false)] out TextOrNumberSerializableWithFormatter result)
+   {
+      if (s is null)
+      {
+         result = null;
+         return false;
+      }
+
+      var validationError = Validate(s, provider, out result!);
+      return validationError is null;
+   }
+}
diff --git a/samples/Thinktecture.Runtime.Extensions.Samples/Unions/DiscriminatedUnionsDemos.cs b/samples/Thinktecture.Runtime.Extensions.Samples/Unions/DiscriminatedUnionsDemos.cs
@@ -2,6 +2,7 @@
 using System.ComponentModel.DataAnnotations;
 using System.Text.Json;
 using Serilog;
+using Thinktecture.Text.Json.Serialization;
 
 namespace Thinktecture.Unions;
 
@@ -10,6 +11,7 @@ public class DiscriminatedUnionsDemos
    public static void Demo(ILogger logger)
    {
       DemoForAdHocUnions(logger);
+      SerializationDemoForAdHocUnions(logger);
       DemoForUnions(logger);
       DemoForJurisdiction(logger);
       DemoForPartiallyKnownDate(logger);
@@ -82,6 +84,22 @@ private static void DemoForAdHocUnions(ILogger logger)
       logger.Information("{Response}", mapPartiallyResponse);
    }
 
+   private static void SerializationDemoForAdHocUnions(ILogger logger)
+   {
+      TextOrNumberSerializable textOrNumberFromString = "text";
+      TextOrNumberSerializable textOrNumberFromInt = 42;
+
+      var jsonOptions = new JsonSerializerOptions { Converters = { new ValueObjectJsonConverterFactory() } };
+
+      var json = JsonSerializer.Serialize(textOrNumberFromString, jsonOptions);
+      var deserializedTextOrNumber = JsonSerializer.Deserialize<TextOrNumberSerializable>(json, jsonOptions);
+      logger.Information("TextOrNumberSerializable (de)serialization: {Json} -> {TextOrNumber}", json, deserializedTextOrNumber);
+
+      json = JsonSerializer.Serialize(textOrNumberFromInt, jsonOptions);
+      deserializedTextOrNumber = JsonSerializer.Deserialize<TextOrNumberSerializable>(json, jsonOptions);
+      logger.Information("TextOrNumberSerializable (de)serialization: {Json} -> {TextOrNumber}", json, deserializedTextOrNumber);
+   }
+
    private static void DemoForUnions(ILogger logger)
    {
       DemoForUnionsUsingClass(logger);
@@ -253,7 +271,7 @@ private static void DemoForPartiallyKnownDate(ILogger logger)
       var preciseDate = new PartiallyKnownDate.Date(2023, 12, 31);
 
       // Implicit conversion from DateOnly to PartiallyKnownDate
-      PartiallyKnownDate fullDate = new DateOnly(2024, 3, 15);  // Date(2024, 3, 15)
+      PartiallyKnownDate fullDate = new DateOnly(2024, 3, 15); // Date(2024, 3, 15)
 
       static string FormatDate(PartiallyKnownDate? date)
       {
diff --git a/samples/Thinktecture.Runtime.Extensions.Samples/Unions/TextOrNumberSerializable.cs b/samples/Thinktecture.Runtime.Extensions.Samples/Unions/TextOrNumberSerializable.cs
@@ -0,0 +1,81 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Text.Json.Serialization;
+using Thinktecture.Text.Json.Serialization;
+
+namespace Thinktecture.Unions;
+
+[Union<string, int>(T1Name = "Text",
+                    T2Name = "Number",
+                    SwitchMethods = SwitchMapMethodsGeneration.DefaultWithPartialOverloads,
+                    MapMethods = SwitchMapMethodsGeneration.DefaultWithPartialOverloads)]
+[ValueObjectFactory<string>(UseForSerialization = SerializationFrameworks.All)]
+[JsonConverter(typeof(ValueObjectJsonConverterFactory<TextOrNumberSerializable, string, ValidationError>))] // Optional: otherwise ValueObjectJsonConverterFactory is required
+public partial class TextOrNumberSerializable :
+   IValueObjectFactory<TextOrNumberSerializable, string, ValidationError>, // For deserialization
+   IValueObjectConvertable<string>,                                        // For serialization
+   IParsable<TextOrNumberSerializable> // For Minimal API and ASP.NET Core model binding validation
+{
+   // For serialization
+   public string ToValue()
+   {
+      return Switch(text: t => $"Text|{t}",
+                    number: n => $"Number|{n}");
+   }
+
+   // For deserialization
+   public static ValidationError? Validate(string? value, IFormatProvider? provider, out TextOrNumberSerializable? item)
+   {
+      if (String.IsNullOrWhiteSpace(value))
+      {
+         item = null;
+         return null;
+      }
+
+      if (value.StartsWith("Text|", StringComparison.OrdinalIgnoreCase))
+      {
+         item = value.Substring(5);
+         return null;
+      }
+
+      if (value.StartsWith("Number|", StringComparison.OrdinalIgnoreCase))
+      {
+         if (Int32.TryParse(value.Substring(7), out var number))
+         {
+            item = number;
+            return null;
+         }
+
+         item = null;
+         return new ValidationError("Invalid number format");
+      }
+
+      item = null;
+      return new ValidationError("Invalid format");
+   }
+
+   public static TextOrNumberSerializable Parse(string s, IFormatProvider? provider)
+   {
+      var validationError = Validate(s, provider, out var result);
+
+      if (validationError is null)
+         return result!;
+
+      throw new FormatException(validationError.Message);
+   }
+
+   public static bool TryParse(
+      [NotNullWhen(true)] string? s,
+      IFormatProvider? provider,
+      [MaybeNullWhen(false)] out TextOrNumberSerializable result)
+   {
+      if (s is null)
+      {
+         result = null;
+         return false;
+      }
+
+      var validationError = Validate(s, provider, out result!);
+      return validationError is null;
+   }
+}
