Pourquoi utiliser try {} finally {} avec un bloc try vide ?

Question

J'ai remarqué dans System.Threading.TimerBase.Dispose() que la méthode contient un bloc try{} finally{} mais le bloc try{} est vide.

Y a-t-il une utilité à utiliser try{} finally{} avec un bloc try vide ?

http://labs.developerfusion.co.uk/SourceViewer/browse.aspx?assembly=SSCLI&namespace=System.Threading&type=TimerBase

[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
internal bool Dispose(WaitHandle notifyObject)
{
    bool status = false;
    bool bLockTaken = false;
    RuntimeHelpers.PrepareConstrainedRegions();
    try {
    }
    finally {
        do {
            if (Interlocked.CompareExchange(ref m_lock, 1, 0) == 0) {
                bLockTaken = true;
                try {
                    status = DeleteTimerNative(notifyObject.SafeWaitHandle);
                }
                finally {
                    m_lock = 0;
                }
            }
            Thread.SpinWait(1);
            // yield to processor
        }
        while (!bLockTaken);
        GC.SuppressFinalize(this);
    }

    return status;
}

Answer 1

De http://blog.somecreativity.com/2008/04/10/the-empty-try-block-mystery/:

Cette méthodologie protège contre un appel de Thread.Abort interrompant le traitement. La page MSDN de Thread.Abort indique que "Les blocs finally non exécutés sont exécutés avant que le thread ne soit avorté". Ainsi, pour garantir que votre traitement se termine même si votre thread est interrompu en plein milieu par quelqu'un appelant Abort sur votre thread, vous pouvez placer tout votre code dans le bloc finally (l'alternative est d'écrire du code dans le bloc "catch" pour déterminer où vous étiez avant que le "try" ne soit interrompu par Abort et continuer à partir de là si vous le souhaitez).

Answer 2

Ceci est pour se protéger contre l'interruption de processus par Thread.Abort. La documentation de cette méthode indique que :

Les blocs finally non exécutés sont exécutés avant que le thread soit interrompu.

Cela est dû au fait que pour récupérer avec succès d'une erreur, votre code devra effectuer un nettoyage. Comme C# n'a pas de destructeurs de style C++, les blocs finally et using sont les seuls moyens fiables de garantir que ce nettoyage est effectué de manière fiable. Rappelez-vous que le bloc using se transforme ainsi par le compilateur :

try {
    ...
}
finally {
    if(obj != null)
        ((IDisposable)obj).Dispose();
}

Dans .NET 1.x, il y avait une chance que le bloc finally soit interrompu. Ce comportement a été modifié dans .NET 2.0.

De plus, les blocs try vides ne sont jamais optimisés par le compilateur.