C# per aspiranti programmatori – A overview

C # è un elegante linguaggio orientato agli oggetti che consente agli sviluppatori di creare una varietà di applicazioni sicure e robuste eseguite su .NET Framework. È possibile utilizzare C # per creare applicazioni Windows, servizi Web, applicazioni mobili, applicazioni client-server, applicazioni di database e molto altro ancora. .NET Framework è costituito dal Common Language Runtime (CLR) e dalla libreria di classi .NET Framework. Il CLR è la base di .NET Framework. Gestisce il codice al momento dell’esecuzione, fornendo servizi di base come la gestione della memoria, l’accuratezza del codice e molti altri aspetti del codice. La libreria di classi è una raccolta di classi, interfacce e tipi di valori che consentono di eseguire una serie di attività di programmazione comuni, come raccolta di dati, accesso ai file e utilizzo del testo. I programmi C # utilizzano la libreria di classi .NET Framework in modo estensivo per eseguire attività comuni e fornire varie funzionalità. Questi concetti possono sembrare complessi, ma per ora ricordate che le applicazioni scritte in C # utilizzano .NET Framework e i suoi componenti. I programmi in genere utilizzano i dati per eseguire attività. La creazione di una variabile riserva una posizione di memoria, o uno spazio in memoria, per la memorizzazione dei valori. Si chiama variabile perché le informazioni memorizzate in quella posizione possono essere modificate quando il programma è in esecuzione. Per utilizzare una variabile, è necessario prima dichiararla specificando il nome e il tipo di dati. Un nome di variabile, detto anche identificatore, può contenere lettere, numeri e il carattere di sottolineatura (_) e deve iniziare con una lettera o un trattino basso. Sebbene il nome di una variabile possa essere un qualsiasi insieme di lettere e numeri, l’identificatore migliore è descrittivo dei dati che conterrà. Questo è molto importante per creare un codice chiaro, comprensibile e leggibile! Ad esempio, firstName e lastName sono buoni nomi di variabili descrittive, mentre abc e xyz no. Un tipo di dati definisce le informazioni che possono essere memorizzate in una variabile, la dimensione della memoria necessaria e le operazioni che possono essere eseguite con la variabile. Ad esempio, per memorizzare un valore intero (un numero intero) in una variabile, utilizzare la parola chiave int: int myAge; Il codice sopra dichiara una variabile denominata myAge di tipo intero. Una riga di codice che completa un’azione è detta istruzione. Ogni istruzione in C # deve terminare con un punto e virgola. Puoi assegnare il valore di una variabile quando la dichiari: int myAge = 18; o più tardi nel tuo codice: int myAge; myAge = 18; Ricorda che devi dichiarare la variabile prima di usarla.

Esistono numerosi tipi di dati incorporati in C #. I più comuni sono:

int – numero intero.
float – numero in virgola mobile.
doppia – versione a doppia precisione di float.
char: un singolo carattere.
bool: booleano che può avere solo uno dei due valori: True o False.
string – una sequenza di caratteri.

Le istruzioni seguenti utilizzano tipi di dati C #:

int x = 42;
doppio pi = 3,14;
char y = ‘Z’;
bool isOnline = true;
string firstName = “David”;

Si noti che i valori char vengono assegnati utilizzando virgolette singole e i valori stringa richiedono virgolette doppie. Puoi eseguire, salvare e condividere i tuoi codici C # sul nostro Code Playground, senza installare alcun software aggiuntivo. Fai riferimento a questa lezione se hai bisogno di installare il software sul tuo computer. Per creare un programma C #, è necessario installare un ambiente di sviluppo integrato (IDE) con strumenti di codifica e debug. Useremo Visual Studio Community Edition, che è disponibile per il download gratuito. Dopo averlo installato, scegli la configurazione predefinita. Quindi, fai clic su File-> Nuovo-> Progetto, quindi seleziona Applicazione Console, inserisci un nome per il tuo progetto e fai clic su OK. L’applicazione console utilizza un’interfaccia di solo testo. Abbiamo scelto questo tipo di applicazione per concentrarci sull’apprendimento dei fondamenti di C #. Visual Studio genererà automaticamente del codice per il tuo progetto:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace UmbriaWay
{
programma di classe
{
static void Main (string [] args)
{
}
}
}

Imparerai cosa fa ciascuna delle affermazioni nelle prossime lezioni. Per ora, ricorda che ogni applicazione della console C # deve contenere un metodo (una funzione) denominato Main. Principale è il punto di partenza di ogni applicazione, cioè il punto da cui il nostro programma inizia l’esecuzione. Impareremo a conoscere classi, metodi, argomenti e spazi dei nomi nelle prossime lezioni. Per eseguire il tuo programma, premi Ctrl + F5. Vedrai la finestra della console. Poiché non avevamo alcuna istruzione nel nostro metodo Main, il programma produce solo un messaggio generale. Premendo qualsiasi tasto si chiuderà la console. Congratulazioni, hai appena creato il tuo primo programma C #. La maggior parte delle applicazioni richiede qualche input da parte dell’utente e restituisce l’output come risultato. Per visualizzare il testo nella finestra della console, utilizzare i metodi Console.Write o Console.WriteLine. La differenza tra questi due è che Console.WriteLine è seguito da un terminatore di riga, che sposta il cursore sulla riga successiva dopo l’output del testo. Il programma seguente mostrerà Hello World! alla finestra della console:

static void Main (string [] args)
{
Console.WriteLine (“Hello World!”);
}

Notare le parentesi dopo il metodo WriteLine. Questo è il modo per passare dati o argomenti ai metodi. Nel nostro caso, WriteLine è il metodo e passiamo “Hello World!” ad esso come una discussione. Gli argomenti stringa devono essere racchiusi tra virgolette. Possiamo visualizzare valori variabili nella finestra della console:

static void Main (string [] args)
{
int x = 89;
Console.WriteLine (x);
}
// Output 89

Per visualizzare una stringa formattata, utilizzare la seguente sintassi:

static void Main (string [] args)
{
int x = 10;
doppio y = 20;

Console.WriteLine (“x = {0}; y = {1}”, x, y);
}
// Output: x = 10; y = 20

Come puoi vedere, il valore di x sostituito {0} e il valore di y sostituito {1}.Puoi avere tanti segnaposti variabili di cui hai bisogno. (ad es. {3}, {4}, ecc.).

È inoltre possibile chiedere all’utente di immettere dati e quindi utilizzare il metodo Console.ReadLine per assegnare l’input a una variabile stringa. L’esempio seguente richiede all’utente un nome e quindi visualizza un messaggio che include l’input:

static void Main (string [] args)
{
stringa yourName;
Console.WriteLine (“Qual è il tuo nome?”);

yourName = Console.ReadLine ();

Console.WriteLine (“Hello {0}”, yourName);
}

Il metodo Console.ReadLine attende l’input dell’utente e quindi lo assegna alla variabile. L’istruzione successiva mostra una stringa formattata contenente Hello con l’input dell’utente. Ad esempio, se inserisci David, l’output sarà Hello David. Nota le parentesi vuote nel metodo ReadLine. Ciò significa che non accetta argomenti. Il metodo Console.ReadLine () restituisce un valore stringa. Se si prevede un altro tipo di valore (come int o double), i dati immessi devono essere convertiti in quel tipo. Questo può essere fatto usando i metodi Convert.ToXXX, dove XXX è il nome .NET del tipo che vogliamo convertire. Ad esempio, i metodi includono Convert.ToDouble e Convert.ToBoolean. Per la conversione di interi, sono disponibili tre alternative basate sulla dimensione del bit dell’intero: Convert.ToInt16, Convert.ToInt32 e Convert.ToInt64. Il tipo int predefinito in C # è 32 bit. Creiamo un programma che prende un intero come input e lo visualizza in un messaggio:

static void Main (string [] args)
{
int age = Convert.ToInt32 (Console.ReadLine ());
Console.WriteLine (“Hai {0} anni”, età);
}

Se, nel programma in alto, viene immesso un valore non intero (ad esempio, lettere), Convert fallirà e causerà un errore. I commenti sono dichiarazioni esplicative che puoi includere in un programma a beneficio del lettore del tuo codice. Il compilatore ignora tutto ciò che appare nel commento, quindi nessuna di queste informazioni influisce sul risultato. Un commento che inizia con due barre (//) viene chiamato commento a riga singola. Le barre dicono al compilatore di ignorare tutto ciò che segue, fino alla fine della riga.

// Stampa Hello
Console.WriteLine ( “Ciao”);

Quando si esegue questo codice, Hello verrà visualizzato sullo schermo. // Stampa la linea Hello è un commento e non verrà visualizzato come output.

I commenti che richiedono più righe iniziano con / * e terminano con * / alla fine del blocco dei commenti.
Puoi posizionarli sulla stessa riga o inserire una o più linee tra loro.

/ * Alcuni lungo
testo del commento
* /
int x = 42;
Console.WriteLine (x);

Aggiungere commenti al tuo codice è una buona pratica di programmazione. Facilita una chiara comprensione del codice per te e per gli altri che lo leggono.

Una variabile può essere dichiarata esplicitamente con il suo tipo prima che venga utilizzata. In alternativa, C # fornisce una comoda funzione per consentire al compilatore di determinare automaticamente il tipo di variabile in base all’espressione a cui è assegnato. La parola chiave var viene utilizzata per questi scenari: var num = 15; Il codice fa sì che il compilatore determini il tipo della variabile. Poiché il valore assegnato alla variabile è un numero intero, la variabile verrà dichiarata automaticamente come numero intero. Le variabili dichiarate usando la parola chiave var sono chiamate variabili implicitamente tipizzate. Le variabili implicitamente tipizzate devono essere inizializzate con un valore.

Ad esempio, il seguente programma causerà un errore:
var num;
num = 42;

Sebbene sia facile e conveniente dichiarare variabili usando la parola chiave var, l’uso eccessivo può danneggiare la leggibilità del codice. La migliore pratica è dichiarare esplicitamente le variabili.

Le costanti memorizzano un valore che non può essere modificato dal loro compito iniziale. Per dichiarare una costante, usa il modificatore const.

Ad esempio:
const double PI = 3.14;

Il valore di const PI non può essere modificato durante l’esecuzione del programma. Ad esempio, un’istruzione di assegnazione più avanti nel programma causerà un errore:

const double PI = 3.14;
PI = 8; //errore

Le costanti devono essere inizializzate con un valore quando dichiarato. Vediamo semplici operazioni matematiche:

int x = 10;
int y = 4;
Console.WriteLine(x-y);
//Outputs 6

int x = 10 / 4;
Console.WriteLine(x);
// Outputs 2

int x = 25 % 7;
Console.WriteLine(x);
// Outputs 4

int x = 10;
int y = 4;
Console.WriteLine(x*y);
//Outputs 40

int x = 10;
int y = 4;
Console.WriteLine(x+y);
//Outputs 14

La precedenza degli operatori determina il raggruppamento dei termini in un’espressione, che influisce sul modo in cui viene valutata un’espressione. Alcuni operatori hanno la precedenza sugli altri; ad esempio, l’operatore di moltiplicazione ha una precedenza maggiore rispetto all’operatore di addizione. Per esempio:

int x = 4+3*2;
Console.WriteLine(x);
// Outputs 10

Il programma valuta prima 3 * 2, quindi aggiunge il risultato a 4. Come in matematica, l’uso delle parentesi altera la precedenza degli operatori.

int x = (4 + 3) *2;
Console.WriteLine(x);
// Outputs 14

Le operazioni tra parentesi vengono eseguite per prime. Se ci sono espressioni parentetiche annidate l’una nell’altra, l’espressione all’interno delle parentesi più interne viene valutata per prima. Se nessuna delle espressioni è tra parentesi, gli operatori moltiplicativi (moltiplicazione, divisione, modulo) saranno valutati prima degli operatori additivi (addizione, sottrazione). Operatori di uguale precedenza sono valutati da sinistra a destra.

L’operatore = assignment assegna il valore sul lato destro dell’operatore alla variabile sul lato sinistro. C # fornisce anche operatori di assegnazione composti che eseguono un’operazione e un compito in un’unica istruzione.Per esempio:

int x = 42;
x + = 2; // equivalente a x = x + 2
x – = 6; // equivalente a x = x – 6

La stessa sintassi abbreviata si applica agli operatori di moltiplicazione, divisione e modulo.

x * = 8; // equivalente a x = x * 8
x / = 5; // equivalente a x = x / 5
x% = 2; // equivalente a x = x% 2

L’operatore di incremento viene utilizzato per aumentare il valore di un intero di uno ed è un operatore C # di uso comune.

x ++; // equivalente a x = x + 1

Per esempio:

int x = 10;
x ++;
Console.WriteLine (x);
// Output 11

L’operatore di incremento ha due forme, prefisso e suffisso.

++ x; //prefisso
x ++; // postfix

Il prefisso incrementa il valore e quindi procede con l’espressione. Postfix valuta l’espressione e quindi esegue l’incremento.

Esempio di prefisso:

int x = 3;
int y = ++ x;
// x è 4, y è 4

Esempio di postfix:

int x = 3;
int y = x ++;
// x è 4, y è 3

L’esempio del prefisso incrementa il valore di x, quindi assegna a y. L’esempio postfix assegna il valore di x a y, quindi incrementa x. L’operatore di decremento (-) funziona allo stesso modo dell’operatore di incremento, ma invece di aumentare il valore, lo diminuisce di uno .– x; // prefisso X–; // postfix. L’operatore di decremento (-) funziona allo stesso modo dell’operatore di incremento.

Rispondi

Inserisci i tuoi dati qui sotto o clicca su un'icona per effettuare l'accesso:

Logo di WordPress.com

Stai commentando usando il tuo account WordPress.com. Chiudi sessione /  Modifica )

Google photo

Stai commentando usando il tuo account Google. Chiudi sessione /  Modifica )

Foto Twitter

Stai commentando usando il tuo account Twitter. Chiudi sessione /  Modifica )

Foto di Facebook

Stai commentando usando il tuo account Facebook. Chiudi sessione /  Modifica )

Connessione a %s...