1.服务器

  1. using System;
  2. using System.Collections.Generic;
  3. using System.ComponentModel;
  4. using System.Data;
  5. using System.Drawing;
  6. using System.IO;
  7. using System.Linq;
  8. using System.Net;
  9. using System.Net.Sockets;
  10. using System.Text;
  11. using System.Threading;
  12. using System.Threading.Tasks;
  13. using System.Windows.Forms;
  15. namespace Server
  16. {
  17.     public partial class Form1 : Form
  18.     {
  19.         public Form1()
  20.         {
  21.             InitializeComponent();
  22.         }
  24.         private void btnStart_Click(object sender, EventArgs e)
  25.         {
  26.             try
  27.             {
  28.                 //当点击开始监听的时候 在服务器端创建一个负责监IP地址跟端口号的Socket
  29.                 Socket socketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
  30.                 IPAddress ip = IPAddress.Any;//IPAddress.Parse(txtServer.Text);
  31.                 //创建端口号对象
  32.                 IPEndPoint point = new IPEndPoint(ip, Convert.ToInt32(txtPort.Text));
  33.                 //监听
  34.                 socketWatch.Bind(point);
  35.                 ShowMsg("监听成功");
  36.                 socketWatch.Listen(10);
  38.                 Thread th = new Thread(Listen);
  39.                 th.IsBackground = true;
  40.                 th.Start(socketWatch);
  41.             }
  42.             catch
  43.             { }
  44.         }
  45.         /// <summary>
  46.         /// 等待客户端的连接 并且创建与之通信用的Socket
  47.         /// </summary>
  48.         /// 
  49.         Socket socketSend;
  50.         void Listen(object o)
  51.         {
  52.             Socket socketWatch = o as Socket;
  53.             //等待客户端的连接 并且创建一个负责通信的Socket
  54.             while (true)
  55.             {
  56.                 try
  57.                 {
  58.                     //负责跟客户端通信的Socket
  59.                     socketSend = socketWatch.Accept();
  60.                     //将远程连接的客户端的IP地址和Socket存入集合中
  61.                     dicSocket.Add(socketSend.RemoteEndPoint.ToString(), socketSend);
  62.                     //将远程连接的客户端的IP地址和端口号存储下拉框中
  63.                     cboUsers.Items.Add(socketSend.RemoteEndPoint.ToString());
  64.                     //192.168.11.78：连接成功
  65.                     ShowMsg(socketSend.RemoteEndPoint.ToString() + ":" + "连接成功");
  66.                     //开启 一个新线程不停的接受客户端发送过来的消息
  67.                     Thread th = new Thread(Recive);
  68.                     th.IsBackground = true;
  69.                     th.Start(socketSend);
  70.                 }
  71.                 catch
  72.                 { }
  73.             }
  74.         }
  76.         //将远程连接的客户端的IP地址和Socket存入集合中
  77.         Dictionary<string, Socket> dicSocket = new Dictionary<string, Socket>();
  79.         /// <summary>
  80.         /// 服务器端不停的接受客户端发送过来的消息
  81.         /// </summary>
  82.         /// <param name="o"></param>
  83.         void Recive(object o)
  84.         {
  85.             Socket socketSend = o as Socket;
  86.             while (true)
  87.             {
  88.                 try
  89.                 {
  90.                     //客户端连接成功后，服务器应该接受客户端发来的消息
  91.                     byte[] buffer = new byte[1024 * 1024 * 2];
  92.                     //实际接受到的有效字节数
  93.                     int r = socketSend.Receive(buffer);
  94.                     if (r == 0)
  95.                     {
  96.                         break;
  97.                     }
  98.                     string str = Encoding.UTF8.GetString(buffer, 0, r);
  99.                     ShowMsg(socketSend.RemoteEndPoint + ":" + str);
  100.                 }
  101.                 catch
  102.                 { }
  103.             }
  104.         }
  107.         void ShowMsg(string str)
  108.         {
  109.             txtLog.AppendText(str + "\r\n");
  110.         }
  112.         private void Form1_Load(object sender, EventArgs e)
  113.         {
  114.             Control.CheckForIllegalCrossThreadCalls = false;
  115.         }
  116.         /// <summary>
  117.         /// 服务器给客户端发送消息
  118.         /// </summary>
  119.         /// <param name="sender"></param>
  120.         /// <param name="e"></param>
  121.         private void btnSend_Click(object sender, EventArgs e)
  122.         {
  123.             string str = txtMsg.Text;
  124.             byte[] buffer = System.Text.Encoding.UTF8.GetBytes(str);
  125.             List<byte> list = new List<byte>();
  126.             list.Add(0);
  127.             list.AddRange(buffer);
  128.             //将泛型集合转换为数组
  129.             byte[] newBuffer = list.ToArray();
  130.             //buffer = list.ToArray();不可能
  131.             //获得用户在下拉框中选中的IP地址
  132.             string ip = cboUsers.SelectedItem.ToString();
  133.             dicSocket[ip].Send(newBuffer);
  134.             //     socketSend.Send(buffer);
  135.         }
  139.         /// <summary>
  140.         /// 选择要发送的文件
  141.         /// </summary>
  142.         /// <param name="sender"></param>
  143.         /// <param name="e"></param>
  144.         private void btnSelect_Click(object sender, EventArgs e)
  145.         {
  146.             OpenFileDialog ofd = new OpenFileDialog();
  147.             ofd.InitialDirectory = @"C:\Users\SpringRain\Desktop";
  148.             ofd.Title = "请选择要发送的文件";
  149.             ofd.Filter = "所有文件|*.*";
  150.             ofd.ShowDialog();
  152.             txtPath.Text = ofd.FileName;
  153.         }
  155.         private void btnSendFile_Click(object sender, EventArgs e)
  156.         {
  157.             //获得要发送文件的路径
  158.             string path = txtPath.Text;
  159.             using (FileStream fsRead = new FileStream(path, FileMode.Open, FileAccess.Read))
  160.             {
  161.                 byte[] buffer = new byte[1024 * 1024 * 5];
  162.                 int r = fsRead.Read(buffer, 0, buffer.Length);
  163.                 List<byte> list = new List<byte>();
  164.                 list.Add(1);
  165.                 list.AddRange(buffer);
  166.                 byte[] newBuffer = list.ToArray();
  167.                 dicSocket[cboUsers.SelectedItem.ToString()].Send(newBuffer, 0, r+1, SocketFlags.None);
  168.             }
  169.         }
  172.         /// <summary>
  173.         /// 发送震动
  174.         /// </summary>
  175.         /// <param name="sender"></param>
  176.         /// <param name="e"></param>
  177.         private void btnZD_Click(object sender, EventArgs e)
  178.         {
  179.             byte[] buffer = new byte[1];
  180.             buffer[0] = 2;
  181.             dicSocket[cboUsers.SelectedItem.ToString()].Send(buffer);
  182.         }
  184.         private void txtServer_TextChanged(object sender, EventArgs e)
  185.         {
  187.         }
  188.     }
  189. }

解释：
1.
IPAddress.Any表示本机ip，换言之，如果服务器绑定此地址，则表示侦听本机所有ip对应的那个端口（本机可能有多个ip或只有一个ip）
IPAddress.Any微软给出的解释是：Provides an IP address that indicates that the server must listen for client activity on all network interfaces. This field is read-only.翻译过来就是：提供一个iP地址来指示服务器必须监听所有网卡上的客户端活动。此字段为只读的。也就是说，对双卡网或者多网卡的机器，每个网卡都会有一个独立的ip，如果使用了IPAddress.Any就表示服务器必须监听本机所有网卡上的指定端口。
比如双网卡机器，内网ip为192.168.0.1，外网ip为120.210.1.1，服务器可以同时监听192.168.0.1:80和120.210.1.1:80。

2.客户端

  1. using System;
  2. using System.Collections.Generic;
  3. using System.ComponentModel;
  4. using System.Data;
  5. using System.Drawing;
  6. using System.IO;
  7. using System.Linq;
  8. using System.Net;
  9. using System.Net.Sockets;
  10. using System.Text;
  11. using System.Threading;
  12. using System.Threading.Tasks;
  13. using System.Windows.Forms;
  15. namespace _07Client
  16. {
  17.     public partial class Form1 : Form
  18.     {
  19.         public Form1()
  20.         {
  21.             InitializeComponent();
  22.         }
  23.         Socket socketSend;
  24.         private void btnStart_Click(object sender, EventArgs e)
  25.         {
  26.             try
  27.             {
  28.                 //创建负责通信的Socket
  29.                 socketSend = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
  30.                 IPAddress ip = IPAddress.Parse(txtServer.Text);
  31.                 IPEndPoint point = new IPEndPoint(ip, Convert.ToInt32(txtPort.Text));
  32.                 //获得要连接的远程服务器应用程序的IP地址和端口号
  33.                 socketSend.Connect(point);
  34.                 ShowMsg("连接成功");
  36.                 //开启一个新的线程不停的接收服务端发来的消息
  37.                 Thread th = new Thread(Recive);
  38.                 th.IsBackground = true;
  39.                 th.Start();
  40.             }
  41.             catch
  42.             { }
  44.         }
  47.         /// <summary>
  48.         /// 不停的接受服务器发来的消息
  49.         /// </summary>
  50.         void Recive()
  51.         {
  52.             while (true)
  53.             {
  54.                 try
  55.                 {
  56.                     byte[] buffer = new byte[1024 * 1024 * 3];
  57.                     int r = socketSend.Receive(buffer);
  58.                     //实际接收到的有效字节数
  59.                     if (r == 0)
  60.                     {
  61.                         break;
  62.                     }
  63.                     //表示发送的文字消息
  64.                     if (buffer[0] == 0)
  65.                     {
  66.                         string s = Encoding.UTF8.GetString(buffer, 1, r-1);
  67.                         ShowMsg(socketSend.RemoteEndPoint + ":" + s);
  68.                     }
  69.                     else if (buffer[0] == 1)
  70.                     {
  71.                         SaveFileDialog sfd = new SaveFileDialog();
  72.                         sfd.InitialDirectory = @"C:\Users\SpringRain\Desktop";
  73.                         sfd.Title = "请选择要保存的文件";
  74.                         sfd.Filter = "所有文件|*.*";
  75.                         sfd.ShowDialog(this);
  76.                         string path = sfd.FileName;
  77.                         using (FileStream fsWrite = new FileStream(path, FileMode.OpenOrCreate, FileAccess.Write))
  78.                         {
  79.                             fsWrite.Write(buffer, 1, r - 1);
  80.                         }
  81.                         MessageBox.Show("保存成功");
  82.                     }
  83.                     else if (buffer[0] == 2)
  84.                     {
  85.                         ZD();
  86.                     }
  88.                 }
  89.                 catch { }
  91.             }
  92.         }
  97.         /// <summary>
  98.         /// 震动
  99.         /// </summary>
  100.         void ZD()
  101.         {
  102.             for (int i = 0; i < 500; i++)
  103.             {
  104.                 this.Location = new Point(200, 200);
  105.                 this.Location = new Point(280, 280);
  106.             }
  107.         }
  111.         void ShowMsg(string str)
  112.         {
  113.             txtLog.AppendText(str + "\r\n");
  114.         }
  116.         /// <summary>
  117.         /// 客户端给服务器发送消息
  118.         /// </summary>
  119.         /// <param name="sender"></param>
  120.         /// <param name="e"></param>
  121.         private void btnSend_Click(object sender, EventArgs e)
  122.         {
  123.             string str = txtMsg.Text.Trim();
  124.             byte[] buffer = System.Text.Encoding.UTF8.GetBytes(str);
  125.             socketSend.Send(buffer);
  126.         }
  128.         private void Form1_Load(object sender, EventArgs e)
  129.         {
  130.             Control.CheckForIllegalCrossThreadCalls = false;
  131.         }
  132.     }
  133. }