static void Main(string[] args)
{
  var orders = new ObservableCollection<Order>()
    {
       new Order(1, 15),
       new Order(2, 15),
       new Order(3, 25),
       new Order(4, 27),
       new Order(5, 30),
       new Order(6, 75),
       new Order(7, 80),
    });
  //********************************************
  // We start using ObservableCalculations here!
  var expensiveOrders = from o in orders where o.Price > 25 select o; 
  checkFiltering(orders, expensiveOrders); 
  expensiveOrders.CollectionChanged += (sender, eventArgs) =>
  { 
    // see the changes (add, remove, replace, move, reset) here
  };
  // Start the changing...
  orders.Add(new Order(8, 30));
  orders.Add(new Order(9, 10));
  orders[0].Price = 60;
  orders[4].Price = 10;
  orders.Move(5, 1);
  orders[1] = new Order(10, 17);

  checkFiltering(orders, expensiveOrders); // Prints "True"

  var discountedOrders = from o in orders select new {o.Num, o.Price, o.Discount, DiscountedPrice = o.Price - o.Price * o.Discount / 100};

Expression<Func<Order, decimal>> discountedPriceExpression =
o => o.Price - o.Price * o.Discount / 100;

//********************************************
// We start using ObservableCalculations here!
Calculating<decimal> discountedPriceCalculating = 
    order.Using(discountedPriceExpression);

using System;
using System.ComponentModel;
using IBCode.ObservableCalculations;

namespace ObservableCalculationsExamples
{
    public class ObservableTimer : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        private int _seconds;
        public int Seconds
        {
            get => _seconds;
            set
            {
                _seconds = value;
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Seconds)));
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            ObservableTimer observableTimer = new ObservableTimer();
            Calculating<int> t = Expr.Is(() => observableTimer.Seconds + 1).Calculating();
            Calculating<bool> g = Expr.Is(() => t.Value > observableTimer.Seconds).Calculating();
            g.PropertyChanged += (sender, eventArgs) =>
            {
                if (eventArgs.PropertyName == nameof(Calculating<bool>.Value))
                    Console.WriteLine(g.Value);
            };

            observableTimer.Seconds++;
            observableTimer.Seconds++;

            Console.ReadLine();
        }

    }
}

True
True
True
True

False
True
False
True

S>static void Main(string[] args)
S>{
S>  var orders = new ObservableCollection<Order>()
S>    {
S>       new Order(1, 15),
S>       new Order(2, 15),
S>       new Order(3, 25),
S>       new Order(4, 27),
S>       new Order(5, 30),
S>       new Order(6, 75),
S>       new Order(7, 80),
S>    });
S>  //********************************************
S>  // We start using ObservableCalculations here!
S>  var expensiveOrders = from o in orders where o.Price > 25 select o; 
S>  checkFiltering(orders, expensiveOrders); 
S>  expensiveOrders.CollectionChanged += (sender, eventArgs) =>
S>  { 
S>    // see the changes (add, remove, replace, move, reset) here
S>  };
S>  // Start the changing...
S>  orders.Add(new Order(8, 30));
S>  orders.Add(new Order(9, 10));
S>  orders[0].Price = 60;
S>  orders[4].Price = 10;
S>  orders.Move(5, 1);
S>  orders[1] = new Order(10, 17);

S>  checkFiltering(orders, expensiveOrders); // Prints "True"
S>

S>  var discountedOrders = from o in orders select new {o.Num, o.Price, o.Discount, DiscountedPrice = o.Price - o.Price * o.Discount / 100};
S>

    CollectionCalculationSource<Order> orders = 
        new ObservableCollection<Order>(new []
        {
            new Order(1, 15),
            new Order(2, 15),
            new Order(3, 25),
            new Order(4, 27),
            new Order(5, 30),
            new Order(6, 75),
            new Order(7, 80),
        }).AsObservableCalculationSource();
    
    //********************************************
    // We start using ObservableCalculations here!
    var expensiveOrders = (from o in orders where o.Price > 25 select o).Observe();
    
    checkFiltering(orders, expensiveOrders); // Prints "True"
    
    expensiveOrders.CollectionChanged += (sender, eventArgs) =>
    {
        // see the changes (add, remove, replace, move, reset) here
    };

public static class ObservableHelper
{
  public static ObservableCollection<T> Where(this ObservableCollection<T> source, Predicate<T> predicate)
  public static ObservableCollection<R> Select(this ObservableCollection<T> source, Expression<Func<T, R>> selector )
}