private ZipReadOnlyObservableList(
IReadOnlyList <TOuter> outerSource, IReadOnlyList <TInner> innerSource,
PropertyObservableFactory <TOuter, TInner, TResult> selector,
Action <TResult> onRemove = null, Action <TResult, TResult> onChange = null)
: this(outerSource, innerSource, selector.Observe, onRemove, onChange)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="GroupingReadOnlyObservableListSource{TSource, TKey}" /> class.
/// </summary>
/// <param name="source">The source sequence.</param>
/// <param name="keySelector">The function used to obtain keys that represent the items.</param>
/// <param name="keyComparer">
/// The comparer used for key comparison. Specify <c>null</c> to use the default comparer for
/// <typeparamref name="TKey" />.
/// </param>
/// <param name="sourceComparer">
/// A comparer for the source items. This is only used if the source collection is not a list
/// and does not provide index information in its <see cref="NotifyCollectionChangedEventArgs" /> events.
/// </param>
public GroupingReadOnlyObservableListSource(IEnumerable <TSource> source,
Expression <Func <TSource, TKey> > keySelector, IEqualityComparer <TKey> keyComparer,
IEqualityComparer <TSource> sourceComparer)
: this(
source, item => PropertyObservableFactory <TSource, TKey> .CreateFrom(keySelector).Observe(item),
keyComparer, sourceComparer,
new ObservableCollection <ReadOnlyObservableGroup <TSource, TKey> >())
{
}
private InnerJoinReadOnlyObservableCollection(
IEnumerable <TOuter> outerSource, IEnumerable <TInner> innerSource,
PropertyObservableFactory <TOuter, TKey> outerKeySelector, PropertyObservableFactory <TInner, TKey> innerKeySelector,
PropertyObservableFactory <TOuter, TInner, TResult> resultSelector, IEqualityComparer <TKey> keyComparer = null,
IEqualityComparer <TOuter> outerComparer = null, IEqualityComparer <TInner> innerComparer = null)
: this(outerSource, innerSource, outerKeySelector.Observe, innerKeySelector.Observe, resultSelector.Observe,
keyComparer, outerComparer, innerComparer)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="InnerJoinReadOnlyObservableCollection{TOuter, TInner, TKey, TResult}"/> class.
/// </summary>
/// <param name="outerSource">The outer source.</param>
/// <param name="innerSource">The inner source.</param>
/// <param name="outerKeySelector">The outer key selector.</param>
/// <param name="innerKeySelector">The inner key selector.</param>
/// <param name="resultSelector">The result selector.</param>
/// <param name="keyComparer">The key comparer.</param>
/// <param name="outerComparer">The comparer of outer items.</param>
/// <param name="innerComparer">The comparer of inner items.</param>
/// <exception cref="ArgumentNullException">
/// outerSource
/// or
/// innerSource
/// or
/// outerKeySelector
/// or
/// innerKeySelector
/// or
/// resultSelector
/// </exception>
public InnerJoinReadOnlyObservableCollection(
IEnumerable <TOuter> outerSource, IEnumerable <TInner> innerSource,
Expression <Func <TOuter, TKey> > outerKeySelector, Expression <Func <TInner, TKey> > innerKeySelector,
Expression <Func <TOuter, TInner, TResult> > resultSelector, IEqualityComparer <TKey> keyComparer = null,
IEqualityComparer <TOuter> outerComparer = null, IEqualityComparer <TInner> innerComparer = null)
: this(outerSource, innerSource,
PropertyObservableFactory <TOuter, TKey> .CreateFrom(outerKeySelector),
PropertyObservableFactory <TInner, TKey> .CreateFrom(innerKeySelector),
PropertyObservableFactory <TOuter, TInner, TResult> .CreateFrom(resultSelector),
keyComparer, outerComparer, innerComparer)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="SortedReadOnlyObservableList{TSource}"/> class.
/// </summary>
/// <param name="source">The source collection.</param>
/// <param name="keySelector">The key generator.</param>
/// <param name="comparer">The comparison used to establish the order of elements (and keys).</param>
public KeySortedReadOnlyObservableList(IEnumerable <TSource> source, Expression <Func <TSource, TKey> > keySelector,
IComparer <TKey> comparer) : this(source,
item => PropertyObservableFactory <TSource, TKey> .CreateFrom(keySelector).Observe(item),
comparer == null ? null as Comparison <TKey> : comparer.Compare,
null)
{
}
/// <summary>
/// Finds the properties that can affect the result of the specified function.
/// </summary>
/// <typeparam name="TFirst">The type of the first input.</typeparam>
/// <typeparam name="TSecond">The type of the second input.</typeparam>
/// <typeparam name="TResult">The type of the result.</typeparam>
/// <param name="function">The function.</param>
/// <returns>
/// A <see cref="PropertyObservableFactory{TItem, TSecond, TResult}"/> that can be used to
/// create <see cref="IObservable{TResult}"/> efficiently.
/// </returns>
public static PropertyObservableFactory <TFirst, TSecond, TResult> FindProperties <TFirst, TSecond, TResult>(
this Expression <Func <TFirst, TSecond, TResult> > function)
{
return(PropertyObservableFactory <TFirst, TSecond, TResult> .CreateFrom(function));
}
/// <summary>
/// Finds the properties that can affect the result of the specified function.
/// </summary>
/// <typeparam name="TItem">The type of the item.</typeparam>
/// <typeparam name="TResult">The type of the result.</typeparam>
/// <param name="function">The function.</param>
/// <returns>
/// A <see cref="PropertyObservableFactory{TItem, TResult}"/> that can be used to
/// create <see cref="IObservable{TResult}"/> efficiently.
/// </returns>
public static PropertyObservableFactory <TItem, TResult> FindProperties <TItem, TResult>(
this Expression <Func <TItem, TResult> > function) where TItem : INotifyPropertyChanged
{
return(PropertyObservableFactory <TItem, TResult> .CreateFrom(function));
}
/// <summary>
/// Creates an <see cref="System.IObservable{T}"/> of a value that can be calculated based on the instance's properties.
/// </summary>
/// <typeparam name="TItem">The type of the instance.</typeparam>
/// <typeparam name="TResult">The type of the observed value.</typeparam>
/// <param name="item">The instance.</param>
/// <param name="expression">The expression that calculates the value.</param>
/// <returns>The observable</returns>
/// <remarks>
/// The properties that can affect the observable value will be automatically obtained from
/// <paramref name="expression"/> using reflection. This may result in observing unnecessary
/// read-only properties, as the <see cref="INotifyPropertyChanged"/> does not allow to know
/// in advance which properties can generate change notifications.
/// </remarks>
public static IObservable <TResult> Observe <TItem, TResult>(this TItem item,
System.Linq.Expressions.Expression <Func <TItem, TResult> > expression) where TItem : INotifyPropertyChanged
{
return(PropertyObservableFactory <TItem, TResult> .CreateFrom(expression).Observe(item));
}
public Definition(Expression <Func <TElement, TKey> > keySelector, IComparer <TKey> comparer = null)
: this(item => PropertyObservableFactory <TElement, TKey> .CreateFrom(keySelector).Observe(item), comparer)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="PrefixReadOnlyObservableList{T}"/> class.
/// </summary>
/// <param name="source">The source list.</param>
/// <param name="selector">The condition.</param>
/// <param name="comparer">The comparer of source items.</param>
/// <param name="onRemove">The function that is called when removing an item.</param>
/// <param name="onChange">The function that is called when the result assigned to a pair changes.</param>
public PrefixReadOnlyObservableList(IReadOnlyList <T> source, Expression <Func <T, bool> > selector,
IEqualityComparer <T> comparer = null, Action <bool> onRemove = null, Action <bool, bool> onChange = null)
: this(source, PropertyObservableFactory <T, bool> .CreateFrom(selector), comparer, onRemove, onChange)
{
}
private PrefixReadOnlyObservableList(IReadOnlyList <T> source, PropertyObservableFactory <T, bool> selector,
IEqualityComparer <T> comparer = null, Action <bool> onRemove = null, Action <bool, bool> onChange = null)
: this(source, selector.Observe, comparer, onRemove, onChange)
{
}
