| public Serialize ( Stream stream, object o ) : void | ||
| stream | Stream | |
| o | object | |
| return | void | |
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);
}
/// <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;
}
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();
}
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);
}
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);
}
}
}
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 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 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 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");
}
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);
}
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();
}
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();
}
}
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;
}
/// <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 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 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 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;
}
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 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 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 */
}
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 string Serialize(MaterialList mats)
{
StringWriter sw = new StringWriter();
XmlSerializer ser = new XmlSerializer(typeof(MaterialList));
ser.Serialize(sw, mats);
return sw.ToString();
}
/// <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 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 void Save()
{
var serializer = new XmlSerializer(typeof(Project));
var writer = new StreamWriter(GetPath(),false, Encoding.UTF8);
serializer.Serialize(writer, this);
writer.Close();
}
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>
/// 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;
}
}
