-
Se SomeParameterClassName raggruppa oggetti connessi logicamente, quindi assegna un nome di conseguenza.
Ad esempio, se raggruppa le coordinate X, Y e Z, chiamane 3DPoint . Se raggruppa il nome del prodotto, il prezzo del prodotto e la descrizione del prodotto, chiamalo Product .
void Demo(int x, int y, int z) { }
――― ↧ ―――
void Demo(3DPoint coordinates) { }
e
void Demo(string productName, int productPrice, string productDescription) { }
――― ↧ ―――
void Demo(ProductInfo product) { }
-
Se SomeParameterClassName raggruppa oggetti che non hanno nulla in comune tranne che per essere passati allo stesso metodo, allora stai sbagliando. Non è necessario creare un tipo per entità non correlate: basta passarle così com'è al metodo.
Ad esempio, se raggruppa le coordinate X e la descrizione del prodotto, rimuovi l'oggetto e passa due parametri.
void Demo(int x, string productDescription) { }
――― ↺ ―――
-
Può darsi che tu abbia molti parametri passati a un metodo, ma non tutti possono essere raggruppati. In questo caso, cerca quelli che puoi raggruppare e lascia gli altri.
Ad esempio, con parametri come nome del prodotto, prezzo del prodotto, descrizione del prodotto e registratore, quindi raggruppa i primi tre in una classe di prodotto e lascia l'ultimo:
void Demo(string productName, int productPrice,
string productDescription, AppLogger logger) { }
――― ↧ ―――
void Demo(ProductInfo product, AppLogger logger) { }
In presenza di un metodo che accetta molti parametri disparati, potrebbe essere necessario un ulteriore refactoring . Ad esempio, nel codice precedente, ci si potrebbe chiedere perché è AppLogger passato come parametro, invece di essere iniettato quando si chiama un costruttore:
var something = new Something();
...
something.Demo(product, logger);
――― ↧ ―――
var something = new Something(logger);
...
something.Demo(product);
Dato che probabilmente anche l'altro metodo di Something sta registrando la loro attività, l'iniezione del logger nel costruttore ha senso.
Un'altra tecnica di refactoring è quella di dividere il metodo. Il gran numero di parametri è una buona indicazione che il metodo fa troppo. Ci sono casi a volte ovvi:
void Demo(a, b, c, d, e, f, g, h)
{
if (a)
{
// A few hundred lines which use exclusively the parameters b, c and d.
}
else
{
// A few hundred lines which use exclusively the parameters e, f, g and h.
}
}
ma la maggior parte sono meno ovvi: alcuni parametri possono essere utilizzati attraverso l'intero metodo, possono essere interconnessi, ecc. Tuttavia, se hai la sensazione di avere troppi parametri, guarda altre indicazioni (come LOC, ILLOC in C # e il numero di filiali) e controlla se il tuo metodo sta facendo una sola cosa.