Question

I’d like to know your opinion on a matter of coding style that I’m on the fence about. I realize there probably isn’t a definitive answer, but I’d like to see if there is a strong preference in one direction or the other.

I’m going through a solution adding using statements in quite a few places. Often I will come across something like so:

{
    log = new log();
    log.SomeProperty = something;  // several of these
    log.Connection = new OracleConnection("...");
    log.InsertData(); // this is where log.Connection will be used
    ... // do other stuff with log, but connection won't be used again
}

where log.Connection is an OracleConnection, which implements IDisposable.

The neatnik in me wants to change it to:

{
    using (OracleConnection connection = new OracleConnection("..."))
    {
        log = new log();
        log.SomeProperty = something;
        log.Connection = conn;
        log.InsertData();
        ...
    }
}

But the lover of brevity and getting-the-job-done-slightly-faster wants to do:

{
    log = new log();
    log.SomeProperty = something; 
    using (log.Connection = new OracleConnection("..."))
        log.InsertData();
    ...
}

For some reason I feel a bit dirty doing this. Do you consider this bad or not? If you think this is bad, why? If it’s good, why?

EDIT: Please note that this is just one (somewhat contrived) example of many. Please don’t fixate on the fact that this happens to indicate a logger class with a poorly thought-out interface. This is not relevant to my question, and I’m not at liberty to improve the classes themselves anyway.

Answer 1

I agree that ideally log itself should implement IDisposable, but let’s assume that’s not possible and address the question the OP actually asked.

The second way is better, simply because it’s less code that accomplishes the same thing. There is no advantage to introducing an additional connection variable here.

Also note that you could do other initialisation outside of the using block. It won’t matter here, but may matter if you’re “using” some really expensive resource. That is:

log = new log();
log.SomeProperty = something; // This can be outside the "using"
using (OracleConnection connection = new OracleConnection("..."))
{
    log.Connection = conn;
    log.InsertData();
    ...
}