È possibile scrivere C# in modo che gli oggetti vengano eliminati quando non rientrano nell'ambito di applicazione?

Question

Per esempio, nel seguente codice verrà creato un 'image'object e poi garbage collection ad un certo punto sconosciuto nel futuro

void MyFunction() { 

    Bitmap image = RetrieveImage(); 
    DoSomething(image); 
} 

Che dire

void MyFunction() { 

    DoSomething(RetrieveImage()); 

} 

in questo caso è l'oggetto raccolta dei rifiuti una volta fuori portata, vale a dire dopo la fine di MyFunction. Se no, c'è da qualche parte per far rispettare questo?

Answer 1

No. In realtà, non si vuole veramente che si tratti di garbage collection: il prompt del garbage collector molto spesso ridurrà le prestazioni.

Quello che fai vuoi è quello di disporre delle risorse non gestite in modo tempestivo - ed è qui che IDisposable entra, insieme con la using dichiarazione:

void MyFunction() 
{ 
    using (Bitmap image = RetrieveImage()) 
    { 
     DoSomething(image); 
    } 
} 

che chiamerà image.Dispose() in quanto lascia il using, indipendentemente dal fatto che DoSomething abbia fatto o meno un'eccezione.

Non è necessario utilizzare la variabile in più anche se - a meno che non si cambia DoSomething di prendere un Func<Bitmap> invece, così invece di:

void DoSomething(Bitmap image) 
{ 
    // Code here 
} 
... 
DoSomething(RetrieveImage()); 

avresti:

void DoSomething(Func<Bitmap> imageProvider) 
{ 
    using (Bitmap image = imageProvider()) 
    { 
     // Code here 
    } 
} 
... 
DoSomething(() => RetrieveImage()); 

Si noti che che non offre l'opportunità di passare in una bitmap senza da smaltire, il che potrebbe essere un problema se si desidera utilizzarlo nuovamente in un secondo momento. Comunque, è una buona tecnica per saperlo.

MODIFICA: come sottolineato da Mbeckish nei suoi commenti, non ci sono molti vantaggi rispetto allo smaltimento della bitmap entro RetrieveImage. Ecco una variante del modello però:

public void ApplyToEachLineInFile(string file, Action<string> action) 
{ 
    using (TextReader reader = File.OpenText(file)) 
    { 
     string line; 
     while ((line = reader.ReadLine()) != null) 
     { 
      action(line); 
     } 
    } 
} 

qui la logica "acquistare e cedere" è incapsulato, senza che il chiamante preoccuparsi - ma il chiamante può ancora essere molto flessibile in termini di complessità della logica passano poll.

Answer 2

La raccolta dei dati inutili non si verifica quando un oggetto non rientra nell'ambito. Piuttosto è una funzione di gestione automatica della memoria dal framework.

http://msdn.microsoft.com/en-us/magazine/bb985010.aspx

È possibile forzare .Net per raccogliere la spazzatura, ma a meno che non si verificano problemi di memoria gravi, io non consiglierei di andare su questa strada.

Answer 3

È possibile imporre Garbage Collection con:

System.GC.Collect()

dopo lo smaltimento in modo corretto (vedi Jons Risposta per l'uso() {} - Syntax).

< Modifica>

Non dimenticare (come ho appena fatto)

System.GC.WaitForPendingFinalizers();

dopo.

</Modifica>

Anche se non è raccomandato - come ha detto Jon.

Answer 4

NOTA: Non si vuole fare questo. Il garbage collector .NET è "più intelligente" di te (o io, o Jon Skeet o chiunque altro).

try 
{ 
    Bitmap image = RetrieveImage(); 
    DoSomething(image); 
} 
finally 
{ 
    GC.Collect(); 
} 

(questo è supponendo che nessuno degli oggetti che cadono fuori portata implementare IDisposable)