在两台计算机传输文件之前，必需得先有一台计算机建立套节子连接并绑定一个固定得端口，并在这个端口侦听另外一台计算机的连接请求。

socket   =   new   Socket(AddressFamily.InterNetwork,SocketType.Stream,   ProtocolType.Tcp);
socket.Blocking   =   true   ;
IPEndPoint   computernode1   =   new   IPEndPoint(serverIpadress,   8080);

socket.Bind(computernode1);

socket.Listen(-1);

当有其他的计算机发出连接请求的时候，被请求的计算机将对每一个连接请求分配一个线程，用于处理文件传输和其他服务。

while   (   true   )  

    {

        clientsock   =   socket.Accept();

        if   (   clientsock.Connected   )  

        {

              Thread   tc   =   new   Thread(new   ThreadStart(listenclient));

            tc.Start();

        }

    }

下面的代码展示了listenclient方法是如何处理另外一台计算机发送过来的请求。首先并对发送过来的请求字符串作出判断，看看是何种请求，然后决定相应的处理方法。

void   listenclient()
{
    Socket   sock   =   clientsock   ;
    try
    {
        while   (   sock   !=   null   )  
        {
            byte[]   recs   =   new   byte[32767];
            int   rcount   =   sock.Receive(recs,recs.Length,0)   ;
            string   message   =   System.Text.Encoding.ASCII.GetString(recs)   ;
          //对message作出处理，解析处请求字符和参数存储在cmdList   中
                    execmd＝cmdList[0];
            sender   =   null   ;
            sender   =   new   Byte[32767];
   
            string   parm1   =   " ";
//目录列举          
if   (   execmd   ==   "LISTING "   )  
            {
                ListFiles(message);
                continue   ;
            }  
//文件传输
            if   (   execmd   ==   "GETOK "   )
            {
                cmd   =   "BEGINSEND   "     +   filepath   +   "   "   +   filesize   ;
                sender   =   new   Byte[1024];
                sender   =   Encoding.ASCII.GetBytes(cmd);
                sock.Send(sender,   sender.Length   ,   0   );
                              //转到文件下载处理
                DownloadingFile(sock);
                continue   ;
            }      
        }
    }
    catch(Exception   Se)
    {
        string   s   =   Se.Message;
        Console.WriteLine(s);
    }
}

至此，基本的工作已经完成了，下面我们看看如何处理文件传输的。
while(rdby   <   total   &&   nfs.CanWrite)
    {
//从要传输的文件读取指定长度的数据
len   =fin.Read(buffed,0,buffed.Length)   ;
        //将读取的数据发送到对应的计算机
        nfs.Write(buffed,   0,len);
        //增加已经发送的长度
        rdby=rdby+len   ;                    
    }
从上面的代码可以看出是完成文件转换成FileStream   流，然后通过NetworkStream绑定对应的套节子，最后调用他的write方法发送到对应的计算机。
我们再看看接受端是如何接受传输过来的流，并且转换成文件的：
NetworkStream   nfs   =   new   NetworkStream(sock)   ;
try
{
                //一直循环直到指定的文件长度
                while(rby   <   size)
    {
            byte[]   buffer   =   new   byte[1024]   ;
            //读取发送过来的文件流
            int   i   =   nfs.Read(buffer,0,buffer.Length)   ;
            fout.Write(buffer,0,(int)i)   ;
            rby=rby+i   ;
        }    
    fout.Close()   ;

从上面可以看出接受与发送恰好是互为相反的过程，非常简单。

//取得预保存的文件名  
string   fileName= "test.rar ";  
//远程主机  
string   hostName=TextBoxHost.Text.Trim();  
//端口  
int   port=80;  
//得到主机信息  
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)  
{  
LeixunCMS.Common.MessageBox.Show(this.Page, "连接错误 "+se.Message);

}

例子2：

这几天一直想写一个类似QQ文件发送的东西，上网找了一些资料，都不是很理想，下面我把我的思路和基本实现代码说下。

         为了把问题说清楚，把一些变量都直接附值了，并没有通过输入附值

                      private string path = "F://SmartMovie.EXE";    //要发送的文件

                      private Socket s;                             

         private void listen()
        {
            string ip = "127.0.0.1";   //远程IP 这里定义为自己的机器
            IPAddress[] ih = Dns.GetHostAddresses(ip);       //获得IP列表
            IPAddress newip = ih[0];      //获取IP地址           
            int port = 6789;              //定义端口
            IPEndPoint Conncet = new IPEndPoint(newip, port);     //构造结点
            s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);                   //初始化socket

     try
         {                                  
            s.Connect(Conncet);      //连接远程服务器
            if (s.Connected)         //如果连接成功 s.Connected 则为true 否则为 false
            {

                Console.WriteLine("连接成功");
                Thread t = new Thread(new ThreadStart(set)); //创建进程
                t.Start();                             //开始进程
                Console.WriteLine("发送完毕")      

            }

                }
                catch(NullReferenceException e)
            {

              Console.WriteLine("{0}",e);

             }

             private void set()                       //创建set函数
        {
            Console.WriteLine("开始发送数据");
            byte[] b = new byte[10000000];            //创建文件缓冲区，这里可以认为文件的最大值
            FileStream file = File.Open(path, FileMode.Open,FileAccess.Read);   //创建文件流
            int start = 0;
            int end = (int)file.Length;               //获取文件长度 文件传送如果有需要超过int的范围估计就要改写FileStream类了

      try
           {
            while (end != 0)
            {
                int count = file.Read(b, start, end);      //把数据写进流
                start += count;
                end -= count;
            }
            while (start != 0)
            {
                int n = s.Send(b, end, start, SocketFlags.None); //用Socket的Send方法发送流
                end += n;
                start -= n;
            }
        
            file.Close();     //关闭文件流
            s.Close();        //关闭Socket
           }  
       catch (NullReferenceException e)
            {
                Console.WriteLine("{0}", e);
            }             
        }   

这样文件发送的模型就实现了

    接下去实现文件的接收，首先要确定对方发送文件的长度，其实上面的那段还要加入发送文件长度的功能，实现很简单，就是发送int变量end ，然后要求接收代码返回一个Boolean确定是否发送，这里为了更简明的说清楚原理并没有实现

             private void get()
        {
            string path = "G://da.exe"; //接收的文件
            FileStream file = new FileStream(path, FileMode.OpenOrCreate, FileAccess.Write); //写入文件流
            TcpListener listen = new TcpListener(6789); //监听端口
            Socket s1 = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); //定义Socket并初始化
            try
            {
             listen.Start();        //开始监听
            s1 = listen.AcceptSocket();            //获取Socket连接
            byte[] data = new byte[10000000];      //定义缓冲区
            int longer = data.Length;              
            int start = 0;                
            int mid = 0;
            if (s1.Connected)             //确定连接
            {
                Console.WriteLine("连接成功");
                int count = s1.Receive(data, start, longer, SocketFlags.None); //把接收到的byte存入缓冲区
                mid += count;
                longer -= mid;
                while (count != 0)
                {
                    count = s1.Receive(data, mid, longer, SocketFlags.None);
                    mid += count;
                    longer -= mid;
                }
                file.Write(data, 0, 1214134); //写入文件，1214134为文件大小，可以用socket发送获得，代码前面已经说明。
                s1.Close();
                file.Close();
            }
            }
                catch(NullReferenceException e)
            {
                    Console.WriteLine("{0}",e);
            }
          }

//2：可以随时终止传输过程

//发送数据线程

UINT SendDataThread(LPVOID lpParam);

//接收数据线程

UINT ReceiveDataThread(LPVOID lpParam);

//发送数据按钮消息响应函数

void CTzg004Dlg::OnButtonSend()

{

     // TODO: Add your control notification handler code here

     //初始化数据发送结束标志

     m_bSendEnd=FALSE;

     //初始化数据接收结束标志

     m_bRecEnd=FALSE;

     //更新对话框数据

     UpdateData(TRUE);

     //打开文件对话框

     CFileDialog dlg(TRUE,NULL,NULL,OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT,

          "所有文件 (*.*)|*.*||");

     if(dlg.DoModal()==IDOK)

     {

         m_strFileName=dlg.GetPathName();

          //开始发送数据线程

         AfxBeginThread(SendDataThread,this,THREAD_PRIORITY_NORMAL);

     }

}

//接收数据按钮消息响应函数

void CTzg004Dlg::OnButtonReceive()

{

     // TODO: Add your control notification handler code here

     //初始化数据发送结束标志

     m_bSendEnd=FALSE;

     //初始化数据接收结束标志

     m_bRecEnd=FALSE;

     UpdateData(TRUE);

     //开始接收数据线程

     AfxBeginThread(ReceiveDataThread,this,THREAD_PRIORITY_NORMAL);

}

//终止发送按钮消息响应

void CTzg004Dlg::OnButtonSendEnd()

{

     // TODO: Add your control notification handler code here

     //设置发送数据结束标志

     m_bSendEnd=TRUE;

}

//终止接收按钮消息响应

void CTzg004Dlg::OnButtonRecEnd()

{

     // TODO: Add your control notification handler code here

     //设置接收数据结束标志

     m_bRecEnd=TRUE;

}

UINT SendDataThread(LPVOID lpParam)

{

     CTzg004Dlg *pDlg=(CTzg004Dlg *)lpParam;

     CFile file;

     if( !file.Open(pDlg->m_strFileName, CFile::modeRead) )

     {

         AfxMessageBox("打开文件出错！");

          return 0;

     }

     CSocket sockTemp;

     CString str,str1;

     sockTemp.Create(pDlg->m_iDataPort1); //得到端口号

     sockTemp.Listen(1);//只接受一个连接

     CSocket sockSend;

     //设置发送按钮禁止

     pDlg->GetDlgItem(IDC_BUTTON_SEND)->EnableWindow(FALSE);

     sockTemp.Accept(sockSend);//注意，sockTemp已交了自己的指针地址到sockSend，故不用Close

     //打开发送终止按钮

     pDlg->GetDlgItem(IDC_BUTTON_SEND_END)->EnableWindow(TRUE);

     int iBufSize = 1024 * 5; 

     int iSize = iBufSize;

     LPBYTE pBuf = new BYTE[iBufSize];    

     DWORD dwTemp = 0;

     BOOL bTest = sockSend.AsyncSelect(0);//由于CSocket实际是异步，将它变为同步（阻塞）方式。

     sockSend.IOCtl( FIONBIO, &dwTemp);//用IOCtl要将AsyncSelect的第一个参数为0，参看MSDN

     UINT uiLength = file.GetLength();

     sockSend.Send(&uiLength, 4);//传送文件大小到接收方（Client端）

     int iNumByte;

     UINT uiTotal = 0;

     while(uiTotal < uiLength)

     {

          int iEnd=pDlg->m_bSendEnd;

          //传送发送端状态（是否结束）

         iNumByte = sockSend.Send(&iEnd, sizeof(int));

          //发送错误

         if(iNumByte == SOCKET_ERROR)

          {

              AfxMessageBox("发送错误！");

              goto ExitLable1;

          }else if(iEnd==1)//发送端终止

          {

              AfxMessageBox("发送端终止");

              goto ExitLable1;

          }        

          //读取文件内容

         if((int)(uiLength - uiTotal) < iBufSize)

              iSize = uiLength - uiTotal;//当小于缓冲区iTEST时的处理

         iSize=file.Read(pBuf , iSize);//得到读取的字节数

          int iCount=0;

          //发送定长文件数据

         while(iCount<iSize)

          {

              iNumByte = sockSend.Send(pBuf, iSize-iCount);//注意iNumByte为实际的发送字节数，不要以iSize为准

              if(iNumByte == SOCKET_ERROR)

              {

                   AfxMessageBox("发送错误！");

                   goto ExitLable1;

              }

              iCount+=iNumByte;

              if(iCount<iSize)

              {

                   file.Seek(iSize-iCount,CFile::current);

              }

          }

          uiTotal += iCount;

          //设置发送数据进度条

         pDlg->m_CtrlProgressSend.SetPos(int(((double)uiTotal/uiLength)*100));

         str.Format("发送进度：%d%%",int(((double)uiTotal/uiLength)*100));

          //表明发送数据百分比

         pDlg->GetDlgItem(IDC_STATIC_SEND)->GetWindowText(str1);

         if(str1!=str)

              pDlg->GetDlgItem(IDC_STATIC_SEND)->SetWindowText(str);

     }

     //发送文件成功

     AfxMessageBox("发送文件成功！");

ExitLable1:

     delete[] pBuf;

     file.Close();

     sockSend.Close();

     pDlg->m_CtrlProgressSend.SetPos(0);//恢复进度

     pDlg->GetDlgItem(IDC_BUTTON_SEND_END)->EnableWindow(FALSE);//设置发送结束按钮禁止

     pDlg->GetDlgItem(IDC_BUTTON_SEND)->EnableWindow(TRUE);//设置发送按钮正常

     pDlg->GetDlgItem(IDC_STATIC_SEND)->SetWindowText("发送进度："); //恢复提示进度

     return 0;

}

UINT ReceiveDataThread(LPVOID lpParam)

{

     CTzg004Dlg *pDlg=(CTzg004Dlg *)lpParam;

     //保存文件对话框

     CFileDialog dlg(FALSE,NULL,NULL,OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT,

          "所有文件 (*.*)|*.*||");

     while(dlg.DoModal()!=IDOK)

     {

         AfxMessageBox("选择文件出错，请重新选择！");

     }        

     CString str,str1,str2;

     CSocket sockRecv;

     sockRecv.Create();

     pDlg->m_CtrlIPSend.GetWindowText(str);//得到发送端IP地址

     pDlg->GetDlgItem(IDC_BUTTON_RECEIVE)->EnableWindow(FALSE);//禁止接收按钮

     while(sockRecv.Connect(str,pDlg->m_iDataPort2)==0)//连接发送方地址，若上网，可改为实际IP地址，端口要跟Server端相同。

     {

         Sleep(50);

     }

     pDlg->GetDlgItem(IDC_BUTTON_REC_END)->EnableWindow(TRUE);//打开终止接收按钮

     str2=dlg.GetPathName();//得到文件名

     CFile file;

     file.Open(str2, CFile::modeCreate | CFile::modeWrite);

     BOOL bFileFail=FALSE;

     DWORD dwTemp = 0;

     sockRecv.AsyncSelect(0);

     sockRecv.IOCtl( FIONBIO, &dwTemp);//变为阻塞方式

     UINT uiLength;

     sockRecv.Receive(&uiLength, 4);//接收发方（Server端）的文件大小

     int iBufSize = 1024 * 5;

     int iSize = iBufSize;

     LPBYTE pBuf = new BYTE[iBufSize];

     int iNumByte;

     UINT uiTotal = 0;

     while(uiTotal < uiLength)

     {

          int iEnd=0;

          //接收端终止

         if(pDlg->m_bRecEnd)

          {

              AfxMessageBox("接收端终止！");

              goto ExitLable2;

          }

          //接收发送端状态数据

         iNumByte=sockRecv.Receive(&iEnd, sizeof(int));

         if(iNumByte == SOCKET_ERROR)

          {

              AfxMessageBox("接收信号错误！");

              goto ExitLable2;

          }

          //发送端终止

         if(iEnd==1)

          {

              AfxMessageBox("发送端终止！");

              goto ExitLable2;

          }

         if((int)(uiLength - uiTotal) < iBufSize)

              iSize = uiLength - uiTotal;

          int iCount=0;

          //读取定长数据

         while(iCount<iSize)

          {

              iNumByte = sockRecv.Receive(pBuf, iSize-iCount);

              if(iNumByte == SOCKET_ERROR)

              {

                   AfxMessageBox("接收错误！");

                   goto ExitLable2;

              }

              iCount+=iNumByte;

              file.Write(pBuf, iNumByte);

          }

          uiTotal += iCount;//以实际接收字节为准

          //设置接收进度

         pDlg->m_CtrlProgressRec.SetPos(int(((double)uiTotal/uiLength)*100));

         str.Format("接收进度：%d%%",int(((double)uiTotal/uiLength)*100));

          //显示接收进度百分比

         pDlg->GetDlgItem(IDC_STATIC_REC)->GetWindowText(str1);

         if(str1!=str)

              pDlg->GetDlgItem(IDC_STATIC_REC)->SetWindowText(str);

     }

     //接收文件成功

     AfxMessageBox("接收文件成功！");

     bFileFail=TRUE;

ExitLable2:

     delete[] pBuf;

     file.Close();

     //文件接收失败，则删除接收文件

     if(!bFileFail)

     {

         CFile::Remove( str2 );

     }

     sockRecv.Close();

     pDlg->m_CtrlProgressRec.SetPos(0);//恢复接收进度

     //禁止终止接收按钮

     pDlg->GetDlgItem(IDC_BUTTON_REC_END)->EnableWindow(FALSE);

     //打开接收按钮

     pDlg->GetDlgItem(IDC_BUTTON_RECEIVE)->EnableWindow(TRUE);

     //恢复提示进度

     pDlg->GetDlgItem(IDC_STATIC_REC)->SetWindowText("接收进度：");

     return 0;

}