Core/Castle.Core/Resource/AbstractStreamResource.cs

   1 // Copyright 2004-2007 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.Core.Resource
  16 {
  17         using System;
  18         using System.IO;
  19         using System.Runtime.Remoting;
  20         using System.Text;
  21
  22         /// <summary>
  23         ///
  24         /// </summary>
  25         public abstract class AbstractStreamResource : AbstractResource
  26         {
  27                 public AbstractStreamResource()
  28                 {
  29                 }
  30
  31                 ~AbstractStreamResource()
  32                 {
  33                         Dispose(false);
  34                 }
  35
  36                 protected abstract Stream Stream { get; }
  37
  38                 public override TextReader GetStreamReader()
  39                 {
  40                         // The StreamReader can't take ownership of the stream
  41                         // that's why we use StreamHideCloseDelegate
  42                         return new StreamReader(new StreamHideCloseDelegate(Stream));
  43                 }
  44
  45                 public override TextReader GetStreamReader(Encoding encoding)
  46                 {
  47                         // The StreamReader can't take ownership of the stream
  48                         // that's why we use StreamHideCloseDelegate
  49                         return new StreamReader(new StreamHideCloseDelegate(Stream), encoding);
  50                 }
  51
  52                 public override void Dispose()
  53                 {
  54                         Dispose(true);
  55                 }
  56
  57                 protected void Dispose(bool disposing)
  58                 {
  59                         if (disposing)
  60                         {
  61                                 GC.SuppressFinalize(this);
  62                         }
  63
  64                         if (Stream != null)
  65                         {
  66                                 Stream.Close();
  67                         }
  68                 }
  69
  70                 #region StreamHideCloseDelegate nested class
  71
  72                 /// <summary>
  73                 /// Do not allow closing and disposal of the
  74                 /// underlying <see cref="Stream"/>.
  75                 /// </summary>
  76                 public class StreamHideCloseDelegate : Stream, IDisposable
  77                 {
  78                         private readonly Stream inner;
  79
  80                         public StreamHideCloseDelegate(Stream inner)
  81                         {
  82                                 this.inner = inner;
  83                         }
  84
  85                         #region Stream implementation
  86
  87                         public override bool CanRead
  88                         {
  89                                 get { return inner.CanRead; }
  90                         }
  91
  92                         public override bool CanSeek
  93                         {
  94                                 get { return inner.CanSeek; }
  95                         }
  96
  97                         public override bool CanWrite
  98                         {
  99                                 get { return inner.CanWrite; }
 100                         }
 101
 102                         public override long Length
 103                         {
 104                                 get { return inner.Length; }
 105                         }
 106
 107                         public override long Position
 108                         {
 109                                 get { return inner.Position; }
 110                                 set { inner.Position = value; }
 111                         }
 112
 113                         public override void Flush()
 114                         {
 115                                 inner.Flush();
 116                         }
 117
 118                         public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
 119                         {
 120                                 return inner.BeginRead(buffer, offset, count, callback, state);
 121                         }
 122
 123                         public override int EndRead(IAsyncResult asyncResult)
 124                         {
 125                                 return inner.EndRead(asyncResult);
 126                         }
 127
 128                         public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
 129                         {
 130                                 return inner.BeginWrite(buffer, offset, count, callback, state);
 131                         }
 132
 133                         public override void EndWrite(IAsyncResult asyncResult)
 134                         {
 135                                 inner.EndWrite(asyncResult);
 136                         }
 137
 138                         public override long Seek(long offset, SeekOrigin origin)
 139                         {
 140                                 return inner.Seek(offset, origin);
 141                         }
 142
 143                         public override void SetLength(long value)
 144                         {
 145                                 inner.SetLength(value);
 146                         }
 147
 148                         public override int Read(byte[] buffer, int offset, int count)
 149                         {
 150                                 return inner.Read(buffer, offset, count);
 151                         }
 152
 153                         public override int ReadByte()
 154                         {
 155                                 return inner.ReadByte();
 156                         }
 157
 158                         public override void Write(byte[] buffer, int offset, int count)
 159                         {
 160                                 inner.Write(buffer, offset, count);
 161                         }
 162
 163                         public override void WriteByte(byte value)
 164                         {
 165                                 inner.WriteByte(value);
 166                         }
 167
 168                         public override object InitializeLifetimeService()
 169                         {
 170                                 return inner.InitializeLifetimeService();
 171                         }
 172
 173                         public override ObjRef CreateObjRef(Type requestedType)
 174                         {
 175                                 return inner.CreateObjRef(requestedType);
 176                         }
 177
 178                         public override void Close()
 179                         {
 180                         }
 181
 182                         #endregion
 183                 }
 184
 185                 #endregion
 186         }
 187 }