Self-Tracking Entities Part 1 - Fundamentals

[Test]
public void Updating_Repository_Sets_HasChanges_On_Repository_To_True()
{
  var author = repository.Find(a => a.Name == "John Doe");

  Assert.IsFalse(repository.HasChanges);

  author.Name = "John William Doe";

  Assert.IsFalse(repository.HasChanges);

  repository.Update(author);

  Assert.IsTrue(repository.HasChanges);
}

[Test]
public void Modifying_Entity_Sets_HasChanges_On_Repository_And_Entity_To_True()
{
  var author = repository.Find(a => a.Name == "John Doe");

  Assert.IsFalse(repository.HasChanges);
  Assert.IsFalse(author.HasChanges);

  author.Name = "John William Doe";

  Assert.IsTrue(repository.HasChanges);
  Assert.IsTrue(author.HasChanges);
}

public interface IRepository<TEntity>
{
  IEnumerable<TEntity> GetAll();
  bool ContainsItem(TEntity entity);
  void AddItem(TEntity entity);
  void RemoveItem(TEntity entity);
  void ClearItems();
  TEntity Find(Func<TEntity, bool> expression);
  IQueryable<TEntity> FindAll(Func<TEntity, bool> expression);
}

public interface IUnitOfWork<TEntity>
{
  void Insert(TEntity entity);
  void Update(TEntity entity);
  void Delete(TEntity entity);
  void RejectChanges();
  void SaveChanges();
}

public interface IUnitOfWork<TEntity>
{
  void Insert(TEntity entity);
  void Update(TEntity entity);
  void Delete(TEntity entity);

  event EventHandler HasChangesChanged;
  bool HasChanges { get; }
  void AcceptChanges();
  void RejectChanges();
  IChangeTracker<TEntity> ChangeTracker { get; }

  event EventHandler<SaveCompletedEventArgs> SaveChangesCompleted;
  void SaveChangesAsync();
  void SaveChanges();
}

public abstract class RepositoryBase<TEntity> : IUnitOfWorkRepository<TEntity>
{
  private readonly ICollection<TEntity> _items = new HashSet<TEntity>();
  protected ICollection<TEntity> InternalItems
  {
    get
    {
      return _items;
    }
  }
  
  public void AddItem(TEntity entity)
  {
    lock (_syncRoot)
    {
      if (!InternalItems.Contains(entity))
      {
        AddItemInternal(entity);
      }
      else
      {
        throw new InvalidOperationException("Entity has already been added to repository");
      }
    }
  }
  private void AddItemInternal(TEntity entity)
  {
    InternalItems.Add(entity);
    OnItemAdded(entity);
  }
  protected virtual void OnItemAdded(TEntity entity)
  { }

  public void RemoveItem(TEntity entity)
  {
    lock (_syncRoot)
    {
      if (InternalItems.Contains(entity) || ChangeTracker.ContainsDeleted(entity))
      {
        RemoveItemInternal(entity);
        ChangeTracker.RemoveItem(entity);
      }
    }
  }
  private void RemoveItemInternal(TEntity entity)
  {
    InternalItems.Remove(entity);
    OnItemRemoved(entity);
  }
  protected virtual void OnItemRemoved(TEntity entity)
  { }
  
  public void ClearItems()
  {
    lock (_syncRoot)
    {
      IList<TEntity> itemsCopy = new List<TEntity>(InternalItems.Union(ChangeTracker.Deleted));
      foreach (TEntity item in itemsCopy)
      {
        RemoveItem(item);
      }
    }
  }

  public TEntity Find(Func<TEntity, bool> expression)
  {
    return InternalItems.Where(expression).SingleOrDefault();
  }

  public IQueryable<TEntity> FindAll(Func<TEntity, bool> expression)
  {
    return InternalItems.Where(expression).AsQueryable();
  }
  
  // ...
}

public virtual void Insert(TEntity entity)
{
  lock (_syncRoot)
  {
    if (!InternalItems.Contains(entity))
    {
      ChangeTracker.Insert(entity);
      AddItemInternal(entity);
    }
    else
    {
      throw new InvalidOperationException("Entity has not yet been added to repository");
    }
  }
}

public virtual void Update(TEntity entity)
{
  lock (_syncRoot)
  {
    if (InternalItems.Contains(entity))
    {
      if (ChangeTracker.ContainsDeleted(entity))
      {
        ChangeTracker.RemoveDeleted(entity);
      }

      if (!ChangeTracker.ContainsInserted(entity) && !ChangeTracker.ContainsChanged(entity))
      {
        ChangeTracker.Update(entity);
      }
    }
    else
    {
      throw new InvalidOperationException("Entity has not yet been added to repository");
    }
  }
}

public virtual void Delete(TEntity entity)
{
  lock (_syncRoot)
  {
    if (InternalItems.Contains(entity))
    {
      bool doDelete = true;

      if (ChangeTracker.ContainsInserted(entity))
      {
        ChangeTracker.RemoveInserted(entity);
        doDelete = false;
      }

      if (ChangeTracker.ContainsChanged(entity))
      {
        ChangeTracker.RemoveChanged(entity);
      }

      if (doDelete)
      {
        ChangeTracker.Delete(entity);
      }

      RemoveItemInternal(entity);
    }
    else
    {
      throw new InvalidOperationException("Entity has not yet been added to repository");
    }
  }
}

public virtual void RejectChanges()
{
  foreach (TEntity entity in ChangeTracker.Deleted)
  {
    AddItem(entity);
  }

  foreach (TEntity entity in ChangeTracker.Inserted)
  {
    RemoveItem(entity);
  }

  ChangeTracker.Reset();
}

public virtual void AcceptChanges()
{
  ChangeTracker.Reset();
}

public event EventHandler HasChangesChanged;
protected void NotifyHasChangesChangedListeners()
{
  EventHandler handler = HasChangesChanged;
  if (handler != null)
  {
    handler(this, new EventArgs());
  }
}

public bool HasChanges
{
  get
  {
    return ChangeTracker.HasChanges;
  }
}

public interface IChangeTracker<TEntity>
{
  IEnumerable<TEntity> Inserted { get; }
  void Insert(TEntity entity);
  bool ContainsInserted(TEntity entity);
  void RemoveInserted(TEntity entity);
  
  IEnumerable<TEntity> Changed { get; }
  void Update(TEntity entity);
  bool ContainsChanged(TEntity entity);
  void RemoveChanged(TEntity entity);

  IEnumerable<TEntity> Deleted { get; }
  void Delete(TEntity entity);
  bool ContainsDeleted(TEntity entity);
  void RemoveDeleted(TEntity entity);

  event EventHandler HasChangesChanged;
  bool HasChanges { get; }

  void RemoveItem(TEntity item);
  void Reset();
}

public sealed class RepositoryStateManager<TEntity> : IChangeTracker<TEntity>
{
  private readonly object _syncRoot = new object();

  private void OnStateChanged()
  {
    lock (_syncRoot)
    {
      HasChanges = _deleted.Count > 0 || _changed.Count > 0 || _inserted.Count > 0;
    }
  }

  public event EventHandler HasChangesChanged;
  private void NotifyHasChangesChangedListeners()
  {
    EventHandler handler = HasChangesChanged;
    if (handler != null)
    {
      handler(this, new EventArgs());
    }
  }

  private bool _hasChanges;
  public bool HasChanges 
  { 
    get
    {
      return _hasChanges;
    }
    private set
    {
      if (_hasChanges != value)
      {
        _hasChanges = value;
        NotifyHasChangesChangedListeners();
      }
    }
  }

  public void RemoveItem(TEntity item)
  {
    lock (_syncRoot)
    {
      _inserted.Remove(item);
      _changed.Remove(item);
      _deleted.Remove(item);

      OnStateChanged();
    }
  }

  private readonly ICollection<TEntity> _deleted = new HashSet<TEntity>();
  public IEnumerable<TEntity> Deleted
  {
    get
    {
      lock (_syncRoot)
      {
        return new List<TEntity>(_deleted);
      }
    }
  }
  public bool ContainsDeleted(TEntity entity)
  {
    return _deleted.Contains(entity);
  }
  public void RemoveDeleted(TEntity entity)
  {
    lock (_syncRoot)
    {
      _deleted.Remove(entity);
      OnStateChanged();
    }
  }
  public void Delete(TEntity entity)
  {
    lock (_syncRoot)
    {
      _deleted.Add(entity);
      OnStateChanged();
    }
  }

  private readonly ICollection<TEntity> _changed = new HashSet<TEntity>();
  public IEnumerable<TEntity> Changed
  {
    get
    {
      lock (_syncRoot)
      {
        return new List<TEntity>(_changed);
      }
    }
  }
  public bool ContainsChanged(TEntity entity)
  {
      return _changed.Contains(entity);
  }
  public void RemoveChanged(TEntity entity)
  {
    lock (_syncRoot)
    {
      _changed.Remove(entity);
      OnStateChanged();
    }
  }
  public void Update(TEntity entity)
  {
    lock (_syncRoot)
    {
      _changed.Add(entity);
      OnStateChanged();
    }
  }

  private readonly ICollection<TEntity> _inserted = new HashSet<TEntity>();
  public IEnumerable<TEntity> Inserted
  {
    get
    {
      lock (_syncRoot)
      {
        return new List<TEntity>(_inserted);
      }
    }
  }
  public bool ContainsInserted(TEntity entity)
  {
    return _inserted.Contains(entity);
  }
  public void RemoveInserted(TEntity entity)
  {
    lock (_syncRoot)
    {
      _inserted.Remove(entity);
      OnStateChanged();
    }
  }
  public void Insert(TEntity entity)
  {
    lock (_syncRoot)
    {
      _inserted.Add(entity);
      OnStateChanged();
    }
  }

  public void Reset()
  {
    lock (_syncRoot)
    {
      _changed.Clear();
      _inserted.Clear();
      _deleted.Clear();

      HasChanges = false;
    }
  }
}

public interface IRepository<TEntity>
{
  IReadOnlyCollection<TEntity> GetAll();
  // ...
}

public interface IChangeTracker<TEntity>
{
  IReadOnlyCollection<TEntity> Inserted { get; }
  IReadOnlyCollection<TEntity> Changed { get; }
  IReadOnlyCollection<TEntity> Deleted { get; }
  // ...
}

public abstract class RepositoryBase<TEntity> : IUnitOfWorkRepository<TEntity>
{
  private IImmutableSet<TEntity> _items = ImmutableHashSet<TEntity>.Empty;
  public IReadOnlyCollection<TEntity> GetAll()
  {
    return _items;
  }
  private void AddItemInternal(TEntity entity)
  {
    _items = _items.Add(entity);

    OnItemAdded(entity);
  }
  private void RemoveItemInternal(TEntity entity)
  {
    _items = _items.Remove(entity);

    OnItemRemoved(entity);
  }
  
  // ...
}

public sealed class RepositoryStateManager<TEntity> : IChangeTracker<TEntity>
{
  private IImmutableSet<TEntity> _changed = ImmutableHashSet<TEntity>.Empty;
  public IReadOnlyCollection<TEntity> Changed
  {
    get
    {
      return _changed;
    }
  }
  public void RemoveChanged(TEntity entity)
  {
    lock (_syncRoot)
    {
      _changed = _changed.Remove(entity);

      OnStateChanged();
    }
  }
  public void Update(TEntity entity)
  {
    lock (_syncRoot)
    {
      _changed = _changed.Add(entity);

      OnStateChanged();
    }
  }
  // ... 
}