[.NET2] FAIRE UNE IMAGE ISO D'UN CD/DVD

using System;
using System.IO;
using System.Threading;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;

namespace Iso9660
{
    public class Iso9660
    {

        #region 'Variables'

        Thread _thIso;
        string _output;
        long _cdsize;
        FileStream _fsr;
        FileStream _fsw;
        SafeFileHandle _hdev;

        #endregion


        #region 'Constantes'

        const int BUFFER_SIZE = 0x20000;            //128ko taille des blocs de copie
        const long FAT32_LIMIT = 4294967296;        //4go taille max. d'un fichier sur FAT32

        #endregion


        #region 'Evénement'

        /// <summary>Indique la progression.</summary>
        public event Iso9660EventHandler OnProgress;
        /// <summary>Se déclenche lors d'un message pendant la création.</summary>
        public event Iso9660EventHandler OnMessage;
        /// <summary>Se déclenche quand l'image est créée.</summary>
        public event Iso9660EventHandler OnFinish;

        #endregion
        

        #region 'Propriété'

        /// <summary>
        /// Retourne la taille en octets du CD.
        /// </summary>
        public long SizeOfCD
        {
            get { return _cdsize; }
        }
	
        #endregion


        #region 'Constructeur'

        /// <summary>
        /// Constructeur.
        /// </summary>
        public Iso9660()
        {
            _thIso = null;
            _output = @"C:\MyCd.iso";
        }

        #endregion


        #region 'Méthodes'

        /// <summary>
        /// Créer une image ISO9660 d'un cd/dvd.
        /// </summary>
        /// <param name="source">Lecteur cd/dvd.</param>
        /// <param name="output">Fichier iso de sortie.</param>
        /// <returns>1 = Création de l'image en cours.
        /// -1 = Handle du lecteur invalide.
        /// -2 = La source n'est pas un cd/dvd.
        /// -3 = Espace disque insuffisant pour la création de l'image.
        /// -4 = Volume de destination FAT32 et taille de la source > 4 096 Mo.</returns>
        public int MakeIsoFromCD(string source, string output)
        {
            //Source CD/DVD
            if (new DriveInfo(source).DriveType != DriveType.CDRom) return -2;

            //récupérer taille du cd
            _cdsize = CDLenght(source);

            //vérif espace disque
            long hddsize = new DriveInfo(Path.GetPathRoot(output)).AvailableFreeSpace;
            if (hddsize <= _cdsize) return -3;

            //Test capacité > 4 096 Mo (partition NTFS)
            if (!IsNTFS(output) & _cdsize >= FAT32_LIMIT) return -4;

            //Ouverture
            _hdev = NativeMethods.CreateFileR(source);
            if (output != "") _output = output;

            //Si handle invalide ou fermé
            if (_hdev.IsClosed | _hdev.IsInvalid) return -1;

            //Création thread pour copie + Démarrage
            _thIso = new Thread(new ThreadStart(ThProcIso));
            _thIso.Start();

            return 1;
        }

        /// <summary>
        /// Arrete la création de l'image.
        /// (+ Supprime l'image créer)
        /// </summary>
        public void Stop()
        {
            _thIso.Abort();

            CloseAll();

            if (File.Exists(_output)) File.Delete(_output);

            if (OnMessage != null)
            {
                EventIso9660 e = new EventIso9660(@"Création de l'image annulée");
                OnMessage(e);
            }
        }

        /// <summary>
        /// Méthode - C'est ici que l'ont crée l'image iso9660.
        /// </summary>
        private void ThProcIso()
        {
            System.Diagnostics.Stopwatch chrono = new System.Diagnostics.Stopwatch();
            chrono.Start();

            try
            {
                _fsr = new FileStream(_hdev, FileAccess.Read, BUFFER_SIZE);
                _fsw = new FileStream(_output, FileMode.Create, FileAccess.Write, FileShare.None, BUFFER_SIZE);

                byte[] buffer = new byte[BUFFER_SIZE];

                //Lecture des blocs de données du volume -> écriture des blocs dans le fichier iso
                do
                {
                    _fsr.Read(buffer, 0, BUFFER_SIZE);
                    _fsw.Write(buffer, 0, BUFFER_SIZE);

                    if (OnProgress != null)
                    {
                        EventIso9660 e = new EventIso9660(_fsw.Position);
                        OnProgress(e);
                    }

                } while (_fsw.Position == _fsr.Position);
            }
            catch (Exception ex)
            {
                //En cas d'erreur.
                if (OnMessage != null)
                {
                    EventIso9660 e = new EventIso9660("Erreur pendant la création de l'image: " + ex.Message);
                    OnMessage(e);
                }
            }
            finally
            {
                CloseAll();

                if (OnFinish != null)
                {
                    EventIso9660 e = new EventIso9660(chrono.Elapsed);
                    OnFinish(e);
                }
            }
        }

        /// <summary>
        /// Ferme les flux + handles et libère les ressources utilisées.
        /// </summary>
        private void CloseAll()
        {
            //Ferme les flux sur les 2 fichiers et libère les ressources utilisées.
            _fsr.Close();
            _fsw.Close();

            //Marque le handle et libère les ressources utilisées.
            _hdev.Close();
            _hdev.Dispose();
        }

        /// <summary>
        /// Taille du cd/dvd.
        /// </summary>
        /// <param name="drive">Lecteur source.</param>
        /// <returns>Taille en octets.</returns>
        private long CDLenght(string drive)
        {
            return new DriveInfo(drive).TotalSize;
        }

        /// <summary>
        /// Indique si système de fichiers du volume est NTFS.
        /// </summary>
        /// <param name="destination">Image ISO de sortie.</param>
        /// <returns>True si NTFS.</returns>
        private bool IsNTFS(string destination)
        {
            return new DriveInfo(Path.GetPathRoot(destination)).DriveFormat == "NTFS" ? true : false;
        }

        #endregion

    }
}