Conferma Metodo Rcommon

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. :slight_smile:

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 ? :thinking: :grinning_face_with_smiling_eyes:

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. :slight_smile:

P.S.

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

parto dall’ultima :wink:

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?)

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.

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. :wink: :blush: )

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. :blush: :grinning_face_with_smiling_eyes:

1 Mi Piace

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:

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

Peccato che non sia un valore double … :wink:

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

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

( Ripeto ancora … sono un disco rotto, lo so … :wink: )
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 … :wink:
Comunque se tu ti trovi bene cosi’, OK ! :grinning:

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

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();
 
  }
}
1 Mi Piace

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. . . . :joy: :joy: :sweat_smile:

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 :laughing:

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. . . :wink:

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

Credevo che il compilatore ricavasse comunque il tipo di dati utilizzato … :thinking:
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. :slight_smile:

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

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

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:

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”

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

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.

:thinking:

Ottimo, proviamo a ripartire da qui. :grinning:

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

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

… cosi’ abbiamo qualcosa da cui partire.
O almeno ci proviamo … :confused: :wink: :grinning_face_with_smiling_eyes:

ok prof :+1:

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:

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:

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

1 Mi Piace

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 ? :slight_smile:
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.

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. :grinning_face_with_smiling_eyes:
Ma e’ l’unico modo di utilizzare RhinoCommon.

1 Mi Piace

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

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

ok su questo è assodato

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

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

1 Mi Piace

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

string risultato = 5 + 8;

Come non puoi scrivere

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 ? :slight_smile:
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 ? :slight_smile:

2 Mi Piace

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 :blush:

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?

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

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

getter.SetCommandPrompt("Inserisci un numero");

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

3

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

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:

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ì:

double x = 0;
Rhino.Input.RhinoGet.GetNumber("Inserisci un numero", true, ref 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ì:

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ì:

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:

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…

3 Mi Piace

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 ? :slight_smile:

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:

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.

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

2 Mi Piace

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:

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

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 , il tuo è veramente un codice compatto! :grinning:

3 Mi Piace

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

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

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)

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

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 :+1:

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)

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.

è una formattazzione che fa il forum discourse , non l’ho voluto io.
Anzi, “getter” è quasi fuorviante, potrebbe alludere ad altro… sarebbe stato meglio lo chiamavo “corriere” o “postino” … è un nome come un’altro.

…no, “new Rhino.Input.Custom.GetNumber()” non è un nuovo ordine ma un nuovo facchino, la creazione di un nuovo facchino… che in quel caso lo chiamiamo “getter”.


Guarda qua:
2022-12-29 12_40_35-Script Editor
Rhino.Input.Custom contiene già molti tipi diversi di “facchini” ognuno già specializzato a prendere qualcosa in spacifico, l’ideale è prendere subito quello più vicino alle necessità.
Come già detto, io consiglierei di usare Rhino.Input.RhinoGet , sono più semplici…


Edit:
ad ogni modo, come al solito, consiglierei di andare sul pratico, piuttosto di stare sul teorico/astratto.
Poniti un obbiettivo semplice, un esercizio, una piccola macro funzionale, e poi cerca di crearla fino in fondo.
Tutte le cose che so di programmazione le ho imparate solo ed esclusivamente andando a tentativi per ottenere script che mi servivano, mai studiato teoria.
Non dico che sia il percorso migliore, ma neanche l’estremo opposto aiuta.
Metti in pratica in parallelo alla teoria.

PS, se lavori con c#, non usare “var”. È controproducente, soprattutto se vuoi imparare.

2 Mi Piace