C# XmlNode.ShouldNotBeNull方法代码示例

        /// <summary>
        /// <paramref name="parentNode"/>를 기준으로 XmlElement를 찾아서 InnerText값을 반환한다.
        /// </summary>
        /// <param name="parentNode">검색 기준이 되는 parent node</param>
        /// <param name="xpath">검색 식</param>
        /// <returns>검색한 XmlElement의 Text 속성 값, 없으면 빈 문자열 반환</returns>
        public string GetElementText(XmlNode parentNode, string xpath) {
            parentNode.ShouldNotBeNull("parentNode");

            var element = FindElement(parentNode, xpath);

            return (element != null) ? element.InnerText : string.Empty;
        }

        /// <summary>
        /// Processing Instruction Node를 추가한다.
        /// </summary>
        /// <param name="parentNode"></param>
        /// <param name="target"></param>
        /// <param name="data"></param>
        /// <returns></returns>
        public XmlProcessingInstruction AddPI(XmlNode parentNode, string target, string data) {
            parentNode.ShouldNotBeNull("parentNode");

            if(IsDebugEnabled)
                log.Debug("Add XmlProcessingInstruction node. parentNode=[{0}], target=[{1}], data=[{2}]",
                          parentNode.Name, target, data);

            var result = CreateProcessingInstruction(target, data);
            parentNode.AppendChild(result);

            return result;
        }

        /// <summary>
        /// Text Node를 추가한다.
        /// </summary>
        /// <param name="parentNode"></param>
        /// <param name="text"></param>
        /// <returns></returns>
        public XmlText AddTextNode(XmlNode parentNode, string text) {
            parentNode.ShouldNotBeNull("parentNode");

            if(IsDebugEnabled)
                log.Debug("Add XmlText node. parentNode=[{0}], text=[{1}]", parentNode.Name, text);

            var result = CreateTextNode(text);
            parentNode.AppendChild(result);

            return result;
        }

        /// <summary>
        /// XML Element로 파일 내용을 넣는다<br/>
        /// 파일내용은 bin.base64 형태로 XML string을 만들어서 XmlElement의 InnerText로 넣는다.
        /// </summary>
        /// <param name="parentNode">부모 노드</param>
        /// <param name="name">새로운 XML Element TagName</param>
        /// <param name="filename">DOM에 포함시킬 파일 이름(fullpath)</param>
        /// <returns>추가된 XmlElement</returns>
        /// <remarks>
        ///	파일 내용을 XML DOM에 넣어서 기존의 MSXML2.IXmlHttp를 사용하면 속도문제가 크다.<br />
        ///	.NET Version에서는 XMLHttp를 WebHttpRequest/WebHttpResponse를 사용하므로 문제없다. 
        ///	Client용 Application 중 MSXML 2,3,4를 사용하면 속도문제는 해결되지 않는다.
        /// </remarks>
        public XmlElement AddFileElement(XmlNode parentNode, string name, string filename) {
            parentNode.ShouldNotBeNull("parentNode");

            if(IsDebugEnabled)
                log.Debug("Add XmlElement that has file contents. parentNode=[{0}], name=[{1}], filename=[{2}]",
                          parentNode.Name, name, filename);

            if(File.Exists(filename) == false)
                throw new FileNotFoundException("File not founded", filename);

            var element = AddElementText(parentNode, name, string.Empty);

            if(element != null) {
                AddAttribute(element, "dt", "bin.base64");
                AddAttribute(element, "filePath", filename);
                AddAttribute(element, "length", filename.GetFileSize());

                element.InnerText = FileTool.ToByteArray(filename).Base64Encode();
            }

            return element;
        }

        /// <summary>
        /// 부모 노드에 노드를 추가한다.
        /// </summary>
        /// <param name="parentNode">부모노드</param>
        /// <param name="nodeType">System.Xml.XmlNodeType</param>
        /// <param name="name">Tag Name</param>
        /// <param name="text">Node Value or Text</param>
        /// <returns>추가된 System.Xml.XmlNode</returns>
        public XmlNode AddNode(XmlNode parentNode, XmlNodeType nodeType, string name, string text) {
            parentNode.ShouldNotBeNull("parentNode");

            XmlNode result;

            switch(nodeType) {
                case XmlNodeType.Element:
                    result = AddElementText(parentNode, name, text);
                    break;
                case XmlNodeType.Attribute:
                    result = AddAttribute(parentNode, name, text);
                    break;
                case XmlNodeType.Text:
                    result = AddTextNode(parentNode, text);
                    break;
                case XmlNodeType.CDATA:
                    result = AddCDataSection(parentNode, text);
                    break;
                case XmlNodeType.EntityReference:
                    result = AddEntityRef(parentNode, name);
                    break;
                case XmlNodeType.ProcessingInstruction:
                    result = AddPI(parentNode, name, text);
                    break;
                case XmlNodeType.Comment:
                    result = AddComment(parentNode, text);
                    break;
                case XmlNodeType.Entity:
                    result = AddEntity(parentNode, text);
                    break;

                case XmlNodeType.Document:
                case XmlNodeType.DocumentType:
                case XmlNodeType.DocumentFragment:
                case XmlNodeType.Notation:
                    throw new NotSupportedException("제공하지 않는 NodeType 입니다.");

                default:
                    throw new InvalidOperationException("알 수 없는 NodeType 입니다.");
            }

            return result;
        }

        /// <summary>
        /// 부모노드에 <see cref="XmlEntity"/>를 추가한다.
        /// </summary>
        /// <param name="parentNode">부모 노드</param>
        /// <param name="name">Entity 노드 이름</param>
        /// <returns>추가된 <see cref="XmlEntity"/> 노드</returns>
        public XmlEntity AddEntity(XmlNode parentNode, string name) {
            parentNode.ShouldNotBeNull("parentNode");

            if(IsDebugEnabled)
                log.Debug("Add XmlEntity node... parentNode=[{0}], name=[{1}]", parentNode.Name, name);

            var result = (XmlEntity)CreateNode(XmlNodeType.Entity, name, null);

            if(DocumentType != null)
                DocumentType.Entities.SetNamedItem(result);

            parentNode.AppendChild(result);

            return result;
        }

        /// <summary>
        /// <paramref name="parentNode"/>에 <see cref="XmlEntityReference"/>를 추가한다.
        /// </summary>
        /// <param name="parentNode">대상 노드</param>
        /// <param name="name">추가할 <see cref="XmlEntityReference"/>의 이름</param>
        /// <returns>추가된 <see cref="XmlEntityReference"/></returns>
        public XmlEntityReference AddEntityRef(XmlNode parentNode, string name) {
            parentNode.ShouldNotBeNull("parentNode");

            if(IsDebugEnabled)
                log.Debug("Add XmlEntityReference node... parentNode=[{0}], name=[{1}]", parentNode.Name, name);

            var result = CreateEntityReference(name);
            parentNode.AppendChild(result);

            return result;
        }

        /// <summary>
        /// XmlElement를 생성하여 부모 노드에 추가한다.
        /// </summary>
        /// <param name="parentNode"></param>
        /// <param name="name">Element Tag Name (Element의 TagName은 문자, '_', ':' 만 가능하다.)</param>
        /// <param name="text">Element Text Value</param>
        /// <returns>추가된 XmlElement</returns>
        public XmlElement AddElementText(XmlNode parentNode, string name, string text) {
            parentNode.ShouldNotBeNull("parentNode");

            if(IsDebugEnabled)
                log.Debug("XmlElement를 추가합니다... parentNode=[{0}], name=[{1}], text=[{2}]", parentNode.Name, name, text);

            var result = CreateElementText(name, text);
            parentNode.AppendChild(result);

            return result;
        }

        /// <summary>
        /// 부모 노드에 원본 노드의 복사본을 추가한다.
        /// </summary>
        /// <param name="parentNode">부모 노드</param>
        /// <param name="srcNode">복사할 대상 요소</param>
        /// <returns>새로 복사해서 부모노드에 추가한 요소(<see cref="XmlElement"/>)</returns>
        public XmlElement AddElement(XmlNode parentNode, XmlElement srcNode) {
            parentNode.ShouldNotBeNull("parentNode");
            srcNode.ShouldNotBeNull("srcNode");

            if(IsDebugEnabled)
                log.Debug("XmlElement를 추가합니다... parentNode=[{0}], srcNode=[{1}]", parentNode.Name, srcNode.Name);

            var result = srcNode.CloneNode(true) as XmlElement;

            if(result != null) {
                parentNode.AppendChild(result);

                if(IsDebugEnabled)
                    log.Debug("XmlElement를 추가했습니다!!! 추가된 XmlElement=[{0}]", result);
            }

            return result;
        }

        /// <summary>
        /// XmlCommend Node를 추가한다.
        /// </summary>
        /// <param name="parentNode"></param>
        /// <param name="comment">Commant Text</param>
        /// <returns></returns>
        public XmlComment AddComment(XmlNode parentNode, string comment) {
            parentNode.ShouldNotBeNull("parentNode");

            if(IsDebugEnabled)
                log.Debug("Add Comment node... parentNode=[{0}], comment=[{1}]", parentNode.Name, comment);

            var result = CreateComment(comment);
            return parentNode.AppendChild(result) as XmlComment;
        }

        /// <summary>
        /// Xml 문자열을 XmlDocument로 만들어서 Root Node를 부모 노드의 자식 노드로 추가한다.
        /// </summary>
        /// <param name="parentNode"></param>
        /// <param name="xmlText"></param>
        /// <returns>추가에 성공한 노드, 실패하면 null이 반환된다.</returns>
        public XmlElement AddElementXml(XmlNode parentNode, string xmlText) {
            parentNode.ShouldNotBeNull("parentNode");

            if(IsDebugEnabled)
                log.Debug("새로운 XmlElement를 추가합니다... parentNode=[{0}], xmlText=[{1}]", parentNode.Name, xmlText);

            XmlElement result = null;

            try {
                XmlDocument document = xmlText.CreateXmlDocument();
                if(document.IsValidDocument()) {
                    result = document.DocumentElement.CloneNode(true) as XmlElement;
                    if(result != null)
                        parentNode.AppendChild(result);
                }
            }
            catch(Exception ex) {
                if(log.IsWarnEnabled) {
                    log.Warn("새로운 XmlElement를 추가하는데 실패했습니다.");
                    log.Warn(ex);
                }

                result = null;
            }
            return result;
        }

        /// <summary>
        /// XmlCDataSection Node를 부모 노드에 추가한다. (&lt;![CDATA[ xxxx ]]&gt;)
        /// </summary>
        /// <param name="parentNode">부모노드</param>
        /// <param name="cdata">CDataSection의 값</param>
        /// <returns></returns>
        /// <exception cref="ArgumentNullException">parentNode가 null일 때</exception>
        public XmlCDataSection AddCDataSection(XmlNode parentNode, string cdata) {
            parentNode.ShouldNotBeNull("parentNode");

            if(IsDebugEnabled)
                log.Debug("Add CDataSection node... parentNode=[{0}], cdata=[{1}]", parentNode.Name, cdata);

            var cds = CreateCDataSection(cdata);
            parentNode.AppendChild(cds);

            return cds;
        }

        /// <summary>
        /// parentNode에 Attribute를 추가한다.
        /// </summary>
        /// <param name="parentNode">부모 노드</param>
        /// <param name="srcAttribute">원본 XmlAttribute 객체</param>
        /// <returns></returns>
        /// <exception cref="ArgumentNullException">parentNode가 null일 때</exception>
        public XmlAttribute AddAttribute(XmlNode parentNode, XmlAttribute srcAttribute) {
            parentNode.ShouldNotBeNull("parentNode");
            srcAttribute.ShouldNotBeNull("srcAttribute");

            if(IsDebugEnabled)
                log.Debug("Add instance of Addtribute to parent node. parentNode=[{0}], srcAttribute=[{1}]",
                          parentNode.Name, srcAttribute.Name);

            return (XmlAttribute)parentNode.Attributes.SetNamedItem(srcAttribute);
        }

        /// <summary>
        /// 지정된 노드내에서 XmlNode를 찾는다.
        /// </summary>
        /// <param name="parentNode">부모 노드</param>
        /// <param name="xpath">XPATH 형식 ("ROOT") </param>
        public XmlNode FindNode(XmlNode parentNode, string xpath) {
            parentNode.ShouldNotBeNull("parentNode");

            if(IsDebugEnabled)
                log.Debug("노드 찾기... parentNode=[{0}], xpath=[{1}]", parentNode.Name, xpath);

            return parentNode.SelectSingleNode(xpath);
        }

        /// <summary>
        /// <paramref name="parentNode"/>에서 <paramref name="xpath"/>에 해당하는 모든 XmlElement를 리스트로 반환한다.
        /// </summary>
        /// <param name="parentNode">기준이 되는 parent node</param>
        /// <param name="xpath">검색 식</param>
        /// <returns>XmlNodeList</returns>
        protected virtual XmlNodeList FindElements(XmlNode parentNode, string xpath) {
            parentNode.ShouldNotBeNull("parentNode");

            if(IsDebugEnabled)
                log.Debug("요소 찾기... parentNode=[{0}], xpath=[{1}]", parentNode.Name, xpath);

            if(xpath.IsNotWhiteSpace())
                return parentNode.SelectNodes(xpath);

            return null;
        }