expressions in C#'s using statement

An example of using an expression is as follows:

var stream = new MemoryStream(); using(stream) { //Perform operations with stream here. } //Stream is now disposed. 

Here, the stream variable is declared outside the using, but wrapped by the using. It will then dispose the stream variable upon completion.

This isn't a very common pattern, but it is useful for where you may need to perform other operations on the resource after it has been disposed of.

This can be used with method calls, etc. Essentially any expression that evaluates to a type of IDisposable can be used. Generally, not having access to the IDisposable inside the using statement isn't that useful.

The only scenario where I have seen it used this way is in ASP.NET MVC with the form helpers such as.

@using(Html.BeginForm()) { @Html.TextBox("Name"); } 

An example:

//Create the file. using (FileStream fs = File.Create(path)) { AddText(fs, "This is some text"); AddText(fs, "This is some more text,"); AddText(fs, "\r\nand this is on a new line"); AddText(fs, "\r\n\r\nThe following is a subset of characters:\r\n"); for (int i=1;i < 120;i++) { AddText(fs, Convert.ToChar(i).ToString()); } } 

Explanation:

Provides a convenient syntax that ensures the correct use of IDisposable objects.

The using statement calls the Dispose method on the object at the and of the block.

It will call the Dispose method even if an Exception is thrown.

The key thing to look at is actually the definition of local-variable-declaration from section 8.5.1

A local-variable-declaration declares one or more local variables.

local-variable-declaration:
local-variable-type   local-variable-declarators

local-variable-type:
type
var

local-variable-declarators:
local-variable-declarator
local-variable-declarators   ,   local-variable-declarator

local-variable-declarator:
identifier
identifier   =   local-variable-initializer

local-variable-initializer:
expression
array-initializer

So a local-variable-declaration could be expressed as type identifer = expression. So what the specification for using is telling you is you can either declare a variable in the form var variableName = xxxxxxx or you can just use the xxxxxx part by itself.

Another example of expression that I don't see mentioned here is:

IDisposable disposable; using (disposable = new SomeDisposableObject()) { // do something } 

or

IDisposable disposable; using (disposable = SomeExpressionOrFunctionThatEvaluatesToADisposable()) { // do something } 

The reference doesn't have to be of type IDisposable, it could be any type that implements it.