public Post ( SendOrPostCallback d, object state ) : void | ||
d | SendOrPostCallback | |
state | object | |
Résultat | void |
void Client_AddDiamondShoppingItemCompleted(object sender, Wcf.Clients.WebInvokeEventArgs <int> e) { try { App.BusyToken.CloseBusyWindow(); if (e.Error != null) { MyMessageBox.ShowInfo("保存钻石商品失败。原因为:" + e.Error.Message); return; } if (e.Result == OperResult.RESULTCODE_TRUE) { MyMessageBox.ShowInfo("保存钻石商品成功"); _syn.Post((o) => { this.Close(); }, null); } else { MyMessageBox.ShowInfo("保存钻石商品失败。原因为:" + OperResult.GetMsg(e.Result)); } } catch (Exception exc) { MyMessageBox.ShowInfo("保存钻石商品异常。原因为:" + exc.Message); } }
public static void ExecuteGaleryScrape(MainPage mainpage, SynchronizationContext context, Api.Parameter.OverviewParameter parameters = null) { if (parameters == null) parameters = new Api.Parameter.OverviewParameter(); context.Post((_) => { mainpage.SkoftenDataContext.GalleryItemsLoading = true; }, null); parameters.Type = mainpage.SkoftenDataContext.CurrentGalleryType; if (parameters.StartOver) { mainpage.SkoftenDataContext.GalleryPaging = 0; mainpage.SkoftenDataContext.GalleryItemIndex = 0; mainpage.SkoftenDataContext.SelectedGallery = 0; } parameters.Paging = mainpage.SkoftenDataContext.GalleryPaging; mainpage.SkoftenDataContext.GalleryPaging += 12; OverviewExecute oe = new OverviewExecute(); oe.Parameters = parameters; oe.Execute(); var result = oe.Result; context.Post((_) => { if(parameters.StartOver) { mainpage.SkoftenDataContext.Gallery.Clear(); } foreach (var item in result) { if(parameters.Type == Api.Parameter.OverviewType.EroDump) { if (!item.Url.Contains("babes.skoften.net")) { mainpage.SkoftenDataContext.GalleryItemIndex++; continue; } } item.Index = mainpage.SkoftenDataContext.GalleryItemIndex; mainpage.SkoftenDataContext.Gallery.Add(item); mainpage.SkoftenDataContext.GalleryItemIndex++; } mainpage.SkoftenDataContext.GalleryItemsLoading = false; }, null); }
public PresentationWindow(IMainWindowPresenter dataContext) { InitializeComponent(); context = SynchronizationContext.Current; // register callbacks for slide control dataContext.NextSlide += (o, args) => context.Post(state => NextSlide(), null); dataContext.PreviousSlide += (o, pres) => context.Post(state => PreviousSlide(), null); dataContext.SwitchPause += (o, pres) => context.Post(state => SwitchPause(), null); }
private async void MainWindow_Loaded(object sender, RoutedEventArgs e) { var deviceName = ConfigurationManager.AppSettings["DeviceName"]; device = PTZDevice.GetDevice(deviceName, PTZType.Relative); url = ConfigurationManager.AppSettings["relayServerUrl"]; remoteGroup = Environment.MachineName; //They have to hardcode the group, but for us it's our machine name connection = new HubConnection(url); proxy = connection.CreateHubProxy("RelayHub"); connection.TraceLevel = TraceLevels.StateChanges | TraceLevels.Events; connection.TraceWriter = new PTZRemoteTraceWriter(Log); //Can't do this here because DirectShow has to be on the UI thread! // This would cause an obscure COM casting error with no clue what's up. So, um, ya. //proxy.On<int, int>("Move",(x,y) => device.Move(x, y)); //proxy.On<int>("Zoom", (z) => device.Zoom(z)); magic = SynchronizationContext.Current; proxy.On<int, int>("Move", (x, y) => { //Toss this over the fence from this background thread to the UI thread magic.Post((_) => { Log(String.Format("Move({0},{1})", x,y)); device.Move(x, y); }, null); }); proxy.On<int>("Zoom", (z) => { magic.Post((_) => { Log(String.Format("Zoom({0})", z)); device.Zoom(z); }, null); }); try { await connection.Start(); Log("After connection.Start()"); await proxy.Invoke("JoinRelay", remoteGroup); Log("After JoinRelay"); } catch (Exception pants) { Log(pants.GetError().ToString()); throw; } }
public static void ExecuteGaleryScrape(MainPage mainpage, SynchronizationContext context, Api.Parameter.OverviewParameter parameters = null) { if (parameters == null) parameters = new Api.Parameter.OverviewParameter(); context.Post((_) => { mainpage.PageDataContext.GalleryItemsLoading = true; if (parameters.StartOver) mainpage.PageDataContext.Gallery.Clear(); }, null); parameters.Category = mainpage.PageDataContext.CurrentArticleGallery; if (parameters.StartOver) { mainpage.PageDataContext.GalleryPaging = -1; mainpage.PageDataContext.GalleryItemIndex = 0; mainpage.PageDataContext.SelectedGallery = 0; } mainpage.PageDataContext.GalleryPaging += 1; parameters.Paging = mainpage.PageDataContext.GalleryPaging; OverviewExecute oe = new OverviewExecute(); oe.Parameters = parameters; oe.Execute(); var result = oe.Result; context.Post((_) => { if (parameters.StartOver) { mainpage.PageDataContext.Gallery.Clear(); } foreach (var item in result) { item.Index = mainpage.PageDataContext.GalleryItemIndex; mainpage.PageDataContext.Gallery.Add(item); mainpage.PageDataContext.GalleryItemIndex++; } mainpage.PageDataContext.GalleryItemsLoading = false; }, null); }
public ToolStripGitStatus() { syncContext = SynchronizationContext.Current; gitGetUnstagedCommand.Exited += (o, ea) => syncContext.Post(_ => onData(), null); InitializeComponent(); Settings.WorkingDirChanged += Settings_WorkingDirChanged; GitUICommands.Instance.PreCheckoutBranch += GitUICommands_PreCheckout; GitUICommands.Instance.PreCheckoutRevision += GitUICommands_PreCheckout; GitUICommands.Instance.PostCheckoutBranch += GitUICommands_PostCheckout; GitUICommands.Instance.PostCheckoutRevision += GitUICommands_PostCheckout; // Setup a file watcher to detect changes to our files, or the .git repo files. When they // change, we'll update our status. watcher.Changed += watcher_Changed; watcher.Created += watcher_Changed; watcher.Deleted += watcher_Changed; watcher.Error += watcher_Error; watcher.IncludeSubdirectories = true; try { watcher.Path = Settings.WorkingDir; watcher.EnableRaisingEvents = true; } catch { } update(); }
public ToolStripGitStatus() { syncContext = SynchronizationContext.Current; gitGetUnstagedCommand.Exited += new EventHandler(delegate(object o, EventArgs ea) { syncContext.Post(_ => onData(), null); }); InitializeComponent(); Settings.WorkingDirChanged += new Settings.WorkingDirChangedHandler(Settings_WorkingDirChanged); // Setup a file watcher to detect changes to our files, or the .git repo files. When they // change, we'll update our status. watcher.Changed += new FileSystemEventHandler(watcher_Changed); watcher.Created += new FileSystemEventHandler(watcher_Changed); watcher.Deleted += new FileSystemEventHandler(watcher_Changed); watcher.Error += new ErrorEventHandler(watcher_Error); watcher.IncludeSubdirectories = true; try { watcher.Path = Settings.WorkingDir; watcher.EnableRaisingEvents = true; } catch { } update(); }
public InboxViewModel(IEmailService emailService, IRegionManager regionManager) { synchronizationContext = SynchronizationContext.Current ?? new SynchronizationContext(); _composeMessageCommand = new DelegateCommand<object>(ComposeMessage); _replyMessageCommand = new DelegateCommand<object>(ReplyMessage, CanReplyMessage); _openMessageCommand = new DelegateCommand<EmailDocument>(OpenMessage); messagesCollection = new ObservableCollection<EmailDocument>(); Messages = new CollectionView(this.messagesCollection); Messages.CurrentChanged += (s, e) => _replyMessageCommand.RaiseCanExecuteChanged(); _emailService = emailService; _regionManager = regionManager; if (_emailService != null) { _emailService.BeginGetEmailDocuments( r => { var messages = _emailService.EndGetEmailDocuments(r); synchronizationContext.Post( s => { foreach (var message in messages) { messagesCollection.Add(message); } }, null); }, null); } }
public ToolStripGitStatus() { syncContext = SynchronizationContext.Current; gitGetUnstagedCommand.Exited += (o, ea) => syncContext.Post(_ => onData(), null); InitializeComponent(); CommitTranslatedString = "Commit"; Settings.WorkingDirChanged += (_, newDir, newGitDir) => TryStartWatchingChanges(newDir, newGitDir); GitUICommands.Instance.PreCheckoutBranch += GitUICommands_PreCheckout; GitUICommands.Instance.PreCheckoutRevision += GitUICommands_PreCheckout; GitUICommands.Instance.PostCheckoutBranch += GitUICommands_PostCheckout; GitUICommands.Instance.PostCheckoutRevision += GitUICommands_PostCheckout; // Setup a file watcher to detect changes to our files. When they // change, we'll update our status. watcher.Changed += watcher_Changed; watcher.Created += watcher_Changed; watcher.Deleted += watcher_Changed; watcher.Error += watcher_Error; watcher.IncludeSubdirectories = true; watcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.LastWrite; // Setup a file watcher to detect changes to the .git repo files. When they // change, we'll update our status. gitDirWatcher.Changed += gitWatcher_Changed; gitDirWatcher.Created += gitWatcher_Changed; gitDirWatcher.Deleted += gitWatcher_Changed; gitDirWatcher.Error += watcher_Error; gitDirWatcher.IncludeSubdirectories = true; gitDirWatcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.LastWrite; TryStartWatchingChanges(Settings.WorkingDir, Settings.Module.GetGitDirectory()); }
/// <summary>Throws the exception on the thread pool.</summary> /// <param name="exception">The exception to propagate.</param> /// <param name="targetContext"> /// The target context on which to propagate the exception; otherwise, <see langword="null"/> to use the thread /// pool. /// </param> internal static void ThrowAsync(Exception exception, SynchronizationContext targetContext) { if (targetContext != null) { try { targetContext.Post( state => { throw PrepareExceptionForRethrow((Exception)state); }, exception); return; } catch (Exception ex) { exception = new AggregateException(exception, ex); } } #if NET45PLUS Task.Run(() => { throw PrepareExceptionForRethrow(exception); }); #else ThreadPool.QueueUserWorkItem(state => { throw PrepareExceptionForRethrow((Exception)state); }, exception); #endif }
/// <summary>Throws the exception on the thread pool.</summary> /// <param name="exception">The exception to propagate.</param> /// <param name="targetContext"> /// The target context on which to propagate the exception; otherwise, <see langword="null"/> to use the thread /// pool. /// </param> internal static void ThrowAsync(Exception exception, SynchronizationContext targetContext) { // If the user supplied a SynchronizationContext... if (targetContext != null) { try { // Post the throwing of the exception to that context, and return. targetContext.Post(state => { throw PrepareExceptionForRethrow((Exception)state); }, exception); return; } catch (Exception postException) { // If something goes horribly wrong in the Post, we'll propagate both exceptions on the thread pool exception = new AggregateException(exception, postException); } } #if NET45PLUS Task.Run(() => { throw PrepareExceptionForRethrow(exception); }); #else // Propagate the exception(s) on the ThreadPool ThreadPool.QueueUserWorkItem(state => { throw PrepareExceptionForRethrow((Exception)state); }, exception); #endif }
private static CancellableTimout ScheduleInternal(Action action, int delay, SynchronizationContext syncCtx) { var c = new CancellableTimout(); c.action = action; c.syncCtx = syncCtx; var t = new Timer(state => { var cc = (CancellableTimout)state; var a = cc.action; if (a != null) { if (cc.syncCtx != null) { syncCtx.Post(new SendOrPostCallback(z => { using (cc) { if (cc.action != null) a(); } }), null); return; } else { a(); } } cc.Dispose(); }, c, delay, Timeout.Infinite); c.timer = t; c.delay = delay; return c; }
internal static void ThrowAsync(Exception exception, SynchronizationContext targetContext) { if (targetContext != null) { try { targetContext.Post(delegate(object state) { throw AsyncServices.PrepareExceptionForRethrow((Exception)state); }, exception); return; } catch (Exception ex) { exception = new AggregateException(new Exception[] { exception, ex }); } } ThreadPool.QueueUserWorkItem(delegate(object state) { throw AsyncServices.PrepareExceptionForRethrow((Exception)state); }, exception); }
int DoSign(IEnumerable<Artifact> artifacts, SynchronizationContext sc) { var restApi = new RallyRestApi(Settings.Default.RallyUser, Settings.Default.RallyPassword //, proxy: new WebProxy("localhost:8888", false) ); foreach (var tagArt in artifacts) { var toCreate = new DynamicJsonObject(); toCreate["Text"] = "%FIX_CODE_REVIEW_PASSED%"; toCreate["Artifact"] = tagArt.Reference; var createResult = restApi.Create("ConversationPost", toCreate); // update status sc.Post(_ => { var lvi = listViewArtifacts.Items.Cast<ListViewItem>().FirstOrDefault(l => l.Tag == tagArt); if (!createResult.Success) { lvi.BackColor = Color.Tomato; if (createResult.Errors.Count > 0) lvi.SubItems[1].Text = createResult.Errors[0]; else lvi.SubItems[1].Text = "Unexpected error"; } else { lvi.BackColor = Color.LightGreen; lvi.SubItems[3].Text = "✔"; } }, null); } return 0; }
public void addToLog(string description) { // The UI thread won't be handling the callback, but it is the only one allowed to update the controls. // So, we will dispatch the UI update back to the UI sync context. //Create a SendOrPostCallback delegate with an anon method which recieves an Object called state and runs code in the SychronisationContext it is marshalled to using Post SendOrPostCallback callback = delegate(object state) { //state is a string object. mainForm.updateTextBoxLog(state.ToString()); }; //Post takes a delagate and a State object and runs the delegate(State object) in the context Post is called on. _uiSyncContext.Post(callback, description); }
/// <summary> /// 处理连接关闭事件 /// </summary> /// <param name="e"></param> /// <param name="context"></param> protected virtual void InvokeConnectionClosed(SocketModuleEventArgs e, SynchronizationContext context) { if (null != context) context.Post(HandlerConnectionClosed, e); else HandlerConnectionClosed(e); }
public async void CarregaTirinhas() { synchronizationContext = SynchronizationContext.Current; var p = new PostsService(); var tirinhas = await p.GetPosts(0, tirinha => true); foreach (var tirinha in tirinhas) synchronizationContext.Post(state => { Tirinhas.Add(tirinha); }, null); }
void GambleStoneVMObject_GambleStoneGetRoundInfoEvent(GambleStoneRoundInfo obj) { _syn.Post(o => { for (int i = 0; i < obj.WinColorItems.Length; i++) { BitmapImage bmp = null; switch ((GambleStoneItemColor)obj.WinColorItems[i]) { case GambleStoneItemColor.Red: //bmp = new BitmapImage(new Uri(@"../../Resources/gamblered.png", UriKind.Relative)); bmp = bmpRed; break; case GambleStoneItemColor.Green: //bmp = new BitmapImage(new Uri(@"../../Resources/gamblegreen.png", UriKind.Relative)); bmp = bmpGreen; break; case GambleStoneItemColor.Blue: //bmp = new BitmapImage(new Uri(@"../../Resources/gambleblue.png", UriKind.Relative)); bmp = bmpBlue; break; case GambleStoneItemColor.Purple: //bmp = new BitmapImage(new Uri(@"../../Resources/gambleyellow.png", UriKind.Relative)); bmp = bmpPurple; break; default: break; } this._WinnedColorItem[i].Source = bmp; if (bmp == null) { this._WinnedColorItem[i].Visibility = System.Windows.Visibility.Collapsed; } else { this._WinnedColorItem[i].Visibility = System.Windows.Visibility.Visible; } } GC.Collect(); }, null); }
static void PrintOnDifferentThread() { for (int i = 0; i <= 10; i++) { Console.WriteLine(string.Format("{0}", i.ToString(System.Globalization.NumberFormatInfo.CurrentInfo))); } _synchObject.Post((x) => { Console.WriteLine("djsfkajdskfjasdlkf"); }, null); }
private void Update(SynchronizationContext context, CancellationToken token) { // this loop runs on a worker thread while (!token.IsCancellationRequested) { context.Post(_ => this.UpdatePlot(), null); Thread.Sleep(250); } }
public MainWindow() { InitializeComponent(); _uiContext = SynchronizationContext.Current; _neovim = new NeovimClient(@"C:\Program Files\Neovim\bin\nvim.exe"); // Event is asynchronous so we need to handle the redraw event in the UI thread _neovim.Redraw += (o, args) => _uiContext.Post((x) => NeovimOnRedraw(o, args), null); _neovim.ui_attach(_columns, _rows, true); }
protected void InvokeIfRequired(SynchronizationContext context, SendOrPostCallback action) { if (SynchronizationContext.Current == context) { action(new Object()); } else { context.Post(action, new Object()); } }
public static void ExecuteSingleArticleScrape(MainPage mainpage, SynchronizationContext theContext, OverviewResult search) { theContext.Post((_) => { mainpage.Pivot.SelectedIndex = 1; mainpage.PageDataContext.ArticleLoading = true; mainpage.PageDataContext.Articles.Clear(); }, null); ArticleExecute execute = new ArticleExecute(); execute.Parameters.Url = "http://www.trending.nl/" + search.Url; execute.Parameters.Type = mainpage.PageDataContext.CurrentArticleGallery; execute.Execute(); var article = execute.Result; theContext.Post((_) => { mainpage.PageDataContext.InitializeNewArticle(article); }, null); }
public static void ExecuteSingleDumpScrape(MainPage mainpage, SynchronizationContext theContext, OverviewResult search) { theContext.Post((_) => { mainpage.Pivot.SelectedIndex = 1; mainpage.SkoftenDataContext.DumpItemsLoading = true; mainpage.SkoftenDataContext.DumpItems.Clear(); }, null); DumpExecute execute = new DumpExecute(); execute.Parameters.Url = search.Url; execute.Parameters.Type = mainpage.SkoftenDataContext.CurrentGalleryType; execute.Execute(); var dumpItems = execute.Result; theContext.Post((_) => { mainpage.SkoftenDataContext.InitializeNewDumpList(dumpItems); }, null); }
internal static void SetUiContext(SynchronizationContext synchronizationContext) { _onUiExec = action => { if (_isUiThread) action(); else synchronizationContext.Post(e => action(), null); }; OnUiThread(() => _isUiThread = true); }
void OnDownloadComplete(string filename) { EventHandler <downloadCompleteEventArgs> temp = downloadComplete; if (temp != null) { downloadCompleteEventArgs e = new downloadCompleteEventArgs(); e.filename = filename; context.Post(delegate(object state) { downloadComplete(this, e); }, null); } }
public EnableControlCommand(Control control, Fact canExecute) { this.control = control; this.canExecute = canExecute; ctx = AsyncOperationManager.SynchronizationContext; if (canExecute != null) { this.canExecute.PropertyChanged += (sender, args) => ctx.Post(x => control.Enabled = canExecute.Value, null); } }
private void LoadingVisible(System.Threading.SynchronizationContext sync, bool val) { sync.Post(new System.Threading.SendOrPostCallback(delegate { this.elementHost1.Visible = val; if (val) { this.elementHost1.BringToFront(); } else { this.elementHost1.SendToBack(); } }), null); }
internal static void OnCompletedInternal(Task t, Action continuation, SynchronizationContext capturedContext) { t.OnCompleted(() => { if (capturedContext == null) { continuation(); } else { capturedContext.Post(state => ((Action)state)(), continuation); } }); }
private async void MainWindow_Loaded(object sender, RoutedEventArgs e) { var deviceName = ConfigurationManager.AppSettings["DeviceName"]; device = PTZDevice.GetDevice(deviceName, PTZType.Relative); url = ConfigurationManager.AppSettings["relayServerUrl"]; remoteGroup = Environment.MachineName; //They have to hardcode the group, but for us it's our machine name connection = new HubConnection(url); proxy = connection.CreateHubProxy("RelayHub"); connection.TraceLevel = TraceLevels.StateChanges | TraceLevels.Events; connection.TraceWriter = new PTZRemoteTraceWriter(Log); magic = SynchronizationContext.Current; proxy.On<int, int>("Move", (x, y) => magic.Post((_) => { Log(String.Format("Move({0},{1})", x, y)); device.Move(x, y); }, null)); proxy.On<int>("Zoom", (z) => magic.Post((_) => { Log(String.Format("Zoom({0})", z)); device.Zoom(z); }, null)); try { await connection.Start(); Log("After connection.Start()"); await proxy.Invoke("JoinRelay", remoteGroup); Log("After JoinRelay"); Log("Joined remote group - " + remoteGroup); } catch (Exception pants) { Log(pants.GetError().ToString()); throw; } }
private void Do(SynchronizationContext sc, IEnumerable<Tuple<string, Action>> actions, ref int failures) { foreach (var a in actions) { try { a.Item2(); } catch (Exception e) { failures++; var exn = e is TargetInvocationException ? e.InnerException : e; var message = a.Item1 + " failed:" + exn.Message; sc.Post(state => { testResults.Items.Add(message); }, null); return; } } }
private async void OnMessage(object sender, MessageEventArgs e) { Message msg = e.Message; if (msg == null || msg.Type != MessageType.Text) { return; } _masseges.Id = e.Message.Chat.Id.ToString(); _masseges.UserName = e.Message.Chat.Username; _masseges.FirstName = e.Message.Chat.FirstName; _masseges.LastName = e.Message.Chat.LastName; _masseges.Date = DateTime.Now; _masseges.Content = e.Message.Text; _masseges.Type = DisBotMessage.MessageType.OutMessage; _synchronizationContext.Post(obj => Log?.Invoke(_masseges), null); await _botclient.SendTextMessageAsync(chatId : e.Message.Chat, text : StaticLogicBot.UserInfo.UserLogin); }
void Instance_LogAdded(bool isError, string log) { lock (_lockListLogs) { if (isError) { _syn.Post(o => { if (ListErrorLogsOutput.Count >= MAXLISTERRORLOGSCOUNT) { for (int i = 0; i < 10; i++) { ListErrorLogsOutput.RemoveAt(ListErrorLogsOutput.Count - 1); } } ListErrorLogsOutput.Insert(0, log); }, null); } } }
public static async Task DownloadHTMLAsync(SynchronizationContext sc, string url, WebBrowser toSet) { HttpClient client = new HttpClient(); HttpResponseMessage response = await client.GetAsync(url); string content = await response.Content.ReadAsStringAsync(); sc.Post(rawState => { string strToRemove = "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\" \"http://www.w3.org/TR/html4/strict.dtd\">"; string parsedState = ((string)rawState).Replace(strToRemove, "").Trim(); HtmlDocument document = new HtmlDocument(); document.LoadHtml(parsedState); HtmlNode collection = document.GetElementbyId("fw-mainColumn"); toSet.NavigateToString(collection.InnerHtml); }, content); }
internal static void ThrowAsync(Exception exception, SynchronizationContext targetContext) { if (exception == null) return; // TODO - decide how to cleanly do it so it lights up if TA is defined //if (exception is ThreadAbortException) // return; ExceptionDispatchInfo exceptionDispatchInfo = ExceptionDispatchInfo.Capture(exception); if (targetContext != null) { try { targetContext.Post((edi) => ((ExceptionDispatchInfo)edi).Throw(), exceptionDispatchInfo); } catch { // Something went wrong in the Post; let's try using the thread pool instead: ThrowAsync(exception, null); } return; } bool scheduled = true; try { new SynchronizationContext().Post((edi) => ((ExceptionDispatchInfo)edi).Throw(), exceptionDispatchInfo); } catch { // Something went wrong when scheduling the thrower; we do our best by throwing the exception here: scheduled = false; } if (!scheduled) exceptionDispatchInfo.Throw(); }
async public void makeConnection() { try { var hubConnection = new HubConnection("http://bananasvc.azurewebsites.net"); chat = hubConnection.CreateHubProxy("ChatHub"); Context = SynchronizationContext.Current; chat.On<string, string>("broadcastMessage", (name, message) => Context.Post(delegate { if (message.Equals("200")) tbstatus.Text = "Elevador Chegou!!!"; }, null) ); await hubConnection.Start(); } catch (Exception ex) { } }
protected bool IfReceived(SerialPortManager sp, ProtocolBase protocol, IOBuffer buffer, SynchronizationContext syncContext) { byte receivedByte; if (sp.ReadByte(out receivedByte)) { switch (step) { case 0: if (receivedByte == protocol.Header) { step++; buffer[counterOfTheReceivedBytes++] = receivedByte; } break; case 1: if ((receivedByte & 0x80) == 0x80) RestartReceiv(); else { buffer[counterOfTheReceivedBytes++] = receivedByte; if (counterOfTheReceivedBytes == buffer.Size) { if (protocol.UnPack(buffer)) { syncContext.Post(delegate { logger.Log(string.Format("Rx: {0}", buffer.ToString()), Category.Debug, Priority.None); }, null); return true; } else RestartReceiv(); } } break; } } return false; }
async private void makeConnection() { try { var hubConnection = new HubConnection("http://bananasvc.azurewebsites.net"); chat = hubConnection.CreateHubProxy("ChatHub"); Context = SynchronizationContext.Current; chat.On<string, string>("broadcastMessage", (name, message) => Context.Post(delegate { if (message.Equals("100")) CallElevator(); }, null) ); await hubConnection.Start(); //await chat.Invoke("Notify", chatName.Text, hubConnection.ConnectionId); } catch (Exception ex) { } }
void ListTodayRealTimeTradeRecords_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) { StoneStackDailyRecordInfo newItem = null; if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Reset) { _listTodayMinuteTradeRecords.Clear(); _needRendAll = true; } if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Add) { if (e.NewItems == null || e.NewItems.Count == 0) { return; } newItem = e.NewItems[0] as StoneStackDailyRecordInfo; if (newItem == null) { return; } //_needRendAll = true; if (this._listTodayMinuteTradeRecords.Count == 0) { this._listTodayMinuteTradeRecords.Add(newItem); } else { var lastRecord = this._listTodayMinuteTradeRecords[this._listTodayMinuteTradeRecords.Count - 1]; if (lastRecord.Day.Hour == newItem.Day.Hour && lastRecord.Day.Minute == newItem.Day.Minute) { this._listTodayMinuteTradeRecords[this._listTodayMinuteTradeRecords.Count - 1] = newItem; this._addItem = false; } else { this._listTodayMinuteTradeRecords.Add(newItem); this._addItem = true; } } if (this.OpenPrice != newItem.OpenPrice) { this._needRendAll = true; } this.OpenPrice = newItem.OpenPrice; double newRangeValue = Math.Abs(Math.Round((double)(newItem.ClosePrice - newItem.OpenPrice), 2)); if (newRangeValue > this._maxRangeValue) { _needRendAll = true; this._maxRangeValue = newRangeValue; } } _syn.Post(o => { if (_needRendAll) { Draw(); } else { if (newItem != null && newItem.Day != null) { Point newPoint = ConvertStoneStackDailyRecordInfoToPoint(newItem); if (this._addItem) { this.polyLine.Points.Add(newPoint); } else { if (this.polyLine.Points.Count == 0) { this.polyLine.Points.Add(newPoint); } else { this.polyLine.Points[this.polyLine.Points.Count - 1] = newPoint; } } } } }, null); }
static public void Thread(System.Threading.SynchronizationContext context, ThreadCallbackType callback) { context.Post(( object state ) => { callback(); }, null); }
public void Post(SendOrPostCallback sendOrPostCallback, object state) { synchronizationContext.Post(sendOrPostCallback, state); }
public void BroadcastToClient(EventDataType eventData) { syncContext.Post(new System.Threading.SendOrPostCallback(OnBroadcast), eventData); }
private void ThreadRunForMethodOne(object state) { m_SyncContext.Post(SendOrPostCallback, state); }