1  using  System;

 2 

 3  namespace  ConsoleApplication

 4  {

 5       abstract   class  MyStream : IDisposable

 6      {

 7           public  MyStream()

 8          {

 9              m_unmanagedResource  =  Marshal.AllocCoTaskMem( 100 );

10              m_bitmap  =   new  Bitmap( 50 ,  50 );

11          }

12 

13           #region  IDisposable Members

14           void  IDisposable.Dispose()

15          {

16              Dispose( true );

17              GC.SuppressFinalize( this );

18          }

19 

20           protected   virtual   void  Dispose( bool  isDisposing)

21          {

22               if  ( ! m_disposed)

23              {

24                   if  (isDisposing)

25                  {

26                      m_bitmap.Dispose();

27                  }

28                  Marshal.FreeCoTaskMem(m_unmanagedResource);

29                  m_disposed  =   true ;

30              }

31          }

32          

33           public   void  Close()

34          {

35              ((IDisposable) this ).Dispose();

36          }

37 

38           ~ MyStream()

39          {

40              Dispose( false );            

41          }

42 

43           private  IntPtr m_unmanagedResource;      //  Unmanaged resource

44           private  Bitmap m_bitmap;                 //  IDisposable managed resources

45           private   bool  m_disposed;

46          

47           #endregion

48      }

49 

50       class  MyDerivedStream : MyStream

51      {

52           public  MyDerivedStream()

53          {

54              m_anotherMemory  =  Marshal.AllocCoTaskMem( 20 );

55              m_anotherImage  =   new  Bitmap( 24 ,  24 );

56          }

57 

58           protected   override   void  Dispose( bool  isDisposing)

59          {

60               if  ( ! m_disposed)

61              {

62                   if  (isDisposing)

63                  {

64                      m_anotherImage.Dispose();

65                  }

66 

67                  Marshal.FreeCoTaskMem(m_anotherMemory);

68                   base .Dispose(isDisposing);

69                  m_disposed  =   true ;

70              }

71          }

72 

73           public   static   void  Main( string [] args)

74          {

75              MyStream aStream  =   new  MyDerivedStream();

76 

77              aStream.Close();           //  Allowed

78               //  aStream.Dispose();     //  Cannot compile

79 

80              ((IDisposable)aStream).Dispose();      //  Allowed

81 

82               //

83               //   This one works as well, because newStream calls the explicit implemented

84               //   IDisposable.Dispose method

85               //

86               using  (MyStream newStream  =   new  MyDerivedStream())

87              {

88                   //

89                   //   Do something

90                   //

91              }

92          }

93          

94           private  IntPtr m_anotherMemory;

95           private  Bitmap m_anotherImage;

96           private   bool  m_disposed;

97      }

98  }

99