// Solution Code

using MessagePack;

using MessagePack.Formatters;

using MessagePack.Resolvers;

using System;

using System.Collections.Generic;

using System.Reflection;

​

namespace DateTimeSerialization

{

    public class UtcNullableDateTimeFormatter : IMessagePackFormatter<DateTime?>

    {

        public void Serialize(ref MessagePackWriter writer, DateTime? value, MessagePackSerializerOptions options)

        {

            if (value.HasValue)

            {

                writer.Write(DateTime.SpecifyKind(value.Value, DateTimeKind.Utc));

            }

            else

            {

                writer.WriteNil();

            }

        }

​

        public DateTime? Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)

        {

            if (reader.IsNil)

            {

                reader.ReadNil();

                return null;

            }

            else

            {

                return DateTime.SpecifyKind(reader.ReadDateTime(), DateTimeKind.Utc);

            }

        }

    }

​

    public class CustomResolver : IFormatterResolver

    {

        public static readonly CustomResolver Instance = new CustomResolver();

​

        private CustomResolver() { }

​

        public IMessagePackFormatter<T>? GetFormatter<T>()

        {

            if (typeof(T) == typeof(DateTime?))

            {

                return (IMessagePackFormatter<T>)new UtcNullableDateTimeFormatter();

            }

​

            return StandardResolver.Instance.GetFormatter<T>();

        }

    }

​

    [MessagePackObject]

    public class MyPoco

    {

        [Key(0)]

        public DateTime? Date1 { get; set; }

        [Key(1)]

        public DateTime? Date2 { get; set; }

        [Key(2)]

        public DateTime? Date3 { get; set; }

        [Key(3)]

        public DateTime? Date4 { get; set; }

        [Key(4)]

        public DateTime? Date5 { get; set; }

    }

​

    public class SerializationHelper

    {

        /// <summary>

        /// Serializes an object using MessagePack with a custom resolver to handle multiple nullable DateTime properties.

        /// </summary>

        /// <typeparam name="T">The type of the object to serialize.</typeparam>

        /// <param name="obj">The object to serialize.</param>

        /// <returns>A byte array representing the serialized object, or null if serialization fails.</returns>

        public static byte[]? Serialize<T>(T obj)

        {

            try

            {

                var options = MessagePackSerializerOptions.Standard.WithResolver(CustomResolver.Instance);

                return MessagePackSerializer.Serialize<T>(obj, options);

            }

            catch (Exception ex)

            {

                Console.WriteLine($"Serialization failed: {ex.Message}");

                return null;

            }

        }

​

        /// <summary>

        /// Deserializes an object from a byte array using MessagePack with a custom resolver.

        /// </summary>

        /// <typeparam name="T">The type of the object to deserialize.</typeparam>

        /// <param name="data">The byte array containing the serialized data.</param>

        /// <returns>The deserialized object, or default(T) if deserialization fails.</returns>

        public static T? Deserialize<T>(byte[] data)

        {

            if (data == null || data.Length == 0)

            {

                Console.WriteLine("Data is null or empty.");

                return default(T);

            }

​

            try

            {

                var options = MessagePackSerializerOptions.Standard.WithResolver(CustomResolver.Instance);

                return MessagePackSerializer.Deserialize<T>(data, options);

            }

            catch (Exception ex)

            {

                Console.WriteLine($"Deserialization failed: {ex.Message}");

                return default(T);

            }

        }

    }

​

    public class Program

    {

        public static void Main(string[] args)

        {

            MyPoco obj = new MyPoco

            {

                Date1 = DateTime.Now,

                Date2 = DateTime.Now.AddDays(1),

                Date3 = DateTime.Now.AddDays(2),

                Date4 = DateTime.Now.AddDays(3),

                Date5 = null

            };

​

            byte[]? serializedData = SerializationHelper.Serialize(obj);

​

            if (serializedData != null)

            {

                MyPoco? deserializedObj = SerializationHelper.Deserialize<MyPoco>(serializedData);

​

                if (deserializedObj != null)

                {

                    Console.WriteLine($"Date1: {deserializedObj.Date1}");

                    Console.WriteLine($"Date2: {deserializedObj.Date2}");

                    Console.WriteLine($"Date3: {deserializedObj.Date3}");

                    Console.WriteLine($"Date4: {deserializedObj.Date4}");

                    Console.WriteLine($"Date5: {deserializedObj.Date5}");

                }

                else

                {

                    Console.WriteLine("Deserialization failed.");

                }

            }

            else

            {

                Console.WriteLine("Serialization failed.");

            }

        }

    }

}