C# 实现刻录光盘功能

最近公司提出一个需求,要把公司系统的图像刻录成光盘(公司系统是医院放射科系统,很多放射科的图像)

查看了很多资料发现有两个比较可靠

1:使用IMAPI2，进行文件的光盘刻录，具体实例可以参照以下链接：

C#实现方式：

Burning and Erasing CD/DVD Media with C# and IMAPI2

地址：http://www.codeproject.com/Articles/24544/Burning-and-Erasing-CD-DVD-Blu-ray-Media-with-C-an

C++实现方式：

Burning CD/DVD Media with the Image Mastering API Version 2.0 (IMAPI2)

地址：http://www.codeproject.com/Articles/22538/Burning-CD-DVD-Media-with-the-Image-Mastering-API

我用的C#的版本,经过测试 在WIN7下好用,xp 下不好用, 虽然很多人说xp sp3补丁可以,但是我还是失败了,公司的系统要求Xp可以使用

而且有个奇怪的问题,我自定义的项目就没有进度条的事件,下载老外的源码就有,好奇怪

郁闷呀..

2:C#调用Nero SDK进行

参考资料:1.http://blog.sina.com.cn/s/blog_962aaf5d01012vow.html

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

这两位写的都很完全,我只是把它收集补充了一下

首先是

SDK的版本: 采用NeroSDK-1.08版本,

Nero版本: 你的电脑需要安装Nero, 应该是必须要Nero7, 我安装了8不好用,只有安装7才好用

开发注意:.net版本应该是1.0到3.5之间.4.0,4.5编译不了,而且项目的目标平台必须是x86 其他的会报错

基于Nero SDK有我自己的一个简单的封装,帖出来给大家分享一下

项目结构


系统定义部分委托:

/// <summary>
/// 显示时间进度
/// </summary>
/// <param name="time"></param>
public delegate void ShowTimeProcessDelegate(string time);

/// <summary>
/// 显示进度
/// </summary>
/// <param name="percentProgress"></param>
public delegate void ShowBrushLogLineDelegate(string value);

/// <summary>
/// 显示进度
/// </summary>
/// <param name="percentProgress"></param>
public delegate void ShowBrushProcessDelegate(ProcessEntity percentEvent);

/// <summary>
/// 刻录错误
/// </summary>
/// <param name="error"></param>
public delegate void BurshErrorDelegate(Exception ex);

/// <summary>
/// 刻录成功
/// </summary>
/// <param name="value"></param>
public delegate void BrushSuccessDelegate(string value);

/// <summary>
/// 显示光盘信息
/// </summary>
/// <returns></returns>
public delegate  void  ShowDiscInfoDelegate(DiscInfoEntity disc);

/// <summary>
/// 获取所以刻录信息
/// </summary>
/// <param name="collection"></param>
public delegate void GetSpeedEntityCollectionDelegate(SpeedEntityCollection collection);

获取光盘信息方法

/// <summary>
/// 光盘信息帮助类
/// </summary>
class DiscHelper
{

private Nero m_nero;
private NeroDrive m_drive;
internal event ShowDiscInfoDelegate ShowDisc;

public DiscHelper(Nero nero, NeroDrive drive)
{
this.m_nero = nero;
this.m_drive = drive;
}

/// <summary>
/// 获取光盘容量
/// </summary>
/// <param name="driveInfo">驱动器信息</param>
/// <returns></returns>
public void GetDriveInfoSize()
{
if (m_drive != null)
{
m_drive.OnDoneCDInfo += drive_OnDoneCDInfo;
}
RefreshDiscInfo();
}

private void RefreshDiscInfo()
{
if (m_drive != null)
{
m_drive.CDInfo(NERO_CDINFO_FLAGS.NERO_READ_CD_TEXT);
}
}

/// <summary>
/// 异步触发信息类
/// </summary>
/// <param name="pCDInfo"></param>
private void drive_OnDoneCDInfo(INeroCDInfo pCDInfo)
{

m_drive.OnDoneCDInfo -= drive_OnDoneCDInfo;
DisplayDiscInfo((NeroCDInfo)pCDInfo);
}

/// <summary>
/// 格式化光盘信息实体类
/// </summary>
/// <param name="cdinfo"></param>
private void DisplayDiscInfo(NeroCDInfo cdinfo)
{
DiscInfoEntity info = null;
if (cdinfo != null)
{

info = new DiscInfoEntity();
long l2048 = 2048;//2048转换成long类型
info.MediaType = m_nero.get_TypeNameOfMedia(cdinfo.MediaType);
info.StrFreeCapacity = BlockToByte(cdinfo.FreeCapacityInBlocks);
info.StrUnused = BlockToByte((uint)cdinfo.UnusedBlocks);
info.StrTotalCapacity = BlockToByte(cdinfo.TotalCapacity);
info.TotalCapacity = cdinfo.FreeCapacityInBlocks * l2048;
info.Unused = ((uint)cdinfo.UnusedBlocks) * l2048;
info.TotalCapacity = cdinfo.TotalCapacity * l2048;
info.Cdinfo = cdinfo;

}
//委托返回信息
if (ShowDisc != null)
{
ShowDisc(info);
}
}

#region 格式化函数

private string BlockToByte(int block)
{
string Value = string.Empty;
int temp = FromByteM(block);
if (temp < 1024)
{
Value = string.Format("{0}MB", temp);
}
else
{
Value = string.Format("{0:N}GB", FromByteG(block));
}
return Value;
}

private string BlockToByte(uint block)
{
string Value = string.Empty;
int temp = FromByteM(block);
if (temp < 1024)
{
Value = string.Format("{0}MB", temp);
}
else
{
Value = string.Format("{0:N}GB", FromByteG(block));
}
return Value;
}

/// <summary>
/// Block转换MB
/// </summary>
/// <param name="block"></param>
/// <returns></returns>
private int FromByteM(int block)
{

int temp = block * 2 / 1024;
return temp;
}

/// <summary>
/// Block转换MB
/// </summary>
/// <param name="block"></param>
/// <returns></returns>
private int FromByteM(uint block)
{
uint ut1 = 2;
uint ut2 = 1024;
int temp = (int)(block * ut1 / ut2);
return temp;
}

/// <summary>
/// Block转换GB
/// </summary>
/// <param name="block"></param>
/// <returns></returns>
private double FromByteG(int block)
{
double d1 = (double)block;
double temp = d1 * 2 / 1024 / 1024;
return temp;
}

/// <summary>
/// Block转换GB
/// </summary>
/// <param name="block"></param>
/// <returns></returns>
private double FromByteG(uint block)
{
uint ut1 = 2;
uint ut2 = 1024;
double d1 = (double)block;
double temp = (double)(d1 * ut1 / ut2 / ut2);
return temp;
}

#endregion

}

有一部分是block转换使用的.SDK获取到的并不在我们常用的单位

光盘信息定义的实体类

/// <summary>
/// 光盘信息实体类
/// </summary>
public class DiscInfoEntity
{
/// <summary>
/// 剩余容量(带单位)
/// </summary>
public string StrFreeCapacity { get; set; }

/// <summary>
/// 不可用容量(带单位)
/// </summary>
public string StrUnused { get; set; }

/// <summary>
/// 全部容量(带单位)
/// </summary>
public string StrTotalCapacity { get; set; }

/// <summary>
/// 剩余容量Byte
/// </summary>
public long FreeCapacity { get; set; }

/// <summary>
/// 已用容量Byte
/// </summary>
public long Unused { get; set; }

/// <summary>
/// 全部容量
/// </summary>
public long TotalCapacity { get; set; }

/// <summary>
/// 光盘类型
/// </summary>
public string MediaType { get; set; }

/// <summary>
///
/// </summary>
public NeroCDInfo Cdinfo { get; set; }
}

2:获取刻录机的读写速度

/// <summary>
/// 刻录速度帮助类
/// </summary>
class SpeedHelper
{

public NeroDrive m_drive;
private bool m_bWriteSpeeds;
private _INeroDriveEvents_OnDoneCDInfoEventHandler m_evOnDoneCDInfo;
internal event GetSpeedEntityCollectionDelegate GetSpeedCollect;

public SpeedHelper(NeroDrive drive, bool writeSpeed)
{
m_drive = drive;
m_bWriteSpeeds = writeSpeed;
m_evOnDoneCDInfo = new _INeroDriveEvents_OnDoneCDInfoEventHandler(m_drive_OnDoneCDInfo);
m_drive.OnDoneCDInfo += m_evOnDoneCDInfo;

}

/// <summary>
///异步获取速度
/// </summary>
public void GetSpeed()
{
m_drive.CDInfo(0);
}

/// <summary>
/// 触发异步事件
/// </summary>
/// <param name="pCDInfo"></param>
private void m_drive_OnDoneCDInfo(INeroCDInfo pCDInfo)
{
// Unsubscribe from event, get the speeds and populate the
// speeds combobox with it
m_drive.OnDoneCDInfo -= m_evOnDoneCDInfo;
SpeedEntityCollection collection = GetSpeedCollection(pCDInfo, m_bWriteSpeeds);
if (GetSpeedCollect != null)
{
GetSpeedCollect(collection);
}

}

/// <summary>
/// 获取读取速度
/// </summary>
/// <param name="pCDInfo">光盘信息</param>
/// <returns></returns>
public SpeedEntityCollection GetReadSpeedCollection(INeroCDInfo pCDInfo)
{
SpeedEntityCollection collection = GetSpeedCollection(pCDInfo, false);
return collection;
}

/// <summary>
/// 获取写入速度
/// </summary>
/// <param name="pCDInfo">光盘信息</param>
/// <returns></returns>
public SpeedEntityCollection GetWriteSpeedCollection(INeroCDInfo pCDInfo)
{
SpeedEntityCollection collection = GetSpeedCollection(pCDInfo, true);
return collection;
}

/// <summary>
/// 获取读写速度
/// </summary>
/// <param name="pCDInfo">光盘信息</param>
/// <param name="WriteSpeeds">是否读写</param>
/// <returns></returns>
private SpeedEntityCollection GetSpeedCollection(INeroCDInfo pCDInfo, bool WriteSpeeds)
{
NERO_MEDIA_TYPE nmt = (pCDInfo != null ?
pCDInfo.MediaType : NERO_MEDIA_TYPE.NERO_MEDIA_NONE);
NeroSpeeds speeds = m_drive.get_AvailableSpeeds(WriteSpeeds ? NERO_ACCESSTYPE.NERO_ACCESSTYPE_WRITE : NERO_ACCESSTYPE.NERO_ACCESSTYPE_READ, nmt);
SpeedEntityCollection collection = GetSpeedEntityCollection(speeds, WriteSpeeds);
return collection;
}

/// <summary>
/// 生成速度集合
/// </summary>
/// <param name="speeds"></param>
/// <param name="WriteSpeeds"></param>
/// <returns></returns>
private SpeedEntityCollection GetSpeedEntityCollection(NeroSpeeds speeds, bool WriteSpeeds)
{
SpeedEntityCollection collection = new SpeedEntityCollection();
// If we should add "Maximum", do it here and now.
//
if (WriteSpeeds)
{
collection.SpeedEntity.Add(new SpeedEntity("Maximum", 0));
}
else
{
// If we should not add "Maximum", see if there is at
// least one speed. If not, add "<none>".
//
if (speeds.Count == 0)
{
collection.SpeedEntity.Add(new SpeedEntity("<none>", 0));
}
}

// Now, add each speed from the NeroSpeeds collection.
//
foreach (int iSpeed in speeds)
{
float fSpeed = iSpeed / (float)speeds.BaseSpeedKBs;
collection.SpeedEntity.Add(new SpeedEntity(fSpeed.ToString() + "x (" + iSpeed.ToString() + " kb/s)", iSpeed));
}

return collection;
}

读写速度的实体类

/// <summary>
/// 速度集合类
/// </summary>
public class SpeedEntityCollection
{
public IList<SpeedEntity> SpeedEntity { get; set; }

public SpeedEntityCollection()
{
this.SpeedEntity = new List<SpeedEntity>();
}
}

/// <summary>
/// 速度实体类
/// </summary>
public class SpeedEntity
{
public string m_sItem;
public int m_iSpeed;

public SpeedEntity(string sItem, int iSpeed)
{
m_sItem = sItem;
m_iSpeed = iSpeed;
}

public override string ToString()
{
return m_sItem;
}
}

刻录类

class BrushHelper
{

private NeroDrive m_drive;
private Nero m_nero;
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_OnWaitCDEventHandler m_evOnWaitCD;
private _INeroEvents_OnWaitCDDoneEventHandler m_evOnWaitCDDone;
private _INeroEvents_OnWaitCDMediaInfoEventHandler m_evOnWaitCDMediaInfo;
private _INeroEvents_OnNonEmptyCDRWEventHandler m_evOnNonEmptyCDRW;
private bool m_bAborted;
private DateTime m_timeStart;
private System.Timers.Timer m_timer;
private WaitCD m_frmWaitCD = null;
public bool IsCancle { get; set; }

/// <summary>
/// 使用时间
/// </summary>
internal event ShowTimeProcessDelegate ShowTimeProcess;
/// <summary>
/// 显示进度
/// </summary>
internal event ShowBrushProcessDelegate ShowBurshProcess;
/// <summary>
/// 显示子进度
/// </summary>
internal event ShowBrushProcessDelegate SubShowBurshProcess;
/// <summary>
/// 显示进度
/// </summary>
internal event ShowBrushLogLineDelegate ShowLogLine;
/// <summary>
/// 刻录成功委托
/// </summary>
internal event BrushSuccessDelegate BrushSuccess;
/// <summary>
/// 刻录失败委托
/// </summary>
internal event BurshErrorDelegate BrushError;

public BrushHelper(Nero nero, NeroDrive drive)
{
IsCancle = true;
this.m_nero = nero;
this.m_drive = drive;
this.m_frmWaitCD = new WaitCD();
this.m_frmWaitCD.OnCancel += m_frmWaitCD_OnCancel;
}

void m_frmWaitCD_OnCancel(object sender, EventArgs e)
{
this.Cancle();
}

/// <summary>
/// 刻录光盘
/// </summary>
/// <param name="isoTrack"></param>
/// <param name="audioTracks"></param>
/// <param name="cdStamp"></param>
/// <param name="BurnFlags"></param>
/// <param name="m_iSpeed"></param>
/// <param name="MediaType"></param>
public void Brush(NeroISOTrack isoTrack,
NeroAudioTracks audioTracks,
NeroCDStamp cdStamp,
NERO_BURN_FLAGS BurnFlags,
int m_iSpeed,
NERO_MEDIA_TYPE MediaType
)
{
BurnIsoAudio(string.Empty, string.Empty, isoTrack, audioTracks, cdStamp, BurnFlags, m_iSpeed, MediaType);
}

/// <summary>
/// 刻录光盘
/// </summary>
/// <param name="sArtist"></param>
/// <param name="sTitle"></param>
/// <param name="isoTrack">光盘类</param>
/// <param name="audioTracks">音频类</param>
/// <param name="cdStamp"></param>
/// <param name="BurnFlags">刻录标记</param>
/// <param name="m_iSpeed">速度</param>
/// <param name="MediaType">光盘类型</param>
public void Brush(string sArtist,
string sTitle,
NeroISOTrack isoTrack,
NeroAudioTracks audioTracks,
NeroCDStamp cdStamp,
NERO_BURN_FLAGS BurnFlags,
int m_iSpeed,
NERO_MEDIA_TYPE MediaType
)
{
BurnIsoAudio(sArtist, sTitle, isoTrack, audioTracks, cdStamp, BurnFlags, m_iSpeed, MediaType);
}

/// <summary>
/// 停止刻录
/// </summary>
public void Cancle()
{
if (!IsCancle)
{
return;
}
m_bAborted = true;
m_nero.Abort();
}

private void BurnIsoAudio(string sArtist, string sTitle, NeroISOTrack isoTrack, NeroAudioTracks audioTracks, NeroCDStamp cdStamp, NERO_BURN_FLAGS nbf, int iSpeedInKBS, NERO_MEDIA_TYPE mediaType)
{
try
{
// First subscribe to all events of interest.
//
SubscribeToEvents(true);

// If the iso track passed in has neither files nor folders,
// don't use it.
//
if (isoTrack.RootFolder.Files.Count == 0 &&
isoTrack.RootFolder.Folders.Count == 0)
{
isoTrack = null;
}

// Just pass on all the gathered parameters.
//
m_drive.BurnIsoAudioCD(sArtist,
sTitle,
false,
isoTrack,
audioTracks,
cdStamp,
(NERO_BURN_FLAGS)((uint)nbf | (uint)NERO_BURN_FLAGS.NERO_BURN_FLAG_SPEED_IN_KBS),
iSpeedInKBS,
mediaType);
}
catch (COMException ex)
{
SubscribeToEvents(false);
XLogManager.LogError(ex);
//MessageBox.Show(this, ex.Message);
}
catch (Exception exx)
{
XLogManager.LogError(exx);
// MessageBox.Show(this, exx.Message);
}
}

private void SubscribeToEvents(bool bSubscribe)
{
if (bSubscribe)
{
// Subscribe to NeroDrive events.
//
m_evOnDoneBurn = new _INeroDriveEvents_OnDoneBurnEventHandler(m_drive_OnDoneBurn);
m_drive.OnDoneBurn += m_evOnDoneBurn;
m_evOnProgress = new _INeroDriveEvents_OnProgressEventHandler(m_drive_OnProgress);
m_drive.OnProgress += m_evOnProgress;
m_evOnSubTaskProgress = new _INeroDriveEvents_OnSubTaskProgressEventHandler(m_drive_OnSubTaskProgress);
m_drive.OnSubTaskProgress += m_evOnSubTaskProgress;
m_evOnAborted = new _INeroDriveEvents_OnAbortedEventHandler(m_drive_OnAborted);
m_drive.OnAborted += m_evOnAborted;
m_evOnAddLogLine = new _INeroDriveEvents_OnAddLogLineEventHandler(m_drive_OnAddLogLine);
m_drive.OnAddLogLine += m_evOnAddLogLine;
m_evOnSetPhase = new _INeroDriveEvents_OnSetPhaseEventHandler(m_drive_OnSetPhase);
m_drive.OnSetPhase += m_evOnSetPhase;
m_evOnDisableAbort = new _INeroDriveEvents_OnDisableAbortEventHandler(m_drive_OnDisableAbort);
m_drive.OnDisableAbort += m_evOnDisableAbort;

// Subscribe to Nero events.
//
m_evOnFileSelImage = new _INeroEvents_OnFileSelImageEventHandler(m_nero_OnFileSelImage);
m_nero.OnFileSelImage += m_evOnFileSelImage;
m_evOnWaitCD = new _INeroEvents_OnWaitCDEventHandler(m_nero_OnWaitCD);
m_nero.OnWaitCD += m_evOnWaitCD;
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;

//// Start the timer that is responsible for displaying
//// the elapsed time during burning.
////
m_timeStart = DateTime.Now;
m_timer = new System.Timers.Timer(500);
m_timer.Elapsed += new System.Timers.ElapsedEventHandler(m_timer_Elapsed);
m_timer.Start();
}
else
{
//// Stop the elapsed time timer.
////
m_timer.Stop();

// Unsubscribe from NeroDrive events.
//
m_drive.OnDoneBurn -= m_evOnDoneBurn;
m_drive.OnProgress -= m_evOnProgress;
m_drive.OnSubTaskProgress -= m_evOnSubTaskProgress;
m_drive.OnAborted -= m_evOnAborted;
m_drive.OnAddLogLine -= m_evOnAddLogLine;
m_drive.OnSetPhase -= m_evOnSetPhase;
m_drive.OnDisableAbort -= m_evOnDisableAbort;

// Unsubscribe from Nero events.
//
m_nero.OnFileSelImage -= m_evOnFileSelImage;
m_nero.OnWaitCD -= m_evOnWaitCD;
m_nero.OnWaitCDDone -= m_evOnWaitCDDone;
m_nero.OnWaitCDMediaInfo -= m_evOnWaitCDMediaInfo;
m_nero.OnNonEmptyCDRW -= m_evOnNonEmptyCDRW;
}
}

/// <summary>
/// 光盘信息
/// </summary>
/// <param name="LastDetectedMedia"></param>
/// <param name="LastDetectedMediaName"></param>
/// <param name="RequestedMedia"></param>
/// <param name="RequestedMediaName"></param>
private void m_nero_OnWaitCDMediaInfo(ref NERO_MEDIA_TYPE LastDetectedMedia, ref string LastDetectedMediaName, ref NERO_MEDIA_TYPE RequestedMedia, ref string RequestedMediaName)
{
// When this event is fired, we need to update the
// information on the WaitCD form. Also, sometimes
// this event can come before the actual OnWaitCD so
// make sure that either of them is prepared to
// show the WaitCD form.
//
m_frmWaitCD.c_LastDetectedMedia.Text = LastDetectedMediaName;
m_frmWaitCD.c_RequestedMedia.Text = RequestedMediaName;
m_frmWaitCD.Show();
}

/// <summary>
/// 光盘不为空时,是否格式化
/// </summary>
/// <param name="Response"></param>
private void m_nero_OnNonEmptyCDRW(ref NERO_RESPONSE Response)
{
//// This event will be fired only if the proper conditions
//// are met AND if NERO_BURN_FLAGS.NERO_BURN_FLAG_DETECT_NON_EMPTY_CDRW
//// was specified to the burn fucntion. Ask if we should erase
//// the rewritable.
////
if (DialogResult.Yes != MessageBox.Show("当前光盘不是空的.需要被删除才能继续,你想删除光盘吗?", "擦除?", MessageBoxButtons.YesNo, MessageBoxIcon.Question))
{
// If the answer was NO, ask for a new disc.
//
Response = NERO_RESPONSE.NERO_RETURN_RESTART;
}
else
{
// If YES, then do erase the disc and continue burning
// afterwards.
//
EraseProgressForm frm = new EraseProgressForm(m_drive, true, false);
frm.ShowDialog();

Response = NERO_RESPONSE.NERO_RETURN_CONTINUE;
}
}

/// <summary>
/// 光盘完成
/// </summary>
private void m_nero_OnWaitCDDone()
{
// When waiting on a disc is done, make sure to
// enable us and hide the WaitCD form.
//
m_frmWaitCD.Hide();
}

/// <summary>
/// 等待光盘
/// </summary>
/// <param name="WaitCD"></param>
/// <param name="WaitCDLocalizedText"></param>
private void m_nero_OnWaitCD(ref NERO_WAITCD_TYPE WaitCD, ref string WaitCDLocalizedText)
{
// Ok, so now we need to wait on a disc. Let's pass
// the WaitCD form the text and show it (if not already
// shown). Make sure to disable the parent (this window)
// so that a modal behavior is simulated.
//
string value = WaitCDLocalizedText;
if (WaitCDLocalizedText.Contains("Please insert the disc to write to..."))
{
value = "请插入可写光盘...";
}
m_frmWaitCD.c_WaitCDText.Text = value;
m_frmWaitCD.Show();
}

/// <summary>
/// 设置文件信息时
/// </summary>
/// <param name="Filename"></param>
private void m_nero_OnFileSelImage(ref string Filename)
{
//// This events asks us to supply the image filename to
//// save to if the chose recorder is "Image Recorder".
////
//SaveFileDialog dlg = new SaveFileDialog();
//dlg.DefaultExt = ".nrg";
//dlg.Filter = "NRG files (*.nrg)|*.nrg|All files (*.*)|*.*";

//// To cancel, assign empty string.
////
//if (DialogResult.OK == dlg.ShowDialog(this))
//{
//    Filename = dlg.FileName;
//}
//else
//{
//    Filename = "";
//}
}

/// <summary>
/// 禁用中止
/// </summary>
/// <param name="EnableAbort"></param>
private void m_drive_OnDisableAbort(ref bool EnableAbort)
{
// This event will be fired at appropriate moments
// only if NERO_BURN_FLAGS.NERO_BURN_FLAG_DISABLE_ABORT
// was specified to the burning function. Make sure to
// update the state of the Cancel button accordingly.
//
//c_Cancel.Enabled = EnableAbort;
IsCancle = EnableAbort;
}

/// <summary>
/// 添加进度说明
/// </summary>
/// <param name="TextType"></param>
/// <param name="Text"></param>
private void m_drive_OnAddLogLine(ref NERO_TEXT_TYPE TextType, ref string Text)
{
// This one informs us of the important events during
// the burn process. We simply add a line to the list
// view with the current time beside it.
//
DateTime time = DateTime.Now;

//ListViewItem lvi = c_Events.Items.Add(time.ToLongTimeString());
//lvi.SubItems.Add(Text);
if (ShowLogLine != null)
{
ShowLogLine(Text);
}
}

private void m_timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
// When the timer ticks, we should update the elapsed
// time.
//

try
{
TimeSpan ts = System.DateTime.Now - m_timeStart;

if (ShowTimeProcess != null)
{
this.ShowTimeProcess(ts.Hours.ToString("00") + ":" + ts.Minutes.ToString("00") + ":" + ts.Seconds.ToString("00"));
}
}
catch (Exception ex)
{
XLogManager.LogError(ex);
Console.WriteLine(ex.Message);
}

}

/// <summary>
/// 设置阶段
/// </summary>
/// <param name="Text"></param>
private void m_drive_OnSetPhase(ref string Text)
{
// When a new phase comes in, display it.
//
//c_Phase.Text = Text;
if (this.ShowBurshProcess != null)
{
ShowLogLine(Text);
}
}

/// <summary>
/// 终止刻录
/// </summary>
/// <param name="Abort"></param>
private void m_drive_OnAborted(ref bool Abort)
{
// This is a general aborted event that is called
// more frequently than other events that might
// also give us a chance to abort.
//
Abort = m_bAborted;
}

/// <summary>
/// 刻录结束
/// </summary>
/// <param name="StatusCode"></param>
private void m_drive_OnDoneBurn(ref NERO_BURN_ERROR StatusCode)
{
// When burning is over, make sure to unsubscribe from all
// events.
//
SubscribeToEvents(false);

// Show the appropriate message for success and failure.
//
if (StatusCode == NERO_BURN_ERROR.NERO_BURN_OK)
{
//MessageBox.Show(this, "Burn process completed successfully!");
BrushSuccess("刻录完成");
}
else
{
//MessageBox.Show(this, "Burn process failed!\n" + StatusCode.ToString());
XLogManager.LogError(StatusCode.ToString());
BrushError(new Exception("刻录失败!\n" + StatusCode.ToString()));
}

this.IsCancle = false;
}

/// <summary>
/// 任务进度
/// </summary>
/// <param name="ProgressInPercent"></param>
/// <param name="Abort"></param>
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_bAborted;
if (ProgressInPercent <= 0)
return;

if (this.ShowBurshProcess != null)
{
ShowBurshProcess(new  ProcessEntity(ProgressInPercent, string.Empty));
}
//c_Task.Value = ProgressInPercent;
//c_TaskPercent.Text = ProgressInPercent.ToString() + "%";
}

/// <summary>
/// 子任务进度
/// </summary>
/// <param name="ProgressInPercent"></param>
/// <param name="Abort"></param>
private void m_drive_OnSubTaskProgress(ref int ProgressInPercent, ref bool Abort)
{
// This event gives us the other task's progress.
//
Abort = m_bAborted;
if (this.SubShowBurshProcess != null)
{

SubShowBurshProcess(new  ProcessEntity(ProgressInPercent, string.Empty));
}
//c_SubTask.Value = ProgressInPercent;
//c_SubTaskPercent.Text = ProgressInPercent.ToString() + "%";
}

}

刻录管理类

/// <summary>
/// 刻录管理类
/// </summary>
public class BrushManagerHelper
{
private Nero m_nero;
private NeroDrives m_devices;

/// <summary>
/// 刻录进程
/// </summary>
private Thread BrushThread;

/// <summary>
/// 调用窗口
/// </summary>
private Form ParentFrm;

/// <summary>
/// 文件列表
/// </summary>
private IList<FileFolers> fileFolersList = null;
/// <summary>
/// 文件大小
/// </summary>
private long FileSize = 0;
/// <summary>
/// 刻录成功委托
/// </summary>
public event BrushSuccessDelegate BrushSuccess;
/// <summary>
/// 刻录失败委托
/// </summary>
public event BurshErrorDelegate BrushError;
/// <summary>
/// 显示进度委托
/// </summary>
public event ShowBrushProcessDelegate ShowBurshProcess;
/// <summary>
/// 委托返回光盘信息
/// </summary>
public event ShowDiscInfoDelegate ShowDisc;
/// <summary>
/// 显示进度
/// </summary>
public event ShowBrushLogLineDelegate ShowLogLine;
/// <summary>
/// 显示子进度
/// </summary>
public event ShowBrushProcessDelegate SubShowBurshProcess;
/// <summary>
/// 使用时间
/// </summary>
public event ShowTimeProcessDelegate ShowTimeProcess;
/// <summary>
/// 获取刻录速度
/// </summary>
public event GetSpeedEntityCollectionDelegate ShowSpeedCollect;

public BrushManagerHelper(Form frm)
{
m_nero = new NeroClass();
ParentFrm = frm;
fileFolersList = new List<FileFolers>();
}

/// <summary>
/// 获取所有刻录机信息
/// </summary>
/// <returns></returns>
public IList<CDDriveInfo> GetAllDriveInfo()
{

m_devices = m_nero.GetDrives(NERO_MEDIA_TYPE.NERO_MEDIA_CD);
IList<CDDriveInfo> list = new List<CDDriveInfo>();
for (int i = 0; i < m_devices.Count; i++)
{

NeroDrive drive = (NeroDrive)m_devices.Item(i);
string sDriveLetter = (drive.DriveLetter == "") ? "?" : drive.DriveLetter.ToUpper();
list.Add(new CDDriveInfo()
{
VolumeName = sDriveLetter + ": " + drive.DeviceName,
NeroDrive = drive
});
}
return list;
}

/// <summary>
/// 获取光盘信息
/// </summary>
/// <param name="driverInfo"></param>
public void GetDriveInfoSize(CDDriveInfo driverInfo)
{
if (driverInfo == null)
{
return;
}
DiscHelper disHelper = new DiscHelper(this.m_nero, driverInfo.NeroDrive);
disHelper.ShowDisc += disHelper_ShowDisc;
disHelper.GetDriveInfoSize();
}

#region 读写速度
/// <summary>
/// 获取光盘信息
/// </summary>
/// <param name="driverInfo"></param>
/// <param name="writed"></param>
public void GetSpeedCollect(CDDriveInfo driverInfo, bool writed)
{
if (driverInfo == null)
return;
SpeedHelper speedHelper = new SpeedHelper(driverInfo.NeroDrive, writed);
speedHelper.GetSpeedCollect += speedHelper_GetSpeedCollect;
speedHelper.GetSpeed();
}

/// <summary>
/// 获取读取速度
/// </summary>
/// <param name="driverInfo"></param>
/// <param name="pCDInfo"></param>
/// <returns></returns>
public SpeedEntityCollection GetReadSpeedCollection(CDDriveInfo driverInfo, INeroCDInfo pCDInfo)
{
if (driverInfo == null)
return null;
SpeedHelper speedHelper = new SpeedHelper(driverInfo.NeroDrive, true);
return speedHelper.GetReadSpeedCollection(pCDInfo);
}

/// <summary>
/// 获取写入速度
/// </summary>
/// <returns></returns>
public SpeedEntityCollection GetWriteSpeedCollection(CDDriveInfo driverInfo, INeroCDInfo pCDInfo)
{
if (driverInfo == null)
return null;
SpeedHelper speedHelper = new SpeedHelper(driverInfo.NeroDrive, true);
return speedHelper.GetWriteSpeedCollection(pCDInfo);
}

#endregion

/// <summary>
/// 刻录
/// </summary>
public void Brush(CDDriveInfo driverInfo, DiscInfoEntity DiscInfo)
{
StopThread();
BrushThread = new Thread(new ParameterizedThreadStart(BurshStart));
BrushThread.Start(new object[] { driverInfo, DiscInfo });
}

/// <summary>
/// 获取文件夹大小
/// </summary>
/// <param name="folderPath"></param>
/// <param name="size"></param>
private void GetFiloderSize(string folderPath, ref long size)
{
if (Directory.Exists(folderPath))
{
DirectoryInfo info = new DirectoryInfo(folderPath);
DirectoryInfo[] direArray = info.GetDirectories();
if (direArray != null)
{
foreach (DirectoryInfo item in direArray)
{
GetFiloderSize(item.FullName, ref size);
}
}

FileInfo[] fileArray = info.GetFiles();
if (fileArray != null)
{
foreach (FileInfo item in fileArray)
{
size += item.Length;
}
}
}
}

/// <summary>
/// 多线程刻录
/// </summary>
/// <param name="Array"></param>

private void BurshStart(object Array)
{
try
{
if (Array.GetType().Name == "Object[]")
{
object[] obj = Array as object[];
CDDriveInfo CDDriveInfo = obj[0] as CDDriveInfo;
DiscInfoEntity DiscInfo = obj[1] as DiscInfoEntity;

if (CDDriveInfo == null)
{
throw new Exception("请选择刻录机");
}

if (DiscInfo == null)
{
throw new Exception("没有找到光盘信息");
}

NeroISOTrack isoTrack = CreateISOTrack();

isoTrack.BurnOptions = GetNeroBurnOptions();
AddFileFolerToISO(ref isoTrack);

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

BrushHelper helper = new BrushHelper(this.m_nero, CDDriveInfo.NeroDrive);
helper.ShowTimeProcess += helper_ShowTimeProcess;
helper.ShowBurshProcess += helper_ShowBurshProcess;
helper.ShowLogLine += helper_ShowLogLine;
helper.SubShowBurshProcess += helper_SubShowBurshProcess;
helper.BrushSuccess += helper_BrushSuccess;
helper.BrushError += helper_BrushError;

helper.Brush(isoTrack, null, null
, GetNeroFlages()
, GetWriteSpeedCollection(CDDriveInfo, DiscInfo.Cdinfo).SpeedEntity[0].m_iSpeed
, DiscInfo.Cdinfo.MediaType);
}

}
catch (Exception ex)
{
XInvoke(BrushError, ex);
StopThread();
}
}

/// <summary>
/// 停止线程
/// </summary>
private void StopThread()
{
if (BrushThread != null &&
(BrushThread.ThreadState == ThreadState.Running
|| BrushThread.ThreadState == ThreadState.WaitSleepJoin))
{
try
{
BrushThread.Abort();
}
catch (Exception ex)
{
XLogManager.LogError(ex);
}

}
}

/// <summary>
/// 获取文件大小
/// </summary>
/// <returns></returns>
public long GetFileSize()
{
FileSize = 0;
if (this.fileFolersList != null)
{
foreach (FileFolers item in this.fileFolersList)
{
if (item.FileType == FileType.Folder)
{
long temp = 0;
GetFiloderSize(item.FullPath, ref temp);
FileSize += temp;
}
if (item.FileType == FileType.File)
{
FileInfo fileInfo = new FileInfo(item.FullPath);
FileSize += fileInfo.Length;
}
}
}
return FileSize;
}

/// <summary>
/// 获取刻录
/// </summary>
/// <returns></returns>
private NERO_BURN_OPTIONS GetNeroBurnOptions()
{
NERO_BURN_OPTIONS options =
(NERO_BURN_OPTIONS)((uint)NERO_BURN_OPTIONS.NERO_BURN_OPTION_CREATE_ISO_FS
+ (uint)NERO_BURN_OPTIONS.NERO_BURN_OPTION_USE_JOLIET);
return options;
}

/// <summary>
/// 刻录形式
/// </summary>
/// <returns></returns>
private NERO_BURN_FLAGS GetNeroFlages()
{
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;
return flags;
}

#region ISO部分
/// <summary>
/// 添加文件到光盘
/// </summary>
/// <param name="sFile"></param>
/// <param name="isoTrack"></param>
private void AddFileToISO(string sFile, ref NeroISOTrack isoTrack)
{
// This is a file. Create a new NeroFile
// change its properties.
//
NeroFile file = new NeroFileClass();
file.SourceFilePath = sFile;
file.Name = Path.GetFileName(sFile);
file.EntryTime = Directory.GetLastWriteTime(sFile);

// In this implementation, specified files are added
// to the root of the disc only.
//
XInvoke(ShowBurshProcess, new ProcessEntity(0, string.Format("添加文件{0}到关盘", sFile)));
isoTrack.RootFolder.Files.Add(file);
}

/// <summary>
/// 添加文件到目录
/// </summary>
private void AddFileFolerToISO(ref NeroISOTrack isoTrack)
{

if (this.fileFolersList != null)
{
foreach (FileFolers item in this.fileFolersList)
{
if (item.FileType == FileType.Folder)
{
NeroFolder folder = isoTrack.RootFolder;
AddFolderRecursively(ref folder, item.FullPath);
}
if (item.FileType == FileType.File)
{
AddFileToISO(item.FullPath, ref isoTrack);
}
}
}
}

/// <summary>
/// 创建一个光盘
/// </summary>
/// <returns></returns>
private NeroISOTrack CreateISOTrack()
{
NeroISOTrack isoTrack = new NeroISOTrackClass();
return isoTrack;
}
#endregion

#region 文件文件夹

/// <summary>
/// 添加目录
/// </summary>
/// <param name="directioryPath"></param>
public void AddDirectory(string directioryPath)
{

if (!Directory.Exists(directioryPath))
{
return;
}

fileFolersList.Add(new FileFolers() { FileType = FileType.Folder, FullPath = directioryPath });
}

/// <summary>
/// 添加一个目录
/// </summary>
/// <param name="filePath"></param>
public void AddFile(string filePath)
{
if (!File.Exists(filePath))
{
return;
}

fileFolersList.Add(new FileFolers() { FullPath = filePath, FileType = FileType.File });
}

/// <summary>
/// 这个函数是用于递归路径添加到提供的父NeroFolder
/// </summary>
/// <param name="folderParent"></param>
/// <param name="sPath"></param>
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)
{
AddFolderToFolder(sSubDirPath + "\\", ref folder);
}
}

string[] sFiles = Directory.GetFiles(sPath);
foreach (string sFile in sFiles)
{
AddFileToFolder(sFile, ref folder);
}
}

/// <summary>
/// 添加文件夹到关盘
/// </summary>
private void AddFolderToFolder(string sPath, ref NeroFolder folderParent)
{
XInvoke(ShowBurshProcess, new ProcessEntity(0, string.Format("添加文件假{0}到关盘", sPath)));
AddFolderRecursively(ref folderParent, sPath);
}

/// <summary>
/// 添加文件到目录
/// </summary>
/// <param name="sFile"></param>
/// <param name="folder"></param>
private void AddFileToFolder(string sFile, ref NeroFolder folder)
{
NeroFile file = new NeroFileClass();
file.SourceFilePath = sFile;
file.Name = Path.GetFileName(sFile);
file.EntryTime = Directory.GetLastWriteTime(sFile);
XInvoke(ShowBurshProcess, new ProcessEntity(0, string.Format("添加文件{0}到关盘", sFile)));
folder.Files.Add(file);
}
#endregion

#region 事件

/// <summary>
/// 刻录出错
/// </summary>
/// <param name="ex"></param>
void helper_BrushError(Exception ex)
{
XInvoke(BrushError, ex);
}

/// <summary>
/// 刻录成功后
/// </summary>
/// <param name="value"></param>
void helper_BrushSuccess(string value)
{
XInvoke(BrushSuccess, value);
}

/// <summary>
/// 子进度
/// </summary>
/// <param name="percentEvent"></param>
void helper_SubShowBurshProcess(ProcessEntity percentEvent)
{
XInvoke(SubShowBurshProcess, percentEvent);
}

/// <summary>
/// 显示日志记录
/// </summary>
/// <param name="value"></param>
void helper_ShowLogLine(string value)
{
XInvoke(ShowLogLine, value);
}

/// <summary>
/// 显示百分比进度
/// </summary>
/// <param name="percentEvent"></param>
void helper_ShowBurshProcess(ProcessEntity percentEvent)
{
XInvoke(ShowBurshProcess, percentEvent);
}

/// <summary>
/// 显示时间进度
/// </summary>
/// <param name="time"></param>
void helper_ShowTimeProcess(string time)
{
XInvoke(ShowTimeProcess, time);
}

/// <summary>
/// 显示可以刻录的速度
/// </summary>
/// <param name="collection"></param>
void speedHelper_GetSpeedCollect(SpeedEntityCollection collection)
{
XInvoke(this.ShowSpeedCollect, collection);
}

/// <summary>
/// 显示光盘信息
/// </summary>
/// <param name="disc"></param>
void disHelper_ShowDisc(DiscInfoEntity disc)
{
XInvoke(this.ShowDisc, disc);
}

/// <summary>
/// 调用事件
/// </summary>
/// <param name="delegateValue"></param>
/// <param name="args"></param>
private void XInvoke(Delegate delegateValue, params object[] args)
{
if (this.ParentFrm == null)
{
StopThread();
return;

}
if (this.ParentFrm != null && this.ParentFrm.IsDisposed)
{
StopThread();
return;
}
if (delegateValue != null)
{
this.ParentFrm.BeginInvoke(delegateValue, args);
Thread.Sleep(10);
}
}

#endregion
}

本机刻录前需要获取光盘信息,系统刻录是需要光盘的容量,大小类型等信息,采用多线程刻录,防止因为刻录卡死界面线程

下面的测试功能:



最后把我的代码分享出来:http://yunpan.cn/QiW6hcu9QwLfe 访问密码 4fad

没有找到博客园上传文件地方,就用网盘了.