public void LoadStoredPositions()
{
XmlSerializer serializer = new XmlSerializer(typeof(SavedItem[]));
for(int i = 0; i < 14; i++)
{
XmlReader reader = new XmlTextReader(Application.dataPath + "/_XML/StoreObj/" + "StoreObj" + i + ".xml");
if (serializer.CanDeserialize(reader))
{
SavedItem[] storeObject = (SavedItem[])serializer.Deserialize(reader);
_target._storedPositions[i]._savedItems = storeObject;
}
}
}
public static T getConfig <T>(string Path) where T : class
{
string xmlPath = $"{AppDomain.CurrentDomain.BaseDirectory}config\\{Path}";
if (File.Exists(xmlPath))
{
return(new RuntimeCache().GetOrAdd(Path, () =>
{
T result = default(T);
XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));
XmlReader xmlReader = XmlReader.Create(xmlPath);
if (xmlSerializer.CanDeserialize(xmlReader))
{
object obj = xmlSerializer.Deserialize(xmlReader);
result = obj as T;
}
xmlReader.Close();
return result;
}, new string[] { xmlPath }));
}
return(default(T));
}
public static T DeSerializeObject <T>(string xmlData = "", string filePath = "")
{
T deSerializeObject = default(T);
if (!String.IsNullOrEmpty(filePath))
{
xmlData = File.ReadAllText(filePath);
}
XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));
StringReader stringReader = new StringReader(xmlData);
XmlReader XR = new XmlTextReader(stringReader);
if (xmlSerializer.CanDeserialize(XR))
{
deSerializeObject = (T)xmlSerializer.Deserialize(XR);
}
return(deSerializeObject);
}
public T İceAktar <T>(T kisiler)
{
try
{
XmlSerializer xmlserializer = new XmlSerializer(typeof(T));
XmlReader reader = new XmlTextReader($@"..\..\Xml\{kisiler.ToString().Substring(33)}.xml");
if (xmlserializer.CanDeserialize(reader))
{
kisiler = (T)xmlserializer.Deserialize(reader);
reader.Close();
reader.Dispose();
}
else
{
MessageBox.Show("Lutfen dogru bir xml dosyasını seciniz");
}
}
catch (FileNotFoundException) { return(kisiler); }
catch (Exception ex) { throw ex; }
return(kisiler);
}
private async Task <T> GetXmlDataAsync <T>(string url, params KeyValuePair <string, string>[] parameters)
{
var content = new HttpFormUrlEncodedContent(parameters);
var res = await _HttpClient.PostAsync(new Uri(url), content);
if (res.IsSuccessStatusCode)
{
var alertstatusRes = await res.Content.ReadAsStringAsync();
var serializer = new XmlSerializer(typeof(T));
using (var textReader = System.Xml.XmlReader.Create(new System.IO.StringReader(alertstatusRes)))
{
if (serializer.CanDeserialize(textReader))
{
return((T)serializer.Deserialize(textReader));
}
}
}
return(default(T));
}
public static void ApplyNameLists()
{
XmlSerializer serializer = new XmlSerializer(typeof(NameList));
foreach (string nameListFile in
from pluginInfo in Singleton <PluginManager> .instance.GetPluginsInfo()
where pluginInfo.isEnabled
from file in Directory.GetFiles(pluginInfo.modPath, NameListSearchPattern, SearchOption.AllDirectories)
select file)
{
using (XmlReader stream = XmlReader.Create(nameListFile))
{
if (serializer.CanDeserialize(stream))
{
NameList nameList = (NameList)serializer.Deserialize(stream);
nameList.Apply();
}
}
}
Log("Namelists applied.");
}
public Window1()
{
this.InitializeComponent();
ViewModel.Converter vm = (ViewModel.Converter) this.FindResource("vm");
vm.PlainText = Settings.Default.InputText;
try
{
if (!string.IsNullOrEmpty(Settings.Default.SettingsXml))
{
XmlReader reader = XmlReader.Create(new StringReader(Settings.Default.SettingsXml));
if (settingsSerialiser.CanDeserialize(reader))
{
vm.Settings = (ConversionSettings)settingsSerialiser.Deserialize(reader);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public object ToModel(Type type)
{
try
{
XmlSerializer serializer = new XmlSerializer(type);
XmlReader xmlReader = XmlReader.Create(file);
if (serializer.CanDeserialize(xmlReader))
{
var des = serializer.Deserialize(xmlReader);
xmlReader.Dispose();
return(des);
}
else
{
return(null);
}
}
catch
{
return(null);
}
}
/// <summary>
/// Makes a HTTP/HTTPS request and returns the result in a deserialized object.
/// </summary>
/// <param name="types">
/// An array of <see cref="Type"/> to be used for deserialization. If the first types fails, we will try the
/// second and so on, until a compatible type is found or the array has been completely parsed.
/// </param>
/// <returns>
/// A <see cref="System.Object"/> containing the response deserialized to the specified type.
/// </returns>
/// <exception cref="ArgumentException">The array is empty.</exception>
/// <exception cref="XmlException">No compatible type found.</exception>
public object GetResponseObject(Type[] types)
{
int len = types.Length;
if (len == 0)
{
throw new ArgumentException("The array must contain at least one type", "types");
}
XmlReader xr = GetResponseXml();
for (int i = 0; i < len; i++)
{
XmlSerializer ser = new XmlSerializer(types[i]);
if (ser.CanDeserialize(xr))
{
return(ser.Deserialize(xr));
}
}
throw new XmlException("No compatible type found");
}
private void içeriAktarToolStripMenuItem_Click(object sender, EventArgs e)
{
dosyaAc.Title = "Bir XML dosyası seçiniz";
dosyaAc.Filter = "(XML Dosyası) | *.xml";
dosyaAc.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
dosyaAc.FileName = "Kisiler.xml";
if (dosyaAc.ShowDialog() == DialogResult.OK)
{
XmlSerializer xmlSerializer = new XmlSerializer(typeof(List <Kisi>));
XmlReader reader = new XmlTextReader(dosyaAc.FileName);
if (xmlSerializer.CanDeserialize(reader))
{
kisiler = xmlSerializer.Deserialize(reader) as List <Kisi>;
MessageBox.Show($"{kisiler.Count} kisi sisteme basariyla eklendi");
lstKisiler.Items.AddRange(kisiler.ToArray());
}
else
{
MessageBox.Show("Lutfen dogru xml dosyasini seciniz");
}
}
}
/// <summary>
/// XML Deserialize
/// </summary>
/// <param name="xmlString">Set XML string</param>
/// <returns></returns>
public static ImageBlendingBitmapFilterData XmlDeserialize(string xmlString)
{
XmlSerializer xmlSerializer = new XmlSerializer(typeof(ImageBlendingBitmapFilterData));
MemoryStream memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(xmlString));
XmlReader xmlReader = XmlReader.Create(memoryStream);
ImageBlendingBitmapFilterData filterData = null;
if (xmlSerializer.CanDeserialize(xmlReader) == true)
{
xmlReader.Close();
memoryStream.Position = 0;
filterData = (ImageBlendingBitmapFilterData)xmlSerializer.Deserialize(memoryStream);
}
memoryStream.Close();
memoryStream.Dispose();
return(filterData);
}
private Expense ReadExpenseFromXml(string xml)
{
if (string.IsNullOrEmpty(xml))
{
return(null);
}
using (var reader = new StringReader(xml))
using (var xmlReader = XmlReader.Create(reader))
{
var serializer = new XmlSerializer(typeof(Expense));
if (!serializer.CanDeserialize(xmlReader))
{
return(null);
}
var expenseObject = serializer.Deserialize(xmlReader) as Expense;
return(expenseObject);
}
}
public static T Deserialize <T>(string path) where T : class
{
T result = default(T);
XmlSerializer serializer = new XmlSerializer(typeof(T));
using (FileStream fs = File.OpenRead(path))
{
using (StreamReader inputReader = new StreamReader(fs))
{
using (XmlReader reader = XmlReader.Create(inputReader))
{
bool canSerialize = serializer.CanDeserialize(reader);
if (canSerialize)
{
result = serializer.Deserialize(reader) as T;
}
}
}
}
return(result);
}
// This function loads the user defined options. First, it checks to see
// if an options file exists. if it does, the options are loaded from it.
// if the file doesn't exist, one is created with the defaults.
public void LoadOptions()
{
Options myOptions = new Options(); //' An Options object to use;
// Check to see if an Option file exists, if so, load it! else {
// create one.
if (myOptions.IsOptionFileExisting())
{
// Load the options
// Create an XmlSerializer to use for retrieving options values
XmlSerializer mySerializer = new XmlSerializer(typeof(Options));
// Create a StreamReader to point to the options file
StreamReader myTextReader = new StreamReader(OptionsPath);
// Create an XmlTextReader to actually read the options.
XmlTextReader myXmlReader = new XmlTextReader(myTextReader);
// First verify that the file can be deserialized into an Option
// object format.
if (mySerializer.CanDeserialize(myXmlReader))
{
// Deserialize the object
myOptions = ((Options)mySerializer.Deserialize(myXmlReader));
}
else
{
// Save a new Options file
myOptions.SaveOptions();
}
// Close the IO objects we've used.
myXmlReader.Close();
myTextReader.Close();
// Set the properties for this Options object to those retrieved
// from the file (or else use the defaults from the temporary
// Options object, if the file could not be deserialized).
this.Speed = myOptions.Speed;
this.IsTransparent = myOptions.IsTransparent;
this.Shape = myOptions.Shape;
}
}
public override void Initialize()
{
List <string> levelnames = Directory.GetFiles("Levels").ToList();
pages = (int)Math.Floor((double)((levelnames.Count - 1) / 15));
int left = 117;
int top = 117;
int levelsInRow = 0;
levels.Clear();
for (int i = currentPage * 15; i < (levelnames.Count > 15 + 15 * currentPage ? 15 + 15 * currentPage : levelnames.Count); i++)
{
if (levelsInRow >= 5)
{
left = 117;
top += 180;
levelsInRow = 0;
}
Vector2 pos = new Vector2(left, top);
levels.Add(new Level(levelnames.ElementAt(i), pos));
levelsInRow++;
left += 346;
}
XmlSerializer xmlSerializer = new XmlSerializer(scores.GetType(), new Type[] { typeof(Score) });
if (File.Exists("Scores.xml"))
{
XmlReader xmlReader = XmlReader.Create("Scores.xml");
if (xmlSerializer.CanDeserialize(xmlReader))
{
scores = (List <Score>)xmlSerializer.Deserialize(xmlReader);
}
xmlReader.Close();
}
//Load();
}
public static async Task <Rules> LoadFromAppDataAsync()
{
var d20Rules = new D20Rules()
{
Rules = new Rules()
};
var appPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
var basePath = Path.Combine(appPath, "CBLoader");
var rulesPath = Path.Combine(basePath, "combined.dnd40");
if (!File.Exists(rulesPath))
{
return(d20Rules.Rules);
}
Stopwatch timer = Stopwatch.StartNew();
try {
d20Rules = await Task.Run <D20Rules>(() => {
XmlSerializer serializer = new XmlSerializer(typeof(D20Rules));
using (var file = new FileStream(rulesPath, FileMode.Open, FileAccess.Read, FileShare.Read, 0x1000, useAsync: true)) {
using (var reader = new XmlTextReader(file)) {
if (serializer.CanDeserialize(reader))
{
return(serializer.Deserialize(reader) as D20Rules);
}
}
}
return(d20Rules);
}).ConfigureAwait(false);
}
finally {
timer.Stop();
Trace.TraceInformation("Deserializing D20Rules took {0}ms", timer.ElapsedMilliseconds);
}
return(d20Rules.Rules);
}
public void LoadSettings()
{
try
{
// Create an instance of the Settings class
Settings settings = new Settings();
if (File.Exists(this.settingsPath))
{
// Create an instance of System.Xml.Serialization.XmlSerializer
XmlSerializer serializer = new XmlSerializer(typeof(Settings));
// Create an instance of System.IO.StreamReader
// to point to the settings file on disk
StreamReader textReader = new StreamReader(this.settingsPath);
// Create an instance of System.Xml.XmlTextReader
// to read from the StreamReader
XmlTextReader xmlReader = new XmlTextReader(textReader);
if (serializer.CanDeserialize(xmlReader))
{
// Assign the deserialized object to the new settings object
settings = ((Settings)serializer.Deserialize(xmlReader));
Instance = settings;
}
// Close the XmlTextReader
xmlReader.Close();
textReader.Close();
}
}
catch (Exception ex)
{
MessageBox.Show("Error retrieving settings!\n" + ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
/// <summary>
/// Send this message.
/// </summary>
/// <exception cref="OpenWeatherMapException">Thrown when an Open Weather Map error condition
/// occurs.</exception>
/// <typeparam name="T">Generic type parameter.</typeparam>
/// <returns>
/// A Task<T>
/// </returns>
async Task <T> Send <T>()
{
HttpResponseMessage response;
try
{
response = await this.Request.HttpClient.SendAsync(this.Request.Request);
}
catch (Exception ex)
{
throw new OpenWeatherMapException(ex);
}
if (!response.IsSuccessStatusCode)
{
throw new OpenWeatherMapException(response);
}
var responseString = await response.Content.ReadAsStringAsync();
// OpenWeatherMap returns errors with json
if (string.IsNullOrEmpty(responseString) || responseString.StartsWith("{", StringComparison.Ordinal))
{
throw new OpenWeatherMapException(response);
}
var responseStream = await response.Content.ReadAsStreamAsync();
var xmlSerializer = new XmlSerializer(typeof(T));
var xmlReader = XmlReader.Create(responseStream);
if (xmlSerializer.CanDeserialize(xmlReader))
{
return((T)xmlSerializer.Deserialize(xmlReader));
}
throw new OpenWeatherMapException(response);
}
public void CanDeserializeRssFeedFromXml()
{
var serializer = new XmlSerializer(_rssDocument.GetType());
using (var storage = IsolatedStorageFile.GetUserStoreForApplication())
{
if (!storage.FileExists(SimpleRssPath))
{
using (var filestream = new IsolatedStorageFileStream(SimpleRssPath, FileMode.Create, storage))
{
serializer.Serialize(filestream, _rssDocument);
}
}
using (var filestream = storage.OpenFile(SimpleRssPath, FileMode.Open))
{
using (var reader = XmlReader.Create(filestream))
{
Assert.IsTrue(serializer.CanDeserialize(reader));
var resultantObject = serializer.Deserialize(reader);
//Assert that the result object is of the expected type (some derivative of IFeed)
Assert.IsInstanceOfType(resultantObject, _rssDocument.GetType());
//Assert that the two objects are distinct instances
Assert.AreNotSame(_rssDocument, resultantObject);
//Cast the object back into an IFeed and perform some specific assertions
var resultantFeed = resultantObject as IFeed;
Assert.AreEqual(_rssDocument.Title, resultantFeed.Title);
Assert.AreEqual(_rssDocument.LastUpdated, resultantFeed.LastUpdated);
Assert.AreEqual(_rssDocument.FeedUri, resultantFeed.FeedUri);
Assert.AreEqual(_rssDocument.FeedType, resultantFeed.FeedType);
Assert.AreEqual(_rssDocument.Items.Count, resultantFeed.Items.Count);
}
}
}
}
private void ImportXML(string path)
{
using (XmlReader xmlreader = XmlReader.Create(path))
{
var serializer = new XmlSerializer(typeof(Employee[]));
if (serializer.CanDeserialize(xmlreader))
{
Employee[] employees = (Employee[])serializer.Deserialize(xmlreader);
var aef = new AddEmployeeForm();
using (OleDbConnection connection = new OleDbConnection())
{
connection.ConnectionString = MainForm.Connection;
try
{
connection.Open();
for (int i = 0; i < employees.Length; i++)
{
OleDbCommand add = connection.CreateCommand();
//employees[i].ID or aef.FindNewID().ToString("D4")
add.CommandText = "INSERT INTO Employees (ID, FirstName, MiddleName," +
" LastName, DateOfBirth, PhoneNumber, HomeAddress)" +
" VALUES ('" + aef.FindNewID().ToString("D4") + "','" +
employees[i].FirstName + "','" + employees[i].MiddleName + "','" +
employees[i].LastName + "','" + employees[i].DateOfBirth + "','" +
employees[i].PhoneNumber + "','" + employees[i].HomeAddress + "')";
add.ExecuteNonQuery();
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message.ToString());
}
}
}
}
FillEmployeesTableAsync(this, EventArgs.Empty);
}
public static bool TryDeserialize <T>(string xml, out T obj)
{
obj = default(T);
var serializer = new XmlSerializer(typeof(T));
using (var stringReader = new StringReader(xml))
{
using (var xmlReader = XmlReader.Create(stringReader))
{
if (!serializer.CanDeserialize(xmlReader))
{
return(false);
}
var deserializedObj = serializer.Deserialize(xmlReader);
if (!(deserializedObj is T))
{
return(false);
}
obj = (T)deserializedObj;
}
}
return(true);
}
/// <summary>
/// xml文件序列化成对象
/// </summary>
/// <param name="xmlFileName">xml文件</param>
/// <param name="type">对象类别</param>
/// <return>对象</return>
public static object XmlFileToObject <T>(string xmlFileName)
{
if (!File.Exists(xmlFileName))
{
throw new FileNotFoundException(xmlFileName);
}
XmlTextReader xmlReader = new XmlTextReader(xmlFileName);
try
{
var type = typeof(T);
XmlSerializer xs = new XmlSerializer(type);
if (xs.CanDeserialize(xmlReader))
{
return(xs.Deserialize(xmlReader));
}
}
finally
{
xmlReader.Close();
}
return(null);
}
public static object DeserializePolymorphicXml(this TextReader textReader, params Type[] types)
{
if (textReader == null || types == null)
{
throw new ArgumentNullException();
}
var settings = new XmlReaderSettings {
CloseInput = false
}; // Let caller close the input.
using (var xmlReader = XmlReader.Create(textReader, settings))
{
foreach (var type in types)
{
var serializer = new XmlSerializer(type);
if (serializer.CanDeserialize(xmlReader))
{
return(serializer.Deserialize(xmlReader));
}
}
}
throw new XmlException("Invalid root type.");
}
public bool CanDeSerialize(StreamWrapper streamWrapper)
{
try
{
streamWrapper.Position = 0;
using (var reader = XmlReader.Create(streamWrapper, new XmlReaderSettings {
CloseInput = false
})) {
if (_xmlSerializer.CanDeserialize(reader))
{
if (reader.MoveToContent() == XmlNodeType.Element)
{
return(CanDeSerialize(reader));
}
}
}
return(false);
}
catch (XmlException)
{
return(false);
}
}
private void Load(string name)
{
entityManager = new EntityManager();
XmlSerializer xmlSerializer = new XmlSerializer(entityManager.GetType(), new Type[] { typeof(Character), typeof(Block), typeof(Enemy), typeof(Coin) });
XmlReader xmlReader = XmlReader.Create(name);
if (xmlSerializer.CanDeserialize(xmlReader))
{
entityManager = (EntityManager)xmlSerializer.Deserialize(xmlReader);
}
xmlReader.Close();
entityManager.onGameOver += entityManager_GameOver;
foreach (Character character in entityManager.entities.Where(x => x is Character).ToList())
{
if (character.playerIndex != 0)
{
character.isActive = false;
}
}
entityManager.entities.OfType <Block>().ToList().ForEach(x => x.getImage());
entityManager.DivideIntoSections();
}
public void DeSerializeXML(string fileName)
{
if (File.Exists(fileName))
{
StreamReader sr = new StreamReader(fileName);
XmlTextReader xr = new XmlTextReader(sr);
XmlSerializer xs = new XmlSerializer(typeof(XMLShapes));
object c;
if (xs.CanDeserialize(xr))
{
try
{
XMLShapes ret = (XMLShapes)xs.Deserialize(xr);
System.Console.WriteLine("XMLShapes Created");
OnShapesLoaded(ret);
}
catch (Exception e)
{
System.Console.WriteLine("Open file " + e.InnerException.Message);
}
finally
{
/*
* c = xs.Deserialize(xr);
* Type t = this.GetType();
* PropertyInfo[] properties = t.GetProperties();
* foreach (PropertyInfo p in properties)
* {
* p.SetValue(this, p.GetValue(c, null), null);
* }
*/
}
}
xr.Close();
sr.Close();
}
}
/// <summary>
/// Reads XML Configuration File.
/// </summary>
/// <param name="xmlFile">File Path to XML file.</param>
/// <param name="addins">List of Addins to be deserialized.</param>
public static void ReadConfig(string xmlFile, ref Addins addins)
{
try
{
if (!File.Exists(xmlFile))
{
return;
}
var serializer = new XmlSerializer(typeof(Addins));
var fs = new FileStream(xmlFile, FileMode.Open);
var reader = XmlReader.Create(fs);
if (serializer.CanDeserialize(reader))
{
var settingAddins = (Addins)serializer.Deserialize(reader);
for (var i = 0; i < addins.AddinCollection.Count; i++)
{
var info = addins.AddinCollection[i];
var settingFound = settingAddins.AddinCollection
.Where(x => x.ToolName == info.ToolName)
.ToList();
if (!settingFound.Any())
{
continue;
}
var settingInfo = settingFound.First();
addins.AddinCollection[i].ToolLoadType = settingInfo.ToolLoadType;
}
}
fs.Close();
}
catch (Exception ex)
{
Log.AppendLog(LogMessageType.EXCEPTION, ex.Message);
}
}
public static ConsultResponse Consult(this GlobalMedicalFileConsultationPortTypeClient client, CommonInputType common, RoutingType routing, RetrieveTransactionRequestType detailValue, out ArchivingInfo archivingInfo)
{
var detail = new BlobType();
detail.Id = "_" + Guid.NewGuid().ToString();
detail.ContentType = "text/xml";
detail.ContentEncoding = "none";
var detailStream = new MemoryStream();
var serializer = new XmlSerializer(typeof(RetrieveTransactionRequestType));
serializer.Serialize(detailStream, detailValue);
detail.Value = detailStream.ToArray();
ResponseReturnType super = client.Consult(common, routing, detail);
archivingInfo = new ArchivingInfo();
archivingInfo.RequestDetail = detail;
archivingInfo.RequestXadesT = null;
archivingInfo.ResponseDetail = super.Detail;
archivingInfo.ResponseXadesT = super.XadesT;
var retVal = new ConsultResponse();
retVal.Common = super.CommonOutput;
if (super.Detail.ContentType == "text/xml" &&
super.Detail.ContentEncoding == "none")
{
var reader = XmlReader.Create(new MemoryStream(super.Detail.Value));
var deserializer = new XmlSerializer(typeof(RetrieveTransactionResponseType));
if (deserializer.CanDeserialize(reader))
{
retVal.DetailValue = deserializer.Deserialize(reader) as RetrieveTransactionResponseType;
}
}
return(retVal);
}
private void OpenProject()
{
// Setup dialog:
using (OpenFileDialog dialog = new OpenFileDialog())
{
dialog.AddExtension = true;
dialog.DefaultExt = "rpproj";
dialog.Filter = "Replacer project (*.rpproj)|*.rpproj|All files (*.*)|*.*";
// Show dialog:
if (dialog.ShowDialog(this) == DialogResult.OK)
{
Stream openFileStream = new FileStream(dialog.FileName, FileMode.Open);
XmlSerializer serializer = new XmlSerializer(typeof(ReplacerProject));
XmlReader reader = new XmlTextReader(openFileStream);
if (!serializer.CanDeserialize(reader))
{
MessageBox.Show(this, "Invalid Project file", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
ReplacerProject project = (ReplacerProject)serializer.Deserialize(reader);
this.pathList.Clear();
foreach (FileFolderPath path in project.FileFolderPaths)
{
this.pathList.Add(path);
}
this.patternList.Clear();
foreach (ReplacePattern pattern in project.PatternList)
{
this.patternList.Add(pattern);
}
}
openFileStream.Close();
}
}
}
private void xMLOlarakAktarToolStripMenuItem_Click(object sender, EventArgs e)
{
dosyaAc.Title = "Bir XML dosyası seçiniz";
dosyaAc.Filter = "(XML Dosyası) | *.xml;";
dosyaAc.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
dosyaAc.FileName = "Kisiler.xml";
if (dosyaAc.ShowDialog() == DialogResult.OK)
{
XmlSerializer xmlSerializer = new XmlSerializer(typeof(List <Kisi>));
XmlReader reader = new XmlTextReader(dosyaAc.FileName);
if (xmlSerializer.CanDeserialize(reader))
{
kisiler = xmlSerializer.Deserialize(reader) as List <Kisi>;
MessageBox.Show($"{kisiler.Count} kişi sisteme başarıyla eklendi.");
FormuTemizle();
ListeGuncelle();
}
else
{
MessageBox.Show("Lütfen bir XML dosyası seçin.");
}
}
}
// Deserialization işlemi için kullanılacak olan metod
private static void DeserializeXml(string XmlData)
{
// Yeni bir Personel Nesnesi Yaratıyoruz Personel ReturnedEmployee;
// DeSerialize işleminde kullanılmak üzere yeni bir XmlSerializer
// nesnesi yaratıyor ve Serialize edilmiş verinin hangi nesne(Class) tipine çevirileceğini gösteriyoruz.
XmlSerializer MyDeserializer = new XmlSerializer(typeof(Personel));
FileStream fs = new FileStream(@"XML Document.txt", FileMode.Open, FileAccess.Read);
// XML Verisini tutmak için bir StringReader yaratıyoruz.
StreamReader sr = new StreamReader(fs);
XmlReader XR = new XmlTextReader(sr);
// XML verisinin Deserialize edilip edilmeyeceğini kontrol ediyoruz.
if (MyDeserializer.CanDeserialize(XR))
{
// Ve XML verisini Deserialize ediyoruz.
Personel ReturnedEmployee = (Personel)MyDeserializer.Deserialize(XR);
ShowEmployeeData(ReturnedEmployee);
}
fs.Dispose();
}
