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有我自己的一个简单的封装,帖出来给大家分享一下

项目结构

系统定义部分委托:

?





1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

/// <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);

获取光盘信息方法

?





1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

/// <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获取到的并不在我们常用的单位

光盘信息定义的实体类

?





1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

/// <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:获取刻录机的读写速度

?





1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

/// <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;

        }

读写速度的实体类

?





1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

/// <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;

    }

}

刻录类

?





1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

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() + "%";

    }

}

刻录管理类

?





1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

/// <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>

    /// 获取所有刻录机信息<br>        /// </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

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

C# 实现刻录光盘功能,布布扣,bubuko.com

时间： 2025-01-01 17:43:36

C# 实现刻录光盘功能的相关文章

win7自带刻录功能的使用方法

win7自带刻录功能用起来其实很方便. 弹出“刻录光盘”对话框的两种方法: 1.把一张空白光盘放入刻录机,打开“计算机”窗口,双击DVD RW 驱动器图标(或选中该图标右击点击“打开”),弹出“刻录光盘”对话框,选择刻录类型. 2.把一张空白光盘放入刻录机,把需要刻录的文件直接右击——>发送到DVD RW 驱动器,弹出“刻录光盘”对话框,选择刻录类型. 这里有两个刻录类型:一个是“类似于USB闪存驱动器”:另一个是“带有CD/DVD播放器”.选择“类似于USB闪存驱动器”, 将刻录一张可以随时保

【203】利用UltraISO制作和刻录光盘映像的方法

参考:利用UltraISO制作和刻录光盘映像的方法 1.利用UltraISO制作光盘映像 UltraISO下载地址 利用UltraISO制作光盘映像文件需要具备以下条件: 一.安装有光存储,也就是DVD-ROM/RW光驱或者CD-ROM/RW光驱: 二.硬盘有足够的空间来存放映像文件. 安装好UltraISO软件以后,把需要制作成映像的光盘放入光驱,然后打开“我的电脑”,在放入光盘的光驱上点右键,然后选择“UltraISO-制作光盘映像文件”,如图1: 之后会弹出“ISO 文件另存”窗口,选择好

采用c#实现功能1

看了好多c#的菜鸟教程不如自己开始动手打代码,最终实现了功能一,参考了网上的wordcount代码发现无论是c++还是c#大部分采用的是哈希表的方法实现的,本来还想仅用循环实现遍历句子中的所有字符,即发现"  "就total++,但是考虑到功能二的单词数变得很多,这样做时间相对来说会慢一点,因此选择了hash表来实现功能.因为仅是一个句子,所以只需要将句子中的空格split就可以了,但在解决过程中我碰到的最大问题是C:\Users\dell-pc\Desktop\wcc\wcc\Int

微信公众平台的最新功能详细介绍与使用技巧！

近日微信官方发布消息,微信公众平台的操作进行了又一次"感天动地"的更新 且听我一一道来 本次主要重要改(Geng)革(Xin)凸显在三个地方 改(Geng)革(Xin)一:图文模版的收藏与使用 这,真的是一个超级实用的功能呀,那么如何使用呢?在哪里找呢? 首先告诉大家,如何收藏图文模板 选中编辑区的部分或者全部素材,然后点击添加模版,图文模板即可收藏成功: 当然,你还可以从外部进行粘贴和复制内容到图文模版. 那么,在哪里找到我收藏的模版呢?? 嗯,就在添加图文模版的旁边啦! 同时,你还

最新版勤哲Excel服务器V2016.12.0.292无限用户支持手机APP,微信，网页等功能不绑定电脑，任意安装,支持后续升级

最新版勤哲Excel服务器V2016.12.0.292无限用户支持手机APP,微信,网页等功能不绑定电脑,任意安装,支持后续升级. 这个版本发布过之后,再发布新的版本需要到下个月的中下旬,老朋友可以使用本版本后面延续升级 目前有大约127家用户在用,没有修改过注册授权文件,系统非常成熟,推荐指数为五星,QQ:619920289 麦枫论坛http://www.mfsun.com 简介 EXCEL服务器作为一款客户化.综合性管理软件,它通过Excel就能构造出您自主的管理系统:同时,她也可将您公司现

微信JS-SDK实现上传图片功能

最近在项目开放中,有一个在微信WEB项目中上传图片的需求,一开始使用了传统的<input type="file">的方式去实现,但是后面发现在使用这种传统模式时会由于手机系统的差异而导致一系列的问题,后改用微信JSSDK的方式来实现. 总的来说,利用JSSDK来实现该功能一共分为四步. 1. 调用wx.config(),初始化jssdk的配置,并在jsApiList中配置上传图片需要的四个api('chooseImage','previewImage','uploadIma

019 添加分区功能 - bos

一.基础调整 1.删除subarea.jsp中新增窗口的分区编码一行 2.修改Subarea.hbm.xml,主键生成策略为uuid 二.easyUI - combobox下拉框的使用 1.静态页面编写(并不实用) <select class="easyui-combobox"> <option>小黑</option> <option>小白</option> <option>小红</option> &l

集成Android免费语音合成功能（在线、离线、离在线融合）

集成Android免费语音合成功能(在线.离线.离在线融合),有这一篇文章就够了(离线)集成Android免费语音合成功能(在线.离线.离在线融合),有这一篇文章就够了(离在线融合) 转眼间,大半年没写文章了,没什么理由,就是人变懒了.囧~ 看标题,其实大家都被骗了,有这一篇文章还不够,我其实是打算分3篇文章来写的,如果合在一章里面就太长了,不过现在这个标题党横行的网络世界,我也被污染了,哈.那么为什么要分3篇文章来讲呢?看标题也能猜到了,就是在线.离线.离在线融合这3种语音合成方式,我将分别使

跟陈湾来完善C++(2)， 添加属性功能

上面几篇文章中,我们添加了名称空间优化,添加事件功能.这些对我来说其实已经够了.但还可以加一个属性功能. 当我们在C++中更改一个属性时,平常都是Get函数加上Set函数,但是这样,没有直接写一个成员变量方便.例如: a.SetValue(a.GetValue() + 1); 没有 a.Value = a.Value + 1; 方便. 但是这种方便只有在调用有属性功能的对象时才能使用.在创建属性的时候我还是用老套路,写一个Get和Set函数,该干啥还是干啥.我的属性功能其实就是在类中添加一个共有