『代码』扩展一哈 XmlNode 的取值

#region  扩 展 XmlNode 取 值

        internal static string ReadInnerString(this XmlNode node, string keyNode = @"", string defaultValue = @"")
        {
            if (node == null) return defaultValue;
            if (string.IsNullOrWhiteSpace(keyNode))
            {
                string innerXml = node.InnerXml ?? defaultValue;
                if (innerXml != null) innerXml = innerXml.Trim();
                return XmlDecode(innerXml);
            }
            else
            {
                XmlNode childNode = node.SelectSingleNode(keyNode);  //从子节点中 获取 String
                return ReadInnerString(childNode, string.Empty, defaultValue);
            }
        }
        internal static int ReadInnerInt32(this XmlNode node, string keyNode = @"", int defaultValue = 0)
        {
            if (node == null) return defaultValue;
            if (string.IsNullOrWhiteSpace(keyNode))
            {
                string innerXml = (node.InnerXml ?? string.Empty).Trim();
                if (string.IsNullOrEmpty(innerXml))
                    return defaultValue;

                int result;
                int.TryParse(innerXml, out result);
                return result;
            }
            else
            {
                XmlNode childNode = node.SelectSingleNode(keyNode);  //从子节点中 获取 Int32
                return ReadInnerInt32(childNode, string.Empty, defaultValue);
            }
        }
        internal static long ReadInnerInt64(this XmlNode node, string keyNode = @"", long defaultValue = 0)
        {
            if (node == null) return defaultValue;
            if (string.IsNullOrWhiteSpace(keyNode))
            {
                string innerXml = (node.InnerXml ?? string.Empty).Trim();
                if (string.IsNullOrEmpty(innerXml))
                    return defaultValue;

                long result;
                long.TryParse(innerXml, out result);
                return result;
            }
            else
            {
                XmlNode childNode = node.SelectSingleNode(keyNode);  //从子节点中 获取 Int64
                return ReadInnerInt64(childNode, string.Empty, defaultValue);
            }
        }
        internal static DateTime ReadInnerDateTime(this XmlNode node, string keyNode = @"")
        {
            return ReadInnerDateTime(node, new DateTime(1900, 1, 1), keyNode);
        }
        internal static DateTime ReadInnerDateTime(this XmlNode node, DateTime defaultValue, string keyNode = @"")
        {
            if (node == null) return defaultValue;
            if (string.IsNullOrWhiteSpace(keyNode))
            {
                string innerXml = (node.InnerXml ?? string.Empty).Trim();
                if (string.IsNullOrEmpty(innerXml))
                    return defaultValue;

                DateTime result;
                DateTime.TryParse(innerXml, out result);
                if (result.Year < 1900) result = defaultValue;
                return result;
            }
            else
            {
                XmlNode childNode = node.SelectSingleNode(keyNode);  //从子节点中 获取 DateTime
                return ReadInnerDateTime(childNode, defaultValue, string.Empty);
            }
        }
        internal static bool ReadInnerBoolean(this XmlNode node, string keyNode = @"", bool defaultValue = false)
        {
            if (node == null) return defaultValue;
            if (string.IsNullOrWhiteSpace(keyNode))
            {
                string innerXml = (node.InnerXml ?? string.Empty).Trim().ToLower();
                if (string.IsNullOrEmpty(innerXml))
                    return defaultValue;

                bool isTrue = string.Equals(innerXml, "true") || string.Equals(innerXml, "1") || string.Equals(innerXml, "t");
                if (isTrue)
                    return true;
                else
                {
                    bool isFalse = string.Equals(innerXml, "false") || string.Equals(innerXml, "0") || string.Equals(innerXml, "f");
                    if (isFalse) return false;
                }

                return defaultValue;
            }
            else
            {
                XmlNode childNode = node.SelectSingleNode(keyNode);  //从子节点中 获取 Boolean
                return ReadInnerBoolean(childNode, string.Empty, defaultValue);
            }
        }

        internal static string ReadAttrString(this XmlNode node, string attrName, string defaultValue = @"")
        {
            if (node == null) return defaultValue;
            if (string.IsNullOrWhiteSpace(attrName))
            {
                return ReadInnerString(node, attrName, defaultValue);
            }
            else
            {
                XmlAttribute attr = node.Attributes == null ? null : node.Attributes[attrName];
                string attrValue = attr != null ? attr.Value : defaultValue;
                if (attrValue != null) attrValue = attrValue.Trim();
                return XmlDecode(attrValue);
            }
        }
        internal static int ReadAttrInt32(this XmlNode node, string attrName, int defaultValue = 0)
        {
            if (node == null) return defaultValue;
            if (string.IsNullOrWhiteSpace(attrName))
            {
                return ReadInnerInt32(node, attrName, defaultValue);
            }
            else
            {
                XmlAttribute attr = node.Attributes == null ? null : node.Attributes[attrName];
                string attrValue = attr != null ? attr.Value : null;
                int result = defaultValue;
                if (!string.IsNullOrWhiteSpace(attrValue))
                {
                    attrValue = attrValue.Trim();
                    int.TryParse(attrValue, out result);
                }
                return result;
            }
        }
        internal static long ReadAttrInt64(this XmlNode node, string attrName, long defaultValue = 0)
        {
            if (node == null) return defaultValue;
            if (string.IsNullOrWhiteSpace(attrName))
            {
                return ReadInnerInt64(node, attrName, defaultValue);
            }
            else
            {
                XmlAttribute attr = node.Attributes == null ? null : node.Attributes[attrName];
                string attrValue = attr != null ? attr.Value : null;
                long result = defaultValue;
                if (!string.IsNullOrWhiteSpace(attrValue))
                {
                    attrValue = attrValue.Trim();
                    long.TryParse(attrValue, out result);
                }
                return result;
            }
        }
        internal static DateTime ReadAttrDateTime(this XmlNode node, string attrName)
        {
            return ReadAttrDateTime(node, attrName, new DateTime(1900, 1, 1));
        }
        internal static DateTime ReadAttrDateTime(this XmlNode node, string attrName, DateTime defaultValue)
        {
            if (node == null) return defaultValue;
            if (string.IsNullOrWhiteSpace(attrName))
            {
                return ReadInnerDateTime(node, defaultValue, attrName);
            }
            else
            {
                XmlAttribute attr = node.Attributes == null ? null : node.Attributes[attrName];
                string attrValue = attr != null ? attr.Value : null;
                DateTime result = defaultValue;
                if (!string.IsNullOrWhiteSpace(attrValue))
                {
                    attrValue = attrValue.Trim();
                    DateTime.TryParse(attrValue, out result);
                }
                return result;
            }
        }
        internal static bool ReadAttrBoolean(this XmlNode node, string attrName, bool defaultValue = false)
        {
            if (node == null) return defaultValue;
            if (string.IsNullOrWhiteSpace(attrName))
            {
                return ReadInnerBoolean(node, attrName, defaultValue);
            }
            else
            {
                XmlAttribute attr = node.Attributes == null ? null : node.Attributes[attrName];
                string attrValue = attr != null ? attr.Value : null;
                if (!string.IsNullOrWhiteSpace(attrValue))
                {
                    attrValue = attrValue.Trim();
                    bool isTrue = string.Equals(attrValue, "true") || string.Equals(attrValue, "1") || string.Equals(attrValue, "t");
                    if (isTrue)
                        return true;
                    else
                    {
                        bool isFalse = string.Equals(attrValue, "false") || string.Equals(attrValue, "0") || string.Equals(attrValue, "f");
                        if (isFalse) return false;
                    }
                }
                return defaultValue;
            }
        }

        public static string XmlEncode(string xmlValue)
        {
            xmlValue = xmlValue.Replace("&", "&amp;");
            xmlValue = xmlValue.Replace("<", "&lt;");
            xmlValue = xmlValue.Replace(">", "&gt;");
            xmlValue = xmlValue.Replace("\'", "&apos;");
            xmlValue = xmlValue.Replace("\"", "&quot;");
            return xmlValue;
        }
        public static string XmlDecode(string xmlValue)
        {
            xmlValue = xmlValue.Replace("&amp;", "&");
            xmlValue = xmlValue.Replace("&lt;", "<");
            xmlValue = xmlValue.Replace("&gt;", ">");
            xmlValue = xmlValue.Replace("&apos;", "\'");
            xmlValue = xmlValue.Replace("&quot;", "\"");
            return xmlValue;
        }

        #endregion