UniRx

`AnimationCurveReactiveProperty`

Inspectable ReactiveProperty.

public class UniRx.AnimationCurveReactiveProperty
    : ReactiveProperty<AnimationCurve>, IReactiveProperty<AnimationCurve>, IReadOnlyReactiveProperty<AnimationCurve>, IObservable<AnimationCurve>, IDisposable, IOptimizedObservable<AnimationCurve>, IObserverLinkedList<AnimationCurve>

`AsyncMessageBroker`

In-Memory PubSub filtered by Type.

public class UniRx.AsyncMessageBroker
    : IAsyncMessageBroker, IAsyncMessagePublisher, IAsyncMessageReceiver, IDisposable

Methods

Type	Name	Summary
`void`	Dispose()
`IObservable<Unit>`	PublishAsync(`T` message)
`IDisposable`	Subscribe(`Func<T, IObservable<Unit>>` asyncMessageReceiver)

Static Fields

Type	Name	Summary
`IAsyncMessageBroker`	Default	AsyncMessageBroker in Global scope.

`AsyncOperationExtensions`

public static class UniRx.AsyncOperationExtensions

Static Methods

Type	Name	Summary
`IObservable<T>`	AsAsyncOperationObservable(this `T` asyncOperation, `IProgress<Single>` progress = null)
`IObservable<AsyncOperation>`	AsObservable(this `AsyncOperation` asyncOperation, `IProgress<Single>` progress = null)	If you needs return value, use AsAsyncOperationObservable instead.

`AsyncReactiveCommand`

Variation of ReactiveCommand, when executing command then CanExecute = false after CanExecute = true.

public class UniRx.AsyncReactiveCommand
    : AsyncReactiveCommand<Unit>, IAsyncReactiveCommand<Unit>

Methods

Type	Name	Summary
`IDisposable`	Execute()

`AsyncReactiveCommand<T>`

Variation of ReactiveCommand, canExecute is changed when executing command then CanExecute = false after CanExecute = true.

public class UniRx.AsyncReactiveCommand<T>
    : IAsyncReactiveCommand<T>

Properties

Type	Name	Summary
`IReadOnlyReactiveProperty<Boolean>`	CanExecute
`Boolean`	IsDisposed

Methods

Type	Name	Summary
`IDisposable`	Execute(`T` parameter)	Push parameter to subscribers when CanExecute.
`IDisposable`	Subscribe(`Func<T, IObservable<Unit>>` asyncAction)	Subscribe execute.
`UniTask<T>`	WaitUntilExecuteAsync()

`AsyncReactiveCommandExtensions`

public static class UniRx.AsyncReactiveCommandExtensions

Static Methods

Type	Name	Summary
`IDisposable`	BindTo(this `IAsyncReactiveCommand<Unit>` command, `Button` button)	Bind AsyncRaectiveCommand to button's interactable and onClick.
`IDisposable`	BindToOnClick(this `IAsyncReactiveCommand<Unit>` command, `Button` button, `Func<Unit, IObservable<Unit>>` asyncOnClick)	Bind AsyncRaectiveCommand to button's interactable and onClick and register async action to command.
`IDisposable`	BindToOnClick(this `Button` button, `Func<Unit, IObservable<Unit>>` asyncOnClick)	Bind AsyncRaectiveCommand to button's interactable and onClick and register async action to command.
`IDisposable`	BindToOnClick(this `Button` button, `IReactiveProperty<Boolean>` sharedCanExecuteSource, `Func<Unit, IObservable<Unit>>` asyncOnClick)	Bind AsyncRaectiveCommand to button's interactable and onClick and register async action to command.
`Awaiter<T>`	GetAwaiter(this `IAsyncReactiveCommand<T>` command)
`AsyncReactiveCommand`	ToAsyncReactiveCommand(this `IReactiveProperty<Boolean>` sharedCanExecuteSource)
`AsyncReactiveCommand<T>`	ToAsyncReactiveCommand(this `IReactiveProperty<Boolean>` sharedCanExecuteSource)

`AsyncSubject<T>`

public class UniRx.AsyncSubject<T>
    : ISubject<T>, ISubject<T, T>, IObserver<T>, IObservable<T>, IOptimizedObservable<T>, IDisposable, INotifyCompletion

Properties

Type	Name	Summary
`Boolean`	HasObservers
`Boolean`	IsCompleted
`T`	Value

Methods

Type	Name	Summary
`void`	Dispose()
`AsyncSubject<T>`	GetAwaiter()	Gets an awaitable object for the current AsyncSubject.
`T`	GetResult()	Gets the last element of the subject, potentially blocking until the subject completes successfully or exceptionally.
`Boolean`	IsRequiredSubscribeOnCurrentThread()
`void`	OnCompleted()	Specifies a callback action that will be invoked when the subject completes.
`void`	OnCompleted(`Action` continuation)	Specifies a callback action that will be invoked when the subject completes.
`void`	OnError(`Exception` error)
`void`	OnNext(`T` value)
`IDisposable`	Subscribe(`IObserver<T>` observer)

`BehaviorSubject<T>`

public class UniRx.BehaviorSubject<T>
    : ISubject<T>, ISubject<T, T>, IObserver<T>, IObservable<T>, IDisposable, IOptimizedObservable<T>

Properties

Type	Name	Summary
`Boolean`	HasObservers
`T`	Value

Methods

Type	Name	Summary
`void`	Dispose()
`Boolean`	IsRequiredSubscribeOnCurrentThread()
`void`	OnCompleted()
`void`	OnError(`Exception` error)
`void`	OnNext(`T` value)
`IDisposable`	Subscribe(`IObserver<T>` observer)

`BooleanDisposable`

public class UniRx.BooleanDisposable
    : IDisposable, ICancelable

Properties

Type	Name	Summary
`Boolean`	IsDisposed

Methods

Type	Name	Summary
`void`	Dispose()

`BooleanNotifier`

Notify boolean flag.

public class UniRx.BooleanNotifier
    : IObservable<Boolean>

Properties

Type	Name	Summary
`Boolean`	Value	Current flag value

Methods

Type	Name	Summary
`IDisposable`	Subscribe(`IObserver<Boolean>` observer)	Subscribe observer.
`void`	SwitchValue()	Set and raise reverse value.
`void`	TurnOff()	Set and raise false if current value isn't false.
`void`	TurnOn()	Set and raise true if current value isn't true.

`BoolReactiveProperty`

Inspectable ReactiveProperty.

public class UniRx.BoolReactiveProperty
    : ReactiveProperty<Boolean>, IReactiveProperty<Boolean>, IReadOnlyReactiveProperty<Boolean>, IObservable<Boolean>, IDisposable, IOptimizedObservable<Boolean>, IObserverLinkedList<Boolean>

`BoundsReactiveProperty`

Inspectable ReactiveProperty.

public class UniRx.BoundsReactiveProperty
    : ReactiveProperty<Bounds>, IReactiveProperty<Bounds>, IReadOnlyReactiveProperty<Bounds>, IObservable<Bounds>, IDisposable, IOptimizedObservable<Bounds>, IObserverLinkedList<Bounds>

Properties

Type	Name	Summary
`IEqualityComparer<Bounds>`	EqualityComparer

`ByteReactiveProperty`

Inspectable ReactiveProperty.

public class UniRx.ByteReactiveProperty
    : ReactiveProperty<Byte>, IReactiveProperty<Byte>, IReadOnlyReactiveProperty<Byte>, IObservable<Byte>, IDisposable, IOptimizedObservable<Byte>, IObserverLinkedList<Byte>

`CancellationDisposable`

Represents a disposable resource that has an associated that will be set to the cancellation requested state upon disposal.

public class UniRx.CancellationDisposable
    : ICancelable, IDisposable

Properties

Type	Name	Summary
`Boolean`	IsDisposed	Gets a value that indicates whether the object is disposed.
`CancellationToken`	Token	Gets the `System.Threading.CancellationToken` used by this CancellationDisposable.

Methods

Type	Name	Summary
`void`	Dispose()	Cancels the underlying .

`CollectionAddEvent<T>`

public struct UniRx.CollectionAddEvent<T>
    : IEquatable<CollectionAddEvent<T>>

Properties

Type	Name	Summary
`Int32`	Index
`T`	Value

Methods

Type	Name	Summary
`Boolean`	Equals(`CollectionAddEvent<T>` other)
`Int32`	GetHashCode()
`String`	ToString()

`CollectionMoveEvent<T>`

public struct UniRx.CollectionMoveEvent<T>
    : IEquatable<CollectionMoveEvent<T>>

Properties

Type	Name	Summary
`Int32`	NewIndex
`Int32`	OldIndex
`T`	Value

Methods

Type	Name	Summary
`Boolean`	Equals(`CollectionMoveEvent<T>` other)
`Int32`	GetHashCode()
`String`	ToString()

`CollectionRemoveEvent<T>`

public struct UniRx.CollectionRemoveEvent<T>
    : IEquatable<CollectionRemoveEvent<T>>

Properties

Type	Name	Summary
`Int32`	Index
`T`	Value

Methods

Type	Name	Summary
`Boolean`	Equals(`CollectionRemoveEvent<T>` other)
`Int32`	GetHashCode()
`String`	ToString()

`CollectionReplaceEvent<T>`

public struct UniRx.CollectionReplaceEvent<T>
    : IEquatable<CollectionReplaceEvent<T>>

Properties

Type	Name	Summary
`Int32`	Index
`T`	NewValue
`T`	OldValue

Methods

Type	Name	Summary
`Boolean`	Equals(`CollectionReplaceEvent<T>` other)
`Int32`	GetHashCode()
`String`	ToString()

`ColorReactiveProperty`

Inspectable ReactiveProperty.

public class UniRx.ColorReactiveProperty
    : ReactiveProperty<Color>, IReactiveProperty<Color>, IReadOnlyReactiveProperty<Color>, IObservable<Color>, IDisposable, IOptimizedObservable<Color>, IObserverLinkedList<Color>

Properties

Type	Name	Summary
`IEqualityComparer<Color>`	EqualityComparer

`CompositeDisposable`

public class UniRx.CompositeDisposable
    : ICollection<IDisposable>, IEnumerable<IDisposable>, IEnumerable, IDisposable, ICancelable

Properties

Type	Name	Summary
`Int32`	Count	Gets the number of disposables contained in the CompositeDisposable.
`Boolean`	IsDisposed	Gets a value that indicates whether the object is disposed.
`Boolean`	IsReadOnly	Always returns false.

Methods

Type	Name	Summary
`void`	Add(`IDisposable` item)	Adds a disposable to the CompositeDisposable or disposes the disposable if the CompositeDisposable is disposed.
`void`	Clear()	Removes and disposes all disposables from the CompositeDisposable, but does not dispose the CompositeDisposable.
`Boolean`	Contains(`IDisposable` item)	Determines whether the CompositeDisposable contains a specific disposable.
`void`	CopyTo(`IDisposable[]` array, `Int32` arrayIndex)	Copies the disposables contained in the CompositeDisposable to an array, starting at a particular array index.
`void`	Dispose()	Disposes all disposables in the group and removes them from the group.
`IEnumerator<IDisposable>`	GetEnumerator()	Returns an enumerator that iterates through the CompositeDisposable.
`Boolean`	Remove(`IDisposable` item)	Removes and disposes the first occurrence of a disposable from the CompositeDisposable.

`CoroutineAsyncBridge`

public class UniRx.CoroutineAsyncBridge
    : INotifyCompletion

Properties

Type	Name	Summary
`Boolean`	IsCompleted

Methods

Type	Name	Summary
`void`	GetResult()
`void`	OnCompleted(`Action` continuation)

Static Methods

Type	Name	Summary
`CoroutineAsyncBridge`	Start(`T` awaitTarget)

`CoroutineAsyncBridge<T>`

public class UniRx.CoroutineAsyncBridge<T>
    : INotifyCompletion

Properties

Type	Name	Summary
`Boolean`	IsCompleted

Methods

Type	Name	Summary
`T`	GetResult()
`void`	OnCompleted(`Action` continuation)

Static Methods

Type	Name	Summary
`CoroutineAsyncBridge<T>`	Start(`T` awaitTarget)

`CoroutineAsyncExtensions`

public static class UniRx.CoroutineAsyncExtensions

Static Methods

Type	Name	Summary
`CoroutineAsyncBridge`	GetAwaiter(this `Coroutine` coroutine)

`CountChangedStatus`

Event kind of CountNotifier.

public enum UniRx.CountChangedStatus
    : Enum, IComparable, IFormattable, IConvertible

Enum

Value	Name	Summary
`0`	Increment	Count incremented.
`1`	Decrement	Count decremented.
`2`	Empty	Count is zero.
`3`	Max	Count arrived max.

`CountNotifier`

Notify event of count flag.

public class UniRx.CountNotifier
    : IObservable<CountChangedStatus>

Properties

Type	Name	Summary
`Int32`	Count
`Int32`	Max

Methods

Type	Name	Summary
`void`	Decrement(`Int32` decrementCount = 1)	Decrement count and notify status.
`IDisposable`	Increment(`Int32` incrementCount = 1)	Increment count and notify status.
`IDisposable`	Subscribe(`IObserver<CountChangedStatus>` observer)	Subscribe observer.

`DictionaryAddEvent<TKey, TValue>`

public struct UniRx.DictionaryAddEvent<TKey, TValue>
    : IEquatable<DictionaryAddEvent<TKey, TValue>>

Properties

Type	Name	Summary
`TKey`	Key
`TValue`	Value

Methods

Type	Name	Summary
`Boolean`	Equals(`DictionaryAddEvent<TKey, TValue>` other)
`Int32`	GetHashCode()
`String`	ToString()

`DictionaryDisposable<TKey, TValue>`

public class UniRx.DictionaryDisposable<TKey, TValue>
    : IDisposable, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable

Properties

Type	Name	Summary
`Int32`	Count
`TValue`	Item
`KeyCollection<TKey, TValue>`	Keys
`ValueCollection<TKey, TValue>`	Values

Methods

Type	Name	Summary
`void`	Add(`TKey` key, `TValue` value)
`void`	Clear()
`Boolean`	ContainsKey(`TKey` key)
`void`	Dispose()
`Enumerator<TKey, TValue>`	GetEnumerator()
`void`	GetObjectData(`SerializationInfo` info, `StreamingContext` context)
`void`	OnDeserialization(`Object` sender)
`Boolean`	Remove(`TKey` key)
`Boolean`	TryGetValue(`TKey` key, `TValue&` value)

`DictionaryRemoveEvent<TKey, TValue>`

public struct UniRx.DictionaryRemoveEvent<TKey, TValue>
    : IEquatable<DictionaryRemoveEvent<TKey, TValue>>

Properties

Type	Name	Summary
`TKey`	Key
`TValue`	Value

Methods

Type	Name	Summary
`Boolean`	Equals(`DictionaryRemoveEvent<TKey, TValue>` other)
`Int32`	GetHashCode()
`String`	ToString()

`DictionaryReplaceEvent<TKey, TValue>`

public struct UniRx.DictionaryReplaceEvent<TKey, TValue>
    : IEquatable<DictionaryReplaceEvent<TKey, TValue>>

Properties

Type	Name	Summary
`TKey`	Key
`TValue`	NewValue
`TValue`	OldValue

Methods

Type	Name	Summary
`Boolean`	Equals(`DictionaryReplaceEvent<TKey, TValue>` other)
`Int32`	GetHashCode()
`String`	ToString()

`Disposable`

public static class UniRx.Disposable

Static Fields

Type	Name	Summary
`IDisposable`	Empty

Static Methods

Type	Name	Summary
`IDisposable`	Create(`Action` disposeAction)
`IDisposable`	CreateWithState(`TState` state, `Action<TState>` disposeAction)

`DisposableExtensions`

public static class UniRx.DisposableExtensions

Static Methods

Type	Name	Summary
`T`	AddTo(this `T` disposable, `ICollection<IDisposable>` container)	Add disposable(self) to CompositeDisposable(or other ICollection). Return value is self disposable.
`T`	AddTo(this `T` disposable, `GameObject` gameObject)	Add disposable(self) to CompositeDisposable(or other ICollection). Return value is self disposable.
`T`	AddTo(this `T` disposable, `Component` gameObjectComponent)	Add disposable(self) to CompositeDisposable(or other ICollection). Return value is self disposable.
`T`	AddTo(this `T` disposable, `ICollection<IDisposable>` container, `GameObject` gameObject)	Add disposable(self) to CompositeDisposable(or other ICollection). Return value is self disposable.
`T`	AddTo(this `T` disposable, `ICollection<IDisposable>` container, `Component` gameObjectComponent)	Add disposable(self) to CompositeDisposable(or other ICollection). Return value is self disposable.

`DoubleReactiveProperty`

Inspectable ReactiveProperty.

public class UniRx.DoubleReactiveProperty
    : ReactiveProperty<Double>, IReactiveProperty<Double>, IReadOnlyReactiveProperty<Double>, IObservable<Double>, IDisposable, IOptimizedObservable<Double>, IObserverLinkedList<Double>

`EventPattern<TEventArgs>`

Represents a .NET event invocation consisting of the weakly typed object that raised the event and the data that was generated by the event.

public class UniRx.EventPattern<TEventArgs>
    : EventPattern<Object, TEventArgs>, IEquatable<EventPattern<Object, TEventArgs>>, IEventPattern<Object, TEventArgs>

`EventPattern<TSender, TEventArgs>`

Represents a .NET event invocation consisting of the strongly typed object that raised the event and the data that was generated by the event.

public class UniRx.EventPattern<TSender, TEventArgs>
    : IEquatable<EventPattern<TSender, TEventArgs>>, IEventPattern<TSender, TEventArgs>

Properties

Type	Name	Summary
`TEventArgs`	EventArgs	Gets the event data that was generated by the event.
`TSender`	Sender	Gets the sender object that raised the event.

Methods

Type	Name	Summary
`Boolean`	Equals(`EventPattern<TSender, TEventArgs>` other)	Determines whether the current EventPattern<TSender, TEventArgs> object represents the same event as a specified EventPattern<TSender, TEventArgs> object.
`Boolean`	Equals(`Object` obj)	Determines whether the current EventPattern<TSender, TEventArgs> object represents the same event as a specified EventPattern<TSender, TEventArgs> object.
`Int32`	GetHashCode()	Returns the hash code for the current EventPattern<TSender, TEventArgs> instance.

`FloatReactiveProperty`

Inspectable ReactiveProperty.

public class UniRx.FloatReactiveProperty
    : ReactiveProperty<Single>, IReactiveProperty<Single>, IReadOnlyReactiveProperty<Single>, IObservable<Single>, IDisposable, IOptimizedObservable<Single>, IObserverLinkedList<Single>

`FrameCountType`

public enum UniRx.FrameCountType
    : Enum, IComparable, IFormattable, IConvertible

Enum

Value	Name	Summary
`0`	Update
`1`	FixedUpdate
`2`	EndOfFrame

`FrameCountTypeExtensions`

public static class UniRx.FrameCountTypeExtensions

Static Methods

Type	Name	Summary
`YieldInstruction`	GetYieldInstruction(this `FrameCountType` frameCountType)

`FrameInterval<T>`

Represents a value associated with time interval information. The time interval can represent the time it took to produce the value, the interval relative to a previous value, the value's delivery time relative to a base, etc.

public struct UniRx.FrameInterval<T>
    : IEquatable<FrameInterval<T>>

Properties

Type	Name	Summary
`Int32`	Interval	Gets the interval.
`T`	Value	Gets the value.

Methods

Type	Name	Summary
`Boolean`	Equals(`FrameInterval<T>` other)	Determines whether the current FrameInterval<T> value has the same Value and Interval as a specified FrameInterval<T> value.
`Boolean`	Equals(`Object` obj)	Determines whether the current FrameInterval<T> value has the same Value and Interval as a specified FrameInterval<T> value.
`Int32`	GetHashCode()	Returns the hash code for the current FrameInterval<T> value.
`String`	ToString()	Returns a string representation of the current FrameInterval<T> value.

`IAsyncMessageBroker`

public interface UniRx.IAsyncMessageBroker
    : IAsyncMessagePublisher, IAsyncMessageReceiver

`IAsyncMessagePublisher`

public interface UniRx.IAsyncMessagePublisher

Methods

Type	Name	Summary
`IObservable<Unit>`	PublishAsync(`T` message)	Send Message to all receiver and await complete.

`IAsyncMessageReceiver`

public interface UniRx.IAsyncMessageReceiver

Methods

Type	Name	Summary
`IDisposable`	Subscribe(`Func<T, IObservable<Unit>>` asyncMessageReceiver)	Subscribe typed message.

`IAsyncReactiveCommand<T>`

public interface UniRx.IAsyncReactiveCommand<T>

Properties

Type	Name	Summary
`IReadOnlyReactiveProperty<Boolean>`	CanExecute

Methods

Type	Name	Summary
`IDisposable`	Execute(`T` parameter)
`IDisposable`	Subscribe(`Func<T, IObservable<Unit>>` asyncAction)
`UniTask<T>`	WaitUntilExecuteAsync()

`ICancelable`

public interface UniRx.ICancelable
    : IDisposable

Properties

Type	Name	Summary
`Boolean`	IsDisposed

`IConnectableObservable<T>`

public interface UniRx.IConnectableObservable<T>
    : IObservable<T>

Methods

Type	Name	Summary
`IDisposable`	Connect()

`IEventPattern<TSender, TEventArgs>`

Represents a .NET event invocation consisting of the strongly typed object that raised the event and the data that was generated by the event.

public interface UniRx.IEventPattern<TSender, TEventArgs>

Properties

Type	Name	Summary
`TEventArgs`	EventArgs	Gets the event data that was generated by the event.
`TSender`	Sender	Gets the sender object that raised the event.

`IGroupedObservable<TKey, TElement>`

public interface UniRx.IGroupedObservable<TKey, TElement>
    : IObservable<TElement>

Properties

Type	Name	Summary
`TKey`	Key

`IMessageBroker`

public interface UniRx.IMessageBroker
    : IMessagePublisher, IMessageReceiver

`IMessagePublisher`

public interface UniRx.IMessagePublisher

Methods

Type	Name	Summary
`void`	Publish(`T` message)	Send Message to all receiver.

`IMessageReceiver`

public interface UniRx.IMessageReceiver

Methods

Type	Name	Summary
`IObservable<T>`	Receive()	Subscribe typed message.

`InspectorDisplayAttribute`

public class UniRx.InspectorDisplayAttribute
    : PropertyAttribute, _Attribute

Properties

Type	Name	Summary
`String`	FieldName
`Boolean`	NotifyPropertyChanged

`InspectorDisplayDrawer`

public class UniRx.InspectorDisplayDrawer
    : PropertyDrawer

Methods

Type	Name	Summary
`void`	EmitPropertyField(`Rect` position, `SerializedProperty` targetSerializedProperty, `GUIContent` label)
`Single`	GetPropertyHeight(`SerializedProperty` property, `GUIContent` label)
`void`	OnGUI(`Rect` position, `SerializedProperty` property, `GUIContent` label)

`IntReactiveProperty`

Inspectable ReactiveProperty.

public class UniRx.IntReactiveProperty
    : ReactiveProperty<Int32>, IReactiveProperty<Int32>, IReadOnlyReactiveProperty<Int32>, IObservable<Int32>, IDisposable, IOptimizedObservable<Int32>, IObserverLinkedList<Int32>

`IObserver<TValue, TResult>`

Provides a mechanism for receiving push-based notifications and returning a response.

public interface UniRx.IObserver<TValue, TResult>

Methods

Type	Name	Summary
`TResult`	OnCompleted()	Notifies the observer of the end of the sequence.
`TResult`	OnError(`Exception` exception)	Notifies the observer that an exception has occurred.
`TResult`	OnNext(`TValue` value)	Notifies the observer of a new element in the sequence.

`IOptimizedObservable<T>`

public interface UniRx.IOptimizedObservable<T>
    : IObservable<T>

Methods

Type	Name	Summary
`Boolean`	IsRequiredSubscribeOnCurrentThread()

`IReactiveCollection<T>`

public interface UniRx.IReactiveCollection<T>
    : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IReadOnlyReactiveCollection<T>

Properties

Type	Name	Summary
`Int32`	Count
`T`	Item

Methods

Type	Name	Summary
`void`	Move(`Int32` oldIndex, `Int32` newIndex)

`IReactiveCommand<T>`

public interface UniRx.IReactiveCommand<T>
    : IObservable<T>

Properties

Type	Name	Summary
`IReadOnlyReactiveProperty<Boolean>`	CanExecute

Methods

Type	Name	Summary
`Boolean`	Execute(`T` parameter)
`UniTask<T>`	WaitUntilExecuteAsync()

`IReactiveDictionary<TKey, TValue>`

public interface UniRx.IReactiveDictionary<TKey, TValue>
    : IReadOnlyReactiveDictionary<TKey, TValue>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>

`IReactiveProperty<T>`

public interface UniRx.IReactiveProperty<T>
    : IReadOnlyReactiveProperty<T>, IObservable<T>

Properties

Type	Name	Summary
`T`	Value

`IReadOnlyReactiveCollection<T>`

public interface UniRx.IReadOnlyReactiveCollection<T>
    : IEnumerable<T>, IEnumerable

Properties

Type	Name	Summary
`Int32`	Count
`T`	Item

Methods

Type	Name	Summary
`IObservable<CollectionAddEvent<T>>`	ObserveAdd()
`IObservable<Int32>`	ObserveCountChanged(`Boolean` notifyCurrentCount = False)
`IObservable<CollectionMoveEvent<T>>`	ObserveMove()
`IObservable<CollectionRemoveEvent<T>>`	ObserveRemove()
`IObservable<CollectionReplaceEvent<T>>`	ObserveReplace()
`IObservable<Unit>`	ObserveReset()

`IReadOnlyReactiveDictionary<TKey, TValue>`

public interface UniRx.IReadOnlyReactiveDictionary<TKey, TValue>
    : IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable

Properties

Type	Name	Summary
`Int32`	Count
`TValue`	Item

Methods

Type	Name	Summary
`Boolean`	ContainsKey(`TKey` key)
`IObservable<DictionaryAddEvent<TKey, TValue>>`	ObserveAdd()
`IObservable<Int32>`	ObserveCountChanged(`Boolean` notifyCurrentCount = False)
`IObservable<DictionaryRemoveEvent<TKey, TValue>>`	ObserveRemove()
`IObservable<DictionaryReplaceEvent<TKey, TValue>>`	ObserveReplace()
`IObservable<Unit>`	ObserveReset()
`Boolean`	TryGetValue(`TKey` key, `TValue&` value)

`IReadOnlyReactiveProperty<T>`

public interface UniRx.IReadOnlyReactiveProperty<T>
    : IObservable<T>

Properties

Type	Name	Summary
`Boolean`	HasValue
`T`	Value

Methods

Type	Name	Summary
`UniTask<T>`	WaitUntilValueChangedAsync()

`IScheduler`

public interface UniRx.IScheduler

Properties

Type	Name	Summary
`DateTimeOffset`	Now

Methods

Type	Name	Summary
`IDisposable`	Schedule(`Action` action)
`IDisposable`	Schedule(`TimeSpan` dueTime, `Action` action)

`ISchedulerLongRunning`

public interface UniRx.ISchedulerLongRunning

Methods

Type	Name	Summary
`IDisposable`	ScheduleLongRunning(`Action<ICancelable>` action)

`ISchedulerPeriodic`

public interface UniRx.ISchedulerPeriodic

Methods

Type	Name	Summary
`IDisposable`	SchedulePeriodic(`TimeSpan` period, `Action` action)

`ISchedulerQueueing`

public interface UniRx.ISchedulerQueueing

Methods

Type	Name	Summary
`void`	ScheduleQueueing(`ICancelable` cancel, `T` state, `Action<T>` action)

`ISubject<T>`

public interface UniRx.ISubject<T>
    : ISubject<T, T>, IObserver<T>, IObservable<T>

`ISubject<TSource, TResult>`

public interface UniRx.ISubject<TSource, TResult>
    : IObserver<TSource>, IObservable<TResult>

`LongReactiveProperty`

Inspectable ReactiveProperty.

public class UniRx.LongReactiveProperty
    : ReactiveProperty<Int64>, IReactiveProperty<Int64>, IReadOnlyReactiveProperty<Int64>, IObservable<Int64>, IDisposable, IOptimizedObservable<Int64>, IObserverLinkedList<Int64>

`MainThreadDispatcher`

public class UniRx.MainThreadDispatcher
    : MonoBehaviour

Static Fields

Type	Name	Summary
`CullingMode`	cullingMode

Static Properties

Type	Name	Summary
`String`	InstanceName
`Boolean`	IsInitialized
`Boolean`	IsInMainThread

Static Methods

Type	Name	Summary
`void`	CullAllExcessDispatchers()
`void`	Initialize()
`IObservable<Unit>`	LateUpdateAsObservable()
`IObservable<Boolean>`	OnApplicationFocusAsObservable()
`IObservable<Boolean>`	OnApplicationPauseAsObservable()
`IObservable<Unit>`	OnApplicationQuitAsObservable()
`void`	Post(`Action<Object>` action, `Object` state)	Dispatch Asyncrhonous action.
`void`	RegisterUnhandledExceptionCallback(`Action<Exception>` exceptionCallback)
`void`	Send(`Action<Object>` action, `Object` state)	Dispatch Synchronous action if possible.
`void`	SendStartCoroutine(`IEnumerator` routine)	ThreadSafe StartCoroutine.
`Coroutine`	StartCoroutine(`IEnumerator` routine)
`void`	StartEndOfFrameMicroCoroutine(`IEnumerator` routine)
`void`	StartFixedUpdateMicroCoroutine(`IEnumerator` routine)
`void`	StartUpdateMicroCoroutine(`IEnumerator` routine)
`void`	UnsafeSend(`Action` action)	Run Synchronous action.
`void`	UnsafeSend(`Action<T>` action, `T` state)	Run Synchronous action.
`IObservable<Unit>`	UpdateAsObservable()

`MainThreadDispatchType`

public enum UniRx.MainThreadDispatchType
    : Enum, IComparable, IFormattable, IConvertible

Enum

Value	Name	Summary
`0`	Update	yield return null
`1`	FixedUpdate
`2`	EndOfFrame
`3`	GameObjectUpdate
`4`	LateUpdate

`MessageBroker`

In-Memory PubSub filtered by Type.

public class UniRx.MessageBroker
    : IMessageBroker, IMessagePublisher, IMessageReceiver, IDisposable

Methods

Type	Name	Summary
`void`	Dispose()
`void`	Publish(`T` message)
`IObservable<T>`	Receive()

Static Fields

Type	Name	Summary
`IMessageBroker`	Default	MessageBroker in Global scope.

`MultilineReactivePropertyAttribute`

Enables multiline input field for StringReactiveProperty. Default line is 3.

public class UniRx.MultilineReactivePropertyAttribute
    : PropertyAttribute, _Attribute

Properties

Type	Name	Summary
`Int32`	Lines

`MultipleAssignmentDisposable`

public class UniRx.MultipleAssignmentDisposable
    : IDisposable, ICancelable

Properties

Type	Name	Summary
`IDisposable`	Disposable
`Boolean`	IsDisposed

Methods

Type	Name	Summary
`void`	Dispose()

`Notification`

Provides a set of static methods for constructing notifications.

public static class UniRx.Notification

Static Methods

Type	Name	Summary
`Notification<T>`	CreateOnCompleted()	Creates an object that represents an OnCompleted notification to an observer.
`Notification<T>`	CreateOnError(`Exception` error)	Creates an object that represents an OnError notification to an observer.
`Notification<T>`	CreateOnNext(`T` value)	Creates an object that represents an OnNext notification to an observer.

`Notification<T>`

Represents a notification to an observer.

public abstract class UniRx.Notification<T>
    : IEquatable<Notification<T>>

Properties

Type	Name	Summary
`Exception`	Exception	Returns the exception of an OnError notification or returns null.
`Boolean`	HasValue	Returns a value that indicates whether the notification has a value.
`NotificationKind`	Kind	Gets the kind of notification that is represented.
`T`	Value	Returns the value of an OnNext notification or throws an exception.

Methods

Type	Name	Summary
`void`	Accept(`IObserver<T>` observer)	Invokes the observer's method corresponding to the notification.
`TResult`	Accept(`IObserver<T, TResult>` observer)	Invokes the observer's method corresponding to the notification.
`void`	Accept(`Action<T>` onNext, `Action<Exception>` onError, `Action` onCompleted)	Invokes the observer's method corresponding to the notification.
`TResult`	Accept(`Func<T, TResult>` onNext, `Func<Exception, TResult>` onError, `Func<TResult>` onCompleted)	Invokes the observer's method corresponding to the notification.
`Boolean`	Equals(`Notification<T>` other)	Determines whether the current Notification<T> object has the same observer message payload as a specified Notification<T> value.
`Boolean`	Equals(`Object` obj)	Determines whether the current Notification<T> object has the same observer message payload as a specified Notification<T> value.
`IObservable<T>`	ToObservable()	Returns an observable sequence with a single notification, using the immediate scheduler.
`IObservable<T>`	ToObservable(`IScheduler` scheduler)	Returns an observable sequence with a single notification, using the immediate scheduler.

`NotificationKind`

Indicates the type of a notification.

public enum UniRx.NotificationKind
    : Enum, IComparable, IFormattable, IConvertible

Enum

Value	Name	Summary
`0`	OnNext	Represents an OnNext notification.
`1`	OnError	Represents an OnError notification.
`2`	OnCompleted	Represents an OnCompleted notification.

`Observable`

public static class UniRx.Observable

Static Methods

Type	Name	Summary
`IObservable<TSource>`	Aggregate(this `IObservable<TSource>` source, `Func<TSource, TSource, TSource>` accumulator)
`IObservable<TAccumulate>`	Aggregate(this `IObservable<TSource>` source, `TAccumulate` seed, `Func<TAccumulate, TSource, TAccumulate>` accumulator)
`IObservable<TResult>`	Aggregate(this `IObservable<TSource>` source, `TAccumulate` seed, `Func<TAccumulate, TSource, TAccumulate>` accumulator, `Func<TAccumulate, TResult>` resultSelector)
`IObservable<T>`	Amb(`IObservable`1[]` sources)
`IObservable<T>`	Amb(`IEnumerable<IObservable<T>>` sources)
`IObservable<T>`	Amb(this `IObservable<T>` source, `IObservable<T>` second)
`IObservable<T>`	AsObservable(this `IObservable<T>` source)
`IObservable<Unit>`	AsSingleUnitObservable(this `IObservable<T>` source)	Same as LastOrDefault().AsUnitObservable().
`IObservable<Unit>`	AsUnitObservable(this `IObservable<T>` source)	Converting .Select(_ => Unit.Default) sequence.
`IObservable<IList<T>>`	BatchFrame(this `IObservable<T>` source)	Buffer elements in during target frame counts. Default raise same frame of end(frameCount = 0, frameCountType = EndOfFrame).
`IObservable<IList<T>>`	BatchFrame(this `IObservable<T>` source, `Int32` frameCount, `FrameCountType` frameCountType)	Buffer elements in during target frame counts. Default raise same frame of end(frameCount = 0, frameCountType = EndOfFrame).
`IObservable<Unit>`	BatchFrame(this `IObservable<Unit>` source)	Buffer elements in during target frame counts. Default raise same frame of end(frameCount = 0, frameCountType = EndOfFrame).
`IObservable<Unit>`	BatchFrame(this `IObservable<Unit>` source, `Int32` frameCount, `FrameCountType` frameCountType)	Buffer elements in during target frame counts. Default raise same frame of end(frameCount = 0, frameCountType = EndOfFrame).
`IObservable<IList<T>>`	Buffer(this `IObservable<T>` source, `Int32` count)
`IObservable<IList<T>>`	Buffer(this `IObservable<T>` source, `Int32` count, `Int32` skip)
`IObservable<IList<T>>`	Buffer(this `IObservable<T>` source, `TimeSpan` timeSpan)
`IObservable<IList<T>>`	Buffer(this `IObservable<T>` source, `TimeSpan` timeSpan, `IScheduler` scheduler)
`IObservable<IList<T>>`	Buffer(this `IObservable<T>` source, `TimeSpan` timeSpan, `Int32` count)
`IObservable<IList<T>>`	Buffer(this `IObservable<T>` source, `TimeSpan` timeSpan, `Int32` count, `IScheduler` scheduler)
`IObservable<IList<T>>`	Buffer(this `IObservable<T>` source, `TimeSpan` timeSpan, `TimeSpan` timeShift)
`IObservable<IList<T>>`	Buffer(this `IObservable<T>` source, `TimeSpan` timeSpan, `TimeSpan` timeShift, `IScheduler` scheduler)
`IObservable<IList<TSource>>`	Buffer(this `IObservable<TSource>` source, `IObservable<TWindowBoundary>` windowBoundaries)
`IObservable<TResult>`	Cast(this `IObservable<TSource>` source)	witness is for type inference.
`IObservable<TResult>`	Cast(this `IObservable<TSource>` source, `TResult` witness)	witness is for type inference.
`IObservable<T>`	Catch(this `IObservable<T>` source, `Func<TException, IObservable<T>>` errorHandler)
`IObservable<TSource>`	Catch(this `IEnumerable<IObservable<TSource>>` sources)
`IObservable<TSource>`	CatchIgnore(this `IObservable<TSource>` source)	Catch exception and return Observable.Empty.
`IObservable<TSource>`	CatchIgnore(this `IObservable<TSource>` source, `Action<TException>` errorAction)	Catch exception and return Observable.Empty.
`IObservable<TResult>`	CombineLatest(this `IObservable<TLeft>` left, `IObservable<TRight>` right, `Func<TLeft, TRight, TResult>` selector)
`IObservable<IList<T>>`	CombineLatest(this `IEnumerable<IObservable<T>>` sources)
`IObservable<IList<TSource>>`	CombineLatest(`IObservable`1[]` sources)
`IObservable<TR>`	CombineLatest(this `IObservable<T1>` source1, `IObservable<T2>` source2, `IObservable<T3>` source3, `CombineLatestFunc<T1, T2, T3, TR>` resultSelector)
`IObservable<TR>`	CombineLatest(this `IObservable<T1>` source1, `IObservable<T2>` source2, `IObservable<T3>` source3, `IObservable<T4>` source4, `CombineLatestFunc<T1, T2, T3, T4, TR>` resultSelector)
`IObservable<TR>`	CombineLatest(this `IObservable<T1>` source1, `IObservable<T2>` source2, `IObservable<T3>` source3, `IObservable<T4>` source4, `IObservable<T5>` source5, `CombineLatestFunc<T1, T2, T3, T4, T5, TR>` resultSelector)
`IObservable<TR>`	CombineLatest(this `IObservable<T1>` source1, `IObservable<T2>` source2, `IObservable<T3>` source3, `IObservable<T4>` source4, `IObservable<T5>` source5, `IObservable<T6>` source6, `CombineLatestFunc<T1, T2, T3, T4, T5, T6, TR>` resultSelector)
`IObservable<TR>`	CombineLatest(this `IObservable<T1>` source1, `IObservable<T2>` source2, `IObservable<T3>` source3, `IObservable<T4>` source4, `IObservable<T5>` source5, `IObservable<T6>` source6, `IObservable<T7>` source7, `CombineLatestFunc<T1, T2, T3, T4, T5, T6, T7, TR>` resultSelector)
`IObservable<TSource>`	Concat(`IObservable`1[]` sources)
`IObservable<TSource>`	Concat(this `IEnumerable<IObservable<TSource>>` sources)
`IObservable<TSource>`	Concat(this `IObservable<IObservable<TSource>>` sources)
`IObservable<TSource>`	Concat(this `IObservable<TSource>` first, `IObservable`1[]` seconds)
`IObservable<TR>`	ContinueWith(this `IObservable<T>` source, `IObservable<TR>` other)	Lightweight SelectMany for Single Async Operation.
`IObservable<TR>`	ContinueWith(this `IObservable<T>` source, `Func<T, IObservable<TR>>` selector)	Lightweight SelectMany for Single Async Operation.
`IObservable<T>`	Create(`Func<IObserver<T>, IDisposable>` subscribe)	Create anonymous observable. Observer has exception durability. This is recommended for make operator and event like generator.
`IObservable<T>`	Create(`Func<IObserver<T>, IDisposable>` subscribe, `Boolean` isRequiredSubscribeOnCurrentThread)	Create anonymous observable. Observer has exception durability. This is recommended for make operator and event like generator.
`IObservable<T>`	CreateSafe(`Func<IObserver<T>, IDisposable>` subscribe)	Create anonymous observable. Safe means auto detach when error raised in onNext pipeline. This is recommended for make generator (ColdObservable).
`IObservable<T>`	CreateSafe(`Func<IObserver<T>, IDisposable>` subscribe, `Boolean` isRequiredSubscribeOnCurrentThread)	Create anonymous observable. Safe means auto detach when error raised in onNext pipeline. This is recommended for make generator (ColdObservable).
`IObservable<T>`	CreateWithState(`TState` state, `Func<TState, IObserver<T>, IDisposable>` subscribe)	Create anonymous observable. Observer has exception durability. This is recommended for make operator and event like generator.
`IObservable<T>`	CreateWithState(`TState` state, `Func<TState, IObserver<T>, IDisposable>` subscribe, `Boolean` isRequiredSubscribeOnCurrentThread)	Create anonymous observable. Observer has exception durability. This is recommended for make operator and event like generator.
`IObservable<T>`	DefaultIfEmpty(this `IObservable<T>` source)
`IObservable<T>`	DefaultIfEmpty(this `IObservable<T>` source, `T` defaultValue)
`IObservable<T>`	Defer(`Func<IObservable<T>>` observableFactory)
`IObservable<T>`	Delay(this `IObservable<T>` source, `TimeSpan` dueTime)
`IObservable<TSource>`	Delay(this `IObservable<TSource>` source, `TimeSpan` dueTime, `IScheduler` scheduler)
`IObservable<T>`	DelayFrame(this `IObservable<T>` source, `Int32` frameCount, `FrameCountType` frameCountType = Update)
`IObservable<T>`	DelayFrameSubscription(this `IObservable<T>` source, `Int32` frameCount, `FrameCountType` frameCountType = Update)
`IObservable<T>`	DelaySubscription(this `IObservable<T>` source, `TimeSpan` dueTime)
`IObservable<T>`	DelaySubscription(this `IObservable<T>` source, `TimeSpan` dueTime, `IScheduler` scheduler)
`IObservable<T>`	DelaySubscription(this `IObservable<T>` source, `DateTimeOffset` dueTime)
`IObservable<T>`	DelaySubscription(this `IObservable<T>` source, `DateTimeOffset` dueTime, `IScheduler` scheduler)
`IObservable<T>`	Dematerialize(this `IObservable<Notification<T>>` source)
`IObservable<TSource>`	Distinct(this `IObservable<TSource>` source)
`IObservable<TSource>`	Distinct(this `IObservable<TSource>` source, `IEqualityComparer<TSource>` comparer)
`IObservable<TSource>`	Distinct(this `IObservable<TSource>` source, `Func<TSource, TKey>` keySelector)
`IObservable<TSource>`	Distinct(this `IObservable<TSource>` source, `Func<TSource, TKey>` keySelector, `IEqualityComparer<TKey>` comparer)
`IObservable<T>`	DistinctUntilChanged(this `IObservable<T>` source)
`IObservable<T>`	DistinctUntilChanged(this `IObservable<T>` source, `IEqualityComparer<T>` comparer)
`IObservable<T>`	DistinctUntilChanged(this `IObservable<T>` source, `Func<T, TKey>` keySelector)
`IObservable<T>`	DistinctUntilChanged(this `IObservable<T>` source, `Func<T, TKey>` keySelector, `IEqualityComparer<TKey>` comparer)
`IObservable<T>`	Do(this `IObservable<T>` source, `IObserver<T>` observer)
`IObservable<T>`	Do(this `IObservable<T>` source, `Action<T>` onNext)
`IObservable<T>`	Do(this `IObservable<T>` source, `Action<T>` onNext, `Action<Exception>` onError)
`IObservable<T>`	Do(this `IObservable<T>` source, `Action<T>` onNext, `Action` onCompleted)
`IObservable<T>`	Do(this `IObservable<T>` source, `Action<T>` onNext, `Action<Exception>` onError, `Action` onCompleted)
`IObservable<T>`	DoOnCancel(this `IObservable<T>` source, `Action` onCancel)
`IObservable<T>`	DoOnCompleted(this `IObservable<T>` source, `Action` onCompleted)
`IObservable<T>`	DoOnError(this `IObservable<T>` source, `Action<Exception>` onError)
`IObservable<T>`	DoOnSubscribe(this `IObservable<T>` source, `Action` onSubscribe)
`IObservable<T>`	DoOnTerminate(this `IObservable<T>` source, `Action` onTerminate)
`IObservable<T>`	Empty()	Empty Observable. Returns only OnCompleted.
`IObservable<T>`	Empty(`IScheduler` scheduler)	Empty Observable. Returns only OnCompleted.
`IObservable<T>`	Empty(`T` witness)	Empty Observable. Returns only OnCompleted.
`IObservable<T>`	Empty(`IScheduler` scheduler, `T` witness)	Empty Observable. Returns only OnCompleted.
`IObservable<Boolean>`	EveryApplicationFocus()
`IObservable<Boolean>`	EveryApplicationPause()
`IObservable<Int64>`	EveryEndOfFrame()
`IObservable<Int64>`	EveryFixedUpdate()
`IObservable<Int64>`	EveryGameObjectUpdate()	EveryGameObjectUpdate calls from MainThreadDispatcher's Update.
`IObservable<Int64>`	EveryLateUpdate()	EveryLateUpdate calls from MainThreadDispatcher's OnLateUpdate.
`IObservable<Int64>`	EveryUpdate()	EveryUpdate calls coroutine's yield return null timing. It is after all Update and before LateUpdate.
`IObservable<T>`	Finally(this `IObservable<T>` source, `Action` finallyAction)
`IObservable<T>`	First(this `IObservable<T>` source)
`IObservable<T>`	First(this `IObservable<T>` source, `Func<T, Boolean>` predicate)
`IObservable<T>`	FirstOrDefault(this `IObservable<T>` source)
`IObservable<T>`	FirstOrDefault(this `IObservable<T>` source, `Func<T, Boolean>` predicate)
`IObservable<Unit>`	ForEachAsync(this `IObservable<T>` source, `Action<T>` onNext)
`IObservable<Unit>`	ForEachAsync(this `IObservable<T>` source, `Action<T, Int32>` onNext)
`IObservable<FrameInterval<T>>`	FrameInterval(this `IObservable<T>` source)
`IObservable<TimeInterval<T>>`	FrameTimeInterval(this `IObservable<T>` source, `Boolean` ignoreTimeScale = False)
`Func<IObservable<TResult>>`	FromAsyncPattern(`Func<AsyncCallback, Object, IAsyncResult>` begin, `Func<IAsyncResult, TResult>` end)
`Func<T1, IObservable<TResult>>`	FromAsyncPattern(`Func<T1, AsyncCallback, Object, IAsyncResult>` begin, `Func<IAsyncResult, TResult>` end)
`Func<T1, T2, IObservable<TResult>>`	FromAsyncPattern(`Func<T1, T2, AsyncCallback, Object, IAsyncResult>` begin, `Func<IAsyncResult, TResult>` end)
`Func<IObservable<Unit>>`	FromAsyncPattern(`Func<AsyncCallback, Object, IAsyncResult>` begin, `Action<IAsyncResult>` end)
`Func<T1, IObservable<Unit>>`	FromAsyncPattern(`Func<T1, AsyncCallback, Object, IAsyncResult>` begin, `Action<IAsyncResult>` end)
`Func<T1, T2, IObservable<Unit>>`	FromAsyncPattern(`Func<T1, T2, AsyncCallback, Object, IAsyncResult>` begin, `Action<IAsyncResult>` end)
`IObservable<Unit>`	FromCoroutine(`Func<IEnumerator>` coroutine, `Boolean` publishEveryYield = False)	From has no callback coroutine to IObservable. If publishEveryYield = true then publish OnNext every yield return else return once on enumeration completed.
`IObservable<Unit>`	FromCoroutine(`Func<CancellationToken, IEnumerator>` coroutine, `Boolean` publishEveryYield = False)	From has no callback coroutine to IObservable. If publishEveryYield = true then publish OnNext every yield return else return once on enumeration completed.
`IObservable<T>`	FromCoroutine(`Func<IObserver<T>, IEnumerator>` coroutine)	From has no callback coroutine to IObservable. If publishEveryYield = true then publish OnNext every yield return else return once on enumeration completed.
`IObservable<T>`	FromCoroutine(`Func<IObserver<T>, CancellationToken, IEnumerator>` coroutine)	From has no callback coroutine to IObservable. If publishEveryYield = true then publish OnNext every yield return else return once on enumeration completed.
`IObservable<T>`	FromCoroutineValue(`Func<IEnumerator>` coroutine, `Boolean` nullAsNextUpdate = True)	Convert coroutine to typed IObservable. If nullAsNextUpdate = true then yield return null when Enumerator.Current and no null publish observer.OnNext.
`IObservable<T>`	FromCoroutineValue(`Func<CancellationToken, IEnumerator>` coroutine, `Boolean` nullAsNextUpdate = True)	Convert coroutine to typed IObservable. If nullAsNextUpdate = true then yield return null when Enumerator.Current and no null publish observer.OnNext.
`IObservable<Unit>`	FromEvent(`Func<Action, TDelegate>` conversion, `Action<TDelegate>` addHandler, `Action<TDelegate>` removeHandler)
`IObservable<TEventArgs>`	FromEvent(`Func<Action<TEventArgs>, TDelegate>` conversion, `Action<TDelegate>` addHandler, `Action<TDelegate>` removeHandler)
`IObservable<Unit>`	FromEvent(`Action<Action>` addHandler, `Action<Action>` removeHandler)
`IObservable<T>`	FromEvent(`Action<Action<T>>` addHandler, `Action<Action<T>>` removeHandler)
`IObservable<EventPattern<TEventArgs>>`	FromEventPattern(`Func<EventHandler<TEventArgs>, TDelegate>` conversion, `Action<TDelegate>` addHandler, `Action<TDelegate>` removeHandler)
`IObservable<Unit>`	FromMicroCoroutine(`Func<IEnumerator>` coroutine, `Boolean` publishEveryYield = False, `FrameCountType` frameCountType = Update)	MicroCoroutine is lightweight, fast coroutine dispatcher. IEnumerator supports only yield return null. If publishEveryYield = true then publish OnNext every yield return else return once on enumeration completed.
`IObservable<Unit>`	FromMicroCoroutine(`Func<CancellationToken, IEnumerator>` coroutine, `Boolean` publishEveryYield = False, `FrameCountType` frameCountType = Update)	MicroCoroutine is lightweight, fast coroutine dispatcher. IEnumerator supports only yield return null. If publishEveryYield = true then publish OnNext every yield return else return once on enumeration completed.
`IObservable<T>`	FromMicroCoroutine(`Func<IObserver<T>, IEnumerator>` coroutine, `FrameCountType` frameCountType = Update)	MicroCoroutine is lightweight, fast coroutine dispatcher. IEnumerator supports only yield return null. If publishEveryYield = true then publish OnNext every yield return else return once on enumeration completed.
`IObservable<T>`	FromMicroCoroutine(`Func<IObserver<T>, CancellationToken, IEnumerator>` coroutine, `FrameCountType` frameCountType = Update)	MicroCoroutine is lightweight, fast coroutine dispatcher. IEnumerator supports only yield return null. If publishEveryYield = true then publish OnNext every yield return else return once on enumeration completed.
`AsyncSubject<TSource>`	GetAwaiter(this `IObservable<TSource>` source)	Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty. This operation subscribes to the observable sequence, making it hot.
`AsyncSubject<TSource>`	GetAwaiter(this `IConnectableObservable<TSource>` source)	Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty. This operation subscribes to the observable sequence, making it hot.
`AsyncSubject<TSource>`	GetAwaiter(this `IObservable<TSource>` source, `CancellationToken` cancellationToken)	Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty. This operation subscribes to the observable sequence, making it hot.
`AsyncSubject<TSource>`	GetAwaiter(this `IConnectableObservable<TSource>` source, `CancellationToken` cancellationToken)	Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty. This operation subscribes to the observable sequence, making it hot.
`IObservable<IGroupedObservable<TKey, TSource>>`	GroupBy(this `IObservable<TSource>` source, `Func<TSource, TKey>` keySelector)
`IObservable<IGroupedObservable<TKey, TSource>>`	GroupBy(this `IObservable<TSource>` source, `Func<TSource, TKey>` keySelector, `IEqualityComparer<TKey>` comparer)
`IObservable<IGroupedObservable<TKey, TElement>>`	GroupBy(this `IObservable<TSource>` source, `Func<TSource, TKey>` keySelector, `Func<TSource, TElement>` elementSelector)
`IObservable<IGroupedObservable<TKey, TElement>>`	GroupBy(this `IObservable<TSource>` source, `Func<TSource, TKey>` keySelector, `Func<TSource, TElement>` elementSelector, `IEqualityComparer<TKey>` comparer)
`IObservable<IGroupedObservable<TKey, TSource>>`	GroupBy(this `IObservable<TSource>` source, `Func<TSource, TKey>` keySelector, `Int32` capacity)
`IObservable<IGroupedObservable<TKey, TSource>>`	GroupBy(this `IObservable<TSource>` source, `Func<TSource, TKey>` keySelector, `Int32` capacity, `IEqualityComparer<TKey>` comparer)
`IObservable<IGroupedObservable<TKey, TElement>>`	GroupBy(this `IObservable<TSource>` source, `Func<TSource, TKey>` keySelector, `Func<TSource, TElement>` elementSelector, `Int32` capacity)
`IObservable<IGroupedObservable<TKey, TElement>>`	GroupBy(this `IObservable<TSource>` source, `Func<TSource, TKey>` keySelector, `Func<TSource, TElement>` elementSelector, `Int32` capacity, `IEqualityComparer<TKey>` comparer)
`IObservable<T>`	IgnoreElements(this `IObservable<T>` source)
`IObservable<Int64>`	Interval(`TimeSpan` period)
`IObservable<Int64>`	Interval(`TimeSpan` period, `IScheduler` scheduler)
`IObservable<Int64>`	IntervalFrame(`Int32` intervalFrameCount, `FrameCountType` frameCountType = Update)
`IObservable<T>`	Last(this `IObservable<T>` source)
`IObservable<T>`	Last(this `IObservable<T>` source, `Func<T, Boolean>` predicate)
`IObservable<T>`	LastOrDefault(this `IObservable<T>` source)
`IObservable<T>`	LastOrDefault(this `IObservable<T>` source, `Func<T, Boolean>` predicate)
`IObservable<Notification<T>>`	Materialize(this `IObservable<T>` source)
`IObservable<TSource>`	Merge(this `IEnumerable<IObservable<TSource>>` sources)
`IObservable<TSource>`	Merge(this `IEnumerable<IObservable<TSource>>` sources, `IScheduler` scheduler)
`IObservable<TSource>`	Merge(this `IEnumerable<IObservable<TSource>>` sources, `Int32` maxConcurrent)
`IObservable<TSource>`	Merge(this `IEnumerable<IObservable<TSource>>` sources, `Int32` maxConcurrent, `IScheduler` scheduler)
`IObservable<TSource>`	Merge(`IObservable`1[]` sources)
`IObservable<TSource>`	Merge(`IScheduler` scheduler, `IObservable`1[]` sources)
`IObservable<T>`	Merge(this `IObservable<T>` first, `IObservable`1[]` seconds)
`IObservable<T>`	Merge(this `IObservable<T>` first, `IObservable<T>` second, `IScheduler` scheduler)
`IObservable<T>`	Merge(this `IObservable<IObservable<T>>` sources)
`IObservable<T>`	Merge(this `IObservable<IObservable<T>>` sources, `Int32` maxConcurrent)
`IConnectableObservable<T>`	Multicast(this `IObservable<T>` source, `ISubject<T>` subject)
`IObservable<T>`	Never()	Non-Terminating Observable. It's no returns, never finish.
`IObservable<T>`	Never(`T` witness)	Non-Terminating Observable. It's no returns, never finish.
`IObservable<Unit>`	NextFrame(`FrameCountType` frameCountType = Update)
`IObservable<T>`	ObserveOn(this `IObservable<T>` source, `IScheduler` scheduler)
`IObservable<T>`	ObserveOnMainThread(this `IObservable<T>` source)
`IObservable<T>`	ObserveOnMainThread(this `IObservable<T>` source, `MainThreadDispatchType` dispatchType)
`IObservable<TResult>`	OfType(this `IObservable<TSource>` source)	witness is for type inference.
`IObservable<TResult>`	OfType(this `IObservable<TSource>` source, `TResult` witness)	witness is for type inference.
`IObservable<Unit>`	OnceApplicationQuit()	publish OnNext(Unit) and OnCompleted() on application quit.
`IObservable<TSource>`	OnErrorRetry(this `IObservable<TSource>` source)	Repeats the source observable sequence until it successfully terminates. This is same as Retry().
`IObservable<TSource>`	OnErrorRetry(this `IObservable<TSource>` source, `Action<TException>` onError)	Repeats the source observable sequence until it successfully terminates. This is same as Retry().
`IObservable<TSource>`	OnErrorRetry(this `IObservable<TSource>` source, `Action<TException>` onError, `TimeSpan` delay)	Repeats the source observable sequence until it successfully terminates. This is same as Retry().
`IObservable<TSource>`	OnErrorRetry(this `IObservable<TSource>` source, `Action<TException>` onError, `Int32` retryCount)	Repeats the source observable sequence until it successfully terminates. This is same as Retry().
`IObservable<TSource>`	OnErrorRetry(this `IObservable<TSource>` source, `Action<TException>` onError, `Int32` retryCount, `TimeSpan` delay)	Repeats the source observable sequence until it successfully terminates. This is same as Retry().
`IObservable<TSource>`	OnErrorRetry(this `IObservable<TSource>` source, `Action<TException>` onError, `Int32` retryCount, `TimeSpan` delay, `IScheduler` delayScheduler)	Repeats the source observable sequence until it successfully terminates. This is same as Retry().
`IObservable<Pair<T>>`	Pairwise(this `IObservable<T>` source)	Projects old and new element of a sequence into a new form.
`IObservable<TR>`	Pairwise(this `IObservable<T>` source, `Func<T, T, TR>` selector)	Projects old and new element of a sequence into a new form.
`IConnectableObservable<T>`	Publish(this `IObservable<T>` source)
`IConnectableObservable<T>`	Publish(this `IObservable<T>` source, `T` initialValue)
`IConnectableObservable<T>`	PublishLast(this `IObservable<T>` source)
`IObservable<Int32>`	Range(`Int32` start, `Int32` count)
`IObservable<Int32>`	Range(`Int32` start, `Int32` count, `IScheduler` scheduler)
`IObservable<T>`	RefCount(this `IConnectableObservable<T>` source)
`IObservable<T>`	Repeat(`T` value)
`IObservable<T>`	Repeat(`T` value, `IScheduler` scheduler)
`IObservable<T>`	Repeat(`T` value, `Int32` repeatCount)
`IObservable<T>`	Repeat(`T` value, `Int32` repeatCount, `IScheduler` scheduler)
`IObservable<T>`	Repeat(this `IObservable<T>` source)
`IObservable<T>`	RepeatSafe(this `IObservable<T>` source)	Same as Repeat() but if arriving contiguous "OnComplete" Repeat stops.
`IObservable<T>`	RepeatUntilDestroy(this `IObservable<T>` source, `GameObject` target)
`IObservable<T>`	RepeatUntilDestroy(this `IObservable<T>` source, `Component` target)
`IObservable<T>`	RepeatUntilDisable(this `IObservable<T>` source, `GameObject` target)
`IObservable<T>`	RepeatUntilDisable(this `IObservable<T>` source, `Component` target)
`IConnectableObservable<T>`	Replay(this `IObservable<T>` source)
`IConnectableObservable<T>`	Replay(this `IObservable<T>` source, `IScheduler` scheduler)
`IConnectableObservable<T>`	Replay(this `IObservable<T>` source, `Int32` bufferSize)
`IConnectableObservable<T>`	Replay(this `IObservable<T>` source, `Int32` bufferSize, `IScheduler` scheduler)
`IConnectableObservable<T>`	Replay(this `IObservable<T>` source, `TimeSpan` window)
`IConnectableObservable<T>`	Replay(this `IObservable<T>` source, `TimeSpan` window, `IScheduler` scheduler)
`IConnectableObservable<T>`	Replay(this `IObservable<T>` source, `Int32` bufferSize, `TimeSpan` window, `IScheduler` scheduler)
`IObservable<TSource>`	Retry(this `IObservable<TSource>` source)
`IObservable<TSource>`	Retry(this `IObservable<TSource>` source, `Int32` retryCount)
`IObservable<T>`	Return(`T` value)	Return single sequence Immediately.
`IObservable<T>`	Return(`T` value, `IScheduler` scheduler)	Return single sequence Immediately.
`IObservable<Unit>`	Return(`Unit` value)	Return single sequence Immediately.
`IObservable<Boolean>`	Return(`Boolean` value)	Return single sequence Immediately.
`IObservable<Int32>`	Return(`Int32` value)	Return single sequence Immediately.
`IObservable<Unit>`	ReturnUnit()	Same as Observable.Return(Unit.Default); but no allocate memory.
`IObservable<T>`	Sample(this `IObservable<T>` source, `TimeSpan` interval)
`IObservable<T>`	Sample(this `IObservable<T>` source, `TimeSpan` interval, `IScheduler` scheduler)
`IObservable<T>`	Sample(this `IObservable<T>` source, `IObservable<T2>` sampler)
`IObservable<T>`	SampleFrame(this `IObservable<T>` source, `Int32` frameCount, `FrameCountType` frameCountType = Update)
`IObservable<TSource>`	Scan(this `IObservable<TSource>` source, `Func<TSource, TSource, TSource>` accumulator)
`IObservable<TAccumulate>`	Scan(this `IObservable<TSource>` source, `TAccumulate` seed, `Func<TAccumulate, TSource, TAccumulate>` accumulator)
`IObservable<TR>`	Select(this `IObservable<T>` source, `Func<T, TR>` selector)
`IObservable<TR>`	Select(this `IObservable<T>` source, `Func<T, Int32, TR>` selector)
`IObservable<Unit>`	SelectMany(this `IObservable<T>` source, `IEnumerator` coroutine, `Boolean` publishEveryYield = False)	Note: publishEveryYield is always false. If you want to set true, use Observable.FromCoroutine(() => selector(x), true). This is workaround of Unity compiler's bug.
`IObservable<Unit>`	SelectMany(this `IObservable<T>` source, `Func<IEnumerator>` selector, `Boolean` publishEveryYield = False)	Note: publishEveryYield is always false. If you want to set true, use Observable.FromCoroutine(() => selector(x), true). This is workaround of Unity compiler's bug.
`IObservable<Unit>`	SelectMany(this `IObservable<T>` source, `Func<T, IEnumerator>` selector)	Note: publishEveryYield is always false. If you want to set true, use Observable.FromCoroutine(() => selector(x), true). This is workaround of Unity compiler's bug.
`IObservable<TResult>`	SelectMany(this `IObservable<TSource>` source, `Func<TSource, Int32, IEnumerable<TCollection>>` collectionSelector, `Func<TSource, Int32, TCollection, Int32, TResult>` resultSelector)	Note: publishEveryYield is always false. If you want to set true, use Observable.FromCoroutine(() => selector(x), true). This is workaround of Unity compiler's bug.
`IObservable<TR>`	SelectMany(this `IObservable<T>` source, `IObservable<TR>` other)	Note: publishEveryYield is always false. If you want to set true, use Observable.FromCoroutine(() => selector(x), true). This is workaround of Unity compiler's bug.
`IObservable<TR>`	SelectMany(this `IObservable<T>` source, `Func<T, IObservable<TR>>` selector)	Note: publishEveryYield is always false. If you want to set true, use Observable.FromCoroutine(() => selector(x), true). This is workaround of Unity compiler's bug.
`IObservable<TResult>`	SelectMany(this `IObservable<TSource>` source, `Func<TSource, Int32, IObservable<TResult>>` selector)	Note: publishEveryYield is always false. If you want to set true, use Observable.FromCoroutine(() => selector(x), true). This is workaround of Unity compiler's bug.
`IObservable<TR>`	SelectMany(this `IObservable<T>` source, `Func<T, IObservable<TC>>` collectionSelector, `Func<T, TC, TR>` resultSelector)	Note: publishEveryYield is always false. If you want to set true, use Observable.FromCoroutine(() => selector(x), true). This is workaround of Unity compiler's bug.
`IObservable<TResult>`	SelectMany(this `IObservable<TSource>` source, `Func<TSource, Int32, IObservable<TCollection>>` collectionSelector, `Func<TSource, Int32, TCollection, Int32, TResult>` resultSelector)	Note: publishEveryYield is always false. If you want to set true, use Observable.FromCoroutine(() => selector(x), true). This is workaround of Unity compiler's bug.
`IObservable<TResult>`	SelectMany(this `IObservable<TSource>` source, `Func<TSource, IEnumerable<TResult>>` selector)	Note: publishEveryYield is always false. If you want to set true, use Observable.FromCoroutine(() => selector(x), true). This is workaround of Unity compiler's bug.
`IObservable<TResult>`	SelectMany(this `IObservable<TSource>` source, `Func<TSource, Int32, IEnumerable<TResult>>` selector)	Note: publishEveryYield is always false. If you want to set true, use Observable.FromCoroutine(() => selector(x), true). This is workaround of Unity compiler's bug.
`IObservable<TResult>`	SelectMany(this `IObservable<TSource>` source, `Func<TSource, IEnumerable<TCollection>>` collectionSelector, `Func<TSource, TCollection, TResult>` resultSelector)	Note: publishEveryYield is always false. If you want to set true, use Observable.FromCoroutine(() => selector(x), true). This is workaround of Unity compiler's bug.
`IObservable<T>`	Share(this `IObservable<T>` source)	same as Publish().RefCount()
`IObservable<T>`	Single(this `IObservable<T>` source)
`IObservable<T>`	Single(this `IObservable<T>` source, `Func<T, Boolean>` predicate)
`IObservable<T>`	SingleOrDefault(this `IObservable<T>` source)
`IObservable<T>`	SingleOrDefault(this `IObservable<T>` source, `Func<T, Boolean>` predicate)
`IObservable<T>`	Skip(this `IObservable<T>` source, `Int32` count)
`IObservable<T>`	Skip(this `IObservable<T>` source, `TimeSpan` duration)
`IObservable<T>`	Skip(this `IObservable<T>` source, `TimeSpan` duration, `IScheduler` scheduler)
`IObservable<T>`	SkipUntil(this `IObservable<T>` source, `IObservable<TOther>` other)
`IObservable<T>`	SkipWhile(this `IObservable<T>` source, `Func<T, Boolean>` predicate)
`IObservable<T>`	SkipWhile(this `IObservable<T>` source, `Func<T, Int32, Boolean>` predicate)
`IObservable<T>`	Start(`Func<T>` function)
`IObservable<T>`	Start(`Func<T>` function, `TimeSpan` timeSpan)
`IObservable<T>`	Start(`Func<T>` function, `IScheduler` scheduler)
`IObservable<T>`	Start(`Func<T>` function, `TimeSpan` timeSpan, `IScheduler` scheduler)
`IObservable<Unit>`	Start(`Action` action)
`IObservable<Unit>`	Start(`Action` action, `TimeSpan` timeSpan)
`IObservable<Unit>`	Start(`Action` action, `IScheduler` scheduler)
`IObservable<Unit>`	Start(`Action` action, `TimeSpan` timeSpan, `IScheduler` scheduler)
`Coroutine`	StartAsCoroutine(this `IObservable<T>` source, `CancellationToken` cancel = null)	AutoStart observable as coroutine.
`Coroutine`	StartAsCoroutine(this `IObservable<T>` source, `Action<T>` onResult, `CancellationToken` cancel = null)	AutoStart observable as coroutine.
`Coroutine`	StartAsCoroutine(this `IObservable<T>` source, `Action<Exception>` onError, `CancellationToken` cancel = null)	AutoStart observable as coroutine.
`Coroutine`	StartAsCoroutine(this `IObservable<T>` source, `Action<T>` onResult, `Action<Exception>` onError, `CancellationToken` cancel = null)	AutoStart observable as coroutine.
`IObservable<T>`	StartWith(this `IObservable<T>` source, `T` value)
`IObservable<T>`	StartWith(this `IObservable<T>` source, `Func<T>` valueFactory)
`IObservable<T>`	StartWith(this `IObservable<T>` source, `T[]` values)
`IObservable<T>`	StartWith(this `IObservable<T>` source, `IEnumerable<T>` values)
`IObservable<T>`	StartWith(this `IObservable<T>` source, `IScheduler` scheduler, `T` value)
`IObservable<T>`	StartWith(this `IObservable<T>` source, `IScheduler` scheduler, `IEnumerable<T>` values)
`IObservable<T>`	StartWith(this `IObservable<T>` source, `IScheduler` scheduler, `T[]` values)
`IObservable<T>`	SubscribeOn(this `IObservable<T>` source, `IScheduler` scheduler)
`IObservable<T>`	SubscribeOnMainThread(this `IObservable<T>` source)
`IObservable<T>`	Switch(this `IObservable<IObservable<T>>` sources)
`IObservable<T>`	Synchronize(this `IObservable<T>` source)
`IObservable<T>`	Synchronize(this `IObservable<T>` source, `Object` gate)
`IObservable<T>`	Take(this `IObservable<T>` source, `Int32` count)
`IObservable<T>`	Take(this `IObservable<T>` source, `TimeSpan` duration)
`IObservable<T>`	Take(this `IObservable<T>` source, `TimeSpan` duration, `IScheduler` scheduler)
`IObservable<T>`	TakeLast(this `IObservable<T>` source, `Int32` count)
`IObservable<T>`	TakeLast(this `IObservable<T>` source, `TimeSpan` duration)
`IObservable<T>`	TakeLast(this `IObservable<T>` source, `TimeSpan` duration, `IScheduler` scheduler)
`IObservable<T>`	TakeUntil(this `IObservable<T>` source, `IObservable<TOther>` other)
`IObservable<T>`	TakeUntilDestroy(this `IObservable<T>` source, `Component` target)
`IObservable<T>`	TakeUntilDestroy(this `IObservable<T>` source, `GameObject` target)
`IObservable<T>`	TakeUntilDisable(this `IObservable<T>` source, `Component` target)
`IObservable<T>`	TakeUntilDisable(this `IObservable<T>` source, `GameObject` target)
`IObservable<T>`	TakeWhile(this `IObservable<T>` source, `Func<T, Boolean>` predicate)
`IObservable<T>`	TakeWhile(this `IObservable<T>` source, `Func<T, Int32, Boolean>` predicate)
`IObservable<TSource>`	Throttle(this `IObservable<TSource>` source, `TimeSpan` dueTime)
`IObservable<TSource>`	Throttle(this `IObservable<TSource>` source, `TimeSpan` dueTime, `IScheduler` scheduler)
`IObservable<TSource>`	ThrottleFirst(this `IObservable<TSource>` source, `TimeSpan` dueTime)
`IObservable<TSource>`	ThrottleFirst(this `IObservable<TSource>` source, `TimeSpan` dueTime, `IScheduler` scheduler)
`IObservable<TSource>`	ThrottleFirstFrame(this `IObservable<TSource>` source, `Int32` frameCount, `FrameCountType` frameCountType = Update)
`IObservable<TSource>`	ThrottleFrame(this `IObservable<TSource>` source, `Int32` frameCount, `FrameCountType` frameCountType = Update)
`IObservable<T>`	Throw(`Exception` error)	Empty Observable. Returns only onError.
`IObservable<T>`	Throw(`Exception` error, `T` witness)	Empty Observable. Returns only onError.
`IObservable<T>`	Throw(`Exception` error, `IScheduler` scheduler)	Empty Observable. Returns only onError.
`IObservable<T>`	Throw(`Exception` error, `IScheduler` scheduler, `T` witness)	Empty Observable. Returns only onError.
`IObservable<TimeInterval<TSource>>`	TimeInterval(this `IObservable<TSource>` source)
`IObservable<TimeInterval<TSource>>`	TimeInterval(this `IObservable<TSource>` source, `IScheduler` scheduler)
`IObservable<T>`	Timeout(this `IObservable<T>` source, `TimeSpan` dueTime)
`IObservable<T>`	Timeout(this `IObservable<T>` source, `TimeSpan` dueTime, `IScheduler` scheduler)
`IObservable<T>`	Timeout(this `IObservable<T>` source, `DateTimeOffset` dueTime)
`IObservable<T>`	Timeout(this `IObservable<T>` source, `DateTimeOffset` dueTime, `IScheduler` scheduler)
`IObservable<T>`	TimeoutFrame(this `IObservable<T>` source, `Int32` frameCount, `FrameCountType` frameCountType = Update)
`IObservable<Int64>`	Timer(`TimeSpan` dueTime, `TimeSpan` period, `IScheduler` scheduler)
`IObservable<Int64>`	Timer(`DateTimeOffset` dueTime, `TimeSpan` period, `IScheduler` scheduler)
`IObservable<Int64>`	Timer(`TimeSpan` dueTime)
`IObservable<Int64>`	Timer(`DateTimeOffset` dueTime)
`IObservable<Int64>`	Timer(`TimeSpan` dueTime, `TimeSpan` period)
`IObservable<Int64>`	Timer(`DateTimeOffset` dueTime, `TimeSpan` period)
`IObservable<Int64>`	Timer(`TimeSpan` dueTime, `IScheduler` scheduler)
`IObservable<Int64>`	Timer(`DateTimeOffset` dueTime, `IScheduler` scheduler)
`IObservable<Int64>`	TimerFrame(`Int32` dueTimeFrameCount, `FrameCountType` frameCountType = Update)
`IObservable<Int64>`	TimerFrame(`Int32` dueTimeFrameCount, `Int32` periodFrameCount, `FrameCountType` frameCountType = Update)
`IObservable<Timestamped<TSource>>`	Timestamp(this `IObservable<TSource>` source)
`IObservable<Timestamped<TSource>>`	Timestamp(this `IObservable<TSource>` source, `IScheduler` scheduler)
`IObservable<T[]>`	ToArray(this `IObservable<T>` source)
`Func<IObservable<T>>`	ToAsync(`Func<T>` function)
`Func<IObservable<T>>`	ToAsync(`Func<T>` function, `IScheduler` scheduler)
`Func<IObservable<Unit>>`	ToAsync(`Action` action)
`Func<IObservable<Unit>>`	ToAsync(`Action` action, `IScheduler` scheduler)
`IEnumerator`	ToAwaitableEnumerator(this `IObservable<T>` source, `CancellationToken` cancel = null)	Convert to awaitable IEnumerator.
`IEnumerator`	ToAwaitableEnumerator(this `IObservable<T>` source, `Action<T>` onResult, `CancellationToken` cancel = null)	Convert to awaitable IEnumerator.
`IEnumerator`	ToAwaitableEnumerator(this `IObservable<T>` source, `Action<Exception>` onError, `CancellationToken` cancel = null)	Convert to awaitable IEnumerator.
`IEnumerator`	ToAwaitableEnumerator(this `IObservable<T>` source, `Action<T>` onResult, `Action<Exception>` onError, `CancellationToken` cancel = null)	Convert to awaitable IEnumerator.
`IObservable<IList<T>>`	ToList(this `IObservable<T>` source)
`IObservable<Unit>`	ToObservable(this `IEnumerator` coroutine, `Boolean` publishEveryYield = False)
`IObservable<T>`	ToObservable(this `IEnumerable<T>` source)
`IObservable<T>`	ToObservable(this `IEnumerable<T>` source, `IScheduler` scheduler)
`ObservableYieldInstruction<T>`	ToYieldInstruction(this `IObservable<T>` source, `CancellationToken` cancel)	Convert to yieldable IEnumerator. e.g. yield return source.ToYieldInstruction();. If needs last result, you can take ObservableYieldInstruction.HasResult/Result property. This overload throws exception if received OnError events(same as coroutine).
`ObservableYieldInstruction<T>`	ToYieldInstruction(this `IObservable<T>` source, `Boolean` throwOnError)	Convert to yieldable IEnumerator. e.g. yield return source.ToYieldInstruction();. If needs last result, you can take ObservableYieldInstruction.HasResult/Result property. This overload throws exception if received OnError events(same as coroutine).
`ObservableYieldInstruction<T>`	ToYieldInstruction(this `IObservable<T>` source, `Boolean` throwOnError, `CancellationToken` cancel)	Convert to yieldable IEnumerator. e.g. yield return source.ToYieldInstruction();. If needs last result, you can take ObservableYieldInstruction.HasResult/Result property. This overload throws exception if received OnError events(same as coroutine).
`ObservableYieldInstruction<Unit>`	ToYieldInstruction(this `IEnumerator` coroutine)	Convert to yieldable IEnumerator. e.g. yield return source.ToYieldInstruction();. If needs last result, you can take ObservableYieldInstruction.HasResult/Result property. This overload throws exception if received OnError events(same as coroutine).
`ObservableYieldInstruction<Unit>`	ToYieldInstruction(this `IEnumerator` coroutine, `Boolean` throwOnError)	Convert to yieldable IEnumerator. e.g. yield return source.ToYieldInstruction();. If needs last result, you can take ObservableYieldInstruction.HasResult/Result property. This overload throws exception if received OnError events(same as coroutine).
`ObservableYieldInstruction<Unit>`	ToYieldInstruction(this `IEnumerator` coroutine, `CancellationToken` cancellationToken)	Convert to yieldable IEnumerator. e.g. yield return source.ToYieldInstruction();. If needs last result, you can take ObservableYieldInstruction.HasResult/Result property. This overload throws exception if received OnError events(same as coroutine).
`ObservableYieldInstruction<Unit>`	ToYieldInstruction(this `IEnumerator` coroutine, `Boolean` throwOnError, `CancellationToken` cancellationToken)	Convert to yieldable IEnumerator. e.g. yield return source.ToYieldInstruction();. If needs last result, you can take ObservableYieldInstruction.HasResult/Result property. This overload throws exception if received OnError events(same as coroutine).
`ObservableYieldInstruction<T>`	ToYieldInstruction(this `IObservable<T>` source)	Convert to yieldable IEnumerator. e.g. yield return source.ToYieldInstruction();. If needs last result, you can take ObservableYieldInstruction.HasResult/Result property. This overload throws exception if received OnError events(same as coroutine).
`T`	Wait(this `IObservable<T>` source)
`T`	Wait(this `IObservable<T>` source, `TimeSpan` timeout)
`IObservable<T[]>`	WhenAll(`IObservable`1[]` sources)	Specialized for single async operations like Task.WhenAll, Zip.Take(1). If sequence is empty, return T[0] array.
`IObservable<Unit>`	WhenAll(`IObservable`1[]` sources)	Specialized for single async operations like Task.WhenAll, Zip.Take(1). If sequence is empty, return T[0] array.
`IObservable<T[]>`	WhenAll(this `IEnumerable<IObservable<T>>` sources)	Specialized for single async operations like Task.WhenAll, Zip.Take(1). If sequence is empty, return T[0] array.
`IObservable<Unit>`	WhenAll(this `IEnumerable<IObservable<Unit>>` sources)	Specialized for single async operations like Task.WhenAll, Zip.Take(1). If sequence is empty, return T[0] array.
`IObservable<T>`	Where(this `IObservable<T>` source, `Func<T, Boolean>` predicate)
`IObservable<T>`	Where(this `IObservable<T>` source, `Func<T, Int32, Boolean>` predicate)
`IObservable<TResult>`	WithLatestFrom(this `IObservable<TLeft>` left, `IObservable<TRight>` right, `Func<TLeft, TRight, TResult>` selector)
`IObservable<TR>`	Zip(this `IObservable<T1>` source1, `IObservable<T2>` source2, `IObservable<T3>` source3, `IObservable<T4>` source4, `IObservable<T5>` source5, `IObservable<T6>` source6, `IObservable<T7>` source7, `ZipFunc<T1, T2, T3, T4, T5, T6, T7, TR>` resultSelector)
`IObservable<TResult>`	Zip(this `IObservable<TLeft>` left, `IObservable<TRight>` right, `Func<TLeft, TRight, TResult>` selector)
`IObservable<IList<T>>`	Zip(this `IEnumerable<IObservable<T>>` sources)
`IObservable<IList<T>>`	Zip(`IObservable`1[]` sources)
`IObservable<TR>`	Zip(this `IObservable<T1>` source1, `IObservable<T2>` source2, `IObservable<T3>` source3, `ZipFunc<T1, T2, T3, TR>` resultSelector)
`IObservable<TR>`	Zip(this `IObservable<T1>` source1, `IObservable<T2>` source2, `IObservable<T3>` source3, `IObservable<T4>` source4, `ZipFunc<T1, T2, T3, T4, TR>` resultSelector)
`IObservable<TR>`	Zip(this `IObservable<T1>` source1, `IObservable<T2>` source2, `IObservable<T3>` source3, `IObservable<T4>` source4, `IObservable<T5>` source5, `ZipFunc<T1, T2, T3, T4, T5, TR>` resultSelector)
`IObservable<TR>`	Zip(this `IObservable<T1>` source1, `IObservable<T2>` source2, `IObservable<T3>` source3, `IObservable<T4>` source4, `IObservable<T5>` source5, `IObservable<T6>` source6, `ZipFunc<T1, T2, T3, T4, T5, T6, TR>` resultSelector)
`IObservable<TResult>`	ZipLatest(this `IObservable<TLeft>` left, `IObservable<TRight>` right, `Func<TLeft, TRight, TResult>` selector)
`IObservable<IList<T>>`	ZipLatest(this `IEnumerable<IObservable<T>>` sources)
`IObservable<IList<TSource>>`	ZipLatest(`IObservable`1[]` sources)
`IObservable<TR>`	ZipLatest(this `IObservable<T1>` source1, `IObservable<T2>` source2, `IObservable<T3>` source3, `ZipLatestFunc<T1, T2, T3, TR>` resultSelector)
`IObservable<TR>`	ZipLatest(this `IObservable<T1>` source1, `IObservable<T2>` source2, `IObservable<T3>` source3, `IObservable<T4>` source4, `ZipLatestFunc<T1, T2, T3, T4, TR>` resultSelector)
`IObservable<TR>`	ZipLatest(this `IObservable<T1>` source1, `IObservable<T2>` source2, `IObservable<T3>` source3, `IObservable<T4>` source4, `IObservable<T5>` source5, `ZipLatestFunc<T1, T2, T3, T4, T5, TR>` resultSelector)
`IObservable<TR>`	ZipLatest(this `IObservable<T1>` source1, `IObservable<T2>` source2, `IObservable<T3>` source3, `IObservable<T4>` source4, `IObservable<T5>` source5, `IObservable<T6>` source6, `ZipLatestFunc<T1, T2, T3, T4, T5, T6, TR>` resultSelector)
`IObservable<TR>`	ZipLatest(this `IObservable<T1>` source1, `IObservable<T2>` source2, `IObservable<T3>` source3, `IObservable<T4>` source4, `IObservable<T5>` source5, `IObservable<T6>` source6, `IObservable<T7>` source7, `ZipLatestFunc<T1, T2, T3, T4, T5, T6, T7, TR>` resultSelector)

`ObservableExtensions`

public static class UniRx.ObservableExtensions

Static Methods

Type	Name	Summary
`IDisposable`	Subscribe(this `IObservable<T>` source)
`IDisposable`	Subscribe(this `IObservable<T>` source, `Action<T>` onNext)
`IDisposable`	Subscribe(this `IObservable<T>` source, `Action<T>` onNext, `Action<Exception>` onError)
`IDisposable`	Subscribe(this `IObservable<T>` source, `Action<T>` onNext, `Action` onCompleted)
`IDisposable`	Subscribe(this `IObservable<T>` source, `Action<T>` onNext, `Action<Exception>` onError, `Action` onCompleted)
`IDisposable`	SubscribeWithState(this `IObservable<T>` source, `TState` state, `Action<T, TState>` onNext)
`IDisposable`	SubscribeWithState(this `IObservable<T>` source, `TState` state, `Action<T, TState>` onNext, `Action<Exception, TState>` onError)
`IDisposable`	SubscribeWithState(this `IObservable<T>` source, `TState` state, `Action<T, TState>` onNext, `Action<TState>` onCompleted)
`IDisposable`	SubscribeWithState(this `IObservable<T>` source, `TState` state, `Action<T, TState>` onNext, `Action<Exception, TState>` onError, `Action<TState>` onCompleted)
`IDisposable`	SubscribeWithState2(this `IObservable<T>` source, `TState1` state1, `TState2` state2, `Action<T, TState1, TState2>` onNext)
`IDisposable`	SubscribeWithState2(this `IObservable<T>` source, `TState1` state1, `TState2` state2, `Action<T, TState1, TState2>` onNext, `Action<Exception, TState1, TState2>` onError)
`IDisposable`	SubscribeWithState2(this `IObservable<T>` source, `TState1` state1, `TState2` state2, `Action<T, TState1, TState2>` onNext, `Action<TState1, TState2>` onCompleted)
`IDisposable`	SubscribeWithState2(this `IObservable<T>` source, `TState1` state1, `TState2` state2, `Action<T, TState1, TState2>` onNext, `Action<Exception, TState1, TState2>` onError, `Action<TState1, TState2>` onCompleted)
`IDisposable`	SubscribeWithState3(this `IObservable<T>` source, `TState1` state1, `TState2` state2, `TState3` state3, `Action<T, TState1, TState2, TState3>` onNext)
`IDisposable`	SubscribeWithState3(this `IObservable<T>` source, `TState1` state1, `TState2` state2, `TState3` state3, `Action<T, TState1, TState2, TState3>` onNext, `Action<Exception, TState1, TState2, TState3>` onError)
`IDisposable`	SubscribeWithState3(this `IObservable<T>` source, `TState1` state1, `TState2` state2, `TState3` state3, `Action<T, TState1, TState2, TState3>` onNext, `Action<TState1, TState2, TState3>` onCompleted)
`IDisposable`	SubscribeWithState3(this `IObservable<T>` source, `TState1` state1, `TState2` state2, `TState3` state3, `Action<T, TState1, TState2, TState3>` onNext, `Action<Exception, TState1, TState2, TState3>` onError, `Action<TState1, TState2, TState3>` onCompleted)

`ObservableWWW`

public static class UniRx.ObservableWWW

Static Methods

Type	Name	Summary
`IObservable<String>`	Get(`String` url, `Dictionary<String, String>` headers = null, `IProgress<Single>` progress = null)
`IObservable<Byte[]>`	GetAndGetBytes(`String` url, `Dictionary<String, String>` headers = null, `IProgress<Single>` progress = null)
`IObservable<WWW>`	GetWWW(`String` url, `Dictionary<String, String>` headers = null, `IProgress<Single>` progress = null)
`IObservable<AssetBundle>`	LoadFromCacheOrDownload(`String` url, `Int32` version, `IProgress<Single>` progress = null)
`IObservable<AssetBundle>`	LoadFromCacheOrDownload(`String` url, `Int32` version, `UInt32` crc, `IProgress<Single>` progress = null)
`IObservable<AssetBundle>`	LoadFromCacheOrDownload(`String` url, `Hash128` hash128, `IProgress<Single>` progress = null)
`IObservable<AssetBundle>`	LoadFromCacheOrDownload(`String` url, `Hash128` hash128, `UInt32` crc, `IProgress<Single>` progress = null)
`IObservable<String>`	Post(`String` url, `Byte[]` postData, `IProgress<Single>` progress = null)
`IObservable<String>`	Post(`String` url, `Byte[]` postData, `Dictionary<String, String>` headers, `IProgress<Single>` progress = null)
`IObservable<String>`	Post(`String` url, `WWWForm` content, `IProgress<Single>` progress = null)
`IObservable<String>`	Post(`String` url, `WWWForm` content, `Dictionary<String, String>` headers, `IProgress<Single>` progress = null)
`IObservable<Byte[]>`	PostAndGetBytes(`String` url, `Byte[]` postData, `IProgress<Single>` progress = null)
`IObservable<Byte[]>`	PostAndGetBytes(`String` url, `Byte[]` postData, `Dictionary<String, String>` headers, `IProgress<Single>` progress = null)
`IObservable<Byte[]>`	PostAndGetBytes(`String` url, `WWWForm` content, `IProgress<Single>` progress = null)
`IObservable<Byte[]>`	PostAndGetBytes(`String` url, `WWWForm` content, `Dictionary<String, String>` headers, `IProgress<Single>` progress = null)
`IObservable<WWW>`	PostWWW(`String` url, `Byte[]` postData, `IProgress<Single>` progress = null)
`IObservable<WWW>`	PostWWW(`String` url, `Byte[]` postData, `Dictionary<String, String>` headers, `IProgress<Single>` progress = null)
`IObservable<WWW>`	PostWWW(`String` url, `WWWForm` content, `IProgress<Single>` progress = null)
`IObservable<WWW>`	PostWWW(`String` url, `WWWForm` content, `Dictionary<String, String>` headers, `IProgress<Single>` progress = null)

`ObservableYieldInstruction<T>`

public class UniRx.ObservableYieldInstruction<T>
    : IEnumerator<T>, IDisposable, IEnumerator, ICustomYieldInstructionErrorHandler

Properties

Type	Name	Summary
`Exception`	Error
`Boolean`	HasError
`Boolean`	HasResult
`Boolean`	IsCanceled
`Boolean`	IsDone	HasResult
`T`	Result

Methods

Type	Name	Summary
`void`	Dispose()

`ObserveExtensions`

public static class UniRx.ObserveExtensions

Static Methods

Type	Name	Summary
`IObservable<TProperty>`	ObserveEveryValueChanged(this `TSource` source, `Func<TSource, TProperty>` propertySelector, `FrameCountType` frameCountType = Update, `Boolean` fastDestroyCheck = False)	Publish target property when value is changed. If source is destroyed/destructed, publish OnCompleted.
`IObservable<TProperty>`	ObserveEveryValueChanged(this `TSource` source, `Func<TSource, TProperty>` propertySelector, `FrameCountType` frameCountType, `IEqualityComparer<TProperty>` comparer)	Publish target property when value is changed. If source is destroyed/destructed, publish OnCompleted.
`IObservable<TProperty>`	ObserveEveryValueChanged(this `TSource` source, `Func<TSource, TProperty>` propertySelector, `FrameCountType` frameCountType, `IEqualityComparer<TProperty>` comparer, `Boolean` fastDestroyCheck)	Publish target property when value is changed. If source is destroyed/destructed, publish OnCompleted.

`Observer`

public static class UniRx.Observer

Static Methods

Type	Name	Summary
`IObserver<T>`	Create(`Action<T>` onNext)
`IObserver<T>`	Create(`Action<T>` onNext, `Action<Exception>` onError)
`IObserver<T>`	Create(`Action<T>` onNext, `Action` onCompleted)
`IObserver<T>`	Create(`Action<T>` onNext, `Action<Exception>` onError, `Action` onCompleted)
`IObserver<T>`	CreateAutoDetachObserver(`IObserver<T>` observer, `IDisposable` disposable)
`IObserver<T>`	CreateSubscribeObserver(`Action<T>` onNext, `Action<Exception>` onError, `Action` onCompleted)
`IObserver<T>`	CreateSubscribeWithState2Observer(`TState1` state1, `TState2` state2, `Action<T, TState1, TState2>` onNext, `Action<Exception, TState1, TState2>` onError, `Action<TState1, TState2>` onCompleted)
`IObserver<T>`	CreateSubscribeWithState3Observer(`TState1` state1, `TState2` state2, `TState3` state3, `Action<T, TState1, TState2, TState3>` onNext, `Action<Exception, TState1, TState2, TState3>` onError, `Action<TState1, TState2, TState3>` onCompleted)
`IObserver<T>`	CreateSubscribeWithStateObserver(`TState` state, `Action<T, TState>` onNext, `Action<Exception, TState>` onError, `Action<TState>` onCompleted)

`ObserverExtensions`

public static class UniRx.ObserverExtensions

Static Methods

Type	Name	Summary
`IObserver<T>`	Synchronize(this `IObserver<T>` observer)
`IObserver<T>`	Synchronize(this `IObserver<T>` observer, `Object` gate)

`OptimizedObservableExtensions`

public static class UniRx.OptimizedObservableExtensions

Static Methods

Type	Name	Summary
`Boolean`	IsRequiredSubscribeOnCurrentThread(this `IObservable<T>` source)
`Boolean`	IsRequiredSubscribeOnCurrentThread(this `IObservable<T>` source, `IScheduler` scheduler)

`Pair<T>`

public struct UniRx.Pair<T>
    : IEquatable<Pair<T>>

Properties

Type	Name	Summary
`T`	Current
`T`	Previous

Methods

Type	Name	Summary
`Boolean`	Equals(`Object` obj)
`Boolean`	Equals(`Pair<T>` other)
`Int32`	GetHashCode()
`String`	ToString()

`QuaternionReactiveProperty`

Inspectable ReactiveProperty.

public class UniRx.QuaternionReactiveProperty
    : ReactiveProperty<Quaternion>, IReactiveProperty<Quaternion>, IReadOnlyReactiveProperty<Quaternion>, IObservable<Quaternion>, IDisposable, IOptimizedObservable<Quaternion>, IObserverLinkedList<Quaternion>

Properties

Type	Name	Summary
`IEqualityComparer<Quaternion>`	EqualityComparer

`RangeReactivePropertyAttribute`

Enables range input field for Int/FloatReactiveProperty.

public class UniRx.RangeReactivePropertyAttribute
    : PropertyAttribute, _Attribute

Properties

Type	Name	Summary
`Single`	Max
`Single`	Min

`ReactiveCollection<T>`

public class UniRx.ReactiveCollection<T>
    : Collection<T>, IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IList, ICollection, IReadOnlyList<T>, IReadOnlyCollection<T>, IReactiveCollection<T>, IReadOnlyReactiveCollection<T>, IDisposable

Methods

Type	Name	Summary
`void`	ClearItems()
`void`	Dispose(`Boolean` disposing)
`void`	Dispose()
`void`	InsertItem(`Int32` index, `T` item)
`void`	Move(`Int32` oldIndex, `Int32` newIndex)
`void`	MoveItem(`Int32` oldIndex, `Int32` newIndex)
`IObservable<CollectionAddEvent<T>>`	ObserveAdd()
`IObservable<Int32>`	ObserveCountChanged(`Boolean` notifyCurrentCount = False)
`IObservable<CollectionMoveEvent<T>>`	ObserveMove()
`IObservable<CollectionRemoveEvent<T>>`	ObserveRemove()
`IObservable<CollectionReplaceEvent<T>>`	ObserveReplace()
`IObservable<Unit>`	ObserveReset()
`void`	RemoveItem(`Int32` index)
`void`	SetItem(`Int32` index, `T` item)

`ReactiveCollectionExtensions`

public static class UniRx.ReactiveCollectionExtensions

Static Methods

Type	Name	Summary
`ReactiveCollection<T>`	ToReactiveCollection(this `IEnumerable<T>` source)

`ReactiveCommand`

Represents ReactiveCommand<Unit>

public class UniRx.ReactiveCommand
    : ReactiveCommand<Unit>, IReactiveCommand<Unit>, IObservable<Unit>, IDisposable

Methods

Type	Name	Summary
`Boolean`	Execute()	Push null to subscribers.
`void`	ForceExecute()	Force push parameter to subscribers.

`ReactiveCommand<T>`

public class UniRx.ReactiveCommand<T>
    : IReactiveCommand<T>, IObservable<T>, IDisposable

Properties

Type	Name	Summary
`IReadOnlyReactiveProperty<Boolean>`	CanExecute
`Boolean`	IsDisposed

Methods

Type	Name	Summary
`void`	Dispose()	Stop all subscription and lock CanExecute is false.
`Boolean`	Execute(`T` parameter)	Push parameter to subscribers when CanExecute.
`void`	ForceExecute(`T` parameter)	Force push parameter to subscribers.
`IDisposable`	Subscribe(`IObserver<T>` observer)	Subscribe execute.
`UniTask<T>`	WaitUntilExecuteAsync()

`ReactiveCommandExtensions`

public static class UniRx.ReactiveCommandExtensions

Static Methods

Type	Name	Summary
`IDisposable`	BindTo(this `IReactiveCommand<Unit>` command, `Button` button)	Bind ReactiveCommand to button's interactable and onClick.
`IDisposable`	BindToButtonOnClick(this `IObservable<Boolean>` canExecuteSource, `Button` button, `Action<Unit>` onClick, `Boolean` initialValue = True)	Bind canExecuteSource to button's interactable and onClick and register onClick action to command.
`IDisposable`	BindToOnClick(this `IReactiveCommand<Unit>` command, `Button` button, `Action<Unit>` onClick)	Bind ReactiveCommand to button's interactable and onClick and register onClick action to command.
`Awaiter<T>`	GetAwaiter(this `IReactiveCommand<T>` command)
`ReactiveCommand`	ToReactiveCommand(this `IObservable<Boolean>` canExecuteSource, `Boolean` initialValue = True)	Create non parameter commands. CanExecute is changed from canExecute sequence.
`ReactiveCommand<T>`	ToReactiveCommand(this `IObservable<Boolean>` canExecuteSource, `Boolean` initialValue = True)	Create non parameter commands. CanExecute is changed from canExecute sequence.

`ReactiveDictionary<TKey, TValue>`

public class UniRx.ReactiveDictionary<TKey, TValue>
    : IReactiveDictionary<TKey, TValue>, IReadOnlyReactiveDictionary<TKey, TValue>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, ICollection, IDisposable, ISerializable, IDeserializationCallback

Properties

Type	Name	Summary
`Int32`	Count
`TValue`	Item
`KeyCollection<TKey, TValue>`	Keys
`ValueCollection<TKey, TValue>`	Values

Methods

Type	Name	Summary
`void`	Add(`TKey` key, `TValue` value)
`void`	Clear()
`Boolean`	ContainsKey(`TKey` key)
`void`	Dispose(`Boolean` disposing)
`void`	Dispose()
`Enumerator<TKey, TValue>`	GetEnumerator()
`void`	GetObjectData(`SerializationInfo` info, `StreamingContext` context)
`IObservable<DictionaryAddEvent<TKey, TValue>>`	ObserveAdd()
`IObservable<Int32>`	ObserveCountChanged(`Boolean` notifyCurrentCount = False)
`IObservable<DictionaryRemoveEvent<TKey, TValue>>`	ObserveRemove()
`IObservable<DictionaryReplaceEvent<TKey, TValue>>`	ObserveReplace()
`IObservable<Unit>`	ObserveReset()
`void`	OnDeserialization(`Object` sender)
`Boolean`	Remove(`TKey` key)
`Boolean`	TryGetValue(`TKey` key, `TValue&` value)

`ReactiveDictionaryExtensions`

public static class UniRx.ReactiveDictionaryExtensions

Static Methods

Type	Name	Summary
`ReactiveDictionary<TKey, TValue>`	ToReactiveDictionary(this `Dictionary<TKey, TValue>` dictionary)

`ReactiveProperty<T>`

Lightweight property broker.

public class UniRx.ReactiveProperty<T>
    : IReactiveProperty<T>, IReadOnlyReactiveProperty<T>, IObservable<T>, IDisposable, IOptimizedObservable<T>, IObserverLinkedList<T>

Properties

Type	Name	Summary
`IEqualityComparer<T>`	EqualityComparer
`Boolean`	HasValue
`T`	Value

Methods

Type	Name	Summary
`void`	Dispose()
`void`	Dispose(`Boolean` disposing)
`Boolean`	IsRequiredSubscribeOnCurrentThread()
`void`	SetValue(`T` value)
`void`	SetValueAndForceNotify(`T` value)
`IDisposable`	Subscribe(`IObserver<T>` observer)
`String`	ToString()
`UniTask<T>`	WaitUntilValueChangedAsync()

`ReactivePropertyExtensions`

Extension methods of ReactiveProperty<T>

public static class UniRx.ReactivePropertyExtensions

Static Methods

Type	Name	Summary
`IObservable<Boolean>`	CombineLatestValuesAreAllFalse(this `IEnumerable<IObservable<Boolean>>` sources)	Lastest values of each sequence are all false.
`IObservable<Boolean>`	CombineLatestValuesAreAllTrue(this `IEnumerable<IObservable<Boolean>>` sources)	Lastest values of each sequence are all true.
`Awaiter<T>`	GetAwaiter(this `IReadOnlyReactiveProperty<T>` source)
`IObservable<T>`	SkipLatestValueOnSubscribe(this `IReadOnlyReactiveProperty<T>` source)
`IReadOnlyReactiveProperty<T>`	ToReactiveProperty(this `IObservable<T>` source)
`IReadOnlyReactiveProperty<T>`	ToReactiveProperty(this `IObservable<T>` source, `T` initialValue)
`ReadOnlyReactiveProperty<T>`	ToReadOnlyReactiveProperty(this `IObservable<T>` source)
`ReadOnlyReactiveProperty<T>`	ToReadOnlyReactiveProperty(this `IObservable<T>` source, `T` initialValue)
`ReadOnlyReactiveProperty<T>`	ToSequentialReadOnlyReactiveProperty(this `IObservable<T>` source)	Create ReadOnlyReactiveProperty with distinctUntilChanged: false.
`ReadOnlyReactiveProperty<T>`	ToSequentialReadOnlyReactiveProperty(this `IObservable<T>` source, `T` initialValue)	Create ReadOnlyReactiveProperty with distinctUntilChanged: false.

`ReadOnlyReactiveProperty<T>`

Lightweight property broker.

public class UniRx.ReadOnlyReactiveProperty<T>
    : IReadOnlyReactiveProperty<T>, IObservable<T>, IDisposable, IOptimizedObservable<T>, IObserverLinkedList<T>, IObserver<T>

Properties

Type	Name	Summary
`IEqualityComparer<T>`	EqualityComparer
`Boolean`	HasValue
`T`	Value

Methods

Type	Name	Summary
`void`	Dispose()
`void`	Dispose(`Boolean` disposing)
`Boolean`	IsRequiredSubscribeOnCurrentThread()
`IDisposable`	Subscribe(`IObserver<T>` observer)
`String`	ToString()
`UniTask<T>`	WaitUntilValueChangedAsync()

`RectReactiveProperty`

Inspectable ReactiveProperty.

public class UniRx.RectReactiveProperty
    : ReactiveProperty<Rect>, IReactiveProperty<Rect>, IReadOnlyReactiveProperty<Rect>, IObservable<Rect>, IDisposable, IOptimizedObservable<Rect>, IObserverLinkedList<Rect>

Properties

Type	Name	Summary
`IEqualityComparer<Rect>`	EqualityComparer

`RefCountDisposable`

Represents a disposable resource that only disposes its underlying disposable resource when all dependent disposable objects have been disposed.

public class UniRx.RefCountDisposable
    : ICancelable, IDisposable

Properties

Type	Name	Summary
`Boolean`	IsDisposed	Gets a value that indicates whether the object is disposed.

Methods

Type	Name	Summary
`void`	Dispose()	Disposes the underlying disposable only when all dependent disposables have been disposed.
`IDisposable`	GetDisposable()	Returns a dependent disposable that when disposed decreases the refcount on the underlying disposable.

`ReplaySubject<T>`

public class UniRx.ReplaySubject<T>
    : ISubject<T>, ISubject<T, T>, IObserver<T>, IObservable<T>, IOptimizedObservable<T>, IDisposable

Methods

Type	Name	Summary
`void`	Dispose()
`Boolean`	IsRequiredSubscribeOnCurrentThread()
`void`	OnCompleted()
`void`	OnError(`Exception` error)
`void`	OnNext(`T` value)
`IDisposable`	Subscribe(`IObserver<T>` observer)

`ScenePlaybackDetector`

public class UniRx.ScenePlaybackDetector

Static Properties

Type	Name	Summary
`Boolean`	IsPlaying

Static Methods

Type	Name	Summary
`void`	OnDidReloadScripts()

`ScheduledDisposable`

public class UniRx.ScheduledDisposable
    : ICancelable, IDisposable

Properties

Type	Name	Summary
`IDisposable`	Disposable
`Boolean`	IsDisposed
`IScheduler`	Scheduler

Methods

Type	Name	Summary
`void`	Dispose()

`ScheduledNotifier<T>`

Notify value on setuped scheduler.

public class UniRx.ScheduledNotifier<T>
    : IObservable<T>, IProgress<T>

Methods

Type	Name	Summary
`void`	Report(`T` value)	Push value to subscribers on setuped scheduler.
`IDisposable`	Report(`T` value, `TimeSpan` dueTime)	Push value to subscribers on setuped scheduler.
`IDisposable`	Report(`T` value, `DateTimeOffset` dueTime)	Push value to subscribers on setuped scheduler.
`IDisposable`	Subscribe(`IObserver<T>` observer)	Subscribe observer.

`Scheduler`

public static class UniRx.Scheduler

Static Fields

Type	Name	Summary
`IScheduler`	CurrentThread
`IScheduler`	Immediate
`IScheduler`	ThreadPool

Static Properties

Type	Name	Summary
`Boolean`	IsCurrentThreadSchedulerScheduleRequired
`IScheduler`	MainThread	Unity native MainThread Queue Scheduler. Run on mainthread and delayed on coroutine update loop, elapsed time is calculated based on Time.time.
`IScheduler`	MainThreadEndOfFrame	Run on end of frame mainthread, delay elapsed time is calculated based on Time.deltaTime.
`IScheduler`	MainThreadFixedUpdate	Run on fixed update mainthread, delay elapsed time is calculated based on Time.fixedTime.
`IScheduler`	MainThreadIgnoreTimeScale	Another MainThread scheduler, delay elapsed time is calculated based on Time.unscaledDeltaTime.
`DateTimeOffset`	Now

Static Methods

Type	Name	Summary
`TimeSpan`	Normalize(`TimeSpan` timeSpan)
`IDisposable`	Schedule(this `IScheduler` scheduler, `DateTimeOffset` dueTime, `Action` action)
`IDisposable`	Schedule(this `IScheduler` scheduler, `Action<Action>` action)
`IDisposable`	Schedule(this `IScheduler` scheduler, `TimeSpan` dueTime, `Action<Action<TimeSpan>>` action)
`IDisposable`	Schedule(this `IScheduler` scheduler, `DateTimeOffset` dueTime, `Action<Action<DateTimeOffset>>` action)
`void`	SetDefaultForUnity()

`SerialDisposable`

public class UniRx.SerialDisposable
    : IDisposable, ICancelable

Properties

Type	Name	Summary
`IDisposable`	Disposable
`Boolean`	IsDisposed

Methods

Type	Name	Summary
`void`	Dispose()

`SingleAssignmentDisposable`

public class UniRx.SingleAssignmentDisposable
    : IDisposable, ICancelable

Properties

Type	Name	Summary
`IDisposable`	Disposable
`Boolean`	IsDisposed

Methods

Type	Name	Summary
`void`	Dispose()

`StableCompositeDisposable`

Represents a group of disposable resources that are disposed together.

public abstract class UniRx.StableCompositeDisposable
    : ICancelable, IDisposable

Properties

Type	Name	Summary
`Boolean`	IsDisposed	Gets a value that indicates whether the object is disposed.

Methods

Type	Name	Summary
`void`	Dispose()	Disposes all disposables in the group.

Static Methods

Type	Name	Summary
`ICancelable`	Create(`IDisposable` disposable1, `IDisposable` disposable2)	Creates a new group containing two disposable resources that are disposed together.
`ICancelable`	Create(`IDisposable` disposable1, `IDisposable` disposable2, `IDisposable` disposable3)	Creates a new group containing two disposable resources that are disposed together.
`ICancelable`	Create(`IDisposable` disposable1, `IDisposable` disposable2, `IDisposable` disposable3, `IDisposable` disposable4)	Creates a new group containing two disposable resources that are disposed together.
`ICancelable`	Create(`IDisposable[]` disposables)	Creates a new group containing two disposable resources that are disposed together.
`ICancelable`	Create(`IEnumerable<IDisposable>` disposables)	Creates a new group containing two disposable resources that are disposed together.
`ICancelable`	CreateUnsafe(`IDisposable[]` disposables)	Creates a new group of disposable resources that are disposed together. Array is not copied, it's unsafe but optimized.

`StringReactiveProperty`

Inspectable ReactiveProperty.

public class UniRx.StringReactiveProperty
    : ReactiveProperty<String>, IReactiveProperty<String>, IReadOnlyReactiveProperty<String>, IObservable<String>, IDisposable, IOptimizedObservable<String>, IObserverLinkedList<String>

`Subject<T>`

public class UniRx.Subject<T>
    : ISubject<T>, ISubject<T, T>, IObserver<T>, IObservable<T>, IDisposable, IOptimizedObservable<T>

Properties

Type	Name	Summary
`Boolean`	HasObservers

Methods

Type	Name	Summary
`void`	Dispose()
`Boolean`	IsRequiredSubscribeOnCurrentThread()
`void`	OnCompleted()
`void`	OnError(`Exception` error)
`void`	OnNext(`T` value)
`IDisposable`	Subscribe(`IObserver<T>` observer)

`SubjectExtensions`

public static class UniRx.SubjectExtensions

Static Methods

Type	Name	Summary
`ISubject<T>`	Synchronize(this `ISubject<T>` subject)
`ISubject<T>`	Synchronize(this `ISubject<T>` subject, `Object` gate)

`TaskObservableExtensions`

Provides a set of static methods for converting tasks to observable sequences.

public static class UniRx.TaskObservableExtensions

Static Methods

Type	Name	Summary
`IObservable<Unit>`	ToObservable(this `Task` task)	Returns an observable sequence that signals when the task completes.
`IObservable<Unit>`	ToObservable(this `Task` task, `IScheduler` scheduler)	Returns an observable sequence that signals when the task completes.
`IObservable<TResult>`	ToObservable(this `Task<TResult>` task)	Returns an observable sequence that signals when the task completes.
`IObservable<TResult>`	ToObservable(this `Task<TResult>` task, `IScheduler` scheduler)	Returns an observable sequence that signals when the task completes.
`Task<TResult>`	ToTask(this `IObservable<TResult>` observable)	Returns a task that will receive the last value or the exception produced by the observable sequence.
`Task<TResult>`	ToTask(this `IObservable<TResult>` observable, `Object` state)	Returns a task that will receive the last value or the exception produced by the observable sequence.
`Task<TResult>`	ToTask(this `IObservable<TResult>` observable, `CancellationToken` cancellationToken)	Returns a task that will receive the last value or the exception produced by the observable sequence.
`Task<TResult>`	ToTask(this `IObservable<TResult>` observable, `CancellationToken` cancellationToken, `Object` state)	Returns a task that will receive the last value or the exception produced by the observable sequence.

`TimeInterval<T>`

Represents a value associated with time interval information. The time interval can represent the time it took to produce the value, the interval relative to a previous value, the value's delivery time relative to a base, etc.

public struct UniRx.TimeInterval<T>
    : IEquatable<TimeInterval<T>>

Properties

Type	Name	Summary
`TimeSpan`	Interval	Gets the interval.
`T`	Value	Gets the value.

Methods

Type	Name	Summary
`Boolean`	Equals(`TimeInterval<T>` other)	Determines whether the current TimeInterval<T> value has the same Value and Interval as a specified TimeInterval<T> value.
`Boolean`	Equals(`Object` obj)	Determines whether the current TimeInterval<T> value has the same Value and Interval as a specified TimeInterval<T> value.
`Int32`	GetHashCode()	Returns the hash code for the current TimeInterval<T> value.
`String`	ToString()	Returns a string representation of the current TimeInterval<T> value.

`Timestamped`

A helper class with a factory method for creating Timestamped<T> instances.

public static class UniRx.Timestamped

Static Methods

Type	Name	Summary
`Timestamped<T>`	Create(`T` value, `DateTimeOffset` timestamp)	Creates an instance of a Timestamped<T>. This is syntactic sugar that uses type inference to avoid specifying a type in a constructor call, which is very useful when using anonymous types.

`Timestamped<T>`

Represents value with a timestamp on it. The timestamp typically represents the time the value was received, using an IScheduler's clock to obtain the current time.

public struct UniRx.Timestamped<T>
    : IEquatable<Timestamped<T>>

Properties

Type	Name	Summary
`DateTimeOffset`	Timestamp	Gets the timestamp.
`T`	Value	Gets the value.

Methods

Type	Name	Summary
`Boolean`	Equals(`Timestamped<T>` other)	Determines whether the current Timestamped<T> value has the same Value and Timestamp as a specified Timestamped<T> value.
`Boolean`	Equals(`Object` obj)	Determines whether the current Timestamped<T> value has the same Value and Timestamp as a specified Timestamped<T> value.
`Int32`	GetHashCode()	Returns the hash code for the current Timestamped<T> value.
`String`	ToString()	Returns a string representation of the current Timestamped<T> value.

`Unit`

public struct UniRx.Unit
    : IEquatable<Unit>

Methods

Type	Name	Summary
`Boolean`	Equals(`Unit` other)
`Boolean`	Equals(`Object` obj)
`Int32`	GetHashCode()
`String`	ToString()

Static Properties

Type	Name	Summary
`Unit`	Default

`UniTaskObservableExtensions`

public static class UniRx.UniTaskObservableExtensions

Static Methods

Type	Name	Summary
`IObservable<T>`	ToObservable(this `UniTask<T>` task)
`IObservable<Unit>`	ToObservable(this `UniTask` task)
`UniTask<T>`	ToUniTask(this `IObservable<T>` source, `CancellationToken` cancellationToken = null, `Boolean` useFirstValue = False)

`UnityEqualityComparer`

public static class UniRx.UnityEqualityComparer

Static Fields

Type	Name	Summary
`IEqualityComparer<Bounds>`	Bounds
`IEqualityComparer<Color>`	Color
`IEqualityComparer<Quaternion>`	Quaternion
`IEqualityComparer<Rect>`	Rect
`IEqualityComparer<Vector2>`	Vector2
`IEqualityComparer<Vector3>`	Vector3
`IEqualityComparer<Vector4>`	Vector4

Static Methods

Type	Name	Summary
`IEqualityComparer<T>`	GetDefault()

`UnityEventExtensions`

public static class UniRx.UnityEventExtensions

Static Methods

Type	Name	Summary
`IObservable<Unit>`	AsObservable(this `UnityEvent` unityEvent)
`IObservable<T>`	AsObservable(this `UnityEvent<T>` unityEvent)
`IObservable<Tuple<T0, T1>>`	AsObservable(this `UnityEvent<T0, T1>` unityEvent)
`IObservable<Tuple<T0, T1, T2>>`	AsObservable(this `UnityEvent<T0, T1, T2>` unityEvent)
`IObservable<Tuple<T0, T1, T2, T3>>`	AsObservable(this `UnityEvent<T0, T1, T2, T3>` unityEvent)

`UnityGraphicExtensions`

public static class UniRx.UnityGraphicExtensions

Static Methods

Type	Name	Summary
`IObservable<Unit>`	DirtyLayoutCallbackAsObservable(this `Graphic` graphic)
`IObservable<Unit>`	DirtyMaterialCallbackAsObservable(this `Graphic` graphic)
`IObservable<Unit>`	DirtyVerticesCallbackAsObservable(this `Graphic` graphic)

`UnityUIComponentExtensions`

public static class UniRx.UnityUIComponentExtensions

Static Methods

Type	Name	Summary
`IObservable<Unit>`	OnClickAsObservable(this `Button` button)	Observe onClick event.
`IObservable<String>`	OnEndEditAsObservable(this `InputField` inputField)	Observe onEndEdit(Submit) event.
`IObservable<Boolean>`	OnValueChangedAsObservable(this `Toggle` toggle)	Observe onValueChanged with current `isOn` value on subscribe.
`IObservable<Single>`	OnValueChangedAsObservable(this `Scrollbar` scrollbar)	Observe onValueChanged with current `isOn` value on subscribe.
`IObservable<Vector2>`	OnValueChangedAsObservable(this `ScrollRect` scrollRect)	Observe onValueChanged with current `isOn` value on subscribe.
`IObservable<Single>`	OnValueChangedAsObservable(this `Slider` slider)	Observe onValueChanged with current `isOn` value on subscribe.
`IObservable<String>`	OnValueChangedAsObservable(this `InputField` inputField)	Observe onValueChanged with current `isOn` value on subscribe.
`IDisposable`	SubscribeToInteractable(this `IObservable<Boolean>` source, `Selectable` selectable)
`IDisposable`	SubscribeToText(this `IObservable<String>` source, `Text` text)
`IDisposable`	SubscribeToText(this `IObservable<T>` source, `Text` text)
`IDisposable`	SubscribeToText(this `IObservable<T>` source, `Text` text, `Func<T, String>` selector)

`Vector2ReactiveProperty`

Inspectable ReactiveProperty.

public class UniRx.Vector2ReactiveProperty
    : ReactiveProperty<Vector2>, IReactiveProperty<Vector2>, IReadOnlyReactiveProperty<Vector2>, IObservable<Vector2>, IDisposable, IOptimizedObservable<Vector2>, IObserverLinkedList<Vector2>

Properties

Type	Name	Summary
`IEqualityComparer<Vector2>`	EqualityComparer

`Vector3ReactiveProperty`

Inspectable ReactiveProperty.

public class UniRx.Vector3ReactiveProperty
    : ReactiveProperty<Vector3>, IReactiveProperty<Vector3>, IReadOnlyReactiveProperty<Vector3>, IObservable<Vector3>, IDisposable, IOptimizedObservable<Vector3>, IObserverLinkedList<Vector3>

Properties

Type	Name	Summary
`IEqualityComparer<Vector3>`	EqualityComparer

`Vector4ReactiveProperty`

Inspectable ReactiveProperty.

public class UniRx.Vector4ReactiveProperty
    : ReactiveProperty<Vector4>, IReactiveProperty<Vector4>, IReadOnlyReactiveProperty<Vector4>, IObservable<Vector4>, IDisposable, IOptimizedObservable<Vector4>, IObserverLinkedList<Vector4>

Properties

Type	Name	Summary
`IEqualityComparer<Vector4>`	EqualityComparer

`WebRequestExtensions`

public static class UniRx.WebRequestExtensions

Static Methods

Type	Name	Summary
`IObservable<Stream>`	GetRequestStreamAsObservable(this `WebRequest` request)
`IObservable<WebResponse>`	GetResponseAsObservable(this `WebRequest` request)
`IObservable<HttpWebResponse>`	GetResponseAsObservable(this `HttpWebRequest` request)

`WWWErrorException`

public class UniRx.WWWErrorException
    : Exception, ISerializable, _Exception

Properties

Type	Name	Summary
`Boolean`	HasResponse
`String`	RawErrorMessage
`Dictionary<String, String>`	ResponseHeaders
`HttpStatusCode`	StatusCode
`String`	Text
`WWW`	WWW

Methods

Type	Name	Summary
`String`	ToString()

Reference document is generated by neuecc/MarkdownGenerator