コード例 #1
0
		public ListTypeSerializer(SerializationMemberInfo memberInfo, TypeSerializerCache cache, SerializerOptions options)
			: base(memberInfo, memberInfo.ReturnType, cache, options)
		{
			typeToItemMap = new Dictionary<Type, ListItem>();
			aliasToItemMap = new Dictionary<string, ListItem>();

			var attribute = (XmlListElementDynamicTypeProviderAttribute)memberInfo.GetFirstApplicableAttribute(typeof(XmlListElementDynamicTypeProviderAttribute));

			if (attribute != null)
			{
				if (dynamicTypeResolver == null)
				{
					try
					{
						dynamicTypeResolver  = (IXmlListElementDynamicTypeProvider)Activator.CreateInstance(attribute.ProviderType, new object[0]);
					}
					catch (Exception)
					{
					}
				}

				if (dynamicTypeResolver == null)
				{
					dynamicTypeResolver = (IXmlListElementDynamicTypeProvider)Activator.CreateInstance(attribute.ProviderType, new object[] {memberInfo, cache, options});
				}
			}

			serializationMemberInfo = memberInfo;

			this.cache = cache;

			Scan(memberInfo, cache, options);
		}
コード例 #2
0
        public ListTypeSerializer(SerializationMemberInfo memberInfo, TypeSerializerCache cache, SerializerOptions options)
        {
            m_TypeToItemMap  = new Hashtable(CaseInsensitiveHashCodeProvider.Default, CaseInsensitiveComparer.Default);
            m_AliasToItemMap = new Hashtable(CaseInsensitiveHashCodeProvider.Default, CaseInsensitiveComparer.Default);

            Scan(memberInfo, cache, options);
        }
コード例 #3
0
        public DictionaryTypeSerializer(SerializationMemberInfo memberInfo, TypeSerializerCache cache, SerializerOptions options)
            : base(memberInfo, memberInfo.ReturnType, cache, options)
        {
            typeToItemMap  = new Dictionary <Type, DictionaryItem>();
            aliasToItemMap = new Dictionary <string, DictionaryItem>();

            Scan(memberInfo, cache, options);
        }
コード例 #4
0
        public EnumTypeSerializer(SerializationMemberInfo memberInfo, TypeSerializerCache cache, SerializerOptions options)
        {
            m_Type = memberInfo.LogicalType;

            if (!typeof(Enum).IsAssignableFrom(m_Type))
            {
                throw new ArgumentException(this.GetType().Name + " only works with Enum types");
            }
        }
コード例 #5
0
        public SerializationMemberInfo(MemberInfo memberInfo, SerializerOptions options, TypeSerializerCache cache, bool includeIfUnattributed)
        {
            typeSerializerCache = cache;
            this.memberInfo     = memberInfo;

            this.includeIfUnattributed = includeIfUnattributed;

            Scan(options, includeIfUnattributed);
        }
コード例 #6
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="memberInfo"></param>
        /// <param name="cache"></param>
        /// <param name="options"></param>
        public DateTimeTypeSerializer(SerializationMemberInfo memberInfo, TypeSerializerCache cache, SerializerOptions options)
        {
            m_FormatAttribute = (XmlDateTimeFormatAttribute)memberInfo.GetFirstApplicableAttribute(typeof(XmlDateTimeFormatAttribute));

            if (m_FormatAttribute == null)
            {
                m_FormatAttribute = new XmlDateTimeFormatAttribute("G");
                m_FormatSpecified = false;
            }
        }
コード例 #7
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="type"></param>
        /// <param name="cache"></param>
        /// <param name="options"></param>
        public ComplexTypeTypeSerializer(Type type, TypeSerializerCache cache, SerializerOptions options)
        {
            m_Type = type;

            m_ElementMembersMap   = new Hashtable(0x10);
            m_AttributeMembersMap = new Hashtable(0x10);

            cache.Add(this);

            Scan(cache, options);
        }
コード例 #8
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="type"></param>
        /// <param name="cache"></param>
        /// <param name="options"></param>
        public AnyTypeTypeSerializer(Type type, TypeSerializerCache cache, SerializerOptions options)
        {
            m_Type = type;

            m_ElementMembersMap   = new SortedList(0x10);
            m_AttributeMembersMap = new SortedList(0x10);

            cache.Add(this);

            Scan(cache, options);
        }
コード例 #9
0
ファイル: XmlSerializer.cs プロジェクト: samcook/Platform
        /// <summary>
        /// Constructs a new XmlSerializer supporting type <see cref="type"/> with the provided options
        /// </summary>
        /// <param name="options">The options</param>
        internal XmlSerializer(Type type, SerializerOptions options)
        {
            this.Options = options;

            var factory = new StandardTypeSerializerFactory(options);

            var cache = new TypeSerializerCache(factory);

            rootMemberInfo = new SerializationMemberInfo(type, options, cache);

            if (!rootMemberInfo.Serializable)
            {
                throw new XmlSerializerException("Unable to serialize given type, type must have [XmlElement] attribute.");
            }
        }
コード例 #10
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="cache"></param>
        /// <param name="options"></param>
        private void Scan(TypeSerializerCache cache, SerializerOptions options)
        {
            Type type;

            FieldInfo[]    fields;
            PropertyInfo[] properties;

            type = m_Type;

            while (type != typeof(object) && type != null)
            {
                fields     = m_Type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
                properties = m_Type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);

                foreach (FieldInfo field in fields)
                {
                    AddMember(field, cache, options);
                }

                foreach (PropertyInfo property in properties)
                {
                    AddMember(property, cache, options);
                }

                object[] attribs;
                bool     serializeBase = true;

                attribs = type.GetCustomAttributes(typeof(XmlSerializeBaseAttribute), false);

                foreach (XmlSerializeBaseAttribute attrib in attribs)
                {
                    if (attrib.Applies(options))
                    {
                        if (attrib.SerializeBase)
                        {
                            serializeBase = true;
                        }
                    }
                }

                if (!serializeBase)
                {
                    break;
                }

                type = type.BaseType;
            }
        }
コード例 #11
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="memberInfo"></param>
        /// <param name="cache"></param>
        /// <param name="options"></param>
        private void AddMember(MemberInfo memberInfo, TypeSerializerCache cache, SerializerOptions options)
        {
            SerializationMemberInfo serializationMemberInfo;

            serializationMemberInfo = new SerializationMemberInfo(memberInfo, options, cache);

            if (serializationMemberInfo.SerializedNodeType == XmlNodeType.Element)
            {
                m_ElementMembersMap[serializationMemberInfo.GetSerializedName()] = new LightSerializationMember(serializationMemberInfo);

                return;
            }
            else if (serializationMemberInfo.SerializedNodeType == XmlNodeType.Attribute)
            {
                if (!(serializationMemberInfo.Serializer is TypeSerializerWithSimpleTextSupport))
                {
                    throw new InvalidOperationException("Serializer for member doesn't support serializing to an attribute.");
                }

                m_AttributeMembersMap[serializationMemberInfo.GetSerializedName()] = new LightSerializationMember(serializationMemberInfo);
            }
        }
コード例 #12
0
        /// <summary>
        /// Scan the tyoe for properties and fields to serialize.
        /// </summary>
        /// <param name="cache"></param>
        /// <param name="options"></param>
        protected virtual void Scan(TypeSerializerCache cache, SerializerOptions options)
        {
            var type = supportedType;

            while (type != typeof(object) && type != null)
            {
                var fields     = supportedType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
                var properties = supportedType.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);

                foreach (var field in fields)
                {
                    AddMember(field, cache, options);
                }

                foreach (var property in properties)
                {
                    AddMember(property, cache, options);
                }

                var serializeBase = true;
                var attribs       = type.GetCustomAttributes(typeof(XmlSerializeBaseAttribute), false);

                foreach (XmlSerializeBaseAttribute attrib in attribs)
                {
                    if (attrib.Applies(options))
                    {
                        serializeBase = attrib.SerializeBase;
                    }
                }

                if (!serializeBase)
                {
                    break;
                }

                type = type.BaseType;
            }
        }
コード例 #13
0
 public SerializationMemberInfo(MemberInfo memberInfo, SerializerOptions options, TypeSerializerCache cache)
     : this(memberInfo, options, cache, false)
 {
 }
コード例 #14
0
        public StringableTypeSerializer(Type type, SerializationMemberInfo memberInfo, TypeSerializerCache cache, SerializerOptions options)
        {
            supportedType = type;
            if (memberInfo != null)
            {
                formatAttribute = (XmlFormatAttribute)memberInfo.GetFirstApplicableAttribute(typeof(XmlFormatAttribute));
            }

            formatSpecified = formatAttribute != null;
        }
コード例 #15
0
 public ColorSerializer(Type type, SerializationMemberInfo memberInfo, TypeSerializerCache cache, SerializerOptions options)
     : base(type, memberInfo, cache, options)
 {
 }
コード例 #16
0
		protected virtual void Scan(SerializationMemberInfo memberInfo, TypeSerializerCache cache, SerializerOptions options)
		{
			XmlSerializationAttribute[] attribs;

			var attributes = new List<Attribute>();

			// Get the ElementType attributes specified on the type itself as long
			// as we're not the type itself!

			if (memberInfo.MemberInfo != memberInfo.ReturnType)
			{
				var smi = new SerializationMemberInfo(memberInfo.ReturnType, options, cache);

				attribs = smi.GetApplicableAttributes(typeof(XmlListElementAttribute));

				foreach (var a in attribs)
				{
					attributes.Add(a);
				}
			}
			
			// Get the ElementType attributes specified on the member.

			attribs = memberInfo.GetApplicableAttributes(typeof(XmlListElementAttribute));

			foreach (var a in attribs)
			{
				attributes.Add(a);
			}
			
			foreach (XmlListElementAttribute attribute in attributes)
			{
				var listItem = new ListItem();
				
				if (attribute.Type == null)
				{
					if (serializationMemberInfo.ReturnType.IsArray)
					{
						attribute.Type = serializationMemberInfo.ReturnType.GetElementType();
					}
					else if (serializationMemberInfo.ReturnType.IsGenericType)
					{
						attribute.Type = serializationMemberInfo.ReturnType.GetGenericArguments()[0];
					}
				}
			
				var smi2 = new SerializationMemberInfo(attribute.ItemType, options, cache);

				if (attribute.Alias == null)
				{
					attribute.Alias = smi2.SerializedName;
				}

				listItem.Attribute = attribute;
				listItem.Alias = attribute.Alias;

				// Check if a specific type of serializer is specified.

				if (attribute.SerializerType == null)
				{
					// Figure out the serializer based on the type of the element.

					listItem.Serializer = cache.GetTypeSerializerBySupportedType(attribute.ItemType, smi2);
				}
				else
				{
					// Get the type of serializer they specify.

					listItem.Serializer = cache.GetTypeSerializerBySerializerType(attribute.SerializerType, smi2);
				}

				typeToItemMap[attribute.ItemType] = listItem;
				aliasToItemMap[attribute.Alias] = listItem;
			}

			if (typeToItemMap.Count == 0)
			{
				if (memberInfo.ReturnType.IsArray)
				{
					var listItem = new ListItem();
					var elementType = memberInfo.ReturnType.GetElementType();
					var sm = new SerializationMemberInfo(elementType, options, cache);

					listItem.Alias = sm.SerializedName;

					listItem.Serializer = cache.GetTypeSerializerBySupportedType(elementType, new SerializationMemberInfo(elementType, options, cache));

					typeToItemMap[elementType] = listItem;
					aliasToItemMap[listItem.Alias] = listItem;
				}
			}

			if (memberInfo.ReturnType.IsGenericType)
			{
				var elementType = memberInfo.ReturnType.GetGenericArguments()[0];

				if (!typeToItemMap.ContainsKey(elementType) && dynamicTypeResolver == null && !(elementType.IsAbstract || elementType.IsInterface))
				{
					var listItem = new ListItem();
					var sm = new SerializationMemberInfo(elementType, options, cache);

					listItem.Alias = sm.SerializedName;

					listItem.Serializer = cache.GetTypeSerializerBySupportedType(elementType, new SerializationMemberInfo(elementType, options, cache));

					typeToItemMap[elementType] = listItem;
					aliasToItemMap[listItem.Alias] = listItem;
				}
			}

			if (typeToItemMap.Count == 0 && this.dynamicTypeResolver == null)
			{
			    throw new InvalidOperationException(
			        string.Format(
			            "Must specify at least one XmlListElemenType or an XmlListElementTypeSerializerProvider for field {0}",
			             ((Type)memberInfo.MemberInfo).FullName));
			}

			listType = memberInfo.ReturnType;		
		}
コード例 #17
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="memberInfo"></param>
 /// <param name="cache"></param>
 /// <param name="options"></param>
 public DictionaryTypeSerializer(SerializationMemberInfo memberInfo, TypeSerializerCache cache, SerializerOptions options)
 {
 }
コード例 #18
0
 public RuntimeTypeTypeSerializer(SerializationMemberInfo memberInfo, TypeSerializerCache cache, SerializerOptions options)
 {
     verifyAttributes = (XmlSerializationAttribute[])memberInfo.GetApplicableAttributes(typeof(XmlVerifyRuntimeTypeAttribute));
 }
コード例 #19
0
        public ComplexTypeTypeSerializer(SerializationMemberInfo memberInfo, Type type, TypeSerializerCache cache, SerializerOptions options)
        {
            supportedType = type;

            serializationMemberInfo = memberInfo;

            elementMembersMap   = new ListDictionary();
            attributeMembersMap = new ListDictionary();

            if (memberInfo != null && memberInfo.IncludeIfUnattributed)
            {
                memberBound = true;
            }

            cache.Add(this, memberInfo);

            Scan(cache, options);
        }
コード例 #20
0
        public override TypeSerializer NewTypeSerializerBySupportedType(Type supportedType, SerializationMemberInfo memberInfo, TypeSerializerCache cache)
        {
            const string error = "A TypeSerializer can't be created for the given type without a memberInfo";

            if (typeof(Enum).IsAssignableFrom(supportedType))
            {
                return(new EnumTypeSerializer(memberInfo, cache, options));
            }
            else if (typeof(IDictionary).IsAssignableFrom(supportedType))
            {
                return(new DictionaryTypeSerializer(memberInfo, cache, options));
            }
            else if (typeof(Type).IsAssignableFrom(supportedType))
            {
                return(new RuntimeTypeTypeSerializer(memberInfo, cache, options));
            }
            else if (supportedType == typeof(XmlNode))
            {
                return(XmlNodeNodeTypeSerializer.Default);
            }
            else if (StringableTypeSerializer.SupportedTypes.Contains(supportedType))
            {
                return(new StringableTypeSerializer(supportedType, memberInfo, cache, options));
            }
            else if (supportedType == typeof(Guid))
            {
                return(new GuidSerializer(supportedType, memberInfo, cache, options));
            }
            else if (supportedType == typeof(Color))
            {
                return(new ColorSerializer(supportedType, memberInfo, cache, options));
            }
            else if (supportedType == typeof(DateTime))
            {
                return(new DateTimeTypeSerializer(memberInfo, cache, options));
            }
            else if (supportedType.IsGenericType && supportedType.GetGenericTypeDefinition() == typeof(Nullable <>))
            {
                return(NewTypeSerializerBySupportedType
                       (
                           Nullable.GetUnderlyingType(supportedType),
                           memberInfo,
                           cache
                       ));
            }
            else
            {
                var implementsList        = false;
                var implementsGenericList = false;

                implementsList = typeof(IList).IsAssignableFrom(supportedType);

                implementsGenericList = supportedType.FindInterfaces
                                        (
                    (type, criterea) => type.IsGenericType && type.GetGenericTypeDefinition() == typeof(System.Collections.Generic.IList <>),
                    null
                                        ).Length > 0;

                if (implementsList || implementsGenericList)
                {
                    if (memberInfo == null)
                    {
                        throw new XmlSerializerException(error);
                    }

                    return(new ListTypeSerializer(memberInfo, cache, options));
                }

                return(new ComplexTypeTypeSerializer(memberInfo, supportedType, cache, options));
            }
        }
コード例 #21
0
 public override TypeSerializer NewTypeSerializerBySupportedType(Type supportedType, TypeSerializerCache cache)
 {
     return(NewTypeSerializerBySupportedType(supportedType, null, cache));
 }
コード例 #22
0
 public abstract TypeSerializer NewTypeSerializerBySupportedType(Type supportedType, TypeSerializerCache cache);
コード例 #23
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="memberInfo"></param>
        /// <param name="cache"></param>
        /// <param name="options"></param>
        private void Scan(SerializationMemberInfo memberInfo, TypeSerializerCache cache, SerializerOptions options)
        {
            IList attributes;
            SerializationMemberInfo smi;

            XmlSerializationAttribute[] attribs;

            attributes = new ArrayList(10);

            // Get the ElementType attributes specified on the type itself as long
            // as we're not the type itself!

            if (memberInfo.MemberInfo != memberInfo.LogicalType)
            {
                smi = new SerializationMemberInfo(memberInfo.LogicalType, options, cache);

                attribs = smi.GetApplicableAttributes(typeof(XmlListElementAttribute));

                foreach (Attribute a in attribs)
                {
                    attributes.Add(a);
                }
            }

            // Get the ElementType attributes specified on the member.

            attribs = memberInfo.GetApplicableAttributes(typeof(XmlListElementAttribute));

            foreach (Attribute a in attribs)
            {
                attributes.Add(a);
            }


            foreach (XmlListElementAttribute attribute in attributes)
            {
                SerializationMemberInfo smi2;
                ListItem listItem = new ListItem();

                smi2 = new SerializationMemberInfo(attribute.ItemType, options, cache);

                if (attribute.Alias == null)
                {
                    attribute.Alias = smi2.SerializedName;
                }

                listItem.Attribute = attribute;
                listItem.Alias     = attribute.Alias;

                // Check if a specific type of serializer is specified.

                if (attribute.SerializerType == null)
                {
                    // Figure out the serializer based on the type of the element.

                    listItem.Serializer = cache.GetTypeSerializerBySupportedType(attribute.ItemType, smi2);
                }
                else
                {
                    // Get the type of serializer they specify.

                    listItem.Serializer = cache.GetTypeSerializerBySerializerType(attribute.SerializerType, smi2);
                }

                m_TypeToItemMap[attribute.ItemType] = listItem;
                m_AliasToItemMap[attribute.Alias]   = listItem;
            }

            if (m_TypeToItemMap.Count == 0)
            {
                if (memberInfo.LogicalType.IsArray)
                {
                    ListItem listItem;
                    Type     elementType;

                    listItem = new ListItem();

                    elementType    = memberInfo.LogicalType.GetElementType();
                    listItem.Alias = elementType.Name;

                    listItem.Serializer = cache.GetTypeSerializerBySupportedType(elementType, new SerializationMemberInfo(elementType, options, cache));

                    m_TypeToItemMap[elementType]     = listItem;
                    m_AliasToItemMap[listItem.Alias] = listItem;
                }
            }

            if (m_TypeToItemMap.Count == 0)
            {
                throw new InvalidOperationException("Must specify at least one XmlListElementype.");
            }

            m_ListType = memberInfo.LogicalType;

            if (m_ListType.IsAbstract)
            {
                m_ListType = typeof(ArrayList);
            }
        }
コード例 #24
0
 public abstract TypeSerializer NewTypeSerializerBySerializerType(Type serializerType, SerializationMemberInfo memberInfo, TypeSerializerCache cache);
コード例 #25
0
        private void Scan(SerializationMemberInfo memberInfo, TypeSerializerCache cache, SerializerOptions options)
        {
            XmlSerializationAttribute[] attribs;

            var attributes = new List <Attribute>();

            // Get the ElementType attributes specified on the type itself as long
            // as we're not the type itself!

            if (memberInfo.MemberInfo != memberInfo.ReturnType)
            {
                var smi = new SerializationMemberInfo(memberInfo.ReturnType, options, cache);

                attribs = smi.GetApplicableAttributes(typeof(XmlDictionaryElementTypeAttribute));

                foreach (XmlSerializationAttribute a in attribs)
                {
                    attributes.Add(a);
                }
            }

            // Get the ElementType attributes specified on the member.

            attribs = memberInfo.GetApplicableAttributes(typeof(XmlDictionaryElementTypeAttribute));

            foreach (var a in attribs)
            {
                attributes.Add(a);
            }

            foreach (XmlDictionaryElementTypeAttribute attribute in attributes)
            {
                var dictionaryItem = new DictionaryItem();

                var smi2 = new SerializationMemberInfo(attribute.ElementType, options, cache);

                if (attribute.TypeAlias == null)
                {
                    attribute.TypeAlias = smi2.SerializedName;
                }

                dictionaryItem.attribute = attribute;
                dictionaryItem.typeAlias = attribute.TypeAlias;

                // Check if a specific type of serializer is specified.

                if (attribute.SerializerType == null)
                {
                    // Figure out the serializer based on the type of the element.

                    dictionaryItem.serializer = cache.GetTypeSerializerBySupportedType(attribute.ElementType, smi2);
                }
                else
                {
                    // Get the type of serializer they specify.

                    dictionaryItem.serializer = cache.GetTypeSerializerBySerializerType(attribute.SerializerType, smi2);
                }

                primaryDictionaryItem = dictionaryItem;

                typeToItemMap[attribute.ElementType] = dictionaryItem;
                aliasToItemMap[attribute.TypeAlias]  = dictionaryItem;
            }

            if (aliasToItemMap.Count != 1)
            {
                primaryDictionaryItem = null;
            }
        }
コード例 #26
0
        protected virtual void AddMember(MemberInfo memberInfo, TypeSerializerCache cache, SerializerOptions options)
        {
            SerializationMemberInfo localSerializationMemberInfo;

            if (this.MemberBound && this.serializationMemberInfo.IncludeIfUnattributed)
            {
                bool ok;
                var  fieldInfo    = memberInfo as FieldInfo;
                var  propertyInfo = memberInfo as PropertyInfo;

                if (fieldInfo != null && fieldInfo.IsPublic)
                {
                    ok = true;
                }
                else if (propertyInfo != null &&
                         propertyInfo.CanRead && propertyInfo.CanWrite &&
                         propertyInfo.GetSetMethod().IsPublic &&
                         propertyInfo.GetGetMethod().IsPublic)
                {
                    ok = true;
                }
                else
                {
                    ok = false;
                }

                if (ok)
                {
                    localSerializationMemberInfo = new SerializationMemberInfo(memberInfo, options, cache, true);

                    elementMembersMap[localSerializationMemberInfo.SerializedName] = localSerializationMemberInfo;

                    return;
                }
            }

            localSerializationMemberInfo = new SerializationMemberInfo(memberInfo, options, cache);

            if (localSerializationMemberInfo.SerializedNodeType == XmlNodeType.Element)
            {
                if (localSerializationMemberInfo.Namespace.Length > 0)
                {
                    elementMembersMap[localSerializationMemberInfo.Namespace + (char)0xff + localSerializationMemberInfo.SerializedName] = localSerializationMemberInfo;
                }
                else
                {
                    elementMembersMap[localSerializationMemberInfo.SerializedName] = localSerializationMemberInfo;
                }

                return;
            }
            else if (localSerializationMemberInfo.SerializedNodeType == XmlNodeType.Attribute)
            {
                if (localSerializationMemberInfo.Namespace.Length > 0)
                {
                    attributeMembersMap[localSerializationMemberInfo.Namespace + (char)0xff + localSerializationMemberInfo.SerializedName] = localSerializationMemberInfo;
                }
                else
                {
                    attributeMembersMap[localSerializationMemberInfo.SerializedName] = localSerializationMemberInfo;
                }
            }
            else if (localSerializationMemberInfo.SerializedNodeType == XmlNodeType.Text)
            {
                if (TextMember != null && !TextMember.Equals(localSerializationMemberInfo))
                {
                    throw new Exception(string.Format("There should only be one XmlTextAttribute in type {0}", ((Type)this.serializationMemberInfo.MemberInfo).FullName));
                }
                TextMember = localSerializationMemberInfo;
            }
        }
コード例 #27
0
 public override TypeSerializer NewTypeSerializerBySerializerType(Type serializerType, TypeSerializerCache cache)
 {
     return(NewTypeSerializerBySerializerType(serializerType, null, cache));
 }
コード例 #28
0
        public override TypeSerializer NewTypeSerializerBySerializerType(Type serializerType, SerializationMemberInfo memberInfo, TypeSerializerCache cache)
        {
            TypeSerializer retval = null;

            try
            {
                retval = (TypeSerializer)Activator.CreateInstance(serializerType, new object[] { cache, options });
            }
            catch (Exception)
            {
            }

            if (retval == null && memberInfo != null)
            {
                try
                {
                    retval = (TypeSerializer)Activator.CreateInstance(serializerType, new object[] { memberInfo, cache, options });
                }
                catch (Exception)
                {
                }
            }

            if (retval == null && memberInfo != null)
            {
                try
                {
                    retval = (TypeSerializer)Activator.CreateInstance(serializerType, new object[] { memberInfo.ReturnType });
                }
                catch (Exception)
                {
                }
            }

            if (retval == null)
            {
                try
                {
                    retval = (TypeSerializer)Activator.CreateInstance(serializerType, new object[0]);
                }
                catch (Exception)
                {
                }
            }

            if (retval == null)
            {
                throw new XmlSerializerException("Unable to create TypeSerializer: " + serializerType.GetType().ToString());
            }

            return(retval);
        }
コード例 #29
0
 public abstract TypeSerializer NewTypeSerializerBySerializerType(Type serializerType, TypeSerializerCache cache);