Add project files.

Compat.Private.Serialization/Compat/Runtime/Serialization/DataMember.cs

@@ -0,0 +1,295 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+namespace Compat.Runtime.Serialization
+{
+    internal class DataMember
+    {
+        private readonly CriticalHelper helper;
+
+        internal DataMember()
+        {
+            helper = new CriticalHelper();
+        }
+
+        internal DataMember(MemberInfo memberInfo)
+        {
+            helper = new CriticalHelper(memberInfo);
+        }
+
+        internal DataMember(string name)
+        {
+            helper = new CriticalHelper(name);
+        }
+
+        internal DataMember(DataContract memberTypeContract, string name, bool isNullable, bool isRequired, bool emitDefaultValue, int order)
+        {
+            helper = new CriticalHelper(memberTypeContract, name, isNullable, isRequired, emitDefaultValue, order);
+        }
+
+        internal MemberInfo MemberInfo => helper.MemberInfo;
+
+        internal string Name
+        {
+            get => helper.Name;
+            set => helper.Name = value;
+        }
+
+        internal int Order
+        {
+            get => helper.Order;
+            set => helper.Order = value;
+        }
+
+        internal bool IsRequired
+        {
+            get => helper.IsRequired;
+            set => helper.IsRequired = value;
+        }
+
+        internal bool EmitDefaultValue
+        {
+            get => helper.EmitDefaultValue;
+            set => helper.EmitDefaultValue = value;
+        }
+
+        internal bool IsNullable
+        {
+            get => helper.IsNullable;
+            set => helper.IsNullable = value;
+        }
+
+        internal bool IsGetOnlyCollection
+        {
+            get => helper.IsGetOnlyCollection;
+            set => helper.IsGetOnlyCollection = value;
+        }
+
+        internal Type MemberType => helper.MemberType;
+
+        internal DataContract MemberTypeContract
+        {
+            get => helper.MemberTypeContract;
+            set => helper.MemberTypeContract = value;
+        }
+
+        internal bool HasConflictingNameAndType
+        {
+            get => helper.HasConflictingNameAndType;
+            set => helper.HasConflictingNameAndType = value;
+        }
+
+        internal DataMember ConflictingMember
+        {
+            get => helper.ConflictingMember;
+            set => helper.ConflictingMember = value;
+        }
+
+        private class CriticalHelper
+        {
+            private DataContract memberTypeContract;
+            private string name;
+            private int order;
+            private bool isRequired;
+            private bool emitDefaultValue;
+            private bool isNullable;
+            private bool isGetOnlyCollection = false;
+            private readonly MemberInfo memberInfo;
+            private bool hasConflictingNameAndType;
+            private DataMember conflictingMember;
+
+            internal CriticalHelper()
+            {
+                emitDefaultValue = Globals.DefaultEmitDefaultValue;
+            }
+
+            internal CriticalHelper(MemberInfo memberInfo)
+            {
+                emitDefaultValue = Globals.DefaultEmitDefaultValue;
+                this.memberInfo = memberInfo;
+            }
+
+            internal CriticalHelper(string name)
+            {
+                Name = name;
+            }
+
+            internal CriticalHelper(DataContract memberTypeContract, string name, bool isNullable, bool isRequired, bool emitDefaultValue, int order)
+            {
+                MemberTypeContract = memberTypeContract;
+                Name = name;
+                IsNullable = isNullable;
+                IsRequired = isRequired;
+                EmitDefaultValue = emitDefaultValue;
+                Order = order;
+            }
+
+            internal MemberInfo MemberInfo => memberInfo;
+
+            internal string Name
+            {
+                get => name;
+                set => name = value;
+            }
+
+            internal int Order
+            {
+                get => order;
+                set => order = value;
+            }
+
+            internal bool IsRequired
+            {
+                get => isRequired;
+                set => isRequired = value;
+            }
+
+            internal bool EmitDefaultValue
+            {
+                get => emitDefaultValue;
+                set => emitDefaultValue = value;
+            }
+
+            internal bool IsNullable
+            {
+                get => isNullable;
+                set => isNullable = value;
+            }
+
+            internal bool IsGetOnlyCollection
+            {
+                get => isGetOnlyCollection;
+                set => isGetOnlyCollection = value;
+            }
+
+            internal Type MemberType
+            {
+                get
+                {
+                    FieldInfo field = MemberInfo as FieldInfo;
+                    if (field != null)
+                    {
+                        return field.FieldType;
+                    }
+
+                    return ((PropertyInfo)MemberInfo).PropertyType;
+                }
+            }
+
+            internal DataContract MemberTypeContract
+            {
+                get
+                {
+                    if (memberTypeContract == null)
+                    {
+                        if (MemberInfo != null)
+                        {
+                            if (IsGetOnlyCollection)
+                            {
+                                memberTypeContract = DataContract.GetGetOnlyCollectionDataContract(DataContract.GetId(MemberType.TypeHandle), MemberType.TypeHandle, MemberType, SerializationMode.SharedContract);
+                            }
+                            else
+                            {
+                                memberTypeContract = DataContract.GetDataContract(MemberType);
+                            }
+                        }
+                    }
+                    return memberTypeContract;
+                }
+                set => memberTypeContract = value;
+            }
+
+            internal bool HasConflictingNameAndType
+            {
+                get => hasConflictingNameAndType;
+                set => hasConflictingNameAndType = value;
+            }
+
+            internal DataMember ConflictingMember
+            {
+                get => conflictingMember;
+                set => conflictingMember = value;
+            }
+        }
+
+        internal bool RequiresMemberAccessForGet()
+        {
+            MemberInfo memberInfo = MemberInfo;
+            FieldInfo field = memberInfo as FieldInfo;
+            if (field != null)
+            {
+                return DataContract.FieldRequiresMemberAccess(field);
+            }
+            else
+            {
+                PropertyInfo property = (PropertyInfo)memberInfo;
+                MethodInfo getMethod = property.GetGetMethod(true /*nonPublic*/);
+                if (getMethod != null)
+                {
+                    return DataContract.MethodRequiresMemberAccess(getMethod) || !DataContract.IsTypeVisible(property.PropertyType);
+                }
+            }
+            return false;
+        }
+
+        internal bool RequiresMemberAccessForSet()
+        {
+            MemberInfo memberInfo = MemberInfo;
+            FieldInfo field = memberInfo as FieldInfo;
+            if (field != null)
+            {
+                return DataContract.FieldRequiresMemberAccess(field);
+            }
+            else
+            {
+                PropertyInfo property = (PropertyInfo)memberInfo;
+                MethodInfo setMethod = property.GetSetMethod(true /*nonPublic*/);
+                if (setMethod != null)
+                {
+                    return DataContract.MethodRequiresMemberAccess(setMethod) || !DataContract.IsTypeVisible(property.PropertyType);
+                }
+            }
+            return false;
+        }
+
+        internal DataMember BindGenericParameters(DataContract[] paramContracts, Dictionary<DataContract, DataContract> boundContracts)
+        {
+            DataContract memberTypeContract = MemberTypeContract.BindGenericParameters(paramContracts, boundContracts);
+            DataMember boundDataMember = new DataMember(memberTypeContract,
+                Name,
+                !memberTypeContract.IsValueType,
+                IsRequired,
+                EmitDefaultValue,
+                Order);
+            return boundDataMember;
+        }
+
+        internal bool Equals(object other, Dictionary<DataContractPairKey, object> checkedContracts)
+        {
+            if ((object)this == other)
+            {
+                return true;
+            }
+
+            DataMember dataMember = other as DataMember;
+            if (dataMember != null)
+            {
+                // Note: comparison does not use Order hint since it influences element order but does not specify exact order
+                bool thisIsNullable = (MemberTypeContract == null) ? false : !MemberTypeContract.IsValueType;
+                bool dataMemberIsNullable = (dataMember.MemberTypeContract == null) ? false : !dataMember.MemberTypeContract.IsValueType;
+                return (Name == dataMember.Name
+                        && (IsNullable || thisIsNullable) == (dataMember.IsNullable || dataMemberIsNullable)
+                        && IsRequired == dataMember.IsRequired
+                        && EmitDefaultValue == dataMember.EmitDefaultValue
+                        && MemberTypeContract.Equals(dataMember.MemberTypeContract, checkedContracts));
+            }
+            return false;
+        }
+
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+    }
+}