# Conferma Metodo Rcommon

**URL:** <https://it.discourse.mcneel.com/t/conferma-metodo-rcommon/4833>\
**Category:** Bar-Rhino\
**Created:** [28 Dicembre 2022, 12:09pm UTC](https://it.discourse.mcneel.com/t/conferma-metodo-rcommon/4833 "2022-12-28T12:09:41Z")\
**Posts on this page:** 20\
**Page:** 1

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [28 Dicembre 2022, 12:09pm UTC](https://it.discourse.mcneel.com/t/conferma-metodo-rcommon/4833/1 "2022-12-28T12:09:41Z")

</div>

```auto
var gd = new GetNumber();
gd.SetCommandPrompt("Distance");
gd.Get();
gd.Number();

```

premesso che il modo corretto è quello indicato sopra,  
ho provato a restringere il tutto in una sola riga ma  
non ci sono riuscito. mi confermate ciò?

---

<div class="post-metadata">

**Author:** ![emilio](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/emilio/32/16095_2.png) [@emilio](https://it.discourse.mcneel.com/u/emilio)\
**Post date:** [28 Dicembre 2022, 1:37pm UTC](https://it.discourse.mcneel.com/t/conferma-metodo-rcommon/4833/2 "2022-12-28T13:37:20Z")

</div>

Ciao Salvio

Suppongo che **GetNumber** qui sia **Rhino.Input.Custom.GetNumber** e che quindi prima ci sia uno **using**.  
Se e’ cosi’ secondo me e’ meglio riportare anche quello, cosi’ anche chi non conosce RhinoCommon a memoria sa dove andare a cercare eventualmente. 🙂

> [@0904](#):
>
> ho provato a restringere il tutto in una sola riga ma  
> non ci sono riuscito. mi confermate ciò?

Be’, ovviamente puoi scrivere quelle istruzioni una dopo l’altra senza andare a capo, se vuoi.  
Ma non credo sia quello che ti interessa … O no ? 🤔 😄

Se intendi concatenate il tutto in una singola istruzione, e’ vero, hai ragione. non e’ possibile.  
Per poter fare cosi’ quei metodi dovrebbero restituire l’oggetto **GetNumber** (quello salvato nella variabile **gd** ), ma non lo fanno.  
Questa e’ una scelta di chi scrive la libreria, e personalmente qui concordo, mi sembra piu’ comodo da utilizzare cosi’.  
Penso che, volendo, puoi riunire in una singola istruzione le prime due istruzioni, ma le altre vanno tenute divise.

Ovviamente in caso di bisogno puoi sempre derivare una classe da **GetNumber** oppure scriverne una nuova da zero con dei metodi che funzionino in modo diverso e che possano quindi essere concatenati, per cosi’ dire.

Oppure, senza scrivere nuove classi, se desideri puoi farti una semplice funzione che accetti un prompt come parametro e ti restituisca direttamente il numero.  
Piu’ o meno e’ quello che fa **rhinoscriptsyntax** per Python. 🙂

P.S.

> [@0904](#):
>
> premesso che il modo corretto è quello indicato sopra

Ovviamente, se ti interessa il numero ottenuto, dovresti mettere in una variabile quanto restituito da **gd.Number();**😉

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [28 Dicembre 2022, 4:34pm UTC](https://it.discourse.mcneel.com/t/conferma-metodo-rcommon/4833/3 "2022-12-28T16:34:38Z")

</div>

parto dall’ultima 😉

> [@emilio](#):
>
> Ovviamente, se ti interessa il numero ottenuto, dovresti mettere in una variabile quanto restituito da **gd.Number();** 😉

esatto, solo che si trattava di un valore per un offset quindi avevo inserito direttamente nel metodo

(credo che non dovrebbero esserci complicanze essendo che è fine a se stesso giusto?)

> [@emilio](#):
>
> Suppongo che **GetNumber** qui sia **Rhino.Input.Custom.GetNumber** e che quindi prima ci sia uno **using**.  
> Se e’ cosi’ secondo me e’ meglio riportare anche quello, cosi’ anche chi non conosce RhinoCommon a memoria sa dove andare a cercare eventualmente. 🙂

mi ero fatto la stessa domanda, nell’esemio c’era solo **GetNumber** andando a controllare  
ho notato che oltre a **using Rhino** era stato inserito anche **Rhino.Input** e **Rhino.Input.Custom**  
di sicuro chi ha scritto il codice sapeva bene cosa stava facendo e per non digitare spesso i riferimenti  
li mette tutti all’inizio ricordandoseli tutti quanti, per quanto mi riguarda sono daccordo con te meglio  
riportarli man mano di sicuro per chi sta all’inizio come me aiuta a fare meno errori nella compilazione.

> [@emilio](#):
>
> Ovviamente in caso di bisogno puoi sempre derivare una classe da **GetNumber** oppure scriverne una nuova da zero con dei metodi che funzionino in modo diverso e che possano quindi essere concatenati, per cosi’ dire.
> 
> Oppure, senza scrivere nuove classi, se desideri puoi farti una semplice funzione che accetti un prompt come parametro e ti restituisca direttamente il numero.  
> Piu’ o meno e’ quello che fa **rhinoscriptsyntax** per Python. 🙂

un piccolo esempio?

---

<div class="post-metadata">

**Author:** ![emilio](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/emilio/32/16095_2.png) [@emilio](https://it.discourse.mcneel.com/u/emilio)\
**Post date:** [28 Dicembre 2022, 5:14pm UTC](https://it.discourse.mcneel.com/t/conferma-metodo-rcommon/4833/4 "2022-12-28T17:14:14Z")

</div>

> [@0904](#):
>
> un piccolo esempio?

Direi di mettere semplicemente dentro una funzione quanto hai scritto:  
( **Occhio** che sono arrugginito con C# e rimbambito in generale, per cui se sbaglio la sintassi … correggi tu che stai facendo il corso. 😉 😊 )

```csharp
double getnumber( string prompt )
{
  var gd = new GetNumber();
  gd.SetCommandPrompt( prompt);
  gd.Get();
  return gd.Number();
}

```

… e poi usi la funzione come faresti con con **rs.GetReal()** in Python

Quanto all’altra alternativa, cioe’ scrivere dei metodi che restituiscano l’oggetto …  
provo poi a scrivere un semplice esempio.  
E se ci riesco dopo lo posto. 😊 😄

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [28 Dicembre 2022, 5:24pm UTC](https://it.discourse.mcneel.com/t/conferma-metodo-rcommon/4833/5 "2022-12-28T17:24:16Z")

</div>

> [@emilio](#):
>
> ```auto
> double getnumber( string prompt )
> {
> var gd = new GetNumber();
> gd.SetCommandPrompt( prompt);
> gd.Get();
> return gd.Number();
> }
> 
> ```

non una correzione ma un’osservazione:

non so con quale editor stai scrivendo, ma in VS il double me lo aveva dato come errore in questo caso:

> [@emilio](#):
>
> ` var gd = new GetNumber();`

volevo specificare che fosse un valore double ma non mi veniva accettato ho dovuto lasciare var

ora non ho provato se in questo caso mi bloccava lo stesso il codice

---

<div class="post-metadata">

**Author:** ![emilio](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/emilio/32/16095_2.png) [@emilio](https://it.discourse.mcneel.com/u/emilio)\
**Post date:** [28 Dicembre 2022, 5:38pm UTC](https://it.discourse.mcneel.com/t/conferma-metodo-rcommon/4833/6 "2022-12-28T17:38:16Z")

</div>

> [@0904](#):
>
> in VS il double me lo aveva dato come errore in questo caso:

> [@0904](#):
>
> volevo specificare che fosse un valore double

Peccato che non sia un valore double … 😉

Certo che ti da’ errore, GetNumber() e’ un costruttore e ti restituisce un oggetto di tipo … rullo di tamburi … **GetNumber** , non double.  
😉

Non c’entra l’editor, c’entra cosa scrivi.

( Ripeto ancora … sono un disco rotto, lo so … 😉 )  
Sei sicuro di voler provare a usare RhinoCommon senza capire prima cosa sono classi e oggetti ?  
A me sembra tanto come provare ad andare avanti nella nebbia … 😉  
Comunque se tu ti trovi bene cosi’, OK ! 😀

---

<div class="post-metadata">

**Author:** ![emilio](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/emilio/32/16095_2.png) [@emilio](https://it.discourse.mcneel.com/u/emilio)\
**Post date:** [28 Dicembre 2022, 5:52pm UTC](https://it.discourse.mcneel.com/t/conferma-metodo-rcommon/4833/7 "2022-12-28T17:52:52Z")

</div>

> [@0904](#):
>
> un piccolo esempio?

Esempio di classe con i metodi che restituiscono l’oggetto, e quindi consentono di ‘collegare’ diverse operazioni in un’unica istruzione. 🙂

```csharp
using System;

class pnt
{

  double xx;
  double yy;

  public pnt( double xval, double yval )
  {
    xx = xval;
    yy = yval;
  }

  public pnt show()
  {
    Console.WriteLine( $"Point at X {xx}, Y {yy}" );
    return this;
  }

  public pnt scale( double scl )
  {
    xx *= scl;
    yy *= scl;
    return this;
  }

  public pnt movex( double dex )
  {
    xx += dex;
    return this;
  }

  public pnt movey( double dey )
  {
    yy += dey;
    return this;
  }

}

class main
{
  static void Main()
  {
       
    new pnt( 11, 22 ).scale( 2 ).movex( 11 ).movey( 22 ).show();
 
  }
}

```

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [28 Dicembre 2022, 6:51pm UTC](https://it.discourse.mcneel.com/t/conferma-metodo-rcommon/4833/8 "2022-12-28T18:51:45Z")

</div>

> [@emilio](#):
>
> ```auto
> double xx;
> double yy;
> 
> public pnt( double xval, double yval )
> 
> ```

e giustamente (non so se in questo caso si è obbligati o meno) hai usato il double ahahahah  
diciamo che per ora il C# riesco per lo meno a leggere il codice, a scriverlo lo so che non’è cosa  
per adesso mi sto limitando a fare il dott. frankenstein, ricerco e unisco/assemblo i codici trovati in rete  
(che dire, sono stato sempre contrario a ciò, ma a quanto pare si dice che è inutile re-inventare la ruota. . .)

lo so lo so che avrei dovuto aspettare ancora prima di tuffarmici ma ti assicuro che se non iniziavo potevo anche seguire tutti i tutorial e leggere tutti i testi in rete ma poi quando avrei iniziato sarebbe stato lo stesso.

purtroppo è cosi, prima ne ero ignaro, fino a quando poco tempo fa vedendo questo film  
**il campione con Accorsi** , (insegnante che doveva provvedere all’istruzione di un calciatore)  
impresa ardua essendo che cozzava coi libri, ma avendo notato che con gli schemi delle azioni  
in campo riusciva a districarsi bene, quindi intuì che il cervello del ragazzo funzionava in modo visivo,  
portandolo quindi per arrivare allo scopo nel superare gli esami, a cambiare approccio di insegnamento.

personalmente, che c’erano differenze di apprendimento, tra quando quella cosa la faccio oppure la studio soltanto ne ero consapevole, ma che esistesse l’apprendimento visivo questo mi mancava, per carità forse è giusto un’alibi che mi sono dato dopo aver visto il film ahahahah chissà può darsi. . . . 😂 😂 😅

però so anche di un conoscente che lavora proprio nel campo informatico, e mi disse di aver selezionato una ragazza laureata in matematica con cv impeccabile, al primo giorno messa davanti al pc per scrivere alcune righe di codice per vedere cosa sapesse fare, dopo poco lei si alzò e se ne andò

ps oppure magari la mia non’é nemmeno intelligenza visiva ma è grazie solamente alla mia testa dura 😆

pps tornando al double che è un tipo di dato numerico con virgola, volevo sostituirlo al var essendo che da quello che avevo appreso dai tutorial il var dovrebbe richiedere maggiore memoria essendo che è generica mentre col double andavo a specificare che quel valore dovesse essere numerico con virgola.

considerando il ragionamento sopra, credo che l’intenzione era buona essendo che negli script fatti fin’ora con VBS o Py questo tipo di analisi non l’avevo mai fatta quindi uno step di livello ritengo che c’è stato.  
adesso rimane (come sto facendo) la pratica. . . 😉

---

<div class="post-metadata">

**Author:** ![emilio](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/emilio/32/16095_2.png) [@emilio](https://it.discourse.mcneel.com/u/emilio)\
**Post date:** [28 Dicembre 2022, 7:13pm UTC](https://it.discourse.mcneel.com/t/conferma-metodo-rcommon/4833/9 "2022-12-28T19:13:40Z")

</div>

> [@0904](#):
>
> l’apprendimento visivo

Il fatto e’ che non saprei proprio come rendere visiva la programmazione in C# … 😕  
Ma se hai qualche idea, di’ pure … 🙂

> [@0904](#):
>
> volevo sostituirlo al var essendo che da quello che avevo appreso dai tutorial il var dovrebbe richiedere maggiore memoria essendo che è generica

Credevo che il compilatore ricavasse comunque il tipo di dati utilizzato … 🤔  
Ma non importa.  
Se vuoi sostituire il **var** , benissimo, nelle prima versione del C# il **var** non c’era proprio e scrivevi sempre il tipo di dati reale.  
Dicevo, benissimo sostituire il **var** , ma col tipo giusto.  
Quindi in quella istruzione il **var** lo puoi sostituire con **GetNumber** , credo che cosi’ funzioni. 🙂

> [@0904](#):
>
> diciamo che per ora il C# riesco per lo meno a leggere il codice

Secondo me, se non riconosci un costruttore o non sai come funziona manca ancora qualcosetta …

> [@0904](#):
>
> ma a quanto pare si dice che è inutile re-inventare la ruota

D’accordo, ma se riusciamo a capire cosa stiamo copiando credo sia meglio … 😉

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [28 Dicembre 2022, 8:37pm UTC](https://it.discourse.mcneel.com/t/conferma-metodo-rcommon/4833/10 "2022-12-28T20:37:03Z")

</div>

> [@emilio](#):
>
> D’accordo, ma se riusciamo a capire cosa stiamo copiando credo sia meglio … 😉

proprio questo è il mio intento, infatti la fissa di sezionare un metodo/funzione, oltre a voler mettere tutto in una sola riga è data proprio da questo, dal fatto di andare a capire il funzionamento di ogni sua parte.

e qui mi collego anche a questo:

> [@emilio](#):
>
> Il fatto e’ che non saprei proprio come rendere visiva la programmazione in C# … 😕

per **visivo** nel codice intendo proprio quello che ho scritto sopra,  
smontare e rimontare combinando un codice e **vedere** il risultato  
“è vero che la scuola insegna (in mancanza) la pratica spratica”

> [@emilio](#):
>
> Dicevo, benissimo sostituire il **var** , ma col tipo giusto.

ma se **GetNumber** richiede un valore numerico e double sarebbe un tipo di dato numerico non comprendo il perché non l’ho accetti. . . avevo cercato anche quali tipi di dati disponibili ci fossero  
e come numerici se non erro c’era solo int oltre a quello, a me serviva con la virgola e quindi  
nel mio ragionamento sarebbe stato corretto; variabile\* gd uguale nuovo prendi-numero  
(che tipo di numero deve essere: double\*) ma per questo mi dovrò scrivere un linguaggio mio ahahahah

> [@emilio](#):
>
> Secondo me, se non riconosci un costruttore o non sai come funziona manca ancora qualcosetta …

su questo confermo e sottoscrivo, ne sono ben consapevole, infatti mi ero ripromesso di cercare un tipo di schema dove riporta bene le differenze dei costruttori delle classi anzi se trovate qualche link sono qui.

---

<div class="post-metadata">

**Author:** ![emilio](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/emilio/32/16095_2.png) [@emilio](https://it.discourse.mcneel.com/u/emilio)\
**Post date:** [28 Dicembre 2022, 9:58pm UTC](https://it.discourse.mcneel.com/t/conferma-metodo-rcommon/4833/11 "2022-12-28T21:58:52Z")

</div>

> [@0904](#):
>
> ma se **GetNumber** richiede un valore numerico e double sarebbe un tipo di dato numerico non comprendo il perché non lo accetti. . .

🤔

> [@0904](#):
>
> andare a capire il funzionamento di ogni sua parte

Ottimo, proviamo a ripartire da qui. 😀

Se vuoi, spiega cosa fanno secondo te queste istruzioni, una per una:

```auto
var gd = new GetNumber();
gd.SetCommandPrompt("Distance");
gd.Get();
gd.Number();

```

… cosi’ abbiamo qualcosa da cui partire.  
O almeno ci proviamo … 😕 😉 😄

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [28 Dicembre 2022, 10:21pm UTC](https://it.discourse.mcneel.com/t/conferma-metodo-rcommon/4833/12 "2022-12-28T22:21:31Z")

</div>

> [@emilio](#):
>
> … cosi’ abbiamo qualcosa da cui partire.  
> O almeno ci proviamo … 😕 😉 😄

ok prof 👍

provo dalla prima riga:

gd è la variabile dichiarata con var e new sarebbe il nuovo oggetto del quale deve essere fatta la variabile  
SetCommandPrompt imposta il testo da visualizzare corrisponderebbe al primo parametro di rs.GetObject  
Get() richiama input da dare nella barra di comando di rhino equivarrebbe a rs.getreal() in questo caso  
ed infine Number() preleva il valore preso dal get essendo che si tratta del metodo GetNumber è numero

ora tornando al discorso col quale ho aperto questo 3d chiedendo se era possibile inserire tutto in una sola riga (ribadisco chiedevo conferma) non era possibile essendo che i parametri non sono concatenati ma diciamo cosi vengono richiamati tutti a cascata dall’associazione dell’oggetto creato con la variabile,  
quindi per questo la variabile gd viene indicata fino a GetNumber() compresa di parentesi  
per poi impostare ciascun parametro in sequenza ed equivarrebbe a questo:

```auto
GetNumber.SetCommandPrompt("Distance")
GetNumber.Get()
GetNumber.Number()

```

spiegazione (da libro stracciato) a parte, spero che i concetti oltre ad essere comprensibili siano giusti. . .  
rimandato?

edit:

> [@0904](#):
>
> corrisponderebbe al primo parametro di rs.GetObject

a questo punto potevo come nella riga successiva dire che corrispondeva al primo parametro di rs.getreal() essendo che si parla di numeri mentre il secondo parametro sarebbe inserimento del valore

---

<div class="post-metadata">

**Author:** ![emilio](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/emilio/32/16095_2.png) [@emilio](https://it.discourse.mcneel.com/u/emilio)\
**Post date:** [28 Dicembre 2022, 11:10pm UTC](https://it.discourse.mcneel.com/t/conferma-metodo-rcommon/4833/13 "2022-12-28T23:10:11Z")

</div>

> [@0904](#):
>
> gd è la variabile dichiarata con var e new sarebbe il nuovo oggetto del quale deve essere fatta la variabile

Non sono sicuro di capire bene, ma se vuoi dire che **new GetNumber()** crea un nuovo oggetto di tipo **GetNumber** e questo oggetto viene salvato nella variabile **gd** …  
OK, siamo d’accordo.

Quindi converrai che cercare di dichiarare **gd** come **double** non ha senso.  
**gd** e’ un oggetto di tipo **GetNumber** , non di tipo **double**.

E’ chiaro questo punto, o ci sono dei dubbi ? 🙂  
Peche’ secondo me questo e’ un punto importante.

Poi, va bene, le istruzioni successive settano il prompt ed eseguono l’input del numero fornito dallutilizzatore.  
E l’ultima serve per accedere a quel numero.

> [@0904](#):
>
> ed equivarrebbe a questo:
> 
> ```auto
> GetNumber.SetCommandPrompt("Distance")
> GetNumber.Get()
> GetNumber.Number()
> 
> ```

Non esattamente.  
nel tuo script c’e’ **gd** , non **GetNumber**. Sono cose un po’ diverse.  
**gd** e’ la variabile che contiene il nostro oggetto di tipo **GetNumber**.  
**GetNumber** e’ solo il nome della classe, e’ come scrivere **double** o **int** , non e’ il nome di una variabile.

Poi in alcune classi ci sono dei metodi **static** che richiedono proprio di essere richiamati col nome della classe, ma e’ un altro discorso, ne parleremo quando servira’, qui non funziona, qui serve un oggetto, non una classe.

Se ti sembra che la OOP sia un bel casino … be’, siamo in due. 😄  
Ma e’ l’unico modo di utilizzare RhinoCommon.

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [28 Dicembre 2022, 11:53pm UTC](https://it.discourse.mcneel.com/t/conferma-metodo-rcommon/4833/14 "2022-12-28T23:53:24Z")

</div>

> [@emilio](#):
>
> Se ti sembra che la OOP sia un bel casino … be’, siamo in due. 😄  
> Ma e’ l’unico modo di utilizzare RhinoCommon.

eeee per questo all’epoca me ne scappai a gambe levate e mi dissi meglio VBS o Py  
però poi alla fine se si vuole proseguire anche per fare piccole cose un po bisogna masticarne  
in Py anche per usare ETO bisogna usare Rcommon quindi volente o nolente deve entrare nella testuggine

> [@emilio](#):
>
> Non esattamente.  
> nel tuo script c’e’ **gd** , non **GetNumber**. Sono cose un po’ diverse.  
> **gd** e’ la variabile che contiene il nostro oggetto di tipo **GetNumber**.  
> **GetNumber** e’ solo il nome della classe, e’ come scrivere **double** o **int** , non e’ il nome di una variabile.

hai ragione, ho sbagliato a fare quell’esempio, ovviamente chiamare oggetto è diverso da chiamare la classe

> [@emilio](#):
>
> Non sono sicuro di capire bene, ma se vuoi dire che **new GetNumber()** crea un nuovo oggetto di tipo **GetNumber** e questo oggetto viene salvato nella variabile **gd** …  
> OK, siamo d’accordo.

ok su questo è assodato

> [@emilio](#):
>
> Quindi converrai che cercare di dichiarare **gd** come **double** non ha senso.  
> **gd** e’ un oggetto di tipo **GetNumber** , non di tipo **double**.
> 
> E’ chiaro questo punto, o ci sono dei dubbi ? 🙂  
> Peche’ secondo me questo e’ un punto importante.

qui ho bisogno qualche precisazioni; spiego riallacciandomi al fatto che adesso avevo bisogno di fare pratica, essendo che quando apprendo nozioni accumulo tutto in un calderone poi dopo quando inizio  
ad impastare qualcosa man mano debbo cercare di sistemare tutti i vari pezzi al proprio giusto posto

![Immagine 2022-12-29 002929](https://global.discourse-cdn.com/mcneel/uploads/mcneel_it/original/2X/b/b3c4a711be66be8f97fe24a041dd269567456e47.jpeg)

ho mischiato le due cose var gd = new GetNumber(); con public double X{get} o public Coords(double x);

quindi posso impostare double sia una variabile che un parametro di un costruttore ma no un oggetto

edit:  
pensandoci bene, in Py ho sempre usato solo rs.getreal oppure rs.getint non esiste rs.getdouble

---

<div class="post-metadata">

**Author:** ![emilio](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/emilio/32/16095_2.png) [@emilio](https://it.discourse.mcneel.com/u/emilio)\
**Post date:** [29 Dicembre 2022, 12:34am UTC](https://it.discourse.mcneel.com/t/conferma-metodo-rcommon/4833/15 "2022-12-29T00:34:32Z")

</div>

> [@0904](#):
>
> quindi posso impostare double sia una variabile che un parametro di un costruttore ma no un oggetto

Non e’ questione di dove usare **double** , ma di usare il tipo di dati giusto.  
Se hai una istruzione che somma due numeri, non puoi assegnarla a una stringa.  
Non puoi scrivere

```csharp
string risultato = 5 + 8;

```

Come non puoi scrivere

```csharp
double testo = "Hello Rhino !";

```

Se da una certa operazione ottieni un numero, la variabile che usi deve avere un tipo numerico.  
Se ottieni un testo, deve essere una stringa.  
Se richiami un costruttore della classe **GetNumber** , il valore che ottieni e’ del tipo **GetNumber** ,  
come fa ad essere di un altro tipo ? 🙂  
Quando assegni il valore di una espressione ad una variabile, il tipo della variabile **deve** essere quello del valore che ottieni come risultato da quella espressione.

Qui c’e’ una grande differenza da VBScript o da Python, dove tu non ti preoccupi del tipo di dati, pensa a tutto l’interprete. Questi sono linguaggi non ‘tipizzati’.

C# invece e’ un linguaggio ‘tipizzato’, tu devi dichiarare li tipo di dati di ogni variabile, di ogni parametro di funzione e di ogni valore restituito da una funzione.  
( **var** e’ un aiuto per velocizzare la scrittura in certe situazioni, ma tu devi comunque sapere esattamente che tipo di dati stai utilizzando, se no non vai lontano col tuo script )  
E devi dichiarare il tipo che corrisponde al valore che metti nella variabile, non puoi dichiararne uno a piacere.

Qui non c’entra la programmazione ad oggetti, questo e’ un concetto valido per ogni linguaggio ‘tipizzato’.  
Devi utilizzare e quindi dichiarare per le variabili il giusto tipo di dati.  
Non importa se il tipo di dati in questione e’ un ‘vecchio’ **int** o **double** o **string** oppure una classe di RhinoCommon o scritta da te ecc.  
Se una variabile deve contenere un valore/oggetto di un certo tipo, devi dichiararla con quel tipo.

E’ per questo che il C#, come altri linguaggi simili, e’ piu’ veloce di Python.  
Quando esegui uno script in Python, l’interprete non sa in anticipo che tipo di dati e’ salvato in una certa variabile, quindi deve verificare in fase di esecuzione e comportarsi di conseguenza, perdendo un mucchio di tempo.

Il compilatore di un linguaggio tipizzato sa da subito che tipi di dati sta utilizzando e quindi puo’ scrivere nel file **exe** o quello che e’ le giuste istruzioni per elaborare quei dati, senza inserire nessun controllo, e la cosa e’ decisamente piu’ veloce.  
Ma per fare questo e’ necessario che tu dichiari le variabili con il giusto tipo/classe quando scrivi lo script.

E’ chiaro adesso che **GetNumber** e’ solo un tipo di dati, come **int** o **string**? 🙂

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [29 Dicembre 2022, 1:24am UTC](https://it.discourse.mcneel.com/t/conferma-metodo-rcommon/4833/16 "2022-12-29T01:24:43Z")

</div>

> [@emilio](#):
>
> E’ chiaro adesso che **GetNumber** e’ solo un tipo di dati, come **int** o **string**? 🙂

su questo punto si è chiaro, la confusione come hai detto è nata dal fatto che fin’ora non ho mai dovuto preoccuparmi di dichiarare il tipo di dati quindi questo è un argomento del tutto nuovo e che quindi dovrò capire il ragionamento che c’é dietro e metabolizzarlo. di sicuro divieto di applicare double al GetNumber 😊

battute a parte, in Py non avevo mai fatto caso che per inizializzare una variabile ci sono vari tipi tra cui  
double, mentre come input di valori / tipi di dati digitabili da tastiera siano solo stringa, integer e real. . .

quindi var in **var gd = new GetNumber();** come tipo di dato è corretto definirlo generico?

---

<div class="post-metadata">

**Author:** ![RiccardoMajewski](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/riccardomajewski/32/22945_2.png) [@RiccardoMajewski](https://it.discourse.mcneel.com/u/RiccardoMajewski)\
**Post date:** [29 Dicembre 2022, 1:32am UTC](https://it.discourse.mcneel.com/t/conferma-metodo-rcommon/4833/17 "2022-12-29T01:32:14Z")

</div>

```auto
Rhino.Input.Custom.GetNumber getter = new Rhino.Input.Custom.GetNumber();
getter.SetCommandPrompt("Inserisci un numero");
getter.Get();
double a = getter.Number();

```

Per farne una metafora:  
1

```auto
Rhino.Input.Custom.GetNumber getter = new Rhino.Input.Custom.GetNumber();

```

Questa riga crea un nuovo oggetto, chiamiamolo “postino”, “corriere” o “messaggero”.  
È un corriere nuovo, non specializzato, senza istruzioni specifiche.  
Conosce solo la sua destinazione: la barra di comando, l’utente.

2

```auto
getter.SetCommandPrompt("Inserisci un numero");

```

Qui diciamo al corriere cosa dire quando arriverà a destinazione.

3

```auto
getter.Get();

```

Ora diciamo al corriere “vai, parti” e lui parte a fare il suo lavoro (altrimenti stava li tranquillo a oziare).  
In questo caso il corriere è andato a raccogliere una pizza (un numero double), e poi torna.  
(Potremmo dire al corriere nuovamente “vai!” e lui partirebbe, buttando la vecchia pizza!)

4

```auto
double a = getter.Number();

```

Chiediamo al corriere di darci la pizza che ha ritirato.

Nota che “getter”, il nostro corriere, non è una pizza!  
Potremmo avere molti altri tipi di “getter”: postini, messaggeri, sicari, ecc ecc …e dargli istruzioni diverse… o istruire in modo diverso il nostro corriere così che impari a ritirare panini (int).

* * *

* * *

* * *

Una cosa completamente diversa è questa, invece:

```auto
double x = 0;
Rhino.Commands.Result risultato = Rhino.Input.RhinoGet.GetNumber("Inserisci un numero", true, ref x);

```

In questo caso abbiamo un oggetto che viene “consumato” al volo, nell’istante in cui lo crei ha già compiuto il suo lavoro, ovvero impostare il numero ottenuto dentro la variabile “x”.  
Molto più sbrigativo e senza fronzoli.  
L’oggetto risultato non ha alcuna utilità, se non dirti se il comando è andato a buon fine (success/failure).  
Si può omettere, così:

```auto
double x = 0;
Rhino.Input.RhinoGet.GetNumber("Inserisci un numero", true, ref x);

```

* * *

* * *

* * *

> [@0904](#):
>
> ho mischiato le due cose var gd = new GetNumber(); con public double X{get} o public Coords(double x);

Si, decisamente.  
I primi, i metodi di Rhinocommon come Input.Custom… o Input.RhinoGet sono metodi creati da McNeel per far interagire l’utente durante l’esecuzione di un codice.  
I secondi, sono metodi “accessors” che permettono di gestire l’accessibilità di una proprietà di un oggetto.  
Ad esempio, se io ho una classe così:

```auto
class Persona{
   public string Nome;
   public string Età;
}

```

Il nome ed età della persona sono pubblici, qualsiasi metodo esterno può modificarli senza che nient’altro accada.  
Invece, se fai così:

```auto
class Persona{
   private string Nome;
   private int Età;
   public string nome{
      get{
      return this.Nome;
      }
      set{
      this.Nome = value;
      }
   }
   public int eta{
      get{
      return this.Età;
      }
      set{
      this.Età= value;
      }
   }
}

```

vedi che non si accede più **direttamente** alle proprietà dell’oggetto, ma attraverso un metodo, che ci permette dei get/set in base a come abbiamo deciso che sia permessa la lettura/scrittura di tale proprietà.  
Nota che, essendo metodi potrebbero fare dell’altro, come:

```auto
class Persona{
   private string Nome;
   private int Età;
   public string nome{
      get{
      return this.Nome;
      }
      set{
      bool x = ChiedoAllAnagrafeSePossoCambiareNome();
      if(x){this.Nome = value;}
      }
   }
   public int eta{
      get{
      RispostaEmotivaInBaseAlContesto();
      return this.Età;
      }
   }
}

```

Nel tuo esercizio sembra che vogliano dare un permesso solo di lettura a due variabili pubbliche, ma non ho mai usato struct quindi non so…

---

<div class="post-metadata">

**Author:** ![emilio](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/emilio/32/16095_2.png) [@emilio](https://it.discourse.mcneel.com/u/emilio)\
**Post date:** [29 Dicembre 2022, 2:05am UTC](https://it.discourse.mcneel.com/t/conferma-metodo-rcommon/4833/18 "2022-12-29T02:05:19Z")

</div>

> [@0904](#):
>
> quindi var in **var gd = new GetNumber();** come tipo di dato è corretto definirlo generico?

Credo che in C# il tipo generico sia **object**.  
Qui in **gd** carichi un oggetto di tipo **GetNumber** , dato che stai richiamando un costruttore della classe **GetNumber**.

Forse c’e’ ancora qualcosa che non ti convince nel tipo/classe **GetNumber**? 🙂

Se ti riferisci al **var** , non significa che sia generico o sconosciuto.  
Vuol solo dire che il compilatore ricava il tipo di dati dal valore che carichi nella variabile.  
Sono problemi del compilatore, comunque se ti confonde puoi benissimo scrivere:

```csharp
GetNumber gd = new GetNumber();

```

Anzi, secondo me e’ meglio se per ora usi questa sintassi, cosi’ il tipo di dati risulta chiaro e non ci sono posssibilita’ di confondersi.

> [@0904](#):
>
> in Py non avevo mai fatto caso che per inizializzare una variabile ci sono vari tipi tra cui  
> double, mentre come input di valori / tipi di dati digitabili da tastiera siano solo stringa, integer e real. . .

In Python il **double** si chiama **float**.  
Mentre **rhinoscriptsyntax** a volte lo chiama **real**.  
Ma sono sempre la stessa cosa, non preoccuparti. 😉

---

<div class="post-metadata">

**Author:** ![Sergio\_Alessi](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/sergio_alessi/32/22676_2.png) [@Sergio\_Alessi](https://it.discourse.mcneel.com/u/Sergio_Alessi)\
**Post date:** [29 Dicembre 2022, 8:42am UTC](https://it.discourse.mcneel.com/t/conferma-metodo-rcommon/4833/19 "2022-12-29T08:42:25Z")

</div>

Tutti i metodi di input (così come i metodi getX) di rhino sono dei Command che restituiscono  
un tipo Return che indica lo stato in cui è terminato il comando: Success, Cancel ecc..  
Riccardo ha spiegato come “contenere” il codice:

> [@RiccardoMajewski](#):
>
> ```auto
> double x = 0;
> Rhino.Input.RhinoGet.GetNumber("Inserisci un numero", true, ref x);
> 
> ```

Se l’utente annulla il comando, come si intercetta l’eccezione a livello di codice?

```auto
double x = 0;
Rhino.Command.Result rc = Rhino.Input.RhinoGet.GetNumber("Inserisci un numero", true, ref x);
if (rc != Rhino.Commands.Result.Success)
  return rc;

```

> [@emilio](#):
>
> ```auto
> class main
> {
> static void Main()
> {
>        
> new pnt( 11, 22 ).scale( 2 ).movex( 11 ).movey( 22 ).show();
>  
> }
> }
> 
> ```

@emilio , il tuo è veramente un codice compatto! 😀

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [29 Dicembre 2022, 10:54am UTC](https://it.discourse.mcneel.com/t/conferma-metodo-rcommon/4833/20 "2022-12-29T10:54:03Z")

</div>

ragazzi grazie a tutti per gli esempi e spiegazioni postate vedrò di asimilare il più possibile 👍

diciamo che adesso sto cercando di capire quale sia il modo corretto di assemblare tutti i pezzi acquisiti

> [@emilio](#):
>
> Se ti riferisci al **var** , non significa che sia generico o sconosciuto.  
> Vuol solo dire che il compilatore ricava il tipo di dati dal valore che carichi nella variabile.  
> Sono problemi del compilatore, comunque se ti confonde puoi benissimo scrivere:
> 
> ```auto
> GetNumber gd = new GetNumber();
> 
> ```
> 
> Anzi, secondo me e’ meglio se per ora usi questa sintassi, cosi’ il tipo di dati risulta chiaro e non ci sono posssibilita’ di confondersi.

chiarito che **var** non vuole dire variabile generica ma che è il compilatore che va a cercarsi il tipo di dato caricato nella variabile (quindi va a fare quello che fa di consueto un linguaggio non tipizzato)

> [@emilio](#):
>
> `GetNumber gd = new GetNumber();`

infatti negli esempi visti veniva usato proprio questa sintassi, quindi quel var ha finito di confondermi

> [@RiccardoMajewski](#):
>
> `double a = getter.Number();`

a ecco dove mi perdevo, giustamente GetNumber è un metodo/classe  
se debbo settarlo come double lo debbo fare col suo valore `double a = getter.Number();` giusto 👍

Riccardo una domanda: ma quel **getter** è in grassetto perché è una parola chiave oppure è come **gd**?

poi faccio giusto una mia riflessione anche se può sembrare un ragionamento limitato:  
gd o getter come citato da Riccardo è un facchino che sa solo dove andare  
(quello che non comprendo del perché viene fatto in questo modo anche se ne prendo atto)

```auto
Rhino.Input.Custom.GetNumber getter = new Rhino.Input.Custom.GetNumber();

```

getter è il facchino, “new Rhino.Input.Custom.GetNumber()” è nuovo ordine che gli verrà dato  
però prima debbo impostare/scegliere il facchino giusto con “Rhino.Input.Custom.GetNumber”

in pratica il facchino che deve andare a prendere la pizza per poi consegnarla  
deve avere impostato che ciò che dovrà prendere è una pizza, perché si dovrà portare con se il cartone della pizza per metterla dentro e consegnarla, se invece gli davo un panino, dovevo settarlo in modo che sapesse che quello che gli davo fosse un panino, in modo che si doveva portate il cartone del panino.  
altrimenti il facchino si dovrebbe portare tutti i tipi di cartone per poi scegliere quello giusto. . .

spero sia +/- corretto come riassunto? (anche se nella vita reale il cartone lo da il pizzaiolo ahahahah)

edit: vedo di fare un’altro esempio diciamo che se chiamo una ditta di traslochi, vuole sapere inizialmente il tipo di lavoro per organizzarsi se deve trasportare oggetti fragili deve portare il pluriball, mentre se sono solo abiti va bene metterli semplicemente in un cartone da imballaggio per poi trasprtarli.

[Pagina seguente](https://it.discourse.mcneel.com/t/conferma-metodo-rcommon/4833.md?page=2)