public void Dispose() { foreach (EventHandler e in DataReady.GetInvocationList()) { DataReady -= e; } }
//When ReceiverClient events private void OnReceiverClientEvent(object sender, DataEventArgs e) { foreach (var track in e.Tracks) { // Look for track in list of tracks in airspace var foundTrack = _airCraftsInAirspaceList.Find(ByTag(track.Tag)); Track trackToValidate = null; // If already in list - update speed and coordinates. if (foundTrack != null) { double trackSeconds = (track.Time.Minute * 60) + track.Time.Second; double foundTrackSeconds = (foundTrack.Time.Minute * 60) + foundTrack.Time.Second; // Workaround TimeSpan differenceTime = track.Time.Subtract(foundTrack.Time); var velocity = _trackCalculator.CalculateVelocity(foundTrack.XCoordinate, track.XCoordinate, foundTrack.YCoordinate, track.YCoordinate, foundTrack.Altitude, track.Altitude, 0, differenceTime.TotalSeconds); var compassCourse = _trackCalculator.CalculateCourse(foundTrack.XCoordinate, track.XCoordinate, foundTrack.YCoordinate, track.YCoordinate); var newTrack = new Track(foundTrack.Tag, track.XCoordinate, track.YCoordinate, track.Altitude, track.Time, velocity, compassCourse); _airCraftsInAirspaceList.Remove(foundTrack); _airCraftsInAirspaceList.Add(newTrack); trackToValidate = newTrack; } // If not in list - add it This should be tested - intellisense says expression is always true else if (foundTrack == null) { _airCraftsInAirspaceList.Add(track); trackToValidate = track; } // If outside airspace, remove it. bool inAirSpace = _monitoredAirspace.ValidateAirspace(trackToValidate); if (!inAirSpace) { _airCraftsInAirspaceList.Remove(trackToValidate); } } // Pass on Tracks in monitored airspace if not empty if (_airCraftsInAirspaceList.Count != 0) { var args = new ATMSEventArgs(); args.Tracks = _airCraftsInAirspaceList; // Raise event if somebody has "subscribed" to it DataReady?.Invoke(this, args); } }
public PipelineReader(System.Management.Automation.Runspaces.PipelineReader <T> pipelineReader) { this.pipelineReader = pipelineReader; pipelineReader.DataReady += (sender, e) => { DataReady?.Invoke(sender, e); }; }
void _serial_PortDataReveived(Object sender, SerialDataReceivedEventArgs e) { SerialPort _Dataport = (SerialPort)sender; Byte[] ReadData = new Byte[_Dataport.BytesToRead]; for (int i = 0; i < _Dataport.BytesToRead; i++) { ReadData[i] = (byte)_Dataport.ReadByte(); } this.LastreadData = ReadData; DataReady?.Invoke(this, e); }
public async void BeginLoad() { HttpClient client = new HttpClient(); client.BaseAddress = new Uri("http://www.google.com"); HttpResponseMessage msg = await client.GetAsync(""); string content = await msg.Content.ReadAsStringAsync(); Data = content; DataReady?.Invoke(this, EventArgs.Empty); }
void OnDataReady() { UT60EPacket package = new UT60EPacket(current_package_time_stamp, buffer); buffer.Clear(); EventArgs e = new UT60EPackageReceivedEventArgs(package); foreach (EventHandler event_handler in DataReady.GetInvocationList()) { event_handler.BeginInvoke(this, e, null, null); } }
public static void UpdateDataReady(int gameId, DataReady dataReady, string databaseName) { string cmdText = string.Format("UPDATE {0}.dbo.GameCompanyMap SET data_ready=@data_ready WHERE game_id=@game_id;", (object)databaseName); SqlParameter[] sqlParameterArray = new SqlParameter[2] { new SqlParameter("@game_id", (object)gameId), null }; sqlParameterArray[0].DbType = DbType.Int32; sqlParameterArray[1] = new SqlParameter("@data_ready", (object)dataReady); sqlParameterArray[1].DbType = DbType.Int32; SqlServerHelper.ExecuteNonQuery(CommandType.Text, cmdText, sqlParameterArray); }
void OnDataReady(object sender, EventArgs e) { UT60EPacket package = (e as UT60EPackageReceivedEventArgs).package; IUT60EData data = package.Parse(); if (data == null) { parse_error_count += 1; } else if (data.Unit == unit) { data_packages.Add(data); } else { data = null; } DataReady.Invoke(this, new UT60EDataReadyEventArgs(data)); }
public void Clear() { lock (this) { IsEmpty.Set(); DataReady.Reset(); WriteReady.Set(); readclosevent.Reset(); writecloseevent.Reset(); foreach (byte[] block in m_Blocks) { FreeBlock(block); } m_Blocks.Clear(); m_RPos = 0; m_WPos = 0; m_Size = 0; EOS.Reset(); } }
public async void Get_Json(string company_name) { string base_url = "http://www.alphavantage.co/query?function=TIME_SERIES_DAILY&symbol="; string Json_Url = String.Concat(base_url + company_name + "&apikey="); HttpClient client = new HttpClient(); HttpResponseMessage response = await client.GetAsync(Json_Url); data = await response.Content.ReadAsStringAsync(); data = data.Replace("1. open", "open"); data = data.Replace("2. high", "high"); data = data.Replace("3. low", "low"); data = data.Replace("4. close", "close"); data = data.Replace("5. volume", "volume"); File.WriteAllText(Json_FilePath, data); _stockvalues = Parse_Json(); //check if data is ready DataReady?.Invoke(this, EventArgs.Empty); Console.WriteLine($"file saved to {Json_FilePath}."); }
private void calculateTransform(ChannelData channel) { for (int i = 0; i < transformLength; i++) { channel.Complex[i] = new Complex { X = channel.InputHistory[i] * window[i], Y = 0f }; } transformProvider.FFT(true, m, channel.Complex); var e = new FourierTransformEventArgs( transformLength, channel.Index, channel.Complex); if (DataReady != null) { DataReady.Invoke(this, e); } }
private void OnDataReady(DataReadyEventArgs e) => DataReady?.Invoke(this, e);
protected virtual void OnDataReady(string path, long size, int count, string name) { DataReady?.Invoke(path, size, count, name); }
/// <summary> /// It will connect on the server with given IP and Port then listens on it. Use it in the thread/task /// </summary> /// <param name="ip">Server IP</param> /// <param name="port">Server Port</param> /// <param name="endBytesIdentifier"> /// This identifies the end packet once receive these bytes it will push the packet. If null /// then it pushes as it receives /// </param> /// <param name="connectionTimeoutMs"></param> /// <param name="receiveTimeOut"></param> /// <param name="transmissionTimeout"></param> /// <returns>Connection Status</returns> public bool Connect(string ip, int port, byte[] endBytesIdentifier = null, int connectionTimeoutMs = 2000, int receiveTimeOut = 1000, int transmissionTimeout = 1000) { if (endBytesIdentifier != null) { endBytesIdentifier = endBytesIdentifier.Reverse().ToArray(); } if (IsConnected) { return(IsConnected); } clientTcp = new TcpClient() { ReceiveTimeout = receiveTimeOut, SendTimeout = transmissionTimeout }; try { IAsyncResult result = clientTcp.BeginConnect(ip, port, null, null); bool success = result.AsyncWaitHandle.WaitOne(connectionTimeoutMs, true); IsConnected = clientTcp.Connected; if (!IsConnected) { return(IsConnected); } Port = port; Ip = ip; } catch (Exception ex) { ExceptionHandler?.Invoke(this, ex); return(IsConnected); } try { stream = clientTcp.GetStream(); ReplyPacket replyPacket = new ReplyPacket() { IsSentAndReplyReceived = true, IPSender = ip }; IsConnected = true; List <byte> completePacket = new List <byte>(); Task.Run(async() => { while (clientTcp.Connected) { if (!IsConnected) { break; } if (!stream.DataAvailable) { await Task.Delay(1).ConfigureAwait(false); } else { try { byte[] packet = new byte[clientTcp.Available]; await stream.ReadAsync(packet, 0, packet.Length).ConfigureAwait(false); completePacket.AddRange(packet); int lenth = completePacket.Count; if (endBytesIdentifier != null) { //this will flush any data that was there before connecting to the software //if (lenth > 5000) { completePacket.Clear(); continue; } if (completePacket.Count > endBytesIdentifier.Length) { bool isPacketEndIdentified = false; for (int i = 0; i < endBytesIdentifier.Length; i++) { if (completePacket[lenth - (i + 1)] == endBytesIdentifier[i]) { isPacketEndIdentified = true; } else { isPacketEndIdentified = false; break; } } if (isPacketEndIdentified) { replyPacket.SetReply(completePacket); DataReady?.Invoke(this, replyPacket); completePacket.Clear(); } } } else { replyPacket.SetReply(completePacket); DataReady?.Invoke(this, replyPacket); completePacket.Clear(); } } catch (Exception ex) { ExceptionHandler?.Invoke(this, ex); } } } }); } catch (Exception ex) { ExceptionHandler?.Invoke(this, ex); } return(IsConnected); }
protected virtual void OnDataReady(DataReadyEventArgs e) { DataReady?.Invoke(this, e); }
public static void UpdateDataReady(int gameId, DataReady dataReady) { DataHandlerSina.UpdateDataReady(gameId, dataReady, "FootballSina"); }
public override void Write(byte[] buf, int ofs, int count) { try { int Left = count; while (Left > 0) { switch (WaitHandle.WaitAny(new WaitHandle[] { this.WriteReady, this.writecloseevent }, this.WriteTimeout, false)) { case 0: break; case 1: //System.Diagnostics.Trace.WriteLine($"{Name} Write closed"); this.towrite = 0; throw new EndOfStreamException(); default: this.towrite = 0; throw new TimeoutException(); } lock (this) { int ToWrite = Math.Min(BlockSize - m_WPos, Left); var block = GetWBlock(); ToWrite = Math.Min(BlockSize - m_WPos, Left); System.Array.Copy(buf, ofs + count - Left, block, m_WPos, ToWrite); m_WPos += ToWrite; Left -= ToWrite; m_Size += ToWrite; this.towrite = Left; IsEmpty.Reset(); if (m_Size >= this.MaxLength) { // Trace.WriteLine("Write, buffer full, writeready.reset()"); this.WriteReady.Reset(); } /* if (Length >= this.toread) * { * // Trace.WriteLine("Write, readready, dataready.set()"); * DataReady.Set(); * }*/ } } } finally { // var doset = false; lock (this) { if (Length >= this.toread) { // doset = true; // Trace.WriteLine("Write, readready, dataready.set()"); DataReady.Set(); } } } }
public static List <GameInfo> GetGameInfos(DataReady dataReady) { return(DataHandlerSina.GetGameInfosBySQL(string.Format("SELECT * FROM GameInfo g left join GameCompanyMap c on g.id=c.game_id WHERE data_ready={0};", (object)dataReady))); }
public static List <GameInfo> GetDailyGameInfos(DataReady dataReady) { return(DataHandlerSina.GetGameInfosBySQL2(string.Format("SELECT * FROM FootballSinaDaily.dbo.GameInfo_Daily g left join FootballSinaDaily.dbo.GameCompanyMap c on g.id=c.game_id WHERE data_ready={0};", (object)dataReady))); }
public void SetDataReady(int index) { DataReady?.Invoke(index); }
/// <summary> /// Transmit a packet to a remote host /// </summary> /// <param name="destination">The host to transmit to</param> /// <param name="buffer">The buffer to transmit</param> /// <param name="length">The length of the data to transfer</param> internal void Transmit(IPEndPoint destination, byte[] buffer, int length) { DataReady?.Invoke(destination, buffer, length); }
private void ProcessScmpRecvBuffer(object sender) { var bCanProcess = true; while ((m_recvBuf.Size >= Shared.Scmp.Base.SizeOf) && bCanProcess) { // Have received at least a Scmp.Base message var scmp = new Shared.Scmp.Base(); scmp.Unpack(m_recvBuf.Buffer); // Determine endianness first thing. The first message // that makes it here should be the endianness message. // If it is not (or endianness cannot be determined) // then we abort. if (m_endian == Endian.Unknown) { var endianness = GetScmpBlob <Shared.Scmp.Endianness>(); SetEndianness(endianness.Order); // If endianness is still undetermined then we cannot continue if (m_endian == Endian.Unknown) { SledOutDevice.OutLine( SledMessageType.Error, Localization.SledTargetErrorUnknownEndianness); m_recvBuf.Reset(); m_netPlugin.Disconnect(); break; } // Remove endianness message from buffer m_recvBuf.Shuffle(endianness.Length); // Restart loop to advance "scmp" to next chunk (if a chunk has been received) so we're not // referencing stale memory and processing the Endianness message more than once. continue; } if (m_recvBuf.Size >= scmp.Length) { var bFlag = false; //Sce.Sled.Shared.SledOutDevice.OutLine(Sce.Sled.Shared.SledMessageType.Info, string.Format("[DebugService] Receiving {0}:{1}", scmp.GetType(), scmp.TypeCode)); // Have receive at least one full Scmp message; process it switch (scmp.TypeCode) { case (UInt16)Shared.Scmp.TypeCodes.Disconnect: { m_netPlugin.Disconnect(); bFlag = true; } break; case (UInt16)Shared.Scmp.TypeCodes.Authenticated: { m_bAuthenticated = true; NetPluginConnectedEvent(sender, m_curTarget); } break; case (UInt16)Shared.Scmp.TypeCodes.PluginsReady: { NetPluginPluginsReadyEvent(m_curTarget); } break; case (UInt16)Shared.Scmp.TypeCodes.Ready: { NetPluginReadyEvent(m_curTarget); } break; case (UInt16)Shared.Scmp.TypeCodes.Version: AuthenticateVersion(); break; case (UInt16)Shared.Scmp.TypeCodes.BreakpointBegin: HandleBreakpointBegin(); break; case (UInt16)Shared.Scmp.TypeCodes.BreakpointSync: HandleBreakpointSync(); break; case (UInt16)Shared.Scmp.TypeCodes.BreakpointEnd: HandleBreakpointEnd(); break; case (UInt16)Shared.Scmp.TypeCodes.BreakpointContinue: HandleBreakpointContinue(); break; default: { // Dispatch message DataReady.Raise(this, new SledDebugServiceEventArgs(m_curTarget, scmp)); } break; } // Remove this message if (!bFlag) { try { // This shouldn't throw now that we catch the problem in Dtlib but lets at least // stop annoying people with the stupid crashes from not handling the exception. m_recvBuf.Shuffle(scmp.Length); } catch (ArgumentOutOfRangeException ex) { SledOutDevice.OutLine(SledMessageType.Error, ex.Message); // Can't continue so force disconnect m_netPlugin.Disconnect(); bFlag = true; } } } else { // Not a full message, need to wait until we've received more data bCanProcess = false; } } }
public bool IsLogging() { return(DataReady.GetInvocationList().Count() > 0); }