public LatencyViewModel() { var mapper = Mappers.Xy <LatencyModel>() .X(model => model.DateTime.Ticks) .Y(model => model.Value); Charting.For <LatencyModel>(mapper); ChartValues = new ChartValues <LatencyModel>(); DateTimeFormatter = value => new DateTime((long)value).ToString("mm:ss"); CpuFormatter = value => String.Format("{0}%", value.ToString()); AxisStep = TimeSpan.FromSeconds(1).Ticks; AxisUnit = TimeSpan.TicksPerSecond; SetAxisLimits(DateTime.Now); IsReading = false; // 新建一个进程获取网络监控信息 IsReading = !IsReading; // start a task with a means to do a hard abort (unsafe!) Cts = new CancellationTokenSource(); Ct = Cts.Token; if (IsReading) { Task.Factory.StartNew(Read, Ct); } //获取事件聚合器, 连接成功时开始监控 eventAggregator = ServiceLocator.Current.GetInstance <IEventAggregator>(); ConnectedEvent e = eventAggregator.GetEvent <ConnectedEvent>(); e.Subscribe(GetConfig, ThreadOption.UIThread); }
/// <summary> /// Create a rx mqtt client based on a <see cref="IManagedMqttClient"/>. /// </summary> /// <param name="managedMqttClient">The manged mqtt client.</param> /// <param name="logger">The mqtt net logger.</param> /// <remarks> /// Use the <see cref="MqttFactoryExtensions.CreateRxMqttClient(IMqttFactory)"/> or /// <see cref="MqttFactoryExtensions.CreateRxMqttClient(IMqttFactory, IMqttNetLogger)"/> /// factory methods to crate the client. /// </remarks> /// <exception cref="ArgumentNullException"></exception> public RxMqttClient(IManagedMqttClient managedMqttClient, IMqttNetLogger logger) { InternalClient = managedMqttClient ?? throw new ArgumentNullException(nameof(managedMqttClient)); if (logger == null) { throw new ArgumentNullException(nameof(logger)); } this.logger = logger.WithSource(nameof(RxMqttClient)); topicSubscriptionCache = new Dictionary <string, IObservable <MqttApplicationMessageReceivedEventArgs> >(); var cancelationSubject = new Subject <Unit>(); ConnectedEvent = CrateFromHandler <MqttClientConnectedEventArgs>(observer => { managedMqttClient.UseConnectedHandler(args => observer.OnNext(args)); return(Disposable.Create(() => managedMqttClient.ConnectedHandler = null)); }); DisconnectedEvent = CrateFromHandler <MqttClientDisconnectedEventArgs>(observer => { managedMqttClient.UseDisconnectedHandler(args => observer.OnNext(args)); return(Disposable.Create(() => managedMqttClient.DisconnectedHandler = null)); }); ConnectingFailedEvent = CrateFromHandler <ManagedProcessFailedEventArgs>(observer => { managedMqttClient.ConnectingFailedHandler = new ConnectingFailedHandlerDelegate(args => observer.OnNext(args)); return(Disposable.Create(() => managedMqttClient.ConnectingFailedHandler = null)); }); SynchronizingSubscriptionsFailedEvent = CrateFromHandler <ManagedProcessFailedEventArgs>(observer => { managedMqttClient.SynchronizingSubscriptionsFailedHandler = new SynchronizingSubscriptionsFailedHandlerDelegate(args => observer.OnNext(args)); return(Disposable.Create(() => managedMqttClient.SynchronizingSubscriptionsFailedHandler = null)); }); ApplicationMessageProcessedEvent = CrateFromHandler <ApplicationMessageProcessedEventArgs>(observer => { managedMqttClient.ApplicationMessageProcessedHandler = new ApplicationMessageProcessedHandlerDelegate(args => observer.OnNext(args)); return(Disposable.Create(() => managedMqttClient.ApplicationMessageReceivedHandler = null)); }); ApplicationMessageSkippedEvent = CrateFromHandler <ApplicationMessageSkippedEventArgs>(observer => { managedMqttClient.ApplicationMessageSkippedHandler = new ApplicationMessageSkippedHandlerDelegate(args => observer.OnNext(args)); return(Disposable.Create(() => managedMqttClient.ApplicationMessageReceivedHandler = null)); }); Connected = Observable .Create <bool>(observer => { var connected = ConnectedEvent.Subscribe(_ => observer.OnNext(true)); var disconnected = DisconnectedEvent.Subscribe(_ => observer.OnNext(false)); return(new CompositeDisposable(connected, disconnected)); }) .TakeUntil(cancelationSubject) // complete on dispose .Prepend(IsConnected) // start with current state .Append(false) // finish with false .Replay(1) // replay last state on subscribe .RefCount(); // count subscriptions and dispose source observable when no subscription applicationMessageReceived = CrateFromHandler <MqttApplicationMessageReceivedEventArgs>(observer => { managedMqttClient.UseApplicationMessageReceivedHandler(args => observer.OnNext(args)); return(Disposable.Create(() => managedMqttClient.ApplicationMessageReceivedHandler = null)); }); IObservable <T> CrateFromHandler <T>(Func <IObserver <T>, IDisposable> func) { return(Observable.Create(func) .TakeUntil(cancelationSubject) // complete on dispose .Publish() // publish from on source observable .RefCount()); // count subscriptions and dispose source observable when no subscription } cleanUp = Disposable.Create(() => { cancelationSubject.OnNext(Unit.Default); // complete all observers cancelationSubject.Dispose(); try { managedMqttClient.Dispose(); } catch { } }); }