[.net2] faire une image iso d'un cd/dvd

Télécharger le projet
Commenter

Description

C'est juste une traduction de la traduction en C de Vecchio56 d'une source écrit par BruNews en assembleur

Vous trouvez l'original ici:
http://www.asmfr.com/codes/FAIRE-FICHIER-ISO-MASM32_22635.aspx
Sa traduction en C:
http://www.cppfrance.com/codes/FAIRE-FICHIER-ISO-WIN32_37943.aspx

Informations:
Windows 2000 ou supérieur requis.

Fait un fichier Iso9660 depuis un CD ou DVD.
On peut stopper pendant l'opération.
Les CDs musique non pris en charge.

La source est commentée, assez simple à comprendre :)

Source / Exemple : 


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

    }
}

Conclusion :


Voila,
A vos notes et commentaires :)

++
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (cs_Willi)