调用Nero SDK 刻录光盘

http://blog.csdn.net/laibeikele/article/details/2500185 

项目中有多光驱刻录的需求，但在一个进程里同时启动多个刻录任务，进程经常报异常，于是把刻录部分单独做了个控制台程序，每个光驱刻录就启动一个进程去执行刻录任务，这样就算刻录进程出错也不会影响到父进程。

        以下是Nero 刻碟的类，SDK采用NeroSDK-1.08版本，调用NeroCOM组件。调用时必须引用Interop.NEROLib.dll 和 Interop.NeroVisionAPI.dll 两个dll。

public class NeroBurn
    {
        #region 属性
        private  NeroDrive m_neroDerive;
        private  Nero m_nero;
        private bool m_aborted;
        private string m_burnPath;
        private bool m_isDoneBurn;
        private int m_returnCode;//0:失败；1：成功；-1：未知
        private string m_discvol;
        
        //nero 委托
        private _INeroDriveEvents_OnDoneBurnEventHandler m_evOnDoneBurn;
        private  _INeroDriveEvents_OnAddLogLineEventHandler m_evOnAddLogLine;
        private _INeroEvents_OnWaitCDEventHandler m_evOnWaitCD;
        private _INeroDriveEvents_OnAbortedEventHandler m_evOnAborted;
        private _INeroDriveEvents_OnProgressEventHandler m_evOnProgress;
        private _INeroEvents_OnWaitCDDoneEventHandler m_evOnWaitCDDone;
        
        #endregion 

        #region 构造函数

        /// <summary></summary>
        /// 构造函数
        /// 
        /// <param name="driverletter">盘符
        /// <param name="burnpath">待刻录的文件路径
        /// <param name="discvol">盘的卷标
        public NeroBurn(string driverletter,string burnpath,string discvol)
        {
            m_burnPath = burnpath;
            m_nero = new NeroClass();
            m_neroDerive = allocDevice(driverletter);
            m_aborted = false;
            m_isDoneBurn = false;
            m_discvol = discvol;
        }

        #endregion 
        
        #region Nero事件处理

        /// <summary></summary>
        /// 发起刻录事件
        /// 
        /// <param name="bSubscribe">
        private  void SubscribeToEvents(bool bSubscribe)
        {
            if (bSubscribe)
            {
                m_evOnAddLogLine = new _INeroDriveEvents_OnAddLogLineEventHandler(m_drive_OnAddLogLine);
                m_neroDerive.OnAddLogLine += m_evOnAddLogLine;
                m_evOnWaitCD = new _INeroEvents_OnWaitCDEventHandler(m_nero_OnWaitCD);
                m_nero.OnWaitCD += m_evOnWaitCD;
                m_evOnDoneBurn = new _INeroDriveEvents_OnDoneBurnEventHandler(m_drive_OnDoneBurn);
                m_neroDerive.OnDoneBurn += m_evOnDoneBurn;
                m_evOnWaitCDDone = new _INeroEvents_OnWaitCDDoneEventHandler(m_nero_OnWaitCDDone);
                m_nero.OnWaitCDDone += m_evOnWaitCDDone;
                m_evOnProgress = new _INeroDriveEvents_OnProgressEventHandler(m_drive_OnProgress);
                m_neroDerive.OnProgress += m_evOnProgress;
            }
            else
            {               
                m_neroDerive.OnAddLogLine -= m_evOnAddLogLine;
                m_nero.OnWaitCD -= m_evOnWaitCD;
                m_nero.OnWaitCDDone -= m_evOnWaitCDDone;
                m_neroDerive.OnDoneBurn -= m_evOnDoneBurn;
                m_neroDerive.OnProgress -= m_evOnProgress;
            }
        }
        private void m_drive_OnProgress(ref int ProgressInPercent, ref bool Abort)
        {
            // This events gives us an opportunity to show progress
            // as well as abort if needed.
            // 
            Abort = m_aborted;            

            Console.WriteLine("光盘" + m_discvol + " " + ProgressInPercent.ToString() + "% had Burned!!");
            //c_TaskPercent.Text = ProgressInPercent.ToString() + "%";
        }
        private void m_nero_OnWaitCDDone()
        {
            // When waiting on a disc is done, make sure to
            // enable us and hide the WaitCD form.
            // 
            Console.WriteLine("a Disc has inserted!");
        }
        /// <summary></summary>
        ///刻录完成，不管失败成功！ 
        /// 
        /// <param name="StatusCode">
        private void m_drive_OnDoneBurn(ref NERO_BURN_ERROR StatusCode)
        {
            // When burning is over, make sure to unsubscribe from all
            // events.
            // 
            SubscribeToEvents(false);
            if (StatusCode == NERO_BURN_ERROR.NERO_BURN_OK)
            {
                m_returnCode = 1;
                Console.WriteLine(m_neroDerive.DriveLetter + "盘卷标为 " + m_discvol + " 刻录成功!!");
            }
            else
            {
                m_returnCode = 0;
                Console.WriteLine(m_neroDerive.DriveLetter + "盘卷标为 " + m_discvol + " 刻录失败!!");
            }

            m_isDoneBurn = true;

            Console.WriteLine("Burn Finish!!");
        }

        /// <summary></summary>
        /// 如果光驱为空，等待光驱
        /// 
        /// <param name="WaitCD">
        /// <param name="WaitCDLocalizedText">
        private void m_nero_OnWaitCD(ref NERO_WAITCD_TYPE WaitCD, ref string WaitCDLocalizedText)
        {
            Console.WriteLine("Wait CD...");
        }

        /// <summary></summary>
        /// 写日志
        /// 
        /// <param name="TextType">
        /// <param name="Text">
        private  void m_drive_OnAddLogLine(ref NERO_TEXT_TYPE TextType, ref string Text)
        {
            
            Console.WriteLine( Text);
        }

        #endregion 

        #region 申请设备

        /// <summary></summary>
        /// 申请设备
        /// 
        /// <param name="driverletter">
        /// <returns></returns>
        private NeroDrive allocDevice(string driverletter)
        {

            NeroDrives drives = m_nero.GetDrives(NERO_MEDIA_TYPE.NERO_MEDIA_DVD_M);
            if (drives.Count > 0)
            {
                foreach (NeroDrive d in drives)
                {
                    if (driverletter.ToLower().Contains(d.DriveLetter.ToLower()))
                        return d;

                }
            }

            return null;

        }

        #endregion 

        #region 刻录

        /// <summary></summary>
        /// 刻录
        /// 
        /// <returns></returns>0: 失败；1：成功；-1：未知错误
        public int Burn()
        {
            m_isDoneBurn = false;    
        
            SubscribeToEvents(true);

            NeroISOTrack isoTrack = new NeroISOTrackClass();
            isoTrack.BurnOptions = (NERO_BURN_OPTIONS)((uint)NERO_BURN_OPTIONS.NERO_BURN_OPTION_CREATE_ISO_FS + (uint)NERO_BURN_OPTIONS.NERO_BURN_OPTION_USE_JOLIET);
            isoTrack.Name = m_discvol;

            Console.WriteLine("Begin AddFilesAndFoldersToISOTrack.");
            AddFilesAndFoldersToISOTrack(ref isoTrack, m_burnPath);
            Console.WriteLine("End AddFilesAndFoldersToISOTrack.");

            if (isoTrack.RootFolder.Files.Count == 0 &&
                    isoTrack.RootFolder.Folders.Count == 0)
            {
                isoTrack = null;
                return 0;
            }

            NERO_BURN_FLAGS flags = new NERO_BURN_FLAGS();
            flags = flags | NERO_BURN_FLAGS.NERO_BURN_FLAG_WRITE;
            flags = flags | NERO_BURN_FLAGS.NERO_BURN_FLAG_CLOSE_SESSION;
            flags = flags | NERO_BURN_FLAGS.NERO_BURN_FLAG_BUF_UNDERRUN_PROT;
            flags = flags | NERO_BURN_FLAGS.NERO_BURN_FLAG_DISABLE_ABORT;
            flags = flags | NERO_BURN_FLAGS.NERO_BURN_FLAG_DAO;
            flags = flags | NERO_BURN_FLAGS.NERO_BURN_FLAG_CD_TEXT;
            flags = flags | NERO_BURN_FLAGS.NERO_BURN_FLAG_DETECT_NON_EMPTY_CDRW;
            flags = flags | NERO_BURN_FLAGS.NERO_BURN_FLAG_SPEED_IN_KBS;  

            try
            {
                if (null == m_neroDerive)
                {
                    Console.WriteLine("m_neroDerive is null!!");
                    return -1;
                }
                
                int speed = 10000;

                string BurnSpeed_s = System.Configuration.ConfigurationSettings.AppSettings["BurnSpeed"];
                
                if (!string.IsNullOrEmpty(BurnSpeed_s))
                    speed = int.Parse(BurnSpeed_s);

                m_neroDerive.BurnIsoAudioCD("", "", false,
                    isoTrack,
                    null,
                    null,
                    flags,
                        speed,
                        NERO_MEDIA_TYPE.NERO_MEDIA_DVD_M);

                //循环执行，等待刻录完成
                while (true)
                {
                    if(m_isDoneBurn)  //如果刻录完成
                        return m_returnCode;

                    System.Threading.Thread.Sleep(1000);
                }
            }
            catch (Exception e)
            {
                m_aborted = true;
                Console.WriteLine("Burn Error : "+e.Message);
                return 0;
            }

            return -1;
        }

        #endregion 

        #region 辅助函数
        /// <summary></summary>
        /// This function adds the files and folders to the supplied NeroISOTrack.
        /// Add by Cola 2008-4-14
        /// 
        /// <param name="isoTrack">
        /// <param name="discPath">
        private  void AddFilesAndFoldersToISOTrack(ref NeroISOTrack isoTrack, string discPath)
        {
            string sPath = discPath;

            // The string should really not be empty...
            // 
            if (sPath != "")
            {
                // If path ends in a backslash, it is a folder.
                // 
                if (sPath[sPath.Length - 1] == '//')
                {
                    NeroFolder folder = isoTrack.RootFolder;
                    AddFolderRecursively(ref folder, sPath);
                }
                else
                {
                    // This is a file. Create a new NeroFile
                    // change its properties.
                    // 
                    NeroFile file = new NeroFileClass();
                    file.SourceFilePath = sPath;
                    file.Name = Path.GetFileName(sPath);
                    file.EntryTime = Directory.GetLastWriteTime(sPath);

                    // In this implementation, specified files are added
                    // to the root of the disc only.
                    // 
                    isoTrack.RootFolder.Files.Add(file);
                }
            }

        }


        /// <summary></summary>
        /// This function is used to recursively add the path to the supplied
        /// parent NeroFolder. Add by Cola 2008-4-14
        /// 
        /// <param name="folderParent">
        /// <param name="sPath">
        private  void AddFolderRecursively(ref NeroFolder folderParent, string sPath)
        {
            NeroFolder folder = new NeroFolderClass();
            folderParent.Folders.Add(folder);

            string[] sSplits = sPath.Split(new char[] { '//' }, sPath.Length);
            if (sSplits.GetLength(0) >= 2)
            {
                string sFolderName = sSplits[sSplits.GetLength(0) - 2];
                folder.Name = sFolderName;

                string[] sDirectories = Directory.GetDirectories(sPath);
                foreach (string sSubDirPath in sDirectories)
                {
                    AddFolderRecursively(ref folder, sSubDirPath + "//");
                }
            }

            string[] sFiles = Directory.GetFiles(sPath);
            foreach (string sFile in sFiles)
            {
                NeroFile file = new NeroFileClass();
                file.SourceFilePath = sFile;
                file.Name = Path.GetFileName(sFile);
                file.EntryTime = Directory.GetLastWriteTime(sFile);

                folder.Files.Add(file);
            }
        }

        #endregion 

    }

　　然后，在Main函数中调用NeroBurn类的方法，Main函数的参数如下：

static int Main(string[] args)  
        {  
            string driverletter; //驱动器盘符,含':'号   
            string burnpath;     //刻录文件目录  
            string discvol;      //光盘卷标  
            if (args.Length == 3)  
            {  
                driverletter = args[0];  
                burnpath = args[1];  
                discvol = args[2];  
                NeroBurn b = new NeroBurn(driverletter, burnpath, discvol);  
                int ret = b.Burn();  
                  
                return ret;  
            }  
              
  
            return -1;