internal XmlMapping(LogicalType lType, XmlSerializationReflector reflector, bool isSoap) { System.Diagnostics.Debug.Assert(null != reflector, "The reflector parameter can not be null."); System.Diagnostics.Debug.Assert(null != lType, "The logicalType parameter can not be null."); serializationReflector = reflector; logicalType = lType; }
/// <summary> /// Constructs the XmlSerializer using the XmlTypeMapping parameter /// to initialize the logical type(reflection data) of the object /// that will be serialized/de-serialized. /// </summary> /// <param name="xmlMapping"></param> /// <remarks> /// The XmlTypeMapping parameter has already reflected over the type, /// we just pull the reflection data from the <see cref="XmlTypeMapping"/> object. /// </remarks> public XmlSerializer(XmlTypeMapping xmlMapping) { if (xmlMapping == null) { throw new ArgumentNullException("xmlMapping"); } _events.sender = this; _reflector = xmlMapping.Reflector; _logicalType = xmlMapping.LogicalType; _isEncoded = xmlMapping.IsSoap; if (true /* AppDomain.CompatVersion >= AppDomain.Orcas */) { _reflector.ReflectionDisabled = true; } }
public XmlReflectionImporter(XmlAttributeOverrides attributeOverrides, string defaultNamespace) { if (defaultNamespace == null) { defaultNamespace = String.Empty; } if (attributeOverrides == null) { attributeOverrides = new XmlAttributeOverrides(); } _attributeOverrides = attributeOverrides; _defaultNs = defaultNamespace; _defaultNs = defaultNamespace; _attributeOverrides = attributeOverrides; _serializationReflector = new XmlSerializationReflector(_attributeOverrides, _defaultNs); }
internal XmlMapping(LogicalType lType, XmlSerializationReflector reflector) : this(lType, reflector, false) { }
internal XmlTypeMapping(LogicalType logicalType, XmlSerializationReflector reflector) : base(logicalType, reflector) { }
/// <summary> /// Constructs the XmlSerializer, reflecting over the given /// types and any types that are statically referenced from them. /// Reflection overrides may be given. /// </summary> /// <param name="extraTypes">The additional types the serializer should be /// prepared to encounter during serialization of the primary <paramref name="type"/>.</param> /// <param name="defaultNamespace">The default namespace to use for all the XML elements.</param> public XmlSerializer(Type type, XmlAttributeOverrides overrides, Type[] extraTypes, XmlRootAttribute root, string defaultNamespace) { if (type == null) { throw new ArgumentNullException("type"); } if (defaultNamespace == null) { defaultNamespace = ""; } _events.sender = this; _isEncoded = false; if (root != null) { if (overrides == null) { overrides = new XmlAttributeOverrides(); } // If we're dealing with a nullable type, we need to set the override // on the generic type argument as well. System.Collections.Generic.List <Type> typesToOverride = new System.Collections.Generic.List <Type>(2); typesToOverride.Add(type); if (type.GetTypeInfo().IsGenericType&& type.GetGenericTypeDefinition() == typeof(Nullable <>)) { Type[] args = type.GetGenericArguments(); if (args.Length > 0) { // just in case they passed in typeof(Nullable<>) with no generic arg typesToOverride.Add(args[0]); } } foreach (Type t in typesToOverride) { XmlAttributes attrs = overrides[t]; if (attrs != null) { attrs.XmlRoot = root; } else { attrs = new XmlAttributes(); attrs.XmlRoot = root; // Preserve any XmlType that may be declared on the type itself, // since by providing this XmlRoot override, we prevent any declared // XmlTypeAttribute from being reflected. object[] declaredAttributes = t.GetTypeInfo().GetCustomAttributes(typeof(XmlTypeAttribute), false).ToArray(); if (declaredAttributes.Length > 0) { // The user shouldn't have more than one defined, but just in case he does, // we read the last reflected one, to emulate the behavior of the // TypeAttributes class. attrs.XmlType = (XmlTypeAttribute)declaredAttributes[declaredAttributes.Length - 1]; } overrides.Add(t, attrs); } } } _defaultNamespace = defaultNamespace; _reflector = new XmlSerializationReflector(overrides, defaultNamespace); // Reflect over the main type. Never search over intrinsics so we get a // LogicalType with a RootAccessor whose Namespace property reflects the defaultNamespace. // In fact, any type's RootAccessor.Namespace may not be set correctly given // the defaultNamespace if it was reflected over previously. But since this // is the very first request we make of the m_Reflector, we're going to get // the right one. And this is the only place where that is important. _logicalType = _reflector.FindTypeForRoot(type, _isEncoded, defaultNamespace); // Reflect over the extra types if (extraTypes != null && extraTypes.Length > 0) { _extraTypes = new LogicalType[extraTypes.Length]; for (int typeNDX = 0; typeNDX < extraTypes.Length; ++typeNDX) { _extraTypes[typeNDX] = findTypeByType(extraTypes[typeNDX], defaultNamespace); } } // Reflect over the included types _reflector.ReflectIncludedTypes(); if (true /* AppDomain.CompatVersion >= AppDomain.Orcas */) { _reflector.ReflectionDisabled = true; } }