async private Task Save(XDocument xdoc, string path)
{
StringWriter swriter = new StringWriter();
xdoc.Save(swriter, SaveOptions.None);
string xmlString = swriter.GetStringBuilder().ToString();
IBuffer xmlEncryptedBuffer = EncryptionProvider.Encrypt(xmlString);
StorageFolder sf = await ApplicationData.Current.LocalFolder.GetFolderAsync(@"data\");
var file = await sf.GetFileAsync(Path.GetFileName(path));
using (IRandomAccessStream ras = await file.OpenAsync(FileAccessMode.ReadWrite))
{
using (IOutputStream outs = ras.GetOutputStreamAt(0))
{
await outs.WriteAsync(xmlEncryptedBuffer);
bool suc = await outs.FlushAsync();
outs.Dispose();
}
ras.Dispose();
}
}
/// <summary>
/// Saves all data that this repository has
/// </summary>
/// <param name="rootFolder">Folder in which to save the data</param>
public async Task Save(StorageFolder rootFolder)
{
StorageFolder modelFolder = await GetFolder(rootFolder);
// If all data was deleted then delete all the files
if (modelProperty().Count == 0)
{
// Create a new folder for this model, deleting the old one while it does
modelFolder = await rootFolder.CreateFolderAsync(ModelName + "s", CreationCollisionOption.ReplaceExisting);
}
// Loop each instance in the list
foreach (T model in modelProperty())
{
// Create an XmlSerializer for serializing the data
XmlSerializer xmlSerializer = new XmlSerializer(model.GetType());
// Create a file for the model
// We replace existing files so that it overwrites old data
StorageFile file = await modelFolder.CreateFileAsync(model.ID.ToString(), CreationCollisionOption.ReplaceExisting);
// A random access stream is used to push data to the file
IRandomAccessStream fileRandomAccessStream = await file.OpenAsync(FileAccessMode.ReadWrite);
// Used to disposing and flushing data which helps for memory conservation
IOutputStream fileOutputStream = fileRandomAccessStream.GetOutputStreamAt(0);
// Serialize the data to the file
xmlSerializer.Serialize(fileRandomAccessStream.AsStreamForWrite(), model);
// Dispose of and flush the file streams (Do flush asynchronously so it doesn't jam the thread)
fileRandomAccessStream.Dispose();
await fileOutputStream.FlushAsync();
fileOutputStream.Dispose();
}
}
public async Task <bool> SaveEpisodeList()
{
var filename = "Episodes.json";
try
{
StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
IRandomAccessStream raStream = await file.OpenAsync(FileAccessMode.ReadWrite);
using (IOutputStream outStream = raStream.GetOutputStreamAt(0))
{
// Serialize the Session State.
DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(List <Episode>));
serializer.WriteObject(outStream.AsStreamForWrite(), EpisodesList);
await outStream.FlushAsync();
outStream.Dispose();
raStream.Dispose();
Debug.WriteLine("Episodelist saved");
return(true);
}
}
catch (Exception) { Debug.WriteLine("episodelist failed to save"); return(false); }
}
//-------------------------------------------------------------------------zamykanie polaczenia
private void disconnect()
{
if (reader != null)
{
reader.Dispose();
reader = null;
}
if (writer != null)
{
writer.Dispose();
writer = null;
}
if (socket != null)
{
socket.Dispose();
socket = null;
}
if (service != null)
{
service = null;
}
if (stream != null)
{
stream.Dispose();
stream = null;
}
if (buffer != null)
{
buffer = null;
}
}
public async Task StopRecording()
{
await datawriter.StoreAsync();
await outputstream.FlushAsync();
outputstream.Dispose();
datawriter.Dispose();
using (outputstream = stream.GetOutputStreamAt(4))
using (datawriter = new DataWriter(outputstream)
{
ByteOrder = ByteOrder.LittleEndian
})
{
datawriter.WriteUInt32((uint)size + 44);
await datawriter.StoreAsync();
await outputstream.FlushAsync();
}
using (outputstream = stream.GetOutputStreamAt(40))
using (datawriter = new DataWriter(outputstream)
{
ByteOrder = ByteOrder.LittleEndian
})
{
datawriter.WriteUInt32((uint)size);
await datawriter.StoreAsync();
await outputstream.FlushAsync();
}
}
public static async Task <bool> writeObjektAsync <T>(string file, T objekt)
{
try
{
StorageFile userdetailsfile = await
ApplicationData.Current.LocalFolder.CreateFileAsync(file, CreationCollisionOption.ReplaceExisting);
IRandomAccessStream rndStream = await
userdetailsfile.OpenAsync(FileAccessMode.ReadWrite);
using (IOutputStream outStream = rndStream.GetOutputStreamAt(0))
{
DataContractSerializer serializer = new DataContractSerializer(typeof(T));
serializer.WriteObject(outStream.AsStreamForWrite(), objekt);
var xx = await outStream.FlushAsync();
rndStream.Dispose();
outStream.Dispose();
}
return(true);
}
catch (Exception e)
{
return(false);
}
}
/// <summary>
/// Convert the given MemoryStream to a stream that allows random access
/// </summary>
/// <param name="memoryStream">The MemoryStream to convert</param>
/// <returns>Stream that allows random access</returns>
public static async Task <IRandomAccessStream> ConvertToRandomAccessStream(MemoryStream memoryStream)
{
InMemoryRandomAccessStream randomAccessStream = new InMemoryRandomAccessStream();
MemoryStream contentStream = new MemoryStream();
memoryStream.CopyTo(contentStream);
using (IOutputStream outputStream = randomAccessStream.GetOutputStreamAt(0))
{
using (DataWriter dw = new DataWriter(outputStream))
{
Task task = new Task(() => dw.WriteBytes(contentStream.ToArray()));
task.Start();
await task;
await dw.StoreAsync();
await outputStream.FlushAsync();
await dw.FlushAsync();
outputStream.Dispose();
dw.DetachStream();
dw.Dispose();
}
}
return(randomAccessStream);
}
internal async void SaveProfile()
{
FileSavePicker savePicker = new FileSavePicker();
savePicker.SuggestedStartLocation = PickerLocationId.DocumentsLibrary;
// Dropdown of file types the user can save the file as
savePicker.FileTypeChoices.Add("profile", new List <string>()
{
".prof"
});
savePicker.FileTypeChoices.Add("csv", new List <string>()
{
".csv"
});
// Default file name if the user does not type one in or select a file to replace
savePicker.SuggestedFileName = "new profile";
StorageFile file = await savePicker.PickSaveFileAsync();
if (file != null)
{
IRandomAccessStream sessionRandomAccess = await file.OpenAsync(FileAccessMode.ReadWrite);
IOutputStream sessionOutputStream = sessionRandomAccess.GetOutputStreamAt(0);
XmlSerializer serializer;
serializer = new XmlSerializer(typeof(Profile));
serializer.Serialize(sessionOutputStream.AsStreamForWrite(), CurrentProfile);
sessionRandomAccess.Dispose();
await sessionOutputStream.FlushAsync();
sessionOutputStream.Dispose();
}
}
public async Task ExportCurrentPath()
{
// Code to call file picker
FileSavePicker savePicker = new FileSavePicker();
savePicker.SuggestedStartLocation = PickerLocationId.DocumentsLibrary;
// Dropdown of file types the user can save the file as
savePicker.FileTypeChoices.Add("Xml", new List <string>()
{
".xml"
});
// Default file name if the user does not type one in or select a file to replace
savePicker.SuggestedFileName = _currentPathData.Name;
StorageFile file = await savePicker.PickSaveFileAsync();
if (file != null)
{
IRandomAccessStream sessionRandomAccess = await file.OpenAsync(FileAccessMode.ReadWrite);
IOutputStream sessionOutputStream = sessionRandomAccess.GetOutputStreamAt(0);
List <List <Point> > Allpaths = CurrentPath.AllPoints;
var serializer = new XmlSerializer(typeof(List <List <Point> >));
serializer.Serialize(sessionOutputStream.AsStreamForWrite(), Allpaths);
sessionRandomAccess.Dispose();
await sessionOutputStream.FlushAsync();
sessionOutputStream.Dispose();
}
}
public void CheckShutdown()
{
// cryptor?.Dispose();
// cryptor = null;
// outboundChan = null;
if (recvData != null)
{
ZeroMemory(recvData);
}
if (udpClient != null)
{
udpClient.MessageReceived -= UdpClient_MessageReceived;
}
try
{
tcpInputStream?.Dispose();
udpOutputStream?.Dispose();
}
catch (ObjectDisposedException) { }
// networkStream = null;
try
{
client?.Dispose();
udpClient?.Dispose();
}
catch (ObjectDisposedException) { }
try
{
udpSendLock.Dispose();
}
catch (ObjectDisposedException) { }
// client = null;
// udpClient = null;
}
public async Task StartUPnPDiscoveryAsync()
{
_socket = new DatagramSocket();
_socket.MessageReceived += _socket_MessageReceived;
IOutputStream stream = await _socket.GetOutputStreamAsync(new HostName("239.255.255.250"), "1900");
const string message = "M-SEARCH * HTTP/1.1\r\n" +
"HOST: 239.255.255.250:1900\r\n" +
"ST:upnp:rootdevice\r\n" +
"MAN:\"ssdp:discover\"\r\n" +
"MX:3\r\n\r\n";
var writer = new DataWriter(stream)
{
UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8
};
writer.WriteString(message);
_upnpDiscoveryStart = DateTime.Now;
_upnpListener = new DispatcherTimer();
_upnpListener.Interval = new TimeSpan(0, 0, 1); //1 second
_upnpListener.Tick += _upnpListener_Tick;
_upnpListener.Start();
await writer.StoreAsync();
await stream.FlushAsync();
stream.Dispose();
}
public static async void init(TiSettings settings)
{
if (!settings.ContainsKey("logToken") || settings["logToken"].Length == 0)
{
return;
}
logToken = settings["logToken"];
multicastSocket = new DatagramSocket();
multicastSocket.MessageReceived += multicastSocket_MessageReceived;
HostName hostname = new HostName("239.6.6.6");
try {
await multicastSocket.BindServiceNameAsync("8666");
multicastSocket.JoinMulticastGroup(hostname);
IOutputStream stream = await multicastSocket.GetOutputStreamAsync(hostname, "8666");
DataWriter writer = new DataWriter(stream);
writer.WriteString("TI_WP8_LOGGER");
await writer.StoreAsync();
writer.DetachStream();
stream.Dispose();
} catch (Exception ex) {
if (SocketError.GetStatus(ex.HResult) == SocketErrorStatus.Unknown)
{
throw;
}
Debug.WriteLine(ex.ToString());
}
}
/// <summary>
/// Writes page content back to socket
/// </summary>
/// <param name="socket"></param>
/// <param name="html"></param>
/// <param name="lastModifiedUtc"></param>
/// <param name="contentType"></param>
/// <param name="keepAlive"></param>
/// <param name="canBeCached"></param>
/// <returns></returns>
private async Task WritePageContent(StreamSocket socket, string html, DateTime?lastModifiedUtc, string contentType, bool keepAlive, bool canBeCached)
{
// respond with the html:
IOutputStream output = socket.OutputStream;
//using (IOutputStream output = socket.OutputStream) -- cannot close anything in Keep-Alive mode
{
//using (Stream resp = output.AsStreamForWrite()) -- cannot use this, will be blocked on Dispose()
Stream respStream = output.AsStreamForWrite(262144); // 256K for uninterrupted send of most sizes
{
//resp.WriteTimeout = 1000; // milliseconds -- does not work here
// Look in the Data subdirectory of the app package
byte[] bodyArray = Encoding.UTF8.GetBytes(html);
MemoryStream stream = new MemoryStream(bodyArray);
string header = generateHeader(lastModifiedUtc, contentType, stream.Length, keepAlive, canBeCached);
byte[] headerArray = Encoding.UTF8.GetBytes(header);
await respStream.WriteAsync(headerArray, 0, headerArray.Length, tokenSource.Token);
await stream.CopyToAsync(respStream, bodyArray.Length, tokenSource.Token);
await respStream.FlushAsync(tokenSource.Token);
}
}
if (!keepAlive)
{
output.Dispose();
}
}
private async void Button_Savelocal_Click(object sender, RoutedEventArgs e)
{
FileSavePicker savePicker = new FileSavePicker();
savePicker.SuggestedStartLocation = PickerLocationId.DocumentsLibrary;
// Dropdown of file types the user can save the file as
savePicker.FileTypeChoices.Add("Template", new List <string>()
{
".ctmpl"
});
savePicker.FileTypeChoices.Add("Xml", new List <string>()
{
".xml"
});
// Default file name if the user does not type one in or select a file to replace
savePicker.SuggestedFileName = "New Template Collection";
StorageFile file = await savePicker.PickSaveFileAsync();
if (file != null)
{
IRandomAccessStream sessionRandomAccess = await file.OpenAsync(FileAccessMode.ReadWrite);
IOutputStream sessionOutputStream = sessionRandomAccess.GetOutputStreamAt(0);
var serializer = new XmlSerializer(typeof(TemplateCollection));
serializer.Serialize(sessionOutputStream.AsStreamForWrite(), App.CodeSettingsContext.Templates);
sessionRandomAccess.Dispose();
await sessionOutputStream.FlushAsync();
sessionOutputStream.Dispose();
}
}
public void Dispose()
{
_cts.Cancel();
_input.Dispose();
_output.Dispose();
_serialDevice.Dispose();
}
public void Dispose()
{
_isOpen = false;
_cts.Cancel();
_input.Dispose();
_output.Dispose();
_serialDevice.Dispose();
}
public async Task SendTextMessage(User rec, Message msg, List <User> groupMessageUsers = null)
{
string toSend;
if (msg.Type == Message.MessageType.Buzz && groupMessageUsers == null)
{
toSend = "buzz:" + ChatScreen.loggedInUser.Username;
}
else if (msg.Type == Message.MessageType.Buzz && groupMessageUsers != null)
{
//send buzz to group
toSend = "groupBuzz;";
toSend += ChatScreen.loggedInUser.Username + ";";
foreach (User u in groupMessageUsers)
{
toSend += u.Username;
if (u != groupMessageUsers.Last())
{
toSend += ";";
}
}
}
else
{
if (groupMessageUsers != null)
{
toSend = ParseGroupTextMessage(groupMessageUsers, msg);
}
else
{
toSend = ParseTextMessage(msg);
}
}
try
{
IOutputStream stream = await textMessageSocket.GetOutputStreamAsync(new HostName(rec.IPAddress), unicastServicePort);
using (var MyDataWriter = new DataWriter(stream))
{
string encryptedMessage = StringCipher.Encrypt(toSend);
MyDataWriter.WriteString(encryptedMessage);
await MyDataWriter.StoreAsync();
MyDataWriter.DetachStream();
}
stream.Dispose();
}
catch (Exception ex)
{
if (SocketError.GetStatus(ex.HResult) == SocketErrorStatus.Unknown)
{
throw;
}
}
}
public void Dispose()
{
output?.Dispose();
if (process?.HasExited == false)
{
process?.WaitForExit();
}
process = null;
}
public async static Task WriteFile(IBuffer buffer, IOutputStream file)
{
try
{
await file.WriteAsync(buffer);
}
catch (Exception)
{
file.Dispose();
return;
}
}
static async private Task SaveAsync <T>(string filename)
{
StorageFile sessionFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
IRandomAccessStream sessionRandomAccess = await sessionFile.OpenAsync(FileAccessMode.ReadWrite);
IOutputStream sessionOutputStream = sessionRandomAccess.GetOutputStreamAt(0);
var serializer = new XmlSerializer(typeof(List <object>), new Type[] { typeof(T) });
serializer.Serialize(sessionOutputStream.AsStreamForWrite(), _data);
sessionRandomAccess.Dispose();
await sessionOutputStream.FlushAsync();
sessionOutputStream.Dispose();
}
/// <summary>
/// Save the settings to a file
/// </summary>
/// <param name="settings">Settings object to save</param>
/// <param name="filename">Name of file to save to</param>
/// <returns></returns>
public static async Task SaveAsync(AppSettings settings, string filename)
{
StorageFile sessionFile = await SettingsFolder.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
IRandomAccessStream sessionRandomAccess = await sessionFile.OpenAsync(FileAccessMode.ReadWrite);
IOutputStream sessionOutputStream = sessionRandomAccess.GetOutputStreamAt(0);
var serializer = new XmlSerializer(typeof(AppSettings), new Type[] { typeof(AppSettings) });
serializer.Serialize(sessionOutputStream.AsStreamForWrite(), settings);
sessionRandomAccess.Dispose();
await sessionOutputStream.FlushAsync();
sessionOutputStream.Dispose();
}
public async Task SaveListofLocation()
{
StorageFile userListofLocations = await ApplicationData.Current.LocalFolder.CreateFileAsync("userListofLocation", CreationCollisionOption.ReplaceExisting);
IRandomAccessStream raStream = await userListofLocations.OpenAsync(FileAccessMode.ReadWrite);
using (IOutputStream outStream = raStream.GetOutputStreamAt(0))
{
DataContractSerializer serializer = new DataContractSerializer(typeof(ObservableCollection <string>));
serializer.WriteObject(outStream.AsStreamForWrite(), locationList);
await outStream.FlushAsync();
outStream.Dispose();
raStream.Dispose();
}
}
/// <summary>
/// Save object from file
/// </summary>
/// <param name="obj"></param>
/// <param name="fileName"></param>
public async Task SaveAsync(T obj, string fileName)
{
fileName = fileName + GetFileExtension();
try
{
if (obj != null)
{
//Get file
StorageFile file = null;
StorageFolder folder = await GetFolderAsync().ConfigureAwait(false);
file = await folder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);
//Serialize object with JSON or XML serializer
string storageString = null;
switch (_serializerType)
{
case StorageSerializer.JSON:
storageString = JsonConvert.SerializeObject(obj);
//Write content to file
await FileIO.WriteTextAsync(file, storageString);
break;
#if USE_XML_SERIALIZER
case StorageSerializer.XML:
IRandomAccessStream sessionRandomAccess = await file.OpenAsync(FileAccessMode.ReadWrite);
IOutputStream sessionOutputStream = sessionRandomAccess.GetOutputStreamAt(0);
XmlSerializer serializer = new XmlSerializer(typeof(T));
serializer.Serialize(sessionOutputStream.AsStreamForWrite(), obj);
sessionRandomAccess.Dispose();
await sessionOutputStream.FlushAsync();
sessionOutputStream.Dispose();
break;
#endif
}
}
}
catch (Exception ex)
{
throw;
}
}
public static async void SaveProjecList()
{
StorageFile storageFile = await Globals.storageLocation.CreateFileAsync("projectList", CreationCollisionOption.ReplaceExisting);
IRandomAccessStream raStream = await storageFile.OpenAsync(FileAccessMode.ReadWrite);
using (IOutputStream outStream = raStream.GetOutputStreamAt(0))
{
//Serialize the Session State
DataContractSerializer serializer = new DataContractSerializer(typeof(List <ProjectList>));
serializer.WriteObject(outStream.AsStreamForWrite(), Globals.projects);
await outStream.FlushAsync();
outStream.Dispose();
raStream.Dispose();
}
}
async Task OnDestroy()
{
await audioFrameReader.StopAsync();
await videoFrameReader.StopAsync();
audioFrameReader.FrameArrived -= AudioFrameArrived;
audioStream.FlushAsync();
audioStream.Dispose();
audioStream = null;
videoFrameReader.FrameArrived -= VideoFrameArrived;
videoStream.FlushAsync();
videoStream.Dispose();
videoStream = null;
mediaCapture.Dispose();
}
private async void addNewButton_Click(object sender, RoutedEventArgs e)
{
var dialog = new AddProjectDialog();
var result = await dialog.ShowAsync();
bool exists = false;
if (result == ContentDialogResult.Primary)
{
foreach (var rec in Globals.projects)
{
if (rec.projectName == dialog.Text)
{
exists = true;
}
}
if (exists == false)
{
Globals.projects.Add(new ProjectList
{
projectName = dialog.Text,
dateCreated = DateTime.Now,
lastModified = DateTime.Now
});
Globals.SortProjectList();
}
}
//Save List To File
StorageFile storageFile = await Globals.storageLocation.CreateFileAsync("projectList", CreationCollisionOption.ReplaceExisting);
IRandomAccessStream raStream = await storageFile.OpenAsync(FileAccessMode.ReadWrite);
using (IOutputStream outStream = raStream.GetOutputStreamAt(0))
{
//Serialize the Session State
DataContractSerializer serializer = new DataContractSerializer(typeof(List <ProjectList>));
serializer.WriteObject(outStream.AsStreamForWrite(), Globals.projects);
await outStream.FlushAsync();
outStream.Dispose();
raStream.Dispose();
}
this.Frame.Navigate(typeof(MainPage));
}
// ReSharper disable once MemberCanBeMadeStatic.Local
private async void DoShipping(Order order)
{
try
{
string fileName = $"dispatch-{order.OrderId}.txt";
StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync(fileName);
if (file != null)
{
string dispatchNote =
"Order Summary: \r\n" +
$"Order ID: {order.OrderId}\r\n" +
$"Order Total: {order.TotalValue:C}";
IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite);
IOutputStream writeStream = stream.GetOutputStreamAt(0);
DataWriter writer = new DataWriter(writeStream);
writer.WriteString(dispatchNote);
await writer.StoreAsync();
await writeStream.FlushAsync();
writeStream.Dispose();
}
else
{
MessageDialog messageDialog = new MessageDialog($"Unable to save to file: {fileName}", "Not saved");
await messageDialog.ShowAsync();
}
}
catch (Exception exception)
{
MessageDialog messageDialog = new MessageDialog(exception.Message, "Exception");
await messageDialog.ShowAsync();
}
finally
{
ShipProcessingComplete?.Invoke($"Dispatch note generated for Order {order.OrderId}");
}
}
public void CheckShutdown()
{
try
{
inputStream?.Dispose();
}
catch (ObjectDisposedException) { }
try
{
outputStream?.Dispose();
}
catch (ObjectDisposedException) { }
try
{
socket.Dispose();
}
catch (ObjectDisposedException) { }
}
/// <summary>
/// Elementy z listBoxa przekazywane są do odpowiedniej Listy (Array), dzięki czemu możemy te dane przechowywać w osobnej klasie.
/// Dodatkowo te dane z Listy zapisujemy do pliku.
/// </summary>
/// <param name="list">Lista, do której chcesz się odwołać.</param>
/// <param name="nameFileList">Nazwa pliku, w której przechowywane są dane o liście.</param>
/// <param name="nameList">Nazwa listy nadana podczas tworzenia.</param>
/// <param name="nameFileName">Nazwa pliku, w którym przechowywana jest nazwa listy.</param>
private async void SaveList(List <string> list, string nameFileList, string nameFileName, string nameList)
{
list.Clear();
//Przekazywanie danych z listBoxa do listy.
for (int i = 0; i < listBoxPurchases.Items.Count; i++)
{
list.Add((string)listBoxPurchases.Items[i]);
}
//Przekazywanie nazwy do pliku .txt
StorageFile nameData = await ApplicationData.Current.LocalFolder.CreateFileAsync
(nameFileName, CreationCollisionOption.ReplaceExisting);
await FileIO.WriteTextAsync(nameData, nameList);
//Dzięki drugiemu parametrowi, jeśli edytujemy dane, to aktualny plik zostanie nadpisany, a nie utworzony nowy.
//Przekazywanie danych z listy do pliku .txt
StorageFile listData = await ApplicationData.Current.LocalFolder.CreateFileAsync
(nameFileList, CreationCollisionOption.ReplaceExisting);
IRandomAccessStream randStream = await listData.OpenAsync(FileAccessMode.ReadWrite);
using (IOutputStream outStream = randStream.GetOutputStreamAt(0))
{
//Stan sesji.
//Przekazujemy dane w struemieniu określonego typu, u nas jest to List<string>
DataContractSerializer serializer = new DataContractSerializer(typeof(List <string>));
//Zapisujemy dane do strumienia/pliku
serializer.WriteObject(outStream.AsStreamForWrite(), list);
//Zwolnienie zasobów
await outStream.FlushAsync();
outStream.Dispose();
randStream.Dispose();
}
ListboxData.list1Edited = false; ListboxData.list2Edited = false; ListboxData.list3Edited = false;
//Ponieważ konczymy edytowanie wybranej listy.
this.Frame.GoBack();
}
public async void WritePersonObjects()
{
StorageFile slateUsersFile = await ApplicationData.Current.LocalFolder.CreateFileAsync
("SlateUsers", CreationCollisionOption.ReplaceExisting);
IRandomAccessStream raStream = await slateUsersFile.OpenAsync(FileAccessMode.ReadWrite);
using (IOutputStream outStream = raStream.GetOutputStreamAt(0))
{
// Serialize the Session State
DataContractSerializer serializer = new DataContractSerializer(typeof(List <Person>));
serializer.WriteObject(outStream.AsStreamForWrite(), slateUsers);
await outStream.FlushAsync();
outStream.Dispose();
raStream.Dispose();
}
}