예제 #1
0
        public void BeginListeningForBroadcasts()
        {
            var t = Task.Run(() =>
            {
                try
                {
                    while (!this.IsDisposed)
                    {
                        _BroadcastAvailableSignal.WaitOne();

                        if (this.IsDisposed)
                        {
                            break;
                        }

                        while (_ReceivedBroadcastsQueue.Any())
                        {
                            if (this.IsDisposed)
                            {
                                break;
                            }

                            var data           = _ReceivedBroadcastsQueue.Dequeue();
                            Action processWork = () => ProcessMessage(System.Text.UTF8Encoding.UTF8.GetString(data.Buffer, 0, data.ReceivedBytes), data.ReceivedFrom);
                            var processTask    = TaskEx.Run(processWork);
                        }
                        _BroadcastAvailableSignal.Reset();
                    }
                }
                catch (ObjectDisposedException) { }
            });
        }
예제 #2
0
        public void SendMulticastMessage(byte[] messageData)
        {
            SentBroadcasts.Enqueue(new ReceivedUdpData()
            {
                Buffer        = messageData,
                ReceivedBytes = messageData.Length,
                ReceivedFrom  = new UdpEndPoint()
                {
                    IPAddress = SsdpConstants.MulticastLocalAdminAddress,
                    Port      = SsdpConstants.MulticastPort
                }
            });

            if (_ListenTask == null)
            {
                _ListenTask = Task.Run(() =>
                {
                    try
                    {
                        while (!this.IsDisposed)
                        {
                            _MessageAvailableSignal.WaitOne();

                            if (this.IsDisposed)
                            {
                                break;
                            }

                            while (_ReceivedMessageQueue.Any())
                            {
                                if (this.IsDisposed)
                                {
                                    break;
                                }

                                var data           = _ReceivedMessageQueue.Dequeue();
                                Action processWork = () => ProcessMessage(System.Text.UTF8Encoding.UTF8.GetString(data.Buffer, 0, data.ReceivedBytes), data.ReceivedFrom);
                                var processTask    = TaskEx.Run(processWork);
                            }
                            _MessageAvailableSignal.Reset();
                        }
                    }
                    catch (ObjectDisposedException) { }
                    finally
                    {
                        _ListenTask = null;
                    }
                });
            }

            _BroadcastSentSignalTimer.Change(50, System.Threading.Timeout.Infinite);
            //_SentBroadcastSignal.Set();
        }
예제 #3
0
            public Task <ReceivedUdpData> ReceiveAsync()
            {
                var tcs = new TaskCompletionSource <ReceivedUdpData>();

                Task.Run(() =>
                {
                    try
                    {
                        var signal = _DataAvailableSignal;
                        if (!_ReceiveQueue.Any() && signal != null)
                        {
                            signal.WaitOne();
                        }

                        if (this.IsDisposed)
                        {
                            tcs.SetCanceled();
                        }
                        else
                        {
                            tcs.SetResult(_ReceiveQueue.Dequeue());

                            signal.Reset();
                        }
                    }
                    catch (ObjectDisposedException)
                    {
                        tcs.SetCanceled();
                    }
                });

                return(tcs.Task);
            }
예제 #4
0
        public void WaitForMockBroadcast(int timeoutMilliseconds)
        {
            if (!SentBroadcasts.Any())
            {
                _SentBroadcastSignal.Reset();
            }

            _SentBroadcastSignal.WaitOne(timeoutMilliseconds);
            _SentBroadcastSignal.Reset();
        }
예제 #5
0
        public bool WaitForMockMessage(int timeoutMilliseconds)
        {
            if (!SentMessages.Any())
            {
                _SentMessageSignal.Reset();
            }

            var retVal = _SentMessageSignal.WaitOne(timeoutMilliseconds);

            _SentMessageSignal.Reset();
            return(retVal);
        }
예제 #6
0
 public void SubmitChanges()
 {
     try
     {
         while (_cudActions.Any())
         {
             _cudActions.Dequeue()();
         }
         Debug.WriteLine("Änderungen an CanvasScriptServerUnitOfWorks übernommen. Anz:" + _UsersTab.Count);
     }
     catch (Exception ex)
     {
         throw new Exception(mko.TraceHlp.FormatErrMsg(this, "SubmitChanges"), ex);
     }
 }
예제 #7
0
            public Task <ReceivedUdpData> ReceiveAsync()
            {
                var tcs = new TaskCompletionSource <ReceivedUdpData>();

                Task.Run
                (
                    () =>
                {
                    try
                    {
                        var signal = _DataAvailableSignal;
                        if (!_ReceiveQueue.Any() && signal != null)
                        {
                            signal.WaitOne();
                        }

                        if (this.IsDisposed)
                        {
                            tcs.SetCanceled();
                        }
                        else
                        {
                            var message = _ReceiveQueue.Dequeue();
                            if (message.Buffer == null && message.ReceivedBytes == 0 && message.ReceivedFrom == null)
                            {
                                tcs.SetException(new SocketClosedException());
                            }
                            else
                            {
                                tcs.SetResult(message);
                            }

                            signal.Reset();
                        }
                    }
                    catch (ObjectDisposedException)
                    {
                        if (!tcs.Task.IsCompleted)
                        {
                            tcs.SetCanceled();
                        }
                    }
                }
                );

                return(tcs.Task);
            }