restituire la variabile utilizzata per l'utilizzo all'interno del usando C#

Question

sto tornando la variabile che sto creando in un utilizzando istruzione all'interno l'istruzione using (suona strano):

public DataTable foo() 
{ 
    using (DataTable properties = new DataTable()) 
    { 
     // do something 
     return properties; 
    } 
} 

sarà questo Smaltire le proprietà delle variabili ??

Dopo aver fatto questo ancora sto ottenendo questo avvertimento:

Attenzione 34 CA2000: Microsoft.Reliability: Nel metodo 'test.test', chiamare System.IDisposable.Dispose sull'oggetto 'proprietà' prima che tutti i riferimenti a è fuori portata.

Qualsiasi idea?

Grazie

Answer 1

Se si desidera tornare, non si può avvolgere in un comunicato using, perché una volta che si lascia le parentesi graffe, che va fuori del campo di applicazione e viene smaltito.

Si dovrà creare un'istanza in questo modo:

public DataTable Foo() 
{ 
    DataTable properties = new DataTable(); 
    return properties; 
} 

e chiamare Dispose() in seguito.

Answer 2

Sì. Perché stai usando la parola chiave using su qualcosa che non vuoi essere eliminato alla fine del blocco di codice?

Lo scopo della parola chiave using è quello di eliminare l'oggetto.

http://msdn.microsoft.com/en-us/library/yh598w02.aspx

Answer 3

Sì, disporrà - e poi restituirlo. Questa è quasi sempre una brutta cosa da fare.

Infatti per DataTable, Dispose quasi mai fa nulla (ad eccezione se è remotato da qualche parte, IIRC) ma è ancora una cattiva idea. Normalmente si dovrebbe considerare inutilizzabili gli oggetti dismessi.

Answer 4

Il punto di un blocco using è creare un ambito artificiale per un valore/oggetto. Al termine del blocco using, l'oggetto viene ripulito perché non è più necessario. Se vuoi davvero restituire l'oggetto che stai creando, allora non è il caso in cui vuoi usarlo.

Questo funzionerà bene.

public DataTable foo() 
{ 
    DataTable properties = new DataTable(); 
    // do something 
    return properties; 
} 

Answer 5

il codice utilizzando la parola chiave utilizzando espande a:

{ 
    DataTable properties = new DataTable(); 
    try 
    { 
     //do something 
     return properties; 
    } 
    finally 
    { 
     if(properties != null) 
     { 
      ((IDisposable)properties).Dispose(); 
     } 
    } 
} 

La variabile è in via di dismissione dalla natura di come utilizzare opere. Se si desidera poter restituire le proprietà, non avvolgerle in un blocco di utilizzo.

Answer 6

Presumibilmente, questo è lo schema per un metodo factory che crea un oggetto monouso.Ma, ho ancora visto analisi del codice lamentano anche questo:

 Wrapper tempWrapper = null; 
     Wrapper wrapper = null; 

     try 
     { 
      tempWrapper = new Wrapper(callback); 
      Initialize(tempWrapper); 

      wrapper = tempWrapper; 
      tempWrapper = null; 
     } 
     finally 
     { 
      if (tempWrapper != null) 
       tempWrapper.Dispose(); 
     } 

     return wrapper; 

Questo dovrebbe garantire che se l'inizializzazione fallisce, l'oggetto viene correttamente smaltito, ma se tutto riesce, un'istanza undisposed viene restituito dal metodo .

MSDN Articolo: CA2000: Dispose objects before losing scope.

Answer 7

Le altre risposte sono corrette: non appena si esce dal blocco using, l'oggetto viene eliminato. Il blocco using è ottimo per assicurarsi che un oggetto venga smaltito in modo tempestivo, quindi se non si vuole fare affidamento sugli utenti della funzione per ricordare di smaltire l'oggetto in un secondo momento, è possibile provare qualcosa del genere:

public void UsingDataContext (Action<DataContext> action) 
{ 
    using (DataContext ctx = new DataContext()) 
    { 
     action(ctx) 
    } 
} 

questo modo si può dire qualcosa di simile:

var user = GetNewUserInfo(); 
UsingDataContext(c => c.UserSet.Add(user));