A second (critical) problem in C++/ClI

[Vedo]

Hi again;

after the 'literal's problem in abstract sealed classes, today I realized
another problem. As you know, if you require a finalizer in your class the
compiler automatically implements the general dispose pattern to ease the
development. (You only implement the !classname and ~classname methods) So
far so good. But if you derive from the CriticalFinalizerObject class, you
must annotate all methods reachable from the finalizer with a
ReliabilityContract attribute. Otherwise the CLR cannot pre-JIT your
finalization code to ensure that no asynchronous exceptions are thrown
during a critical finalization.

Now the problem is that the compiler does not allow you to define your own
Finalize method and internally implements the classical Dispose(bool
disposing) idiom which calls your actual finalization code. What this means
is; you cannot apply a ReliabilityContact attribute to this compiler
generated Dispose method and therefore your finalization code can never be
"prepared" for critical finalizations. You loose all the reliability that
the CLR provides, you can never be sure that your finalization code will be
executed, and much more important your CriticalFinalizerObject derived class
can also affect other objects waiting for finalization.
public ref class XXX : CriticalFinalizerObject
{
protected:

// Compiler generated Dispose method

// [ReliabilityContract(Consistency::WillNotCorruptSta te, Cer::Success)]
!!! missing !!!
virtual void Dispose([MarshalAs(::U1)]bool disposing)
{
if (disposing)
{
this->~XXX();
}
else
{
try
{
this->!XXX();
}
finally
{
CriticalFinalizerObject->Finalize();
}
}
}
...
};