Adding Sound(or any) Cards to a combobox

using System;
using System.Collections.Generic;
using System.ComponentModel;
using Microsoft.DirectX.DirectSound;
 
public class AudioDevice
{
 
    public AudioDevice(string description, Guid uniqueIdentifier, string moduleName, Device device)
    {
        _description = description;
        _uniqueIdentifier = uniqueIdentifier;
        _moduleName = moduleName;
 
        if (device != null)
        {
            this._fivePointOne = device.SpeakerConfig.FivePointOne;
            this._geometryMax = device.SpeakerConfig.GeometryMax;
            this._geometryMin = device.SpeakerConfig.GeometryMin;
            this._geometryNarrow = device.SpeakerConfig.GeometryNarrow;
            this._geometryWide = device.SpeakerConfig.GeometryWide;
            this._headphone = device.SpeakerConfig.Headphone;
            this._mono = device.SpeakerConfig.Mono;
            this._quad = device.SpeakerConfig.Quad;
            this._sevenPointOne = device.SpeakerConfig.SevenPointOne;
            this._stereo = device.SpeakerConfig.Stereo;
            this._surround = device.SpeakerConfig.Surround;
 
            this._certified = device.Caps.Certified;
            this._continuousRate = device.Caps.ContinuousRate;
            this._emulateDriver = device.Caps.EmulateDriver;
            this._freeHardware3DAllBuffers = device.Caps.FreeHardware3DAllBuffers;
            this._freeHardware3DStaticBuffers = device.Caps.FreeHardware3DStaticBuffers;
            this._freeHardware3DStreamingBuffers = device.Caps.FreeHardware3DStreamingBuffers;
            this._freeHardwareMemoryBytes = device.Caps.FreeHardwareMemoryBytes;
            this._freeHardwareMixingAllBuffers = device.Caps.FreeHardwareMixingAllBuffers;
            this._freeHardwareMixingStaticBuffers = device.Caps.FreeHardwareMixingStaticBuffers;
            this._freeHardwareMixingStreamingBuffers = device.Caps.FreeHardwareMixingStreamingBuffers;
            this._maxContigousFreeHardwareMemoryBytes = device.Caps.MaxContigousFreeHardwareMemoryBytes;
            this._maxHardware3DAllBuffers = device.Caps.MaxHardware3DAllBuffers;
            this._maxHardware3DStaticBuffers = device.Caps.MaxHardware3DStaticBuffers;
            this._maxHardware3DStreamingBuffers = device.Caps.MaxHardware3DStreamingBuffers;
            this._maxHardwareMixingAllBuffers = device.Caps.MaxHardwareMixingAllBuffers;
            this._maxHardwareMixingStaticBuffers = device.Caps.MaxHardwareMixingStaticBuffers;
            this._maxHardwareMixingStreamingBuffers = device.Caps.MaxHardwareMixingStreamingBuffers;
            this._maxSecondarySampleRate = device.Caps.MaxSecondarySampleRate;
            this._minSecondarySampleRate = device.Caps.MinSecondarySampleRate;
            this._playCpuOverheadSoftwareBuffers = device.Caps.PlayCpuOverheadSoftwareBuffers;
            this._primary16Bit = device.Caps.Primary16Bit;
            this._primary8Bit = device.Caps.Primary8Bit;
            this._primaryBuffers = device.Caps.PrimaryBuffers;
            this._primaryMono = device.Caps.PrimaryMono;
            this._primaryStereo = device.Caps.PrimaryStereo;
            this._secondary16Bit = device.Caps.Secondary16Bit;
            this._secondary8Bit = device.Caps.Secondary8Bit;
            this._secondaryMono = device.Caps.SecondaryMono;
            this._secondaryStereo = device.Caps.SecondaryStereo;
            this._totalHardwareMemoryBytes = device.Caps.TotalHardwareMemoryBytes;
            this._unlockTransferRateHardwareBuffers = device.Caps.UnlockTransferRateHardwareBuffers;
 
        }
    }
 
 
    public static List<AudioDevice> GetDeviceList()
    {
        DevicesCollection deviceList = new DevicesCollection();
 
        List<AudioDevice> list = new List<AudioDevice>();
 
        foreach (DeviceInformation deviceInfo in deviceList)
        {
            Device device = (deviceInfo.DriverGuid != Guid.Empty) ?
                new Device(deviceInfo.DriverGuid) : null;
 
            AudioDevice audioDevice = new AudioDevice(deviceInfo.Description, deviceInfo.DriverGuid, 
                deviceInfo.ModuleName, device);
 
            list.Add(audioDevice);
        }
 
        return list;
    }
 
 
    private string _description;
    public string Description
    {
        get { return _description; }
    }
 
    private Guid _uniqueIdentifier;
    public Guid UniqueIdentifier
    {
        get { return _uniqueIdentifier; }
    }
 
    private string _moduleName;
    public string ModuleName
    {
        get { return _moduleName; }
    }
 
    private bool _fivePointOne;
 
    public bool FivePointOne
    {
        get { return _fivePointOne; }
    }
 
    private bool _geometryMax;
 
    public bool GeometryMax
    {
        get { return _geometryMax; }
    }
 
    private bool _geometryMin;
 
    public bool GeometryMin
    {
        get { return _geometryMin; }
    }
 
    private bool _geometryNarrow;
 
    public bool GeometryNarrow
    {
        get { return _geometryNarrow; }
    }
 
    private bool _geometryWide;
 
    public bool GeometryWide
    {
        get { return _geometryWide; }
    }
 
    private bool _headphone;
 
    public bool Headphone
    {
        get { return _headphone; }
    }
 
    private bool _mono;
 
    public bool Mono
    {
        get { return _mono; }
    }
 
    private bool _quad;
 
    public bool Quad
    {
        get { return _quad; }
    }
 
    private bool _sevenPointOne;
 
    public bool SevenPointOne
    {
        get { return _fivePointOne; }
    }
 
    private bool _stereo;
 
    public bool Stereo
    {
        get { return _stereo; }
    }
 
    private bool _surround;
 
    public bool Surround
    {
        get { return _surround; }
    }
 
    private bool _certified;
 
    /// <summary>
    /// Retrieves whether the driver is a certified Windows Driver Module (WDM) device driver.
    /// </summary>
    public bool Certified
    {
        get { return _certified; }
    }
 
    private bool _continuousRate;
 
    /// <summary>
    /// Retrieves whether the Device object supports all sample rates between the 
    /// <seealso cref="MinSecondarySampleRate"/> and <seealso cref="MaxSecondarySampleRate"/> values.
    /// </summary>
    public bool ContinuousRate
    {
        get { return _continuousRate; }
    }
 
    private bool _emulateDriver;
 
    /// <summary>
    /// Retrieves whether the Device object does not have a Microsoft DirectSound driver installed.
    /// </summary>
    public bool EmulateDriver
    {
        get { return _emulateDriver; }
    }
 
    private int _freeHardware3DAllBuffers;
 
    /// <summary>
    /// Retrieves the number of unallocated 3-D buffers.
    /// </summary>
    public int FreeHardware3DAllBuffers
    {
        get { return _freeHardware3DAllBuffers; }
    }
 
    private int _freeHardware3DStaticBuffers;
 
    /// <summary>
    /// Retrieves the number of unallocated static 3-D buffers.
    /// </summary>
    public int FreeHardware3DStaticBuffers
    {
        get { return _freeHardware3DStaticBuffers; }
    }
 
    private int _freeHardware3DStreamingBuffers;
 
    /// <summary>
    /// Retrieves the number of unallocated streaming 3-D buffers.
    /// </summary>
    public int FreeHardware3DStreamingBuffers
    {
        get { return _freeHardware3DStreamingBuffers; }
    }
 
    private int _freeHardwareMemoryBytes;
 
    /// <summary>
    /// Retrieves the size, in bytes, of the free memory on the sound card.
    /// </summary>
    public int FreeHardwareMemoryBytes
    {
        get { return _freeHardwareMemoryBytes; }
    }
 
    private int _freeHardwareMixingAllBuffers;
 
    /// <summary>
    /// Retrieves the number of unallocated buffers.
    /// </summary>
    public int FreeHardwareMixingAllBuffers
    {
        get { return _freeHardwareMixingAllBuffers; }
    }
 
    private int _freeHardwareMixingStaticBuffers;
 
    /// <summary>
    /// Retrieves the number of unallocated static buffers.
    /// </summary>
    public int FreeHardwareMixingStaticBuffers
    {
        get { return _freeHardwareMixingStaticBuffers; }
    }
 
    private int _freeHardwareMixingStreamingBuffers;
 
    /// <summary>
    /// Retrieves the number of unallocated streaming buffers.
    /// </summary>
    public int FreeHardwareMixingStreamingBuffers
    {
        get { return _freeHardwareMixingStreamingBuffers; }
    }
 
    private int _maxContigousFreeHardwareMemoryBytes;
 
    /// <summary>
    /// Retrieves the size, in bytes, of the largest contiguous block of free memory on the sound card.
    /// </summary>
    public int MaxContigousFreeHardwareMemoryBytes
    {
        get { return _maxContigousFreeHardwareMemoryBytes; }
    }
 
    private int _maxHardware3DAllBuffers;
 
    /// <summary>
    /// Retrieves the maximum number of 3-D buffers.
    /// </summary>
    public int MaxHardware3DAllBuffers
    {
        get { return _maxHardware3DAllBuffers; }
    }
 
    private int _maxHardware3DStaticBuffers;
 
    /// <summary>
    /// Retrieves the maximum number of static 3-D buffers.
    /// </summary>
    public int MaxHardware3DStaticBuffers
    {
        get { return _maxHardware3DStaticBuffers; }
    }
 
    private int _maxHardware3DStreamingBuffers;
 
    /// <summary>
    /// Retrieves the maximum number of streaming 3-D buffers.
    /// </summary>
    public int MaxHardware3DStreamingBuffers
    {
        get { return _maxHardware3DStreamingBuffers; }
        set { _maxHardware3DStreamingBuffers = value; }
    }
 
    private int _maxHardwareMixingAllBuffers;
 
    /// <summary>
    /// Retrieves the number of buffers that can be mixed in hardware.
    /// </summary>
    public int MaxHardwareMixingAllBuffers
    {
        get { return _maxHardwareMixingAllBuffers; }
    }
 
    private int _maxHardwareMixingStaticBuffers;
 
    /// <summary>
    /// Retrieves the maximum number of static buffers.
    /// </summary>
    public int MaxHardwareMixingStaticBuffers
    {
        get { return _maxHardwareMixingStaticBuffers; }
        set { _maxHardwareMixingStaticBuffers = value; }
    }
 
    private int _maxHardwareMixingStreamingBuffers;
 
    /// <summary>
    /// Retrieves the maximum number of streaming sound buffers.
    /// </summary>
    public int MaxHardwareMixingStreamingBuffers
    {
        get { return _maxHardwareMixingStreamingBuffers; }
    }
 
    private int _maxSecondarySampleRate;
 
    /// <summary>
    /// Retrieves the maximum sample rate specifications that are supported by this Device 
    /// object's hardware SecondaryBuffer objects.
    /// </summary>
    public int MaxSecondarySampleRate
    {
        get { return _maxSecondarySampleRate; }
    }
 
    private int _minSecondarySampleRate;
 
    /// <summary>
    /// Retrieves the minimum sample rate specifications that are supported by this Device 
    /// object's hardware SecondaryBuffer objects.
    /// </summary>
    public int MinSecondarySampleRate
    {
        get { return _minSecondarySampleRate; }
        set { _minSecondarySampleRate = value; }
    }
 
    private int _playCpuOverheadSoftwareBuffers;
 
    /// <summary>
    /// Retrieves the processing overhead, as a percentage of main processor cycles, needed
    /// to mix software buffers.
    /// </summary>
    public int PlayCpuOverheadSoftwareBuffers
    {
        get { return _playCpuOverheadSoftwareBuffers; }
    }
 
    private bool _primary16Bit;
 
    /// <summary>
    /// Retrieves whether the Device object supports a primary buffer with 16-bit samples.
    /// </summary>
    public bool Primary16Bit
    {
        get { return _primary16Bit; }
    }
 
    private bool _primary8Bit;
 
    /// <summary>
    /// Retrieves whether the Device object supports primary buffers with 8-bit samples.
    /// </summary>
    public bool Primary8Bit
    {
        get { return _primary8Bit; }
    }
 
    private int _primaryBuffers;
 
    /// <summary>
    /// Retrieves the number of primary buffers supported.
    /// </summary>
    public int PrimaryBuffers
    {
        get { return _primaryBuffers; }
    }
 
    private bool _primaryMono;
 
    /// <summary>
    /// Retrieves whether the Device object supports monophonic primary buffers.
    /// </summary>
    public bool PrimaryMono
    {
        get { return _primaryMono; }
    }
 
    private bool _primaryStereo;
 
    /// <summary>
    /// Retrieves whether the Device object supports stereo primary buffers.
    /// </summary>
    public bool PrimaryStereo
    {
        get { return _primaryStereo; }
    }
 
    private bool _secondary16Bit;
 
    /// <summary>
    /// Retrieves whether the Device object supports hardware-mixed SecondaryBuffer objects
    /// with 16-bit samples.
    /// </summary>
    public bool Secondary16Bit
    {
        get { return _secondary16Bit; }
    }
 
    private bool _secondary8Bit;
 
    /// <summary>
    /// Retrieves whether the Device object supports hardware-mixed SecondaryBuffer objects 
    /// with 8-bit samples.
    /// </summary>
    public bool Secondary8Bit
    {
        get { return _secondary8Bit; }
    }
 
    private bool _secondaryMono;
 
    /// <summary>
    /// Retrieves whether the Device object supports hardware-mixed monophonic SecondaryBuffer 
    /// objects.
    /// </summary>
    public bool SecondaryMono
    {
        get { return _secondaryMono; }
    }
 
    private bool _secondaryStereo;
 
    /// <summary>
    /// Retrieves whether the Device object supports hardware-mixed stereo SecondaryBuffer objects.
    /// </summary>
    public bool SecondaryStereo
    {
        get { return _secondaryStereo; }
    }
 
    private int _totalHardwareMemoryBytes;
 
    /// <summary>
    /// Retrieves the size, in bytes, of the amount of memory on the sound card that stores static 
    /// sound buffers.
    /// </summary>
    public int TotalHardwareMemoryBytes
    {
        get { return _totalHardwareMemoryBytes; }
    }
 
    private int _unlockTransferRateHardwareBuffers;
 
    /// <summary>
    /// Retrieves the rate, in kilobytes per second, at which data can be transferred to hardware 
    /// static sound buffers.
    /// </summary>
    public int UnlockTransferRateHardwareBuffers
    {
        get { return _unlockTransferRateHardwareBuffers; }
    }
 
    public override string ToString()
    {
        return this.Description;
    }
}

                                              

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: