private void btn_send_Click(object sender, EventArgs e)
{
if (this.mqttclient.IsConnected)
{
for (int i = 0; i < int.Parse(this.nud_sendNum.Value.ToString()); i++)
{
MqttApplicationMessageBuilder builder = new MqttApplicationMessageBuilder();
builder.WithPayload(this.mtb_sendmsg.Text.Trim())
.WithTopic(this.mtb_sendTopic.Text.Trim());
switch (this.cb_sendQos.SelectedText)
{
case "0":
builder.WithAtMostOnceQoS();
break;
case "1":
builder.WithAtLeastOnceQoS();
break;
case "2":
builder.WithExactlyOnceQoS();
break;
}
if (this.nud_sendDelay.Value > 0)
{
Task.Delay(new TimeSpan(0, 0, 0, 0, int.Parse(this.nud_sendDelay.Value.ToString()))).Wait();
}
this.mqttclient.PublishAsync(builder.Build());
insertLog($"topic:{this.mtb_sendTopic.Text.Trim()},value:{this.mtb_sendmsg.Text.Trim()}");
}
}
else
{
MessageBox.Show("当前连接已断开，请连接后重试", "系统提示");
}
}
static async Task Main(string[] args)
{
Console.WriteLine("Hello World!");
var factory = new MqttFactory();
var l = factory.CreateMqttClient();
var opt = new MqttClientOptions();
opt.ClientId = "LocalTestClient";
opt.ChannelOptions = new MqttClientTcpOptions
{
Port = 8883,
// TlsOptions = new MqttClientTlsOptions
// {
// AllowUntrustedCertificates = true,
// UseTls = true,
// },
Server = "localhost",
// Server = "mqtt.qaybe.de",
};
opt.Credentials = new MqttClientCredentials
{
Username = "******",
Password = Encoding.UTF8.GetBytes("Test")
};
var result = await l.ConnectAsync(opt, CancellationToken.None);
var mssg = new MqttApplicationMessageBuilder();
mssg.WithRetainFlag(true);
var la = mssg.WithPayload("Hello from Client sowieso")
.WithTopic("test/nace/message")
.Build();
var response = await l.PublishAsync(la, CancellationToken.None);
Console.WriteLine(response.ReasonString);
}
// In class _Startup_ of the ASP.NET Core 2.0 project.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
app.UseMqttEndpoint();
app.UseMqttServer(async server =>
{
var msg = new MqttApplicationMessageBuilder()
.WithPayload("Mqtt is awesome")
.WithTopic("message");
while (true)
{
server.PublishAsync(msg.Build()).Wait();
await Task.Delay(TimeSpan.FromSeconds(2));
msg.WithPayload("Mqtt is still awesome at " + DateTime.Now);
}
});
app.Use((context, next) =>
{
if (context.Request.Path == "/")
{
context.Request.Path = "/Index.html";
}
return(next());
});
app.UseStaticFiles();
app.UseStaticFiles(new StaticFileOptions
{
RequestPath = "/node_modules",
FileProvider = new PhysicalFileProvider(Path.Combine(env.ContentRootPath, "node_modules"))
});
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseStaticFiles();
app.UseHttpsRedirection();
app.UseAuthentication();
app.UseRouting();//路由配置
app.UseAuthorization();
#region mqtt服务器启动
app.UseMqttEndpoint();
app.UseMqttServer(server =>
{
server.ApplicationMessageReceived += ServerOnApplicationMessageReceived;
//服务启动事件
server.Started += async(sender, args) =>
{
var msg = new MqttApplicationMessageBuilder().WithPayload("welcome to mqtt").WithTopic("start");
while (true)
{
try
{
await server.PublishAsync(msg.Build());
msg.WithPayload("you are welcome to mqtt");
}
catch (Exception e)
{
Console.WriteLine(e);
}
finally
{
await Task.Delay(TimeSpan.FromSeconds(5));
}
}
};
//服务停止事件
server.Stopped += (sender, args) =>
{
};
//客户端连接事件
server.ClientConnected += (sender, args) =>
{
var clientId = args.ClientId;
Console.WriteLine($"有客户连接");
};
//客户端断开事件
server.ClientDisconnected += (sender, args) =>
{
var clientId = args.ClientId;
};
});
#endregion
#region swagger
app.UseSwagger();
app.UseSwaggerUI(c =>
{
c.SwaggerEndpoint("/swagger/v1/swagger.json", "MqttServer");
});
#endregion
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
//DONT TAKE FORWARD, just a helper for spike
public static MqttApplicationMessageBuilder WithMessage <T>(this MqttApplicationMessageBuilder builder,
T message)
{
return(builder.WithPayload(JsonConvert.SerializeObject(message).ToByteArray()));
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseMvc();
app.UseConnections(c => c.MapConnectionHandler <MqttConnectionHandler>("/data", options =>
{
options.WebSockets.SubProtocolSelector = MQTTnet.AspNetCore.ApplicationBuilderExtensions.SelectSubProtocol;
}));
app.UseMqttEndpoint("/data");
app.UseMqttServer(server =>
{
//服务启动事件
server.Started += async(sender, args) =>
{
var msg = new MqttApplicationMessageBuilder().WithPayload("welcome to mqtt").WithTopic("start");
while (true)
{
try
{
await server.PublishAsync(msg.Build());
msg.WithPayload("you are welcome to mqtt");
}
catch (Exception e)
{
Console.WriteLine(e);
}
finally
{
await Task.Delay(TimeSpan.FromSeconds(5));
}
}
};
//服务停止事件
server.Stopped += (sender, args) =>
{
};
//客户端连接事件
server.ClientConnected += (sender, args) =>
{
var clientId = args.ClientId;
};
//客户端断开事件
server.ClientDisconnected += (sender, args) =>
{
var clientId = args.ClientId;
};
});
//app.Use((context, next) =>
//{
// if (context.Request.Path == "/")
// {
// context.Request.Path = "/Index.html";
// }
// return next();
//});
//app.UseStaticFiles();
//app.UseStaticFiles(new StaticFileOptions
//{
// RequestPath="",
// FileProvider=new PhysicalFileProvider(System.IO.Path.Combine(env.ContentRootPath,"node_modules"))
//});
Controllers.ServiceLocator.Instance = app.ApplicationServices;
}
public static async Task ReqRepTest(int LoopNum)
{
string requestTopic = "mytopic/A/request";
var sw = new System.Diagnostics.Stopwatch();
sw.Start();
using (var cts = new CancellationTokenSource())
using (var startedev = new ManualResetEventSlim())
using (var connectedev = new ManualResetEventSlim())
using (var recvev = new ManualResetEventSlim())
{
var fac = new MqttFactory();
await Task.WhenAll(
Task.Run(async() =>
{
var svr = fac.CreateMqttServer();
var msgbuilder = new MqttApplicationMessageBuilder().WithPayload("req");
svr.ApplicationMessageReceived += async(sender, ev) =>
{
if (ev.ApplicationMessage.Topic.Equals(requestTopic, StringComparison.Ordinal))
{
var reqmsg = MessagePackSerializer.Deserialize <ReqMsg>(ev.ApplicationMessage.Payload);
var msg = msgbuilder.WithTopic(reqmsg.ReplyTopic).Build();
await svr.PublishAsync(msg);
}
};
svr.Started += (sender, ev) =>
{
startedev.Set();
};
var opt = new MqttServerOptionsBuilder()
.WithDefaultEndpoint()
.WithDefaultEndpointBoundIPAddress(IPAddress.Loopback)
.WithDefaultEndpointPort(10012)
.Build();
await svr.StartAsync(opt).ConfigureAwait(false);
cts.Token.WaitHandle.WaitOne();
await svr.StopAsync().ConfigureAwait(false);
})
,
Task.Run(async() =>
{
var client = fac.CreateMqttClient();
string replyTopic = "mytopic/A/reply";
var queue = new ConcurrentQueue <TaskCompletionSource <byte[]> >();
client.ApplicationMessageReceived += (sender, ev) =>
{
if (queue.TryDequeue(out var tcs))
{
tcs.TrySetResult(ev.ApplicationMessage.Payload);
}
};
client.Connected += (sender, ev) =>
{
connectedev.Set();
};
var clientopt = new MqttClientOptionsBuilder()
.WithClientId("clid")
.WithTcpServer("localhost", 10012)
.Build()
;
await client.ConnectAsync(clientopt).ConfigureAwait(false);
connectedev.Wait();
var topicFilter = new TopicFilterBuilder()
.WithTopic(replyTopic)
.WithAtLeastOnceQoS()
.Build()
;
await client.SubscribeAsync(topicFilter).ConfigureAwait(false);
Console.WriteLine($"client task loop started:{sw.Elapsed}");
var beginTime = sw.Elapsed;
var msgbuilder = new MqttApplicationMessageBuilder().WithTopic(requestTopic);
for (int i = 0; i < LoopNum; i++)
{
var reqpayload = MessagePackSerializer.Serialize(new ReqMsg(replyTopic, "hoge"));
var msg = msgbuilder
.WithPayload(reqpayload)
.Build();
;
var reqtcs = new TaskCompletionSource <byte[]>();
queue.Enqueue(reqtcs);
await client.PublishAsync(msg).ConfigureAwait(false);
await reqtcs.Task;
}
var endTime = sw.Elapsed;
Console.WriteLine($"elapsed(mqtt):{sw.Elapsed},rps={LoopNum/(endTime.Subtract(beginTime).TotalSeconds)}");
}).ContinueWith(t =>
{
Console.WriteLine($"all client task done:{sw.Elapsed}");
cts.Cancel();
if (t.IsCanceled)
{
throw new TaskCanceledException("server task cancelled", t.Exception);
}
else if (t.IsFaulted)
{
throw new AggregateException(t.Exception);
}
})
).ConfigureAwait(false);
}
}
public static async Task TestMany(int loopNum, int taskNum)
{
var fac = new MqttFactory();
using (var cts = new CancellationTokenSource())
{
var sw = new System.Diagnostics.Stopwatch();
sw.Start();
await Task.WhenAll(
Task.Run(async() =>
{
var svr = fac.CreateMqttServer();
svr.Started += (sender, ev) =>
{
Console.WriteLine($"{sw.Elapsed} svr started");
};
svr.ClientConnected += (sender, ev) =>
{
Console.WriteLine($"{sw.Elapsed} client connected(S): {ev.Client.ClientId}");
};
svr.ClientDisconnected += (sender, ev) =>
{
Console.WriteLine($"{sw.Elapsed} client disconnected(S): {ev.Client.ClientId}");
};
var opt = new MqttServerOptionsBuilder()
.WithDefaultEndpoint()
.WithDefaultEndpointBoundIPAddress(IPAddress.Loopback)
.WithDefaultEndpointPort(10012)
.Build();
await svr.StartAsync(opt).ConfigureAwait(false);
cts.Token.WaitHandle.WaitOne();
await svr.StopAsync().ConfigureAwait(false);
})
,
Task.Run(async() =>
{
await Task.Delay(100).ConfigureAwait(false);
var client = fac.CreateMqttClient();
var clientopt = new MqttClientOptionsBuilder()
.WithClientId("clid")
.WithTcpServer("localhost", 10012)
.Build()
;
// var opt = new ManagedMqttClientOptionsBuilder()
// .WithClientOptions(clientopt)
// .WithAutoReconnectDelay(TimeSpan.FromMilliseconds(100))
// .Build();
using (var connectedEvent = new ManualResetEventSlim(false))
{
client.ApplicationMessageReceived += (sender, ev) =>
{
Console.WriteLine($"{sw.Elapsed} recv {ev.ApplicationMessage.Topic},{ev.ApplicationMessage.Payload[0]}");
};
client.Connected += (sender, ev) =>
{
Console.WriteLine($"{sw.Elapsed} client connected");
connectedEvent.Set();
};
client.Disconnected += (sender, ev) =>
{
Console.WriteLine($"{sw.Elapsed} client disconnected");
};
var topicFilter = new TopicFilterBuilder()
.WithTopic("mytopic/A").WithAtLeastOnceQoS().Build();
Console.WriteLine($"{sw.Elapsed} begin connection");
await client.ConnectAsync(clientopt).ConfigureAwait(false);
// await client.StartAsync(opt).ConfigureAwait(false);
connectedEvent.Wait();
if (!client.IsConnected)
{
Console.WriteLine($"not connected");
}
else
{
Console.WriteLine($"{sw.Elapsed} connection established");
}
await client.SubscribeAsync(new[] { topicFilter }).ConfigureAwait(false);
Console.WriteLine($"{sw.Elapsed} subscribing done");
var msgbuilder = new MqttApplicationMessageBuilder();
msgbuilder = msgbuilder.WithTopic("mytopic/A").WithAtLeastOnceQoS();
var dat = new byte[1];
for (int i = 0; i < 100; i++)
{
await Task.Yield();
dat[0] = (byte)(i % 255);
var msg = msgbuilder.WithPayload(dat).Build();
await client.PublishAsync(msg).ConfigureAwait(false);
Console.WriteLine($"{sw.Elapsed}: publish{i}");
}
await client.UnsubscribeAsync(new[] { topicFilter.Topic }).ConfigureAwait(false);
await client.DisconnectAsync().ConfigureAwait(false);
// await client.StopAsync().ConfigureAwait(false);
// cts.Cancel();
}
// var opt = new MqttClientOptionsBuilder()
// .Build();
// await client.ConnectAsync(opt).ConfigureAwait(false);
// var topicFilter = new TopicFilterBuilder()
// .WithTopic("topic")
// .Build();
// var subresults = await client.SubscribeAsync(new TopicFilter[] {topicFilter}).ConfigureAwait(false);
// foreach(var subresult in subresults)
// {
// }
}).ContinueWith(t =>
{
cts.Cancel();
})
);
sw.Stop();
}
}
