Do computations in F# call Dispose() on completion?

Question

I have a database connection with a query similar to as follows in a couple separate files in a project:

SqlTypes.fs

module SqlTypes
open FSharp.Data.TypeProviders

type DBType = SqlDataConnection<ConnectionStrings.DbConnStr>

let getDb() = DBType.GetDataContext() //will this cause a memory leak when called from outside here?

Utilities.fs

module Utilities
open System
open SqlTypes
open System.Linq

///Returns an IQueryable of Orders whose OrderStatus is less than 5 (Not yet released)
let private getOrdersNotYetReleased () =
    let orders = query {
        for order in getDb().Orders do //memleak here?
        where(order.Status < 5)
        sortBy (order.CreatedDateUtc)
        select order
    }
    //return
    orders

Q: Is it necessary to use a use clause (like in the following) to prevent a memory leak?

///Returns an IQueryable of Orders whose OrderStatus is less than 5 (Not yet released)
let private getOrdersNotYetReleased () =
    use db = DBType.GetDataContext() //is this safer? Does it matter if this `use` is here?
    let orders = query {
        for order in db.Orders do 
        where(order.Status < 5)
        sortBy (order.CreatedDateUtc)
        select order
    }
    //return
    orders

Or, will Dispose() be called on the Db object when the computation block exits?

F# has garbage collection, so the term "memory leak" may not mean what you think it means in this context. — Robert Harvey, Oct 26 '20 at 12:44

Robert Harvey · Accepted Answer · 2020-10-26T12:57:32.030

2

The IDisposable pattern provides for a Dispose() method. The use keyword is there to take advantage of this pattern; if a class implements IDisposable, the author of the class is telling you that using the use keyword with their class is probably a good idea.

What the Dispose() method actually does depends entirely on what code the author of the class writes for the Dispose() method. There is no guarantee that it even does anything.

Microsoft's official word on IDisposable has always been that its purpose is to "clean up unmanaged resources," but in practice, Dispose() does whatever the author of the class believes it needs to do to gracefully shut down the object. What it generally does not do is recover memory from managed objects; that is the purpose of the garbage collector.

But, generally speaking, if a class implements IDisposable, that means it contains a Dispose() method that does something meaningful for the disposition of the object, like closing files or database connections, for example. So. Class implements IDisposable? Use use with it.

Further Reading
Managing Resources in F#

edited Oct 26 '20 at 12:57

answered Oct 26 '20 at 12:51

Robert Harvey

178,213
47
333
501

So it's still possible that even when the `query` block exits there can be "unmanaged resources" still lying around (or open connections, etc)? – LSM07 Oct 26 '20 at 12:58
1

Generally, no. If there are actual "unmanaged resources" being used in a class, and the class is properly written, `Dispose()` will properly clean up those resources. But it's merely a convention; it still depends on the author of the class doing the right thing with `Dispose()`. – Robert Harvey Oct 26 '20 at 13:01
1

To be clear, `Dispose()` will *not* be called unless you use the `use` keyword or call it directly. The whole point of the `use` keyword is to hook up the `IDisposable` machinery so that it will work properly. – Robert Harvey Oct 26 '20 at 13:03

Do computations in F# call Dispose() on completion?

1 Answers1