ReactiveUI

IObservedChange is a generic interface that replaces the non-generic PropertyChangedEventArgs. Note that it is used for both Changing (i.e. 'before change') and Changed Observables. In the future, this interface will be Covariant which will allow simpler casting between specific and generic changes.

The object that has raised the change.

The name of the property that has changed on Sender.

The value of the property that has changed. IMPORTANT NOTE: This property is often not set for performance reasons, unless you have explicitly requested an Observable for a property via a method such as ObservableForProperty. To retrieve the value for the property, use the Value() extension method.

IReactiveNotifyPropertyChanged represents an extended version of INotifyPropertyChanged that also exposes Observables.

IEnableLogger is a dummy interface - attaching it to any class will give you access to the Log() method.

When this method is called, an object will not fire change notifications (neither traditional nor Observable notifications) until the return value is disposed.

An object that, when disposed, reenables change notifications.

Represents an Observable that fires *before* a property is about to be changed. Note that this should not fire duplicate change notifications if a property is set to the same value multiple times.

Represents an Observable that fires *after* a property has changed. Note that this should not fire duplicate change notifications if a property is set to the same value multiple times.

IReactiveNotifyPropertyChanged of TSender is a helper interface that adds typed versions of Changing and Changed.

IReactiveCollection represents a collection that can notify when its contents are changed (either items are added/removed, or the object itself changes). It is important to implement the Changing/Changed from IReactiveNotifyPropertyChanged semantically as "Fire when *anything* in the collection or any of its items have changed, in any way".

Fires when items are added to the collection, once per item added. Functions that add multiple items such AddRange should fire this multiple times. The object provided is the item that was added.

Fires before an item is going to be added to the collection.

Fires once an item has been removed from a collection, providing the item that was removed.

Fires before an item will be removed from a collection, providing the item that will be removed.

Fires whenever the number of items in a collection has changed, providing the new Count.

Fires before a collection is about to change, providing the previous Count.

Provides Item Changed notifications for any item in collection that implements IReactiveNotifyPropertyChanged. This is only enabled when ChangeTrackingEnabled is set to True.

Provides Item Changing notifications for any item in collection that implements IReactiveNotifyPropertyChanged. This is only enabled when

Enables the ItemChanging and ItemChanged properties; when this is enabled, whenever a property on any object implementing IReactiveNotifyPropertyChanged changes, the change will be rebroadcast through ItemChanging/ItemChanged.

IReactiveCollection of T is the typed version of IReactiveCollection and adds type-specified versions of Observables

IMessageBus represents an object that can act as a "Message Bus", a simple way for ViewModels and other objects to communicate with each other in a loosely coupled way. Specifying which messages go where is done via a combination of the Type of the message as well as an additional "Contract" parameter; this is a unique string used to distinguish between messages of the same Type, and is arbitrarily set by the client.

Listen provides an Observable that will fire whenever a Message is provided for this object via RegisterMessageSource or SendMessage.

The type of the message to listen to. A unique string to distinguish messages with identical types (i.e. "MyCoolViewModel") - if the message type is only used for one purpose, leave this as null.

Determins if a particular message Type is registered.

The type of the message. A unique string to distinguish messages with identical types (i.e. "MyCoolViewModel") - if the message type is only used for one purpose, leave this as null. True if messages have been posted for this message Type.

Registers an Observable representing the stream of messages to send. Another part of the code can then call Listen to retrieve this Observable.

The type of the message to listen to. An Observable that will be subscribed to, and a message sent out for each value provided. A unique string to distinguish messages with identical types (i.e. "MyCoolViewModel") - if the message type is only used for one purpose, leave this as null.

Sends a single message using the specified Type and contract. Consider using RegisterMessageSource instead if you will be sending messages in response to other changes such as property changes or events.

The type of the message to send. The actual message to send A unique string to distinguish messages with identical types (i.e. "MyCoolViewModel") - if the message type is only used for one purpose, leave this as null.

Log returns the current logger object, which allows the object to log messages with the type name attached.

This data structure is a representation of a memoizing cache - i.e. a class that will evaluate a function, but keep a cache of recently evaluated parameters. Since this is a memoizing cache, it is important that this function be a "pure" function in the mathematical sense - that a key *always* maps to a corresponding return value.

The type of the parameter to the calculation function. The type of the value returned by the calculation function.

Constructor

The function whose results you want to cache, which is provided the key value, and an Tag object that is user-defined The size of the cache to maintain, after which old items will start to be thrown out. A function to call when a result gets evicted from the cache (i.e. because Invalidate was called or the cache is full)

Evaluates the function provided, returning the cached value if possible

The value to pass to the calculation function. An additional optional user-specific parameter.

Ensure that the next time this key is queried, the calculation function will be called.

Invalidate all items in the cache

Returns all values currently in the cache

MessageBus represents an object that can act as a "Message Bus", a simple way for ViewModels and other objects to communicate with each other in a loosely coupled way. Specifying which messages go where is done via a combination of the Type of the message as well as an additional "Contract" parameter; this is a unique string used to distinguish between messages of the same Type, and is arbitrarily set by the client.

Listen provides an Observable that will fire whenever a Message is provided for this object via RegisterMessageSource or SendMessage.

The type of the message to listen to. A unique string to distinguish messages with identical types (i.e. "MyCoolViewModel") - if the message type is only used for one purpose, leave this as null. An Observable representing the notifications posted to the message bus.

Determins if a particular message Type is registered.

The Type of the message to listen to. A unique string to distinguish messages with identical types (i.e. "MyCoolViewModel") - if the message type is only used for one purpose, leave this as null. True if messages have been posted for this message Type.

Registers an Observable representing the stream of messages to send. Another part of the code can then call Listen to retrieve this Observable.

Returns the Current MessageBus from the RxApp global object.

Registers a ViewModel object to send property change messages; this allows a ViewModel to listen to another ViewModel's changes in a loosely-typed manner.

The ViewModel to register A unique string to distinguish messages with identical types (i.e. "MyCoolViewModel") - if the message type is only used for one purpose, leave this as null. ExceptionThe registered ViewModel must be the only instance (i.e. not in an ItemsControl)

Listens to a registered ViewModel's property change notifications.

A unique string to distinguish messages with identical types (i.e. "MyCoolViewModel") - if the message type is only used for one purpose, leave this as null. An Observable that fires when an object changes and provides the property name that has changed.

Return the current instance of the ViewModel with the specified type.

A unique string to distinguish messages with identical types (i.e. "MyCoolViewModel") - if the message type is only used for one purpose, leave this as null. The ViewModel object registered for this type.

ObservableAsPropertyHelper is a class to help ViewModels implement "output properties", that is, a property that is backed by an Observable. The property will be read-only, but will still fire change notifications. This class can be created directly, but is more often created via the ToProperty and ObservableToProperty extension methods. This class is also an Observable itself, so that output properties can be chained - for example a "Path" property and a chained "PathFileNameOnly" property.

Constructs an ObservableAsPropertyHelper object.

The Observable to base the property on. The action to take when the property changes, typically this will call the ViewModel's RaisePropertyChanged method. The initial value of the property. The scheduler that the notifications will be provided on - this should normally be a Dispatcher-based scheduler (and is by default)

Constructs a "default" ObservableAsPropertyHelper object. This is useful for when you will initialize the OAPH later, but don't want bindings to access a null OAPH at startup.

The initial (and only) value of the property. The scheduler that the notifications will be provided on - this should normally be a Dispatcher-based scheduler (and is by default)

The last provided value from the Observable.

Returns the Exception which has been provided by the Observable; normally steps should be taken to ensure that Observables provided to OAPH should never complete or fail.

Converts an Observable to an ObservableAsPropertyHelper and automatically provides the onChanged method to raise the property changed notification. The ToProperty method is semantically equivalent to this method and is often more convenient.

The Observable to base the property on. An Expression representing the property (i.e. 'x => x.SomeProperty' The initial value of the property. The scheduler that the notifications will be provided on - this should normally be a Dispatcher-based scheduler (and is by default) An initialized ObservableAsPropertyHelper; use this as the backing field for your property.

Converts an Observable to an ObservableAsPropertyHelper and automatically provides the onChanged method to raise the property changed notification.

The ReactiveObject that has the property An Expression representing the property (i.e. 'x => x.SomeProperty' The initial value of the property. The scheduler that the notifications will be provided on - this should normally be a Dispatcher-based scheduler (and is by default) An initialized ObservableAsPropertyHelper; use this as the backing field for your property.

ObservableAsyncMRUCache implements memoization for asynchronous or expensive to compute methods. This memoization is an MRU-based cache with a fixed limit for the number of items in the cache. This class guarantees that only one calculation for any given key is in-flight at a time, subsequent requests will wait for the first one and return its results (for example, an empty web image cache that receives two concurrent requests for "Foo.jpg" will only issue one WebRequest - this does not mean that a request for "Bar.jpg" will wait on "Foo.jpg"). Concurrency is also limited by the maxConcurrent parameter - when too many in-flight operations are in progress, further operations will be queued until a slot is available.

The key type. The type of the value to return from the cache.

Constructs an ObservableAsyncMRUCache object.

The function that performs the expensive or asyncronous calculation and returns an async result - for CPU-based operations, Observable.Return may be used to return the result. Note that this function *must* return an equivalently-same result given a specific input - because the function is being memoized, if the calculationFunc depends on other varables other than the input value, the results will be unpredictable. The number of items to cache. When this limit is reached, not recently used items will be discarded. The maximum number of concurrent asynchronous operations regardless of key - this is important for web-based caches to limit the number of concurrent requests to a server. The default is 5. This optional method is called when an item is evicted from the cache - this can be used to clean up / manage an on-disk cache; the calculationFunc can download a file and save it to a temporary folder, and the onRelease action will delete the file. The scheduler to run asynchronous operations on - defaults to TaskpoolScheduler

Issues an request to fetch the value for the specified key as an async operation. The Observable returned will fire one time when the async operation finishes. If the operation is cached, an Observable that immediately fires upon subscribing will be returned.

The key to provide to the calculation function. Returns an Observable representing the future result.

The synchronous version of AsyncGet - it will issue a request for the value of a specific key and wait until the value can be provided.

The key to provide to the calculation function. The resulting value.

A selector similar to one you would pass as a parameter passed to SelectMany. Note that similarly to ObservableAsyncMRUCache.AsyncGet, a selector must return semantically identical results given the same key - i.e. it must be a 'function' in the mathematical sense. The number of items to cache. When this limit is reached, not recently used items will be discarded. The maximum number of concurrent asynchronous operations regardless of key - this is important for web-based caches to limit the number of concurrent requests to a server. The default is 5. An Observable representing the flattened results of the selector.

Works like SelectMany, but memoizes selector calls. In addition, it guarantees that no more than 'maxConcurrent' selectors are running concurrently and queues the rest. This is very important when using web services to avoid potentially spamming the server with hundreds of requests. This overload is useful when making the same web service call in several places in the code, to ensure that all of the code paths are using the same cache.

An already-configured ObservableAsyncMRUCache. An Observable representing the flattened results of the cache selector.

Returns the current value of a property given a notification that it has changed.

The current value of the property

Attempts to return the current value of a property given a notification that it has changed. If any property in the property expression is null, false is returned.

The value of the property expression. True if the entire expression was able to be followed, false otherwise

Given a fully filled-out IObservedChange object, SetValueToProperty will apply it to the specified object (i.e. it will ensure that target.property == This.GetValue() and "replay" the observed change onto another object)

The target object to apply the change to. The target property to apply the change to.

Given a stream of notification changes, this method will convert the property changes to the current value of the property.

An Observable representing the stream of current values of the given change notification stream.

ValueIfNotDefault is similar to Value(), but filters out null values from the stream.

An Observable representing the stream of current values of the given change notification stream.

Given a stream of notification changes, this method will convert the property changes to the current value of the property.

BindTo takes an Observable stream and applies it to a target property. Conceptually it is similar to "Subscribe(x => target.property = x)", but allows you to use child properties without the null checks.

The target object whose property will be set. An expression representing the target property to set. This can be a child property (i.e. x.Foo.Bar.Baz). An object that when disposed, disconnects the binding.

The type of the objects in the collection.

Constructs a ReactiveCollection.

Constructs a ReactiveCollection given an existing list.

The existing list with which to populate the new list.

When this method is called, an object will not fire change notifications (neither traditional nor Observable notifications) until the return value is disposed.

An object that, when disposed, reenables change notifications.

Fires when items are added to the collection, once per item added. Functions that add multiple items such as AddRange should fire this multiple times. The object provided is the item that was added.

Fires before an item is going to be added to the collection.

Fires once an item has been removed from a collection, providing the item that was removed.

Fires before an item will be removed from a collection, providing the item that will be removed.

Fires before a collection is about to change, providing the previous Count.

Fires whenever the number of items in a collection has changed, providing the new Count.

Provides Item Changed notifications for any item in collection that implements IReactiveNotifyPropertyChanged. This is only enabled when ChangeTrackingEnabled is set to True.

Provides Item Changing notifications for any item in collection that implements IReactiveNotifyPropertyChanged. This is only enabled when

Fires when anything in the collection or any of its items (if Change Tracking is enabled) are about to change.

Fires when anything in the collection or any of its items (if Change Tracking is enabled) have changed.

Creates a collection based on an an Observable by adding items provided until the Observable completes, optionally ensuring a delay. Note that if the Observable never completes and withDelay is set, this method will leak a Timer. This method also guarantees that items are always added via the UI thread.

The Observable whose items will be put into the new collection. If set, items will be populated in the collection no faster than the delay provided. A new collection which will be populated with the Observable.

The Observable whose items will be put into the new collection. A Select function that will be run on each item. If set, items will be populated in the collection no faster than the delay provided. A new collection which will be populated with the Observable.

Creates a collection whose contents will "follow" another collection; this method is useful for creating ViewModel collections that are automatically updated when the respective Model collection is updated.

A Select function that will be run on each item. A new collection whose items are equivalent to Collection.Select(selector) and will mirror the initial collection.

ObservableForProperty returns an Observable representing the property change notifications for a specific property on a ReactiveObject. This method (unlike other Observables that return IObservedChange) guarantees that the Value property of the IObservedChange is set.

An Expression representing the property (i.e. 'x => x.SomeProperty.SomeOtherProperty' If True, the Observable will notify immediately before a property is going to change. An Observable representing the property change notifications for the given property.

ObservableForProperty returns an Observable representing the property change notifications for a specific property on a ReactiveObject, running the IObservedChange through a Selector function.

An Expression representing the property (i.e. 'x => x.SomeProperty' A Select function that will be run on each item. If True, the Observable will notify immediately before a property is going to change. An Observable representing the property change notifications for the given property.

ReactiveObject is the base object for ViewModel classes, and it implements INotifyPropertyChanged. In addition, ReactiveObject provides Changing and Changed Observables to monitor object changes.

When this method is called, an object will not fire change notifications (neither traditional nor Observable notifications) until the return value is disposed.

An object that, when disposed, reenables change notifications.

Represents an Observable that fires *before* a property is about to be changed.

Represents an Observable that fires *after* a property has changed.

An Expression representing the property (i.e. 'x => x.SomeProperty' The new value to set the property to, almost always the 'value' keyword. The newly set value, normally discarded.

RaiseAndSetIfChanged fully implements a Setter for a read-write property on a ReactiveObject, making the assumption that the property has a backing field named "_NameOfProperty". To change this assumption, set RxApp.GetFieldNameForPropertyNameFunc. This overload is intended for Silverlight and WP7 where reflection cannot access the private backing field.

An Expression representing the property (i.e. 'x => x.SomeProperty' A Reference to the backing field for this property. The new value to set the property to, almost always the 'value' keyword. The newly set value, normally discarded.

Use this method in your ReactiveObject classes when creating custom properties where raiseAndSetIfChanged doesn't suffice.

An Expression representing the property (i.e. 'x => x.SomeProperty'

Use this method in your ReactiveObject classes when creating custom properties where raiseAndSetIfChanged doesn't suffice.

An Expression representing the property (i.e. 'x => x.SomeProperty'

RaisePropertyChanging is a helper method intended for test / mock scenarios to manually fake a property change.

The ReactiveObject to invoke raisePropertyChanging on. The property that will be faking a change.

RaisePropertyChanging is a helper method intended for test / mock scenarios to manually fake a property change.

The ReactiveObject to invoke raisePropertyChanging on. The property that will be faking a change.

RaisePropertyChanged is a helper method intended for test / mock scenarios to manually fake a property change.

The ReactiveObject to invoke raisePropertyChanging on. The property that will be faking a change.

RaisePropertyChanged is a helper method intended for test / mock scenarios to manually fake a property change.

The ReactiveObject to invoke raisePropertyChanging on. The property that will be faking a change.

This class helps you take existing objects and make them compatible with ReactiveUI and Rx.Net. To use this, declare an instance field of this class in your class, initialize it in your Constructor, make your class derive from IReactiveNotifyPropertyChanged, then implement all of the properties/methods using MakeObjectReactiveHelper.

InUnitTestRunner attempts to determine heuristically if the current application is running in a unit test framework.

True if we have determined that a unit test framework is currently running.

GetFieldNameForProperty returns the corresponding backing field name for a given property name, using the convention specified in GetFieldNameForPropertyNameFunc.

The name of the property whose backing field needs to be found. The backing field name.

DeferredScheduler is the scheduler used to schedule work items that should be run "on the UI thread". In normal mode, this will be DispatcherScheduler, and in Unit Test mode this will be Immediate, to simplify writing common unit tests.

TaskpoolScheduler is the scheduler used to schedule work items to run in a background thread. In both modes, this will run on the TPL Task Pool (or the normal Threadpool on Silverlight).

Set this property to implement a custom logger provider - the string parameter is the 'prefix' (usually the class name of the log entry)

Set this property to implement a custom MessageBus for MessageBus.Current.

Set this property to override the default field naming convention of "_PropertyName" with a custom one.

WhenAny allows you to observe whenever one or more properties on an object have changed, providing an initial value when the Observable is set up, unlike ObservableForProperty(). Use this method in constructors to set up bindings between properties that also need an initial setup.