I just want to make sure I'm getting this right.
In the next release of c++.net, lets assume the following code

===============================

#using <mscorlib.dll>

using namespace System;
using namespace System::Net::Sockets;

public __gc class Foo : public IDisposable
{
   public:
       Foo()
       {
               _socket = new
System::Net::Sockets::Socket(AddressFamily::InterNetwork,
SocketType::Stream, ProtocolType::Tcp);
               _isocket = dynamic_cast<IDisposable*>(socket);
       }

       void IDisposable::Dispose()
       {
               _isocket->Dispose();
       }

       ~Foo()
       {
               try
               {
                   Dispose();
               }
               catch(...)
               {
               }
       }

       __property Socket* get_Socket()
       {
               //TODO: do check to make sure object is not disposed.
               return _socket;
       }

   private:
       System::Net::Socket __gc* _socket;
       IDisposable __gc* _isocket;
};

int main(int argc, char* argcv[])
{
   {
       Foo f;
       Object __gc* socket = f.Socket;
   }
   //the desctructor should have been called by now.
   return 0;
}

==========================

I'm assuming the the following happen behind the scenes.

1) f.Dispose() will be called automatically in the same thread context in
which f was initialized and no exception handling being performed
if f.dtor() throws an exception.
2) f.dtor() [same text as 1]
3) there is no excpetion handling performed when f.Dispose() and the
f.dtor() is automatically called.
4) the private variable f._socket will not be finalized instantly when
variable, f, goes out of scope. It will be finalized the next time garbage
collection is performed by either the system, or a call to GC::Collect.
5) When I say automatically, this is done at compile time and not runtime.
the compiler adds code to do 1, 2 and 3. 4 would be at runtime.

Thx in advance, I'm just trying to get a solid understanding of this new
feature of c++.net.

Also, if an object contains a finalizer, such as the Regex class. In the
next version of c++, will finalizers be treated as destructors so I can do

Regex __gc* regex = new Regex();
delete regex;