C# 实现刻录光盘功能
生活随笔
收集整理的這篇文章主要介紹了
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#調用NeroSDK進行
參考資料: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!
" + StatusCode.ToString());
XLogManager.LogError(StatusCode.ToString());
BrushError(new Exception("刻錄失敗!
" + 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/QTeiwZifcurhr（提取碼：a7d8）
沒有找到博客園上傳文件地方,就用網盤了.
總結
以上是生活随笔為你收集整理的C# 实现刻录光盘功能的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 微信小程序 导航 4种页面跳转 详解
- 下一篇： 鸵鸟心态