Merge pull request dotnet/coreclr#13845 from ViktorHofer/DBNull-Seria…

…lization

Make DBNull serializable

Signed-off-by: dotnet-bot <[email protected]>

src/System.Private.CoreLib/shared/System.Private.CoreLib.Shared.projitems

@@ -487,6 +487,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\UnauthorizedAccessException.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\UnhandledExceptionEventArgs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\UnhandledExceptionEventHandler.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\UnitySerializationHolder.cs"/> 
     <Compile Include="$(MSBuildThisFileDirectory)System\ValueTuple.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Version.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Void.cs" />

src/System.Private.CoreLib/shared/System/DBNull.cs

@@ -6,17 +6,23 @@
 
 namespace System
 {
+    [Serializable]
     public sealed class DBNull : ISerializable, IConvertible
     {
         private DBNull()
         {
         }
-
+
+        private DBNull(SerializationInfo info, StreamingContext context)
+        {
+            throw new NotSupportedException(SR.NotSupported_DBNullSerial);
+        }
+
         public static readonly DBNull Value = new DBNull();
 
         public void GetObjectData(SerializationInfo info, StreamingContext context)
         {
-            throw new PlatformNotSupportedException();
+            UnitySerializationHolder.GetUnitySerializationInfo(info, UnitySerializationHolder.NullUnity);
         }
 
         public override string ToString()

src/System.Private.CoreLib/shared/System/UnitySerializationHolder.cs

@@ -0,0 +1,66 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.Serialization;
+
+namespace System
+{
+    /// <summary>
+    /// Holds Null class for which we guarantee that there is only ever one instance of.
+    /// This only exists for compatibility with .NET Framework.
+    /// </summary>
+    [Serializable]
+#if CORECLR
+    internal
+#else
+    public  // On CoreRT this must be public.
+#endif
+    sealed class UnitySerializationHolder : ISerializable, IObjectReference
+    {
+        internal const int NullUnity = 0x0002;
+        private readonly int _unityType;
+        private readonly string _data;
+
+        /// <summary>
+        /// A helper method that returns the SerializationInfo that a class utilizing 
+        /// UnitySerializationHelper should return from a call to GetObjectData. It contains
+        /// the unityType (defined above) and any optional data (used only for the reflection types).
+        /// </summary>
+        internal static void GetUnitySerializationInfo(SerializationInfo info, int unityType)
+        {
+            info.SetType(typeof(UnitySerializationHolder));
+            info.AddValue("Data", null, typeof(string));
+            info.AddValue("UnityType", unityType);
+            info.AddValue("AssemblyName", string.Empty);
+        }
+
+        public UnitySerializationHolder(SerializationInfo info, StreamingContext context)
+        {
+            if (info == null)
+            {
+                throw new ArgumentNullException(nameof(info));
+            }
+
+            // We are ignoring any other serialization input as we are only concerned about DBNull.
+            // We also store data and use it for erorr logging.
+            _unityType = info.GetInt32("UnityType");
+            _data = info.GetString("Data");
+        }
+
+        public void GetObjectData(SerializationInfo info, StreamingContext context) =>
+            throw new NotSupportedException(SR.NotSupported_UnitySerHolder);
+
+        public object GetRealObject(StreamingContext context)
+        {
+            // We are only support deserializing DBNull and throwing for everything else.
+            if (_unityType != NullUnity)
+            {
+                throw new ArgumentException(SR.Format(SR.Argument_InvalidUnity, _data ?? "UnityType"));
+            }
+
+            // We are always returning the same DBNull instance.
+            return DBNull.Value;
+        }
+    }
+}