Is it good practice to use empty using statement to close a disposable object in C#?

Question

I'm developing a class that can send fttp requests, it has a utility method that can execute different types of ftp methods:

private FtpWebResponse DoFttpRequest(Uri uri, NetworkCredential credentials, string method, string file = null)
{
    var request = (FtpWebRequest)WebRequest.Create(uri);
    request.Credentials = credentials;
    request.Method = method;

    if (!string.IsNullOrEmpty(file))
    {
        using (var stream = request.GetRequestStream())
        using (var writer = new StreamWriter(stream))
        {
            writer.Write(file);
        }
    }

    return (FtpWebResponse)request.GetResponse();
}

As you can see, this methods executes ftp method and returns response stream to the caller. Here is the client method that uses this method to write string contents to a file through ftp:

public void WriteToFile(string path, string contents)
{
    var uri = new Uri(path);
    using (var ftpResponse = DoFttpRequest(uri, _credentials, Ftp.UploadFile, contents)) { }
}

As you can see, here I'm using empty using statement using (var ftpResponse = DoFttpRequest(uri, _credentials, Ftp.UploadFile, contents)) { } to dispose of the received stream. Is this a good approach to dispose object like that? Is it even necessary to dispose this stream, since it will probably be disposed by the garbage collector anyway?

Answer 1

Is it even necessary to dispose this stream, since it will probably be disposed by the garbage collector anyway

You can use this simple code to see how not disposing response stream might completely break application. I use http request instead of ftp for simlicity of testing, but that applies equally to ftp requests.

public class Program {
    static void Main(string[] args) {
        // this value is *already* 2 by default, set for visibility
        ServicePointManager.DefaultConnectionLimit = 2;
        // replace example.com with real site
        DoFttpRequest("http://example.com");
        DoFttpRequest("http://example.com");
        DoFttpRequest("http://example.com");
        Console.ReadLine();
    }

    private static HttpWebResponse DoFttpRequest(string uri) {
        var request = (HttpWebRequest) WebRequest.Create(uri);
        var response = (HttpWebResponse) request.GetResponse();
        Console.WriteLine("got response");
        return response;
    }
}

Note that you are not disposing HttpWebResponse. What will happen is you will see 2 "got response" messages in console and then application will hang trying to get response 3rd time. That's because concurrent connections limit per endpoint (per host) is 2, so while 2 connections to the host (example.com here) are "in progress" - next connection to the same host will have to wait for them to complete. Because you don't dispose response - those connections will not be "completed" until GC collects them. Until then - your application hangs and then fails by timeout (if request.Timeout is set to some reasonable time). All subsequent requests also hang then fail by timeout. If you dispose responses - application will work as expected.

So always dispose things that are disposable. Using block is not necessary, you can just do DoFtpRequest(..).Dispose(). But if you prefer empty using - at least don't declare unnecessary variable, just do using (DoFttpRequest(..)) {}. One thing to note when choosing between empty using and Dispose is the possibility of null being returned by DoFtpRequest, because if it will return null - explicit Dispose will throw NullReferenceException while empty using will just ignore it (you can do DoFttpRequest(...)?.Dispose(); if you expect nulls but don't want to use using).

Answer 2

What using statement does is actually execute some sort of code and then simply calls the Dispose method. That's why u can use it only types inherits from IDisposible interface(in most case)

So you don't really have to use using statement. Just simply call

DoFttpRequest(uri, _credentials, Ftp.UploadFile, contents)).Dispose()

If you dont Dispose and object by yourself the Garbage Collector automatically disposes it after the scope completed. You don't have to think much about memory when you use high level languages like c#, java ... They are called Memory Managed Languages. They handle thoose kind of staff for you.