using System;

using System.Collections.Generic;

using Newtonsoft.Json;

​

​

/// <summary>

/// MassTransit message type containing a list of properties to serialize

/// </summart>

public record PrintCustomer

{

  public string AccountNumber { get; init; }

  [JsonProperty(ItemTypeNameHandling = TypeNameHandling.Objects)]

  public List<Property> Properties { get; init; } = new List<Property>();

}

​

/// <summary>

/// Base class for a property. Exposes the datatype and value as a downcast <see cref="object"/>.

/// </summary>

public abstract class Property

{

    /// <summary>

    /// Attribute Id

    /// </summary

    public Guid Id { get; set; }    

    /// <summary>

    /// Attribute value

    /// </summary

    public abstract object GetValue();

    /// <summary>

    /// Attribute datatype

    /// </summary

    public abstract Type GetDataType();

    /// <summary>

    /// Create a new property of type <typeparamref name="T"/>

    /// </summary

    /// <typeparam name="T">The datatype of the property value.</typeparam>

    /// <param name="id">Property Id</param>

    /// <param name="value">Property Value</param>

    public static Property CreateNew<T>(Guid id, T value) => new Property<T> { Id = id, Value = value };

    /// <summary>

    /// Returns a string representaiton of the property and data type.

    /// </summary

    public override string ToString() => $"{Id} = {GetValue()} <{GetDataType()}>";

}

​

/// <summary>

/// Generic property of a given type <typeparamref name="T"/>. 

/// Allows for serialization of strongly typed properties.

/// </summary>

public class Property<T> : Property

{

    /// <summary>

    /// Internal attribute value of type <typeparamref name="T"/>

    /// </summary

    public T Value { get; set; }

    /// <summary>

    /// Attribute value

    /// </summary

    public override object GetValue() => Value; 

    /// <summary>

    /// Attribute datatype

    /// </summary

    public override Type GetDataType() => typeof(T);    

}

​

class Program 

{

    static void Main(string[] args) 

    {

        var customer = new PrintCustomer() 

        {

            AccountNumber = "Foo#123",

            Properties = new List<Property>() 

            {               

                // Raw generic types

                new Property<int> { Id = Guid.NewGuid(), Value = 123 },

                new Property<string> { Id = Guid.NewGuid(), Value = "Foo" },

                new Property<decimal> { Id = Guid.NewGuid(), Value = 99.99m },

                new Property<DateTime> { Id = Guid.NewGuid(), Value = DateTime.UtcNow },

                // Type inference using static constructors

                Property.CreateNew(Guid.NewGuid(), 123),

                Property.CreateNew(Guid.NewGuid(), 456L),

                Property.CreateNew(Guid.NewGuid(), "Bar"),

                Property.CreateNew(Guid.NewGuid(), 4812.4839m),

                Property.CreateNew(Guid.NewGuid(), DateTimeOffset.UtcNow),

            }

        };

        Console.Out.WriteLine("Expected:\n");

        foreach (var prop in customer.Properties)

        {

            Console.Out.WriteLine($"Property {prop}");              

        }               

        Console.Out.WriteLine("");

        Console.Out.WriteLine("Serialized:\n");

        var json = JsonConvert.SerializeObject(customer, Formatting.Indented);

        Console.Out.WriteLine($"JSON = {json}\n");

        Console.Out.WriteLine("");

        Console.Out.WriteLine("Deserialized:\n");

        var deserializedCustomer = JsonConvert.DeserializeObject<PrintCustomer>(json);

        foreach (var prop in deserializedCustomer.Properties)

        {

            Console.Out.WriteLine($"Property {prop}");              

        }   

    }

}