LinqObservableCollection.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="LinqObservableCollection.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Synchronized view over a source list, </summary>
//-----------------------------------------------------------------------
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Linq;
using System.Linq.Expressions;
 
namespace Csla
{
  public class LinqObservableCollection<T> : IList<T>, ICollection<T>, IEnumerable<T>, 
    IList, ICollection, INotifyCollectionChanged
  {
    public event System.Collections.Specialized.NotifyCollectionChangedEventHandler CollectionChanged;
 
    private System.Collections.ObjectModel.ObservableCollection<T> _baseCollection;
    private List<T> _filteredCollection;
    private bool _suppressEvents = false;
    public LinqObservableCollection(System.Collections.ObjectModel.ObservableCollection<T> source, IEnumerable<T> queryResult)
      : this(source, queryResult.ToList())
    { }
 
    public LinqObservableCollection(System.Collections.ObjectModel.ObservableCollection<T> source, List<T> queryResult)
    {
      _filteredCollection = queryResult;
      _baseCollection = source;
      _baseCollection.CollectionChanged += (o, e) =>
        {
          if (!_suppressEvents)
          {
            NotifyCollectionChangedEventArgs newE = null;
            T item;
            int index;
            switch (e.Action)
            {
              case NotifyCollectionChangedAction.Add:
                item = (T)e.NewItems[0];
                index = e.NewStartingIndex;
                if (index > _filteredCollection.Count)
                  index = _filteredCollection.Count;
                _filteredCollection.Insert(index, item);
                newE = new NotifyCollectionChangedEventArgs(
                  e.Action, item, _filteredCollection.IndexOf(item));
                break;
              case NotifyCollectionChangedAction.Remove:
                item = (T)e.OldItems[0];
                index = _filteredCollection.IndexOf(item);
                if (index > -1)
                {
                  _filteredCollection.Remove(item);
                  newE = new NotifyCollectionChangedEventArgs(e.Action, item, index);
                }
                break;
              case NotifyCollectionChangedAction.Replace:
                index = _filteredCollection.IndexOf((T)e.OldItems[0]);
                if (index > -1)
                {
                  _filteredCollection[index] = (T)e.NewItems[0];
                  newE = new NotifyCollectionChangedEventArgs(
                    e.Action,
                    e.NewItems, e.OldItems, index);
                }
                break;
              case NotifyCollectionChangedAction.Reset:
                if (source.Count == 0)
                {
                  _filteredCollection.Clear();
                  newE = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset);
                }
                break;
              default:
                break;
            }
            if (newE != null)
              OnCollectionChanged(newE);
          }
        };
    }
 
    protected virtual void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
    {
      if (!_suppressEvents && CollectionChanged != null)
        CollectionChanged(this, e);
    }
 
    public IList<T> Source
    {
      get { return _baseCollection; }
    }
 
    public List<T> QueryResult
    {
      get { return _filteredCollection; }
    }
 
    public int IndexOf(T item)
    {
      return _filteredCollection.IndexOf(item);
    }
 
    public void Insert(int index, T item)
    {
      _baseCollection.Insert(index, item);
    }
 
    public void RemoveAt(int index)
    {
      _baseCollection.Remove(_filteredCollection[index]);
    }
 
    public T this[int index]
    {
      get
      {
        return _filteredCollection[index];
      }
      set
      {
        var idx = _baseCollection.IndexOf(_filteredCollection[index]);
        _baseCollection[idx] = value;
      }
    }
 
    public void Add(T item)
    {
      _baseCollection.Add(item);
    }
 
    public void Clear()
    {
      _suppressEvents = true;
      foreach (var item in _filteredCollection)
        _baseCollection.Remove(item);
      _suppressEvents = false;
      _filteredCollection.Clear();
      OnCollectionChanged(
        new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
    }
 
    public bool Contains(T item)
    {
      return _filteredCollection.Contains(item);
    }
 
    public void CopyTo(T[] array, int arrayIndex)
    {
      _filteredCollection.CopyTo(array, arrayIndex);
    }
 
    public int Count
    {
      get { return _filteredCollection.Count; }
    }
 
    public bool IsReadOnly
    {
      get 
      {
        var obj = _baseCollection as ICollection<T>;
        if (obj != null)
          return obj.IsReadOnly;
        else
          return false; 
      }
    }
 
    public bool Remove(T item)
    {
      return _baseCollection.Remove(item);
    }
 
    public IEnumerator<T> GetEnumerator()
    {
      return _filteredCollection.GetEnumerator();
    }
 
    IEnumerator IEnumerable.GetEnumerator()
    {
      return _filteredCollection.GetEnumerator();
    }
 
    public int Add(object value)
    {
      return ((IList)_baseCollection).Add(value);
    }
 
    public bool Contains(object value)
    {
      return _filteredCollection.Contains((T)value);
    }
 
    public int IndexOf(object value)
    {
      return _filteredCollection.IndexOf((T)value);
    }
 
    public void Insert(int index, object value)
    {
      _baseCollection.Insert(index, (T)value);
    }
 
    public bool IsFixedSize
    {
      get { return ((IList)_baseCollection).IsFixedSize; }
    }
 
    public void Remove(object value)
    {
      _baseCollection.Remove((T)value);
    }
 
    object IList.this[int index]
    {
      get
      {
        return this[index];
      }
      set
      {
        this[index] = (T)value;
      }
    }
 
    public void CopyTo(Array array, int index)
    {
      ((IList)_filteredCollection).CopyTo(array, index);
    }
 
    public bool IsSynchronized
    {
      get { return ((IList)_baseCollection).IsSynchronized; }
    }
 
    public object SyncRoot
    {
      get { return ((IList)_baseCollection).SyncRoot; }
    }
  }
 
  public static class LinqObservableCollectionExtension
  {
    public static LinqObservableCollection<C> ToSyncList<C>(this IEnumerable<C> queryResult, System.Collections.ObjectModel.ObservableCollection<C> source)
    {
      return new LinqObservableCollection<C>(source, queryResult);
    }
 
    public static LinqObservableCollection<C> ToSyncList<C>(this System.Collections.ObjectModel.ObservableCollection<C> source, IEnumerable<C> queryResult)
    {
      return new LinqObservableCollection<C>(source, queryResult);
    }
 
    public static LinqObservableCollection<C> ToSyncList<C>(this System.Collections.ObjectModel.ObservableCollection<C> source, Expression<Func<C, bool>> expr)
    {
      IEnumerable<C> sourceEnum = source.AsEnumerable<C>();
      var output = sourceEnum.Where<C>(expr.Compile());
      return new LinqObservableCollection<C>(source, output.ToList());
    }
  }
}