C# - Question de disposition liée à la conception (prendre deux)

Question

J'ai posé une question plus tôt aujourd'hui, mais je pense que je dois l'aborder d'une manière différente (en plus de cela il y avait un "raccrocher" en ce qui concerne DataSet) .

est ici une classe qui encapsule la création d'une police (autrement dit, il est en train de lire les données à partir d'un fichier xml et crée une police, lors de l'exécution, en fonction de ce qu'il lit dans ce fichier):

public class FontCreator 
{ 
    private Font m_TheFont = null; 

    public FontCreator(... some parameters ...) 
    { 
     m_TheFont = GetTheFont(); 
    } 

    public Font TheFont 
    { 
     return m_TheFont; 
    } 

    private Font GetTheFont() 
    { 
     // code, and more code, that eventually leads to: 

     Font f = new Font(fntFamily, fntSize, fntStyle); 
     return f; 
    } 
} 

le consommateur de la classe FontCreator ressemble à quelque chose comme:

public class TheConsumer() 
{ 
    private FontCreator m_FontCreator = null; 

    public TheConsumer() 
    { 
     m_FontCreator = new m_FontCreator(... some parameters ...); 
     Initialize(); 
    } 

    private void Initialize() 
    { 
     InitializeThis(); 
     InitializeThat(); 
    } 

    private void InitializeThis() 
    { 
     .... some code ... 
     SomeObject.ApplyFont(m_FontCreator.TheFont); 
    } 

    private void InitializeThat() 
    { 
     ... some code ... 
     SomeObject.ApplyFont(m_FontCreator.TheFont); 
    } 
} 

Quel code ajoutez-vous, et où, pour faire en sorte que « TheFont » de méthode Dispose est explicitement appelé?

Answer 1

Si vous ne souhaitez pas conserver une référence à TheFont après avoir été d'abord utilisé, puis appeler sa méthode Dispose dans votre constructeur, juste après Initialize. Si vous souhaitez conserver TheConsumer en vie pendant un certain temps et maintenir une référence à TheFont, cela devient plus intéressant. Deux options:

1. Vous pouvez faire appel à la méthode d'élimination de TheFont à partir du Destructeur de l'objet TheConsumer. Ce n'est pas la pratique courante et a des problèmes. Principalement, ce n'est pas appelé jusqu'à ce que la collecte des ordures se passe. Mieux vaut:
2. Vous pouvez rendre l'objet TheConsumer implémenter IDisposable et appeler TheFont.Dispose depuis TheConsumer.Dispose. Puisque TheConsumer implémente IDisposable, le code qui utilise it devrait appeler sa méthode Dispose.

Modifier en réponse à un commentaire dur! Oui, j'aurais dû préciser de n'utiliser que 1 en plus à 2, voire pas du tout. Je sais que tous les développeurs sont supposés à remarquer quand IDisposable est implémenté, mais ils ne le font souvent pas. Si la ressource gérée référencée peut vraiment rester longtemps et causer des problèmes si elle n'est pas correctement éliminée, j'ai parfois un appel de méthode de sécurité Dispose() dans le destructeur de l'objet contenant la référence. Est-ce que c'est si faux? :)

Answer 2

public TheConsumer() 
{ 
    using (m_FontCreator = new m_FontCreator(... some parameters ...)) 
    { 
     Initialize(); 
    } 
} 

Answer 3

Je suis confus, si vous voulez utiliser rapidement l'objet creater de la police puis mettre en œuvre IDisposable sur le FontCreater et utiliser

using(m_FontCreator = new FontCreater(....)) 
{ 
    InitializeThis(); 
    InitializeThat(); 
} 

Si vous devez garder l'instance de la FontCreater par la durée de vie TheConsumer , puis implémentez IDisposablesur les deux classesFontCreater et TheConsumer.

public class TheConsumer : IDisposable 
{ 
    void Dispose() 
    { 
    if(m_FontCreator != null) 
      m_FontCreator.Dispose(); 
    } 
} 

puis utilisez TheConsumer classe comme si

using(TheConsumer consumer = new TheConsumer(....)) 
{ 
    .... 
} 

Answer 4

Réponse 1: éviter. Ne gardez pas les objets contenant des ressources non gérées plus longtemps que nécessaire.

Réponse 2: Si vous avez besoin des champs incorporés comme indiqué dans votre code, les classes FontCreator et Consumer doivent implémenter IDisposable. Mais pas un destructeur (Finalizer).
L'argument principal pour cela est que FontCreator est le «propriétaire» de la police et devrait donc prendre la responsabilité. Et le Consommateur est responsable du Créateur de la même manière.

Comme d'autres l'ont noté, il semble que vous pouvez au moins éviter le champ m_FontCreator dans la classe Consumer. Mais cela dépend du reste du code, m_FontCreator est-il utilisé ailleurs?