protected override void OnWriteBodyContents(XmlDictionaryWriter writer) { if (IsDisposed) { throw new ObjectDisposedException("", "MessageClosed."); } if (writer == null) { throw new ArgumentNullException(nameof(writer)); } if (addComments) { writer.WriteComment("some comment"); } while (!bodyReader.EOF) { writer.WriteNode(bodyReader, false); if (addComments) { writer.WriteComment("some comment"); } } bodyReader.Close(); }
void ValidateMessageBody(ref System.ServiceModel.Channels.Message message, bool isRequest) { if (!message.IsFault) { XmlDictionaryReaderQuotas quotas = new XmlDictionaryReaderQuotas(); XmlReader bodyReader = message.GetReaderAtBodyContents().ReadSubtree(); XmlReaderSettings wrapperSettings = new XmlReaderSettings(); wrapperSettings.CloseInput = true; wrapperSettings.Schemas = schemaSet; wrapperSettings.ValidationFlags = XmlSchemaValidationFlags.None; wrapperSettings.ValidationType = ValidationType.Schema; wrapperSettings.ValidationEventHandler += new ValidationEventHandler(InspectionValidationHandler); XmlReader wrappedReader = XmlReader.Create(bodyReader, wrapperSettings); // pull body into a memory backed writer to validate this.isRequest = isRequest; MemoryStream memStream = new MemoryStream(); XmlDictionaryWriter xdw = XmlDictionaryWriter.CreateBinaryWriter(memStream); xdw.WriteNode(wrappedReader, false); xdw.Flush(); memStream.Position = 0; XmlDictionaryReader xdr = XmlDictionaryReader.CreateBinaryReader(memStream, quotas); // reconstruct the message with the validated body Message replacedMessage = Message.CreateMessage(message.Version, null, xdr); replacedMessage.Headers.CopyHeadersFrom(message.Headers); replacedMessage.Properties.CopyProperties(message.Properties); message = replacedMessage; } }
public byte[] CanonicalizeUsingDictionaryWriter(XmlReader reader) { _canonicalWriterStream.Seek(0, SeekOrigin.Begin); _canonicalWriterStream.SetLength(0); MemoryStream writerStream = new MemoryStream(); XmlDictionaryWriter dicWriter = XmlDictionaryWriter.CreateTextWriter(writerStream); dicWriter.WriteStartElement("Foo"); if (_tokenizedInclusivePrefixes != null) { // Populate the Canonicalizer with prefix that are already read in // by the reader. foreach (string inclusivePrefix in _tokenizedInclusivePrefixes) { string ns = reader.LookupNamespace(inclusivePrefix); if (ns != null) { dicWriter.WriteXmlnsAttribute(inclusivePrefix, ns); } } } dicWriter.StartCanonicalization(_canonicalWriterStream, _includeComments, _tokenizedInclusivePrefixes); reader.MoveToContent(); dicWriter.WriteNode(reader, false); dicWriter.EndCanonicalization(); dicWriter.WriteEndElement(); return(_canonicalWriterStream.ToArray()); }
internal static XmlBuffer ReadExtensions(XmlDictionaryReader reader, AddressingVersion version, XmlBuffer buffer, out EndpointIdentity identity, out int section) { if (reader == null) { identity = null; section = -1; return(buffer); } // EndpointIdentity and extensions identity = null; XmlDictionaryWriter bufferWriter = null; reader.MoveToContent(); while (reader.IsStartElement()) { if (reader.IsStartElement(XD.AddressingDictionary.Identity, XD.AddressingDictionary.IdentityExtensionNamespace)) { if (identity != null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateXmlException(reader, SR.Format(SR.UnexpectedDuplicateElement, XD.AddressingDictionary.Identity.Value, XD.AddressingDictionary.IdentityExtensionNamespace.Value))); } identity = EndpointIdentity.ReadIdentity(reader); } else if (version != null && reader.NamespaceURI == version.Namespace) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateXmlException(reader, SR.Format(SR.AddressingExtensionInBadNS, reader.LocalName, reader.NamespaceURI))); } else { if (bufferWriter == null) { if (buffer == null) { buffer = new XmlBuffer(short.MaxValue); } bufferWriter = buffer.OpenSection(reader.Quotas); bufferWriter.WriteStartElement(DummyName, DummyNamespace); } bufferWriter.WriteNode(reader, true); } reader.MoveToContent(); } if (bufferWriter != null) { bufferWriter.WriteEndElement(); buffer.CloseSection(); section = buffer.SectionCount - 1; } else { section = -1; } return(buffer); }
void ValidateMessageBody(ref System.ServiceModel.Channels.Message message, bool isRequest) { if (!message.IsFault) { XmlDictionaryReaderQuotas quotas = new XmlDictionaryReaderQuotas(); XmlReader bodyReader = message.GetReaderAtBodyContents().ReadSubtree(); XmlReaderSettings wrapperSettings = new XmlReaderSettings(); wrapperSettings.CloseInput = true; wrapperSettings.Schemas = EntityBase <object> .Schemas; wrapperSettings.ValidationFlags = XmlSchemaValidationFlags.None; wrapperSettings.ValidationType = ValidationType.Schema; wrapperSettings.ValidationEventHandler += new ValidationEventHandler(InspectionValidationHandler); XmlReader wrappedReader = XmlReader.Create(bodyReader, wrapperSettings); // pull body into a memory backed writer to validate this.isRequest = isRequest; MemoryStream memStream = new MemoryStream(); XmlDictionaryWriter xdw = XmlDictionaryWriter.CreateBinaryWriter(memStream); xdw.WriteNode(wrappedReader, false); xdw.Flush(); memStream.Position = 0; XmlDictionaryReader xdr = XmlDictionaryReader.CreateBinaryReader(memStream, quotas); } }
protected override void OnWriteBodyContents(XmlDictionaryWriter writer) { switch (_state) { case BodyState.Created: InnerMessage.WriteBodyContents(writer); return; case BodyState.Signed: case BodyState.EncryptedThenSigned: XmlDictionaryReader reader = _fullBodyBuffer.GetReader(0); reader.ReadStartElement(); while (reader.NodeType != XmlNodeType.EndElement) { writer.WriteNode(reader, false); } reader.ReadEndElement(); reader.Close(); return; case BodyState.Encrypted: case BodyState.SignedThenEncrypted: throw ExceptionHelper.PlatformNotSupported(); default: throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateBadStateException(nameof(OnWriteBodyContents))); } }
protected override void OnWriteBodyContents(XmlDictionaryWriter writer) { if (!IsEmpty) { if (!isInboundRequest) { writer.WriteStartElement(IsXmlRpcMethodCall ? XmlRpcProtocol.MethodCall : XmlRpcProtocol.MethodResponse); if (IsXmlRpcMethodCall) { writer.WriteStartElement(XmlRpcProtocol.MethodName); writer.WriteString((string)properties["XmlRpcMethodName"]); writer.WriteEndElement(); } } writer.WriteNode(bodyReader, true); if (!isInboundRequest) { writer.WriteEndElement(); } writer.Flush(); } }
public static void WriteNodeToWriter(byte[] buffer, XmlDictionaryWriter writer) { using (XmlDictionaryReader reader = Utility.CreateReader(buffer)) { writer.WriteNode((XmlReader)reader, false); } }
protected override void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion) { foreach (XmlNode node in _usageReceipt.ChildNodes[0].ChildNodes) { writer.WriteNode(node.CreateNavigator(), false); } }
protected override void OnWriteBodyContents(XmlDictionaryWriter writer) { switch (this.state) { case BodyState.Created: this.InnerMessage.WriteBodyContents(writer); return; case BodyState.Signed: using (XmlDictionaryReader reader = Utility.CreateReader(this.fullBodyBuffer)) { reader.MoveToStartElement(); reader.ReadStartElement(); while (reader.NodeType != XmlNodeType.EndElement) { writer.WriteNode(reader, false); } reader.ReadEndElement(); } return; default: throw new ArgumentException("Can't write the message because it is in a bad or unknown state"); } }
protected override void OnWriteBodyContents(XmlDictionaryWriter writer) { if (!IsEmpty) { writer.WriteNode(_bodyReader, true); } }
public XmlSyndicationContent(XmlReader reader) { if (reader == null) { throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader"); } SyndicationFeedFormatter.MoveToStartElement(reader); if (reader.HasAttributes) { while (reader.MoveToNextAttribute()) { string localName = reader.LocalName; string namespaceURI = reader.NamespaceURI; string str3 = reader.Value; if ((localName == "type") && (namespaceURI == string.Empty)) { this.type = str3; } else if (!FeedUtils.IsXmlns(localName, namespaceURI)) { base.AttributeExtensions.Add(new XmlQualifiedName(localName, namespaceURI), str3); } } reader.MoveToElement(); } this.type = string.IsNullOrEmpty(this.type) ? "text/xml" : this.type; this.contentBuffer = new XmlBuffer(0x7fffffff); using (XmlDictionaryWriter writer = this.contentBuffer.OpenSection(XmlDictionaryReaderQuotas.Max)) { writer.WriteNode(reader, false); } this.contentBuffer.CloseSection(); this.contentBuffer.Close(); }
public override void WriteObjectContent(XmlDictionaryWriter writer, object graph) { if (writer == null) throw new ArgumentNullException("writer"); if (writer.WriteState != WriteState.Element) throw new SerializationException(string.Format("WriteState '{0}' not valid. Caller must write start element before serializing in contentOnly mode.", writer.WriteState)); using (MemoryStream memoryStream = new MemoryStream()) { using (XmlDictionaryWriter bufferWriter = XmlDictionaryWriter.CreateTextWriter(memoryStream, Encoding.UTF8)) { serializer.Serialize(bufferWriter, graph); bufferWriter.Flush(); memoryStream.Position = 0; using (XmlReader reader = new XmlTextReader(memoryStream)) { reader.MoveToContent(); writer.WriteAttributes(reader, false); if (reader.Read()) // move off start node (we want to skip it) { while (reader.NodeType != XmlNodeType.EndElement) // also skip end node. writer.WriteNode(reader, false); // this will take us to the start of the next child node, or the end node. reader.ReadEndElement(); // not necessary, but clean } } } } }
// copy all of reader to writer static internal void Copy(XmlDictionaryWriter writer, XmlDictionaryReader reader) { while (!Done(reader)) { writer.WriteNode(reader, true); } }
// Saves the element in the reader to the buffer (attributes preserved) // Type is populated from type attribute on reader // Reader must be positioned at an element public XmlSyndicationContent(XmlReader reader) { if (reader == null) { throw new ArgumentNullException(nameof(reader)); } SyndicationFeedFormatter.MoveToStartElement(reader); if (reader.HasAttributes) { while (reader.MoveToNextAttribute()) { string name = reader.LocalName; string ns = reader.NamespaceURI; string value = reader.Value; if (name == Atom10Constants.TypeTag && ns == string.Empty) { _type = value; } else if (!FeedUtils.IsXmlns(name, ns)) { base.AttributeExtensions.Add(new XmlQualifiedName(name, ns), value); } } reader.MoveToElement(); } _type = string.IsNullOrEmpty(_type) ? Atom10Constants.XmlMediaType : _type; _contentBuffer = new XmlBuffer(int.MaxValue); using (XmlDictionaryWriter writer = _contentBuffer.OpenSection(XmlDictionaryReaderQuotas.Max)) { writer.WriteNode(reader, false); } _contentBuffer.CloseSection(); _contentBuffer.Close(); }
internal static async Task <Tuple <XmlBuffer, XmlDictionaryWriter> > CreateBufferIfRequiredAndWriteNodeAsync(XmlBuffer buffer, XmlDictionaryWriter extWriter, XmlReader reader, int maxExtensionSize) { if (buffer == null) { buffer = new XmlBuffer(maxExtensionSize); extWriter = buffer.OpenSection(XmlDictionaryReaderQuotas.Max); extWriter.WriteStartElement(Rss20Constants.ExtensionWrapperTag); } XmlDictionaryReader dictionaryReader = reader as XmlDictionaryReader; if (dictionaryReader != null) { // Reimplementing WriteNode for XmlDictionaryWriter asynchronously depends on multiple internal methods // so isn't feasible to reimplement here. As the primary scenario will be usage with an XmlReader which // isn't an XmlDictionaryReader, deferring to the synchronous implementation is a reasonable fallback. extWriter.WriteNode(reader, false); } else { await extWriter.WriteNodeAsync(reader, false); } return(Tuple.Create(buffer, extWriter)); }
public BufferedHeader(MessageVersion version, XmlBuffer buffer, XmlDictionaryReader reader, XmlAttributeHolder[] envelopeAttributes, XmlAttributeHolder[] headerAttributes) { this.streamed = true; this.buffer = buffer; this.version = version; MessageHeader.GetHeaderAttributes(reader, version, out this.actor, out this.mustUnderstand, out this.relay, out this.isRefParam); this.name = reader.LocalName; this.ns = reader.NamespaceURI; this.bufferIndex = buffer.SectionCount; XmlDictionaryWriter writer = buffer.OpenSection(reader.Quotas); writer.WriteStartElement("Envelope"); if (envelopeAttributes != null) { XmlAttributeHolder.WriteAttributes(envelopeAttributes, writer); } writer.WriteStartElement("Header"); if (headerAttributes != null) { XmlAttributeHolder.WriteAttributes(headerAttributes, writer); } writer.WriteNode(reader, false); writer.WriteEndElement(); writer.WriteEndElement(); buffer.CloseSection(); }
protected override void OnWriteDetail(XmlDictionaryWriter writer, EnvelopeVersion version) { using (XmlReader r = _detail.GetReader(0)) { // Start the element base.OnWriteStartDetail(writer, version); // Copy the attributes while (r.MoveToNextAttribute()) { if (ShouldWriteDetailAttribute(version, r.Prefix, r.LocalName, r.Value)) { writer.WriteAttributeString(r.Prefix, r.LocalName, r.NamespaceURI, r.Value); } } r.MoveToElement(); r.Read(); // Copy the contents while (r.NodeType != XmlNodeType.EndElement) { writer.WriteNode(r, false); } // End the element writer.WriteEndElement(); } }
protected override void OnWriteBodyContents(XmlDictionaryWriter writer) { switch (this.state) { case BodyState.Created: this.InnerMessage.WriteBodyContents(writer); return; case BodyState.Signed: case BodyState.EncryptedThenSigned: XmlDictionaryReader reader = fullBodyBuffer.GetReader(0); reader.ReadStartElement(); while (reader.NodeType != XmlNodeType.EndElement) { writer.WriteNode(reader, false); } reader.ReadEndElement(); reader.Close(); return; case BodyState.Encrypted: case BodyState.SignedThenEncrypted: this.encryptedBodyContent.WriteTo(writer, ServiceModelDictionaryManager.Instance); break; default: throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateBadStateException(nameof(OnWriteBodyContents))); } }
public BufferedHeader(MessageVersion version, XmlBuffer buffer, XmlDictionaryReader reader, XmlAttributeHolder[] envelopeAttributes, XmlAttributeHolder[] headerAttributes) { streamed = true; this.buffer = buffer; this.version = version; GetHeaderAttributes(reader, version, out actor, out mustUnderstand, out relay, out isRefParam); name = reader.LocalName; ns = reader.NamespaceURI; Fx.Assert(name != null, ""); Fx.Assert(ns != null, ""); bufferIndex = buffer.SectionCount; XmlDictionaryWriter writer = buffer.OpenSection(reader.Quotas); // Write an enclosing Envelope tag writer.WriteStartElement(MessageStrings.Envelope); if (envelopeAttributes != null) { XmlAttributeHolder.WriteAttributes(envelopeAttributes, writer); } // Write and enclosing Header tag writer.WriteStartElement(MessageStrings.Header); if (headerAttributes != null) { XmlAttributeHolder.WriteAttributes(headerAttributes, writer); } writer.WriteNode(reader, false); writer.WriteEndElement(); writer.WriteEndElement(); buffer.CloseSection(); }
public void WriteTo(Stream canonicalStream) { if (this.reader != null) { XmlDictionaryReader dicReader = this.reader as XmlDictionaryReader; if ((dicReader != null) && (dicReader.CanCanonicalize)) { dicReader.MoveToContent(); dicReader.StartCanonicalization(canonicalStream, this.includeComments, this.inclusivePrefixes); dicReader.Skip(); dicReader.EndCanonicalization(); } else { XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(Stream.Null); if (this.inclusivePrefixes != null) { // Add a dummy element at the top and populate the namespace // declaration of all the inclusive prefixes. writer.WriteStartElement("a", reader.LookupNamespace(String.Empty)); for (int i = 0; i < this.inclusivePrefixes.Length; ++i) { string ns = reader.LookupNamespace(this.inclusivePrefixes[i]); if (ns != null) { writer.WriteXmlnsAttribute(this.inclusivePrefixes[i], ns); } } } writer.StartCanonicalization(canonicalStream, this.includeComments, this.inclusivePrefixes); if (reader is WrappedReader) { ((WrappedReader)reader).XmlTokens.GetWriter().WriteTo(writer, new DictionaryManager()); } else { writer.WriteNode(reader, false); } writer.Flush(); writer.EndCanonicalization(); if (this.inclusivePrefixes != null) { writer.WriteEndElement(); } writer.Close(); } if (this.closeReadersAfterProcessing) { this.reader.Close(); } this.reader = null; } else { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.NoInputIsSetForCanonicalization))); } }
protected override void OnWriteBodyContents(XmlDictionaryWriter writer) { XmlDictionaryReader reader = this.originalMessage.GetReaderAtBodyContents(); // Write root StartElement writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI); writer.WriteAttributes(reader, true); reader.ReadStartElement(); // Write QueryResult StartElement writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI); writer.WriteAttributes(reader, true); // Write QueryResult content string nodeName = reader.LocalName; reader.Read(); while (reader.NodeType != XmlNodeType.EndElement || reader.Name != nodeName) { XmlReader subtree = reader.ReadSubtree(); writer.WriteNode(subtree, false); reader.ReadEndElement(); } // Insert metadata start writer.WriteStartElement("Metadata"); writer.WriteAttributeString("type", "array"); // This two foreach loops are to ensure we write the return entity of the query first, then all the rest. // This is a requirement of the RIA/JS client side implementation. If modifying this, client side needs update too. foreach (ServiceMetadataGenerator.TypeMetadata map in ServiceMetadataGenerator.EntitiesMetadata) { if (map.Name == this.entityTypeName) { writer.WriteStartElement("item"); writer.WriteAttributeString("type", "object"); map.WriteJson(writer); writer.WriteEndElement(); break; } } foreach (ServiceMetadataGenerator.TypeMetadata map in ServiceMetadataGenerator.EntitiesMetadata) { if (map.Name != this.entityTypeName) { writer.WriteStartElement("item"); writer.WriteAttributeString("type", "object"); map.WriteJson(writer); writer.WriteEndElement(); } } writer.WriteEndElement(); // Insert metadata end // Close QueryResult writer.WriteEndElement(); // Close root writer.WriteEndElement(); }
protected override void OnWriteBodyContents( XmlDictionaryWriter writer) { XmlReader r = reader ?? XmlReader.Create(new StringReader(xml)); r.MoveToContent(); writer.WriteNode(r, false); }
protected override void OnWriteBodyContents(XmlDictionaryWriter writer) { using (var sr = new System.IO.StringReader(_content)) using (var xr = XmlReader.Create(sr)) { writer.WriteNode(xr, true); } }
private void WriteContentsTo200408(XmlDictionaryWriter writer) { writer.WriteStartElement(XD.AddressingDictionary.Address, XD.Addressing200408Dictionary.Namespace); if (this.isAnonymous) { writer.WriteString(XD.Addressing200408Dictionary.Anonymous); } else { if (this.isNone) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("addressingVersion", System.ServiceModel.SR.GetString("SFxNone2004")); } writer.WriteString(this.Uri.AbsoluteUri); } writer.WriteEndElement(); if ((this.headers != null) && this.headers.HasReferenceProperties) { writer.WriteStartElement(XD.AddressingDictionary.ReferenceProperties, XD.Addressing200408Dictionary.Namespace); this.headers.WriteReferencePropertyContentsTo(writer); writer.WriteEndElement(); } if ((this.headers != null) && this.headers.HasNonReferenceProperties) { writer.WriteStartElement(XD.AddressingDictionary.ReferenceParameters, XD.Addressing200408Dictionary.Namespace); this.headers.WriteNonReferencePropertyContentsTo(writer); writer.WriteEndElement(); } XmlDictionaryReader readerAtSection = null; if (this.pspSection >= 0) { readerAtSection = GetReaderAtSection(this.buffer, this.pspSection); Copy(writer, readerAtSection); } readerAtSection = null; if (this.metadataSection >= 0) { readerAtSection = GetReaderAtSection(this.buffer, this.metadataSection); Copy(writer, readerAtSection); } if (this.Identity != null) { this.Identity.WriteTo(writer); } if (this.extensionSection >= 0) { readerAtSection = GetReaderAtSection(this.buffer, this.extensionSection); while (readerAtSection.IsStartElement()) { if (readerAtSection.NamespaceURI == AddressingVersion.WSAddressingAugust2004.Namespace) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateXmlException(readerAtSection, System.ServiceModel.SR.GetString("AddressingExtensionInBadNS", new object[] { readerAtSection.LocalName, readerAtSection.NamespaceURI }))); } writer.WriteNode(readerAtSection, true); } } }
protected override void OnBodyToString(XmlDictionaryWriter writer) { using (XmlDictionaryReader reader = this.GetBufferedReaderAtBody()) { if (this.Version == MessageVersion.None) { writer.WriteNode(reader, false); } else if (!reader.IsEmptyElement) { reader.ReadStartElement(); while (reader.NodeType != XmlNodeType.EndElement) { writer.WriteNode(reader, false); } } } }
public override void WriteTokenCore(XmlDictionaryWriter writer, SecurityToken token) { if (token is BufferedGenericXmlSecurityToken bufferedXmlToken && bufferedXmlToken.TokenXmlBuffer != null) { using (XmlDictionaryReader reader = bufferedXmlToken.TokenXmlBuffer.GetReader(0)) { writer.WriteNode(reader, false); } }
void WriteContentsTo10(XmlDictionaryWriter writer) { // Address writer.WriteStartElement(XD.AddressingDictionary.Address, XD.Addressing10Dictionary.Namespace); if (isAnonymous) { writer.WriteString(XD.Addressing10Dictionary.Anonymous); } else if (isNone) { writer.WriteString(XD.Addressing10Dictionary.NoneAddress); } else { writer.WriteString(Uri.AbsoluteUri); } writer.WriteEndElement(); // Headers if (headers != null && headers.Count > 0) { writer.WriteStartElement(XD.AddressingDictionary.ReferenceParameters, XD.Addressing10Dictionary.Namespace); headers.WriteContentsTo(writer); writer.WriteEndElement(); } // Metadata if (metadataSection >= 0) { XmlDictionaryReader reader = GetReaderAtSection(buffer, metadataSection); writer.WriteStartElement(XD.Addressing10Dictionary.Metadata, XD.Addressing10Dictionary.Namespace); Copy(writer, reader); writer.WriteEndElement(); } // EndpointIdentity if (Identity != null) { Identity.WriteTo(writer); } // Extensions if (extensionSection >= 0) { XmlDictionaryReader reader = GetReaderAtSection(buffer, extensionSection); while (reader.IsStartElement()) { if (reader.NamespaceURI == AddressingVersion.WSAddressing10.Namespace) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateXmlException(reader, SR.Format(SR.AddressingExtensionInBadNS, reader.LocalName, reader.NamespaceURI))); } writer.WriteNode(reader, true); } } }
internal static void CreateBufferIfRequiredAndWriteNode(ref XmlBuffer buffer, ref XmlDictionaryWriter extWriter, XmlReader reader, int maxExtensionSize) { if (buffer == null) { buffer = new XmlBuffer(maxExtensionSize); extWriter = buffer.OpenSection(XmlDictionaryReaderQuotas.Max); extWriter.WriteStartElement(Rss20Constants.ExtensionWrapperTag); } extWriter.WriteNode(reader, false); }
protected override void OnWriteBodyContents( XmlDictionaryWriter writer) { XmlDictionaryReader reader = GetReaderAtBodyContents(); while (!reader.EOF && reader.NodeType != XmlNodeType.EndElement) { writer.WriteNode(reader, false); } }