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

最新推荐文章于 2019-05-24 10:03:33 发布
最新推荐文章于 2019-05-24 10:03:33 发布
阅读量738 收藏
点赞数
分类专栏： <font color=red>P2P/P2SP技术</font> C# & dotNet 文章标签： byte buffer string exception null structure

From: http://blog.csdn.net/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:/ "  );

 

以上代码由于写得比较急，细节处理并不是很完善，因此使用的时候要加以细化，甚至可以在我的基础上进行扩充。
 
pcfirebird
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
如何将多个文件捆绑成一个可执行文件
小发猫
06-15 2686
如何将多个文件捆绑成一个可执行文件内容:下载示例程序代码将多个文件合并成一个最终可执行文件，运行这个最终合成文件后，就相当于运行了合并前的多个文件。这种程序在木马程序合并中会经常用到，你想知道它是怎么用程序实现的么？下面我就拿我用VC6.0做的一个文件捆绑器的实例代码来告诉你，实例程序运行后的界面如下：图例基本构成思想：其实，文件捆绑的构成思想非常简单，它主要可分为合并文件和分解释放文件二大部分。
如何把多个文件写入到一个文件中去并能分解[转]
anhai6033的博客
10-10 96
http://blog.csdn.net/Knight94/archive/2006/05/17/742055.aspx 对于一个文件的读写，其实很简单，就是用FileStream进行Read或者Write就行了。但是如何把多个文件写入到同一个文件，之后要能把这个文件进行还原成多个文件。那么光靠FileStream的Read和Write方法是不够的，首先你需要自行建立文件索引，来...
多个文件写入到一个文件里
liaozhiweihaifeng的专栏
09-01 485
/* * 其中类的操作参看clsComposeFiles这个类，而文件索引结构参看FileIndex这个Structure。 *  * */namespace ComposeFiles{    using System;    using System.IO;    using System.Collections;    using System.Text;     //
多个文件合并为一个文件并将文件拆分开来
05-23
本文将详细探讨“多个文件合并为一个文件”以及“文件拆分”的概念、方法和应用场景。 首先，让我们理解什么是“合并文件”。在计算机操作中，合并文件指的是将两个或更多个独立的文件整合成一个单一的文件。这种...
EXCEL按行内容分解成多个单独的文件
04-03
标题“EXCEL按行内容分解成多个单独的文件”所描述的操作，就是一种批量处理技术，它能帮助我们高效地整理数据。这种技术通常涉及到VBA（Visual Basic for Applications）编程，用于自动化Excel的功能。 描述中提到...
文本文件转换到EXCEL中.zip易语言项目例子源码下载
03-22
在“文本文件转换到EXCEL中.zip”这个易语言项目中，我们可以了解到如何利用易语言来实现文本文件的数据提取和转换，将这些数据导入到Excel表格中进行管理和分析。 首先，我们需要理解文本文件的格式。文本文件通常...
VB文件切割分解工具代码
05-07
在VB（Visual Basic）编程环境中，我们可以创建一个实用的小工具，用于执行文件的切割与合并操作。这个"VB文件切割分解工具代码"就是一个这样的实例，它允许用户将大文件分割成多个小文件，以便于存储、传输或者优化...
MFC多视图，分割合并文件的一个例子
12-12
MDI是一种用户界面模式，允许在一个应用程序窗口中同时打开多个文档，每个文档有自己的视图。在MFC中，MDI应用程序可以通过继承CWinApp、CMDIFrameWnd和CMDIChildWnd类来创建。每个视图是用户与数据交互的窗口，通过...
批量将多个文件内容，写入一个文件（用到了，就写了一个）
linmz0621的博客
10-30 3283
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 ...
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, ...
2024年欧洲铝桁架市场主要企业市场占有率及排名.docx
07-17
2024年欧洲铝桁架市场主要企业市场占有率及排名.docx
torchaudio-0.13.1+cpu-cp39-cp39-win_amd64.whl
最新发布
07-17
torchaudio软件包，直接下载下来，通过命令窗口输入：pip install torchaudio-xxx.whl安装就行，再也不怕pip安装timeout了
出入库存盘点表-图表分析-分类查询-Excel模板
07-17
【作品名称】：出入库存盘点表-图表分析-分类查询-Excel模板 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
torchaudio-0.12.1+cpu-cp37-cp37m-win_amd64.whl
07-17
torchaudio软件包，直接下载下来，通过命令窗口输入：pip install torchaudio-xxx.whl安装就行，再也不怕pip安装timeout了
中南大学机械设计课程设计说明书.doc
07-17
说明书
仓库进销出入库存管理系统（带库存预警）-Excel模版
07-17
【作品名称】：仓库进销出入库存管理系统（带库存预警）-Excel模版 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
python合并多个txt文件并保存txt文件名称
09-24
最后，我们可以使用Python的文件处理功能来创建一个新的txt文件，并将我们所保存的所有文件内容全部写入到这个文件中。我们可以使用`open()`函数创建一个新的txt文件，并使用`.write()`方法将之前保存的合并内容写入...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值