Appunti C#

Template

using System;

namespace Test
{
class program
{
static void Main(string[] args)
{
//codice qui
}
}
}

sintassi:

ogni riga si separa con punto e virgola ( ; )

commenti

sono preceduti da //
oppure con:

/*
*
* commento qui
*
*/

comandi:

Console.Write

usato per scrivere nella console,

ma non mette a capo.

Console.Write("Hello world");
Console.Write("deez");

output

Hello worlddeez

Console.WriteLine

usato per scrivere nella console,

mette a capo le scritte seguenti

Console.WriteLine("Hello world");
Console.WriteLine("deez");

ouput

Hello world
deez
comandi utili

/t ---> mette 1 tab

es:

Console.WriteLine("/t deez");

output

deez

/b ---> toglie 1 carattere

es:

Console.WriteLine("deez /b nuts");

output

deenuts

/n ---> come usare NewLine

per untire 2 o più scritte si usa +

es
int età = 15;
Console.WriteLine("hai " + età + " anni");

output

hai 15 anni

Console.beep();

fa un suono al completamento del programma.

Console.ReadKey();

fa finire il programma se clicco un carattere nella tastiera.

Variabili

sono simili a C++

ci sono 2 fasi:
declaration and inizialization

int x; <--- declaration

x = 2; <--- inizialization

si può unire in:

int x = 22;

nelle variabili booleane vero e falso

sono scritte tutte minuscole

i simboli nelle char sono tra '';

non "".

le variabili string hanno la S maiuscola.

le costanti hanno const prima.

operazioni

+ addizione
- sottrazione
* moltiplicazione
/ divisione
+= aumenta di ...
++ aumenta di 1
-= diminuisce di ...
-- diminuisce di 1
*= moltiplica di ...
/= divide di...
% guarda il resto di una divisione

Math.

si usa per calcoli avanzati

Math.Pow(base,esponente) <--- potenza

Math.Sqrt(numero) <--- radice quadrata
Math.Abs(numero) <--- trova il valore assoluto
Math.Round(numero) <--- arrotondamento
Math.Ceiling(numero) <--- arrotonda per eccesso
Math.Floor(numero) <--- arrotonda per difetto
Math.Max(numero1,numero...) <--- trova il numero maggiore
Math.Min(numero1,numero...) <--- trova il numero minore

type casting

cambia il tipo di variabile

es:

double a = 3.14;

int b = Convert.ToInt32(a)

b sarà uguale a 3

.GetType()

permette di vedere il tipo di variabile

serve per vedere cosa scrivere in Convert. /// <--- qui

es

int a = 3;

Console.WriteLine(a.GetType());

prendere Input

Console.ReadLine();

per prendere altri tipi di variabili oltre a String,

dobbiamo convertirli

es:

int age = ConvertToInt32(Console.ReadLine());

exeption

le exeption avvengono quando, per esempio,

dò una stringa quando mi viene chiesto
un intero, e farà terminare il programma

numeri casuali ( pseudorandom )

( numeri interi )

Random random = new Random();

int numero = random.Next(valoreMinore,ValoreMassimo +1);

( numeri decimali )

Random random = new Random();

int numero = random.NextDouble(valoreMinore,ValoreMassimo +1);

Strings Methods

nomeStringa.ToUpper() <--- mette tutto maiuscolo

nomeStringa.ToLower() <--- mette tutto minuscolo

nomeStringa.Replace("carattereDaCambiare","carattereCheSostituisce) <--- rimpiazza

dei caratteri

nomeStringa.Insert(posizione,"scritta")

per posizione, s'intende dove va inserita la

scritta, ed è un Intero

per esempio, 0 è all'inizio

nomeStringa.Lenght <--- numero di caratteri

nomeStringa.Substring(posizione,numeroCaratteri)

estrae una parte di una stringa.

if statement
struttura:

if(condizione)
{

}
else if
{

}
else
{

comparatori

== uguale
< minore
> maggiore
<= minore o uguale
>= maggiore o uguale
!= non uguale

switch

struttura:

switch(dato)
{
case "deez":
//code
break;
case "nuts":
//code2
break;
}

se il dato non rientra nei possibili casi, si aggiunge:

default:
//code
break;

operatori logici

&& <--- and, e

|| <--- or, o

servono per if statements

es:

if ( dato > 10 && dato < 20 )

dato è maggiore di 10 E minore di 20

if ( dato == 10 || dato == 20 )

dato equivale a 10 O equivale a 20

while loop

struttura:

while (condizione)
{
//code
}

for loop

struttura:

for( int i = 0; i < 10; i++)

{
//code
}

i sta per Index,

la prima parte determina il tipo di variabile e il valore di Index,

la seconda parte indica la condizione richiesta per continuare il loop,

la terza quanto si aggiunge a Index a ogni ciclo.

arrays (lista)

sono variabili che possono contenere un numero definito di valori dello stesso tipo

es:

String[] macchine = {"BMW" , "Tesla"}

per chiamare un dato in una lista si usa

macchine[0] <--- in questo caso corrisponde a BMW

per creare una lista senza mettere dati all'interno:

String oggetti = new string [5] <--- 5 = numero di dati che si possono inserire

foreach loop

struttura:

String[] cars = {"BMW", "Tesla"};

foreach (String car in cars)

{
Console.WriteLine(car);
}

ouput:
BMW
Tesla

car è un nome che diamo ai valori nella lista

Methods (funzioni)

parte di codice riutilizzabile

struttura

static void funzione()

{
//codice qui
}

possiamo dare vaiabili alle funzioni:

static void funzione(int x, int y)

{
z = x + y;
}

per chiamare la funzione usiamo funzione(1,2) <--- x = 1, y = 2

per darci indietro il valore di z, per esempio, possiamo usare return

per usare return, dobbiamo sostituire void con il tipo di variabile che è z

static int funzione(int x, int y)

{
z = x + y;
return z;
}

method overloading

due funzioni possono avere lo stesso nome, a patto che abbiano diversi parametri

static int funzione(int x, int y)

{
z = x + y;
return z;
}

funzione = nome
int x, int y = parametri

params keyword

serve per evitare di allungare troppo il codice riempiendolo di overloaded methods

static int funzione(params int[] a) <--- a è un array

{
b = 0;
foreach (int dato in a)
{
b += dato;
}
 return b;
}

se diamo funzione(1,2,3,4,5,6), ci darà la somma che è 21

la funzione può accettare un numero variabile di dati, a patto che siano tutti
dello stesso tipo

exception handling

se una parte di codice potrebbe dare qualche errore, come chiedere per un int ma
gli viene dato una string, invece di fermare il programma, possiamo prendere
l'errore senza far fermare il programma

try = prova il codice "pericoloso"

catch = prende e maneggia l'errore
finally = viene sempre eseguito sia se l'errore si verifica o meno

struttura:

try
{
//codice pericoloso
}
catch(FormatException e)
{
//codice eseguito se si verifica l'errore specificato nella condizione
}
finally
{
//codice che si esegue sia se l'errore si verifichi o meno.
}

possiamo mettere più catch, e con Exception, possiamo prendere ogni errore che si
verifica, senza sapere della sua natura.

conditional operator

formula:

(condizione) ? x : y

vuol dire, se condizione = vero, allora x, sennò se condizione = falso, allora y.

string interpolation

metodo comodo per scrivere robe

String nome = "simone";

String cognome = "assirelli";
int età = 15;

Console.WriteLine($"hello {nome} {cognome}");

Console.WriteLine($"hai {età} anni");

output:

hello simone assirelli

hai 15 anni
possiamo mettere {nome, -10} <--- il meno dieci indica che che dopo il nome vanno
10 spazi, in positivo vanno dietro, credo.

multidimensional arrays

è un array di array, una lista di liste

String[,] parcheggio { {"macchina" , "moto"},

{"camiom", "bici"}, }

per prendere il valore " camion ", dobbiamo scrivere:

parcheggio [1,0]

prima la riga, poi la colonna.

classes

per creare una classe:

static class NomeClasse

{
public static void funzione1()
{
//codice
}
public static void funzione2()
{
//codice
}

per usare i comandi nella classe:

NomeClasse.NomeFunzione() <--- in questo caso sono funzione1 o funzione2

object

un oggetto ha fields ( caratteristiche ) e methods ( metodi )

fields = cosa un oggetto ha

methods = cosa un oggetto può fare

si possono creare oggetti grazie a una classe

struttura:

nomeClasse nomeOggetto = new nomeClasse();

il nome è a scelta

possiamo assegnare a un oggetto caratteristiche, ed eseguire azioni

constructor
serve per automaticamente assegnare caratteristiche a un oggetto senza
doverle assegnare manualmente

struttura

nomeClasse nomeOggetto = new nomeClasse(1,"deez"); <--- metti qui parametri

( nella classe )

public nomeClasse(int caratteristica1 , string caratteristica2)

{
this.caratteristica1 = caratteristica1;
this caratteristica2 = caratteristica2;
}

public ( modifier )

rende una caratteristica/metodi/classe pubblica, cioè utilizzabile al di fuori

della classe.

static ( modifier )

il modificatore static rende una caratteristica/metodo/classe condivisa tra tutti

gli oggetti della stessa classe.

overloaded constructor

metodo per creare più constructor, con lo stesso nome, a patto che richiedano
parametri diversi.

inheritance

classi possono avere " sottoclassi ", cioè classi che ereditano le caratteristiche
e metodi della classe iniziale.

struttura:

class sottoClasse: ClasseIniziale

{
// codice che solo la sottoclasse usa.
}

abstract ( modifier )

in una classe, indica che è incompleta, e quindi non si possono creare oggetti da
quella classe

struttura:

abstract class NomeClasse

{

array of objects

numeroOggetti = quanti oggetti può contenere? 1 = 1 slot, ecc...

nomeClasse[] nomeArray = new nomeClasse[numeroOggetti] <--- non dichiara cosa c'è

dentro

nomeArray [numeroSlot] = oggetto1 <--- dichiara

ecc....

oppure:

nomeClasse[] nomeArray = {new nomeClasse{oggetto1}, new nomeClasse{oggetto2},

ecc...} <--- dichiara cosa c'è dentro

per chiamare un oggetto in un array:

nomeArray[numeroSlot]

objects as arguments

permette di usare un oggetto come parametro in un metodo

struttura

public static void nomeFunzione(nomeClasse nomeOggetto)

{

se bisogna creare una funzione che deve ritornare ( return ) l'oggetto, al posto di
"void" si mette il nome della classe di appartenenza dell'oggetto

quando si invoca un metodo, bisogna passare il nome dell'oggetto

esempio:

nomeFunzione(nomeOggetto);

method overriding

permette a una sottoclasse di avere uno stesso metodo con nome uguale a quello
ereditato, ma che faccia cose diverse.

ci sono 2 modi:

1) la classe, e il metodo della classe devono essere astratti, e il metodo nella

classe non deve contenere nulla.
il metodo nella sottoclasse deve avere il modifier override, e lo stesso nome del
metodo ereditato

es:

abstract class classeMadre

{
public abstract void Metodo()
}

class sottoClasse: classeMadre

{
public override void Metodo()
{
 // codice qui
}
}

2) il metodo nella classe deve avere il modifier virtual

il metodo della sottoclasse deve avere il modifier override

( la classe può avere codice nella funzione )

es:

class classeMadre
{
public virtual void Metodo()
{
// codice qui
}
}

class sottoClasse: classeMadre

{
public override void Metodo()
{
// codice qui
}
}

ToString method

converte l'oggetto in stringa.

es:

class nomeClasse
{
String dato = "DeezNuts"

public override string ToString()

{
return dato;
}
}

se scriviamo Console.WriteLine(nomeOggetto), in questo caso ci darà DeezNuts

polimorphism

un oggetto può essere identificato con più classi,

come un cane è un Mammifero, ma anche un Animale, e anche un Organismo

per esempio, possiamo mettere in un array una serie di oggetti che stanno in delle
sottoclassi diverse, ma che hanno una classe in comune da cui hanno ereditato

es:

nomeClasseMadre[] nomeArray = {oggetto1, oggetto2, oggetto3};

funziona anche per dei Loop, ecc...

interface

un interface è una serie di istruzioni che delle classi devono avere

possiamo settare un interface con:

interface cosa1
{
void funzione1();
}

in questo caso, le classi a cui attaccheremo questa interfaccia dovrà avere un

metodo chiamato funzione1

per attaccare un interfaccia a una classe si fa come attaccare una classe a una
sottoclasse

class nomeClasse: nomeInteface

{

una classe può avere più interfacce:

class nomeClasse: nomeInteface1, nomeInterface2

{

list

simile ad un array di oggetti, ma la differenza è che una list può avere un numero
massimo di dati/oggetti illimitato, invece a quello limitato degli array

struttura:

using System.Collections.Generic;

List<dataType> nomeList = new List<dataType>

( datatype sono int, String, ecc... )

!!! per i dati !!!

aggiungere dati:

nomeList.Add(dato);

rimuovere dati:

nomeList.Remove(dato);

aggiungere ad un index determinato:

nomeList.Insert(index, dato)

trovare l'index di un dato in una list:

nomeList.IndexOf(dato);

trovare l'ultimo index di un dato in una list se ce ne sono + copie

nomeList.LastIndexOf(dato);

vedere se una lista contiene un dato

nomeList.Contains(dato);

( darà un valore booleano: true se dato è presente nella list, false se no )

ordinare i dati per ordine alfabetico

nomeList.Sort();

ordinare il dati per ordine alfabetico al contrario:

nomeList.Reverse();

ripulire la list:

nomeList.Clear();

trasformare una list in array:

daraType[] nomeArray = nomeList.ToArray();

!!! per gli oggetti !!!

creare una lista:

List<nomeClasse> nomeList = new List<nomeClasse>();

i altri comandi solo gli stessi ma con delle eccezioni:

aggiungere oggetti:

NomeList.Add(nomeOggetto.nomeCaratteristica);

oppure

NomeList.Add(nomeOggetto(caratteristica)); <--- caratteristica potrebbe essere il

valore di una String, per esempio, che si trova nella classe.

oppure

NomeList.Add(nomeOggetto); <--- mostrerà quello che c'è scritto nella funzione

ToString