I'm really bothered by having to nest using
blocks in C#. It's not elegant and it takes up a lot of space. In some cases it appears to be unavoidable because I need to declare variables of different data types, but it seems like the single-type case should be possible to simplify. What I mean by "the single-type case" is when several variables of the same type are declared in series. Here's an example of what I'm talking about:
class Program
{
static void Main(string[] args)
{
using (A a = new A("a"), b = new A("b"))
{
}
}
class A : IDisposable
{
string n = null;
public A(string name)
{
n = name;
Console.WriteLine(String.Format("Creating {0}", n));
}
public void Dispose()
{
Console.WriteLine(String.Format("Disposing {0}", n));
}
}
}
The way I want this to work is that a
is constructed before b
, and that b
is disposed before a
. Unfortunately there doesn't appear to be any direction in the C# specification as to how it should actually happen. It appears as though Microsoft's C# compiler treats it like this, as this is the output of running the above program:
Creating a
Creating b
Disposing b
Disposing a
However, I have no way of ensuring that this is deterministic behavior. Can someone either confirm or refute the idea that this sequence is deterministic? References would be great. And obviously, if it's prone to breakage (undocumented, etc.) it's probably not useful, but that's a good thing to know.
There's already a similar question about deterministic disposal that talks about the multiple-type case, and I understand that there's no real solution there aside from clever syntax tricks. Most of the answers there miss the point, anyway. My question is just about the single-type case and whether this disposal is deterministic and dependable or not. Thanks.
What Does Dispose Mean? In the context of C#, dispose is an object method invoked to execute code required for memory cleanup and release and reset unmanaged resources, such as file handles and database connections.
The GC does not call Dispose , it calls your finalizer (which you should make call Dispose(false) ).
When the close brace is reached, the Dispose( ) method will be called on the object automatically, as illustrated in Example 4-6. In the first part of this example, the Font object is created within the using statement. When the using statement ends, Dispose( ) is called on the Font object.
This method is defined in the IDisposable interface. It has to be invoked by the user. Whenever it is invoked, it helps free the unmanaged resources. It can be implemented whenever a close() method is present.
From the C# spec:
"A using
statement of the form using (ResourceType r1 = e1, r2 = e2, ..., rN = eN)
is precisely equivalent to a sequence of nested using
statements:"
using (ResourceType r1 = e1)
using (ResourceType r2 = e2)
...
using (ResourceType rN = eN)
statement
So it seems fair to say that this is quite set in stone.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With