static Int32 WorkOne(NetUri uri, Config cfg, Packet pk)
{
var count = 0;
try
{
var client = uri.CreateRemote();
(client as SessionBase).MaxAsync = 0;
client.Open();
for (var k = 0; k < cfg.Times; k++)
{
client.Send(pk);
if (cfg.Reply)
{
var pk2 = client.Receive();
if (pk2.Count > 0)
{
count++;
}
}
else
{
count++;
}
}
}
catch { }
return(count);
}
static void TestClient()
{
var uri = new NetUri("tcp://::1:1234");
//var uri = new NetUri("tcp://net.newlifex.com:1234");
var client = uri.CreateRemote();
client.Log = XTrace.Log;
client.LogSend = true;
client.LogReceive = true;
client.Received += (s, e) =>
{
XTrace.WriteLine("收到：{0}", e.Packet.ToStr());
};
client.Open();
// 定时显示性能数据
_timer = new TimerX(ShowStat, client, 100, 1000);
// 循环发送数据
for (var i = 0; i < 5; i++)
{
Thread.Sleep(1000);
var str = "你好" + (i + 1);
client.Send(str);
}
client.Dispose();
}
static void TestClient()
{
//var uri = new NetUri("tcp://127.0.0.1:1234");
var uri = new NetUri("tcp://www.armku.com:1234");
var client = uri.CreateRemote();
client.Log = XTrace.Log;
client.Received += (s, e) =>
{
var pk = e.Message as Packet;
XTrace.WriteLine("收到：{0}", pk.ToStr());
};
//client.Add(new LengthFieldCodec { Size = 4 });
client.Add <StandardCodecDemo>();
// 打开原始数据日志
var ns = client;
ns.LogSend = true;
ns.LogReceive = true;
client.Open();
// 定时显示性能数据
_timer = new TimerX(ShowStat, client, 100, 1000);
// 循环发送数据
for (var i = 0; i < 1; i++)
{
var str = "你好" + (i + 1);
var pk = new Packet(str.GetBytes());
client.SendMessageAsync(pk);
}
}
public Task SetEndPoint(IPEndPoint endPoint)
{
var reBind = false;
if (endPoint != null)
{
Console.WriteLine($"设置连接点为 {endPoint.Address} {endPoint.Port}");
_endPoint = endPoint;
reBind = true;
}
if (endPoint != null && !Equals(_endPoint, endPoint))
{
_endPoint = endPoint;
reBind = true;
}
if (_netUri == null || reBind)
{
_netUri = new NetUri(NetType.Tcp, _endPoint);
}
if (_socketClient == null || reBind)
{
_socketClient = _netUri.CreateRemote();
}
// if (_socketClient.Disposed)
// {
// _socketClient = new TcpSession(new Socket(SocketType.Stream,ProtocolType.Tcp));
// _socketClient.Remote = _netUri;
// }
return(Task.CompletedTask);
}
/// <summary>创建客户端会话</summary>
/// <param name="uri"></param>
/// <returns></returns>
protected virtual HttpClient Create(NetUri uri)
{
var http = uri.CreateRemote() as HttpClient;
http.Log = Log;
//if (XTrace.Debug)
//{
// http.LogSend = true;
// http.LogReceive = true;
//}
var req = http.Request;
req.UserAgent = UserAgent;
if (AutomaticDecompression != DecompressionMethods.None)
{
req.Compressed = true;
}
//if (!String.IsNullOrEmpty(Accept)) req.Headers[HttpRequestHeader.Accept + ""] = Accept;
//if (!String.IsNullOrEmpty(AcceptLanguage)) req.Headers[HttpRequestHeader.AcceptLanguage + ""] = AcceptLanguage;
//if (!String.IsNullOrEmpty(Referer)) req.Headers[HttpRequestHeader.Referer + ""] = Referer;
req.Accept = Accept;
req.AcceptLanguage = AcceptLanguage;
req.Referer = Referer;
return(http);
}
/// <summary>创建客户端会话</summary>
/// <param name="uri"></param>
/// <returns></returns>
protected virtual HttpSession Create(NetUri uri)
{
var http = uri.CreateRemote() as HttpSession;
http.Log = Log;
//if (XTrace.Debug)
//{
// http.LogSend = true;
// http.LogReceive = true;
//}
http.UserAgent = UserAgent;
if (AutomaticDecompression != DecompressionMethods.None)
{
http.Compressed = true;
}
if (!String.IsNullOrEmpty(Accept))
{
http.Headers[HttpRequestHeader.Accept] = Accept;
}
if (!String.IsNullOrEmpty(AcceptLanguage))
{
http.Headers[HttpRequestHeader.AcceptLanguage] = AcceptLanguage;
}
if (!String.IsNullOrEmpty(Referer))
{
http.Headers[HttpRequestHeader.Referer] = Referer;
}
return(http);
}
static void TestSend(String name, NetUri uri, Boolean isAsync, Boolean isSendData, Boolean isReceiveData)
{
Console.WriteLine();
String msg = String.Format("{0}Test_{1}_{2}!", name, uri.Type, isAsync ? "异步" : "同步");
var client = uri.CreateRemote();
client.Error += OnError;
if (isAsync && isReceiveData)
{
_are.Reset();
client.Received += OnReceived;
client.Open();
}
if (isSendData)
{
client.Send(msg);
}
var rs = false;
if (isReceiveData)
{
if (!isAsync)
{
try
{
//Console.WriteLine("客户端" + session + " " + session.ReceiveString());
var pk = client.Receive();
Console.WriteLine("客户端{0} 收到 [{1}]: {2}", client, pk.Count, pk.ToStr());
rs = true;
}
catch (Exception ex)
{
Debug.Fail("同步超时！" + ex.Message);
}
}
else
{
if (!_are.WaitOne(2000))
{
Debug.Fail("异步超时！");
}
else
{
rs = true;
}
}
}
client.Dispose();
client = null;
GC.Collect();
XTrace.WriteLine(rs ? "成功！" : "失败！");
}
static void Work(Config cfg)
{
var uri = new NetUri(cfg.Address);
if (cfg.Content.IsNullOrEmpty())
{
cfg.Content = "学无先后达者为师";
}
var pk = new Packet(cfg.Content.GetBytes());
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("NewLife.NC v{0}", AssemblyX.Entry.Version);
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("目标：{0}", uri);
Console.WriteLine("请求：{0:n0}", cfg.Times);
Console.WriteLine("并发：{0:n0}", cfg.Thread);
Console.WriteLine("并发：[{0:n0}] {1}", pk.Count, cfg.Content);
Console.ResetColor();
Console.WriteLine();
var sw = Stopwatch.StartNew();
// 多线程
var ts = new List <Task>();
var total = 0;
for (var i = 0; i < cfg.Thread; i++)
{
var tsk = Task.Factory.StartNew(() =>
{
try
{
var client = uri.CreateRemote();
client.Open();
for (var k = 0; k < cfg.Times; k++)
{
client.Send(pk);
Interlocked.Increment(ref total);
}
}
catch { }
}, TaskCreationOptions.LongRunning);
ts.Add(tsk);
}
Task.WaitAll(ts.ToArray());
sw.Stop();
Console.WriteLine("完成：{0:n0}", total);
var ms = sw.Elapsed.TotalMilliseconds;
Console.WriteLine("速度：{0:n0}tps", total * 1000L / ms);
}
public void BindTest2()
{
var addr = NetHelper.GetIPsWithCache().FirstOrDefault(e => e.IsIPv4() && !IPAddress.IsLoopback(e));
Assert.NotNull(addr);
var uri = new NetUri("https://www.newlifex.com");
var client = uri.CreateRemote();
client.Local.Address = addr;
client.Open();
}
public void BindTest3()
{
var addr = NetHelper.GetIPsWithCache().FirstOrDefault(e => e.IsIPv4() && !IPAddress.IsLoopback(e));
Assert.NotNull(addr);
var uri = new NetUri("https://newlifex.com");
var client = uri.CreateRemote() as TcpSession;
client.Open();
Assert.True(client.RemoteAddress.IsIPv4());
}
/// <summary>设置远程地址</summary>
/// <param name="uri"></param>
/// <returns></returns>
public Boolean SetRemote(String uri)
{
var nu = new NetUri(uri);
WriteLog("SetRemote {0}", nu);
var ct = Client = nu.CreateRemote();
ct.Log = Log;
ct.Add(new StandardCodec {
UserPacket = false
});
//ct.Add<JsonCodec2>();
return(true);
}
static async Task Main(string[] args)
{
Console.WriteLine("Hello World!");
packet = new Packet(TagerId, Sign);
//连接到服务器
var uri = new NetUri($"tcp://{serverip}:{port}");
client = uri.CreateRemote();
client.Log = XTrace.Log;
//数据收到事件
client.Received += Client_Received;
//注册
var data = packet.GetLoginReq();
client.Send(data);
//发送心跳包
Task.Run(async() =>
{
await RunHealth();
});
while (true)
{
Console.Write("发送几个初始信息:");
string str = Console.ReadLine();
int sendCount;
if (!int.TryParse(str, out sendCount))
{
Console.WriteLine("请输入整数");
}
//发送初始化包
for (int i = 0; i < sendCount; i++)
{
data = packet.GetInitReq();
client.Send(data);
Console.WriteLine("发送初始化");
}
}
await Task.Delay(-1);
Console.ReadLine();
}
//static Thread[] threads;
static void TestClient()
{
Console.Write("请输入服务器地址：");
var host = Console.ReadLine();
var port = ReadInt("请输入服务器端口：", 1, 65535);
var ep = NetHelper.ParseEndPoint(host, port);
var uri = new NetUri(NetType.Tcp, ep);
Console.WriteLine("开始测试连接{0}……", uri);
var session = uri.CreateRemote();
session.Send("Hi");
var rs = session.ReceiveString();
session.Dispose();
if (rs.IsNullOrWhiteSpace())
{
Console.WriteLine("连接失败！");
return;
}
var threadcount = ReadInt("请输入线程数（建议20）：", 1, 10000);
var perthread = ReadInt("请输入每线程连接数（建议500）：", 1, 10000);
//var time = ReadInt("请输入连接间隔（毫秒，建议10毫秒）：", 1, 10000);
var time = 10;
var threads = new Thread[threadcount];
for (int i = 0; i < threadcount; i++)
{
var th = new Thread(ClientProcess);
th.IsBackground = true;
th.Priority = ThreadPriority.BelowNormal;
th.Name = "Client_" + (i + 1);
threads[i] = th;
var p = new TCParam()
{
ID = i + 1, Count = perthread, Period = time, Uri = uri
};
th.Start(p);
Thread.Sleep(100);
}
}
static Int32 WorkOne(NetUri uri, Config cfg, Packet pk)
{
var count = 0;
try
{
var client = uri.CreateRemote();
client.Open();
for (var k = 0; k < cfg.Times; k++)
{
client.Send(pk);
count++;
}
}
catch { }
return(count);
}
static void Main(string[] args)
{
//10kb data pack
for (int i = 0; i < 1024; i++)
{
data += "1234567890";
}
try
{
var uri = new NetUri(ConfigurationManager.AppSettings["URI"]);
var pk = new Packet(data.GetBytes());
//
var ts = new List <Task>();
for (var i = 0; i < 10000; i++)
{
var tsk = Task.Factory.StartNew(() =>
{
try
{
var client = uri.CreateRemote();
client.Add <StandardCodec>();
client.Add <ReadHandler>();
client.Open();
for (var k = 0; k < 100; k++)
{
client.SendMessageAsync(pk);
}
return(client);
}
catch { return(null); }
}, TaskCreationOptions.LongRunning);
ts.Add(tsk);
}
Task.WaitAll(ts.ToArray());
//
Console.WriteLine("All The Job Have Done");
Console.ReadKey();
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
Console.ReadKey();
}
}
public void BindTest3()
{
Assert.True(Socket.OSSupportsIPv4);
Assert.True(Socket.OSSupportsIPv6);
var entry = Dns.GetHostEntry("www.newlifex.com");
//var entry = Dns.GetHostEntry("www.newlifex.com.w.cdngslb.com");
Assert.NotNull(entry);
var addr = NetHelper.GetIPsWithCache().FirstOrDefault(e => !e.IsIPv4() && !IPAddress.IsLoopback(e));
Assert.NotNull(addr);
var uri = new NetUri("https://www.newlifex.com");
var client = uri.CreateRemote();
client.Local.Address = addr;
client.Open();
}
static async Task <Int32> WorkOneAsync(NetUri uri, Config cfg, Packet pk)
{
var count = 0;
try
{
var client = uri.CreateRemote();
client.Open();
await Task.Yield();
for (var k = 0; k < cfg.Times; k++)
{
client.Send(pk);
count++;
await Task.Yield();
}
}
catch { }
return(count);
}
private static void Test8()
{
XTrace.WriteLine("启动两个服务端");
// 不管是哪一种服务器用法，都具有相同的数据接收处理事件
var onReceive = new EventHandler <ReceivedEventArgs>((s, e) =>
{
// ReceivedEventArgs中标准使用Data+Length或Stream表示收到的数据，测试时使用ToStr/ToHex直接输出
// UserState表示来源地址IPEndPoint
XTrace.WriteLine("收到 {0}：{1}", e.UserState, e.ToStr());
// 拿到会话，原样发回去。
// 不管是TCP/UDP，都会有一个唯一的ISocketSession对象表示一个客户端会话
var session = s as ISocketSession;
session.Send(e.Stream);
});
// 入门级UDP服务器，直接收数据
var udp = new UdpServer(3388);
udp.Received += onReceive;
udp.Open();
// 入门级TCP服务器，先接收会话连接，然后每个连接再分开接收数据
var tcp = new TcpServer(3388);
tcp.NewSession += (s, e) =>
{
XTrace.WriteLine("新连接 {0}", e.Session);
e.Session.Received += onReceive;
};
tcp.Start();
// 轻量级应用服务器（不建议作为产品级使用），同时在TCP/TCPv6/UDP/UDPv6监听指定端口，统一事件接收数据
var svr = new NetServer();
svr.Port = 3377;
svr.Received += onReceive;
svr.Start();
Console.WriteLine();
// 构造多个客户端连接上面的服务端
var uri1 = new NetUri(NetType.Udp, IPAddress.Loopback, 3388);
var uri2 = new NetUri(NetType.Tcp, IPAddress.Loopback, 3388);
var uri3 = new NetUri(NetType.Tcp, IPAddress.IPv6Loopback, 3377);
var clients = new ISocketClient[] { uri1.CreateRemote(), uri2.CreateRemote(), uri3.CreateRemote() };
// 打开每个客户端，如果是TCP，此时连接服务器。
// 这一步也可以省略，首次收发数据时也会自动打开连接
// TCP客户端设置AutoReconnect指定断线自动重连次数，默认3次。
foreach (var item in clients)
{
item.Open();
}
Thread.Sleep(1000);
Console.WriteLine();
XTrace.WriteLine("以下灰色日志为客户端日志，其它颜色为服务端日志，可通过线程ID区分");
// 循环发送几次数据
for (int i = 0; i < 3; i++)
{
foreach (var item in clients)
{
item.Send("第{0}次{1}发送".F(i + 1, item.Remote.Type));
var str = item.ReceiveString();
Trace.Assert(!str.IsNullOrEmpty());
}
Thread.Sleep(500);
}
XTrace.WriteLine("不用担心断开连接等日志，因为离开当前函数后，客户端连接将会被销毁");
// 为了统一TCP/UDP架构，网络库底层（UdpServer/TcpServer）是重量级封装为ISocketServer
// 实际产品级项目不关心底层，而是继承中间层（位于NewLife.Net）的NetServer/NetSession，直接操作ISocketSession
// 平台级项目一般在中间层之上封装消息序列化，转化为消息收发或者RPC调用，无视网络层的存在
// 以太网接口之上还有一层传输接口ITransport，它定义包括以太网和其它工业网络接口的基本数据收发能力
}
private static async Task <Int32> WorkOneAsync(IPEndPoint local, NetUri uri, Config cfg, Packet pk)
{
var count = 0;
try
{
Interlocked.Increment(ref _SessionCount);
var client = uri.CreateRemote();
if (cfg.Reply)
{
(client as SessionBase).MaxAsync = 0;
}
if (local != null)
{
client.Local.EndPoint = local;
}
client.Timeout = 30_000;
client.Open();
await Task.Yield();
for (var k = 0; k < cfg.Times; k++)
{
var ticks = _Counter.StartCount();
client.Send(pk);
if (cfg.Reply)
{
var pk2 = client.Receive();
if (pk2.Count > 0)
{
count++;
}
}
else
{
count++;
}
_Counter.StopCount(ticks);
if (cfg.Interval > 0)
{
await Task.Delay(cfg.Interval);
}
else
{
await Task.Yield();
}
}
}
catch (Exception ex)
{
if (_LastErrors.TryAdd(ex.GetType()))
{
XTrace.WriteLine("{0}=>{1}", local, uri);
XTrace.WriteException(ex);
}
}
Interlocked.Decrement(ref _SessionCount);
return(count);
}
void Connect()
{
_Server = null;
_Client = null;
var uri = new NetUri(cbAddr.Text);
// 网络封包
var idx = cbPacket.SelectedIndex;
var fact = idx < 0 ? null : _packets.Result[idx].CreateInstance() as IPacketFactory;
_Packet = fact.Create();
var cfg = MessageConfig.Current;
switch (cbMode.Text)
{
case "服务端":
var svr = new NetServer();
svr.Log = cfg.ShowLog ? XTrace.Log : Logger.Null;
svr.SocketLog = cfg.ShowSocketLog ? XTrace.Log : Logger.Null;
svr.Port = uri.Port;
if (uri.IsTcp || uri.IsUdp)
{
svr.ProtocolType = uri.Type;
}
svr.MessageReceived += OnReceived;
svr.LogSend = cfg.ShowSend;
svr.LogReceive = cfg.ShowReceive;
// 加大会话超时时间到1天
svr.SessionTimeout = 24 * 3600;
svr.SessionPacket = fact;
svr.Start();
"正在监听{0}".F(svr.Port).SpeechTip();
if (uri.Port == 0)
{
uri.Port = svr.Port;
}
_Server = svr;
break;
case "客户端":
var client = uri.CreateRemote();
client.Log = cfg.ShowLog ? XTrace.Log : Logger.Null;
client.MessageReceived += OnReceived;
client.LogSend = cfg.ShowSend;
client.LogReceive = cfg.ShowReceive;
client.Packet = _Packet;
client.Open();
"已连接服务器".SpeechTip();
if (uri.Port == 0)
{
uri.Port = client.Port;
}
_Client = client;
break;
default:
return;
}
pnlSetting.Enabled = false;
btnConnect.Text = "关闭";
// 添加地址
var addr = uri.ToString();
var list = cfg.Address.Split(";").ToList();
if (!list.Contains(addr))
{
list.Insert(0, addr);
cfg.Address = list.Join(";");
}
cfg.Save();
_timer = new TimerX(ShowStat, null, 5000, 5000);
BizLog = TextFileLog.Create("MessageLog");
}