C # Posso annullare un oggetto di un'altra classe

Question

Ho un oggetto che viene generato in una classe

public class CreatingClass
{
    public T CreateObject<T>(Dictionary<string, object> parameters) where T : IMyInterface, new()
    {
        ....
    }

    public void DestroyObject(IMyInterface objectToDestroy)
    {
        ....
    }
}

Chiamo questa funzione da una classe client, quindi a volte devo annullarla attraverso la mia applicazione dalla classe che crea.

Posso fare qualcosa del tipo

public class ClientClass
{
    MyObject obj;
    CreatingClass creatingClass = new CreatingClass();

    private void AFunctionToCreateMyClass()
    {
        obj = creatingClass.CreateObject<MyClass>(parameters);
    }

    private void AFunctionToDeleteMyObject()
    {
        CreatingClass.DestroyObject(obj);
        Assert.IsNull(obj);//Doesn't fail
    }
}

Avevo provato objectToDestroy = null, ma non pensavo che avrebbe funzionato (e non ha funzionato)

Answer 1

Nota che non puoi effettivamente distruggere un oggetto; sei soggetto alle regole della raccolta dei rifiuti. Con un semplice clic, è possibile verificare IDisposable e chiamare Dispose (),

Puoi usare gli esempi ref forniti, ma non sono sicuro che ci sia molto da dire; è più semplice cancellare il campo con " obj = null; " ;.

L'utilizzo di ref potrebbe creare confusione, dal momento che funziona sulla variabile - vale a dire se si fa:

var tmp = obj;
DestroyObject(ref tmp);

quindi obj sarà comunque il valore originale. A meno che tu non abbia una buona ragione, non raccomando l'approccio ref .

Answer 2

Quello che vuoi è

public void DestroyClass(ref IMyInterface objectToDestroy)
{
    ....
    objectToDestroy = null;
}

Questo imposterà il riferimento locale su null

Answer 3

Tutti i parametri in C # vengono passati per valore, quindi se si desidera modificare il riferimento stesso, è necessario passarlo utilizzando la parola chiave ref .

Answer 4

Stai cercando il Motivo identificabile ?

Answer 5

[Il tuo 'CreatedClass' è generalmente definito una fabbrica]

Non so perché ti preoccuperesti di annullare un oggetto; sarà spazzatura raccolta solo dopo che tutti i riferimenti "root" sono stati rimossi. Ma se cambi in:

 public void DestroyClass(ref IMyInterface objectToDestroy)   
 {       
     ....    
     objectToDestroy = null;
 }

e chiama come:

private void AFunctionToDeleteMyObject()    
{        
   CreatingClass.DestroyObject(ref obj);    
   Assert.IsNull(obj);  
}

Answer 6

Un piccolo chiarimento sulle risposte fornite ...

I parametri in C # vengono passati per tipo, valore per tipi di valore, riferimento per tipi di riferimento. Tuttavia, stai passando un'interfaccia che potrebbe essere correlata a una classe (tipo di riferimento) o struct (tipo di valore), pertanto devi dichiararla esplicitamente come variabile ref.

Tuttavia, ciò che dovresti davvero seguire (come menzionato in precedenza) è il modello IDisposable, che è stato progettato per questa funzionalità.

EDIT: i parametri vengono passati per valore, ma per i tipi di riferimento il riferimento è il valore. Pertanto, si distrugge il riferimento nella funzione, il tipo di riferimento originale non è interessato. Se apporti una modifica alla variabile di riferimento, ovvero modificando i dati in un set di dati, il tipo di riferimento originale viene aggiornato al di fuori della funzione.