Comment faire pour supprimer l'objet?

J'ai besoin de créer une méthode de classe que de supprimer l'instance.

public class Car
{
    private string m_Color;

    public string Color
    {
        get { return m_Color; }
        set { m_Color = value; }
    }

    public Car()
    {
    }

    public void Delete()
    {
        /*This method will delete the instance,
        so any references to this instance will be now null*/
    }
}

class Program
{
    static void Main( string[] args )
    {
        Car car = new Car();

        car.Delete();

        if(car==null)
            Console.WriteLine("It works.");
        else
            Console.WriteLine("It doesn't work.")
    }
}

Je veux savoir si il existe une solution possible (même si il n'est pas recommandé) comment faire cela.

Instance de cette classe seront stockées dans des centaines de classe différente. Je vais essayer de le décrire, par exemple, il y aura ces classes:

public class CarKey
{
    private Car m_Car;

    public Car Car
    {
        get { return m_Car; }
    }

    public bool CarExist{ get{ return m_Car != null; } }

    public CarKey( Car car )
    {
        m_Car = car;
    }
}

public class Garages
{
     private List<Car> m_Collection = new List<Car>();

     private int m_Size;

     public int Size{ get{ return m_Size; } }

     public Garages( int size )
     {
         for(int i=0;i<size;i++)
             m_Collection.Add(null);
     }

     public bool IsEmpty( int garage )
     {
         return m_Collection[garage] == null;
     }

     public void InsertCar( Car car, int garage )
     {
          if( m_Collection[garage] != null )
            throw new Exception("This garage is full.");

          m_Collection[garage] = car;
     }


     public Car GetCar( int garage )
     {
         if( m_Collection[garage] == null )
           throw new Exception("There is no car, maybe it was deleted.");

         return m_Collection[garage];
     }
}

Au lieu de car.Delete() pourquoi ne pas tout simplement car = null?
/*Cette méthode permet de supprimer l'instance, de sorte que toute référence à cette instance sera maintenant null*/, de sorte que toutes les réponses sur null asigment sont incorrectes.
Je ne peux pas faire ça. Dans mon programme sera des centaines de références dans différents endroits et différents format, je ne peux pas les gérer.
Pourquoi avez-vous besoin de faire cela? Le garbage collector .NET va supprimer vos objets à partir de la mémoire quand il n'y a pas plus de références. De quoi êtes-vous en train d'essayer de réaliser que le garbage collector ne pas faire pour vous? Il semble que le problème réel que vous êtes confronté à est ailleurs, dans la conception. Métaphoriquement parlant, vous vous demandez comment faire pour exécuter l'Étape 5 mais vous avez pris un mauvais virage de retour à l'Étape 2.
Chers StackOverflow: au Lieu de venir avec des avec des moyens plus créatifs pour supprimer une instance, pourquoi ne pas vous essayer d'aider les OP à résoudre son problème? Il n'a pas besoin d'aide pour décider entre un Vieille Chaussure et une Bouteille en Verre.

OriginalL'auteur user1576055 | 2013-10-20

c#memory-management

13

De toute la classe, vous ne pouvez pas définir sa valeur à null. Ce n'est pas autorisé et ne fait pas de sens aussi -
```
public void Delete()
{
    this = null; <-- NOT ALLOWED
}
```
Vous avez besoin d'une instance de classe à l'appel de méthode Delete() alors, pourquoi ne pas l'instance null lui-même une fois que vous avez fini avec elle.
```
Car car = new Car();
//Use car objects and once done set back to null
car = null;
```
Enfin, ce que vous essayez de réaliser n'est pas possible en C#. Je soupçonne
de votre question que vous voulez parce qu'il y a des fuites de mémoire
présent dans votre conception actuelle qui ne laisse pas la Voiture instance de
aller loin. Je vous suggère de mieux profil de votre application et
identifier les domaines qui est l'arrêt de GC pour recueillir voiture instance et
travail sur l'amélioration de cette zone.

Avec cette commande, vous réglez la voiture de référence à la valeur null s'il n'y a d'autres références pour le même objet, ils pointent toujours vers le même objet.
C'est ce que j'ai mentionné dans la réponse qu'il n'est pas possible de le faire de cette façon.

OriginalL'auteur Rohit Vats

Je dirais , à utiliser .Net de l'interface IDisposable, si vous êtes à la pensée de la libération de l'instance après son utilisation.

Voir un exemple de mise en œuvre ci-dessous.

public class Car : IDisposable
{

   public void Dispose()
   {  
      Dispose(true);
       //any other managed resource cleanups you can do here
       Gc.SuppressFinalize(this);
   }
   ~Car()      //finalizer
   {
        Dispose(false);
   }

   protected virtual void Dispose(bool disposing)
   {
     if (!_disposed)
     {
      if (disposing)
      {
        if (_stream != null) _stream.Dispose(); //say you have to dispose a stream
      }

      _stream = null;
    _disposed = true;
    }

   }
}

Maintenant dans votre code:

void main()
{
   using(var car = new Car())
   {
     //do something with car
   } //here dispose will automtically get called. 
}

Pourquoi faites-vous appel à SupressFinalize dans ce cas? Il n'y a rien à finaliser.. même si l'OP a défini un Finaliseur.
merci de remarquer. My bad , j'ai été peu paresseux expliquer les choses. Maintenant mis à jour l'ensemble de la mise en œuvre..

OriginalL'auteur

Cela sonne comme vous avez besoin de créer un wrapper autour d'une instance vous pouvez invalider:

public class Ref<T> where T : class
{
    private T instance;
    public Ref(T instance)
    {
        this.instance = instance;
    }

    public static implicit operator Ref<T>(T inner)
    {
        return new Ref<T>(inner);
    }

    public void Delete()
    {
        this.instance = null;
    }

    public T Instance
    {
        get { return this.instance; }
    }
}

et vous pouvez l'utiliser comme:

Ref<Car> carRef = new Car();
carRef.Delete();
var car = carRef.Instance;     //car is null

Sachez toutefois que si aucun code enregistre l'intérieur de la valeur dans une variable, ce ne sera pas invalidé par l'appel de Delete.

OriginalL'auteur Lee

3

Ce que vous demandez n'est pas possible. Il n'y a pas de mécanisme .Net qui permettrait de définir toutes les références à un objet à null.

Et je pense que le fait que vous essayez de faire cela indique une sorte de problème de conception. Vous devez probablement penser le problème sous-jacent et de le résoudre d'une autre manière (les autres réponses ici à proposer certaines options).

OriginalL'auteur svick
1

Vous ne pouvez pas supprimer un objet géré dans le C# . C'est pourquoi est appelé langage MANAGÉ. Si vous n'avez pas à troble vous-même avec les supprimer (tout comme en c++).

Il est vrai que vous pouvez définir c'est l'instance à null. Mais cela ne va pas vous aider à ce que beaucoup parce que vous n'avez pas le contrôle de votre GC (Garbage collector) pour supprimer des objets en dehors de Recueillir. Et ce n'est pas ce que vous voulez, car cela permettra de supprimer tous votre collection de toute une génération.

Alors, comment est-il fait alors ? Donc : GC recherche régulièrement des objets qui ne sont plus utilisés et il supprime l'objet avec un mécanisme interne qui ne devrait pas vous préoccuper.
```
When you set an instance to null you just notify that your object has no referene anymore ant that could help CG to collect it faster !!!
```
GC.Collect recueille toutes les générations.. pas seulement "une génération".
Whitehead mon pardon . Oui, en effet!
J'ai pensé qu'il ne sera pas possible de le faire. Je vais utiliser une base de données pour le stockage de données à la place d'instances. Parce que si je supprimer des données dans la base de données, toutes les références données dans la base de données sera automatiquement nulle, c'est ce qui est stupide, la langue ne peut pas faire. Je ne comprends pas pourquoi il suffit de chose ne peut pas être fait, C# savoir où il sauver son insatnces alors pourquoi l'enfer, il ne peut pas les supprimer ?!
C'est pourquoi, il est appelé un langage sûr. Je pense que ma réponse était correcte. Si vous voulez débat il en est ainsi : En c++ on peut souvent rencontrer des situations dans lesquelles un objet a de l'instance supprimé ou déplacé, et de tels cas peuvent conduire à des fuites de mémoire. C'est pourquoi un géré la langue est dit d'être en sécurité. Vous pouvez surrely désactiver le coffre de la directive et de jouer à l'insécurité des blocs à l'intérieur d'un langage c#. Pour vaincre dans une certaine meassure la purposse d'un langage managé. Essayez-le avec un si qui répondent mieux à vos besoins .
Savez-vous comment faire pour supprimer l'instance avec le code unsafe ? Selon la documentation MSDN seulement les structures et certains types de base (par exemple int, long, double, etc.) peut être consulté par le pointeur. Mais j'ai besoin d'accéder à l'instance de ma classe de Voiture et de le supprimer.

OriginalL'auteur Iulian Radulescu
1

Utiliser une collection qui est une propriété statique de votre Car classe.
Chaque fois que vous créez une nouvelle instance d'un Car, stocker la référence dans cette collection.

De détruire tous les Cars, il suffit de mettre tous les éléments à null.

Ce n'est pas de fournir une réponse à la question. À la critique ou à la demande de clarification d'un auteur, de laisser un commentaire en dessous de leur poste, vous pouvez toujours commenter vos propres messages, et une fois que vous avez suffisamment de réputation vous serez en mesure de commentaire sur post.
Je pense que c'EST la réponse pourquoi êtes-vous en désaccord?
Je suis nouveau et je ne savais pas que vous pouviez mettre des mots dans ma bouche, je suis en colère ! Je pense également qu'il doit être la référence de la référence. Parce que vous ne voulez pas null votre collection, mais tout utilisateur créé des instances.
Si rien d'autre avait aussi une référence aux éléments de cette collection, alors l'objet ne serait pas le garbage collector.

OriginalL'auteur user3761570
0

Vous pouvez proxyfy références à votre objet avec, par exemple, un dictionnaire, un singleton. Vous pouvez stocker pas l'objet, mais son ID ou de hachage et d'accès trought le dictionnaire. Puis, quand vous avez besoin de retirer l'objet que vous définissez la valeur de sa clé null.

OriginalL'auteur FLCL
-1

Vous pouvez utiliser des méthodes d'extension pour arriver à cela.
```
public static ObjRemoverExtension {
    public static void DeleteObj<T>(this T obj) where T: new()
    {
        obj = null;
    }
}
```
Et puis vous venez d'importer dans le fichier source et l'utiliser sur n'importe quel objet. GC permettra de recueillir. Comme ceci:Car.DeleteObj()

MODIFIER
Désolé de ne pas remarquer la méthode de la classe/toutes les références de la partie, mais je vais laisser ça de toute façon.

L'OP n'est pas à la recherche d'un cadeau d'appel myCar = null, mais un moyen de forcer toutes les tenues des instances de l'ensemble du système afin d'être invalidée.
Encore une fois, "Supprimer" n'est pas le bon terme pour cela. Vous êtes à la définition d'une référence à null.. pas la suppression d'un objet. Il est encore dans la mémoire jusqu'à ce que le garbage collector décide de le supprimer. C'est quand il est supprimé.

OriginalL'auteur Stanislav Ageev

Vous devez vous connecter pour publier un commentaire.