TIPI DI DATO IN C SHARP GLI INTEGRAL TYPES

Dato .NET

Byte

Valore Minimo

Valore Massimo

int

System.Int32

4

-2.147.483.648

2.147.483.647

byte

System.Byte

1

0

255

short

System.Int16

2

-32.768

32.767

long

System.Int64

8

-9.223.372.036.854.775.808

9.223.372.036.854.775.807

sbyte

System.SByte

1

-128

127

uint

System.UInt32

4

0

4.294.967.295

ushort

System.UInt16

2

0

65.535

ulong

System.UInt64

8

0

18.446.744.073.709.551.615

char

System.Char

2

0

65.535

TIPI DI DATO IN C SHARP IL TIPO CHAR

C sharpCome riportato in tabella nei tipi di dato in C Sharp i tipi interi possono essere signed come int, long, short, sbyte e unsigned byte, uint, ushort, ulong, char. Il tipo char è atipico in quanto rappresenta un carattere Unicode. Per dichiarare un char si procede nel seguente modo:

char c = ‘A’;

Il singolo carattere va racchiuso tra apici singoli.

Se utilizziamo il formato literal possiamo anche specificare un numero in notazione binaria o un numero in notazione esadecimale. Vediamo un esempio.

NOTAZIONE BINARIA E ESADECIMALE

int binary = 0b1111;

int esadecimale = 0x1FB76;

Per dichiarare un numero in forma binaria occorre anteporre il simbolo 0b seguito dalla sequenza binaria mentre per un numero esadecimale 0x seguito dalla sequenza esadecimale. In C# 7.0 è stato introdotto l’underscore per separare le cifre, è semplicemente una semplificazione visiva e non è detto che gli underscore vadano a separare le migliaia, si possono usare arbitrariamente tanto poi il compilatore li ignora perché come ti ho detto è solo una esemplificazione visiva. Ti faccio un esempio.

int x = 123_456_789; (Nella memoria gli underscore saranno ignorati).

CODICE VISUAL STUDIO CODE PER GLI INTEGRAL TYPES

using System;

namespace IntegralTypes;

internal class Program
{
    private static void Main(string[] args)
    {
        byte b = 90; //1 byte unsigned da 0 a 255
        var x = 120; //4 byte signed da -2.147.483.648 a 2.147.483.647
        short y = -90; //2 byte signed da -32.768 a 32.767
        long l = 100; //8 byte signed da -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807
        Console.WriteLine($"b:{b},x:{x},y:{y};l:{l}");
        sbyte sb = -90; //1 byte signed da -128 a 127
        uint x1 = 1200; //4 byte unsigned da 0 a 4.294.967.295
        ushort y1 = 190; //2 byte unsigned da 0 a 65.535
        ulong l1 = 1100; //8 byte unsigned da 0 a 18.446.744.073.709.551.615
        var c = 'A'; /*2 byte unsigned da 0 a 65.535 rappresenta un codepoint
                            di un carattere Unicode.*/
        //usare int per scrivere un codice binario e esadecimale
        var b0 = 0b1111; /*per dichiarare un numero in binario basta anteporre
        0b al numero binario.*/
        var ex = 0x1FB76; /*per dichiarare un numero esadecimale basta
        anteporre 0x al numero esadecimale.*/
        var unicodeString = "\U0001F680"; // 🚀
        Console.WriteLine(unicodeString);
        //INTERPOLAZIONE DI STRINGHE MOLTO PIU' COMPATTA E FACILE DA LEGGERE
        Console.WriteLine($"sb:{sb},x1:{x1},y1:{y1},l1:{l1},c:{c},b0:{b0},ex:{ex}");
    }
}

TIPI DI DATO IN C SHARP I FLOATING POINT

Dato C#

Dato .NET

Byte

Intervallo

Precisione

float

System.Single

4

±1.5 x 10−45 e ±3.4 x 1038

~6-9 cifre

double

System.Double

8

±5,0 × 10−324 e ±1,7 × 10308

~15-17 cifre

decimal

System.Decimal

16

±1.0 x 10-28 e ±7.9228 x 1028

~28-29 cifre

Il tipo float riesce a mantenere una precisione di circa 6-9 cifre per la parte decimale, il tipo double riesce a mantenere 15-17 cifre di precisione per la parte decimale.

Il formato literal per i float e i double è identica, prima la parte intera, il punto e la parte decimale.

float myFloat = 20.89f;

double myDouble = 20.87;

Per default il compilatore C# quando vede in un numero la parte decimale lo assegna ad un double, quindi se vogliamo dichiarare un float alla fine del numero dobbiamo aggiungere una f. Sia il double che i float usano lo standard IEEE 754 che abbiamo già visto, molti microprocessori supportano questo standard e i calcoli sono velocissimi, l’unico problema è che a volte tali tipi di dato non hanno una precisione elevata. Per risolvere il problema il C# introduce il tipo decimal con 28 cifre di precisione nella parte decimale. Tale tipo di dato non è conforme allo standard IEEE 754 quindi può risultare più lento da un punto di vista computazionale, però ha 28 cifre decimali il che lo rende particolarmente adatto laddove è richiesta una elevata precisione, ad esempio nei calcoli finanziari.

decimal myDecimal = 10.98m;

La lettera m obbligatoria sta ad indicare un formato money, cioè particolarmente adatto quando si gestisce il denaro.

LA NOTAZIONE SCIENTIFICA

È possibile utilizzare la notazione scientifica per i tipi float, double e decimal, ad esempio:

double x = 1.8e8; = 1.8×108 = 180000000.0

double y = 1.8e-8; =1.8×10-8 =0.000000018

TIPO BOOLEAN E STRING

Il tipo bool ammette solo i valori vero o falso, cioè true (1) false (0) occupa 1 Byte.

bool myBool1 = true;

bool myBool2 = false;

Le stringhe non sono dei tipi primitivi come quelli visti finora ma sono veri e propri oggetti che tratteremo separatamente. Al momento basta sapere che una stringa è una sequenza di caratteri Unicode racchiusa tra i doppi apici.

string s = “Ciao Mondo”;

TYPE INFERENCE

int x = 10;

bool b = true;

float f = 5.9f;

Sino adesso abbiamo visto che nella dichiarazione di una variabile abbiamo sempre usato un tipo di dato primitivo. In realtà il compilatore C# è in grado di inferire da solo il tipo che stiamo dichiarando analizzando il literal. Detto ciò si può usare la keyword var per dichiarare un certo tipo di dato, sarà poi il compilatore a stabilire il tipo tramite appunto la Type Inference. Detto ciò c’è da dire che la type inference peggiora la leggibilità del codice, tuttavia ci sono dei casi (come ad esempio in una query LINQ che vedremo successivamente) in cui non si sa a priori il tipo restituito ed in questi casi la keyword var si rende molto utile. Le dichiarazioni precedenti possono essere sostituite con var e non si avranno errori di compilazione.

var x = 10;

var b = true;

var f = 5.9;

CODICE VISUAL STUDIO CODE PER I FLOATING POINT

using System;
namespace FloatingPoint
{
    class Program
    {
        static void Main(string[] args)
        {
            float f = 18.78965f;
            double d = 987.89;
            decimal dc = 12.987654323456m;
            double d1 = 8.1e-8;
            float f1 = 7.897e12f;
            //Tipo Boolean che non c'entra nulla con i floating point ma che per comodità riporto quì.
            //ammette solo due valori, vero o falso, true(1) false(0) occupa 1 Byte.
            bool myBool1 = true;
            bool myBool2 = false;
            Console.WriteLine($"f:{f}, d:{d}, dc:{dc}, d1:{d1}, f1:{f1}, myBool1{myBool1},myBool2:{myBool2}");
            
            
        }
    }
}

APPROFONDIMENTO

In C#, i tipi di dati possono essere suddivisi in diverse categorie principali: tipi di valore, tipi di riferimento e tipi nullable. Ecco una panoramica di ciascuna categoria e dei tipi specifici che ne fanno parte:

Tipi di Valore (Value Types)

I tipi di valore memorizzano direttamente i dati e sono allocati nello stack. Comprendono i tipi semplici, le enumerazioni, le strutture e i tipi nullable.

Tipi Semplici

•Numerici Interi:





•byte: 8-bit unsigned integer (0 to 255)


•sbyte: 8-bit signed integer (-128 to 127)


•short: 16-bit signed integer (-32,768 to 32,767)


•ushort: 16-bit unsigned integer (0 to 65,535)


•int: 32-bit signed integer (-2,147,483,648 to 2,147,483,647)


•uint: 32-bit unsigned integer (0 to 4,294,967,295)


•long: 64-bit signed integer (-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807)


•ulong: 64-bit unsigned integer (0 to 18,446,744,073,709,551,615)


•Numerici con Virgola Mobile:


•float: 32-bit single-precision floating point


•double: 64-bit double-precision floating point


•decimal: 128-bit high-precision floating point (specificamente per calcoli finanziari)


•Altri Tipi Semplici:


•char: 16-bit single Unicode character


•bool: boolean (true or false)


Enumerazioni (Enums)


•enum: un insieme di costanti denominate.


Strutture (Structs)


•struct: tipi di valore definiti dall’utente.


Tipi di Riferimento (Reference Types)


I tipi di riferimento memorizzano riferimenti a oggetti, che sono allocati nell’heap. Comprendono classi, interfacce, array, delegati e il tipo stringa.


•Classi:


•class: tipi di riferimento definiti dall’utente.


•Interfacce:


•interface: dichiarazioni di contratto.


•Array:


•array: una raccolta di elementi, tutti dello stesso tipo.


•Delegati:


•delegate: puntatori a metodi.


•Stringhe:


•string: una sequenza di caratteri Unicode immutabile.


Tipi Nullable (Nullable Types)


•Nullable: tipi di valore che possono anche essere nulli. Usati per rappresentare tipi di valore che possono avere un valore nullo.


•int?: un int che può essere nullo.


•double?: un double che può essere nullo.


•e così via per altri tipi di valore.


Oggetto di Base


•object: il tipo di riferimento base di cui tutti gli altri tipi derivano.


Esempi di Dichiarazione di Variabili in C#






int numeroIntero = 10;
float numeroVirgolaMobile = 3.14f;
double numeroVirgolaMobileDoppia = 3.14;
char carattere = 'A';
bool valoreBooleano = true;
string testo = "Hello, World!";
int? numeroNullable = null;

enum GiorniDellaSettimana { Lunedì, Martedì, Mercoledì, Giovedì, Venerdì, Sabato, Domenica }
GiorniDellaSettimana oggi = GiorniDellaSettimana.Venerdì;

struct Punto
{
    public int X;
    public int Y;
}
Punto punto = new Punto();
punto.X = 5;
punto.Y = 10;



LINK AI POST PRECEDENTI