C#

public interface IPersist<T>
{
  void LoadLayout(T instance);
  void SaveLayout(T instance);
}

public class MyModel
{
  public string Name { get; set; }
  public string FriendlyName { get; set; }
  public DateTime LastLogin { get; set; }
}

public class MyModelPersistence : IPersist<MyModel>
{
  public void LoadLayout(MyModel instance)
  {
    // Work directly with items such as item.Name
  }

  public void SaveLayout(MyModel instance)
  {
    // Work directly with items such as item.Name
  }
}

Pete O'Hanlon wrote:

... once I really got into SOLID as a discipline

BillWoodruff wrote:

'm going to dare post an alternative take on generic interface on this thread based on your example

using System;
using System.IO;
using System.Runtime.Serialization;

namespace YourNameSpace
{
    public interface IPersist<T> where T : class
    {
        void LoadLayout();
        void SaveLayout();
    }

    [DataContract]
    public class MyModel : IPersist<MyModel>
    {
        // changed from VS 2015 legal auto-property with 'get only
        // to readonly string because VS 2013 does not that syntax
        private readonly string FilePath;

        public MyModel(string name, string fname, string filepath)
        {
            Name = name;
            FriendlyName = fname;
            FilePath = filepath;
            LastLogin = DateTime.Now;
        }

        [DataMember]
        public string Name { private set; get; }

        [DataMember]
        public string FriendlyName { private set; get; }

        [DataMember]
        public DateTime LastLogin { private set; get; }

        public void LoadLayout()
        {
            if (!File.Exists(FilePath)) throw new FileNotFoundException("Invalid file path");

            MyModel temp;

            try
            {
                temp = Persistence<MyModel>.LoadLayout(FilePath);
            }
            catch (Exception ex)
            {
                throw new InvalidDataContractException(string.Format("Failed to read data file: {0}", ex.Message),
                    ex.InnerException);
            }

            if (temp == null) throw new InvalidDataContractException("no data error");

            Name = temp.Name;
            FriendlyName = temp.FriendlyName;
            LastLogin = temp.LastLogin;
        }

        public void SaveLayout()
        {
            if (!File.Exists(FilePath)) throw new FileNotFoundException("Invalid file path");

            try
            {
                Persistence<MyModel>.SaveLayout(FilePath, this);
            }
            catch (Exception ex)
            {
                throw new InvalidDataContractException(string.Format("Failed to save to data file: {0}", ex.Message),
                    ex.InnerException);
            }
        }
    }

    internal static class Persistence<T> where T : class
    {
        // changed to private variable per suggestion Richard Deeming
        private static DataContractSerializer serializer;

        public static T LoadLayout(string filepath)
        {
            serializer = new DataContractSerializer(typeof (T));

            Console.WriteLine("Loading");

            T LoadedData = null;

            using (var reader = new FileStream(filepath, FileMode.Open, FileAccess.Read))
            {
                LoadedData = serializer.ReadObject(reader) as T;
            }

            return LoadedData;
        }

        public static void SaveLayout(string filepath, T instance)
        {
            serializer = new DataContractSerializer(typeof (T));

            Console.WriteLine("Saving");

            using (var writer = new FileStream(filepath, FileMode.Create, FileAccess.Write))
            {
                serializer.WriteObject(writer, instance);
            }
        }
    }
}

Richard Deeming wrote:

You've added a generic type parameter ... but you don't seem to use it anywher

Richard Deeming wrote:

serializer field ... should be a local variable in both methods.

Richard Deeming wrote:

missed the set; (or the body of the get;) on the FilePath auto-property.

BillWoodruff wrote:

That syntax is certainly legal/compilable in .NET 4.5. An "automatic" property with only a 'getter is de facto readonly.

'FilePath.get' must declare a body because it is not marked abstract or extern. Automatically implemented properties must define both get and set accessors.