C#调用Nero SDK进行 刻录、擦拭、弹出光驱、关闭光驱

 

 

必须安装Nero 7

代码

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using NEROLib;
using System.IO;
using System.Runtime.InteropServices;
using biovision.ihospital.utility;
using biovision.ihospital.uicommon;

namespace biovision.ihospital.BackUp
{
    public delegate void EarseProcess();

    public partial class DiskInfo : Form
    {
        public DiskInfo()
        {
            InitializeComponent();

            eProcess += new EarseProcess(this.EreasePro);
        }
        private string _diskpatch;
        public string DiskPatch
        {
            get { return _diskpatch; }
            set { _diskpatch = value; }
        }
        private Nero m_nero;
        private bool bQuick;
        private NeroDrives m_nerdrives;
        private NeroDrive m_nerdrive;
        bool m_abort;
        private bool m_bError;
        private bool m_bEof;
        private FileStream m_fs;
        //private _INeroDriveEvents_OnDriveStatusChangedEventHandler m_evDriveStatusChanged;
        private DateTime m_timeStart;
        private System.Timers.Timer m_timer;
        private int m_iErasingTime;
        private _INeroDriveEvents_OnDoneEraseEventHandler m_evOnDoneErase;
        private _INeroEvents_OnWaitCDEventHandler m_evOnWaitCD;//等待光驱
        private _INeroEvents_OnWaitCDDoneEventHandler m_evOnWaitCDDone;
        private _INeroDriveEvents_OnDoneBurnEventHandler m_evOnDoneBurn;
        private _INeroDriveEvents_OnProgressEventHandler m_evOnProgress;
        private _INeroDriveEvents_OnSubTaskProgressEventHandler m_evOnSubTaskProgress;
        private _INeroDriveEvents_OnAbortedEventHandler m_evOnAborted;
        private _INeroDriveEvents_OnAddLogLineEventHandler m_evOnAddLogLine;
        private _INeroDriveEvents_OnSetPhaseEventHandler m_evOnSetPhase;
        private _INeroDriveEvents_OnDisableAbortEventHandler m_evOnDisableAbort;
        private _INeroEvents_OnFileSelImageEventHandler m_evOnFileSelImage;
        private _INeroEvents_OnWaitCDMediaInfoEventHandler m_evOnWaitCDMediaInfo;
        private _INeroEvents_OnNonEmptyCDRWEventHandler m_evOnNonEmptyCDRW;
        private _INeroDriveEvents_OnDriveStatusChangedEventHandler m_evDriveStatusChanged;

        private EarseProcess eProcess;

        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);
            try
            {
                m_abort = false;
                m_nero = new NeroClass();//实例nero类
            }
            catch (Exception ex)
            {
                return;
            }
            m_nerdrives = m_nero.GetDrives(NERO_MEDIA_TYPE.NERO_MEDIA_CD);//获得所有刻录光驱
            for (int i = 0; i < m_nerdrives.Count; i++)
            {
                m_nerdrive = (NeroDrive)m_nerdrives.Item(i);//获得可刻录的光驱
                string driveleffter = "";
                if (m_nerdrive.DriveLetter != "" && m_nerdrive.DriveLetter != "?")
                {
                    driveleffter = m_nerdrive.DriveLetter.ToLower();//光盘的前缀
                    cbdrive.Items.Add(driveleffter + ":" + m_nerdrive.DeviceName);
                    cbdrive.SelectedIndex = 0;
                }
            }
            m_nerdrive = GetCurrentlySelectedDrive();
           
        }

        protected override void OnClosed(EventArgs e)
        {
            base.OnClosed(e);

            //this.Close();

        }
        private void m_nero_OnWaitCDDone()
        {
            m_nerdrive = GetCurrentlySelectedDrive();
            if (m_nerdrive != null)
            {
                m_nerdrive.EjectCD();//打开驱动
            }
        }
        /// <summary>
        /// 打开光驱
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnshow_Click(object sender, EventArgs e)
        {
            m_nerdrive = GetCurrentlySelectedDrive();
            if (m_nerdrive != null)
            {
                m_nerdrive.EjectCD();//打开驱动
            }
        }

        private NeroDrive GetCurrentlySelectedDrive()
        {
            return cbdrive.SelectedIndex == -1 ? null : (NeroDrive)m_nerdrives.Item(cbdrive.SelectedIndex);
        }

        /// <summary>
        /// 关闭光驱
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnclose_Click(object sender, EventArgs e)
        {
            m_nerdrive = GetCurrentlySelectedDrive();
            if (m_nerdrive != null)
            {
                m_nerdrive.LoadCD();//加载光盘
            }
        }
        /// <summary>
        /// 快速擦除
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btncelerityClear_Click(object sender, EventArgs e)
        {
            bQuick = true;
            ClearDisk();
        }
        /// <summary>
        /// 完全擦除
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnclear_Click(object sender, EventArgs e)
        {
            bQuick = false;//bQuick为false是为完全擦去
            ClearDisk();
        }
        /// <summary>
        /// 清除磁盘
        /// </summary>
        private void ClearDisk()
        {
            try
            {
                m_iErasingTime = m_nerdrive.get_CDRWErasingTime(bQuick);//得到擦去的时间

                this.label1.Text = "正在擦除光盘。。。。";
                SetBtnState(false);

                m_timeStart = System.DateTime.Now;//获得开始时间
                m_timer = new System.Timers.Timer(500);//设置时间周期
                m_timer.Elapsed += new System.Timers.ElapsedEventHandler(m_timer_Elapsed);//发起时间间隔事件
                m_timer.Start();//开始计时
                m_evOnDoneErase = new _INeroDriveEvents_OnDoneEraseEventHandler(m_drive_OnDoneErase);//添加擦除成功后事件
                m_nerdrive.OnDoneErase += m_evOnDoneErase;
                m_nerdrive.EraseDisc(bQuick, NERO_ERASE_MODE.NERO_ERASE_MODE_DEFAULT);//擦除光盘

               
            }
            catch
            {
                this.label1.Text = "";
                MessageBox.Show(this, "光盘不可用或是没有光盘", "警告", MessageBoxButtons.OK,MessageBoxIcon.Warning);
                m_nerdrive.OnDoneErase -= m_evOnDoneErase;
                SetBtnState(true);
            }
        }

        /// <SUMMARY></SUMMARY>  
        /// 如果光驱为空，等待光驱  
        ///   
        /// <PARAM name="WaitCD" />  
        /// <PARAM name="WaitCDLocalizedText" />  
        private void m_nero_OnWaitCD(ref NERO_WAITCD_TYPE WaitCD, ref string WaitCDLocalizedText)
        {
            CountdownMsgFrm.ShowMsg("提示", "驱动器中没有可用的光盘，请将光盘放入驱动器后重试！");
           
            //m_nerdrive = GetCurrentlySelectedDrive();
            //if (m_nerdrive != null)
            //{
            //    m_nerdrive.EjectCD();//弹出驱动
            //}
            SubscribeToEvents(false);
           
           
            this.Close();

            //DialogResult result = MessageBox.Show(this, "光驱为空？", "警告", MessageBoxButtons.OK,MessageBoxIcon.Warning);
            //if (result == DialogResult.OK)
            //{
            //    m_nerdrive = GetCurrentlySelectedDrive();
            //    if (m_nerdrive != null)
            //    {
            //        m_nerdrive.EjectCD();//打开驱动
            //    }
            //}
            //else
            //{
            //    m_nerdrive = GetCurrentlySelectedDrive();
            //    if (m_nerdrive != null)
            //    {
            //        m_nerdrive.LoadCD();//加载驱动
            //    }
            //}
        }
        private void m_drive_OnDoneErase(ref bool Ok)
        {
            m_timer.Stop();//停止计时
            this.pbguage.Value = 100;
            this.label1.Text = "";

            //MessageBox.Show(this, "擦除光盘" + (Ok ? "成功!" : "失败!"),"提示",MessageBoxButtons.OK,MessageBoxIcon.Information);
            CountdownMsgFrm.ShowMsg("提示", "擦除光盘" + (Ok ? "成功!" : "失败!"));
            this.pbguage.Value = 0;
            SetBtnState(true);

            isearead = Ok;

            m_nerdrive.OnDoneErase -= m_evOnDoneErase;
           
        }
        private void m_timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            TimeSpan ts = System.DateTime.Now - m_timeStart;
            int iElapsedTime = ts.Minutes * 60 + ts.Seconds;
            iPercent = (iElapsedTime * 100) / m_iErasingTime;
            MethodInvoker method = new MethodInvoker(eProcess);
            this.BeginInvoke(method);
        }

        private int iPercent = 0;
        private void EreasePro()
        {
            pbguage.Value = (iPercent > 100 ? 100 : iPercent);
        }

        private void m_timer_Elapseds(object sender, System.Timers.ElapsedEventArgs e)
        {
            TimeSpan ts = System.DateTime.Now - m_timeStart;
        }

        private void btnyes_Click(object sender, EventArgs e)
        {

        }

        private void btncancel_Click(object sender, EventArgs e)
        {
            this.Close();
        }
        public string sFolder;
        /// <summary>
        /// 选择刻录盘目录
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnbackupdirectory_Click(object sender, EventArgs e)
        {
            BrowseForFolderClass bff = new BrowseForFolderClass();
            sFolder = bff.BrowseForFolder("选择刻盘目录");
            if (sFolder != "")
            {
                txtbackuppatch.Text = sFolder;
            }
        }

        private void SubscribeToEvents(bool bSubscribe)
        {
            if (bSubscribe)
            {
                m_evOnDoneBurn = new _INeroDriveEvents_OnDoneBurnEventHandler(m_drive_OnDoneBurn);
                m_nerdrive.OnDoneBurn += m_evOnDoneBurn;
                m_evOnProgress = new _INeroDriveEvents_OnProgressEventHandler(m_drive_OnProgress);
                m_nerdrive.OnProgress += m_evOnProgress;
                m_evOnSubTaskProgress = new _INeroDriveEvents_OnSubTaskProgressEventHandler(m_drive_OnSubTaskProgress);
                m_nerdrive.OnSubTaskProgress += m_evOnSubTaskProgress;
                m_evOnWaitCDDone = new _INeroEvents_OnWaitCDDoneEventHandler(m_nero_OnWaitCDDone);
                m_nero.OnWaitCDDone += m_evOnWaitCDDone;
                m_evOnWaitCDMediaInfo = new _INeroEvents_OnWaitCDMediaInfoEventHandler(m_nero_OnWaitCDMediaInfo);
                m_nero.OnWaitCDMediaInfo += m_evOnWaitCDMediaInfo;
                m_evOnNonEmptyCDRW = new _INeroEvents_OnNonEmptyCDRWEventHandler(m_nero_OnNonEmptyCDRW);
                m_nero.OnNonEmptyCDRW += m_evOnNonEmptyCDRW;
                m_evOnWaitCD = new _INeroEvents_OnWaitCDEventHandler(m_nero_OnWaitCD);
                m_nero.OnWaitCD += m_evOnWaitCD;
                m_timeStart = DateTime.Now;
                m_timer = new System.Timers.Timer(500);
                m_timer.Elapsed += new System.Timers.ElapsedEventHandler(m_timer_Elapseds);
                m_timer.Start();
            }
            else
            {
                m_timer.Stop();
                m_timer.Elapsed -= m_timer_Elapseds;
                m_nerdrive.OnDoneBurn -= m_evOnDoneBurn;
                m_nerdrive.OnProgress -= m_evOnProgress;
                m_nerdrive.OnSubTaskProgress -= m_evOnSubTaskProgress; ;
                m_nero.OnWaitCD -= m_evOnWaitCD;
                m_nero.OnWaitCDDone -= m_evOnWaitCDDone;
                m_nero.OnWaitCDMediaInfo -= m_evOnWaitCDMediaInfo;
                m_nero.OnNonEmptyCDRW -= m_evOnNonEmptyCDRW;
            }
        }
        private void m_nero_OnWaitCDMediaInfo(ref NERO_MEDIA_TYPE LastDetectedMedia, ref string LastDetectedMediaName, ref NERO_MEDIA_TYPE RequestedMedia, ref string RequestedMediaName)
        {
            m_nerdrive = GetCurrentlySelectedDrive();
            if (m_nerdrive != null)
            {
                m_nerdrive.EjectCD();//打开驱动
            }
        }
        bool m_isDoneBurn;
        /// <summary>
        /// 刻录完成
        /// </summary>
        /// <param name="StatusCode"></param>
        private void m_drive_OnDoneBurn(ref NERO_BURN_ERROR StatusCode)
        {

            SubscribeToEvents(false);

            if (StatusCode == NERO_BURN_ERROR.NERO_BURN_OK)
            {
                isBurned = true;
                //MessageBox.Show(this, "光盘刻录成功!", "提示",MessageBoxButtons.OK,MessageBoxIcon.Information);
                CountdownMsgFrm.ShowMsg("提示", "光盘刻录成功！");
            }
            else
            {
                //MessageBox.Show(this, "光盘刻录失败！", "错误提示！",MessageBoxButtons.OK,MessageBoxIcon);
                CountdownMsgFrm.ShowMsg("提示", "光盘刻录失败！");
                m_nerdrive = GetCurrentlySelectedDrive();
                if (m_nerdrive != null)
                {
                    m_nerdrive.EjectCD();//打开驱动
                }
            }
            m_isDoneBurn = true;
           
            this.label1.Text = "";
            SetBtnState(true);
            this.pbguage.Value = 0;
            if (isBurned)
                this.Close();

        }
        /// <summary>
        /// 进度条的进度
        /// </summary>
        /// <param name="ProgressInPercent"></param>
        /// <param name="Abort"></param>
        private void m_drive_OnProgress(ref int ProgressInPercent, ref bool Abort)
        {
            pbguage.Value = (ProgressInPercent > 100 ? 100 : ProgressInPercent);
        }
        /// <summary>
        /// 进度条的进度
        /// </summary>
        /// <param name="ProgressInPercent"></param>
        /// <param name="Abort"></param>
        private void m_drive_OnSubTaskProgress(ref int ProgressInPercent, ref bool Abort)
        {
            pbguage.Value = (ProgressInPercent > 100 ? 100 : ProgressInPercent);
        }
        /// <summary>
        /// 检查到没有可用的磁盘
        /// </summary>
        /// <param name="Response"></param>
        private void m_nero_OnNonEmptyCDRW(ref NERO_RESPONSE Response)
        {
            CountdownMsgFrm.ShowMsg("提示", "驱动器中没有可用的光盘！");
            Response = NERO_RESPONSE.NERO_RETURN_EXIT;
            //if (DialogResult.Yes != MessageBox.Show(this, "没有可用的光盘", "提示", MessageBoxButtons.YesNo, MessageBoxIcon.Question))
            //{
            //    Response = NERO_RESPONSE.NERO_RETURN_RESTART;
            //}
            //else
            //{

            //    Response = NERO_RESPONSE.NERO_RETURN_CONTINUE;
            //}
        }

        private bool isearead = false;
        /// <summary>
        /// 开始刻录
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnstartbackup_Click(object sender, EventArgs e)
        {
            if (!isearead)
            {
                DialogResult dr = MessageBox.Show("开始刻录之前，请确认您的光盘是否已经擦除？如果已经擦除请选择‘是’，否则选择‘否’开始光盘擦除。", "提示", MessageBoxButtons.YesNo, MessageBoxIcon.Information);
                if (dr == DialogResult.No)
                {
                    ClearDisk();
                    return;
                }
            }
            try
            {
                m_nerdrive = GetCurrentlySelectedDrive();
                SubscribeToEvents(true);
                GetAudioTracks();
            }
            catch(Exception ex)
            {
                MessageBox.Show("无法开始刻录.错误：" + ex.Message, "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void GetAudioTracks()
        {
            this.label1.Text = "正在刻录数据到光盘。。。。";
            SetBtnState(false);

            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 = txtvolume.Text;
            AddFilesAndFoldersToISOTrack(ref isoTrack);
            if (isoTrack.RootFolder.Files.Count == 0 &&
                             isoTrack.RootFolder.Folders.Count == 0)
            {
                isoTrack = null;
            }

            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_nerdrive)
                {
                    MessageBox.Show("光驱为空");
                }

                int speed = 10000;
                m_nerdrive.BurnIsoAudioCD("", "", false,
                    isoTrack,
                    null,
                    null,
                    flags,
                        speed,
                        NERO_MEDIA_TYPE.NERO_MEDIA_DVD_M);
            }
            catch (Exception e)
            {
                this.label1.Text = "";
                SetBtnState(true);
                m_aborted = true;
                MessageBox.Show("Burn Error : " + e.Message);
            }
        }
        private bool m_aborted = false;
        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);
            }
        }
        private void AddFilesAndFoldersToISOTrack(ref NeroISOTrack isoTrack)
        {

            string sPath = txtbackuppatch.Text;
            if (sPath != "")
            {
                if (sPath[sPath.Length - 1] == '\\')
                {
                    NeroFolder folder = isoTrack.RootFolder;
                    AddFolderRecursively(ref folder, sPath);
                }
                else
                {
                    NeroFile file = new NeroFileClass();
                    file.SourceFilePath = sPath;
                    file.Name = Path.GetFileName(sPath);
                    file.EntryTime = Directory.GetLastWriteTime(sPath);
                    isoTrack.RootFolder.Files.Add(file);
                }
            }

        }
        private static string states = "none";
        private void cbdrive_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (m_nerdrive != null)
            {
                try
                {
                    m_nerdrive.EnableStatusCallback(NERO_DRIVESTATUS_TYPE.NDT_DISC_CHANGE, false);
                    m_nerdrive.EnableStatusCallback(NERO_DRIVESTATUS_TYPE.NDT_IN_USE_CHANGE, false);
                    m_nerdrive.OnDriveStatusChanged -= m_evDriveStatusChanged;
                }
                catch
                {

                }
            }

            m_nerdrive = GetCurrentlySelectedDrive();

            if (m_nerdrive != null)
            {
                m_evDriveStatusChanged = new _INeroDriveEvents_OnDriveStatusChangedEventHandler(m_lastDrive_OnDriveStatusChanged);//cd  驱动状态判断
                m_nerdrive.OnDriveStatusChanged += m_evDriveStatusChanged;
                m_nerdrive.EnableStatusCallback(NERO_DRIVESTATUS_TYPE.NDT_DISC_CHANGE, true);
                m_nerdrive.EnableStatusCallback(NERO_DRIVESTATUS_TYPE.NDT_IN_USE_CHANGE, true);

            }
        }
        /// <summary>
        /// 驱动状态判断
        /// </summary>
        /// <param name="driveStatus"></param>
        private void m_lastDrive_OnDriveStatusChanged(NERO_DRIVESTATUS_RESULT driveStatus)
        {
            switch (driveStatus)
            {
                case NERO_DRIVESTATUS_RESULT.NDR_DISC_INSERTED:
                    states = "光盘已经插入";
                    SetBtnState(true);
                    break;
                case NERO_DRIVESTATUS_RESULT.NDR_DISC_REMOVED:
                    states = "光盘已经移出";
                    this.btnclose.Enabled = true;
                    this.btnshow.Enabled = false;
                    break;
                case NERO_DRIVESTATUS_RESULT.NDR_DRIVE_IN_USE:
                    states = "光盘正在使用";
                    SetBtnState(false);
                    break;
                case NERO_DRIVESTATUS_RESULT.NDR_DRIVE_NOT_IN_USE:
                    states = "光盘可使用";
                    SetBtnState(true);
                    break;
                default:
                    states = "驱动为不可用";
                    SetBtnState(false);
                    this.btncancel.Enabled = true;
                    break;
            }
            //if (states != "none")
            //{
            //    MessageBox.Show(states);
            //}
        }

        private void SetBtnState(bool enable)
        {
            this.btncancel.Enabled = enable;
            this.btnclose.Enabled = enable;
            this.btnEntire.Enabled = enable;
            this.btnshow.Enabled = enable;
            this.btnstartbackup.Enabled = enable;
            this.btnQuick.Enabled = enable;
            this.btnbackupdirectory.Enabled = enable;

            this.cbdrive.Enabled = enable;
            this.txtbackuppatch.ReadOnly = !enable;
            this.txtvolume.ReadOnly = !enable;
        }

        private void DiskInfo_Load(object sender, EventArgs e)
        {
            if(DiskPatch!=null)
            txtbackuppatch.Text = DiskPatch;
        }

        private bool isBurned = false;

        public bool IsBurned
        {
            get { return isBurned; }
            set { isBurned = value; }
        }
    }
}