public string RenderComponentFieldAsBBCode(string fieldExpression, int fieldIndex, bool outputImages)
        {
            BuiltInFunctions functions = new BuiltInFunctions(_engine, _package);
            string output = functions.RenderComponentField(fieldExpression, fieldIndex);

            StringReader sr = new StringReader(output);
            NameTable nt = new NameTable();
            XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt);
            nsmgr.AddNamespace("tcdl", Tridion.ContentManager.Templating.TcdlTags.TcdlNamespace);
            XmlParserContext parserContext = new XmlParserContext(null, nsmgr, null, XmlSpace.None);

            XmlReader xmlReader = XmlReader.Create(sr, new XmlReaderSettings(), parserContext);

            XslCompiledTransform transform = new XslCompiledTransform(true);

            using (Stream xsltStream = System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream("Tridion.ContentManager.Templating.Expression.NetbiscuitsFunctions.XhtmlToBBCode.xslt"))
            {
                using (XmlReader xsltReader = XmlReader.Create(xsltStream))
                {
                    transform.Load(xsltReader);
                }
            }

            StringWriter resultWriter = new StringWriter();
            XsltArgumentList argumentList = new XsltArgumentList();
            argumentList.AddParam("IncludeImages", String.Empty, outputImages);

            transform.Transform(xmlReader, argumentList, resultWriter);

            return resultWriter.ToString();   
        }

 static Schema() {
     NameTable nt = new NameTable();
     nt.Add(Namespace.Xs.NamespaceName);
     NamespaceManager = new XmlNamespaceManager(nt);
     Swidtag = XDocument.Load(XmlReader.Create(new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream("FearTheCowboy.Iso19770.Properties.Swidtag.xsd.xml")), new XmlReaderSettings()));
     NamespaceManager.AddNamespace("xs", Namespace.Xs.NamespaceName);
 }

        static int cellSize = 10;//网格大小 10m
        /// <summary>
        /// 打开并加载参数xml文档
        /// 将参数值存储到参数list中
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void openFileButton_Click(object sender, EventArgs e)
        {
            try
            {
                XmlDocument paraxml = new XmlDocument();
                OpenFileDialog fd = new OpenFileDialog();
                fd.Filter = "(*.xml;)|*.xml";
                fd.InitialDirectory = Application.StartupPath + @"";
                fd.ShowReadOnly = true;
                DialogResult result = fd.ShowDialog();
                if (result == DialogResult.OK)
                {
                    paraxml.Load(fd.FileName);
                }
                openFileButton.Enabled = false;

                NameTable xmt = new NameTable();
                XmlNamespaceManager xnm = new XmlNamespaceManager(xmt);
                xnm.AddNamespace(string.Empty, "");
                XmlNodeList xnlist = paraxml.SelectNodes("/ParameterML/ParameterList/Parameter/value");
                foreach (XmlNode xn in xnlist)
                {
                    paraList.Add(Convert.ToDouble(xn.InnerText));
                }
                calculateButton.Enabled = true;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        public static void WDDeleteHiddenText(string docName)
        {
            // Given a document name, delete all the hidden text.
            const string wordmlNamespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";

            using (WordprocessingDocument wdDoc = WordprocessingDocument.Open(docName, true))
            {
                // Manage namespaces to perform XPath queries.
                NameTable nt = new NameTable();
                XmlNamespaceManager nsManager = new XmlNamespaceManager(nt);
                nsManager.AddNamespace("w", wordmlNamespace);

                // Get the document part from the package.
                // Load the XML in the document part into an XmlDocument instance.
                XmlDocument xdoc = new XmlDocument(nt);
                xdoc.Load(wdDoc.MainDocumentPart.GetStream());
                XmlNodeList hiddenNodes = xdoc.SelectNodes("//w:vanish", nsManager);
                foreach (System.Xml.XmlNode hiddenNode in hiddenNodes)
                {
                    XmlNode topNode = hiddenNode.ParentNode.ParentNode;
                    XmlNode topParentNode = topNode.ParentNode;
                    topParentNode.RemoveChild(topNode);
                    if (!(topParentNode.HasChildNodes))
                    {
                        topParentNode.ParentNode.RemoveChild(topParentNode);
                    }
                }

                // Save the document XML back to its document part.
                xdoc.Save(wdDoc.MainDocumentPart.GetStream(FileMode.Create, FileAccess.Write));
            }
        }

 public void FortifyStrings_ContainsCorrectStrings()
 {
     var nameTable = new NameTable();
     var uut = new FortifyStrings(nameTable);
     Assert.AreSame(nameTable.Add("Issue"), uut.Issue);
     Assert.AreSame(nameTable.Add("iid"), uut.Iid);
     Assert.AreSame(nameTable.Add("ruleID"), uut.RuleId);
     Assert.AreSame(nameTable.Add("Category"), uut.Category);
     Assert.AreSame(nameTable.Add("Folder"), uut.Folder);
     Assert.AreSame(nameTable.Add("Kingdom"), uut.Kingdom);
     Assert.AreSame(nameTable.Add("Abstract"), uut.Abstract);
     Assert.AreSame(nameTable.Add("AbstractCustom"), uut.AbstractCustom);
     Assert.AreSame(nameTable.Add("Friority"), uut.Friority);
     Assert.AreSame(nameTable.Add("Tag"), uut.Tag);
     Assert.AreSame(nameTable.Add("Comment"), uut.Comment);
     Assert.AreSame(nameTable.Add("Primary"), uut.Primary);
     Assert.AreSame(nameTable.Add("Source"), uut.Source);
     Assert.AreSame(nameTable.Add("TraceDiagramPath"), uut.TraceDiagramPath);
     Assert.AreSame(nameTable.Add("ExternalCategory"), uut.ExternalCategory);
     Assert.AreSame(nameTable.Add("type"), uut.Type);
     Assert.AreSame(nameTable.Add("FileName"), uut.FileName);
     Assert.AreSame(nameTable.Add("FilePath"), uut.FilePath);
     Assert.AreSame(nameTable.Add("LineStart"), uut.LineStart);
     Assert.AreSame(nameTable.Add("Snippet"), uut.Snippet);
     Assert.AreSame(nameTable.Add("SnippetLine"), uut.SnippetLine);
     Assert.AreSame(nameTable.Add("TargetFunction"), uut.TargetFunction);
 }

 private XmlNamespaceManager GetNamespaceManager()
 {
     NameTable nt = new NameTable();
     XmlNamespaceManager mgr = new XmlNamespaceManager(nt);
     mgr.AddNamespace("sn", "http://www.sensenet.com/2010");
     return mgr;
 }

        public TestRunSummary Execute()
        {
            string vsFolder = Environment.Is64BitProcess ? @"%ProgramFiles(x86)%\Microsoft Visual Studio 10.0\Common7\IDE" : @"%ProgramFiles%\Microsoft Visual Studio 10.0\Common7\IDE";
            var nunitConsolePath = Path.Combine(AssemblyFolderHelper.GetTestAssemblyFolder(),
                Environment.ExpandEnvironmentVariables(vsFolder + @"\MsTest.exe"));

            string resultsFilePath = Path.Combine(inputProjectDriver.DeploymentFolder, "mstest-result.trx");

            var provessHelper = new ProcessHelper();
            provessHelper.RunProcess(nunitConsolePath, "\"/testcontainer:{0}\" \"/resultsfile:{1}\"", 
                inputProjectDriver.CompiledAssemblyPath, resultsFilePath);

            XDocument logFile = XDocument.Load(resultsFilePath);

            TestRunSummary summary = new TestRunSummary();

            XmlNameTable nameTable = new NameTable();
            XmlNamespaceManager namespaceManager = new XmlNamespaceManager(nameTable);
            namespaceManager.AddNamespace("mstest", "http://microsoft.com/schemas/VisualStudio/TeamTest/2010");

            var summaryElement = logFile.XPathSelectElement("//mstest:ResultSummary/mstest:Counters", namespaceManager);
            if (summaryElement != null)
            {
                summary.Total = int.Parse(summaryElement.Attribute("total").Value);
                summary.Succeeded = int.Parse(summaryElement.Attribute("passed").Value);
                summary.Failed = int.Parse(summaryElement.Attribute("failed").Value);
                summary.Pending = int.Parse(summaryElement.Attribute("inconclusive").Value);
                summary.Ignored = 0; // mstest does not support ignored in the report
            }

            testExecutionResult.LastExecutionSummary = summary;

            return summary;
        }

        static NuspecDocument()
        {
            var nameTable = new NameTable();

            _xmlNamespaceManager = new XmlNamespaceManager(nameTable);
            _xmlNamespaceManager.AddNamespace("nuspec", "http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd");
        }

 private XmlNamespaceManager AddNameSpaceTable(string parametersetname, XmlDocument xDoc, Hashtable namespacetable)
 {
     XmlNamespaceManager manager;
     if (parametersetname.Equals("Xml"))
     {
         XmlNameTable nameTable = new NameTable();
         manager = new XmlNamespaceManager(nameTable);
     }
     else
     {
         manager = new XmlNamespaceManager(xDoc.NameTable);
     }
     foreach (DictionaryEntry entry in namespacetable)
     {
         try
         {
             string prefix = entry.Key.ToString();
             manager.AddNamespace(prefix, entry.Value.ToString());
         }
         catch (NullReferenceException)
         {
             InvalidOperationException exception = new InvalidOperationException(StringUtil.Format(UtilityCommonStrings.SearchXMLPrefixNullError, new object[0]));
             ErrorRecord errorRecord = new ErrorRecord(exception, "PrefixError", ErrorCategory.InvalidOperation, namespacetable);
             base.WriteError(errorRecord);
         }
         catch (ArgumentNullException)
         {
             InvalidOperationException exception2 = new InvalidOperationException(StringUtil.Format(UtilityCommonStrings.SearchXMLPrefixNullError, new object[0]));
             ErrorRecord record2 = new ErrorRecord(exception2, "PrefixError", ErrorCategory.InvalidOperation, namespacetable);
             base.WriteError(record2);
         }
     }
     return manager;
 }

        /// <summary>
        /// Validates XML definition against given XSD schema.
        /// </summary>
        /// <param name="xmlFileName">Full path to the XML file on file system.</param>
        /// <param name="schemaContent">XSD schema.</param>
        /// <param name="schemaName">XSD schema name.</param>
        public void Validate(string xmlFileName, string schemaContent, string schemaName)
        {
            _xmlFileName = xmlFileName;

            var xmlDoc = GetUpdatedXml(xmlFileName, schemaName);
            var xmlSchemaSet = GetXmlSchema(schemaContent, schemaName);

            var nt = new NameTable();
            var nsmgr = new XmlNamespaceManager(nt);
            var context = new XmlParserContext(null, nsmgr, null, XmlSpace.None);

            var settings = new XmlReaderSettings();
            settings.ValidationType = ValidationType.Schema;
            settings.Schemas.Add(xmlSchemaSet);
            settings.ValidationEventHandler += ValidationCallbackOne;

            using (var xmlr = new XmlTextReader(xmlDoc.OuterXml, XmlNodeType.Document, context))
            {
                using (var reader = XmlReader.Create(xmlr, settings))
                {
                    while (reader.Read())
                    {
                        var val = reader.Value;
                    }
                }
            }
        }

        private static NameTable CreateAtomNameTable()
        {
            NameTable table = new NameTable();
            table.Add(XmlConstants.AtomNamespace);
            table.Add(XmlConstants.DataWebNamespace);
            table.Add(XmlConstants.DataWebMetadataNamespace);

            table.Add(XmlConstants.AtomContentElementName);
            table.Add(XmlConstants.AtomContentSrcAttributeName);
            table.Add(XmlConstants.AtomEntryElementName);
            table.Add(XmlConstants.AtomETagAttributeName);
            table.Add(XmlConstants.AtomFeedElementName);

            table.Add(XmlConstants.AtomIdElementName);

            table.Add(XmlConstants.AtomInlineElementName);
            table.Add(XmlConstants.AtomLinkElementName);
            table.Add(XmlConstants.AtomLinkRelationAttributeName);
            table.Add(XmlConstants.AtomNullAttributeName);
            table.Add(XmlConstants.AtomPropertiesElementName);
            table.Add(XmlConstants.AtomTitleElementName);
            table.Add(XmlConstants.AtomTypeAttributeName);

            table.Add(XmlConstants.XmlErrorCodeElementName);
            table.Add(XmlConstants.XmlErrorElementName);
            table.Add(XmlConstants.XmlErrorInnerElementName);
            table.Add(XmlConstants.XmlErrorMessageElementName);
            table.Add(XmlConstants.XmlErrorTypeElementName);
            return table;
        }

		void Initialize ()
		{
			var nt = new NameTable ();
			initial_reader = new NonInteractiveStateXmlReader (String.Empty, nt, ReadState.Initial);
			eof_reader = new NonInteractiveStateXmlReader (String.Empty, nt, ReadState.EndOfFile);
			xml_reader = initial_reader;
		}

        private static string ParseWordDoc(Stream file)
        {
            const string wordmlNamespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";

            System.Text.StringBuilder textBuilder = new System.Text.StringBuilder();
            using (WordprocessingDocument wdDoc = WordprocessingDocument.Open(file, false))
            {

                NameTable nt = new NameTable();
                XmlNamespaceManager nsManager = new XmlNamespaceManager(nt);
                nsManager.AddNamespace("w", wordmlNamespace);
                XmlDocument xdoc = new XmlDocument(nt);
                xdoc.Load(wdDoc.MainDocumentPart.GetStream());

                XmlNodeList paragraphNodes = xdoc.SelectNodes("//w:p", nsManager);
                foreach (XmlNode paragraphNode in paragraphNodes)
                {
                    XmlNodeList textNodes = paragraphNode.SelectNodes(".//w:t", nsManager);
                    foreach (System.Xml.XmlNode textNode in textNodes)
                    {
                        textBuilder.Append(textNode.InnerText);
                    }
                    textBuilder.Append(Environment.NewLine);
                }

            }
            file.Close();
            return textBuilder.ToString();

        }

		public XmlEditorNavigator(XmlEditorNavigator navigator ) 
		{
			//StreamUtil.WriteText("I:\\debug.txt","进到 构造函数XmlEditorNavigator(navigator)里\r\n");

            this.m_navigatorState = new NavigatorState(navigator.m_navigatorState);
            this.m_nametable = (NameTable)navigator.NameTable;
		}

    /// <include file='doc\XmlPatch.uex' path='docs/doc[@for="XmlPatch.Patch3"]/*' />
    /// <summary>
    ///    Reads the XDL diffgram from the diffgramFileName and modifies the original XML document
    ///    sourceDoc according to the changes described in the diffgram. 
    /// </summary>
    /// <param name="sourceDoc">The original xml document</param>
    /// <param name="diffgramFileName">XmlReader for the XDL diffgram.</param>
	public void Patch( string sourceFile, Stream outputStream, XmlReader diffgram ) 
	{
        if ( sourceFile == null )
            throw new ArgumentNullException( "sourceFile" );
        if ( outputStream == null )
            throw new ArgumentNullException( "outputStream" );
        if ( diffgram == null ) 
            throw new ArgumentException( "diffgram" );

        XmlDocument diffDoc = new XmlDocument();
        diffDoc.Load( diffgram );

        // patch fragment
        if ( diffDoc.DocumentElement.GetAttribute( "fragments" ) == "yes" ) {
            NameTable nt = new NameTable();
            XmlTextReader tr = new XmlTextReader( new FileStream( sourceFile, FileMode.Open, FileAccess.Read ),
                                                  XmlNodeType.Element,
                                                  new XmlParserContext( nt, new XmlNamespaceManager( nt ),
                                                                        string.Empty, XmlSpace.Default ) );
            Patch( tr, outputStream, diffDoc ); 
        }
        // patch document
        else {
            Patch ( new XmlTextReader( sourceFile ), outputStream, diffDoc );
        }
	}

 //[Variation(Desc = "v3 - XmlDataSourceResolver(XmlNameTable = valid) check back")]
 public void v3()
 {
     NameTable NT = new NameTable();
     XmlSchemaSet sc = new XmlSchemaSet(NT);
     Assert.Equal(sc.NameTable, NT);
     return;
 }

        /// <summary>
        /// Method to parse the vector styles from a <see cref="XmlDocument"/>
        /// </summary>
        /// <param name="doc">The xml document</param>
        /// <returns>A dictionary of vector styles</returns>
        public static IDictionary<string, VectorStyle> ParseFeatureStyle(XmlDocument doc)
        {
            var styles = new Dictionary<string, VectorStyle>();

            // Load SLD file
            var nt = new NameTable();
            var nsm = new XmlNamespaceManager(nt);
            nsm.AddNamespace("sld", "http://www.opengis.net/sld");
            nsm.AddNamespace("ogc", "http://www.opengis.net/ogc");
            nsm.AddNamespace("xlink", "http://www.w3.org/1999/xlink");


            var sldConfig = new XmlDocument(nt);
            sldConfig.LoadXml(doc.OuterXml);

            var featureTypeStyleEls = sldConfig.SelectNodes("//sld:FeatureTypeStyle", nsm);
            if (featureTypeStyleEls == null)
                return null;
            
            foreach (XmlElement featTypeStyle in featureTypeStyleEls)
            {
                var el = (XmlElement) featTypeStyle.SelectSingleNode("sld:FeatureTypeName", nsm);
                var mainName = el != null ? el.InnerText : "";
                var rules = featTypeStyle.SelectNodes("sld:Rule", nsm);

                if (rules != null)
                {
                    foreach (XmlElement rule in rules)
                    {
                        el = (XmlElement) rule.SelectSingleNode("sld:Name", nsm);
                        var name = el != null ? el.InnerText : "";
                        var style = new VectorStyle();
                        SetSymbologyForRule(style, rule, nsm);
                        styles.Add(mainName + ":" + name, style);
                    }
                }
            }

            return styles;


            //style.AreFeaturesSelectable
            //style.Enabled
            //style.EnableOutline
            //style.Fill
            //style.HighlightFill
            //style.HighlightLine
            //style.HighlightOutline
            //style.HighlightSymbol
            //style.Line
            //style.MaxVisible
            //style.MinVisible
            //style.Outline
            //style.RenderingMode
            //style.SelectFill
            //style.SelectLine
            //style.SelectOutline
            //style.SelectSymbol
        }

        /// <summary>
        /// 
        /// </summary>
        /// 
        /// <param name="soapMessage"></param>
        /// <param name="actor"></param>
        /// <param name="description"></param>
        /// <param name="source"></param>
        /// 
        /// <returns></returns>
        ///
        public static int CreateSoapHeader(XmlDocument soapMessage, string actor, string description, string source, long elapsed)
        {
            // Set up a name table so we can query based on namespaces
            NameTable SoapNameTable = new NameTable();
            XmlNamespaceManager soapNamespaceManager = new XmlNamespaceManager(SoapNameTable);
            soapNamespaceManager.AddNamespace(String.Empty, "urn:none");
            soapNamespaceManager.AddNamespace("soap", SoapURN);

            // Find the header block
            XmlElement header = (XmlElement)soapMessage.SelectSingleNode("/soap:Envelope/soap:Header", soapNamespaceManager);
            if (Guard.IsNull(header))
            {
                // If none exists and there is a soap:Envelope, create the header
                XmlElement envelope = (XmlElement)soapMessage.SelectSingleNode("/soap:Envelope", soapNamespaceManager);
                if (Guard.IsNull(envelope))
                {
                    return -1;
                }
                header = soapMessage.CreateElement("soap", "Header", SoapURN);
                envelope.AppendChild(header);
            }

            // Create, populate and add various pieces of data
            XmlElement action = soapMessage.CreateElement("action");
            XmlElement actorElement = soapMessage.CreateElement("actor");
            XmlElement from = soapMessage.CreateElement("from");
            XmlElement time = soapMessage.CreateElement("timestamp");
            XmlElement machine = soapMessage.CreateElement("machine");
            XmlElement descriptionElement = soapMessage.CreateElement("description");
            XmlElement timeElement = soapMessage.CreateElement("elapsed");

            actorElement.AppendChild(soapMessage.CreateTextNode(actor));
            from.AppendChild(soapMessage.CreateTextNode(source));
            time.AppendChild(soapMessage.CreateTextNode(DateTime.Now.ToString()));
            machine.AppendChild(soapMessage.CreateTextNode(System.Net.Dns.GetHostName()));
            descriptionElement.AppendChild(soapMessage.CreateTextNode(description));
            timeElement.AppendChild(soapMessage.CreateTextNode(elapsed.ToString()));

            action.AppendChild(actorElement);
            action.AppendChild(from);
            action.AppendChild(time);
            action.AppendChild(machine);
            action.AppendChild(descriptionElement);
            action.AppendChild(timeElement);

            // Try to set an index up
            try
            {
                action.SetAttribute("index", (header.SelectNodes("action").Count + 1).ToString());
            }
            catch
            {
                action.SetAttribute("index", "1");
            }

            // Add this header to the document
            header.AppendChild(action);
            return header.SelectNodes("action").Count;
        }

 public NonValidatingReader(string content)
     : base()
 {
     this.content = content;
     _NameTable = new NameTable();
     Namespaces = new Dictionary<string,string>();
     Namespaces.Add(_NameTable.Add("xml"),"http://www.w3.org/XML/1998/namespace");
 }

        static CfgXmlHelper()
        {
            NameTable nt = new NameTable();
            nsMgr = new XmlNamespaceManager(nt);
            nsMgr.AddNamespace(CfgNamespacePrefix, CfgSchemaXMLNS);

            SearchFactoryExpression = XPathExpression.Compile(RootPrefixPath + ":search-factory", nsMgr);
        }