Conditional using block

Very interesting question, but yes, you are missing something.

Your code sample may mean the different things. Look at the constructor Class2.Class2. It may mean:

Single constructor based on late binding of the type Class1:

class Class1 : IDisposable {/* ... */}

class Class2 : IDisposable {
   internal Class2(Class1 variable) {/* ... */}
   //...
}

// which is based on this inheritance:
class Class2 : Class1, IDisposable {/* ... */}

The same code fragments could be implemented in different content, where the classes Class1 and Class2 are unrelated:

class Class2 {
   internal Class2(Class1 variable) {/* ... */}
   internal Class2(Class2 variable) {/* ... */}
   //...
}

Are you starting to get it? If you use polymorphism, you can optimize your code and avoid "if":

static void AMethod(bool useClass2) {
    using (Class1 variable1 = new Class1()) {
        Class1 factoryParameter = null;
        if (useClass2)
            factoryParameter = variable1;
        using (Class1 variable2 = Class1Factory(factoryParameter)) {
            using (Class3 variable3 = new Class3(variable2)) {
                variable3.DoSomething();
            } //variable3 is disposed here
        } //variable2 is disposed here
    } //variable1 is disposed here
} //AMethod

static Class1 Class1Factory(Class1 factoryParameter) { // important: late-bound return type
    if (factoryParameter == null)
        return new Class1();
    else
        return new Class2(factoryParameter);
} //Class1Factory

What to do in the more general case, when those IDisposable classes/structures are unrelated? You can leave your "naive" separate implementation putting both samples together with one "if" operator, but it could look too much messed up if you have greater level of nesting (which easily can be the case).

There is another way of doing thing. First, the using statement is equivalent to some try-finally block (or nested blocks). You can literally use it; it can be more compact then using, because try-finally is more general. But you can also use the special and well known technique:

Create a special "DisposalAccumulator" class which can accumulate all instances to be disposed in some container. This class should also implement IDisposable, to be used in one single using statement. Create only the instance of such class under using with only one level of nesting. Do you need to explain you more? I thing you should get an idea. If not just yes, your follow-up questions are very welcome — it's always a pleasure to deal with correctly formulated and sensible questions.

[EDIT #1]

I think most important criterion here would be to avoid any repeated code. I think you understand it. Please see:
http://en.wikipedia.org/wiki/Don%27t_repeat_yourself[^].

[EDIT #2]

Hold on, I'll try to provide code samples for those two general-case solutions: try-finally and "DisposalAccumulator", because it may be of some value to other readers.

My very best wishes,

—SA

I landed here via the article[^] proposed by Sergey, but I'm sure you'd like to see my solution as well.

You can actually assign null values to using statement variables. The syntactic sugar for the using block actually checks for a null variable in the finally block prior to a dispose. So, per Sergey's example, I provided the following solution that reduces redundant code and doesn't require the need for an additional class:

static void NotSoNaiveWay(bool createSecond)
{
    using (First first = new First())
    using (Second second = (createSecond) ? new Second(first) : null)
    using (Third third = (createSecond) ? new Third(second) : new Third(first))
    {
        third.DoSomething();
    }
}

If you made the Third class dispose of any provided IDisposable elements, you could simplify this further to:

static void NotSoNaiveWay(bool createSecond)
{
    using (First first = new First())
    using (Third third = (createSecond) ? new Third(new Second(first)) : new Third(first))
    {
        third.DoSomething();
    }
}

I hope that helps.

In this case I would probably have separate public methods and call a common private method if you need to reduce code duplication. An option would be to use a generic in the private class. Can also just use the generic in a public class. Here is the general concept:

public void Test1 ()
{
    Test<test1>();
}

public void Test2()
{
    Test<test2>();
}

private void Test<T> () where T : IDisposable, new()
{
    using (var x = new T())
    {

    }
}

Why dont you go for inheritance ?

Class3 > Inherits Class2
Class2 > Inherits Class1

Now Implement Class1 as IDisposable, and you will be able to use Single using statement

Also define proper methods and constructors that act on specific objects.