MemoryStream.Close() or MemoryStream.Dispose()

Which one do I call?

Is it necessary to call both?

Will the other throw an exception if I have already called one of them?

Close() and Dispose(), when called on a MemoryStream, only serve to do two things:

• Mark the object disposed so that future accidental usage of the object will throw an exception.
• Possibly¹ release references to managed objects, which can make the GC's job a bit easier depending on the GC implementation. (On today's GC algorithms it makes no real difference, so this is a point for an academic discussion and has no significant real-world impact.)

MemoryStream does not have any unmanaged resources to dispose, so you don't technically have to dispose of it. The effect of not disposing a MemoryStream is roughly the same thing as dropping a reference to a byte[] -- the GC will clean both up the same way.

> Which one do I call? Is it necessary to call both?

The Dispose() method of streams delegate directly to the Close() method², so both do exactly the same thing.

> Will the other throw an exception if I have already called one of them?

The documentation for IDisposable.Dispose() specifically states it is safe to call Dispose() multiple times, on any object³. (If that is not true for a particular class then that class implements the IDisposable interface in a way that violates its contract, and this would be a bug.)

All that to say: it really doesn't make a huge difference whether you dispose a MemoryStream or not. The only real reason it has Close/Dispose methods is because it inherits from Stream, which requires those methods as part of its contract to support streams that do have unmanaged resources (such as file or socket descriptors).

---

¹ Mono's implementation does not release the byte[] reference. I don't know if the Microsoft implementation does.

² "This method calls Close, which then calls Stream.Dispose(Boolean)."

³ "If an object's Dispose method is called more than once, the object must ignore all calls after the first one."

None of the above. You needn't call either Close or Dispose.

MemoryStream doesn't hold any unmanaged resources, so the only resource to be reclaimed is memory. The memory will be reclaimed during garbage collection with the rest of the MemoryStream object when your code no longer references the MemoryStream.

If you have a long-lived reference to the MemoryStream, you can set that reference to null to allow the MemoryStream to be garbage collected. Close and Dispose free neither the steam buffer nor the MemoryStream object proper.

Since neither Stream nor MemoryStream have a finalizer, there is no need to call Close or Dispose to cause GC.SuppressFinalize to be called to optimize garbage collection. There is no finalizer to suppress.

The docs for MemoryStream put it this way: > This type implements the IDisposable interface, but does not actually have any resources to dispose. This means that disposing it by directly calling Dispose() or by using a language construct such as using (in C#) or Using (in Visual Basic) is not necessary.

You can use the using block for this. It will automatically call Dispose when it goes outside of its scope.

Example:

using (MemoryStream ms = new MemoryStream())
{
    // Do something with ms..
}
// ms is disposed here

Hope this helped.

Use using block so that your object is disposed if its implements IDisposable interface

>Which one do I call?

Any of them.

>Is it necessary to call both?

No, either one is sufficient.

>Will the other throw an exception if I have already called one of them?

No, disposable pattern declares that subsequent calls to Dispose don't cause negative effects.

the following code is Stream.Dispose from reflector as you can see, you don't need to close if you dispose (which is implicit when using using)

public void Dispose()
{
    this.Close();
}

Calling Close() will internally call Dispose() to release the resources.

See this link for more information: msdn

Calling only Dispose() will do the trick =)

In .NET 3.5 (haven't checked other versions), methods are called in the following order when disposing a MemoryStream:

1. Stream.Dispose()

• simply calls Close

2. Stream.Close()

• calls Dispose(true), then GC.SuppressFinalize(this)

3. MemoryStream.Dispose(true)

• sets _isOpen , _writable, and _expandable flags to false

4. Stream.Dispose(true)

• closes async event if active

As a first solution, it's recommended to use using statements wherever possible. This is described here: http://msdn.microsoft.com/en-us/library/yh598w02.aspx

>When the lifetime of an IDisposable object is limited to a single method, you should declare and instantiate it in the using statement. The using statement calls the Dispose method on the object in the correct way, and (when you use it as shown earlier) it also causes the object itself to go out of scope as soon as Dispose is called. Within the using block, the object is read-only and cannot be modified or reassigned.

Coming to the question now, as others suggested in most .NET framework classes, there is no difference between Close() and Dispose() and it doesn't matter which of the two methods you call. You should call one but not both. However, there are exceptions.

>There are exceptions; for example, System.Windows.Forms.Form and System.Data.SqlClient.SqlConnection have different behavior for Close() and Dispose().

For complete details, you can check here: https://blogs.msdn.microsoft.com/kimhamil/2008/03/15/the-often-non-difference-between-close-and-dispose/