Implement helpers to serialize system types in preparation for .NET Core. (fix)

ngbrown · ngbrown · commit 3e9c9b6664be · 2017-12-03T20:06:29.000-07:00
diff --git a/src/NHibernate/Util/AssemblyQualifiedTypeName.cs b/src/NHibernate/Util/AssemblyQualifiedTypeName.cs
@@ -11,8 +11,8 @@ public class AssemblyQualifiedTypeName
 
 		public AssemblyQualifiedTypeName(string type, string assembly)
 		{
-			this._type = type ?? throw new ArgumentNullException(nameof(type));
-			this._assembly = assembly;
+			_type = type ?? throw new ArgumentNullException(nameof(type));
+			_assembly = assembly;
 			unchecked
 			{
 				_hashCode = (type.GetHashCode() * 397) ^ (assembly?.GetHashCode() ?? 0);
diff --git a/src/NHibernate/Util/SerializableConstructorInfo.cs b/src/NHibernate/Util/SerializableConstructorInfo.cs
@@ -1,8 +1,8 @@
 ﻿using System;
-using System.Globalization;
 using System.Linq;
 using System.Reflection;
 using System.Runtime.Serialization;
+using System.Security;
 
 namespace NHibernate.Util
 {
@@ -27,7 +27,7 @@ public static SerializableConstructorInfo Wrap(ConstructorInfo constructorInfo)
 		/// Creates a new <see cref="SerializableConstructorInfo"/>
 		/// </summary>
 		/// <param name="constructorInfo">The <see cref="ConstructorInfo"/> being wrapped for serialization.</param>
-		public SerializableConstructorInfo(ConstructorInfo constructorInfo)
+		private SerializableConstructorInfo(ConstructorInfo constructorInfo)
 		{
 			_constructorInfo = constructorInfo;
 			if (constructorInfo != null && constructorInfo.DeclaringType == null)
@@ -42,18 +42,19 @@ private SerializableConstructorInfo(SerializationInfo info, StreamingContext con
 			SerializableSystemType[] parameterSystemTypes = info.GetValue<SerializableSystemType[]>("parameterTypesHelper");
 
 			System.Type[] parameterTypes = parameterSystemTypes?.Select(x => x.GetType()).ToArray();
-			this._constructorInfo = declaringType?.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, CallingConventions.Any, parameterTypes, null);
+			_constructorInfo = declaringType?.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, CallingConventions.Any, parameterTypes, null);
 		}
 
+		[SecurityCritical]
 		public void GetObjectData(SerializationInfo info, StreamingContext context)
 		{
 			SerializableSystemType[] parameterSystemTypes =
 				_constructorInfo?.GetParameters()
-				                .Select(x => new SerializableSystemType(x.ParameterType))
+				                .Select(x => SerializableSystemType.Wrap(x.ParameterType))
 				                .ToArray();
 
-			info.AddValueWithType("declaringType", SerializableSystemType.Wrap(_constructorInfo?.DeclaringType));
-			info.AddValueWithType("parameterTypesHelper", parameterSystemTypes);
+			info.AddValue("declaringType", SerializableSystemType.Wrap(_constructorInfo?.DeclaringType));
+			info.AddValue("parameterTypesHelper", parameterSystemTypes);
 		}
 
 		public ConstructorInfo Value => _constructorInfo;
diff --git a/src/NHibernate/Util/SerializableFieldInfo.cs b/src/NHibernate/Util/SerializableFieldInfo.cs
@@ -1,7 +1,7 @@
 ﻿using System;
-using System.Globalization;
 using System.Reflection;
 using System.Runtime.Serialization;
+using System.Security;
 
 namespace NHibernate.Util
 {
@@ -26,7 +26,7 @@ public static SerializableFieldInfo Wrap(FieldInfo fieldInfo)
 		/// Creates a new <see cref="SerializableFieldInfo"/>
 		/// </summary>
 		/// <param name="fieldInfo">The <see cref="FieldInfo"/> being wrapped for serialization.</param>
-		public SerializableFieldInfo(FieldInfo fieldInfo)
+		private SerializableFieldInfo(FieldInfo fieldInfo)
 		{
 			_fieldInfo = fieldInfo;
 			if (fieldInfo != null)
@@ -42,36 +42,18 @@ private SerializableFieldInfo(SerializationInfo info, StreamingContext context)
 			System.Type declaringType = info.GetValue<SerializableSystemType>("declaringType")?.GetType();
 			string fieldName = info.GetString("fieldName");
 
-			this._fieldInfo = declaringType?.GetField(
+			_fieldInfo = declaringType?.GetField(
 				fieldName,
 				BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
 		}
 
+		[SecurityCritical]
 		public void GetObjectData(SerializationInfo info, StreamingContext context)
 		{
-			info.AddValueWithType("declaringType", SerializableSystemType.Wrap(_fieldInfo?.DeclaringType));
+			info.AddValue("declaringType", SerializableSystemType.Wrap(_fieldInfo?.DeclaringType));
 			info.AddValue("fieldName", _fieldInfo?.Name);
 		}
 
 		public FieldInfo Value => _fieldInfo;
-
-		private bool Equals(SerializableFieldInfo other)
-		{
-			return Equals(_fieldInfo, other._fieldInfo);
-		}
-
-		public override bool Equals(object obj)
-		{
-			if (ReferenceEquals(null, obj)) return false;
-			if (ReferenceEquals(this, obj)) return true;
-			if (ReferenceEquals(this._fieldInfo, obj)) return true;
-			if (obj is SerializableFieldInfo) return Equals((SerializableFieldInfo) obj);
-			return (obj is FieldInfo) && this._fieldInfo.Equals(obj);
-		}
-
-		public override int GetHashCode()
-		{
-			return _fieldInfo.GetHashCode();
-		}
 	}
 }
diff --git a/src/NHibernate/Util/SerializableMethodInfo.cs b/src/NHibernate/Util/SerializableMethodInfo.cs
@@ -1,9 +1,8 @@
 ﻿using System;
-using System.Collections.Generic;
-using System.Globalization;
 using System.Linq;
 using System.Reflection;
 using System.Runtime.Serialization;
+using System.Security;
 
 namespace NHibernate.Util
 {
@@ -28,7 +27,7 @@ public static SerializableMethodInfo Wrap(MethodInfo methodInfo)
 		/// Creates a new <see cref="SerializableMethodInfo"/>
 		/// </summary>
 		/// <param name="methodInfo">The <see cref="MethodInfo"/> being wrapped for serialization.</param>
-		public SerializableMethodInfo(MethodInfo methodInfo)
+		private SerializableMethodInfo(MethodInfo methodInfo)
 		{
 			_methodInfo = methodInfo;
 			if (methodInfo != null)
@@ -46,42 +45,24 @@ private SerializableMethodInfo(SerializationInfo info, StreamingContext context)
 			SerializableSystemType[] parameterSystemTypes = info.GetValue<SerializableSystemType[]>("parameterTypesHelper");
 
 			System.Type[] parameterTypes = parameterSystemTypes?.Select(x => x.GetType()).ToArray() ?? new System.Type[0];
-			this._methodInfo = declaringType?.GetMethod(
+			_methodInfo = declaringType?.GetMethod(
 				fieldName,
 				BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, parameterTypes, null);
 		}
 
+		[SecurityCritical]
 		public void GetObjectData(SerializationInfo info, StreamingContext context)
 		{
 			SerializableSystemType[] parameterSystemTypes =
 				_methodInfo?.GetParameters()
-				           .Select(x => new SerializableSystemType(x.ParameterType))
+				           .Select(x => SerializableSystemType.Wrap(x.ParameterType))
 				           .ToArray();
 
-			info.AddValueWithType("declaringType", SerializableSystemType.Wrap(_methodInfo?.DeclaringType));
+			info.AddValue("declaringType", SerializableSystemType.Wrap(_methodInfo?.DeclaringType));
 			info.AddValue("methodName", _methodInfo?.Name);
-			info.AddValueWithType("parameterTypesHelper", parameterSystemTypes);
+			info.AddValue("parameterTypesHelper", parameterSystemTypes);
 		}
 
 		public MethodInfo Value => _methodInfo;
-
-		private bool Equals(SerializableMethodInfo other)
-		{
-			return Equals(_methodInfo, other._methodInfo);
-		}
-
-		public override bool Equals(object obj)
-		{
-			if (ReferenceEquals(null, obj)) return false;
-			if (ReferenceEquals(this, obj)) return true;
-			if (ReferenceEquals(this._methodInfo, obj)) return true;
-			if (obj is SerializableMethodInfo) return Equals((SerializableMethodInfo) obj);
-			return (obj is MethodInfo) && this._methodInfo.Equals(obj);
-		}
-
-		public override int GetHashCode()
-		{
-			return _methodInfo.GetHashCode();
-		}
 	}
 }
diff --git a/src/NHibernate/Util/SerializablePropertyInfo.cs b/src/NHibernate/Util/SerializablePropertyInfo.cs
@@ -1,7 +1,7 @@
 ﻿using System;
-using System.Globalization;
 using System.Reflection;
 using System.Runtime.Serialization;
+using System.Security;
 
 namespace NHibernate.Util
 {
@@ -26,7 +26,7 @@ public static SerializablePropertyInfo Wrap(PropertyInfo propertyInfo)
 		/// Creates a new <see cref="SerializablePropertyInfo"/>
 		/// </summary>
 		/// <param name="propertyInfo">The <see cref="PropertyInfo"/> being wrapped for serialization.</param>
-		public SerializablePropertyInfo(PropertyInfo propertyInfo)
+		private SerializablePropertyInfo(PropertyInfo propertyInfo)
 		{
 			_propertyInfo = propertyInfo;
 			if (propertyInfo != null)
@@ -42,14 +42,15 @@ private SerializablePropertyInfo(SerializationInfo info, StreamingContext contex
 			System.Type declaringType = info.GetValue<SerializableSystemType>("declaringType")?.GetType();
 			string propertyName = info.GetString("propertyName");
 
-			this._propertyInfo = declaringType?.GetProperty(
+			_propertyInfo = declaringType?.GetProperty(
 				propertyName,
 				BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
 		}
 
+		[SecurityCritical]
 		public void GetObjectData(SerializationInfo info, StreamingContext context)
 		{
-			info.AddValueWithType("declaringType", SerializableSystemType.Wrap(_propertyInfo?.DeclaringType));
+			info.AddValue("declaringType", SerializableSystemType.Wrap(_propertyInfo?.DeclaringType));
 			info.AddValue("propertyName", _propertyInfo?.Name);
 		}
 
diff --git a/src/NHibernate/Util/SerializableSystemType.cs b/src/NHibernate/Util/SerializableSystemType.cs
@@ -1,5 +1,6 @@
 ﻿using System;
 using System.Runtime.Serialization;
+using System.Security;
 
 namespace NHibernate.Util
 {
@@ -26,7 +27,7 @@ public static SerializableSystemType Wrap(System.Type type)
 		/// Creates a new <see cref="SerializableSystemType"/>
 		/// </summary>
 		/// <param name="type">The <see cref="System.Type"/> being wrapped for serialization.</param>
-		public SerializableSystemType(System.Type type)
+		private SerializableSystemType(System.Type type)
 		{
 			_type = type;
 		}
@@ -52,10 +53,11 @@ private SerializableSystemType(SerializationInfo info, StreamingContext context)
 
 		public string AssemblyQualifiedName => _typeName?.ToString() ?? _type?.AssemblyQualifiedName;
 
+		[SecurityCritical]
 		public void GetObjectData(SerializationInfo info, StreamingContext context)
 		{
 			AssemblyQualifiedTypeName typeName = _typeName ?? ((_type == null) ? null : TypeNameParser.Parse(_type.AssemblyQualifiedName));
-			info.AddValueWithType("typeName", typeName);
+			info.AddValue("typeName", typeName);
 		}
 	}
 }
diff --git a/src/NHibernate/Util/SerializationInfoExtensions.cs b/src/NHibernate/Util/SerializationInfoExtensions.cs
@@ -10,10 +10,5 @@ public static T GetValue<T>(this SerializationInfo info, string name)
 			if (info == null) throw new ArgumentNullException(nameof(info));
 			return (T) info.GetValue(name, typeof(T));
 		}
-
-		public static void AddValueWithType<T>(this SerializationInfo info, string name, T value)
-		{
-			info.AddValue(name, value, typeof(T));
-		}
 	}
-}
+}

Original file line number	Diff line number	Diff line change
`@@ -11,8 +11,8 @@ public class AssemblyQualifiedTypeName`
`11`	`11`
`12`	`12`	`public AssemblyQualifiedTypeName(string type, string assembly)`
`13`	`13`	`{`
`14`		`- this._type = type ?? throw new ArgumentNullException(nameof(type));`
`15`		`- this._assembly = assembly;`
	`14`	`+ _type = type ?? throw new ArgumentNullException(nameof(type));`
	`15`	`+ _assembly = assembly;`
`16`	`16`	`unchecked`
`17`	`17`	`{`
`18`	`18`	`_hashCode = (type.GetHashCode() * 397) ^ (assembly?.GetHashCode() ?? 0);`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Runtime.Serialization;`
	`3`	`+using System.Security;`
`3`	`4`
`4`	`5`	`namespace NHibernate.Util`
`5`	`6`	`{`
`@@ -26,7 +27,7 @@ public static SerializableSystemType Wrap(System.Type type)`
`26`	`27`	`/// Creates a new <see cref="SerializableSystemType"/>`
`27`	`28`	`/// </summary>`
`28`	`29`	`/// <param name="type">The <see cref="System.Type"/> being wrapped for serialization.</param>`
`29`		`- public SerializableSystemType(System.Type type)`
	`30`	`+ private SerializableSystemType(System.Type type)`
`30`	`31`	`{`
`31`	`32`	`_type = type;`
`32`	`33`	`}`
`@@ -52,10 +53,11 @@ private SerializableSystemType(SerializationInfo info, StreamingContext context)`
`52`	`53`
`53`	`54`	`public string AssemblyQualifiedName => _typeName?.ToString() ?? _type?.AssemblyQualifiedName;`
`54`	`55`
	`56`	`+ [SecurityCritical]`
`55`	`57`	`public void GetObjectData(SerializationInfo info, StreamingContext context)`
`56`	`58`	`{`
`57`	`59`	`AssemblyQualifiedTypeName typeName = _typeName ?? ((_type == null) ? null : TypeNameParser.Parse(_type.AssemblyQualifiedName));`
`58`		`- info.AddValueWithType("typeName", typeName);`
	`60`	`+ info.AddValue("typeName", typeName);`
`59`	`61`	`}`
`60`	`62`	`}`
`61`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,10 +10,5 @@ public static T GetValue<T>(this SerializationInfo info, string name)`
`10`	`10`	`if (info == null) throw new ArgumentNullException(nameof(info));`
`11`	`11`	`return (T) info.GetValue(name, typeof(T));`
`12`	`12`	`}`
`13`		`-`
`14`		`- public static void AddValueWithType<T>(this SerializationInfo info, string name, T value)`
`15`		`- {`
`16`		`- info.AddValue(name, value, typeof(T));`
`17`		`- }`
`18`	`13`	`}`
`19`		`-}`
	`14`	`+}`