title: Implementing IDisposable with empty Dispose for reasons of readability
body: <p>I like the using(){} statement for its control of scope and for readability. Not only can you create objects, use them and dispose them neatly, but you can also use it like this:</p>
  
  <p>Suppose myInstance is an instance of MyClass from some other place in code - ie a method parameter or something</p>
  
  <pre><code>using (var t = myInstance) {
      t.Foo= "Hello";
      t.Bar= "World";
      ...
  }
  </code></pre>
  
  <p>Definition of MyClass:</p>
  
  <pre><code>public class MyClass : IDisposable
  {
     public string Foo {get; set;}
     public string Bar {get; set;}
     ...
  
     public void Dispose() {}
  }
  </code></pre>
  
  <p>This makes code neater and more readable (I feel) and certainly easier to type. However in order to use this widely you have to implement IDisposable. In this case there's no need for MyClass actually handle anything in Dispose, so its empty.</p>
  
  <p><strong>My question is, is there any drawback to using IDisposable in this way?</strong></p>
  
  <p>I appreciate that there are similar questions already on SO, but I don't think these deal with using IDispose for this purpose (or they refer to specific classes).</p>
  
  <p><strong>EDIT:</strong></p>
  
  <p>OK, so I guess I was being a bit specifc, but there's a wider point here. The using statement is a handy, very neat way to define an instance for a specific length of time, and then you can forget about it. Its seems unfair that this ability should be restricted to IDisposable objects only.  Yes there's a certain amount of laziness in not just instancing and then setting to null, but the using block makes it very specific what the instance's scope is. <strong>Why shouldn't I be allowed to do it with non IDisposable classes?</strong></p>