目录
概述
事件起因，一哥们在群里面贴出了类似下面这样的一段代码：
1 class Program 2 { 3 static void Main(string[] args) 4 { 5 byte[] buffer = File.ReadAllBytes("test.txt"); 6 MemoryStream ms = new MemoryStream(buffer); 7 ms.Dispose(); 8 Console.WriteLine(ms.ToArray().Length); 9 Console.Read(); 10 } 11 }
先不去考究这段代码到底有没有什么意义，就代码而言，内存流释放之后，再去使用ms会有问题么？
运行结果：
在印象中非托管资源Dispose之后，应该会出现“无法访问已释放的资源”之类的异常吧，但是你真正的运行的时候，你会发现并没有错。真的怪了，没办法，出于好奇也就研究了一下。
那我们如果访问ms对象的其他的属性（ms.Length）会怎么样呢？
访问其它的方法它也会出现上面的异常。
这问题出来了，难道内存流的Dispose方法是选择性的释放？
在看MemoryStream分析之前，回顾一下托管与非托管资源的概念。
托管资源
一般是指被CLR控制的内存资源，这些资源的管理可以由CLR来控制，例如程序中分配(new)的对象，作用域内的变量等。
非托管资源
是CLR不能控制或者管理的部分，这些资源有很多，比如文件流，数据库的连接，系统的窗口句柄(Window内核对象（句柄）)、字体、刷子、dc打印机资源等等……这些资源一般情况下不存在于Heap（内存中用于存储对象实例的地方）中。
C#的垃圾回收器：
CLR为程序员提供的内存管理机制，使得程序员在编写代码时不需要显式的去释放自己使用的内存资源（这些在先前C和C++中是需要程序员自己去显式的释放的）。这种管理机制称为GC(garbage collection)。GC的作用是很明显的，当系统内存资源匮乏时，它就会被激发，然后自动的去释放那些没有被使用的托管资源（也就是程序员没有显式释放的对象）。对于那些非托管资源虽然垃圾回收器可以跟踪封装非托管资源的对象的生存期,但它不了解具体如何清理这些资源。还好.net提供了Finalize()方法，它允许在垃圾回收器回收该类资源时，适当的清理非托管资源。但是Finalize()会产生很多副作用。释放非托管资源
资源的释放一般是通过"垃圾回收器"自动完成的,但具体来说,仍有些需要注意的地方：
1、值类型和引用类型的引用其实是不需要什么"垃圾回收器"来释放内存的,因为当它们出了作用域后会自动释放所占内存，因为它们都保存在栈(Stack)中;
2、只有引用类型的引用所指向的对象实例才保存在堆(Heap)中,而堆因为是一个自由存储空间,所以它并没有像"栈"那样有生存期("栈"的元素弹出后就代表生存期结束,也就代表释放了内存),并且要注意的是,"垃圾回收器"只对这块区域起作用。
然而,有些情况下，当需要释放非托管资源时,就必须通过写代码的方式来解决。非托管资源的释放
当我们在类中封装了对非托管资源的操作时，我们就需要显式释放(Dispose)，或隐式释放(Finalize)的释放这些资源。
Finalize一般情况下用于基类不带close方法或者不带Dispose显式方法的类，也就是说，在Finalize过程中我们需要隐式的去实现非托管资源的释放，然后系统会在Finalize过程完成后，自己的去释放托管资源。如果要实现Dispose方法，可以通过实现IDisposable接口，这样用户在使用这个类的同时就可以显示的执行Dispose方法，释放资源。（详细的内容可参考：http://blog.csdn.net/xiven/article/details/4951099）
MemoryStream分析
对于这个问题，吃饭的时候一直很纠结，所以就查了一些这方面的资料，也试图反编译MemoryStream类，看看Dispose方法是如何实现。
参考：
http://stackoverflow.com/questions/4274590/memorystream-close-or-memorystream-dispose
github上MemoryStream中的代码：
1 // 2 // System.IO.MemoryStream.cs 3 // 4 // Authors: Marcin Szczepanski (marcins@zipworld.com.au) 5 // Patrik Torstensson 6 // Gonzalo Paniagua Javier (gonzalo@ximian.com) 7 // Marek Safar (marek.safar@gmail.com) 8 // 9 // (c) 2001,2002 Marcin Szczepanski, Patrik Torstensson 10 // (c) 2003 Ximian, Inc. (http://www.ximian.com) 11 // Copyright (C) 2004 Novell, Inc (http://www.novell.com) 12 // Copyright 2011 Xamarin, Inc (http://www.xamarin.com) 13 // 14 // Permission is hereby granted, free of charge, to any person obtaining 15 // a copy of this software and associated documentation files (the 16 // "Software"), to deal in the Software without restriction, including 17 // without limitation the rights to use, copy, modify, merge, publish, 18 // distribute, sublicense, and/or sell copies of the Software, and to 19 // permit persons to whom the Software is furnished to do so, subject to 20 // the following conditions: 21 // 22 // The above copyright notice and this permission notice shall be 23 // included in all copies or substantial portions of the Software. 24 // 25 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 26 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 27 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 28 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 29 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 30 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 31 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 32 // 33 34 using System.Globalization; 35 using System.Runtime.InteropServices; 36 using System.Threading; 37 #if NET_4_5 38 using System.Threading.Tasks; 39 #endif 40 41 namespace System.IO 42 { 43 [Serializable] 44 [ComVisible (true)] 45 [MonoLimitation ("Serialization format not compatible with .NET")] 46 public class MemoryStream : Stream 47 { 48 bool canWrite; 49 bool allowGetBuffer; 50 int capacity; 51 int length; 52 byte [] internalBuffer; 53 int initialIndex; 54 bool expandable; 55 bool streamClosed; 56 int position; 57 int dirty_bytes; 58 #if NET_4_5 59 [NonSerialized] 60 Task<int> read_task; 61 #endif 62 63 public MemoryStream () : this (0) 64 { 65 } 66 67 public MemoryStream (int capacity) 68 { 69 if (capacity < 0) 70 throw new ArgumentOutOfRangeException ("capacity"); 71 72 canWrite = true; 73 74 this.capacity = capacity; 75 internalBuffer = new byte [capacity]; 76 77 expandable = true; 78 allowGetBuffer = true; 79 } 80 81 public MemoryStream (byte [] buffer) 82 { 83 if (buffer == null) 84 throw new ArgumentNullException ("buffer"); 85 86 InternalConstructor (buffer, 0, buffer.Length, true, false); 87 } 88 89 public MemoryStream (byte [] buffer, bool writable) 90 { 91 if (buffer == null) 92 throw new ArgumentNullException ("buffer"); 93 94 InternalConstructor (buffer, 0, buffer.Length, writable, false); 95 } 96 97 public MemoryStream (byte [] buffer, int index, int count) 98 { 99 InternalConstructor (buffer, index, count, true, false); 100 } 101 102 public MemoryStream (byte [] buffer, int index, int count, bool writable) 103 { 104 InternalConstructor (buffer, index, count, writable, false); 105 } 106 107 public MemoryStream (byte [] buffer, int index, int count, bool writable, bool publiclyVisible) 108 { 109 InternalConstructor (buffer, index, count, writable, publiclyVisible); 110 } 111 112 void InternalConstructor (byte [] buffer, int index, int count, bool writable, bool publicallyVisible) 113 { 114 if (buffer == null) 115 throw new ArgumentNullException ("buffer"); 116 117 if (index < 0 || count < 0) 118 throw new ArgumentOutOfRangeException ("index or count is less than 0."); 119 120 if (buffer.Length - index < count) 121 throw new ArgumentException ("index+count", 122 "The size of the buffer is less than index + count."); 123 124 canWrite = writable; 125 126 internalBuffer = buffer; 127 capacity = count + index; 128 length = capacity; 129 position = index; 130 initialIndex = index; 131 132 allowGetBuffer = publicallyVisible; 133 expandable = false; 134 } 135 136 void CheckIfClosedThrowDisposed () 137 { 138 if (streamClosed) 139 throw new ObjectDisposedException ("MemoryStream"); 140 } 141 142 public override bool CanRead { 143 get { return !streamClosed; } 144 } 145 146 public override bool CanSeek { 147 get { return !streamClosed; } 148 } 149 150 public override bool CanWrite { 151 get { return (!streamClosed && canWrite); } 152 } 153 154 public virtual int Capacity { 155 get { 156 CheckIfClosedThrowDisposed (); 157 return capacity - initialIndex; 158 } 159 160 set { 161 CheckIfClosedThrowDisposed (); 162 163 if (!expandable) 164 throw new NotSupportedException ("Cannot expand this MemoryStream"); 165 166 if (value < 0 || value < length) 167 throw new ArgumentOutOfRangeException ("value", 168 "New capacity cannot be negative or less than the current capacity " + value + " " + capacity); 169 170 if (internalBuffer != null && value == internalBuffer.Length) 171 return; 172 173 byte [] newBuffer = null; 174 if (value != 0) { 175 newBuffer = new byte [value]; 176 if (internalBuffer != null) 177 Buffer.BlockCopy (internalBuffer, 0, newBuffer, 0, length); 178 } 179 180 dirty_bytes = 0; // discard any dirty area beyond previous length 181 internalBuffer = newBuffer; // It's null when capacity is set to 0 182 capacity = value; 183 } 184 } 185 186 public override long Length { 187 get { 188 // LAMESPEC: The spec says to throw an IOException if the 189 // stream is closed and an ObjectDisposedException if 190 // "methods were called after the stream was closed". What 191 // is the difference? 192 193 CheckIfClosedThrowDisposed (); 194 195 // This is ok for MemoryStreamTest.ConstructorFive 196 return length - initialIndex; 197 } 198 } 199 200 public override long Position { 201 get { 202 CheckIfClosedThrowDisposed (); 203 return position - initialIndex; 204 } 205 206 set { 207 CheckIfClosedThrowDisposed (); 208 if (value < 0) 209 throw new ArgumentOutOfRangeException ("value", 210 "Position cannot be negative" ); 211 212 if (value > Int32.MaxValue) 213 throw new ArgumentOutOfRangeException ("value", 214 "Position must be non-negative and less than 2^31 - 1 - origin"); 215 216 position = initialIndex + (int) value; 217 } 218 } 219 220 protected override void Dispose (bool disposing) 221 { 222 streamClosed = true; 223 expandable = false; 224 } 225 226 public override void Flush () 227 { 228 // Do nothing 229 } 230 231 public virtual byte [] GetBuffer () 232 { 233 if (!allowGetBuffer) 234 throw new UnauthorizedAccessException (); 235 236 return internalBuffer; 237 } 238 239 public override int Read ([In,Out] byte [] buffer, int offset, int count) 240 { 241 if (buffer == null) 242 throw new ArgumentNullException ("buffer"); 243 244 if (offset < 0 || count < 0) 245 throw new ArgumentOutOfRangeException ("offset or count less than zero."); 246 247 if (buffer.Length - offset < count ) 248 throw new ArgumentException ("offset+count", 249 "The size of the buffer is less than offset + count."); 250 251 CheckIfClosedThrowDisposed (); 252 253 if (position >= length || count == 0) 254 return 0; 255 256 if (position > length - count) 257 count = length - position; 258 259 Buffer.BlockCopy (internalBuffer, position, buffer, offset, count); 260 position += count; 261 return count; 262 } 263 264 public override int ReadByte () 265 { 266 CheckIfClosedThrowDisposed (); 267 if (position >= length) 268 return -1; 269 270 return internalBuffer [position++]; 271 } 272 273 public override long Seek (long offset, SeekOrigin loc) 274 { 275 CheckIfClosedThrowDisposed (); 276 277 // It's funny that they don't throw this exception for < Int32.MinValue 278 if (offset > (long) Int32.MaxValue) 279 throw new ArgumentOutOfRangeException ("Offset out of range. " + offset); 280 281 int refPoint; 282 switch (loc) { 283 case SeekOrigin.Begin: 284 if (offset < 0) 285 throw new IOException ("Attempted to seek before start of MemoryStream."); 286 refPoint = initialIndex; 287 break; 288 case SeekOrigin.Current: 289 refPoint = position; 290 break; 291 case SeekOrigin.End: 292 refPoint = length; 293 break; 294 default: 295 throw new ArgumentException ("loc", "Invalid SeekOrigin"); 296 } 297 298 // LAMESPEC: My goodness, how may LAMESPECs are there in this 299 // class! :) In the spec for the Position property it's stated 300 // "The position must not be more than one byte beyond the end of the stream." 301 // In the spec for seek it says "Seeking to any location beyond the length of the 302 // stream is supported." That's a contradiction i'd say. 303 // I guess seek can go anywhere but if you use position it may get moved back. 304 305 refPoint += (int) offset; 306 if (refPoint < initialIndex) 307 throw new IOException ("Attempted to seek before start of MemoryStream."); 308 309 position = refPoint; 310 return position; 311 } 312 313 int CalculateNewCapacity (int minimum) 314 { 315 if (minimum < 256) 316 minimum = 256; // See GetBufferTwo test 317 318 if (minimum < capacity * 2) 319 minimum = capacity * 2; 320 321 return minimum; 322 } 323 324 void Expand (int newSize) 325 { 326 // We don't need to take into account the dirty bytes when incrementing the 327 // Capacity, as changing it will only preserve the valid clear region. 328 if (newSize > capacity) 329 Capacity = CalculateNewCapacity (newSize); 330 else if (dirty_bytes > 0) { 331 Array.Clear (internalBuffer, length, dirty_bytes); 332 dirty_bytes = 0; 333 } 334 } 335 336 public override void SetLength (long value) 337 { 338 if (!expandable && value > capacity) 339 throw new NotSupportedException ("Expanding this MemoryStream is not supported"); 340 341 CheckIfClosedThrowDisposed (); 342 343 if (!canWrite) { 344 throw new NotSupportedException (Locale.GetText 345 ("Cannot write to this MemoryStream")); 346 } 347 348 // LAMESPEC: AGAIN! It says to throw this exception if value is 349 // greater than "the maximum length of the MemoryStream". I haven't 350 // seen anywhere mention what the maximum length of a MemoryStream is and 351 // since we're this far this memory stream is expandable. 352 if (value < 0 || (value + initialIndex) > (long) Int32.MaxValue) 353 throw new ArgumentOutOfRangeException (); 354 355 int newSize = (int) value + initialIndex; 356 357 if (newSize > length) 358 Expand (newSize); 359 else if (newSize < length) // Postpone the call to Array.Clear till expand time 360 dirty_bytes += length - newSize; 361 362 length = newSize; 363 if (position > length) 364 position = length; 365 } 366 367 public virtual byte [] ToArray () 368 { 369 int l = length - initialIndex; 370 byte[] outBuffer = new byte [l]; 371 372 if (internalBuffer != null) 373 Buffer.BlockCopy (internalBuffer, initialIndex, outBuffer, 0, l); 374 return outBuffer; 375 } 376 377 public override void Write (byte [] buffer, int offset, int count) 378 { 379 if (buffer == null) 380 throw new ArgumentNullException ("buffer"); 381 382 if (offset < 0 || count < 0) 383 throw new ArgumentOutOfRangeException (); 384 385 if (buffer.Length - offset < count) 386 throw new ArgumentException ("offset+count", 387 "The size of the buffer is less than offset + count."); 388 389 CheckIfClosedThrowDisposed (); 390 391 if (!CanWrite) 392 throw new NotSupportedException ("Cannot write to this stream."); 393 394 // reordered to avoid possible integer overflow 395 if (position > length - count) 396 Expand (position + count); 397 398 Buffer.BlockCopy (buffer, offset, internalBuffer, position, count); 399 position += count; 400 if (position >= length) 401 length = position; 402 } 403 404 public override void WriteByte (byte value) 405 { 406 CheckIfClosedThrowDisposed (); 407 if (!canWrite) 408 throw new NotSupportedException ("Cannot write to this stream."); 409 410 if (position >= length) { 411 Expand (position + 1); 412 length = position + 1; 413 } 414 415 internalBuffer [position++] = value; 416 } 417 418 public virtual void WriteTo (Stream stream) 419 { 420 CheckIfClosedThrowDisposed (); 421 422 if (stream == null) 423 throw new ArgumentNullException ("stream"); 424 425 stream.Write (internalBuffer, initialIndex, length - initialIndex); 426 } 427 428 #if NET_4_5 429 430 public override Task CopyToAsync (Stream destination, int bufferSize, CancellationToken cancellationToken) 431 { 432 // TODO: Specialization but what for? 433 return base.CopyToAsync (destination, bufferSize, cancellationToken); 434 } 435 436 public override Task FlushAsync (CancellationToken cancellationToken) 437 { 438 if (cancellationToken.IsCancellationRequested) 439 return TaskConstants.Canceled; 440 441 try { 442 Flush (); 443 return TaskConstants.Finished; 444 } catch (Exception ex) { 445 return Task<object>.FromException (ex); 446 } 447 } 448 449 public override Task<int> ReadAsync (byte[] buffer, int offset, int count, CancellationToken cancellationToken) 450 { 451 if (buffer == null) 452 throw new ArgumentNullException ("buffer"); 453 454 if (offset < 0 || count < 0) 455 throw new ArgumentOutOfRangeException ("offset or count less than zero."); 456 457 if (buffer.Length - offset < count ) 458 throw new ArgumentException ("offset+count", 459 "The size of the buffer is less than offset + count."); 460 if (cancellationToken.IsCancellationRequested) 461 return TaskConstants<int>.Canceled; 462 463 try { 464 count = Read (buffer, offset, count); 465 466 // Try not to allocate a new task for every buffer read 467 if (read_task == null || read_task.Result != count) 468 read_task = Task<int>.FromResult (count); 469 470 return read_task; 471 } catch (Exception ex) { 472 return Task<int>.FromException (ex); 473 } 474 } 475 476 public override Task WriteAsync (byte[] buffer, int offset, int count, CancellationToken cancellationToken) 477 { 478 if (buffer == null) 479 throw new ArgumentNullException ("buffer"); 480 481 if (offset < 0 || count < 0) 482 throw new ArgumentOutOfRangeException (); 483 484 if (buffer.Length - offset < count) 485 throw new ArgumentException ("offset+count", 486 "The size of the buffer is less than offset + count."); 487 488 if (cancellationToken.IsCancellationRequested) 489 return TaskConstants.Canceled; 490 491 try { 492 Write (buffer, offset, count); 493 return TaskConstants.Finished; 494 } catch (Exception ex) { 495 return Task<object>.FromException (ex); 496 } 497 } 498 #endif 499 } 500 }
通过上面的代码，你可以看出，很多方法和属性中都会有这样的一个方法的调用：
CheckIfClosedThrowDisposed ();
该方法的实现
1 void CheckIfClosedThrowDisposed () 2 { 3 if (streamClosed) 4 throw new ObjectDisposedException ("MemoryStream"); 5 }
通过方法名可以清楚的知道该方法的作用：检查如果关闭了则抛出Dispose异常，通过方法体也可以清楚的知道该方法的作用。
你可以看一下ToArray方法
1 public virtual byte [] ToArray () 2 { 3 int l = length - initialIndex; 4 byte[] outBuffer = new byte [l]; 5 6 if (internalBuffer != null) 7 Buffer.BlockCopy (internalBuffer, initialIndex, outBuffer, 0, l); 8 return outBuffer; 9 }
从代码中，也可以看出该方法并没有对流是否关闭进行检查。
总结
虽然上面的代码能说明为什么出现异常的原因，但是为什么要这样设计？为什么其他的方法会检测是否释放而ToArray方法反而放过呢？
功底有限，也只能到这地步，如果哪个园友有更深入的解释，可以给个合理的解释，为什么这样设计？
选择性的释放，那会不会就不安全了呢？
| 博客地址： | http://www.cnblogs.com/wolf-sun/ |
| 博客版权： | 本文以学习、研究和分享为主，欢迎转载，但必须在文章页面明显位置给出原文连接。 如果文中有不妥或者错误的地方还望高手的你指出，以免误人子弟。如果觉得本文对你有所帮助不如【推荐】一下！如果你有更好的建议，不如留言一起讨论，共同进步！ 再次感谢您耐心的读完本篇文章。 转载：http://www.cnblogs.com/wolf-sun/p/3925477.html |
