No longer carry reference to MsftDiscRecorder2.

awalsh128 · awalsh128 · commit daa28a583e34 · 2012-09-18T10:01:25.000-07:00
Instantiate recorder as needed and release resource inside same method
call instead of carrying the reference around and requiring a Dispose
call on the object.
diff --git a/DiscRecorder.cs b/DiscRecorder.cs
@@ -6,14 +6,14 @@
 
 namespace IMAPI2
 {
-    public class DiscRecorder : IDisposable
+    public class DiscRecorder
     {
-        private MsftDiscRecorder2 _internal;
+        private string _internalUniqueId;
         private ReadOnlyCollection<MediaProfile> _profiles;
 
-        internal MsftDiscRecorder2 Internal
+        internal string InternalUniqueId
         {
-            get { return _internal; }
+            get { return _internalUniqueId; }
         }
         public ReadOnlyCollection<MediaProfile> SupportedProfiles
         {
@@ -22,16 +22,25 @@ public ReadOnlyCollection<MediaProfile> SupportedProfiles
 
         internal DiscRecorder(string uniqueId)
         {
-            List<MediaProfile> profiles;
-            _internal = new MsftDiscRecorder2();
-            _internal.InitializeDiscRecorder(uniqueId);
-
-            profiles = new List<MediaProfile>();
-            foreach (IMAPI_PROFILE_TYPE item in _internal.SupportedProfiles)
+            _internalUniqueId = uniqueId;
+            MsftDiscRecorder2 recorder = null;
+            try
+            {
+                List<MediaProfile> profiles;
+                recorder = new MsftDiscRecorder2();
+                recorder.InitializeDiscRecorder(uniqueId);
+
+                profiles = new List<MediaProfile>();
+                foreach (IMAPI_PROFILE_TYPE item in recorder.SupportedProfiles)
+                {
+                    profiles.Add((MediaProfile)item);
+                }
+                _profiles = profiles.AsReadOnly();
+            }
+            finally
             {
-                profiles.Add((MediaProfile)item);
+                if (recorder != null) Marshal.ReleaseComObject(recorder);
             }
-            _profiles = profiles.AsReadOnly();
         }
 
         private static string _GetProfileText(IMAPI_PROFILE_TYPE profileType)
@@ -103,9 +112,5 @@ private static string _GetProfileText(IMAPI_PROFILE_TYPE profileType)
             }
         }
 
-        void IDisposable.Dispose()
-        {
-            if (_internal != null) Marshal.ReleaseComObject(_internal);
-        }
     }
 }
diff --git a/IMAPI2.csproj b/IMAPI2.csproj
@@ -49,7 +49,7 @@
     <CodeAnalysisIgnoreBuiltInRules>true</CodeAnalysisIgnoreBuiltInRules>
   </PropertyGroup>
   <PropertyGroup>
-    <SignAssembly>true</SignAssembly>
+    <SignAssembly>false</SignAssembly>
   </PropertyGroup>
   <PropertyGroup>
     <AssemblyOriginatorKeyFile>VibrantStrongName.snk</AssemblyOriginatorKeyFile>
@@ -66,6 +66,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="BurnVerificationLevel.cs" />
+    <Compile Include="RecorderNotFoundException.cs" />
     <Compile Include="FormatDataWriteAction.cs" />
     <Compile Include="FormatWriteUpdateEventArgs.cs" />
     <Compile Include="ImageUpdateEventArgs.cs" />
@@ -85,9 +86,6 @@
     <Compile Include="ReadOnlySelectableCollection.cs" />
     <Compile Include="MediaProfile.cs" />
   </ItemGroup>
-  <ItemGroup>
-    <None Include="VibrantStrongName.snk" />
-  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/IMAPI2.suo b/IMAPI2.suo
diff --git a/IMAPI2.v11.suo b/IMAPI2.v11.suo
diff --git a/ImageMaster.cs b/ImageMaster.cs
@@ -14,11 +14,11 @@ namespace IMAPI2
     public class ImageMaster : IDisposable
     {
         private const string ClientName = "IMAPI2 Wrapper";
-
+        
         private ReadOnlySelectableCollection<DiscRecorder> _recorders;
         private bool _isWriting;
         private long _mediaCapacity;
-        private bool _mediaLoaded;        
+        private bool _mediaLoaded;
         private PhysicalMedia _media;
         private ReadOnlyCollection<MediaState> _mediaStates;
         private List<IMediaNode> _nodes;
@@ -60,11 +60,11 @@ public string VolumeLabel
         }
 
         public ImageMaster()
-        {
-            List<DiscRecorder> recorders = new List<DiscRecorder>();            
+        {            
+            List<DiscRecorder> recorders = new List<DiscRecorder>();
             _media = PhysicalMedia.Unknown;
             _nodes = new List<IMediaNode>();
-            _mediaStates = new ReadOnlyCollection<MediaState>(new List<MediaState> {MediaState.Unknown});
+            _mediaStates = new ReadOnlyCollection<MediaState>(new List<MediaState> { MediaState.Unknown });
 
             MsftDiscMaster2 discMaster = null;
             try
@@ -163,11 +163,13 @@ public void FormatMedia(bool quick, bool eject)
             if (!_mediaLoaded)
                 throw new InvalidOperationException("LoadMedia must be called first.");
 
-            IDiscRecorder2 recorder = _recorders.SelectedItem.Internal;
+            MsftDiscRecorder2 recorder = null;
             MsftDiscFormat2Erase discFormatErase = null;
 
             try
             {
+                recorder = new MsftDiscRecorder2();
+                recorder.InitializeDiscRecorder(_recorders.SelectedItem.InternalUniqueId);
                 discFormatErase = new MsftDiscFormat2Erase
                 {
                     Recorder = recorder,
@@ -183,6 +185,7 @@ public void FormatMedia(bool quick, bool eject)
             finally
             {
                 if (discFormatErase != null) Marshal.ReleaseComObject(discFormatErase);
+                if (recorder != null) Marshal.ReleaseComObject(recorder);
             }
         }
 
@@ -196,15 +199,14 @@ public void LoadMedia()
             if (_recorders.SelectedIndex == -1)
                 throw new InvalidOperationException("No DiscRecorder selected on the DiscRecorders list.");
 
-            MsftDiscRecorder2 recorder = _recorders.SelectedItem.Internal;
+            MsftDiscRecorder2 recorder = null;
             MsftFileSystemImage image = null;
             MsftDiscFormat2Data format = null;
 
             try
             {
-                //
-                // Create and initialize the IDiscFormat2Data
-                //
+                recorder = new MsftDiscRecorder2();
+                recorder.InitializeDiscRecorder(_recorders.SelectedItem.InternalUniqueId);
                 format = new MsftDiscFormat2Data();
                 if (!format.IsCurrentMediaSupported(recorder))
                     throw new MediaNotSupportedException("There is no media in the device.");
@@ -214,7 +216,7 @@ public void LoadMedia()
                 //
                 format.Recorder = recorder;
                 _media = (PhysicalMedia)format.CurrentPhysicalMediaType;
-                                
+
                 mediaStateFlags = (long)format.CurrentMediaStatus;
                 foreach (MediaState state in Enum.GetValues(typeof(MediaState)))
                 {
@@ -229,7 +231,7 @@ public void LoadMedia()
                 //
                 // Create a file system and select the media type
                 //
-                image = new MsftFileSystemImage();                
+                image = new MsftFileSystemImage();
                 image.ChooseImageDefaultsForMediaType((IMAPI_MEDIA_PHYSICAL_TYPE)_media);
 
                 //
@@ -246,8 +248,9 @@ public void LoadMedia()
             }
             finally
             {
-                if (format != null) Marshal.ReleaseComObject(format);
                 if (image != null) Marshal.ReleaseComObject(image);
+                if (format != null) Marshal.ReleaseComObject(format);
+                if (recorder != null) Marshal.ReleaseComObject(recorder);
             }
         }
 
@@ -256,14 +259,13 @@ public void LoadRecorder()
             if (_recorders.SelectedIndex == -1)
                 throw new InvalidOperationException("No DiscRecorder selected from the DiscRecorders list.");
 
-            var recorder = _recorders.SelectedItem.Internal;
-
-            //
-            // Verify recorder is supported
-            //
+            MsftDiscRecorder2 recorder = null;
             IDiscFormat2Data discFormatData = null;
             try
             {
+                recorder = new MsftDiscRecorder2();
+                recorder.InitializeDiscRecorder(_recorders.SelectedItem.InternalUniqueId);
+
                 discFormatData = new MsftDiscFormat2Data();
                 switch (discFormatData.IsRecorderSupported(recorder))
                 {
@@ -277,10 +279,8 @@ public void LoadRecorder()
             }
             finally
             {
-                if (discFormatData != null)
-                {
-                    Marshal.ReleaseComObject(discFormatData);
-                }
+                if (discFormatData != null) Marshal.ReleaseComObject(discFormatData);
+                if (recorder != null) Marshal.ReleaseComObject(recorder);
             }
         }
 
@@ -294,7 +294,8 @@ public void WriteImage(BurnVerificationLevel verification, bool finalize, bool e
 
             try
             {
-                recorder = _recorders.SelectedItem.Internal;
+                recorder = new MsftDiscRecorder2();
+                recorder.InitializeDiscRecorder(_recorders.SelectedItem.InternalUniqueId);
 
                 discFormatData = new MsftDiscFormat2Data
                     {
@@ -333,22 +334,18 @@ public void WriteImage(BurnVerificationLevel verification, bool finalize, bool e
                 }
                 finally
                 {
-                    if (fileSystem != null)
-                    {
-                        Marshal.FinalReleaseComObject(fileSystem);
-                    }
+                    if (fileSystem != null) Marshal.FinalReleaseComObject(fileSystem);                    
                 }
 
                 discFormatData.Update -= _discFormatWrite_Update;
 
-                if (eject)
-                    recorder.EjectMedia();
+                if (eject) recorder.EjectMedia();
             }
             finally
             {
-                if (recorder != null) Marshal.ReleaseComObject(recorder);
-                if (discFormatData != null) Marshal.ReleaseComObject(discFormatData);
                 _isWriting = false;
+                if (discFormatData != null) Marshal.ReleaseComObject(discFormatData);
+                if (recorder != null) Marshal.ReleaseComObject(recorder);                
             }
         }
 
@@ -371,7 +368,7 @@ void IDisposable.Dispose()
             if ((_writerThread != null) && (_writerThread.IsAlive)) _writerThread.Join();
             foreach (DiscRecorder recorder in _recorders)
             {
-                Marshal.ReleaseComObject(recorder.Internal);
+                Marshal.ReleaseComObject(recorder.InternalUniqueId);
             }
         }
     }
diff --git a/RecorderNotFoundException.cs b/RecorderNotFoundException.cs
@@ -0,0 +1,15 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace IMAPI2
+{
+    public class RecorderNotFoundException : RecorderNotSupportedException
+    {
+        public RecorderNotFoundException(string message)
+            : base(message)
+        {            
+        }
+    }
+}
diff --git a/RecorderNotSupportedException.cs b/RecorderNotSupportedException.cs
@@ -5,7 +5,7 @@
 
 namespace IMAPI2
 {
-    class RecorderNotSupportedException : NotSupportedException
+    public class RecorderNotSupportedException : NotSupportedException
     {
         public RecorderNotSupportedException(string message)
             : base(message)

Original file line number	Diff line number	Diff line change
`@@ -6,14 +6,14 @@`
`6`	`6`
`7`	`7`	`namespace IMAPI2`
`8`	`8`	`{`
`9`		`- public class DiscRecorder : IDisposable`
	`9`	`+ public class DiscRecorder`
`10`	`10`	`{`
`11`		`- private MsftDiscRecorder2 _internal;`
	`11`	`+ private string _internalUniqueId;`
`12`	`12`	`private ReadOnlyCollection<MediaProfile> _profiles;`
`13`	`13`
`14`		`- internal MsftDiscRecorder2 Internal`
	`14`	`+ internal string InternalUniqueId`
`15`	`15`	`{`
`16`		`- get { return _internal; }`
	`16`	`+ get { return _internalUniqueId; }`
`17`	`17`	`}`
`18`	`18`	`public ReadOnlyCollection<MediaProfile> SupportedProfiles`
`19`	`19`	`{`
`@@ -22,16 +22,25 @@ public ReadOnlyCollection<MediaProfile> SupportedProfiles`
`22`	`22`
`23`	`23`	`internal DiscRecorder(string uniqueId)`
`24`	`24`	`{`
`25`		`- List<MediaProfile> profiles;`
`26`		`- _internal = new MsftDiscRecorder2();`
`27`		`- _internal.InitializeDiscRecorder(uniqueId);`
`28`		`-`
`29`		`- profiles = new List<MediaProfile>();`
`30`		`- foreach (IMAPI_PROFILE_TYPE item in _internal.SupportedProfiles)`
	`25`	`+ _internalUniqueId = uniqueId;`
	`26`	`+ MsftDiscRecorder2 recorder = null;`
	`27`	`+ try`
	`28`	`+ {`
	`29`	`+ List<MediaProfile> profiles;`
	`30`	`+ recorder = new MsftDiscRecorder2();`
	`31`	`+ recorder.InitializeDiscRecorder(uniqueId);`
	`32`	`+`
	`33`	`+ profiles = new List<MediaProfile>();`
	`34`	`+ foreach (IMAPI_PROFILE_TYPE item in recorder.SupportedProfiles)`
	`35`	`+ {`
	`36`	`+ profiles.Add((MediaProfile)item);`
	`37`	`+ }`
	`38`	`+ _profiles = profiles.AsReadOnly();`
	`39`	`+ }`
	`40`	`+ finally`
`31`	`41`	`{`
`32`		`- profiles.Add((MediaProfile)item);`
	`42`	`+ if (recorder != null) Marshal.ReleaseComObject(recorder);`
`33`	`43`	`}`
`34`		`- _profiles = profiles.AsReadOnly();`
`35`	`44`	`}`
`36`	`45`
`37`	`46`	`private static string _GetProfileText(IMAPI_PROFILE_TYPE profileType)`
`@@ -103,9 +112,5 @@ private static string _GetProfileText(IMAPI_PROFILE_TYPE profileType)`
`103`	`112`	`}`
`104`	`113`	`}`
`105`	`114`
`106`		`- void IDisposable.Dispose()`
`107`		`- {`
`108`		`- if (_internal != null) Marshal.ReleaseComObject(_internal);`
`109`		`- }`
`110`	`115`	`}`
`111`	`116`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,11 +14,11 @@ namespace IMAPI2`
`14`	`14`	`public class ImageMaster : IDisposable`
`15`	`15`	`{`
`16`	`16`	`private const string ClientName = "IMAPI2 Wrapper";`
`17`		`-`
	`17`	`+`
`18`	`18`	`private ReadOnlySelectableCollection<DiscRecorder> _recorders;`
`19`	`19`	`private bool _isWriting;`
`20`	`20`	`private long _mediaCapacity;`
`21`		`- private bool _mediaLoaded;`
	`21`	`+ private bool _mediaLoaded;`
`22`	`22`	`private PhysicalMedia _media;`
`23`	`23`	`private ReadOnlyCollection<MediaState> _mediaStates;`
`24`	`24`	`private List<IMediaNode> _nodes;`
`@@ -60,11 +60,11 @@ public string VolumeLabel`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`public ImageMaster()`
`63`		`- {`
`64`		`- List<DiscRecorder> recorders = new List<DiscRecorder>();`
	`63`	`+ {`
	`64`	`+ List<DiscRecorder> recorders = new List<DiscRecorder>();`
`65`	`65`	`_media = PhysicalMedia.Unknown;`
`66`	`66`	`_nodes = new List<IMediaNode>();`
`67`		`- _mediaStates = new ReadOnlyCollection<MediaState>(new List<MediaState> {MediaState.Unknown});`
	`67`	`+ _mediaStates = new ReadOnlyCollection<MediaState>(new List<MediaState> { MediaState.Unknown });`
`68`	`68`
`69`	`69`	`MsftDiscMaster2 discMaster = null;`
`70`	`70`	`try`
`@@ -163,11 +163,13 @@ public void FormatMedia(bool quick, bool eject)`
`163`	`163`	`if (!_mediaLoaded)`
`164`	`164`	`throw new InvalidOperationException("LoadMedia must be called first.");`
`165`	`165`
`166`		`- IDiscRecorder2 recorder = _recorders.SelectedItem.Internal;`
	`166`	`+ MsftDiscRecorder2 recorder = null;`
`167`	`167`	`MsftDiscFormat2Erase discFormatErase = null;`
`168`	`168`
`169`	`169`	`try`
`170`	`170`	`{`
	`171`	`+ recorder = new MsftDiscRecorder2();`
	`172`	`+ recorder.InitializeDiscRecorder(_recorders.SelectedItem.InternalUniqueId);`
`171`	`173`	`discFormatErase = new MsftDiscFormat2Erase`
`172`	`174`	`{`
`173`	`175`	`Recorder = recorder,`
`@@ -183,6 +185,7 @@ public void FormatMedia(bool quick, bool eject)`
`183`	`185`	`finally`
`184`	`186`	`{`
`185`	`187`	`if (discFormatErase != null) Marshal.ReleaseComObject(discFormatErase);`
	`188`	`+ if (recorder != null) Marshal.ReleaseComObject(recorder);`
`186`	`189`	`}`
`187`	`190`	`}`
`188`	`191`
`@@ -196,15 +199,14 @@ public void LoadMedia()`
`196`	`199`	`if (_recorders.SelectedIndex == -1)`
`197`	`200`	`throw new InvalidOperationException("No DiscRecorder selected on the DiscRecorders list.");`
`198`	`201`
`199`		`- MsftDiscRecorder2 recorder = _recorders.SelectedItem.Internal;`
	`202`	`+ MsftDiscRecorder2 recorder = null;`
`200`	`203`	`MsftFileSystemImage image = null;`
`201`	`204`	`MsftDiscFormat2Data format = null;`
`202`	`205`
`203`	`206`	`try`
`204`	`207`	`{`
`205`		`- //`
`206`		`- // Create and initialize the IDiscFormat2Data`
`207`		`- //`
	`208`	`+ recorder = new MsftDiscRecorder2();`
	`209`	`+ recorder.InitializeDiscRecorder(_recorders.SelectedItem.InternalUniqueId);`
`208`	`210`	`format = new MsftDiscFormat2Data();`
`209`	`211`	`if (!format.IsCurrentMediaSupported(recorder))`
`210`	`212`	`throw new MediaNotSupportedException("There is no media in the device.");`
`@@ -214,7 +216,7 @@ public void LoadMedia()`
`214`	`216`	`//`
`215`	`217`	`format.Recorder = recorder;`
`216`	`218`	`_media = (PhysicalMedia)format.CurrentPhysicalMediaType;`
`217`		`-`
	`219`	`+`
`218`	`220`	`mediaStateFlags = (long)format.CurrentMediaStatus;`
`219`	`221`	`foreach (MediaState state in Enum.GetValues(typeof(MediaState)))`
`220`	`222`	`{`
`@@ -229,7 +231,7 @@ public void LoadMedia()`
`229`	`231`	`//`
`230`	`232`	`// Create a file system and select the media type`
`231`	`233`	`//`
`232`		`- image = new MsftFileSystemImage();`
	`234`	`+ image = new MsftFileSystemImage();`
`233`	`235`	`image.ChooseImageDefaultsForMediaType((IMAPI_MEDIA_PHYSICAL_TYPE)_media);`
`234`	`236`
`235`	`237`	`//`
`@@ -246,8 +248,9 @@ public void LoadMedia()`
`246`	`248`	`}`
`247`	`249`	`finally`
`248`	`250`	`{`
`249`		`- if (format != null) Marshal.ReleaseComObject(format);`
`250`	`251`	`if (image != null) Marshal.ReleaseComObject(image);`
	`252`	`+ if (format != null) Marshal.ReleaseComObject(format);`
	`253`	`+ if (recorder != null) Marshal.ReleaseComObject(recorder);`
`251`	`254`	`}`
`252`	`255`	`}`
`253`	`256`
`@@ -256,14 +259,13 @@ public void LoadRecorder()`
`256`	`259`	`if (_recorders.SelectedIndex == -1)`
`257`	`260`	`throw new InvalidOperationException("No DiscRecorder selected from the DiscRecorders list.");`
`258`	`261`
`259`		`- var recorder = _recorders.SelectedItem.Internal;`
`260`		`-`
`261`		`- //`
`262`		`- // Verify recorder is supported`
`263`		`- //`
	`262`	`+ MsftDiscRecorder2 recorder = null;`
`264`	`263`	`IDiscFormat2Data discFormatData = null;`
`265`	`264`	`try`
`266`	`265`	`{`
	`266`	`+ recorder = new MsftDiscRecorder2();`
	`267`	`+ recorder.InitializeDiscRecorder(_recorders.SelectedItem.InternalUniqueId);`
	`268`	`+`
`267`	`269`	`discFormatData = new MsftDiscFormat2Data();`
`268`	`270`	`switch (discFormatData.IsRecorderSupported(recorder))`
`269`	`271`	`{`
`@@ -277,10 +279,8 @@ public void LoadRecorder()`
`277`	`279`	`}`
`278`	`280`	`finally`
`279`	`281`	`{`
`280`		`- if (discFormatData != null)`
`281`		`- {`
`282`		`- Marshal.ReleaseComObject(discFormatData);`
`283`		`- }`
	`282`	`+ if (discFormatData != null) Marshal.ReleaseComObject(discFormatData);`
	`283`	`+ if (recorder != null) Marshal.ReleaseComObject(recorder);`
`284`	`284`	`}`
`285`	`285`	`}`
`286`	`286`
`@@ -294,7 +294,8 @@ public void WriteImage(BurnVerificationLevel verification, bool finalize, bool e`
`294`	`294`
`295`	`295`	`try`
`296`	`296`	`{`
`297`		`- recorder = _recorders.SelectedItem.Internal;`
	`297`	`+ recorder = new MsftDiscRecorder2();`
	`298`	`+ recorder.InitializeDiscRecorder(_recorders.SelectedItem.InternalUniqueId);`
`298`	`299`
`299`	`300`	`discFormatData = new MsftDiscFormat2Data`
`300`	`301`	`{`
`@@ -333,22 +334,18 @@ public void WriteImage(BurnVerificationLevel verification, bool finalize, bool e`
`333`	`334`	`}`
`334`	`335`	`finally`
`335`	`336`	`{`
`336`		`- if (fileSystem != null)`
`337`		`- {`
`338`		`- Marshal.FinalReleaseComObject(fileSystem);`
`339`		`- }`
	`337`	`+ if (fileSystem != null) Marshal.FinalReleaseComObject(fileSystem);`
`340`	`338`	`}`
`341`	`339`
`342`	`340`	`discFormatData.Update -= _discFormatWrite_Update;`
`343`	`341`
`344`		`- if (eject)`
`345`		`- recorder.EjectMedia();`
	`342`	`+ if (eject) recorder.EjectMedia();`
`346`	`343`	`}`
`347`	`344`	`finally`
`348`	`345`	`{`
`349`		`- if (recorder != null) Marshal.ReleaseComObject(recorder);`
`350`		`- if (discFormatData != null) Marshal.ReleaseComObject(discFormatData);`
`351`	`346`	`_isWriting = false;`
	`347`	`+ if (discFormatData != null) Marshal.ReleaseComObject(discFormatData);`
	`348`	`+ if (recorder != null) Marshal.ReleaseComObject(recorder);`
`352`	`349`	`}`
`353`	`350`	`}`
`354`	`351`
`@@ -371,7 +368,7 @@ void IDisposable.Dispose()`
`371`	`368`	`if ((_writerThread != null) && (_writerThread.IsAlive)) _writerThread.Join();`
`372`	`369`	`foreach (DiscRecorder recorder in _recorders)`
`373`	`370`	`{`
`374`		`- Marshal.ReleaseComObject(recorder.Internal);`
	`371`	`+ Marshal.ReleaseComObject(recorder.InternalUniqueId);`
`375`	`372`	`}`
`376`	`373`	`}`
`377`	`374`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`
`6`	`6`	`namespace IMAPI2`
`7`	`7`	`{`
`8`		`- class RecorderNotSupportedException : NotSupportedException`
	`8`	`+ public class RecorderNotSupportedException : NotSupportedException`
`9`	`9`	`{`
`10`	`10`	`public RecorderNotSupportedException(string message)`
`11`	`11`	`: base(message)`