Detecting changes within serializable data classes in C#

Question

I've been experimenting with detecting changes in plain objects in C#. The aim being to have a container-type class for a bunch of data objects that can react when any one of them changes. For fun I wanted to see if all the work could be done in the container class, rather than resort to properties and dirty flags or events on the objects themselves.

What I'm curious about is whether there is a smart, fast and efficient way of doing this. My attempt is below, and it's none of those (the 'CheckStates' method would need to be called every frame for a start!) I've restricted it to only allow one instance per type, which suits my needs.

Note that an object passed in might be as follows:

[Serializable]
public class PlayerInfo
{
    public string name = string.Empty;
    public int score = 0;
}

Then the container:

public class AppState
{
    private class StateData
    {
        public System.Object instance = null;
        public Byte[] currentState = new Byte[0];
        public Byte[] previousState = new Byte[0];
    }

    private Dictionary<Type, StateData> _allStates = new Dictionary<Type, StateData>();
    private BinaryFormatter _formatter = new BinaryFormatter();
    private MemoryStream _memoryStream = new MemoryStream();

    public T GetState<T>() where T : class, new()
    {
        T state = default(T);

        var stateType = typeof(T);
        StateData stateData;
        if(_allStates.TryGetValue(stateType, out stateData))
        {
            state = ReadData<T>(stateData);
        }
        else
        {
            var newState = CreateData<T>(out state);
            _allStates[stateType] = newState;
        }

        return state;
    }

    public void CheckStates()
    {
        foreach(var state in _allStates)
        {
            if(HasChanged(state.Value))
            {
                Console.WriteLine(state.Key.ToString() + " has changed");
                UpdateState(state.Value);
            }
        }
    }

    private StateData CreateData<T>(out T instance) where T : class, new()
    {
        instance = new T();

        var stateData = new StateData();
        stateData.instance = instance;
        _formatter.Serialize(_memoryStream, instance);
        var bytes = _memoryStream.ToArray();
        stateData.currentState = bytes;
        stateData.previousState = bytes;

        return stateData;
    }

    private T ReadData<T>(StateData data) where T : class, new()
    {
        return data.currentState as T;
    }

    private bool HasChanged(StateData data)
    {
        _memoryStream.Position = 0;
        _formatter.Serialize(_memoryStream, data.instance);
        var current = _memoryStream.ToArray();
        var previous = data.previousState;
        if(current.Length != previous.Length)
        {
            return true;
        }
        for(int i = 0; i < current.Length; ++i)
        {
            if(current[i] != previous[i])
            {
                return true;
            }
        }
        return false;
    }

    private void UpdateState(StateData data)
    {
        _memoryStream.Position = 0;
        _formatter.Serialize(_memoryStream, data.instance);
        data.previousState = _memoryStream.ToArray();
    }
}

Alternatives I could think of were:

• use structs instead of serializable classes (being forced to pass by value would mean that any change would have to go through a 'set' method on the container)
• have the AppState's 'GetState' method return an IDisposable wrapper, which on Dispose could trigger a check for changes on that type (only problem is that there's nothing to stop someone from storing a reference to the object and modifying it without the container knowing)

EDIT: should add that it doesn't need to be thread-safe

Answer 1

I don't regard serializable classes as POCO, because you're engineering the classes so that they work with your change detection mechanism. So I wouldn't call them plain.

Your alternatives:

use structs instead of serializable classes

Don't use mutable structs Why are mutable structs “evil”?. And if your struct is immutable, then you might as well pass by reference, i.e. have a class.

have the 'get' method return an IDisposable wrapper

I'm not sure what get method you are referring to.

Proxy

One alternative is to allow a descendant proxy to react to calls to the setters:

public class PlayerInfo
{
    public virtual string Name { get; set; }
    public virtual int Score { get; set; }
}

public class PlayerInfoDetection : PlayerInfo
{
    public int Revision { get; private set; }

    public override string Name
    {
        set
        {
            base.Name = value;
            Revision++;
        }
    }

    public override int Score
    {
        set
        {
            base.Score = value;
            Revision++;
        }
    }
}

private static void Example()
{
    PlayerInfo pi = new PlayerInfoDetection();
    Console.WriteLine(((PlayerInfoDetection)pi).Revision);
    pi.Name = "weston";
    Console.WriteLine(((PlayerInfoDetection)pi).Revision);
    pi.Score = 123;
    Console.WriteLine(((PlayerInfoDetection)pi).Revision);
}

This is how NHibernate "watches" objects fetched from the database, and why every object property must be virtual in NHibernate.

Aspect orientated

The same could be achieved with a product like post sharp where you could annotate your class to tell it when the revision must be changed.

public class PlayerInfo
{
    public int Revision { get; private set; }
    public string Name { get; [IncreaseRevision] set; }
    public int Score { get; [IncreaseRevision] set; }
}

Making use of a well implemented hash function

Hash functions should not change their value while the object is in a container such as a hash set. We can make use of this to detect changes.

Drawback Note that any Hash collisions will yield incorrect results. This includes duplicates.

[TestClass]
public class ChangeDetectUnitTest
{
    public class ChangeDetectList<T>
    {
        private readonly List<T> list = new List<T>();
        private readonly ISet<T> hashes = new HashSet<T>();

        public bool HasChanged(T t)
        {
            return !hashes.Contains(t);
        }

        public void Add(T t)
        {
            list.Add(t);
            hashes.Add(t);
        }

        public void Reset()
        {
            hashes.Clear();
            foreach (var t in list)
                hashes.Add(t);
        }
    }

    public class PlayerInfo
    {
        public string Name { get; set; }
        public int Score { get; set; }
        public override int GetHashCode()
        {
            //every field that you want to detect must feature in the hashcode
            return (Name ?? "").GetHashCode() * 31 + Score;
        }
        public override bool Equals(object obj)
        {
            return Equals(obj as PlayerInfo);
        }
        public bool Equals(PlayerInfo other)
        {
            if (other == null) return false;
            return Equals(other.Name, Name) && Score == Score;
        }
    }

    private ChangeDetectList<PlayerInfo> list;

    [TestInitialize]
    public void Setup()
    {
        list = new ChangeDetectList<PlayerInfo>();
    }

    [TestMethod]
    public void Can_add()
    {
        var p1 = new PlayerInfo();
        list.Add(p1);
        Assert.IsFalse(list.HasChanged(p1));
    }

    [TestMethod]
    public void Can_detect_change()
    {
        var p1 = new PlayerInfo();
        list.Add(p1);
        p1.Name = "weston";
        Assert.IsTrue(list.HasChanged(p1));
    }

    [TestMethod]
    public void Can_reset_change()
    {
        var p1 = new PlayerInfo();
        list.Add(p1);
        p1.Name = "weston";
        list.Reset();
        Assert.IsFalse(list.HasChanged(p1));
    }
}