class MyDialogWindow : public MyDialogBase
{
public:
 MyDialogWindow(){};
~MyDialogWindow()
{ 
  // Тут ничего писать не надо. оно все само освободится.
}

public:
  virtual void OnCreateFile()
  {
    Operation.reset(new FileOperation("c:\\file.txt"));
  }

  virtual void OnAddLineButton()
  {
    Operation->AddLine();
  }

  virtual void OnAddTitleButton()
  {
    Operation->AddTitle();
  }

  virtual void OnBlaBlaAction()
  {
    Operation->BlaBlaAction();
  }

private:
  std::auto_ptr<FileOperation> Operation;
}

A>>>А вообще, using это каменный век по сравнению с работой деструкторов...

HL>>Толсто троллите.

Stopwatch t=new Stopwatch();
using(t.Start())//указываем функцию начала
{
...
}(t.Stop());//указываем функцию завершения
Console.WriteLine(t.Elapsed);

GZ>Stopwatch t=new Stopwatch();
GZ>using(t.Start())//указываем функцию начала
GZ>{
GZ>...
GZ>}(t.Stop());//указываем функцию завершения
GZ>Console.WriteLine(t.Elapsed);
GZ>

try {
  t.Start();
} finally {
  t.Stop();
}

D>Нет такого правила в "Стандарте" В C++ деструкторы вполне себе могут бросать исключения. Просто потенциально возможные последствия оных "бросков" не устраивают пользователей языка

The process of calling destructors for automatic objects constructed on the path from a try block to a
throw-expression is called “stack unwinding.” [Note: If a destructor called during stack unwinding exits
with an exception, terminate is called (15.5.1). So destructors should generally catch exceptions and
not let them propagate out of the destructor. —end note]

15.5.1 The std::terminate() function
1
[except.terminate]
In the following situations exception handling must be abandoned for less subtle error handling techniques:
— when the exception handling mechanism, after completing evaluation of the expression to be thrown but before
the exception is caught (15.1), calls a user function that exits via an uncaught exception,140)
— when the exception handling mechanism cannot find a handler for a thrown exception (15.3), or
— when the destruction of an object during stack unwinding (15.2) exits using an exception, or

15.3
Handling an exception
The process of calling destructors for automatic objects constructed on the path from a try block to a throw-expression is
called “stack unwinding.” [ Note: If a destructor called during stack unwinding exits with an exception, std::termin-
ate is called (15.5.1). So destructors should generally catch exceptions and not let them propagate out of the destructor.
— end note ]

        class Scope: IDisposable
        {
            private readonly Action onDispose;

            public Scope(Action onDispose)
            {
                this.onDispose = onDispose;
            }

            public void Dispose()
            {
                onDispose();
            }
        }

        // пример использования
        public IDisposable InTransaction(IsolationLevel isolationLevel = IsolationLevel.ReadCommitted)
        {
            BeginTransaction(isolationLevel);

            return new Scope(() =>
                                 {
                                     if (Transaction != null)
                                         CommitTransaction();
                                 });
        }
        void foo()
        {
           using (InTransaction())
           {
              // some logic
           }
        }

public void Dispose() {
  Commit();
}

file data("....");
// пишем что-то в файл
data.flush(); // здесь может вылететь птичка
// автоматический вызов data.~file(), данные либо уже сохранены,
// либо flush выкинул исключение и мы и так получим информацию об ошибке,
// либо нам вобще не удалось сделать всё что нужно, и сохранять нет смысла,
// но закрыть дескриптор файла всё равно нужно.

D>У оппонентов наконец-то начинает возникать понимание Конечно, сделать аналог схемы using\IDisposable на C++ никаких проблем нет. Разве что будет страшненько и громоздко. Но как же тогда песнь о красоте и удобстве деструкторов ?

L>>>Как-то все равно все путанно и непонятен сделанный вывод. Рассказывал одно, потом взял и без какого-либо перехода объявил, что откат в Dispose — бред.

    public void Dispose()
    {
        if (Marshal.GetExceptionCode()==0)
            Console.WriteLine("Completed Successfully!");
        else
            Console.WriteLine("Exception!");
    }

_FR>Руки бы поотрывал!

_FR>    public void Dispose()
_FR>    {
_FR>        if (Marshal.GetExceptionCode()==0)
_FR>            Console.WriteLine("Completed Successfully!");
_FR>        else
_FR>            Console.WriteLine("Exception!");
_FR>    }
_FR>

public class ExceptionDetector : IDisposable
{
    public void Dispose()
    {
        if (Marshal.GetExceptionCode() == 0)
            Console.WriteLine("Completed Successfully!");
        else
            Console.WriteLine("Exception!");
    }
}

static void Main(string[] args)
{
    try
    {
        try
        {
            throw new NotImplementedException();
        }
        finally
        {
            using (new ExceptionDetector())
            {
                // no exception here!
            }
        }
    }
    catch (NotImplementedException)
    {
    }
}

GZ>Stopwatch t=new Stopwatch();
GZ>using(t.Start())//указываем функцию начала
GZ>{
GZ>...
GZ>}(t.Stop());//указываем функцию завершения
GZ>Console.WriteLine(t.Elapsed);
GZ>

var t = Stopwatch.StartNew();
using (Disposable.Create(t.Stop))
{
  ...
}
Console.WriteLine(t.Elapsed);