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); }