[generico]Costruttori con molti parametri

[RaouL_BennetH]

Ciao a tutti

La mia più che altro è una curiosità..

Vi capita mai di avere a che fare con costruttori che abbiano molti parametri ?

per es.:

public DatiAnagrafici(cognome, nome, dataDiNascita, comuneDiNascita, provincia, blablabla

E' una cosa normale, o c'è un modo più 'elegante' in presenza di un oggetto
con molti campi ?

Grazie

RaouL.

[banryu79]

Se stiamo parlando di semplificare un metodo (costruttore o altro) e in particolare di ridurre la sua lista dei parametri, penso la cosa vada vista caso per caso.

Ad esempio, eaminando quello che hai postato, mi vengono in mente due scenari diversi e due possibilità:

1) la classe DatiAnagrafici è un "value object" che mappa la tabella di un db relazionale: in questo caso non mi pare si possa fare molto, visto che si e' costretti a rispettare la struttura della tabella che giustifica l'esistenza della classe stessa.

2) la classe DatiAnagrafici non è un value object e quindi posso rifattorizzarla come mi pare.
In questo caso vale la pena di osservare che potrei dividere i parametri in due gruppi: uno relativo al concetto di "Persona" (cognome, nome, dataNascita) e l'altro relativo al concetto di "Indirizzo" o "Luogo" cha a dir si voglia (comune, provincia, ecc...).

In questo caso potrei vedere il costruttore di DatiAnagrafici così:

DatiAnagrafici(Persona p, Indirizzo luogoDiNascita) {...}

oppure, più semplicemente, potrei eliminare DatiAnagrafici e stabilire che Persona ha un Indirizzo di nascita (così come ha una Data di nascita): tutte le info che aveva DatiAnagrafici sono ora contenute in Persona mediante le info che possiede direttamente e quelle che referenzia indirettamente grazie alle relazioni che ha con altre classi (Indirizzo, Data, ecc...)

class Persona
{
    private String nome;
    private String cognome;
    private final Indirizzo luogoDiNascita;
    private final Data dataDiNascita;
    private Indirizzo residenza;
    ...
    
    public Persona(String nome, String cognome, Data dNascita, 
        Indirizzo iNascita) {...}
    ...
    public void getLuogoDiNascita(Indirizzo ind) {luogoDiNascita=ind;}
    public void setResidenza(Indirizzo res) {residenza=res;}
    ...
}

Alla fine tutto dipende dal modello che si deve rappresentare...



Se più in generale ti interessanto le tecniche di refactoring del codice qui trovi un buon punto di partenza.

[cdimauro]

Dipende anche dal linguaggio. Esempio:

>>> class c:
...   def __init__(self, *Args, **Keys):
...     self.Arguments = Args
...     self.Keywords = Keys
...   def __str__(self):
...     return 'Mi hai passato gli argomenti %s e le keyword %s' % (self.Arguments, self.Keywords)
...
>>> a = c(1, 2, 3, a = 'Qui', b = 'Quo', c = 'Qua')
>>> print a
Mi hai passato gli argomenti (1, 2, 3) e le keyword {'a': 'Qui', 'c': 'Qua', 'b': 'Quo'}

[vhost87]

Nooooo che brutta sintassi cdimauro

prrrr
PS. ottimo esempio! Grande il pitone!

[banryu79]

Originariamente inviato da cdimauro

Dipende anche dal linguaggio. Esempio:
...snip...

Equivalente tradotto in Java;

public class Prova
{
    Integer[] args;
    Map<String,String> keys;

    public Prova(Integer[] args, Map<String,String> keys) {
        this.args = args;
        this.keys = keys;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("Mi hai passato gli argomenti");
        for (Integer i : args) {
            sb.append(" ").append(i).append(" ");
        }
        sb.append("e le keyword");
        for (Map.Entry<String,String> keyword : keys.entrySet()) {
            sb.append(" ")
              .append(keyword.getKey()).append(" = ").append(keyword.getValue())
              .append(" ");
        }
        return sb.toString();
    }

    public static void main(String... argv) {
        Integer[] args = {1,2,3};
        Map keys = new HashMap<String,String>();
        keys.put("a", "Qui");
        keys.put("b", "Quo");
        keys.put("c", "Qua");
        
        Prova a = new Prova(args, keys);
        System.out.println(a);
    }
}

// output:
// Mi hai passato gli argomenti 1  2  3 e le keyword b = Quo  c = Qua  a = Qui

Al di la della maggiore verbosità del codice Java non mi pare che il numero di argomenti passati ad un metodo, in questo caso il costruttore, sia maggiore.
Immagino in C# sia lo stesso, e in genere ovunque uno possa passare come argomento ad un metodo un tipo-collezione, per così dire.

[RaouL_BennetH]

Ciao a tutti !

allora, in ordine :

@Banryu79:

Anche io avevo pensato a semplificare il costruttore più o meno nel modo da te indicato ma, se è vero che semplifico il costruttore, vado poi a fare le stesse cose all'interno del metodo, per esempio:

void AggiungiNominativo(Persona p)
{
   //necessariamente dovrò creare o qui o altrove 
   //un oggetto Persona e:
   p.Cognome = valore;
   p.Nome = valore;
   etc..
}

Nella mia domanda, non c'era riferimento ai legami con i db in quanto
come correttamente sottolineato da te, li per forza di cosa bisogna
semplicemente rappresentare la tabella e amen.


@cdimauro

In effetti ho visto che sia in java che in c# esiste una
tecnica particolare per passare molti parametri (indicata però
solo nei casi in cui non se ne conosca a monte il numero)

//Java
public double getQualcheEuro(double... euri);

//C#
public double GetQualcheEuro(params[] double);

//o anche ma non è CLS; dalla documentazione ufficiale

[assembly: CLSCompliant(true)]
namespace UsageLibrary
{
    public class UseParams 
    {
        // This method violates the rule.
        [CLSCompliant(false)]
        public void VariableArguments(__arglist) 
        { 
            ArgIterator argumentIterator = new ArgIterator(__arglist);
            for(int i = 0; i < argumentIterator.GetRemainingCount(); i++) 
            { 
                Console.WriteLine(
                    __refvalue(argumentIterator.GetNextArg(), string));
            } 
        }

        // This method satisfies the rule.
        public void VariableArguments(params string[] wordList)
        { 
            for(int i = 0; i < wordList.Length; i++) 
            { 
                Console.WriteLine(wordList[i]);
            } 
        }
    }
}

[banryu79]

In effetti ho visto che sia in java che in c# esiste una
tecnica particolare per passare molti parametri (indicata però
solo nei casi in cui non se ne conosca a monte il numero)

Infatti, se è sufficiente passare tipi di dato-collezione monodimensionali esistono i varargs.

[cdimauro]

Le soluzioni Java e C# possono sembrare simili, ma sono molto diverse: state semplicemente utilizzando classi di tipo lista o mappa/dizionario per cercare di mascherare il passaggio di una quantità variabile di parametri.

Anche in Python esistono da tempo le liste e le mappe/dizionari, per cui si poteva applicare la stessa soluzione.

Ma qui stiamo parlando di parametri in quantità variabile, cioè una funzione/metodo cambia la sua arietà dinamicamente in base al chiamante.

Può sembrare sottile, ma col seguente esempio si capisce perché la differenza è, invece, notevole:

>>> class c:
...   def __init__(self, a, b, c, x = 1, y = 2, z = 3, *Args, **Keys):
...     Args = (a, b, c) + Args
...     Keys.update({'x' : x, 'y' : y, 'z' : z})
...     self.Arguments = Args
...     self.Keywords = Keys
...   def __str__(self):
...     return 'Mi hai passato gli argomenti %s e le keyword %s' % (self.Arguments, self.Keywords)
...
>>> a = c(1, 2, 3, 4, 5, Emi = 'Qui', Eli = 'Quo', Evy = 'Qua')
>>> print a
Mi hai passato gli argomenti (1, 2, 3) e le keyword {'Evy': 'Qua', 'Eli': 'Quo', 'y': 5, 'x': 4, 'z': 3, 'Emi': 'Qui'}
>>> a = c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, Emi = 'Qui', Eli = 'Quo', Evy = 'Qua')
>>> print a
Mi hai passato gli argomenti (1, 2, 3, 7, 8, 9, 10) e le keyword {'Evy': 'Qua', 'Eli': 'Quo', 'y': 5, 'x': 4, 'z': 6, 'Emi': 'Qui'}

[banryu79]

Originariamente inviato da cdimauro

Ma qui stiamo parlando di parametri in quantità variabile, cioè una funzione/metodo cambia la sua arietà dinamicamente in base al chiamante.

Può sembrare sottile, ma col seguente esempio si capisce perché la differenza è, invece, notevole:

Se quando hai tempo puoi spiegarmi più esplicitamente la cosa, perchè ho letto con calma la definizione di arietà al link postato, e ho provato a leggere con calma il codice Python postato, ma per mia ignoranza del linguaggio non riesco intanto a capire di preciso i singoli passi che compie anche a fronte di due esempi forniti di input e relativi output, e poi (di conseguenza probabilmente) non riesco a cogliere la sottile differenza da te citata.

[cdimauro]

Certamente. Con arietà intanto definiamo il numero di argomenti accettati (o che si aspetta) una determinata funzione (o metodo).

Nel caso in oggetto, abbiamo un costruttore (quindi una funzione) della classe c che accetta almeno 6 parametri, di cui i primi 3 fissi / obbligatori, e i seguenti 3 opzionali.

Inoltre può accettare un qualunque altro numero di parametri, siano essi con o senza nome, i quali, se presenti, vengono inseriti nella tupla (è una lista non modificabile) Args oppure nel dizionario (mappa) Keys rispettivamente.

Tutti i parametri definiti si possono referenziare col nome. Esempio:

>>> a = c(a = 0, b = -1, c = -2)
>>> print a
Mi hai passato gli argomenti (0, -1, -2) e le keyword {'y': 2, 'x': 1, 'z': 3}

Quando viene creata una nuova istanza di c, viene invocato il suo costruttore e gli vengono passati tutti i parametri, procedendo nel seguente modo:
- se ci sono parametri obbligatori, questi devono essere necessariamente presenti (e lo si può fare senza specificare il nome, visto che sono sempre i primi, oppure col nome, come ho mostrato poco sopra);
- se sono presenti altri parametri senza che venga specificato il loro nome, questi vengono assegnati agli eventuali parametri con valore di default (x, y e z, nello specifico caso);
- se sono presenti ulteriori parametri senza nome, vengono tutti inseriti in *Args (il nome ovviamente si può cambiare);
- se sono presenti parametri con nome che non coincidono coi parametri con valori predefiniti, questi vengono tutti inseriti in **Keys (anche qui si può cambiare il nome).

Le istruzioni:

Args = (a, b, c) + Args
Keys.update({'x' : x, 'y' : y, 'z' : z})

servono rispettivamente a creare una tupla che abbia come primi 3 elementi a, b, e c, e a seguire tutti i parametri senza nome che sono stati "raccolti" dalla funzione, e ad aggiornare il dizionario contenente i parametri con nome col valore dei 3 parametri con nome previsti dalla funzione.

Se ci sono dubbi, fammi/temi sapere.

[vhost87]

cdimauro docet!

[banryu79]

Originariamente inviato da cdimauro

Se ci sono dubbi, fammi/temi sapere.

Ok, mi ero "perso" a causa dei parametri con valore di default, che in Java non ci sono (e la mia memoria storica del C++ ormai è stata relegata chissà dove...), mea culpa. Ora ho capito, grazie alla tua spiegazione, ma la cosa (probabilmente perchè non ne sono abituato) mi pare un poco error-prone.

Più che altro, mi domando in quali situazioni/scenari possa tornare molto comoda questa funzionalità?

[Kralizek]

Data questa classe:

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string City { get; set; }
    public DateTime DateOfBirth { get; set; }
    public Person.Sex Sex { get; set; }

    public enum Sex {
        Male = 0, Female = 1 
    }
}

in C#, si puó usare:

    Person p = new Person
    {
         FirstName = "Salvatore",
         LastName = "Esposito",
         City = "Napoli",
         DateOfBirth = new DateTime( 1970, 12, 1),
         Sex = Person.Sex.Male
   };

o anche solo un sottoinsieme delle proprietá.

[cdimauro]

Originariamente inviato da banryu79

Ok, mi ero "perso" a causa dei parametri con valore di default, che in Java non ci sono (e la mia memoria storica del C++ ormai è stata relegata chissà dove...), mea culpa. Ora ho capito, grazie alla tua spiegazione, ma la cosa (probabilmente perchè non ne sono abituato) mi pare un poco error-prone.

Mumble. Perché? Hai in mente qualche caso d'uso che potrebbe esserlo?

Più che altro, mi domando in quali situazioni/scenari possa tornare molto comoda questa funzionalità?

Non hai idea in quante. E anche la possibilità di poter richiamare una funzione passandole più argomenti, con o senza nome, che vengono poi raccolti nelle rispettive Args e Keys, è estremamente utile.

Originariamente inviato da Kralizek

Data questa classe:

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string City { get; set; }
    public DateTime DateOfBirth { get; set; }
    public Person.Sex Sex { get; set; }

    public enum Sex {
        Male = 0, Female = 1 
    }
}

in C#, si puó usare:

    Person p = new Person
    {
         FirstName = "Salvatore",
         LastName = "Esposito",
         City = "Napoli",
         DateOfBirth = new DateTime( 1970, 12, 1),
         Sex = Person.Sex.Male
   };

o anche solo un sottoinsieme delle proprietá.

Però puoi soltanto (pre)assegnare valori ad alcune proprietà definite: non puoi fare altro, come ad esempio ho fatto io prima in cui ho già "giocato" un po' con tutti i parametri che erano stati passati.

x michele.broggi: esagerato!

[vhost87]

Sono serio cdimauro, tu sei da curare!
Ciò che hai scritto è sensazionale per gli occhi di un programmatore , quasi come alcune parti del kernel di Linus ahahah

[U235]

Ma qui stiamo parlando di parametri in quantità variabile, cioè una funzione/metodo cambia la sua arietà dinamicamente in base al chiamante.

ciao,

mi scusa in anticipo per la mia ignoranza, ma con params in c# non ottieni il risultato di cambiare dinamicamente il numero di parametri passati? ma forse non mi è ancora molto chiaro il significato di questa discussione

edit
capisco che sia comodo con i parametri con valore di default, ma se in un linguaggio non ci sono è chiaro che sia diverso, e il metodo piu' elegante sarà diverso. Ma forse non ho afferrato la domanda iniziale.

[RaouL_BennetH]

Per fugare un pò ogni dubbio:

Usare in C# i params, equivale a non sapere quanti parametri possano essere passati in anticipo, ma, per la mia domanda iniziale, non era questo il caso che mi incuriosiva.

La mia domanda era rivolta invece quando in presenza di un numero elevato e fisso di parametri, ci fosse un modo migliore per non passarli tutti nel costruttore o in un metodo.

Giustamente Banryu79 ha fatto una degna osservazione sull'ambito:

1) devi rappresentare tabelle di un db ? <= ciccia

2) devi rappresentare altro ? <= probabilmente il design è sbagliato a monte
e c'è bisogno di refactor.

Però... per la (1) forse forse con un ORM si potrebbe ottenere un design migliore .

Questo, ovviamente, non toglie nulla a quanto mostrato da cdimauro con python, anche perchè il titolo è appunto [generico] e non mi riferivo in particolare ad un linguaggio

chissà che un domani non riesca a farci qualcosina pure io col pitone oltre a mangiarmene di crudi per colazione

[U235]

Originariamente inviato da RaouL_BennetH

Per fugare un pò ogni dubbio:

Usare in C# i params, equivale a non sapere quanti parametri possano essere passati in anticipo, ma, per la mia domanda iniziale, non era questo il caso che mi incuriosiva.

ok

La mia domanda era rivolta invece quando in presenza di un numero elevato e fisso di parametri, ci fosse un modo migliore per non passarli tutti nel costruttore o in un metodo.

ok, mi era chiara allora

secondo me dipende dai linguaggi, da come devi utilizzarli ecc.

Questo, ovviamente, non toglie nulla a quanto mostrato da cdimauro con python, anche perchè il titolo è appunto [generico] e non mi riferivo in particolare ad un linguaggio

che abbia fatto un ottima dimostrazione di come si possono fare le cose con python credo non ci siano dubbi per quanto posso capirne io. (era python )

chissà che un domani non riesca a farci qualcosina pure io col pitone oltre a mangiarmene di crudi per colazione

[cdimauro]

Originariamente inviato da michele.broggi

Sono serio cdimauro, tu sei da curare!

Eh, no: adesso non ci siamo proprio.

Ciò che hai scritto è sensazionale per gli occhi di un programmatore , quasi come alcune parti del kernel di Linus ahahah

Che per me non è affatto un complimento.

Originariamente inviato da U235

ciao,

mi scusa in anticipo per la mia ignoranza, ma con params in c# non ottieni il risultato di cambiare dinamicamente il numero di parametri passati? ma forse non mi è ancora molto chiaro il significato di questa discussione

edit
capisco che sia comodo con i parametri con valore di default, ma se in un linguaggio non ci sono è chiaro che sia diverso, e il metodo piu' elegante sarà diverso. Ma forse non ho afferrato la domanda iniziale.

Sì, *Args è equivalente a params di C#. Sul resto vedo che ha già risposto Raoul.

Originariamente inviato da RaouL_BennetH

Per fugare un pò ogni dubbio:

Usare in C# i params, equivale a non sapere quanti parametri possano essere passati in anticipo, ma, per la mia domanda iniziale, non era questo il caso che mi incuriosiva.

La mia domanda era rivolta invece quando in presenza di un numero elevato e fisso di parametri, ci fosse un modo migliore per non passarli tutti nel costruttore o in un metodo.

Giustamente Banryu79 ha fatto una degna osservazione sull'ambito:

1) devi rappresentare tabelle di un db ? <= ciccia

2) devi rappresentare altro ? <= probabilmente il design è sbagliato a monte
e c'è bisogno di refactor.

Però... per la (1) forse forse con un ORM si potrebbe ottenere un design migliore .

Questo, ovviamente, non toglie nulla a quanto mostrato da cdimauro con python, anche perchè il titolo è appunto [generico] e non mi riferivo in particolare ad un linguaggio

chissà che un domani non riesca a farci qualcosina pure io col pitone oltre a mangiarmene di crudi per colazione

In genere sono i pitoni che mangiano gli altri.

Comunque male non ti farà di sicuro lavorare con Python.

[Kralizek]

Originariamente inviato da cdimauro

Però puoi soltanto (pre)assegnare valori ad alcune proprietà definite: non puoi fare altro, come ad esempio ho fatto io prima in cui ho già "giocato" un po' con tutti i parametri che erano stati passati.

puoi "giocare" con i valori se specifichi il codice del setter

private DateTime _DateOfBirth;
public DateTime DateOfBirth
{
     get { return _DateOfBirth; }
     set
     {
          if (value > DateTime.Today)
              throw new OMGException("OMG!");
          _DateOfBirth = value;
     }
}