protected String convertToXml(Object obj, RequestItem request)
{
MemoryStream ms = new MemoryStream();
XmlWriter xw = XmlWriter.Create(ms, new XmlWriterSettings {
Indent = true
});
using (var writer = XmlDictionaryWriter.CreateDictionaryWriter(xw))
{
if (obj is IRestfulCollection)
{
IRestfulCollection collection = (IRestfulCollection)obj;
var responses = collection.getEntry();
writer.WriteStartElement("response", osNameSpace);
writer.WriteElementString("startIndex", collection.startIndex.ToString());
if (request.getCount().HasValue)
{
writer.WriteElementString("itemsPerPage", request.getCount().ToString());
}
writer.WriteElementString("totalResults", collection.totalResults.ToString());
writer.WriteElementString("isFiltered", collection.isFiltered.ToString().ToLower());
writer.WriteElementString("isSorted", collection.isSorted.ToString().ToLower());
writer.WriteElementString("isUpdatedSince", collection.isUpdatedSince.ToString().ToLower());
foreach (var item in (IList)responses)
{
writer.WriteStartElement("entry");
//ser.WriteObject(writer, item);
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
ns.Add("", osNameSpace);
XmlSerializer ser = new XmlSerializer(item.GetType());
ser.Serialize(writer, item, ns);
writer.WriteEndElement();
}
writer.WriteEndElement();
}
else if (obj is DataCollection)
{
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
ns.Add("", osNameSpace);
XmlSerializer ser = new XmlSerializer(obj.GetType());
ser.Serialize(writer, obj, ns);
}
else
{
throw new Exception("XMLSerialization: shouldn't have got here");
}
writer.Flush();
return(Encoding.UTF8.GetString(ms.ToArray()));
}
}
public virtual XmlDictionaryReader GetAddressHeaderReader()
{
var sw = new StringWriter();
var s = new XmlWriterSettings()
{
OmitXmlDeclaration = true
};
var xw = XmlDictionaryWriter.CreateDictionaryWriter(XmlWriter.Create(sw, s));
WriteAddressHeader(xw);
xw.Close();
return(XmlDictionaryReader.CreateDictionaryReader(XmlReader.Create(new StringReader(sw.ToString()))));
}
public static void WiteTypeDesc(string fileName, VarDesc td)
{
using (FileStream stream = new FileStream(fileName, FileMode.Create))
using (XmlWriter xmlWrier = XmlWriter.Create(stream, new XmlWriterSettings {
Indent = true, Encoding = Encoding.UTF8
}))
using (XmlDictionaryWriter dictWriter = XmlDictionaryWriter.CreateDictionaryWriter(xmlWrier))
{
DataContractSerializer ser = new DataContractSerializer(typeof(VarDesc));
ser.WriteObject(dictWriter, td);
dictWriter.Flush();
}
}
public void Save()
{
XmlTextWriter xw = new XmlTextWriter(Path.Combine(
Path.GetDirectoryName(Application.ExecutablePath), ConfigDictFileName), Encoding.UTF8);
xw.Formatting = Formatting.Indented;
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateDictionaryWriter(xw);
DataContractSerializer ser = new DataContractSerializer(this.GetType());
ser.WriteObject(writer, this);
writer.Close();
xw.Close();
}
protected virtual XmlDictionaryReader OnGetReaderAtDetailContents()
{
MemoryStream ms = new MemoryStream();
using (XmlDictionaryWriter dw =
XmlDictionaryWriter.CreateDictionaryWriter(
XmlWriter.Create(ms))) {
OnWriteDetailContents(dw);
}
ms.Seek(0, SeekOrigin.Begin);
return(XmlDictionaryReader.CreateDictionaryReader(
XmlReader.Create(ms)));
}
protected virtual BodyWriter OnCreateBufferedCopy(
int maxBufferSize)
{
var s = new XmlWriterSettings();
s.OmitXmlDeclaration = true;
s.ConformanceLevel = ConformanceLevel.Auto;
StringWriter sw = new StringWriter();
using (XmlDictionaryWriter w = XmlDictionaryWriter.CreateDictionaryWriter(XmlWriter.Create(sw, s)))
WriteBodyContents(w);
return(new XmlReaderBodyWriter(sw.ToString()));
}
public virtual void WriteXml(XmlDictionaryWriter writer, SamlSerializer samlSerializer, SecurityTokenSerializer keyInfoSerializer)
{
this.CheckObjectValidity();
if (writer == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("writer"));
}
if (samlSerializer == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("samlSerializer"));
}
SamlDictionary samlDictionary = samlSerializer.DictionaryManager.SamlDictionary;
writer.WriteStartElement(samlDictionary.PreferredPrefix.Value, samlDictionary.Subject, samlDictionary.Namespace);
if (this.name != null)
{
writer.WriteStartElement(samlDictionary.PreferredPrefix.Value, samlDictionary.NameIdentifier, samlDictionary.Namespace);
if (this.nameFormat != null)
{
writer.WriteStartAttribute(samlDictionary.NameIdentifierFormat, null);
writer.WriteString(this.nameFormat);
writer.WriteEndAttribute();
}
if (this.nameQualifier != null)
{
writer.WriteStartAttribute(samlDictionary.NameIdentifierNameQualifier, null);
writer.WriteString(this.nameQualifier);
writer.WriteEndAttribute();
}
writer.WriteString(this.name);
writer.WriteEndElement();
}
if (this.confirmationMethods.Count > 0)
{
writer.WriteStartElement(samlDictionary.PreferredPrefix.Value, samlDictionary.SubjectConfirmation, samlDictionary.Namespace);
foreach (string str in this.confirmationMethods)
{
writer.WriteElementString(samlDictionary.SubjectConfirmationMethod, samlDictionary.Namespace, str);
}
if (!string.IsNullOrEmpty(this.confirmationData))
{
writer.WriteElementString(samlDictionary.SubjectConfirmationData, samlDictionary.Namespace, this.confirmationData);
}
if (this.securityKeyIdentifier != null)
{
SamlSerializer.WriteSecurityKeyIdentifier(XmlDictionaryWriter.CreateDictionaryWriter(writer), this.securityKeyIdentifier, keyInfoSerializer);
}
writer.WriteEndElement();
}
writer.WriteEndElement();
}
/// <summary>
/// Writes the source data, if available.
/// </summary>
/// <exception cref="InvalidOperationException">When no source data is available</exception>
/// <param name="writer"></param>
public virtual void WriteSourceData(XmlWriter writer)
{
if (!this.CanWriteSourceData)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(SR.GetString(SR.ID4140)));
}
// This call will properly just reuse the existing writer if it already qualifies
XmlDictionaryWriter dictionaryWriter = XmlDictionaryWriter.CreateDictionaryWriter(writer);
this.sourceData.SetElementExclusion(null, null);
this.sourceData.GetWriter().WriteTo(dictionaryWriter, null);
}
static void Main(string[] args)
{
// <Snippet4>
string[] strings = { "Hello", "world" };
MyBodyWriter bw = new MyBodyWriter(strings);
StringBuilder strBuilder = new StringBuilder(10);
XmlWriter writer = XmlWriter.Create(strBuilder);
XmlDictionaryWriter dictionaryWriter = XmlDictionaryWriter.CreateDictionaryWriter(writer);
bw.WriteBodyContents(dictionaryWriter);
dictionaryWriter.Flush();
// </Snippet4>
}
public static void ToXmlStream(this Iori iori, string rootElement, Stream sink)
{
var writer = XmlDictionaryWriter.CreateDictionaryWriter(XmlWriter.Create(sink, new XmlWriterSettings {
OmitXmlDeclaration = true,
ConformanceLevel = ConformanceLevel.Fragment,
CloseOutput = false,
}));
var serializer = new DataContractSerializer(typeof(Iori));
writer.WriteStartElement(rootElement);
serializer.WriteObject(writer, iori);
writer.WriteEndElement();
writer.Flush();
}
public static void Save(Settings settings)
{
// сериализация и сохранение
XmlTextWriter xmlWriter = new XmlTextWriter(mainPath, Encoding.UTF8);
xmlWriter.Formatting = Formatting.Indented;
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateDictionaryWriter(xmlWriter);
DataContractSerializer serialization = new DataContractSerializer(typeof(Settings));
serialization.WriteObject(writer, settings);
writer.Close();
xmlWriter.Close();
}
/// <summary>
/// Сериализация
/// </summary>
/// <param name="path">Путь к файлу</param>
public static void WriteToXml(string path)
{
var xw = new XmlTextWriter(path, Encoding.UTF8)
{
Formatting = Formatting.Indented
};
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateDictionaryWriter(xw);
var ser = new DataContractSerializer(typeof(SemanticWeb));
ser.WriteObject(writer, _web);
writer.Close();
xw.Close();
IsChanged = false;
}
public void SavePerformers()
{
try
{
XmlTextWriter xw = new XmlTextWriter("Performer.xml", Encoding.UTF8);
xw.Formatting = Formatting.Indented;
XmlDictionaryWriter xmldw = XmlDictionaryWriter.CreateDictionaryWriter(xw);
DataContractSerializer ser = new DataContractSerializer(typeof(Dictionary <Guid, Performer>));
ser.WriteObject(xmldw, Performer.Items);
xmldw.Close();
xw.Close();
}
catch { }
}
private string WriteElement(Action <XmlDictionaryWriter> action)
{
using (var stream = new MemoryStream())
{
using (var inner = XmlWriter.Create(stream, new XmlWriterSettings {
OmitXmlDeclaration = true, CloseOutput = false
}))
using (var writer = XmlDictionaryWriter.CreateDictionaryWriter(inner))
{
action(writer);
}
var buffer = stream.GetBuffer();
return(Encoding.UTF8.GetString(buffer));
}
}
protected override bool SerializeToXmlElement(XmlWriter writer, String elementName)
{
#if DESKTOP
bool dataToWrite = this.Headers.Count != 0;
if (dataToWrite && writer != null)
{
writer.WriteStartElement(elementName);
this.Headers.WriteContentsTo(XmlDictionaryWriter.CreateDictionaryWriter(writer));
writer.WriteEndElement();
}
return(dataToWrite);
#else
throw new PlatformNotSupportedException();
#endif
}
public void WriteToWSA10()
{
X509Certificate2 cert = new X509Certificate2("Test/Resources/test.cer");
EndpointAddress a = new EndpointAddress(
new Uri("http://localhost:8080"),
new X509CertificateEndpointIdentity(cert));
StringWriter sw = new StringWriter();
XmlWriterSettings xws = new XmlWriterSettings();
xws.OmitXmlDeclaration = true;
using (XmlDictionaryWriter xw = XmlDictionaryWriter.CreateDictionaryWriter(XmlWriter.Create(sw, xws))) {
a.WriteTo(AddressingVersion.WSAddressing10, xw);
}
Assert.AreEqual(C14N("<EndpointReference xmlns=\"http://www.w3.org/2005/08/addressing\"><Address>http://localhost:8080/</Address>" + identity1 + "</EndpointReference>"), C14N(sw.ToString()), "#2");
}
static string ExtensionToString(SyndicationElementExtension extension)
{
StringBuilder sb = new StringBuilder();
XmlWriterSettings xws = new XmlWriterSettings();
xws.ConformanceLevel = ConformanceLevel.Fragment;
xws.Indent = true;
xws.Encoding = Encoding.ASCII;
XmlWriter xw = XmlWriter.Create(sb, xws);
XmlDictionaryWriter xdw = XmlDictionaryWriter.CreateDictionaryWriter(xw);
extension.WriteTo(xdw);
xdw.Close();
return(sb.ToString());
}
public void WriteKeyIdentifierClause(XmlWriter writer, SecurityKeyIdentifierClause keyIdentifierClause)
{
XmlDictionaryWriter dictionaryWriter = XmlDictionaryWriter.CreateDictionaryWriter(writer);
if (keyIdentifierClause is LocalIdKeyIdentifierClause)
{
SerializeLocalIdKeyIdentifierClause(dictionaryWriter, keyIdentifierClause as LocalIdKeyIdentifierClause);
}
else
{
throw new NotSupportedException("keyIdentifierClause's type not supported.");
}
dictionaryWriter.Flush();
}
public override string ToString()
{
XmlWriterSettings xmlSettings = new XmlWriterSettings()
{
Indent = true
};
using (StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture))
{
using (XmlWriter textWriter = XmlWriter.Create(stringWriter, xmlSettings))
{
using (XmlDictionaryWriter writer = XmlDictionaryWriter.CreateDictionaryWriter(textWriter))
{
if (IsMessageVersionSupported(MessageVersion.Soap12WSAddressing10))
{
WriteHeader(writer, MessageVersion.Soap12WSAddressing10);
}
//else if (IsMessageVersionSupported(MessageVersion.Soap12WSAddressingAugust2004))
//{
// WriteHeader(writer, MessageVersion.Soap12WSAddressingAugust2004);
//}
//else if (IsMessageVersionSupported(MessageVersion.Soap11WSAddressing10))
//{
// WriteHeader(writer, MessageVersion.Soap11WSAddressing10);
//}
//else if (IsMessageVersionSupported(MessageVersion.Soap11WSAddressingAugust2004))
//{
// WriteHeader(writer, MessageVersion.Soap11WSAddressingAugust2004);
//}
//else if (IsMessageVersionSupported(MessageVersion.Soap12))
//{
// WriteHeader(writer, MessageVersion.Soap12);
//}
else if (IsMessageVersionSupported(MessageVersion.Soap11))
{
WriteHeader(writer, MessageVersion.Soap11);
}
else
{
WriteHeader(writer, MessageVersion.None);
}
writer.Flush();
return(stringWriter.ToString());
}
}
}
}
protected virtual MessageBuffer OnCreateBufferedCopy(
int maxBufferSize)
{
var s = new XmlWriterSettings();
s.OmitXmlDeclaration = true;
s.ConformanceLevel = ConformanceLevel.Auto;
StringWriter sw = new StringWriter();
using (XmlDictionaryWriter w = XmlDictionaryWriter.CreateDictionaryWriter(XmlWriter.Create(sw, s)))
WriteBodyContents(w);
var headers = new MessageHeaders(Headers);
var props = new MessageProperties(Properties);
return(new DefaultMessageBuffer(maxBufferSize, headers, props, new XmlReaderBodyWriter(sw.ToString(), maxBufferSize, null), false, new AttributeCollection()));
}
protected virtual XmlDictionaryReader OnGetReaderAtBodyContents()
{
var ws = new XmlWriterSettings();
ws.ConformanceLevel = ConformanceLevel.Auto;
StringWriter sw = new StringWriter();
using (XmlDictionaryWriter body = XmlDictionaryWriter.CreateDictionaryWriter(XmlWriter.Create(sw, ws))) {
WriteBodyContents(body);
}
var rs = new XmlReaderSettings();
rs.ConformanceLevel = ConformanceLevel.Auto;
return(XmlDictionaryReader.CreateDictionaryReader(XmlReader.Create(new StringReader(sw.ToString()), rs)));
}
public override void WriteRequestSecurityTokenResponseCollection(RequestSecurityTokenResponseCollection rstrCollection, XmlWriter xmlWriter)
{
if (rstrCollection == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("rstrCollection");
}
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateDictionaryWriter(xmlWriter);
writer.WriteStartElement(DriverDictionary.Prefix.Value, DriverDictionary.RequestSecurityTokenResponseCollection, DriverDictionary.Namespace);
foreach (RequestSecurityTokenResponse rstr in rstrCollection.RstrCollection)
{
rstr.WriteTo(writer);
}
writer.WriteEndElement();
}
/// <summary>
/// Serializes this instance.
/// </summary>
/// <returns></returns>
public String Serialize()
{
using (MemoryStream stream = new MemoryStream())
{
DataContractSerializer ser = new DataContractSerializer(typeof(DataBox));
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateDictionaryWriter(XmlWriter.Create(stream));
ser.WriteObject(writer, this, new Utilities.DataboxResolver());
writer.Flush();
stream.Position = 0;
using (StreamReader sr = new StreamReader(stream))
{
return(sr.ReadToEnd());
}
}
}
public static void Snippet2()
{
// <Snippet2>
string[] strings = { "Hello", "world" };
MyBodyWriter bodyWriter = new MyBodyWriter(strings);
StringBuilder strBuilder = new StringBuilder(10);
XmlWriter writer = XmlWriter.Create(strBuilder);
XmlDictionaryWriter dictionaryWriter = XmlDictionaryWriter.CreateDictionaryWriter(writer);
bodyWriter.WriteBodyContents(dictionaryWriter);
dictionaryWriter.Flush();
MyBodyWriter bufferedBodyWriter = (MyBodyWriter)bodyWriter.CreateBufferedCopy(1024);
// </Snippet2>
}
public static void SerializeObjectXML(string filename, object objectToSerialize)
{
try
{
MemoryStream stream = new MemoryStream();
DataContractSerializer serializer = new DataContractSerializer(objectToSerialize.GetType(), null, int.MaxValue, false, true, null);
var settings = new XmlWriterSettings()
{
Indent = true,
IndentChars = "\t"
};
settings.NamespaceHandling = NamespaceHandling.OmitDuplicates;
//settings.OutputMethod = XmlOutputMethod.Xml;
settings.ConformanceLevel = ConformanceLevel.Fragment;
using (XmlDictionaryWriter writer = XmlDictionaryWriter.CreateDictionaryWriter(XmlWriter.Create(stream, settings)))
{
serializer.WriteObject(writer, objectToSerialize, new MyCustomerResolver());
}
byte[] serializedData = stream.ToArray();
File.WriteAllBytes(filename, serializedData);
//var emptyNamepsaces = new XmlSerializerNamespaces(new[] { XmlQualifiedName.Empty });
//var serializer = new XmlSerializer(objectToSerialize.GetType());
//var settings = new XmlWriterSettings();
//settings.Indent = true;
//settings.OmitXmlDeclaration = true;
//MemoryStream stream = new MemoryStream();
//using (var writer = XmlWriter.Create(stream, settings))
//{
// serializer.Serialize(writer, objectToSerialize, emptyNamepsaces);
//}
//byte[] serializedData = stream.ToArray();
//File.WriteAllBytes(filename, serializedData);
//stream.Dispose();
}
catch (Exception ex)
{
Console.Write(string.Format("Error!\nError Message: {0}\n{1}", ex.Message, ex.StackTrace));
}
}
/// <summary>
/// Translates the message using the SOAP 1.1 schema.
/// </summary>
/// <param name="message">The message to be translated.</param>
private static string TranslateMessageAsSoap11(Message message)
{
StringBuilder sb = new StringBuilder();
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateDictionaryWriter(XmlWriter.Create(sb));
message.WriteStartEnvelope(writer);
message.WriteBody(writer);
writer.Flush();
string raw = sb.ToString();
//to get past the damn utf 16 header
raw = raw.Substring(raw.LastIndexOf("?>") + 2).Trim();
//well there is no WriteEndEnvelope(writer) method:-)
return(raw + "</s:Envelope>");
}
// Simple ENS implementation just takes raw message (not used in demo)
public void NotificationMessage(Message msg)
{
StringBuilder sb = new StringBuilder();
XmlWriterSettings settings = new XmlWriterSettings()
{
Indent = true,
NewLineHandling = NewLineHandling.Entitize
};
using (XmlWriter xw = XmlWriter.Create(sb, settings))
{
XmlDictionaryWriter xdw = XmlDictionaryWriter.CreateDictionaryWriter(xw);
msg.WriteBodyContents(xdw);
xdw.Flush();
}
Console.WriteLine(sb.ToString());
}
public void WriteContentsToWSA10()
{
X509Certificate2 cert = new X509Certificate2(TestResourceHelper.GetFullPathOfResource("Test/Resources/test.cer"));
EndpointAddress a = new EndpointAddress(
new Uri("http://localhost:8080"),
new X509CertificateEndpointIdentity(cert));
StringWriter sw = new StringWriter();
XmlWriterSettings xws = new XmlWriterSettings();
xws.OmitXmlDeclaration = true;
using (XmlDictionaryWriter xw = XmlDictionaryWriter.CreateDictionaryWriter(XmlWriter.Create(sw, xws))) {
xw.WriteStartElement("root");
a.WriteContentsTo(AddressingVersion.WSAddressing10, xw);
xw.WriteEndElement();
}
Assert.AreEqual(C14N("<root><Address xmlns=\"http://www.w3.org/2005/08/addressing\">http://localhost:8080/</Address>" + identity1 + "</root>"), C14N(sw.ToString()), "#2");
}
protected virtual XmlDictionaryReader OnGetReaderAtDetailContents()
{
if (!HasDetail)
{
throw new InvalidOperationException("There is no fault detail to read");
}
MemoryStream ms = new MemoryStream();
using (XmlDictionaryWriter dw =
XmlDictionaryWriter.CreateDictionaryWriter(
XmlWriter.Create(ms))) {
OnWriteDetailContents(dw);
}
ms.Seek(0, SeekOrigin.Begin);
return(XmlDictionaryReader.CreateDictionaryReader(
XmlReader.Create(ms)));
}
private static XElement Saml2AssertionToXElement(Saml2Assertion assertion)
{
var sb = new StringBuilder();
var settings = new XmlWriterSettings
{
OmitXmlDeclaration = true,
Encoding = Encoding.UTF8
};
using (var stringWriter = new StringWriter(sb))
using (var xmlWriter = XmlWriter.Create(stringWriter, settings))
using (var dictionaryWriter = XmlDictionaryWriter.CreateDictionaryWriter(xmlWriter))
{
new Saml2AssertionSerializer().WriteSaml2Assertion(xmlWriter, assertion);
}
return(XElement.Parse(sb.ToString()));
}