public async Task Promote(CommandContext ctx, DiscordMember profileName)
{
var name = profileName.Nickname;
var rankHandler = new stringHandler();
if (rankHandler.HasRank(name))
{
var rank = rankHandler.GetRank(name);
var charRankArray = rank.ToCharArray();
var trimedName = name.TrimStart(charRankArray);
rank = rankHandler.FindNextRank(rank);
var rankName = rank + trimedName;
await profileName.ModifyAsync(member => member.Nickname = rankName);
await ctx.Channel.SendMessageAsync("```Congratulations " + trimedName + " on your promotion to: " +
rank + ". you do the 77th proud.```").ConfigureAwait(false);
}
else
{
var rankName = "Pvt " + name;
await profileName.ModifyAsync(member => member.Nickname = rankName);
await ctx.Channel.SendMessageAsync("```Welcome to the 77th " + name + ". Good to have you.```")
.ConfigureAwait(false);
}
}
public string loremReplace(string text)
{
stringHandler strHandler = str.replaceToComma;
strHandler(ref text);
return(text);
}
public string loremReverse(string text)
{
stringHandler strHandler = str.reverseString;
strHandler(ref text);
return(text);
}
public Example39()
{
strRev = str.reverseString;
rToComma = str.replaceToComma;
rToSpace = str.replaceToSpace;
removeSpaces = str.removeSpaces;
chainOp = str.getStr;
}
public string chainedOp(string text)
{
stringHandler op1 = new stringHandler(str.replaceToComma);
stringHandler op2 = new stringHandler(str.reverseString);
stringHandler op3 = op1;
op3 += op2;
op3(ref text);
return(text);
}
public void listenTcpMessage(TcpListener TcpListener1, List<NetworkStream> NetworkStreamList,stringHandler succMessageHandler,stringHandler errorMessageHandler)
{
Thread listenThead = new Thread(new ThreadStart(() =>
{
while (true)
{
NetworkStream NetworkStream1 = startTcpConnect(TcpListener1);
NetworkStreamList.Add(NetworkStream1);
if (NetworkStream1.DataAvailable == true) {
tcpReceiveMessage(TcpListener1, NetworkStream1, "UTF-8", succMessageHandler,errorMessageHandler);
}
}
}));
listenThead.Start();
}
/*
* 0 - Reverse
* 1 - Replace Spaces With Commas
* 2 - Remove Spaces
* 3 - Replace Commas With Spaces
*/
public void removeToChain(short opt)
{
if (opt == 0)
{
chainOp -= strRev;
}
else if (opt == 1)
{
chainOp -= rToComma;
}
else if (opt == 2)
{
chainOp -= removeSpaces;
}
else if (opt == 3)
{
chainOp -= rToSpace;
}
}
/// <summary>
/// 在socket客户端新开一个线程,监听来自服务器的socket的消息
/// </summary>
/// <param name="Socket1">socket对象</param>
/// <param name="encode">编码</param>
/// <param name="threadHandler1">操作当前的线程委托,参数为thread</param>
/// <param name="stringHandler1">接收消息失败时执行的委托,参数为string</param>
/// <param name="stringHandler2">收到消息后执行的委托,参数为string</param>
public void clentListenSocketMessage(Socket Socket1, string encode, threadHandler threadHandler1, stringHandler stringHandler1, stringHandler stringHandler2)
{
Thread Thread1 = new Thread(new ThreadStart(() =>
{
threadHandler1(Thread.CurrentThread);
string leaveMessage = string.Empty;
while (true)
{
string[] result = receiveMessageFromSocket(Socket1, encode);
//如果socket连接已断开,则终止监听该消息的线程
if (Socket1.Connected == false)
{
Thread.CurrentThread.Abort();
break;
}
if (result[0] == null)
{
stringHandler1(result[1]);
}
else
{
leaveMessage = leaveMessage + result[0];
Match Match1 = Regex1.Match(leaveMessage);
//消息未发送完成
if (Match1.Value == string.Empty)
{
}
//有完整的一条消息
else {
string decodeMessage = getMessageFromMyJson(Match1.Value);
leaveMessage = leaveMessage.Substring(Match1.Value.Length, leaveMessage.Length - Match1.Value.Length);
stringHandler2(decodeMessage);
}
}
}
}));
Thread1.Start();
}
public void tcpClientInit(string ip, int port, stringHandler failConnectHandler, networkStreamHandler networkStreamHandler1, stringHandler succReadHandler, stringHandler failReadHandler)
{
TcpClient TcpClient1 = new TcpClient();
try {
TcpClient1.Connect(ip, port);
}
catch(Exception e){
failConnectHandler(e.Message);
return;
}
Thread clientListenThread = new Thread(new ThreadStart(()=>{
NetworkStream NetworkStream1 = TcpClient1.GetStream();
networkStreamHandler1(NetworkStream1);
if (NetworkStream1.DataAvailable == true) {
readNetworkStream(NetworkStream1, "UTF-8", succReadHandler, failReadHandler);
}
}));
clientListenThread.Start();
}
public string applyChain(string text)
{
chainOp(ref text);
chainOp = str.getStr;
return(text);
}
public void setMessageHandler(stringHandler message)
{
this.messageHandler = message;
}
private void readNetworkStream(NetworkStream NetworkStream1, string encode, stringHandler succReadHandler, stringHandler failReadHandler)
{
Byte[] bytes = new Byte[1024];
try
{
int i = NetworkStream1.Read(bytes, 0, bytes.Length);
while (i != 0)
{
String message = Encoding.GetEncoding(encode).GetString(bytes, 0, i);
succReadHandler(message);
i = NetworkStream1.Read(bytes, 0, bytes.Length);
}
}
catch (Exception e)
{
failReadHandler(e.Message);
}
}
/// <summary>
/// 监听tcp客户端发来的一条消息，并在收到消息后以指定的编码读取数据，调用委托处理结果
/// </summary>
/// <param name="TcpListener1">监听的TcpListener对象</param>
/// <param name="encode">编码格式</param>
/// <param name="successHandler">成功接收消息后执行的委托,参数为消息的文本内容</param>
/// <param name="exceptionHandler">发生异常后执行的委托,参数为异常的Message内容</param>
public void tcpReceiveMessage(TcpListener TcpListener1, NetworkStream NetworkStream1, string encode, stringHandler successHandler, stringHandler exceptionHandler)
{
Byte[] bytes = new Byte[1024];
String data = null;
try
{
int i = NetworkStream1.Read(bytes, 0, bytes.Length);
while (i != 0)
{
data = Encoding.GetEncoding(encode).GetString(bytes, 0, i);
successHandler(data);
i = NetworkStream1.Read(bytes, 0, bytes.Length);
}
}
catch(Exception e) {
exceptionHandler(e.Message);
}
}
/// <summary>
/// 新开一个线程管理socket服务器收到的客户端连接
/// </summary>
/// <param name="ClientSocketList">所有客户端连接的集合</param>
/// <param name="StartSocket">服务器监听端口的socket</param>
/// <param name="manageThread">新开的管理线程</param>
private void manageConnectClient(List<Socket> ClientSocketList, Socket StartSocket, threadHandler manageThread, threadHandler listenThreadHandler, stringHandler errorMessageHandler, stringHandler succMessageHandler)
{
Thread t = new Thread(new ThreadStart(() =>
{
manageThread(Thread.CurrentThread);
while (true)
{
Socket ClientSocket = StartSocket.Accept();
ClientSocketList.Add(ClientSocket);
listenSocketMessage(ClientSocketList,ClientSocket, "UTF-8", listenThreadHandler, errorMessageHandler, succMessageHandler);
}
}));
t.Start();
}
/// <summary>
/// 以指定的本机端口初始化服务器socket链接，并分别新开1个所有客户端的socket管理线程和1个所有客户端的socket消息监听线程
/// </summary>
/// <param name="ip">本机ip</param>
/// <param name="port">机端口号</param>
/// <param name="listenNum">允许的最大客户端连接数</param>
/// <param name="listenFailHandler">监听端口失败时执行的委托</param>
/// <param name="manageThreadHandler">管理客户端连接的所有socket集合的线程</param>
/// <param name="listenThreadHandler">监听客户端消息的线程</param>
/// <param name="errorMessageHandler">监听消息失败时执行的委托</param>
/// <param name="succMessageHandler">收到客户端消息时执行的委托</param>
/// <param name="ClientSocketList">客户端连接的所有socket集合的对象</param>
public void socketServerInit(string ip, int port, int listenNum, stringHandler listenFailHandler, socketHandler socketHandler1, threadHandler manageThreadHandler, threadHandler listenThreadHandler, stringHandler errorMessageHandler, stringHandler succMessageHandler, List<Socket> ClientSocketList)
{
object[] object1 = startSocketServer(ip, port, listenNum);
Socket StartSocket = (Socket)object1[0];
//监听端口失败
if (StartSocket == null)
{
listenFailHandler((string)object1[1]);
return;
}
socketHandler1(StartSocket);
manageConnectClient(ClientSocketList, StartSocket, manageThreadHandler, listenThreadHandler, errorMessageHandler, succMessageHandler);
}
/// <summary>
/// 以指定ip和端口初始化客户端的socket连接，连接成功后会新增一个线程监听服务器的消息
/// </summary>
/// <param name="ip">服务器ip</param>
/// <param name="port">服务器端口</param>
/// <param name="connectFailHanlder">socket连接失败时执行的委托,参数为string</param>
/// <param name="currentSocketHandler">socket连接成功时执行的委托,参数为socket</param>
/// <param name="listenThreadHandler">监听消息线程的委托,参数为thread</param>
/// <param name="errorMessageHandler">socket接收消息失败时执行的委托,参数为string</param>
/// <param name="succMessageHandler">初始化成功后,接收到消息时执行的委托,参数为string</param>
public void socketClientInit(string ip, int port, string encode, stringHandler connectFailHanlder, socketHandler currentSocketHandler, threadHandler listenThreadHandler, stringHandler errorMessageHandler, stringHandler succMessageHandler)
{
object[] object1 = connectToSocketServer(ip, port);
Socket ClientSocket = (Socket)object1[0];
//判断建立连接是否失败
if (ClientSocket == null)
{
connectFailHanlder((string)object1[1]);
return;
}
//建立连接成功后返回该socket对象,用于发送和接收消息
currentSocketHandler(ClientSocket);
//使用该socket对象监听服务器链接
clentListenSocketMessage(ClientSocket, encode,
(listenMessageThread) =>
{
listenThreadHandler(listenMessageThread);
},
(receiveExc) =>
{
errorMessageHandler(receiveExc);
},
(result) =>
{
succMessageHandler(result);
});
}
