Speichern von Dateien auf Raspberry PI mit Windows IoT

Können Sie die Serialisierung für organisierte Lagerung als textuelle Speicherung.

Bin ich anbringen statische Klasse, die Datei enthält die Methode zum serialisieren und Deserialisieren wieder auf das ursprüngliche Objekt.

Download Source-Code

Nehmen wir ein Beispiel verallgemeinern. Angenommen, Sie haben Schüler und Mark-Klasse wie folgt:

///<summary>
///Provides structure for 'Student' entity
///</summary>
///'DataContract' attribute is necessary to serialize object of following class. By removing 'DataContract' attribute, the following class 'Student' will no longer be serialized
[DataContract]
public class Student
{
    [DataMember]
    public ushort Id { get; set; }

    [DataMember]
    public string UserName { get; set; }

    ///<summary>
    ///Password has been marked as non-serializable by removing 'DataContract'
    ///</summary>
    //[DataMember] //Password will not be serialized. Uncomment this line to serialize password
    public string Password { get; set; }

    [DataMember]
    public string FirstName { get; set; }

    [DataMember]
    public string LastName { get; set; }

    [DataMember]
    public List<Mark> Marks { get; set; }
}

[DataContract]
public class Mark
{
    [DataMember]
    public string Subject { get; set; }

    [DataMember]
    public short Percentage { get; set; }
}

Stellen Sie sicher, dass das Attribut '[DataContract]' auf calss und " [DataMember]' auf Daten, die Mitglied zu serialisieren Sie sonst ignoriert werden beim serialisieren Objekt

Jetzt, zu serialisieren und Deserialisieren, haben Sie folgende statische Klasse mit Save und Load Funktion:

///<summary>
///Provides functions to save and load single object as well as List of 'T' using serialization
///</summary>
///<typeparam name="T">Type parameter to be serialize</typeparam>
public static class SerializableStorage<T> where T : new()
{
    public static async void Save(string FileName, T _Data)
    {
        MemoryStream _MemoryStream = new MemoryStream();
        DataContractSerializer Serializer = new DataContractSerializer(typeof(T));
        Serializer.WriteObject(_MemoryStream, _Data);

        Task.WaitAll();

        StorageFile _File = await ApplicationData.Current.LocalFolder.CreateFileAsync(FileName, CreationCollisionOption.ReplaceExisting);

        using (Stream fileStream = await _File.OpenStreamForWriteAsync())
        {
            _MemoryStream.Seek(0, SeekOrigin.Begin);
            await _MemoryStream.CopyToAsync(fileStream);
            await fileStream.FlushAsync();
            fileStream.Dispose();
        }
    }

    public static async Task<T> Load(string FileName)
    {
        StorageFolder _Folder = ApplicationData.Current.LocalFolder;
        StorageFile _File;
        T Result;

        try
        {
            Task.WaitAll();
            _File = await _Folder.GetFileAsync(FileName);

            using (Stream stream = await _File.OpenStreamForReadAsync())
            {
                DataContractSerializer Serializer = new DataContractSerializer(typeof(T));

                Result = (T)Serializer.ReadObject(stream);

            }
            return Result;
        }
        catch (Exception ex)
        {
            return new T();
        }
    }
}

Nun, mal sehen, wie die store-Objekt von Student und rufen es wieder aus der Datei:

/* Create an object of Student class to store */
Student s1 = new Student();
s1.Id = 1;
s1.UserName = "Student1";
s1.Password = "Student123";
s1.FirstName = "Abc";
s1.LastName = "Xyz";
s1.Marks = new List<Mark>();

/* Create list of Marks */
Mark m1 = new Mark();
m1.Subject = "Computer";
m1.Percentage = 89;

Mark m2 = new Mark();
m2.Subject = "Physics";
m2.Percentage = 92;

/* Add marks into Student object */
s1.Marks.Add(m1);
s1.Marks.Add(m2);

/* Store Student object 's1' into file 'MyFile1.dat' */
SerializableStorage<Student>.Save("MyFile1.dat", s1);

/* Load stored student object from 'MyFile1.dat' */
Student s2 = await SerializableStorage<Student>.Load("MyFile1.dat");

Sie können die Serialisierung und de-Serialisierung für jede Klasse. Zum speichern von Objekt einer anderen Klasse als 'Studenten' angenommen, 'MyClass', ersetzen Sie einfach Student Art von " T " - parameter der Funktion, wie unten:

/* Store MyClass object 's1' into file 'MyFile1.dat' */
SerializableStorage<MyClass>.Save("MyFile1.dat", s1);

/* Load stored MyClass object from 'MyFile1.dat' */
MyClass s2 = await SerializableStorage<MyClass>.Load("MyFile1.dat");

HINWEIS: 'MyFile1.dat' gespeichert 'ApplicationData.Aktuelle.LocalFolder'. Dieser code ist getestet auf Windows 10 IoT-Core (10.0.10586.0) und können alle UWP-app.

Download Source-Code