Add config option to save DateTime and TimeOffset as Int64

Assets/FullSerializer/Source/Converters/fsDateConverter.cs

@@ -27,31 +27,45 @@ public override bool CanProcess(Type type) {
         public override fsResult TrySerialize(object instance, out fsData serialized, Type storageType) {
             if (instance is DateTime) {
                 var dateTime = (DateTime)instance;
-                serialized = new fsData(dateTime.ToString(DateTimeFormatString));
+                if(Serializer.Config.SerializeDateTimeAsInteger) {
+                    serialized = new fsData(dateTime.Ticks);
+                } else {
+                    serialized = new fsData(dateTime.ToString(DateTimeFormatString));
+                    return fsResult.Success;
+                }
                 return fsResult.Success;
             }
 
             if (instance is DateTimeOffset) {
                 var dateTimeOffset = (DateTimeOffset)instance;
-                serialized = new fsData(dateTimeOffset.ToString(DateTimeOffsetFormatString));
+                serialized = new fsData(dateTimeOffset.Ticks);
                 return fsResult.Success;
             }
 
             if (instance is TimeSpan) {
                 var timeSpan = (TimeSpan)instance;
-                serialized = new fsData(timeSpan.ToString());
+                if(Serializer.Config.SerializeDateTimeAsInteger) {
+                    serialized = new fsData(timeSpan.Ticks);
+                } else {
+                    serialized = new fsData(timeSpan.ToString());
+                }
                 return fsResult.Success;
             }
 
             throw new InvalidOperationException("FullSerializer Internal Error -- Unexpected serialization type");
         }
 
         public override fsResult TryDeserialize(fsData data, ref object instance, Type storageType) {
-            if (data.IsString == false) {
-                return fsResult.Fail("Date deserialization requires a string, not " + data.Type);
+            if (data.IsString == false && (data.IsInt64 == false || Serializer.Config.SerializeDateTimeAsInteger == false || instance is DateTimeOffset)) {
+                return fsResult.Fail("Date deserialization requires a string or int, not " + data.Type);
             }
 
             if (storageType == typeof(DateTime)) {
+                if (Serializer.Config.SerializeDateTimeAsInteger && data.IsInt64) {
+                    instance = new DateTime(data.AsInt64);
+                    return fsResult.Success;
+                }
+
                 DateTime result;
                 if (DateTime.TryParse(data.AsString, null, DateTimeStyles.RoundtripKind, out result)) {
                     instance = result;
@@ -84,6 +98,11 @@ public override fsResult TryDeserialize(fsData data, ref object instance, Type s
             }
 
             if (storageType == typeof(TimeSpan)) {
+                if (Serializer.Config.SerializeDateTimeAsInteger && data.IsInt64) {
+                    instance = new TimeSpan(data.AsInt64);
+                    return fsResult.Success;
+                }
+
                 TimeSpan result;
                 if (TimeSpan.TryParse(data.AsString, out result)) {
                     instance = result;

Assets/FullSerializer/Source/fsConfig.cs

@@ -98,6 +98,12 @@ public class fsConfig {
         /// </summary>
         public string CustomDateTimeFormatString = null;
 
+        /// <summary>
+        /// If true, DateTime and TimeSpan will be saved as 64 bit integers
+        /// rather than strings. DateTimeOffset will still be saved as string.
+        /// </summary>
+        public bool SerializeDateTimeAsInteger = false;
+
         /// <summary>
         /// Int64 and UInt64 will be serialized and deserialized as string for
         /// compatibility

Assets/FullSerializer/Testing/Editor/DateTimeTests.cs

@@ -1,14 +1,44 @@
 using System;
-using FullSerializer;
 using NUnit.Framework;
 
-public class DateTimeTests {
-    [Test]
-    public void StrangeFormatTests() {
-        var serializer = new fsSerializer();
-        DateTime time = DateTime.Now;
-        serializer.TryDeserialize(new fsData("2016-01-22T12:06:57.503005Z"), ref time).AssertSuccessWithoutWarnings();
+namespace FullSerializer.Tests {
+    public class DateTimeTests {
+        [Test]
+        public void StrangeFormatTests() {
+            var serializer = new fsSerializer();
+            DateTime time = DateTime.Now;
+            serializer.TryDeserialize(new fsData("2016-01-22T12:06:57.503005Z"), ref time).AssertSuccessWithoutWarnings();
 
-        Assert.AreEqual(Convert.ToDateTime("2016-01-22T12:06:57.503005Z"), time);
+            Assert.AreEqual(Convert.ToDateTime("2016-01-22T12:06:57.503005Z"), time);
+        }
+
+        [Test]
+        public void TestDateTimeAsIntIsInt() {
+            var serializer = new fsSerializer {Config = {SerializeDateTimeAsInteger = true}};
+
+            var original = new DateTime(1985, 8, 22, 4, 19, 01, 123, DateTimeKind.Utc);
+            fsData serializedData;
+            serializer.TrySerialize(original, out serializedData).AssertSuccessWithoutWarnings();
+
+            Assert.That(serializedData.IsInt64);
+        }
+
+        [Test]
+        public void TestDateTimeAsIntRoundTrips() {
+            var serializer = new fsSerializer {Config = {SerializeDateTimeAsInteger = true}};
+
+            var original = new DateTime(1985, 8, 22, 4, 19, 01, 123, DateTimeKind.Utc);
+            var deserialized = Clone(original, serializer, serializer);
+
+            Assert.AreEqual(original, deserialized);
+        }
+
+        public static T Clone<T>(T original, fsSerializer serializer, fsSerializer deserializer) {
+            fsData serializedData;
+            serializer.TrySerialize(original, out serializedData).AssertSuccessWithoutWarnings();
+            var actual = default(T);
+            deserializer.TryDeserialize(serializedData, ref actual);
+            return actual;
+        }
     }
-}
+}