Question

I have an ObservableCollection<Data> Items

Data has a “Columns” property on it which is again an ObservableCollection<Column>.

A Column object has a boolean property called “IsActive”.

I have a case where I need to determine if all “Items” have the “Columns” property and if so,
all the columns should either have “IsActive” as true or false but not both.

The trick is i need to put this logic in CanExecute of a button.. I will need to make this as efficient and fast as possible…Any ideas?
The struture is:

public class MyClass
{
     public ObservableCollection<Data> Items
    {
         get{return _items;}
     }
}

public class Data
{
    public ObservableCollection<Column> Columns
    {
         get{return _columns;}
     }
}

public class Column
{

   public bool IsActive{ get; set;}

}

Thanks!

Answer 1

This smells like premature optimization. Have you measured the speed of a simplistic approach? Iterating through a few not too big collections will only take a few milliseconds on a modern CPU.

If you want to use LINQ to compute if all Column objects are either active or inactive you can use this expression.

public Boolean CanExecute {
  get {
    var aggregate = Items
      .SelectMany(i => i.Columns)
      .Aggregate(
        new {
          IsEmpty = true,
          AllAreActive = true,
          AllAreInactive = true
        },
        (a, c) => new {
          IsEmpty = false,
          AllAreActive = a.AllAreActive && c.IsActive,
          AllAreInactive = a.AllAreInactive && !c.IsActive
        }
    );
    return !aggregate.IsEmpty && (aggregate.AllAreActive || aggregate.AllAreInactive);
  }

This code will iterate over all elements in all collections. You can improve on this by using a for loop and breaking it when both boolean variables becomes false. This can also by done in LINQ using TakeWhile using a predicate with side effects but a simple for loop is probably easier to understand.

If you decide that a simplistic approach is too slow you need to keep track of the CanExecute property at the MyClass level. You can do this by setting up change notification handlers for all the ObservableCollection instances. It is somewhat tedious because you have two levels of collections but it will ensure that whenever a Column is added or removed from a collection or the IsActive property is changed the boolean variable backing CanExecute in MyClass is updated.

Initially Column has to implement INotifyPropertyChanged:

class Column : INotifyPropertyChanged {

  Boolean isActive;

  public Boolean IsActive {
    get { return this.isActive; }
    set {
      if (this.isActive == value)
        return;
      this.isActive = value;
      OnPropertyChanged("IsActive");
    }
  }

  public event PropertyChangedEventHandler PropertyChanged;

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

}

Data has to expose the desired property which for lack of better name I have called AllColumnsAreActiveOrInactive and changes to this property is signaled by implementing INotifyPropertyChanged.

To track the status of all columns the CollectionChanged of the Column collection is handled. When a new Column is added the value of AllColumnsAreActiveOrInactive can be recomputed without iterating the Column collection. However, when IsActive changes on a single Column or when a Column is removed the collection has to be iterated to determine the new value of the AllColumnsAreActiveOrInactive.

class Data : INotifyPropertyChanged {

  readonly ObservableCollection<Column> columns;

  Boolean allColumnsAreActive = true;

  Boolean allColumnsAreInactive = true;

  Boolean allColumnsAreActiveOrInactive = false;

  public Data() {
    this.columns = new ObservableCollection<Column>();
    this.columns.CollectionChanged += CollectionChanged;
  }

  public ObservableCollection<Column> Columns { get { return this.columns; } }

  public Boolean AllColumnsAreActiveOrInactive {
    get { return this.allColumnsAreActiveOrInactive; }
    set {
      if (value == this.allColumnsAreActiveOrInactive)
        return;
      this.allColumnsAreActiveOrInactive = value;
      OnPropertyChanged("AllColumnsAreActiveOrInactive");
    }
  }

  public event PropertyChangedEventHandler PropertyChanged;

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

  void CollectionChanged(Object sender, NotifyCollectionChangedEventArgs e) {
    if (e.Action == NotifyCollectionChangedAction.Reset) {
      RecomputeAllColumnsAreActiveOrInactive();
      return;
    }
    if (e.OldItems != null) {
      foreach (var item in e.OldItems.Cast<Column>())
        item.PropertyChanged -= ColumnPropertyChanged;
      RecomputeAllColumnsAreActiveOrInactive();
      return;
    }
    if (e.NewItems != null) {
      foreach (var column in e.NewItems.Cast<Column>()) {
        column.PropertyChanged += ColumnPropertyChanged;
        this.allColumnsAreActive = this.allColumnsAreActive && column.IsActive;
        this.allColumnsAreInactive = this.allColumnsAreInactive && !column.IsActive;
      }
      UpdateAllColumnsAreActiveOrInactive();
    }
  }

  void ColumnPropertyChanged(Object sender, PropertyChangedEventArgs e) {
    if (e.PropertyName == "IsActive") {
      var column = sender as Column;
      RecomputeAllColumnsAreActiveOrInactive();
    }
  }

  void RecomputeAllColumnsAreActiveOrInactive() {
    this.allColumnsAreActive = this.columns.All(c => c.IsActive);
    this.allColumnsAreInactive = this.columns.All(c => !c.IsActive);
    UpdateAllColumnsAreActiveOrInactive();
  }

  void UpdateAllColumnsAreActiveOrInactive() {
    AllColumnsAreActiveOrInactive = this.columns.Any()
      && (this.allColumnsAreActive || this.allColumnsAreInactive);
  }

}

class Column : INotifyPropertyChanged {

  Boolean isActive;

  public Boolean IsActive {
    get { return this.isActive; }
    set {
      if (this.isActive == value)
        return;
      this.isActive = value;
      OnPropertyChanged("IsActive");
    }
  }

  public event PropertyChangedEventHandler PropertyChanged;

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

}

To complete this solution the Column/Data collection approach has to be repeated for the Data/MyClass collection.