Socket简单通讯

C# code

public class XmlSocket
    {

        //异步socket诊听
        // Incoming data from client.从客户端传来的数据
        public static string data = null;

        // Thread signal.线程 用一个指示是否将初始状态设置为终止的布尔值初始化 ManualResetEvent 类的新实例。
        public static ManualResetEvent allDone = new ManualResetEvent(false);
        //static void Main(string[] args)
        //{
        //    StartListening();
        //}

        public static void StartListening()
        {
            // Data buffer for incoming data. 传入数据缓冲
            byte[] bytes = new Byte[1024];
            // Establish the local endpoint for the socket. 建立本地端口
            // The DNS name of the computer
            // running the listener is "host.contoso.com".

            IPAddress ipAddress;
            String ipString = ConfigurationManager.AppSettings.Get("SocketIP");
            if (ipString==null || ipString ==String.Empty)
            {
                IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());
                ipAddress = ipHostInfo.AddressList[0];
            }
            else
            {
                ipAddress = IPAddress.Parse(ipString);
            }

            int port;
            String portString = ConfigurationManager.AppSettings.Get("SocketPort");
            if (portString==null || portString==String.Empty)
            {
                port = 11001;
            }
            else
            {
                port = int.Parse(portString);
            }
            IPEndPoint localEndPoint = new IPEndPoint(ipAddress, port);

            // Create a TCP/IP socket.
            Socket listener = new Socket(AddressFamily.InterNetwork,
             SocketType.Stream, ProtocolType.Tcp);

            // Bind the socket to the local endpoint and listen for incoming connections.绑定端口和数据
            try
            {
                listener.Bind(localEndPoint);
                listener.Listen(100);

                while (true)
                {
                    // Set the event to nonsignaled state.设置无信号状态的事件
                    allDone.Reset();
                    // Start an asynchronous socket to listen for connections.重新 启动异步连接
                    listener.BeginAccept(new AsyncCallback(AcceptCallback), listener);
                    // Wait until a connection is made before continuing.等待连接创建后继续
                    allDone.WaitOne();
                }
            }
            catch (Exception e)
            {
                //
            }
        }

        public static void AcceptCallback(IAsyncResult ar)
        {
            try
            {
                // Signal the main thread to continue.接受回调方法 该方法的此节向主应用程序线程发出信号，
                //让它继续处理并建立与客户端的连接
                allDone.Set();
                // Get the socket that handles the client request.获取客户端请求句柄
                Socket listener = (Socket)ar.AsyncState;
                Socket handler = listener.EndAccept(ar);
                // Create the state object.
                StateObject state = new StateObject();
                state.workSocket = handler;
                handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
                 new AsyncCallback(ReadCallback), state);
            }
            catch (Exception e)
            {
                //
            }
        }

        /// <summary>
        /// 与接受回调方法一样，读取回调方法也是一个 AsyncCallback 委托。
        /// 该方法将来自客户端套接字的一个或多个字节读入数据缓冲区，然后再次调用 BeginReceive 方法，直到客户端发送的数据完成为止。
        /// 从客户端读取整个消息后，在控制台上显示字符串，并关闭处理与客户端的连接的服务器套接字。
        /// </summary>
        /// <param name="ar">IAsyncResult 委托</param>
        public static void ReadCallback(IAsyncResult ar)
        {
            try
            {
                String content = String.Empty;
                // Retrieve the state object and the handler socket创建自定义的状态对象 from the asynchronous state object.
                StateObject state = (StateObject)ar.AsyncState;
                Socket handler = state.workSocket;//处理的句柄
                // Read data from the client socket. 读出
                int bytesRead = handler.EndReceive(ar);
                if (bytesRead > 0)
                {
                    //业务代码
                    string result = DoSomeThing(...);
                    String len = Encoding.UTF8.GetBytes(result).Length.ToString().PadLeft(8, '0');
                    log.writeLine(len);
                    Send(len + result, handler);
                }
            }
            catch (Exception e)
            {
                //
            }

        }
        private static void Send(String data, Socket handler)
        {
            try
            {
                // Convert the string data to byte data using UTF8 encoding.
                byte[] byteData = Encoding.UTF8.GetBytes(data);
                // Begin sending the data to the remote device.
                handler.BeginSend(byteData, 0, byteData.Length, 0,
                 new AsyncCallback(SendCallback), handler);
            }
            catch (Exception e)
            {
                //
            }
        }
        /// <summary>
        /// 发送
        /// </summary>
        /// <param name="ar"></param>
        private static void SendCallback(IAsyncResult ar)
        {
            try
            {
                // Retrieve the socket from the state object.
                Socket handler = (Socket)ar.AsyncState;

                // Complete sending the data to the remote device.向远端发送数据
                int bytesSent = handler.EndSend(ar);
                StateObject state = new StateObject();
                state.workSocket = handler;

                handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,new AsyncCallback(ReadCallback), state);
                handler.Shutdown(SocketShutdown.Both);
                handler.Close();
            }
            catch (Exception e)
            {
//
            }
        }

        public static void StopListening()
        {
            allDone.Close();
            log.close();
        }

        /// <summary>
        /// 具体处理业务的方法
        /// </summary>
        /// <returns></returns>
        private static string DoSomething(int i)
        {
            //具体业务代码,返回需要返回的字符串信息
        }
        /// <summary>
        /// 写日志方法
        /// </summary>
        /// <param name="strLog">写入内容</param>
        public static void WriteLog(string strLog)
        {
             //写入日志代码
        }
    }

                        while (count >0) 
                        { 
                            clientSkt.Send(ret); 
                          count =  stream.Read(ret, 0, _maxPacket); 
                        } 
                        clientSkt.Send(Encoding.Unicode.GetBytes("Find::FindFriendEnd"));  
                        stream.Close(); 
                        TabFind = null; 
                        FindRow = null; //这里不需要再继续接受后继数据包了，跳出当前循环体。 
                        continue; 
                    } //请求添加好友 
                    if (_str.StartsWith("Find::AddFriendAsk")) 
                    { 
                        string UserName = _str.Substring("Find::AddFriendAsk".Length, _str.Length - "Find::AddFriendAsk".Length); 
                        //通过转发表查找接收方的套接字 
                        if (_transmit_tb.Count != 0 && _transmit_tb.ContainsKey(UserName)) 
                        { 
                            Socket receiverSkt = _transmit_tb[UserName] as Socket; 
                            receiverSkt.Send(Encoding.Unicode.GetBytes("Find::AddFriendAsk" + obj as string)); 
                        } 
                        //这里不需要再继续接受后继数据包了，跳出当前循环体。 
                        continue; 
                    } 
                    //回复答应添加好友 
                    if (_str.StartsWith("Find::AddFriendYes")) 
                    { 
                        string UserName = _str.Substring("Find::AddFriendYes".Length, _str.Length - "Find::AddFriendYes".Length); 
                      //// 保存数据 
                        DataTable TabmyFriend = new DataTable() ; 
                        //保存该用户 
                        TabmyFriend.ReadXml(MyPath + "\\UserFriend\\" +  obj as string + ".xml"); 
                        DataRow newRow = TabmyFriend.NewRow(); 
                        newRow["UserName"] = UserName; 
                        TabmyFriend.Rows.Add(newRow); 
                        TabmyFriend.WriteXml(MyPath + "\\UserFriend\\" + obj as string + ".xml", XmlWriteMode.WriteSchema, false); 
                        //保存其好友 
                        TabmyFriend = new DataTable(); 
                        TabmyFriend.ReadXml(MyPath + "\\UserFriend\\" + UserName + ".xml"); 
                        DataRow newRow1 = TabmyFriend.NewRow(); 
                        newRow1["UserName"] = obj as string; 
                        TabmyFriend.Rows.Add(newRow1); 
                        TabmyFriend.WriteXml(MyPath + "\\UserFriend\\" + UserName + ".xml", XmlWriteMode.WriteSchema, false); 
                        TabmyFriend = null; 
                        SerializeFriendList(obj, clientSkt);

C# code 
//"开始"按钮事件 

  private void button1_Click(object sender, System.EventArgs e) { 

   //取得预保存的文件名 

   string fileName=textBox3.Text.Trim(); 

   //远程主机 

   string hostName=textBox1.Text.Trim(); 

   //端口 

   int port=Int32.Parse(textBox2.Text.Trim()); 

   //得到主机信息 

   IPHostEntry ipInfo=Dns.GetHostByName(hostName); 

   //取得IPAddress[] 

   IPAddress[] ipAddr=ipInfo.AddressList; 

   //得到ip 

   IPAddress ip=ipAddr[0]; 

   //组合出远程终结点 

   IPEndPoint hostEP=new IPEndPoint(ip,port); 

   //创建Socket 实例 

   Socket socket=new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp); 

   try 

   { 

   //尝试连接 

   socket.Connect(hostEP); 

   } 

   catch(Exception se) 

   { 

   MessageBox.Show("连接错误"+se.Message,"提示信息 

   ,MessageBoxButtons.RetryCancel,MessageBoxIcon.Information); 

  } 

  //发送给远程主机的请求内容串 

  string sendStr="GET / HTTP/1.1\r\nHost: " + hostName + 

  "\r\nConnection: Close\r\n\r\n"; 

   //创建bytes字节数组以转换发送串 

   byte[] bytesSendStr=new byte[1024]; 

   //将发送内容字符串转换成字节byte数组 

   bytesSendStr=Encoding.ASCII.GetBytes(sendStr); 

  try 

  { 

  //向主机发送请求 

  socket.Send(bytesSendStr,bytesSendStr.Length,0); 

  } 

  catch(Exception ce) 

   { 

   MessageBox.Show("发送错误:"+ce.Message,"提示信息 

   ,MessageBoxButtons.RetryCancel,MessageBoxIcon.Information); 

   } 

   //声明接收返回内容的字符串 

   string recvStr=""; 

   //声明字节数组，一次接收数据的长度为1024字节 

   byte[] recvBytes=new byte[1024]; 

   //返回实际接收内容的字节数 

   int bytes=0; 

  //循环读取，直到接收完所有数据 

  while(true) 

  { 

  bytes=socket.Receive(recvBytes,recvBytes.Length,0); 

  //读取完成后退出循环 

  if(bytes〈=0) 

  break; 

  //将读取的字节数转换为字符串 

  recvStr+=Encoding.ASCII.GetString(recvBytes,0,bytes); 

  } 

  //将所读取的字符串转换为字节数组 

  byte[] content=Encoding.ASCII.GetBytes(recvStr); 

   try 

   { 

   //创建文件流对象实例 

   FileStream fs=new FileStream(fileName,FileMode.OpenOrCreate,FileAccess.ReadWrite); 

  //写入文件 

  fs.Write(content,0,content.Length); 

  } 

  catch(Exception fe) 

   { 

   MessageBox.Show("文件创建/写入错误:"+fe.Message,"提示信息",MessageBoxButtons.RetryCancel,MessageBoxIcon.Information); 

   } 

   //禁用Socket 

   socket.Shutdown(SocketShutdown.Both); 

   //关闭Socket 

   socket.Close(); 

   } 

   } 

TCP/UDP通讯 
//////////////////////////////////////////////////////////////////////// 
UDP的： 
C# code 

namespace UDPServer
{
    class Program
    {
        static void Main(string[] args)
        {
            int recv;
            byte[] data = new byte[1024]; 

            //构建TCP 服务器

            //得到本机IP，设置TCP端口号         
            IPEndPoint ipep = new IPEndPoint(IPAddress.Any , 8001);
            Socket newsock = new Socket(AddressFamily.InterNetwork, SocketType.Dgram , ProtocolType.Udp);

            //绑定网络地址
            newsock.Bind(ipep);

            Console.WriteLine("This is a Server, host name is {0}",Dns.GetHostName());

            //等待客户机连接
            Console.WriteLine("Waiting for a client...");

            //得到客户机IP
            IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);
            EndPoint Remote = (EndPoint)(sender);
            recv = newsock.ReceiveFrom(data, ref Remote);
            Console .WriteLine ("Message received from {0}: ", Remote.ToString ());
            Console .WriteLine (Encoding .ASCII .GetString (data ,0,recv ));

            //客户机连接成功后，发送欢迎信息
            string welcome = "Welcome ! ";

            //字符串与字节数组相互转换
            data  = Encoding .ASCII .GetBytes (welcome );

            //发送信息
            newsock .SendTo (data ,data.Length ,SocketFlags .None ,Remote );
            while (true )
            {
                data =new byte [1024];
                //发送接受信息
                recv =newsock.ReceiveFrom(data ,ref Remote);
                Console .WriteLine (Encoding .ASCII .GetString (data ,0,recv));
                newsock .SendTo (data ,recv ,SocketFlags .None ,Remote );
            }
        }

        }
    }




C# code 


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

namespace UDPClient
{
    class Program
    {
        static void Main(string[] args)
        {
            byte[] data = new byte[1024];
            string input ,stringData;

            //构建TCP 服务器

            Console.WriteLine("This is a Client, host name is {0}", Dns.GetHostName());

            //设置服务IP，设置TCP端口号
            IPEndPoint ipep = new IPEndPoint(IPAddress .Parse ("127.0.0.1") , 8001);

            //定义网络类型，数据连接类型和网络协议UDP
            Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);

            string welcome = "Hello! ";
            data = Encoding.ASCII.GetBytes(welcome);
            server.SendTo(data, data.Length, SocketFlags.None, ipep);
            IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);
            EndPoint Remote = (EndPoint)sender;

            data = new byte[1024];
            int recv = server.ReceiveFrom(data, ref Remote);
            Console.WriteLine("Message received from {0}: ", Remote.ToString());
            Console.WriteLine(Encoding .ASCII .GetString (data,0,recv));
            while (true)
            {
                input = Console .ReadLine ();
                if (input =="exit")
                    break ;
                server .SendTo (Encoding .ASCII .GetBytes (input ),Remote );
                data = new byte [1024];
                recv = server.ReceiveFrom(data, ref Remote);
                stringData = Encoding.ASCII.GetString(data, 0, recv);
                Console.WriteLine(stringData);
            }
            Console .WriteLine ("Stopping Client.");
            server .Close ();            
        }

        }
    }



简单的UDP 
C# code 


try
                    {
                        Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);  //向此网段发广播包
                          int UDPListenerPort = 8082;
                        IPAddress broadcast = IPAddress.Parse("192.168.0.255"); //此处根据IP及子网掩码改为相应的广播IP
                        string ts = "This is UPD string for sending";
                        byte[] sendbuf = Encoding.ASCII.GetBytes(ts);
                        IPEndPoint ep = new IPEndPoint(broadcast, UDPListenerPort);
                        s.SendTo(sendbuf, ep);

                    }
                    catch (Exception e)
                    {}



C# code 


           UdpClient listener;
            int UDPListenerPort = 8082;
            IPEndPoint groupEP = new IPEndPoint(IPAddress.Any, UDPListenerPort);

            try
            {
                while (true)
                {
                    byte[] bytes = listener.Receive(ref groupEP);
                    string RecIP = groupEP.ToString().Substring(0, groupEP.ToString().IndexOf(":"));  //收到发送UPD端的IP
                    string RecStr = Encoding.ASCII.GetString(bytes, 0, bytes.Length);   //收到的UPD字符串
                }
            }
            catch
            {}