Feedback

C# - Lazy Serialization-Extensions including Compression

Veröffentlicht von am 22.01.2011
(0 Bewertungen)
Mit den beiden folgenden Extensions-Methods könnt Ihr beliebige Objekte komprimiert serialisieren. Ihr findet unten auch ein kleines Beispiel, wie ich eine ExampleSettings-Klasse serialisiere.
GFU-Schulungen  [Anzeige]

VB.NET 2017/2015/2013 Aufbau

Nach dieser Schulung können Sie mittels objektorientierter Modelle in VB.NET 2017/2015/2013 wiederverwendbare Elemente eigenständig erstellen.

C# 2017/2015/2013 Grundlagen

Nach Abschluss des Kurses sind Ihnen die Datentypen und Klassenbibliotheken von C# bekannt. Außerdem sind Sie in der Lage, mit Variablen umzugehen und deren Typen zu konvertieren. Sie definieren Namespaces und setzen diese ein, Sie erstellen eigene Klassen  und bauen Trouble Shooting ein.

namespace CKing.Extensions
{
  using System.IO;
  using System.IO.Compression;
  using System.Runtime.Serialization.Formatters.Binary;
  using System.Xml.Serialization;

  public static class GenericExt
  {
    public static T Load<T>(this string path, bool binary)
    {
      try
      {
        if (path != null && File.Exists(path))
        {
          using (FileStream fs = new FileStream(path, FileMode.Open))
          {
            using (GZipStream zip = new GZipStream(fs, CompressionMode.Decompress))
            {
              if (!binary)
              {
                XmlSerializer xf = new XmlSerializer(typeof(T));
                return (T)xf.Deserialize(zip);
              }
              else
              {
                BinaryFormatter bf = new BinaryFormatter();
                return (T)bf.Deserialize(zip);
              }
            }
          }
        }
        return default(T);
      }
      catch
      {
        return default(T);
      }
    }

    public static bool Save<T>(this T obj, string path, bool binary)
    {
      try
      {
        DirectoryInfo di = new FileInfo(path).Directory;
        if (obj != null && di != null && di.Exists)
        {
          using (FileStream fs = new FileStream(path, FileMode.Create))
          {
            using (GZipStream zip = new GZipStream(fs, CompressionMode.Compress))
            {
              if (!binary)
              {
                XmlSerializer xf = new XmlSerializer(typeof(T));
                xf.Serialize(zip, obj);
              }
              else
              {
                BinaryFormatter bf = new BinaryFormatter();
                bf.Serialize(zip, obj);
              }
            }
          }
          return true;
        }
        return false;
      }
      catch
      {
        return false;
      }
    }
  }
}

namespace CKing.Settings
{
  using System;
  using System.ComponentModel;

  [Serializable]
  public class ExampleSettings : INotifyPropertyChanged
  {
    #region Fields & Properties

    private string _exampleProperty1 = string.Empty;

    public string ExampleProperty1
    {
      get { return this._exampleProperty1; }
      set { this.SetNotifyingProperty("ExampleProperty1", ref this._exampleProperty1, value); }
    }

    private string _exampleProperty2 = string.Empty;

    public string ExampleProperty2
    {
      get { return this._exampleProperty2; }
      set { this.SetNotifyingProperty("ExampleProperty2", ref this._exampleProperty2, value); }
    }

    #endregion Fields & Properties

    #region INotifyPropertyChanged Member

    public event PropertyChangedEventHandler PropertyChanged;

    private void OnPropertyChanged(String propertyName)
    {
      if (PropertyChanged != null)
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }

    private void SetNotifyingProperty<T>(string propertyName, ref T source, T value)
    {
      if (value.Equals(source))
        return;

      source = value;
      this.OnPropertyChanged(propertyName);
    }

    #endregion INotifyPropertyChanged Member
  }
}

namespace CKing.Application
{
  using System.IO;
  using System.Reflection;
  using CKing.Extensions;
  using CKing.Settings;

  class Program
  {
    static void Main(string[] args)
    {
      string appPath = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);

      Program.SettingsPath = Path.Combine(appPath, "CKing.Application.set");
      Program.Settings = Program.SettingsPath.Load<ExampleSettings>(false);
      if (Program.Settings == null)
        Program.Settings = new ExampleSettings();

      Program.Settings.ExampleProperty1 = "Mal was speichern...";
      Program.Settings.ExampleProperty2 = "...und beim nächsten Start wird es wieder geladen.";

      if (!Program.Settings.Save<ExampleSettings>(Program.SettingsPath, false))
      {
        System.Diagnostics.Debug.WriteLine("An error occured while trying to save the Application-Settings");
      }
    }

    #region Properties

    internal static ExampleSettings Settings { get; set; }

    internal static string SettingsPath { get; set; }

    #endregion Properties
  }
}

Kommentare zum Snippet

 

Logge dich ein, um hier zu kommentieren!