void WriteBytes(string name, Type type, byte[] value, int offset, int length, string comment) { writer.WriteStartElement("data"); writer.WriteAttributeString("name", name); if (type != null) { writer.WriteAttributeString("type", type.AssemblyQualifiedName); // byte[] should never get a mimetype, otherwise MS.NET won't be able // to parse the data. if (type != typeof(byte[])) { writer.WriteAttributeString("mimetype", ByteArraySerializedObjectMimeType); } writer.WriteStartElement("value"); WriteNiceBase64(value, offset, length); } else { writer.WriteAttributeString("mimetype", BinSerializedObjectMimeType); writer.WriteStartElement("value"); writer.WriteBase64(value, offset, length); } writer.WriteEndElement(); if (!(comment == null || comment.Equals(String.Empty))) { writer.WriteStartElement("comment"); writer.WriteString(comment); writer.WriteEndElement(); } writer.WriteEndElement(); }
public void AddValue(string name, System.IO.MemoryStream stream) { m_Writer.WriteStartElement(name); if (stream == null) { m_Writer.WriteAttributeString("Length", XmlConvert.ToString(0)); } else { byte[] buffer = stream.ToArray(); m_Writer.WriteAttributeString("Length", XmlConvert.ToString(buffer.Length)); m_Writer.WriteBase64(buffer, 0, buffer.Length); } m_Writer.WriteEndElement(); }
static void Main(string[] args) { // Dateinamen ermitteln string imageFileName = Path.Combine(Application.StartupPath, "hitchhiker.jpg"); string xmlFileName = Path.Combine(Application.StartupPath, "hitchhiker.xml"); // FileStream-Instanz erzeugen FileInfo fi = new FileInfo(imageFileName); FileStream fs = fi.OpenRead(); // Byte-Puffer erzeugen und die Datei in diesen einlesen byte[] buffer = new Byte[fi.Length]; fs.Read(buffer, 0, buffer.Length); // Die eingelesenen Daten Base-64-codiert in eine XML-Datei schreiben XmlTextWriter xmlWriter = new XmlTextWriter(xmlFileName, Encoding.UTF8); xmlWriter.WriteStartDocument(true); xmlWriter.WriteStartElement("applicationData"); xmlWriter.WriteStartElement("splashImage"); xmlWriter.WriteBase64(buffer, 0, buffer.Length); xmlWriter.WriteEndElement(); xmlWriter.WriteEndElement(); // XML-Datei schließen xmlWriter.Close(); // FileStream schließen fs.Close(); Console.WriteLine("Fertig"); Console.WriteLine("Beenden mit Return"); Console.ReadLine(); }
void SavePictureToFile(XmlTextWriter xmlOut) { ImageControl.Cursor = Cursors.Wait; try { xmlOut.WriteStartElement("PhotoPicture"); JpegBitmapEncoder encoder = new JpegBitmapEncoder(); encoder.QualityLevel = CompressionRate; encoder.Frames.Add(BitmapFrame.Create(bitmapImage)); MemoryStream memory = new MemoryStream(1000000); encoder.Save(memory); memory.Seek(0, SeekOrigin.Begin); BinaryReader br = new BinaryReader(memory); int bufferSize = 1000; byte[] buffer = new byte[bufferSize]; int readBytes = 0; do { readBytes = br.Read(buffer, 0, bufferSize); xmlOut.WriteBase64(buffer, 0, readBytes); } while (bufferSize <= readBytes); br.Close(); xmlOut.WriteEndElement(); } finally { ImageControl.Cursor = Cursors.Arrow; } }
/// <summary> /// Only subscribed keys in the same namespace are saved. /// </summary> /// <param name="dict"></param> /// <returns>XML file</returns> public static MemoryStream Save(P2PDictionary dict) { MemoryStream writeStream = new MemoryStream(); System.Xml.XmlTextWriter writer = new XmlTextWriter(writeStream, Encoding.UTF8); ICollection <string> keys = dict.Keys; writer.WriteStartDocument(); writer.WriteStartElement("p2pdictionary"); writer.WriteStartElement("namespace"); writer.WriteAttributeString("name", dict.Namespace); writer.WriteAttributeString("description", dict.Description); IFormatter formatter = new BinaryFormatter(); foreach (string k in keys) { writer.WriteStartElement("entry"); writer.WriteAttributeString("key", k); using (MemoryStream contents = new MemoryStream()) { formatter.Serialize(contents, dict[k]); writer.WriteBase64(contents.GetBuffer(), 0, (int)contents.Length); } writer.WriteEndElement(); } writer.WriteEndElement(); writer.WriteEndElement(); writer.Flush(); return(writeStream); }
private void button1_Click(object sender, EventArgs e) { if (!System.IO.File.Exists(textBox1.Text)) { MessageBox.Show("Invalid image file name"); return; } if (!System.IO.Directory.Exists(System.IO.Path.GetDirectoryName(textBox2.Text))) { MessageBox.Show("Invalid destination directory"); return; } XmlTextWriter writer = new XmlTextWriter(textBox2.Text, null); FileStream fs = File.OpenRead(textBox1.Text); byte[] data = new byte[fs.Length]; fs.Position = 0; fs.Read(data, 0, data.Length); fs.Close(); writer.WriteStartDocument(); writer.WriteStartElement("imagefile"); writer.WriteAttributeString("filename", textBox1.Text); writer.WriteAttributeString("size", data.Length.ToString()); writer.WriteBase64(data, 0, data.Length); writer.WriteEndElement(); writer.Close(); }
public static void Save(string filename, object options) { Byte[] buffer = new Byte[80]; MemoryStream ms; BinaryFormatter bf = new BinaryFormatter(); System.Xml.XmlTextWriter xmlwriter = new XmlTextWriter(filename, System.Text.Encoding.Default); xmlwriter.Formatting = Formatting.Indented; xmlwriter.WriteStartDocument(); xmlwriter.WriteComment("Option File. Do not edit! [email protected]"); xmlwriter.WriteStartElement(options.ToString()); PropertyInfo[] props = options.GetType().GetProperties( BindingFlags.Public | BindingFlags.Instance | BindingFlags.SetField); foreach (PropertyInfo prop in props) { xmlwriter.WriteStartElement(prop.Name); object da = prop.GetValue(options, null); if (da != null) { xmlwriter.WriteAttributeString("Value", da.ToString()); ms = new MemoryStream(); try { bf.Serialize(ms, da); ms.Position = 0; int count = 0; do { count = ms.Read(buffer, 0, buffer.Length); xmlwriter.WriteBase64(buffer, 0, count); }while (count == buffer.Length); } //end try catch (System.Runtime.Serialization.SerializationException) { System.Diagnostics.Trace.WriteLine("SERIALIZATION FAILED: {0}", prop.Name); } //end catch } //end if else { xmlwriter.WriteAttributeString("Value", "null"); } xmlwriter.WriteEndElement(); } //end foreach xmlwriter.WriteEndElement(); xmlwriter.WriteEndDocument(); xmlwriter.Flush(); xmlwriter.Close(); } //end Save
/// <summary> /// Handle the reception of a RTStroke object. /// </summary> /// <param name="rtStroke">Stroke received</param> private void RTStrokeReceived(RTStroke rtStroke) { Page pg = rtDoc.Resources.Pages[rtStroke.PageIdentifier]; if (pg == null) // if the page is missing, ignore the stroke :( { return; } SizeF imageSize = GetSlideSize(pg.Image); // Resize the received stroke float xRatio = (imageSize.Width / constWidthPageSend) * inkSpaceToPixel; float yRatio = (imageSize.Height / constHeightPageSend) * inkSpaceToPixel; Rectangle bounds = rtStroke.Stroke.GetBoundingBox(); RectangleF newBounds = new RectangleF(bounds.X * xRatio, bounds.Y * yRatio, bounds.Width * xRatio, bounds.Height * yRatio); // Add the stroke to the page StringBuilder importData = new StringBuilder(2000); XmlTextWriter xml = CreateInitdXml(importData); xml.WriteStartElement("PlaceObjects"); xml.WriteAttributeString("pagePath", crntONFile); xml.WriteAttributeString("pageGuid", rtStroke.PageIdentifier.ToString("B")); xml.WriteStartElement("Object"); xml.WriteAttributeString("guid", rtStroke.StrokeIdentifier.ToString("B")); xml.WriteStartElement("Position"); xml.WriteAttributeString("x", newBounds.X.ToString()); xml.WriteAttributeString("y", newBounds.Y.ToString()); xml.WriteEndElement(); // end Position xml.WriteStartElement("Ink"); xml.WriteAttributeString("width", newBounds.Width.ToString()); xml.WriteAttributeString("height", newBounds.Height.ToString()); Ink ink = new Ink(); ink.AddStrokesAtRectangle(rtStroke.Strokes, rtStroke.Strokes.GetBoundingBox()); byte[] base64ISF_bytes = ink.Save(PersistenceFormat.Base64InkSerializedFormat); xml.WriteStartElement("Data"); xml.WriteBase64(base64ISF_bytes, 0, base64ISF_bytes.Length); xml.WriteEndElement(); // end Data xml.WriteEndDocument(); string finalData = importData.ToString(); LogAsLastCommand(finalData); importer.Import(finalData); // prevents ink & objects from getting inserted too quickly after a page System.Threading.Thread.Sleep(50); // Store the stroke ID in strokesPerPage ((ArrayList)strokesPerPage[rtStroke.PageIdentifier]).Add(rtStroke.StrokeIdentifier); }
public void ToXml(XmlTextWriter writer) { writer.WriteStartElement("Plugin"); writer.WriteElementString("FileName", _fileName); writer.WriteStartElement("Data"); writer.WriteBase64(_serializedData, 0, _serializedData.Length); writer.WriteEndElement(); writer.WriteEndElement(); }
public override string ToString() { StringWriter sw = new StringWriter(); XmlTextWriter tw = new XmlTextWriter(sw); tw.WriteBase64(BinaryValue, 0, BinaryValue.Length); tw.Close(); return(sw.ToString()); }
internal static void WriteMeshGeometryXml(XmlTextWriter x, Point3DCollection polyline) { using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { WriteDatStream(polyline, ms); ms.Flush(); byte[] data = ms.GetBuffer(); x.WriteBase64(data, 0, data.Length); } }
protected override void writeCustomXml(XmlTextWriter writer) { writer.WriteStartElement("image"); string fileName = Path.GetTempPath() + "mazioPictureShape.png"; PngFormat format = new PngFormat(); Img.Save(fileName, format.getCodecInfo(), format.getParameters()); byte[] bytes = File.ReadAllBytes(fileName); writer.WriteBase64(bytes, 0, bytes.Length); writer.WriteEndElement(); }
private void savePrivateKey(User user) { XmlTextWriter writer = new XmlTextWriter(Path.Combine(privateKeyPath, user.name + ".private"), Encoding.ASCII); writer.WriteStartDocument(true); writer.Formatting = Formatting.Indented; writer.Indentation = 2; writer.WriteStartElement("RSA"); form.writeElement("D", user.privateKey.D, writer); form.writeElement("DP", user.privateKey.DP, writer); form.writeElement("DQ", user.privateKey.DQ, writer); form.writeElement("Exponent", user.privateKey.Exponent, writer); form.writeElement("InverseQ", user.privateKey.InverseQ, writer); form.writeElement("Modulus", user.privateKey.Modulus, writer); form.writeElement("P", user.privateKey.P, writer); form.writeElement("Q", user.privateKey.Q, writer); writer.WriteEndElement(); writer.Close(); String path = Path.Combine(privateKeyPath, nazwaUzytkownikaTextBox.Text + ".private"); CryptoService service = new CryptoService(); AesCryptoServiceProvider aes = new AesCryptoServiceProvider(); byte[] file = File.ReadAllBytes(path); List <byte[]> message = new List <byte[]>(); byte[] encryptedMessage = { }; byte[] blockOfFile = { }; int readedByte = 0; int sizeOfBlock = 256; aes.GenerateIV(); while (readedByte < file.Length - sizeOfBlock) { blockOfFile = file.Skip(readedByte).Take(sizeOfBlock).ToArray <byte>(); readedByte += sizeOfBlock; message.Add(service.aesEncoding(service.createSha512Hash(hasloUzytkownikaTextBox.Text, 16), "ECB", 128, blockOfFile, aes.IV)); } blockOfFile = file.Skip(readedByte).Take(file.Length - readedByte).ToArray <byte>(); message.Add(service.aesEncoding(service.createSha512Hash(hasloUzytkownikaTextBox.Text, 16), "ECB", 128, blockOfFile, aes.IV)); XmlTextWriter writer2 = new XmlTextWriter(path, Encoding.UTF8); foreach (byte[] block in message) { writer2.WriteBase64(block, 0, block.Length); writer2.WriteWhitespace("\n"); } writer2.Close(); }
/// <summary> /// Returns an xml representation of an Attachment /// </summary> /// <returns></returns> public string ToXml() { StringWriter sw = new StringWriter(); XmlTextWriter xtw = new XmlTextWriter(sw); xtw.WriteStartElement("Attachment"); xtw.WriteAttributeString("Name", _fullName); byte[] data = this.GetBytes(); xtw.WriteBase64(data, 0, data.Length); xtw.WriteEndElement(); return(sw.ToString()); }
/// <summary> /// Takes an image and writes it as an Image element to the Xml stream provided. /// </summary> private void GetImageAsXml(Image img, XmlTextWriter xml) { xml.WriteStartElement("Object"); xml.WriteAttributeString("guid", Guid.NewGuid().ToString("B")); xml.WriteStartElement("Position"); xml.WriteAttributeString("x", "0"); xml.WriteAttributeString("y", "0"); xml.WriteEndElement(); // end Position xml.WriteStartElement("Image"); xml.WriteAttributeString("backgroundImage", "true"); // Set size of image SizeF imageSize = GetSlideSize(img); xml.WriteAttributeString("width", (imageSize.Width).ToString()); xml.WriteAttributeString("height", (imageSize.Height).ToString()); // Write the image in the xml as Base64 xml.WriteStartElement("Data"); byte[] bits; if (img.RawFormat.Equals(ImageFormat.Emf) || img.RawFormat.Equals(ImageFormat.Wmf)) { // The image goes bad during serialization, so we have to clone it. Metafile mf = (Metafile)((Metafile)img).Clone(); IntPtr ptr = mf.GetHenhmetafile(); Debug.Assert(ptr != IntPtr.Zero, "Failed to get pointer to image."); uint size = GetEnhMetaFileBits(ptr, 0, null); bits = new byte[size]; uint numBits = GetEnhMetaFileBits(ptr, size, bits); mf.Dispose(); Debug.Assert(size == numBits, "Improper serialization of metafile!"); } else { MemoryStream imgMS = new MemoryStream(); img.Save(imgMS, System.Drawing.Imaging.ImageFormat.Jpeg); bits = imgMS.ToArray(); } xml.WriteBase64(bits, 0, bits.Length); xml.WriteEndElement(); // end Data xml.WriteEndElement(); // end Image xml.WriteEndElement(); // end Object }
private void WriteValue(XmlTextWriter writer, object value) { TypeConverter c = TypeDescriptor.GetConverter(value.GetType()); if (c.CanConvertTo(typeof(System.Byte[]))) { byte[] bs = c.ConvertTo(value, typeof(System.Byte[])) as byte[]; writer.WriteBase64(bs, 0, bs.Length); } else { writer.WriteAttributeString(XN_AT_VALUE, value.ToString()); } }
public static string ImageToString(Image image) { MemoryStream memoryStream = new MemoryStream(); image.Save(memoryStream, ImageFormat.Png); memoryStream.Seek(0L, SeekOrigin.Begin); StringBuilder stringBuilder = new StringBuilder(); XmlTextWriter xmlTextWriter = new XmlTextWriter(new StringWriter(stringBuilder, CultureInfo.InvariantCulture)); byte[] array = memoryStream.ToArray(); xmlTextWriter.WriteBase64(array, 0, array.Length); xmlTextWriter.Close(); memoryStream.Close(); return(stringBuilder.ToString()); }
static void WriteBytes(XmlTextWriter writer, string name, byte[] data) { writer.WriteStartElement(name); byte[] d; if (data != null) { d = data; } else { d = Utils.EmptyBytes; } writer.WriteBase64(d, 0, d.Length); writer.WriteEndElement(); // name }
private void button1_Click(object sender, EventArgs e) { XmlTextWriter writer = new XmlTextWriter(textBox2.Text, null); FileStream fs = File.OpenRead(textBox1.Text); byte[] data = new byte[fs.Length]; fs.Position = 0; fs.Read(data, 0, data.Length); fs.Close(); writer.WriteStartDocument(); writer.WriteStartElement("imagefile"); writer.WriteAttributeString("filename", textBox1.Text); writer.WriteAttributeString("size", data.Length.ToString()); writer.WriteBase64(data, 0, data.Length); writer.WriteEndElement(); writer.Close(); }
/// <summary> /// Converts the object passed in to its XML representation. /// The XML string is written on the XmlTextWriter. /// </summary> public void ToXml(object value, FieldInfo field, XmlTextWriter xml, IMarshalContext context) { Type type = value.GetType(); if (type.IsArray) { byte[] bytes = value as byte[]; context.WriteStartTag(__arrayType, field, xml); xml.WriteBase64(bytes, 0, bytes.Length); context.WriteEndTag(__arrayType, field, xml); } else { context.WriteStartTag(__type, field, xml); xml.WriteString(value.ToString()); context.WriteEndTag(__type, field, xml); } }
//public XmlNode UpdateCase(string CreateUserName, string CreateUserDomain, string processName, string entityName, List<KeyValuePair<string, string>> request, string entityNameWithFileType, string fileName, string path) //{ // XmlDocument requestNode = new XmlDocument(); // string filePath = string.Format("{0}\\{1}", fileName, path); // string xmlString = "<BizAgiWSParam>"; // xmlString += "<domain>" + CreateUserDomain + "</domain>"; // xmlString += "<userName>" + CreateUserName + "</userName>"; // xmlString += "<Cases>"; // xmlString += "<Case>"; // xmlString += "<Process>" + processName + "</Process>"; // xmlString += "<Entities>"; // xmlString += "<" + entityName + ">"; // foreach (KeyValuePair<string, string> pair in request) // { // xmlString += Utility.FormTag(pair.Key, pair.Value); // } // xmlString += "<" + entityNameWithFileType + ">"; // xmlString += string.Format("<File fileName=\"{0}\">{1}</File>", fileName, ConvertToBase64(filePath)); // xmlString += "</" + entityNameWithFileType + ">"; // xmlString += "</" + entityName + ">"; // xmlString += "</Entities>"; // xmlString += "</Case>"; // xmlString += "</Cases>"; // xmlString += "</BizAgiWSParam>"; // requestNode.LoadXml(xmlString); // return connObject.createCases(requestNode); //} public string ConvertToBase64(string file) { FileStream stream = File.Open(file, FileMode.Open, FileAccess.Read); //The fileStream is loaded into a BinaryReader BinaryReader binaryReader = new BinaryReader(stream); //Read the bytes and save them in an array byte[] oBytes = binaryReader.ReadBytes(Convert.ToInt32(stream.Length)); //Load an empty StringBuilder into an XmlWriter System.Text.StringBuilder sb = new System.Text.StringBuilder(); TextWriter tw = new StringWriter(sb); XmlTextWriter m_XmlWriter = new XmlTextWriter(tw); //Transform the bytes in the StringBuilder into Base64 m_XmlWriter.WriteBase64(oBytes, 0, oBytes.Length); stream.Close(); return(sb.ToString()); }
private void createEndFile(List <User> users, AesCryptoServiceProvider aes, string extension, List <byte[]> message) { XmlTextWriter writer = new XmlTextWriter(lokalizacjaSzyfrowaniaTextBox.Text + "\\" + nazwaPlikuSzyfrowanegoTextBox.Text + ".xml", Encoding.UTF8); CryptoService service = new CryptoService(); writer.WriteStartDocument(true); writer.Formatting = Formatting.Indented; writer.Indentation = 2; writer.WriteStartElement("EncryptedFileHeader"); writeElement("Algorithm", "AES", writer); writeElement("KeySize", dlugoscKluczaComboBox.Text, writer); writeElement("BlockSize", "128", writer); writeElement("Subblock", dlugoscPodblokuComboBox.Text, writer); writeElement("Mode", trybSzyfrowaniaComboBox.Text, writer); writeElement("IV", aes.IV, writer); writeElement("Extension", extension, writer); writer.WriteStartElement("ApprovedUsers"); foreach (User singleUser in users) { singleUser.publicKey = loadPublicKey(singleUser.name); singleUser.sessionKey = service.rsaEncoding(singleUser.sessionKey, singleUser.publicKey); writer.WriteStartElement("User"); writeElement("Name", singleUser.name, writer); writeElement("sessionKey", singleUser.sessionKey, writer); writer.WriteEndElement(); } writer.WriteEndElement(); writer.WriteStartElement("EnFile"); writer.WriteWhitespace("\n"); foreach (byte[] block in message) { writer.WriteBase64(block, 0, block.Length); writer.WriteWhitespace("\n"); } writer.WriteEndElement(); writer.WriteEndDocument(); writer.Close(); }
// Use the WriteBase64 method to create an XML document. The object // passed by the user is encoded and included in the document. public static void EncodeXmlFile(string xmlFileName, FileStream fileOld) { var buffer = new byte[bufferSize]; int readByte = 0; var xw = new XmlTextWriter(xmlFileName, Encoding.UTF8); xw.WriteStartDocument(); xw.WriteStartElement("root"); // Create a Char writer. var br = new BinaryReader(fileOld); // Set the file pointer to the end. try { do { readByte = br.Read(buffer, 0, bufferSize); xw.WriteBase64(buffer, 0, readByte); } while (bufferSize <= readByte); } catch (Exception ex) { var ex1 = new EndOfStreamException(); if (ex1.Equals(ex)) { Console.WriteLine("We are at end of file"); } else { Console.WriteLine(ex); } } xw.WriteEndElement(); xw.WriteEndDocument(); xw.Flush(); xw.Close(); }
private void Write(byte[] binary, int length) { switch (binaryTextMode) { case BinaryTextMode.Base64: xml.WriteBase64(binary, 0, length); break; case BinaryTextMode.BinHex: xml.WriteBinHex(binary, 0, length); break; case BinaryTextMode.QuotedPrintable: xml.WriteString(QuotedPrintable.Encode(binary, 0, length)); break; case BinaryTextMode.AsciiHexSwitch: xml.WriteString(AsciiHexSwitch.Encode(binary, 0, length)); break; } }
public static string wrapsignature(byte[] A_0) { UTF8Encoding utF8Encoding = new UTF8Encoding(); using (MemoryStream memoryStream = new MemoryStream()) { XmlTextWriter xmlTextWriter = new XmlTextWriter((Stream)memoryStream, (Encoding)utF8Encoding); xmlTextWriter.Formatting = Formatting.Indented; xmlTextWriter.Indentation = 3; xmlTextWriter.WriteStartDocument(); string localName = "Base64"; xmlTextWriter.WriteStartElement(localName); byte[] buffer = A_0; int index = 0; int length = A_0.Length; xmlTextWriter.WriteBase64(buffer, index, length); xmlTextWriter.WriteEndElement(); xmlTextWriter.WriteEndDocument(); xmlTextWriter.Flush(); xmlTextWriter.Close(); byte[] array = memoryStream.ToArray(); return(utF8Encoding.GetString(array)); } }
private void xmlWriterBtn_Click(object sender, EventArgs e) { Bitmap image = new Bitmap(path); using (MemoryStream ms = new MemoryStream()) { image.Save(ms, System.Drawing.Imaging.ImageFormat.Jpeg); using (FileStream fm = new FileStream(Path.GetDirectoryName(Application.ExecutablePath) + "/test.xml", FileMode.Create, FileAccess.ReadWrite)) { XmlTextWriter writer = new XmlTextWriter(fm, Encoding.UTF8); writer.WriteStartDocument(); writer.WriteStartElement("Im"); writer.WriteElementString("Name", Path.GetFileNameWithoutExtension(this.path)); writer.WriteElementString("Number", "1"); writer.WriteElementString("Type", Path.GetExtension(this.path).Substring(1)); writer.WriteStartElement("Data"); writer.WriteBase64(ms.ToArray(), 0, ms.ToArray().Length); writer.WriteEndElement(); writer.WriteEndElement(); writer.WriteEndDocument(); writer.Flush(); writer.Close(); } } }
void TrySerialize(XmlTextWriter xtw, object targetObject, ArrayList nestedObjs) { xtw.WriteStartElement("", "value", ""); var xType = XmlRpcServiceInfo.GetXmlRpcType(targetObject.GetType()); if (xType == XmlRpcType.Array) { xtw.WriteStartElement("", "array", ""); xtw.WriteStartElement("", "data", ""); foreach (var aobj in (Array)targetObject) { if (aobj == null) { throw new XmlRpcMappingSerializeException($"Items in array cannot be null ({targetObject.GetType().GetElementType()}[])."); } Serialize(xtw, aobj, nestedObjs); } xtw.WriteEndElement(); xtw.WriteEndElement(); } else if (xType == XmlRpcType.MultiDimArray) { var mda = (Array)targetObject; var indices = new int[mda.Rank]; BuildArrayXml(xtw, mda, 0, indices, nestedObjs); } else if (xType == XmlRpcType.Base64) { var buf = (byte[])targetObject; xtw.WriteStartElement("", "base64", ""); xtw.WriteBase64(buf, 0, buf.Length); xtw.WriteEndElement(); } else if (xType == XmlRpcType.Boolean) { bool boolVal; if (targetObject is bool) { boolVal = (bool)targetObject; } else { boolVal = (XmlRpcBoolean)targetObject; } if (boolVal) { xtw.WriteElementString("boolean", "1"); } else { xtw.WriteElementString("boolean", "0"); } } else if (xType == XmlRpcType.DateTime) { DateTime dt; if (targetObject is DateTime) { dt = (DateTime)targetObject; } else { dt = (XmlRpcDateTime)targetObject; } var sdt = dt.ToString("yyyyMMdd'T'HH':'mm':'ss", DateTimeFormatInfo.InvariantInfo); xtw.WriteElementString("dateTime.iso8601", sdt); } else if (xType == XmlRpcType.Double) { double doubleVal; if (targetObject is double) { doubleVal = (double)targetObject; } else { doubleVal = (XmlRpcDouble)targetObject; } xtw.WriteElementString("double", doubleVal.ToString(null, CultureInfo.InvariantCulture)); } else if (xType == XmlRpcType.Hashtable) { xtw.WriteStartElement("", "struct", ""); var xrs = targetObject as XmlRpcStruct; foreach (object obj in xrs.Keys) { var skey = obj as string; xtw.WriteStartElement("", "member", ""); xtw.WriteElementString("name", skey); Serialize(xtw, xrs[skey], nestedObjs); xtw.WriteEndElement(); } xtw.WriteEndElement(); } else if (xType == XmlRpcType.Int32) { if (Configuration.UseIntTag) { xtw.WriteElementString("int", targetObject.ToString()); } else { xtw.WriteElementString("i4", targetObject.ToString()); } } else if (xType == XmlRpcType.Int64) { xtw.WriteElementString("i8", targetObject.ToString()); } else if (xType == XmlRpcType.String) { if (Configuration.UseStringTag) { xtw.WriteElementString("string", (string)targetObject); } else { xtw.WriteString((string)targetObject); } } else if (xType == XmlRpcType.Struct) { xtw.WriteStartElement("", "struct", ""); var mis = targetObject.GetType().GetMembers(); var structAction = AttributeHelper.StructMappingAction(targetObject.GetType(), Configuration.MappingAction); foreach (var mi in mis) { if (Attribute.IsDefined(mi, typeof(NonSerializedAttribute))) { continue; } if (mi.MemberType == MemberTypes.Field) { var fi = (FieldInfo)mi; var member = fi.Name; var attrchk = Attribute.GetCustomAttribute(fi, typeof(XmlRpcMemberAttribute)); if (attrchk != null && attrchk is XmlRpcMemberAttribute) { var mmbr = ((XmlRpcMemberAttribute)attrchk).Member; if (mmbr != "") { member = mmbr; } } if (fi.GetValue(targetObject) == null) { var memberAction = AttributeHelper.MemberMappingAction(targetObject.GetType(), fi.Name, structAction); if (memberAction == MappingAction.Ignore) { continue; } throw new XmlRpcMappingSerializeException(@"Member """ + member + @""" of class """ + targetObject.GetType().Name + @""" cannot be null."); } xtw.WriteStartElement("", "member", ""); xtw.WriteElementString("name", member); Serialize(xtw, fi.GetValue(targetObject), nestedObjs); xtw.WriteEndElement(); } else if (mi.MemberType == MemberTypes.Property) { var pi = (PropertyInfo)mi; var member = pi.Name; var attrchk = Attribute.GetCustomAttribute(pi, typeof(XmlRpcMemberAttribute)); if (attrchk != null && attrchk is XmlRpcMemberAttribute) { var mmbr = ((XmlRpcMemberAttribute)attrchk).Member; if (mmbr != "") { member = mmbr; } } if (pi.GetValue(targetObject) == null) { var memberAction = AttributeHelper.MemberMappingAction(targetObject.GetType(), pi.Name, structAction); if (memberAction == MappingAction.Ignore) { continue; } } xtw.WriteStartElement("", "member", ""); xtw.WriteElementString("name", member); Serialize(xtw, pi.GetValue(targetObject, null), nestedObjs); xtw.WriteEndElement(); } } xtw.WriteEndElement(); } else if (xType == XmlRpcType.Void) { xtw.WriteElementString("string", ""); } else { throw new XmlRpcUnsupportedTypeException(targetObject.GetType()); } xtw.WriteEndElement(); }
/// <remarks>Serialize the object to the output stream.</remarks> /// <param name="output">An <c>XmlTextWriter</c> stream to write data to.</param> /// <param name="obj">An <c>Object</c> to serialize.</param> public void SerializeObject(XmlTextWriter output, Object obj) { if (obj == null) { return; } if (obj is byte[]) { byte[] ba = (byte[])obj; output.WriteStartElement(BASE64); output.WriteBase64(ba, 0, ba.Length); output.WriteEndElement(); } else if (obj is String) { output.WriteElementString(STRING, obj.ToString()); } else if (obj is Int32) { output.WriteElementString(INT, obj.ToString()); } else if (obj is DateTime) { output.WriteElementString(DATETIME, ((DateTime)obj).ToString(ISO_DATETIME)); } else if (obj is Double) { output.WriteElementString(DOUBLE, obj.ToString()); } else if (obj is Boolean) { output.WriteElementString(BOOLEAN, ((((Boolean)obj) == true)?"1":"0")); } else if (obj is IList) { output.WriteStartElement(ARRAY); output.WriteStartElement(DATA); if (((ArrayList)obj).Count > 0) { foreach (Object member in ((IList)obj)) { output.WriteStartElement(VALUE); SerializeObject(output, member); output.WriteEndElement(); } } output.WriteEndElement(); output.WriteEndElement(); } else if (obj is IDictionary) { IDictionary h = (IDictionary)obj; output.WriteStartElement(STRUCT); foreach (String key in h.Keys) { output.WriteStartElement(MEMBER); output.WriteElementString(NAME, key); output.WriteStartElement(VALUE); SerializeObject(output, h[key]); output.WriteEndElement(); output.WriteEndElement(); } output.WriteEndElement(); } }
private string Content() { int iStubID; int iCurrentStubVersion = Root.GetStubsVersion(currentUserID); StringBuilder sb = new StringBuilder(); StringWriter stringWriter = new StringWriter(sb); XmlTextWriter writer = new XmlTextWriter(stringWriter); writer.WriteStartElement("options"); writer.WriteAttributeString("xmlns", "dt", null, "urn:schemas-microsoft-com:datatypes"); // Stubs int iGroupId = Root.GetGroupByUser(currentUserID); if (iStubsVersion != iCurrentStubVersion && iCurrentStubVersion >= 0) { writer.WriteStartElement("stubs"); writer.WriteAttributeString("version", iCurrentStubVersion.ToString()); using (IDataReader reader = Root.GetAllStubsForUser(currentUserID)) { while (reader.Read()) { writer.WriteStartElement("stub"); iStubID = Convert.ToInt32(reader["StubId"]); writer.WriteElementString("stub_id", iStubID.ToString()); writer.WriteElementString("stub_name", reader["Abbreviation"].ToString()); writer.WriteElementString("tooltip", reader["ToolTip"].ToString()); writer.WriteElementString("url", reader["Url"].ToString()); writer.WriteElementString("open_window", reader["OpenInBrowser"].ToString()); byte[] bit_icon = null; using (IDataReader reader_for_BLOB = Root.GetBinaryStubIcon(iStubID)) { if (reader_for_BLOB.Read()) { try { bit_icon = (byte[])reader_for_BLOB["Icon"]; } catch { } } } if (bit_icon != null) { writer.WriteStartElement("icon"); writer.WriteAttributeString("dt:dt", "bin.base64"); writer.WriteBase64(bit_icon, 0, bit_icon.Length); writer.WriteEndElement(); //icon } else { writer.WriteElementString("icon", ""); } writer.WriteEndElement(); //stub } } writer.WriteEndElement(); //stubs } // Versions int iMaxBuild = -1; // CManage.GetMaxBuild(sProdGUID); if (iMaxBuild > iBuild) { writer.WriteStartElement("versions"); writer.WriteAttributeString("latest", iMaxBuild.ToString()); writer.WriteAttributeString("url", "Download/IBN Client.msi"); writer.WriteAttributeString("mcupdate", "Download/McUpdate.exe#1.1.25.0"); //DateTime dt; //using (IDataReader reader = CManage.GetHightVersions(iBuild, sProdGUID)) //{ // while (reader.Read()) // { // writer.WriteStartElement("version"); // writer.WriteAttributeString("build", reader["build"].ToString()); // dt = Convert.ToDateTime(reader["date"].ToString()); // writer.WriteAttributeString("date", dt.ToString("d", DateTimeFormatInfo.InvariantInfo)); // writer.WriteAttributeString("description", reader["description"].ToString()); // writer.WriteEndElement(); //version // } //} writer.WriteEndElement(); //versions } // Logos using (IDataReader reader = Root.GetLogoByGroup(iGroupId)) { if (reader.Read()) { int iLogoGroupVersion = Convert.ToInt32(reader["logo_version"]); // Write color and encoded image if (iLogoVersion != iLogoGroupVersion) { try { string version = iLogoGroupVersion.ToString(); string color = reader["color"].ToString(); byte[] bit_logo = null; using (IDataReader reader_for_BLOB = Root.GetBinaryClientLogo(iGroupId)) { try { if (reader_for_BLOB.Read()) { bit_logo = (byte[])reader_for_BLOB["client_logo"]; } } catch { } } writer.WriteStartElement("logos"); writer.WriteAttributeString("version", version); writer.WriteStartElement("logo"); writer.WriteElementString("color", color); if (bit_logo != null) { writer.WriteStartElement("client_logo"); writer.WriteAttributeString("dt:dt", "bin.base64"); writer.WriteBase64(bit_logo, 0, bit_logo.Length); writer.WriteEndElement(); // client_logo } writer.WriteEndElement(); // logo writer.WriteEndElement(); // logos } catch { } } } } writer.WriteEndElement(); // options return(sb.ToString()); }
private void WriteButtonDetails(XmlTextWriter xwriter, HerbiSpeaksButton btn) { xwriter.WriteAttributeString("CenterX", btn.CenterX.ToString()); xwriter.WriteAttributeString("CenterY", btn.CenterY.ToString()); xwriter.WriteAttributeString("Width", btn.Size.Width.ToString()); xwriter.WriteAttributeString("Height", btn.Size.Height.ToString()); xwriter.WriteAttributeString("IsPictureButton", btn.IsPictureButton.ToString()); xwriter.WriteAttributeString("BoardLink", btn.BoardLink); xwriter.WriteAttributeString("BoardLinkSpoken", btn.BoardLinkSpoken.ToString()); string text = btn.Text; if (text == "") { text = btn.AccessibleName; xwriter.WriteAttributeString("ShowText", false.ToString()); } xwriter.WriteAttributeString("Text", text); // Always write out the button's font name, font size and text colour, even // if any of those things are the same as the app's current default settings. xwriter.WriteAttributeString("TextColour", btn.ForeColor.ToArgb().ToString()); xwriter.WriteAttributeString("FontName", btn.Font.Name); xwriter.WriteAttributeString("FontSize", ((int)btn.Font.Size).ToString()); xwriter.WriteAttributeString("ButtonTransparent", ((bool)btn.ButtonTransparent).ToString()); xwriter.WriteAttributeString("ButtonTransparentOnHover", ((bool)btn.ButtonTransparentOnHover).ToString()); if ((btn.Media != null) && (btn.Media != "")) { xwriter.WriteAttributeString("Media", btn.Media); } xwriter.WriteAttributeString("ButtonTextSpokenBeforeMedia", btn.ButtonTextSpokenBeforeMedia.ToString()); xwriter.WriteAttributeString("AutoPlayMedia", btn.AutoPlayMedia.ToString()); xwriter.WriteAttributeString("TextPosition", btn.TextPosition); // Always stream out the full image. We don't care here how the image // happens to be presented on the button at the moment. if (btn.ImageFull != null) { MemoryStream stream = new MemoryStream(); btn.ImageFull.Save(stream, ImageFormat.Png); byte[] bytes = stream.ToArray(); xwriter.WriteStartElement("PictureData"); xwriter.WriteAttributeString("Length", bytes.Length.ToString()); xwriter.WriteBase64(stream.ToArray(), 0, bytes.Length); xwriter.WriteEndElement(); } if (btn.ImageHoverFull != null) { MemoryStream stream = new MemoryStream(); btn.ImageHoverFull.Save(stream, ImageFormat.Png); byte[] bytes = stream.ToArray(); xwriter.WriteStartElement("HoverPictureData"); xwriter.WriteAttributeString("Length", bytes.Length.ToString()); xwriter.WriteBase64(stream.ToArray(), 0, bytes.Length); xwriter.WriteEndElement(); } }