Skip to content

Commit bc92c9b

Browse files
ngbrownngbrown
committed
Implement helpers to serialize system types in preparation for .NET Core. (fix)
1 parent ee88543 commit bc92c9b

7 files changed

+232
-81
lines changed

‎src/NHibernate/Util/AssemblyQualifiedTypeName.cs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -11,8 +11,8 @@ public class AssemblyQualifiedTypeName
1111

1212
public AssemblyQualifiedTypeName(string type, string assembly)
1313
{
14-
this._type = type ?? throw new ArgumentNullException(nameof(type));
15-
this._assembly = assembly;
14+
_type = type ?? throw new ArgumentNullException(nameof(type));
15+
_assembly = assembly;
1616
unchecked
1717
{
1818
_hashCode = (type.GetHashCode() * 397) ^ (assembly?.GetHashCode() ?? 0);

‎src/NHibernate/Util/SerializableConstructorInfo.cs‎

Lines changed: 51 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,8 @@
11
using System;
2-
using System.Globalization;
32
using System.Linq;
43
using System.Reflection;
54
using System.Runtime.Serialization;
5+
using System.Security;
66

77
namespace NHibernate.Util
88
{
@@ -27,35 +27,75 @@ public static SerializableConstructorInfo Wrap(ConstructorInfo constructorInfo)
2727
/// Creates a new <see cref="SerializableConstructorInfo"/>
2828
/// </summary>
2929
/// <param name="constructorInfo">The <see cref="ConstructorInfo"/> being wrapped for serialization.</param>
30-
public SerializableConstructorInfo(ConstructorInfo constructorInfo)
30+
private SerializableConstructorInfo(ConstructorInfo constructorInfo)
3131
{
32-
_constructorInfo = constructorInfo;
33-
if (constructorInfo != null && constructorInfo.DeclaringType == null)
32+
_constructorInfo = constructorInfo ?? throw new ArgumentNullException(nameof(constructorInfo));
33+
if (constructorInfo.DeclaringType == null)
3434
{
3535
throw new ArgumentException("ConstructorInfo must have non-null DeclaringType", nameof(constructorInfo));
3636
}
3737
}
3838

3939
private SerializableConstructorInfo(SerializationInfo info, StreamingContext context)
4040
{
41-
System.Type declaringType = info.GetValue<SerializableSystemType>("declaringType")?.GetType();
41+
System.Type declaringType = info.GetValue<SerializableSystemType>("declaringType").GetType();
4242
SerializableSystemType[] parameterSystemTypes = info.GetValue<SerializableSystemType[]>("parameterTypesHelper");
4343

44-
System.Type[] parameterTypes = parameterSystemTypes?.Select(x => x.GetType()).ToArray();
45-
this._constructorInfo = declaringType?.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, CallingConventions.Any, parameterTypes, null);
44+
System.Type[] parameterTypes = parameterSystemTypes?.Select(x => x.GetType()).ToArray() ?? new System.Type[0];
45+
_constructorInfo = declaringType.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, CallingConventions.Any, parameterTypes, null);
46+
47+
if (_constructorInfo == null) throw new MissingMethodException(declaringType.FullName, ".ctor");
4648
}
4749

50+
[SecurityCritical]
4851
public void GetObjectData(SerializationInfo info, StreamingContext context)
4952
{
5053
SerializableSystemType[] parameterSystemTypes =
51-
_constructorInfo?.GetParameters()
52-
.Select(x => new SerializableSystemType(x.ParameterType))
54+
_constructorInfo.GetParameters()
55+
.Select(x => SerializableSystemType.Wrap(x.ParameterType))
5356
.ToArray();
5457

55-
info.AddValueWithType("declaringType", SerializableSystemType.Wrap(_constructorInfo?.DeclaringType));
56-
info.AddValueWithType("parameterTypesHelper", parameterSystemTypes);
58+
info.AddValue("declaringType", SerializableSystemType.Wrap(_constructorInfo.DeclaringType));
59+
info.AddValue("parameterTypesHelper", parameterSystemTypes);
5760
}
5861

5962
public ConstructorInfo Value => _constructorInfo;
63+
64+
private bool Equals(SerializableConstructorInfo other)
65+
{
66+
return Equals(_constructorInfo, other._constructorInfo);
67+
}
68+
69+
public override bool Equals(object obj)
70+
{
71+
if (ReferenceEquals(null, obj)) return false;
72+
if (ReferenceEquals(this, obj)) return true;
73+
return obj is SerializableConstructorInfo && Equals((SerializableConstructorInfo) obj);
74+
}
75+
76+
public override int GetHashCode()
77+
{
78+
return (_constructorInfo != null ? _constructorInfo.GetHashCode() : 0);
79+
}
80+
81+
public static bool operator ==(SerializableConstructorInfo left, SerializableConstructorInfo right)
82+
{
83+
return Equals(left, right);
84+
}
85+
86+
public static bool operator !=(SerializableConstructorInfo left, SerializableConstructorInfo right)
87+
{
88+
return !Equals(left, right);
89+
}
90+
91+
public static implicit operator ConstructorInfo(SerializableConstructorInfo serializableConstructorInfo)
92+
{
93+
return serializableConstructorInfo?.Value;
94+
}
95+
96+
public static explicit operator SerializableConstructorInfo(ConstructorInfo constructorInfo)
97+
{
98+
return Wrap(constructorInfo);
99+
}
60100
}
61101
}

‎src/NHibernate/Util/SerializableFieldInfo.cs‎

Lines changed: 34 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
using System;
2-
using System.Globalization;
32
using System.Reflection;
43
using System.Runtime.Serialization;
4+
using System.Security;
55

66
namespace NHibernate.Util
77
{
@@ -26,31 +26,30 @@ public static SerializableFieldInfo Wrap(FieldInfo fieldInfo)
2626
/// Creates a new <see cref="SerializableFieldInfo"/>
2727
/// </summary>
2828
/// <param name="fieldInfo">The <see cref="FieldInfo"/> being wrapped for serialization.</param>
29-
public SerializableFieldInfo(FieldInfo fieldInfo)
29+
private SerializableFieldInfo(FieldInfo fieldInfo)
3030
{
31-
_fieldInfo = fieldInfo;
32-
if (fieldInfo != null)
33-
{
34-
if (fieldInfo.IsStatic) throw new ArgumentException("Only for instance fields", nameof(fieldInfo));
35-
if (fieldInfo.DeclaringType == null)
36-
throw new ArgumentException("FieldInfo must have non-null DeclaringType", nameof(fieldInfo));
37-
}
31+
_fieldInfo = fieldInfo ?? throw new ArgumentNullException(nameof(fieldInfo));
32+
if (fieldInfo.IsStatic) throw new ArgumentException("Only for instance fields", nameof(fieldInfo));
33+
if (fieldInfo.DeclaringType == null) throw new ArgumentException("FieldInfo must have non-null DeclaringType", nameof(fieldInfo));
3834
}
3935

4036
private SerializableFieldInfo(SerializationInfo info, StreamingContext context)
4137
{
42-
System.Type declaringType = info.GetValue<SerializableSystemType>("declaringType")?.GetType();
38+
System.Type declaringType = info.GetValue<SerializableSystemType>("declaringType").GetType();
4339
string fieldName = info.GetString("fieldName");
4440

45-
this._fieldInfo = declaringType?.GetField(
41+
_fieldInfo = declaringType.GetField(
4642
fieldName,
4743
BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
44+
45+
if (_fieldInfo == null) throw new MissingFieldException(declaringType.FullName, fieldName);
4846
}
4947

48+
[SecurityCritical]
5049
public void GetObjectData(SerializationInfo info, StreamingContext context)
5150
{
52-
info.AddValueWithType("declaringType", SerializableSystemType.Wrap(_fieldInfo?.DeclaringType));
53-
info.AddValue("fieldName", _fieldInfo?.Name);
51+
info.AddValue("declaringType", SerializableSystemType.Wrap(_fieldInfo.DeclaringType));
52+
info.AddValue("fieldName", _fieldInfo.Name);
5453
}
5554

5655
public FieldInfo Value => _fieldInfo;
@@ -64,14 +63,32 @@ public override bool Equals(object obj)
6463
{
6564
if (ReferenceEquals(null, obj)) return false;
6665
if (ReferenceEquals(this, obj)) return true;
67-
if (ReferenceEquals(this._fieldInfo, obj)) return true;
68-
if (obj is SerializableFieldInfo) return Equals((SerializableFieldInfo) obj);
69-
return (obj is FieldInfo) && this._fieldInfo.Equals(obj);
66+
return obj is SerializableFieldInfo && Equals((SerializableFieldInfo) obj);
7067
}
7168

7269
public override int GetHashCode()
7370
{
74-
return _fieldInfo.GetHashCode();
71+
return (_fieldInfo != null ? _fieldInfo.GetHashCode() : 0);
72+
}
73+
74+
public static bool operator ==(SerializableFieldInfo left, SerializableFieldInfo right)
75+
{
76+
return Equals(left, right);
77+
}
78+
79+
public static bool operator !=(SerializableFieldInfo left, SerializableFieldInfo right)
80+
{
81+
return !Equals(left, right);
82+
}
83+
84+
public static implicit operator FieldInfo(SerializableFieldInfo serializableFieldInfo)
85+
{
86+
return serializableFieldInfo?.Value;
87+
}
88+
89+
public static explicit operator SerializableFieldInfo(FieldInfo fieldInfo)
90+
{
91+
return Wrap(fieldInfo);
7592
}
7693
}
7794
}

‎src/NHibernate/Util/SerializableMethodInfo.cs‎

Lines changed: 39 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,8 @@
11
using System;
2-
using System.Collections.Generic;
3-
using System.Globalization;
42
using System.Linq;
53
using System.Reflection;
64
using System.Runtime.Serialization;
5+
using System.Security;
76

87
namespace NHibernate.Util
98
{
@@ -28,39 +27,38 @@ public static SerializableMethodInfo Wrap(MethodInfo methodInfo)
2827
/// Creates a new <see cref="SerializableMethodInfo"/>
2928
/// </summary>
3029
/// <param name="methodInfo">The <see cref="MethodInfo"/> being wrapped for serialization.</param>
31-
public SerializableMethodInfo(MethodInfo methodInfo)
30+
private SerializableMethodInfo(MethodInfo methodInfo)
3231
{
33-
_methodInfo = methodInfo;
34-
if (methodInfo != null)
35-
{
36-
if (methodInfo.IsStatic) throw new ArgumentException("Only for instance fields", nameof(methodInfo));
37-
if (methodInfo.DeclaringType == null) throw new ArgumentException("MethodInfo must have non-null DeclaringType", nameof(methodInfo));
38-
39-
}
32+
_methodInfo = methodInfo ?? throw new ArgumentNullException(nameof(methodInfo));
33+
if (methodInfo.IsStatic) throw new ArgumentException("Only for instance fields", nameof(methodInfo));
34+
if (methodInfo.DeclaringType == null) throw new ArgumentException("MethodInfo must have non-null DeclaringType", nameof(methodInfo));
4035
}
4136

4237
private SerializableMethodInfo(SerializationInfo info, StreamingContext context)
4338
{
44-
System.Type declaringType = info.GetValue<SerializableSystemType>("declaringType")?.GetType();
45-
string fieldName = info.GetString("methodName");
39+
System.Type declaringType = info.GetValue<SerializableSystemType>("declaringType").GetType();
40+
string methodName = info.GetString("methodName");
4641
SerializableSystemType[] parameterSystemTypes = info.GetValue<SerializableSystemType[]>("parameterTypesHelper");
4742

4843
System.Type[] parameterTypes = parameterSystemTypes?.Select(x => x.GetType()).ToArray() ?? new System.Type[0];
49-
this._methodInfo = declaringType?.GetMethod(
50-
fieldName,
44+
_methodInfo = declaringType.GetMethod(
45+
methodName,
5146
BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, parameterTypes, null);
47+
48+
if (_methodInfo == null) throw new MissingMethodException(declaringType.FullName, methodName);
5249
}
5350

51+
[SecurityCritical]
5452
public void GetObjectData(SerializationInfo info, StreamingContext context)
5553
{
5654
SerializableSystemType[] parameterSystemTypes =
57-
_methodInfo?.GetParameters()
58-
.Select(x => new SerializableSystemType(x.ParameterType))
55+
_methodInfo.GetParameters()
56+
.Select(x => SerializableSystemType.Wrap(x.ParameterType))
5957
.ToArray();
6058

61-
info.AddValueWithType("declaringType", SerializableSystemType.Wrap(_methodInfo?.DeclaringType));
62-
info.AddValue("methodName", _methodInfo?.Name);
63-
info.AddValueWithType("parameterTypesHelper", parameterSystemTypes);
59+
info.AddValue("declaringType", SerializableSystemType.Wrap(_methodInfo.DeclaringType));
60+
info.AddValue("methodName", _methodInfo.Name);
61+
info.AddValue("parameterTypesHelper", parameterSystemTypes);
6462
}
6563

6664
public MethodInfo Value => _methodInfo;
@@ -74,14 +72,32 @@ public override bool Equals(object obj)
7472
{
7573
if (ReferenceEquals(null, obj)) return false;
7674
if (ReferenceEquals(this, obj)) return true;
77-
if (ReferenceEquals(this._methodInfo, obj)) return true;
78-
if (obj is SerializableMethodInfo) return Equals((SerializableMethodInfo) obj);
79-
return (obj is MethodInfo) && this._methodInfo.Equals(obj);
75+
return obj is SerializableMethodInfo && Equals((SerializableMethodInfo) obj);
8076
}
8177

8278
public override int GetHashCode()
8379
{
84-
return _methodInfo.GetHashCode();
80+
return (_methodInfo != null ? _methodInfo.GetHashCode() : 0);
81+
}
82+
83+
public static bool operator ==(SerializableMethodInfo left, SerializableMethodInfo right)
84+
{
85+
return Equals(left, right);
86+
}
87+
88+
public static bool operator !=(SerializableMethodInfo left, SerializableMethodInfo right)
89+
{
90+
return !Equals(left, right);
91+
}
92+
93+
public static implicit operator MethodInfo(SerializableMethodInfo serializableMethodInfo)
94+
{
95+
return serializableMethodInfo?.Value;
96+
}
97+
98+
public static explicit operator SerializableMethodInfo(MethodInfo methodInfo)
99+
{
100+
return Wrap(methodInfo);
85101
}
86102
}
87103
}

‎src/NHibernate/Util/SerializablePropertyInfo.cs‎

Lines changed: 49 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
using System;
2-
using System.Globalization;
32
using System.Reflection;
43
using System.Runtime.Serialization;
4+
using System.Security;
55

66
namespace NHibernate.Util
77
{
@@ -26,33 +26,69 @@ public static SerializablePropertyInfo Wrap(PropertyInfo propertyInfo)
2626
/// Creates a new <see cref="SerializablePropertyInfo"/>
2727
/// </summary>
2828
/// <param name="propertyInfo">The <see cref="PropertyInfo"/> being wrapped for serialization.</param>
29-
public SerializablePropertyInfo(PropertyInfo propertyInfo)
29+
private SerializablePropertyInfo(PropertyInfo propertyInfo)
3030
{
31-
_propertyInfo = propertyInfo;
32-
if (propertyInfo != null)
33-
{
34-
if (propertyInfo.DeclaringType == null) throw new ArgumentException("PropertyInfo must have non-null DeclaringType", nameof(propertyInfo));
35-
if (propertyInfo.GetIndexParameters().Length > 0) throw new ArgumentException("PropertyInfo not supported with IndexParameters", nameof(propertyInfo));
36-
37-
}
31+
_propertyInfo = propertyInfo ?? throw new ArgumentNullException(nameof(propertyInfo));
32+
if (propertyInfo.DeclaringType == null) throw new ArgumentException("PropertyInfo must have non-null DeclaringType", nameof(propertyInfo));
33+
if (propertyInfo.GetIndexParameters().Length > 0) throw new ArgumentException("PropertyInfo not supported with IndexParameters", nameof(propertyInfo));
3834
}
3935

4036
private SerializablePropertyInfo(SerializationInfo info, StreamingContext context)
4137
{
42-
System.Type declaringType = info.GetValue<SerializableSystemType>("declaringType")?.GetType();
38+
System.Type declaringType = info.GetValue<SerializableSystemType>("declaringType").GetType();
4339
string propertyName = info.GetString("propertyName");
4440

45-
this._propertyInfo = declaringType?.GetProperty(
41+
_propertyInfo = declaringType.GetProperty(
4642
propertyName,
4743
BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
44+
45+
if (_propertyInfo == null) throw new MissingMethodException(declaringType.FullName, propertyName);
4846
}
4947

48+
[SecurityCritical]
5049
public void GetObjectData(SerializationInfo info, StreamingContext context)
5150
{
52-
info.AddValueWithType("declaringType", SerializableSystemType.Wrap(_propertyInfo?.DeclaringType));
53-
info.AddValue("propertyName", _propertyInfo?.Name);
51+
info.AddValue("declaringType", SerializableSystemType.Wrap(_propertyInfo.DeclaringType));
52+
info.AddValue("propertyName", _propertyInfo.Name);
5453
}
5554

5655
public PropertyInfo Value => _propertyInfo;
56+
57+
private bool Equals(SerializablePropertyInfo other)
58+
{
59+
return Equals(_propertyInfo, other._propertyInfo);
60+
}
61+
62+
public override bool Equals(object obj)
63+
{
64+
if (ReferenceEquals(null, obj)) return false;
65+
if (ReferenceEquals(this, obj)) return true;
66+
return obj is SerializablePropertyInfo && Equals((SerializablePropertyInfo) obj);
67+
}
68+
69+
public override int GetHashCode()
70+
{
71+
return (_propertyInfo != null ? _propertyInfo.GetHashCode() : 0);
72+
}
73+
74+
public static bool operator ==(SerializablePropertyInfo left, SerializablePropertyInfo right)
75+
{
76+
return Equals(left, right);
77+
}
78+
79+
public static bool operator !=(SerializablePropertyInfo left, SerializablePropertyInfo right)
80+
{
81+
return !Equals(left, right);
82+
}
83+
84+
public static implicit operator PropertyInfo(SerializablePropertyInfo serializablePropertyInfo)
85+
{
86+
return serializablePropertyInfo?.Value;
87+
}
88+
89+
public static explicit operator SerializablePropertyInfo(PropertyInfo propertyInfo)
90+
{
91+
return Wrap(propertyInfo);
92+
}
5793
}
5894
}

0 commit comments

Comments
 (0)