ReactiveUI

This class implements View Activation for classes that explicitly describe their activation via . This class is used by the framework.

Returns a positive integer for derived instances of the interface.

The source type to check. A positive integer if is supported, zero otherwise.

Get an observable defining whether the view is active.

The view to observe. An observable tracking whether the view is active.

Implement this interface to override how ReactiveUI determines when a View is activated or deactivated. This is usually only used when porting ReactiveUI to a new UI framework.

Determines the priority that the Activation View Fetcher will be able to process the view type. 0 means it cannot activate the View, value larger than 0 indicates it can activate the View. The class derived off IActivationForViewFetcher which returns the highest affinity value will be used to activate the View.

The type for the View. The affinity value which is equal to 0 or above.

Gets a Observable which will activate the View. This is called after the GetAffinityForView method.

The view to get the activation observable for. A Observable which will returns if Activation was successful.

A set of extension methods to help wire up View and ViewModel activation.

WhenActivated allows you to register a Func to be called when a ViewModel's View is Activated.

Object that supports activation. The method to be called when the corresponding View is activated. It returns a list of Disposables that will be cleaned up when the View is deactivated.

WhenActivated allows you to register a Func to be called when a ViewModel's View is Activated.

WhenActivated allows you to register a Func to be called when a View is Activated.

Object that supports activation. The method to be called when the corresponding View is activated. It returns a list of Disposables that will be cleaned up when the View is deactivated. The IActivatableView will ordinarily also host the View Model, but in the event it is not, a class implementing can be supplied here. A Disposable that deactivates this registration.

WhenActivated allows you to register a Func to be called when a View is Activated.

Object that supports activation. The method to be called when the corresponding View is activated. The Action parameter (usually called 'd') allows you to register Disposables to be cleaned up when the View is deactivated (i.e. "d(someObservable.Subscribe());"). The IActivatableView will ordinarily also host the View Model, but in the event it is not, a class implementing can be supplied here. A Disposable that deactivates this registration.

WhenActivated allows you to register a Func to be called when a View is Activated.

Object that supports activation. The method to be called when the corresponding View is activated. The Action parameter (usually called 'disposables') allows you to collate all disposables that should be cleaned up during deactivation. The IActivatableView will ordinarily also host the View Model, but in the event it is not, a class implementing can be supplied here. A Disposable that deactivates this registration.

ViewModelActivator is a helper class that you instantiate in your ViewModel classes in order to help with Activation. Views will internally call this class when the corresponding View comes on screen. This means you can set up resources such as subscriptions to global objects that should be cleaned up on exit. Once you instantiate this class, use the WhenActivated method to register what to do when activated. View Activation is **not** the same as being loaded / unloaded; Views are Activated when they *enter* the Visual Tree, and are Deactivated when they *leave* the Visual Tree. This is a critical difference when it comes to views that are recycled, such as UITableViews or Virtualizing ScrollViews. Create this class solely in the **Base Class** of any classes that inherit from this class (i.e. if you create a FooViewModel that supports activation, the instance should be protected and a child BarViewModel should use the existing ViewModelActivator). NOTE: You **must** set up Activation in the corresponding View when using ViewModel Activation.

Initializes a new instance of the class.

Gets a observable which will tick every time the Activator is activated.

The activated.

Gets a observable which will tick every time the Activator is deactivated.

The deactivated.

This method is called by the framework when the corresponding View is activated. Call this method in unit tests to simulate a ViewModel being activated.

A Disposable that calls Deactivate when disposed.

This method is called by the framework when the corresponding View is deactivated.

Force the VM to be deactivated, even if more than one person called Activate.

Adds a action blocks to the list of registered blocks. These will called on activation, then disposed on deactivation.

The block to add.

The type of binding that the ReactiveBinding represents.

The binding is updated only one way from the ViewModel.

The binding is updated from both the View and the ViewModel.

The binding is updated asynchronously one way from the ViewModel.

Various helpers to bind View controls and ViewModel commands together.

Bind a command from the ViewModel to an explicitly specified control on the View.

The view type. The view model type. The property type. The control type. The parameter type. A class representing the binding. Dispose it to disconnect the binding. The View. The View model. The ViewModel command to bind. The name of the control on the view. The ViewModel property to pass as the param of the ICommand. If specified, bind to the specific event instead of the default. NOTE: If this parameter is used inside WhenActivated, it's important to dispose the binding when the view is deactivated.

Bind a command from the ViewModel to an explicitly specified control on the View.

The view type. The view model type. The property type. The control type. A class representing the binding. Dispose it to disconnect the binding. The View. The View model. The ViewModel command to bind. The name of the control on the view. If specified, bind to the specific event instead of the default. NOTE: If this parameter is used inside WhenActivated, it's important to dispose the binding when the view is deactivated.

Bind a command from the ViewModel to an explicitly specified control on the View.

Used by the CommandBinder extension methods to handle binding View controls and ViewModel commands.

Bind a command from the ViewModel to an explicitly specified control on the View.

The view type. The view model type. The property type. The control type. The parameter type. The View model. The View. The ViewModel command to bind. The name of the control on the view. The ViewModel property to pass as the param of the ICommand. If specified, bind to the specific event instead of the default. NOTE: If this parameter is used inside WhenActivated, it's important to dispose the binding when the view is deactivated. A class representing the binding. Dispose it to disconnect the binding. nameof(vmProperty) or nameof(vmProperty).

Bind a command from the ViewModel to an explicitly specified control on the View.

The view type. The view model type. The property type. The control type. The parameter type. A class representing the binding. Dispose it to disconnect the binding. The View model. The View. The ViewModel command to bind. The name of the control on the view. The ViewModel property to pass as the param of the ICommand. If specified, bind to the specific event instead of the default. NOTE: If this parameter is used inside WhenActivated, it's important to dispose the binding when the view is deactivated.

Internal implementation details which performs Binding ICommand's to controls.

Class that registers Command Binding and Command Parameter Binding.

This binder is the default binder for connecting to arbitrary events.

Implementation logic for command binding.

Binds the command on a ViewModel to a control on the View.

The view model to bind to. The view to bind to. The name of the property on the View Model. The name of the control on the View. A function if we want to pass a parameter to the ICommand. A event on the view that will also trigger the command. The type of the view. The type of the view model. The type of the property on the view model. The type of control on the view. The type of the parameter to pass to the ICommand. A reactive binding. Often only used for disposing the binding.

Binds the command on a ViewModel to a control on the View.

The view model to bind to. The view to bind to. The name of the property on the View Model. The name of the control on the View. A observable if we want to pass a parameter to the ICommand. A event on the view that will also trigger the command. The type of the view. The type of the view model. The type of the property on the view model. The type of control on the view. The type of the parameter to pass to the ICommand. A reactive binding. Often only used for disposing the binding.

Internal relay command used for Command binding.

Short To String Type Converter.

Decimal To String Type Converter.

Double To String Type Converter.

The default converter, simply converts between types that are equal or can be converted (i.e. Button => UIControl).

Handles casting for a reference. Understands about nullable types and can cast appropriately.

The object we are casting from. The target we want to cast to. The new value after it has been casted. If we cannot cast the object.

Integer To String Type Converter.

Short To String Type Converter.

Decimal To String Type Converter.

Double To String Type Converter.

Integer To String Type Converter.

Short To String Type Converter.

Single To String Type Converter.

Short To String Type Converter.

Single To String Type Converter.

Calls ToString on types. In WPF, ComponentTypeConverter should win instead of this, since It's Better™.

This interface is the extensible implementation of IValueConverters for Bind and OneWayBind. Implement this to teach Bind and OneWayBind how to convert between types.

Returns a positive integer when this class supports TryConvert for this particular Type. If the method isn't supported at all, return a non-positive integer. When multiple implementations return a positive value, the host will use the one which returns the highest value. When in doubt, return '2' or '0'.

The source type to convert from. The target type to convert to. A positive integer if TryConvert is supported, zero or a negative value otherwise.

Convert a given object to the specified type.

The object to convert. The type to coerce the object to. An implementation-defined value, usually to specify things like locale awareness. An object that is of the type . True if conversion was successful.

Implementation logic for binding.

Binds the on a ViewModel to the specified handler.

The view model to bind to. The view to bind to. The name of the property on the View Model. The handler. The type of the view model. The type of the view being bound. The interaction's input type. The interaction's output type. An object that when disposed, disconnects the binding.

Binds the on a ViewModel to the specified handler.

The view model to bind to. The view to bind to. The name of the property on the View Model. The handler. The type of the view model. The type of the view being bound. The interaction's input type. The interaction's output type. The interaction's signal type. An object that when disposed, disconnects the binding.

Provides methods to bind s to handlers.

This class provides extension methods for the ReactiveUI view binding mechanism.

Binds the on a ViewModel to the specified handler.

The view to bind to. The view model to bind to. The name of the property on the View Model. The handler. The type of the view model. The type of the view being bound. The interaction's input type. The interaction's output type. An object that when disposed, disconnects the binding.

Binds the on a ViewModel to the specified handler.

The view to bind to. The view model to bind to. The name of the property on the View Model. The handler. The type of the view model. The type of the view being bound. The interaction's input type. The interaction's output type. The interaction's signal type. An object that when disposed, disconnects the binding.

This converter will allow users to change the way the set functionality is performed in ReactiveUI property binding.

Returns a positive integer when this class supports PerformSet for this particular Type. If the method isn't supported at all, return a non-positive integer. When multiple implementations return a positive value, the host will use the one which returns the highest value. When in doubt, return '2' or '0'.

The from type to convert from. The target type to convert to. A positive integer if PerformSet is supported, zero or a negative value otherwise.

Convert a given object to the specified type.

The target object we are setting to. The value to set on the new object. The arguments required. Used for indexer based values. The value that was set.

This interface represents an object that is capable of providing binding implementations.

Creates a two-way binding between a view model and a view. This binding will attempt to convert the values of the view and view model properties using a if they are not of the same type.

The type of the view model that is bound. The type of the view being bound. The type of the property bound on the view model. The type of the property bound on the view. A dummy type, only the fact that emits values is considered, not the actual values emitted. The instance of the view model object to be bound. The instance of the view object to be bound. An expression representing the property to be bound to on the view model. This can be a child property, for example x => x.Foo.Bar.Baz in which case the binding will attempt to subscribe recursively to updates in order to always get and set the correct property. An expression representing the property to be bound to on the view. This can be a child property, for example x => x.Foo.Bar.Baz in which case the binding will attempt to subscribe recursively to updates in order to always get and set the correct property. An observable, that when signaled, indicates that the view property has been changed, and that the binding should update the view model property accordingly. An object that can provide a hint for the converter. The semantics of this object is defined by the converter used. An optional to use when converting from the viewModel to view property. An optional to use when converting from the view to viewModel property. The trigger update direction. An instance of that, when disposed, disconnects the binding.

Creates a two-way binding between a view model and a view. This binding will attempt to convert the values of the view and view model properties using a if they are not of the same type.

The type of the view model that is bound. The type of the view being bound. The type of the property bound on the view model. The type of the property bound on the view. A dummy type, only the fact that emits values is considered, not the actual values emitted. The instance of the view model object to be bound. The instance of the view object to be bound. An expression representing the property to be bound to on the view model. This can be a child property, for example x => x.Foo.Bar.Baz in which case the binding will attempt to subscribe recursively to updates in order to always get and set the correct property. An expression representing the property to be bound to on the view. This can be a child property, for example x => x.Foo.Bar.Baz in which case the binding will attempt to subscribe recursively to updates in order to always get and set the correct property. An observable, that when signaled, indicates that the view property has been changed, and that the binding should update the view model property accordingly. Delegate to convert the value of the view model's property's type to a value of the view's property's type. Delegate to convert the value of the view's property's type to a value of the view model's property's type. The trigger update direction. An instance of that, when disposed, disconnects the binding.

Creates a one-way binding, i.e. a binding that flows from the to the only. This binding will attempt to convert the value of the view model property to the view property if they are not of the same type.

The type of the view model that is bound. The type of the view that is bound. The type of the property bound on the view model. The type of the property bound on the view. The instance of the view model to bind to. The instance of the view to bind to. An expression representing the property to be bound to on the view model. This can be a child property, for example x => x.Foo.Bar.Baz in which case the binding will attempt to subscribe recursively to updates in order to always get the last value of the property chain. An expression representing the property to be bound to on the view. This can be a child property, for example x => x.Foo.Bar.Baz in which case the binding will attempt to subscribe recursively to updates in order to always set the correct property. An object that can provide a hint for the converter. The semantics of this object is defined by the converter used. An optional to use when converting from the viewModel to view property. An instance of that, when disposed, disconnects the binding. There is no registered converter from to .

Creates a one way binding with a selector, i.e. a binding that flows from the to the only, and where the value of the view model property is mapped through the before being set to the view.

The type of the view model that is bound. The type of the view that is bound. The type of the property bound on the view model. The return type of the . The instance of the view model to bind to. The instance of the view to bind to. An expression representing the property to be bound to on the view model. This can be a child property, for example x => x.Foo.Bar.Baz in which case the binding will attempt to subscribe recursively to updates in order to always get the last value of the property chain. An expression representing the property to be bound to on the view. This can be a child property, for example x => x.Foo.Bar.Baz in which case the binding will attempt to subscribe recursively to updates in order to always set the correct property. A function that will be used to transform the values of the property on the view model before being bound to the view property. An instance of that, when disposed, disconnects the binding.

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 value type. The target type. The target value type. The target observable to bind to. 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 can provide a hint for the converter. The semantics of this object is defined by the converter used. An optional to use when converting from the viewModel to view property. An object that when disposed, disconnects the binding.

Provides methods to bind properties to observables.

This class provides extension methods for the ReactiveUI view binding mechanism.

Binds the specified view model property to the given view property.

The type of the view model being bound. The type of the view being bound. The type of the property bound on the view model. The type of the property bound on the view. The instance of the view to bind. The instance of the view model to bind. An expression indicating the property that is bound on the view model. This can be a chain of properties of the form. vm => vm.Foo.Bar.Baz and the binder will attempt to subscribe to changes on each recursively. The property on the view that is to be bound. This can be a chain of properties of the form. view => view.Foo.Bar.Baz and the binder will attempt to set the last one each time the view model property is updated. An object that can provide a hint for the converter. The semantics of this object is defined by the converter used. An optional to use when converting from the viewModel to view property. An optional to use when converting from the view to viewModel property. An instance of that, when disposed, disconnects the binding.

Binds the specified view model property to the given view property, and provide a custom view update signaler to signal when the view property has been updated.

The type of the view model being bound. The type of the view being bound. The type of the property bound on the view model. The type of the property bound on the view. A dummy type, only the fact that emits values is considered, not the actual values emitted. The instance of the view to bind. The instance of the view model to bind. An expression indicating the property that is bound on the view model. This can be a chain of properties of the form. vm => vm.Foo.Bar.Baz and the binder will attempt to subscribe to changes on each recursively. The property on the view that is to be bound. This can be a chain of properties of the form. view => view.Foo.Bar.Baz and the binder will attempt to set the last one each time the view model property is updated. An observable, that when signaled, indicates that the view property has been changed, and that the binding should update the view model property accordingly. An object that can provide a hint for the converter. The semantics of this object is defined by the converter used. An optional to use when converting from the viewModel to view property. An optional to use when converting from the view to viewModel property. The trigger update direction. An instance of that, when disposed, disconnects the binding.

Binds the specified view model property to the given view property.

The type of the view model being bound. The type of the view being bound. The type of the property bound on the view model. The type of the property bound on the view. The instance of the view to bind. The instance of the view model to bind. An expression indicating the property that is bound on the view model. This can be a chain of properties of the form. vm => vm.Foo.Bar.Baz and the binder will attempt to subscribe to changes on each recursively. The property on the view that is to be bound. This can be a chain of properties of the form. view => view.Foo.Bar.Baz and the binder will attempt to set the last one each time the view model property is updated. Delegate to convert the value of the view model's property's type to a value of the view's property's type. Delegate to convert the value of the view's property's type to a value of the view model's property's type. An instance of that, when disposed, disconnects the binding.

Binds the specified view model property to the given view property.

The type of the view model being bound. The type of the view being bound. The type of the property bound on the view model. The type of the property bound on the view. A dummy type, only the fact that emits values is considered, not the actual values emitted. The instance of the view to bind. The instance of the view model to bind. An expression indicating the property that is bound on the view model. This can be a chain of properties of the form. vm => vm.Foo.Bar.Baz and the binder will attempt to subscribe to changes on each recursively. The property on the view that is to be bound. This can be a chain of properties of the form. view => view.Foo.Bar.Baz and the binder will attempt to set the last one each time the view model property is updated. An observable, that when signaled, indicates that the view property has been changed, and that the binding should update the view model property accordingly. Delegate to convert the value of the view model's property's type to a value of the view's property's type. Delegate to convert the value of the view's property's type to a value of the view model's property's type. The trigger update direction. An instance of that, when disposed, disconnects the binding.

Binds the given property on the view model to a given property on the view in a one-way (view model to view) fashion.

The type of the view model. The type of the view. The type of view model property. The type of the property bound on the view. The instance of the view object which is bound. Usually, it is the. this instance. The view model that is bound. It is usually set to the property of the . An expression indicating the property that is bound on the view model. This can be a chain of properties of the form. vm => vm.Foo.Bar.Baz and the binder will attempt to subscribe to changes on each recursively. The property on the view that is to be bound. This can be a chain of properties of the form. view => view.Foo.Bar.Baz and the binder will attempt to set the last one each time the view model property is updated. An object that can provide a hint for the converter. The semantics of this object is defined by the converter used. An optional to use when converting from the viewModel to view property. An instance of that, when disposed, disconnects the binding.

Binds the specified view model property to the given view, in a one-way (view model to view) fashion, with the value of the view model property mapped through a function.

The type of the view model that is bound. The type of the view that is bound. The type of the property bound on the view model. The return type of the . The instance of the view to bind to. The instance of the view model to bind to. An expression representing the property to be bound to on the view model. This can be a child property, for example x => x.Foo.Bar.Baz in which case the binding will attempt to subscribe recursively to updates in order to always get the last value of the property chain. An expression representing the property to be bound to on the view. This can be a child property, for example x => x.Foo.Bar.Baz in which case the binding will attempt to subscribe recursively to updates in order to always set the correct property. A function that will be used to transform the values of the property on the view model before being bound to the view property. An instance of that, when disposed, disconnects the binding.

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 source type. The target object type. The type of the property on the target object. The observable stream to bind to a target property. 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 can provide a hint for the converter. The semantics of this object is defined by the converter used. An optional to use when converting from the viewModel to view property. An object that when disposed, disconnects the binding.

Trigger Update.

The view to view model.

The view model to view.

This interface represents the result of a Bind/OneWayBind and gives information about the binding. When this object is disposed, it will destroy the binding it is describing (i.e. most of the time you won't actually care about this object, just that it is disposable).

The view type. The value type.

Gets an expression representing the property on the viewmodel bound to the view. This can be a child property, for example x.Foo.Bar.Baz in which case that will be the expression.

Gets the instance of the view this binding is applied to.

Gets an expression representing the property on the view bound to the viewmodel. This can be a child property, for example x.Foo.Bar.Baz in which case that will be the expression.

Gets an observable representing changed values for the binding.

Gets the direction of the binding.

Disposes of resources inside the class.

If we are disposing managed resources.

Convenience class to help chain selectors onto existing parent comparers.

Creates a derived comparer based on the given parent comparer. The returned comparer will sort elements using the parent comparer first. If the parent considers the values equal elements will be sorted in ascending order based on the values returned by the provided selector. The selector values will be compared using the default comparer for the return type of the selector.

The comparison type. The value type. The parent comparer to use first. A function supplying the values for the comparer. A comparer.

Creates a derived comparer based on the given parent comparer. The returned comparer will sort elements using the parent comparer first. If the parent considers the values equal elements will be sorted in ascending order based on the values returned by the provided selector. The selector values will be compared using the provided comparer or the default comparer for the return type of the selector if no comparer is specified.

The comparison type. The value type. The parent comparer to use first. A function supplying the values for the comparer. The comparer to use when comparing the values returned by the selector. A comparer.

Creates a derived comparer based on the given parent comparer. The returned comparer will sort elements using the parent comparer first. If the parent considers the values equal elements will be sorted in descending order based on the values returned by the provided selector. The selector values will be compared using the default comparer for the return type of the selector.

The comparison type. The value type. The parent comparer to use first. A function supplying the values for the comparer. A comparer.

Creates a derived comparer based on the given parent comparer. The returned comparer will sort elements using the parent comparer first. If the parent considers the values equal elements will be sorted in descending order based on the values returned by the provided selector. The selector values will be compared using the provided comparer or the default comparer for the return type of the selector if no comparer is specified.

Convenience interface for providing a starting point for chaining comparers.

The comparison type.

The value type. A function supplying the values for the comparer. A comparer.

Creates a derived comparer based on the given parent comparer. The returned comparer will sort elements using the parent comparer first. If the parent considers the values equal elements will be sorted in ascending order based on the values returned by the provided selector. The selector values will be compared using the provided comparer or the default comparer for the return type of the selector if no comparer is specified.

The value type. A function supplying the values for the comparer. The comparer to use when comparing the values returned by the selector. The default comparer for that type will be used if this parameter is null. A comparer.

Creates a derived comparer based on the given parent comparer. The returned comparer will sort elements using the parent comparer first. If the parent considers the values equal elements will be sorted in descending order based on the values returned by the provided selector. The selector values will be compared using the default comparer for the return type of the selector.

The value type. A function supplying the values for the comparer. A comparer.

Creates a derived comparer based on the given parent comparer. The returned comparer will sort elements using the parent comparer first. If the parent considers the values equal elements will be sorted in descending order based on the values returned by the provided selector. The selector values will be compared using the provided comparer or the default comparer for the return type of the selector if no comparer is specified.

The value type. A function supplying the values for the comparer. /// The comparer to use when comparing the values returned by the selector. The default comparer for that type will be used if this parameter is null. A comparer.

Convenience class providing a starting point for chaining comparers for anonymous types.

If the type you're creating a comparer for is known this class is nothing more than an alias for the generic OrderedComparer. This class can be used to create comparers for anonymous types.

Creates a type inferred comparer builder for the element type of the enumerable. Useful for creating comparers for anonymous types. Note that the builder is not a comparer in itself, you need to use the OrderBy or OrderByDescending methods on the builder to get an actual comparer.

The type. The enumerable. A comparer builder.

Creates a comparer builder for the specified type. Note that the builder is not a comparer in itself, you need to use the OrderBy or OrderByDescending methods on the builder to get an actual comparer. If the type is known at compile time this method is nothing more than an alias for the generic OrderedComparer class.

The comparison type. A comparer builder.

Convenience class providing a starting point for chaining comparers.

The comparison type.

Creates a comparer that will sort elements in ascending order based on the values returned by the provided selector. The values will be compared using the default comparer for the return type of the selector.

The value type. A function supplying the values for the comparer. A comparer.

Creates a comparer that will sort elements in ascending order based on the values returned by the provided selector. The selector values will be compared using the provided comparer or the default comparer for the return type of the selector if no comparer is specified.

Creates a comparer that will sort elements in descending order based on the values returned by the provided selector. The values will be compared using the default comparer for the return type of the selector.

The value type. A function supplying the values for the comparer. A comparer.

Creates a comparer that will sort elements in descending order based on the values returned by the provided selector. The selector values will be compared using the provided comparer or the default comparer for the return type of the selector if no comparer is specified.

Class for simplifying and validating expressions.

Helper class for handling Reflection amd Expression tree related items.

Uses the expression re-writer to simplify the Expression down to it's simplest Expression.

The expression to rewrite. The rewritten expression.

Will convert a Expression which points towards a property to a string containing the property names. The sub-properties will be separated by the '.' character. Index based values will include [] after the name.

The expression to generate the property names from. A string form for the property the expression is pointing to.

Converts a MemberInfo into a Func which will fetch the value for the Member. Handles either fields or properties.

The member info to convert. A Func that takes in the object/indexes and returns the value.

Converts a MemberInfo into a Func which will fetch the value for the Member. Handles either fields or properties. If there is no field or property with the matching MemberInfo it'll throw an ArgumentException.

The member info to convert. A Func that takes in the object/indexes and returns the value.

Converts a MemberInfo into a Func which will set the value for the Member. Handles either fields or properties. If there is no field or property with the matching MemberInfo it'll throw an ArgumentException.

The member info to convert. A Func that takes in the object/indexes and sets the value.

Based on a list of Expressions get the value of the last property in the chain if possible. The Expressions are typically property chains. Eg Property1.Property2.Property3 The method will make sure that each Expression can get a value along the way and get each property until each expression is evaluated.

A output value where to store the value if the value can be fetched. The object that starts the property chain. A list of expressions which will point towards a property or field. The type of the end value we are trying to get. If the value was successfully retrieved or not.

Based on a list of Expressions get a IObservedChanged for the value of the last property in the chain if possible. The Expressions are property chains. Eg Property1.Property2.Property3 The method will make sure that each Expression can get a value along the way and get each property until each expression is evaluated.

A IObservedChanged for the value. The object that starts the property chain. A list of expressions which will point towards a property or field. If the value was successfully retrieved or not.

Based on a list of Expressions set a value of the last property in the chain if possible. The Expressions are property chains. Eg Property1.Property2.Property3 The method will make sure that each Expression can use each value along the way and set the last value.

The object that starts the property chain. A list of expressions which will point towards a property or field. The value to set on the last property in the Expression chain. If we should throw if we are unable to set the value. The type of the end value we are trying to set. If the value was successfully retrieved or not.

Gets a Type from the specified type name. Uses a cache to avoid having to use Reflection every time.

The name of the type. If we should throw an exception if the type can't be found. The type that was found or null. If we were unable to find the type.

Gets the appropriate EventArgs derived object for the specified event name for a Type.

The type of object to find the event on. The mame of the event. The Type of the EventArgs to use. If there is no event matching the name on the target type.

Checks to make sure that the specified method names on the target object are overriden.

The name of the calling type. The object to check. The name of the methods to check. Thrown if the methods aren't overriden on the target object.

Determines if the specified property is static or not.

The property information to check. If the property is static or not.

Represents an interaction between collaborating application components.

Interactions allow collaborating components in an application to ask each other questions. Typically, interactions allow a view model to get the user's confirmation from the view before proceeding with some operation. The view provides the interaction's confirmation interface in a handler registered for the interaction. Interactions have both an input and an output. Interaction inputs and outputs use generic type parameters. The interaction's input provides handlers the information they require to ask a question. The handler then provides the interaction with an output as the answer to the question. By default, handlers are invoked in reverse order of registration. That is, handlers registered later are given the opportunity to handle interactions before handlers that were registered earlier. This chaining mechanism enables handlers to be registered temporarily in a specific context, such that interactions can be handled differently according to the situation. This behavior can be modified by overriding the method in a subclass. Note that handlers are not required to handle an interaction. They can choose to ignore it, leaving it for some other handler to handle. The interaction's method will throw an if no handler handles the interaction. The interaction's input type. The interaction's output type.

Initializes a new instance of the class.

The scheduler to use when invoking handlers, which defaults to CurrentThreadScheduler.Instance if .

Registers a synchronous interaction handler.

This overload of RegisterHandler is only useful if the handler can handle the interaction immediately. That is, it does not need to wait for the user or some other collaborating component. The handler. A disposable which, when disposed, will unregister the handler.

Registers a task-based asynchronous interaction handler.

This overload of RegisterHandler is useful if the handler needs to perform some asynchronous operation, such as displaying a dialog and waiting for the user's response. The handler. A disposable which, when disposed, will unregister the handler.

Registers an observable-based asynchronous interaction handler.

The signal type. This overload of RegisterHandler is useful if the handler needs to perform some asynchronous operation, such as displaying a dialog and waiting for the user's response. The handler. A disposable which, when disposed, will unregister the handler.

Handles an interaction and asynchronously returns the result.

This method passes the interaction in turn to its registered handlers in reverse order of registration until one of them handles the interaction. If the interaction remains unhandled after all its registered handlers have executed, an is thrown. The input for the interaction. An observable that ticks when the interaction completes. Thrown when no handler handles the interaction.

Gets all registered handlers by order of registration.

All registered handlers.

Contains contextual information for an interaction.

Instances of this class are passed into interaction handlers. The property exposes the input to the interaction, whilst the method allows a handler to provide the output. The type of the interaction's input. The type of the interaction's output.

Gets the input for the interaction.

Gets a value indicating whether the interaction is handled. That is, whether the output has been set.

Sets the output for the interaction.

The output. If the output has already been set.

Gets the output of the interaction.

The output. If the output has not been set.

Indicates that an interaction has gone unhandled.

The type of the interaction's input. The type of the interaction's output.

Initializes a new instance of the class.

The interaction that doesn't have a input handler. The input into the interaction.

Initializes a new instance of the class.

A message about the exception.

Initializes a new instance of the class.

A message about the exception. Any other exception that caused the issue.

Initializes a new instance of the class.

The serialization information. The serialization context.

Gets the interaction that was not handled.

Gets the input for the interaction that was not handled.

Use this Interface when you want to mark a control as receiving View Activation when it doesn't have a backing ViewModel.

Implementing this interface on a ViewModel indicates that the ViewModel is interested in Activation events. Instantiate the Activator, then call WhenActivated on your class to register what you want to happen when the View is activated. See the documentation for ViewModelActivator to read more about Activation.

Gets the Activator which will be used by the View when Activation/Deactivation occurs.

This Interface is used by the framework to explicitly provide activation events. Usually you can ignore this unless you are porting RxUI to a new UI Toolkit.

Gets a observable which is triggered when the ViewModel is activated.

Gets a observable which is triggered when the ViewModel is deactivated.

Instead of using System events will allow for external classes to manually Activate the View object.

Activates the view object.

If we are activating or not.

Classes that implement this interface and registered inside Splat will be used to potentially provide binding to a ICommand in the ViewModel to a Control in the View.

Returns a positive integer when this class supports BindCommandToObject for this particular Type. If the method isn't supported at all, return a non-positive integer. When multiple implementations return a positive value, the host will use the one which returns the highest value. When in doubt, return '2' or '0'.

The type to query for. If true, the host intends to use a custom event target. A positive integer if BCTO is supported, zero or a negative value otherwise.

Bind an ICommand to a UI object, in the "default" way. The meaning of this is dependent on the implementation. Implement this if you have a new type of UI control that doesn't have Command/CommandParameter like WPF or has a non-standard event name for "Invoke".

The command to bind. The target object, usually a UI control of some kind. An IObservable source whose latest value will be passed as the command parameter to the command. Hosts will always pass a valid IObservable, but this may be Observable.Empty. An IDisposable which will disconnect the binding when disposed.

Bind an ICommand to a UI object to a specific event. This event may be a standard .NET event, or it could be an event derived in another manner (i.e. in MonoTouch).

The event argument type. The command to bind. The target object, usually a UI control of some kind. An IObservable source whose latest value will be passed as the command parameter to the command. Hosts will always pass a valid IObservable, but this may be Observable.Empty. The event to bind to. An IDisposable which will disconnect the binding when disposed.

ICreatesObservableForProperty represents an object that knows how to create notifications for a given type of object. Implement this if you are porting RxUI to a new UI toolkit, or generally want to enable WhenAny for another type of object that can be observed in a unique way.

Returns a positive integer when this class supports GetNotificationForProperty for this particular Type. If the method isn't supported at all, return a non-positive integer. When multiple implementations return a positive value, the host will use the one which returns the highest value. When in doubt, return '2' or '0'.

The type to query for. The property of the type to query for. If true, returns whether GNFP is supported before a change occurs. A positive integer if GNFP is supported, zero or a negative value otherwise.

Subscribe to notifications on the specified property, given an object and a property name.

The object to observe. The expression on the object to observe. This will be either a MemberExpression or an IndexExpression depending on the property. The property of the type to query for. If true, signal just before the property value actually changes. If false, signal after the property changes. If true, no warnings should be logged. An IObservable which is signaled whenever the specified property on the object changes. If this cannot be done for a specified value of beforeChanged, return Observable.Never.

This interface is implemented by RxUI objects which are given IObservables as input - when the input IObservables OnError, instead of disabling the RxUI object, we catch the IObservable and pipe it into this property. Normally this IObservable is implemented with a ScheduledSubject whose default Observer is RxApp.DefaultExceptionHandler - this means, that if you aren't listening to ThrownExceptions and one appears, the exception will appear on the UI thread and crash the application.

Gets a observable which will fire whenever an exception would normally terminate ReactiveUI internal state.

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.

Registers a scheduler for the type, which may be specified at runtime, and the contract.

If a scheduler is already registered for the specified runtime and contract, this will overwrite the existing registration. The type of the message to listen to. The scheduler on which to post the notifications for the specified type and contract. CurrentThreadScheduler by default. 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.

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 sequence.

ListenIncludeLatest provides an Observable that will fire whenever a Message is provided for this object via RegisterMessageSource or SendMessage and fire the last provided Message immediately if applicable, or null.

Determines 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. A disposable.

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.

IObservedChange is a generic interface that is returned from WhenAny() Note that it is used for both Changing (i.e.'before change') and Changed Observables.

The sender type. The value type.

Gets the object that has raised the change.

Gets the expression of the member that has changed on Sender.

Gets 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 GetValue() extension method.

Additional details implemented by the different ReactiveUI platform projects.

Gets a descriptor that describes (if applicable) the orientation of the screen.

The device orientation descriptor.

Implement this as a way to intercept bindings at the time that they are created and execute an additional action (or to cancel the binding).

Called when any binding is set up.

If false, the binding is cancelled. The source ViewModel. The target View (not the actual control). Get current view model properties. Get current view properties. The Binding direction.

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

The sender type.

Gets 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.

Gets 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.

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.

IReactivePropertyChangedEventArgs is a generic interface that is used to wrap the NotifyPropertyChangedEventArgs and gives information about changed properties. It includes also the sender of the notification. Note that it is used for both Changing (i.e.'before change') and Changed Observables.

The sender type.

Gets the name of the property that has changed on Sender.

Gets the object that has raised the change.

Implement this interface for ViewModels that can be navigated to.

Gets a string token representing the current ViewModel, such as 'login' or 'user'.

Gets the IScreen that this ViewModel is currently being shown in. This is usually passed into the ViewModel in the Constructor and saved as a ReadOnly Property.

IScreen represents any object that is hosting its own routing - usually this object is your AppViewModel or MainWindow object.

Gets the Router associated with this Screen.

ISuspensionDriver represents a class that can load/save state to persistent storage. Most platforms have a basic implementation of this class, but you probably want to write your own.

Loads the application state from persistent storage.

An object observable.

Saves the application state to disk.

The application state. A completed observable.

Invalidates the application state (i.e. deletes it from disk).

A completed observable.

ISuspensionHost represents a standardized version of the events that the host operating system publishes. Subscribe to these events in order to handle app suspend / resume.

Gets or sets the observable which signals when the application is launching new. This can happen when an app has recently crashed, as well as the first time the app has been launched. Apps should create their state from scratch.

Gets or sets the observable which signals when the application is resuming from suspended state (i.e. it was previously running but its process was destroyed).

Gets or sets the observable which signals when the application is activated. Note that this may mean that your process was not actively running before this signal.

Gets or sets the observable which signals when the application should persist its state to disk.

Returns an IDisposable that should be disposed once the application finishes persisting its state.

Gets or sets the observable which signals that the saved application state should be deleted, this usually is called after an app has crashed.

Gets or sets a function that can be used to create a new application state - usually this method just calls 'new' on an object.

Gets or sets the current application state - get a typed version of this via . The "application state" is a notion entirely defined via the client application - the framework places no restrictions on the object other than it can be serialized.

This base class is mostly used by the Framework. Implement instead.

Gets or sets the View Model associated with the View.

Implement this interface on your Views to support Routing and Binding.

The type of ViewModel.

Gets or sets the ViewModel corresponding to this specific View. This should be a DependencyProperty if you're using XAML.

Implement this to override how RoutedViewHost and ViewModelViewHost map ViewModels to Views.

Determines the view for an associated ViewModel.

The view model type. View model. Contract. The view associated with the given view model.

Used by ReactiveUI when first starting up, it will seek out classes inside our own ReactiveUI projects. The implemented methods will register with Splat their dependencies.

A method the deriving class will class to register the type.

A data-only version of IObservedChange.

The sender type. The value type.

Initializes a new instance of the class.

The sender. Expression describing the member. The value.

Event arguments for when a property has changed. Expands on the PropertyChangedEventArgs to add the Sender.

The sender type.

Initializes a new instance of the class.

The sender. Name of the property.

Gets the sender which triggered the property changed event.

Event arguments for when a property is changing.

The sender type.

Initializes a new instance of the class.

The sender. Name of the property.

Gets the sender which triggered the Reactive property changed event.

Helper extension method class associated with the AutoPersist related functionality.

AutoPersist allows you to automatically call a method when an object has changed, throttling on a certain interval. Note that this object must mark its persistable properties via the [DataMember] attribute. Changes to properties not marked with DataMember will not trigger the object to be saved.

The reactive object type. The reactive object to watch for changes. The asynchronous method to call to save the object to disk. The interval to save the object on. Note that if an object is constantly changing, it is possible that it will never be saved. A Disposable to disable automatic persistence.

The reactive object type. The save signal type. The reactive object to watch for changes. The asynchronous method to call to save the object to disk. When invoked, the object will be saved regardless of whether it has changed. The interval to save the object on. Note that if an object is constantly changing, it is possible that it will never be saved. A Disposable to disable automatic persistence.

Apply AutoPersistence to all objects in a collection. Items that are no longer in the collection won't be persisted anymore.

The item type. The reactive collection to watch for changes. The asynchronous method to call to save the object to disk. The interval to save the object on. Note that if an object is constantly changing, it is possible that it will never be saved. A Disposable to disable automatic persistence.

Apply AutoPersistence to all objects in a collection. Items that are no longer in the collection won't be persisted anymore.

The item type. The return signal type. The reactive collection to watch for changes. The asynchronous method to call to save the object to disk. When invoked, the object will be saved regardless of whether it has changed. The interval to save the object on. Note that if an object is constantly changing, it is possible that it will never be saved. A Disposable to disable automatic persistence.

Apply AutoPersistence to all objects in a collection. Items that are no longer in the collection won't be persisted anymore.

The item type. The signal type. The reactive collection to watch for changes. The asynchronous method to call to save the object to disk. When invoked, the object will be saved regardless of whether it has changed. The interval to save the object on. Note that if an object is constantly changing, it is possible that it will never be saved. A Disposable to disable automatic persistence.

Apply AutoPersistence to all objects in a collection. Items that are no longer in the collection won't be persisted anymore.

The item type. The collection type. The signal type. The reactive collection to watch for changes. The asynchronous method to call to save the object to disk. When invoked, the object will be saved regardless of whether it has changed. The interval to save the object on. Note that if an object is constantly changing, it is possible that it will never be saved. A Disposable to disable automatic persistence.

Call methods 'onAdd' and 'onRemove' whenever an object is added or removed from a collection. This class correctly handles both when a collection is initialized, as well as when the collection is Reset.

The item type. The reactive collection to watch for changes. A method to be called when an object is added to the collection. A method to be called when an object is removed from the collection. A Disposable that deactivates this behavior.

The item type. The collection type. The reactive collection to watch for changes. A method to be called when an object is added to the collection. A method to be called when an object is removed from the collection. A Disposable that deactivates this behavior.

Mixin associated with the DynamicData IChangeSet class.

Is the change set associated with a count change.

The change list to evaluate. If the change set is caused by the count being changed.

Is the change set associated with a count change.

The change list to evaluate. An observable of changes that only have count changes.

Is the change set associated with a count change.

The change set type. The change list to evaluate. An observable of changes that only have count changes.

Extension methods associated with the IMutableDependencyResolver interface.

This method allows you to initialize resolvers with the default ReactiveUI types. All resolvers used as the default Locator.Current. If no namespaces are passed in, all registrations will be checked.

The resolver to initialize. Which platforms to use.

Registers inside the Splat dependency container all the classes that derive off IViewFor using Reflection. This is a easy way to register all the Views that are associated with View Models for an entire assembly.

The dependency injection resolver to register the Views with. The assembly to search using reflection for IViewFor classes.

Extension methods associated with the Expression class.

Gets all the chain of child expressions within a Expression. Handles property member accesses, objects and indexes.

The expression. An enumerable of expressions.

Gets the MemberInfo where a Expression is pointing towards. Can handle MemberAccess and Index types and will handle going through the Conversion Expressions.

The expression. The member info from the expression.

Gets the parent Expression of the current Expression object.

The expression. The parent expression.

For a Expression which is a Index type, will get all the arguments passed to the indexer. Useful for when you are attempting to find the indexer when a constant value is passed in.

The expression. An array of arguments.

Extension methods to assist with Logging.

Logs an Observable to Splat's Logger.

The type. The object type. The source observable to log to splat. The hosting class, usually 'this'. An optional method. An optional Func to convert Ts to strings. The same Observable.

Like Catch, but also prints a message and the error to the log.

The type. The object type. The source observable to log to splat. The hosting class, usually 'this'. The Observable to replace the current one OnError. An error message to print. The same Observable.

Like Catch, but also prints a message and the error to the log.

The type. The object type. The exception type. The source observable to log to splat. The hosting class, usually 'this'. A Func to create an Observable to replace the current one OnError. An error message to print. The same Observable.

Extension methods associated with observables.

Returns only values that are not null. Converts the nullability.

The type of value emitted by the observable. The observable that can contain nulls. A non nullable version of the observable that only emits valid values.

A collection of helpers for .

Returns the name of a property which has been changed.

The sender type. The value type. The observed change. The name of the property which has changed.

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

The sender. The changed value. The instance to get the value of. The current value of the property.

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

The sender. The changed value. The instance to get the value of. The current value of the property.

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

The sender type. The value type. The change notification stream to get the values of. An Observable representing the stream of current values of the given change notification stream.

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 sender type. The value type. The instance to get the value of. 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 sender type. The value type. The target type. The instance to use as a value to apply. The target object to apply the change to. The target property to apply the change to.

Extension methods associated with the Observable Changes and the Reactive Notify Property Changed based events.

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.

The sender type. The value type. The source object to observe properties of. 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. If true, the Observable will not notify with the initial value. 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.

The sender type. The value type. The return value type. The source object to observe properties of. 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.

Creates a observable which will subscribe to the each property and sub property specified in the Expression. eg It will subscribe to x => x.Property1.Property2.Property3 each property in the lambda expression. It will then provide updates to the last value in the chain.

The object where we start the chain. A expression which will point towards the property. If we are interested in notifications before the property value is changed. If we don't want to get a notification about the default value of the property. If true, no warnings should be logged. The type of the origin of the expression chain. The end value we want to subscribe to. A observable which notifies about observed changes. If we cannot cast from the target value from the specified last property.

Generates Observables based on observing INotifyPropertyChanged objects.

Generates Observables based on observing Reactive objects.

A collection of helpers to aid working with observable properties.

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

The object type. The result type. The observable to convert to an ObservableAsPropertyHelper. The ReactiveObject that has the property. An Expression representing the property (i.e. x => x.SomeProperty). A value indicating whether the should defer the subscription to the source until the first call to , or if it should immediately subscribe to the source. The scheduler that the notifications will be provided on - this should normally be a Dispatcher-based scheduler. 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 object type. The result type. The observable to convert to an ObservableAsPropertyHelper. The ReactiveObject that has the property. An Expression representing the property (i.e. x => x.SomeProperty). The initial value of the property. A value indicating whether the should defer the subscription to the source until the first call to , or if it should immediately subscribe to the source. The scheduler that the notifications will be provided on - this should normally be a Dispatcher-based scheduler. 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 object type. The result type. The observable to convert to an ObservableAsPropertyHelper. The ReactiveObject that has the property. An Expression representing the property (i.e. x => x.SomeProperty). The function used to retrieve the initial value of the property. A value indicating whether the should defer the subscription to the source until the first call to , or if it should immediately subscribe to the source. The scheduler that the notifications will be provided on - this should normally be a Dispatcher-based scheduler. 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 object type. The result type. The observable to convert to an ObservableAsPropertyHelper. The ReactiveObject that has the property. An Expression representing the property (i.e. x => x.SomeProperty). An out param matching the return value, provided for convenience. A value indicating whether the should defer the subscription to the source until the first call to , or if it should immediately subscribe to the source. The scheduler that the notifications will be provided on - this should normally be a Dispatcher-based scheduler. 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 object type. The result type. The observable to convert to an ObservableAsPropertyHelper. The ReactiveObject that has the property. An Expression representing the property (i.e. x => x.SomeProperty). An out param matching the return value, provided for convenience. The initial value of the property. A value indicating whether the should defer the subscription to the source until the first call to , or if it should immediately subscribe to the source. The scheduler that the notifications will be provided on - this should normally be a Dispatcher-based scheduler. 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 object type. The result type. The observable to convert to an ObservableAsPropertyHelper. The ReactiveObject that has the property. An Expression representing the property (i.e. x => x.SomeProperty). An out param matching the return value, provided for convenience. The function used to retrieve the initial value of the property. A value indicating whether the should defer the subscription to the source until the first call to , or if it should immediately subscribe to the source. The scheduler that the notifications will be provided on - this should normally be a Dispatcher-based scheduler. 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 object type. The result type. The observable to convert to an ObservableAsPropertyHelper. The ReactiveObject that has the property. The name of the property that has changed. Recommended for use with nameof() or a FODY. or a FODY. The initial value of the property. A value indicating whether the should defer the subscription to the source until the first call to , or if it should immediately subscribe to the source. The scheduler that the notifications will be provided on - this should normally be a Dispatcher-based scheduler. 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 object type. The result type. The observable to convert to an ObservableAsPropertyHelper. The ReactiveObject that has the property. The name of the property that has changed. Recommended for use with nameof() or a FODY. or a FODY. A value indicating whether the should defer the subscription to the source until the first call to , or if it should immediately subscribe to the source. The scheduler that the notifications will be provided on - this should normally be a Dispatcher-based scheduler. 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 object type. The result type. The observable to convert to an ObservableAsPropertyHelper. The ReactiveObject that has the property. The name of the property that has changed. Recommended for use with nameof() or a FODY. or a FODY. The function used to retrieve the initial value of the property. A value indicating whether the should defer the subscription to the source until the first call to , or if it should immediately subscribe to the source. The scheduler that the notifications will be provided on - this should normally be a Dispatcher-based scheduler. 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 object type. The result type. The observable to convert to an ObservableAsPropertyHelper. The ReactiveObject that has the property. The name of the property that has changed. Recommended for use with nameof() or a FODY. An out param matching the return value, provided for convenience. A value indicating whether the should defer the subscription to the source until the first call to , or if it should immediately subscribe to the source. The scheduler that the notifications will be provided on - this should normally be a Dispatcher-based scheduler. 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 object type. The result type. The observable to convert to an ObservableAsPropertyHelper. The ReactiveObject that has the property. The name of the property that has changed. Recommended for use with nameof() or a FODY. An out param matching the return value, provided for convenience. The function used to retrieve the initial value of the property. A value indicating whether the should defer the subscription to the source until the first call to , or if it should immediately subscribe to the source. The scheduler that the notifications will be provided on - this should normally be a Dispatcher-based scheduler. An initialized ObservableAsPropertyHelper; use this as the backing field for your property.

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 extension methods.

The type.

Initializes a new instance of the class.

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. A value indicating whether the should defer the subscription to the source until the first call to , or if it should immediately subscribe to the source. The scheduler that the notifications will be provided on - this should normally be a Dispatcher-based scheduler.

Initializes a new instance of the class.

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 action to take when the property changes, typically this will call the ViewModel's RaisePropertyChanging method. The initial value of the property. A value indicating whether the should defer the subscription to the source until the first call to , or if it should immediately subscribe to the source. The scheduler that the notifications will provided on - this should normally be a Dispatcher-based scheduler.

Initializes a new instance of the class.

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 action to take when the property changes, typically this will call the ViewModel's RaisePropertyChanging method. The function used to retrieve the initial value of the property. A value indicating whether the should defer the subscription to the source until the first call to , or if it should immediately subscribe to the source. The scheduler that the notifications will provided on - this should normally be a Dispatcher-based scheduler.

Gets the last provided value from the Observable.

Gets a value indicating whether the ObservableAsPropertyHelper has subscribed to the source Observable. Useful for scenarios where you use deferred subscription and want to know if the ObservableAsPropertyHelper Value has been accessed yet.

Gets an observable which signals whenever an exception would normally terminate ReactiveUI internal state.

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. A default property helper.

Disposes this ObservableAsPropertyHelper.

This class is the final fallback for WhenAny, and will simply immediately return the value of the type at the time it was created. It will also warn the user that this is probably not what they want to do.

Observable Func Mixins.

Converts to observable.

The type of the view model. The type of the result. The expression. The view model. if set to true [before change]. if set to true [skip initial]. An observable Result.

Class that represents the platform registration for ReactiveUI.

Set the platform namespaces to register. This needs to be set before the first call to .

The namespaces to register.

Encapsulates a composite user interaction.

This class provides the bulk of the actual implementation for combined reactive commands. You should not create instances of this class directly, but rather via the static creation methods on the non-generic class. A CombinedReactiveCommand combines multiple reactive commands into a single command. Executing the combined command executes all child commands. Since all child commands will receive the same execution parameter, all child commands must accept a parameter of the same type. In order for the combined command to be executable, all child commands must themselves be executable. In addition, any canExecute observable passed in during construction must also yield true. The type of parameter values passed in during command execution. The type of the values that are the result of command execution.

Initializes a new instance of the class.

The child commands which will be executed. A observable when the command can be executed. The scheduler where to dispatch the output from the command. Fires when required arguments are null. Fires if the child commands container is empty.

Encapsulates a user action behind a reactive interface. This is for interop inside for the command binding. Not meant for external use due to the fact it doesn't implement ICommand to force the user to favor the Reactive style command execution.

Gets an observable whose value indicates whether the command is currently executing.

This observable can be particularly useful for updating UI, such as showing an activity indicator whilst a command is executing.

Gets an observable whose value indicates whether the command can currently execute.

The value provided by this observable is governed both by any canExecute observable provided during command creation, as well as the current execution status of the command. A command that is currently executing will always yield false from this observable, even if the canExecute pipeline is currently true.

Encapsulates a user action behind a reactive interface.

This non-generic base class defines the creation behavior of the ReactiveCommand's. adds the concept of Input and Output generic types. The Input is often passed in by the View and it's type is captured as TInput, and the Output is the result of executing the command which type is captured as TOutput. is IObservable which can be used like any other IObservable. For example, you can Subscribe() to it like any other observable, and add the output to a List on your view model. The Unit type is a functional programming construct analogous to void and can be used in cases where you don't care about either the input and/or output value. Creating synchronous reactive commands:


              command = ReactiveCommand.Create(x => Console.WriteLine(x));
            
             // This outputs 42 to console.
             command.Execute(42).Subscribe();
            
             // A better approach is to invoke a command in response to an Observable.
             // InvokeCommand operator respects the command's executability. That is, if
             // the command's CanExecute method returns false, InvokeCommand will not
             // execute the command when the source observable ticks.
             Observable.Return(42).InvokeCommand(command);
             ]]>

Creating asynchronous reactive commands:


             (
                  _ => Observable.Return(42).Delay(TimeSpan.FromSeconds(2))
             );
            
             // Calling the asynchronous reactive command:
             // Observable.Return(Unit.Default).InvokeCommand(command);
            
             // Subscribing to values emitted by the command:
             command.Subscribe(Console.WriteLine);
             ]]>

Creates a parameterless with synchronous execution logic.

The action to execute whenever the command is executed. An optional observable that dictates the availability of the command for execution. An optional scheduler that is used to surface events. Defaults to RxApp.MainThreadScheduler. The ReactiveCommand instance.

Creates a parameterless with synchronous execution logic that returns a value of type .

The function to execute whenever the command is executed. An optional observable that dictates the availability of the command for execution. An optional scheduler that is used to surface events. Defaults to RxApp.MainThreadScheduler. The ReactiveCommand instance. The type of value returned by command executions.

Creates a with synchronous execution logic that takes a parameter of type .

Creates a with synchronous execution logic that takes a parameter of type and returns a value of type .

Creates a that composes all the provided child commands.

The child commands that the combined command will compose. An optional observable that dictates the availability of the command for execution (in addition to the availability specified by each individual child command). An optional scheduler that is used to surface events. Defaults to RxApp.MainThreadScheduler. The CombinedReactiveCommand instance. The type of the parameter passed through to command execution. The type of the command's result.

Creates a parameterless with asynchronous execution logic.

Provides an observable representing the command's asynchronous execution logic. An optional observable that dictates the availability of the command for execution. An optional scheduler that is used to surface events. Defaults to RxApp.MainThreadScheduler. The ReactiveCommand instance. The type of the command's result.

Creates a with asynchronous execution logic that takes a parameter of type .

Creates a parameterless with asynchronous execution logic.

Provides a representing the command's asynchronous execution logic. An optional observable that dictates the availability of the command for execution. An optional scheduler that is used to surface events. Defaults to RxApp.MainThreadScheduler. The ReactiveCommand instance. The type of the command's result.

Creates a parameterless, cancellable with asynchronous execution logic.

Creates a parameterless with asynchronous execution logic.

Creates a parameterless, cancellable with asynchronous execution logic.

Creates a with asynchronous execution logic that takes a parameter of type .

Creates a with asynchronous, cancellable execution logic that takes a parameter of type .

Creates a with asynchronous execution logic that takes a parameter of type .

Creates a with asynchronous, cancellable execution logic that takes a parameter of type .

Encapsulates a user interaction behind a reactive interface.

This class provides the bulk of the actual implementation for reactive commands. You should not create instances of this class directly, but rather via the static creation methods on the non-generic class. The type of parameter values passed in during command execution. The type of the values that are the result of command execution.

Initializes a new instance of the class.

The Func to perform when the command is executed. A observable which has a value if the command can execute. The scheduler where to send output after the main execution. Thrown if any dependent parameters are null.

A base class for generic reactive commands.

This class extends and adds generic type parameters for the parameter values passed into command execution, and the return values of command execution. Because the result type is known by this class, it can implement . However, the implementation is defined as abstract, so subclasses must provide it. Reactive commands encapsulate the behavior of running some execution logic and then surfacing the results on the UI thread. Importantly, no scheduling is performed against input observables (the canExecute and execution pipelines). To create an instance of ReactiveCommand, call one of the static creation methods defined by this class. can be used when your execution logic is synchronous. ReactiveCommand.CreateFromObservable and ReactiveCommand.CreateFromTask (and overloads) can be used for asynchronous execution logic. Optionally, you can provide an observable that governs the availability of the command for execution, as well as a scheduler to which events will be delivered. The property provides an observable that can be used to determine whether the command is eligible for execution. The value of this observable is determined by both the canExecute observable provided during command creation, and the current execution status of the command. A command that is already executing will yield false from its observable regardless of the canExecute observable provided during command creation. The property provides an observable whose value indicates whether the command is currently executing. This can be a useful means of triggering UI, such as displaying an activity indicator whilst a command is executing. As discussed above, you are under no obligation to somehow incorporate this into your canExecute observable because that is taken care of for you. That is, if the value of IsExecuting is true, the value of CanExecute will be false. However, if the value of CanExecute is false, that does not imply the value of IsExecuting is true. Any errors in your command's execution logic (including any canExecute observable you choose to provide) will be surfaced via the observable. This gives you the opportunity to handle the error before it triggers a default handler that tears down the application. For example, you might use this as a means of alerting the user that something has gone wrong executing the command. For the sake of convenience, all ReactiveCommand instances are also implementations of . This allows you to easily integrate instances of ReactiveCommand into platforms that understands ICommand natively (such as WPF and UWP). The type of parameter values passed in during command execution. The type of the values that are the result of command execution.

Gets an observable whose value indicates whether the command can currently execute.

Gets an observable whose value indicates whether the command is currently executing.

This observable can be particularly useful for updating UI, such as showing an activity indicator whilst a command is executing.

Gets an observable that ticks any exceptions in command execution logic.

Any exceptions that are not observed via this observable will propagate out and cause the application to be torn down. Therefore, you will always want to subscribe to this observable if you expect errors could occur (e.g. if your command execution includes network activity).

Subscribes to execution results from this command.

The observer. An that, when disposed, will unsubscribe the observer.

Gets an observable that, when subscribed, executes this command.

Invoking this method will return a cold (lazy) observable that, when subscribed, will execute the logic encapsulated by the command. It is worth restating that the returned observable is lazy. Nothing will happen if you call Execute and neglect to subscribe (directly or indirectly) to the returned observable. If no parameter value is provided, a default value of type will be passed into the execution logic. Any number of subscribers can subscribe to a given execution observable and the execution logic will only run once. That is, the result is broadcast to those subscribers. In those cases where execution fails, there will be no result value. Instead, the failure will tick through the observable. The parameter to pass into command execution. An observable that will tick the single result value if and when it becomes available.

Gets an observable that, when subscribed, executes this command.

Invoking this method will return a cold (lazy) observable that, when subscribed, will execute the logic encapsulated by the command. It is worth restating that the returned observable is lazy. Nothing will happen if you call Execute and neglect to subscribe (directly or indirectly) to the returned observable. If no parameter value is provided, a default value of type will be passed into the execution logic. Any number of subscribers can subscribe to a given execution observable and the execution logic will only run once. That is, the result is broadcast to those subscribers. In those cases where execution fails, there will be no result value. Instead, the failure will tick through the observable. An observable that will tick the single result value if and when it becomes available.

Disposes of the managed resources.

If its getting called by the Dispose() method.

Will trigger a event when the CanExecute condition has changed.

The new value of the execute.

Will be called by the methods from the ICommand interface. This method is called when the Command should evaluate if it can execute.

The parameter being passed to the ICommand. If the command can be executed.

Will be called by the methods from the ICommand interface. This method is called when the Command should execute.

The parameter being passed to the ICommand.

Extension methods associated with the ReactiveCommand class.

A utility method that will pipe an Observable to an ICommand (i.e. it will first call its CanExecute with the provided value, then if the command can be executed, Execute() will be called).

The type. The source observable to pipe into the command. The command to be executed. An object that when disposes, disconnects the Observable from the command.

A utility method that will pipe an Observable to an ICommand (i.e. it will first call its CanExecute with the provided value, then if the command can be executed, Execute() will be called).

The type. The result type. The source observable to pipe into the command. The command to be executed. An object that when disposes, disconnects the Observable from the command.

A utility method that will pipe an Observable to an ICommand (i.e. it will first call its CanExecute with the provided value, then if the command can be executed, Execute() will be called).

The type. The target type. The source observable to pipe into the command. The root object which has the Command. The expression to reference the Command. An object that when disposes, disconnects the Observable from the command.

A utility method that will pipe an Observable to an ICommand (i.e. it will first call its CanExecute with the provided value, then if the command can be executed, Execute() will be called).

The type. The result type. The target type. The source observable to pipe into the command. The root object which has the Command. The expression to reference the Command. An object that when disposes, disconnects the Observable from the command.

A reactive object is a interface for ViewModels which will expose logging, and notify when properties are either changing or changed. The primary use of this interface is to allow external classes such as the ObservableAsPropertyHelper to trigger these events inside the ViewModel.

Raise a property is changing event.

The arguments with details about the property that is changing.

Raise a property has changed event.

The arguments with details about the property that has changed.

Extension methods associated with the IReactiveObject interface.

Contains the state information about the current status of a Reactive Object.

The type of the sender of the property changes.

Gets an observable for when a property is changing.

Gets an observable for when the property has changed.

Gets a observable for when an exception is thrown.

Subscribe raise property changing events to a property changing observable. Must be called before raising property changing events.

Raises a property changing event.

The name of the property that is changing.

Subscribe raise property changed events to a property changed observable. Must be called before raising property changed events.

Raises a property changed event.

The name of the property that has changed.

Indicates if we are currently sending change notifications.

If change notifications are being sent.

Suppress change notifications until the return value is disposed.

A IDisposable which when disposed will re-enable change notifications.

Are change notifications currently delayed. Used for Observables change notifications only.

If the change notifications are delayed.

Delay change notifications until the return value is disposed.

A IDisposable which when disposed will re-enable change notifications.

RaiseAndSetIfChanged fully implements a Setter for a read-write property on a ReactiveObject, using CallerMemberName to raise the notification and the ref to the backing field to set the property.

The type of the This. The type of the return value. The raising the notification. A Reference to the backing field for this property. The new value. The name of the property, usually automatically provided through the CallerMemberName attribute. The newly set value, normally discarded.

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

The sender type. The instance of ReactiveObject on which the property has changed. A string representing the name of the property that has been changed. Leave null to let the runtime set to caller member name.

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

Use this method for enabling classic PropertyChanging events when you are implementing IReactiveObject manually.

The sender type. The instance of IReactiveObject which should propagate property changes.

Use this method for enabling classic PropertyChanged events when you are implementing IReactiveObject manually.

The sender type. The instance of IReactiveObject which should propagate property changes.

Initializes a new instance of the class.

The sender.

When this method is called, an object will not fire change notifications (neither traditional nor Observable notifications) until the return value is disposed. If this method is called multiple times it will reference count and not perform notification until all values returned are disposed.

An object that, when disposed, reenables change notifications.

When this method is called, an object will not dispatch change Observable notifications until the return value is disposed. When the Disposable it will dispatched all queued notifications. If this method is called multiple times it will reference count and not perform notification until all values returned are disposed.

An object that, when disposed, re-enables Observable change notifications.

Filter a list of change notifications, returning the last change for each PropertyName in original order.

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

Initializes a new instance of the class.

Determines if change notifications are enabled or not.

A value indicating whether change notifications are enabled.

Delays notifications until the return IDisposable is disposed.

A disposable which when disposed will send delayed notifications.

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

Initializes a new instance of the class.

Determines if change notifications are enabled or not.

A value indicating whether change notifications are enabled.

Delays notifications until the return IDisposable is disposed.

A disposable which when disposed will send delayed notifications.

Platforms or other registration namespaces for the dependency resolver to consider when initializing.

No platform to register.

Xamarin Forms.

Windows Forms.

WPF.

Uno.

Uno Win UI.

Blazor.

Drawing.

Avalonia.

Maui.

Uwp.

WinUI.

The main registration for common classes for the Splat dependency injection. We have code that runs reflection through the different ReactiveUI classes searching for IWantsToRegisterStuff and will register all our required DI interfaces. The registered items in this classes are common for all Platforms. To get these registrations after the main ReactiveUI Initialization use the DependencyResolverMixins.InitializeReactiveUI() extension method.

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.

Gets or sets the Current MessageBus.

Registers a scheduler for the type, which may be specified at runtime, and the contract.

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

Determines 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.

Extension methods associated with the IRoutableViewModel interface.

This method allows you to set up connections that only operate while the ViewModel has focus, and cleans up when the ViewModel loses focus.

The ViewModel to watch for focus changes. Called when the ViewModel is navigated to - return an IDisposable that cleans up all of the things that are configured in the method. An IDisposable that lets you disconnect the entire process earlier than normal.

This method will return an observable that fires events every time the topmost ViewModel in the navigation stack is this ViewModel. This allows you to set up connections that only operate while the ViewModel has focus. The observable will complete when the ViewModel is removed completely from the navigation stack. If your ViewModel can be _removed_ from the navigation stack and then reused later, you must call this method and resubscribe each time it is reused.

The viewmodel to watch for navigation changes. An IObservable{Unit} that signals when the ViewModel has been added or brought to the top of the navigation stack. The observable completes when the ViewModel is no longer a part of the navigation stack.

This method will return an observable that fires events _just before_ the ViewModel is no longer the topmost ViewModel in the navigation stack. This allows you to clean up anything before losing focus. The observable will complete when the ViewModel is removed completely from the navigation stack. If your ViewModel can be _removed_ from the navigation stack and then reused later, you must call this method and resubscribe each time it is reused.

/// The viewmodel to watch for navigation changes. An IObservable{Unit} that signals when the ViewModel is no longer the topmost ViewModel in the navigation stack. The observable completes when the ViewModel is no longer a part of the navigation stack.

RoutingState manages the ViewModel Stack and allows ViewModels to navigate to other ViewModels.

Initializes static members of the class.

Initializes a new instance of the class.

A scheduler for where to send navigation changes to.

Gets the current navigation stack, the last element in the collection being the currently visible ViewModel.

Gets or sets a command which will navigate back to the previous element in the stack.

Gets or sets a command that navigates to the a new element in the stack - the Execute parameter must be a ViewModel that implements IRoutableViewModel.

Gets or sets a command that navigates to a new element and resets the navigation stack (i.e. the new ViewModel will now be the only element in the stack) - the Execute parameter must be a ViewModel that implements IRoutableViewModel.

Gets or sets the current view model which is to be shown for the Routing.

Gets or sets an observable which will signal when the Navigation changes.

Extension methods associated with the RoutingState class.

Locate the first ViewModel in the stack that matches a certain Type.

The view model type. The routing state. The matching ViewModel or null if none exists.

Returns the currently visible ViewModel.

The routing state. The matching ViewModel or null if none exists.

The main registration point for common class instances throughout a ReactiveUI application.

N.B. Why we have this evil global class In a WPF or UWP application, most commands must have the Dispatcher scheduler set, because notifications will end up being run on another thread; this happens most often in a CanExecute observable.Unfortunately, in a Unit Test framework, while the MS Test Unit runner will *set* the Dispatcher (so we can't even use the lack of its presence to determine whether we're in a test runner or not), none of the items queued to it will ever be executed during the unit test. Initially, I tried to plumb the ability to set the scheduler throughout the classes, but when you start building applications on top of that, having to have *every single * class have a default Scheduler property is really irritating, with either default making life difficult. This class also initializes a whole bunch of other stuff, including the IoC container, logging and error handling.

The size of a small cache of items. Often used for the MemoizingMRUCache class.

The size of a large cache of items. Often used for the MemoizingMRUCache class.

Initializes static members of the class.

Default exception when we have unhandled exception in RxUI.

Gets or sets a 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.

Gets or sets the a the scheduler used to schedule work items to run in a background thread. In both modes, this will run on the TPL Task Pool.

Gets or sets a value indicating whether log messages should be suppressed for command bindings in the view.

Gets or sets the Observer which signaled whenever an object that has a ThrownExceptions property doesn't Subscribe to that Observable. Use Observer.Create to set up what will happen - the default is to crash the application with an error message.

Gets or sets the current SuspensionHost, a class which provides events for process lifetime events, especially on mobile devices.

A subject which dispatches all its events on the specified Scheduler.

The type of item being dispatched by the Subject.

Initializes a new instance of the class.

The scheduler where to dispatch items to. A optional default observer where notifications will be sent. A optional default subject which this Subject will wrap.

Disposes of any managed resources in our class.

If we are being called by the IDisposable method.

This scheduler attempts to deal with some of the brain-dead defaults on certain Microsoft platforms that make it difficult to access the Dispatcher during startup. This class wraps a scheduler and if it isn't available yet, it simply runs the scheduled item immediately.

Initializes a new instance of the class.

A func which will return a new scheduler.

A suspension driver that does not do anything. Useful potentially for unit testing or for platforms where you don't want to use a Suspension Driver.

A internal state setup by other classes for the different suspension state of a application. The user does not implement themselves but is often setup via the AutoSuspendHelper class.

Initializes a new instance of the class.

Gets or sets a observable which notifies when the application is resuming.

Gets or sets a observable which notifies when the application is un-pausing.

Gets or sets a observable which notifies when the application should persist its state.

Gets or sets a observable which notifies when a application is launching new.

Gets or sets a observable which notifies when the application state should be invalidated.

Gets or sets a Func which will generate a fresh application state.

Gets or sets the application state that will be used when suspending and resuming the class.

Extension methods associated with the ISuspensionHost interface.

Func used to load app state exactly once.

Supsension driver reference field to prevent introducing breaking change.

Get the current App State of a class derived from ISuspensionHost.

The app state type. The suspension host. The app state.

Observe changes to the AppState of a class derived from ISuspensionHost.

The observable type. The suspension host. An observable of the app state.

Setup our suspension driver for a class derived off ISuspensionHost interface. This will make your suspension host respond to suspend and resume requests.

The suspension host. The suspension driver. A disposable which will stop responding to Suspend and Resume requests.

Ensures one time app state load from storage.

The suspension host. The suspension driver. A completed observable.

Indicates that an object implementing has caused an error and nothing is attached to to handle that error.

Initializes a new instance of the class.

The exception message.

Initializes a new instance of the class.

The exception message. The exception that caused this exception.

Initializes a new instance of the class.

The serialization information. The serialization context.

Extension methods associated with the WhenAny/WhenAnyValue classes.

WhenAnyValue allows you to observe whenever the value of a property on an object has 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.

The object where the property chain starts. The first property chain to reference. This will be a expression pointing to a end property or field.

WhenAnyValue allows you to observe whenever the value of 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.

The object where the property chain starts. The 1 property chain to reference. This will be a expression pointing to a end property or field. The selector which will determine the final value from the properties.

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.

The object where the property chain starts. The 1 property chain to reference. This will be a expression pointing to a end property or field. The 2 property chain to reference. This will be a expression pointing to a end property or field. The 3 property chain to reference. This will be a expression pointing to a end property or field. The 4 property chain to reference. This will be a expression pointing to a end property or field. The 5 property chain to reference. This will be a expression pointing to a end property or field. The 6 property chain to reference. This will be a expression pointing to a end property or field. The 7 property chain to reference. This will be a expression pointing to a end property or field. The 8 property chain to reference. This will be a expression pointing to a end property or field. The 9 property chain to reference. This will be a expression pointing to a end property or field. The selector which will determine the final value from the properties.

The object where the property chain starts. The 1 property chain to reference. This will be a expression pointing to a end property or field. The 2 property chain to reference. This will be a expression pointing to a end property or field. The 3 property chain to reference. This will be a expression pointing to a end property or field. The 4 property chain to reference. This will be a expression pointing to a end property or field. The 5 property chain to reference. This will be a expression pointing to a end property or field. The 6 property chain to reference. This will be a expression pointing to a end property or field. The 7 property chain to reference. This will be a expression pointing to a end property or field. The 8 property chain to reference. This will be a expression pointing to a end property or field. The 9 property chain to reference. This will be a expression pointing to a end property or field. The 10 property chain to reference. This will be a expression pointing to a end property or field. The selector which will determine the final value from the properties.

The object where the property chain starts. The 1 property chain to reference. This will be a expression pointing to a end property or field. The 2 property chain to reference. This will be a expression pointing to a end property or field. The 3 property chain to reference. This will be a expression pointing to a end property or field. The 4 property chain to reference. This will be a expression pointing to a end property or field. The 5 property chain to reference. This will be a expression pointing to a end property or field. The 6 property chain to reference. This will be a expression pointing to a end property or field. The 7 property chain to reference. This will be a expression pointing to a end property or field. The 8 property chain to reference. This will be a expression pointing to a end property or field. The 9 property chain to reference. This will be a expression pointing to a end property or field. The 10 property chain to reference. This will be a expression pointing to a end property or field. The 11 property chain to reference. This will be a expression pointing to a end property or field. The selector which will determine the final value from the properties.

The object where the property chain starts. The 1 property chain to reference. This will be a expression pointing to a end property or field. The 2 property chain to reference. This will be a expression pointing to a end property or field. The 3 property chain to reference. This will be a expression pointing to a end property or field. The 4 property chain to reference. This will be a expression pointing to a end property or field. The 5 property chain to reference. This will be a expression pointing to a end property or field. The 6 property chain to reference. This will be a expression pointing to a end property or field. The 7 property chain to reference. This will be a expression pointing to a end property or field. The 8 property chain to reference. This will be a expression pointing to a end property or field. The 9 property chain to reference. This will be a expression pointing to a end property or field. The 10 property chain to reference. This will be a expression pointing to a end property or field. The 11 property chain to reference. This will be a expression pointing to a end property or field. The 12 property chain to reference. This will be a expression pointing to a end property or field. The selector which will determine the final value from the properties.

A mixin which provides support for subscribing to observable properties.

Observe a observable which is set to a property, and automatically subscribe to the most recent emitted value.

The object where the property chain starts. The first observable to observe.

Monitor a property that is an observable, and subscribe to the most recent emitted value.

The object where the property chain starts. The 1 property chain to reference which ends with an observable. This will be a expression pointing to a end property or field which must be an observable. The 2 property chain to reference which ends with an observable. This will be a expression pointing to a end property or field which must be an observable. The 3 property chain to reference which ends with an observable. This will be a expression pointing to a end property or field which must be an observable. The 4 property chain to reference which ends with an observable. This will be a expression pointing to a end property or field which must be an observable. The 5 property chain to reference which ends with an observable. This will be a expression pointing to a end property or field which must be an observable. The 6 property chain to reference which ends with an observable. This will be a expression pointing to a end property or field which must be an observable. The 7 property chain to reference which ends with an observable. This will be a expression pointing to a end property or field which must be an observable. The 8 property chain to reference which ends with an observable. This will be a expression pointing to a end property or field which must be an observable. The 9 property chain to reference which ends with an observable. This will be a expression pointing to a end property or field which must be an observable.

Monitor a property that is an observable, and subscribe to the most recent emitted value.

The object where the property chain starts. The 1 property chain to reference. The 2 property chain to reference. The selector which will determine the final value from the properties. This must be an observable.

Monitor a property that is an observable, and subscribe to the most recent emitted value.

The object where the property chain starts. The 1 property chain to reference. The 2 property chain to reference. The 3 property chain to reference. The selector which will determine the final value from the properties. This must be an observable.

Monitor a property that is an observable, and subscribe to the most recent emitted value.

The object where the property chain starts. The 1 property chain to reference. The 2 property chain to reference. The 3 property chain to reference. The 4 property chain to reference. The 5 property chain to reference. The 6 property chain to reference. The 7 property chain to reference. The 8 property chain to reference. The selector which will determine the final value from the properties. This must be an observable.

Monitor a property that is an observable, and subscribe to the most recent emitted value.

The object where the property chain starts. The 1 property chain to reference. The 2 property chain to reference. The 3 property chain to reference. The 4 property chain to reference. The 5 property chain to reference. The 6 property chain to reference. The 7 property chain to reference. The 8 property chain to reference. The 9 property chain to reference. The selector which will determine the final value from the properties. This must be an observable.

Monitor a property that is an observable, and subscribe to the most recent emitted value.

The object where the property chain starts. The 1 property chain to reference. The 2 property chain to reference. The 3 property chain to reference. The 4 property chain to reference. The 5 property chain to reference. The 6 property chain to reference. The 7 property chain to reference. The 8 property chain to reference. The 9 property chain to reference. The 10 property chain to reference. The selector which will determine the final value from the properties. This must be an observable.

Monitor a property that is an observable, and subscribe to the most recent emitted value.

The object where the property chain starts. The 1 property chain to reference. The 2 property chain to reference. The 3 property chain to reference. The 4 property chain to reference. The 5 property chain to reference. The 6 property chain to reference. The 7 property chain to reference. The 8 property chain to reference. The 9 property chain to reference. The 10 property chain to reference. The 11 property chain to reference. The selector which will determine the final value from the properties. This must be an observable.

Monitor a property that is an observable, and subscribe to the most recent emitted value.

The object where the property chain starts. The 1 property chain to reference. The 2 property chain to reference. The 3 property chain to reference. The 4 property chain to reference. The 5 property chain to reference. The 6 property chain to reference. The 7 property chain to reference. The 8 property chain to reference. The 9 property chain to reference. The 10 property chain to reference. The 11 property chain to reference. The 12 property chain to reference. The selector which will determine the final value from the properties. This must be an observable.

Default implementation for . The default behavior is to replace instances of "View" with "ViewMode" in the Fully Qualified Name of the ViewModel type.

Initializes a new instance of the class.

The method which will convert a ViewModel name into a View.

Gets or sets a function that is used to convert a view model name to a proposed view name.

If unset, the default behavior is to change "ViewModel" to "View". If a different convention is followed, assign an appropriate function to this property. Note that the name returned by the function is a starting point for view resolution. Variants on the name will be resolved according to the rules set out by the method.

Returns the view associated with a view model, deriving the name of the type via , then discovering it via the service locator.

The type. Given view model type T with runtime type RT, this implementation will attempt to resolve the following views: Look for a service registered under the type whose name is given to us by passing RT to (which defaults to changing "ViewModel" to "View"). Look for a service registered under the type IViewFor<RT>. Look for a service registered under the type whose name is given to us by passing T to (which defaults to changing "ViewModel" to "View"). Look for a service registered under the type IViewFor<T>. If T is an interface, change its name to that of a class (i.e. drop the leading "I"). If it's a class, change to an interface (i.e. add a leading "I"). Repeat steps 1-4 with the type resolved from the modified name. The view model whose associated view is to be resolved. Optional contract to be used when resolving from Splat. The view associated with the given view model.

Indicates that this View should be constructed _once_ and then used every time its ViewModel View is resolved. Obviously, this is not supported on Views that may be reused multiple times in the Visual Tree.

Allows an additional string to make view resolution more specific than just a type. When applied to your -derived View, you can select between different Views for a single ViewModel instance.

Initializes a new instance of the class. Constructs the ViewContractAttribute with a specific contract value.

The value of the contract for view resolution.

Gets the contract to use when resolving the view in the Splat Dependency Injection engine.

Helper class which will get the currently registered IViewLocator interface inside the Splat dependency injection container.

Gets the currently registered IViewLocator interface.

If there is no IViewLocator registered. Can happen due to using your own DI container and don't rerun the DependencyResolverMixins.InitializeReactiveUI() method. Also can happen if you don't include all the NuGet packages.

An exception that is thrown if we are unable to find the View Locator.

Initializes a new instance of the class.

A user friendly message.

Initializes a new instance of the class.

A user friendly message. Any exception this exception is wrapping.

Initializes a new instance of the class.

The serialization info. The serialization context.

Binding Type Converter for component model.

.NET Framework platform registrations.

Reserved to be used by the compiler for tracking metadata. This class should not be used by developers in source code.

Extension methods associated with the IDisposable interface.

Ensures the provided disposable is disposed with the specified .

The type of the disposable. The disposable we are going to want to be disposed by the CompositeDisposable. The to which will be added. The disposable.

Provides commonly required, statically-allocated, pre-canned observables.

The observable type.

An empty observable of type .

An observable of type that never ticks a value.

An observable of type that ticks a single, default value.

Provides commonly required, statically-allocated, pre-canned observables.

An observable that ticks a single, Boolean value of true.

An observable that ticks a single, Boolean value of false.

This observable is equivalent to Observable<bool>.Default, but is provided for convenience.

An observable that ticks Unit.Default as a single value.

This observable is equivalent to Observable<Unit>.Default, but is provided for convenience.