L'uso improprio è suscettibile di trarre vantaggio dall'uso di dichiarazioni considerate dannose?

Question

Lo scopo dell'interfaccia IDisposable è di rilasciare le risorse non gestite in modo ordinato. Va di pari passo con la parola chiave using che definisce un ambito dopo il quale viene eliminata la risorsa in questione.

Poiché questo meachismo è così accurato, sono stato ripetutamente tentato di fare in modo che le classi implementino IDisposable in modo da abusare di questo meccanismo in modi per cui non è previsto. Ad esempio, si potrebbe implementare le classi per gestire contesti annidati in questo modo:

class Context : IDisposable 
{ 
    // Put a new context onto the stack 
    public static void PushContext() { ... } 

    // Remove the topmost context from the stack 
    private static void PopContext() { ... } 

    // Retrieve the topmost context 
    public static Context CurrentContext { get { ... } } 

    // Disposing of a context pops it from the stack 
    public void Dispose() 
    { 
     PopContext(); 
    } 
} 

uso nel chiamare il codice potrebbe essere simile a questo:

using (Context.PushContext()) 
{ 
    DoContextualStuff(Context.CurrentContext); 
} // <-- the context is popped upon leaving the block 

(Si prega di notare che questo è solo un esempio e non al argomento di questa domanda.)

Il fatto che venga richiamato lasciando l'ambito dell'istruzione using può anche essere sfruttato per implementare tutti i tipi di cose che dipendono dall'ambito, ad esempio temporizzatori. Questo potrebbe anche essere gestito utilizzando un costrutto try ... finally, ma in tal caso il programmatore dovrebbe chiamare manualmente un metodo (ad esempio Context.Pop), che il costrutto using potrebbe fare per thon.

Questo utilizzo di IDisposable non coincide con lo scopo previsto as stated in the documentation, tuttavia la tentazione persiste.

Ci sono ragioni concrete per illustrare che questa è una cattiva idea e dissipare le mie fantasie per sempre, ad esempio complicazioni con garbage collection, gestione delle eccezioni, ecc. O dovrei andare avanti e concedermi abusando di questo concetto di linguaggio in questo modo ?

Answer 1

Quindi, in asp.net vista MVC, vediamo la seguente costrutto:

using(Html.BeginForm()) 
{ 
    //some form elements 
} 

Un abuso? Microsoft dice no (indirettamente).

Se si dispone di un costrutto che richiede che succeda qualcosa, una volta che hai finito con esso, IDisposable spesso può lavorare fuori abbastanza bene. L'ho fatto più di una volta.

Answer 2

"È un abuso dell'interfaccia IDisposable utilizzarlo in questo modo"? Probabilmente.

L'utilizzo di using come un costrutto puramente "scoping" crea intenti più evidenti e una migliore leggibilità del codice? Certamente.

Quest'ultimo trionfa sul primo per me, quindi dico di usarlo.

Answer 3

Sicuramente non saresti il ​​primo a "abusare" in modo IDisposable in quel modo. Probabilmente il mio preferito l'uso di esso è in timer, come dimostra StatsD.NET client:

using StatsdClient; 
... 
using (statsd.LogTiming("site.db.fetchReport")) 
{ 
    // do some work 
} 
// At this point your latency has been sent to the server 

In realtà, sono abbastanza sicuro che Microsoft si utilizzano in alcune librerie. La mia regola generale sarebbe - se migliora la leggibilità, provaci.