如何把多个文件写入到一个文件中去并能分解

最新推荐文章于 2019-05-24 10:03:33 发布
转载 最新推荐文章于 2019-05-24 10:03:33 发布 · 789 阅读 · 0
文章标签：

#byte #buffer #string #exception #null #structure

本文介绍了一种将多个文件合并为单个文件，并能够从该文件中还原出原始文件的技术实现方法。通过使用FileStream进行读写操作及自定义文件索引来记录每个文件的位置和长度信息，实现了文件的有效管理和恢复。

From: http://blog.youkuaiyun.com/Knight94/archive/2006/05/17/742055.aspx 

对于一个文件的读写，其实很简单，就是用FileStream进行Read或者Write就行了。但是如何把多个文件写入到同一个文件，之后要能把这个文件进行还原成多个文件。那么光靠FileStream的Read和Write方法是不够的，首先你需要自行建立文件索引，来标明每个文件在当前文件的位置。

 

那么最近作了一个简单的DEMO，其中类的部分代码如下：

 // ------------------------------- Compose Files ----------------------------------

 // --------------------------------------------------------------------------------

 // ---File:clsComposeFiles.cs

 // ---Description:This file is to show how-to compose multi-files into one file 

 //                and decompose one file to multi-files.

 // ---Author:Knight

 // ---Date:May.16, 2006

 // --------------------------------------------------------------------------------

 // ------------------------------{ Compose Files }---------------------------------

 

 namespace  ComposeFiles

 {

    using System;

    using System.IO;

    using System.Collections;

    using System.Text;

 

    /// <summary>

    /// Summary description for clsComposeFiles.

    /// </summary>

    public class clsComposeFiles

    {

        private ArrayList arrFiles = new ArrayList();

 

        public clsComposeFiles()

        {

            //

            // TODO: Add constructor logic here

            //

        }

 

        /// <summary>

        /// Add a file to be composed

        /// </summary>

        /// <param name="sFileName"></param>

        public void AddFile( string sFileName )

        {

            arrFiles.Add( sFileName );

        }

 

        /// <summary>

        /// Compose files to the specific file

        /// </summary>

        /// <param name="sFileName"></param>

        /// <returns></returns>

        public bool ComposeFiles( string sFileName )

        {

            if( arrFiles.Count == 0 ) return false;

            

            FileInfo fi = new FileInfo( sFileName );

            // Open file to write

            FileStream fsWriter = null;

            try

            {

                if( !fi.Exists )

                {

                    fsWriter = new FileStream( 

                        sFileName, 

                        FileMode.CreateNew, 

                        FileAccess.ReadWrite,

                        FileShare.None );

                }

                else

                    fsWriter = new FileStream( 

                        sFileName, 

                        FileMode.Truncate, 

                        FileAccess.ReadWrite,

                        FileShare.None );

            }

            catch(Exception err)

            {

                System.Diagnostics.Debug.WriteLine( err.Message );

                return false;

            }

            

            byte[] bBuffer = null;

            // Write files count

            bBuffer = FileIndex.LongToBytes( arrFiles.Count );

            fsWriter.Write( bBuffer, 0, 8 );

 

            const long INDEX_START_POS = 8L;

            // Init files index

            FileIndex FI = new FileIndex();

            for( int i = 0; i < arrFiles.Count; i++ )

                fsWriter.Write( FileIndex.ConvertToBytes( ref FI ), 0, 32 );

 

            long FILE_START_POS = INDEX_START_POS + 32 * arrFiles.Count;

            long lCurFileStartPos = FILE_START_POS;

 

            // Write every file

            for( int i = 0; i < arrFiles.Count; i++ )

            {

                WriteFile( arrFiles[i].ToString(),

                    ref lCurFileStartPos,

                    INDEX_START_POS,

                    fsWriter,

                    i );

            }

 

            // Close stream

            fsWriter.Close();

            return true;

        }

 

        /// <summary>

        /// Write file name and data into composed file

        /// </summary>

        /// <param name="sFileName"></param>

        /// <param name="FileStartPos"></param>

        /// <param name="IndexStartPos"></param>

        /// <param name="fsWriter"></param>

        /// <param name="Index"></param>

        private void WriteFile( 

            string sFileName, 

            ref long FileStartPos,

            long IndexStartPos,

            FileStream fsWriter,

            int Index )

        {

            FileInfo fi = new FileInfo( sFileName );

            if( !fi.Exists ) return;

 

            FileStream fsReader = null;

            try

            {

                fsReader = new FileStream( 

                    sFileName, FileMode.Open, 

                    FileAccess.Read );

            }

            catch{ return;}

 

            // Get file name

            byte[] bFileName = Encoding.Unicode.GetBytes( fi.Name );

            // Write file name

            fsWriter.Write( bFileName, 0, bFileName.Length );

 

            const int BUFFER_LENGTH = 1024;

            byte[] bBuffer = new byte[BUFFER_LENGTH];

            int nRealRead = 0;

            // Write data using

            do

            {

                // Read data from file

                nRealRead = fsReader.Read( bBuffer, 0, 

                    BUFFER_LENGTH );

                // Write data 

                fsWriter.Write( bBuffer, 0, nRealRead );

            }while( nRealRead > 0 );

            // Close file reader

            fsReader.Close();

 

            FileIndex FINew = new FileIndex();

            FINew.NameStartPos = FileStartPos;

            FINew.NameLength = bFileName.Length;

            FINew.FileStartPos = FileStartPos + bFileName.Length;

            FINew.FileLength = fi.Length;

 

            // Go back to file index position

            fsWriter.Seek( IndexStartPos + Index * 32, SeekOrigin.Begin );

 

            // Write file index info

            fsWriter.Write( FileIndex.ConvertToBytes( ref FINew ), 0, 32 );

 

            // Go back to file end

            fsWriter.Seek( 0, SeekOrigin.End );

 

            // Set file current position

            FileStartPos += bFileName.Length + fi.Length;

        }

 

        /// <summary>

        /// Decompose file to multi files into specific directory

        /// </summary>

        /// <param name="sFileName"></param>

        /// <param name="sDestDir"></param>

        /// <returns></returns>

        public bool DecomposeFile( string sFileName, string sDestDir )

        {

            FileInfo fi = new FileInfo( sFileName );

            if( !fi.Exists ) return false;

 

            FileStream fsReader = null;

            try

            {

                fsReader = new FileStream( 

                    sFileName, FileMode.Open, 

                    FileAccess.Read );

            }

            catch{ return false;}

            

            // Read file count

            byte[] bFileCount = new byte[8];

            int nRealRead = 0;

            nRealRead = fsReader.Read( bFileCount, 0, 8 );

            if( nRealRead != 8 )

            {

                fsReader.Close();

                return false;

            }

 

            long lFileCount = FileIndex.BytesToLong( bFileCount );

            if( lFileCount > 0 )

            {

                //Init file index array

                FileIndex[] fiArray = new FileIndex[lFileCount];

                byte[] bFileIndex = new byte[32];

                for( int i = 0; i < lFileCount; i++ )

                {

                    fsReader.Read( bFileIndex, 0, 32 );

                    fiArray[i] = FileIndex.ConvertToFileIndex( bFileIndex );

                }

 

                if( sDestDir[ sDestDir.Length - 1] != '//' )

                    sDestDir += "//";

                // Save every file into current directory

                for( int i = 0; i < fiArray.Length; i++ )

                {

                    SaveFile( fsReader,

                        ref fiArray[i],

                        sDestDir );

                }

            }

 

            // Close file reader

            fsReader.Close();

            return true;

        }

 

        /// <summary>

        /// Save every file into directory

        /// </summary>

        /// <param name="fsReader"></param>

        /// <param name="FI"></param>

        /// <param name="sDestDir"></param>

        private void SaveFile( 

            FileStream fsReader,

            ref FileIndex FI,

            string sDestDir )

        {

            // Read file name

            byte[] bFileName = new byte[ FI.NameLength ];

            int nRealRead = fsReader.Read( bFileName, 0, bFileName.Length );

            if( nRealRead != bFileName.Length ) return;

            string sFileName = Encoding.Unicode.GetString( bFileName );

            sFileName = sDestDir + sFileName;

            FileInfo fi = new FileInfo( sFileName );

            // Open file to write

            FileStream fsWriter = null;

            try

            {

                if( !fi.Exists )

                {

                    fsWriter = new FileStream( 

                        sFileName, 

                        FileMode.CreateNew, 

                        FileAccess.ReadWrite,

                        FileShare.None );

                }

                else

                    fsWriter = new FileStream( 

                        sFileName, 

                        FileMode.Truncate, 

                        FileAccess.ReadWrite,

                        FileShare.None );

            }

            catch(Exception err){

                System.Diagnostics.Debug.WriteLine( err.Message );

                return;

            }

        

            // Init buffer  

            const int BUFFER_LENGTH = 1024;

            byte[] bBuffer = new byte[BUFFER_LENGTH];

            long lLeft = FI.FileLength;

 

            // Copy file 

            do

            {

                if( lLeft > BUFFER_LENGTH )

                {

                    fsReader.Read( bBuffer, 0, BUFFER_LENGTH );

                    fsWriter.Write( bBuffer, 0, BUFFER_LENGTH );

 

                    lLeft -= BUFFER_LENGTH;

                }

                else

                {

                    nRealRead = fsReader.Read( bBuffer, 0, (int)lLeft );

                    fsWriter.Write( bBuffer, 0, nRealRead );

 

                    lLeft -= nRealRead;

                }

            }

            while( lLeft > 0 );

 

            // close file writer

            fsWriter.Close();

        }

    }

 

    /// <summary>

    /// File index data structure

    /// </summary>

    public struct FileIndex

    {

        public long NameStartPos;

        public long NameLength;

        public long FileStartPos;

        public long FileLength;

 

        public static byte[] ConvertToBytes( ref FileIndex FI  )

        {

            byte[] bData = new byte[32];

 

            Array.Copy( LongToBytes( FI.NameStartPos ), 0, bData, 0, 8 );

            Array.Copy( LongToBytes( FI.NameLength ), 0, bData, 8, 8 );

            Array.Copy( LongToBytes( FI.FileStartPos ), 0, bData, 16, 8 );

            Array.Copy( LongToBytes( FI.FileLength ), 0, bData, 24, 8 );

 

            return bData;

        }

 

        public static byte[] LongToBytes( long lValue )

        {

            byte[] bData = new byte[8];

    

            bData[0] = (byte)( ( lValue >> 56 ) & 0xFF);

            bData[1] = (byte)( ( lValue >> 48 ) & 0xFF);

            bData[2] = (byte)( ( lValue >> 40 ) & 0xFF);

            bData[3] = (byte)( ( lValue >> 32 ) & 0xFF);

            bData[4] = (byte)( ( lValue >> 24 ) & 0xFF);

            bData[5] = (byte)( ( lValue >> 16 ) & 0xFF);

            bData[6] = (byte)( ( lValue >> 8 ) & 0xFF);

            bData[7] = (byte)(lValue & 0xFF);

            return bData;

        }

 

        public static FileIndex ConvertToFileIndex( byte[] bData )

        {

            if( bData == null || bData.Length != 32 ) 

                throw new Exception( "Invalid parameters!" );

 

            FileIndex FI = new FileIndex();

            byte[] bBuffer = new byte[8];

            Array.Copy( bData, 0, bBuffer, 0, 8 );

            FI.NameStartPos = BytesToLong( bBuffer );

            Array.Copy( bData, 8, bBuffer, 0, 8 );

            FI.NameLength = BytesToLong( bBuffer );

            Array.Copy( bData, 16, bBuffer, 0, 8 );

            FI.FileStartPos = BytesToLong( bBuffer );

            Array.Copy( bData, 24, bBuffer, 0, 8 );

            FI.FileLength = BytesToLong( bBuffer );

            return FI;

        }

 

        public static long BytesToLong( byte[] bData )

        {

            if( bData == null || bData.Length != 8 )

                throw new Exception( "Invalid parameters!" );

 

            long lngValue = 0;

            lngValue += bData[0];

            lngValue = ( lngValue << 8 );

            lngValue += bData[1];

            lngValue = ( lngValue << 8 );

            lngValue += bData[2];

            lngValue = ( lngValue << 8 );

            lngValue += bData[3];

            lngValue = ( lngValue << 8 );

            lngValue += bData[4];

            lngValue = ( lngValue << 8 );

            lngValue += bData[5];

            lngValue = ( lngValue << 8 );

            lngValue += bData[6];

            lngValue = ( lngValue << 8 );

            lngValue += bData[7];

            return lngValue;

        }

    }

}

 

其中类的操作参看clsComposeFiles这个类，而文件索引结构参看FileIndex这个Structure。

 

之后的调用就很简单，例如：

合成文件：

    clsComposeFiles myComposeFiles  =   new  clsComposeFiles();

    myComposeFiles.AddFile(  @" D:/Ship.exe "  );

    myComposeFiles.AddFile(  @" D:/LoginPage.JPG "  );

myComposeFiles.ComposeFiles(  @" D:/Ship.dat "  );

 

分解文件：

    clsComposeFiles myComposeFiles  =   new  clsComposeFiles();

    myComposeFiles.DecomposeFile(  @" D:/Ship.dat " ,  @" E:/ "  );

 

以上代码由于写得比较急，细节处理并不是很完善，因此使用的时候要加以细化，甚至可以在我的基础上进行扩充。
 
Python基础——一个文件拆分为多个文件
JKenina的博客
06-14 1461
利用python将一个文件拆分为多个文件
可视化编排的数据集成和分发开源框架Nifi轻松入门-上
itxiaoshen博客
12-14 2493
如何你正在为数据采集做技术选型，今天介绍一款功能极其强大性能也高且采用可视化编排的数据集成框架nifi可以列入选型范畴，是数仓开发的强大工具之一，只要使用后就能体会到其丰富的处理器和扩展性。先了解其特性、核心概念和架构，也支持分布式集群，了解常见处理器分类，最后通过源码安装并使用两个简单的处理器演示一个基础入门示例
如何把多个文件写入到一个文件中去并能分解[转]
anhai6033的博客
10-10 164
http://blog.youkuaiyun.com/Knight94/archive/2006/05/17/742055.aspx 对于一个文件的读写，其实很简单，就是用FileStream进行Read或者Write就行了。但是如何把多个文件写入到同一个文件，之后要能把这个文件进行还原成多个文件。那么光靠FileStream的Read和Write方法是不够的，首先你需要自行建立文件索引，来...
多个文件写入到一个文件里
liaozhiweihaifeng的专栏
09-01 568
/* * 其中类的操作参看clsComposeFiles这个类，而文件索引结构参看FileIndex这个Structure。 *  * */namespace ComposeFiles{    using System;    using System.IO;    using System.Collections;    using System.Text;     //
5、NiFi FileFlow示例和NIFI模板示例
05-29
5、NiFi FileFlow示例和NIFI模板示例 网址：https://blog.youkuaiyun.com/chenwewi520feng/article/details/130614514 本文旨在介绍FlowFile属性和内容、模板和简单介绍一个应用示例。其中模板将是后续文章的主要使用内容。 本分前提是nifi环境正常使用。 本分分为三个部分，即FlowFile生成器示例、模板以及FlowFile的内容与属性。
多个文件合并为一个文件并将文件拆分开来
05-23
本文将详细探讨“多个文件合并为一个文件”以及“文件拆分”的概念、方法和应用场景。 首先，让我们理解什么是“合并文件”。在计算机操作中，合并文件指的是将两个或更多个独立的文件整合成一个单一的文件。这种...
精选资源
EXCEL按行内容分解成多个单独的文件
04-03
标题“EXCEL按行内容分解成多个单独的文件”所描述的操作，就是一种批量处理技术，它能帮助我们高效地整理数据。这种技术通常涉及到VBA（Visual Basic for Applications）编程，用于自动化Excel的功能。 描述中提到...
VB文件切割分解工具代码
05-07
在VB（Visual Basic）编程环境中，我们可以创建一个实用的小工具，用于执行文件的切割与合并操作。这个"VB文件切割分解工具代码"就是一个这样的实例，它允许用户将大文件分割成多个小文件，以便于存储、传输或者优化...
文本文件转换到EXCEL中.zip易语言项目例子源码下载
03-22
在“文本文件转换到EXCEL中.zip”这个易语言项目中，我们可以了解到如何利用易语言来实现文本文件的数据提取和转换，将这些数据导入到Excel表格中进行管理和分析。 首先，我们需要理解文本文件的格式。文本文件通常...
NIFI-创建一个FlowFile并利用PutFile保存到到指定目录
dijiao3728的博客
11-25 723
1>在工作台上添加一个创建FlowFile的处理器 　　1.1>拖动Processor到工作台上 　　 　　1.2>在检索框中输入想要查询的关键字【generatef...】,并点击【Add】按钮 　　 　　1.3>查看添加效果 　　 2>在工作台上添加一个存放文件【PutFile】的处理器 　　 3>将鼠标移动到GenerateFl...
如何将多个文件捆绑成一个可执行文件
小发猫
06-15 2759
如何将多个文件捆绑成一个可执行文件内容:下载示例程序代码将多个文件合并成一个最终可执行文件，运行这个最终合成文件后，就相当于运行了合并前的多个文件。这种程序在木马程序合并中会经常用到，你想知道它是怎么用程序实现的么？下面我就拿我用VC6.0做的一个文件捆绑器的实例代码来告诉你，实例程序运行后的界面如下：图例基本构成思想：其实，文件捆绑的构成思想非常简单，它主要可分为合并文件和分解释放文件二大部分。
linux下合并多个文件夹内容成为一个文件夹
热门推荐
CV_YOU的博客
05-24 1万+
一个数据集下载下来有多个部分，part1,part2,part3…需要将这多个部分合成一个部分。查了下，没找到直接可以达到效果的命令行（试过cat,rsync等） 解决方案： 写一段python脚本：merge_folder.py #!/usr/bin/env python3 import argparse import os def move_merge_dirs(source_root, ...
批量将多个文件内容，写入一个文件（用到了，就写了一个）
linmz0621的博客
10-30 3397
package cpFile; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileInputStream; import java.io.FileWriter; import java.io.InputStreamReader; import ...
基于C语言与AG32VF303单片机的智能输液器控制系统设计（含ESP8266 WIFI模块、PCB及源码文档）
12-03
本设计实现了一种基于AG32VF303可编程逻辑器件与ESP8266无线通信模块的智能输液监控系统。该系统提供了完整的源代码、设计文档及印制电路板布局文件，适用于学术研究、教学实践或工程开发等应用场景。经过充分验证的程序代码具备较高的可靠性，可供后续扩展与二次开发参考。 系统硬件架构以AG32VF303为核心处理器，配合ESP8266模块构建无线通信链路。操作界面支持物理按键与移动终端远程控制两种交互模式，用户可根据实际需求灵活选择控制方式。主要功能模块包括：输液流速精确调节单元、药液温度恒温管理单元以及储液容器液位监测预警单元。 工程文件中已包含完整的电路板设计资料，可直接用于生产制造。该设计方案充分考虑了临床输液过程的实际需求，通过集成化的控制策略实现了输液参数的智能化管理。 资源来源于网络分享，仅用于学习交流使用，请勿用于商业，如有侵权请联系我删除！
【自主多无人机系统通信模式选择的概率模型】基于动态环境中的实时数据做出决策，从而提高多无人机协同作业中的协作效果与任务成功率（Matlab代码实现）
12-03
内容概要：本文提出了一种针对自主多无人机系统的通信模式选择概率模型，该模型能够基于动态环境中实时采集的数据进行智能决策，有效提升多无人机在协同作业中的协作效率与任务执行成功率。研究结合了不确定性因素的影响，采用Matlab实现算法仿真，构建了适应复杂环境变化的通信机制，重点解决了多无人机系统在动态环境下通信稳定性与可靠性的问题，具有较强的实用性和工程应用价值。; 适合人群：具备一定控制理论、通信系统或无人机相关背景，熟悉Matlab/Simulink仿真的科研人员及研究生；适用于从事多智能体系统、无线通信优化或协同控制方向的研究者。; 使用场景及目标：①应用于多无人机协同任务中的通信【自主多无人机系统通信模式选择的概率模型】基于动态环境中的实时数据做出决策，从而提高多无人机协同作业中的协作效果与任务成功率（Matlab代码实现）资源动态分配与模式切换；②为应对动态环境干扰下的通信中断问题提供决策支持；③提升复杂场景下无人机集群的任务完成率与系统鲁棒性； 阅读建议：建议结合Matlab代码深入理解模型实现细节，重点关注概率决策机制与实时数据处理流程，可进一步扩展至其他多智能体系统通信优化场景进行二次开发与验证。
UWB-IMU、UWB定位对比研究（Matlab代码实现）
最新发布
12-03
内容概要：本文主要围绕UWB-IMU与UWB定位技术的对比研究展开，基于Matlab代码实现，结合状态估计算法（如UKF、AUKF等）对两种定位方式的性能进行分析与比较。研究重点在于通过数据融合提升定位精度与稳定性，尤其适用于复杂环境下的高精度定位需求。文中提供了完整的仿真代码和实现方法，便于读者复现与扩展应用。此外，文档还列举了大量相关科研方向和技术服务内容，涵盖机器学习、信号处理、路径规划、电力系统等多个领域，展示了广泛的技术支持能力。; 适合人群：具备一定Matlab编程基础，从事定位技术、状态估计、传感器融合或相关科研UWB-IMU、UWB定位对比研究（Matlab代码实现）方向的研究生、科研人员及工程技术人员。; 使用场景及目标：①用于高精度室内定位系统的设计与优化；②开展UWB与IMU融合定位算法的研究与验证；③学习和掌握卡尔曼滤波（如UKF、EKF）在实际定位问题中的应用；④为科研项目提供算法仿真支持和技术参考。; 阅读建议：建议读者结合提供的Matlab代码逐模块分析，重点关注数据融合策略与状态估计实现过程，同时可参考文中提及的相关技术方向拓展研究思路。注意区分纯UWB与UWB-IMU融合方案的性能差异，深入理解IMU在补偿UWB信号缺失方面的关键作用。
Qt怎么把多个文件流怎么合并到一个文件,最后通过这个文件再分解出来
09-21
- 合并多个文件流为一个文件：这意味着我需要读取多个文件的内容，并将它们写入到一个文件中，同时保留信息以便后续分解。 - 分解：从合并的文件中提取出原始文件。 为了支持分解，合并时需要添加元数据，比如文件...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值