Comment rendre les longues listes de paramètres lisibles?

Question

J'ai développé une aversion naturelle aux longues listes de paramètres dans les fonctions. Bien que ce soit dans une certaine mesure une bonne chose, parfois les longues listes de paramètres sont le moindre de deux maux comparés à la duplication de code ou à des fonctions ridiculement longues en raison de "l'inlining manuel". Quel est un bon moyen de rendre au moins certaines de ces monstruosités lisibles par l'homme? Par exemple:

SomeClass[string] someFunction(SomeClass!(TemplateParam) foo, 
    string[][string] someAA, uint[] dataToProcess, SomeEnumType flag) { 
    // Do stuff. 
} 

Ceci ne donne pas un score élevé sur l'échelle de lisibilité, mais quatre paramètres sont assez raisonnables dans de nombreux cas.

Answer 1

Pour ce genre de situation, je tends à formater comme ceci:

SomeClass[string] someFunction(
    SomeClass!(TemplateParam) foo, 
    string[][string] someAA, 
    uint[] dataToProcess, 
    SomeEnumType flag 
) 
{ 
    // Do stuff. 
} 

Answer 2

Je regroupe les paramètres dans une classe (la plupart du temps intérieur) (ou un struct) afin d'éviter de large déclaration de fonction/appel

Answer 3

J'aime la réponse d'Aaron, juste en donnant une nouvelle ligne pour chaque paramètre.

Quand cela devient trop, alors il est temps de refactoriser un peu.

Si encore besoin de nombreux paramètres, passez à passer dans une classe qui enveloppe vos propriétés à la place. Ensuite, vous obtenez le bonus supplémentaire d'ajouter facilement des paramètres par défaut à votre méthode, sans falsifier votre signature.

Answer 4

• pour des raisons de lisibilité - mettre chaque argument sur une nouvelle ligne
• par souci de facilité d'utilisation et une meilleure API desgin - groupe arguments liés à de nouvelles classes, réduisant ainsi le nombre d'arguments.

Answer 5

Vous pouvez introduire objet paramètre:

class ParameterObject { 
    public final SomeClass!(TemplateParam) foo; 
    public final string[][string] someAA; 
    public final uint[] dataToProcess; 
    public final SomeEnumType flag; 

    private ParameterObject(
     SomeClass!(TemplateParam) foo, 
     string[][string] someAA, 
     uint[] dataToProcess, 
     SomeEnumType flag) { 
     this.foo = foo; 
     this.someAA = someAA; 
     this.dataToProcess = dataToProcess; 
     this.flag = flag; 
    } 

    private static class Builder { 
     public SomeClass!(TemplateParam) foo; 
     public string[][string] someAA; 
     public uint[] dataToProcess; 
     public SomeEnumType flag; 

     public Builder foo(SomeClass!(TemplateParam) foo) { 
      this.foo = foo; 
      return this; 
     } 

     public Builder someAA(string[][string] someAA) { 
      this.someAA = someAA; 
      return this; 
     } 

     public Builder dataToProcess(uint[] dataToProcess) { 
      this.dataToProcess = dataToProcess; 
      return this; 
     } 

     public Builder flag(SomeEnumType flag) { 
      this.flag = flag; 
      return this; 
     } 

     public ParameterObject build() { 
      if (null == foo) throw Exception("init foo!"); 
      if (null == someAA) throw Exception("init someAA!"); 
      if (null == dataToProcess) throw Exception("init dataToProcess!"); 
      if (null == flag) throw Exception("init flag!"); 
      return new ParameterObject(foo, someAA, dataToProcess, flag); 
     } 
    } 
} 

Maintenant, votre appel regarderait par exemple:

SomeClass[string] myValue = 
    someFunction(
     new ParameterObject.Build(). 
      foo(myFoo). 
      someAA(myAA). 
      dataToProcess(myData). 
      flag(false). 
      build() 
    ); 

Il est beaucoup plus facile de traiter des cas similaires dans les langues qui permettent la création de ligne cartes:

someFunction(
    Map.new(
     foo => myFoo, 
     someAA => myAA, 
     dataToProcess => myData, 
     flag => false 
    ) 

Qualificateur final signifie qu'un champ peut être défini uniquement à partir du constructeur de la classe. Le qualificateur static placé devant une classe signifie que la classe n'est pas liée à sa classe externe, c'est-à-dire qu'elle ne peut pas accéder/transformer ses champs.