Comment et quand sont c# Static membres éliminés?

J'ai une classe avec de nombreuses membres statiques, certains de ceux qui gardent les références aux gérés et non gérés objets.

Par exemple, le constructeur statique est appelée dès que le Type est référencé, ce qui provoque ma classe de spin un blockingQueue de Tâches. Cela se produit lorsque l'une des méthodes statiques est appelé, par exemple.

J'ai mis en place IDisposable, ce qui me donne des méthodes pour gérer disposition sur toute instance objets que j'ai créé. Cependant, ces méthodes ne sont jamais appelés, si le consommateur ne crée pas des objets d'instance de ma classe.

Comment et où dois-je mettre le code de disposer de références maintenu par la partie statique de ma classe? J'ai toujours pensé que l'élimination de l'électricité statique ressources référencées qui s'est passé lors de la dernière instance de l'objet a été publié; c'est la première fois que j'ai jamais créé une classe où aucune instance ne peut jamais être créé.

  • Des éléments statiques sont disponibles pour l'ensemble de l'exécution de l'application. Vous ne créez pas d'éléments statiques en utilisant le NOUVEAU mot-clé, donc cela signifie que vous n'avez pas plusieurs instances de quoi que ce soit, car vous n'avez pas instancier quoi que ce soit. Sur les objets gérés, ne vous inquiétez pas à ce sujet, l'GC de prendre soin d'eux. À propos de ressources non managées, essayez de les utiliser dans un non statique de la classe, ou ils seront conservés jusqu'à ce que vous fermez votre application. Des éléments statiques ne supportent pas la jeter.
  • Merci. Semble que j'ai besoin de revoir ma conception ici.
InformationsquelleAutor Joe | 2012-08-25
  1. 46

    La variable statique de votre classe ne sont pas des ordures collectées jusqu'à ce que le domaine d'application de l'hébergement de votre classe est déchargée. Le Dispose() méthode ne sera pas appelé, parce que c'est une méthode d'instance, et vous avez dit que vous ne créez pas de toutes les instances de votre classe.

    Si vous souhaitez faire usage de la Dispose() méthode, faites votre objet singleton, créer une instance de celle-ci, et d'en disposer de façon explicite lorsque votre application est sur le point de quitter.

    public class MyClass : IDisposable {
    public IList List1<int> {get; private set;}
    public IDictionary<string,string> Dict1 {get; private set;}
    public void Dispose() {
        //Do something here
    }
    public static MyClass Instance {get; private set;}
    static MyClass() {
        Instance = new MyClass();
    }
    public static void DisposeInstance() {
        if (instance != null) {
            Instance.Dispose();
            Instance = null;
        }
    }
}
    • Qui fait sens. Je me doutais que je pourrais avoir à utiliser un Singleton patter finalement sur ce... merci pour votre aide.
    InformationsquelleAutor dasblinkenlight
  2. 0

    Vous devez disposer de ce manuellement les objets, il n'y a aucun moyen de créer un "outil de finalisation" pour les ressources statiques.

    • Comment puis-je éliminer manuellement? Comment serai-je informé que j'ai besoin de faire cela?
    • C'est entièrement à vous de décider. Seulement, vous savez quand il est temps d'appeler Disposer de quelque chose qui est statiquement tenue.
    • Par exemple, voir l'exemple de la question d'origine, où j'ai lancer un blockingQueue d'Actions. Cette file d'attente doit s'exécuter jusqu'à ce que l'utilisateur ne veut plus drop en elle (via la méthode statique). Permettez-moi de rendre cela plus clair; quand dois-je tuer à la tâche que les drains que la file d'attente? Donc, quand dois-je le tuer? Comment savoir que ma classe n'est plus dans le "champ d'application" pour l'utilisateur?
    • Vous pouvez par exemple utiliser des variable de type entier pour stocker des consommateurs de ressources count (incrémenter/décrémenter par Interlocked classe dans le constructeur/destructeur/débarrasser de la méthode).
    • Permettez-moi de clarifier toutes mes modifications ci-dessus. En particulier, je maintiens une blockingQueue des Actions pour un enregistreur. Lorsqu'un utilisateur veut avoir quelque chose de connecté, il appelle ma méthode statique Journal, et j'ai drop une Action dans le blockingQueue que les appels de l'enregistreur. J'ai une Tâche séparée, créé par mon constructeur statique, qui draine cette file d'attente. Cette file d'attente et la tâche qui drainent il devrait rester en place "pour toujours", ou au moins jusqu'à ce que mon montage est déchargé. Alors - quand dois-je tuer cette Tâche? Est-il une notification que mon montage n'est plus nécessaire, pour que je puisse nettoyer à l'autre (non géré) ressources?
    • Seulement 6 ans plus tard.... Pourquoi ne pas avoir l'utilisateur vous dire quand ils sont finis? Sinon, comment vous savez qu'ils sont fait à l'aide? Ou avoir un objet de contexte de qui encapsule les jetables que l'utilisateur dispose d'un quand ils ont terminé. (Les Singletons sont pratiques, et pour cette raison, ils sont souvent galvaudé. Je suis très coupable de ce moi-même au fil des années.)

    InformationsquelleAutor oxilumin
  3. 0
    public class Logger : IDisposable
{

    private string _logDirectory = null;
    private static Logger _instance = null;

    private Logger() : this(ConfigurationManager.AppSettings["LogDirectory"])
    {
        AppDomain.CurrentDomain.ProcessExit += CurrentDomain_ProcessExit;
    }

    private Logger(string logDirectory) 
    {
    } 

    public static Logger Instance
    {
        get
        {
            if (_instance == null)
                _instance = new Logger();
            return _instance;
        }
    }

    private void CurrentDomain_ProcessExit(object sender, EventArgs e)
    {
        Dispose();
    }



    public void Dispose()
    {
        //Dispose unmanaged resources
    }
}
    InformationsquelleAutor Guido Kleijer
  4. -1

    Si vous voulez vraiment avoir des membres statiques qui permettent de garder des références à des objets managés
    il suffit de créer une méthode pour éliminer les objets managés et de la "force" des consommateurs à utiliser à la sortie.

    Par "force", je veux dire d'un document de votre classe avec un paragraphe qui stipule que "quand" et "pourquoi" pour utiliser cette "jeter" de la méthode.
    Soit si vous êtes le seul consommateur (ou votre code...) ou que vous envisagez de distribuer votre classe.
    Également essayer d'utiliser en quelque sorte un nom descriptif (pour que "jeter" de la méthode) comme "DisposeStatics", "AlwaysDispose", "DisposeAtEnd" etc.

    InformationsquelleAutor ilias iliadis