Aide avec un refactoring: Introduire un objet de paramètre?

Question

J'ai un code qui est le même, sauf qu'une certaine séquence d'affectations se produisent dans des ordres légèrement différents.

Il est facile de factoriser ceci dans un paramètre de méthode de type int[], qui indique la commande.

Cependant, je trouve que ce n'est pas le plus clair.

Une autre option consistait à les factoriser dans un objet de type AssignmentOrders. Je peux aussi faire une validation sur les valeurs dans le constructeur d'objet que je n'ai pas pu faire avec le tableau. Ce serait le "Introduire des objets de paramètres" refactoring du livre, Refactoring.

Je me demande si ce refactoring particulier est exagéré et je devrais rester avec le int[]?

CODE:

Trois échantillons des originaux:

private static PersonDetails parseLine(String line, String deliminator, int[] orderOfSections) 
      throws Exception { 
     String[] sections = line.split(deliminator); 

     String value1 = sections[0].trim(); 
     String value2 = sections[1].trim(); 
     String value3 = sections[4].trim(); 
     String value4 = sections[2].trim(); 
     String value5 = sections[3].trim(); 

     //........ 
    } 

private static PersonDetails parseLine(String line, String deliminator) 
      throws Exception { 
     String[] sections = line.split(deliminator); 

     String value1 = sections[1].trim(); 
     String value2 = sections[0].trim(); 
     String value3 = sections[2].trim(); 
     String value4 = sections[3].trim(); 
     String value5 = sections[4].trim(); 

     //........ 
    } 

private static PersonDetails parseLine(String line, String deliminator, int[] orderOfSections) 


     throws Exception { 
     String[] sections = line.split(deliminator); 

     String value1 = sections[0].trim(); 
     String value2 = sections[1].trim(); 
     String value3 = sections[2].trim(); 
     String value4 = sections[4].trim(); 
     String value5 = sections[5].trim(); 

     //........ 
    } 

Comment j'ai refactorisé 3 ci-dessus dans ce:

private static PersonDetails parseLine(String line, String deliminator, int[] orderOfSections) 
      throws Exception { 
     String[] sections = line.split(deliminator); 

     String value1 = sections[orderOfSections[0]].trim(); 
     String value2 = sections[orderOfSections[1]].trim(); 
     String value3 = sections[orderOfSections[2]].trim(); 
     String value4 = sections[orderOfSections[3]].trim(); 
     String value5 = sections[orderOfSections[4]].trim(); 

     //........ 
    } 

Comment je pourrais théoriquement factoriser dans un paramètre objet:

private static PersonDetails parseLine(String line, String deliminator, OrderOfSections order) 
     throws Exception { 
     String[] sections = line.split(deliminator); 

     String value1 = sections[order.getValue1Idx].trim(); 
     String value2 = sections[order.getValue2Idx].trim(); 
     String value3 = sections[order.getValue3Idx].trim(); 
     String value4 = sections[order.getValue4Idx].trim(); 
     String value5 = sections[order.getValue5Idx].trim(); 

     //........ 
    } 

Ce que je pensais faire était de créer une classe spécifique au lieu d'utiliser int[] ... Mais je me demandais si cela serait exagéré.

Les avantages sont qu'il serait plus lisible. Au lieu de orderOfSections[0], il pourrait être orderOfSections.value1SectionIdx ... Je pourrais aussi mettre du code de validation dans la classe. Je crois que c'est ce que Martin Fowler appelle l'introduction d'un objet de paramètre.

EDIT:

Une autre option serait d'utiliser un dictionnaire. Plus léger qu'une nouvelle classe, mais plus descriptif ... Alors je pourrais utiliser quelque chose comme orderOfSections["value1"]

Answer 1

Au lieu de passer dans un Class ou un tableau qui indique simplement l'ordre des éléments de la String premières et la façon dont ils devraient être affectés, je déléguer l'analyse syntaxique de l'entrée line à cette Class. Il serait beaucoup plus facile à lire pour effectuer les opérations suivantes:

private static PersonDetails parseLine(String line, String deliminator, 
         SectionsReader reader) throws Exception 
{ 
    reader.setLine(line); 
    String value1 = reader.getValue1(); 
    String value2 = reader.getValue2(); 
    String value3 = reader.getValue3(); 
    String value4 = reader.getValue4(); 
    String value5 = reader.getValue5(); 

    //........ 
} 

En fin de compte, ce ne serait pas exagéré, et vous vous remercierez dans le temps de 3 mois quand vous revenez à ce code et trouver plus intelligible .

Answer 2

À mon humble avis, le moyen le plus simple et le plus lisible est de passer une carte au lieu d'un tableau int. Et en fonction de ce à quoi ressemblent vos champs pour PersonDetails, vous pouvez même utiliser la réflexion et affecter les valeurs dans une boucle.