public async Task WriteResponse(XElement feed)
{
ResponseContentType = "application/atom+xml; type=feed; charset=utf-8";
MemoryStream stream = new MemoryStream();
XmlWriter writer = XmlWriter.Create(stream);
feed.WriteTo(writer);
writer.Flush();
byte[] data = stream.ToArray();
await WriteResponseAsync(data);
}
protected string ParseXml2String(XElement doc)
{
using (StringWriter sw = new StringWriter())
{
XmlWriterSettings settings = new XmlWriterSettings();
{
settings.OmitXmlDeclaration = true;
using (XmlWriter writer = XmlWriter.Create(sw, settings))
{
if (doc != null)
{
doc.WriteTo(writer);
}
}
}
return sw.ToString();
}
}
void XmlTest()
{
XElement root = new XElement ("root");
for (int i = 0; i < 3; i ++) {
XElement item = new XElement ("item");
item.Add (new XAttribute ("1item" + i.ToString (), i));
item.Add (new XAttribute ("2item" + i.ToString (), i));
item.Add (new XAttribute ("3item" + i.ToString (), i));
}
using (FileStream fs = new FileStream( Application.dataPath + "/test.xml",FileMode.Create)) {
XmlWriterSettings setting = new XmlWriterSettings ();
setting.Indent = true;
setting.IndentChars = "\t";
setting.NewLineChars = "\n";
setting.Encoding = Encoding.UTF8;
using (XmlWriter xw = XmlWriter.Create(fs, setting)) {
root.WriteTo (xw);
}
}
// using(FileStream fs = new FileStream( FILE_DIR + "/" + "ServerConfig/terrainEditorConfig.xml", FileMode.Create ) )
// {
// XmlWriterSettings setting = new XmlWriterSettings();
// setting.Indent = true;
// setting.IndentChars = "\t";
// setting.NewLineChars = "\n";
// setting.Encoding = Encoding.UTF8;
// using (XmlWriter xw = XmlWriter.Create(fs, setting))
// {
// root.WriteTo(xw);
// }
// }
// }
}
public static string Create(CasperJsTestsResults casperJsTestsResults)
{
XNamespace testRunNamespace =
XNamespace.Get("http://microsoft.com/schemas/VisualStudio/TeamTest/2010");
var xml = new XElement("TestRun",
new XAttribute("id", Guid.NewGuid().ToString()),
new XElement("ResultSummary",
new XAttribute("outcome", "Completed"),
new XElement("Counters",
new XAttribute("total", (casperJsTestsResults.PassedTests.Count + casperJsTestsResults.FailedTests.Count).ToString()),
new XAttribute("passed", casperJsTestsResults.PassedTests.Count.ToString()),
new XAttribute("failed", casperJsTestsResults.FailedTests.Count.ToString()))),
new XElement("TestDefinitions",
GetUnitTestsDefinitions(casperJsTestsResults)),
new XElement("TestEntries",
GetUnitTestsEntries(casperJsTestsResults)),
new XElement("Results",
GetUnitTestsResults(casperJsTestsResults))
);
var xDocument = new XDocument(xml);
xDocument.Root.Name = testRunNamespace + xDocument.Root.Name.LocalName;
using (var textWriter = new StringWriter())
{
using (XmlWriter xmlWriter = XmlWriter.Create(textWriter))
{
xml.WriteTo(xmlWriter);
}
return textWriter.ToString();
}
}
internal static void WriteElement(XmlWriter writer, XElement element)
{
if (WriteWholeNode(element))
{
// Write entire element in one gulp, to avoid eating needed spaces in <Run> elements.
element.WriteTo(writer);
}
else
{
writer.WriteStartElement(element.Name.LocalName);
foreach (var attribute in element.Attributes())
{
writer.WriteAttributeString(attribute.Name.LocalName, attribute.Value);
}
if (element.HasElements)
{
foreach (var childNode in element.Elements().ToArray())
{
// Recurse on down to the bottom.
WriteElement(writer, childNode);
childNode.Remove();
}
}
else
{
if (!string.IsNullOrEmpty(element.Value))
writer.WriteString(element.Value);
}
writer.WriteEndElement();
}
}
public static void WriteTo(Bundle bundle, XmlWriter writer, bool summary = false)
{
if (bundle == null) throw new ArgumentException("Bundle cannot be null");
var root = new XElement(BundleXmlParser.XATOMNS + BundleXmlParser.XATOM_FEED);
if (!String.IsNullOrWhiteSpace(bundle.Title)) root.Add(xmlCreateTitle(bundle.Title));
if (SerializationUtil.UriHasValue(bundle.Id)) root.Add(xmlCreateId(bundle.Id));
if (bundle.LastUpdated != null) root.Add(new XElement(BundleXmlParser.XATOMNS + BundleXmlParser.XATOM_UPDATED, bundle.LastUpdated));
if (!String.IsNullOrWhiteSpace(bundle.AuthorName))
root.Add(xmlCreateAuthor(bundle.AuthorName, bundle.AuthorUri));
if (bundle.TotalResults != null) root.Add(new XElement(BundleXmlParser.XOPENSEARCHNS + BundleXmlParser.XATOM_TOTALRESULTS, bundle.TotalResults));
if (bundle.Links != null)
{
foreach (var l in bundle.Links)
root.Add(xmlCreateLink(l.Rel, l.Uri));
}
if (bundle.Tags != null)
{
foreach (var tag in bundle.Tags)
root.Add(TagListSerializer.CreateTagCategoryPropertyXml(tag));
}
foreach (var entry in bundle.Entries)
root.Add(createEntry(entry, summary));
root.WriteTo(writer);
//var result = new XDocument(root);
//result.WriteTo(writer);
}
public static string XElementToString(XElement xml)
{
var sw = new StringWriterUTF8(CultureInfo.CurrentCulture);
var writer = XmlWriter.Create(sw, new XmlWriterSettings() { Indent = true, IndentChars = "\t", Encoding = Encoding.UTF8 });
xml.WriteTo(writer);
writer.Flush();
writer.Close();
return sw.ToString();
}
public void Write(Interaction interaction) {
var tree = new XElement("tape",
new XElement("interaction",
MapRequest(interaction.Request),
MapResponse(interaction.Response)
)
);
tree.WriteTo(writer);
}
private string SaveXElementUsingXmlWriter(XElement elem, NamespaceHandling nsHandling)
{
StringWriter sw = new StringWriter();
using (XmlWriter w = XmlWriter.Create(sw, new XmlWriterSettings() { NamespaceHandling = nsHandling, OmitXmlDeclaration = true }))
{
elem.WriteTo(w);
}
sw.Dispose();
return sw.ToString();
}
private void Write(XmlWriter writer)
{
writer.WriteStartDocument();
XElement root = new XElement(Xmlns + "Image",
new XAttribute("TileSize", AllTileDefaults.DziTileSize),
new XAttribute("Overlap", _dziTileOverlap),
new XAttribute("Format", AllTileDefaults.DziTileFormat),
new XElement(Xmlns + "Size", new XAttribute("Width", _size.Width), new XAttribute("Height", _size.Height)));
root.WriteTo(writer);
writer.WriteEndDocument();
}
// Private Methods
//======================================================================
private void Write(XmlWriter outputWriter)
{
outputWriter.WriteStartDocument();
XElement root = new XElement(Xmlns + "Image",
new XAttribute("TileSize", DefaultTileSize),
new XAttribute("Overlap", DefaultOverlap),
new XAttribute("Format", DefaultFormat),
new XElement(Xmlns + "Size",
new XAttribute("Width", m_size.Width),
new XAttribute("Height", m_size.Height)));
root.WriteTo(outputWriter);
}
public virtual void Table(TextWriter writer)
{
var tab = new XElement("table"
, new XAttribute("id", "postGrid")
, new XAttribute("class", "list"));
var th = TableHeader();
tab.Add(th);
foreach (object row in ReadData())
tab.Add(row);
tab.WriteTo(XmlWriter.Create(writer));
}
protected override void OnProcessRecord()
{
var netConfig = new XElement(
NetconfigNamespace + "NetworkConfiguration",
new XAttribute("xmlns", NetconfigNamespace.NamespaceName),
new XAttribute(XNamespace.Xmlns + "xsi", InstanceNamespace.NamespaceName),
new XElement(NetconfigNamespace + "VirtualNetworkConfiguration"));
var stream = new MemoryStream();
var writer1 = XmlWriter.Create(stream);
netConfig.WriteTo(writer1);
writer1.Flush();
stream.Seek(0L, SeekOrigin.Begin);
this.ExecuteClientActionInOCS(null, this.CommandRuntime.ToString(), s => this.Channel.SetNetworkConfiguration(s, stream));
}
public static void Write()
{
var xmlConfig = new XElement("Jira",
new XElement("ServerUrl", ServerUrl),
new XElement("Username", Username),
new XElement("Password", Password));
using (var xmlWriter = XmlWriter.Create(JiraOutput.PrefsPathWithFileName, new XmlWriterSettings()
{
Indent = true,
IndentChars = " "
}))
{
xmlConfig.WriteTo(xmlWriter);
}
}
static void Main(string[] args)
{
//Write XML 1.1 file
StringBuilder sb = new StringBuilder();
XmlWriterSettings xws = new XmlWriterSettings();
xws.Encoding = Encoding.UTF8;
xws.Indent = true;
//Disable character checking
xws.CheckCharacters = false;
System.Xml.XmlWriter xw = System.Xml.XmlWriter.Create(sb, xws);
//write your own header
xw.WriteProcessingInstruction("xml", "version='1.1'");
XElement doc = new XElement("root");
doc.Add(
new XElement("test",
new XAttribute("val", "\x03")));
//use WriteTo instead of Save
doc.WriteTo(xw);
xw.Close();
//Print XML contents to console
Console.WriteLine(sb.ToString());
//Read XML 1.1 file
TextReader tr = new StringReader(sb.ToString());
tr.ReadLine(); //skip Version number '1.1' is invalid. exception
XmlReaderSettings xrs = new XmlReaderSettings();
xrs.CheckCharacters = false;
XmlReader xr = XmlReader.Create(tr, xrs);
var xmldoc = XElement.Load(xr);
foreach (var e in xmldoc.Elements())
{
Console.Write("Element: {0}", e.Name);
foreach (var a in e.Attributes())
Console.Write(" Attribute: {0}={1}", a.Name, a.Value);
Console.WriteLine();
}
}
// ReSharper restore SuggestBaseTypeForParameter
// ReSharper disable SuggestBaseTypeForParameter
private static string SerializeXElement(XElement element)
{
using (var stringWriter = new StringWriter())
{
var settings = new XmlWriterSettings
{
Indent = true,
IndentChars = "\t",
OmitXmlDeclaration = true,
};
using (XmlWriter xmlWriter = XmlWriter.Create(stringWriter, settings))
{
element.WriteTo(xmlWriter);
xmlWriter.Flush();
return stringWriter.ToString();
}
}
}
public static BuildScript New(IFormater formater, string name, IEnumerable<Target> targets)
{
XElement scriptRoot = new XElement("project",
new XAttribute("name", Path.GetFileName(name)),
ImportsFor(targets),
from t in targets
select new XElement("target", CollectDependencies(t, AttributesFor(t, formater))));
AddDefaultTargetIfOneExists(scriptRoot, targets);
Stream output = new MemoryStream();
using(var xmlWriter = XmlWriter.Create(output, new XmlWriterSettings { OmitXmlDeclaration = true, Indent = true}))
{
scriptRoot.WriteTo(xmlWriter);
}
output.Position = 0;
return new BuildScript(name, output);
}
public string RemoveVirtualNetworkConfigProcess()
{
Action<string> action = null;
object[] xAttribute = new object[3];
xAttribute[0] = new XAttribute("xmlns", RemoveAzureVNetConfigCommand.netconfigNamespace.NamespaceName);
xAttribute[1] = new XAttribute(XNamespace.Xmlns + "xsi", RemoveAzureVNetConfigCommand.instanceNamespace.NamespaceName);
xAttribute[2] = new XElement(RemoveAzureVNetConfigCommand.netconfigNamespace + "VirtualNetworkConfiguration");
XElement xElement = new XElement(RemoveAzureVNetConfigCommand.netconfigNamespace + "NetworkConfiguration", xAttribute);
MemoryStream memoryStream = new MemoryStream();
XmlWriter xmlWriter = XmlWriter.Create(memoryStream);
xElement.WriteTo(xmlWriter);
xmlWriter.Flush();
memoryStream.Seek((long)0, SeekOrigin.Begin);
using (OperationContextScope operationContextScope = new OperationContextScope((IContextChannel)base.Channel))
{
try
{
RemoveAzureVNetConfigCommand removeAzureVNetConfigCommand = this;
if (action == null)
{
action = (string s) => base.Channel.SetNetworkConfiguration(s, memoryStream);
}
((CmdletBase<IServiceManagement>)removeAzureVNetConfigCommand).RetryCall(action);
Operation operation = base.WaitForOperation(base.CommandRuntime.ToString());
ManagementOperationContext managementOperationContext = new ManagementOperationContext();
managementOperationContext.set_OperationDescription(base.CommandRuntime.ToString());
managementOperationContext.set_OperationId(operation.OperationTrackingId);
managementOperationContext.set_OperationStatus(operation.Status);
ManagementOperationContext managementOperationContext1 = managementOperationContext;
base.WriteObject(managementOperationContext1, true);
}
catch (CommunicationException communicationException1)
{
CommunicationException communicationException = communicationException1;
this.WriteErrorDetails(communicationException);
}
}
return null;
}
public static void Describe(this HttpResponse res, ClaimsPrincipal principal)
{
res.StatusCode = 200;
res.ContentType = "text/xml";
var xml = new XElement("xml");
if (principal != null)
{
foreach (var identity in principal.Identities)
{
xml.Add(identity.Claims.Select(claim =>
new XElement("claim", new XAttribute("type", claim.Type),
new XAttribute("value", claim.Value),
new XAttribute("issuer", claim.Issuer))));
}
}
using (var memory = new MemoryStream())
{
using (var writer = new XmlTextWriter(memory, Encoding.UTF8))
{
xml.WriteTo(writer);
}
res.Body.Write(memory.ToArray(), 0, memory.ToArray().Length);
}
}
private static void WriteXml(Stream outputStream, XElement xml)
{
using (var writer = XmlWriter.Create(outputStream))
{
xml.WriteTo(writer);
}
}
void WriteElement(XElement element)
{
lock (writeLock) {
Log.Debug ("GCM-XMPP: Sending: " + element);
element.WriteTo (xml);
xml.Flush ();
}
}
private static void Describe(HttpResponse res, AuthenticateContext result)
{
res.StatusCode = 200;
res.ContentType = "text/xml";
var xml = new XElement("xml");
if (result != null && result.Principal != null)
{
xml.Add(result.Principal.Claims.Select(claim => new XElement("claim", new XAttribute("type", claim.Type), new XAttribute("value", claim.Value))));
}
if (result != null && result.Properties != null)
{
xml.Add(result.Properties.Select(extra => new XElement("extra", new XAttribute("type", extra.Key), new XAttribute("value", extra.Value))));
}
using (var memory = new MemoryStream())
{
using (var writer = new XmlTextWriter(memory, Encoding.UTF8))
{
xml.WriteTo(writer);
}
res.Body.Write(memory.ToArray(), 0, memory.ToArray().Length);
}
}
/// <summary>
/// Writes the element to custom XML part.
/// </summary>
/// <param name="customXmlPart">The custom XML part.</param>
/// <param name="rootElement">The root element.</param>
public void WriteElementToCustomXmlPart(CustomXmlPart customXmlPart, XElement rootElement)
{
if (customXmlPart == null)
{
throw new ArgumentNullException("customXmlPart");
}
if (rootElement == null)
{
throw new ArgumentNullException("rootElement");
}
using (XmlWriter writer = XmlWriter.Create(customXmlPart.GetStream(FileMode.Create, FileAccess.Write)))
{
rootElement.WriteTo(writer);
writer.Flush();
}
}
public IBaseMessage Execute(IPipelineContext pContext, IBaseMessage pInMsg)
{
//read the incoming JSON stream:
var inStream = pInMsg.BodyPart.GetOriginalDataStream();
var json = string.Empty;
using (var reader = new StreamReader(inStream))
{
json = reader.ReadToEnd();
}
//convert to XML:
var document = JsonConvert.DeserializeXNode(json, "root");
var output = new XElement(XName.Get(RootElementName, TargetNamespace));
output.Add(document.Root.Descendants());
//fix up the namespaces:
XNamespace ns = TargetNamespace;
foreach (var element in output.Descendants())
{
element.Name = ns.GetName(element.Name.LocalName);
var attributes = element.Attributes().ToList();
element.Attributes().Remove();
foreach (XAttribute attribute in attributes)
{
if (!attribute.IsNamespaceDeclaration)
{
element.Add(new XAttribute(attribute.Name.LocalName, attribute.Value));
}
}
}
//write to output body stream:
var outStream = new MemoryStream();
var writer = new XmlTextWriter(outStream, Encoding.Default);
output.WriteTo(writer);
writer.Flush();
outStream.Flush();
outStream.Position = 0;
pInMsg.BodyPart.Data = outStream;
//promote the message type:
pInMsg.Context.Promote(_MessageTypeProperty.Name.Name, _MessageTypeProperty.Name.Namespace, string.Format("{0}#{1}", TargetNamespace, RootElementName));
return pInMsg;
}
/// <summary>
/// Create an audio overlay for the page if appropriate.
/// We are looking for the page to contain spans with IDs. For each such ID X,
/// we look for a file _storage.FolderPath/audio/X.mp{3,4}.
/// If we find at least one such file, we create pageDocName_overlay.smil
/// with appropriate contents to tell the reader how to read all such spans
/// aloud.
/// </summary>
/// <param name="pageDom"></param>
/// <param name="pageDocName"></param>
private void AddAudioOverlay(HtmlDom pageDom, string pageDocName)
{
var spansWithIds = pageDom.RawDom.SafeSelectNodes(".//span[@id]").Cast<XmlElement>();
var spansWithAudio =
spansWithIds.Where(x =>GetOrCreateCompressedAudioIfWavExists(x.Attributes["id"].Value) != null);
if (!spansWithAudio.Any())
return;
var overlayName = GetOverlayName(pageDocName);
_manifestItems.Add(overlayName);
string smilNamespace = "http://www.w3.org/ns/SMIL";
XNamespace smil = smilNamespace;
string epubNamespace = "http://www.idpf.org/2007/ops";
XNamespace epub = epubNamespace;
var seq = new XElement(smil+"seq",
new XAttribute("id", "id1"), // all <seq> I've seen have this, not sure whether necessary
new XAttribute(epub + "textref", pageDocName),
new XAttribute(epub + "type", "bodymatter chapter") // only type I've encountered
);
var root = new XElement(smil + "smil",
new XAttribute( "xmlns", smilNamespace),
new XAttribute(XNamespace.Xmlns + "epub", epubNamespace),
new XAttribute("version", "3.0"),
new XElement(smil + "body",
seq));
int index = 1;
TimeSpan pageDuration = new TimeSpan();
foreach (var span in spansWithAudio)
{
var spanId = span.Attributes["id"].Value;
var path = GetOrCreateCompressedAudioIfWavExists(spanId);
var dataDurationAttr = span.Attributes["data-duration"];
if (dataDurationAttr != null)
{
pageDuration += TimeSpan.FromSeconds(Double.Parse(dataDurationAttr.Value));
}
else
{
//var durationSeconds = TagLib.File.Create(path).Properties.Duration.TotalSeconds;
//duration += new TimeSpan((long)(durationSeconds * 1.0e7)); // argument is in ticks (100ns)
// Haven't found a good way to get duration from MP3 without adding more windows-specific
// libraries. So for now we'll figure it from the wav if we have it. If not we do a very
// crude estimate from file size. Hopefully good enough for BSV animation.
var wavPath = Path.ChangeExtension(path, "wav");
if (RobustFile.Exists(wavPath))
{
#if __MonoCS__
pageDuration += new TimeSpan(new FileInfo(path).Length); // TODO: this needs to be fixed for Linux/Mono
#else
using (WaveFileReader wf = RobustIO.CreateWaveFileReader(wavPath))
pageDuration += wf.TotalTime;
#endif
}
else
{
NonFatalProblem.Report(ModalIf.All, PassiveIf.All,
"Bloom could not find one of the expected audio files for this book, nor a precomputed duration. Bloom can only make a very rough estimate of the length of the mp3 file.");
// Crude estimate. In one sample, a 61K mp3 is 7s long.
// So, multiply by 7 and divide by 61K to get seconds.
// Then, to make a TimeSpan we need ticks, which are 0.1 microseconds,
// hence the 10000000.
pageDuration += new TimeSpan(new FileInfo(path).Length*7*10000000/61000);
}
}
var epubPath = CopyFileToEpub(path);
seq.Add(new XElement(smil+"par",
new XAttribute("id", "s" + index++),
new XElement(smil + "text",
new XAttribute("src", pageDocName + "#" + spanId)),
new XElement(smil + "audio",
// Note that we don't need to preserve any audio/ in the path.
// We now mangle file names so as to replace any / (with _2f) so all files
// are at the top level in the ePUB. Makes one less complication for readers.
new XAttribute("src", Path.GetFileName(epubPath)))));
}
_pageDurations[GetIdOfFile(overlayName)] = pageDuration;
var overlayPath = Path.Combine(_contentFolder, overlayName);
using (var writer = XmlWriter.Create(overlayPath))
root.WriteTo(writer);
}
private void MakeSpine(XNamespace opf, XElement rootElt, string manifestPath)
{
// Generate the spine, which indicates the top-level readable content in order.
// These IDs must match the corresponding ones in the manifest, since the spine
// doesn't indicate where to actually find the content.
var spineElt = new XElement(opf + "spine");
rootElt.Add(spineElt);
foreach (var item in _spineItems)
{
var itemElt = new XElement(opf + "itemref",
new XAttribute("idref", GetIdOfFile(item)));
spineElt.Add(itemElt);
}
using (var writer = XmlWriter.Create(manifestPath))
rootElt.WriteTo(writer);
}
string FormatProjectExtension(XElement element)
{
var settings = new XmlWriterSettings {
Indent = true,
IndentChars = " ",
NewLineChars = "\r\n ",
NewLineHandling = NewLineHandling.Replace,
OmitXmlDeclaration = true
};
var formattedText = new StringBuilder();
using (XmlWriter writer = XmlWriter.Create(new StringWriter(formattedText), settings)) {
element.WriteTo(writer);
}
return formattedText.ToString();
}
/// <summary>
/// Writes the file.
/// </summary>
/// <param name="filename"> The filename. </param>
/// <param name="e"> The e. </param>
/// <remarks>
/// </remarks>
protected virtual void WriteFile(string filename, XElement e) {
filename += ".xml";
using (var xmlwriter = XmlWriter.Create(filename, _xmlsettings)) {
e.WriteTo(xmlwriter);
}
}
public static void PostBlogEntry(ConsumerBase consumer, string accessToken, string blogUrl, string title, XElement body)
{
string feedUrl;
var getBlogHome = WebRequest.Create(blogUrl);
using (var blogHomeResponse = getBlogHome.GetResponse()) {
using (StreamReader sr = new StreamReader(blogHomeResponse.GetResponseStream())) {
string homePageHtml = sr.ReadToEnd();
Match m = Regex.Match(homePageHtml, @"http://www.blogger.com/feeds/\d+/posts/default");
Debug.Assert(m.Success, "Posting operation failed.");
feedUrl = m.Value;
}
}
const string Atom = "http://www.w3.org/2005/Atom";
XElement entry = new XElement(
XName.Get("entry", Atom),
new XElement(XName.Get("title", Atom), new XAttribute("type", "text"), title),
new XElement(XName.Get("content", Atom), new XAttribute("type", "xhtml"), body),
new XElement(XName.Get("category", Atom), new XAttribute("scheme", "http://www.blogger.com/atom/ns#"), new XAttribute("term", "oauthdemo")));
MemoryStream ms = new MemoryStream();
XmlWriterSettings xws = new XmlWriterSettings() {
Encoding = Encoding.UTF8,
};
XmlWriter xw = XmlWriter.Create(ms, xws);
entry.WriteTo(xw);
xw.Flush();
WebRequest request = consumer.PrepareAuthorizedRequest(new MessageReceivingEndpoint(feedUrl, HttpDeliveryMethods.PostRequest | HttpDeliveryMethods.AuthorizationHeaderRequest), accessToken);
request.ContentType = "application/atom+xml";
request.Method = "POST";
request.ContentLength = ms.Length;
ms.Seek(0, SeekOrigin.Begin);
using (Stream requestStream = request.GetRequestStream()) {
ms.CopyTo(requestStream);
}
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) {
if (response.StatusCode == HttpStatusCode.Created) {
// Success
} else {
// Error!
}
}
}
/// <summary>
/// Write xml based on segment type
/// </summary>
/// <param name="x"></param>
/// <param name="segmentType"></param>
/// <returns></returns>
/// <remarks></remarks>
private static string InternalToString(XElement x, SegmentTypes segmentType)
{
var writer = new StringWriter();
var cw = new XmlWriter(writer) {SegmentType = segmentType};
//Strip Namespace if it's an Xelement
x = StripNS(x);
//write
x.WriteTo(cw);
return writer.GetStringBuilder().ToString();
}
