Why is use better than using?

Question

According to the last sentence on this MSDN page use is to be preferred over using. I've heard it elsewhere (this answer, for example). Why is this? I realize use was added later. But what's the difference? On the surface, using seems more useful because you can control when Dispose() is called, and you can explicitly ignore the bound value (e.g., (fun _ -> ...)) if needed.

Answer 1

An example against use is better then using:

using is better than use as using can be written in one line while use cannot.

Example,
xx is a function returning a value by a function fct from a resource which is opened by yy using given parameter p.

let xx p = using (yy(p)) (fun resource-> fct resource)     // <-- this is OK

let xx p  = (use resource = yy(p); fct resource)           // <-- this is Not OK

Answer 2

I think that the reason for preferring use is just that the syntax is simpler. Many other language constructs could be expressed as functions (e.g. try .. with, for, while, ...). If the language designers added a simpler syntax, why not use it...

As I wrote in the earlier answer you referenced, you can precisely control the scope even when using use. (And this way, you can use it even in constructors of object expressions class declarations.) But most of the time, the automatic behavior is just fine (which makes the construct simpler than using in C#).

Whether you'll use use or using in situations where you need to control the scope explicitly is a matter of personal taste. If you don't like the explicit scoping of use (which looks a bit weird, I admit, but works fine for me), you can use using.

EDIT: In a class declaration, you cannot for example write:

type Foo() =
  use a = new Whatever()
  // ...

because the scope of a would be (possibly) the whole lifetime of the instance. (Although I think this could be useful and it could add automatic implementation of IDisposable to your type). If you use using, you don't get this sort of trouble.

Answer 3

You can control when dispose is called with use as well, just by using usual scoping contructs (like parens or begin-end), e.g.

let F() =
    let x = 4
    (
        use file = System.IO.File.Open("foo.xml", System.IO.FileMode.Append)
        let z = 4
        printfn "file still open here"
    )
    printfn "file was already closed/disposed"

But I think this is rarely useful. I think it is also rare to not want to name/utilize the IDisposable object. use is more syntactically convenient, and 95% of the time does what you need, so I think that's why it's preferred.

Answer 4

Personally, I prefer use to using for the same reason that I prefer

let a = some_expr
some_stuff_with_a

to

(fun a -> some_stuff_with_a) some_expr

With the binding form, you can typically avoid a set of parentheses, and the association between the identifier and the value that it's being bound to are closer in space and easier to see.