C#使用Protocol Buffer(ProtoBuf)进行Unity中的Socket通信_C#教程

首先来说一下本文中例子所要实现的功能：

基于ProtoBuf序列化对象
使用Socket实现时时通信
数据包的编码和解码

下面来看具体的步骤：

一、Unity中使用ProtoBuf

导入DLL到Unity中，
创建网络传输的模型类：

using System;
using ProtoBuf;

//添加特性，表示可以被ProtoBuf工具序列化
[ProtoContract]
public class NetModel {
 //添加特性，表示该字段可以被序列化，1可以理解为下标
 [ProtoMember(1)]
 public int ID;
 [ProtoMember(2)]
 public string Commit;
 [ProtoMember(3)]
 public string Message;
}

using System;
using ProtoBuf;

//添加特性，表示可以被ProtoBuf工具序列化
[ProtoContract]
public class NetModel {
 //添加特性，表示该字段可以被序列化，1可以理解为下标
 [ProtoMember(1)]
 public int ID;
 [ProtoMember(2)]
 public string Commit;
 [ProtoMember(3)]
 public string Message;
}

在Unity中添加测试脚本，介绍ProtoBuf工具的使用。

using System;
using System.IO;

public class Test : MonoBehaviour {

 void Start () {
  //创建对象
  NetModel item = new NetModel(){ID = 1, Commit = "LanOu", Message = "Unity"};
  //序列化对象
  byte[] temp = Serialize(item);
  //ProtoBuf的优势一：小
  Debug.Log(temp.Length);
  //反序列化为对象
  NetModel result = DeSerialize(temp);
  Debug.Log(result.Message);

 }

 // 将消息序列化为二进制的方法
 // < param name="model">要序列化的对象< /param>
 private byte[] Serialize(NetModel model)
 {
  try {
   //涉及格式转换，需要用到流，将二进制序列化到流中
   using (MemoryStream ms = new MemoryStream()) {
    //使用ProtoBuf工具的序列化方法
    ProtoBuf.Serializer.Serialize<NetModel> (ms, model);
    //定义二级制数组，保存序列化后的结果
    byte[] result = new byte[ms.Length];
    //将流的位置设为0，起始点
    ms.Position = 0;
    //将流中的内容读取到二进制数组中
    ms.Read (result, 0, result.Length);
    return result;
   }
  } catch (Exception ex) {
   Debug.Log ("序列化失败: " + ex.ToString());
   return null;
  }
 }

 // 将收到的消息反序列化成对象
 // < returns>The serialize.< /returns>
 // < param name="msg">收到的消息.</param>
 private NetModel DeSerialize(byte[] msg)
 {
  try {
   using (MemoryStream ms = new MemoryStream()) {
    //将消息写入流中
    ms.Write (msg, 0, msg.Length);
    //将流的位置归0
    ms.Position = 0;
    //使用工具反序列化对象
    NetModel result = ProtoBuf.Serializer.Deserialize<NetModel> (ms);
    return result;
   }
  } catch (Exception ex) {
    Debug.Log("反序列化失败: " + ex.ToString());
    return null;
  }
 }
}

using System;
using System.IO;

public class Test : MonoBehaviour {

 void Start () {
  //创建对象
  NetModel item = new NetModel(){ID = 1, Commit = "LanOu", Message = "Unity"};
  //序列化对象
  byte[] temp = Serialize(item);
  //ProtoBuf的优势一：小
  Debug.Log(temp.Length);
  //反序列化为对象
  NetModel result = DeSerialize(temp);
  Debug.Log(result.Message);

 }

 // 将消息序列化为二进制的方法
 // < param name="model">要序列化的对象< /param>
 private byte[] Serialize(NetModel model)
 {
  try {
   //涉及格式转换，需要用到流，将二进制序列化到流中
   using (MemoryStream ms = new MemoryStream()) {
    //使用ProtoBuf工具的序列化方法
    ProtoBuf.Serializer.Serialize<NetModel> (ms, model);
    //定义二级制数组，保存序列化后的结果
    byte[] result = new byte[ms.Length];
    //将流的位置设为0，起始点
    ms.Position = 0;
    //将流中的内容读取到二进制数组中
    ms.Read (result, 0, result.Length);
    return result;
   }
  } catch (Exception ex) {
   Debug.Log ("序列化失败: " + ex.ToString());
   return null;
  }
 }

 // 将收到的消息反序列化成对象
 // < returns>The serialize.< /returns>
 // < param name="msg">收到的消息.</param>
 private NetModel DeSerialize(byte[] msg)
 {
  try {
   using (MemoryStream ms = new MemoryStream()) {
    //将消息写入流中
    ms.Write (msg, 0, msg.Length);
    //将流的位置归0
    ms.Position = 0;
    //使用工具反序列化对象
    NetModel result = ProtoBuf.Serializer.Deserialize<NetModel> (ms);
    return result;
   }
  } catch (Exception ex) {
    Debug.Log("反序列化失败: " + ex.ToString());
    return null;
  }
 }
}

二、Unity中使用Socket实现时时通信

通信应该实现的功能：

服务器可以时时监听多个客户端
服务器可以时时监听某一个客户端消息
服务器可以时时给某一个客户端发消息
首先我们需要定义一个客户端对象

using System;
using System.Net.Sockets;

// 表示一个客户端
public class NetUserToken {
 //连接客户端的Socket
 public Socket socket;
 //用于存放接收数据
 public byte[] buffer;

 public NetUserToken()
 {
  buffer = new byte[1024];
 }

 // 接受消息
 // < param name="data">Data.< /param>
 public void Receive(byte[] data)
 {
  UnityEngine.Debug.Log("接收到消息！");
 }

 // 发送消息
 //< param name="data">Data.< /param>
 public void Send(byte[] data)
 {  

 }
}

using System;
using System.Net.Sockets;

// 表示一个客户端
public class NetUserToken {
 //连接客户端的Socket
 public Socket socket;
 //用于存放接收数据
 public byte[] buffer;

 public NetUserToken()
 {
  buffer = new byte[1024];
 }

 // 接受消息
 // < param name="data">Data.< /param>
 public void Receive(byte[] data)
 {
  UnityEngine.Debug.Log("接收到消息！");
 }

 // 发送消息
 //< param name="data">Data.< /param>
 public void Send(byte[] data)
 {  

 }
}

然后实现我们的服务器代码

using System.Collections;
using System.Collections.Generic;
using System.Net;
using System;
using System.Net.Sockets;

public class NetServer{
 //单例脚本
 public static readonly NetServer Instance = new NetServer();
 //定义tcp服务器
 private Socket server;
 private int maxClient = 10;
 //定义端口
 private int port = 35353;
 //用户池
 private Stack<NetUserToken> pools;
 private NetServer()
 {
  //初始化socket
  server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
  server.Bind(new IPEndPoint(IPAddress.Any, port));

 }

 //开启服务器
 public void Start()
 {
  server.Listen(maxClient);
  UnityEngine.Debug.Log("Server OK!");
  //实例化客户端的用户池
  pools = new Stack<NetUserToken>(maxClient);
  for(int i = 0; i < maxClient; i++)
  {
   NetUserToken usertoken = new NetUserToken();
   pools.Push(usertoken);
  }
  //可以异步接受客户端, BeginAccept函数的第一个参数是回调函数，当有客户端连接的时候自动调用
  server.BeginAccept (AsyncAccept, null);
 }

 //回调函数， 有客户端连接的时候会自动调用此方法
 private void AsyncAccept(IAsyncResult result)
 {
  try {
   //结束监听，同时获取到客户端
   Socket client = server.EndAccept(result);
   UnityEngine.Debug.Log("有客户端连接");
   //来了一个客户端
   NetUserToken userToken = pools.Pop();
   userToken.socket = client;
   //客户端连接之后，可以接受客户端消息
   BeginReceive(userToken);

   //尾递归，再次监听是否还有其他客户端连入
   server.BeginAccept(AsyncAccept, null);
  } catch (Exception ex) {
   UnityEngine.Debug.Log(ex.ToString());
  }
 }

 //异步监听消息
 private void BeginReceive(NetUserToken userToken)
 {
  try {
   //异步方法
   userToken.socket.BeginReceive(userToken.buffer, 0, userToken.buffer.Length, SocketFlags.None,
           EndReceive, userToken);
  } catch (Exception ex) {
   UnityEngine.Debug.Log(ex.ToString());
  }
 }

 //监听到消息之后调用的函数
 private void EndReceive(IAsyncResult result)
 {
  try {
   //取出客户端
   NetUserToken userToken = result.AsyncState as NetUserToken;
   //获取消息的长度
   int len = userToken.socket.EndReceive(result);
   if(len > 0)
   {
    byte[] data = new byte[len];
    Buffer.BlockCopy(userToken.buffer, 0, data, 0, len);
    //用户接受消息
    userToken.Receive(data);
    //尾递归，再次监听客户端消息
    BeginReceive(userToken);
   }

  } catch (Exception ex) {
   UnityEngine.Debug.Log(ex.ToString());
  }
 }
}

using System.Collections;
using System.Collections.Generic;
using System.Net;
using System;
using System.Net.Sockets;

public class NetServer{
 //单例脚本
 public static readonly NetServer Instance = new NetServer();
 //定义tcp服务器
 private Socket server;
 private int maxClient = 10;
 //定义端口
 private int port = 35353;
 //用户池
 private Stack<NetUserToken> pools;
 private NetServer()
 {
  //初始化socket
  server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
  server.Bind(new IPEndPoint(IPAddress.Any, port));

 }

 //开启服务器
 public void Start()
 {
  server.Listen(maxClient);
  UnityEngine.Debug.Log("Server OK!");
  //实例化客户端的用户池
  pools = new Stack<NetUserToken>(maxClient);
  for(int i = 0; i < maxClient; i++)
  {
   NetUserToken usertoken = new NetUserToken();
   pools.Push(usertoken);
  }
  //可以异步接受客户端, BeginAccept函数的第一个参数是回调函数，当有客户端连接的时候自动调用
  server.BeginAccept (AsyncAccept, null);
 }

 //回调函数， 有客户端连接的时候会自动调用此方法
 private void AsyncAccept(IAsyncResult result)
 {
  try {
   //结束监听，同时获取到客户端
   Socket client = server.EndAccept(result);
   UnityEngine.Debug.Log("有客户端连接");
   //来了一个客户端
   NetUserToken userToken = pools.Pop();
   userToken.socket = client;
   //客户端连接之后，可以接受客户端消息
   BeginReceive(userToken);

   //尾递归，再次监听是否还有其他客户端连入
   server.BeginAccept(AsyncAccept, null);
  } catch (Exception ex) {
   UnityEngine.Debug.Log(ex.ToString());
  }
 }

 //异步监听消息
 private void BeginReceive(NetUserToken userToken)
 {
  try {
   //异步方法
   userToken.socket.BeginReceive(userToken.buffer, 0, userToken.buffer.Length, SocketFlags.None,
           EndReceive, userToken);
  } catch (Exception ex) {
   UnityEngine.Debug.Log(ex.ToString());
  }
 }

 //监听到消息之后调用的函数
 private void EndReceive(IAsyncResult result)
 {
  try {
   //取出客户端
   NetUserToken userToken = result.AsyncState as NetUserToken;
   //获取消息的长度
   int len = userToken.socket.EndReceive(result);
   if(len > 0)
   {
    byte[] data = new byte[len];
    Buffer.BlockCopy(userToken.buffer, 0, data, 0, len);
    //用户接受消息
    userToken.Receive(data);
    //尾递归，再次监听客户端消息
    BeginReceive(userToken);
   }

  } catch (Exception ex) {
   UnityEngine.Debug.Log(ex.ToString());
  }
 }
}

在Unity中开启服务器，并使用C#控制台模拟客户端连接、发送消息操作。测试OK了，Unity中可以时时监听到消息。

using UnityEngine;
using System.Collections;

public class CreateServer : MonoBehaviour {

 void StartServer () {
  NetServer.Instance.Start();
 }

}

//C#控制台工程

using System;
using System.Net;
using System.Net.Sockets;
using System.IO;
using System.Text;

namespace Temp
{
 class MainClass
 {
  public static void Main (string[] args)
  {
   TcpClient tc = new TcpClient();
   IPEndPoint ip = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 35353);
   tc.Connect(ip);

   if(tc.Connected)
   {
    while(true)
    {

     string msg = Console.ReadLine();
     byte[] result = Encoding.UTF8.GetBytes(msg);
     tc.GetStream().Write(result, 0, result.Length);
    }
   }
   Console.ReadLine();
  }
 }
}

using UnityEngine;
using System.Collections;

public class CreateServer : MonoBehaviour {

 void StartServer () {
  NetServer.Instance.Start();
 }

}

//C#控制台工程

using System;
using System.Net;
using System.Net.Sockets;
using System.IO;
using System.Text;

namespace Temp
{
 class MainClass
 {
  public static void Main (string[] args)
  {
   TcpClient tc = new TcpClient();
   IPEndPoint ip = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 35353);
   tc.Connect(ip);

   if(tc.Connected)
   {
    while(true)
    {

     string msg = Console.ReadLine();
     byte[] result = Encoding.UTF8.GetBytes(msg);
     tc.GetStream().Write(result, 0, result.Length);
    }
   }
   Console.ReadLine();
  }
 }
}

三、数据包的编码和解码

首先，举个例子，这个月信用卡被媳妇刷爆了，面对房贷车贷的压力，我只能选择分期付款。。。

那么OK了，现在我想问一下，当服务器向客户端发送的数据过大时怎么办呢？

当服务器需要向客户端发送一条很长的数据，也会“分期付款！”，服务器会把一条很长的数据分成若干条小数据，多次发送给客户端。

可是，这样就又有另外一个问题，客户端接受到多条数据之后如何解析？

这里其实就是客户端的解码。server发数据一般采用“长度+内容”的格式，Client接收到数据之后，先提取出长度来，然后根据长度判断内容是否发送完毕。

再次重申，用户在发送序列化好的消息的前，需要先编码后再发送消息；用户在接受消息后，需要解码之后再解析数据（反序列化）。

using UnityEngine;
using System.Collections.Generic;
using System.IO;

// 编码和解码
public class NetEncode {

 // 将数据编码 长度+内容
 /// < param name="data">内容< /param>
 public static byte[] Encode(byte[] data)
 {
  //整形占四个字节，所以声明一个+4的数组
  byte[] result = new byte[data.Length + 4];
  //使用流将编码写二进制
  MemoryStream ms = new MemoryStream();
  BinaryWriter br = new BinaryWriter(ms);
  br.Write(data.Length);
  br.Write(data);
  //将流中的内容复制到数组中
  System.Buffer.BlockCopy(ms.ToArray(), 0, result, 0, (int)ms.Length);
  br.Close();
  ms.Close();
  return result;
 }

 // 将数据解码
 // < param name="cache">消息队列< /param>
 public static byte[] Decode(ref List<byte> cache)
 {
  //首先要获取长度，整形4个字节，如果字节数不足4个字节
  if(cache.Count < 4)
  {
   return null;
  }
  //读取数据
  MemoryStream ms = new MemoryStream(cache.ToArray());
  BinaryReader br = new BinaryReader(ms);
  int len = br.ReadInt32();
  //根据长度，判断内容是否传递完毕
  if(len > ms.Length - ms.Position)
  {
   return null;
  }
  //获取数据
  byte[] result = br.ReadBytes(len);
  //清空消息池
  cache.Clear();
  //讲剩余没处理的消息存入消息池
  cache.AddRange(br.ReadBytes((int)ms.Length - (int)ms.Position));

  return result;
 }
}

using UnityEngine;
using System.Collections.Generic;
using System.IO;

// 编码和解码
public class NetEncode {

 // 将数据编码 长度+内容
 /// < param name="data">内容< /param>
 public static byte[] Encode(byte[] data)
 {
  //整形占四个字节，所以声明一个+4的数组
  byte[] result = new byte[data.Length + 4];
  //使用流将编码写二进制
  MemoryStream ms = new MemoryStream();
  BinaryWriter br = new BinaryWriter(ms);
  br.Write(data.Length);
  br.Write(data);
  //将流中的内容复制到数组中
  System.Buffer.BlockCopy(ms.ToArray(), 0, result, 0, (int)ms.Length);
  br.Close();
  ms.Close();
  return result;
 }

 // 将数据解码
 // < param name="cache">消息队列< /param>
 public static byte[] Decode(ref List<byte> cache)
 {
  //首先要获取长度，整形4个字节，如果字节数不足4个字节
  if(cache.Count < 4)
  {
   return null;
  }
  //读取数据
  MemoryStream ms = new MemoryStream(cache.ToArray());
  BinaryReader br = new BinaryReader(ms);
  int len = br.ReadInt32();
  //根据长度，判断内容是否传递完毕
  if(len > ms.Length - ms.Position)
  {
   return null;
  }
  //获取数据
  byte[] result = br.ReadBytes(len);
  //清空消息池
  cache.Clear();
  //讲剩余没处理的消息存入消息池
  cache.AddRange(br.ReadBytes((int)ms.Length - (int)ms.Position));

  return result;
 }
}

用户接受数据代码如下：

using System;
using System.Collections.Generic;
using System.Net.Sockets;

// 表示一个客户端
public class NetUserToken {
 //连接客户端的Socket
 public Socket socket;
 //用于存放接收数据
 public byte[] buffer;
 //每次接受和发送数据的大小
 private const int size = 1024;

 //接收数据池
 private List<byte> receiveCache;
 private bool isReceiving;
 //发送数据池
 private Queue<byte[]> sendCache;
 private bool isSending;

 //接收到消息之后的回调
 public Action<NetModel> receiveCallBack;

 public NetUserToken()
 {
  buffer = new byte[size];
  receiveCache = new List<byte>();
  sendCache = new Queue<byte[]>();
 }

 // 服务器接受客户端发送的消息
 // < param name="data">Data.< /param>
 public void Receive(byte[] data)
 {
  UnityEngine.Debug.Log("接收到数据");
  //将接收到的数据放入数据池中
  receiveCache.AddRange(data);
  //如果没在读数据
  if(!isReceiving)
  {
   isReceiving = true;
   ReadData();
  }
 }

 // 读取数据
 private void ReadData()
 {
  byte[] data = NetEncode.Decode(ref receiveCache);
  //说明数据保存成功
  if(data != null)
  {
   NetModel item = NetSerilizer.DeSerialize(data);
   UnityEngine.Debug.Log(item.Message);
   if(receiveCallBack != null)
   {
    receiveCallBack(item);
   }
   //尾递归，继续读取数据
   ReadData();
  }
  else
  {
   isReceiving = false;
  }
 }

 // 服务器发送消息给客户端
 public void Send()
 {
  try {
   if (sendCache.Count == 0) {
    isSending = false;
    return;
   }
   byte[] data = sendCache.Dequeue ();
   int count = data.Length / size;
   int len = size;
   for (int i = 0; i < count + 1; i++) {
    if (i == count) {
     len = data.Length - i * size;
    }
    socket.Send (data, i * size, len, SocketFlags.None);
   }
   UnityEngine.Debug.Log("发送成功!");
   Send ();
  } catch (Exception ex) {
   UnityEngine.Debug.Log(ex.ToString());
  }
 }

 public void WriteSendDate(byte[] data){
  sendCache.Enqueue(data);
  if(!isSending)
  {
   isSending = true;
   Send();
  }
 }
}

using System;
using System.Collections.Generic;
using System.Net.Sockets;

// 表示一个客户端
public class NetUserToken {
 //连接客户端的Socket
 public Socket socket;
 //用于存放接收数据
 public byte[] buffer;
 //每次接受和发送数据的大小
 private const int size = 1024;

 //接收数据池
 private List<byte> receiveCache;
 private bool isReceiving;
 //发送数据池
 private Queue<byte[]> sendCache;
 private bool isSending;

 //接收到消息之后的回调
 public Action<NetModel> receiveCallBack;

 public NetUserToken()
 {
  buffer = new byte[size];
  receiveCache = new List<byte>();
  sendCache = new Queue<byte[]>();
 }

 // 服务器接受客户端发送的消息
 // < param name="data">Data.< /param>
 public void Receive(byte[] data)
 {
  UnityEngine.Debug.Log("接收到数据");
  //将接收到的数据放入数据池中
  receiveCache.AddRange(data);
  //如果没在读数据
  if(!isReceiving)
  {
   isReceiving = true;
   ReadData();
  }
 }

 // 读取数据
 private void ReadData()
 {
  byte[] data = NetEncode.Decode(ref receiveCache);
  //说明数据保存成功
  if(data != null)
  {
   NetModel item = NetSerilizer.DeSerialize(data);
   UnityEngine.Debug.Log(item.Message);
   if(receiveCallBack != null)
   {
    receiveCallBack(item);
   }
   //尾递归，继续读取数据
   ReadData();
  }
  else
  {
   isReceiving = false;
  }
 }

 // 服务器发送消息给客户端
 public void Send()
 {
  try {
   if (sendCache.Count == 0) {
    isSending = false;
    return;
   }
   byte[] data = sendCache.Dequeue ();
   int count = data.Length / size;
   int len = size;
   for (int i = 0; i < count + 1; i++) {
    if (i == count) {
     len = data.Length - i * size;
    }
    socket.Send (data, i * size, len, SocketFlags.None);
   }
   UnityEngine.Debug.Log("发送成功!");
   Send ();
  } catch (Exception ex) {
   UnityEngine.Debug.Log(ex.ToString());
  }
 }

 public void WriteSendDate(byte[] data){
  sendCache.Enqueue(data);
  if(!isSending)
  {
   isSending = true;
   Send();
  }
 }
}

ProtoBuf网络传输到这里就全部完成了。

以上是小编为您精心准备的的内容，在的博客、问答、公众号、人物、课程等栏目也有的相关内容，欢迎继续使用右上角搜索按钮进行搜索c#
， unity
， socket
， protobuf
ProtocolBuffer
c站、c语言、cf、ch、c罗，以便于您获取更多的相关知识。

时间： 2024-02-28 14:14:35

C#使用Protocol Buffer(ProtoBuf)进行Unity中的Socket通信_C#教程的相关文章

Java Web项目中使用Socket通信多线程、长连接的方法_java

很多时候在javaweb项目中我们需要用到Socket通信来实现功能,在web中使用Socket我们需要建立一个监听程序,在程序启动时,启动socket监听.我们的应用场景是在java项目中,需要外接如一个硬件设备,通过tcp通信,获取设备传上来的数据,并对数据做回应. 先看一下web的监听代码: import javax.servlet.ServletContextEvent; import javax.servlet.ServletContextListener; public class

线程-android中UDP socket通信的问题

问题描述 android中UDP socket通信的问题我使用两个线程,一个用来发送数据,一个用来接收数据,先开启接收数据线程,接收到数据之后然后回应给对方,但是发送一直停在SocketAddess s=pacakge.getSocketAddess这一步,pacakge是接收到的包.接收线程是这样的:while(true){ socket.receive(packge);}接收到包之后我开启发送线程就卡在上面那步了,是不是 socket在处于阻塞状态时不能发送数据包啊? 解决方案默认是

datagramsocket-flex中的socket通信里bind()与connect()的区别

问题描述 flex中的socket通信里bind()与connect()的区别根据api里的描述, bind(localPort:int = 0, localAddress:String = "0.0.0.0"):void 将此套接字绑定到指定的本地地址和端口. connect(remoteAddress:String, remotePort:int):void 将套接字连接到指定的远程地址和端口. 那么 q1:他们仅仅是分别绑定本地地址和连接远程地址的区别吗? q2:如果在指定本地

浅谈C#中正则表达式的使用_C#教程

目前为止,许多编程语言和工具都包含对正则表达式的支持,C#也不例外,C#基础类库中包含有一个命名空间(System.Text.RegularExpressions)和一系列可以充分发挥规则表达式威力的类(Regex.Match.Group等).那么,什么是正则表达式,怎么定义正则表达式呢? 一.正则表达式基础什么是正则表达式在编写字符串的处理程序时,经常会有查找符合某些复杂规则的字符串的需要.正则表达式就是用于描述这些规则的工具.换句话说,正则表达式就是记录文本规则的代码. 通常,我们在使用

C#设置子窗体在主窗体中居中显示解决方案_C#教程

问题的开始是由C#传传看主群里的印醒提出来的,下面我来说一下解决方案吧其实表面上看是很简单的开始吧,现在有两个窗体Form1主窗体,Form2子窗体而且我相信大部分人都会这样写在子窗体的Load事件中这样写复制代码代码如下: this.StartPosition = FormStartPosition.CenterParent; 其实这样写是不对的,正确的写法应该是复制代码代码如下: this.StartPosition = FormStartPosition.CenterSc

Android中使用socket通信实现消息推送的方法详解_Android

原理最近用socket写了一个消息推送的demo,在这里和大家分享一下. 主要实现了:一台手机向另外一台手机发送消息,这两台手机可以随时自由发送文本消息进行通信,类似我们常用的QQ. 效果图: 原理:手机通过socket发送消息到服务器,服务器每接收到一条消息之后,都会把这条消息放进一个messageList里面,服务器会不停地检测messageList是否含有消息,如果有的话就会根据messageList里面item的数据,推送到相应的另一端手机上面. 下面简单画了一个图来说明这个原理: 演示

请问C#中的socket通信服务器端accept函数的使用时机

问题描述 c#的socket编程服务器端一般遵循1.创建socket实例2.bind3.listen4.accept等待客户端链接5.receive/send....等等步骤问题如下:1.请问accept等待链接我看到很多实例是在Form_Load中调用了一次,我在想,只调用了一次如果客户端关掉重新启动,服务器端会不会建立新的客户端链接2.在msdn帮助中说accept函数在链接时会返回一个socket类型的实例,那么在没有客户端和他链接呢,是什么情况?返回一个空的socket实例吗?3.一般如

C＃7.0中新特性汇总_C#教程

以下将是 C# 7.0 中所有计划的语言特性的描述.随着 Visual Studio "15" Preview 4 版本的发布,这些特性中的大部分将活跃起来.现在是时候来展示这些特性,你也告诉借此告诉我们你的想法! C#7.0 增加了许多新功能,并专注于数据消费,简化代码和性能的改善.或许最大的特性就是元祖和模式匹配,元祖可以很容易地拥有多个返回结果,而模型匹配可以根据数据的"形"的不同来简化代码.我们希望,将它们结合起来,从而使你的代码更加简洁高效,也可以使你更加

浅谈C# 中的委托和事件_C#教程

引言委托和事件在 .Net Framework中的应用非常广泛,然而,较好地理解委托和事件对很多接触C#时间不长的人来说并不容易.它们就像是一道槛儿,过了这个槛的人,觉得真是太容易了,而没有过去的人每次见到委托和事件就觉得心里别(biè)得慌,混身不自在.本文中,我将通过两个范例由浅入深地讲述什么是委托.为什么要使用委托.事件的由来..Net Framework中的委托和事件.委托和事件对Observer设计模式的意义,对它们的中间代码也做了讨论. 将方法作为方法的参数我们先不管这个标题