Xmlserialization

  public class XmlSerializer
    {
        private static Dictionary<Type, System.Xml.Serialization.XmlSerializer> _dict = new Dictionary<Type, System.Xml.Serialization.XmlSerializer>();
        private static XmlSerializerNamespaces _namespaces;
        private static XmlSerializerNamespaces Namespaces
        {
            get
            {
                if (_namespaces == null)
                {
                    _namespaces = new XmlSerializerNamespaces();
                    _namespaces.Add("", "");
                }
                return _namespaces;
            }
        }
        public static T Clone<T>(T obj)
        {
            string xml = Serialize(obj);
            return Deserialize<T>(xml);
        }
        public static string Serialize(object obj)
        {
            if (obj == null)
            {
                return null;
            }
            using (StringWriter w = new StringWriter())
            {
                Serialize(w, obj);
                w.Flush();
                string result = w.ToString();
                w.Close();
                return result;
            }
        }
        public static void Serialize(Stream stream, object obj)
        {
            if (obj == null)
            {
                return;
            }
            StreamWriter w = new StreamWriter(stream);
            Serialize(w, obj);
            w.Flush();
            stream.Flush();
        }
        public static void Serialize(TextWriter writer, object obj)
        {
            if (obj == null)
            {
                return;
            }
            if (obj is IList)
            {
                using (XmlWriter w = XmlWriter.Create(writer, new XmlWriterSettings() { OmitXmlDeclaration = true }))
                {
                    w.WriteStartDocument();
                    w.WriteStartElement("XmlObjectList");
                    foreach (object element in (IList)obj)
                    {
                        w.WriteStartElement("Items");
                        w.WriteString(Serialize(element));
                        w.WriteEndElement();
                    }
                    w.WriteEndElement();
                    w.WriteEndDocument();
                    w.Flush();
                }
                writer.Flush();
                return;
            }
            Type type = obj.GetType();
            if (type.IsArray)
            {
                using (XmlWriter w = XmlWriter.Create(writer, new XmlWriterSettings() { OmitXmlDeclaration = true }))
                {
                    w.WriteStartDocument();
                    w.WriteStartElement("XmlObjectList");
                    foreach (object element in (Array)obj)
                    {
                        w.WriteStartElement("Items");
                        w.WriteString(Serialize(element));
                        w.WriteEndElement();
                    }
                    w.WriteEndElement();
                    w.WriteEndDocument();
                    w.Flush();
                }
                writer.Flush();
                return;
            }
            if (Util.IsSimpleType(type))
            {
                writer.Write(obj);
                writer.Flush();
                return;
            }
            System.Xml.Serialization.XmlSerializer xs = GetXmlSerializer(type);
            using (XmlWriter w = XmlWriter.Create(writer, new XmlWriterSettings() { OmitXmlDeclaration = true, Encoding = Encoding.UTF8 }))
            {
                lock (xs)
                {
                    xs.Serialize(w, obj, Namespaces);
                }
                w.Flush();
            }
            writer.Flush();
            return;
        }
        public static object Deserialize(TextReader reader, Type type)
        {
            if (reader == null)
            {
                return null;
            }
            if (type.IsArray)
            {
                Type elementType = type.GetElementType();
                IList list = DeserializeList(XmlReader.Create(reader), elementType);
                Array array = Array.CreateInstance(elementType, list.Count);
                for (int i = 0; i < list.Count; i++)
                {
                    array.SetValue(list[i], i);
                }
                return array;
            }
            if (Util.IsSimpleType(type))
            {
                return Util.ParseSimpleType(reader.ReadToEnd(), type);
            }
            System.Xml.Serialization.XmlSerializer xs = GetXmlSerializer(type);
            object result;
            lock (xs)
            {
                result = xs.Deserialize(reader);
            }
            return result;
        }
        public static T Deserialize<T>(TextReader reader)
        {
            return (T)Deserialize(reader, typeof(T));
        }
        public static T Deserialize<T>(string xml)
        {
            if (xml == null)
            {
                return default(T);
            }
            T result;
            using (StringReader r = new StringReader(xml))
            {
                result = Deserialize<T>(r);
                r.Close();
            }
            return result;
        }
        public static T Deserialize<T>(Stream stream)
        {
            if (stream == null)
            {
                return default(T);
            }
            T result;
            using (StreamReader r = new StreamReader(stream, Encoding.UTF8))
            {
                result = Deserialize<T>(r);
                r.Close();
            }
            return result;
        }
        public static List<T> DeserializeList<T>(string xml)
        {
            if (xml == null)
            {
                return null;
            }
            using (XmlReader reader = XmlReader.Create(new StringReader(xml)))
            {
                List<T> list = DeserializeList<T>(reader);
                reader.Close();
                return list;
            }
        }
        public static List<T> DeserializeList<T>(Stream stream)
        {
            if (stream == null)
            {
                return null;
            }
            using (XmlReader reader = XmlReader.Create(stream))
            {
                List<T> list = DeserializeList<T>(reader);
                reader.Close();
                return list;
            }
        }
        public static IList DeserializeList(XmlReader reader, Type type)
        {
            if (reader == null)
            {
                return null;
            }
            IList list = new ArrayList();
            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.Text)
                {
                    using (StringReader r = new StringReader(reader.ReadContentAsString()))
                    {
                        object element = XmlSerializer.Deserialize(r, type);
                        r.Close();
                        list.Add(element);
                    }
                }
            }
            return list;
        }
        public static List<T> DeserializeList<T>(XmlReader reader)
        {
            IList list = DeserializeList(reader, typeof(T));
            List<T> result = new List<T>();
            foreach (T element in list)
            {
                result.Add((T)element);
            }
            return result;
        }
        private static System.Xml.Serialization.XmlSerializer GetXmlSerializer(Type type)
        {
            System.Xml.Serialization.XmlSerializer xs;
            lock (_dict)
            {
                if (_dict.ContainsKey(type))
                {
                    xs = _dict[type];
                }
                else
                {
                    xs = new System.Xml.Serialization.XmlSerializer(type);
                    _dict.Add(type, xs);
                }
            }
            return xs;
        }
        private static bool IsXmlType(Type type)
        {
            object[] attributes = type.GetCustomAttributes(true);
            foreach (object attribute in attributes)
            {
                if (attribute is System.Xml.Serialization.XmlRootAttribute)
                {
                    return true;
                }
            }
            return false;
        }
    }