Est-il possible par exemple de détruire/supprimer soi-même?

Votre question est très intéressante, et je ne connais pas d'autre façon de le faire en C#, mais à force de l'intérieur de l'instance de sa destruction de l'extérieur. C'est donc ce que j'ai trouvé pour vérifier s'il est possible.
Vous pouvez créer la classe Foo, qui a de l'événement est déclenché lorsque l'intervalle du timer est écoulé. La classe qui est inscrit à cet événement (Bar) dans les cas de registres de l'événement et définit la référence de l'instance de null. C'est comment j'allais le faire, testé et il fonctionne.

public class Foo
{
    public delegate void SelfDestroyer(object sender, EventArgs ea);

    public event SelfDestroyer DestroyMe;

    Timer t;

    public Foo()
    {
        t = new Timer();
        t.Interval = 2000;
        t.Tick += t_Tick;
        t.Start();
    }

    void t_Tick(object sender, EventArgs e)
    {
        OnDestroyMe();
    }

    public void OnDestroyMe()
    {
        SelfDestroyer temp = DestroyMe;
        if (temp != null)
        {
            temp(this, new EventArgs());
        }
    }
}

public class Bar
{
    Foo foo;
    public Bar()
    {
        foo = new Foo();
        foo.DestroyMe += foo_DestroyMe;
    }

    void foo_DestroyMe(object sender, EventArgs ea)
    {
        foo.DestroyMe -= foo_DestroyMe;
        foo = null;
    }
}

Et pour tester cela, vous pouvez configurer un clic sur un bouton dans un Formulaire, quelque chose comme cela, et de le vérifier dans le débogueur:

Bar bar = null;
private void button2_Click(object sender, EventArgs e)
{
       if(bar==null)
             bar = new Bar();
}

Alors la prochaine fois quand vous cliquez sur le bouton, vous serez en mesure de voir que Bar instance existe toujours mais la Foo instance dans un délai de elle est nulle même si elle a été créée au sein de la Bar'constructeur.

OriginalL'auteur Nikola Davidovic

Non, il n'y a aucun moyen d'obtenir ce que vous essayez de faire en C#.

Si vous considérez un exemple :

public class Kamikadze {

     ......             
     private void TimerTick(..) 
     {
        ....
        if(itsTime) {
            DestroyMe();
        }
     }

     .....
}


var kamikadze = new Kamikadze ();

après un certain temps DestroyMe() sera appelé que nettoie interne de données.

Mais la référence kamikadze (pointeur si vous le souhaitez) est toujours valide et points à cet emplacement de la mémoire, de sorte GC ne rien faire, à ne pas recueillir, et de l'instance de Kamikadze restera en mémoire.

OriginalL'auteur Tigran

La chose la plus proche en C# que je peux penser:

Sur la création, chaque objet stocke une référence à lui-même à la racine de la rp, par exemple en mettant la référence dans une classe statique de la liste. En dehors de la classe, personne n'est autorisé à stocker (fort) les références à l'objet. Tout le monde utilise un WeakReference et vérifie si le Target est encore IsAlive avant de toucher l'objet. De cette façon, la seule chose qui est de garder l'objet vivant, c'est la référence statique.

Lorsque l'objet décide de tuer lui-même, il supprime simplement la référence de la liste. Tôt ou tard, le GC recueille l'objet. Ou, si vous êtes vraiment impatient, appel GC.Collect() (ouch!).

Mais j'ai vraiment vraiment recommande pas cette solution!

C'est beaucoup mieux de mettre quelques-drapeau dans la classe/objet de signal s'il est encore en vie et de faire tout le monde de vérifier ce drapeau avant d'utiliser l'objet. Ceci peut être combiné avec le IDisposable solution.

OriginalL'auteur Sebastian Negraszus