◆ ClassDataContractCriticalHelper() [1/2]

System.Runtime.Serialization.ClassDataContract.ClassDataContractCriticalHelper.ClassDataContractCriticalHelper ( [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicProperties)] Type type )

inlinepackage

Definition at line 290 of file ClassDataContract.cs.

            : base(type)
        {
            XmlQualifiedName stableNameAndSetHasDataContract = GetStableNameAndSetHasDataContract(type);
            if (type == Globals.TypeOfDBNull)
            {
                base.StableName = stableNameAndSetHasDataContract;
                _members = new List<DataMember>();
                XmlDictionary xmlDictionary = new XmlDictionary(2);
                base.Name = xmlDictionary.Add(base.StableName.Name);
                base.Namespace = xmlDictionary.Add(base.StableName.Namespace);
                ContractNamespaces = (MemberNames = (MemberNamespaces = Array.Empty<XmlDictionaryString>()));
                EnsureMethodsImported();
                return;
            }
            Type type2 = type.BaseType;
            _isISerializable = Globals.TypeOfISerializable.IsAssignableFrom(type);
            SetIsNonAttributedType(type);
            if (_isISerializable)
            {
                if (HasDataContract)
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(System.SR.Format(System.SR.ISerializableCannotHaveDataContract, DataContract.GetClrTypeFullName(type))));
                }
                if (type2 != null && (!type2.IsSerializable || !Globals.TypeOfISerializable.IsAssignableFrom(type2)))
                {
                    type2 = null;
                }
            }
            SetKeyValuePairAdapterFlags(type);
            base.IsValueType = type.IsValueType;
            if (type2 != null && type2 != Globals.TypeOfObject && type2 != Globals.TypeOfValueType && type2 != Globals.TypeOfUri)
            {
                DataContract dataContract = DataContract.GetDataContract(type2);
                if (dataContract is CollectionDataContract)
                {
                    BaseContract = ((CollectionDataContract)dataContract).SharedTypeContract as ClassDataContract;
                }
                else
                {
                    BaseContract = dataContract as ClassDataContract;
                }
                if (BaseContract != null && BaseContract.IsNonAttributedType && !_isNonAttributedType)
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(System.SR.Format(System.SR.AttributedTypesCannotInheritFromNonAttributedSerializableTypes, DataContract.GetClrTypeFullName(type), DataContract.GetClrTypeFullName(type2))));
                }
            }
            else
            {
                BaseContract = null;
            }
            _hasExtensionData = Globals.TypeOfIExtensibleDataObject.IsAssignableFrom(type);
            if (_hasExtensionData && !HasDataContract && !IsNonAttributedType)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(System.SR.Format(System.SR.OnlyDataContractTypesCanHaveExtensionData, DataContract.GetClrTypeFullName(type))));
            }
            if (_isISerializable)
            {
                SetDataContractName(stableNameAndSetHasDataContract);
            }
            else
            {
                base.StableName = stableNameAndSetHasDataContract;
                ImportDataMembers();
                XmlDictionary xmlDictionary2 = new XmlDictionary(2 + Members.Count);
                base.Name = xmlDictionary2.Add(base.StableName.Name);
                base.Namespace = xmlDictionary2.Add(base.StableName.Namespace);
                int num = 0;
                int num2 = 0;
                if (BaseContract == null)
                {
                    MemberNames = new XmlDictionaryString[Members.Count];
                    MemberNamespaces = new XmlDictionaryString[Members.Count];
                    ContractNamespaces = new XmlDictionaryString[1];
                }
                else
                {
                    num = BaseContract.MemberNames.Length;
                    MemberNames = new XmlDictionaryString[Members.Count + num];
                    Array.Copy(BaseContract.MemberNames, MemberNames, num);
                    MemberNamespaces = new XmlDictionaryString[Members.Count + num];
                    Array.Copy(BaseContract.MemberNamespaces, MemberNamespaces, num);
                    num2 = BaseContract.ContractNamespaces.Length;
                    ContractNamespaces = new XmlDictionaryString[1 + num2];
                    Array.Copy(BaseContract.ContractNamespaces, ContractNamespaces, num2);
                }
                ContractNamespaces[num2] = base.Namespace;
                for (int i = 0; i < Members.Count; i++)
                {
                    MemberNames[i + num] = xmlDictionary2.Add(Members[i].Name);
                    MemberNamespaces[i + num] = base.Namespace;
                }
            }
            EnsureMethodsImported();
            _isScriptObject = IsNonAttributedType && Globals.TypeOfScriptObject_IsAssignableFrom(base.UnderlyingType);
        }

Referenced by System.Runtime.Serialization.ClassDataContract.ClassDataContractCriticalHelper.Clone().