| public abstract WriteFullEndElement ( ) : void | ||
| return | void | |
internal override void WriteTo(XmlWriter xml)
{
if (xml == null)
return;
xml.WriteComment(SR.GetString(SR.ServiceNameFromClient));
xml.WriteElementString("ServiceName", this.serviceBindingNameSentByClient);
xml.WriteComment(SR.GetString(SR.ServiceNameOnService));
xml.WriteStartElement("ServiceNameCollection");
if (this.serviceNameCollectionConfiguredOnServer == null || this.serviceNameCollectionConfiguredOnServer.Count < 1)
{
xml.WriteElementString("ServiceName", this.defaultServiceBindingNameOfServer);
}
else
{
foreach (string serviceName in this.serviceNameCollectionConfiguredOnServer)
{
xml.WriteElementString("ServiceName", serviceName);
}
}
xml.WriteFullEndElement();
}
/// <summary>
/// 寫XML元素
/// </summary>
/// <param name="write">XmlWriter</param>
/// <param name="elementName">元素名稱</param>
/// <param name="value">元素的值</param>
public void WriteElement(XmlWriter writer, string elementName, string value)
{
if (string.IsNullOrEmpty(value) || value.Length == 0)
{
writer.WriteStartElement(elementName);
writer.WriteFullEndElement();
}
else
{
writer.WriteElementString(elementName, value);
}
}
public void WriteXml(System.Xml.XmlWriter writer)
{
writer.WriteElementString("Name", Name);
writer.WriteStartElement("XmlString");
writer.WriteRaw(XmlString);
writer.WriteFullEndElement();
}
public bool fullEndElement()
{
if (!EndElementHelper())
{
return(false);
}
return(CheckedCall(() => _writer.WriteFullEndElement()));
}
public void WriteXml(System.Xml.XmlWriter writer)
{
XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
writer.WriteStartElement("item");
foreach (TKey key in this.Keys)
{
writer.WriteStartElement("key");
keySerializer.Serialize(writer, key);
writer.WriteEndElement();
writer.WriteStartElement("value");
TValue value = this[key];
valueSerializer.Serialize(writer, value);
writer.WriteFullEndElement();
}
writer.WriteFullEndElement();
}
void IXmlSerializable.WriteXml(System.Xml.XmlWriter writer)
{
writer.WriteAttributeString("id", Id);
writer.WriteAttributeString("name", Name);
writer.WriteAttributeString("description", Description);
writer.WriteAttributeString("activator", ActivatorClass);
writer.WriteAttributeString("version", Version.ToString());
writer.WriteAttributeString("provider", Provider);
writer.WriteAttributeString("assemblyLocation", AssemblyLocation);
foreach (IExtensionPointConfiguration ep in ContributedExtensionPoints)
{
writer.WriteStartElement("extensionPoint", RuntimeConstants.CurrentXmlSchemaNamespace);
((IXmlSerializable)ep).WriteXml(writer);
writer.WriteFullEndElement();
}
foreach (IExtensionConfiguration ext in ContributedExtensions)
{
writer.WriteStartElement("extension", RuntimeConstants.CurrentXmlSchemaNamespace);
((IXmlSerializable)ext).WriteXml(writer);
writer.WriteFullEndElement();
}
}
void WriteXml(XmlWriter writer)
{
CommonUtility.AssertNotNull("writer", writer);
writer.WriteComment(SR.ExceptionOccurred);
writer.WriteStartElement("RequestResult");
writer.WriteElementString("HTTPStatusCode", Convert.ToString(this.HttpStatusCode, CultureInfo.InvariantCulture));
writer.WriteElementString("HttpStatusMessage", this.HttpStatusMessage);
writer.WriteElementString("TargetLocation", this.TargetLocation.ToString());
// Headers
writer.WriteElementString("ServiceRequestID", this.ServiceRequestID);
writer.WriteElementString("ContentMd5", this.ContentMd5);
writer.WriteElementString("Etag", this.Etag);
writer.WriteElementString("RequestDate", this.RequestDate);
// Dates - using RFC 1123 pattern
writer.WriteElementString("StartTime", this.StartTime.ToUniversalTime().ToString("R", CultureInfo.InvariantCulture));
writer.WriteElementString("EndTime", this.EndTime.ToUniversalTime().ToString("R", CultureInfo.InvariantCulture));
// Extended info
if (this.ExtendedErrorInformation != null)
{
this.ExtendedErrorInformation.WriteXml(writer);
}
else
{
// Write empty
writer.WriteStartElement(Constants.ErrorRootElement);
writer.WriteFullEndElement();
}
#if WINDOWS_RT || ASPNET_K
// Exception
if (this.ExceptionInfo != null)
{
this.ExceptionInfo.WriteXml(writer);
}
else
{
// Write empty
writer.WriteStartElement("ExceptionInfo");
writer.WriteFullEndElement();
}
#endif
// End RequestResult
writer.WriteEndElement();
}
private void WriteNode(XmlWriter xtw, bool defattr)
{
int num = (this.NodeType == XmlNodeType.None) ? -1 : this.Depth;
while (this.Read() && (num < this.Depth))
{
switch (this.NodeType)
{
case XmlNodeType.Element:
xtw.WriteStartElement(this.Prefix, this.LocalName, this.NamespaceURI);
((XmlTextWriter) xtw).QuoteChar = this.QuoteChar;
xtw.WriteAttributes(this, defattr);
if (this.IsEmptyElement)
{
xtw.WriteEndElement();
}
break;
case XmlNodeType.Text:
xtw.WriteString(this.Value);
break;
case XmlNodeType.CDATA:
xtw.WriteCData(this.Value);
break;
case XmlNodeType.EntityReference:
xtw.WriteEntityRef(this.Name);
break;
case XmlNodeType.ProcessingInstruction:
case XmlNodeType.XmlDeclaration:
xtw.WriteProcessingInstruction(this.Name, this.Value);
break;
case XmlNodeType.Comment:
xtw.WriteComment(this.Value);
break;
case XmlNodeType.DocumentType:
xtw.WriteDocType(this.Name, this.GetAttribute("PUBLIC"), this.GetAttribute("SYSTEM"), this.Value);
break;
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
xtw.WriteWhitespace(this.Value);
break;
case XmlNodeType.EndElement:
xtw.WriteFullEndElement();
break;
}
}
if ((num == this.Depth) && (this.NodeType == XmlNodeType.EndElement))
{
this.Read();
}
}
private static void WriteList(XmlWriter writer, IList<string> list, string listName)
{
writer.WriteElementString("key", listName);
writer.WriteStartElement("array");
foreach (string listEntry in list)
{
writer.WriteStartElement("dict");
writer.WriteElementString("key", "name");
writer.WriteElementString("string", listEntry);
writer.WriteEndElement();
}
writer.WriteFullEndElement();
}
internal override void WriteTo(XmlWriter xml)
{
if (xml == null)
return;
if (this.policyHelper != null)
{
xml.WriteElementString("PolicyEnforcement", this.policyHelper.PolicyEnforcement.ToString());
xml.WriteElementString("ProtectionScenario", this.policyHelper.ProtectionScenario.ToString());
xml.WriteStartElement("ServiceNameCollection");
if (this.policyHelper.ServiceNameCollection != null && this.policyHelper.ServiceNameCollection.Count > 0)
{
foreach (string serviceName in this.policyHelper.ServiceNameCollection)
{
xml.WriteElementString("ServiceName", serviceName);
}
}
xml.WriteFullEndElement();
if (this.isServer)
{
this.channelBindingUsed = this.policyHelper.ShouldAddChannelBindingToASC();
}
else
{
this.channelBindingUsed = this.policyHelper.ChannelBinding != null;
}
xml.WriteElementString("ChannelBindingUsed", this.channelBindingUsed.ToString());
if (this.channelBinding != null && this.policyHelper.PolicyEnforcement != PolicyEnforcement.Never && this.channelBindingUsed == true)
{
ExtendedProtectionPolicy extendedProtection = new ExtendedProtectionPolicy(policyHelper.PolicyEnforcement, channelBinding);
xml.WriteElementString("ChannelBindingData", GetBase64EncodedChannelBindingData(extendedProtection));
}
}
else
{
// This is the case for KerberosRequestorSecurityToken where policyHelper is null.
if (this.channelBinding != null)
{
xml.WriteElementString("ChannelBindingUsed", "true");
// We do not know the PolicyEnforcement value here on the client side and we can not pass Never
//as ExtendedProtectionPolicy constructor would throw on PolicyEnforcement.Never
ExtendedProtectionPolicy extendedProtection = new ExtendedProtectionPolicy(PolicyEnforcement.WhenSupported, channelBinding);
xml.WriteElementString("ChannelBindingData", GetBase64EncodedChannelBindingData(extendedProtection));
}
else
{
xml.WriteElementString("ChannelBindingUsed", "false");
xml.WriteElementString("ChannelBindingData", null);
}
}
}
public override void WriteTo (XmlWriter w)
{
// some people expect the same prefix output as in input,
// in the loss of performance... see bug #466423.
string prefix = name.NamespaceName.Length > 0 ? w.LookupPrefix (name.Namespace.NamespaceName) : String.Empty;
foreach (XAttribute a in Attributes ()) {
if (a.IsNamespaceDeclaration && a.Value == name.Namespace.NamespaceName) {
if (a.Name.Namespace == XNamespace.Xmlns)
prefix = a.Name.LocalName;
// otherwise xmlns="..."
break;
}
}
w.WriteStartElement (prefix, name.LocalName, name.Namespace.NamespaceName);
foreach (XAttribute a in Attributes ()) {
if (a.IsNamespaceDeclaration) {
if (a.Name.Namespace == XNamespace.Xmlns)
w.WriteAttributeString ("xmlns", a.Name.LocalName, XNamespace.Xmlns.NamespaceName, a.Value);
else
w.WriteAttributeString ("xmlns", a.Value);
}
else
w.WriteAttributeString (a.Name.LocalName, a.Name.Namespace.NamespaceName, a.Value);
}
foreach (XNode node in Nodes ())
node.WriteTo (w);
if (explicit_is_empty)
w.WriteEndElement ();
else
w.WriteFullEndElement ();
}
// Writes the content (inner XML) of the current node into the provided XmlWriter.
private void WriteNode(XmlWriter xtw, bool defattr) {
#if !SILVERLIGHT
Debug.Assert(xtw is XmlTextWriter);
#endif
int d = this.NodeType == XmlNodeType.None ? -1 : this.Depth;
while (this.Read() && (d < this.Depth)) {
switch (this.NodeType) {
case XmlNodeType.Element:
xtw.WriteStartElement(this.Prefix, this.LocalName, this.NamespaceURI);
#if !SILVERLIGHT // Removing dependency on XmlTextWriter
((XmlTextWriter)xtw).QuoteChar = this.QuoteChar;
#endif
xtw.WriteAttributes(this, defattr);
if (this.IsEmptyElement) {
xtw.WriteEndElement();
}
break;
case XmlNodeType.Text:
xtw.WriteString(this.Value);
break;
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
xtw.WriteWhitespace(this.Value);
break;
case XmlNodeType.CDATA:
xtw.WriteCData(this.Value);
break;
case XmlNodeType.EntityReference:
xtw.WriteEntityRef(this.Name);
break;
case XmlNodeType.XmlDeclaration:
case XmlNodeType.ProcessingInstruction:
xtw.WriteProcessingInstruction(this.Name, this.Value);
break;
case XmlNodeType.DocumentType:
xtw.WriteDocType(this.Name, this.GetAttribute("PUBLIC"), this.GetAttribute("SYSTEM"), this.Value);
break;
case XmlNodeType.Comment:
xtw.WriteComment(this.Value);
break;
case XmlNodeType.EndElement:
xtw.WriteFullEndElement();
break;
}
}
if (d == this.Depth && this.NodeType == XmlNodeType.EndElement) {
Read();
}
}
private static void WriteShallowNode(XmlReader reader, XmlWriter writer)
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
writer.WriteAttributes(reader, true);
if (reader.IsEmptyElement)
{
writer.WriteEndElement();
}
return;
case XmlNodeType.Text:
writer.WriteString(reader.Value);
return;
case XmlNodeType.CDATA:
writer.WriteCData(reader.Value);
return;
case XmlNodeType.ProcessingInstruction:
writer.WriteProcessingInstruction(reader.Name, reader.Value);
return;
case XmlNodeType.Comment:
writer.WriteComment(reader.Value);
return;
case XmlNodeType.DocumentType:
writer.WriteDocType(reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), reader.Value);
return;
case XmlNodeType.Whitespace:
writer.WriteWhitespace(reader.Value);
return;
case XmlNodeType.SignificantWhitespace:
writer.WriteWhitespace(reader.Value);
return;
case XmlNodeType.EndElement:
writer.WriteFullEndElement();
return;
case XmlNodeType.XmlDeclaration:
writer.WriteProcessingInstruction(reader.Name, reader.Value);
return;
}
throw new InvalidOperationException("Invalid node");
}
/// <summary>
/// Saves docking configuration information using a provider xml writer.
/// </summary>
/// <param name="xmlWriter">Xml writer object.</param>
public virtual void SaveElementToXml(XmlWriter xmlWriter)
{
// Output docking lement
xmlWriter.WriteStartElement(XmlElementName);
xmlWriter.WriteAttributeString("N", Name);
xmlWriter.WriteAttributeString("C", Count.ToString());
// Output an element per child
foreach (IDockingElement child in this)
child.SaveElementToXml(xmlWriter);
// Terminate the workspace element
xmlWriter.WriteFullEndElement();
}
// This method is copied from System.Xml.Linq.ElementWriter.WriteElement but adapted to DOM
private static void WriteElementTo(XmlWriter writer, XmlElement e)
{
XmlNode root = e;
XmlNode n = e;
while (true)
{
e = n as XmlElement;
// Only use the inlined write logic for XmlElement, not for derived classes
if (e != null && e.GetType() == typeof(XmlElement))
{
// Write the element
e.WriteStartElement(writer);
// Write the element's content
if (e.IsEmpty)
{
// No content; use a short end element <a />
writer.WriteEndElement();
}
else if (e._lastChild == null)
{
// No actual content; use a full end element <a></a>
writer.WriteFullEndElement();
}
else
{
// There are child node(s); move to first child
n = e.FirstChild;
Debug.Assert(n != null);
continue;
}
}
else
{
// Use virtual dispatch (might recurse)
n.WriteTo(writer);
}
// Go back to the parent after writing the last child
while (n != root && n == n.ParentNode.LastChild)
{
n = n.ParentNode;
Debug.Assert(n != null);
writer.WriteFullEndElement();
}
if (n == root)
break;
n = n.NextSibling;
Debug.Assert(n != null);
}
}
/// <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 WriteFullEndElement()
{
CheckAsync();
_coreWriter.WriteFullEndElement();
}
public void WriteXml(System.Xml.XmlWriter writer)
{
writer.WriteElementString("Val", ValueToSerialize);
writer.WriteFullEndElement();
}
public virtual void WriteXml(System.Xml.XmlWriter writer)
{
writer.WriteStartElement("WriteFullEndElement");
writer.WriteFullEndElement(); //WriteFullEndElement
}
private void WriteNil(XmlWriter writer)
{
writer.WriteStartElement("nil");
writer.WriteFullEndElement();
}
private void WriteTuneNode(XmlWriter xmlWriter, Track tune)
{
xmlWriter.WriteStartElement("Tune");
xmlWriter.WriteAttributeString("Filename", tune.Filename);
WritePlainElement(xmlWriter, "Genre", tune.Genre);
WritePlainElement(xmlWriter, "Title", tune.Title);
if (HasContent(tune.Song))
WritePlainElement(xmlWriter, "Song", tune.Song);
if (tune.IsTheme)
WritePlainElement(xmlWriter, "Theme", "Yes");
WritePlainElement(xmlWriter, "TrackLength", tune.TrackLength.ToString());
if (HasContent(tune.SkipSecs))
WritePlainElement(xmlWriter, "Skipsecs", tune.SkipSecs.ToString());
if (HasContent(tune.PlaySecs))
WritePlainElement(xmlWriter, "Playsecs", tune.PlaySecs.ToString());
if (HasContent(tune.CloseAnswer)) {
foreach (string answer in tune.CloseAnswer.Split('|')) {
if (HasContent(answer))
WritePlainElement(xmlWriter, "CloseAnswer", answer);
}
}
WritePlainElement(xmlWriter, "TimesPlayed", tune.TimesPlayed.ToString());
xmlWriter.WriteFullEndElement();
}
/// <summary>
/// Serializes a rectagular table range
/// </summary>
private static void WriteXamlTableCellRange(XmlWriter xmlWriter, ITextRange range, XamlTypeMapper xamlTypeMapper, ref int elementLevel, WpfPayload wpfPayload, bool preserveTextElements)
{
Invariant.Assert(range.IsTableCellRange, "range is expected to be in IsTableCellRange state");
List<TextSegment> textSegments = range.TextSegments;
int checkElementLevel = -1; // negative value as an indicator that it is not yet initialized
// Set ignoreWriteHyperlinkEnd as false initially
bool ignoreWriteHyperlinkEnd = false;
List<int> ignoreList = new List<int>();
for (int i = 0; i < textSegments.Count; i++)
{
TextSegment textSegment = textSegments[i];
// Open a row for this segment (except for the very first one, for which we opened a row in a WriteOpeningTags method)
if (i > 0)
{
ITextPointer pointer = textSegment.Start.CreatePointer();
while (!typeof(TableRow).IsAssignableFrom(pointer.ParentType))
{
Invariant.Assert(typeof(TextElement).IsAssignableFrom(pointer.ParentType), "pointer must be still in a scope of TextElement");
pointer.MoveToElementEdge(ElementEdge.BeforeStart);
}
Invariant.Assert(typeof(TableRow).IsAssignableFrom(pointer.ParentType), "pointer must be in a scope of TableRow");
pointer.MoveToElementEdge(ElementEdge.BeforeStart);
ITextRange textRange = new TextRange(textSegment.Start, textSegment.End);
elementLevel += WriteOpeningTags(textRange, textSegment.Start, pointer, xmlWriter, xamlTypeMapper, /*reduceElement:*/wpfPayload == null, out ignoreWriteHyperlinkEnd, ref ignoreList, preserveTextElements);
}
// Output the cell segment for one row
WriteXamlTextSegment(xmlWriter, textSegment.Start, textSegment.End, xamlTypeMapper, ref elementLevel, wpfPayload, ignoreWriteHyperlinkEnd, ignoreList, preserveTextElements);
Invariant.Assert(elementLevel >= 4, "At the minimun we expected to stay within four elements: Section(wrapper),Table,TableRowGroup,TableRow");
if (checkElementLevel < 0) checkElementLevel = elementLevel; // initialize level checking variable
Invariant.Assert(checkElementLevel == elementLevel, "elementLevel is supposed to be unchanged between segments of table cell range");
// Assuming that the element is TableRow - close it.
// NOTE: Such assumption is valid because WriteXamlTextSegment moves end pointer out of all opening tags,
// so it ends serialization immediately after the last cell's closing tag.
// This means that we only need to close one level - for TableRow.
//
elementLevel--;
xmlWriter.WriteFullEndElement();
}
}
public override void WriteTo (XmlWriter writer)
{
// some people expect the same prefix output as in input,
// in the loss of performance... see bug #466423.
string prefix = LookupPrefix (name.NamespaceName, writer);
int createdNS = 0;
if (prefix == null)
prefix = CreateDummyNamespace (ref createdNS, Attributes (), false);
writer.WriteStartElement (prefix, name.LocalName, name.Namespace.NamespaceName);
foreach (XAttribute a in Attributes ()) {
if (a.IsNamespaceDeclaration) {
if (a.Name.Namespace == XNamespace.Xmlns)
writer.WriteAttributeString ("xmlns", a.Name.LocalName, XNamespace.Xmlns.NamespaceName, a.Value);
else
writer.WriteAttributeString ("xmlns", a.Value);
} else {
string apfix = LookupPrefix (a.Name.NamespaceName, writer);
if (apfix == null)
apfix = CreateDummyNamespace (ref createdNS, Attributes (), true);
writer.WriteAttributeString (apfix, a.Name.LocalName, a.Name.Namespace.NamespaceName, a.Value);
}
}
foreach (XNode node in Nodes ())
node.WriteTo (writer);
if (explicit_is_empty)
writer.WriteEndElement ();
else
writer.WriteFullEndElement ();
}
internal void BuildSubtree(XmlReader reader, XmlWriter writer)
{
string ns = "http://www.w3.org/2000/xmlns/";
ReadState readState = reader.ReadState;
if ((readState != ReadState.Initial) && (readState != ReadState.Interactive))
{
throw new ArgumentException(Res.GetString("Xml_InvalidOperation"), "reader");
}
int num = 0;
if (readState == ReadState.Initial)
{
if (!reader.Read())
{
return;
}
num++;
}
do
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
{
writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
bool isEmptyElement = reader.IsEmptyElement;
while (reader.MoveToNextAttribute())
{
if (reader.NamespaceURI == ns)
{
if (reader.Prefix.Length == 0)
{
writer.WriteAttributeString("", "xmlns", ns, reader.Value);
}
else
{
writer.WriteAttributeString("xmlns", reader.LocalName, ns, reader.Value);
}
}
else
{
writer.WriteStartAttribute(reader.Prefix, reader.LocalName, reader.NamespaceURI);
writer.WriteString(reader.Value);
writer.WriteEndAttribute();
}
}
reader.MoveToElement();
if (isEmptyElement)
{
writer.WriteEndElement();
}
else
{
num++;
}
break;
}
case XmlNodeType.Attribute:
if (reader.NamespaceURI != ns)
{
writer.WriteStartAttribute(reader.Prefix, reader.LocalName, reader.NamespaceURI);
writer.WriteString(reader.Value);
writer.WriteEndAttribute();
break;
}
if (reader.Prefix.Length != 0)
{
writer.WriteAttributeString("xmlns", reader.LocalName, ns, reader.Value);
break;
}
writer.WriteAttributeString("", "xmlns", ns, reader.Value);
break;
case XmlNodeType.Text:
case XmlNodeType.CDATA:
writer.WriteString(reader.Value);
break;
case XmlNodeType.EntityReference:
reader.ResolveEntity();
break;
case XmlNodeType.ProcessingInstruction:
writer.WriteProcessingInstruction(reader.LocalName, reader.Value);
break;
case XmlNodeType.Comment:
writer.WriteComment(reader.Value);
break;
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
writer.WriteString(reader.Value);
break;
case XmlNodeType.EndElement:
writer.WriteFullEndElement();
num--;
break;
}
}
while (reader.Read() && (num > 0));
}
public override void WriteTo(XmlWriter w)
{
w.WriteStartElement(this.Prefix, this.LocalName, this.NamespaceURI);
if (this.HasAttributes)
{
XmlAttributeCollection attributes = this.Attributes;
for (int i = 0; i < attributes.Count; i++)
{
attributes[i].WriteTo(w);
}
}
if (this.IsEmpty)
{
w.WriteEndElement();
}
else
{
this.WriteContentTo(w);
w.WriteFullEndElement();
}
}
public override void WriteFullEndElement()
{
writer.WriteFullEndElement();
}
// -------------------------------------------------------------
//
// Private Methods
//
// -------------------------------------------------------------
#region Private Methods
// .............................................................
//
// Serialization
//
// .............................................................
/// <summary>
/// This function serializes text segment formed by rangeStart and rangeEnd to valid xml using xmlWriter.
/// </summary>
/// <SecurityNote>
/// To mask the security exception from XamlWriter.Save in partial trust case,
/// this function checks if the current call stack has the all clipboard permission.
/// </SecurityNote>
private static void WriteXamlTextSegment(XmlWriter xmlWriter, ITextPointer rangeStart, ITextPointer rangeEnd, XamlTypeMapper xamlTypeMapper, ref int elementLevel, WpfPayload wpfPayload, bool ignoreWriteHyperlinkEnd, List<int> ignoreList, bool preserveTextElements)
{
// Special case for pure text selection - we need a Run wrapper for it.
if (elementLevel == EmptyDocumentDepth && typeof(Run).IsAssignableFrom(rangeStart.ParentType))
{
elementLevel++;
xmlWriter.WriteStartElement(typeof(Run).Name);
}
// Create text navigator for reading the range's content
ITextPointer textReader = rangeStart.CreatePointer();
// Exclude last opening tag from serialization - we don't need to create extra element
// is cases when we have whole paragraphs/cells selected.
// NOTE: We do this slightly differently than in TextRangeEdit.AdjustRangeEnd, where we use normalization for adjusted position.
// In this case normalized position does not work, because we need to keep information about crossed paragraph boundary.
while (rangeEnd.GetPointerContext(LogicalDirection.Backward) == TextPointerContext.ElementStart)
{
rangeEnd = rangeEnd.GetNextContextPosition(LogicalDirection.Backward);
}
// Write the range internal contents
while (textReader.CompareTo(rangeEnd) < 0)
{
TextPointerContext runType = textReader.GetPointerContext(LogicalDirection.Forward);
switch (runType)
{
case TextPointerContext.ElementStart:
TextElement nextElement = (TextElement)textReader.GetAdjacentElement(LogicalDirection.Forward);
if (nextElement is Hyperlink)
{
// Don't write Hyperlink start element if Hyperlink is invalid
// in case of having a UiElement except Image or stated the range end
// position before the end position of the Hyperlink.
if (IsHyperlinkInvalid(textReader, rangeEnd))
{
ignoreWriteHyperlinkEnd = true;
textReader.MoveToNextContextPosition(LogicalDirection.Forward);
continue;
}
}
else if (nextElement != null)
{
//
TextElementEditingBehaviorAttribute att = (TextElementEditingBehaviorAttribute)Attribute.GetCustomAttribute(nextElement.GetType(), typeof(TextElementEditingBehaviorAttribute));
if (att != null && !att.IsTypographicOnly)
{
if (IsPartialNonTypographic(textReader, rangeEnd))
{
// Add pointer to ignore list
ITextPointer ptr = textReader.CreatePointer();
ptr.MoveToElementEdge(ElementEdge.BeforeEnd);
ignoreList.Add(ptr.Offset);
textReader.MoveToNextContextPosition(LogicalDirection.Forward);
continue;
}
}
}
elementLevel++;
textReader.MoveToNextContextPosition(LogicalDirection.Forward);
WriteStartXamlElement(/*range:*/null, textReader, xmlWriter, xamlTypeMapper, /*reduceElement:*/wpfPayload == null, preserveTextElements);
break;
case TextPointerContext.ElementEnd:
// Don't write Hyperlink end element if Hyperlink include the invalid
// in case of having a UiElement except Image or stated the range end
// before the end position of the Hyperlink or Hyperlink opening tag is
// skipped from WriteOpeningTags by selecting of the partial of Hyperlink.
if (ignoreWriteHyperlinkEnd && (textReader.GetAdjacentElement(LogicalDirection.Forward) is Hyperlink))
{
// Reset the flag to keep walk up the next Hyperlink tag
ignoreWriteHyperlinkEnd = false;
textReader.MoveToNextContextPosition(LogicalDirection.Forward);
continue;
}
// Check the ignore list
ITextPointer endPointer = textReader.CreatePointer();
endPointer.MoveToElementEdge(ElementEdge.BeforeEnd); //
if (ignoreList.Contains(endPointer.Offset))
{
ignoreList.Remove(endPointer.Offset);
textReader.MoveToNextContextPosition(LogicalDirection.Forward);
continue;
}
elementLevel--;
if (TextSchema.IsBreak(textReader.ParentType))
{
// For LineBreak, etc. use empty element syntax
xmlWriter.WriteEndElement();
}
else
{ //
// For all other textelements use explicit closing tag.
xmlWriter.WriteFullEndElement();
}
textReader.MoveToNextContextPosition(LogicalDirection.Forward);
break;
case TextPointerContext.Text:
int textLength = textReader.GetTextRunLength(LogicalDirection.Forward);
char[] text = new Char[textLength];
textLength = TextPointerBase.GetTextWithLimit(textReader, LogicalDirection.Forward, text, 0, textLength, rangeEnd);
// XmlWriter will throw an ArgumentException if text contains
// any invalid surrogates, so strip them out now.
textLength = StripInvalidSurrogateChars(text, textLength);
xmlWriter.WriteChars(text, 0, textLength);
textReader.MoveToNextContextPosition(LogicalDirection.Forward);
break;
case TextPointerContext.EmbeddedElement:
object embeddedObject = textReader.GetAdjacentElement(LogicalDirection.Forward);
textReader.MoveToNextContextPosition(LogicalDirection.Forward);
WriteEmbeddedObject(embeddedObject, xmlWriter, wpfPayload);
break;
default:
Invariant.Assert(false, "unexpected value of runType");
textReader.MoveToNextContextPosition(LogicalDirection.Forward);
break;
}
}
}
static void WriteDictionary(XmlWriter writer)
{
XmlSerializer xs = new XmlSerializer(typeof (RBFDictEntry));
writer.WriteStartElement("Dictionary");
foreach (var kvp in s_dictionary)
{
if (kvp.Value.Options.Count == 0)
continue;
xs.Serialize(writer, kvp.Value);
}
writer.WriteFullEndElement();
}
/// <summary>
/// Writes a content of current range in form of valid xml.
/// Places an artificial element xaml:FlowDocument as a root of output xml.
/// </summary>
/// <param name="xmlWriter">
/// XmlWriter to which the range will be serialized
/// </param>
/// <param name="range">
/// TextRange whose content is copied into XmlWriter xmlWriter.
/// </param>
/// <param name="useFlowDocumentAsRoot">
/// true means that we need to serialize the whole FlowDocument - used in FileSave scenario;
/// false means that we are in copy-paste scenario and will use Section or Span as a root - depending on context.
/// </param>
/// <param name="wpfPayload">
/// When this parameter is not null, images are serialized. When null, images are stripped out.
/// </param>
/// <param name="preserveTextElements">
/// When TRUE, TextElements are serialized as-is. When FALSE, they're upcast to their base type.
/// </param>
internal static void WriteXaml(XmlWriter xmlWriter, ITextRange range, bool useFlowDocumentAsRoot, WpfPayload wpfPayload, bool preserveTextElements)
{
// Set unindented formatting to avoid inserting insignificant whitespaces as significant ones
Formatting saveWriterFormatting = Formatting.None;
if (xmlWriter is XmlTextWriter)
{
saveWriterFormatting = ((XmlTextWriter)xmlWriter).Formatting;
((XmlTextWriter)xmlWriter).Formatting = Formatting.None;
}
// Get the default xamlTypeMapper.
XamlTypeMapper xamlTypeMapper = XmlParserDefaults.DefaultMapper;
// Identify structural scope of selection - nearest common ancestor
ITextPointer commonAncestor = FindSerializationCommonAncestor(range);
// Decide whether we need last paragraph merging or not
bool lastParagraphMustBeMerged =
!TextPointerBase.IsAfterLastParagraph(range.End) &&
range.End.GetPointerContext(LogicalDirection.Backward) != TextPointerContext.ElementStart;
// Write wrapping element with contextual properties
WriteRootFlowDocument(range, commonAncestor, xmlWriter, xamlTypeMapper, lastParagraphMustBeMerged, useFlowDocumentAsRoot);
// The ignoreWriteHyperlinkEnd flag will be set after call WriteOpeningTags.
// If ignoreWriteHyperlinkEnd is true, WriteXamlTextSegment won't write Hyperlink end element
// since Hyperlink writing opening tag is ignored by selecting the partial of Hyperlink.
bool ignoreWriteHyperlinkEnd;
List<int> ignoreList = new List<int>();
// Start counting tags needed to be closed.
// EmptyDocumentDepth==1 - counts FlowDocument opened in WriteRootFlowDocument above.
int elementLevel = EmptyDocumentDepth + WriteOpeningTags(range, range.Start, commonAncestor, xmlWriter, xamlTypeMapper, /*reduceElement:*/wpfPayload == null, out ignoreWriteHyperlinkEnd, ref ignoreList, preserveTextElements);
if (range.IsTableCellRange)
{
WriteXamlTableCellRange(xmlWriter, range, xamlTypeMapper, ref elementLevel, wpfPayload, preserveTextElements);
}
else
{
WriteXamlTextSegment(xmlWriter, range.Start, range.End, xamlTypeMapper, ref elementLevel, wpfPayload, ignoreWriteHyperlinkEnd, ignoreList, preserveTextElements);
}
// Close all remaining tags - scoping its End position
Invariant.Assert(elementLevel >= 0, "elementLevel cannot be negative");
while (elementLevel-- > 0)
{
xmlWriter.WriteFullEndElement();
}
// Restore xmlWriter's Formatting property
if (xmlWriter is XmlTextWriter)
{
((XmlTextWriter)xmlWriter).Formatting = saveWriterFormatting;
}
}
static void WriteSearchpaths(XmlWriter writer)
{
XmlSerializer xs = new XmlSerializer(typeof (SearchPathInfo));
writer.WriteStartElement("Searchpaths");
foreach (var kvp in s_searchpaths)
{
if (kvp.Value.Count == 0)
continue;
writer.WriteStartElement("Entry");
writer.WriteElementString("Key", kvp.Key);
writer.WriteStartElement("Paths");
foreach (var path in kvp.Value)
xs.Serialize(writer, path);
writer.WriteEndElement();
writer.WriteFullEndElement();
}
writer.WriteFullEndElement();
}
/* -------------------------------------------------------------------------------------
* Name: WriteShallowNode
* Goal: Copy piece-by-piece
* History:
* 2/oct/2015 ERK Created
------------------------------------------------------------------------------------- */
public void WriteShallowNode(XmlReader reader, XmlWriter writer)
{
if (reader == null) {
throw new ArgumentNullException("reader");
}
if (writer == null) {
throw new ArgumentNullException("writer");
}
try {
switch (reader.NodeType) {
case XmlNodeType.Element:
writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
bool bIsFOLIA = (reader.LocalName == "FoLiA");
string sLocalName = reader.LocalName;
// Process attributes one by one
if (reader.HasAttributes) {
if (reader.MoveToFirstAttribute()) {
do {
if (reader.Name != "xmlns") {
bool bWritten = false;
// Action depends on local name
switch (sLocalName) {
case "FoLiA":
// Is the the attribute @version?
if (reader.Name == "version") { writer.WriteAttributeString(reader.Name, FOLIA_VERSION); bWritten = true; }
break;
case "t":
// is this the attribute @class?
if (reader.Name == "class") { writer.WriteAttributeString(reader.Name, "eng"); bWritten = true; }
break;
}
if (!bWritten) {
String[] arName = reader.Name.Split(':');
if (arName.Length > 1) {
writer.WriteAttributeString(arName[0], arName[1], null, reader.Value);
} else {
writer.WriteAttributeString(reader.Name, reader.Value);
}
}
/*
// Check for FoLiA version
if (bIsFOLIA && reader.Name == "version") {
// Adapt version number
writer.WriteAttributeString(reader.Name, FOLIA_VERSION);
} else {
String[] arName = reader.Name.Split(':');
if (arName.Length > 1) {
writer.WriteAttributeString(arName[0], arName[1], null, reader.Value);
} else {
writer.WriteAttributeString(reader.Name, reader.Value);
}
} */
}
} while (reader.MoveToNextAttribute());
}
}
if (reader.IsEmptyElement) {
writer.WriteEndElement();
}
break;
case XmlNodeType.Text:
writer.WriteString(reader.Value);
break;
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
writer.WriteWhitespace(reader.Value);
break;
case XmlNodeType.CDATA:
writer.WriteCData(reader.Value);
break;
case XmlNodeType.EntityReference:
writer.WriteEntityRef(reader.Name);
break;
case XmlNodeType.XmlDeclaration:
case XmlNodeType.ProcessingInstruction:
writer.WriteProcessingInstruction(reader.Name, reader.Value);
break;
case XmlNodeType.DocumentType:
writer.WriteDocType(reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), reader.Value);
break;
case XmlNodeType.Comment:
writer.WriteComment(reader.Value);
break;
case XmlNodeType.EndElement:
writer.WriteFullEndElement();
break;
}
} catch (Exception ex) {
errHandle.DoError("WriteShallowNode", ex); // Provide standard error message
}
}
internal void BuildSubtree(XmlReader reader, XmlWriter writer) {
// important (perf) string literal...
string xmlnsUri = XmlReservedNs.NsXmlNs; // http://www.w3.org/2000/xmlns/
ReadState readState = reader.ReadState;
if (readState != ReadState.Initial
&& readState != ReadState.Interactive) {
throw new ArgumentException(Res.GetString(Res.Xml_InvalidOperation), "reader");
}
int level = 0;
if ( readState == ReadState.Initial ) {
if( !reader.Read() )
return;
level++; // if start in initial, read everything (not just first)
}
do {
switch (reader.NodeType) {
case XmlNodeType.Element:
writer.WriteStartElement( reader.Prefix, reader.LocalName, reader.NamespaceURI );
bool isEmptyElement = reader.IsEmptyElement;
while (reader.MoveToNextAttribute()) {
if ((object) reader.NamespaceURI == (object) xmlnsUri) {
if (reader.Prefix.Length == 0) {
// Default namespace declaration "xmlns"
Debug.Assert(reader.LocalName == "xmlns");
writer.WriteAttributeString( "", "xmlns", xmlnsUri, reader.Value );
}
else {
Debug.Assert(reader.Prefix == "xmlns");
writer.WriteAttributeString( "xmlns", reader.LocalName, xmlnsUri, reader.Value );
}
}
else {
writer.WriteStartAttribute(reader.Prefix, reader.LocalName, reader.NamespaceURI);
writer.WriteString(reader.Value);
writer.WriteEndAttribute();
}
}
reader.MoveToElement();
if (isEmptyElement) {
// there might still be a value, if there is a default value specified in the schema
writer.WriteEndElement();
}
else {
level++;
}
break;
case XmlNodeType.EndElement:
writer.WriteFullEndElement();
//should not read beyond the level of the reader's original position.
level--;
break;
case XmlNodeType.Text:
case XmlNodeType.CDATA:
writer.WriteString( reader.Value );
break;
case XmlNodeType.SignificantWhitespace:
case XmlNodeType.Whitespace:
//
writer.WriteString( reader.Value );
break;
case XmlNodeType.Comment:
writer.WriteComment( reader.Value );
break;
case XmlNodeType.ProcessingInstruction:
writer.WriteProcessingInstruction( reader.LocalName , reader.Value);
break;
case XmlNodeType.EntityReference:
reader.ResolveEntity(); //
break;
case XmlNodeType.EndEntity:
case XmlNodeType.None:
case XmlNodeType.DocumentType:
case XmlNodeType.XmlDeclaration:
break;
case XmlNodeType.Attribute:
if ((object) reader.NamespaceURI == (object) xmlnsUri) {
if (reader.Prefix.Length == 0) {
// Default namespace declaration "xmlns"
Debug.Assert(reader.LocalName == "xmlns");
writer.WriteAttributeString( "", "xmlns", xmlnsUri, reader.Value );
}
else {
Debug.Assert(reader.Prefix == "xmlns");
writer.WriteAttributeString( "xmlns", reader.LocalName, xmlnsUri, reader.Value );
}
}
else {
writer.WriteStartAttribute(reader.Prefix, reader.LocalName, reader.NamespaceURI);
writer.WriteString(reader.Value);
writer.WriteEndAttribute();
}
break;
}
}
while( reader.Read() && ( level > 0 ) );
}
//copies from example
private void PassNodeThrough(XmlReader reader, XmlWriter writer)
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
writer.WriteAttributes(reader, true);
if (reader.IsEmptyElement)
{
writer.WriteEndElement();
}
break;
case XmlNodeType.Text:
writer.WriteString(reader.Value);
break;
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
writer.WriteWhitespace(reader.Value);
break;
case XmlNodeType.CDATA:
writer.WriteCData(reader.Value);
break;
case XmlNodeType.EntityReference:
writer.WriteEntityRef(reader.Name);
break;
case XmlNodeType.XmlDeclaration:
case XmlNodeType.ProcessingInstruction:
writer.WriteProcessingInstruction(reader.Name, reader.Value);
break;
case XmlNodeType.DocumentType:
writer.WriteDocType(reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), reader.Value);
break;
case XmlNodeType.Comment:
writer.WriteComment(reader.Value);
break;
case XmlNodeType.EndElement:
writer.WriteFullEndElement();
break;
}
}
// Writes the content (inner XML) of the current node into the provided XmlWriter.
private async Task WriteNodeAsync(XmlWriter xtw, bool defattr)
{
int d = this.NodeType == XmlNodeType.None ? -1 : this.Depth;
while (await this.ReadAsync().ConfigureAwait(false) && (d < this.Depth))
{
switch (this.NodeType)
{
case XmlNodeType.Element:
xtw.WriteStartElement(this.Prefix, this.LocalName, this.NamespaceURI);
xtw.WriteAttributes(this, defattr);
if (this.IsEmptyElement)
{
xtw.WriteEndElement();
}
break;
case XmlNodeType.Text:
xtw.WriteString(await this.GetValueAsync().ConfigureAwait(false));
break;
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
xtw.WriteWhitespace(await this.GetValueAsync().ConfigureAwait(false));
break;
case XmlNodeType.CDATA:
xtw.WriteCData(this.Value);
break;
case XmlNodeType.EntityReference:
xtw.WriteEntityRef(this.Name);
break;
case XmlNodeType.XmlDeclaration:
case XmlNodeType.ProcessingInstruction:
xtw.WriteProcessingInstruction(this.Name, this.Value);
break;
case XmlNodeType.DocumentType:
xtw.WriteDocType(this.Name, this.GetAttribute("PUBLIC"), this.GetAttribute("SYSTEM"), this.Value);
break;
case XmlNodeType.Comment:
xtw.WriteComment(this.Value);
break;
case XmlNodeType.EndElement:
xtw.WriteFullEndElement();
break;
}
}
if (d == this.Depth && this.NodeType == XmlNodeType.EndElement)
{
await ReadAsync().ConfigureAwait(false);
}
}
/// <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.");
}
public static void WriteShallowNode(XmlReader reader, XmlWriter writer)
{
//Console.WriteLine("{0}: {1}", reader.NodeType, reader.Name);
switch(reader.NodeType) {
case XmlNodeType.Element:
writer.WriteStartElement(reader.Prefix , reader.LocalName, reader.NamespaceURI);
writer.WriteAttributes(reader, true);
if(reader.IsEmptyElement)
writer.WriteEndElement();
break;
case XmlNodeType.Text:
writer.WriteString(reader.Value);
break;
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
writer.WriteWhitespace(reader.Value);
break;
case XmlNodeType.CDATA:
writer.WriteCData(reader.Value);
break;
case XmlNodeType.EntityReference:
writer.WriteEntityRef(reader.Name);
break;
case XmlNodeType.XmlDeclaration:
case XmlNodeType.ProcessingInstruction:
writer.WriteProcessingInstruction(reader.Name, reader.Value);
break;
case XmlNodeType.DocumentType:
writer.WriteDocType(reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), reader.Value);
break;
case XmlNodeType.Comment:
writer.WriteComment(reader.Value);
break;
case XmlNodeType.EndElement:
writer.WriteFullEndElement();
break;
}
}
public override void WriteTo (XmlWriter w)
{
// some people expect the same prefix output as in input,
// in the loss of performance... see bug #466423.
int createdNS = 0;
string prefix = LookupPrefix (name.NamespaceName, w);
Func<string> nsCreator = () => {
string p = null;
do {
p = "p" + (++createdNS);
// check conflict
if (Attributes ().All (a => a.Name.LocalName != p))
break;
} while (true);
return p;
};
if (prefix == null)
prefix = nsCreator ();
w.WriteStartElement (prefix, name.LocalName, name.Namespace.NamespaceName);
foreach (XAttribute a in Attributes ()) {
if (a.IsNamespaceDeclaration) {
if (a.Name.Namespace == XNamespace.Xmlns)
w.WriteAttributeString ("xmlns", a.Name.LocalName, XNamespace.Xmlns.NamespaceName, a.Value);
else
w.WriteAttributeString ("xmlns", a.Value);
} else {
string apfix = LookupPrefix (a.Name.NamespaceName, w);
if (apfix == null)
apfix = nsCreator ();
w.WriteAttributeString (apfix, a.Name.LocalName, a.Name.Namespace.NamespaceName, a.Value);
}
}
foreach (XNode node in Nodes ())
node.WriteTo (w);
if (explicit_is_empty)
w.WriteEndElement ();
else
w.WriteFullEndElement ();
}
private void WriteItem(FeedFileCreationContext fileCreation, XmlWriter writer, Product product, Currency currency, string measureWeightSystemKey)
{
GoogleProductRecord googleProduct = null;
try
{
googleProduct = GetGoogleProductRecord(product.Id);
if (googleProduct != null && !googleProduct.Export)
return;
}
catch (Exception exc)
{
fileCreation.Logger.Error(exc.Message, exc);
}
writer.WriteStartElement("item");
try
{
var manu = _manufacturerService.GetProductManufacturersByProductId(product.Id).FirstOrDefault();
var mainImageUrl = Helper.GetMainProductImageUrl(fileCreation.Store, product);
var category = ProductCategory(googleProduct);
if (category.IsEmpty())
fileCreation.ErrorMessage = Helper.GetResource("MissingDefaultCategory");
string manuName = (manu != null ? manu.Manufacturer.GetLocalized(x => x.Name, Settings.LanguageId, true, false) : null);
string productName = product.GetLocalized(x => x.Name, Settings.LanguageId, true, false);
string shortDescription = product.GetLocalized(x => x.ShortDescription, Settings.LanguageId, true, false);
string fullDescription = product.GetLocalized(x => x.FullDescription, Settings.LanguageId, true, false);
var brand = (manuName ?? Settings.Brand);
var mpn = Helper.GetManufacturerPartNumber(product);
bool identifierExists = product.Gtin.HasValue() || brand.HasValue() || mpn.HasValue();
writer.WriteElementString("g", "id", _googleNamespace, product.Id.ToString());
writer.WriteStartElement("title");
writer.WriteCData(productName.Truncate(70));
writer.WriteEndElement();
var description = Helper.BuildProductDescription(productName, shortDescription, fullDescription, manuName, d =>
{
if (fullDescription.IsEmpty() && shortDescription.IsEmpty())
{
var rnd = new Random();
switch (rnd.Next(1, 5))
{
case 1: return d.Grow(Settings.AppendDescriptionText1, " ");
case 2: return d.Grow(Settings.AppendDescriptionText2, " ");
case 3: return d.Grow(Settings.AppendDescriptionText3, " ");
case 4: return d.Grow(Settings.AppendDescriptionText4, " ");
case 5: return d.Grow(Settings.AppendDescriptionText5, " ");
}
}
return d;
});
writer.WriteStartElement("description");
writer.WriteCData(description.RemoveInvalidXmlChars());
writer.WriteEndElement();
writer.WriteStartElement("g", "google_product_category", _googleNamespace);
writer.WriteCData(category);
writer.WriteFullEndElement();
string productType = Helper.GetCategoryPath(product);
if (productType.HasValue())
{
writer.WriteStartElement("g", "product_type", _googleNamespace);
writer.WriteCData(productType);
writer.WriteFullEndElement();
}
writer.WriteElementString("link", Helper.GetProductDetailUrl(fileCreation.Store, product));
writer.WriteElementString("g", "image_link", _googleNamespace, mainImageUrl);
foreach (string additionalImageUrl in Helper.GetAdditionalProductImages(fileCreation.Store, product, mainImageUrl))
{
writer.WriteElementString("g", "additional_image_link", _googleNamespace, additionalImageUrl);
}
writer.WriteElementString("g", "condition", _googleNamespace, Condition());
writer.WriteElementString("g", "availability", _googleNamespace, Availability(product));
decimal price = Helper.GetProductPrice(product, currency, fileCreation.Store);
string specialPriceDate;
if (SpecialPrice(product, out specialPriceDate))
{
writer.WriteElementString("g", "sale_price", _googleNamespace, price.FormatInvariant() + " " + currency.CurrencyCode);
writer.WriteElementString("g", "sale_price_effective_date", _googleNamespace, specialPriceDate);
// get regular price ignoring any special price
decimal specialPrice = product.SpecialPrice.Value;
product.SpecialPrice = null;
price = Helper.GetProductPrice(product, currency, fileCreation.Store);
product.SpecialPrice = specialPrice;
_dbContext.SetToUnchanged<Product>(product);
}
writer.WriteElementString("g", "price", _googleNamespace, price.FormatInvariant() + " " + currency.CurrencyCode);
writer.WriteCData("gtin", product.Gtin, "g", _googleNamespace);
writer.WriteCData("brand", brand, "g", _googleNamespace);
writer.WriteCData("mpn", mpn, "g", _googleNamespace);
writer.WriteCData("gender", Gender(googleProduct), "g", _googleNamespace);
writer.WriteCData("age_group", AgeGroup(googleProduct), "g", _googleNamespace);
writer.WriteCData("color", Color(googleProduct), "g", _googleNamespace);
writer.WriteCData("size", Size(googleProduct), "g", _googleNamespace);
writer.WriteCData("material", Material(googleProduct), "g", _googleNamespace);
writer.WriteCData("pattern", Pattern(googleProduct), "g", _googleNamespace);
writer.WriteCData("item_group_id", ItemGroupId(googleProduct), "g", _googleNamespace);
writer.WriteElementString("g", "online_only", _googleNamespace, Settings.OnlineOnly ? "y" : "n");
writer.WriteElementString("g", "identifier_exists", _googleNamespace, identifierExists ? "TRUE" : "FALSE");
if (Settings.ExpirationDays > 0)
{
writer.WriteElementString("g", "expiration_date", _googleNamespace, DateTime.UtcNow.AddDays(Settings.ExpirationDays).ToString("yyyy-MM-dd"));
}
if (Settings.ExportShipping)
{
string weightInfo, weight = product.Weight.FormatInvariant();
if (measureWeightSystemKey.IsCaseInsensitiveEqual("gram"))
weightInfo = weight + " g";
else if (measureWeightSystemKey.IsCaseInsensitiveEqual("lb"))
weightInfo = weight + " lb";
else if (measureWeightSystemKey.IsCaseInsensitiveEqual("ounce"))
weightInfo = weight + " oz";
else
weightInfo = weight + " kg";
writer.WriteElementString("g", "shipping_weight", _googleNamespace, weightInfo);
}
if (Settings.ExportBasePrice && product.BasePriceHasValue)
{
string measureUnit = BasePriceUnits(product.BasePriceMeasureUnit);
if (BasePriceSupported(product.BasePriceBaseAmount ?? 0, measureUnit))
{
string basePriceMeasure = "{0} {1}".FormatWith((product.BasePriceAmount ?? decimal.Zero).FormatInvariant(), measureUnit);
string basePriceBaseMeasure = "{0} {1}".FormatWith(product.BasePriceBaseAmount, measureUnit);
writer.WriteElementString("g", "unit_pricing_measure", _googleNamespace, basePriceMeasure);
writer.WriteElementString("g", "unit_pricing_base_measure", _googleNamespace, basePriceBaseMeasure);
}
}
}
catch (Exception exc)
{
fileCreation.Logger.Error(exc.Message, exc);
}
writer.WriteEndElement(); // item
}
// Write this node and all of its contents to a specified XmlWriter.
public override void WriteTo(XmlWriter w)
{
w.WriteStartElement(Prefix, LocalName, NamespaceURI);
if(attributes != null)
{
foreach(XmlAttribute attr in attributes)
{
attr.WriteTo(w);
}
}
if(!IsEmpty)
{
WriteContentTo(w);
w.WriteFullEndElement();
}
else
{
w.WriteEndElement();
}
}
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);
}
}
}
}
