void RegisterCaches()
{
_cacheScheduler = TaskPoolScheduler.Default;
Container.RegisterInitializer <IBlobCache>(RegisterCache);
RegisterMemoryCaches();
RegisterLocalCaches();
RegisterRoamingCaches();
}
public RxSocket(ISocket socket, IParser parser, IMessageFormatter <TPayload> formatter)
{
_socket = socket;
_parser = parser;
_formatter = formatter;
_socket.WhenMessageParsed.Subscribe(bytes => _formatter.FormatMessageAsync(bytes));
_whenMessageReceived = new Subject <TPayload>();
_whenMessageSent = new Subject <TPayload>();
_factoryScheduler = new TaskPoolScheduler(Task.Factory);
_formatter.WhenNewMessage.Subscribe(message => _whenMessageReceived.OnNext(message));
}
public async Task Listen(IByteReceiver byteReceiver,
IStreamFactory streamFactory,
string destinationPath = "",
CancellationToken cancellationToken = default)
{
var observableScheduler =
new TaskPoolScheduler(new TaskFactory(cancellationToken)); //Scheduler.Default; //
await Listen(byteReceiver,
streamFactory,
observableScheduler,
destinationPath,
cancellationToken).ConfigureAwait(false);
}
/**
* Scheduler控制订阅和通知的发送。
* Scheduler包含三个组件：1）一个优先队列存放任务，2）Execution context，用来决定任务在哪执行（线程池，当前线程）3)scheduler的时钟，Task是根据这个时钟调度的，不是系统时钟。
*
* rx中所有的Scheduler实现IScheduler接口。
*
*/
public static void GetSchedulers()
{
//立刻在当前线程上执行
ImmediateScheduler immediate = Scheduler.Immediate;
//在当前线程上尽可能快的执行(先放到队列中，尽快执行)
CurrentThreadScheduler currentThreadScheduler = Scheduler.CurrentThread;
//每次创建一个线程执行
NewThreadScheduler newThreadScheduler = NewThreadScheduler.Default;
//在Task Factory上执行
TaskPoolScheduler taskPoolScheduler = TaskPoolScheduler.Default;
//在当前Dispatcher上执行任务
DispatcherScheduler dispatcherScheduler = DispatcherScheduler.Current;
//在ThreadPool上执行
ThreadPoolScheduler threadPoolScheduler = ThreadPoolScheduler.Instance;
//默认的调度器 其原则是使用最小的并行性，for operators returning an observable with a finite and small number of messages, Rx calls Immediate. For operators returning a potentially large or infinite number of messages, CurrentThread is called. For operators which use timers, ThreadPool is used.
DefaultScheduler defaultScheduler = Scheduler.Default;
}
/// <summary>
/// The pump for received messages.
/// </summary>
/// <param name="uri">
/// The uri.
/// </param>
/// <param name="cancellation">
/// The cancellation token source.
/// </param>
/// <returns>
/// The observable stream of messages.
/// </returns>
private static IObservableSocket CreateObservableSocket(Uri uri, CancellationTokenSource cancellation)
{
var status = new ReplaySubject <ConnectionStatus>(1);
var socket = new WebSocket4Net.WebSocket(uri.ToString());
var connected = new TaskCompletionSource <int>();
var dispatcher = new ConcurrentExclusiveSchedulerPair();
var sendScheduler = new TaskPoolScheduler(new TaskFactory(dispatcher.ExclusiveScheduler));
var receiveScheduler = new TaskPoolScheduler(new TaskFactory(dispatcher.ConcurrentScheduler));
Func <string, Task> send = message =>
{
var tcs = new TaskCompletionSource <int>();
sendScheduler.Schedule(
() =>
{
try
{
if (socket.State != WebSocket4Net.WebSocketState.Open)
{
socket.Open();
}
socket.Send(message);
tcs.SetResult(0);
}
catch (Exception e)
{
tcs.SetException(e);
}
});
;
return(tcs.Task);
};
socket.Open();
var incoming = Observable.Create <string>(
observer =>
{
status.OnNext(ConnectionStatus.Connecting);
var completed = false;
EventHandler <WebSocket4Net.MessageReceivedEventArgs> onMessage = (sender, args) => observer.OnNext(args.Message);
EventHandler <ws::SuperSocket.ClientEngine.ErrorEventArgs> onError = (sender, args) =>
{
observer.OnError(args.Exception);
completed = true;
cancellation.Cancel();
};
EventHandler onClosed = (sender, args) => cancellation.Cancel();
socket.MessageReceived += onMessage;
socket.Error += onError;
socket.Closed += onClosed;
socket.Opened += (sender, args) => connected.TrySetResult(0);
cancellation.Token.Register(
() =>
{
if (!completed)
{
observer.OnCompleted();
}
socket.MessageReceived -= onMessage;
socket.Error -= onError;
socket.Closed -= onClosed;
try
{
socket.Close();
}
catch
{
// Ignore errors closing the socket.
}
dispatcher.Complete();
});
return(Disposable.Create(cancellation.Cancel));
}).SubscribeOn(receiveScheduler).Publish().RefCount();
return(new ObservableSocket(incoming, send, status, connected.Task));
}
