La journalisation à côté d'une implémentation est-elle une violation SRP?

Lorsque la pensée du développement logiciel agile et tous les principes (SRP, OCP, ...) Je me demande comment l'exploitation forestière plaisir.

La journalisation à côté d'une implémentation est-elle une violation SRP?

yesJ'ai vérifié des motifs et est venu à la conclusion que la meilleure façon de ne pas violer les principes d'une manière définie par l' utilisateur, à utiliser toute forme qui est connu pour violer un principe est d'utiliser un modèle de décorateur.

Disons que nous avons un tas de composants complètement sans violation de SRP et nous voulons ajouter la journalisation.

• le composant A
• le composant B utilise un

Nous voulons que l'exploitation forestière A, donc nous créons un autre élément D ornée d'une fois mise en œuvre d'une interface I.

• interface I
• composante L (composante identification du système)
• le composant A implémente I
• Composant D instruments I, décore / A utilise, L utilise pour l'exploitation forestière
• le composant B utilise un I

Avantages: - Je peux utiliser une sans vous connecter - test A moyen Je ne pas besoin de se moque d'exploitation - les tests sont plus simples

Inconvénient: - plus de composants et plus de tests

Je sais que cela semble être une autre question ouverte de discussion, mais je veux vraiment savoir si quelqu'un utilise de meilleures stratégies d'exploitation forestière que la violation décorateur ou SRP.

Oui, il s'agit d'une violation de SRP car la journalisation est une préoccupation transversale.

La bonne façon est de déléguer la journalisation à une classe de journalisation (Interception) dont le seul but est de se conformer au protocole SRP.

Voir ce lien pour un bon exemple: https://msdn.microsoft.com/en-us/library/dn178467%28v=pandp.30%29.aspx

Voici un petit exemple :

public interface ITenantStore
{
    Tenant GetTenant(string tenant);
    void SaveTenant(Tenant tenant);
}

public class TenantStore : ITenantStore
{
    public Tenant GetTenant(string tenant)
    {....}

    public void SaveTenant(Tenant tenant)
    {....}
} 

public class TenantStoreLogger : ITenantStore
{
    private readonly ILogger _logger; //dep inj
    private readonly ITenantStore _tenantStore;

    public TenantStoreLogger(ITenantStore tenantStore)
    {
        _tenantStore = tenantStore;
    }

    public Tenant GetTenant(string tenant)
    {
        _logger.Log("reading tenant " + tenant.id);
        return _tenantStore.GetTenant(tenant);
    }

    public void SaveTenant(Tenant tenant)
    {
        _tenantStore.SaveTenant(tenant);
        _logger.Log("saving tenant " + tenant.id);
    }
}

Les avantages comprennent

• Vous pouvez tester cela sans vous connecter - de vrais tests unitaires
• vous pouvez facilement activer / désactiver la connexion, même lors de l'exécution
• vous pouvez remplacer la journalisation par d'autres formes de journalisation, sans jamais avoir à modifier le fichier TenantStore.

Je dirais que vous prenez SRP beaucoup trop au sérieux. Si votre code est suffisamment ordonné pour que la journalisation soit la seule "violation" de SRP, vous réussissez mieux que 99% de tous les autres programmeurs, et vous devriez vous féliciter.

Le point de SRP est d'éviter le code horrible spaghetti où le code qui fait des choses différentes sont brouillées ensemble. l'exploitation forestière de mélange avec le code fonctionnel ne sonne pas la sonnette d'alarme pour moi.

Non, ce n'est pas une violation de SRP.

Les messages que vous envoyez dans le journal devrait changer pour les mêmes raisons que le code environnant.

Ce qui est une violation du SRP utilise une bibliothèque spécifique pour se connecter directement dans le code. Si vous décidez de changer le mode de l'exploitation forestière, SRP affirme qu'il ne devrait pas influer sur votre code d'entreprise.

Une sorte de résumé Loggerdoit être accessible à votre code de mise en œuvre, et la seule chose que votre mise en œuvre devrait dire est « Envoyer ce message au journal », sans préoccupations wrt comment faire. Décider de la façon exacte de l' exploitation forestière (même timestamping) n'est pas la responsabilité de votre mise en œuvre.

Votre mise en œuvre doit alors également savoir pas si l'enregistreur , il envoie des messages à un NullLogger.

Cela dit.

Je n'abandonnerais pas trop vite l'abattage comme une préoccupation transversale . Journaux pour retrouver la trace émettant des événements spécifiques qui se produisent dans votre code de mise en œuvre appartient au code de mise en œuvre.

Ce qui est une préoccupation transversale, OTOH, est l' exécution de traçage : l' exploitation forestière entre et sort dans chaque méthode. L'AOP est le mieux placé pour le faire.

Comme l'exploitation forestière est souvent considérée comme un problème transversal je suggère d'utiliser AOP pour séparer l'exploitation de la mise en œuvre.

Selon le langage, vous utiliseriez un intercepteur ou un cadre AOP (par exemple AspectJ en Java) pour effectuer cela.

La question est de savoir si cela en vaut vraiment la peine. Notez que cette séparation augmentera la complexité de votre projet tout en offrant très peu d'avantages.

Cette belle sons. Vous décrivez un décorateur d'exploitation forestière assez standard. Vous avez:

composante L (composante identification du système)

Cela a une responsabilité: consigner les informations qui lui sont transmises.

le composant A implémente I

Cela a une responsabilité: fournir une implémentation de l'interface I (en supposant que I soit correctement compatible SRP, c'est-à-dire).

Ceci est la partie cruciale:

Composant D instruments I, décore / A utilise, L utilise pour l'exploitation forestière

Lorsque cela est dit de cette façon, cela semble complexe, mais regardez-le de cette façon: le composant D fait une chose: rapprocher A et L.

• Le composant D ne se connecte pas; il délègue à ce que L
• Composante D ne met pas en œuvre elle-même je; il délègue cela à un

La seule responsabilité du composant D est de s'assurer que L est notifié lorsque A est utilisé. Les implémentations de A et L sont toutes deux ailleurs. Ceci est complètement conforme à SRP, en plus d'être un exemple soigné d'OCP et une utilisation assez courante des décorateurs.

Une mise en garde importante: lorsque D utilise votre composant de journalisation L, il doit le faire de manière à vous permettre de modifier la façon dont vous vous connectez. La façon la plus simple de le faire est d'avoir une interface IL implémentée par L. Ensuite:

• Le composant D utilise un IL pour se connecter; une instance de L est fournie
• Le composant D utilise un I pour fournir des fonctionnalités; une instance de A est fournie
• Le composant B utilise un I; une instance de D est fournie

De cette façon, rien ne dépend directement d'autre chose, ce qui facilite leur échange. Il est ainsi facile de s'adapter aux changements et de se moquer facilement des parties du système afin que vous puissiez effectuer des tests unitaires.

Bien sûr, c'est une violation de SRP car vous avez une préoccupation transversale. Vous pouvez cependant créer une classe chargée de composer la journalisation avec l'exécution de toute action.

exemple:

class Logger {
   ActuallLogger logger;
   public Action ComposeLog(string msg, Action action) {
      return () => {
          logger.debug(msg);
          action();
      };
   }
}