一，iOS网络编程层次模型

Cocoa 中网络编程层次结构分为三层iOS网络编程层次结构也分为三层：

• Cocoa层：NSURL，Bonjour，Game Kit，WebKit
• Core Foundation层：基于 C 的 CFNetwork 和 CFNetServices
• OS层:基于 C 的 BSD socket

Cocoa层是最上层的基于 Objective-C 的 API，比如 URL访问，Nsstream，Bonjour，GameKit等，这是大多数情况下我们常用的 API。Cocoa 层是基于 Core Foundation 实现的。

Core Foundation层：因为直接使用 socket 需要更多的编程工作，所以苹果对 OS 层的 socket 进行简单的封装以简化编程任务。该层提供了 CFNetwork 和 CFNetServices，其中 CFNetwork 又是基于 CFStream 和 CFSocket。

OS层：最底层的 BSD socket 提供了对网络编程最大程度的控制，但是编程工作也是最多的。因此，苹果建议我们使用 Core Foundation 及以上层的 API 进行编程。

本文将介绍如何在 iOS 系统下使用最底层的 socket 进行编程，这和在 window 系统下使用 C/C++ 进行 socket 编程并无多大区别。

本文源码：http://download.csdn.net/detail/iot_li/9200329

运行效果如下：

BSD socket API 和 winsock API 接口大体差不多，下面将列出比较常用的 API：

int socket(int addressFamily,int type,
int protocol)

int close(int socketFileDescriptor)

int bind(int socketFileDescriptor,
sockaddr *addresstoBind,
int addressstructLength) 

int accept(int socketFileDescriptor,sockaddr *clientAddress,int
clientAddressstructLength)

int connect(int socketFileDescriptor,sockaddr *serverAddress,int
serverAddressLength)

hostent* gethostbyname(char *hostname)

int send(int socketFileDescriptor,char
*buffer,int bufferLength,int flags)

int receive(int socketFileDescriptor,int flags)

int sendto(int socketFileDescriptor,char *buffer,int
flags,sockaddr *destinationAddress,int
destinationAddressLength)

int recvfrom(int socketFileDescriptor,sockaddr *fromAddress,int
*fromAddressLength)

三，服务器工作流程

有了上面的 socket API 讲解，下面来总结一下服务器的工作流程。

1. 服务器调用 socket(...) 创建socket；
2. 服务器调用 listen(...) 设置缓冲区；
3. 服务器通过 accept(...)接受客户端请求建立连接；
4. 服务器与客户端建立连接之后，就可以通过 send(...)/receive(...)向客户端发送或从客户端接收数据；
5. 服务器调用 close 关闭 socket；

由于 iOS 设备通常是作为客户端，因此在本文中不会用代码来演示如何建立一个iOS服务器：

1.直接用一个WiFi模块作为服务端，不用写一句代码，像Android一样，通过IP、Port连接上WiFi模块，即可控制局域网中的家居设备。

2.可以参考文：《深入浅出Cocoa之Bonjour网络编程》：http://www.cnblogs.com/kesalin/archive/2011/09/15/cocoa_bonjour.html看看如何在 Mac 系统下建立桌面服务器。

四，客户端工作流程

由于 iOS 设备通常是作为客户端，下文将演示如何编写客户端代码。先来总结一下客户端工作流程。

1. 客户端调用 socket(...) 创建socket；
2. 客户端调用 connect(...) 向服务器发起连接请求以建立连接；
3. 客户端与服务器建立连接之后，就可以通过 send(...)/receive(...)向客户端发送或从客户端接收数据；
4. 客户端调用 close 关闭 socket；

五，客户端代码示例

下面的代码就实现了上面客户端的工作流程：

- (void)loadDataFromServerWithURL:(NSURL *)url
{
    Nsstring * host = [url host];
    NSNumber * port = [url port];
    
    // Create socket
    //
    int socketFileDescriptor = socket(AF_INET,SOCK_STREAM,0);
    if (-1 == socketFileDescriptor) {
        NSLog(@"Failed to create socket.");
        return;
    }
    
     Get IP address from host
    struct hostent * remoteHostEnt = gethostbyname([host UTF8String]);
    if (NULL == remoteHostEnt) {
        close(socketFileDescriptor);
        
        [self networkFailedWithErrorMessage:Unable to resolve the hostname of the warehouse server."];
        struct in_addr * remoteInAddr = (struct in_addr *)remoteHostEnt->h_addr_list[0];
    
     Set the socket parameters
    struct sockaddr_in socketParameters;
    socketParameters.sin_family = AF_INET;
    socketParameters.sin_addr = *remoteInAddr;
    socketParameters.sin_port = htons([port intValue]);
    
     Connect the socket
    int ret = connect(socketFileDescriptor,(struct sockaddr *) &socketParameters,sizeof(socketParameters));
    1 == ret) {
        close(socketFileDescriptor);
        
        Nsstring * errorInfo = [Nsstring stringWithFormat: >> Failed to connect to %@:%@",host,port];
        [self networkFailedWithErrorMessage:errorInfo];
        return;
    }
    
    NSLog( >> Successfully connected to %@:%@ [[NSMutableData alloc] init];
    BOOL waitingForData = YES;
    
     Continually receive data until we reach the end of the data
    int maxCount = 5;    just for test.
    int i = 0;
    while (waitingForData && i < maxCount) {
        const char * buffer[1024];
        int length = sizeof(buffer);
        
         Read a buffer's amount of data from the socket; the number of bytes read is returned
        //
        int result = recv(socketFileDescriptor,&buffer,length,128); line-height:1.5!important">0);
        if (result > 0) {
            [data appendBytes:buffer length:result];
        }
        else {
             if we didn't get any data,stop the receive loop
            //
            waitingForData = NO;
        }
        
        ++i;
    }
    
     Close the socket
    //
 close(socketFileDescriptor);
    
    [self networkSucceedWithData:data];
}

前面说过，connect/recv/send 等接口都是阻塞式的，因此我们需要将这些操作放在非 UI 线程中进行。如下所示：

    NSThread * backgroundThread = [[NSThread alloc] initWithTarget:self
                                                          selector:@selector(loadDataFromServerWithURL:)
                                                            object:url];
    [backgroundThread start];

同样，在获取到数据或者网络异常导致任务失败，我们需要更新 UI，这也要回到 UI 线程中去做这个事情。如下所示：

public void OpenTCP() {
        System.out.println("***startTCP***" + Ip + ":" + tcpPort);
        tcpsendData = "1";
        try {
            tcpSocket = new Socket(Ip, Integer.parseInt(tcpPort));
//            tcpSocket.setSoTimeout(1000);
        } catch (Exception ex) {
            Log.e("TCP连接错误:", "TCP连接错误");
            Log.e("TCP连接错误:", ex.toString());
            ex.printStackTrace();
        }
        if (tcpSocket != null) {
            new Thread(TcpReceiver).start();
        }

    }

    Runnable TcpReceiver = new Runnable() {
        @Override
        public void run() {
byte[] buffer0=null;
            byte[] buffer=null;

            System.out.println("***startTCP---tcpPort***" + tcpPort);
            while (true) {

                try {
//                    tcpSocket = new Socket(Ip, Integer.parseInt(tcpPort));
                    //接收数据
                    buffer0 = new byte[10];
                    InputStream inputStream0 = tcpSocket.getInputStream();
                    DataInputStream input0 = new DataInputStream(inputStream0);
                    int length0 = input0.read(buffer0);
                    if (length0 <10) {
                        //发送数据
           
                        OutputStream OutStream = tcpSocket.getOutputStream();
                        OutStream.write("1".getBytes());
                        OutStream.flush();
      

                        String lengthMsg = new String(buffer0, 0, length0, "gb2312");
                        Log.e("lengthMsg:", "" + lengthMsg);
                        int size = Integer.parseInt(lengthMsg);
                        buffer = new byte[size];
                        int len = 0;
                        int offset=0;
                        while (len < size) {
                            offset=size-len;
                            if(offset>=1024*5){
                                offset=1024*5;
                            }
                            len += input0.read(buffer, len, offset);
//                            System.out.println("***len***" + len);
                        }
                        System.out.println("***buffer.length***" + buffer.length);
                        final Bitmap bitmap = BitmapFactory.decodeByteArray(buffer, 0, buffer.length);

                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                image.setImageBitmap(bitmap);
                           }
                        });
                       //                        if (!bitmap.isRecycled()) {
//                            bitmap.recycle();
//                        }
                    } else {
                        continue;
                    }
//                    tcpSocket.close();

                } catch (IOException e) {
                    Log.e("接收错误:", e.toString());
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            Toast.makeText(MainActivity_tcp.this, "网络接收断开", Toast.LENGTH_SHORT).show();
                        }
                    });
                    try {
                        tcpSocket = new Socket(Ip, Integer.parseInt(tcpPort));
                    }catch (IOException e1) {
                        e1.printStackTrace();
                    }

                }
            }

        }
    };

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Net;
using System.Net.sockets;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.Threading;
using System.Runtime.InteropServices;
  
public delegate void DGShowMsg(string strMsg);
namespace Server
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            TextBox.CheckForIllegalCrossthreadCalls = false;//关闭跨线程修改控件检查
            // txtIP.Text = Dns.GetHostEntry(Dns.GetHostName()).AddressList[0].ToString();
            txtIP.Text = Dns.GetHostByName(Dns.GetHostName()).AddressList[0].ToString();
        }
    
        [DllImport("kernel32")] ///获取系统时间
        public static extern void GetSystemTime(ref SYstemTIME_INFO stinfo);
          
  
        ///定义系统时间结构信息
        [StructLayout(LayoutKind.Sequential)]
        public struct SYstemTIME_INFO
        {
            public ushort wYear;
            public ushort wMonth;
            public ushort wDayOfWeek;
            public ushort wDay;
            public ushort wHour;
            public ushort wMinute;
            public ushort wSecond;
            public ushort wMilliseconds;
        }
  
        Socket sokWatch = null;//负责监听 客户端段 连接请求的  套接字(女生宿舍的大妈)
        Thread threadWatch = null;//负责 调用套接字， 执行 监听请求的线程
          
        //开启监听 按钮
        private void btnStartListen_Click(object sender,EventArgs e)
        {
            //实例化 套接字 （ip4寻址协议，流式传输，TCP协议）
            sokWatch = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
                  
            //创建 ip对象
            IPAddress address = IPAddress.Parse(txtIP.Text.Trim());
           // IPAddress[] addressList = Dns.GetHostEntry(Dns.GetHostName()).AddressList;
            //string ip= this.geta
            //创建网络节点对象 包含 ip和port
           // IPEndPoint endpoint = new IPEndPoint(address,int.Parse(txtPort.Text.Trim())); comboBox1.Text.Trim();
            IPEndPoint endpoint = new IPEndPoint(address,int.Parse(comboBox1.Text.Trim()));
            //将 监听套接字  绑定到 对应的IP和端口
            sokWatch.Bind(endpoint);
            //设置 监听队列 长度为10(同时能够处理 10个连接请求)
            sokWatch.Listen(20);
            threadWatch = new Thread(StartWatch);
            threadWatch.IsBackground = true;
            threadWatch.Start();
            //txtShow.AppendText("启动服务器成功......rn");
            label4.Text = "启动服务器成功......";
              
        }
        //Dictionary<string,Socket> dictSocket = new Dictionary<string,Socket>();
        Dictionary<string,ConnectionClient> dictConn = new Dictionary<string,ConnectionClient>();
  
        bool isWatch = true;
  
        #region 1.被线程调用 监听连接端口
        /// <summary>
        /// 被线程调用 监听连接端口
        /// </summary>
        void StartWatch()
        {
            string recode;
            while (isWatch)
            {
                //threadWatch.SetApartmentState(ApartmentState.STA);
                //监听 客户端 连接请求，但是，Accept会阻断当前线程
                Socket sokMsg = sokWatch.Accept();//监听到请求，立即创建负责与该客户端套接字通信的套接字
                ConnectionClient connection = new ConnectionClient(sokMsg,ShowMsg,RemoveClientConnection);
                //将负责与当前连接请求客户端 通信的套接字所在的连接通信类 对象 装入集合
                dictConn.Add(sokMsg.RemoteEndPoint.ToString(),connection);
                //将 通信套接字 加入 集合，并以通信套接字的远程IpPort作为键
                //dictSocket.Add(sokMsg.RemoteEndPoint.ToString(),sokMsg);
                //将 通信套接字的 客户端IP端口保存在下拉框里
                cboClient.Items.Add(sokMsg.RemoteEndPoint.ToString());
                MessageBox.Show("有一个客户端新添加！");
                recode = sokMsg.RemoteEndPoint.ToString();
                //调用GetSystemTime函数获取系统时间信息
                SYstemTIME_INFO StInfo; StInfo = new SYstemTIME_INFO();
                GetSystemTime(ref StInfo);
                recode +="子计算机在"+StInfo.wYear.ToString() + "年" + StInfo.wMonth.ToString() + "月" + StInfo.wDay.ToString() + "日";
                recode += (StInfo.wHour + 8).ToString() + "点" + StInfo.wMinute.ToString() + "分" + StInfo.wSecond.ToString() + "秒"+"连接服务";
                  
                //记录每台子计算机连接服务主机的日志
                StreamWriter m_sw = new StreamWriter(System.Windows.Forms.Application.StartupPath + @"\file.DAT",true);
                m_sw.WriteLine(recode);
                m_sw.WriteLine("------------------------------------------------------------------");
                m_sw.Close();
                //MessageBox.Show(recode);
                dictConn[sokMsg.RemoteEndPoint.ToString()].SendTrue();
                //启动一个新线程，负责监听该客户端发来的数据
                //Thread threadConnection = new Thread(ReciveMsg);
                //threadConnection.IsBackground = true;
                //threadConnection.Start(sokMsg);
                  
            }
        }
        #endregion
  
        //bool isRec = true;
        //与客户端通信的套接字 是否 监听消息
  
        #region 发送消息 到指定的客户端 -btnSend_Click
        //发送消息 到指定的客户端
  
        private void btnSend_Click(object sender,EventArgs e)
        {
            //byte[] arrMsg = System.Text.Encoding.UTF8.GetBytes(txtInput.Text.Trim());
            //从下拉框中 获得 要哪个客户端发送数据
            string time;
            string connectionSokKey = cboClient.Text;
            if (!string.IsNullOrEmpty(connectionSokKey))
            {
                //从字典集合中根据键获得 负责与该客户端通信的套接字，并调用send方法发送数据过去
                dictConn[connectionSokKey].Send(txtInput.Text.Trim());
                SYstemTIME_INFO StInfo; StInfo = new SYstemTIME_INFO();
                GetSystemTime(ref StInfo);
                time = StInfo.wYear.ToString() + "/" + StInfo.wMonth.ToString() + "/" + StInfo.wDay.ToString() +"  ";
                time += (StInfo.wHour + 8).ToString() + ":" + StInfo.wMinute.ToString();
                richTextBox1.AppendText(time + "rn");
                richTextBox1.AppendText("对" + cboClient.Text +"说："+ txtInput.Text.Trim() + "rn");
                txtInput.Text = "";
                //sokMsg.Send(arrMsg);
            }
            else
            {
                MessageBox.Show("请选择要发送的子计算机～～");
            }
        }
        #endregion
  
        //发送闪屏
        private void btnShack_Click(object sender,EventArgs e)
        {
            string connectionSokKey = cboClient.Text;
            if (!string.IsNullOrEmpty(connectionSokKey))
            {
                dictConn[connectionSokKey].SendShake();
            }
            else
            {
                MessageBox.Show("请选择要发送的子计算机～～");
            }
        }
        //群闪
        private void btnShackAll_Click(object sender,EventArgs e)
        {
            foreach (ConnectionClient conn in dictConn.Values)
            {
                conn.SendShake();
            }
        }
         
        #region 2 移除与指定客户端的连接 +void RemoveClientConnection(string key)
        /// <summary>
        /// 移除与指定客户端的连接
        /// </summary>
        /// <param name="key">指定客户端的IP和端口</param>
        public void RemoveClientConnection(string key)
        {
            if (dictConn.ContainsKey(key))
            {
                dictConn.Remove(key);
                MessageBox.Show(key +"断开连接");
                cboClient.Items.Remove(key);
            }
        }
        #endregion
  
        //选择要发送的文件
        private void btnChooseFile_Click(object sender,EventArgs e)
        {
            OpenFileDialog ofd = new OpenFileDialog();
            if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                txtFilePath.Text = ofd.FileName;
            }
        }
  
        //发送文件
        private void btnSendFile_Click(object sender,EventArgs e)
        {
            //拿到下拉框中选中的客户端IPPORT
            string key = cboClient.Text;
            if (!string.IsNullOrEmpty(key))
            {
                dictConn[key].SendFile(txtFilePath.Text.Trim());
               // txtFilePath.Text = "";
            }
            else
            {
                MessageBox.Show("请选择要发送的子计算机~");
            }
        }
  
        #region 向文本框显示消息 -void ShowMsg(string msgStr)
        /// <summary>
        /// 向文本框显示消息
        /// </summary>
        /// <param name="msgStr">消息</param>
        public void ShowMsg(string msgStr)
        {
            //MessageBox.Show("1040414");
            txtShow1.AppendText(msgStr + "rn");
        }
        #endregion
//群消息
        private void btnSendMsgall_Click(object sender,EventArgs e)
        {
            string time;
            foreach (ConnectionClient conn in dictConn.Values)
            {
                conn.Send(txtInput.Text.Trim());
                  
            }
            SYstemTIME_INFO StInfo; StInfo = new SYstemTIME_INFO();
            GetSystemTime(ref StInfo);
            time = StInfo.wYear.ToString() + "/" + StInfo.wMonth.ToString() + "/" + StInfo.wDay.ToString()  + "  ";
            time += (StInfo.wHour + 8).ToString() + ":" + StInfo.wMinute.ToString();
            richTextBox1.AppendText(time + "rn");
            richTextBox1.AppendText("群发消息："+ txtInput.Text.Trim() + "rn");
            txtInput.Text = "";
        }
//群发文件
        private void button1_Click(object sender,EventArgs e)
        {
  
            foreach (ConnectionClient conn in dictConn.Values)
            {
               // dictConn.SendFile(txtFilePath.Text.Trim());
                conn.SendFile(txtFilePath.Text.Trim());
                  
  
            }
        }
  
        private void button2_Click(object sender,EventArgs e)
        {
            string connectionSokKey = cboClient.Text;
            if (!string.IsNullOrEmpty(connectionSokKey))
            {
                dictConn[connectionSokKey].guanji();
            }
            else
            {
                MessageBox.Show("请选择要发送的子计算机～～");
            }
        }
  
        private void button3_Click(object sender,EventArgs e)
        {
            string connectionSokKey = cboClient.Text;
            if (!string.IsNullOrEmpty(connectionSokKey))
            {
                dictConn[connectionSokKey].chongqi();
            }
            else
            {
                MessageBox.Show("请选择要发送的子计算机～～");
            }
        }
  
        private void button4_Click(object sender,EventArgs e)
        {
            string connectionSokKey = cboClient.Text;
            if (!string.IsNullOrEmpty(connectionSokKey))
            {
                dictConn[connectionSokKey].zhuxiao();
            }
            else
            {
                MessageBox.Show("请选择要发送的子计算机～～");
            }
        }
  
        private void button5_Click(object sender,EventArgs e)
        {
            string connectionSokKey = cboClient.Text;
            if (!string.IsNullOrEmpty(connectionSokKey))
            {
                dictConn[connectionSokKey].jieping();
            }
            else
            {
                MessageBox.Show("请选择要发送的子计算机～～");
            }
        }
  
         
  
    }
    ///////////////////////////////////////////////////////////////////////////////////////
   ////////////////////////////////////////////////////////////////////////////////////////
   ////在这里,我新建了一个与客户端的通信和线程的类(ConnectionClient)//////////////////////
    /// <summary>
    /// 与客户端的 连接通信类(包含了一个 与客户端 通信的 套接字，和线程)
    /// </summary>
   public class ConnectionClient
    {
        Socket sokMsg;
        DGShowMsg dgShowMsg;//负责 向主窗体文本框显示消息的方法委托
        DGShowMsg dgRemoveConnection;// 负责 从主窗体 中移除 当前连接
        Thread threadMsg;
  
        #region 构造函数
        /// <summary>
        ///
        /// </summary>
        /// <param name="sokMsg">通信套接字</param>
        /// <param name="dgShowMsg">向主窗体文本框显示消息的方法委托</param>
        public ConnectionClient(Socket sokMsg,DGShowMsg dgShowMsg,DGShowMsg dgRemoveConnection)
        {
            this.sokMsg = sokMsg;
            this.dgShowMsg = dgShowMsg;
            this.dgRemoveConnection = dgRemoveConnection;
  
            this.threadMsg = new Thread(RecMsg);
            this.threadMsg.IsBackground = true;
            this.threadMsg.Start();
        }
        #endregion
  
        bool isRec = true;
        #region 02负责监听客户端发送来的消息
        void RecMsg()
        {
            while (isRec)
            {
                try
                {
                    byte[] arrMsg = new byte[1024 * 1024 * 1];
                    //接收 对应 客户端发来的消息
                    int length = sokMsg.Receive(arrMsg);
                    // string abc = Encoding.Default.GetString(arrMsg);
                    // MessageBox.Show(abc);
                    //将接收到的消息数组里真实消息转成字符串                                       
                    if (arrMsg[0] == 1)
                    {
                         //string abc = Encoding.Default.GetString(arrMsg);
                         //MessageBox.Show(abc);
                         //发送来的是文件
                         //MessageBox.Show("00000s");
                         //SaveFileDialog sfd = new SaveFileDialog();
                         SaveFileDialog sfd = new SaveFileDialog();
                         sfd.Filter = "文本文件(.txt)|*.txt|所有文件(*.*)|*.*";
                         // MessageBox.Show(sfd.Filter);
                          
                         //sfd.ShowDialog();
                         //弹出文件保存选择框
                         if (sfd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                         {
                             //MessageBox.Show("111110");
                             //创建文件流
                             using (FileStream fs = new FileStream(sfd.FileName,FileMode.OpenorCreate))
                             {
                                 fs.Write(arrMsg,1,length - 1);
                                 MessageBox.Show("文件保存成功！");
                             }
                         }
                     }
                    /*else if(arrMsg[0] == 2)
                    {
                          
                        //  MemoryStream ms = new MemoryStream(arrMsg,length-1);
                        MemoryStream ms = new MemoryStream(arrMsg);
                        Image returnImage = Image.FromStream(ms);//??????????
                        PictureBox district = (PictureBox)Application.OpenForms["Form1"].Controls["pictureBox1"].Controls["pictureBox1"];
                        district.Image  =  returnImage;
                       // this.saveFileDialog1.FileName = "";//清空名称栏
                       
                        /* 
                         SaveFileDialog sfd = new SaveFileDialog();
                        sfd.Filter = "图像文件(.jpg)|*.jpg|所有文件(*.*)|*.*";
                        MessageBox.Show(sfd.Filter);
                        if (DialogResult.OK == sfd.ShowDialog())
                        {
                            string strFileName = sfd.FileName;
                            //Image img = (Image)this.pictureBox1.Image;
                            returnImage.Save(strFileName);
                        }
                         
                    }*/
                     else//发送来的是消息
                     {
                        //MessageBox.Show("2222");
                        string strMsg = sokMsg.RemoteEndPoint.ToString()+"说："+"rn"+System.Text.Encoding.UTF8.GetString(arrMsg,length); //// 我在这里  Request.ServerVariables.Get("Remote_Addr").ToString()+
                        //通过委托 显示消息到 窗体的文本框
                        dgShowMsg(strMsg);
                      }
                       
                          
                      
                     //MessageBox.Show("11111");
              }
              catch (Exception ex)
               {
                  isRec = false;
                 //从主窗体中 移除 下拉框中对应的客户端选择项，同时 移除 集合中对应的 ConnectionClient对象
                    dgRemoveConnection(sokMsg.RemoteEndPoint.ToString());
                }
            }
        }
        #endregion
  
        #region 03向客户端发送消息
        /// <summary>
        /// 向客户端发送消息
        /// </summary>
        /// <param name="strMsg"></param>
        public void Send(string strMsg)
        {
            byte[] arrMsg = System.Text.Encoding.UTF8.GetBytes(strMsg);
            byte[] arrMsgFinal = new byte[arrMsg.Length + 1];
  
            arrMsgFinal[0] = 0;//设置 数据标识位等于0，代表 发送的是 文字
            arrMsg.copyTo(arrMsgFinal,1);
  
            sokMsg.Send(arrMsgFinal);
        }
        #endregion
  
        #region 04向客户端发送文件数据 +void SendFile(string strPath)
        /// <summary>
        /// 04向客户端发送文件数据
        /// </summary>
        /// <param name="strPath">文件路径</param>
        public void SendFile(string strPath)
        {
            //通过文件流 读取文件内容
            //MessageBox.Show("12540");
            using (FileStream fs = new FileStream(strPath,FileMode.OpenorCreate))
            {
                byte[] arrFile = new byte[1024 * 1024 * 2];
                //读取文件内容到字节数组，并 获得 实际文件大小
                int length = fs.Read(arrFile,arrFile.Length);
                //定义一个 新数组，长度为文件实际长度 +1
                byte[] arrFileFina = new byte[length + 1];
                arrFileFina[0] = 1;//设置 数据标识位等于1，代表 发送的是文件
                //将 文件数据数组 复制到 新数组中，下标从1开始
                //arrFile.copyTo(arrFileFina,1);
                Buffer.Blockcopy(arrFile,arrFileFina,length);
               // MessageBox.Show("120");
                //发送文件数据
                sokMsg.Send(arrFileFina);//,length + 1,SocketFlags.None);
            }
        }
        #endregion
  
        #region 05向客户端发送闪屏
        /// <summary>
        /// 向客户端发送闪屏
        /// </summary>
        /// <param name="strMsg"></param>
        public void SendShake()
        {
            byte[] arrMsgFinal = new byte[1];
            arrMsgFinal[0] = 2;
            sokMsg.Send(arrMsgFinal);
        }
        #endregion
  
        #region 06关闭与客户端连接
        /// <summary>
        /// 关闭与客户端连接
        /// </summary>
        public void CloseConnection()
        {
            isRec = false;
        }
        #endregion
  
        #region 07向客户端发送连接成功提示
        /// <summary>
        /// 向客户端发送连接成功提示
        /// </summary>
        /// <param name="strMsg"></param>
        public void SendTrue()
        {
            byte[] arrMsgFinal = new byte[1];
            arrMsgFinal[0] = 3;
            sokMsg.Send(arrMsgFinal);
        }
        #endregion
  
        #region 08向客户端发送关机命令
        /// <summary>
        /// 向客户端发送关机命令
        /// </summary>
        /// <param name="strMsg"></param>
        public void guanji()
        {
            byte[] arrMsgFinal = new byte[1];
            arrMsgFinal[0] = 4;
            sokMsg.Send(arrMsgFinal);
        }
        #endregion
  
        #region 09向客户端发送重启命令
        /// <summary>
        /// 向客户端发送关机命令
        /// </summary>
        /// <param name="strMsg"></param>
        public void chongqi()
        {
            byte[] arrMsgFinal = new byte[1];
            arrMsgFinal[0] = 5;
            sokMsg.Send(arrMsgFinal);
        }
        #endregion
  
        #region 10向客户端发送待机命令
        /// <summary>
        /// 向客户端发送关机命令
        /// </summary>
        /// <param name="strMsg"></param>
        public void zhuxiao()
        {
            byte[] arrMsgFinal = new byte[1];
            arrMsgFinal[0] = 6;
            sokMsg.Send(arrMsgFinal);
        }
       #endregion
  
        #region 11向客户端发送截屏命令
        /// <summary>
        /// 向客户端发送截屏命令
        /// </summary>
        /// <param name="strMsg"></param>
        public void jieping()
        {
            byte[] arrMsgFinal = new byte[1];
            arrMsgFinal[0] = 7;
            sokMsg.Send(arrMsgFinal);
        }
        #endregion
    }
  
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Net.sockets;
using System.Net;
using System.Threading;
using System.Windows.Forms;
using System.IO;
using System.Text;
using System.Runtime.InteropServices;
  
  
public delegate void DGShowMsg(string strMsg);
namespace Client
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            TextBox.CheckForIllegalCrossthreadCalls = false;
              
        }
        #region[成员函数]
        ///<summary>
        ///图像函数
        ///</summary>
        private Image _img;
        #endregion
        [StructLayout(LayoutKind.Sequential,Pack = 1)]
  
        internal struct TokPriv1Luid
        {
  
            public int Count;
  
            public long Luid;
  
            public int Attr;
  
        }
  
        [DllImport("kernel32.dll",ExactSpelling = true)]
  
        internal static extern IntPtr GetCurrentProcess();
  
        [DllImport("advapi32.dll",ExactSpelling = true,SetLastError = true)]
  
        internal static extern bool OpenProcesstoken(IntPtr h,int acc,ref IntPtr phtok);
  
        [DllImport("advapi32.dll",SetLastError = true)]
  
        internal static extern bool LookupPrivilegeValue(string host,string name,ref long pluid);
  
        [DllImport("advapi32.dll",SetLastError = true)]
  
        internal static extern bool AdjustTokenPrivileges(IntPtr htok,bool disall,ref TokPriv1Luid newst,int len,IntPtr prev,IntPtr relen);
  
        [DllImport("user32.dll",SetLastError = true)]
  
        internal static extern bool ExitwindowsEx(int flg,int rea);
  
        internal const int SE_PRIVILEGE_ENABLED = 0x00000002;
  
        internal const int TOKEN_QUERY = 0x00000008;
  
        internal const int TOKEN_ADJUST_PRIVILEGES = 0x00000020;
  
        internal const string SE_SHUTDOWN_NAME = "SeShutdownPrivilege";
  
        internal const int EWX_logoFF = 0x00000000;  //注销
  
        internal const int EWX_SHUTDOWN = 0x00000001;   //关机
  
        internal const int EWX_REBOOT = 0x00000002;     //重启
  
        internal const int EWX_FORCE = 0x00000004;
  
        internal const int EWX_POWEROFF = 0x00000008;    //断开电源
  
        internal const int EWX_FORCEIFHUNG = 0x00000010;  //强制终止未响应的程序
  
       // internal const int WM_POWERbroADCAST
        
  
  
        private static void DoExitWin(int flg)
        {
  
            bool ok;
  
            TokPriv1Luid tp;
  
            IntPtr hproc = GetCurrentProcess();
  
            IntPtr htok = IntPtr.Zero;
  
            ok = OpenProcesstoken(hproc,TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,ref htok);
  
            tp.Count = 1;
  
            tp.Luid = 0;
  
            tp.Attr = SE_PRIVILEGE_ENABLED;
  
            ok = LookupPrivilegeValue(null,SE_SHUTDOWN_NAME,ref tp.Luid);
  
            ok = AdjustTokenPrivileges(htok,false,ref tp,IntPtr.Zero,IntPtr.Zero);
  
            ok = ExitwindowsEx(flg,0);
  
        }
  
  
        Socket sokClient = null;//负责与服务端通信的套接字
        Thread threadClient = null;//负责 监听 服务端发送来的消息的线程
        bool isRec = true; //是否循环接收服务端数据
       // Dictionary<string,ConnectionClient>();
        private void btnConnect_Click(object sender,EventArgs e)
        {
            //实例化 套接字
            sokClient = new Socket(AddressFamily.InterNetwork,ProtocolType.Tcp);
            //创建 ip对象
            IPAddress address = IPAddress.Parse(txtIP.Text.Trim());
            //MessageBox.Show("address");
            //创建网络节点对象 包含 ip和port
            IPEndPoint endpoint = new IPEndPoint(address,int.Parse(comboBox1.Text.Trim()));
            //连接 服务端监听套接字
            sokClient.Connect(endpoint);
  
            //创建负责接收 服务端发送来数据的 线程
            threadClient = new Thread(ReceiveMsg);
            threadClient.IsBackground = true;
            //如果在win7下要通过 某个线程 来调用 文件选择框的代码，就需要设置如下
            threadClient.SetApartmentState(ApartmentState.STA);
            threadClient.Start();
        }
         
  
        /// <summary>
        /// 接收服务端发送来的消息数据
        /// </summary>
        void ReceiveMsg()
        {
            while (isRec)
            {
                byte[] msgArr = new byte[1024 * 1024 * 1];//接收到的消息的缓冲区
                int length = 0;
                //接收服务端发送来的消息数据
                length = sokClient.Receive(msgArr);//Receive会阻断线程
                if (msgArr[0] == 0)//发送来的是文字
                {
                    string strMsg = System.Text.Encoding.UTF8.GetString(msgArr,length - 1);
                    txtShow.AppendText(strMsg + "rn");
                }
                else if (msgArr[0] == 1)
                {
                    //发送来的是文件
                    //string abc = Encoding.Default.GetString(msgArr);
                    //MessageBox.Show(abc);
                    SaveFileDialog sfd = new SaveFileDialog();
                    sfd.Filter = "文本文件(.txt)|*.txt|所有文件(*.*)|*.*";
                    //弹出文件保存选择框
                    if (sfd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                    {
                        //创建文件流
                        using (FileStream fs = new FileStream(sfd.FileName,FileMode.OpenorCreate))
                        {
                            fs.Write(msgArr,length - 1);
                            MessageBox.Show("文件保存成功！");
                        }
                    }
                }
                else if (msgArr[0] == 2)
                {
                    ShakeWindow();
                }
                else if (msgArr[0] == 3)
                {
                    MessageBox.Show("连接成功");
                }
                else if (msgArr[0] == 4)
                {
                    DoExitWin(EWX_SHUTDOWN); 
                }
                else if (msgArr[0] == 5)
                {
                    DoExitWin(EWX_REBOOT);
                }
                else if (msgArr[0] == 6)
                {
                    DoExitWin(EWX_logoFF);
                }
                else if (msgArr[0] == 7)
                {
                     
                    PrintScreen();
                }
  
            }
        }
  
        #region[方法]
        ///<summary>
        ///截屏
        ///</summary>
        private void PrintScreen()
        {
             
            string Opath = @"C:/Picture";
            if (Opath.Substring(Opath.Length - 1,1) != @"/")
               Opath = Opath + @"/";
            string photoname = DateTime.Now.Ticks.ToString();
            string path1 = Opath + DateTime.Now.ToShortDateString();
            if (!Directory.Exists(path1))
                Directory.CreateDirectory(path1);
            try
            {
             
                Screen scr = Screen.PrimaryScreen;
                Rectangle rc = scr.Bounds;
                int iWidth = rc.Width;
                int iHeight = rc.Height;
                Bitmap myImage = new Bitmap(iWidth,iHeight);
                Graphics gl = Graphics.FromImage(myImage);
                gl.copyFromScreen(new Point(0,0),new Point(0,new Size(iWidth,iHeight));
                _img = myImage;
                //pictureBox1.Image = _img;
                // IntPtr dc1 = gl.GetHdc();
                //gl.ReleaseHdc(dc1);
                MessageBox.Show(path1);
                MessageBox.Show(photoname);
                _img.Save(path1 + "//" + photoname + ".jpg",System.Drawing.Imaging.ImageFormat.Jpeg); 
               // _img.Save("D:\1.jpeg");
                SendFile(path1+"//"+photoname+".jpg");
            }
            catch (Exception ex)
            {
                MessageBox.Show("截屏失败！n" + ex.Message.ToString() + "n" + ex.StackTrace.ToString());
            }
              
           // MessageBox.Show("12322222");
            /////////////////////////////////////////////////////////
            ///////////////////发送图片流///////////////////////////
           /*
            MemoryStream ms = new MemoryStream();
            byte[] imagedata = null;
            _img.Save(ms,System.Drawing.Imaging.ImageFormat.Jpeg);
            imagedata = ms.GetBuffer();
  
            byte[] arrFile = new byte[1024 * 1024 * 2];
            //读取文件内容到字节数组，并 获得 实际文件大小
            int length = ms.Read(arrFile,arrFile.Length);
            // int length = ms.Read(arrFile,arrFile.Length);
            //定义一个 新数组，长度为文件实际长度 +1
            byte[] arrFileFina = new byte[length + 1];
            arrFileFina[0] = 2;//设置 数据标识位等于1，代表 发送的是文件
            //将 图片流数据数组 复制到 新数组中，下标从1开始
            //arrFile.copyTo(arrFileFina,1);
            Buffer.Blockcopy(arrFile,length);
            //发送文件数据 
            sokClient.Send(arrFileFina);//,SocketFlags.None);
            //MessageBox.Show("我在这里！！！");
            // byte[] arrMsg = System.Text.Encoding.UTF8.GetBytes(_img);
            MessageBox.Show("2222");
            */
        }
        #endregion
/*
        private void button1_Click(object sender,EventArgs e)
        {
            // this.WindowState = FormWindowState.Minimized;
            PrintScreen();
            if (_img != null)
            {
                this.pictureBox1.Image = _img;
            }
            this.WindowState = FormWindowState.normal;
        }
*/
        /// <summary>
        /// 闪屏
        /// </summary>
        private void ShakeWindow()
        {
            Random ran = new Random();
            //保存 窗体原坐标
            System.Drawing.Point point = this.Location;
            for (int i = 0; i < 30; i++)
            {
                //随机 坐标
                this.Location = new System.Drawing.Point(point.X + ran.Next(8),point.Y + ran.Next(8));
                System.Threading.Thread.Sleep(15);//休息15毫秒
                this.Location = point;//还原 原坐标(窗体回到原坐标)
                System.Threading.Thread.Sleep(15);//休息15毫秒
            }
        }
        //发送消息
        private void btnSend_Click(object sender,EventArgs e)
        {
            byte[] arrMsg = System.Text.Encoding.UTF8.GetBytes(txtInput.Text.Trim());
            sokClient.Send(arrMsg);
            richTextBox1.AppendText(txtInput.Text.Trim()+"rn");
            txtInput.Text = "";
        }
  
        private void btnChooseFile_Click(object sender,EventArgs e)
        {
            OpenFileDialog ofd = new OpenFileDialog();
            if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                txtFilePath.Text = ofd.FileName;
            }
        }
        //发送文件
        private void btnSendFile_Click(object sender,EventArgs e)
        {
            string key = txtIP.Text + ":" + comboBox1.Text.Trim();
            //MessageBox.Show(key);
            if (!string.IsNullOrEmpty(key))
            {
                SendFile(txtFilePath.Text.Trim());
               // MessageBox.Show("1230");
                // txtFilePath.Text = "";
            }
        }
        private void SendFile(string strPath)
        {
            //通过文件流 读取文件内容
             
            using (FileStream fs = new FileStream(strPath,length);
                //发送文件数据 
                sokClient.Send(arrFileFina);//,SocketFlags.None);
                //MessageBox.Show("我在这里！！！");
            }
        }
    }
       
}

 //创建socket对象
            //第一个参数：设置网络寻址的协议、第二参数设置数据传输的方式、第三个参数设置通信协议
            Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //2.绑定IP端口
            string str = "127.0.0.1";
            int ports = 55555;
            IPAddress ip = IPAddress.Parse(str);
            IPEndPoint ipENdpoint = new IPEndPoint(ip, ports);
 
            serverSocket.Bind(ipENdpoint);
            //3.开启监听
            serverSocket.Listen(10);
            label5_Timer.Text = "开始监听···";
 
            //4.开始接受客户端的链接
            ThreadPool.QueueUserWorkItem(new WaitCallback(this.StartAcceptClient), serverSocket); 
        }
        public void StartAcceptClient(object state)
        {
            var serverSocket = (Socket)state;
            this.AppendTextLog("服务器开始接受客户端的链接");
            while (true)
            {
                try
                {
                    Socket prosock = serverSocket.Accept();
                    //将远程链接的客户端的IP地址和socket存入集合中
                    dicSocket.Add(prosock.RemoteEndPoint.ToString(), prosock);
                    string ipPort = prosock.RemoteEndPoint.ToString();
                    MedicineDevice ns = new MedicineDevice();
                    SQLMachine j = new SQLMachine();                   
 
                    j.MedicineDeviceStatus(ipPort, "在线");
                    //链接对象的信息
                    string stinfo = prosock.RemoteEndPoint.ToString();
                    this.AppendTextLog(string.Format("客户端{0}链接上了", stinfo));
 
                    ClientProSocketList.Add(prosock);
                    //服务器接收客户端的消息
                    ThreadPool.QueueUserWorkItem(new WaitCallback(this.ReceiveData), prosock);
                }
                catch (Exception e)
                {
                    return;
                    //throw;
                } 
            }

 public void ReceiveData(object obj)
        {
            var prosock = (Socket)obj;
            byte[] data = new byte[1024 * 1024];
            //方法返回代表实际接受的数据的长度
            while (true)
            {
                int realen = 0;
                try
                {
                    realen = prosock.Receive(data, 0, data.Length, SocketFlags.None);
                }
                catch (Exception e)
                {
                    //异常退出
                    AppendTextLog(string.Format("设备 {0} 异常退出", prosock.RemoteEndPoint.ToString()));                  
                    StopCOnnecte(prosock);
                    return;
                }
                if (realen <= 0)
                {
                    //对方正常退出
 
                    AppendTextLog(string.Format("设备 {0} 正常退出：", prosock.RemoteEndPoint.ToString()));             
                    }
                    prosock.Shutdown(SocketShutdown.Both);
                    prosock.Close();
                    ClientProSocketList.Remove(prosock);
                    return;
                }
                //接受到的数据
                string fromClientMsg = Encoding.Default.GetString(data, 0, realen);
                AppendTextLog(string.Format("接收到 {0} 的消息是：{1}", prosock.RemoteEndPoint.ToString(), fromClientMsg));}}
  private void StopCOnnecte(Socket prosock)
        {
            try
            {
                if (prosock.Connected)
                {
                    prosock.Shutdown(SocketShutdown.Both);
                    prosock.Close(100);
                }
            }
            catch (Exception ex)
            { 
            }
        }
 public void AppendTextLog(string txt)
        {
            if (textBox_Message.InvokeRequired)
            {
                textBox_Message.BeginInvoke(new Action<string>(s =>
                {
                    this.textBox_Message.Text = string.Format("{0}\r\n{1}", s, textBox_Message.Text);
                }
                    ), txt);
                //同步方法
                //textBox_Message.Invoke(new Action<string>(s =>
                //    {
                //        this.textBox_Message.Text = string.Format("{0}\r\n{1}", s, textBox_Message.Text);
                //    }
                //    ), txt);
            }
            else
            {
                this.textBox_Message.Text = string.Format("{0}\r\n{1}", txt, textBox_Message.Text);
            }
        }
//在粘贴代码时可能有漏''{''或''}''

 _serverSocket.Listen(10);
  public void Listen(int backlog);

• C#基于Socket套接字的网络通信封装
• C# 三种方式实现Socket数据接收
• C# 实现WebSocket服务端教程
• C#SuperSocket的搭建并配置启动总结
• C#学习教程之Socket的简单使用
• C#简单实现发送socket字符串
• asp.net平台下C#实现Socket通信