Namespace ReactiveUI
Classes
- Activation
For View Fetcher ActivationForViewFetcher is how ReactiveUI determine when a View is activated or deactivated. This is usually only used when porting ReactiveUI to a new UI framework.
- Auto
Data Template Binding Hook AutoDataTemplateBindingHook is a binding hook that checks ItemsControls that don't have DataTemplates, and assigns a default DataTemplate that loads the View associated with each ViewModel.
- Auto
Persist Helper Helper extension method class associated with the AutoPersist related functionality.
- Auto
Suspend Helper Wires WPF Application lifecycle events into Suspension
Host so application state can be persisted automatically.
- Boolean
ToVisibility Type Converter This type convert converts between Boolean and XAML Visibility - the conversionHint is a BooleanToVisibilityHint.
- Byte
ToString Type Converter Short To String Type Converter.
- Can
Activate View Fetcher This class implements View Activation for classes that explicitly describe their activation via ICan
Activate . This class is used by the framework.
- Change
Set Mixin Mixin associated with the DynamicData IChangeSet class.
- CombinedReactiveCommand<TParam, TResult>
Encapsulates a composite user interaction.
- Command
Binder Various helpers to bind View controls and ViewModel commands together.
- Command
Binder Implementation Used by the CommandBinder extension methods to handle binding View controls and ViewModel commands.
- Comparer
Chaining Extensions Convenience class to help chain selectors onto existing parent comparers.
- Component
Model Type Converter Binding Type Converter for component model.
- Creates
Command Binding Via Command Parameter Class that registers Command Binding and Command Parameter Binding.
- Creates
Command Binding Via Event This binder is the default binder for connecting to arbitrary events.
- Decimal
ToString Type Converter Decimal To String Type Converter.
- Default
View Locator Adds an AOT-friendly mapping configuration to DefaultViewLocator so callers can avoid reflection.
- Dependency
Object Observable For Property Creates a observable for a property if available that is based on a DependencyProperty.
- Dependency
Resolver Mixins Extension methods associated with the IMutableDependencyResolver interface.
- Double
ToString Type Converter Double To String Type Converter.
- Dummy
Suspension Driver 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.
- Equality
Type Converter The default converter, simply converts between types that are equal or can be converted (i.e. Button => UIControl).
- Exclude
From View Registration Attribute Apply this attribute to a view class to exclude it from automatic registration when calling RegisterViewsForViewModels/WithViewsFromAssembly.
- Expression
Mixins Extension methods associated with the Expression class.
- INPCObservable
For Property Generates Observables based on observing INotifyPropertyChanged objects.
- IROObservable
For Property Generates Observables based on observing Reactive objects.
- IReactive
Object Extensions Extension methods associated with the IReactiveObject interface.
- Integer
ToString Type Converter Integer To String Type Converter.
- Interaction
Binder Implementation Provides methods to bind Interaction<TInput, TOutput>s to handlers.
- Interaction
Binding Mixins This class provides extension methods for the ReactiveUI view binding mechanism.
- InteractionContext<TInput, TOutput>
Contains contextual information for an interaction.
- Interaction<TInput, TOutput>
Represents an interaction between collaborating application components.
- Long
ToString Type Converter Integer To String Type Converter.
- Message
Bus 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.
- Mutable
Dependency Resolver Extensions Public AOT-friendly generic registration helpers for IMutableDependencyResolver. These avoid reflection by relying on generic constraints and parameterless constructors.
- Nullable
Byte ToString Type Converter Short To String Type Converter.
- Nullable
Decimal ToString Type Converter Decimal To String Type Converter.
- Nullable
Double ToString Type Converter Double To String Type Converter.
- Nullable
Integer ToString Type Converter Integer To String Type Converter.
- Nullable
Long ToString Type Converter Integer To String Type Converter.
- Nullable
Short ToString Type Converter Short To String Type Converter.
- Nullable
Single ToString Type Converter Single To String Type Converter.
- OAPHCreation
Helper Mixin A collection of helpers to aid working with observable properties.
- ObservableAsPropertyHelper<T>
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 OAPHCreation
Helper extension methods.Mixin
- Observable
Func Mixins Observable Func Mixins.
- Observable
Logging Mixin Extension methods to assist with Logging.
- Observable
Mixins Extension methods associated with observables.
- ObservedChange<TSender, TValue>
A data-only version of IObservedChange.
- Observed
Changed Mixin A collection of helpers for IObservedChange<TSender, TValue>.
- Ordered
Comparer Convenience class providing a starting point for chaining comparers for anonymous types.
- OrderedComparer<T>
Convenience class providing a starting point for chaining comparers.
- POCOObservable
For Property 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.
- Platform
Operations Returns the current orientation of the device on Windows.
- Platform
Registration Manager Class that represents the platform registration for ReactiveUI.
- Platform
Registrations .NET Framework platform registrations.
- Property
Binder Implementation Provides methods to bind properties to observables.
- Property
Binding Mixins This class provides extension methods for the ReactiveUI view binding mechanism.
- Reactive
Command Encapsulates a user action behind a reactive interface.
- ReactiveCommandBase<TParam, TResult>
A base class for generic reactive commands.
- Reactive
Command Mixins Extension methods associated with the ReactiveCommand class.
- ReactiveCommand<TParam, TResult>
Encapsulates a user interaction behind a reactive interface.
- Reactive
Notify Property Changed Mixin Extension methods associated with the Observable Changes and the Reactive Notify Property Changed based events.
- Reactive
Object ReactiveObject is the base object for ViewModel classes, and it implements INotifyPropertyChanged. In addition, ReactiveObject provides Changing and Changed Observables to monitor object changes.
- ReactivePage<TViewModel>
A Page that is reactive.
- ReactivePropertyChangedEventArgs<TSender>
Event arguments for when a property has changed. Expands on the PropertyChangedEventArgs to add the Sender.
- ReactivePropertyChangingEventArgs<TSender>
Event arguments for when a property is changing.
- Reactive
Property Mixins Reactive Property Extensions.
- ReactiveProperty<T>
ReactiveProperty - a two way bindable declarative observable property with imperative get set.
- Reactive
Record ReactiveObject is the base object for ViewModel classes, and it implements INotifyPropertyChanged. In addition, ReactiveObject provides Changing and Changed Observables to monitor object changes.
- ReactiveUserControl<TViewModel>
A User
Control that is reactive.
- ReactiveWindow<TViewModel>
A Window that is reactive.
- Reflection
Helper class for handling Reflection amd Expression tree related items.
- Registrations
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.
- Routable
View Model Mixin Extension methods associated with the IRoutableViewModel interface.
- Routed
View Host This control hosts the View associated with a Router, and will display the View and wire up the ViewModel whenever a new ViewModel is navigated to. Put this control as the only control in your Window.
- Routing
State RoutingState manages the ViewModel Stack and allows ViewModels to navigate to other ViewModels.
- Routing
State Mixins Extension methods associated with the RoutingState class.
- Rx
App The main registration point for common class instances throughout a ReactiveUI application.
- Rx
Schedulers Provides access to ReactiveUI schedulers without requiring unreferenced code attributes. This is a lightweight alternative to RxApp for consuming scheduler properties.
- ScheduledSubject<T>
A subject which dispatches all its events on the specified Scheduler.
- Short
ToString Type Converter Short To String Type Converter.
- Single
Instance View Attribute 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.
- Single
ToString Type Converter Single To String Type Converter.
- String
Converter Calls ToString on types. In WPF, ComponentTypeConverter should win instead of this, since It's Better™.
- Suspension
Host Extensions Extension methods associated with the ISuspensionHost interface.
- Transitioning
Content Control A control with a single transition.
- Unhandled
Error Exception Indicates that an object implementing IHandle
Observable has caused an error and nothing is attached to ThrownErrors Exceptions to handle that error.
- UnhandledInteractionException<TInput, TOutput>
Indicates that an interaction has gone unhandled.
- Validation
Binding Mixins ValidationBindingMixins.
- View
Contract Attribute Allows an additional string to make view resolution more specific than just a type. When applied to your IViewFor<T> -derived View, you can select between different Views for a single ViewModel instance.
- View
For Mixins A set of extension methods to help wire up View and ViewModel activation.
- View
Locator Provides access to the IView
Locator registered in the global dependency resolver.
- View
Locator Not Found Exception An exception that is thrown if ReactiveUI fails to locate an IView
Locator implementation.
- View
Model Activator 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.
- View
Model View Host This content control will automatically load the View associated with the ViewModel property and display it. This control is very useful inside a DataTemplate to display the View associated with a ViewModel.
- Wait
For Dispatcher Scheduler 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.
- When
Any Mixin Extension methods associated with the WhenAny/WhenAnyValue classes.
- When
Any Observable Mixin A mixin which provides support for subscribing to observable properties.
Interfaces
- IActivatable
View Use this Interface when you want to mark a control as receiving View Activation when it doesn't have a backing ViewModel.
- IActivatable
View Model 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.
- IActivation
For View Fetcher 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.
- IBinding
Type Converter This interface is the extensible implementation of IValueConverters for Bind and OneWayBind. Implement this to teach Bind and OneWayBind how to convert between types.
- ICan
Activate 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.
- IComparerBuilder<T>
Convenience interface for providing a starting point for chaining comparers.
- ICreates
Command Binding 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.
- ICreates
Observable For Property 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.
- IHandle
Observable Errors 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.
- IInteraction
Binder Implementation Implementation logic for Interaction<TInput, TOutput> binding.
- IInteractionContext<TInput, TOutput>
Contains contextual information for an interaction.
- IInteraction<TInput, TOutput>
Represents an interaction between collaborating application components.
- IMessage
Bus 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.
- IObservedChange<TSender, TValue>
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.
- IOutputContext<TInput, TOutput>
Gives the ability to get the output.
- IPlatform
Operations Additional details implemented by the different ReactiveUI platform projects.
- IProperty
Binder Implementation This interface represents an object that is capable of providing binding implementations.
- IProperty
Binding Hook 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).
- IReactiveBinding<TView, TValue>
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).
- IReactive
Command 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.
- IReactiveCommand<TParam, TResult>
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.
- IReactiveNotifyPropertyChanged<TSender>
IReactiveNotifyPropertyChanged represents an extended version of INotifyPropertyChanged that also exposes typed Observables.
- IReactive
Object 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.
- IReactivePropertyChangedEventArgs<TSender>
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.
- IReactiveProperty<T>
Reactive Property.
- IRoutable
View Model Defines the minimum contract for view models that participate in Routing
State navigation.
- IScreen
Represents any object capable of hosting its own navigation stack via Routing
State .
- ISet
Method Binding Converter This converter will allow users to change the way the set functionality is performed in ReactiveUI property binding.
- ISuspension
Driver 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.
- ISuspension
Host 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.
- IView
For Provides a non-generic abstraction over views so infrastructure can interact with IViewFor<T> instances.
- IViewFor<T>
Implement this interface on views to participate in ReactiveUI routing, activation, and binding.
- IView
Locator Implement this to override how RoutedViewHost and ViewModelViewHost map view models to views.
- IWants
ToRegister Stuff 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.
Enums
- Binding
Direction The type of binding that the ReactiveBinding represents.
- Boolean
ToVisibility Hint Enum that hints at the visibility of a ui element.
- Registration
Namespace Platforms or other registration namespaces for the dependency resolver to consider when initializing.
- Transitioning
Content Control. Transition Direction Specifies the directional variant of a transition (where applicable).
- Transitioning
Content Control. Transition Type Specifies the animation behavior to use when the content changes.
- Trigger
Update Trigger Update.