C# XmlTextWriter.Dispose方法代碼示例

 public ActionResult ViewDrivingLicense(string id)
 {
     if (id == null)
     {
         return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
     }
     DLDetails inventory = _dbContext.DLDetailss.Find(id);
     generateXML(inventory);
     XslTransform xslt = new XslTransform();
     String path = HostingEnvironment.MapPath("~/XMLClasses/DrivingLicense.xsl");
     xslt.Load(path);
     path = HostingEnvironment.MapPath("~/XMLClasses/DrivingLicense.xml");
     XPathDocument xpathdocument = new
     XPathDocument(path);
     path = HostingEnvironment.MapPath("~/XMLClasses/MyDrivingLicense.html");
     XmlTextWriter writer = new XmlTextWriter(path, UTF8Encoding.UTF8);
     writer.Formatting = Formatting.Indented;
     xslt.Transform(xpathdocument, null, writer, null);
     writer.Flush();
     writer.Close();
     writer.Dispose();
     return new FilePathResult(path, "text/html");
 }

        public static void Save(TilesMap tilesmap, string path)
        {
            if (tilesmap == null)
                throw new ArgumentException("Argument does not accept null", "tilesmap");
            if (path == null)
                throw new ArgumentException("Argument does not accept null", "path");
            using (XmlTextWriter wr = new XmlTextWriter(path, Encoding.UTF8))
            {
                wr.Formatting = Formatting.Indented;
                wr.WriteStartDocument();
                wr.WriteStartElement("Tilesmap");
                {
                    wr.WriteAttributeString("columns", tilesmap.Columns.ToString());
                    wr.WriteAttributeString("rows", tilesmap.Rows.ToString());

                    wr.WriteStartElement("MatrixIndex");
                    {
                        for (int i = 0; i < tilesmap.Rows; i++)
                        {
                            wr.WriteStartElement("Row");
                            {
                                wr.WriteAttributeString("id", i.ToString());
                                for (int j = 0; j < tilesmap.Columns; j++)
                                {
                                    wr.WriteString(tilesmap[j, i].ToString());
                                    if (j != tilesmap.Columns - 1)
                                        wr.WriteString("\t");
                                }
                            }
                            wr.WriteEndElement(); // rows
                        }
                    }
                    wr.WriteEndElement();   // Matrixindex
                    if (tilesmap.TileSet != null)
                    {
                        TileSet.Save(wr, tilesmap.TileSet, path);
                    }
                    if (tilesmap.ListObject.Any())
                    {
                        ObjectEditor.Save(wr, tilesmap.ListObject, path);
                    }

                }

                wr.WriteEndElement();       // Tiles map
                wr.WriteEndDocument();
                wr.Close();
                wr.Dispose();
            }
        }

        public int TransformResolver(String szXmlFile, XmlResolver xr, bool errorCase)
        {
            szXmlFile = FullFilePath(szXmlFile);

            _output.WriteLine("Loading XML " + szXmlFile);
            IXPathNavigable xd = LoadXML(szXmlFile, _navType);

            _output.WriteLine("Executing transform");
            xrXSLT = null;
            Stream strmTemp = null;

            switch (_nOutput)
            {
                case OutputType.Stream:
                    try
                    {
                        strmTemp = new FileStream(_strOutFile, FileMode.Create, FileAccess.ReadWrite);
                        xslt.Transform(xd, null, strmTemp);
                    }
                    catch (Exception ex)
                    {
                        throw (ex);
                    }
                    finally
                    {
                        if (strmTemp != null)
                            strmTemp.Dispose();
                    }
                    break;

                case OutputType.Writer:
                    XmlWriter xw = null;
                    try
                    {
                        xw = new XmlTextWriter(_strOutFile, Encoding.UTF8);
                        xw.WriteStartDocument();
                        xslt.Transform(xd, null, xw);
                    }
                    catch (Exception ex)
                    {
                        throw (ex);
                    }
                    finally
                    {
                        if (xw != null)
                            xw.Dispose();
                    }
                    break;

                case OutputType.TextWriter:
                    TextWriter tw = null;
                    try
                    {
                        tw = new StreamWriter(new FileStream(_strOutFile, FileMode.Create, FileAccess.Write), Encoding.UTF8);
                        xslt.Transform(xd, null, tw);
                    }
                    catch (Exception ex)
                    {
                        throw (ex);
                    }
                    finally
                    {
                        if (tw != null)
                            tw.Dispose();
                    }
                    break;
            }
            return 1;
        }

    public void Save(string strName, bool fOverWrite, System.Text.Encoding Encoding)
    {
        CXmlBase rNode;
        XmlTextWriter rXmlTextWriter = null;

        try
        {
            if (fOverWrite)
            {
                File.Delete(strName);
            }

            rXmlTextWriter = new XmlTextWriter(strName, Encoding);
            rXmlTextWriter.Namespaces = _fNamespaces;

            for (rNode = _rDocumentRootNode._rFirstChildNode; rNode != null; rNode = rNode._rNextNode)
            {
                rNode.Write(rXmlTextWriter);
            }
            rXmlTextWriter.Dispose();
        }
        catch (Exception e)
        {
            DebugTrace(e.ToString());
            if (rXmlTextWriter != null)
                rXmlTextWriter.Dispose();
            throw (e);
        }
    }

        public bool Table_Save(Guid tableId, object table)
        {
            var returnValue = false;

            try
            {
                var fileName = Path.Combine(this._tableDirectoryPath, tableId + ".xml");
                var fileStream = base.GetFileWriteStream(fileName);
                var xmlTextWriter = new XmlTextWriter(fileStream, encoding);

                Serializer.Serialize(xmlTextWriter, table);

                fileStream.Close();
                fileStream.Dispose();

                xmlTextWriter.Close();
                xmlTextWriter.Dispose();
            }
            catch (Exception ex)
            {
                if (this._logger != null)
                {
                    this._logger.Log(ex.Message, Category.Exception, Priority.High);
                }
            }

            return returnValue;
        }

        public void export(String fileName)
        {
            WindowTitle = "Exporting Tags";

            XmlTextWriter outFile = null;
            try
            {
                if (CancellationToken.IsCancellationRequested) return;

                outFile = new XmlTextWriter(fileName, Encoding.UTF8);
                outFile.Formatting = Formatting.Indented;
                Type[] knownTypes = new Type[] { typeof(TagDTO), typeof(TagCategoryDTO) };

                DataContractSerializer tagSerializer = new DataContractSerializer(typeof(List<TagDTO>), knownTypes);

                using (var tagCommands = new TagDbCommands())
                {
                    tagCommands.Db.Configuration.ProxyCreationEnabled = false;
                    List<Tag> tags = tagCommands.getAllTags(true);
                    TotalProgressMax = tags.Count;
                    TotalProgress = 0;
                    List<TagDTO> tagsDTO = new List<TagDTO>();

                    foreach (Tag tag in tags)
                    {
                        if (CancellationToken.IsCancellationRequested) return;

                        var tagDTO = Mapper.Map<Tag, TagDTO>(tag, new TagDTO());

                        ItemInfo = "Exporting: " + tagDTO.Name;
                        ItemProgress = 0;

                        tagsDTO.Add(tagDTO);

                        ItemProgress = 100;
                        InfoMessages.Add("Exported: " + tagDTO.Name);
                        TotalProgress++;
                    }

                    tagSerializer.WriteObject(outFile, tagsDTO);
                }               
            }
            catch (Exception e)
            {
                InfoMessages.Add("Error exporting tags: " + e.Message);                           
            }
            finally
            {
                operationFinished();    

                if (outFile != null)
                {
                    outFile.Dispose();
                }
            }
        }

        public int Transform_ArgList(String szXmlFile, bool errorCase)
        {
            lock (s_outFileMemoryLock)
            {
                szXmlFile = FullFilePath(szXmlFile);

                _output.WriteLine("Loading XML {0}", szXmlFile);
                IXPathNavigable xd = LoadXML(szXmlFile, _docType);

                _output.WriteLine("Executing transform");
                xrXSLT = null;
                Stream strmTemp = null;
                switch (_nTransform)
                {
                    case TransformType.Reader:
                        xrXSLT = xslt.Transform(xd, m_xsltArg);
                        if (errorCase)
                        {
                            try
                            {
                                while (xrXSLT.Read()) { }
                            }
                            catch (Exception ex)
                            {
                                throw (ex);
                            }
                            finally
                            {
                                if (xrXSLT != null)
                                    xrXSLT.Dispose();
                            }
                        }
                        break;

                    case TransformType.Stream:
                        try
                        {
                            strmTemp = new FileStream(_strOutFile, FileMode.Create, FileAccess.ReadWrite);
                            xslt.Transform(xd, m_xsltArg, strmTemp);
                        }
                        catch (Exception ex)
                        {
                            throw (ex);
                        }
                        finally
                        {
                            if (strmTemp != null)
                                strmTemp.Dispose();
                        }
                        break;

                    case TransformType.Writer:
                        XmlWriter xw = null;
                        try
                        {
                            xw = new XmlTextWriter(_strOutFile, Encoding.UTF8);
                            xw.WriteStartDocument();
                            xslt.Transform(xd, m_xsltArg, xw);
                        }
                        catch (Exception ex)
                        {
                            throw (ex);
                        }
                        finally
                        {
                            if (xw != null)
                                xw.Dispose();
                        }
                        break;

                    case TransformType.TextWriter:
                        TextWriter tw = null;
                        try
                        {
                            tw = new StreamWriter(new FileStream(_strOutFile, FileMode.Create, FileAccess.Write), Encoding.UTF8);
                            xslt.Transform(xd, m_xsltArg, tw);
                        }
                        catch (Exception ex)
                        {
                            throw (ex);
                        }
                        finally
                        {
                            if (tw != null)
                            {
                                tw.Dispose();
                            }
                        }
                        break;
                }
                return 1;
            }
        }

        private void createXML()
        {
            XmlTextWriter textWritter;
            XmlDocument document;
            XmlNode element;
            XmlAttribute attribute;
            XmlNode subElement;

            #region ore.xml
            //создание ore.xml
            textWritter = new XmlTextWriter("ore.xml", Encoding.UTF8);
            textWritter.WriteStartDocument();
            textWritter.WriteStartElement("head");
            textWritter.WriteEndElement();

            //запись в ore.xml
            document = new XmlDocument();
            document.Load("ore.xml");

            //заполнение ore.xml
            foreach (KeyValuePair<string, TradeSystem.Goods.Ore> pair in oreList)
            {
                element = document.CreateElement("ore");
                document.DocumentElement.AppendChild(element);
                attribute = document.CreateAttribute("Имя");
                attribute.Value = pair.Value.getName();
                element.Attributes.Append(attribute);

                subElement = document.CreateElement("price");
                subElement.InnerText = pair.Value.getPrice().ToString();
                element.AppendChild(subElement);

                subElement = document.CreateElement("rarity");
                subElement.InnerText = pair.Value.getRarity().ToString();
                element.AppendChild(subElement);

                subElement = document.CreateElement("product");
                subElement.InnerText = pair.Value.getProduct().ToString();
                element.AppendChild(subElement);

                subElement = document.CreateElement("refTime");
                subElement.InnerText = pair.Value.getRefTime().ToString();
                element.AppendChild(subElement);

                subElement = document.CreateElement("need");
                subElement.InnerText = pair.Value.getNeed().ToString();
                element.AppendChild(subElement);

                subElement = document.CreateElement("demand");
                subElement.InnerText = pair.Value.getDemand().ToString();
                element.AppendChild(subElement);

                subElement = document.CreateElement("supply");
                subElement.InnerText = pair.Value.getSupply().ToString();
                element.AppendChild(subElement);

                subElement = document.CreateElement("labor");
                subElement.InnerText = pair.Value.getLabor().ToString();
                element.AppendChild(subElement);
            }
            document.Save("ore.xml");
            textWritter.Close();
            textWritter.Dispose();
            #endregion

            #region ignots.xml
            textWritter = new XmlTextWriter("ignots.xml", Encoding.UTF8);
            textWritter.WriteStartDocument();
            textWritter.WriteStartElement("head");
            textWritter.WriteEndElement();
            document = new XmlDocument();
            document.Load("ignots.xml");

            foreach (KeyValuePair<string, TradeSystem.Goods.Ignots> pair in ignotsList)
            {
                element = document.CreateElement("ignot");
                document.DocumentElement.AppendChild(element);
                attribute = document.CreateAttribute("Имя");
                attribute.Value = pair.Value.getName();
                element.Attributes.Append(attribute);

                subElement = document.CreateElement("price");
                subElement.InnerText = pair.Value.getPrice().ToString();
                element.AppendChild(subElement);
            }
            document.Save("ignots.xml");
            textWritter.Close();
            textWritter.Dispose();
            #endregion
        }

 public void TransformStrStrResolver1()
 {
     String szFullFilename = FullFilePath("fruits.xml");
     try
     {
         if (LoadXSL("xmlResolver_main.xsl", new XmlUrlResolver()) == 1)
         {
             XmlTextReader xr = new XmlTextReader(szFullFilename);
             XmlTextWriter xw = new XmlTextWriter("out.xml", Encoding.Unicode);
             xslt.Transform(xr, null, xw, null);
             xr.Dispose();
             xw.Dispose();
             if (CheckResult(403.7784431795) == 1)
                 return;
             else
                 Assert.True(false);
         }
     }
     catch (Exception e)
     {
         _output.WriteLine(e.ToString());
         Assert.True(false);
     }
     Assert.True(false);
 }

        public void TransformStrStrResolver1()
        {
            String szFullFilename = FullFilePath("fruits.xml");
            string expected = @"<result>
  <fruit>Apple</fruit>
  <fruit>orange</fruit>
</result>";

            if (LoadXSL("XmlResolver_Main.xsl", new XmlUrlResolver()) == 1)
            {
                XmlTextReader xr = new XmlTextReader(szFullFilename);
                XmlTextWriter xw = new XmlTextWriter("out.xml", Encoding.Unicode);
                xslt.Transform(xr, null, xw, null);
                xr.Dispose();
                xw.Dispose();
                VerifyResult(expected);
                return;
            }
            Assert.True(false);
        }

 public void Save()
 {
     string name = _Doc.DocumentElement.Name +".xml";
     XmlTextWriter xtw = new XmlTextWriter(name,null);
     xtw.Formatting = Formatting.Indented;
     _Doc.Save(xtw);
     xtw.Dispose();
     LoadXMLDoc(name);
 }

        /// <summary>
        /// Enables inspection or modification of a message before a request message is sent to a service.
        /// </summary>
        /// <param name="request">The message to be sent to the service.</param>
        /// <param name="channel">The WCF client object channel.</param>
        /// <returns>The object that is returned as the correlationState argument of the AfterReceiveReply method. This is null if no correlation state is used.</returns>
        /// <exception cref="System.ArgumentNullException">
        /// request
        /// or
        /// channel
        /// </exception>
        /// <exception cref="ArgumentNullException">The <paramref name="request"/> parameter is null.</exception>
        /// <exception cref="ArgumentNullException">The <paramref name="channel"/> parameter is null.</exception>
        public object BeforeSendRequest(ref Message request, IClientChannel channel)
        {
            if (request == null)
                throw new ArgumentNullException("request");

            if (channel == null)
                throw new ArgumentNullException("channel");

            var message = request;

            var extension = OperationContext.Current.Extensions.Find<IntegrationServiceOperationContextExtension>();

            if (extension == null)
                return null;

            foreach (var attributes in
                extension.HeaderAttributes.Where(attributes => attributes.IsActorSet || attributes.IsMustUnderstandSet || attributes.IsRelaySet))
            {
                int index;
               
                for (index = 0; index < message.Headers.Count; ++index)
                {
                    var header = message.Headers[index];
                    if (header.Name == attributes.HeaderName && header.Namespace == attributes.HeaderNamespace)
                        break;
                }

                if (index >= message.Headers.Count)
                    continue;

                var oldHeader = message.Headers[index];
                var sb = new StringBuilder();

                StringWriter writer = null;
                XmlTextWriter xmlWriter = null;
                
                try
                {
                    writer = new StringWriter(sb, CultureInfo.InvariantCulture);

                    xmlWriter = new XmlTextWriter(writer);
                    xmlWriter.WriteStartDocument();
                    message.Headers.WriteHeader(index, xmlWriter);
                }
                finally
                {
                    if (xmlWriter != null)
                        xmlWriter.Dispose();
                    else
                    {
                        if (writer != null)
                            writer.Dispose();
                    }
                }

                var xmlDocument = new XmlDocument();
                xmlDocument.LoadXml(sb.ToString());

                var mustUnderstand = attributes.IsMustUnderstandSet ? attributes.MustUnderstand : oldHeader.MustUnderstand;
                var actor = attributes.IsActorSet ? attributes.Actor : oldHeader.Actor;
                var relay = attributes.IsRelaySet ? attributes.Relay : oldHeader.Relay;

                var newHeader = new XmlElementMessageHeader(
                    oldHeader.Name, oldHeader.Namespace, mustUnderstand, actor, relay, xmlDocument.DocumentElement);

                message.Headers.RemoveAt(index);
                message.Headers.Insert(index, newHeader);
            }

            return null;
        }

        void IExportLeonFormatService.GenerateLeonFormat(List<Lag> items)
        {
            try
            {
                List<Lag> itemsToConvert = items.OrderBy(x => x.LagNummer).ToList();
                foreach (var lag in itemsToConvert)
                {
                    lag.SkiverILaget = lag.SkiverILaget.OrderBy(y => y.SkiveNummer).ToList();
                }

            if (itemsToConvert != null)
            {
                    var outputXmlStream = new MemoryStream { Position = 0 };
                    var memStevne = new MemoryStream();
                    XmlTextWriter write = new XmlTextWriter(memStevne, new UTF8Encoding(false));
                    this.m_serLag.Serialize(write, itemsToConvert);
                    write.Flush();
                    memStevne.Position = 0;

                    var debugStrem = new MemoryStream(memStevne.ToArray());
                    debugStrem.Position = 0;
                    var settings = new XmlReaderSettings();

                    XmlReader xmlReader = XmlReader.Create(debugStrem, settings);
                    XmlDocument docdebug = new XmlDocument();
                    docdebug.Load(xmlReader);

                    memStevne.Position = 0;
                    XPathDocument xpathDoc;
                    var enc = new UTF8Encoding(false);
                    var reader = new StreamReader(memStevne, enc, true);

                    // XmlTextReader xmlReader = new XmlTextReader(reader);
                    xpathDoc = new XPathDocument(reader);
                    this.m_xsltLeonFormat.Transform(xpathDoc, null, outputXmlStream);
                    outputXmlStream.Position = 0;
                    XmlDocument docSaver = new XmlDocument();
                    StreamReader readerOut = new StreamReader(outputXmlStream, enc, true);
                    XmlTextReader xmlReaderOut = new XmlTextReader(readerOut);
                    docSaver.Load(xmlReaderOut);
                     string fileexportName = Path.Combine(m_exportDirLeon, "Paameldinger.xml");
                    if (!string.IsNullOrEmpty(fileexportName))
                    {
                        Log.Info("Generating new Start List {0}", fileexportName);
                        var encServer = Encoding.GetEncoding("UTF-8");
                        XmlTextWriter writer = new XmlTextWriter(fileexportName, encServer);
                        writer.Formatting = Formatting.Indented;
                        docSaver.Save(writer);
                        writer.Flush();
                        writer.Close();
                        writer.Dispose();
                    }

                    string debugfileexportName = Path.Combine(m_exportDirLeon, "InputXml.xml");
                    if (!string.IsNullOrEmpty(debugfileexportName))
                    {
                        Log.Info("Generating new DebugXml {0}", debugfileexportName);
                        var encServer = Encoding.GetEncoding("UTF-8");
                        XmlTextWriter writer = new XmlTextWriter(debugfileexportName, encServer);
                        writer.Formatting = Formatting.Indented;
                        docdebug.Save(writer);
                        writer.Flush();
                        writer.Close();
                        writer.Dispose();
                    }
                }
            }
            catch (Exception e)
            {
                Log.Error(e, "Error GenerateLeonFormat");
                throw;
            }
        }

        private static void CreateXmlPhonebook(string pathToTxtFile)
        {
            int lineNumber = 0;
            var writer = new XmlTextWriter("../../phonebook.xml", Encoding.UTF8);
            writer.WriteStartDocument();
            writer.WriteStartElement("entries");
            using (var reader = new StreamReader(pathToTxtFile))
            {
                while (!reader.EndOfStream)
                {
                    switch (lineNumber % 3)
                    {
                        case 0: writer.WriteStartElement("entry");
                                writer.WriteElementString("name", reader.ReadLine());
                            break;
                        case 1: writer.WriteElementString("address", reader.ReadLine());
                            break;
                        case 2: writer.WriteElementString("phone", reader.ReadLine());
                                writer.WriteEndElement();
                            break;
                    }

                    lineNumber++;
                }
            }

            writer.WriteEndElement();
            writer.WriteEndDocument();
            writer.Close();
            writer.Dispose();
        }