ciao e benvenuto nel forum,
hai vari modi per produrre output, che cambiano in base al tipo di progetto (es. con le applicazioni console puoi fare un Console.WriteLine)

cricchi ha scritto:

Per esempio in questo esempio come faccio?

L'esempio che hai trovato mostra due frammenti di codice da usare separatamente. Il primo è la definizione di una classe che va in un proprio file Person.cs.

Le due righe in cui crei un'istanza di Person, invece vanno nel blocco di esecuzione del programma (es. in un'applicazione console andrebbe nel metodo Main())

...ma non sempre è necessario produrre output per avere un riscontro di quello che si è fatto. In quel caso potresti aggiungere un breakpoint di fianco alla riga Person p = new Person(). E' un pallino rosso che appare quando clicchi alla sinistra della riga in questione.

Ora lancia il programma in debug (tasto F5 sulla tastiera), e l'esecuzione si metterà in pausa in corrispondenza del breakpoint. A questo punto puoi usare la ricca strumentazione di Visual Studio per ispezionare il contenuto delle variabili e vedere, ad esempio, quali sono tutti i membri dell'oggetto Person che hai assegnato alla variabile p, e quali sono i relativi valori (basta portare il mouse sopra la variabile p).

Se sei in fase di studio, questo è un approccio migliore per esaminare il proprio codice, perché puoi intervenire in tempo reale e non sei costretto a rilanciare il programma ogni volta.

• Puoi decidere se proseguire l'esecuzione del programma un passo alla volta (tasto F10)
• Di fare "watch" sulle variabili, per controllarne il contenuto man mano che il programma avanza
• Di eseguire del codice arbitrario dalla finestra "Immediate Window" (anche questo è un modo per produrre output)

Qui trovi delle altre guide all'uso del debugger
http://msdn.microsoft.com/it-it/library/sc65sadd.aspx
https://www.youtube.com/watch?v=7ab4z9u7Q_I

ciao,
Moreno

---

Modificato da BrightSoul il 06 settembre 2014 09.23 -

ciao,

cricchi ha scritto:

per voi magari gli errori sono stupidi

Guarda, spesso gli errori dipendono dalla manca lettura o dalla mancata comprensione del manuale. Si risolvono in fretta perché basta leggere (o rileggere).

In questo caso l'errore dipende dal fatto che non ti sei ancora imbattuto nel paragrafo che spiega che le classi non si possono dichiarare dentro i metodi, ma solo dentro i namespace (o dentro altre classi).

Guarda questo esempio:
https://dotnetfiddle.net/QnXG3a
Ho portato la definizione della classe Persona al di fuori del metodo Main. Ora si trova infatti al pari della classe Program. Sarebbe meglio che ogni classe si trovasse su un proprio file che ne porta il nome, per questione di ordine e chiarezza, ma anche così funzionerà.

L'istruzione che crea un'istanza della classe Persona, invece, si trova nel metodo Main(), che è il punto di ingresso del programma.

ciao,
Moreno

ciao,
sì, ho aggiunto quei nuovi elementi per rendere la classe Persona un po' più vicina ad un caso reale.

cricchi ha scritto:

public Persona() : this("NomeSconosciuto", 18) { }

Questa è semplicemente la dichiarazione di un costruttore senza parametri che, quando viene invocato, richiama l'altro costruttore, quello con due parametri.
Il this identifica l'istanza corrente di Persona, quindi quella riga significa letteralmente:
"Quando si usa il costruttore Persona(), cerca in questa stessa istanzail costruttore con due parametri, e invocalo passando i valori NomeSconosciuto e 18."

In pratica, quando fai new Persona(), il runtime invocherà l'altro costruttore come se tu stesso avessi scritto new Persona("NomeSconosciuto", 18).

Il vantaggio di usare questo sistema è che non sei costretto a ripetere la logica nei due costruttori, fosse anche una banale assegnazione di variabili.
Ricorda che se ti trovi nella situazione di dover copiare-incollare lo stesso codice in due punti diversi, probabilmente esiste una soluzione più elegante al problema. In questo caso, "più elegante" significa anche più manutenibile, perché hai meno codice da gestire.

cricchi ha scritto:

Fino ad ora sapevo che tutto quello che veniva inserito tra virgolette dentro al Console.WriteLine veniva visualizzato a schermo

Certamente, ma le stringhe possono essere trasformate da varie funzioni, come per esempio Replace, che sostituisce un pezzo di stringa in un altro.

Qui ho usato il Replace per modificare una stringa definita nella prima istruzione. Dopo queste due righe di codice, la variabile frase punterà alla stringa "Il mio colore preferito è il verde".

Nell'esempio che ti ho portato, quello con i segnaposto {0} e {1}, succede più o meno la stessa cosa. Essi vengono rimpiazzati dagli altri due argomenti che ho fornito a string.Format, ovvero NomeCompleto ed Età.

cricchi ha scritto:

Pensavo valesse la stessa regola sia per il console.writeline

Il Console.WriteLine mostrerà a video quello che gli arriva, né più né meno. Non esistono regole speciali che ne modificano il comportamento.
Quindi mostrerà il risultato che lo String.Format gli ha restituito, ovvero quella stringa in cui i segnaposto {0} e {1} sono ormai stati sostituiti.

ciao,
Moreno

---

Modificato da BrightSoul il 07 settembre 2014 09.31 -

cricchi ha scritto:

E se invece avessi usato un metodo statico?

Meglio, il codice sarebbe più chiaro perché puoi crearti due metodi statici "CreaPersona" e "CreaPersonaAnonima". Non è il più conosciuto dei pattern, mi stupisce che tu ti sia imbattuto già in questa cosa. Comunque, meglio così perché ha un grande valore semantico: un altro sviluppatore che leggesse il tuo codice, capirebbe subito che tu hai previsto sia la possibilità di creare una persona dando nome e cognome, che di creare una persona anonima.
Usando due costruttori, l'intento non sarebbe ugualmente chiaro.

Se scegli questa strada dovrai rendere privato il costruttore, così che l'utente della tua classe non possa creare un'istanza bypassando quei metodi statici.

cricchi ha scritto:

Perché funziona uguale allo stesso modo?

Get e Set sono caratteristiche di una proprietà. Togliendoli, sei rimasto con un campo.

Entrambi possono essere assegnati ad un valore, ma sono due membri diversi.

Se rendi pubblico un campo, ti esponi facilmente a bug perché l'utente della tua classe può riassegnarlo ad altri valori senza che tu ne sappia nulla.

Invece, una proprietà espone due metodi (get e set) che ti danno un controllo granulare sulla lettura e sulla scrittura. Come nel mio esempio, puoi consentire la sola lettura, ma non la scrittura (rendendo privato il set).

Non solo, come vedi qui, puoi mettere della logica all'interno di get e set, in modo da regolare l'accesso al dato. Se per esempio l'utente provasse a valorizzare la proprietà con un valore non valido, tu potresti intercettarlo e lanciare un'eccezione per proteggere lo stato interno dell'oggetto.

Tutto questo con i campi non puoi farlo. Si usano più che altro col modificatore private, in modo che sia la classe stessa l'unica a poter leggere e scrivere il loro valore.


ciao,
Moreno

---

Modificato da BrightSoul il 07 settembre 2014 19.28 -