/// <summary> /// Sends a PING message to the server. This is automatically done to keep the connection alive. Only call this method /// if you want to send additional PING messages, apart from the ones sent to keep the connection alive. /// </summary> public async Task PING() { BinaryOutput Packet = new BinaryOutput(); Packet.WriteByte((byte)MqttControlPacketType.PINGREQ << 4); Packet.WriteUInt(0); byte[] PacketData = Packet.GetPacket(); await this.Write(PacketData, 0, null); EventHandlerAsync h = this.OnPing; if (h != null) { try { await h(this, new EventArgs()); } catch (Exception ex) { this.Exception(ex); Log.Critical(ex); } } }
public static Task Raise(this EventHandlerAsync handler, object sender) { var temp = Volatile.Read(ref handler); if (temp != null) { return(temp.Invoke(sender, EventArgs.Empty)); } return(TaskHelper.Complete()); }
public static Task Raise <T>(this EventHandlerAsync <T> handler, object sender, T args) { var temp = Volatile.Read(ref handler); if (temp != null) { return(temp.Invoke(sender, args)); } return(TaskHelper.Complete()); }
/// <summary> /// Cancels the readout. /// </summary> public override async Task Cancel() { try { await this.SetState(SensorDataReadoutState.Cancelled); EventHandlerAsync h = this.OnCancel; if (!(h is null)) { await h(this, new EventArgs()); } } catch (Exception ex) { Log.Critical(ex); } }
internal async Task SetState(Socks5State NewState) { if (this.state != NewState) { this.state = NewState; this.Information("State changed to " + this.state.ToString()); EventHandlerAsync h = this.OnStateChange; if (!(h is null)) { try { await h(this, new EventArgs()); } catch (Exception ex) { Log.Critical(ex); } } } }
private async Task <bool> ProcessInputPacket() { try { BinaryInput Packet = new BinaryInput(this.inputPacket); MqttHeader Header = MqttHeader.Parse(Packet); switch (Header.ControlPacketType) { case MqttControlPacketType.CONNECT: default: throw new Exception("Received command from server that is not handled: " + Header.ControlPacketType.ToString()); case MqttControlPacketType.CONNACK: bool SessionPresent = (Packet.ReadByte() & 1) != 0; byte ReturnCode = Packet.ReadByte(); try { switch (ReturnCode) { case 0: this.State = MqttState.Connected; this.nextPing = DateTime.Now.AddMilliseconds(this.keepAliveSeconds * 500); break; case 1: throw new IOException("Connection Refused, unacceptable protocol version."); case 2: throw new IOException("Connection Refused, identifier rejected."); case 3: throw new IOException("Connection Refused, Server unavailable."); case 4: throw new IOException("Connection Refused, bad user name or password."); case 5: throw new IOException("Connection Refused, not authorized."); default: throw new IOException("Unrecognized error code returned: " + ReturnCode.ToString()); } } catch (Exception ex) { await this.ConnectionError(this, ex); this.DisposeClient(); return(false); } break; case MqttControlPacketType.PINGREQ: await this.PINGRESP(); break; case MqttControlPacketType.PINGRESP: EventHandlerAsync h = this.OnPingResponse; if (h != null) { try { await h(this, new EventArgs()); } catch (Exception ex) { this.Exception(ex); Log.Critical(ex); } } break; case MqttControlPacketType.PUBLISH: string Topic = Packet.ReadString(); if (Header.QualityOfService > MqttQualityOfService.AtMostOnce) { Header.PacketIdentifier = Packet.ReadUInt16(); } else { Header.PacketIdentifier = 0; } int c = Packet.BytesLeft; byte[] Data = Packet.ReadBytes(c); MqttContent Content = new MqttContent(Header, Topic, Data); switch (Header.QualityOfService) { case MqttQualityOfService.AtMostOnce: await this.ContentReceived(Content); break; case MqttQualityOfService.AtLeastOnce: await this.PUBACK(Header.PacketIdentifier); await this.ContentReceived(Content); break; case MqttQualityOfService.ExactlyOnce: lock (this.synchObj) { this.contentCache[Header.PacketIdentifier] = Content; } await this.PUBREC(Header.PacketIdentifier); break; } break; case MqttControlPacketType.PUBACK: this.PacketDelivered(Header.PacketIdentifier); PacketAcknowledgedEventHandler h2 = this.OnPublished; if (h2 != null) { try { await h2(this, Header.PacketIdentifier); } catch (Exception ex) { this.Exception(ex); } } break; case MqttControlPacketType.PUBREC: this.PacketDelivered(Header.PacketIdentifier); await this.PUBREL(Header.PacketIdentifier); break; case MqttControlPacketType.PUBREL: lock (this.synchObj) { if (this.contentCache.TryGetValue(Header.PacketIdentifier, out Content)) { this.contentCache.Remove(Header.PacketIdentifier); } else { Content = null; } } await this.PUBCOMP(Header.PacketIdentifier); if (Content != null) { await this.ContentReceived(Content); } break; case MqttControlPacketType.PUBCOMP: this.PacketDelivered(Header.PacketIdentifier); h2 = this.OnPublished; if (h2 != null) { try { await h2(this, Header.PacketIdentifier); } catch (Exception ex) { this.Exception(ex); } } break; case MqttControlPacketType.SUBACK: this.PacketDelivered(Header.PacketIdentifier); h2 = this.OnSubscribed; if (h2 != null) { try { await h2(this, Header.PacketIdentifier); } catch (Exception ex) { this.Exception(ex); } } break; case MqttControlPacketType.UNSUBACK: this.PacketDelivered(Header.PacketIdentifier); h2 = this.OnUnsubscribed; if (h2 != null) { try { await h2(this, Header.PacketIdentifier); } catch (Exception ex) { this.Exception(ex); } } break; } } catch (Exception ex) { await this.Error(ex); } return(true); }
static async Task TestAsync(EventHandlerAsync deleg) { await deleg(); }