/// <summary>异步多次发送数据</summary>
/// <param name="session">会话</param>
/// <param name="pk">数据包</param>
/// <param name="times">次数</param>
/// <param name="msInterval">间隔</param>
/// <returns></returns>
public static Boolean SendMulti(this ISocketRemote session, Packet pk, Int32 times, Int32 msInterval)
{
if (times <= 1)
{
session.Send(pk);
return(true);
}
if (msInterval < 10)
{
for (var i = 0; i < times; i++)
{
session.Send(pk);
}
return(true);
}
var timer = new TimerX(s =>
{
session.Send(pk);
// 如果次数足够，则把定时器周期置空，内部会删除
var t = s as TimerX;
if (--times <= 0)
{
t.Period = 0;
}
}, null, 0, msInterval);
return(true);
}
/// <summary>获取统计信息</summary>
/// <param name="socket"></param>
/// <returns></returns>
public static String GetStat(this ISocketRemote socket)
{
if (socket == null)
{
return(null);
}
var st1 = socket.StatSend;
var st2 = socket.StatReceive;
if (st1 == null && st2 == null)
{
return(null);
}
var sb = Pool.StringBuilder.Get();
if (st1 != null && st1.Value > 0)
{
sb.AppendFormat("发送：{0} ", st1);
}
if (st2 != null && st2.Value > 0)
{
sb.AppendFormat("接收：{0} ", st2);
}
return(sb.Put(true));
}
/// <summary>发送数据流</summary>
/// <param name="session">会话</param>
/// <param name="stream">数据流</param>
/// <returns>返回是否成功</returns>
public static Boolean Send(this ISocketRemote session, Stream stream)
{
// 空数据直接发出
var remain = stream.Length - stream.Position;
if (remain == 0)
{
return(session.Send(new Byte[0]));
}
var buffer = new Byte[session.BufferSize];
while (true)
{
var count = stream.Read(buffer, 0, buffer.Length);
if (count <= 0)
{
break;
}
var pk = new Packet(buffer, 0, count);
if (!session.Send(pk))
{
return(false);
}
if (count < buffer.Length)
{
break;
}
}
return(true);
}
/// <summary>异步发送数据并等待响应</summary>
/// <param name="session">会话</param>
/// <param name="buffer"></param>
/// <returns></returns>
public static async Task <Byte[]> SendAsync(this ISocketRemote session, Byte[] buffer)
{
var pk = new Packet(buffer);
var rs = await session.SendAsync(pk).ConfigureAwait(false);
return(rs?.ToArray());
}
/// <summary>创建上下文</summary>
/// <param name="session">远程会话</param>
/// <returns></returns>
public virtual IHandlerContext CreateContext(ISocketRemote session)
{
var context = new HandlerContext
{
Pipeline = this,
Session = session
};
return(context);
}
/// <summary>创建上下文</summary>
/// <param name="session">远程会话</param>
/// <returns></returns>
internal protected virtual NetHandlerContext CreateContext(ISocketRemote session)
{
var context = new NetHandlerContext
{
Pipeline = Pipeline,
Session = session,
Owner = session,
};
return(context);
}
/// <summary>接收字符串</summary>
/// <param name="session">会话</param>
/// <param name="encoding">文本编码，默认null表示UTF-8编码</param>
/// <returns></returns>
public static String ReceiveString(this ISocketRemote session, Encoding encoding = null)
{
var pk = session.Receive();
if (pk == null || pk.Count == 0)
{
return(null);
}
return(pk.ToStr(encoding ?? Encoding.UTF8));
}
/// <summary>发送字符串</summary>
/// <param name="session">会话</param>
/// <param name="msg">要发送的字符串</param>
/// <param name="encoding">文本编码，默认null表示UTF-8编码</param>
/// <returns>返回自身，用于链式写法</returns>
public static Boolean Send(this ISocketRemote session, String msg, Encoding encoding = null)
{
if (String.IsNullOrEmpty(msg))
{
return(session.Send(new Byte[0]));
}
if (encoding == null)
{
encoding = Encoding.UTF8;
}
return(session.Send(encoding.GetBytes(msg)));
}
/// <summary>发送字符串</summary>
/// <param name="session">会话</param>
/// <param name="msg">要发送的字符串</param>
/// <param name="encoding">文本编码，默认null表示UTF-8编码</param>
/// <returns>返回自身，用于链式写法</returns>
public static Int32 Send(this ISocketRemote session, String msg, Encoding encoding = null)
{
if (String.IsNullOrEmpty(msg))
{
return(session.Send(Array.Empty <Byte>()));
}
if (encoding == null)
{
encoding = Encoding.UTF8;
}
return(session.Send(encoding.GetBytes(msg)));
}
/// <summary>异步多次发送数据</summary>
/// <param name="session">会话</param>
/// <param name="pk">数据包</param>
/// <param name="times">次数</param>
/// <param name="msInterval">间隔</param>
/// <returns></returns>
public static Task SendConcurrency(this ISocketRemote session, Packet pk, Int32 times, Int32 msInterval)
{
var task = TaskEx.Run(async() =>
{
for (var i = 0; i < times; i++)
{
session.Send(pk);
await TaskEx.Delay(msInterval);
}
});
return(task);
}
/// <summary>写入数据</summary>
/// <param name="session">远程会话</param>
/// <param name="message">消息</param>
public virtual Task <Object> FireWriteAndWait(ISocketRemote session, Object message)
{
var ctx = CreateContext(session);
var source = new TaskCompletionSource <Object>();
ctx["TaskSource"] = source;
if (!OnFireWrite(ctx, message))
{
return(TaskEx.FromResult((Object)null));
}
return(source.Task);
}
/// <summary>发送数据流</summary>
/// <param name="session">会话</param>
/// <param name="stream">数据流</param>
/// <returns>返回是否成功</returns>
public static Boolean Send(this ISocketRemote session, Stream stream)
{
// UDP的最大缓冲区
var size = 1460L;
var remain = stream.Length - stream.Position;
// 空数据直接发出
if (remain == 0)
{
return(session.Send(new Byte[0]));
}
// TCP可以加大
if (remain > size && session.Client.SocketType == SocketType.Stream)
{
// 至少使用发送缓冲区的大小，默认8k
size = session.Client.SendBufferSize;
// 超大数据流，缓存加大一千倍
while (size < 0x80000000 && remain > size << 10)
{
size <<= 1;
}
}
if (remain < size)
{
size = (Int32)remain;
}
var buffer = new Byte[size];
while (true)
{
var count = stream.Read(buffer, 0, buffer.Length);
if (count <= 0)
{
break;
}
if (!session.Send(buffer, 0, count))
{
return(false);
}
if (count < buffer.Length)
{
break;
}
}
return(true);
}
/// <summary>接收字符串</summary>
/// <param name="session">会话</param>
/// <param name="encoding">文本编码，默认null表示UTF-8编码</param>
/// <returns></returns>
public static String ReceiveString(this ISocketRemote session, Encoding encoding = null)
{
var buffer = session.Receive();
if (buffer == null || buffer.Length < 1)
{
return(null);
}
if (encoding == null)
{
encoding = Encoding.UTF8;
}
return(encoding.GetString(buffer));
}
/// <summary>获取统计信息</summary>
/// <param name="socket"></param>
/// <returns></returns>
public static String GetStat(this ISocketRemote socket)
{
if (socket == null)
{
return(null);
}
var sb = new StringBuilder();
if (socket.StatSend.Total > 0)
{
sb.AppendFormat("发送：{0} ", socket.StatSend);
}
if (socket.StatReceive.Total > 0)
{
sb.AppendFormat("接收：{0} ", socket.StatReceive);
}
return(sb.ToString());
}
/// <summary>发送数据流</summary>
/// <param name="session">会话</param>
/// <param name="stream">数据流</param>
/// <returns>返回是否成功</returns>
public static Int32 Send(this ISocketRemote session, Stream stream)
{
// 空数据直接发出
var remain = stream.Length - stream.Position;
if (remain == 0)
{
return(session.Send(new Byte[0]));
}
var rs = 0;
var buffer = new Byte[8192];
while (true)
{
var count = stream.Read(buffer, 0, buffer.Length);
if (count <= 0)
{
break;
}
var pk = new Packet(buffer, 0, count);
var count2 = session.Send(pk);
if (count2 < 0)
{
break;
}
rs += count2;
if (count < buffer.Length)
{
break;
}
}
return(rs);
}
/// <summary>异步多次发送数据</summary>
/// <param name="session">会话</param>
/// <param name="buffer"></param>
/// <param name="times"></param>
/// <param name="msInterval"></param>
/// <returns></returns>
public static Boolean SendAsync(this ISocketRemote session, Byte[] buffer, Int32 times, Int32 msInterval)
{
if (times <= 1)
{
return(session.SendAsync(buffer));
}
if (msInterval < 10)
{
for (int i = 0; i < times; i++)
{
session.SendAsync(buffer);
}
return(true);
}
//var src = new TaskCompletionSource<Int32>();
var timer = new TimerX(s =>
{
session.SendAsync(buffer);
//session.Send(buffer);
// 如果次数足够，则把定时器周期置空，内部会删除
var t = s as TimerX;
if (--times <= 0)
{
t.Period = 0;
//src.SetResult(0);
}
}, null, 0, msInterval);
//return src.Task;
return(true);
}
/// <summary>写入数据</summary>
/// <param name="session">远程会话</param>
/// <param name="message">消息</param>
public virtual Boolean FireWrite(ISocketRemote session, Object message)
{
var ctx = CreateContext(session);
return(OnFireWrite(ctx, message));
}
