Replace DvDateTimeZone, DvDateTime, DvTimeSpan with .NET standard types.

src/Microsoft.ML.Api/ApiUtils.cs

@@ -23,7 +23,7 @@ private static OpCode GetAssignmentOpCode(Type t)
                 t == typeof(DvBool) || t == typeof(DvText) || t == typeof(string) || t.IsArray ||
                 (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(VBuffer<>)) ||
                 (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable<>)) ||
-                t == typeof(DvDateTime) || t == typeof(DvDateTimeZone) || t == typeof(DvTimeSpan) || t == typeof(UInt128))
+                t == typeof(DateTime) || t == typeof(DateTimeOffset) || t == typeof(TimeSpan) || t == typeof(UInt128))
             {
                 return OpCodes.Stobj;
             }

src/Microsoft.ML.Core/Data/ColumnType.cs

@@ -120,47 +120,38 @@ public bool IsBool
         }
 
         /// <summary>
-        /// Whether this type is the standard timespan type.
+        /// Whether this type is the standard <see cref="TimeSpan"/> type.
         /// </summary>
         public bool IsTimeSpan
         {
             get
             {
-                if (!(this is TimeSpanType))
-                    return false;
-                // TimeSpanType is a singleton.
-                Contracts.Assert(this == TimeSpanType.Instance);
-                return true;
+                Contracts.Assert((this == TimeSpanType.Instance) == (this is TimeSpanType));
+                return this is TimeSpanType;
             }
         }
 
         /// <summary>
-        /// Whether this type is a DvDateTime.
+        /// Whether this type is a <see cref="DateTime"/>.
         /// </summary>
         public bool IsDateTime
         {
             get
             {
-                if (!(this is DateTimeType))
-                    return false;
-                // DateTimeType is a singleton.
-                Contracts.Assert(this == DateTimeType.Instance);
-                return true;
+                Contracts.Assert((this == DateTimeType.Instance) == (this is DateTimeType));
+                return this is DateTimeType;
             }
         }
 
         /// <summary>
-        /// Whether this type is a DvDateTimeZone.
+        /// Whether this type is a <see cref="DateTimeOffset"/>
         /// </summary>
         public bool IsDateTimeZone
         {
             get
             {
-                if (!(this is DateTimeZoneType))
-                    return false;
-                // DateTimeZoneType is a singleton.
-                Contracts.Assert(this == DateTimeZoneType.Instance);
-                return true;
+                Contracts.Assert((this == DateTimeOffsetType.Instance) == (this is DateTimeOffsetType));
+                return this is DateTimeOffsetType;
             }
         }
 
@@ -319,7 +310,7 @@ public static PrimitiveType FromKind(DataKind kind)
             if (kind == DataKind.DT)
                 return DateTimeType.Instance;
             if (kind == DataKind.DZ)
-                return DateTimeZoneType.Instance;
+                return DateTimeOffsetType.Instance;
             return NumberType.FromKind(kind);
         }
     }
@@ -605,7 +596,7 @@ public static DateTimeType Instance
         }
 
         private DateTimeType()
-            : base(typeof(DvDateTime), DataKind.DT)
+            : base(typeof(DateTime), DataKind.DT)
         {
         }
 
@@ -623,29 +614,29 @@ public override string ToString()
         }
     }
 
-    public sealed class DateTimeZoneType : PrimitiveType
+    public sealed class DateTimeOffsetType : PrimitiveType
     {
-        private static volatile DateTimeZoneType _instance;
-        public static DateTimeZoneType Instance
+        private static volatile DateTimeOffsetType _instance;
+        public static DateTimeOffsetType Instance
         {
             get
             {
                 if (_instance == null)
-                    Interlocked.CompareExchange(ref _instance, new DateTimeZoneType(), null);
+                    Interlocked.CompareExchange(ref _instance, new DateTimeOffsetType(), null);
                 return _instance;
             }
         }
 
-        private DateTimeZoneType()
-            : base(typeof(DvDateTimeZone), DataKind.DZ)
+        private DateTimeOffsetType()
+            : base(typeof(DateTimeOffset), DataKind.DZ)
         {
         }
 
         public override bool Equals(ColumnType other)
         {
             if (other == this)
                 return true;
-            Contracts.Assert(!(other is DateTimeZoneType));
+            Contracts.Assert(!(other is DateTimeOffsetType));
             return false;
         }
 
@@ -672,7 +663,7 @@ public static TimeSpanType Instance
         }
 
         private TimeSpanType()
-            : base(typeof(DvTimeSpan), DataKind.TS)
+            : base(typeof(TimeSpan), DataKind.TS)
         {
         }
 

src/Microsoft.ML.Core/Data/DataKind.cs

@@ -165,11 +165,11 @@ public static Type ToType(this DataKind kind)
                 case DataKind.BL:
                     return typeof(DvBool);
                 case DataKind.TS:
-                    return typeof(DvTimeSpan);
+                    return typeof(TimeSpan);
                 case DataKind.DT:
-                    return typeof(DvDateTime);
+                    return typeof(DateTime);
                 case DataKind.DZ:
-                    return typeof(DvDateTimeZone);
+                    return typeof(DateTimeOffset);
                 case DataKind.UG:
                     return typeof(UInt128);
             }
@@ -209,11 +209,11 @@ public static bool TryGetDataKind(this Type type, out DataKind kind)
                 kind = DataKind.TX;
             else if (type == typeof(DvBool) || type == typeof(bool) || type == typeof(bool?))
                 kind = DataKind.BL;
-            else if (type == typeof(DvTimeSpan))
+            else if (type == typeof(TimeSpan))
                 kind = DataKind.TS;
-            else if (type == typeof(DvDateTime))
+            else if (type == typeof(DateTime))
                 kind = DataKind.DT;
-            else if (type == typeof(DvDateTimeZone))
+            else if (type == typeof(DateTimeOffset))
                 kind = DataKind.DZ;
             else if (type == typeof(UInt128))
                 kind = DataKind.UG;