/// <summary> /// Decode an AMF packet into an AMFX format. /// </summary> /// <exception cref="FormatException">Error during decoding.</exception> public void Decode(Stream stream, XmlWriter output) { if (stream == null) throw new ArgumentNullException("stream"); if (!stream.CanRead) throw new ArgumentException(Errors.AmfPacketReader_Read_StreamClosed, "stream"); if (output == null) throw new ArgumentNullException("output"); try { var amfStreamReader = new AmfStreamReader(stream); var version = ReadPacketVersion(amfStreamReader); var decoder = CreateDecoder(version, _options); output.WriteStartDocument(); output.WriteStartElement(AmfxContent.AmfxDocument, AmfxContent.Namespace); output.WriteAttributeString(AmfxContent.VersionAttribute, version.ToAmfxName()); output.Flush(); //Read headers var headerCount = ReadDataCount(amfStreamReader); for (var i = 0; i < headerCount; i++) { var header = decoder.ReadPacketHeader(stream); output.WriteStartElement(AmfxContent.PacketHeader); output.WriteAttributeString(AmfxContent.PacketHeaderName, header.Name); output.WriteAttributeString(AmfxContent.PacketHeaderMustUnderstand, header.MustUnderstand.ToString()); decoder.Decode(stream, output); output.WriteEndElement(); output.Flush(); } //Read messages var messageCount = ReadDataCount(amfStreamReader); for (var i = 0; i < messageCount; i++) { var body = decoder.ReadPacketBody(stream); output.WriteStartElement(AmfxContent.PacketBody); output.WriteAttributeString(AmfxContent.PacketBodyTarget, body.Target); output.WriteAttributeString(AmfxContent.PacketBodyResponse, body.Response); decoder.Decode(stream, output); output.WriteEndElement(); output.Flush(); } output.WriteEndElement(); output.WriteEndDocument(); output.Flush(); } catch (Exception e) { output.Flush(); throw new FormatException(Errors.AmfPacketReader_DecodingError, e); } }
public void WriteToXML(XmlWriter writer) { writer.WriteStartElement("NeuronLayer"); writer.WriteAttributeString("ID", Convert.ToString(mID)); writer.WriteAttributeString("NumNeurons", Convert.ToString(mNumNeurons)); writer.WriteAttributeString("NumInputsPerNeuron", Convert.ToString(mNumInputsPerNeuron)); writer.Flush(); foreach (Neuron n in mNeurons) n.WriteToXML(writer); writer.WriteEndElement(); writer.Flush(); }
public override void ExecuteResult(ControllerContext context) { var response = context.HttpContext.Response; response.ClearContent(); response.ContentType = "text/xml"; response.AddHeader("Content-Disposition", string.Format("attachment; filename={0}.xml", _exportName)); var settings = new XmlWriterSettings { Indent = true, Encoding = Encoding.UTF8, ConformanceLevel = ConformanceLevel.Document, CheckCharacters = true, NamespaceHandling = NamespaceHandling.OmitDuplicates }; _writer = XmlWriter.Create(response.OutputStream, settings); _writer.WriteStartDocument(true); AddItem(_blob, _rootName, true); _writer.WriteEndDocument(); _writer.Flush(); _writer = null; }
// *************************************************************************** // Beendet an zu schreiben public static void EndXML(XmlWriter writer) { writer.WriteEndElement(); writer.WriteEndDocument(); writer.Flush(); writer.Close(); }
public void Serialize(DbDatabaseMapping databaseMapping, XmlWriter xmlWriter) { DebugCheck.NotNull(xmlWriter); DebugCheck.NotNull(databaseMapping); Debug.Assert(databaseMapping.Model != null); Debug.Assert(databaseMapping.Database != null); _xmlWriter = xmlWriter; _databaseMapping = databaseMapping; _version = databaseMapping.Model.SchemaVersion; _namespace = Equals(_version, XmlConstants.EdmVersionForV3) ? EdmXmlNamespaceV3 : (Equals(_version, XmlConstants.EdmVersionForV2) ? EdmXmlNamespaceV2 : EdmXmlNamespaceV1); _xmlWriter.WriteStartDocument(); using (Element("Edmx", "Version", string.Format(CultureInfo.InvariantCulture, "{0:F1}", _version))) { WriteEdmxRuntime(); WriteEdmxDesigner(); } _xmlWriter.WriteEndDocument(); _xmlWriter.Flush(); }
public void Serialize(DbDatabaseMapping databaseMapping, DbProviderInfo providerInfo, XmlWriter xmlWriter) { //Contract.Requires(xmlWriter != null); //Contract.Requires(databaseMapping != null); //Contract.Requires(providerInfo != null); Contract.Assert(databaseMapping.Model != null); Contract.Assert(databaseMapping.Database != null); _xmlWriter = xmlWriter; _databaseMapping = databaseMapping; _version = databaseMapping.Model.Version; _providerInfo = providerInfo; _namespace = _version == DataModelVersions.Version3 ? EdmXmlNamespaceV3 : EdmXmlNamespaceV2; _xmlWriter.WriteStartDocument(); using (Element("Edmx", "Version", string.Format(CultureInfo.InvariantCulture, "{0:F1}", _version))) { WriteEdmxRuntime(); WriteEdmxDesigner(); } _xmlWriter.WriteEndDocument(); _xmlWriter.Flush(); }
public void Write(Resource rsrc) { var settings = new XmlWriterSettings(); settings.Indent = PrettyPrint; settings.IndentChars = "\t"; using (this.writer = XmlWriter.Create(stream, settings)) { writer.WriteStartElement("save"); writer.WriteStartElement("header"); writer.WriteAttributeString("version", LSXReader.CurrentVersion); writer.WriteAttributeString("time", rsrc.Metadata.timestamp.ToString()); writer.WriteEndElement(); writer.WriteStartElement("version"); writer.WriteAttributeString("major", rsrc.Metadata.majorVersion.ToString()); writer.WriteAttributeString("minor", rsrc.Metadata.minorVersion.ToString()); writer.WriteAttributeString("revision", rsrc.Metadata.revision.ToString()); writer.WriteAttributeString("build", rsrc.Metadata.buildNumber.ToString()); writer.WriteEndElement(); WriteRegions(rsrc); writer.WriteEndElement(); writer.Flush(); } }
private void ProcessTag(IEnumerable<tag_group> h2Tags, string folder, BinaryReader reader, XmlWriter writer, tag_group tag) { const int @null = -1; List<tag_field> fields = null; if (tag.parent_group_tag != @null) { fields = new List<tag_field>(); var parent = h2Tags.Where(x => x.group_tag == tag.parent_group_tag).Single(); if (parent.parent_group_tag != @null) { var @base = h2Tags.Where(x => x.group_tag == parent.parent_group_tag).Single(); fields.AddRange(ExtractFields(h2Tags, reader, @base)); } fields.AddRange(ExtractFields(h2Tags, reader, parent)); fields.AddRange(ExtractFields(h2Tags, reader, tag)); } // Process the tag_group definition. var fieldOffset = 0; ProcessTagBlockDefinition(tag.Definition, writer, tag.definition_address, ref fieldOffset, tag.Class.ToString(), "", root, false, fields); root = root ? false : false; writer.Flush(); //File.WriteAllText(string.Format("{0}\\{1}.cs", folder, readTag.Name), writer.ToString()); return; }
public static void Write(XmlWriter writer, Ticket pt) { var declarations = NamespaceDeclarations(pt); writer.WriteStartDocument(); var prefix = declarations.LookupPrefix(Psf.PrintTicket.NamespaceName); writer.WriteStartElement(prefix, Psf.PrintTicket.LocalName, Psf.PrintTicket.NamespaceName); writer.WriteAttributeString("version", "1"); foreach (var decl in declarations) { writer.WriteAttributeString("xmlns", decl.Prefix, null, decl.Uri.NamespaceName); } foreach (var f in pt.Features()) { Write(writer, f); } foreach (var p in pt.Properties()) { Write(writer, p); } foreach (var p in pt.Parameters()) { Write(writer, p); } writer.WriteEndElement(); writer.Flush(); }
public void DbmlToFile(Database db, string filename, Encoding encoding) { var settings = new XmlWriterSettings {Indent = true, Encoding = encoding}; writer = XmlWriter.Create(filename, settings); VisitDatabase(db); writer.Flush(); writer.Close(); }
/// <summary> /// Serialize the expression into Xml format /// </summary> /// <param name="exp">The Expression</param> /// <returns>The serialized Xml in String Format</returns> public static String Serialize(Expression exp) { outputText = new StringBuilder(); writer = XmlTextWriter.Create(outputText); new ExpressionTreeToXmlSerializer().Visit(exp); writer.Flush(); return outputText.ToString(); }
public override void Generate(XmlWriter writer) { writer.WriteStartElement(@"roamingData", @"http://schemas.microsoft.com/2006/09/sip/roaming-self"); this.categories.Generate(writer); writer.WriteEndElement(); writer.Flush(); }
private static int GetNumberOfExistingTasks(XmlWriter data, TaskDocumentWriter isoTaskData) { data.Flush(); var xml = Encoding.UTF8.GetString(isoTaskData.XmlStream.ToArray()); if(!xml.EndsWith(">")) xml += ">"; xml += "</ISO11783_TaskData>"; var xDocument = XDocument.Parse(xml); return xDocument.Root.Descendants("TSK").Count(); }
public void WriteXml(XmlWriter writer) { writer.WriteStartElement("Rule"); writer.WriteAttributeString("Answer", this._answer); writer.WriteAttributeString("AnswerId", this._answerId); writer.WriteString(this._jumpToPage); writer.WriteEndElement(); writer.Flush(); }
public static void startLocal() { local = true; if (Xmlw == null) { byte[] b = Encoding.UTF8.GetBytes(DateTime.Now.ToString()); log = Convert.ToBase64String(b) + ".gh"; Xmlw = XmlWriter.Create(log); Xmlw.WriteStartElement("doc"); Xmlw.WriteComment(DateTime.Now.ToString()); Xmlw.Flush(); } }
/// <summary> /// Helper method for default serialization /// </summary> internal static void Serialize(this IBatch batch, XmlWriter xmlWriter) { xmlWriter.WriteStartElement(BatchNodeName); batch.SerializeData(xmlWriter); foreach (var log in batch.Logs) { xmlWriter.WriteStartElement(LogNodeName); log.SerializeData(xmlWriter); xmlWriter.WriteEndElement(); } xmlWriter.WriteEndElement(); xmlWriter.Flush(); }
public void Generate(XmlWriter writer) { writer.WriteStartElement(@"state", @"http://schemas.microsoft.com/2006/09/sip/state"); writer.WriteAttributeString(@"xsi", @"type", @"http://www.w3.org/2001/XMLSchema-instance", @"aggregateState"); writer.WriteStartElement(@"availability"); writer.WriteValue(this.Availability); writer.WriteEndElement(); writer.WriteEndElement(); writer.Flush(); }
// Constructor public Hxt(string filePath, Encoding encoding) { Disposed = false; XmlWriterSettings settings = new XmlWriterSettings { Indent = true, NewLineChars = Environment.NewLine, Encoding = encoding, }; writer = XmlWriter.Create(filePath, settings); // Write header writer.WriteStartDocument(); writer.WriteDocType("HelpTOC", null, "MS-Help://Hx/Resources/HelpTOC.DTD", null); writer.WriteStartElement("HelpTOC"); writer.WriteAttributeString("DTDVersion", "1.0"); writer.Flush(); }
public void SaveXml(CompilationUnit cu) { try { this.cu = cu; is_assembly = cu.SyntaxTree is SyntaxTree.program_module || Compiler.is_dll(cu.SyntaxTree); XmlWriterSettings settings = new XmlWriterSettings(); settings.Encoding = Encoding.UTF8; settings.Indent = true; xtw = XmlTextWriter.Create(Path.ChangeExtension(cu.UnitName, ".xml"), settings); unit_name = Path.GetFileNameWithoutExtension(cu.UnitName); xtw.WriteStartDocument(); xtw.WriteStartElement("doc"); if (is_assembly) { xtw.WriteStartElement("assembly"); xtw.WriteStartElement("name"); xtw.WriteString(Path.GetFileNameWithoutExtension(cu.UnitName)); xtw.WriteEndElement(); xtw.WriteEndElement(); } else { xtw.WriteStartElement("unit"); xtw.WriteStartAttribute("name"); //xtw.WriteString((cu.SemanticTree as common_unit_node).unit_name); xtw.WriteString(Path.GetFileNameWithoutExtension(cu.UnitName)); xtw.WriteEndAttribute(); xtw.WriteString(cu.SemanticTree.documentation); xtw.WriteEndElement(); } SaveMembers(); xtw.WriteEndElement(); xtw.Flush(); } catch (Exception e) { } try { if (xtw != null) xtw.Close(); } catch { } }
public void WriteXml(XmlWriter writer) { writer.WriteStartElement("Option"); writer.WriteAttributeString("value", this._value); if (this._selected) writer.WriteAttributeString("selected", "true"); if (!this._enabled) writer.WriteAttributeString("enabled", "false"); writer.WriteString(this._text); writer.WriteEndElement(); writer.Flush(); }
public void Translate(ValueStack stack, System.IO.Stream input, System.IO.Stream output) { XmlDocument doc = new XmlDocument(); doc.Load(input); using (System.Xml.XmlWriter w = System.Xml.XmlWriter.Create(output, new XmlWriterSettings() { NewLineHandling = NewLineHandling.Entitize, Indent = false, NewLineOnAttributes = false })) { ProcessNode(stack, doc.DocumentElement.FirstChild, w); w.Flush(); } }
// start logging adding rows int StartAddingRows(object sender) { updating = true; // uncheck other radio buttons foreach (Control ctl in groupBox1.Controls) { if (ctl is RadioButton && !ctl.Equals(sender)) { ((RadioButton)ctl).Checked = false; } } foreach (Control ctl in groupBox2.Controls) { if (ctl is RadioButton && !ctl.Equals(sender)) { ((RadioButton)ctl).Checked = false; } } // save current view stream = new MemoryStream(); using (System.Xml.XmlWriter xw = System.Xml.XmlWriter.Create(stream)) { _c1FlexPivotPage.FlexPivotEngine.WriteXml(xw); xw.Flush(); stream.Position = 0; } // check selected button sel = ((RadioButton)sender); sel.Checked = true; // disconnect from data var fPanel = _c1FlexPivotPage.FlexPivotPanel; fPanel.DataSource = null; fPanel.ConnectDataEngine(null); // start log int count = int.Parse(sel.Tag.ToString()); addTime = DateTime.Now; listBox1.Items.Add(string.Format("Creating {0} rows...", count.ToString("n0"))); listBox1.TopIndex = listBox1.Items.Count - 1; Application.DoEvents(); return(count); }
private static void RewriteLinks(XmlReader reader, XmlWriter writer) { if (IsAtSelfLink(reader)) { reader.Skip(); } else if (IsAtViaLink(reader)) { string href = reader.GetAttribute("href"); reader.Skip(); writer.WriteStartElement("link", "http://www.w3.org/2005/Atom"); writer.WriteAttributeString("rel", "self"); writer.WriteAttributeString("href", href); writer.WriteEndElement(); writer.Flush(); } }
public void Execute(object defaultDocument, XmlResolver dataSources, XsltArgumentList argumentList, XmlWriter writer) { try { XmlWellFormedWriter writer2 = writer as XmlWellFormedWriter; if (((writer2 != null) && (writer2.RawWriter != null)) && ((writer2.WriteState == WriteState.Start) && (writer2.Settings.ConformanceLevel != ConformanceLevel.Document))) { this.Execute(defaultDocument, dataSources, argumentList, new XmlMergeSequenceWriter(writer2.RawWriter)); } else { this.Execute(defaultDocument, dataSources, argumentList, new XmlMergeSequenceWriter(new XmlRawWriterWrapper(writer))); } } finally { writer.Flush(); } }
public string DbmlToString(Database db, Encoding encoding) { string str; using (var stream = new MemoryStream()) using (var streamWriter = new StreamWriter(stream, encoding)) { var settings = new XmlWriterSettings {Indent = true, Encoding = encoding}; writer = XmlWriter.Create(streamWriter, settings); VisitDatabase(db); writer.Flush(); writer.Close(); using (var reader = new StreamReader(stream, encoding)) { stream.Position = 0L; str = reader.ReadToEnd(); } } return str; }
private void Serialize <T>(T obj, string sConfigFilePath) { try { System.Xml.Serialization.XmlSerializer XmlBuddy = new System.Xml.Serialization.XmlSerializer(typeof(T)); System.Xml.XmlWriterSettings MySettings = new System.Xml.XmlWriterSettings(); MySettings.Indent = true; MySettings.CloseOutput = true; MySettings.OmitXmlDeclaration = true; System.Xml.XmlWriter MyWriter = System.Xml.XmlWriter.Create(sConfigFilePath, MySettings); XmlBuddy.Serialize(MyWriter, obj); MyWriter.Flush(); MyWriter.Close(); } catch (Exception ex) { account.Log(new ErrorTextInformation(ex.Message + ex.StackTrace), 0); } }
// This method creates Xml with a point and returns it in a string form public string ToXml() { //Initiate XML stuff KeyValuePair <string, string> point = GetNewPoint(); string lon = point.Key; string lat = point.Value; StringBuilder sb = new StringBuilder(); XmlWriterSettings settings = new XmlWriterSettings(); System.Xml.XmlWriter writer = System.Xml.XmlWriter.Create(sb, settings); writer.WriteStartDocument(); writer.WriteStartElement("Point"); writer.WriteElementString("lon", lon); writer.WriteElementString("lat", lat); writer.WriteEndElement(); writer.WriteEndDocument(); writer.Flush(); return(sb.ToString()); }
public virtual string ToDescriptionDocument() { if (String.IsNullOrEmpty(this.Uuid)) { throw new InvalidOperationException("Must provide a UUID value."); } //This would have been so much nicer with Xml.Linq, but that's //not available until .NET 4.03 at the earliest, and I want to //target 4.0 :( using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { System.Xml.XmlWriter writer = System.Xml.XmlWriter.Create(ms, new XmlWriterSettings() { Encoding = System.Text.UTF8Encoding.UTF8, Indent = true, NamespaceHandling = NamespaceHandling.OmitDuplicates }); writer.WriteStartDocument(); writer.WriteStartElement("root", SsdpConstants.SsdpDeviceDescriptionXmlNamespace); writer.WriteStartElement("specVersion"); writer.WriteElementString("major", "1"); writer.WriteElementString("minor", "0"); writer.WriteEndElement(); if (this.UrlBase != null && this.UrlBase != this.Location) { writer.WriteElementString("URLBase", this.UrlBase.ToString()); } WriteDeviceDescriptionXml(writer, this); writer.WriteEndElement(); writer.Flush(); ms.Seek(0, System.IO.SeekOrigin.Begin); using (var reader = new System.IO.StreamReader(ms)) { return(reader.ReadToEnd()); } } }
private System.IO.Stream MessageToStream(HttpContextServiceHost ctx, Message message) { System.IO.Stream ms = new System.IO.MemoryStream(); using (System.IO.Stream tempms = new System.IO.MemoryStream()) { using (System.Xml.XmlWriter writer = System.Xml.XmlWriter.Create(tempms)) { message.WriteMessage(writer); writer.Flush(); } ctx.OriginalContentLength = (int)tempms.Length; tempms.Position = 0; using (System.IO.Compression.GZipStream gzip = new System.IO.Compression.GZipStream(ms, System.IO.Compression.CompressionMode.Compress, true)) { tempms.CopyTo(gzip); } } ms.Position = 0; return(ms); }
private string CreateEmptyXml() { var settings = new XmlWriterSettings { OmitXmlDeclaration = false, Encoding = Encoding.UTF8 }; var stream = new MemoryStream(); using (System.Xml.XmlWriter writer = XmlWriter.Create(stream, settings)) { writer.WriteStartDocument(); writer.WriteStartElement("feed"); writer.WriteEndElement(); writer.Flush(); writer.Close(); } stream.Position = 0; var streamReader = new StreamReader(stream); return(streamReader.ReadToEnd()); }
private bool SignForm(XmlReader reader, XmlWriter writer) { if (!reader.IsStartElement("model")) { return false; } var doc = XDocument.Load(reader.ReadSubtree()); var formContents = GetFormContents(doc); var submission = GetSubmission(doc); if (submission != null) { submission.Element.SetAttributeValue("resource", submission.TargetUri.Replace(signaturePlaceholder, signature.GenerateSignature(formContents))); } reader.ReadEndElement(); writer.WriteNode(doc.CreateReader(), false); writer.Flush(); return true; }
void IXmlSerializable.WriteXml(System.Xml.XmlWriter writer) { // This is the chunking code. // ASP.NET buffering must be turned off for this to work. int bufferSize = 4096; char[] songBytes = new char[bufferSize]; FileStream inFile = File.Open(this.filePath, FileMode.Open, FileAccess.Read); long length = inFile.Length; // Write the file name. writer.WriteElementString("fileName", ns, Path.GetFileNameWithoutExtension(this.filePath)); // Write the size. writer.WriteElementString("size", ns, length.ToString()); // Write the song bytes. writer.WriteStartElement("song", ns); StreamReader sr = new StreamReader(inFile, true); int readLen = sr.Read(songBytes, 0, bufferSize); while (readLen > 0) { writer.WriteStartElement("chunk", ns); writer.WriteChars(songBytes, 0, readLen); writer.WriteEndElement(); writer.Flush(); readLen = sr.Read(songBytes, 0, bufferSize); } writer.WriteEndElement(); inFile.Close(); }
public override string Index(string folderPath) { FolderInfo folderInfo = GetFolderInfo(folderPath); folderInfo.Update(); XmlWriterSettings xmlWriterSettings = new XmlWriterSettings(); xmlWriterSettings.Encoding = new UTF8Encoding(false); xmlWriterSettings.ConformanceLevel = ConformanceLevel.Document; xmlWriterSettings.Indent = true; using (MemoryStream ms = new MemoryStream()) { using (xmlWriter = XmlWriter.Create(ms, xmlWriterSettings)) { xmlWriter.WriteStartDocument(); IndexFolder(folderInfo); xmlWriter.WriteEndDocument(); xmlWriter.Flush(); } return Encoding.UTF8.GetString(ms.ToArray()); } }
/// <summary>Builds an Xml file combining the reflected metadata with the /doc comments.</summary> private void BuildXml(XmlWriter writer) { int start = Environment.TickCount; Debug.WriteLine("Memory making xml: " + GC.GetTotalMemory(false).ToString()); try { assemblyLoader = SetupAssemblyLoader(); string DocLangCode = Enum.GetName(typeof(SdkLanguage), this.rep.SdkDocLanguage).Replace("_", "-"); externalSummaryCache = new ExternalXmlSummaryCache(DocLangCode); notEmptyNamespaces = new Hashtable(); namespaceHierarchies = new NamespaceHierarchyCollection(); baseInterfaces = new TypeHierarchy(); derivedTypes = new TypeHierarchy(); interfaceImplementingTypes = new TypeHierarchy(); attributeFilter = new AttributeUsageDisplayFilter(this.rep.DocumentedAttributes); documentedTypes = new Hashtable(); PreReflectionProcess(); string currentAssemblyFilename = ""; try { // Start the document with the XML declaration tag writer.WriteStartDocument(); // Start the root element writer.WriteStartElement("ndoc"); writer.WriteAttributeString("SchemaVersion", "1.4"); if (this.rep.FeedbackEmailAddress.Length > 0) WriteFeedBackEmailAddress(writer); if (this.rep.CopyrightText.Length > 0) WriteCopyright(writer); if (this.rep.IncludeDefaultThreadSafety) WriteDefaultThreadSafety(writer); if (this.rep.Preliminary) writer.WriteElementString("preliminary", ""); WriteNamespaceHierarchies(writer); foreach (string AssemblyFileName in this.rep.AssemblyFileNames) { currentAssemblyFilename = AssemblyFileName; Assembly assembly = assemblyLoader.LoadAssembly(currentAssemblyFilename); int starta = Environment.TickCount; WriteAssembly(writer, assembly); Trace.WriteLine("Completed " + assembly.FullName); Trace.WriteLine(((Environment.TickCount - starta) / 1000.0).ToString() + " sec."); } writer.WriteEndElement(); writer.WriteEndDocument(); writer.Flush(); Trace.WriteLine("MakeXML : " + ((Environment.TickCount - start) / 1000.0).ToString() + " sec."); // if you want to see NDoc's intermediate XML file, use the XML documenter. } finally { if (assemblyLoader != null) { assemblyLoader.Deinstall(); } } } catch (ReflectionTypeLoadException rtle) { StringBuilder sb = new StringBuilder(); if (assemblyLoader.UnresolvedAssemblies.Count > 0) { sb.Append("One or more required assemblies could not be located : \n"); foreach (string ass in assemblyLoader.UnresolvedAssemblies) { sb.AppendFormat(" {0}\n", ass); } sb.Append("\nThe following directories were searched, \n"); foreach (string dir in assemblyLoader.SearchedDirectories) { sb.AppendFormat(" {0}\n", dir); } } else { Hashtable fileLoadExceptions = new Hashtable(); foreach (Exception loaderEx in rtle.LoaderExceptions) { System.IO.FileLoadException fileLoadEx = loaderEx as System.IO.FileLoadException; if (fileLoadEx != null) { if (!fileLoadExceptions.ContainsKey(fileLoadEx.FileName)) { fileLoadExceptions.Add(fileLoadEx.FileName, null); sb.Append("Unable to load: " + fileLoadEx.FileName + "\r\n"); } } sb.Append(loaderEx.Message + Environment.NewLine); sb.Append(loaderEx.StackTrace + Environment.NewLine); sb.Append("--------------------" + Environment.NewLine + Environment.NewLine); } } throw new DocumenterException(sb.ToString()); } }
/// <summary> /// Replay all cached events to an XmlWriter. /// </summary> public void EventsToWriter(XmlWriter writer) { XmlEvent[] page; int idxPage, idxEvent; byte[] bytes; char[] chars; XmlRawWriter rawWriter; // Special-case single text node at the top-level if (this.singleText.Count != 0) { writer.WriteString(this.singleText.GetResult()); return; } rawWriter = writer as XmlRawWriter; // Loop over set of pages for (idxPage = 0; idxPage < this.pages.Count; idxPage++) { page = this.pages[idxPage]; // Loop over events in each page for (idxEvent = 0; idxEvent < page.Length; idxEvent++) { switch (page[idxEvent].EventType) { case XmlEventType.Unknown: // No more events Debug.Assert(idxPage + 1 == this.pages.Count); return; case XmlEventType.DocType: writer.WriteDocType(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3, (string) page[idxEvent].Object); break; case XmlEventType.StartElem: writer.WriteStartElement(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3); break; case XmlEventType.StartAttr: writer.WriteStartAttribute(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3); break; case XmlEventType.EndAttr: writer.WriteEndAttribute(); break; case XmlEventType.CData: writer.WriteCData(page[idxEvent].String1); break; case XmlEventType.Comment: writer.WriteComment(page[idxEvent].String1); break; case XmlEventType.PI: writer.WriteProcessingInstruction(page[idxEvent].String1, page[idxEvent].String2); break; case XmlEventType.Whitespace: writer.WriteWhitespace(page[idxEvent].String1); break; case XmlEventType.String: writer.WriteString(page[idxEvent].String1); break; case XmlEventType.Raw: writer.WriteRaw(page[idxEvent].String1); break; case XmlEventType.EntRef: writer.WriteEntityRef(page[idxEvent].String1); break; case XmlEventType.CharEnt: writer.WriteCharEntity((char) page[idxEvent].Object); break; case XmlEventType.SurrCharEnt: chars = (char[]) page[idxEvent].Object; writer.WriteSurrogateCharEntity(chars[0], chars[1]); break; case XmlEventType.Base64: bytes = (byte[]) page[idxEvent].Object; writer.WriteBase64(bytes, 0, bytes.Length); break; case XmlEventType.BinHex: bytes = (byte[]) page[idxEvent].Object; writer.WriteBinHex(bytes, 0, bytes.Length); break; case XmlEventType.XmlDecl1: if (rawWriter != null) rawWriter.WriteXmlDeclaration((XmlStandalone) page[idxEvent].Object); break; case XmlEventType.XmlDecl2: if (rawWriter != null) rawWriter.WriteXmlDeclaration(page[idxEvent].String1); break; case XmlEventType.StartContent: if (rawWriter != null) rawWriter.StartElementContent(); break; case XmlEventType.EndElem: if (rawWriter != null) rawWriter.WriteEndElement(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3); else writer.WriteEndElement(); break; case XmlEventType.FullEndElem: if (rawWriter != null) rawWriter.WriteFullEndElement(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3); else writer.WriteFullEndElement(); break; case XmlEventType.Nmsp: if (rawWriter != null) rawWriter.WriteNamespaceDeclaration(page[idxEvent].String1, page[idxEvent].String2); else writer.WriteAttributeString("xmlns", page[idxEvent].String1, XmlReservedNs.NsXmlNs, page[idxEvent].String2); break; case XmlEventType.EndBase64: if (rawWriter != null) rawWriter.WriteEndBase64(); break; case XmlEventType.Close: writer.Close(); break; case XmlEventType.Flush: writer.Flush(); break; case XmlEventType.Dispose: ((IDisposable)writer).Dispose(); break; default: Debug.Assert(false, "Unknown event: " + page[idxEvent].EventType); break; } } } Debug.Assert(false, "Unknown event should be added to end of event sequence."); }
private static void SaveDocument(XmlDocument doc, XmlWriter xmlWriter) { doc.Save(xmlWriter); xmlWriter.Flush(); }
public override void Flush() { w.Flush(); }
public Validation.SchematronOutput.schematronoutput Validate(Stream xmlstream, Stream schematronstream) { /////////////////////////////// // Transform original Schemtron /////////////////////////////// string path = AppDomain.CurrentDomain.BaseDirectory; Uri schematronxsl = new Uri(@"file:\\" + path + @"\xsl_2.0\iso_svrl_for_xslt2.xsl"); Stream schematrontransform = new Validation.XSLTransform().Transform(schematronstream, schematronxsl); /////////////////////////////// // Apply Schemtron xslt /////////////////////////////// Stream results = new Validation.XSLTransform().Transform(xmlstream, schematrontransform); results.Position = 0; System.Xml.XmlDocument doc = new System.Xml.XmlDocument(); doc.Load(results); var nodes = doc.ChildNodes[1].ChildNodes; System.Xml.XmlNode activepattern = null; System.Xml.XmlNode firedrule = null; System.Xml.XmlNode failedassert = null; List <System.Xml.XmlNode> nodesclone = new List <System.Xml.XmlNode>(); foreach (System.Xml.XmlNode node in nodes) { nodesclone.Add(node); } foreach (System.Xml.XmlNode node in nodesclone) { if (node.Name == "svrl:active-pattern") { activepattern = node; } if (node.Name == "svrl:fired-rule") { firedrule = node; activepattern.AppendChild(firedrule); } if (node.Name == "svrl:failed-assert") { failedassert = node; firedrule.AppendChild(failedassert); } } //System.IO.StreamReader rd2 = new System.IO.StreamReader(results); //string xsltSchematronResult = rd2.ReadToEnd(); //xsltSchematronResult = xsltSchematronResult.Replace("schematron-output", "schematronoutput"); MemoryStream ms = new MemoryStream(); System.Xml.XmlWriter w = System.Xml.XmlWriter.Create(ms); ms.Position = 0; doc.WriteTo(w); w.Flush(); return(Serialization.DerializeXML <Validation.SchematronOutput.schematronoutput>(ms)); }
public void EventsToWriter(XmlWriter writer) { if (this.singleText.Count != 0) { writer.WriteString(this.singleText.GetResult()); } else { XmlRawWriter writer2 = writer as XmlRawWriter; for (int i = 0; i < this.pages.Count; i++) { XmlEvent[] eventArray = this.pages[i]; for (int j = 0; j < eventArray.Length; j++) { byte[] buffer; switch (eventArray[j].EventType) { case XmlEventType.Unknown: return; case XmlEventType.DocType: { writer.WriteDocType(eventArray[j].String1, eventArray[j].String2, eventArray[j].String3, (string)eventArray[j].Object); continue; } case XmlEventType.StartElem: { writer.WriteStartElement(eventArray[j].String1, eventArray[j].String2, eventArray[j].String3); continue; } case XmlEventType.StartAttr: { writer.WriteStartAttribute(eventArray[j].String1, eventArray[j].String2, eventArray[j].String3); continue; } case XmlEventType.EndAttr: { writer.WriteEndAttribute(); continue; } case XmlEventType.CData: { writer.WriteCData(eventArray[j].String1); continue; } case XmlEventType.Comment: { writer.WriteComment(eventArray[j].String1); continue; } case XmlEventType.PI: { writer.WriteProcessingInstruction(eventArray[j].String1, eventArray[j].String2); continue; } case XmlEventType.Whitespace: { writer.WriteWhitespace(eventArray[j].String1); continue; } case XmlEventType.String: { writer.WriteString(eventArray[j].String1); continue; } case XmlEventType.Raw: { writer.WriteRaw(eventArray[j].String1); continue; } case XmlEventType.EntRef: { writer.WriteEntityRef(eventArray[j].String1); continue; } case XmlEventType.CharEnt: { writer.WriteCharEntity((char)eventArray[j].Object); continue; } case XmlEventType.SurrCharEnt: { char[] chArray = (char[])eventArray[j].Object; writer.WriteSurrogateCharEntity(chArray[0], chArray[1]); continue; } case XmlEventType.Base64: { buffer = (byte[])eventArray[j].Object; writer.WriteBase64(buffer, 0, buffer.Length); continue; } case XmlEventType.BinHex: { buffer = (byte[])eventArray[j].Object; writer.WriteBinHex(buffer, 0, buffer.Length); continue; } case XmlEventType.XmlDecl1: { if (writer2 != null) { writer2.WriteXmlDeclaration((XmlStandalone)eventArray[j].Object); } continue; } case XmlEventType.XmlDecl2: { if (writer2 != null) { writer2.WriteXmlDeclaration(eventArray[j].String1); } continue; } case XmlEventType.StartContent: { if (writer2 != null) { writer2.StartElementContent(); } continue; } case XmlEventType.EndElem: { if (writer2 == null) { break; } writer2.WriteEndElement(eventArray[j].String1, eventArray[j].String2, eventArray[j].String3); continue; } case XmlEventType.FullEndElem: { if (writer2 == null) { goto Label_0367; } writer2.WriteFullEndElement(eventArray[j].String1, eventArray[j].String2, eventArray[j].String3); continue; } case XmlEventType.Nmsp: { if (writer2 == null) { goto Label_0394; } writer2.WriteNamespaceDeclaration(eventArray[j].String1, eventArray[j].String2); continue; } case XmlEventType.EndBase64: { if (writer2 != null) { writer2.WriteEndBase64(); } continue; } case XmlEventType.Close: { writer.Close(); continue; } case XmlEventType.Flush: { writer.Flush(); continue; } case XmlEventType.Dispose: { writer.Dispose(); continue; } default: { continue; } } writer.WriteEndElement(); continue; Label_0367: writer.WriteFullEndElement(); continue; Label_0394: writer.WriteAttributeString("xmlns", eventArray[j].String1, "http://www.w3.org/2000/xmlns/", eventArray[j].String2); } } } }
/// <summary> /// Replay all cached events to an XmlWriter. /// </summary> public void EventsToWriter(XmlWriter writer) { XmlEvent[] page; int idxPage, idxEvent; byte[] bytes; char[] chars; XmlRawWriter?rawWriter; // Special-case single text node at the top-level if (_singleText.Count != 0) { writer.WriteString(_singleText.GetResult()); return; } rawWriter = writer as XmlRawWriter; // Loop over set of pages for (idxPage = 0; idxPage < _pages !.Count; idxPage++) { page = _pages[idxPage]; // Loop over events in each page for (idxEvent = 0; idxEvent < page.Length; idxEvent++) { switch (page[idxEvent].EventType) { case XmlEventType.Unknown: // No more events Debug.Assert(idxPage + 1 == _pages.Count); return; case XmlEventType.DocType: writer.WriteDocType(page[idxEvent].String1 !, page[idxEvent].String2, page[idxEvent].String3, (string?)page[idxEvent].Object); break; case XmlEventType.StartElem: writer.WriteStartElement(page[idxEvent].String1, page[idxEvent].String2 !, page[idxEvent].String3); break; case XmlEventType.StartAttr: writer.WriteStartAttribute(page[idxEvent].String1, page[idxEvent].String2 !, page[idxEvent].String3); break; case XmlEventType.EndAttr: writer.WriteEndAttribute(); break; case XmlEventType.CData: writer.WriteCData(page[idxEvent].String1); break; case XmlEventType.Comment: writer.WriteComment(page[idxEvent].String1); break; case XmlEventType.PI: writer.WriteProcessingInstruction(page[idxEvent].String1 !, page[idxEvent].String2); break; case XmlEventType.Whitespace: writer.WriteWhitespace(page[idxEvent].String1); break; case XmlEventType.String: writer.WriteString(page[idxEvent].String1); break; case XmlEventType.Raw: writer.WriteRaw(page[idxEvent].String1 !); break; case XmlEventType.EntRef: writer.WriteEntityRef(page[idxEvent].String1 !); break; case XmlEventType.CharEnt: writer.WriteCharEntity((char)page[idxEvent].Object !); break; case XmlEventType.SurrCharEnt: chars = (char[])page[idxEvent].Object !; writer.WriteSurrogateCharEntity(chars[0], chars[1]); break; case XmlEventType.Base64: bytes = (byte[])page[idxEvent].Object !; writer.WriteBase64(bytes, 0, bytes.Length); break; case XmlEventType.BinHex: bytes = (byte[])page[idxEvent].Object !; writer.WriteBinHex(bytes, 0, bytes.Length); break; case XmlEventType.XmlDecl1: if (rawWriter != null) { rawWriter.WriteXmlDeclaration((XmlStandalone)page[idxEvent].Object !); } break; case XmlEventType.XmlDecl2: if (rawWriter != null) { rawWriter.WriteXmlDeclaration(page[idxEvent].String1 !); } break; case XmlEventType.StartContent: if (rawWriter != null) { rawWriter.StartElementContent(); } break; case XmlEventType.EndElem: if (rawWriter != null) { rawWriter.WriteEndElement(page[idxEvent].String1 !, page[idxEvent].String2 !, page[idxEvent].String3 !); } else { writer.WriteEndElement(); } break; case XmlEventType.FullEndElem: if (rawWriter != null) { rawWriter.WriteFullEndElement(page[idxEvent].String1 !, page[idxEvent].String2 !, page[idxEvent].String3 !); } else { writer.WriteFullEndElement(); } break; case XmlEventType.Nmsp: if (rawWriter != null) { rawWriter.WriteNamespaceDeclaration(page[idxEvent].String1 !, page[idxEvent].String2 !); } else { writer.WriteAttributeString("xmlns", page[idxEvent].String1 !, XmlReservedNs.NsXmlNs, page[idxEvent].String2); } break; case XmlEventType.EndBase64: if (rawWriter != null) { rawWriter.WriteEndBase64(); } break; case XmlEventType.Close: writer.Close(); break; case XmlEventType.Flush: writer.Flush(); break; case XmlEventType.Dispose: ((IDisposable)writer).Dispose(); break; default: Debug.Fail($"Unknown event: {page[idxEvent].EventType}"); break; } } } Debug.Fail("Unknown event should be added to end of event sequence."); }
public override void Flush() { _writer.Flush(); }
public void Write(System.Xml.XmlWriter writer, System.Xml.XmlNamespaceManager namespaceManager) { XmlSerializerNamespaces nss = new XmlSerializerNamespaces(); if (namespaceManager != null) { foreach (string name in namespaceManager) { //xml and xmlns namespaces are added by default in namespaceManager. //So we should ignore them if (name != "xml" && name != "xmlns") { nss.Add(name, namespaceManager.LookupNamespace(name)); } } } if (Namespaces != null && Namespaces.Count > 0) { XmlQualifiedName [] qnames = Namespaces.ToArray(); foreach (XmlQualifiedName qn in qnames) { nss.Add(qn.Name, qn.Namespace); } string p = String.Empty; bool loop = true; for (int idx = 1; loop; idx++) { loop = false; foreach (XmlQualifiedName qn in qnames) { if (qn.Name == p) { p = "q" + idx; loop = true; break; } } } nss.Add(p, XmlSchema.Namespace); } if (nss.Count == 0) { // Add the xml schema namespace. (It is done // only when no entry exists in Namespaces). nss.Add("xs", XmlSchema.Namespace); if (TargetNamespace != null && TargetNamespace.Length != 0) { nss.Add("tns", TargetNamespace); } } XmlSchemaSerializer xser = new XmlSchemaSerializer(); XmlSerializerNamespaces backup = Namespaces; try { Namespaces = null; xser.Serialize(writer, this, nss); } finally { Namespaces = backup; } writer.Flush(); }
public override void Flush() { _wrapped.Flush(); }
public override void Finished() { output.WriteEndElement(); // results output.WriteEndElement(); // sparql output.Flush(); }
public System.ServiceModel.Channels.Message ProcessInboundMessage(System.ServiceModel.Channels.Message m) { #if DEBUG Trace.TraceInformation("Received message on transport..."); #endif if (ListenConnector == null && OperationContext.Current.Host is WcfServiceHost) { ListenConnector = (OperationContext.Current.Host as WcfServiceHost).ConnectorHost; } if (ListenConnector != null) // In process { // Is this channel one way or two way? if (!(OperationContext.Current.Channel is IOutputChannel)) // Input only { return(null); } #if DEBUG Trace.TraceInformation("Message handoff to WcfServerConnector completed"); #endif WcfSendResult processResult = ListenConnector.ProcessMessage(m); Message retVal = null; // There is an error, so the return value must be a fault! if (processResult == null || processResult.Code != ResultCode.Accepted && processResult.Code != ResultCode.AcceptedNonConformant) { // Web based context? if (WebOperationContext.Current != null) { WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.InternalServerError; WebOperationContext.Current.OutgoingResponse.StatusDescription = "Internal Server Error"; } List <String> details = new List <string>(); if (processResult != null) { details = new List <String>(); foreach (var dtl in processResult.Details) { details.Add(dtl.Message); // Append details } } if (processResult == null) { retVal = Message.CreateMessage(m.Version, MessageFault.CreateFault(FaultCode.CreateReceiverFaultCode(processResult.Code.ToString(), "http://marc.mohawkcollege.ca/hi"), new FaultReason("The receiver has constructed an invalid response that cannot be sent to the sender"), details), m.Headers.Action); } else { retVal = Message.CreateMessage(m.Version, MessageFault.CreateFault(FaultCode.CreateSenderFaultCode("EPIC", "http://marc.mohawkcollege.ca/hi"), new FaultReason("Catastrophic failure occurred in the WcfServer send pipeline. This usually occurs when the connector does not receive a message in the allocated amount of time"), details), m.Headers.Action); } } else { retVal = processResult.Message; if (processResult.Headers != null) { retVal.Headers.Clear(); retVal.Headers.CopyHeadersFrom(processResult.Headers); } } #if DEBUG Trace.TraceInformation("Message sent to client"); #endif return(retVal); } else { // Get settings if (settings == null) { settings = System.Web.Configuration.WebConfigurationManager.GetSection("marc.everest.connectors.wcf") as MARC.Everest.Connectors.WCF.Configuration.ConfigurationSection; } // Now format the message and pass it on ... MemoryStream ms = new MemoryStream(); System.Xml.XmlWriter xw = System.Xml.XmlWriter.Create(ms); // Write to message memory stream for classification matching m.WriteMessage(xw); xw.Flush(); // Flush the Xml Writer ms.Seek(0, SeekOrigin.Begin); // Seek to start XPathDocument xpd = new XPathDocument(ms); // load xpath document XPathNavigator xpn = xpd.CreateNavigator(); IMessageReceiver receiver = null; // The receiver to use // Determine the receiver foreach (KeyValuePair <String, IMessageReceiver> kv in settings.Receiver) { if (xpn.SelectSingleNode(kv.Key) != null) { receiver = kv.Value; break; } } // Was a receiver found? if (receiver == null) { // Create a not implemented exception if (WebOperationContext.Current != null) { WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.NotImplemented; } return(Message.CreateMessage(m.Version, MessageFault.CreateFault(FaultCode.CreateSenderFaultCode( "NotImplemented", "http://marc.mohawkcollege.ca/hi"), new FaultReason("No receiver understands the request message.")), m.Headers.Action)); } // Create a streams for deserialization ms = new MemoryStream(); XmlWriterSettings xws = new XmlWriterSettings(); xws.Indent = true; xw = XmlWriter.Create(ms, xws); // Deserialize body WcfReceiveResult rcv = new WcfReceiveResult(); try { // Because of classification, we need to process this in a wierd way, // Basically the formatter will classify the message based on the root element name // it receives. Because a SOAP message's root isn't what we really want to process, // the first child node under the 'body' must be passed to the xml writer xpn.SelectSingleNode("//*[local-name() = 'Body']/child::node()").WriteSubtree(xw); xw.Flush(); ms.Seek(0, SeekOrigin.Begin); var serResult = settings.Formatter.Parse(ms); rcv.Structure = serResult.Structure; rcv.Details = serResult.Details; if (rcv.Details.Count() == 0) { rcv.Code = ResultCode.Accepted; } else { rcv.Code = ResultCode.AcceptedNonConformant; } } catch (Exception e) { rcv.Code = ResultCode.Error; rcv.Details = new IResultDetail[] { new ResultDetail(ResultDetailType.Error, e.Message, e) }; } // Process on the receiver IGraphable obj = receiver.MessageReceived(rcv.Structure, rcv.Code, rcv.Details); // Graph this back XmlSerializerSurrogate surrogate = new XmlSerializerSurrogate((IXmlStructureFormatter)settings.Formatter); // Serialize the response Message result = Message.CreateMessage(m.Version, m.Headers.Action, obj, surrogate); // Validate surrogate.WriteObject(new MemoryStream(), obj); // Surrogate result code is acceptable? if (surrogate.ResultCode != ResultCode.Accepted && surrogate.ResultCode != ResultCode.AcceptedNonConformant) { if (WebOperationContext.Current != null) { WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.InternalServerError; WebOperationContext.Current.OutgoingResponse.StatusDescription = "Internal Server Error"; } List <string> details = new List <String>(); foreach (var itm in surrogate.Details) { details.Add(itm.Message); // Append details } return(Message.CreateMessage(m.Version, MessageFault.CreateFault(FaultCode.CreateReceiverFaultCode(surrogate.ResultCode.ToString(), "http://marc.mohawkcollege.ca/hi"), new FaultReason("The receiver has constructed an invalid response that cannot be returned to the sender"), details), m.Headers.Action)); } else { return(result); } } }
private void click_Move(object sender, RoutedEventArgs e) { pp.IsOpen = false; List <DB.Halls> Halls = (List <DB.Halls>)lv.ItemsSource; if (((System.Windows.Controls.Button)sender).Tag + "" == "0") { FolderBrowserDialog fbd = new FolderBrowserDialog(); string Path = ""; fbd.Description = "Выберите папку для записи файла."; if (fbd.ShowDialog() == System.Windows.Forms.DialogResult.OK) { Path = fbd.SelectedPath; } else { pp.IsOpen = true; return; } switch (cbxFormat.SelectedIndex) { case 0: { List <string> strList = new List <string>(); foreach (var i in Halls) { strList.Add(i.ID + "" + ';' + i.Square + "" + ';' + i.Windows + ';' + i.Heating + ';' + i.Target + ';' + i.DepartmentID + ';' + i.BuildingID + ';' + i.ChiefID); } File.WriteAllLines(Path + @"\Exsport.csv", strList); break; } case 1: { System.Xml.XmlWriter writer = System.Xml.XmlWriter.Create(Path + @"\Exsport.xml"); writer.WriteStartDocument(); writer.WriteStartElement("Halls"); foreach (var i in Halls) { writer.WriteStartElement("Hall"); writer.WriteElementString("ID", i.ID + ""); writer.WriteElementString("Square", i.Square + ""); writer.WriteElementString("Windows", i.Windows + ""); writer.WriteElementString("Heating", i.Heating + ""); writer.WriteElementString("Target", i.Target); writer.WriteElementString("Department", i.DepartmentID + ""); writer.WriteElementString("Building", i.BuildingID + ""); writer.WriteElementString("Chief", i.ChiefID + ""); writer.WriteEndElement(); writer.Flush(); } writer.WriteEndElement(); writer.WriteEndDocument(); writer.Close(); break; } case 2: { string connectionString = "Provider=Microsoft.Jet.OLEDB.4.0;Extended properties=Excel 8.0; User ID=;Password=;Data Source = " + Path + @"\Exsport.xls"; OleDbConnection conn = new OleDbConnection(connectionString); conn.Open(); OleDbCommand cmd = new OleDbCommand(); cmd.Connection = conn; cmd.CommandText = "CREATE TABLE [Halls] (ID VARCHAR, Square VARCHAR, Windows VARCHAR, Heating VARCHAR, Target VARCHAR, DepartmentID VARCHAR, BuildingID VARCHAR, ChiefID VARCHAR);"; cmd.ExecuteNonQuery(); foreach (var i in Halls) { cmd.CommandText = "INSERT INTO [Halls] (ID,Square,Windows,Heating,Target,DepartmentID,BuildingID,ChiefID) values ('" + i.ID + "', '" + i.Square + "', '" + i.Windows + "', '" + i.Heating + "', '" + i.Target + "', '" + i.DepartmentID + "', '" + i.BuildingID + "', '" + i.ChiefID + "')"; cmd.ExecuteNonQuery(); } conn.Close(); break; } case 3: { string connectionString = "Provider=Microsoft.Jet.OLEDB.4.0;Extended properties=Excel 8.0; User ID=;Password=;Data Source = " + Path + @"\Exsport.xlsx"; OleDbConnection conn = new OleDbConnection(connectionString); conn.Open(); OleDbCommand cmd = new OleDbCommand(); cmd.Connection = conn; cmd.CommandText = "CREATE TABLE [Halls] (ID VARCHAR, Square VARCHAR, Windows VARCHAR, Heating VARCHAR, Target VARCHAR, DepartmentID VARCHAR, BuildingID VARCHAR, ChiefID VARCHAR);"; cmd.ExecuteNonQuery(); foreach (var i in Halls) { cmd.CommandText = "INSERT INTO [Halls] (ID,Square,Windows,Heating,Target,DepartmentID,BuildingID,ChiefID) values ('" + i.ID + "', '" + i.Square + "', '" + i.Windows + "', '" + i.Heating + "', '" + i.Target + "', '" + i.DepartmentID + "', '" + i.BuildingID + "', '" + i.ChiefID + "';"; cmd.ExecuteNonQuery(); } conn.Close(); break; } } System.Windows.MessageBox.Show("Экспорт совершён!", "Perfect", MessageBoxButton.OK, MessageBoxImage.Information); } else { switch (cbxFormat.SelectedIndex) { case 0: { if (System.Windows.MessageBox.Show("Для удачной записи файл должен быть следующего формата: |Square|Windows|Heating|Target|DepartmentID|BuildingID|ChiefID|. Продолжить? ", "Caution", MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.No) { pp.IsOpen = true; return; } OpenFileDialog ofd = new OpenFileDialog(); ofd.Filter = "CSV|*.csv;"; if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.Cancel) { pp.IsOpen = true; return; } var csv = File.ReadAllLines(ofd.FileName); int GoodCount = 0; int BadCount = 0; try { foreach (var i in csv) { var str = i.Split(';'); db.Halls.Add(new DB.Halls { Square = double.Parse(str[0]), Windows = int.Parse(str[1]), Heating = int.Parse(str[2]), Target = str[3], DepartmentID = int.Parse(str[4]), BuildingID = int.Parse(str[5]), ChiefID = int.Parse(str[6]) }); } db.SaveChanges(); GoodCount++; } catch { BadCount++; } string Message = ""; if (BadCount == 0) { Message = "Импорт прошёл успешно!"; } else if (GoodCount != 0) { Message = "Импорт прошёл с некоторыми ошибками!"; } else { Message = "Импорт не прошёл из-за появившихся ошибок!"; } System.Windows.MessageBox.Show(Message, "Message", MessageBoxButton.OK, MessageBoxImage.Information); break; } case 1: { if (System.Windows.MessageBox.Show("Для удачной записи в файле не должно быть поле 'ID'. Продолжить? ", "Caution", MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.No) { pp.IsOpen = true; return; } OpenFileDialog ofd = new OpenFileDialog(); ofd.Filter = "XML|*.xml;"; if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.Cancel) { pp.IsOpen = true; return; } int GoodCount = 0; int BadCount = 0; XmlDocument doc = new XmlDocument(); doc.Load(ofd.FileName); foreach (XmlNode i in doc.DocumentElement) { try { DB.Halls hall = new DB.Halls(); hall.ID = int.Parse(i["ID"].InnerText); hall.Square = double.Parse(i["Square"].InnerText); hall.Windows = int.Parse(i["Windows"].InnerText); hall.Heating = int.Parse(i["Heating"].InnerText); hall.Target = i["Target"].InnerText; hall.DepartmentID = int.Parse(i["Department"].InnerText); hall.BuildingID = HelpClasses.StaticClass.SelectBuilding.Kadastr; hall.ChiefID = int.Parse(i["Chief"].InnerText); db.Halls.Add(hall); db.SaveChanges(); GoodCount++; } catch { BadCount++; } } string Message = ""; if (BadCount == 0) { Message = "Импорт прошёл успешно!"; } else if (GoodCount != 0) { Message = "Импорт прошёл с некоторыми ошибками!"; } else { Message = "Импорт не прошёл из-за появившихся ошибок!"; } System.Windows.MessageBox.Show(Message, "Message", MessageBoxButton.OK, MessageBoxImage.Information); break; } case 2: { OpenFileDialog ofd = new OpenFileDialog(); ofd.Filter = "XLS|*.xls;"; if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.Cancel) { pp.IsOpen = true; return; } DataSet ds = new DataSet(); string connectionString = "Provider=Microsoft.Jet.OLEDB.4.0;Extended properties=Excel 8.0; User ID=;Password=;Data Source = " + ofd.FileName; OleDbConnection conn = new OleDbConnection(connectionString); conn.Open(); OleDbCommand cmd = new OleDbCommand(); cmd.Connection = conn; DataTable dtHalls = conn.GetOleDbSchemaTable(OleDbSchemaGuid.Tables, null); foreach (DataRow dr in dtHalls.Rows) { string hallName = dr["TABLE_NAME"].ToString(); if (!hallName.EndsWith("$")) { continue; } cmd.CommandText = "SELECT * FROM [" + hallName + "]"; DataTable dt = new DataTable(); dt.TableName = hallName; OleDbDataAdapter da = new OleDbDataAdapter(); da.Fill(dt); ds.Tables.Add(dt); } cmd = null; conn.Close(); break; } } click_Sort(null, null); } }
public override void Flush() { CheckAsync(); _coreWriter.Flush(); }
protected override void WriteTokenCore( XmlWriter writer, System.IdentityModel.Tokens.SecurityToken token ) { if ( writer == null ) throw new ArgumentNullException( "writer" ); if ( token == null ) throw new ArgumentNullException( "token" ); var c = token as SecurityToken; if ( c != null ) { writer.WriteStartElement( Constants.UsernameTokenPrefix, Constants.UsernameTokenName, Constants.UsernameTokenNamespace ); writer.WriteAttributeString( Constants.WsUtilityPrefix, Constants.IdAttributeName, Constants.WsUtilityNamespace, token.Id ); writer.WriteElementString( Constants.UsernameElementName, Constants.UsernameTokenNamespace, c.Info.Username ); writer.WriteStartElement( Constants.UsernameTokenPrefix, Constants.PasswordElementName, Constants.UsernameTokenNamespace ); writer.WriteAttributeString( Constants.TypeAttributeName, Constants.PasswordDigestType ); writer.WriteValue( c.GetPasswordDigestAsBase64() ); writer.WriteEndElement(); writer.WriteElementString( Constants.NonceElementName, Constants.UsernameTokenNamespace, c.GetNonceAsBase64() ); writer.WriteElementString( Constants.CreatedElementName, Constants.WsUtilityNamespace, c.GetCreatedAsString() ); writer.WriteEndElement(); writer.Flush(); } else base.WriteTokenCore( writer, token ); }
/// <summary> /// Saves the HTML document to the specified XmlWriter. /// </summary> /// <param name="writer">The XmlWriter to which you want to save.</param> public void Save(XmlWriter writer) { DocumentNode.WriteTo(writer); writer.Flush(); }
protected override void DoWriteComplete() { writer.Flush(); }