SOCKET 文件传输

最新推荐文章于 2025-08-11 13:53:42 发布
最新推荐文章于 2025-08-11 13:53:42 发布 · 95 阅读 · 0
文章标签：

#Socket #DOS #Java #F# #.net

本文介绍了一个通过Socket编程实现的文件传输系统，该系统包括服务端与客户端两个部分，能够实现文件的批量压缩、传输及解压功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

要求将服务端文件夹A下的文件拷贝到客户端文件A下 删除服务端文件夹A下的文件；
客户端文件夹B下的文件拷贝到服务端文件B下 然后删除客户端文件夹B下的文件；

技巧：实现过程中将要传输的文件打包后传输


服务端：

package com.socket.filetrans.exe;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

import com.socket.filetrans.LoadParamConfig;
import com.socket.zip.util.ZipUtil;


public class ServerTest   {

	int port = 0;
    static String SERVER_SENDPATH = "";
    String SERVER_SAVEPATH="";
    ServerSocket ss = null;
    Socket s = null;
    DataInputStream dis=null;
    DataOutputStream dos=null;
    static List fileList=new ArrayList();
    static ZipUtil zipUtilObj=new ZipUtil();
    public ServerTest() throws IOException{
    	Properties properties=LoadParamConfig.getProperties();
    	SERVER_SENDPATH=properties.getProperty("SERVER_SENDPATH");
    	SERVER_SAVEPATH=properties.getProperty("SERVER_SAVEPATH");
    	port=Integer.parseInt(properties.getProperty("SOCKET_PORT"));
    	ss=new ServerSocket(port);

    	File file=new File(SERVER_SENDPATH);
        if(!file.exists()){
       	 file.mkdir();
       	 System.out.println("创建目录:"+SERVER_SENDPATH);
        }  
        File file2=new File(SERVER_SAVEPATH);
        if(!file2.exists()){
       	 file2.mkdir();
       	 System.out.println("创建目录:"+SERVER_SAVEPATH);


        }  
    }

    public static void main(String arg[]) {
        try {

        	ServerTest server=new ServerTest();
        	while(true){
        		fileList=new ArrayList();
        		server.serverStart();
        		server.deleteDirectory(new File(SERVER_SENDPATH));
        		fileList=null;
        		//短时间内new socket操作很多,而socket.close()操作并不能立即释放绑定的端口,
        		//而是把端口设置为TIME_WAIT状态,过段时间(默认240s)才释放
        	    Thread.sleep(240000);
        	}

		} catch (Exception e) {
			e.printStackTrace();
		}
    }

    public void serverStart() throws Exception {


    	//===============================服务端批量写文件==========================================//
    	     File ZipFilePath=null;
    	     getAllFiles(SERVER_SENDPATH);

    	   while(true){ 
    	    if(new File(SERVER_SENDPATH).renameTo(new File(SERVER_SENDPATH))){
    	      if(fileList.size()>0){
    	    	 //压缩文件
    	    	 zipUtilObj.zip(SERVER_SENDPATH+".zip", SERVER_SENDPATH);
    	         //压缩文件绝对路径
    	    	  ZipFilePath=new File(SERVER_SENDPATH+".zip");

	    		  //写文件名
	    	      s = ss.accept();
	 		      dos = new DataOutputStream(s.getOutputStream());  
	 		      dos.writeUTF(ZipFilePath.getName());
	 		      System.out.println("服务端写文件名");
			      dos.close();


    			  //读确认信息
  	               s = ss.accept();
  	               dis= new DataInputStream(new BufferedInputStream(s.getInputStream()));   
  	  		      System.out.println(dis.readUTF());     


    	    	 //写数据
	    		   s = ss.accept();
	    		   DataInputStream fis = new DataInputStream(new BufferedInputStream(new FileInputStream(ZipFilePath)));
	    		   int bufferSize = 8192;
	               byte[] buf = new byte[bufferSize];
	               int read = 0;
	               while ((read = fis.read(buf))!=-1) {
	            	   dos = new DataOutputStream(s.getOutputStream());  
	                   dos.write(buf, 0, read);
	               }
	               dos.flush();
	               fis.close();
	               s.close();
	               System.out.println("服务端 写数据完成...");


	             //读信号
	               s = ss.accept();
	               dis= new DataInputStream(new BufferedInputStream(s.getInputStream()));   
	  		      System.out.println("服务端 读信号:"+dis.readUTF()+"\n");   
    	       }

    	       break;
    	     } 
         }
             // 服务端文件结束标志
    	     System.out.println("服务端没有数据发送或发送完成！");
    	     s = ss.accept();
 		     dos = new DataOutputStream(s.getOutputStream());  
 		     dos.writeUTF("serverFileSendOver");
		     dos.close();

		     //删除发送完的zip文件
			 boolean deleted2=false;
				if(ZipFilePath!=null){
					while(!deleted2){
						deleted2=ZipFilePath.delete();
					}
				}
		   //===============================服务端批量写文件 结束==========================================//





		 //===============================服务端批接收 文件==============================================//

			String	fileABSPath="";
			File tempFile=null;
	     while(true){

	    	 //读文件名  或者结束标志
    	 	 s = ss.accept();
			 dis= new DataInputStream(new BufferedInputStream(s.getInputStream())); 
			 String fileName="";

			 if("clientFileSendOver".endsWith(fileName=dis.readUTF())){
				 System.out.println("服务端 收到客户端文件结束标志:"+fileName);   
				 break;
			 }
			 System.out.println("服务端 收到文件名:"+fileName);   

			//写确认信息
			  s = ss.accept();
              dos = new DataOutputStream(new BufferedOutputStream(s.getOutputStream()));
              dos.writeUTF("服务端 确认收到文件名:"+fileName);
			   // dos.flush();
			  dos.close();

			//读文件
		    fileABSPath=SERVER_SAVEPATH+File.separator+fileName;
            File tempdir=new File(fileABSPath.substring(0, fileABSPath.lastIndexOf("\\")));
            tempFile=new File(fileABSPath);
            if(!tempdir.exists()){
         	   tempdir.mkdirs();

            }
            if(!tempFile.exists()){
         	   tempFile.createNewFile();
            }
            s = ss.accept();
			DataOutputStream fos = new DataOutputStream(new BufferedOutputStream(new BufferedOutputStream(new FileOutputStream(tempFile))));
			dis= new DataInputStream(new BufferedInputStream(s.getInputStream()));   
			 int bufferSize = 8192;
	         byte[] buf = new byte[bufferSize];
	         int read = 0;
	         while ((read = dis.read(buf))!=-1) {
	                fos.write(buf, 0, read);
	            }
	         fos.close();
	         System.out.println("服务端 读取数据完成...");


	         //写信号
	          s = ss.accept();
                dos = new DataOutputStream(new BufferedOutputStream(s.getOutputStream()));
                dos.writeUTF("ServerRecieved");
			   // dos.flush();
			  dos.close();

			   System.out.println("......服务端 接收数据结束...开始解压文件...");

	     }


	       //解压数据
			if(!"".equals(fileABSPath) && ".zip".equals(fileABSPath.substring(fileABSPath.lastIndexOf(".")))){
				zipUtilObj.unzip(fileABSPath, SERVER_SAVEPATH);	
			}
			//删除压缩文件
			boolean deleted=false;
			if(tempFile!=null){
				while(!deleted){
					deleted=tempFile.delete();
				}
			}
    }
    //===============================服务端批接收 文件  结束==============================================//  





    /*
	 * 递归删除一个目录以及下面的文件
	 */
	public  boolean deleteDirectory(File path) {   
	    if( path.exists() ) {   
	      File[] files = path.listFiles();   
	      for(int i=0; i<files.length; i++) {   
	         if(files[i].isDirectory()) {   
	           deleteDirectory(files[i]);  
	         }   
	         else {   
	        	 //删除文件
	           files[i].delete();   
	         }   
	      }   
	    }   
	   //删除目录
	    boolean hasdelete=false;
	    if(!SERVER_SENDPATH.equals(path.getAbsolutePath())){
	     hasdelete=path.delete();
	    if(hasdelete){
	    	System.out.println("删除目录:"+path);

	    }
	    }
		return hasdelete;


	  }   
    /**
     * 得到服务端要发送的文件列表
     * @param dir
     * @return
     * @throws Exception
     */
    public void  getAllFiles(String dir) throws Exception{
    	File file=new File(dir);

    	if(!file.exists()){
    		file.mkdir();
    	}
    	File[] fs = file.listFiles();
		 if(fs!=null){
			 for(int i=0; i<fs.length; i++){
				   if(fs[i].isFile()){
					   fileList.add(fs[i].getAbsolutePath().substring(SERVER_SENDPATH.length()));
				   }
				   if(fs[i].isDirectory()){
				    try{
				    	getAllFiles(fs[i].getPath());
				    }catch(Exception e){}
				   }
				  } 
		 }





  }




}




客户端：

package com.socket.filetrans.exe;


import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

import com.socket.filetrans.LoadParamConfig;
import com.socket.zip.util.ZipUtil;


public class ClientTest {
    private Socket socket = null;

    private String ip = "";// 设置成服务器IP

    private int port = 0;

    static List fileList=null;;
    static String CLIENT_SENDPATH ="";
    String CLIENT_SAVEPATH="";
    DataInputStream dis=null;
    DataOutputStream dos=null;
    static ZipUtil zipUtilObj=new ZipUtil();

public ClientTest() {
        try {
        	Properties properties=LoadParamConfig.getProperties();
        	CLIENT_SENDPATH=properties.getProperty("CLIENT_SENDPATH");
        	CLIENT_SAVEPATH=properties.getProperty("CLIENT_SAVEPATH");
        	port=Integer.parseInt(properties.getProperty("SOCKET_PORT"));
        	ip=properties.getProperty("IP_ADDRESS");
        	File file=new File(CLIENT_SENDPATH);
            if(!file.exists()){
           	 file.mkdir();
           	 System.out.println("创建目录:"+CLIENT_SENDPATH);
            }  
            File file2=new File(CLIENT_SAVEPATH);
            if(!file2.exists()){
           	 file2.mkdir();
           	 System.out.println("创建目录:"+CLIENT_SAVEPATH);
            }  



        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

	public static void main(String arg[]) {
	    try {

	    	ClientTest client=new ClientTest();
	    	while(true){
	    	fileList=new ArrayList();
	    	 client.clientStart();
	    	 client.deleteDirectory(new File(CLIENT_SENDPATH));
	    	 fileList=null;
	    	//短时间内new socket操作很多,而socket.close()操作并不能立即释放绑定的端口,
     		//而是把端口设置为TIME_WAIT状态,过段时间(默认240s)才释放
	    	 Thread.sleep(240000);
	    	}

		} catch (Exception e) {
			e.printStackTrace();
		}
	}


    public void clientStart() throws Exception {

    	    String fileABSPath="";
    	    File tempFile=null;
			//=======================客户端批量 读取文件==================================//
			while(true){

				//读文件名 或者结束标志
				 socket = new Socket(ip, port);
				 dis= new DataInputStream(new BufferedInputStream(socket.getInputStream())); 
				 String fileName="";

				 if("serverFileSendOver".endsWith(fileName=dis.readUTF())){
					 System.out.println("客户端 收到服务端文件结束标志:"+fileName);   
					 break;
				 }
				 System.out.println("收到文件名:"+fileName);   


				 //写确认信息
				  socket = new Socket(ip, port);
	              dos = new DataOutputStream(new BufferedOutputStream(socket.getOutputStream()));
	              dos.writeUTF("客户端 确认收到文件名:"+fileName);
				   // dos.flush();
				  dos.close();


				//读 
			    fileABSPath=CLIENT_SAVEPATH+File.separator+fileName;
	            File tempdir=new File(fileABSPath.substring(0, fileABSPath.lastIndexOf("\\")));
	            tempFile=new File(fileABSPath);
	            if(!tempdir.exists()){
	         	   tempdir.mkdirs();

	            }
	            if(!tempFile.exists()){
	         	   tempFile.createNewFile();
	            }
				socket = new Socket(ip, port);
				DataOutputStream fos = new DataOutputStream(new BufferedOutputStream(new BufferedOutputStream(new FileOutputStream(tempFile))));
				dis= new DataInputStream(new BufferedInputStream(socket.getInputStream()));   
				 int bufferSize = 8192;
		         byte[] buf = new byte[bufferSize];
		         int read = 0;
		         while ((read = dis.read(buf))!=-1) {
		                fos.write(buf, 0, read);
		            }
		         fos.close();
		         System.out.println("客户端 读取数据完成...");


		         //写信号
                socket = new Socket(ip, port);
                dos = new DataOutputStream(new BufferedOutputStream(socket.getOutputStream()));
                dos.writeUTF("ClientRecieved");
                System.out.println("客户端 发送 收到信号:ClientRecieved"+"\n");
			   // dos.flush();
			    dos.close();

			    System.out.println("......客户端 接收数据结束...开始解压文件...");


			}

			//解压数据
			if(!"".equals(fileABSPath) && ".zip".equals(fileABSPath.substring(fileABSPath.lastIndexOf(".")))){
				zipUtilObj.unzip(fileABSPath, CLIENT_SAVEPATH);	
			}
			//删除压缩文件
			boolean deleted=false;
			if(tempFile!=null){
				while(!deleted){
					deleted=tempFile.delete();
				}
			}

			//=======================客户端批量 读取文件 结束==================================//    




		  //=======================客户端批量  发送文件    ==================================//   	

			File ZipFilePath=null;

			getAllFiles(CLIENT_SENDPATH);

		   while(true){ 

			 if(new File(CLIENT_SENDPATH).renameTo(new File(CLIENT_SENDPATH))){

		     if(fileList.size()>0){
				 //压缩文件
    	     zipUtilObj.zip(CLIENT_SENDPATH+".zip", CLIENT_SENDPATH);
    	         //压缩文件绝对路径
    	     ZipFilePath=new File(CLIENT_SENDPATH+".zip");



    	    	 //写文件名
                socket = new Socket(ip, port);
                dos = new DataOutputStream(new BufferedOutputStream(socket.getOutputStream()));
                dos.writeUTF(ZipFilePath.getName());
                System.out.println("客户端写文件名");
			   // dos.flush();
			    dos.close();

			  //读确认信息
			    socket = new Socket(ip, port);
	               dis= new DataInputStream(new BufferedInputStream(socket.getInputStream()));   
	  		      System.out.println(dis.readUTF());     


    	     //写数据


             socket = new Socket(ip, port);
  		   DataInputStream fis = new DataInputStream(new BufferedInputStream(new FileInputStream(ZipFilePath)));
  		   int bufferSize = 8192;
             byte[] buf = new byte[bufferSize];
             int read = 0;
             while ((read = fis.read(buf))!=-1) {
          	   dos = new DataOutputStream(socket.getOutputStream());  
                 dos.write(buf, 0, read);
             }
             dos.flush();
             fis.close();
             socket.close();
             System.out.println("客户端 写数据完成...");


            //读信号
             socket = new Socket(ip, port);
             dis= new DataInputStream(new BufferedInputStream(socket.getInputStream()));   
		     System.out.println("客户端 读信号:"+dis.readUTF()+"/n");    

    	     }
		   break;
		     }
		 }


			//客户端文件结束标志
			 System.out.println("客户端 没有数据发送或发送完成！");
    	     socket = new Socket(ip, port);
 		     dos = new DataOutputStream(socket.getOutputStream());  
 		     dos.writeUTF("clientFileSendOver");
		     dos.close(); 





		//删除发送完的zip文件
		 boolean deleted2=false;
			if(ZipFilePath!=null){
				while(!deleted2){
					deleted2=ZipFilePath.delete();
				}
			}
		  //=======================客户端批量 发送文件 结束    ==================================//    	




 }






     /*
 	 * 递归删除一个目录以及下面的文件
 	 */
 	public  boolean deleteDirectory(File path) {   
 	    if( path.exists() ) {   
 	      File[] files = path.listFiles();   
 	      for(int i=0; i<files.length; i++) {   
 	         if(files[i].isDirectory()) {   
 	           deleteDirectory(files[i]);  
 	         }   
 	         else {   
 	        	 //删除文件
 	           files[i].delete();   
 	         }   
 	      }   
 	    }   
 	   //删除目录
 	   boolean hasdelete=false;
	    if(!CLIENT_SENDPATH.equals(path.getAbsolutePath())){
 	     hasdelete=path.delete();
 	    if(hasdelete){
 	    	System.out.println("删除目录:"+path);

 	    }
	    }
 		return hasdelete;


 	  }   




    /**
     * 得到服务端要发送的文件列表
     * @param dir
     * @return
     * @throws Exception
     */
 	 public void  getAllFiles(String dir) throws Exception{
     	File file=new File(dir);

     	if(!file.exists()){
     		file.mkdir();
     	}
     	File[] fs = file.listFiles();
 		 if(fs!=null){
 			 for(int i=0; i<fs.length; i++){
 				   if(fs[i].isFile()){
 					   fileList.add(fs[i].getAbsolutePath().substring(CLIENT_SENDPATH.length()));
 				   }
 				   if(fs[i].isDirectory()){
 				    try{
 				    	getAllFiles(fs[i].getPath());
 				    }catch(Exception e){}
 				   }
 				  } 
 		 }


   }


}


配置文件：

######### CLIENT_CONFIG #########
CLIENT_SENDPATH=D:\\SOCKET\\client_fa
CLIENT_SAVEPATH=D:\\SOCKET\\client_shou
SOCKET_PORT=8873
IP_ADDRESS=localhost

######### SERVER_CONFIG #########
SERVER_SENDPATH=D:\\SOCKET\\server_fa
SERVER_SAVEPATH=D:\\SOCKET\\server_shou




参数加载器：

package com.socket.filetrans;

import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.Properties;

public class LoadParamConfig {

	public static Properties  getProperties(){
		Properties	properties=new Properties();
		   URL url= Thread.currentThread().getContextClassLoader().getResource("config.properties");
		       InputStream in = null; 
		       if(url != null){
		        try {
					in = url.openStream();
					properties.load(in);
					//String path=properties.getProperty("importFilePath");
				} catch (IOException e) {
					e.printStackTrace();
				}
		       }
			return properties;
	}


}



ZIP压缩和解压缩工具包：

package com.socket.zip.util;

import java.util.*;
import java.util.zip.*;
import java.io.*;

public class ZipUtil 
{
	public void zip(String zipFileName,String inputFile)throws Exception{
		zip(zipFileName,new File(inputFile));
	}
	public void zip(String zipFileName,File inputFile)throws Exception{
		ZipOutputStream out=new ZipOutputStream(new FileOutputStream(zipFileName));
		zip(out,inputFile,"");
		System.out.println("zip done");
		out.close();
	}

	public void unzip(String zipFileName,String outputDirectory)throws Exception{
		ZipInputStream in=new ZipInputStream(new FileInputStream(zipFileName));
		ZipEntry z;
		while ((z=in.getNextEntry() )!= null)
		{
			System.out.println("unziping "+z.getName());
			if (z.isDirectory())
			{
				String name=z.getName();
				name=name.substring(0,name.length()-1);
				File f=new File(outputDirectory+File.separator+name);
				f.mkdir();
				System.out.println("mkdir "+outputDirectory+File.separator+name);
			}
			else{
				File f=new File(outputDirectory+File.separator+z.getName());
				f.createNewFile();
				FileOutputStream out=new FileOutputStream(f);
				int b;
				while ((b=in.read()) != -1)
					out.write(b);
				out.close();
			}
		}

		in.close();
	}

	public void zip(ZipOutputStream out,File f,String base)throws Exception{
		System.out.println("Zipping  "+f.getName());
		if (f.isDirectory())
		{
			File[] fl=f.listFiles();
			out.putNextEntry(new ZipEntry(base+"/"));
			base=base.length()==0?"":base+"/";
			for (int i=0;i<fl.length ;i++ )
			{
				zip(out,fl[i],base+fl[i].getName());
			}
		}
		else
		{
			out.putNextEntry(new ZipEntry(base));
			FileInputStream in=new FileInputStream(f);
			int b;
			while ((b=in.read()) != -1)
				out.write(b);
			in.close();
		}

	}


	public static void main(String[] args) 
	{
		try{
		ZipUtil t=new ZipUtil();
		t.zip("D:\\wulihai\\SocketTrans.zip","D:\\wulihai\\SocketTrans");
		t.unzip("D:\\wulihai\\SocketTrans.zip","D:\\wulihai\\开发手册");
		}
		catch(Exception e){e.printStackTrace(System.out);}
	}
}
java socket传输_java socket 文件传输
weixin_42498487的博客
02-12 1083
闲着无聊，写了一个基于java的socket文件传输。是这样设计的：1、Server提供文件传输的server服务器端，接收client发送过来的文件。提供多线程并发处理，能同时处理多个client的文件传输请求。2、Client根据提供的参数指定的server以及本地文件的路径，进行文件传输client的代码import java.io.BufferedInputStream;import ja...
android Socket文件传输
09-02
在Android平台上，Socket文件传输是一种常见的通信方式，尤其适用于设备间的文件共享，即使涉及的是大文件，如几十兆(MB)的数据。本文将深入探讨如何使用Android的Socket进行文件传输，以及实现过程中需要注意的关键...
socket文件传输
nahnah_的博客
11-20 3166
socket实现文件传输，很拉我就记录下
基于c语言实现socket文件传输
tutu_hu的博客
06-05 9174
c语言实现基于socket的文件传输，从server传输到client。
掌握Socket文件传输技术：从基础到实战
weixin_42613360的博客
05-08 977
Socket通信是计算机网络应用中进程间通信的一种机制。它允许不同主机上的程序通过网络发送和接收数据。Socket可以看作是网络通信的端点，提供了操作数据流的接口。在讨论TCP/IP模型时，网络层的核心协议，IP协议（Internet Protocol）扮演着至关重要的角色。IP协议定义了数据包的格式和数据包的传输机制，它确保了数据包可以在复杂网络中进行传输和路由。IP协议作为无连接的协议，不保证数据包的到达顺序、是否重复或是否丢失。
14.9 Socket 高效文件传输
优快云
10-17 6213
网络上的文件传输功能也是很有必要实现一下的，网络传输文件的过程通常分为客户端和服务器端两部分。客户端可以选择上传或下载文件，将文件分块并逐块发送到服务器，或者从服务器分块地接收文件。服务器端接收来自客户端的请求，根据请求类型执行对应的操作，并根据发送的文件名或其他标识来确定要传输的文件。
使用Java完成Socket文件传输
m0_57099067的博客
04-19 4404
分别使用三个类(TCPFileUpload_Server服务器端、TCPFileUpload_Client客户端、StreamUtils工具类)完成图片的传输。 同样先运行服务器端文件，再运行客户端文件 import java.io.*; import java.net.ServerSocket; import java.net.Socket; /** * 服务器端 */ public class TCPFileUpload_Server { public static void mai
socket文件传输服务器,Socket文件传输（含服务端以及客户端源码）
weixin_39627361的博客
08-10 667
Socket文件传输【实例简介】传输任意格式文件【实例截图】【核心代码】using System;using System.Collections.Generic;using System.ComponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using System.Wi...
C#网络编程：Socket文件传输技术解析与实现
weixin_42612804的博客
11-04 1348
本文还有配套的精品资源，点击获取 简介：本文深入探讨了Socket编程在C#中的应用，特别是在文件传输方面的实践。首先介绍了Socket的基础概念和在C#中的实现方式。接着详细解析了通过Socket进行文件传输的关键步骤，包括服务器端和客户端的设置、文件分块处理、数据传输以及错误处理和连接关闭。文章还提到了优化文件传输性能的异步I/O技术，并强调了正确处理二进制数据的重要性...
android Socket文件传输（readFully)
weixin_52263647的博客
09-02 1748
最近写的项目里要用到文件传输的功能，因此我查找了很多相关的博文，查找到的文章都大同小异。但是这些内容仅限于一些小文件，比如一个几百K到的txt文档，但是我们实际需要传输的数据量远大于这个数，解决不了实际问题。因此这篇博文将用readfully方法实现较大文件的传输，当然这个也有一定的局限性，只适用一些较大的文件，大约在100M以内，对于更大的文件，涉及断点续传的问题，本篇文章没有展现。
Android Socket文件传输：高效、稳定的文件共享利器
gitblog_09708的博客
10-28 303
Android Socket文件传输：高效、稳定的文件共享利器 去发现同类优质开源项目:https://gitcode.com/ 项目介绍 在移动应用开发中，文件传输是一个常见且重要的功能需求。特别是在Android平台上，如何在设备之间实现高效、稳定的文件传输，一直是开发者关注的焦点。为了解决这一问题，我们推出了Android Socket文件传输项目，这是一个专门为Android设备设计的So...
Socket文件传输
09-25
Socket文件传输是一种网络通信技术，它允许两台计算机通过Internet或其他网络进行数据交换。在本软件中，MFC（Microsoft Foundation Classes）库被用来实现面向对象的编程，以构建一个功能完善的Socket文件传输系统...
C#Socket文件传输简单例子（将文件名和文件同时传输）
04-09
在压缩包中的`SocketDemo`项目中，应该包含了实现这个功能的C#代码示例，你可以参考其中的`Server`和`Client`类，理解并学习如何使用Socket进行文件传输。通过实际操作，你会更深入地掌握C# Socket通信的核心技巧。
38.【.NET8 实战--孢子记账--从单体到微服务--转向微服务】--扩展功能--增加日志记录器
喵叔
08-07 351
本文介绍了如何将Loki日志系统集成到孢子记账微服务项目中。首先通过修改日志公共代码，利用Nacos配置中的ServiceName作为Loki的AppName，避免了重复配置。然后在各个微服务中引入日志服务，以用户配置服务为例演示了日志记录的使用方法。这种集中式日志管理方案减少了代码冗余，提高了维护效率，便于问题定位和系统监控。文章还强调了合理使用日志级别的重要性，并指出Loki能有效提升日志管理效率。
使用 C# 通过 .NET 框架开发应用程序的安装与环境配置
sensen_kiss的博客
08-08 1163
.NET开发环境配置指南 本文介绍了.NET开发环境的安装与配置方法。.NET是微软推出的开源跨平台开发框架，支持多种应用开发，主要使用C#语言。文章提供了两种IDE选择：JetBrains Rider和Visual Studio，详细讲解了它们的安装步骤。同时介绍了两种.NET SDK安装方式：单独下载安装和通过Visual Studio工作负荷安装。环境配置完成后，可通过命令行验证安装是否成功。对于曾使用Unity开发C#的用户，文章解释了为何需要额外安装.NET SDK的原因。
.NET/C# webapi框架下给swagger的api文档中显示注释（可下载源码）
最新发布
weixin_46407807的博客
08-11 151
.NET 9 中实现带注释的 Swagger API 文档 本文介绍了在 .NET 9 中如何为 Web API 添加 Swagger 文档支持： 在 Controller 中创建 Post 和 Put 方法，使用 /// 注释添加方法说明 在项目属性中启用 XML 文档生成 在 Swagger 配置中添加 IncludeXmlComments 以包含注释 最终实现效果：Swagger UI 中会显示完整的 API 方法和注释说明 这种方法可以方便地为 API 添加文档支持，提升开发体验和 API 的可读性
在VB.NET中，什么是委托（Delegate）
fsyuheduo的博客
08-10 386
通过委托，VB.NET 实现了方法调用的动态化与解耦，尤其在事件驱动和异步编程中不可或缺。委托（Delegate） 是一种特殊的引用类型，它允许将方法作为参数传递、存储或动态调用，本质上是类型安全的函数指针。委托：无返回值方法（特点：无需显式声明委托类型（如 Delegate Sub LogDelegate()）。：有返回值方法（特点：省略了自定义 Delegate Function 的声明步骤。的基础，用于绑定事件触发时执行的方法（如按钮点击事件）。法的签名（参数类型、返回类型）。的方法，确保了类型安。
对 .NET线程 异常退出引发程序崩溃的反思
一线码农的专栏
08-05 782
如今.NET的主战场在工控，而工控中有大量的C#和C++交互的场景，C++处理不慎就会导致C#灾难性后果，这篇文章所输出的经验希望给后来者少踩坑吧！
C# socket文件传输源码项目
C# socket文件传输源码的深入解读涉及了网络编程、文件操作和多线程处理等多个方面的知识。在开发实际的文件传输程序时，开发者需要充分理解这些知识点，并结合实际项目需求来设计和实现功能。通过优化数据传输过程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值