<PackageReference Include="ReactiveUI.Primitives" Version="7.3.0" />

ReactiveUI.Primitives.Signals.Signal

public static class Signal
public static IObservable<long> After(TimeSpan dueTime)

public static IObservable<long> After(TimeSpan dueTime, ISequencer scheduler)

public static IObservable<long> After(DateTimeOffset dueTime)

public static IObservable<long> After(DateTimeOffset dueTime, ISequencer scheduler)

public static IObservable<long> After(TimeSpan dueTime, TimeSpan period)

public static IObservable<long> After(TimeSpan dueTime, TimeSpan period, ISequencer scheduler)

public static IObservable<T> Blend<T>(IObservable<T>[] sources)

public static IObservable<T> Case<TKey, T>(Func<TKey> selector, IDictionary<TKey, IObservable<T>> sources)

public static IObservable<T> Case<TKey, T>(Func<TKey> selector, IDictionary<TKey, IObservable<T>> sources, IObservable<T> defaultSource)

public static IObservable<T> Chain<T>(IObservable<T>[] sources)

public static IObservable<T> Concat<T>(IObservable<T>[] sources)

public static IObservable<T> Concat<T>(IEnumerable<IObservable<T>> sources)

public static IObservable<T> Create<T>(Func<IObserver<T>, IDisposable> subscribe)

public static IObservable<T> Create<T>(Func<IObserver<T>, Task<IDisposable>> subscribe)

public static IObservable<T> Create<T>(Func<IObserver<T>, CancellationToken, Task<IDisposable>> subscribe)

public static IObservable<T> Create<T>(Func<IObserver<T>, IDisposable> subscribe, bool isRequiredSubscribeOnCurrentThread)

public static IObservable<T> CreateSafe<T>(Func<IObserver<T>, IDisposable> subscribe)

public static IObservable<T> CreateSafe<T>(Func<IObserver<T>, IDisposable> subscribe, bool isRequiredSubscribeOnCurrentThread)

public static IObservable<T> CreateWithState<T, TState>(TState state, Func<TState, IObserver<T>, IDisposable> subscribe)

public static IObservable<T> CreateWithState<T, TState>(TState state, Func<TState, IObserver<T>, IDisposable> subscribe, bool isRequiredSubscribeOnCurrentThread)

public static IObservable<T> Defer<T>(Func<Task<IObservable<T>>> observableFactory)

public static IObservable<T> Defer<T>(Func<CancellationToken, Task<IObservable<T>>> observableFactory)

public static IObservable<T> Defer<T>(Func<IObservable<T>> observableFactory)

public static DelayableNotificationSignal<T> Delayable<T>(Func<bool> isDelayed, Func<IList<T>, IEnumerable<T>> flushDistinct)

public static IObservable<T> Emit<T>(T value, ISequencer scheduler)

public static IObservable<T> Emit<T>(T value)

public static IObservable<RxVoid> Emit(RxVoid value)

public static IObservable<bool> Emit(bool value)

public static IObservable<int> Emit(int value)

public static IObservable<RxVoid> EmitRxVoid()

public static IObservable<T> Empty<T>()

public static IObservable<T> Empty<T>(ISequencer scheduler)

public static IObservable<long> Every(TimeSpan period)

public static IObservable<long> Every(TimeSpan period, ISequencer scheduler)

public static IObservable<T> Expire<T>(IObservable<T> source, TimeSpan dueTime)

public static IObservable<T> Expire<T>(IObservable<T> source, TimeSpan dueTime, ISequencer scheduler)

public static IObservable<T> Fail<T>(Exception error, ISequencer scheduler)

public static IObservable<T> Fail<T>(Exception error)

public static IObservable<T> Fail<T>(Exception error, T witness)

public static IObservable<T> Fail<T>(Exception error, ISequencer scheduler, T witness)

public static IObservable<TResult> ForkJoin<TLeft, TRight, TResult>(IObservable<TLeft> left, IObservable<TRight> right, Func<TLeft, TRight, TResult> selector)

public static IObservable<T> FromAsync<T>(Func<Task<T>> taskFactory)

public static IObservable<T> FromAsync<T>(Func<CancellationToken, Task<T>> taskFactory)

public static IObservable<T> FromAsync<T>(Func<CancellationToken, Task<T>> taskFactory, CancellationToken cancellationToken)

public static IObservable<T> FromAsyncEnumerable<T>(IAsyncEnumerable<T> values)

public static IObservable<T> FromAsyncEnumerable<T>(IAsyncEnumerable<T> values, CancellationToken cancellationToken)

public static IObservable<T> FromEnumerable<T>(IEnumerable<T> values)

public static IObservable<T> FromEnumerable<T>(IEnumerable<T> values, CancellationToken cancellationToken)

public static IObservable<TEventArgs> FromEvent<TEventArgs>(Action<Action<TEventArgs>> addHandler, Action<Action<TEventArgs>> removeHandler)

public static IObservable<TEventArgs> FromEvent<TEventHandler, TEventArgs>(Func<Action<TEventArgs>, TEventHandler> conversion, Action<TEventHandler> addHandler, Action<TEventHandler> removeHandler) where TEventHandler : Delegate

public static IObservable<TEventArgs> FromEvent<TEventHandler, TEventArgs>(Func<Action<TEventArgs>, TEventHandler> conversion, Action<TEventHandler> addHandler, Action<TEventHandler> removeHandler, ISequencer scheduler) where TEventHandler : Delegate

public static IObservable<EventPattern<EventArgs>> FromEventPattern(Action<EventHandler> addHandler, Action<EventHandler> removeHandler)

public static IObservable<EventPattern<EventArgs>> FromEventPattern(Action<EventHandler> addHandler, Action<EventHandler> removeHandler, ISequencer scheduler)

public static IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(Action<EventHandler<TEventArgs>> addHandler, Action<EventHandler<TEventArgs>> removeHandler) where TEventArgs : EventArgs

public static IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventArgs>(Action<EventHandler<TEventArgs>> addHandler, Action<EventHandler<TEventArgs>> removeHandler, ISequencer scheduler) where TEventArgs : EventArgs

public static IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventHandler, TEventArgs>(Action<TEventHandler> addHandler, Action<TEventHandler> removeHandler) where TEventHandler : Delegate where TEventArgs : EventArgs

public static IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventHandler, TEventArgs>(Action<TEventHandler> addHandler, Action<TEventHandler> removeHandler, ISequencer scheduler) where TEventHandler : Delegate where TEventArgs : EventArgs

public static IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventHandler, TEventArgs>(Func<EventHandler<TEventArgs>, TEventHandler> conversion, Action<TEventHandler> addHandler, Action<TEventHandler> removeHandler) where TEventHandler : Delegate where TEventArgs : EventArgs

public static IObservable<EventPattern<TEventArgs>> FromEventPattern<TEventHandler, TEventArgs>(Func<EventHandler<TEventArgs>, TEventHandler> conversion, Action<TEventHandler> addHandler, Action<TEventHandler> removeHandler, ISequencer scheduler) where TEventHandler : Delegate where TEventArgs : EventArgs

public static IObservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TEventHandler, TSender, TEventArgs>(Func<EventHandler<TEventArgs>, TEventHandler> conversion, Action<TEventHandler> addHandler, Action<TEventHandler> removeHandler) where TEventHandler : Delegate where TEventArgs : EventArgs

public static IObservable<EventPattern<TSender, TEventArgs>> FromEventPattern<TEventHandler, TSender, TEventArgs>(Func<EventHandler<TEventArgs>, TEventHandler> conversion, Action<TEventHandler> addHandler, Action<TEventHandler> removeHandler, ISequencer scheduler) where TEventHandler : Delegate where TEventArgs : EventArgs

public static IObservable<T> FromTask<T>(Task<T> task)

public static ITaskSignal<RxVoid> FromTask(Func<CancellationTokenSource, Task<RxVoid>> execution)

public static ITaskSignal<RxVoid> FromTask(Func<CancellationTokenSource, Task<RxVoid>> execution, ISequencer scheduler)

public static ITaskSignal<RxVoid> FromTask(Func<CancellationTokenSource, Task<RxVoid>> execution, ISequencer scheduler, CancellationTokenSource cancellationTokenSource)

public static ITaskSignal<TResult> FromTask<TResult>(Func<CancellationTokenSource, Task<TResult>> actionAsync)

public static ITaskSignal<TResult> FromTask<TResult>(Func<CancellationTokenSource, Task<TResult>> actionAsync, ISequencer scheduler)

public static ITaskSignal<TResult> FromTask<TResult>(Func<CancellationTokenSource, Task<TResult>> actionAsync, ISequencer scheduler, CancellationTokenSource cancellationTokenSource)

public static IObservable<T> Generate<TState, T>(TState initialState, Func<TState, bool> condition, Func<TState, TState> iterate, Func<TState, T> resultSelector)

public static IObservable<T> If<T>(Func<bool> condition, IObservable<T> thenSource)

public static IObservable<T> If<T>(Func<bool> condition, IObservable<T> thenSource, IObservable<T> elseSource)

public static IObservable<long> Interval(TimeSpan period)

public static IObservable<long> Interval(TimeSpan period, ISequencer scheduler)

public static IObservable<TResult> Iterate<TState, TResult>(TState initialState, Func<TState, bool> condition, Func<TState, TState> iterator, Func<TState, TResult> resultSelector)

public static IObservable<T> Lazy<T>(Func<IObservable<T>> observableFactory)

public static IObservable<T> Loop<T>(T value)

public static IObservable<T> Loop<T>(T value, int count)

public static IObservable<T> Merge<T>(IObservable<T>[] sources)

public static IObservable<T> Merge<T>(IEnumerable<IObservable<T>> sources)

public static IObservable<T> Never<T>()

public static IObservable<T> None<T>(ISequencer scheduler)

public static IObservable<T> None<T>(ISequencer scheduler, T witness)

public static IObservable<T> None<T>()

public static IObservable<T> None<T>(T witness)

public static IObservable<T> OnErrorResumeNext<T>(IObservable<T> first, IObservable<T> second)

public static IObservable<T> OnErrorResumeNext<T>(IObservable<T>[] sources)

public static IObservable<T> OnErrorResumeNext<T>(IEnumerable<IObservable<T>> sources)

public static IObservable<TResult> Pair<TLeft, TRight, TResult>(IObservable<TLeft> left, IObservable<TRight> right, Func<TLeft, TRight, TResult> selector)

public static IObservable<TResult> PairLatest<TLeft, TRight, TResult>(IObservable<TLeft> left, IObservable<TRight> right, Func<TLeft, TRight, TResult> selector)

public static IObservable<long> Pulse(TimeSpan period)

public static IObservable<long> Pulse(TimeSpan period, ISequencer scheduler)

public static IObservable<T> Race<T>(IObservable<T>[] sources)

public static IObservable<int> Range(int start, int count)

public static IObservable<int> Range(int start, int count, ISequencer scheduler)

public static IObservable<TSource> Recover<TSource>(IObservable<TSource>[] sources)

public static IObservable<T> Repeat<T>(T value)

public static IObservable<T> Repeat<T>(T value, int repeatCount)

public static IObservable<T> Return<T>(T value)

public static IObservable<T> Return<T>(T value, ISequencer scheduler)

public static IAwaitSignal<TSource> RunAsync<TSource>(IObservable<TSource> source)

public static IAwaitSignal<TSource> RunAsync<TSource>(IObservable<TSource> source, CancellationToken cancellationToken)

public static ScheduledSignal<T> Scheduled<T>(ISequencer scheduler)

public static ScheduledSignal<T> Scheduled<T>(ISequencer scheduler, IObserver<T> defaultObserver)

public static IObservable<int> Sequence(int start, int count)

public static IObservable<int> Sequence(int start, int count, ISequencer scheduler)

public static IObservable<T> Silent<T>()

public static IObservable<T> Silent<T>(T witness)

public static IObservable<T> Start<T>(Func<T> function)

public static IObservable<T> Start<T>(Func<T> function, ISequencer scheduler)

public static IObservable<RxVoid> Start(Action action)

public static IObservable<RxVoid> Start(Action action, ISequencer scheduler)

public static IObservable<T> Switch<T>(IObservable<IObservable<T>> sources)

public static IObservable<TResult> SyncLatest<TLeft, TRight, TResult>(IObservable<TLeft> left, IObservable<TRight> right, Func<TLeft, TRight, TResult> selector)

public static IObservable<T> Throw<T>(Exception error)

public static IObservable<T> Throw<T>(Exception error, ISequencer scheduler)

public static IObservable<T> Timeout<T>(IObservable<T> source, TimeSpan dueTime)

public static IObservable<T> Timeout<T>(IObservable<T> source, TimeSpan dueTime, ISequencer scheduler)

public static IObservable<long> Timer(TimeSpan dueTime)

public static IObservable<long> Timer(TimeSpan dueTime, ISequencer scheduler)

public static IObservable<long> Timer(DateTimeOffset dueTime)

public static IObservable<long> Timer(DateTimeOffset dueTime, ISequencer scheduler)

public static IObservable<long> Timer(TimeSpan dueTime, TimeSpan period)

public static IObservable<long> Timer(TimeSpan dueTime, TimeSpan period, ISequencer scheduler)

public static Task<TSource> ToTask<TSource>(IObservable<TSource> source)

public static Task<TSource> ToTask<TSource>(IObservable<TSource> source, CancellationToken cancellationToken)

public static IObservable<TResult> Unfold<TState, TResult>(TState initialState, Func<TState, bool> condition, Func<TState, TState> iterate, Func<TState, TResult> resultSelector)

public static IObservable<T> Use<TResource, T>(Func<TResource> resourceFactory, Func<TResource, IObservable<T>> signalFactory) where TResource : IDisposable

public static IObservable<T> Using<TResource, T>(Func<TResource> resourceFactory, Func<TResource, IObservable<T>> observableFactory) where TResource : IDisposable