コード例 #1
0
 public object GetValue(object parentobject)
 {
     if (m_CurrentNode.HasAttribute("Type"))
     {
         string type = m_CurrentNode.GetAttribute("Type");
         // Get the surrogate for this type
         IXmlSerializationSurrogate surr = m_SurrogateSelector.GetSurrogate(type);
         if (null == surr)
         {
             throw new ApplicationException(string.Format("Unable to find XmlSurrogate for type {0}!", type));
         }
         else
         {
             PushNodeStack();
             m_CurrentNode = (XmlElement)m_CurrentNode.FirstChild;
             object retvalue = surr.Deserialize(null, this, parentobject);
             PopNodeStack();
             m_CurrentNode = (XmlElement)m_CurrentNode.NextSibling;
             return(retvalue);
         }
     }
     else
     {
         throw new ApplicationException(string.Format("Unable to deserialize element {0}, Type attribute missing!", m_CurrentNode.Name));
     }
 }
コード例 #2
0
        /// <summary>Deserializes the embedded base type.</summary>
        /// <param name="instance">The instance of the object to deserialize.</param>
        /// <param name="fullyQualifiedBaseTypeName">Fully qualified base type name. It is the short name of the assembly, comma, the full type name, comma, and the version. The string must not contain whitespaces. Example: 'AltaxoBase,Altaxo.Main.DocumentPath,0'.</param>
        /// <param name="parent">The parent object of the current object to deserialize.</param>
        public object GetBaseValueEmbedded(object instance, string fullyQualifiedBaseTypeName, object parent)
        {
            object obj;

            if ("BaseType" == CurrentElementName)
            {
                string basetypestring         = _xmlReader.ReadElementString();
                IXmlSerializationSurrogate ss = _surrogateSelector.GetSurrogate(basetypestring);
                if (null == ss)
                {
                    throw new ArgumentException(string.Format("Type {0} has no XmlSerializationSurrogate to get serialized", fullyQualifiedBaseTypeName));
                }
                obj = ss.Deserialize(instance, this, parent);
            }
            else
            {
                IXmlSerializationSurrogate ss = _surrogateSelector.GetSurrogate(fullyQualifiedBaseTypeName);
                if (null == ss)
                {
                    throw new ArgumentException(string.Format("Type {0} has no XmlSerializationSurrogate to get serialized", fullyQualifiedBaseTypeName));
                }
                obj = ss.Deserialize(instance, this, parent);
            }
            return(obj);
        }
コード例 #3
0
        /// <summary>
        /// Adds a surrogate for the type <code>type</code>.
        /// </summary>
        /// <param name="type">The type for which the surrogate is added.</param>
        /// <param name="version">The version of the surrogate (higher version numbers mean more recent versions).</param>
        /// <param name="surrogate">The surrogate used to serialize/deserialize the type.</param>
        public void AddSurrogate(System.Type type, int version, IXmlSerializationSurrogate surrogate)
        {
            // if this attribute cares about a currently existing type,
            // consider the highest value of version among all attributes
            // which care for the same type as the current version of that type
            AddTypeAndVersionIfHigher(type, version, surrogate);

            _surrogates[GetFullyQualifiedTypeName(type, version)] = surrogate;
        }
コード例 #4
0
        protected void AddTypeAndVersionIfHigher(System.Type type, int version, IXmlSerializationSurrogate surrogate)
        {
            int storedversion = _versions.ContainsKey(type) ? (int)(_versions[type] ?? 0) : int.MinValue;

            if (version > storedversion)
            {
                _versions[type]   = version;
                _surrogates[type] = surrogate;
            }
        }
コード例 #5
0
 /// <summary>
 /// Adds a surrogate for the type specified in the XmlSerializationForAttribute.
 /// </summary>
 /// <param name="attr">The attribute used to describe the type this surrogate is intended for.</param>
 /// <param name="surrogate">The surrogate used to serialize/deserialize the type.</param>
 public void AddSurrogate(XmlSerializationSurrogateForAttribute attr, IXmlSerializationSurrogate surrogate)
 {
     if (null != attr.SerializationType)
     {
         AddSurrogate(attr.SerializationType, attr.Version, surrogate);
     }
     else
     {
         AddSurrogate(attr.AssemblyName, attr.TypeName, attr.Version, surrogate);
     }
 }
コード例 #6
0
        public void AddBaseValueEmbedded(object o, System.Type basetype)
        {
            IXmlSerializationSurrogate ss = m_SurrogateSelector.GetSurrogate(basetype);

            if (null == ss)
            {
                throw new ArgumentException(string.Format("Type {0} has no XmlSerializationSurrogate to get serialized", basetype));
            }
            else
            {
                ss.Serialize(o, this);
            }
        }
コード例 #7
0
        public void AddBaseValueEmbedded(object o, System.Type basetype)
        {
            IXmlSerializationSurrogate ss = m_SurrogateSelector.GetSurrogate(basetype);

            if (null == ss)
            {
                throw new ArgumentException(string.Format("Type {0} has no XmlSerializationSurrogate to get serialized", basetype));
            }
            else
            {
                m_Writer.WriteElementString("BaseType", m_SurrogateSelector.GetFullyQualifiedTypeName(basetype));
                ss.Serialize(o, this);
            }
        }
コード例 #8
0
        public void GetBaseValueStandalone(string name, object instance, System.Type basetype, object parent)
        {
            IXmlSerializationSurrogate ss = m_SurrogateSelector.GetSurrogate(basetype);

            if (null == ss)
            {
                throw new ArgumentException(string.Format("Type {0} has no XmlSerializationSurrogate to get serialized", basetype));
            }
            else
            {
                m_Reader.ReadStartElement(); // note: this must now be done by  in the deserialization code
                ss.Deserialize(instance, this, parent);
                m_Reader.ReadEndElement();
            }
        }
コード例 #9
0
        public object GetValue(object parentobject)
        {
            string type = m_Reader.GetAttribute("Type");

            if (null != type)
            {
                if ("UndefinedValue" == type)
                {
                    m_Reader.Read();
                    return(null);
                }

                // Get the surrogate for this type
                IXmlSerializationSurrogate surr = m_SurrogateSelector.GetSurrogate(type);
                if (null == surr)
                {
                    throw new ApplicationException(string.Format("Unable to find XmlSurrogate for type {0}!", type));
                }
                else
                {
                    bool bNotEmpty = !m_Reader.IsEmptyElement;
                    // System.Diagnostics.Trace.WriteLine(string.Format("Xml val {0}, type {1}, empty:{2}",m_Reader.Name,type,bNotEmpty));


                    if (bNotEmpty)
                    {
                        m_Reader.ReadStartElement(); // note: this must now be done by  in the deserialization code
                    }
                    object retvalue = surr.Deserialize(null, this, parentobject);

                    if (bNotEmpty)
                    {
                        m_Reader.ReadEndElement();
                    }
                    else
                    {
                        m_Reader.Read();
                    }


                    return(retvalue);
                }
            }
            else
            {
                throw new ApplicationException(string.Format("Unable to deserialize element at line {0}, position {1}, Type attribute missing!", m_Reader.LineNumber, m_Reader.LinePosition));
            }
        }
コード例 #10
0
        public void AddBaseValueStandalone(string name, object o, System.Type basetype)
        {
            IXmlSerializationSurrogate ss = m_SurrogateSelector.GetSurrogate(basetype);

            if (null == ss)
            {
                throw new ArgumentException(string.Format("Type {0} has no XmlSerializationSurrogate to get serialized", basetype));
            }
            else
            {
                m_Writer.WriteStartElement(name);
                m_Writer.WriteAttributeString("Type", m_SurrogateSelector.GetFullyQualifiedTypeName(basetype));
                ss.Serialize(o, this);
                m_Writer.WriteEndElement();
            }
        }
コード例 #11
0
        public void AddValue(string name, object o)
        {
            IXmlSerializationSurrogate ss = m_SurrogateSelector.GetSurrogate(o.GetType());

            if (null == ss)
            {
                throw new ArgumentException(string.Format("Type {0} has no XmlSerializationSurrogate to get serialized", o.GetType()));
            }
            else
            {
                PushNodeStack();
                m_CurrentNode = m_Doc.CreateElement(name);
                XmlAttribute typeattr = m_Doc.CreateAttribute("Type");
                typeattr.InnerText = m_SurrogateSelector.GetFullyQualifiedTypeName(o.GetType());
                m_CurrentNode.Attributes.Append(typeattr);

                ss.Serialize(o, this);
                FinishCurrentNode();
            }
        }
コード例 #12
0
 public void GetBaseValueEmbedded(object instance, System.Type basetype, object parent)
 {
     if ("BaseType" == CurrentElementName)
     {
         string basetypestring         = m_Reader.ReadElementString();
         IXmlSerializationSurrogate ss = m_SurrogateSelector.GetSurrogate(basetypestring);
         if (null == ss)
         {
             throw new ArgumentException(string.Format("Type {0} has no XmlSerializationSurrogate to get serialized", basetype));
         }
         ss.Deserialize(instance, this, parent);
     }
     else
     {
         IXmlSerializationSurrogate ss = m_SurrogateSelector.GetSurrogate(basetype);
         if (null == ss)
         {
             throw new ArgumentException(string.Format("Type {0} has no XmlSerializationSurrogate to get serialized", basetype));
         }
         ss.Deserialize(instance, this, parent);
     }
 }
コード例 #13
0
 public void AddValue(string name, object o)
 {
     if (null != o)
     {
         IXmlSerializationSurrogate ss = m_SurrogateSelector.GetSurrogate(o.GetType());
         if (null == ss)
         {
             throw new ArgumentException(string.Format("Type {0} has no XmlSerializationSurrogate to get serialized", o.GetType()));
         }
         else
         {
             m_Writer.WriteStartElement(name);
             m_Writer.WriteAttributeString("Type", m_SurrogateSelector.GetFullyQualifiedTypeName(o.GetType()));
             ss.Serialize(o, this);
             m_Writer.WriteEndElement();
         }
     }
     else // o is null, we add only an empty element
     {
         m_Writer.WriteStartElement(name);
         m_Writer.WriteAttributeString("Type", "UndefinedValue");
         m_Writer.WriteEndElement();
     }
 }
コード例 #14
0
ファイル: XmlSurrogateSelector.cs プロジェクト: Altaxo/Altaxo
		/// <summary>
		/// Adds a surrogate for the type <code>type</code>.
		/// </summary>
		/// <param name="type">The type for which the surrogate is added.</param>
		/// <param name="version">The version of the surrogate (higher version numbers mean more recent versions).</param>
		/// <param name="surrogate">The surrogate used to serialize/deserialize the type.</param>
		public void AddSurrogate(System.Type type, int version, IXmlSerializationSurrogate surrogate)
		{
			// if this attribute cares about a currently existing type,
			// consider the highest value of version among all attributes
			// which care for the same type as the current version of that type
			AddTypeAndVersionIfHigher(type, version, surrogate);

			m_Surrogates[GetFullyQualifiedTypeName(type, version)] = surrogate;
		}
コード例 #15
0
ファイル: XmlSurrogateSelector.cs プロジェクト: Altaxo/Altaxo
		protected void AddTypeAndVersionIfHigher(System.Type type, int version, IXmlSerializationSurrogate surrogate)
		{
			int storedversion = m_Versions.ContainsKey(type) ? (int)m_Versions[type] : int.MinValue;

			if (version > storedversion)
			{
				m_Versions[type] = version;
				m_Surrogates[type] = surrogate;
			}
		}
コード例 #16
0
ファイル: XmlSurrogateSelector.cs プロジェクト: Altaxo/Altaxo
		/// <summary>
		/// Adds a surrogate for the type specified in the XmlSerializationForAttribute.
		/// </summary>
		/// <param name="attr">The attribute used to describe the type this surrogate is intended for.</param>
		/// <param name="surrogate">The surrogate used to serialize/deserialize the type.</param>
		public void AddSurrogate(XmlSerializationSurrogateForAttribute attr, IXmlSerializationSurrogate surrogate)
		{
			if (null != attr.SerializationType)
				AddSurrogate(attr.SerializationType, attr.Version, surrogate);
			else
				AddSurrogate(attr.AssemblyName, attr.TypeName, attr.Version, surrogate);
		}
コード例 #17
0
ファイル: XmlSurrogateSelector.cs プロジェクト: Altaxo/Altaxo
		/// <summary>
		/// Adds a surrogate for the type specified by assembly name, full type name, and version.
		/// </summary>
		/// <param name="assemblyname">The short name of the assembly.</param>
		/// <param name="typename">The fully qualified type name.</param>
		/// <param name="version">The version.</param>
		/// <param name="surrogate">The surrogate which is responsible to deserialize the type.</param>
		public void AddSurrogate(string assemblyname, string typename, int version, IXmlSerializationSurrogate surrogate)
		{
			m_Surrogates[assemblyname + "," + typename + "," + version] = surrogate;
		}
コード例 #18
0
 /// <summary>
 /// Adds a surrogate for the type specified by assembly name, full type name, and version.
 /// </summary>
 /// <param name="assemblyname">The short name of the assembly.</param>
 /// <param name="typename">The fully qualified type name.</param>
 /// <param name="version">The version.</param>
 /// <param name="surrogate">The surrogate which is responsible to deserialize the type.</param>
 public void AddSurrogate(string assemblyname, string typename, int version, IXmlSerializationSurrogate surrogate)
 {
     _surrogates[assemblyname + "," + typename + "," + version] = surrogate;
 }