本文整理汇总了C#中IChannel.WriteAndFlushAsync方法的典型用法代码示例。如果您正苦于以下问题:C# IChannel.WriteAndFlushAsync方法的具体用法?C# IChannel.WriteAndFlushAsync怎么用?C# IChannel.WriteAndFlushAsync使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类IChannel
的用法示例。
在下文中一共展示了IChannel.WriteAndFlushAsync方法的5个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: SendIdentification
/// <summary>
/// Sends identification to the server.
/// </summary>
/// <param name="channel">The channel.</param>
private void SendIdentification(IChannel channel)
{
var logon = string.Format(Logon, _email);
channel.WriteAndFlushAsync(Unpooled.WrappedBuffer(XorArray(Encoding.ASCII.GetBytes(logon))));
ByteBlasterEventSource.Log.Info("Sent Logon", logon);
}
示例2: GetCompleteScenarioAsync
async Task GetCompleteScenarioAsync(IChannel channel, ReadListeningHandler readHandler, string clientId, string password, CancellationToken cancellationToken)
{
await channel.WriteAndFlushAsync(new ConnectPacket
{
ClientId = clientId,
CleanSession = false,
HasUsername = true,
Username = clientId,
HasPassword = true,
Password = password,
KeepAliveInSeconds = 120
});
object message = await readHandler.ReceiveAsync();
var connackPacket = message as ConnAckPacket;
if (connackPacket == null)
{
throw new InvalidOperationException(string.Format("{1}: Expected CONNACK, received {0}", message, clientId));
}
else if (connackPacket.ReturnCode != ConnectReturnCode.Accepted)
{
throw new InvalidOperationException(string.Format("{1}: Expected successful CONNACK, received CONNACK with return code of {0}", connackPacket.ReturnCode, clientId));
}
await this.GetScenario(channel, readHandler, clientId, cancellationToken);
}
示例3: RunMqttServerScenarioAsync
static async Task RunMqttServerScenarioAsync(IChannel channel, ReadListeningHandler readListener)
{
var connectPacket = await readListener.ReceiveAsync(DefaultTimeout) as ConnectPacket;
Assert.IsNotNull(connectPacket, "Must be a Connect pkt");
// todo verify
await channel.WriteAndFlushAsync(new ConnAckPacket
{
ReturnCode = ConnectReturnCode.Accepted,
SessionPresent = true
});
var subscribePacket = await readListener.ReceiveAsync(DefaultTimeout) as SubscribePacket;
Assert.IsNotNull(subscribePacket);
// todo verify
await channel.WriteAndFlushAsync(SubAckPacket.InResponseTo(subscribePacket, QualityOfService.ExactlyOnce));
var unsubscribePacket = await readListener.ReceiveAsync(DefaultTimeout) as UnsubscribePacket;
Assert.IsNotNull(unsubscribePacket);
// todo verify
await channel.WriteAndFlushAsync(UnsubAckPacket.InResponseTo(unsubscribePacket));
var publishQos0Packet = await readListener.ReceiveAsync(DefaultTimeout) as PublishPacket;
Assert.IsNotNull(publishQos0Packet);
// todo verify
var publishQos1Packet = await readListener.ReceiveAsync(DefaultTimeout) as PublishPacket;
Assert.IsNotNull(publishQos1Packet);
// todo verify
int publishQos1PacketId = GetRandomPacketId();
await channel.WriteAndFlushManyAsync(
PubAckPacket.InResponseTo(publishQos1Packet),
new PublishPacket(QualityOfService.AtLeastOnce, false, false)
{
PacketId = publishQos1PacketId,
TopicName = PublishS2CQos1Topic,
Payload = Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes(PublishS2CQos1Payload))
});
var pubAckPacket = await readListener.ReceiveAsync(DefaultTimeout) as PubAckPacket;
Assert.AreEqual(publishQos1PacketId, pubAckPacket.PacketId);
var disconnectPacket = await readListener.ReceiveAsync(DefaultTimeout) as DisconnectPacket;
Assert.IsNotNull(disconnectPacket);
}
示例4: GetSubscribeSteps
protected static async Task GetSubscribeSteps(IChannel channel, ReadListeningHandler readHandler, string clientId, string topicNamePattern)
{
int subscribePacketId = Random.Next(1, ushort.MaxValue);
await channel.WriteAndFlushAsync(
new SubscribePacket(
subscribePacketId,
new SubscriptionRequest(string.Format(topicNamePattern, clientId), QualityOfService.ExactlyOnce)));
object message = await readHandler.ReceiveAsync();
var subackPacket = message as SubAckPacket;
if (subackPacket == null)
{
throw new InvalidOperationException(string.Format("{1}: Expected SUBACK, received {0}", message, clientId));
}
else if (subackPacket.PacketId == subscribePacketId && subackPacket.ReturnCodes[0] > QualityOfService.ExactlyOnce)
{
throw new InvalidOperationException($"{clientId}: Expected successful SUBACK({subscribePacketId.ToString()}), received SUBACK({subackPacket.PacketId.ToString()}) with QoS={subackPacket.ReturnCodes[0].ToString()}");
}
}
示例5: RunMqttClientScenarioAsync
static async Task RunMqttClientScenarioAsync(IChannel channel, ReadListeningHandler readListener)
{
await channel.WriteAndFlushAsync(new ConnectPacket
{
ClientId = ClientId,
Username = "testuser",
Password = "notsafe",
WillTopicName = "last/word",
WillMessage = Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes("oops"))
});
var connAckPacket = await readListener.ReceiveAsync(DefaultTimeout) as ConnAckPacket;
Assert.IsNotNull(connAckPacket);
Assert.AreEqual(ConnectReturnCode.Accepted, connAckPacket.ReturnCode);
int subscribePacketId = GetRandomPacketId();
int unsubscribePacketId = GetRandomPacketId();
await channel.WriteAndFlushManyAsync(
new SubscribePacket(subscribePacketId,
new SubscriptionRequest(SubscribeTopicFilter1, QualityOfService.ExactlyOnce),
new SubscriptionRequest(SubscribeTopicFilter2, QualityOfService.AtLeastOnce),
new SubscriptionRequest("for/unsubscribe", QualityOfService.AtMostOnce)),
new UnsubscribePacket(unsubscribePacketId, "for/unsubscribe"));
var subAckPacket = await readListener.ReceiveAsync(DefaultTimeout) as SubAckPacket;
Assert.IsNotNull(subAckPacket);
Assert.AreEqual(subscribePacketId, subAckPacket.PacketId);
Assert.AreEqual(3, subAckPacket.ReturnCodes.Count);
Assert.AreEqual(QualityOfService.ExactlyOnce, subAckPacket.ReturnCodes[0]);
Assert.AreEqual(QualityOfService.AtLeastOnce, subAckPacket.ReturnCodes[1]);
Assert.AreEqual(QualityOfService.AtMostOnce, subAckPacket.ReturnCodes[2]);
var unsubAckPacket = await readListener.ReceiveAsync(DefaultTimeout) as UnsubAckPacket;
Assert.IsNotNull(unsubAckPacket);
Assert.AreEqual(unsubscribePacketId, unsubAckPacket.PacketId);
int publishQoS1PacketId = GetRandomPacketId();
await channel.WriteAndFlushManyAsync(
new PublishPacket(QualityOfService.AtMostOnce, false, false)
{
TopicName = PublishC2STopic,
Payload = Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes(PublishC2SQos0Payload))
},
new PublishPacket(QualityOfService.AtLeastOnce, false, false)
{
PacketId = publishQoS1PacketId,
TopicName = PublishC2SQos1Topic,
Payload = Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes(PublishC2SQos1Payload))
});
//new PublishPacket(QualityOfService.AtLeastOnce, false, false) { TopicName = "feedback/qos/One", Payload = Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes("QoS 1 test. Different data length.")) });
var pubAckPacket = await readListener.ReceiveAsync(DefaultTimeout) as PubAckPacket;
Assert.IsNotNull(pubAckPacket);
Assert.AreEqual(publishQoS1PacketId, pubAckPacket.PacketId);
var publishPacket = await readListener.ReceiveAsync(DefaultTimeout) as PublishPacket;
Assert.IsNotNull(publishPacket);
Assert.AreEqual(QualityOfService.AtLeastOnce, publishPacket.QualityOfService);
Assert.AreEqual(PublishS2CQos1Topic, publishPacket.TopicName);
Assert.AreEqual(PublishS2CQos1Payload, publishPacket.Payload.ToString(Encoding.UTF8));
await channel.WriteAndFlushManyAsync(
PubAckPacket.InResponseTo(publishPacket),
DisconnectPacket.Instance);
}