private async Task AppendToTextFileAsync(string fileLocation, T data)
{
try
{
using (var stream = new FileStream(fileLocation, FileMode.Create, FileAccess.Write))
{
using (XmlDictionaryWriter writer = JsonReaderWriterFactory.CreateJsonWriter(
stream, Encoding.UTF8, true, true, " "))
{
var serializer = new DataContractJsonSerializer(data.GetType());
serializer.WriteObject(writer, data);
writer.Flush();
await Task.CompletedTask;
}
}
}
catch (IOException ex) when((ex.HResult & 0xFFFF) == 0x27 || (ex.HResult & 0xFFFF) == 0x70)
{
Logger.Error("TumblrJsonDownloader:AppendToTextFile: {0}", ex);
shellService.ShowError(ex, Resources.DiskFull);
crawlerService.StopCommand.Execute(null);
}
catch
{
}
}
public static Exception SerializeToXmlString(object toSerialize, out string xmlString)
{
xmlString = null;
string tmpStr = null;
Exception ex = DataContractSerializeHelper.HandleException(delegate
{
XmlWriterSettings settings = new XmlWriterSettings
{
Indent = true,
IndentChars = "\t"
};
DataContractSerializer dataContractSerializer = new DataContractSerializer(toSerialize.GetType());
StringBuilder stringBuilder = new StringBuilder();
using (XmlWriter xmlWriter = XmlWriter.Create(stringBuilder, settings))
{
using (XmlDictionaryWriter xmlDictionaryWriter = XmlDictionaryWriter.CreateDictionaryWriter(xmlWriter))
{
dataContractSerializer.WriteObject(xmlDictionaryWriter, toSerialize);
xmlDictionaryWriter.Flush();
tmpStr = stringBuilder.ToString();
}
}
});
if (ex == null)
{
xmlString = tmpStr;
}
return(ex);
}
public override void WriteObjectContent(XmlDictionaryWriter writer, object graph)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
if (writer.WriteState != WriteState.Element)
{
throw new SerializationException(string.Format("WriteState '{0}' not valid. Caller must write start element before serializing in contentOnly mode.",
writer.WriteState));
}
using (MemoryStream memoryStream = new MemoryStream())
{
using (XmlDictionaryWriter bufferWriter = XmlDictionaryWriter.CreateTextWriter(memoryStream, Encoding.UTF8))
{
serializer.Serialize(bufferWriter, graph);
bufferWriter.Flush();
memoryStream.Position = 0;
using (XmlReader reader = new XmlTextReader(memoryStream))
{
reader.MoveToContent();
writer.WriteAttributes(reader, false);
if (reader.Read()) // move off start node (we want to skip it)
{
while (reader.NodeType != XmlNodeType.EndElement) // also skip end node.
{
writer.WriteNode(reader, false); // this will take us to the start of the next child node, or the end node.
}
reader.ReadEndElement(); // not necessary, but clean
}
}
}
}
}
public static void FragmentTest()
{
string rwTypeStr = "Text";
ReaderWriterFactory.ReaderWriterType rwType = (ReaderWriterFactory.ReaderWriterType)
Enum.Parse(typeof(ReaderWriterFactory.ReaderWriterType), rwTypeStr, true);
Encoding encoding = Encoding.GetEncoding("utf-8");
int numberOfNestedFragments = 1;
MemoryStream ms1 = new MemoryStream();
MemoryStream ms2 = new MemoryStream();
XmlDictionaryWriter writer1 = (XmlDictionaryWriter)ReaderWriterFactory.CreateXmlWriter(rwType, ms1, encoding);
XmlDictionaryWriter writer2 = (XmlDictionaryWriter)ReaderWriterFactory.CreateXmlWriter(rwType, ms2, encoding);
Assert.True(FragmentHelper.CanFragment(writer1));
Assert.True(FragmentHelper.CanFragment(writer2));
writer1.WriteStartDocument(); writer2.WriteStartDocument();
writer1.WriteStartElement(ReaderWriterConstants.RootElementName); writer2.WriteStartElement(ReaderWriterConstants.RootElementName);
SimulateWriteFragment(writer1, true, numberOfNestedFragments);
SimulateWriteFragment(writer2, false, numberOfNestedFragments);
writer1.WriteEndElement(); writer2.WriteEndElement();
writer1.WriteEndDocument(); writer2.WriteEndDocument();
writer1.Flush();
writer2.Flush();
byte[] doc1 = ms1.ToArray();
byte[] doc2 = ms2.ToArray();
CompareArrays(doc1, 0, doc2, 0, doc1.Length);
}
/// <summary>
/// Called when the message body is written to an XML file.
/// </summary>
/// <param name="writer">A <see cref="T:System.Xml.XmlDictionaryWriter"/> that is used to write this message body to an XML file.</param>
protected override void OnWriteBodyContents(XmlDictionaryWriter writer)
{
try
{
var prefix = writer.LookupPrefix(this._xmlQualifiedName.Namespace) ?? "web";
this.ActionQueue.Enqueue(() => writer.WriteStartElement(prefix, this._xmlQualifiedName.Name, this._xmlQualifiedName.Namespace));
base.OnWriteBodyContents(writer);
writer.WriteEndElement();
}
catch (FaultException e)
{
var messageFault = new SdmxMessageFault(e.CreateMessageFault(), this._xmlQualifiedName.Namespace);
messageFault.WriteTo(writer, this.Version.Envelope);
if (WebOperationContext.Current != null)
{
WebOperationContext.Current.OutgoingResponse.StatusCode = HttpStatusCode.InternalServerError;
}
if (HttpContext.Current != null)
{
HttpContext.Current.Response.StatusCode = 500;
}
this._isFaulted = true;
}
finally
{
writer.Flush();
}
}
public static void ReadElementContentAsStringDataExceedsMaxBytesPerReadQuota()
{
XmlDictionaryReaderQuotas quotas = new XmlDictionaryReaderQuotas();
quotas.MaxBytesPerRead = 4096;
int contentLength = 8176;
string testString = new string('a', contentLength);
string returnedString;
XmlDictionary dict = new XmlDictionary();
XmlDictionaryString dictEntry = dict.Add("Value");
using (var ms = new MemoryStream())
{
XmlDictionaryWriter xmlWriter = XmlDictionaryWriter.CreateBinaryWriter(ms, dict);
xmlWriter.WriteElementString(dictEntry, XmlDictionaryString.Empty, testString);
xmlWriter.Flush();
ms.Position = 0;
XmlDictionaryReader xmlReader = XmlDictionaryReader.CreateBinaryReader(ms, dict, quotas);
xmlReader.Read();
returnedString = xmlReader.ReadElementContentAsString();
}
Assert.Equal(testString, returnedString);
}
public void TestWriteHeaderContent()
{
int value = 1;
MessageHeader h = MessageHeader.CreateHeader("foo", "bar", value);
XmlObjectSerializer f = new DataContractSerializer(typeof(int));
StringBuilder sb = new StringBuilder();
XmlWriterSettings settings = new XmlWriterSettings();
settings.ConformanceLevel = ConformanceLevel.Auto;
XmlDictionaryWriter w = XmlDictionaryWriter.CreateDictionaryWriter(
XmlWriter.Create(sb, settings));
w.WriteStartElement("dummy-root");
h.WriteHeaderContents(w, MessageVersion.Soap12WSAddressing10);
w.WriteEndElement();
w.Flush();
string actual = sb.ToString();
f.WriteObject(w, value);
string expected = sb.ToString();
// the output of WriteHeaderContent is the same as XmlSerializer.Serialize
Assert.AreEqual(expected, actual);
}
public override void WriteMessage(Message message, Stream stream)
{
if (message == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(message)));
}
if (stream == null)
{
throw TraceUtility.ThrowHelperError(new ArgumentNullException(nameof(stream)), message);
}
ThrowIfMismatchedMessageVersion(message);
message.Properties.Encoder = this;
XmlDictionaryWriter xmlWriter = TakeStreamedWriter(stream);
if (optimizeWriteForUTF8)
{
message.WriteMessage(xmlWriter);
}
else
{
xmlWriter.WriteStartDocument();
message.WriteMessage(xmlWriter);
xmlWriter.WriteEndDocument();
}
xmlWriter.Flush();
ReturnStreamedWriter(xmlWriter);
}
void InspectMessageBody_msdn(ref Message message, bool isRequest)
{
if (!message.IsFault)
{
XmlDictionaryReaderQuotas quotas = new XmlDictionaryReaderQuotas();
XmlReader bodyReader = message.GetReaderAtBodyContents().ReadSubtree();
XmlReaderSettings wrapperSettings = new XmlReaderSettings();
wrapperSettings.CloseInput = true;
wrapperSettings.Schemas = null;
wrapperSettings.ValidationFlags = XmlSchemaValidationFlags.None;
wrapperSettings.ValidationType = ValidationType.None;
XmlReader wrappedReader = XmlReader.Create(bodyReader, wrapperSettings);
// pull body into a memory backed writer to validate
this.isRequest = isRequest;
MemoryStream memStream = new MemoryStream();
XmlDictionaryWriter xdw = XmlDictionaryWriter.CreateBinaryWriter(memStream);
xdw.WriteNode(wrappedReader, false);
xdw.Flush(); memStream.Position = 0;
XmlDictionaryReader xdr = XmlDictionaryReader.CreateBinaryReader(memStream, quotas);
// reconstruct the message with the validated body
Message replacedMessage = Message.CreateMessage(message.Version, null, xdr);
replacedMessage.Headers.CopyHeadersFrom(message.Headers);
replacedMessage.Properties.CopyProperties(message.Properties);
message = replacedMessage;
// string content = xdr.ReadOuterXml();
}
}
public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
{
info.AddValue(MessageVersionTag, SerializeMessageVersion(this.Message.Version));
MemoryStream stream = null;
try
{
stream = new MemoryStream();
using (XmlDictionaryWriter writer = XmlDictionaryWriter.CreateBinaryWriter(stream))
{
var streamTemp = stream;
stream = null;
this.Message.WriteMessage(writer);
writer.Flush();
info.AddValue(MessageTag, streamTemp.ToArray());
}
}
finally
{
if (stream != null)
{
stream.Dispose();
}
}
}
public void SaveSettings(string fileName, object settings)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
if (string.IsNullOrEmpty(fileName))
{
throw new ArgumentException("String must not be null or empty.", nameof(fileName));
}
if (!Path.IsPathRooted(fileName))
{
throw new ArgumentException("Invalid path. The path must be rooted.", nameof(fileName));
}
string directory = Path.GetDirectoryName(fileName);
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
using (FileStream stream = new FileStream(fileName, FileMode.Create, FileAccess.Write))
{
using (XmlDictionaryWriter writer = JsonReaderWriterFactory.CreateJsonWriter(
stream, Encoding.UTF8, true, true, " "))
{
DataContractJsonSerializer serializer = new DataContractJsonSerializer(settings.GetType(), knownTypes);
serializer.WriteObject(writer, settings);
writer.Flush();
}
}
}
/// <summary>
/// This where all starts. Depending on the HTTP verb the following actions is preformed:
/// GET|DELETE:
/// A new BizTalkWebHttpRequest message is generated from the URI parameters, and passed on
/// to BizTalk with the content type set to HTTP POST.
///
/// POST|PUT:
/// Nothing is done, unless the incoming content type is set to application/json, in which case
/// the incoming JSON message is casted to an XML message
/// </summary>
/// <param name="message"></param>
/// <param name="uriMatched"></param>
/// <returns></returns>
protected override string SelectOperation(ref Message message, out bool uriMatched)
{
HttpRequestMessageProperty httpProp = (HttpRequestMessageProperty)message.Properties[HttpRequestMessageProperty.Name];
if (httpProp.Method == "GET" || httpProp.Method == "DELETE")
{
message = ConvertToURIRequest(message);
}
else if ((httpProp.Method == "POST" || httpProp.Method == "PUT") &&
((HttpRequestMessageProperty)message.Properties["httpRequest"]).Headers.ToString().ToLower().Contains("application/json"))
{
var via = message.Properties.Via;
var type = via.Segments.Last().ToString();
MemoryStream ms = new MemoryStream();
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(ms);
message.WriteMessage(writer);
writer.Flush();
string xmlString = Encoding.UTF8.GetString(ms.ToArray());
xmlString = xmlString.Replace("<root", string.Format("<{0}", type));
xmlString = xmlString.Replace("root>", string.Format("{0}>", type));
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(xmlString));
XmlReader reader = XmlReader.Create(stream);
Message newMessage = Message.CreateMessage(reader, int.MaxValue, MessageVersion.None);
newMessage.Properties.CopyProperties(message.Properties);
message = newMessage;
}
uriMatched = true;
// The TwoWayMethod is the only method exposed from BizTalk
return("TwoWayMethod");
}
static void Main()
{
Record record1 = new Record(1, 2, "+", 3);
Console.WriteLine("Original record: {0}", record1.ToString());
MemoryStream stream1 = new MemoryStream();
//Serialize the Record object to a memory stream using DataContractSerializer.
DataContractSerializer serializer = new DataContractSerializer(typeof(Record));
serializer.WriteObject(stream1, record1);
stream1.Position = 0;
//Deserialize the Record object back into a new record object
Record record2 = (Record)serializer.ReadObject(stream1);
Console.WriteLine("Deserialized record: {0}", record2.ToString());
MemoryStream stream2 = new MemoryStream();
XmlDictionaryWriter binaryDictionaryWriter = XmlDictionaryWriter.CreateBinaryWriter(stream2);
serializer.WriteObject(binaryDictionaryWriter, record1);
binaryDictionaryWriter.Flush();
//report the length of the streams
Console.WriteLine("Text Stream is {0} bytes long", stream1.Length);
Console.WriteLine("Binary Stream is {0} bytes long", stream2.Length);
Console.WriteLine();
Console.WriteLine("Press <ENTER> to terminate client.");
Console.ReadLine();
}
public void WriteTo(XmlWriter writer)
{
if (writer == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("writer");
}
if (this.IsReadOnly)
{
// cache the serialized bytes to ensure repeatability
if (_cachedWriteBuffer.Array == null)
{
MemoryStream stream = new MemoryStream();
using (XmlDictionaryWriter binaryWriter = XmlDictionaryWriter.CreateBinaryWriter(stream, XD.Dictionary))
{
this.OnWriteTo(binaryWriter);
binaryWriter.Flush();
stream.Flush();
stream.Seek(0, SeekOrigin.Begin);
bool gotBuffer = stream.TryGetBuffer(out _cachedWriteBuffer);
if (!gotBuffer)
{
throw new UnauthorizedAccessException(SRServiceModel.UnauthorizedAccess_MemStreamBuffer);
}
_cachedWriteBufferLength = (int)stream.Length;
}
}
writer.WriteNode(XmlDictionaryReader.CreateBinaryReader(_cachedWriteBuffer.Array, 0, _cachedWriteBufferLength, XD.Dictionary, XmlDictionaryReaderQuotas.Max), false);
}
else
{
this.OnWriteTo(writer);
}
}
/// <summary>
/// Called to serialize this context.
/// </summary>
/// <param name="info"><see cref="SerializationInfo"/> container for storing data. Cannot be null.</param>
/// <param name="context"><see cref="StreamingContext"/> contains the context for streaming and optionally additional user data.</param>
/// <exception cref="ArgumentNullException"> thrown if 'info' is null.</exception>
public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
{
if (_tokenBytes != null)
{
info.AddValue(_tokenTypeKey, _byteTokenType);
info.AddValue(_tokenKey, _tokenBytes);
}
else if (_tokenString != null)
{
info.AddValue(_tokenTypeKey, _stringTokenType);
info.AddValue(_tokenKey, _tokenString);
}
else if (_token != null && _tokenHandler != null)
{
using (MemoryStream ms = new MemoryStream())
{
info.AddValue(_tokenTypeKey, _securityTokenType);
using (XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(ms, Text.Encoding.UTF8, false))
{
_tokenHandler.WriteToken(writer, _token);
writer.Flush();
info.AddValue(_tokenKey, Convert.ToBase64String(ms.GetBuffer(), 0, (int)ms.Length));
}
}
}
}
protected override void WriteTokenCore(XmlWriter writer, SecurityToken token)
{
bool wroteToken = false;
XmlDictionaryWriter localWriter = XmlDictionaryWriter.CreateDictionaryWriter(writer);
for (int i = 0; i < _tokenEntries.Count; i++)
{
TokenEntry tokenEntry = _tokenEntries[i];
if (tokenEntry.SupportsCore(token.GetType()))
{
try
{
tokenEntry.WriteTokenCore(localWriter, token);
}
catch (Exception e)
{
if (!ShouldWrapException(e))
{
throw;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.Format(SR.ErrorSerializingSecurityToken), e));
}
wroteToken = true;
break;
}
}
if (!wroteToken)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.StandardsManagerCannotWriteObject, token.GetType())));
}
localWriter.Flush();
}
public static void GetNonAtomizedNamesTest()
{
string localNameTest = "localNameTest";
string namespaceUriTest = "http://www.msn.com/";
var encoding = Encoding.UTF8;
var rndGen = new Random();
int byteArrayLength = rndGen.Next(100, 2000);
byte[] byteArray = new byte[byteArrayLength];
rndGen.NextBytes(byteArray);
MemoryStream ms = new MemoryStream();
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(ms, encoding);
writer.WriteElementString(localNameTest, namespaceUriTest, "value");
writer.Flush();
ms.Position = 0;
XmlDictionaryReader reader = XmlDictionaryReader.CreateTextReader(ms, encoding, XmlDictionaryReaderQuotas.Max, null);
bool success = reader.ReadToDescendant(localNameTest);
Assert.True(success);
string localName;
string namespaceUriStr;
reader.GetNonAtomizedNames(out localName, out namespaceUriStr);
Assert.Equal(localNameTest, localName);
Assert.Equal(namespaceUriTest, namespaceUriStr);
writer.Close();
}
private MessageHeader CreateHeader(StringHeader header)
{
MemoryStream memoryStream = new MemoryStream();
XmlDictionaryWriter bufferWriter = XmlDictionaryWriter.CreateTextWriter(memoryStream);
bufferWriter.WriteStartElement("root");
XmlSerializerNamespaces xs = new XmlSerializerNamespaces();
xs.Add("", "");
xs.Add("xsi", "http://www.w3.org/2001/XMLSchema-instance");
xs.Add("xsd", "http://www.w3.org/2001/XMLSchema");
xs.Add("tns", "http://tempuri.org/");
s_stringHeaderSerializer.Serialize(bufferWriter, new object[] { header }, xs, "http://schemas.xmlsoap.org/soap/encoding/");
bufferWriter.WriteEndElement();
bufferWriter.Flush();
XmlDocument doc = new XmlDocument();
memoryStream.Position = 0;
doc.Load(new XmlTextReader(memoryStream)
{
DtdProcessing = DtdProcessing.Prohibit
});
XmlElement stringHeaderElement = doc.DocumentElement.ChildNodes[0] as XmlElement;
return(new XmlElementMessageHeader("StringHeader", "http://tempuri.org/", stringHeaderElement));
}
public void WriteTo(XmlWriter writer)
{
if (writer == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("writer");
}
if (this.IsReadOnly)
{
// cache the serialized bytes to ensure repeatability
if (this.cachedWriteBuffer == null)
{
MemoryStream stream = new MemoryStream();
using (XmlDictionaryWriter binaryWriter = XmlDictionaryWriter.CreateBinaryWriter(stream, XD.Dictionary))
{
this.OnWriteTo(binaryWriter);
binaryWriter.Flush();
stream.Flush();
stream.Seek(0, SeekOrigin.Begin);
this.cachedWriteBuffer = stream.GetBuffer();
this.cachedWriteBufferLength = (int)stream.Length;
}
}
writer.WriteNode(XmlDictionaryReader.CreateBinaryReader(this.cachedWriteBuffer, 0, this.cachedWriteBufferLength, XD.Dictionary, XmlDictionaryReaderQuotas.Max), false);
}
else
{
this.OnWriteTo(writer);
}
}
private string ReadRawBody(ref Message message)
{
XmlDictionaryReader bodyReader = message.GetReaderAtBodyContents();
bodyReader.ReadStartElement("Binary");
byte[] bodyBytes = bodyReader.ReadContentAsBase64();
//MemoryStream ms1 = new MemoryStream(bodyBytes);
//StreamReader sr = new StreamReader(ms1);
//JsonSerializer serializer = JsonHelper.GetJsonSerializer();
//var obj = serializer.Deserialize(sr, typeof(ReturnMessage<object>));
string messageBody = Encoding.UTF8.GetString(bodyBytes);
// Now to recreate the message
MemoryStream ms = new MemoryStream();
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateBinaryWriter(ms);
writer.WriteStartElement("Binary");
writer.WriteBase64(bodyBytes, 0, bodyBytes.Length);
writer.WriteEndElement();
writer.Flush();
ms.Position = 0;
XmlDictionaryReader reader = XmlDictionaryReader.CreateBinaryReader(ms, XmlDictionaryReaderQuotas.Max);
Message newMessage = Message.CreateMessage(reader, int.MaxValue, message.Version);
newMessage.Properties.CopyProperties(message.Properties);
newMessage.Headers.CopyHeadersFrom(message);
message = newMessage;
return(messageBody);
}
public static void CreateTextReaderWriterTest()
{
string expected = "<localName>the value</localName>";
using (MemoryStream stream = new MemoryStream())
{
using (XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(stream, Encoding.UTF8, false))
{
writer.WriteElementString("localName", "the value");
writer.Flush();
byte[] bytes = stream.ToArray();
StreamReader reader = new StreamReader(stream);
stream.Position = 0;
string content = reader.ReadToEnd();
Assert.Equal(expected, content);
reader.Close();
using (XmlDictionaryReader xreader = XmlDictionaryReader.CreateTextReader(bytes, new XmlDictionaryReaderQuotas()))
{
xreader.Read();
string xml = xreader.ReadOuterXml();
Assert.Equal(expected, xml);
}
}
}
}
private string ReadRawBody(ref Message message)
{
XmlDictionaryReader bodyReader = message.GetReaderAtBodyContents();
bodyReader.ReadStartElement("Binary");
byte[] bodyBytes = bodyReader.ReadContentAsBase64();
string messageBody = Encoding.UTF8.GetString(bodyBytes);
// Now to recreate the message
MemoryStream ms = new MemoryStream();
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateBinaryWriter(ms);
writer.WriteStartElement("Binary");
writer.WriteBase64(bodyBytes, 0, bodyBytes.Length);
writer.WriteEndElement();
writer.Flush();
ms.Position = 0;
XmlDictionaryReader reader = XmlDictionaryReader.CreateBinaryReader(ms, XmlDictionaryReaderQuotas.Max);
Message newMessage = Message.CreateMessage(reader, int.MaxValue, message.Version);
newMessage.Properties.CopyProperties(message.Properties);
message = newMessage;
return(messageBody);
}
private void SaveBlog()
{
string currentIndex = Path.Combine(Location, Name + "." + BlogType);
string newIndex = Path.Combine(Location, Name + "." + BlogType + ".new");
string backupIndex = Path.Combine(Location, Name + "." + BlogType + ".bak");
if (File.Exists(currentIndex))
{
using (var stream = new FileStream(newIndex, FileMode.Create, FileAccess.Write))
{
using (XmlDictionaryWriter writer = JsonReaderWriterFactory.CreateJsonWriter(
stream, Encoding.UTF8, true, true, " "))
{
var serializer = new DataContractJsonSerializer(GetType());
serializer.WriteObject(writer, this);
writer.Flush();
}
}
File.Replace(newIndex, currentIndex, backupIndex, true);
File.Delete(backupIndex);
}
else
{
using (var stream = new FileStream(currentIndex, FileMode.Create, FileAccess.Write))
{
using (XmlDictionaryWriter writer = JsonReaderWriterFactory.CreateJsonWriter(
stream, Encoding.UTF8, true, true, " "))
{
var serializer = new DataContractJsonSerializer(GetType());
serializer.WriteObject(writer, this);
writer.Flush();
}
}
}
}
protected override void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion)
{
// Create the Nonce
byte[] nonce = GenerateNonce();
// Create the Created Date
string created = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.fffZ");
// Create the WSSE Security Header, starting with the Username Element
writer.WriteStartElement("wsse", "UsernameToken", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd");
writer.WriteXmlnsAttribute("wsu", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd");
writer.WriteStartElement("wsse", "Username", null);
writer.WriteString(Username);
writer.WriteEndElement();
// Add the Password Element
writer.WriteStartElement("wsse", "Password", null);
writer.WriteAttributeString("Type", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordDigest");
writer.WriteString(GeneratePasswordDigest(nonce, created, Password));
writer.WriteEndElement();
// Add the Nonce Element
writer.WriteStartElement("wsse", "Nonce", null);
writer.WriteAttributeString("EncodingType", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-soap-message-security-1.0#Base64Binary");
writer.WriteBase64(nonce, 0, nonce.Length);
writer.WriteEndElement();
// Lastly, add the Created Element
writer.WriteStartElement("wsu", "Created", null);
writer.WriteString(created);
writer.WriteEndElement();
writer.WriteEndElement();
writer.Flush();
}
public static string Serialize <T>(T obj)
{
CultureInfo currentCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
string json = null;
try
{
using (MemoryStream stream = new MemoryStream())
{
using (XmlDictionaryWriter writer =
JsonReaderWriterFactory.CreateJsonWriter(stream, Encoding.UTF8, true, true, " "))
{
DataContractJsonSerializer serializer =
new DataContractJsonSerializer(typeof(T), Settings);
serializer.WriteObject(writer, obj);
writer.Flush();
}
byte[] jsonBytes = stream.ToArray();
json = Encoding.UTF8.GetString(jsonBytes, 0, jsonBytes.Length);
}
}
catch (Exception exception)
{
Debug.WriteLine(exception.ToString());
}
finally
{
Thread.CurrentThread.CurrentCulture = currentCulture;
}
return(json);
}
private void WriteHeader(XmlDictionaryWriter writer)
{
writer.WriteStartElement("wsu", "Timestamp", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd");
writer.WriteAttributeString("wsu", "id", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd", "Timestamp-6557466");
writer.WriteStartElement("wsu", "Created", XmlConvert.ToString(DateTime.Now, "yyyy-MM-ddTHH:mm:sszzzzzz"));
writer.WriteEndElement(); //End Created
writer.WriteStartElement("wsu", "Expires", XmlConvert.ToString(DateTime.Now.AddDays(1), "yyyy-MM-ddTHH:mm:sszzzzzz"));
writer.WriteEndElement(); //End Expires
writer.WriteEndElement(); //End Timestamp
writer.WriteStartElement("wsse", "UsernameToken", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd");
writer.WriteXmlnsAttribute("wsu", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd");
writer.WriteStartElement("wsse", "Username", null);
writer.WriteString(SystemUser);
writer.WriteEndElement();//End Username
writer.WriteStartElement("wsse", "Password", null);
writer.WriteAttributeString("Type", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordText");
writer.WriteString(SystemPassword);
writer.WriteEndElement(); //End Password
writer.WriteEndElement(); //End UsernameToken
writer.Flush();
}
public static Exception SerializeToXmlFile(object toSerialize, string fileFullPath)
{
return(DataContractSerializeHelper.HandleException(delegate
{
string directoryName = Path.GetDirectoryName(fileFullPath);
if (!Directory.Exists(directoryName))
{
Directory.CreateDirectory(directoryName);
}
if (File.Exists(fileFullPath))
{
File.Delete(fileFullPath);
}
using (FileStream fileStream = File.OpenWrite(fileFullPath))
{
XmlWriterSettings settings = new XmlWriterSettings
{
Indent = true,
IndentChars = "\t",
Encoding = Encoding.UTF8
};
DataContractSerializer dataContractSerializer = new DataContractSerializer(toSerialize.GetType());
using (XmlWriter xmlWriter = XmlWriter.Create(fileStream, settings))
{
using (XmlDictionaryWriter xmlDictionaryWriter = XmlDictionaryWriter.CreateDictionaryWriter(xmlWriter))
{
dataContractSerializer.WriteObject(xmlDictionaryWriter, toSerialize);
xmlDictionaryWriter.Flush();
}
}
}
}));
}
public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
{
if (this._tokenBytes != null)
{
info.AddValue("K", 'B');
info.AddValue("T", this._tokenBytes);
return;
}
if (this._tokenString != null)
{
info.AddValue("K", 'S');
info.AddValue("T", this._tokenString);
return;
}
if (this._token != null && this._tokenHandler != null)
{
using (MemoryStream memoryStream = new MemoryStream())
{
info.AddValue("K", 'T');
using (XmlDictionaryWriter xmlDictionaryWriter = XmlDictionaryWriter.CreateTextWriter(memoryStream, Encoding.UTF8, false))
{
this._tokenHandler.WriteToken(xmlDictionaryWriter, this._token);
xmlDictionaryWriter.Flush();
info.AddValue("T", Convert.ToBase64String(memoryStream.GetBuffer(), 0, (int)memoryStream.Length));
}
}
}
}
public override ArraySegment <byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (bufferManager == null)
{
throw new ArgumentNullException(nameof(bufferManager));
}
if (maxMessageSize < 0)
{
throw new ArgumentOutOfRangeException(nameof(maxMessageSize));
}
this.ThrowIfInvalidMessageVersion(message);
message.Properties.Encoder = this;
using (MemoryStream ms = new MemoryStream())
using (XmlDictionaryWriter writer = XmlDictionaryWriter.CreateBinaryWriter(ms))
{
message.WriteMessage(writer);
writer.Flush();
byte[] buffer = bufferManager.TakeBuffer((int)ms.Position + messageOffset);
Buffer.BlockCopy(ms.GetBuffer(), 0, buffer, messageOffset, (int)ms.Position);
return(new ArraySegment <byte>(buffer, messageOffset, (int)ms.Position));
}
}
System.ServiceModel.Channels.Message IDispatchMessageFormatter.SerializeReply(System.ServiceModel.Channels.MessageVersion messageVersion, object[] parameters, object result)
{
MemoryStream memStream = new MemoryStream();
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(memStream);
//writer.WriteStartElement(XmlRpcProtocol.MethodResponse);
writer.WriteStartElement(XmlRpcProtocol.Params);
writer.WriteStartElement(XmlRpcProtocol.Param);
writer.WriteStartElement(XmlRpcProtocol.Value);
XmlRpcDataContractSerializationHelper.Serialize(writer, result);
writer.WriteEndElement();
writer.WriteEndElement();
writer.WriteEndElement();
//writer.WriteEndElement();
writer.Flush();
memStream.Position = 0;
XmlDictionaryReaderQuotas quotas = new XmlDictionaryReaderQuotas();
XmlRpcMessage xmlRpcMessage = new XmlRpcMessage(XmlDictionaryReader.CreateTextReader(memStream, quotas));
HttpResponseMessageProperty hrmp = new HttpResponseMessageProperty();
hrmp.Headers.Add(HttpResponseHeader.ContentType, "text/xml");
xmlRpcMessage.Properties.Add(HttpResponseMessageProperty.Name, hrmp);
return(xmlRpcMessage);
}