Quelles sont les dépendances cachées?

Question

Quelqu'un pourrait-il me donner un exemple de dépendance cachée? Je l'ai googlé et trouvé des résultats comme celui-ci:.

« Une dépendance visible est une dépendance que les développeurs peuvent voir d'un Si une dépendance à l'interface de la classe ne peut pas être vu de l'interface de la classe, il est dépendance cachée. "

_{(Source - http://tutorials.jenkov.com/ood/understanding-dependencies.html#visiblehidden)}

Mais je ne comprends toujours pas bien.

Cela signifie-t-il quand une dépendance se produit dans une fonction, et non une variable déclarée au début d'une classe? Ou est-ce quand vous créez simplement des fonctions autres que les méthodes de signature déclarées dans une interface?

Answer 1

Ce qui suit est l'exemple d'une dépendance cachée:

class Foo 
{ 
    void doSomething() //a visible method signature 
    { 
     //the body of this method is an implementation detail 
     //and is thus hidden 
     new Bar().doSomething(); 
    } 
} 

Dans l'exemple ci-dessus, Bar est une dépendance pour Foo parce Foo repose sur la collaboration de Bar.

Il est caché parce que la dépendance à l'égard Bar n'est pas explicite dans le constructeur de signatures ou Foo méthode pour Foo.

Pensez à une classe comme définissant un contrat visible exposé aux collaborateurs. Les méthodes et les signatures du constructeur font partie de ce contrat. Le corps de la méthode doSomething() est caché car il s'agit d'un détail d'implémentation interne de la classe qui n'est pas exposé dans le contrat. Tout ce que nous savons de la signature est qu'il existe une méthode appelée doSomething() qui est de type de retour void.

Pour un contre, on pourrait factoriser la classe pour rendre les dépendances manifeste:

class Foo 
{ 
    private readonly Bar bar; 

    Foo(Bar bar) //the constructor signature is visible 
    { 
     this.bar = bar; 
    } 

    void doSomething() 
    { 
     bar.doSomething(); 
    } 
} 

Dans l'exemple ci-dessus, Bar est explicitement défini comme une dépendance à la signature exposée pour le constructeur.

Sinon, nous pourrait faire:

class Foo 
{ 

    void doSomething(Bar bar) //method signature is visible 
    { 
     bar.doSomething(); 
    } 
} 

Maintenant, la dépendance à l'égard Bar pour la méthode doSomething est visible car il est inclus dans la signature de méthode pour doSomething.