The C# idiom is that if an object implements IDisposable
then you use a using
block. This will allow all resources being used by the object be disposed of properly. You're not suppose to know the implementation details of MemoryStream
. What you do know is that it implements IDisposable
so you should dispose of it properly. Further, you think that you know now that it doesn't need to free any resources but how do you know that in the future MemoryStream
won't change its underlying implementation so that it does use resources that need to be freed using Dispose
? You don't, so since it implements IDispoable
you have more future-proof code by just using the pattern now. Second, what if you change your code in the future to use a different type of Stream
that does have managed resources? By wrapping the MemoryStream
in a using
block now you reduce maintenance issues in the future; again, this is the correct way to use objects, and specifically Stream
s that implement IDisposable
. Third, it's a clear way to signal to readers that you are done using the object; it's what readers of your code will expect to see when they see you are using objects that implement IDisposable
. Finally, this is the current implementation of MemoryStream.Dispose
:
protected override void Dispose(bool disposing) {
try {
if (disposing) {
this._isOpen = false;
this._writable = false;
this._expandable = false;
}
}
finally {
base.Dispose(disposing);
}
}
So, this marks the stream as closed, not-writable and not-growable. If somehow someone else got a hold of a reference to the same MemoryStream
, it now becomes unusable to them which could be a good thing. But this is really the least important issue; the implementation details don't matter.
Use a using
block because MemoryStream
implement IDispoable
. Don't not use a using
block because you think that MemoryStream
doesn't have any resources that need to be freed.
与恶龙缠斗过久,自身亦成为恶龙;凝视深渊过久,深渊将回以凝视…