Come gestire gli oggetti usa e getta a cui non si fa riferimento?

Question

Se si dispone di un pennello e la penna come in:

Brush b = new SolidBrush(color); 
Pen p = new Pen(b); 

e smaltire in questo modo:

b.Dispose(); 
p.Dispose(); 

Come ti smaltire se fosse:

Pen p = CreatePenFromColor(color) che creerebbe il pennello e penna per te? Non riesco a smaltire il pennello all'interno di questo metodo, giusto?

È un metodo da non utilizzare con gli oggetti monouso?

EDIT: Che cosa intendo dire, come smaltire la SPAZZOLA?

Answer 1

È il lavoro del metodo CreatePenFromColor per eliminare l'istanza di Pennello.Non è ovvio a colpo d'occhio, ma se si scava nell'implementazione della classe Pen si vedrà che non si blocca sull'istanza di Brush passata. Invece lo usa solo per calcolare alcuni valori. Quindi non c'è alcun motivo per cui l'istanza di Brush vada oltre la chiamata a CreatePenFromColor e il metodo dovrebbe eliminare l'istanza.

Answer 2

È ancora necessario smaltirlo quando hai finito.

Ad esempio, è possibile chiamare in questo modo:

using (Pen p = CreatePenFromColor(color)) 
{ 
    // do something 
} 

Se un metodo restituisce un oggetto IDisposable, è vostro dovere di disporre di esso.

[Modifica] Ora ho ottenuto la domanda: si sta utilizzando il costruttore Pen (Brush b).

a. In questo caso, sembra che la penna non ha bisogno l'istanza pennello dopo costruttore, in modo che il metodo potrebbe essere la seguente:

public Pen CreatePenFromColor(Color c) 
{ 
    using (Brush b = new SolidBrush(c)) 
    { return new Pen(b); } 
} 

b. Perché non usare semplicemente Pen(Color color)?

public Pen CreatePenFromColor(Color c) 
{ 
    return new Pen(c); 
} 

c. (per quanto riguarda il commento) Se la Penna trattiene un riferimento al Pennello internamente, allora non si potrebbe disporne prima di aver terminato con la Penna. In tal caso, vorrei andare per una classe che avrebbe fatto il lavoro per me:

public class PenHelper : IDisposable 
{ 
    private readonly Brush _brush; 
    public PenHelper(Color color) 
    { 
     _brush = new SolidBrush(color); 
    } 

    public Pen CreatePen() 
    { 
     return new Pen(_brush); 
    } 

    public void Dispose() 
    { 
     _brush.Dispose(); 
    } 
} 

e quindi utilizzarlo in questo modo:

using (PenHelper penHelper = new PenHelper(Color.Black)) 
{ 
    using (Pen pen = penHelper.CreatePen()) 
    { 
      // do stuff 
    } 
} 

Diniego: IDisposable non è implementata secondo le linee guida, ma piuttosto per la sola dimostrazione. Inoltre, l'intero esempio viene utilizzato solo per mostrare come incapsulare un riferimento quando necessario. Dovresti andare a Pen (colore), ovviamente.

Answer 3

Quando un metodo rilascia un'istanza IDisposable, passa simultaneamente alla responsabilità di gestione a vita.

Ora è la responsabilità del chiamante di smaltire l'oggetto dopo l'uso. Se quell'oggetto contiene altri oggetti IDisposabili, per convenzione dobbiamo aspettarci che il contenitore disponga correttamente dei suoi figli quando lo smaltiamo, altrimenti implicherebbe un bug nel contenitore.

Nel vostro esempio concreto, dovreste aspettarvi che la Penna smaltisca la sua istanza di Pennello interna quando la smaltite.

Answer 4

Il tuo problema non ha una soluzione generale.

Nel tuo esempio specifico, non è un problema, perché Pen ha un costruttore che prende direttamente un Colore.

Alcune classi disporranno direttamente i parametri del costruttore (in particolare le classi relative al flusso); controlla ogni classe in Reflector.

Se la classe restituita eredita da Component, è possibile aggiungere un gestore all'evento Disposed.

Se la classe che si sta restituendo non è sigillata, è possibile creare una versione ereditata che dispone l'oggetto da cui è stato creato.

Infine, se lo si desidera, è possibile creare una classe wrapper che contiene l'oggetto che si sta restituendo e dispone il parametro del costruttore. Tuttavia, sarebbe molto confuso e non lo consiglierei.

Answer 5

Uno dei miei problemi con molte delle classi relative alla grafica è che non esiste un modello coerente per la gestione di tali problemi. Ciò che è veramente necessario è un mezzo per implementare il conteggio parziale dei riferimenti. Non nello stile COM, dove il passaggio dei riferimenti richiede il costante aumento dei conteggi dei riferimenti, ma in un modo in base al quale, dato un oggetto grafico IDisposable, è possibile richiedere un'altra istanza che condivide la stessa risorsa sottostante. Le risorse stesse verrebbero incapsulate in un oggetto condiviso con un contatore di riferimento. La creazione di un'altra istanza di riferimento incrementerebbe il contatore; chiamare Dispose su un'istanza di riferimento lo ridurrebbe. Ciò eviterebbe il 95% del sovraccarico del conteggio dei riferimenti, pur mantenendo il 99% del vantaggio.