[c#]file .mdb creati da codice che rimangono in uso

[LoRdCoStE]

Salve a tutti.
Sto creando un programma che legge una lista di file .txt in una cartella e crea un file .mdb (access) per ogni file inserendo come record i dati presenti nel file txt.
Fin qui nessun problema, se non che oltre a creare i file .mdb spesso mi crea anche dei file .Idb (Informazioni di blocco record).
Una volta creati questi file ho l'esigenza di zipparli (uno a uno, o meglio ancora tutti insieme).
Il problema si verifica durante la fase di compressione, in quanto a volte mi viene detto che il file è in uso e viene generato un errore.
Premetto che per zippare uso la SharpZipLib.
Posto un po' di codice:

...
private Thread processo;
...
processo = new Thread(AvviaProcesso);
processo.Start();

protected void AvviaProcesso()
{
	DirectoryInfo dir = new DirectoryInfo(localFolder); //la cartella contenente i miei .txt
	FileInfo[] rgFiles = dir.GetFiles("*.txt");
	if (rgFiles.Length > 0)
	{
		if (!Directory.Exists(Application.StartupPath + "\\temp"))
		{
			try
			{
				Directory.CreateDirectory(Application.StartupPath + "\\temp"); //cartella in cui salvare i file .mdb
			}
			catch (Exception ex)
			{
				MessageBox.Show(ex.Message);
			}
		}

		String db;
		String line;
		OleDbConnection conn;
		OleDbCommand cmd;
		ADOX.CatalogClass cat;
		String name;

		System.IO.StreamReader stream;

		foreach (FileInfo fi in rgFiles)
		{
			name = fi.Name.Replace(".txt", ""); //solo il nome del file senza percorso ed estensione
			db = Application.StartupPath + "\\temp\\" + name + ".mdb";
			
			try
			{
				cat = new ADOX.CatalogClass();
				try
				{
					cat.Create("Provider=Microsoft.Jet.OLEDB.4.0;" +
					"Data Source=" + db + ";" +
					"Jet OLEDB:Engine Type=5");
				}
				catch (Exception ex)
				{
					return;
				}

				string connString = @"Provider=Microsoft.Jet.OLEDB.4.0 ;Data Source=" + db;
				conn = new OleDbConnection(connString);
				conn.Open();
				string query = "CREATE TABLE prova (id AUTOINCREMENT, campo TEXT(30))";
				cmd = new OleDbCommand(query, conn);
				cmd.ExecuteNonQuery();

				stream = new System.IO.StreamReader(fi.FullName);
				while ((line = stream.ReadLine()) != null)
				{
					query = "INSERT INTO prova (campo) VALUES (\"" + line + "\")";
					cmd = new OleDbCommand(query, conn);
					cmd.ExecuteNonQuery();
				}
				stream.Close();
				stream.Dispose();
			}
			catch (System.Data.OleDb.OleDbException ex)
			{
				timer.Enabled = false;
				MessageBox.Show(ex.Message);
				lblStatus.Text = "Stato: Errore - Stoppato";
				return;
			}

			conn.Close();
			conn.Dispose();

			if (!Directory.Exists(Application.StartupPath + "\\zip"))
			{
				try
				{
					Directory.CreateDirectory(Application.StartupPath + "\\zip"); //cartella in cui salvare i file zippati
				}
				catch (Exception ex)
				{
					MessageBox.Show(ex.Message);
				}
			}

			Zip.ZipFile(Application.StartupPath + "\\zip\\" + name + ".zip", db); //singolo gile
			fi.Delete(); //elimino il .txt
			File.Delete(db); //elimino .mdb
		}
	}
	//Zip.ZipFolder(Application.StartupPath+"\\cartella.zip", Application.StartupPath + "\\temp"); //tutta la cartella
}

posto anche la classe Zip (ricordo che mi appogigo a SharpZipLib:

using System;
using System.IO;
using ICSharpCode.SharpZipLib.Zip;
using ICSharpCode.SharpZipLib.Checksums;

namespace FtpTransferDB_V2
{
    /// <summary>
    /// Zip
    /// </summary>
    public class Zip
    {
        #region public methods

/// <summary>
        /// Comprime il contenuto di un file in formato ZIP
        /// </summary>
        /// <param name="ZipFilePath">Path del file compresso da creare</param>
        /// <param name="OriginalFilePath">Path del file da comprimere</param>
        public static void ZipFile(string ZipFilePath, string OriginalFilePath)
        {
            try
            {
                FileInfo fi = new FileInfo(OriginalFilePath);
                ZipOutputStream zip = new ZipOutputStream(File.Create(ZipFilePath));
                zip.SetLevel(6);    // 0 - store only to 9 - means best compression
                AddFile2Zip(zip, fi, "");
                zip.Finish();
                zip.Close();
            }
            catch (Exception ex)
            {
                throw ex; //VIENE GENERATA QUI
            }
        }

        /// <summary>
        /// Comprime il contenuto di una cartella in formato ZIP, ricorsivamente e preservandone la struttura
        /// </summary>
        /// <param name="ZipFilePath">Path del file compresso da creare</param>
        /// <param name="OriginalFolderPath">Path della cartella da comprimere</param>
        public static void ZipFolder(string ZipFilePath, string OriginalFolderPath)
        {
            try
            {
                DirectoryInfo di = new DirectoryInfo(OriginalFolderPath);
                ZipOutputStream zip = new ZipOutputStream(File.Create(ZipFilePath));
                zip.SetLevel(6);    // 0 - store only to 9 - means best compression
                AddFolder2Zip(zip, di, "");
                zip.Finish();
                zip.Close();
            }
            catch (Exception ex)
            {
                throw ex; //VIENE GENERATA QUI
            }
        }
#endregion

        #region private methods

        private static void AddFolder2Zip(ZipOutputStream zip, DirectoryInfo di, string internalzippath)
        {
            string izp = internalzippath + di.Name + "/";    // A directory is determined by an entry name with a trailing slash "/"
            Crc32 crc = new Crc32();
            ZipEntry entry = new ZipEntry(izp);
            entry.Crc = crc.Value;
            zip.PutNextEntry(entry);
            foreach (FileInfo fi in di.GetFiles())
                AddFile2Zip(zip, fi, izp);
            foreach (DirectoryInfo sdi in di.GetDirectories())
                AddFolder2Zip(zip, sdi, izp);
        }
        private static void AddFile2Zip(ZipOutputStream zip, FileInfo fi, string internalzippath)
        {
            Crc32 crc = new Crc32();
            FileStream fs = File.OpenRead(fi.FullName);
            byte[] buffer = new byte[fs.Length];
            fs.Read(buffer, 0, buffer.Length);
            ZipEntry entry = new ZipEntry(internalzippath + fi.Name);
            entry.DateTime = DateTime.Now;
            entry.Size = fs.Length;
            fs.Close();
            crc.Reset();
            crc.Update(buffer);
            entry.Crc = crc.Value;
            zip.PutNextEntry(entry);
            zip.Write(buffer, 0, buffer.Length);
        }

        #endregion
    }
}

Spero che qualcuno abbia la pazienza di leggere e di darmi una mano.
Saluti