Comment bien lire et écrire un fichier à l'aide de Windows.Stockage sur Windows Phone 8

Je suis besoin de simplement écrire dans un fichier et le lire à partir d'un fichier dans Windows Phone 8 à l'aide de Windows.Api De Stockage. Cela est relativement facile à l'aide de l'ancien IsolatedStorage méthode, mais il s'avère beaucoup plus difficile en utilisant la nouvelle API WinRT.

J'ai essayé de l'écrire, mais il semble y avoir toutes ces choses bizarres comme IBuffer. et tel. À l'aide de la version complète de WinRT, il est très facile à l'aide de Windows.Le stockage.FileIO qui semble exister pour garder les développeurs comme moi, de devenir fou. Cependant, il n'est pas implémenté dans la version de Téléphone. Aussi, j'ai regardé un Channel 9 vidéo qui montre quelques exemples de code, mais ils avaient une erreur qu'ils ont utilisé des méthodes de Sécurité Critique pour obtenir régulièrement des ruisseaux. Apparemment, l'obtention d'un Flux régulier n'est tout simplement pas permis.

Donc, quelqu'un peut-il me fournir une description concise et correcte extrait sur la façon de lire un fichier en une chaîne de caractères et la façon d'écrire une chaîne dans un fichier, avec une bonne utilisation et les techniques d'élimination?

En fonction de ce que vous essayez de le faire, de prendre un coup d'oeil à Akavache. Vous pouvez soit l'utiliser si cela résout votre problème, ou de prendre un coup d'oeil autour de la source pour voir comment ils ont travaillé autour de ces questions.
la bonne chose à garder à l'esprit, mais nous ne pouvons pas inclure toutes les dépendances 🙁 de plus, il utilise IsolatedStorage sur WP8
Le PCL de Stockage projet fournit une interface commune pour les opérations d'e/S avec les portables des bibliothèques de classe. Peut-être que cela pourrait vous donner quelques indications?
Est-il une raison using (StreamReader sr = new StreamReader(File.OpenRead(strFileLoc)))... style code ne fonctionne pas pour vous? J'ai une application déployée sur mon dev inscrits WP8 où la norme d'écriture de fichier semble bien fonctionner.

OriginalL'auteur Earlz | 2013-03-25

  1. 13

    Voici un exemple simple:

    public async Task WriteDataToFileAsync(string fileName, string content)
{
    byte[] data = Encoding.Unicode.GetBytes(content);

    var folder = ApplicationData.Current.LocalFolder;
    var file = await folder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);

    using (var s = await file.OpenStreamForWriteAsync())
    {
        await s.WriteAsync(data, 0, data.Length);
    }
}

public async Task<string> ReadFileContentsAsync(string fileName)
{
    var folder = ApplicationData.Current.LocalFolder;

    try
    {
        var file = await folder.OpenStreamForReadAsync(fileName);

        using (var streamReader = new StreamReader(file))
        {
            return streamReader.ReadToEnd();
        }
    }
    catch (Exception)
    {
        return string.Empty;
    }
}

    utiliser comme ceci:

    await this.WriteDataToFileAsync("afile.txt", "some text to save in a file");

var contents = await this.ReadFileContentsAsync("afile.txt");
    Un couple de questions: 1. Vous devez retourner la Tâche sur la méthode d'écriture, de sorte qu'il sera awaitable. 2. On dirait que tu es écrit en utf-8 et de la lecture du UTF16, ou est le StreamReader assez intelligent pour dire l'Encodage sans être dit?
    de bons spots. M'apprendra à simplement copier et coller à partir d'aléatoire sources internet 😉
    Aussi, à l'aide de OpenStreamForReadAsync la SÉCURITÉ est CRITIQUE
    Puis-je vous demander pourquoi il est important que OpenStreamForReadAsync la Sécurité est Critique? Microsoft est à l'aide de ce qu'il y à un exemple de code ( msdn.microsoft.com/en-us/library/windowsphone/develop/...) il semble donc que nous sommes censés utiliser ces.
    oui, il a fini par ne plus compter. Je ne comprends pas ce que la Sécurité Critiques, même moyen, mais je n'ai pas tout de certification des erreurs lors de l'appel de sécurité des fonctions les plus critiques de la non-sécurité de code critique.. donc je suppose que c'est du tout bon

    OriginalL'auteur Matt Lacey

  2. 3

    Je n'ai pas essayé avec Windows Phone 8, mais voici ce XAML une Trousse à outils pour Windows 8 qui pourrait fonctionner.

    using System;
using System.Threading.Tasks;
using Windows.Storage;
using Windows.Storage.Streams;
namespace WinRTXamlToolkit.IO.Extensions
{
///<summary>
///Extensions for simple writing and reading of strings to/from files.
///</summary>
///<remarks>
///Note that these were created before FileIO class existed in WinRT, but they still serve a purpose.
///</remarks>
public static class StringIOExtensions
{
///<summary>
///Reads a string from a text file.
///</summary>
///<param name="fileName">Name of the file.</param>
///<param name="folder">The folder.</param>
///<returns></returns>
public static async Task<string> ReadFromFile(
string fileName,
StorageFolder folder = null)
{
folder = folder ?? ApplicationData.Current.LocalFolder;
var file = await folder.GetFileAsync(fileName);
using (var fs = await file.OpenAsync(FileAccessMode.Read))
{
using (var inStream = fs.GetInputStreamAt(0))
{
using (var reader = new DataReader(inStream))
{
await reader.LoadAsync((uint)fs.Size);
string data = reader.ReadString((uint)fs.Size);
reader.DetachStream();
return data;
}
}
}
}
///<summary>
///Writes a string to a text file.
///</summary>
///<param name="text">The text to write.</param>
///<param name="fileName">Name of the file.</param>
///<param name="folder">The folder.</param>
///<param name="options">
///The enum value that determines how responds if the fileName is the same
///as the name of an existing file in the current folder. Defaults to ReplaceExisting.
///</param>
///<returns></returns>
public static async Task WriteToFile(
this string text,
string fileName,
StorageFolder folder = null,
CreationCollisionOption options = CreationCollisionOption.ReplaceExisting)
{
folder = folder ?? ApplicationData.Current.LocalFolder;
var file = await folder.CreateFileAsync(
fileName,
options);
using (var fs = await file.OpenAsync(FileAccessMode.ReadWrite))
{
using (var outStream = fs.GetOutputStreamAt(0))
{
using (var dataWriter = new DataWriter(outStream))
{
if (text != null)
dataWriter.WriteString(text);
await dataWriter.StoreAsync();
dataWriter.DetachStream();
}
await outStream.FlushAsync();
}
}
}
}
}
    Cela a fonctionné mieux que le "simple exemple". Probablement parce que ce code nettoie avec des méthodes comme FlushAsync. Je suis l'aide de VS2013 mise à jour 2, et les choses changent beaucoup dans ce domaine!

    OriginalL'auteur Filip Skakun