Forum libero

Scritto da: Mattia
> Posto le soluzioni settimana prossima.
> Chi sta seguendo il corso provi a rispondere qui o in privato per vedere se ha capito e per costringersi a ripassare.
>
> 1) Spiega che cosa è .NET. Elenca il tipo di applicazioni che si possono realizzare con .NET. Quali sono i due principali linguaggi di programmazione di .NET?

.NET è un framework.
Si possono realizzare app native multipiattaforma, software compilati per windows, Silverlight e Mono sono tra questi.Rari sono i progetti di scripting in C#.
I principali linguaggi di .NET sono Visual Basic e C#, ma abbiamo anche F# che però è di minore rilevanza.


>
> 2) C# rientra nella categoria dei linguaggi managed, a differenza di altri linguaggi (come ad esempio il C) che è unmanaged. Qual'è la differenza tra un linguaggio managed e un linguaggio unmanaged?

Il C# è un linguaggio managed.Questo significa che è autogestito, ovvero sia la memoria heap che stack sono autogestite, cioè non decidi cosa mettere in tali memorie ma ciò è autogestito dal CLR e tu non devi preoccupartene.Quindi anche se non lo ripulisci non cadi il rischio di memory leak come nel C.In C# , come anche in Java, non ci sono i puntatori come nel C, che invece servivano per gestire direttamente i dati dell'heap avendo un riferimento nello stack.

La differenza tra un linguaggio managed e unmanaged è soprattutto quindi nella semplicità, nella maggiore portabilità, nell'assenza di memory leak.




> Quali sono i vantaaggi di un linguaggio managed? Esistono risorse unmanaged in C#?

Esistono i distruttori in C# ma generalmente non si usano.

Esistono risorse unmanaged in C# e sono relative ad oggetti che usano risorse unmanaged devi ripulirteli da solo con i distruttori.


>
> 3) Javascript è un linguaggio interpretato. C e C# sono linguaggi compilati. Il C viene compilato in linguaggio macchina, mentre C# viene compilato in un linguaggio che viene chiamato CIL (Common Intermediate Language).
> Spiega che differenza c'è tra un linguaggio interpretato e uno compilato e spiega la differenza tra il linguaggio macchina e il CIL. Qual'è il vantaggio di un linguaggio che non viene compilato in linguaggio macchina?


Il linguaggio interpretato utilizza un interprete specifico, come in javascript per tradurre il linguaggio di alto livello in istruzioni imperative che verranno eseguite immediatamente dal processore.
Il linguaggio compilato invece viene scritto generalmente in un IDE o blocco note, salvato in un eseguibile e debuggato , con il vantaggio di scovare eventuali errori dopodichè il linguaggio ad alto livello verrà trasmutato in linguaggio macchina che verrà dato in pasto alla CPU per poi eseguire istruzioni.Questo è il caso del C e C++ che sono linguaggi compilati puri. Mentre Java e C# sono linguaggi intermedi/misti, cioè vengono compilati, ma non generano linguaggio macchina, ma un linguaggio leggermente più ad alto livello chiamato bytecode nel caso di C# si chiama CIL Common intermdiate language, che non essendo linguaggio macchina non potrà essere dato in pasto direttamente alla CPU, ma verrà interpretato dalla CLR Common language runtime per generare istruzioni imperative.

Il vantaggio di un linguaggio compilato è la velocità di esecuzione e la possibilità di scovare errori nel debugging.
I vantaggi di uno interpretato sono la velocità nello sviluppo, visto che hanno meno fasi preparatorie.
Nel linguaggio compilato puoi nel debug scovare errori, in quello interpretato puoi scovare errori durante l'esecuzione (se ho capito bene).


>
> 4) Nelle scorse lezioni abbiamo visto i seguenti tipi di variabili: bool, byte, short, int, long. Spiega le loro caratteristiche (dimensione in bit, tipi di valore che possono contenere, utilizzo che ne viene fatto) e scrivi un programma in cui ciascun tipo viene inizializzato al suo valore minimo, al suo valore massimo e al suo valore di default. Stampa sullo schermo i risultati.


Allora bool può essere True o False
byte è di 8 bit
short 16 bit
int 32 bit
long 64 bit


>
> 5) Il byte è un tipo di variabile che può contenere numeri interi positivi.
> Dimostra che il valore minimo del byte è 0 e il valore massimo 255.
> La dimostrazione deve essere articolata in due parti:
> a) Dimostrazione matematica (suggerimento: è sufficiente la semplice matematica binaria, dal momento che il byte è solo per numeri positivi)
> b) Dimostrazione programmatica con C#: vedi esercizio 4.
>
> 6) Come il 5, ma sta volta per lo short.
> Dimostra che il valore massimo di uno short è 32'767.
> Suggerimento: dal momento che lo short può contenere sia valori negativi che positivi, la semplice matematica binaria non basta: la dimostrazione si deve avvalere del complemento a due, che tiene conto del segno.
>
>
>
>
> **Modificato dall'autore il 25.05.2018 13:39**

il resto Mattia te lo mando in pvt


gatto c'è questo compilatore online https://dotnetfiddle.net/ succedaneo a Visual Studio
se il tuo problema era collegarti al mio Visual Studio potresti fixare con questo, che ne dici?Proviamo!

Posto le soluzioni

Scritto da: Mattia
> 1) Spiega che cosa è .NET. Elenca il tipo di applicazioni che si possono realizzare con .NET. Quali sono i due principali linguaggi di programmazione di .NET?

.NET è un framework per lo sviluppo di applicazioni in ambienti windows.
È possibile con esso realizzare diversi tipi di applicazione: applicazioni console, applicazioni GUI per windows, applicazioni web, applicazioni mobile (con Xamarin), programmi destinati a far funzionare "internet of things" e applicazioni HMI (interfaccia uomo-macchina).

I due linguaggi di programmazione principali di .NET sono C# e Visual Basic, ma ce ne sonio anche diversi altri:

- F#: un linguaggio multiparadigma che consente, oltre alla programmazione ad oggetti come C#, anche la programmazione funzionale

- J#: un linguaggio che assomiglia a java, fatto per i programmatori java che vogliono sviluppare con .NET

- C++/CLI: una versione managed del C++ (in Visual Studio è comunque possibile anche programmare con il vero C++)


> 2) C# rientra nella categoria dei linguaggi managed, a differenza di altri linguaggi (come ad esempio il C) che è unmanaged. Qual'è la differenza tra un linguaggio managed e un linguaggio unmanaged?

Un linguaggio managed gira su una macchina virtuale, a differenza dei linguaggi unmanaged (come il C).

C# viene compilato in un linguaggio chiamato CLI, ovvero un linguaggio di più basso livello rispetto a C# che viene eseguito dal CLR (una macchina virtuale).

Un linguaggio unmanaged con il C invece viene compilato in linguaggio macchina, che ovviamente viene eseguito dalla macchina fisica e non da una macchina virtuale.


> Quali sono i vantaggi di un linguaggio managed?

In un linguaggio managed si può delegare alla macchina virtuale la gestione della memoria.

Nel C bisogna sempre ricordarsi di ripulire tutte le risorse allocate nell'heap. Questo richiede la scrittura di diverse righe di codice, in particolare è necessario dichiarare un distruttore in ogni classe che ha allocato risorse nell'heap.

Se non si ripulisce adeguatamente l'heap, ci possono essere dei memory leak (perdite di memoria) che si possono tradurre in un progressivo sovraccarico della memoria, oppure in situazioni in cui una risorsa del sistema operativo resta parmententemente aperta: ad esempio "file già in uso", "porta già in uso" e cose del genere.

In in linguaggio managed come C# la memoria è autogestita: questo significa, prima di tutto, che non ci si deve preoccupare di allocare risorse nell'heap piuttosto che nello stack, perché queste cose se le gestisce da solo il CLR.

Il più grosso vantaggio però risiede nel garbage collector, ovvero "il ripulitore automatico della memoria": il garbage collector capisce quando un oggetto non serve più: non serve più quando ogni referenza ad esso cessa di esistere, o per meglio dire non è più necessaria.

> Esistono risorse unmanaged in C#?

Si. Sono generalmente non gestite le risorse che non appartengono a .NET (come gli oggetti) ma al sistema operativo sottostante (file, connessioni,...).

Il pattern di C# per ripulire la memoria però è diverso da quello del C: una classe che utilizza risorse unmanaged, deve implementare un'interfaccia che si chiama IDisposable.
Se si utilizassero i distruttori come nel C sarebbe poco utile, perché il distruttore verrebbe chiamato dal garbage collector quando lo decide lui, mentre grazie all'interfaccia IDIsposable l'utilizzatore della classe acquisisce il controllo sulla gestione della memoria e la può ripulire non appena le classe non gli serve più.


> 3) Javascript è un linguaggio interpretato. C e C# sono linguaggi compilati. Il C viene compilato in linguaggio macchina, mentre C# viene compilato in un linguaggio che viene chiamato CIL (Common Intermediate Language).
> Spiega che differenza c'è tra un linguaggio interpretato e uno compilato e spiega la differenza tra il linguaggio macchina e il CIL. Qual'è il vantaggio di un linguaggio che non viene compilato in linguaggio macchina?

Un linguaggio interpretato viene eseguito da un programma, che lo legge nella sua forma originale.

Un linguaggio compilato invece viene prima tradotto in un linguaggio di più basso livello e poi viene eseguito.

Il C è un linguaggio puramente compilato, in quanto la sua compilazione produce file eseguibili contenenti linguaggio macchina.

C# invece è un miscuglio tra un linguaggio compilato e uno interpretato: viene compilato in un linguaggio di più basso livello, ma poi questo deve essere interpretato da un programma (il CLR, appunto) non essendo chiaramente eseguibile dalla macchina.

Il vantaggio di un linguaggio non puramente compilato (o interpretato al 100%) risiede, oltre che nella risposta alla precedente domanda (linguaggio managed vs linguaggio unmanaged), anche nel fatto che siccome non viene compilato in linguaggio macchina ma al massimo in un linguaggio di medio livello è maggiormente portabile da un'architettura all'altra, o da un ambiente all'altro.

Il caso più evidente è quello di Java (che funziona allo stesso modo di C#): una volta che scrivi un programma java, lo puoi far girare sia in linux che windows senza modificare il codice: ovunque la macchina virtuale di java sia installata, java può girare.
Il problema del porting è infatti delegato ai programmatori che realizzano le macchine virtuali per le diverse piattaforme.

In C# questo vantaggio è meno evidente, essendo C# sostanzialmente destinato a girare solo in ambienti windows, ma si può constatare il vantaggio a un altro livello: tutti i linguaggi di .NET vengono compilati in uno stesso linguaggio (il CLI), quindi utilizzare uno o l'altro è solo una questione di preferenza, ma tecnicamente al basso livello non cambia niente. Perciò si possono facilmente mischiare.

> 4) Nelle scorse lezioni abbiamo visto i seguenti tipi di variabili: bool, byte, short, int, long. Spiega le loro caratteristiche (dimensione in bit, tipi di valore che possono contenere, utilizzo che ne viene fatto)

bool: può contenere unicamente due valori, true (1) oppure false (0).

Viene normalmente utilizzato per controllare il flusso del programma, cioè le variabili di tipo bool vengono solitamente passate a istruzioni di controllo come: if, while, ecc ecc...

Qualcuno potrebbe erroneamente pensare che la dimensione di un bool in memoria sia di un bit... e invece è di 8 bit, ovvero 1 byte.

byte: la sua dimensione (come il nome suggerisce) è di 1 byte e può contenere numeri interi da 0 a 255

short: la sua dimensione è di 2 byte (16 bit) e può contenere numeri interi da -32,768 a 32,767.

int: dimensione 4 byte (32 bit) e può contenere numeri interi da -2,147,483,648 a 2,147,483,647.

long: dimensione 8 byte (64 bit) e può contenere numeri interi da -9,223,372,036,854,775,808 a 9,223,372,036,854,775,807

> scrivi un programma in cui ciascun tipo viene inizializzato al suo valore minimo, al suo valore massimo e al suo valore di default. Stampa sullo schermo i risultati.

static void Main(string[] args)
        {
            //Inizializziamo tutte le variabili
            bool minBool = false;
            bool maxBool = true;
            bool defaultBool = default(bool); //false

            byte minByte = byte.MinValue;
            byte maxByte = byte.MaxValue;
            byte defaultByte = default(byte);

            short minShort = short.MinValue;
            short maxShort = short.MaxValue;
            short defaultShort = default(short);

            int minInt = int.MinValue;
            int maxInt = int.MaxValue;
            int defaultInt = default(int);

            long minLong = long.MinValue;
            long maxLong = long.MaxValue;
            long defaultLong = default(long);



            //Stampiamo tutti i valori sulle console
            Console.WriteLine(string.Format("Il bool minimo è {0}", minBool));
            Console.WriteLine(string.Format("Il bool massimo è {0}", maxBool));
            Console.WriteLine(string.Format("Il bool di default è {0}", defaultBool));
            Console.WriteLine(Environment.NewLine); //Ritorno a capo, per paragrafare

            Console.WriteLine(string.Format("Il byte minimo è {0}", minByte));
            Console.WriteLine(string.Format("Il byte massimo è {0}", maxByte));
            Console.WriteLine(string.Format("Il byte di default è {0}", defaultByte));
            Console.WriteLine(Environment.NewLine); //Ritorno a capo, per paragrafare

            Console.WriteLine(string.Format("Lo short minimo è {0}", minShort));
            Console.WriteLine(string.Format("Lo short massimo è {0}", maxShort));
            Console.WriteLine(string.Format("Lo short di default è {0}", defaultShort));
            Console.WriteLine(Environment.NewLine); //Ritorno a capo, per paragrafare

            Console.WriteLine(string.Format("L'int minimo è {0}", minInt));
            Console.WriteLine(string.Format("L'int massimo è {0}", maxInt));
            Console.WriteLine(string.Format("L'int di default è {0}", defaultInt));
            Console.WriteLine(Environment.NewLine); //Ritorno a capo, per paragrafare

            Console.WriteLine(string.Format("Il long minimo è {0}", minLong));
            Console.WriteLine(string.Format("Il long massimo è {0}", maxLong));
            Console.WriteLine(string.Format("Il long di default è {0}", defaultLong));

            //Questa riga di codice serve a fare in modo che la console rimanga aperta fintanto che non premo enter
            Console.ReadLine();
        }

Il risultato

Il bool minimo è False
Il bool massimo è True
Il bool di default è False


Il byte minimo è 0
Il byte massimo è 255
Il byte di default è 0


Lo short minimo è -32768
Lo short massimo è 32767
Lo short di default è 0


L'int minimo è -2147483648
L'int massimo è 2147483647
L'int di default è 0


Il long minimo è -9223372036854775808
Il long massimo è 9223372036854775807
Il long di default è 0

Possiamo notare che tutti i tipi numerici hanno come valore di default lo 0.

Che cosa è il valore di default?
In certi casi C# inizializza automaticamente una variabile a un valore: questo valore è il valore di default del tipo.

Questo non avviene con le variabili locali (che devono essere sempre inizializzate in maniera esplicita), ma avviene per esempio con le variabili di classe (che vedremo più avanti).


> 5) Il byte è un tipo di variabile che può contenere numeri interi positivi.
> Dimostra che il valore minimo del byte è 0 e il valore massimo 255.
> La dimostrazione deve essere articolata in due parti:
> a) Dimostrazione matematica (suggerimento: è sufficiente la semplice matematica binaria, dal momento che il byte è solo per numeri positivi)

Il byte ha 8 bit, ovvero 8 ciffre.

Il primo passo quindi è trovare le prime 8 potenze di 2.

2⁰ = 1
2¹ = 2
2² = 4
2³ = 8
2⁴ = 16
2⁵ = 32
2⁶ = 64
2⁷ = 128

Il byte minimo ovviamente è quello in cui tutti i bit sono a 0, quindi: 0000 0000

Possiamo risicrviere il byte dall'alto al basso (la ciffra più a destra in cima alla "torre", quella più a sinistra in fondo alla torre) e quindi giustapporre ogni risultato della potenza di 2 alla posizione corrispondente

0 - 1
0 - 2
0 - 4
0 - 8
0 - 16
0 - 32
0 - 64
0 - 128

Moltiplichiamo i numeri a sinistra con quelli a destra

0*1 = 0
0*2 = 0
0*4 = 0
0*8 = 0
0*16 = 0
0*32 = 0
0*64 = 0
0*128 = 0

Poi dobbiamo sommare tutti i risultati... uno zero sommato con altri 0 ovviamente dà come risultato 0, quindi non facciamo nemmeno il calcolo.

Perciò il byte minimo è 0.

Ora calcoliamo il byte massimo: chiaramente è quelli in cui tutte le ciffre sono a 1, quindi: 1111 1111

Prendiamo quindi le potenze di 2 e mettiamoli in fila con le ciffre come fatto sopra, quindi moltiplichiamo ogni ciffra con la potenza di 2 corrispondente.

1*1 = 1
1*2 = 2
1*4 = 4
1*8 = 8
1*16 = 16
1*32 = 32
1*64 = 64
1*128 = 128

E quindi sommiamo i risultati

1 + 2 + 4 + 8 + 16 + 32 + 64 + 128 = 255

Quindi abbiamo dimostrato che il byte massimo è 255, in linea con i risultati che ci ha dato il programma dell'esercizio precedente.

> b) Dimostrazione programmatica con C#: vedi esercizio 4.

Console.WriteLine(string.Format("Il byte massimo è {0}", byte.MaxValue));
Console.ReadLine();

> 6) Come il 5, ma sta volta per lo short.
> Dimostra che il valore massimo di uno short è 32'767.
> Suggerimento: dal momento che lo short può contenere sia valori negativi che positivi, la semplice matematica binaria non basta: la dimostrazione si deve avvalere del complemento a due, che tiene conto del segno.

Dal momento che lo short comprende anche numeri negativi (a differenza del byte), dobbiamo tenere conto anche del segno e la cosa si complica leggermente.

Nella semplice matematica binaria si potrebbe semplicemente mettere il segno (+ oppure -) davanti al numero, ma in una macchina dobbiamo codificare il segno all'interno del numero stesso (cioè, all'interno di un bit).

Lo short ha 16 bit, ma di questi 16 bit, uno lo dobbiamo usare per codificare il segno... e come spiegato, a codificare il segno è il bit più a sinistra.

0 = +
1 = -

Lo short massimo ovviamente sarà un numero positivo, quindi possiamo già annotrare che il bit più a sinistra sarà uno 0.

Ci restano quindi 15 bit, con i quali dobbiamo fare la stessa che abbiamo fatto sopra: metterli tutti a 1 per ottenere il massimo valore possibile, quindi abbiamo (metto il segno tra parentesi:

(0)111 1111 1111 1111

Ci servono le prime quindi le prime 15 pontenze di 2.

2⁰ = 1
2¹ = 2
2² = 4
2³ = 8
2⁴ = 16
2⁵ = 32
2⁶ = 64
2⁷ = 128
2⁸ = 256
2⁹ = 512
2¹⁰ = 1'024
2¹¹ = 2'048
2¹² = 4'096
2¹³ = 8'192
2¹⁴ = 16'384


Come nel precente esercizio, moltiplichiamo la ciffra con la potenza corrispondente. Non sto a ripetere il passaggio perché ê spiegato sopra: chiaramente moltiplicando tutti i valori sopra con 1, i valori restano uguali, quindi possiamo semplicemente sommarli direttamente.


1 + 2 + 4 + 8 + 16 + 32 + 64 + 128 + 256 + 512 + 1'024 + 2'048 + 4'096 + 8'192 + 16'384 = 32'767

Quindi, 32'767 è il valore massimo di uno short.

Verifichiamolo con C#

Console.WriteLine(string.Format("Lo short massimo è {0}", short.MaxValue));
Console.ReadLine();

Esercizi completati. Domande?


**Modificato dall'autore il 01.06.2018 19:19**

**Modificato dall'autore il 03.06.2018 04:08**