public static void Write(string file, Map overview) { if (string.IsNullOrEmpty(file)) throw new Exception("File Not Empty"); System.Xml.Serialization.XmlSerializer writer = new System.Xml.Serialization.XmlSerializer(typeof(Map)); System.Xml.XmlWriterSettings setting = new System.Xml.XmlWriterSettings(); setting.Encoding = Encoding.UTF8; setting.CloseOutput = true; setting.NewLineChars = "\r\n"; setting.Indent = true; if (!File.Exists(file)) { using (Stream s = File.Open(file, FileMode.OpenOrCreate)) { System.Xml.XmlWriter tmp = System.Xml.XmlWriter.Create(s, setting); writer.Serialize(tmp, overview); } } else { using (Stream s = File.Open(file, FileMode.Truncate)) { System.Xml.XmlWriter tmp = System.Xml.XmlWriter.Create(s, setting); writer.Serialize(tmp, overview); } } }
static void Main(string[] args) { Person p = new Person { FirstName = "Bart", MiddleName = "A", LastName = "Simpson" }; XmlSerializer x = new XmlSerializer(p.GetType()); x.Serialize(Console.Out, p); var outputFile = $"Person.xml"; using (var fs = new FileStream(outputFile, FileMode.OpenOrCreate)) { x.Serialize(fs, p); } using (var fs = new FileStream(outputFile, FileMode.OpenOrCreate)) { var deserialize = (Person)x.Deserialize(fs); } Console.WriteLine(); Console.ReadLine(); }
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { var orderSerializer = new XmlSerializer(typeof(PurchaseOrderType)); var ordersSerializer = new XmlSerializer(typeof(PurchaseOrdersType)); var responseMessage = new HttpResponseMessage(); var stream = new MemoryStream(); var localPath = request.RequestUri.LocalPath; // GET /orders/notshipped if (localPath.EndsWith("/orders/notshipped")) ordersSerializer.Serialize(stream, repository.GetNotShipped()); // GET /orders/shipped if (localPath.EndsWith("/orders/shipped")) ordersSerializer.Serialize(stream, repository.GetShipped()); // POST /orders/{id}/ship if (localPath.EndsWith("/ship") && request.Method == HttpMethod.Post) { var shipUrl = localPath; var shipId = shipUrl.Replace("/api/orders/", string.Empty).Replace("/ship", string.Empty); var shipOrder = repository.Get(shipId); shipOrder.shipped = true; repository.Update(shipOrder); } // POST /orders if (localPath.EndsWith("/orders") && request.Method == HttpMethod.Post) { var result = request.Content.ReadAsByteArrayAsync().GetAwaiter().GetResult(); var xml = Encoding.UTF8.GetString(result); var newOrder = (PurchaseOrderType)orderSerializer.Deserialize(new StringReader(xml)); repository.Add(newOrder); } // PUT /orders if (request.Method == HttpMethod.Put) { var result = request.Content.ReadAsByteArrayAsync().GetAwaiter().GetResult(); var xml = Encoding.UTF8.GetString(result); var orderToUpdate = (PurchaseOrderType)orderSerializer.Deserialize(new StringReader(xml)); repository.Update(orderToUpdate); } if (request.Method == HttpMethod.Get && !localPath.EndsWith("/orders") && !localPath.EndsWith("/orders/") && !localPath.EndsWith("shipped")) { // GET /orders/{id} var url = localPath; var id = url.Replace("/api/orders/", string.Empty); var order = repository.Get(id); orderSerializer.Serialize(stream, order); } var content = Encoding.UTF8.GetString(stream.GetBuffer()); content = content.Substring(content.IndexOf(Environment.NewLine) + 1); responseMessage.Content = new StringContent(content, Encoding.UTF8, "application/xml"); return Task.FromResult(responseMessage); }
public void ParseTracker() { var generator = new Generator(); generator.Settings.ContextNaming = ContextNaming.Preserve; generator.Settings.EntityNaming = EntityNaming.Singular; generator.Settings.RelationshipNaming = RelationshipNaming.ListSuffix; generator.Settings.TableNaming = TableNaming.Singular; var selector = GetDatabaseSchema("Tracker"); Assert.IsNotNull(selector); EntityContext entityContext = generator.Generate(selector); Assert.IsNotNull(entityContext); var settings = new XmlWriterSettings { Indent = true }; var serializer = new XmlSerializer(typeof(EntityContext)); using (var writer = XmlWriter.Create(@"..\..\Tracker.Generated.xml", settings)) serializer.Serialize(writer, entityContext); string contextDirectory = @"..\..\..\Tracker.Core"; string mappingDirectory = @"..\..\..\Tracker.Core\Mapping"; Synchronizer.UpdateFromSource(entityContext, contextDirectory, mappingDirectory); using (var writer = XmlWriter.Create(@"..\..\Tracker.Updated.xml", settings)) serializer.Serialize(writer, entityContext); }
/// <summary> /// Sessions the info to string. /// </summary> /// <param name="sessionInfo">The session info.</param> /// <returns></returns> public static string SessionInfoToString(SessionInfo sessionInfo) { if (sessionInfo == null) return null; StringBuilder sb = new StringBuilder(); StringWriter sw = new StringWriter(sb); XmlSerializer xml = new XmlSerializer(typeof(SessionInfo)); xml.Serialize(sw, sessionInfo); sw.Flush(); CryptoString cry = new CryptoString(_key, CryptoString.Method.Encrypt, sb.ToString()); string ret = cry.Execute(); sb.Remove(0, sb.Length); if (Regex.IsMatch(ret, @".*[Oo][Nn][a-zA-Z]*=*$")) { sessionInfo.ConnectionString += ';'; xml.Serialize(sw, sessionInfo); sw.Flush(); cry = new CryptoString(_key, CryptoString.Method.Encrypt, sb.ToString()); ret = cry.Execute(); } sw.Close(); return ret; }
public void Can_serialize_object() { var testObject = GetTestObject(); var xmlSerializer = new XmlSerializer<TestObject>(); Assert.DoesNotThrow(() =>xmlSerializer.Serialize(testObject)); var xPathNavigable = xmlSerializer.Serialize(testObject) as XmlDocument; Assert.That(xPathNavigable, Is.Not.Null); }
public void UpdateManufacturingSpec() { // [1] check xml exists // [2] deserialize xml file to a manufacturingDetail object // [3] update manufacturingDetail object with ManufacturingParamters objects // [4] serialize manufacturingDetail object char[] charsToTrim = { '{', '}' }; string fileName = this.GUID.Trim(charsToTrim) + ".xml"; if (!File.Exists(Location)) { Trace.TraceError("Error: " + Location + " not found!"); return; } if (!Directory.Exists(this.NewLocation)) Directory.CreateDirectory(this.NewLocation); if (ManufacturingParamters.Count() > 0) // update xml { XmlSerializer mfgDetails_Serializer = new XmlSerializer(typeof(Part.manufacturingDetails)); Part.manufacturingDetails mfdetail = Part.manufacturingDetails.Deserialize(Location); StringWriter sw = new StringWriter(); sw.NewLine = ""; mfgDetails_Serializer.Serialize(sw, mfdetail); string xmldatastring = sw.ToString(); try { foreach (KeyValuePair<string, string> item in ManufacturingParamters) { xmldatastring = ReplaceParameters(item.Key, item.Value, xmldatastring); } var strreader = new StringReader(xmldatastring); Part.manufacturingDetails mfdetails_revised = (Part.manufacturingDetails)mfgDetails_Serializer.Deserialize(strreader); if (!Directory.Exists(this.NewLocation)) Directory.CreateDirectory(this.NewLocation); StreamWriter myWriter = new StreamWriter(Path.Combine(this.NewLocation, fileName)); mfgDetails_Serializer.Serialize(myWriter, mfdetails_revised); Trace.TraceInformation("Info: Updated manufacturing xml with manufacturing parameter from model. " + this.NewLocation + "\\" + fileName); } catch (System.InvalidOperationException ex) { Console.WriteLine("Exception occured: {0}", ex.ToString()); } } else // copy the xml { File.Copy(Location, Path.Combine(this.NewLocation, fileName), true); Trace.TraceInformation("Info: Copied manufacturing xml. " + this.NewLocation + "\\" + fileName); } }
public void Test() { var serializer = new XmlSerializer(typeof(Quiz)); var quiz = new Quiz { Title = "Title", Id = "Id", Blocks = new SlideBlock[] { new MdBlock {Markdown = "This is quiz!"}, new IsTrueBlock { Id = "1", Text = "Это утверждение ложно", }, new ChoiceBlock { Text = "What is the \nbest color?", Items = new[] { new ChoiceItem {Id="1", Description = "black", IsCorrect = true}, new ChoiceItem {Id="2", Description = "green"}, new ChoiceItem {Id="3", Description = "red"}, } }, new ChoiceBlock { Multiple = true, Text = "What does the fox say?", Items = new[] { new ChoiceItem {Description = "Apapapapa", IsCorrect = true}, new ChoiceItem {Description = "Ding ding ding", IsCorrect = true}, new ChoiceItem {Description = "Mew"}, } }, new FillInBlock { Text = "What does the fox say?", Regexes = new[] {new RegexInfo {Pattern = "([Dd]ing )+"}, new RegexInfo {Pattern = "Ap(ap)+"}}, Sample = "Apapap" }, } }; var w1 = new StringWriter(); var ns = new XmlSerializerNamespaces(); ns.Add("x", "http://www.w3.org/2001/XMLSchema-instance"); serializer.Serialize(w1, quiz, ns); ApprovalTests.Approvals.Verify(w1.ToString()); Console.WriteLine(w1.ToString()); Console.WriteLine(); var quiz2 = serializer.Deserialize(new StringReader(w1.ToString())); var w2 = new StringWriter(); serializer.Serialize(w2, quiz2, ns); Console.WriteLine(w2.ToString()); Assert.AreEqual(w1.ToString(), w2.ToString()); }
public void FolderPollInitTest() { FolderPollConfig testConfig = new FolderPollConfig { Poll = new Poll[] { new Poll { Domain = "domain", Folder = @"C:\FolderPoll", Impersonation = true, Username = "******", Password = "******", NewFile = new NewFile { Filter = "*.txt", Copy = new NewFileCopy { TargetFolder = @"C:\FolderPoll" }, Move = new NewFileMove { TargetFolder = @"C:\FolderPoll" }, Launch = new NewFileLaunch { Application = @"C:\Windows\notepad.exe", Arguments = "{0}" } } } } }; var serializer = new XmlSerializer(typeof(FolderPollConfig)); TextWriter streamWriter = new StreamWriter(@"C:\FolderPoll\testConfig.xml"); serializer.Serialize(streamWriter, testConfig); streamWriter.Close(); XmlSerializerNamespaces ns = new XmlSerializerNamespaces(); ns.Add(string.Empty, string.Empty); StringWriter stringWriter = new StringWriter(); serializer.Serialize(stringWriter, testConfig, ns); stringWriter.GetStringBuilder().ToString(); var fileInitObject = new FolderPollService(); fileInitObject.Init(@"C:\FolderPoll\testConfig.xml", true); var stringInitObject = new FolderPollService(); stringInitObject.Init(stringWriter.GetStringBuilder().ToString(), false); var privateFileInit = new PrivateObject(fileInitObject); var privateStringInit = new PrivateObject(stringInitObject); Assert.IsNotNull(privateFileInit.GetField("folderPoll")); Assert.IsNotNull(privateStringInit.GetField("folderPoll")); }
public void WriteXml(XmlWriter writer) { XmlSerializer strSerializer = new XmlSerializer(typeof(string)); XmlSerializer epcSerializer = new XmlSerializer(typeof(EffectParamCategory)); Type paramType = Type.GetType(ValueTypeFullName); XmlSerializer objSerializer = new XmlSerializer(paramType); strSerializer.Serialize(writer, Name); epcSerializer.Serialize(writer, Category); strSerializer.Serialize(writer, ValueTypeFullName); objSerializer.Serialize(writer, Value); }
public static void Main(string[] args) { // If initial value is the same as DefaultValueAttribute for variable declaration, // it is not persisted by XmlSerializer. Clue clue = new Clue(); clue.text = "Nothing To See Here"; // Buffer for writing. StringBuilder buffer = new StringBuilder(); // Don't need namespaces. XmlSerializerNamespaces no_namespaces = new XmlSerializerNamespaces(); no_namespaces.Add(string.Empty, string.Empty); // Don't need xml declaration. XmlWriterSettings writer_settings = new XmlWriterSettings() { OmitXmlDeclaration = true }; // Serialise the clue... XmlSerializer xml_serializer = new XmlSerializer(typeof(Clue)); StringWriter string_writer = new StringWriter(buffer); using (XmlWriter xml_writer = XmlWriter.Create(string_writer, writer_settings)) { xml_serializer.Serialize(xml_writer, clue, no_namespaces); } string serialized = buffer.ToString(); // Show serialised version of the clue... Console.WriteLine("Clue text value: {0}", clue.text); Console.WriteLine("Clue serialized: {0}", serialized); // Deserialise the clue... Clue clue_read; using (StringReader sr = new StringReader(serialized)) { clue_read = (Clue)xml_serializer.Deserialize(sr); } // Show clue 2 on console // Reset and reuse write buffer. buffer.Length = 0; using (XmlWriter xml_writer = XmlWriter.Create(string_writer, writer_settings)) { xml_serializer.Serialize(xml_writer, clue_read, no_namespaces); } string reserialized = buffer.ToString(); Console.WriteLine("Read Clue text value: {0}", clue_read.text); Console.WriteLine("Read Clue serialized: {0}", reserialized); Debug.Assert(clue.text == clue_read.text, "Written & read clue's text should match"); }
void IXmlSerializable.WriteXml(XmlWriter writer) { XmlSerializer ss = new XmlSerializer(typeof(string)); writer.WriteStartElement("name"); ss.Serialize(writer, Name); writer.WriteEndElement(); writer.WriteStartElement("type"); ss.Serialize(writer, Value.GetType().AssemblyQualifiedName); writer.WriteEndElement(); writer.WriteStartElement("value"); new XmlSerializer(Value.GetType()).Serialize(writer, Value); writer.WriteEndElement(); }
private static void SerializationTest() { Person p1 = new Person() { Name = "Person 1", Age = 20 }; Person p2 = new Person() { Name = "Person 2", Age = 60 }; XmlSerializer serializer = new XmlSerializer(typeof(Person)); serializer.Serialize(Console.OpenStandardOutput(), p1); Console.WriteLine(); Console.WriteLine(); serializer.Serialize(Console.OpenStandardOutput(), p2); }
static void Main() { bool groups_directory_exist = false; bool subjects_directory_exist = false; DirectoryInfo current_dir_info = new DirectoryInfo(Environment.CurrentDirectory); foreach (DirectoryInfo cur_dir_info in current_dir_info.GetDirectories()) { if (cur_dir_info.Name == "all_subjects") { subjects_directory_exist = true; } if (cur_dir_info.Name == "all_groups") { groups_directory_exist = true; } } if (!subjects_directory_exist) { List<subject> test_list_of_subjects = new List<subject>(); test_list_of_subjects.Add(new subject("mathematics", new List<string> { "math_theme_1", "math_theme_2", "math_theme_3" })); test_list_of_subjects.Add(new subject("physics", new List<string> { "phys_theme_1", "phys_theme_2", "phys_theme_3" })); test_list_of_subjects.Add(new subject("biology", new List<string> { "bio_theme_1", "bio_theme_2", "bio_theme_3" })); Directory.CreateDirectory("all_subjects"); XmlSerializer serializer_for_subjects = new XmlSerializer(typeof(List<subject>)); FileStream stream_to_subjects = new FileStream(@"all_subjects\all_subjects.xml", FileMode.Create, FileAccess.Write); serializer_for_subjects.Serialize(stream_to_subjects, test_list_of_subjects); stream_to_subjects.Close(); } if (!groups_directory_exist) { group test_group = new group("TEST_GROUP_1", new List<student> {new student("first_student_1"), new student("second_student_1"),new student("third_student_1")}); group test_group_2 = new group("TEST_GROUP_2", new List<student> {new student("first_student_2"), new student("second_student_2"),new student("third_student_2")}); Directory.CreateDirectory(@"all_groups\" + test_group.name_of_group + @"\all_lessons"); Directory.CreateDirectory(@"all_groups\" + test_group_2.name_of_group + @"\all_lessons"); FileStream stream_to_groups = new FileStream(@"all_groups\" + test_group.name_of_group + @"\" + test_group.name_of_group + ".xml", FileMode.Create, FileAccess.Write); XmlSerializer serializer_for_groups = new XmlSerializer(typeof(group)); serializer_for_groups.Serialize(stream_to_groups, test_group); stream_to_groups.Close(); FileStream stream_to_groups_2 = new FileStream(@"all_groups\" + test_group_2.name_of_group + @"\" + test_group_2.name_of_group + ".xml", FileMode.Create, FileAccess.Write); serializer_for_groups.Serialize(stream_to_groups_2, test_group_2); stream_to_groups_2.Close(); } Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new Form1()); }
private static void ConvertObjectToXml(PhoneBook phoneBook) { XmlSerializer xmlSerializer = new XmlSerializer(typeof(PhoneBook)); // it's better to use Form.GetType() for generics // save to file on the hard drive StreamWriter streamWriter = new StreamWriter("XML/PhoneBookRecreated.xml"); xmlSerializer.Serialize(streamWriter, phoneBook); // example how to convert to string, instead of file (for debug purposes) using (StringWriter stringWriter = new StringWriter()) { xmlSerializer.Serialize(stringWriter, phoneBook); string s = stringWriter.ToString(); } }
/// <summary> /// Test whether the constraint is satisfied by a given value /// </summary> /// <param name="actual">The value to be tested</param> /// <returns>True for success, false for failure</returns> public override bool Matches(object actual) { this.actual = actual; if(actual == null) throw new ArgumentException(); MemoryStream stream = new MemoryStream(); try { serializer = new XmlSerializer(actual.GetType()); serializer.Serialize(stream, actual); stream.Seek(0, SeekOrigin.Begin); object value = serializer.Deserialize(stream); return value != null; } catch (NotSupportedException) { return false; } catch (InvalidOperationException) { return false; } }
private void MediaProfilesTreeViewInit() { XmlSerializer serialization = new XmlSerializer(mediaProfiles.GetType()); MemoryStream memory = new MemoryStream(); try { serialization.Serialize(memory, mediaProfiles); memory.Seek(0, System.IO.SeekOrigin.Begin); XmlDocument xml = new XmlDocument(); xml.Load(memory); MediaProfilesTreeView.Nodes.Clear(); MediaProfilesTreeView.Nodes.Add(new TreeNode(xml.DocumentElement.Name)); TreeNode node = new TreeNode(); node = MediaProfilesTreeView.Nodes[0]; AddNode(xml.DocumentElement, node); MediaProfilesTreeView.ExpandAll(); } catch (XmlException ex) { MessageBox.Show(ex.Message); } catch (Exception ex) { MessageBox.Show(ex.Message); } finally { memory.Close(); } }
public static void Serialization1(Human human) { XmlSerializer serializer = new XmlSerializer(typeof(Human)); StringBuilder sb = new StringBuilder(); /* SERIALIZATION */ using (StringWriter writer = new StringWriter(sb)) { serializer.Serialize(writer, human); } // XML file //Console.WriteLine("SB: " +sb.ToString()); /* END SERIALIZATION */ /* DESERIALIZATION */ Human newMartin = new Human(); using (StringReader reader = new StringReader(sb.ToString())) { newMartin = serializer.Deserialize(reader) as Human; } Console.WriteLine(newMartin.ToString() + Environment.NewLine); /* END DESERIALIZATION */ }
/// <summary> /// Analyzes website and creates XML document /// </summary> /// <param name="config">Website's config</param> /// <returns> /// Updated website's config /// </returns> public WebsiteModel AnalyzeWebsite(WebsiteModel config) { CrawlerHelper crawlHelper = new CrawlerHelper(); OrganizerHelper orgHelper = new OrganizerHelper(); config.OrganizerConfig = new OrganizerModel(); config.ExportConfig = new ExportModel(); config.ExportConfig.Xml = string.Empty; var crawler = crawlHelper.ConfigureCrawler(config.CrawlerConfig); var list = crawler.Crawl(); var analyzer = new WebsiteAnalyzer(config.AnalyzerConfig); var analyticsRunner = new AnalyticsRunner(crawler, analyzer); var site = analyticsRunner.Run(list); site.Name = config.Name; using (var sw = new StringWriter()) { var serializer = new XmlSerializer(typeof(Site)); serializer.Serialize(sw, site); config.ExportConfig.Xml = sw.ToString(); } config.OrganizerConfig.Pages = orgHelper.AddChildren(site.Root, site); return config; }
public static string Serialize(MaterialList mats) { StringWriter sw = new StringWriter(); XmlSerializer ser = new XmlSerializer(typeof(MaterialList)); ser.Serialize(sw, mats); return sw.ToString(); }
public void Convert(string inputFileName, string outputFileName) { var deser = new XmlSerializer(typeof(Song)); Song zigSong; using (FileStream stream = new FileStream(inputFileName, FileMode.Open)) { zigSong = (Song)deser.Deserialize(stream); } var guitarTrack = GetTrack(zigSong); if (guitarTrack == null) { throw new Exception("Couldn't find a guitar track"); } var rsSong = new RsSong(); AddSongMetadata(rsSong, zigSong); AddEbeats(rsSong, zigSong); AddNotes(rsSong, zigSong); deser = new XmlSerializer(typeof(RsSong)); using (FileStream stream = new FileStream(outputFileName, FileMode.Create)) { deser.Serialize(stream, rsSong); } }
public static void ConvertObjectToXml(object obj, string path_to_xml) { //serialize and persist it to it's file FileStream fs = null; try { XmlSerializer ser = new XmlSerializer(obj.GetType()); new FileInfo(path_to_xml).Directory.Create(); fs = File.Open( path_to_xml, FileMode.Create, FileAccess.Write, FileShare.ReadWrite); ser.Serialize(fs, obj); } catch (Exception ex) { throw new Exception( "Could Not Serialize object to " + path_to_xml, ex); } finally { fs.Close(); } }
public override void SaveToDataStore(BlogEngine.Core.DataStore.ExtensionType exType, string exId, object settings) { XmlSerializer xs = new XmlSerializer(settings.GetType()); string objectXML = string.Empty; using (StringWriter sw = new StringWriter()) { xs.Serialize(sw, settings); objectXML = sw.ToString(); } using (var mongo = new MongoDbWr()) { var coll = mongo.BlogDB.GetCollection("DataStoreSettings"); Document spec = new Document(); spec["ExtensionType"] = exType; spec["ExtensionId"] = exId; var res = new Document(); res["Settings"] = objectXML; res["ExtensionType"] = exType; res["ExtensionId"] = exId; coll.Update(res, spec, UpdateFlags.Upsert); } }
public void SerializeObject(string path, SerializableObject objToSerialize) { FileStream fstream = File.Open(path, FileMode.Create); XmlSerializer formatter = new XmlSerializer(typeof(SerializableObject)); formatter.Serialize(fstream, objToSerialize); fstream.Close(); }
public bool Save() { IAmazonResponse amazonResponse = amazonFactory.GetResponse(); XmlSerializer serializer; TextWriter writer; try { if (amazonResponse.Errors.Count != 0) { serializer = new XmlSerializer(typeof (List<string>)); writer = new StreamWriter(fileParameters.ErrorFileNameAndPath); serializer.Serialize(writer, amazonResponse.Errors); writer.Close(); } serializer = new XmlSerializer(typeof (List<Review>)); writer = new StreamWriter(fileParameters.ReviewFileNameAndPath); serializer.Serialize(writer, amazonResponse.Reviews); writer.Close(); serializer = new XmlSerializer(typeof (List<Product>)); writer = new StreamWriter(fileParameters.ProductFileNameAndPath); serializer.Serialize(writer, amazonResponse.Products); writer.Close(); } catch { return false; } return true; }
public void Save() { var serializer = new XmlSerializer(typeof(Project)); var writer = new StreamWriter(GetPath(),false, Encoding.UTF8); serializer.Serialize(writer, this); writer.Close(); }
/// <summary> /// this is something that didnt work out for me but im going to keep it here until we know that we arent going to use it /// </summary> /// <param name="tree"></param> public static void SerializeToXML(Tree tree) { XmlSerializer serializer = new XmlSerializer(typeof(Tree)); TextWriter textWriter = new StreamWriter(@"C:\Users\Chris\Desktop\xmlSerializer.xml"); serializer.Serialize(textWriter, tree); textWriter.Close(); }
public static void SendFileInfo() { // Получаем тип и расширение файла fileDet.FILETYPE = fs.Name.Substring((int)fs.Name.Length - 3, 3); // Получаем длину файла fileDet.FILESIZE = fs.Length; XmlSerializer fileSerializer = new XmlSerializer(typeof(FileDetails)); MemoryStream stream = new MemoryStream(); // Сериализуем объект fileSerializer.Serialize(stream, fileDet); // Считываем поток в байты stream.Position = 0; Byte[] bytes = new Byte[stream.Length]; stream.Read(bytes, 0, Convert.ToInt32(stream.Length)); Console.WriteLine("Отправка деталей файла..."); // Отправляем информацию о файле sender.Send(bytes, bytes.Length, endPoint); stream.Close(); }
public override bool Execute() { Log.LogMessage( MessageImportance.Low, "Packing M-Files Application." ); // Make sure the collections are never null. References = References ?? new ITaskItem[ 0 ]; SourceFiles = SourceFiles ?? new ITaskItem[ 0 ]; DefaultEnvironments = DefaultEnvironments ?? new string[ 0 ]; // Create the application package contents. var references = References.Select( item => new Reference( item ) ).ToList(); var files = SourceFiles.Select( item => new PackageFile( item ) ).ToList(); var appDef = CreateApplicationDefinition( references, files ); var outputZip = CreatePackage( references, files ); // Serialize the application definition file. var stream = new MemoryStream(); var serializer = new XmlSerializer( typeof( ApplicationDefinition ) ); serializer.Serialize( stream, appDef ); stream.Flush(); stream.Position = 0; outputZip.AddEntry( "appdef.xml", stream ); // Save the zip. outputZip.Save(); return true; }
public override int Run(string[] args) { string schemaFileName = args[0]; string outschemaFileName = args[1]; XmlTextReader xr = new XmlTextReader(schemaFileName); SchemaInfo schemaInfo = SchemaManager.ReadAndValidateSchema(xr, Path.GetDirectoryName(schemaFileName)); schemaInfo.Includes.Clear(); schemaInfo.Classes.Sort(CompareNames); schemaInfo.Relations.Sort(CompareNames); XmlSerializer ser = new XmlSerializer(typeof(SchemaInfo)); XmlSerializerNamespaces ns = new XmlSerializerNamespaces(); ns.Add("", SchemaInfo.XmlNamespace); using (FileStream fs = File.Create(outschemaFileName)) { try { ser.Serialize(fs, schemaInfo, ns); } finally { fs.Flush(); fs.Close(); } } return 0; }
/// <summary> /// XML Representation of this object /// </summary> /// <returns>XML String</returns> public string ToXML() { StringBuilder xml = new StringBuilder(1024); System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(this.GetType()); using (StringWriter sw = new StringWriter(xml)) { serializer.Serialize(sw, this); } return(xml.ToString()); }
void saveBasePosList() { // save config System.Xml.Serialization.XmlSerializer writer = new System.Xml.Serialization.XmlSerializer(typeof(List <PointLatLngAlt>), new Type[] { typeof(Color) }); using (StreamWriter sw = new StreamWriter(basepostlistfile)) { writer.Serialize(sw, baseposList); } }
public static String SerializeObject(Object pObject, Type type) { String XmlizedString = null; System.IO.MemoryStream memoryStream = new System.IO.MemoryStream(); System.Xml.Serialization.XmlSerializer xs = new System.Xml.Serialization.XmlSerializer(type); System.Xml.XmlTextWriter xmlTextWriter = new System.Xml.XmlTextWriter(memoryStream, Encoding.UTF8); xs.Serialize(xmlTextWriter, pObject); memoryStream = (System.IO.MemoryStream)xmlTextWriter.BaseStream; XmlizedString = YellowstonePathology.YpiConnect.Client.Helper.SerializationHelper.UTF8ByteArrayToString(memoryStream.ToArray()); return(XmlizedString.Substring(1, XmlizedString.Length - 1)); }
/// <summary> /// 创建XML /// </summary> /// <param name="savePath">保存路径</param> /// <param name="targetObjcet">要储存的对象</param> /// <param name="targetType">类型</param> /// <param name="xmlRootName">根节点名称</param> public void CreateXml(string savePath, object targetObjcet, Type targetType, string xmlRootName) { if (!string.IsNullOrEmpty(savePath) && targetObjcet != null) { targetType = targetType ?? targetObjcet.GetType(); using (StreamWriter writer = new StreamWriter(savePath)) { System.Xml.Serialization.XmlSerializer xmlSerializer = string.IsNullOrEmpty(xmlRootName) ? new System.Xml.Serialization.XmlSerializer(targetType) : new System.Xml.Serialization.XmlSerializer(targetType, new XmlRootAttribute(xmlRootName)); xmlSerializer.Serialize(writer, targetObjcet); } } }
/// <summary> /// Serialize the object as XML /// </summary> /// <param name="obj">Object to serialize</param> /// <returns>XML as string</returns> public string Serialize <T>(object obj) { var ns = new XmlSerializerNamespaces(); ns.Add(string.Empty, Namespace); var serializer = new System.Xml.Serialization.XmlSerializer(typeof(T), STNXmlSerializerCodec.extraTypes); var writer = new EncodingStringWriter(Encoding); serializer.Serialize(writer, obj, ns); return(writer.ToString()); }
/* * public MIGServiceConfiguration.Interface GetInterface(string domain) * { * MIGServiceConfiguration.Interface res = MIGService.Interfaces.Find(i => i.Domain == domain); * return res; * } * * public MIGServiceConfiguration.Interface.Option GetInterfaceOption(string domain, string option) * { * return GetInterfaceOptions(domain).Find(o => o.Name == option); * } * * public List<MIGServiceConfiguration.Interface.Option> GetInterfaceOptions(string domain) * { * MIGServiceConfiguration.Interface mi = MIGService.Interfaces.Find(i => i.Domain == domain); * return mi.Options; * } */ public bool Update() { bool success = false; try { SystemConfiguration syscopy = (SystemConfiguration)this.Clone(); foreach (ModuleParameter p in syscopy.HomeGenie.Settings) { try { if (!String.IsNullOrEmpty(p.Value)) { p.Value = StringCipher.Encrypt(p.Value, GetPassPhrase()); } if (!String.IsNullOrEmpty(p.LastValue)) { p.LastValue = StringCipher.Encrypt( p.LastValue, GetPassPhrase() ); } } catch { } } string fname = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "systemconfig.xml"); if (File.Exists(fname)) { File.Delete(fname); } System.Xml.XmlWriterSettings ws = new System.Xml.XmlWriterSettings(); ws.Indent = true; System.Xml.Serialization.XmlSerializer x = new System.Xml.Serialization.XmlSerializer(syscopy.GetType()); System.Xml.XmlWriter wri = System.Xml.XmlWriter.Create(fname, ws); x.Serialize(wri, syscopy); wri.Close(); success = true; } catch (Exception) { } // if (OnUpdate != null) { OnUpdate(success); } // return(success); }
public static String SerializeObject <T>(T o) { String XmlizedString = null; System.IO.MemoryStream memoryStream = new System.IO.MemoryStream(); System.Xml.Serialization.XmlSerializer xs = new System.Xml.Serialization.XmlSerializer(typeof(T)); System.Xml.XmlTextWriter xmlTextWriter = new System.Xml.XmlTextWriter(memoryStream, Encoding.UTF8); xs.Serialize(xmlTextWriter, o); memoryStream = (System.IO.MemoryStream)xmlTextWriter.BaseStream; XmlizedString = UTF8ByteArrayToString(memoryStream.ToArray()); return(XmlizedString.Substring(1, XmlizedString.Length - 1)); }
public static void WriteLogEntryToClusterDirectory(ClusterSubmitterArgs clusterArgs) { string directory = clusterArgs.ExternalRemoteDirectoryName; string filename = LogEntryFileName(clusterArgs.Name); LogEntry logEntry = new LogEntry(clusterArgs); System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(LogEntry)); using (var writer = File.Create(directory + "\\" + filename)) { serializer.Serialize(writer, logEntry); } }
public static void WriteXML(ListOfDoctors docs) { System.Xml.Serialization.XmlSerializer writer = new System.Xml.Serialization.XmlSerializer(typeof(ListOfDoctors)); var path = Environment.CurrentDirectory + "//SerializationOverview.xml"; System.IO.FileStream file = System.IO.File.Create(path); writer.Serialize(file, docs); file.Close(); }
/// <summary> /// Serialize the object as XML /// </summary> /// <param name="obj">Object to serialize</param> /// <returns>XML as string</returns> public string Serialize(object obj) { var ns = new XmlSerializerNamespaces(); ns.Add(string.Empty, Namespace); var serializer = new System.Xml.Serialization.XmlSerializer(obj.GetType()); var writer = new EncodingStringWriter(Encoding); serializer.Serialize(writer, obj, ns); return(writer.ToString()); }
public static string Serialize(object obj) { using (var sww = new StringWriter()) { var xml = new System.Xml.Serialization.XmlSerializer(obj.GetType()); xml.Serialize(sww, obj); var xmlString = sww.ToString(); xmlString = xmlString.Replace("\"", Quota); return(xmlString); } }
/// <summary> /// xml序列成字符串 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="entity"></param> /// <returns></returns> public static string XMLSerialize <T>(T entity) { StringBuilder buffer = new StringBuilder(); System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(T)); using (TextWriter writer = new StringWriter(buffer)) { serializer.Serialize(writer, entity); } return(buffer.ToString()); }
/// <summary> /// Serialize object to XElement. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="obj">Object to serialize.</param> /// <returns></returns> public static XElement ToXElement <T>(T obj) { using (var memoryStream = new MemoryStream()) { using (TextWriter streamWriter = new StreamWriter(memoryStream)) { var xmlSerializer = new XmlSer.XmlSerializer(typeof(T)); xmlSerializer.Serialize(streamWriter, obj); return(XElement.Parse(Encoding.UTF8.GetString(memoryStream.ToArray()))); } } }
public string Serialize(TModel model) { XmlSerializer xmlSerializer = new XmlSerializer(type); using (TextWriter textWriter = new StringWriter()) { xmlSerializer.Serialize(textWriter, model); String result = textWriter.ToString(); return(result); } }
static public Stream ToKml(IFeatureCursor cursor, int maxFeatures) { KmlType kml = new KmlType(); DocumentType document = new DocumentType(); kml.Item = document; int counter = 0; IFeature feature = null; List <PlacemarkType> placemarks = new List <PlacemarkType>(); while ((feature = cursor.NextFeature) != null) { if (feature.Shape == null) { continue; } PlacemarkType placemark = new PlacemarkType(); placemark.Item_ = ToKml(feature.Shape); placemarks.Add(placemark); counter++; if (counter >= maxFeatures) { break; } } document.Items_ = placemarks.ToArray(); #region Serialize System.Xml.Serialization.XmlSerializerNamespaces namespaces = new System.Xml.Serialization.XmlSerializerNamespaces(); //namespaces.Add("wps", "http://www.opengis.net/wps/1.0.0"); //namespaces.Add("ows", "http://www.opengis.net/ows/1.1"); //namespaces.Add("xlink", "http://www.w3.org/1999/xlink"); //namespaces.Add("xsi", "http://www.w3.org/2001/XMLSchema-instance"); MemoryStream ms = new MemoryStream(); XmlSerializer ser = new System.Xml.Serialization.XmlSerializer(kml.GetType()); ser.Serialize(ms, kml, namespaces); ms.Position = 0; return(ms); //byte[] bytes = new byte[ms.Length]; //ms.Position = 0; //ms.Read(bytes, 0, (int)ms.Length); //return System.Text.Encoding.UTF8.GetString(bytes); #endregion }
public void WriteXML() { System.Xml.Serialization.XmlSerializer writer = new System.Xml.Serialization.XmlSerializer(typeof(OrderDetails)); var path = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + "//SerializationOverview.xml"; System.IO.FileStream file = System.IO.File.Create(path); writer.Serialize(file, this); file.Close(); }
/// <summary> /// This methods creates xml for this control or those inheriting it. /// </summary> /// <param name="type">the type of the control you want to serialize</param> /// <returns>The XML Text</returns> public static string SerializeToXML(object obj, Type type) { var result = new StringBuilder(); using (System.IO.StringWriter sw = new StringWriter(result)) { System.Xml.Serialization.XmlSerializer x = new System.Xml.Serialization.XmlSerializer(type); x.Serialize(sw, obj); } return(result.ToString()); }
/// <summary> /// Serializes the self. /// </summary> /// <param name="filePath">File path.</param> public void SerializeSelf(string filePath) { System.Xml.XmlDocument doc = new System.Xml.XmlDocument(); System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(this.GetType()); using (System.IO.MemoryStream stream = new System.IO.MemoryStream()) { serializer.Serialize(stream, this); stream.Position = 0; doc.Load(stream); doc.Save(filePath); } }
public static void WriteXml() { //var testSale = new SalesAggregated() { VendorName = "test vendor", Date = DateTime.Now, TotalSum = 23 }; var overview = new Book("Serialization Overview"); var writer = new System.Xml.Serialization.XmlSerializer(typeof(SalesAggregated)); var file = new System.IO.StreamWriter( @"c:\temp\SerializationOverview.xml"); writer.Serialize(file, overview); file.Close(); }
public void SavePlayer() { System.Xml.Serialization.XmlSerializer writer = new System.Xml.Serialization.XmlSerializer(typeof(PlayerInfo)); var path = "PlayerSave" + ".xml"; System.IO.FileStream file = System.IO.File.Create(path); PlayerInfo pi = new PlayerInfo(Goods, Money); writer.Serialize(file, pi); file.Close(); }
public static void SaveAll(List <LocalSettings> settings, string filename) { string asmPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); string settingsPath = Path.Combine(asmPath, filename); System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(List <LocalSettings>)); using (TextWriter writer = File.CreateText(settingsPath)) { serializer.Serialize(writer, settings); } }
public static string SerializeObject(object obj) { System.Xml.XmlDocument xmlDoc = new System.Xml.XmlDocument(); System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(obj.GetType()); using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { serializer.Serialize(ms, obj); ms.Position = 0; xmlDoc.Load(ms); return(xmlDoc.InnerXml); } }
public static void SerializeToFile <T>(T info, string fileFullName) { if (info == null) { return; } using (XmlWriter writer = XmlWriter.Create(fileFullName)) { System.Xml.Serialization.XmlSerializer xmlSerializer = new System.Xml.Serialization.XmlSerializer(info.GetType()); xmlSerializer.Serialize(writer, info); } }
public void TestMethod1() { file_path = "simple_svr_one_row_one_test.xls"; full_path = obtain_test_path(file_path); Assert.IsTrue(new FileInfo(full_path).Exists); // загрузка книги svr mc21.svr_viewer.Excel.Load_SVR loaded_svr = new svr_viewer.Excel.Load_SVR(full_path); // в книге svr должно быть 14 листов Assert.AreEqual(14, loaded_svr.Worksheets.Count); // загрузка данных svr foreach (System.Data.DataTable dt in loaded_svr.Worksheets) { m.Fill_Model(dt); } // получение статистики по данным svr m.Obtain_Statictics(); // инициализация фильтров // число позиций в модели должно быть равно 6 Assert.AreEqual(6, m.Positions.Count); // инициализация вью модели отображения SVR vm_dysplay_svr = new svr_viewer.ViewModel.Dysplay_SVR_View_Model.Dysplay_SVR_View_Model(); // число позиций во вьюмодели должно быть равно 6 Assert.AreEqual(6, vm_dysplay_svr.Query_Dysplay_Checkboxes_Positions.Count); // после инициализации фильтров все позиции должын быть включены bool isPositionCheckBoxesTurnON = true; foreach (mc21.svr_viewer.ViewModel.Checkbox checkbox in vm_dysplay_svr.Query_Dysplay_Checkboxes_Positions) { if (checkbox.isChecked == false) { isPositionCheckBoxesTurnON = false; } break; } Assert.IsTrue(isPositionCheckBoxesTurnON); // число вариантов результатов выполнения должно быть равно 3 Assert.AreEqual(3, vm_dysplay_svr.Query_Dysplay_Checkboxes_Results.Count); System.Xml.Serialization.XmlSerializer ser = new System.Xml.Serialization.XmlSerializer(typeof(mc21.svr_viewer.ViewModel.Main_ViewModel)); TextWriter tw = new StreamWriter("blend_data_1.xml"); ser.Serialize(tw, vm); tw.Close(); }
public static XElement SerializeToElement <T>(T o) { String XmlizedString = null; System.IO.MemoryStream memoryStream = new System.IO.MemoryStream(); System.Xml.Serialization.XmlSerializer xs = new System.Xml.Serialization.XmlSerializer(o.GetType()); System.Xml.XmlTextWriter xmlTextWriter = new System.Xml.XmlTextWriter(memoryStream, Encoding.UTF8); xs.Serialize(xmlTextWriter, o); memoryStream = (System.IO.MemoryStream)xmlTextWriter.BaseStream; XmlizedString = UTF8ByteArrayToString(memoryStream.ToArray()); return(XElement.Parse(XmlizedString.Substring(1, XmlizedString.Length - 1))); }
public void Serialize() { System.Xml.Serialization.XmlSerializer xs = new System.Xml.Serialization.XmlSerializer(this.GetType()); StreamWriter writer = File.CreateText(file); xs.Serialize(writer, this); writer.Flush(); writer.Close(); Logger.Log("Configuration saved"); }
static void SaveFileFilterGroupToFile(string saveFilePath, FileFilterGroup filterGroup) { System.Xml.Serialization.XmlSerializer x = new System.Xml.Serialization.XmlSerializer(typeof(FileFilterGroup)); saveFilePath = saveFilePath.Replace("\\", "/"); System.IO.TextWriter writer = new System.IO.StreamWriter(saveFilePath); x.Serialize(writer, filterGroup); writer.Close(); Debug.Log("Build Report Tool: Saved File Filter Group at \"" + saveFilePath + "\""); }
/// <summary> /// 指定したファイルパスへシリアライズします。 /// </summary> /// <typeparam name="T">自分自身の型</typeparam> /// <param name="self">自分自身</param> /// <param name="extraTypes"> /// シリアル化する追加のオブジェクト型の Type 配列。<para/> /// シリアル化したい型を設定すると、<see cref="object"/> 型のデータをシリアライズします。 /// </param> /// <param name="filePath">出力先ファイルパス</param> public static void Serialize <T>(this T self, string filePath, params Type[] extraTypes) { var directory = Path.GetDirectoryName(filePath); FileUtility.CreateDirectory(directory); using (var fs = new FileStream(filePath, FileMode.Create)) { var serializer = new System.Xml.Serialization.XmlSerializer(typeof(T), extraTypes); serializer.Serialize(fs, self); } }
public string SerializeToXml <T>(T obj) { System.Xml.Serialization.XmlSerializer xmlSerializer = new System.Xml.Serialization.XmlSerializer(typeof(T)); using (var writer = new StringWriter()) using (var xmlWriter = XmlWriter.Create(writer, new XmlWriterSettings { Indent = true })) { xmlSerializer.Serialize(xmlWriter, obj, null); return(writer.ToString()); } }
public static void SaveSoftwares(List <software> list) { System.Xml.Serialization.XmlSerializer writer = new System.Xml.Serialization.XmlSerializer(typeof(List <software>), new Type[] { typeof(software) }); using ( StreamWriter sw = new StreamWriter(Application.StartupPath + Path.DirectorySeparatorChar + "fwversions.xml")) { writer.Serialize(sw, list); } }