对于一个文件的读写，其实很简单，就是用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:\" );

　　以上代码由于写得比较急，细节处理并不是很完善，因此使用的时候要加以细化，甚至可以在我的基础上进行扩充。