Wicked Code

        public static void Dispose(this object Object)
        {
            IDisposable disposable;

            if ((disposable = (Object as IDisposable)) != null)
                disposable.Dispose();
        }

Module Module1

    Sub Main()
        Dim di As New Disposer(Of Integer)(43)
        Dim dd As New Disposer(Of DisposableTest)(New DisposableTest)

        Console.WriteLine("Disposing Disposer(Of Integer)")
        di.Cleanup()
        Console.WriteLine("Disposing Disposer(Of DisposableTest)")
        dd.Cleanup()

        Dim dtemp As New DisposableTest()
        Console.WriteLine("Disposing DisposableTest")
        dtemp.Dispose()

        Console.WriteLine("Program complete. Press any key to exit...")
        Console.ReadKey()
    End Sub
End Module

Public Module HelperExtensions
    <System.Runtime.CompilerServices.Extension()> _
    Public Sub Dispose(ByVal this As Object)
        Console.WriteLine("Extension dispose")
    End Sub
End Module

Public Class Disposer(Of T)
    Public Sub New(ByVal data As T)
        _data = data
    End Sub

    Private _data As T

    Public Sub Cleanup()
        If _data IsNot Nothing Then _data.Dispose()
    End Sub
End Class

Public Class DisposableTest
    Implements IDisposable

    Public Sub Dispose() Implements IDisposable.Dispose
        Console.WriteLine("Class dispose called.")
    End Sub
End Class

PIEBALDconsult wrote:

On the other hand, I don't think it's supposed to work this way.

supercat9 wrote:

Extension methods are, from what I understand, an ugly kludge

supercat9 wrote:

Extension methods are, from what I understand, an ugly kludge which serves mainly to make Intellisense more useful, at the expense of introducing all sorts of potential weird bugs.

Super Lloyd wrote:

It's because, as you so well said, don't understand them!

1. Produces a build-time error
   
2. Produces code which will throw "method not implemented" at run-time
   
3. Execute a native method of foo's class
   
4. Execute an extension method (if several exist, which one?)

Super Lloyd wrote:

The declared method of the declared type will be called if it exist.

supercat9 wrote:

So are you saying that the extension method will get called if and only if the compiler was unaware of a normally-declared method when the code was built?

supercat9 wrote:

). In the absence of extension methods, if new methods are added to a library but all pre-existing methods, properties, etc. are unchanged, updating the library in an existing project will not affect the project application's behavior. If applications that use a class might have extension methods, how can one safely add classes, methods, or fields to it without potentially breaking applications of which one might be unaware?

V1
--
class C 
{
  void Foo(object o) {}
}

V2
--

class C
{ 
   void Foo(object o) {}
   void Foo(int x){}
}

PIEBALDconsult wrote:

On the other hand, I don't think it's supposed to work this way.

supercat9 wrote:

I don't see any reason "using" shouldn't work even when it's superfluous

PIEBALDconsult wrote:

I dislike language features that rely on the framework

PIEBALDconsult wrote:

may not require that string be backed by System.String

PIEBALDconsult wrote:

I would allow the using statement to operate on any type

using (int i=new int())
using (int j=new int())
for (i=0; i<10; i++) {
    for (j=0; j<10; j++) {
        ...
    }
}

PIEBALDconsult wrote:

the using statement relies on the existence of an System.IDisposable interface