APPUNTI di PROGRAMMAZIONE WEB con ASP.Net · - CLR = Common Language Runtime = librerie comuni...

1

APPUNTI di PROGRAMMAZIONE WEB con ASP.Net.MVC

Questi sono gli appunti di un corso di programmazione web, che ho seguito nel 2014. Essendo ilmio primo approccio, alcune osservazioni possono sembrare ovvie, e non garantisco sullacorrettezza di tutto quello che c'e' scritto.Allora lavoravo con Windows, ed il corso era con C#; in seguito sono passato a Linux e PHP perimparare anche quello; non ho piu' avuto modo di usare il C#, anche se, per il tipo di siti che hofatto, risulterebbe migliore.Pur cambiando linguaggio e sistema operativo, questi appunti mi sono comunque stati moltoutili, perche' inquadrano i principali problemi e le loro soluzioni, e danno, con esempi, unavisione panoramica completa di tutte le problematiche della programmazione web, che vannodai linguaggi, alle impostazioni dei server, all'uso di un GIT.

F. de Grenet - aprile 2018

© Copyright 2018 Filippo de Grenet

Sommario1) CONCETTI GENERALI..................................................................................................6

1.1) Programmazione WEB - Compilatori.....................................................................6

1.2) Chiamata da Client a Server IIS............................................................................6

1.3) ASP.......................................................................................................................6

1.4) Linguaggi usati:....................................................................................................6

1.5) SoftWare da installare sul Server (NB: rif. anno 2014):........................................7

1.6) BACKUP dei dati su Server...................................................................................7

1.7) SoftWare da installare sul PC:...............................................................................7

1.8) MVC = Model View Controller...............................................................................8

1.9) Altri concetti/linguaggi:........................................................................................8

1.10) Analisi pagine html da Browser:.........................................................................8

1.11) MVC: Struttura di un Link...................................................................................8

2) IIS: INTERNET INFORMATION SERVICE........................................................................9

2.1) Attivare IIS sul Server: installazione.....................................................................9

2.2) Mettere a punto il servizio IIS...............................................................................9

2.2.1) avvio servizio “ASP.Net State Service”:..........................................................9

2.2.2) Registrazione di ASP.Net nell’IIS:....................................................................9

2.2.3) Visualizzazione degli errori del sito..............................................................10

2.2.4) Installazione Framework 4.5.........................................................................10

2.3) Gestore IIS dei siti WEB......................................................................................10

2.3.4) Generare gli altri siti che si vogliono installare:...........................................11

2.3.5) Application Pools..........................................................................................11

2.4) Autenticazione Utenti.........................................................................................12

2

3) GIT............................................................................................................................ 13

3.1) GIT client (SourceTree).......................................................................................13

3.2) GIT server (Bonobo)...........................................................................................14

3.3) interfaccia GIT da locale con il server................................................................15

4) VISUAL STUDIO EXPRESS per WEB...........................................................................17

4.1) Registrazione......................................................................................................17

4.2) Struttura della cartella (Repository) del Progetto...............................................17

4.3) Interfaccia MS Visual Studio 2012......................................................................17

4.3.1) Schermata principale...................................................................................17

4.3.2) Apertura di un nuovo progetto:....................................................................18

4.3.3) Salvataggio, Compilazione, Debugging........................................................18

4.3.4) Aggiunta di nuovi files..................................................................................19

4.3.5) Tipologia di EOL (End Of Line):.....................................................................20

4.3.6) Editor...........................................................................................................20

4.3.7) BreakPoints..................................................................................................20

4.3.8) Pubblicazione del Sito..................................................................................20

4.3.9) Installazione di DLL......................................................................................21

5) PROGRAMMAZIONE ad OGGETTI C#.........................................................................22

5.1) Caratteri particolari............................................................................................22

5.2) FIELDS (CAMPI) e VARIABILI:..............................................................................22

5.3) PROPRIETA’ e Stati.............................................................................................23

5.4) METODI..............................................................................................................24

5.4.1) Definizione di un Metodo: Sintassi:..............................................................24

5.4.2) Esempi:........................................................................................................24

5.4.3) Richiamo di un metodo:...............................................................................25

5.4.4) Metodi ereditati dalle classi standard...........................................................25

5.5) COSTRUTTORI....................................................................................................25

5.6) EVENTI................................................................................................................26

5.7) dichiarazione di una CLASSE di oggetti..............................................................26

5.8) DICHIARAZIONE e Assegnazione di un Oggetto/Variabile...................................26

5.8.1) Oggetti e Tipi Primitivi..................................................................................26

5.8.2) Dichiarazione, Assegnazione, utilizzo...........................................................26

5.8.3) Sintassi.........................................................................................................27

5.8.4) Puntatori......................................................................................................27

5.8.5) Cancellare i puntatori...................................................................................28

5.9) Oggetti Pre-definiti / Operatori particolari..........................................................28

3

5.10) LISTE Dinamiche..............................................................................................28

5.11) ISTRUZIONI basiche..........................................................................................29

5.11.1) Ciclo FOR....................................................................................................29

5.11.2) Ciclo FOREACH...........................................................................................29

5.11.3) IF - then - ELSE...........................................................................................30

5.11.4) SWITCH......................................................................................................30

5.12) Formattazione Stringhe....................................................................................30

5.13) Classi HttpContext e System............................................................................31

5.14) Esempio di definizione di una CLASSE; istruzione “Using”...............................31

6) LINGUAGGIO HTML...................................................................................................32

6.1) Esempi e Note....................................................................................................32

6.2) JavaScript (JS) e JQuery......................................................................................33

6.2.1) Download JQuery..........................................................................................33

6.2.2) Installazione JQuery.....................................................................................34

6.2.3) Files JS e Dichiarazione.................................................................................34

6.2.4) Linguaggio JS: caratteri speciali...................................................................34

6.2.5) Linguaggio JS: istruzioni base.......................................................................34

6.2.6) istruzioni JQuery...........................................................................................35

7) PROGRAMMAZIONE RAZOR MVC – MODEL VIEW CONTROLLER................................35

7.1) File CONTROLLER...............................................................................................36

7.2) VISTE.................................................................................................................. 37

7.3) Layout di pagina.................................................................................................37

7.4) MODELs..............................................................................................................38

7.5) Decorazioni di una Classe..................................................................................39

7.6) PASSAGGIO PARAMETRI: ViewBag e Model.........................................................41

7.6.1) ViewBag.......................................................................................................41

7.6.2) Classe Model................................................................................................41

7.7) Librerie di appoggio: PURE css ed Awesome......................................................42

7.8) Direttive di Compilazione...................................................................................43

8) DATABASE4.exe........................................................................................................43

8.1) Concetti generali................................................................................................43

8.2) Avvio di Database4.exe......................................................................................43

8.3) Interfaccia..........................................................................................................44

8.3.1) Creazione di un nuovo DB............................................................................44

8.3.2) Refresh.........................................................................................................44

8.3.3) Nuova Tabella...............................................................................................44

4

8.3.4) Comandi da TastoDX su una Tabella:............................................................45

8.3.5) Generazione Script SQL, a partire dall’oggetto generato:............................45

8.3.6) Esportazione in Excel...................................................................................45

8.3.7) Generazione Vincoli (Constraint) tra tabelle................................................45

8.4) Comandi SQL......................................................................................................46

8.4.1) Generazione Vincoli (Constraint) tra tabelle................................................46

8.4.2) Cancellazione di un DB................................................................................46

8.4.3) Estrazioni/Query e Riepiloghi.......................................................................46

8.4.4) JOIN di tabelle..............................................................................................46

8.4.5) Creazione di una VISTA................................................................................47

8.4.6) visualizza Ultime righe di una tabella...........................................................47

8.4.7) Assegnazione di un valore BULEANO...........................................................47

8.5) Tipi di Variabili DB..............................................................................................47

9) Interfaccia con un DATABASE...................................................................................48

9.1) Lista Librerie.......................................................................................................48

9.2) Connection Strings.............................................................................................48

9.3) creare l’oggetto DBContext................................................................................49

9.4) Richiamare il DbSet nel Controller......................................................................50

9.4.1) Assegnazione:..............................................................................................50

9.4.2) Lettura di una Lista (o di un singolo Record)................................................50

9.4.3) Esempio di Controller...................................................................................50

9.4.4) Esempio di View...........................................................................................51

9.5) METODI standard: parametri per Query-String ed altri......................................51

9.5.1) metodo TOLIST: lettura di una Lista da tabella DB.......................................51

9.5.2) metodo FIRSTorDEFAULT: lettura di un singolo Record.................................51

9.5.3) Metodo WHERE............................................................................................52

9.5.4) Metodo SELECT............................................................................................53

9.5.5) metodo ORDER BY.......................................................................................53

9.5.6) metodo CONTAINS.......................................................................................53

9.5.7) Altri metodi di interrogazione LINQ (lettura DB)...........................................53

9.6) Generazione Automatica del DB.........................................................................54

10) INPUT – interfaccia Utente......................................................................................55

10.1) FORMs..............................................................................................................55

10.1.1) Sintassi delle Forms HTML..........................................................................55

10.1.2) Input in modalita’ GET (e Query String).....................................................56

10.1.3) Input tramite Pagine in Modalita’ POST......................................................58

5

10.1.4) Esempio.....................................................................................................58

10.1.5) input TextArea............................................................................................61

10.1.6) input CheckBox..........................................................................................61

10.2) Chiamate AJAX.................................................................................................62

11) Soluzioni tipo..........................................................................................................62

11.1) Estrazione Selettiva da DB, in base ad un parametro Calcolato.......................62

11.2) Menu Dinamico................................................................................................63

11.2.1) ~/ Models/ DBIntranetAAA.cs.....................................................................63

11.2.2) ~/ Controllers/ DocumentoController.cs.....................................................63

11.2.3) ~/ Models / RigaMenu.cs............................................................................64

11.2.4) ~/ Views/ Documento/ Elenco.cshtml.........................................................65

11.2.5) ~/ Views/ Shared/ _Layout.cshtml..............................................................66

11.2.6) ~/ Controllers/ HomeController.cs..............................................................67

11.3) Utilizzo di METODI (=Procedure) e PROPRIETA’................................................67

11.4) Stampa pagina.................................................................................................69

11.5) Verifica Esistenza Files.....................................................................................70

11.6) UpLoad Files.....................................................................................................70

11.6.1) Lato Client = html......................................................................................70

11.6.2) Lato Server = Controller............................................................................71

11.7) Lettura Dati su siti terzi....................................................................................72

11.7.1) Parsing.......................................................................................................72

11.7.2) Web Services..............................................................................................72

12) Manuali di Riferimento...........................................................................................73

6

1) CONCETTI GENERALI

1.1) Programmazione WEB - Compilatori

Un sito web puo’ essere costruito usando due tipi di linguaggi:a) linguaggio NATIVO per web (es: html, pdf, js)b) linguaggio COMPILATO, che richiede una Compilazione

Il sistema ASP.Net.MVC utilizzato con VisualStudio, si basa sul linguaggio “Razor”, che combina il C# nell’html (tramite il prefisso “@”). Il codice in Razor, e’ scritto in files conestensione .cshtml.Ogni Progetto avra’ una cartella Sorgente, su cui lavora VisualStudio ed una cartella Eseguibile, letta da IIS.

Le pagine web possono poi essere:a) STATICHE (html, js) = non hanno bisogno di interpreti su server, vengono

interpretate direttamente dai browswersb) DINAMICHE (asp, dll) = hanno bisogno di avere, sul server, un sistema in grado

di interpretarle (IIS per Windows, Tomcat per Linux: vedi cap. 2).NB: una pagina compilata (dll) e’ piu’ performante di una in asp, che richiede una pre-compilazione ad ogni esecuzione.

1.2) Chiamata da Client a Server IIS

- Richiesta: http (:80) oppure https (:443)- Risorsa esiste?: se “No” Errore 404- Se “Si” risposta interpretata (es: asp), o NON

interpretato (es: pdf, html), in base ad estensione o classe (ASP.Net.MVC) del file

1.3) ASP

E’ il sottoinsieme del FrameWork che gestisce la Programmazione Web (Microsoft):- Fino al 2000: ASP (interpretato)- Periodo 2000-2011: ASP.X / ASP.Net (compilato)- Dal 2011: ASP.X.MVC / ASP.Net.MVC (compilato)

1.4) Linguaggi usati:

- Visual C# (pronuncia: “Ci sharp”)- Microsoft.NET – FrameWork 4.0

(il frameWork e’ l’insieme di DLL sul server)- Razor- html- js (JavaScript – da non confondersi con “Java”)

7

1.5) SoftWare da installare sul Server (NB: rif. anno 2014):

- Win 2008 Server- ms SQL Server 2008 R2 SP2 with management studio Express- FrameWork = insieme di classi (/DLL) gia’ pronte per essere usate da ASP

NB: le versioni del FrameWork si vedono su:C:\Windows \ Microsoft.NET \ Framework64 \...

- GIT server (Bonobo)

1.6) BACKUP dei dati su Server

1.6.1) BackUp del Progetto (Sito web)Il backup del progetto deve salvare i file sorgente.La cosa migliore e’ salvare direttamente [tutta] la cartella del GIT su server (Bonobo).

D:\ Siti\ BonoboGitServer\ App_Data\ Repositories\da cui, con un GIT-Client, si possono recuperare tutte le versioni (ma senza GITclient risulta inutilizzabile).

1.6.2) BackUp del DataBaseIl backup di un Database si fa estraendo i suoi dati in un file unico, che va posto in una directory tra quelle periodicamente salvate.

Il sistema SQLServer Express, essendo gratuito, ha alcune limitazioni, tra cui:- E’ limitato ad 1 GB (limite che non da’ problemi per i piccoli progetti)- Non include l’Agent che schedula il BackUp

Il lavoro di questo Agent viene sostituito da un file SQL, schedulato da un BAT; vediC:\ Backup\ Siti

file Backup.sql:BACKUP DATABASE [IntranetAAA] TO DISK = N'C:\Backup\Siti\IntranetAAA.bak' WITH RETAINDAYS = 15, NOFORMAT, INIT, NAME = N'IntranetAAA-Full DB Backup', SKIP, NOREWIND, NOUNLOAD, STATS = 10, CHECKSUM, CONTINUE_AFTER_ERRORGO

file backup.bat:"C:\Program Files\Microsoft SQL Server\100\Tools\Binn\SQLCMD.EXE" -S SVRPROD01\sqlexpress2008 -i C:\Backup\Siti\Backup.sql

dove:-S = nome del server/ istanza-i = nome del file SQL da eseguire

Lanciando questo file, si genera il file dei dati da salvare, inC:\ Backup\ Siti\ IntranetAAA.bak

(vedi comando “AT” da riga comando Windows).

1.7) SoftWare da installare sul PC:

- Visual Studio 2012 (v 11.0) Express MVC- Database4.exe (DataBase Client Freeware: permette di operare direttamente sul DB

del Server)- GIT client

8

- Notepad++ = editor (migliore di Notepad)

1.8) MVC = Model View Controller

Il Model-View-Controller, è un pattern architetturale (cioe’ unmodo di usare, per esempio, il C#) molto diffuso nello sviluppodi sistemi software, in particolare nell'ambito dellaprogrammazione orientata agli oggetti, in grado di separare lalogica di presentazione dei dati dalla logica di business.

1.9) Altri concetti/linguaggi:

- MONO = progetto OpenSource di Linux, che consente (dovrebbe) di lavorare con i siti costruiti con ASP.NET.MVCwww.mono-project.com

- CLR = Common Language Runtime = librerie comuni

1.10) Analisi pagine html da Browser:

Su un sito: TastoDX + Ispeziona Elementofa vedere: - Elements = contenuto html della pagina

- Network = Traffico di rete ([F5]= Reload)

1.11) MVC: Struttura di un Link

La struttura di un link su un sito generico (internet o intranet) e’ la seguente:NomeSito: Porta / Controller / Metodo / Parametro del metodo

Esempio:localhost:4280/Documento/Elenco/Q

In aggiunta/alternativa al Parametro sopra indicato, si possono passare parametri ad unapagina col metodo “QueryString” (vedi 10.4.2).

Valori di Default:Porta = 80Controller = HomeMetodo = IndexParametro = null

Caratteri Speciali:~/ = Radice del sito corrente (NomeSito:Porta) (NB: “~”= [Alt] 126)

Prefissi:Se il sito e’ su internet, si deve premettere:

http://https://

9

2) IIS: INTERNET INFORMATION SERVICECome visto in (1.1), le pagine web possono essere STATICHE (html puro) o DINAMICHE.Quelle statiche non hanno bisogno di interpreti: possono essere aperte da un qualunque browser, in qualunque cartella siano.Quelle dinamiche hanno bisogno di avere, sul server, un sistema in grado di interpretarle.Sui server Windows questa interpretazione e’ gestita dal servizio IIS.Sui server Linux si usano:

- Apache = Web Server (per gestire la parte http)- Tomcat = Application Server = gestisce i contenuti dinamici del web (in particolare lepagine Java)

2.1) Attivare IIS sul Server: installazione

Se Windows 7: Pannello di controllo└→ Programmi e Funzionalità (Programs and Features)

└→ Attivazione/disattivazione funzionalità Windows└→ [v] Internet Information Service

└→ Next impostando:

[v] Fictures http standard --> legge html[v] Application developement: quello che serve[v] Security: Basic[v] Security: Windows --> autentica ID windows[v] Static content Compression[ - ] Dinamic content Compression[v] IIS management Console[v] FTP server --> solo se serve

Verifica attivazione:dal server: aprire Browser: > http://localhost

se risponde significa che è installato.

2.2) Mettere a punto il servizio IIS

Se il servizio IIS non funziona correttamente, verificare i seguenti punti:2.2.1) avvio servizio “ASP.Net State Service”:

Server Manager└→ Ruoli

└→ Web Server IIS└→ System Services

└→ attivare: “ASP.Net State Service”

2.2.2) Registrazione di ASP.Net nell’IIS:da CMD:- portarsi nella cartella: Windows \Microsoft.NET \Framework64 \v4.0.3019 \- lanciare il comando: aspnet_regiis.exe –ir

10

2.2.3) Visualizzazione degli errori del sitoDi default, per motivi di sicurezza, gli errori di un sito non sono visualizzati. Per vederli si puo’:

a) aprire il sito dalla macchina server stessa: http://localhost/nomeSitob) editare il file XML web.config che si trova nella directory root di ogni sito di tipo ASP.Net:<configuration>

<system.web><customerrors mode= “off”/> ==> mettere “on”

2.2.4) Installazione Framework 4.5- Cercare su Google “Framework 4.5 download”, e scegliere il sito Microsoft- verificare compatibilita’, scaricare ed installare

2.3) Gestore IIS dei siti WEB

Apertura gestore:--> sul server: [Start]

└→ da Riga comando: “IIS”o mettere l’icona “Internet Information Service (IIS) Manager” sulla barra Applicazioni.

2.3.1) Scegliere la cartella di archiviazione dei siti, e generare una sottocartella per ogni sito da aprire. In questa cartella andra’ messo il codice eseguibile del sito.NB: di base posso aprire al massimo un sito per ogni porta (default= porta 80). Quindi, dovendo installare piu’ siti, devo scegliere una delle seguenti opzioni:

a) configuro il principale, vuoto, sulla porta 80, e tutti gli altri come suoi sotto-siti; e’ il metodo piu’ comune.

b) imposto ogni sito su una porta diversa; ma poi devo specificarla in chiamata, e devo stare attento ai conflitti.

c) imposto tutti su porta 80, ma con hostName diversi: devo configurare gli hostName sul DNS della rete.

Esempio (usando metodo “a”): \\svrprod01\ D\ Siti\ nomesito

All’interno di questa cartella si puo’ fare una sottodirectory “Content” in cui archiviare anche i files linkati dal sito (Immagini, Documenti, ecc.).Esempio:

\\svrprod01\ d$\ Siti\Manuale\ Content\ Documenti

2.3.2) Cancellare sito di default= “wwwroot”, perche’ e’ il primo bersaglio di ogni hacker:

TastoDX + Remove

2.3.3) Generare il sito principale (metodo “a”):- aprire (da Explorer) la cartella “\Principale”, contenente un sito vuoto, o solo unlogo.Esempio: \\svrprod01\ D\ Siti\ Principale

- da IIS: [Sites]: TastoDX + Add Web Sites

11

NB: comando “Add”: - Add Web Sites --> crea Sito Principale (porta 80)- Add Application --> crea Sotto-Siti (=operativi)- Add Virtual directory --> crea archivio di files

2.3.4) Generare gli altri siti che si vogliono installare:- copiarli (Explorer) nelle corrispondenti cartelle- da IIS: [Sites]\[Principale]: TastoDX + Add Application

Verificare che la versione del Framework sia 4.0NB: la cartella del sito a cui si fa riferimento in questo paragrafo non e’ la cartella del codice, gestita da GIT, ma quella dell’eseguibile. Non serve che sia una sottocartella di \Principale; puo’ essere una cartella parallela; basta aprirli come “figli” su IIS.

2.3.5) Application PoolsLe application pools sono le risorse (CPU) con cui l’applicazione fa girare i siti. In “Gestione Attività” si vedono come singoli “Processi”.E’ bene mettere ogni sito su un’application pool diverso, altrimenti un problema su uno si trasmetterebbe anche agli altri.Per ogni sito, da IIS:

12

- definire un application pool dedicato- selezione sito

└→ Advanced settings (nel menu di destra)└→ selezionare Application pool specifico

2.4) Autenticazione Utenti

Il sistema di autenticazione utenti di un sito si gestisce direttamente da IIS.Cliccare (TastoSX) sul sito, e poi su “Authentication” (DoppioClick):

Compare la pagina dei Criteri di Autenticazione:

I piu’ comuni sono:- Anonymous Authentication = Non richiede autenticazione- Form Authentication = utilizza un “Form” personalizzato, da costruire- Windows Authentication = chiede l’autenticazione con un “Form” predefinito,

verificando le credenziali su ActiveDirectorySono Alternativi: attivarne uno solo. Se se ne attivassero di piu’, bisognerebbe poi, in ogni pagina, specificare quale si vuole usare.

NB: Una volta autenticati, il sito dovra’ comunque gestire una tabella utenti/gruppi, pergestire le autorizzazioni.

2.4.1) LogOffCon un’autenticazione da IIS, non e’ possibile predisporre un comando “LogOff” da pagina web. Si puo’ solo reindirizzare altrove, ma l’utente rimane loggato su quel PC, fino a spegnimento.

Per poter gestire un comando LogOff (che cancelli le variabili di Autenticazione) occorre fare un’autenticazione tramite Forms, con gestione utenti e passwords sul proprio DB.

13

3) GIT(pronuncia: “Ghit”)E’ un programma di “Version Control” distribuito, ideato da Linus Torvalds nel 2005.Sistema NON server-centrico, cioe’ distribuito

--> per “rami” = “Branch”operazioni: - Fork/Branch: divide un ramo;

- Merge: unisce due ramiSoftware download:- www.sourcetreeapp.com --> installa versione grafica del GIT client- bonobogitserver.com --> versione server, con interfaccia web: installare come sito- http://GitHub.com --> es. di GIT server direttamente in cloud (alternativo a bonobo)

3.1) GIT client (SourceTree)

Menu ToolBar fa vedere tutti i Branch, inclusi quelli solo in remoto

riq.”C” Albero versioni riq.”D” Proprieta’ Fileriq.”E” File modificati

riquadro “B” Componenti Progetto riquadro “A” Lista Progetti riq.”F” Record Modificati

- Apertura nuovo progetto:da ToolBar: [Clone/New]

└→ [Create New repository]

14

- NB: le modifiche vanno fatte direttamente sul file nella cartella di lavoro (working copy); eventuali recuperi di vecchie versioni saranno leggibili/editabili sempre nella stessa cartella.

- (?) = file di cui non si e’ ancora detto se tracciarlo o no- “Hunk” = pezzo- Registrazione di una variante (file modificato):

a1) “Stage”/”Unstage” = mettere/togliere un file dal tracciamentoa2) TastoDX + Ignore = toglie il file dal tracciamento, e non lo considera piu’b) da ToolBar: [Commit] = conferma quanto impostato, e salva la “foto”

- Ripristino vecchie versioni:DoppioClick sul pallino della versione da ripristinare (riquadro “C”)

- Crea una Ramificazione:ToolBar: [Branch](v) evidenzia il ramo su cui si sta lavorando

- Riunisce due rami:Seleziona ramo di riferimento; poi ToolBar:[Merge]Risolvere i conflitti editando il file, poi: tastoDX + Mark Resolved

- Estendere il “Commit” sul server di riferimento:ToolBar: [Push]

- Il GIT SourceTree e’ gratuito, ma deve comunque essere registrato:Licenza MyAtlassian: id.myatlassian.com

3.2) GIT server (Bonobo)

Attivare il sito Bonobo sul server (SvrPROD01 /GIT),ed impostare le autorizzazioni come specificato nelle istruzioni.Entrare sul sito inizialmente come utente amministratore di default: “admin”/“admin”

3.2.1) Generare gli utenti di lavoro:[User]: [Create New User]

3.2.2) Autorizzare come amministratore gli utenti opportuni:[User]: [Edit] --> administrator [v]

3.2.3) Creare i repository dei progetti (sul server):utente-amministratore:

--> create new repository

15

3.3) interfaccia GIT da locale con il server

3.3.1) Replicare un progetto locale su server:3.3.1.1) Creare Progetto in Locale (su SourceTree);3.3.1.2) Commit progetto locale;3.3.1.3) Da server (bonobo): creare il progetto, e copiarsi l’URL;3.3.1.4) passare sul client (SourceTree):3.3.1.5) Riquadro”B”-[Remote]: TastoDX + New remote

└→ Add- URL: copiare dal server- [v] Default Remote- Host Type= unknown- UserName = NomeUtente(bonobo)

3.3.1.6) Ora, nel riquadro”B”, si vede il [Remote]= Origin3.3.1.7) da ToolBar: [Push]

3.3.2) Clonare in locale un progetto gia’ sul server:3.3.2.1) da client (SourceTree):3.3.2.2) ToolBar: [Clone/New]

└→ - URL: copiato dal server- indicare in quale cartella (locale) salvarlo- [v] ...Folder: si riferisce all’elenco del riquadro”A”

└→ [Clone]3.3.2.3) Cliccare su [Branches]: [Master] per vederlo3.3.2.4) Se nel riquadro”A” non si vede il progetto nuovo (perche’ ci si e’ dimenticato

il [v]): Drag-and-Drop della relativa cartella, da Explorer

3.3.3) Visualizzazione di tutti i rami, inclusi quelli chiusi su server:+[Remote]/+[Origin]/ [Alternativo]: tastoDX

└→ Checkout origin/alternativo

3.3.4) Salvataggio della propria (ultima) versione su server:- Dopo aver fatto il [Commit]:

--> [Push]

3.3.5) Recupero in locale dei push fatti da altri:3.3.5.1) ToolBar:[Fetch] --> [v]

[ ][ ]

e verifico che modifiche sono state fatte;3.3.5.2) ToolBar:[Pull]

3.3.6) Esclusione dal tracciamento dei file temporanei di lavoro:Quando si usa GIT per organizzare le modifiche ad un sito web costruito con VisualStudio, e’ opportuno togliere dal tracciamento tutta la serie di files temporanei di lavoro, che VisualStudio usa.Questi files si trovano, per lo piu’, nelle cartelle NomeProgetto/NomeProgetto/bin e .../obj.Per sospendere il tracciamento:

3.3.6.1) selezionare dal riquadro”E” uno di questi files: TastoDX + Ignore Cosi’ si genera il file (nascosto) ...\NomeProgetto\ .gitignore

16

3.3.6.2) editare questo file, completandone la lista come segue:*.suo*.user[Bb]in/[Oo]bj/

(cerca anche da Google: “GITignore Visual Studio”)3.3.6.3) Effettuare il “Commit” di questo file

3.3.7) Branch da tracciareIn caso di problemi di Pull/Push, verificare di aver impostato correttamente il Branch datracciare:Su [Branches] \ [Master]: TastoDX

└→ Track remote branch└→ [v] Origin/master

17

4) VISUAL STUDIO EXPRESS per WEB

4.1) Registrazione

La registrazione Microsoft e’ gratuita, ma obbligatoria.

4.2) Struttura della cartella (Repository) del Progetto

La cartella del progetto “NomeProgetto” ha la seguente struttura: +[cartella] NomeProgetto

\ [cartella].git\ [cartella] packages\ [cartella] NomeProgetto\ [file] NomeProgetto.sln <-- file che apre il progetto con VisualStudio\ [file] NomeProgetto\ NomeProgetto.csproj <-- lista dei file usati

4.2.1) File esclusiSe aggiungo file manualmente nella cartella, questi NON sono riconosciuti come parte del progetto: devo aggiungerli tramite VisualStudio.Oppure, una volta aggiunti e visualizzati (bottone [mostra/nascondi]):

TastoDX + includi nel Progetto

4.3) Interfaccia MS Visual Studio 2012

4.3.1) Schermata principaleMenu mostra/nascondi file NON inclusi nel pogetto

Refresh

Visualizza/editor Files Struttura del sito

18

4.3.2) Apertura di un nuovo progetto:Da menu:

\_ FILE- Nuovo Progetto

Attenzione a scegliere il template giusto:

NB: apri/nuovo “Sito Web” e’ un vecchio stile che NON si usa piu’.

4.3.3) Salvataggio, Compilazione, DebuggingOgni volta che si aggiunge un nuovo file, prima di effettuare un “commit” sul GIT, occorre salvare il progetto, in modo da aggiornare il file NomeProgetto.csproj, che ne traccia la struttura:

da menu: FILE + Salva Tutto

Prima di poterlo eseguire, occorre compilarlo:da menu: COMPILA + Compila Soluzione

Per verificarne il funzionamento si puo’ lanciare il debugging, che salva, compila, definisce un localhost su una porta random, e ci apre sopra il sito:

19

da menu: DEBUG + Avvia Debug(comando presente anche nella ToolBar).

NB: ricordarsi, alla fine, di uscire dal debug, col comando: Stop Debug

Esempio di sito aperto in locale dal debugger:localhost:1799/Home/index2

MetodoPorta Controller

4.3.4) Aggiunta di nuovi files4.3.4.1) Definire una nuova Classe:

dal riquadro Struttura, click su cartella corrispondente (Models o Controllers):--> TastoDX --> Aggiungi (Add)

\_ Classe

4.3.4.2) Definire una nuovo Controller:dal riquadro Struttura, click su cartella Controllers:

--> TastoDX --> Aggiungi\_ Controller

4.3.4.3) Aggiungi Vista:a) creare la sotto-cartella della pagina: Views/NomePagina:

dal riquadro Struttura, click su cartella Views:--> TastoDX --> Aggiungi

\_ Nuova Cartellab) creare il file Index.cshtml della pagina:

dal riquadro Struttura, click su cartella Views/NomePagina:--> TastoDX --> Aggiungi

\_ Visualizza... (View)

Baffando [v] la casella “Create a Strongly-Typer View”, chiede anche la Classe dell’oggetto da passare (vedi 7.5.2).

Il comando “Aggiungi Visualizzazione” si ottiene anche col TastoDX sulla chiamata a quella vista, da dentro il file Controller:

return View(doc);

20

NB: la View cosi’ aggiunta contiene, in intestazione, l’istruzioneViewbag.Title= “Index”;

che, con un utilizzo proprio del metodo ViewBag, puo’ essere tranquillamente cancellata.

4.3.5) Tipologia di EOL (End Of Line):Il carattere usato per andare “a capo” varia tra Windows (CR+LF) e gli altri sistemi operativi (CR e basta): se i file del progetto sono stati editati con sistemi operativi diversi, puo’ comparire il seguente messaggio si alert:

scegliere, di massima, il tipo di EOL proprio del OS installato sul server.

4.3.6) EditorUna volta aperto un file:- il tasto [Tab] esegue il completamento automatico.- passando col mouse sopra un campo, visualizzo alcune note dal Manuale on-line.

4.3.7) BreakPointsPer inserire una BreakPoint (solo su un file Controller), cliccare sulla barra verticale grigia di sinistra: comparira’ il segnalino .Una volta lanciato il debugger, a programma fermato compariranno i tasti

corrispondenti ad [F10], [F11]... che controllano l’avanzamento step by step.

4.3.8) Pubblicazione del SitoCon la Pubblicazione, si compila il codice e si copia l’eseguibile nella cartella del sito.TastoDX sul nome del progetto, nel riquadro di sinistra:

\_ Pubblica

21

... e confermare, cliccando su [Pubblica].

La prima volta dovra’ essere specificata la cartella di destinazione, che rimarra’ memorizzata (e distribuita dal GIT). I parametri richiesti saranno:- Connection: --> “New profile” --> faccio un nuovo profilo, e lo chiamo come il

server (SvrProd01)- publish Method --> “File System”- Target Location--> \\svrprod01\ d$\ Siti\ Manuale

E’ buona norma contrassegnare con etichette (“Tag”) sul GIT le versioni che sono state publicate.

4.3.9) Installazione di DLLLa lista delle DLL installate e’ visibile nella cartella [References] (o “Riferimenti”).Per avere il dettaglio del contenuto di una libreria, cliccarci sopra:

TastoDX\_ Visualizza nel visualizzatore oggetti

(Da qui si vede, per es, che System.IO e’ contenuta dentro la DLL System)

Per installare una nuova DLL:[References] --> TastoDX

\_ Add Referencese scegliere tra le seguenti opzioni:- Assembly: GAC (= Global Assembly Cache): e’ una cartella sotto %WinDir%; cache

comune di sistema (installata dal framework)- Soluzione: se la DLL e’ presente dentro la mia Soluzione, come codice Sorgente- COM: se devo cercare la DLL tra quelle Compilate, installate nel Registro (rif.

comando REGEDIT), visibili sotto \System32- Browse: se ho scaricato a mano la DLL, indicando la directory in cui l’ho posizionata

22

5) PROGRAMMAZIONE ad OGGETTI C#Le classi di oggetti sono definite e gestite tramite cinque elementi fondamentali:

- Fields (Campi) / Proprieta’ / Stati- Metodi- Costruttori- Eventi

5.1) Caratteri particolari

In C# si usano i seguenti caratteri speciali:// = riga di Commento/* = inizio Commento*/ = fine Commento{ = inizio Blocco di codice} = fine Blocco di codice~/ = cartella root del sito (usato nei link)|| = OR&& = AND== = Equal!= = Diverso=> = Tale per cui (Appartiene ad insieme di seguito definito)! = Not = negazione dell’espressione (buleana) che segue

5.2) FIELDS (CAMPI) e VARIABILI:

I campi di una classe corrispondono alle variabili (o costanti) che la caratterizzano.Sintassi:

{area} {tipo} nomeCampo; int, float, string, ... ogni istruzione termina con “;”

public o private

I Tipi base utilizzati (detti “primitivi” o “scalari”) sono:- int = intero (4 byte); NB: puo’ assumere il valore zero, ma non Nullo- float = razionale (in virgola mobile: notazione esponenziale)- string = stringa di lunghezza variabile. Per default, puo’ assumere valore nullo- boolean = True/False (NB: negli “IF”, “=True” puo’ essere sottinteso)- byte = intero di 1 byte (da 0 a 255)- short = intero di 2 byte- long = intero di 8 byte- decimal = decimale in virgola fissa- single = razionale a bassa precisione- double = razionale ad alta precisione- char = carattere singolo- int? = intero che puo’ assumere anche il valore Nullo- datetime? = data/ora che puo’ assumere anche il valore Nullo

23

Esempi e Convenzioni:

Variabile definita in una Classe (= “Field”/”Campo”):se pubblica,

per convenzione inizia per maiuscola:public int MioCampo;

se privata,per convenzione si usa “_” e la minuscola:

private int _mioCampo;private int _a;

se privata, che supporta una proprietà pubblica;per convenzione si chiama “_” + nome proprieta’ in minuscolo:

private int _miaProprieta;

Variabile usata all’interno di un Metodo (NON e’ un “Field”):se privata,

per convenzione inizia per minuscola:private int a;

NON puo’ essere pubblica.

5.3) PROPRIETA’ e Stati

Sono campi particolari di una classe.Si distinguono a colpo d’occhio dai Metodi, perche’ non hanno le parentesi tonde “()”.Al suo interno deve sempre essere definito, in due corrispondenti blocchi di codice, cosafare quando si fa un:

- GET = Leggi la proprieta’- SET = Scrivi la proprieta’ (a meno che non sia read-only)

Una Proprieta’ e’ simile ad un Campo; con la differenza che mi consente, volendo, di definire altre eventuali operazioni che volessi fare ogni volta che viene scritta o letta (per esempio generare Eventi).

Esempi:Proprietà pubblica (lettura e scrittura):

private int _miaProprieta;public int MiaProprieta{

get{

return _miaProprieta;}set{

_miaProprieta = value;}

}

Proprietà in forma contratta (identica alla precendente)public int MiaProprieta2 { get; set; }

24

Proprieta’ read-only:private int a;public int MiaProprieta3{ valore che viene passato nel “set”

get {return a;}private set {a = value;}

} usabile solo da dentro la classe

5.4) METODI

I Metodi corrispondono a quelle che, nella programmazione tradizionale, erano le funzioni e procedure. Possono avere parametri in input e/o output.Sono definiti in files

*.cs, posti nella cartella

.../ Models

5.4.1) Definizione di un Metodo: Sintassi:{area} {output} nomeMetodo( ... , ... , ...)

{... definizione Parametri in inputreturn ... ;

}Tipo di Output: “int”, “float”, “string”, ... o “void”, se nullo

Operazioni da fare; tra cui “return”= valorizza variabile di outputInizio

Fine “public” / “private”

Alla fine del metodo, se deve restituire qualcosa, si usa return.NB: l’istruzione return interrompe l’esecuzione della procedura: eventuale codice scritto dopo questa istruzione NON viene eseguito (si puo’ quindi usare dopo un “if”, senza bisogno di “else”).

Un sistema immediato per distinguere un Metodo da una Proprieta’ e’ che il Metodo e’ sempre seguito da parentesi tonde “()”, la Proprieta’ no.

5.4.2) Esempi:Esempio 1:

public int Somma(int a; int b){return a+b}

Metodo che non ritorna nulla:public void MetodoCheNonRitornaNulla(){}

Metodo con parametri in ingresso:

25

public void MetodoConParametri(int a, string b, float c){}

Metodo con parametro in uscita di tipo intero:public int Somma(int addendo1, int addendo2){

// variabile privata visibile solo nel metodoint risultato;risultato = addendo1 + addendo2;return risultato;

}

Potevo scrivere il tutto più velocemente così:public int Somma(int addendo1, int addendo2){

return addendo1 + addendo2;}

Vedi anche File “.../Models/ MiaClasse.cs”

5.4.3) Richiamo di un metodo:Esempio:

int C;C = Somma(6,7);

oppure:int C = Somma(6,7);

5.4.4) Metodi ereditati dalle classi standardAl momento della definizione, ogni nuova Classe eredita tutti i metodi predefiniti per la sua classe Origine.Es: ogni Vettore eredita il metodo “Contains” = conferma se un dato valore e’ presente.Se non e’ specificata nessuna classe origine, eredita dalla classe “Object”.

Per una panoramica sui vari metodi (sopratutto sulle Liste), vedi cap. (9.5).

5.5) COSTRUTTORI

I costruttori sono dei metodi speciali che vengono chiamati in fase di inizializzazione degli elementi di una classe.Devono per forza chiamarsi con il nome della classe.Non hanno il parametro di ritorno ma possono avere parametri in ingresso.Si distinguono dai Metodi normali, perche’ non hanno parametri che li precedono.

Esempi:Costruttore vuoto (di default):

public MiaClasse(){}

26

Costruttore con un parametro in ingresso:public MiaClasse(int partenza){}

Quando, per una classe, definisco piu’ costruttori, questi si differenzieranno tra loro in base al numero e tipo di parametri da passare (visto che hanno sempre lo stesso nome).Quindi, in base a che parametri passo, il sistema capisce quale costruttore deve chiamare.

5.6) EVENTI

Tramite gli eventi una classe o un oggetto sono in grado di segnalare ad altre classi o oggetti una situazione di interesse.La classe che invia (o genera) l'evento è chiamata autore e le classi che ricevono (o gestiscono) l'evento sono chiamate sottoscrittori.Il concetto di “evento”, che consente di essere segnalato senza sapere, a priori, chi usera’ questa informazione, nella programmazione tradizionale non esisteva.

5.7) dichiarazione di una CLASSE di oggetti

Sintassi:{area} class nomeClasse: NomeClasseMaster

{[blocco istruzioni]

}

Se non viene specificata nessuna classe “master”, la nuova classe eredita dalla classe “object” (oggetto generico).

Es:public class LCommercialeEsteroController : Controller

{....

}

5.8) DICHIARAZIONE e Assegnazione di un Oggetto/Variabile

5.8.1) Oggetti e Tipi PrimitiviQuando si parla di “Oggetti”, ci si riferisce normalmente ad oggetti di tipo complesso, definiti da una Classe.Una variabile puo’ quindi puntare ad un Oggetto, o ad un Tipo primitivo.Il comportamento di Oggetti e Variabili di tipo Primitivo, e’ leggermente differente.

5.8.2) Dichiarazione, Assegnazione, utilizzoIn generale, un Oggetto/variabile, prima di poter essere utilizzato, richiede due operazioni:

27

- Dichiarazione = dichiara l’esistenza dell’etichetta, specificando il tipo:creo il puntatore. Non occupo memoria.

- Assegnazione = alloca lo spazio di memoria, a cui l’etichetta puntera’, e cancella eventuali puntamenti precedenti (poi liberera’ la memoria):creo il nuovo oggetto.

Se si tratta di una variabile di Tipo primitivo, l’Assegnazione avviene implicitamente conla Dichiarazione, e prima di ogni valorizzazione, per cui non e’ necessario scriverla esplicitamente.Il C# fa dei controlli periodici (detti di “garbage Collector”), distruggendo gli oggetti in memoria che non sono piu’ Referenziati (= puntati da una variabile), liberando cosi’ spazio. In altri linguaggi il “Destroy” (“free”) va gestito manualmente.

5.8.3) SintassiLa sintassi basica, per la Dichiarazione e’:

TipoOggetto NomeOggetto;e per l’assegnazione:

NomeOggetto = new CostruttoreOggetto(...);(Ricordarsi che il Costruttore ha lo stesso nome della Classe dell’Oggetto da costruire).

Questo doppio comando puo’ essere scritto su una sola riga:TipoOggetto NomeOggetto = new CostruttoreOggetto(...);

o anche, in forma contratta (visto che Tipo e Costruttore hanno lo stesso nome): var NomeOggetto = new CostruttoreOggetto(...);

Esempio1:Documento doc; Dichiarazionedoc = new Documento(); Assegnazionedoc.X = 2; utilizzodoc.A = “pippo”;

Esempio2:Documento doc = new Documento(2, “pippo”);

Esempio3: var doc = new Documento(2, “pippo”);

Esempio4:var doc = new Documento();doc.A = “pippo”;

5.8.4) PuntatoriSe voglio scrivere i valori dentro una variabile-Oggetto, copiandoli tutti da un’altra variabile (della stessa classe, ovviamente), devo comunque riassegnare tutti i campi, uno ad uno. Scrivendo un istruzione “=” a livello di classe, non creerei una copia dei campi, ma un puntamento allo stesso oggetto.Esempio, data: public class Documento

{ public int X {get; set;}public string A {get; set;} }

dichiarate due variabili di classe Documento, doc1 e doc2, per copiarle devo scrivere:doc2.X = doc1.X;doc2.A = doc1.A;

Se scrivessi:doc2 = doc1;

28

qualunque modifica facessi poi su doc2, risulterebbe automaticamente copiata anche su doc1.

In altre parole, se scrivo:A = x;B = A;A = y;

Se A e B sono variabili di tipo Primitivo, ottengo, alla fine: A=y, B=x.Se A e B sono variabili di tipo Oggetto, ottengo, alla fine: A=y, B=y (la terza istruzione non invalida quanto scritto nella seconda).

5.8.5) Cancellare i puntatoriSe (in un controller) faccio una lista con un ciclo “for”, scrivendo:var rv = new RigaVisualizzazioneDocumento();foreach (DocumentoUltimaVersione rd in anagraficaDocumenti){

rv.Id = rd.Id;rv.Codice = rd.Codice;visualizzazioneDocumenti.Add(rv);

}carichero’ nella lista “visualizzazioneDocumenti” n record (con n = numero di record in “anagraficaDocumenti”), ma TUTTI UGUALI.Infatti, facendo la dichiarazione una volta sola, ad ogni iterazione non scrivo una nuova variabile, ma aggiungo un nuovo puntatore alla stessa variabile; cosi’ tutti i record rv puntano allo stesso oggetto, e sono quindi identici (uguali all’ulimo record di “anagraficaDocumenti”).Per risolvere il problema devo resettare “rv” ad ogni iterazione:foreach (DocumentoUltimaVersione rd in anagraficaDocumenti){

var rv = new RigaVisualizzazioneDocumento();rv.Id = rd.Id;rv.Codice = rd.Codice;visualizzazioneDocumenti.Add(rv);

}

5.9) Oggetti Pre-definiti / Operatori particolari

DateTime.Now = Data-Ora di questo momentoString.IsNullOrEmpty(x) = verifica se la stringa “x” e’ nulla o vuota

Es: se “x” NON e’ nulla o vuota, la scrivo in model.Documento.Codice:if (!string.IsNullOrEmpty(x))

model.Documento.Codice = x;

5.10) LISTE Dinamiche

Le Liste sono vettori di oggetti, di dimensione variabile (dinamica).

29

Esempio di dichiarazione + assegnazione:List<Documento> NomeLista = new List<Documento>();

dichiarazione assegnazionetipo di oggetti in lista costruttore di default

NB: nella dichiarazione di un oggetto, la parola “new” puo’ essere omessa solo in caso ditipi primitivi (“scalari”).

Forma estesa, su due righe (dichiarazione ed istanza):List<Documento> lista;lista = new List<Documento>();

Forma contratta, usando il “var”:var NomeLista = new List<Documento>();

Scrittura di un record in una lista:dichiarazione:

var anDoc = new List<Documento>();valorizzazione campi:

var documento = new Documento();documento.Codice = "PI01";documento.Descrizione = "Portafoglio 2010-2012";documento.Percorso = "file:///n:/Grulav/Report/pippo.xls";

scrittura:anDoc.Add(documento);

oppure, utilizzando un Costruttore: documento = new Documento() { Codice = "PI04", Descrizione = "Spedito",

Percorso = "file:///n:/Grulav/Report/pippo.xls" }; anDoc.Add(documento);

oppure, usando lo stesso costruttore, in forma contratta: documento = new Documento("PI03", "Report",

"file:///n:/Grulav/Report/pippo.pdf"); anDoc.Add(documento);

oppure, fondendo i due comandi, in forma tabellare (es. di 3 record):anDoc.Add(new Documento("PI05", "Fatturato", "file:///n:/Grulav/pippo1.xls"));anDoc.Add(new Documento("PI06", "Portafo_", "file:///n:/Grulav/pippo2.xls"));anDoc.Add(new Documento("PI07", "Birra_PP", "file:///n:/Grulav/pippo3.xls"));

5.11) ISTRUZIONI basiche

5.11.1) Ciclo FOREsempio: per i da 1 a 12, incrementando di 1:

For (int i=0; i<12; i++) {}oppure, stessa cosa per lista di 12 elementi:

For (int i=0; i<NomeLista.Count; i=i+1) {}

5.11.2) Ciclo FOREACHEsempio:

ForEach (var Doc in NomeLista) {}

30

equivalente a:ForEach (Documento Doc in NomeLista) {}

5.11.3) IF - then - ELSEEsempio1:

if (tipo != null) {

Titolo = tipo.Descrizione;}else{

Titolo = "Errore - '" + id + "' classe errata";}

Nel caso di blocco di una sola istruzione, si possono omettere le { }Esempio2:

if (ut == null) a = a + 1;

5.11.4) SWITCHEsempio:switch(day){ case "Monday":

message="This is the first weekday.";break;

case "Friday":message="Tomorrow is weekend!";break;

default:message="Today is " + day;

break; }

5.12) Formattazione Stringhe

5.12.1) Metodo diretto:Esempio: DataStringa = Data.ToString("dd/MM/yyyy");

5.12.2) Utilizzo del Metodo “Format” dell’oggetto “String”:Esempio: DataStringa = string.Format("dal{0:dd/MM/yyyy}al{1:dd/MM/yyyy}", Data1, Data2);risultato:

DataString = dal 12/01/2014 al 25/9/2014

Vedi internet:msdn.microsoft.com/it-it/library/system.string.format(v=vs.110).aspx

31

5.13) Classi HttpContext e System

Vari parametri di sistema possono essere letti da HttpContext e System.

Esempi da file Controller:public string UtenteLoggato{ get

{return HttpContext.User.Identity.Name;

} }

Esempi da file View (serve la specifica “.Current.”):<p>Utente loggato: @HttpContext.Current.User.Identity.Name</p><p>Tipo autenticazione:

@HttpContext.Current.User.Identity.AuthenticationType</p><p>Autenticato: @HttpContext.Current.User.Identity.IsAuthenticated</p><p>Utente processo:

@System.Security.Principal.WindowsIdentity.GetCurrent().Name</p>

5.14) Esempio di definizione di una CLASSE; istruzione “Using”using System;using System.Collections.Generic;using System.Linq;using System.Web;

namespace Prova1.Models{

public class MiaClasse{

public int MioCampo;// costruttore (vuoto o di default)

public MiaClasse(){}

// proprietà pubblica (lettura e scrittura)public int MiaProprieta{

get{return _miaProprieta;}set{_miaProprieta = value;}

}// Metodo:

public int Somma(int addendo1, int addendo2){return addendo1 + addendo2;}

}}

il comando “using” definisce il “path” dentro cui andare a cercare le definizioni delle classi.Il codice che usera’ questa classe potra’ chiamarla come

Prova1.Models.MiaClasse()oppure semplicemente

MiaClasse()avendo premesso

using Prova1.Models;

32

6) LINGUAGGIO HTMLPer la programmazione HTML fare riferimento ad altro manuale. Si riportano qui solo annotazioni sparse.

6.1) Esempi e Note

6.1.1) Tag basici<div></div> definisce un Pannello<span></span> definisce un blocco sulla stessa riga (cioe’ che non va a capo)<br/> = va a capo riga blocco di Commento<tr></tr> Riga di una Tabella<th></th> Riga di Intestazione di una Tabella (bold)<td></td> Colonna/Cella di una Tabella

6.1.2) Unita’ di misura:- px = Pixel- pt = Punti (usato sempre e solo per i Fonts)- em = proporzionata ai caratteri usati: 1 em = largh.di 1 carattere?- % = percentuale dello schermo

6.1.3) Margini:“Margin” e’ un margine esterno all’elemento“Padding” e’ un margine interno; solo alcuni oggetti lo supportano (le immagini no)

6.1.4) Tag “Overflow”:definisce la comparsa o meno della Scroll-Bar su un dato pannello:

--> Auto = solo se il pannello esce dallo schermo--> Hidden = mai--> Visible = allarga la finestra, fino ad includere tutto (di solito si attiva una

barra di scorrimento sul contenitore della finestra.--> Scroll = mette la barra di scorrimento (sempre)

6.1.5) Tag <Title>:definisce il titolo della pagina, che compare sul “tag” del browser e sulle liste dei motori di ricerca.

6.1.6) Standard XML: per conformarsi allo standard XML, che richiede che ogni parametro sia seguito da un valore e che ogni tag sia aperto e poi chiuso, in html i parametri che venivano chiamati senza valori, ora vengono assegnati uguali a se stessi.Esempio1: readonly -->diventa--> readonly=”readonly”Esempio2: <br> -->diventa--> <br/> (che equivale a <br></br>)

6.1.7) Stili di formattazionePer la formattazione (incluse dimensioni delle immagini), usare sempre e solo le Classi diStile CSS.

33

Eccezioni agli stili: una volta definito uno stile, posso dire che nel suo interno, per un certo tipo di blocco di pagina (tag), si usa una eccezione.Esempio:

.BoxD form {text-align: left}definisce che le “form” all’interno di un blocco stile “BoxD” sono allineate a sinistra, diversamente dal resto.

6.1.8) Invio e-mail:si usa il comando “mailto”, che apre il client di posta e preimposta una mail da spedire.Es:<p> <a class="pure-button bottone-B" href="mailto:[email protected]?Subject=Manuale%20Qualita'" target="_top">Inoltro e-mail a Gest.Qualita'</a> </p>

porta in primo piano la finestra della mail aperta

Le opzioni possibili sono: cc, bcc, subject, body:separatore indirizzi destinazione prima opzione

<a href="mailto:[email protected],[email protected][email protected] &[email protected]&subject=avviso&body=Testo msg"> Mail completa </a>

opzioni successive opzioniNB: il destinatario puo’ essere lasciato vuoto, per farlo compilare a mano.

Vedi anche:- www.jetbrains.com --> Tool “ReSharper” (a pagamento): help on-line per VisualStudio

- www.csszengarden.com --> Esempi di uso dei fogli di stile- www.webfract.it/GUIDA/mailTo.htm --> opzioni del comando “mailto”

6.2) JavaScript (JS) e JQuery

Se nel codice html si usano anche istruzioni in JS, e’ opportuno installare la libreria “JQuery”.Questo perche’ il JavaScript NON e’ uno standard, mentre, invece, lo e’ il JQuery, nel senso che ci pensa lui a testare la configurazione del sistema (tipo di browser, risoluzione schermo, ecc) e ad adattarsi di conseguenza.

NB: ricordare sempre che un hacker potrebbe facilmente copiarsi una pagina web, modificarla e ripostarla; ma solo relativamente al codice html e js. Quindi i controlli sensibili vanno fatti sul lato server, in C#.

6.2.1) Download JQuerycollegarsi al sito: jquery.com

\_ [Download]\_ versione “JQuery 1.x” (che e’ quella che supporta tutto)

\_ compressed

Notare che le librerie si trovano in varie versioni:

34

- Normale- “min” = compattata, eliminando commenti e spazi- “intellisense” = con opzioni plug-in per Windows- “UI” = Estensione, con le modalita’ Grafiche

6.2.2) Installazione JQueryScompattare il file scaricato (--> jquery-1.11.1.min.js), copiarlo dentro il progetto, nellacartella

.../Scripts/ed includerlo nel progetto.NB: jquery “ui” = “User Interface”

6.2.3) Files JS e DichiarazioneIl codice JS potrebbe essere scritto direttamente nella pagina html che lo usa, dentro l’intestazione <head>:<html>

<head>(...)<script type="text/javascript">

alert("Benvenuto");</script>

</head>

Per convenzione, pero’, viene scritto in files separati, con estensione .js, che vengono richiamati da dentro l’intestazione della pagina (quindi, di solito, nel Layout.cshtml).<html>

<head>(...)<script src="~/Scripts/jquery-1.11.1.min.js"></script><script src="~/Scripts/mioCodiceJS.js"></script>

</head>...

6.2.4) Linguaggio JS: caratteri specialiIl linguaggio JS puo’ essere usato anche senza conoscenza specifica, cercando su web uno script che faccia esattamente quello che serve.Cio’ premesso, elenco alcune regole base:

- il linguaggio e’ Case-Sensitive- i comandi vanno terminati con ;- il delimitatore di testo e’ “- le variabili non sono tipizzate, e NON e’ necessario dichiararle (ma lo si puo’

fare con l’istruzione “var”)- operatori booleani: == != > < >= <=- condizione AND: &&- condizione OR: ||- condizione NOT: ! (quindi "!=" significa "diverso da")

6.2.5) Linguaggio JS: istruzioni base

alert(); --> genera un popup, che chiede conferma per procedere:

35

confirm(); --> genera un popup di tipo booleano:

es: if (confirm("Sei d'accordo?")) alert("Sono d'accordo")else alert ("Non sono d'accordo");

prompt(); --> genera un popup che richiede un input:

es: username=prompt("Inserisci il tuo nome per favore","");

document.write(); --> scrive una finestra di testo sulla pagina correntees: var a; // Dichiarazione facoltativa

a=2;A=7;Risultato=A+a;document.write(Risultato);

6.2.6) istruzioni JQueryLe istruzioni JQuery si distinguono per il fatto che iniziano con il carattere “$”.

$() = Selettore: seleziona un oggetto per IDEsempio (file _inputCodiceDocumento.js):function ChiedeCodiceDocumento() {

var codice = prompt("Codice Documento?", "");//alert("Il codice inserito è" + codice);$("#Codice").val(codice);$("#CodiceNascosto").val(codice);

}

Assegna al campo con id= #Codice il valore letto nel prompt.

Vedi anche: api.jquery.comgoogle: “background sfumato css3”google: “set input text jquery”

7) PROGRAMMAZIONE RAZOR MVC – MODEL VIEW CONTROLLERLe Classi che stanno nella cartella “Models” sono dei Modelli;le Classi che stanno nella cartella “Controllers” sono dei Controlli.In una data pagina:

Il controller di default e’ “Home”Il Metodo di default e’ “Index”

36

I’eventuale parametro DEVE chiamarsi “id” (nel Controller)(per consultazione, queste regole sono scritte nel file ...\App_Start\RouteConfig.cs).

7.1) File CONTROLLER

I file Controller pilotano le pagine web: in prima approssimazione possiamo dire che ognipagina ha il suo controller (un controller potrebbe controllare piu’ pagine, usando metodi diversi).I risultati dei Controllers sono le Viste, che si ottengono attraverso il Metodo “View”.La cartella che contiene la Vista deve avere lo stesso nome del Controller che la pilota.I Controllers sono scritti in linguaggio C#,in files con estensione *.cs, che vanno posizionati nella cartella: .../Controller/

Per regola sintattica, i controller vanno chiamati con il nomeID, seguito dalla parola chiave “Controller” (es: il controller “Home” si chiama “HomeController”); nelle altre parti del codice si fara’ riferimento ad essi con il solo nomeID, senza suffisso “Controller”.

Esempio: file “.../Controller/ CommercialeItaliaController.cs”NB: di solito il nome del file coincide col nome della classe che definisce.

Lista librerie DLL utilizzateusing System;using System.Collections.Generic;using System.Linq;using System.Web;using System.Web.Mvc;

namespace Prova1.Controllers (a){ public class CommercialeItaliaController : Controller (b) {

// riga di commento public ActionResult Index() (c) { return View(); (d) } }}

Definisce nel sito “Prova1”:a) namespace= gruppo di classi; di solito= nomeprogetto.directory. NON possono

esistere due classi con stesso nome e stesso namespace.Una classe che estende una classe pre-esistente, eredita per default tutte le sue caratteristiche (salvo diversa specifica).

b) una nuova classe “CommercialeItalia(Controller)”, che estende la classe pre-esistente “Controller” (e quindi e’ un controller)

c) che utilizza un Metodo che chiama la pagina “Index” (nome di default),d) la classe restituisce la visualizzazione della vista chiamata.

Uno stesso controller puo’ pilotare piu’ viste, ripetendo l’istruzione: public ActionResult nomeVista() (c) {

37

return View(); (d) }

7.2) VISTE

Le Views sono scritte in linguaggio “Razor”, che combina l’html con comandi C#, preceduti dal carattere chiave “@”;stanno in files con estensione *.cshtml (C# + html),che vanno posizionati nella cartella:

.../Views/NomeControllercon NomeController= nome del Controller che la pilota.

Eventuali Layout utilizzati vanno posizionati nella cartella:.../Views/Shared

Altri file collegati, come:- immagini- fogli di Stile- documenti

vanno messi nella cartella:.../Content

NB: all’interno del codice html standard, il carattere “@” identifica l’inizio di un blocco di codice in C#.es: @if ...

@{ ... }Il blocco puo’ essere chiuso dalla “}”, o dalla chiusura di un blocco html.

7.3) Layout di pagina

Le definizioni dei Layout sono scritte in files con estensione *.cshtml (C# + html),che vanno posizionati nella cartella:

.../Views/SharedPer convenzione, il nome del file inizia con “_” e maiuscola (di solito: _Layout.cshtml).

Il Layout puo’ essere richiamato nell’intestazione di una pagina (View/.../Index.cshtml),con l’istruzione “Layout” dentro il blocco iniziale @{...};esempio:

@{Layout = "~/Views/Shared/_Layout.cshtml";}e sta ad indicare che detta pagina va inserita all’interno di uno schema (layout) predefinito.In assenza di Layout, l’istruzione sara’:

@{Layout = null;}

Il file _Layout contiene il codice html della pagina, e l’istruzione@RenderBody()

che indica il punto in cui va inserito il codice specifico scritto nel file Index;in sostanza compone una pagina html, unendo il file Index al file Layout.

Quello dei layout e’ il sistema utilizzato per rimpiazzare i frames.

38

esempio di file Layout: intestazione della pagina html<!DOCTYPE html><html>

<head><title>Intranet Azienda - Reports</title><meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1"><meta name="viewport" content="width=device-width, initial-scale=1"><link rel="stylesheet" href="~/Content/pure-min.css"><link rel="stylesheet" type="text/css" href="~/Content/FoglioStile.css">

</head>

<body><div class="boxS">

<div>

<img class="logo_SGS" src="~/Content/immagini/immSGS.gif" alt="logoSGS"></div>

<h1>Famiglie di Report</h1><p> <a class="pure-button bottone-menu" href="~/Home/Index">Home</a></p><p> <a class="pure-button bottone-menu" href="~/LAssistenza/Index">Assist</a> </p>

<p>@DateTime.Now</p>

</div>

<div class="Titolo"><span>@ViewBag.Titolo</span><span title="Data/ora" style="font-size: 7pt;

margin-left: 30px;">@DateTime.Now</span></div><div class="boxD">

@RenderBody()</div>

</body></html>

Qui viene inserito il contenuto della View che ha chiamato il _Layout

7.4) MODELs

I Modelli (file .../Models/ NomeModello.cs) servono basicamente per definire le Classi dioggetti.Esempio di definizione (della classe “Documento”): file .../Models/Documento.csusing System;


public class Documento{

// costuttore di defaultpublic Documento(){

39

// setto alcuni valori di default delle proprietàVersione = 1;DataAggiornamento = DateTime.Now;

}

// costuttore di comodo usato in alternativa al primopublic Documento(string codice, string descrizione, string percorso){

Codice = codice;Descrizione = descrizione;Percorso = percorso;Versione = 1;DataAggiornamento = DateTime.Now;

}

// definizione della struttura della classepublic int Id { get; set; }public string Codice { get; set; }public int? Versione { get; set; }public string Descrizione { get; set; }public DateTime? DataAggiornamento { get; set; }public string Percorso { get; set; }

}}

Notare che il nome del file (.cs) deve coincidere con il mome della classe in esso definita.

7.5) Decorazioni di una Classe

Si chiamano “Decorazioni” gli attributi usati per definire caratteristiche particolari ai vari campi della classe, in fase di definizione (file Model).Si attivano premettendo il relativo NameSpace, con il seguente comando:

using System.ComponentModel.DataAnnotations;using System.ComponentModel.DataAnnotations.Schema;

Vanno indicati tra parentesi quadre [], prima del campo a cui si riferiscono.

Per la lista degli attributi, fare riferimento al sito:www.entityframeworktutorial.net/code-first/dataannotation-in-code-first.aspx

7.5.1) elenco delle specifiche:

Validation Attributes:Required: Campo non puo’ essere vuoto (=Not Null).MinLength: MinLength annotation validates property whether it has minimum length

of array or string.MaxLength: MaxLength annotation maximum length of property which in-tern set

maximum length of column in the databaseStringLength: Specifies the minimum and maximum length of characters that are

allowed in a data field.

Database Schema related Attributes:Table: Specifica il nome della Tabella del DB, che verrà mappata con questa

classe. (Vedi capitolo 9).

40

Column: Specify column name and datatype which will be mapped with the property

Key: Definisce il campo come “Key” (chiave). Implicitamente diventa anche “Required”.

ComplexType: Mark the class as complex type in EF.Timestamp: Mark the property as a non-nullable timestamp column in the database.ForeignKey: Specify Foreign key property for Navigation propertyNotMapped: Specify that property will not be mapped with databaseConcurrencyCheck: ConcurrencyCheck annotation allows you to flag one or more

properties to be used for concurrency checking in the database when a user edits or deletes an entity.

DatabaseGenerated: DatabaseGenerated attribute specifies that property will be mapped to Computed column of the database table. So the property will be read-only property. Si usa per definire un campo Auto-incrementante: [DatabaseGenerated(DatabaseGeneratedOption.Identity)]

InverseProperty: InverseProperty is useful when you have multiple relationship between two classes.

7.5.2) Esempio: estratto di .../Models/ Documento.csusing System;using System.Collections.Generic;using System.ComponentModel.DataAnnotations;using System.ComponentModel.DataAnnotations.Schema;using System.Linq;using System.Web;

namespace Manuale.Models{ [Table("ManualeDocumenti")] public class Documento { public Documento() {}

[Key][DatabaseGenerated(DatabaseGeneratedOption.Identity)] public int Id {get; set;}

[StringLength(10)][Required] public string Codice {get; set;}

[StringLength(100)]public string Percorso {get; set;}

public DateTime DataAggiornam {get; set;}}

}

7.5.3) Chiave multiplaIn caso di chiave multipla, occorre specificare anche la priorita’ di ordinamento:

[Key, Column(Order=0)] public int K1 {get; set;}

[Key, Column(Order=1)] public int K2 {get; set;}

41

7.6) PASSAGGIO PARAMETRI: ViewBag e Model

Il Controller puo’ passare variabili alla Vista in due modi:1) tramite un oggetto-parametro chiamato “Model” (unico; ma, essendo un oggetto,

puo’ essere strutturato come si vuole)2) tramite il “ViewBag”, che e’ un oggetto predefinito non tipizzato (= che posso

definire dinamicamente)

7.6.1) ViewBagEsempio di utilizzo del ViewBag:Nel Controller definisco e valorizzo un campo del parametro:

ViewBag.OraOdierna = DateTime.Now;

oggetto proprieta’ definita “al volo” valore (data corrente, in C#)

E nella View lo richiamo:<p>@ ViewBag.OraOdierna</p>

7.6.2) Classe ModelIl metodo consiste nel definire un Modello consistente in una classe di oggetti, che integri tutti i dati che vogliamo passare.

La View avra’, in intestazione, il comando@model NomeProgetto.Models.NomeOggetto

e fara’ poi riferimento a questo oggetto con la parola chiave@Model...

Sia nella View, sia nel Controller potro’ includere, in intestazione, l’istanzausing NomeProgetto.Models;

che indica che si sta usando l’oggetto definito in questo modello (evita di dover ripeteresempre “NomeProgetto.Models.” in tutte le chiamate).

Notare che nella view “@model” e “@Model” sono parole chiave (minuscola nella definizione in intestazione e maiuscola nel corpo della pagina); nel controller, invece, si puo’ usare una variabile con un nome qualsiasi (purche’ di classe compatibile).

Esempio:Model = come definito in (7.4) = .../Models/Documento.cs

View = .../Views/Documento/Dettaglio.cshtml@model Prova1.Models.Documento

@{ Layout = "~/Views/Shared/_Layout.cshtml";}<h2>Dettaglio Documento</h2><p>Codice: @Model.Codice</p><p>Descrizione: @Model.Descrizione</p><p>Versione: @Model.Versione</p><p>Data Agg.: @Model.DataAggiornamento</p>

Controller = .../Controllers/DocumentoController.csusing System;

42

using System.Collections.Generic;using System.Linq;using System.Web;using System.Web.Mvc;using Prova1.Models;

namespace Prova1.Controllers{ public class DocumentoController : Controller { public ActionResult Dettaglio()

{ istanzia l’oggetto “doc”, di classe “Documento”Documento doc = new Documento();// setto alcune delle proprietà del documento appena istanziato

doc.Codice = "124"; doc.Descrizione = "Documento di prova";

// restituisco il documento così creato alla vistareturn View(doc);

} }}

passa il l’oggetto “doc” alla View

NB: Model + View + Controller = metodo “MVC”

Ovviamente nel @Model si puo’ passare anche una lista:@Model List<Prova1.Models.Documento>

7.7) Librerie di appoggio: PURE css ed Awesome

7.7.1) Libreria PURE cssLe tabelle html hanno i seguenti svantaggi:

- devono completare il caricamento della tabella, prima di visualizzare la pagina (quindi possono rallentare i tempi di risposta)

- Non sono “Responsive Layout”, cioe’ non sanno adattarsi al dispositivo che le sta guardando (es: i-phone).

Questi problemi vengono risolti con delle combinazioni di css e Java, che si trovano, gia’testate, su librerie in internet.Vedi su google “Pure css” ==>

http://purecss.io--> 1) scaricarsi in locale il file: pure-min.css, e metterlo in .../Content/

2) aggiornare gli headers di tutte le pagine html (di solito in _Layout), come indicato sul sito. Vedi esempio di file _Layout al punto (7.3).NB: il foglio di stile di Pure va inserito prima di quello nostro personale, in modo che, in caso di conflitto, abbia il sopravvento quest’ultimo.

La lista ed istruzioni degli oggetti definiti in questa libreria si trova sul sito stesso.In particolare, sono utili:

- Buttons = Bottoni- Menu- Grid = metodi per il posizionamento degli elementi nella pagina

43

7.7.2) Font AwesomeScaricarsi il set di icone, dal sito:

fortawesome.github.io/Font-Awesome/

7.8) Direttive di Compilazione

Dentro un file cs, sono precedute dal carattere “#”.Esempio (da file Controllers/ DocumentoController.cs):#if DEBUG

ViewBag.Amministratore = true;#else

var gruppi = GruppiUtente();ViewBag.Amministratore = gruppi.Contains("Amministratori");

#endif

Se sono in debug esegue la prima parte del codice, altrimenti la seconda.

8) DATABASE4.exe

8.1) Concetti generali

Per la gestione del DB usiamo:- ms SQL Server come DB “back-end”- database4.exe come “front-end” (= DataBase Client) (compatibile con molti DB)

Sul Firewall e’ necessario aprire le porte 1433 e 1434, altrimenti il DB non si vede.

NB: il Database SQLserver NON e’ case-sensitive.

8.2) Avvio di Database4.exe

8.2.1) PasswordAlla prima connessione con il Server, chiede la password: e’ quella che era stata impostata su SQL Server.

8.2.2) ConnessioneCliccare su [Connect], e scegliere tipo e nome del DB a cui connettersi

44

8.3) Interfaccia

riquadro Struttura DB riquadro Comandi SQL

DB di Sistema: da NON toccare.Memorizzazione comandi SQL

8.3.1) Creazione di un nuovo DBDa menu: Strumenti

\ DataBase\ Crea

oppure, da riga di comando:Create Database NomeDB

\ [Execute]

8.3.2) RefreshUsare comando “Refresh” da ToolBar (F5);oppure, se sono stati aggiunti DB:

[Disconnect] e poi [Connect]

8.3.3) Nuova TabellaTastoDX su [TABLES]: Create Table

= e’ un campo Chiave= aggiunge un altro campo

45

Consente valore nullo campo auto-incrementanteNB: e’ consigliabile non usare commenti (descrizione dei campi), per evitare problemi diinterfaccia con Razor.

8.3.4) Comandi da TastoDX su una Tabella:- Open: la fa vedere- Design: rientra nella Definizione- Edit Rows: Edita le righe, consentendo aggiunte e modifiche di records;

sui campi vincolati, appare il bottone [...] che aggancia la relativa tabella.

NB: nelle righe, il comando [CTRL]-0 inserisce “Null” (elimina un valore, se c’era).

8.3.5) Generazione Script SQL, a partire dall’oggetto generato:- TastoDX su un oggetto

\ Strumenti DB\ Genera Script

oppure:\ Script as

\ Create==> genera, nel riquadro di destra, il comando SQL equivalente

8.3.6) Esportazione in Excel- TastoDX su Tabella

\ Esporta\ in Excel

8.3.7) Generazione Vincoli (Constraint) tra tabelle- TastoDX su Tabella

\ Design (Progettazione)\ Constraints

\ [+]selezionare quindi: - Foreign key

- tabella da linkare- campi collegati sulle due tabelle

NB: se questo metodo va in errore, usare il comando SQL (vedi 8.4.1)

Update e Delete RulesSe una tabella principale “A”, su un suo campo “c”, linka la chiave di una tabella “B” (cioe’ il campo “c” puo’ assumere solo valori della tabella “B”), trattandosi di un DB Relazionale, si pone il problema di cosa fare sui record di “A” quando modifico i corrispondenti valori di “C”.

46

Delete Rule= indica come deve comportarsi il sistema con i record della tabella “A”, se viene cancellato un record dalla tabella “B”:

- “Cascade” = elimino tutti i record di “A” che avevano quel valore nel campo “c”- “No Action” = blocco la cancellazione del record “B”, se presenti valori in “A”- “Set Null” = azzero il campo “c” (opzionabile solo se “c” e’ di tipo “Not Null”)

Update Rule= indica come deve comportarsi il sistema con i record della tabella “A”, se viene modificato un record dalla tabella “B”:

- “Cascade” = aggiorno allo stesso modo il campo “c” dei corrispondenti record di “A”

8.4) Comandi SQL

I comandi in linguaggio SQL si possono scrivere direttamente nel “Riquadro comandi SQL”; si eseguono in uno dei seguenti modi:

- cliccando sul [Execute] del ToolBar- premendo [CTRL] + E- premendo [F5]

Per la lista e sintassi fare riferimento ad altri manuali.Si elencano, di seguito, solo alcuni esempi:

8.4.1) Generazione Vincoli (Constraint) tra tabelleALTER TABLE ManualeDocumenti WITH CHECKADD CONSTRAINT FK_ManualeDocumenti_ManualeFamiglieDocFOREIGN KEY (Famiglia) REFERENCES ManualeFamiglieDoc(Famiglia)

8.4.2) Cancellazione di un DBDROP DATABASE IntranetAAA1

8.4.3) Estrazioni/Query e RiepiloghiSELECT [Codice],MAX([Versione]) AS VersioneMax FROM [ManualeDocumenti] GROUP BY Codice

NB: dove c’e’ un Group By, NON si puo’ usare il SELECT * ... = tutti i campi: si possono estrarre solo:

- campi di raggruppamento (“Codice”, nell’esempio)- Funzioni Aggreganti (= MAX, MIN, COUNT, ecc)

Il comando “AS” assegna un Alias a cio’ che lo precede, sia esso un campo o una tabella.Questa espressione si puo’ anche omettere: in questo caso risulta sottintesa.

8.4.4) JOIN di tabelleSELECT T1.* FROM [Tabella1] AS T1INNER JOIN (

SELECT * FROM [Tabella2] ) AS T2 ON T1.[Codice] = T2.[Codice] AND T1.[Versione] = T2.[Versione]

47

Se voglio fare un Join senza chiave (prodotto cartesiano di tutte le tabelle), posso scrivere:

SELECT * FROM [Tabella1]. [Tabella2]

Tipi di Join:- INNER JOIN: unisce solo i record corrispondenti (equivale al tipo “1” del Query400)- LEFT JOIN: unisce i record corrispondenti, e genera record con campi nulli quando

non trova corrispondenza (equivale al tipo “2” del Query400)- RIGHT JOIN: come “Left”, ma a partire dal secondo file (non c’e’ equivalenza in

Query400)- FULL OUTER JOIN: estrae almeno una riga per ogni record sia del primo che del

secondo file (non c’e’ equivalenza in Query400)

8.4.5) Creazione di una VISTACREATE VIEW NomeVistaAS ...

Esempio:CREATE VIEW ManualeDocumentiUltimaVersioneASSELECT D.* FROM [ManualeDocumenti] AS DINNER JOIN (

SELECT [Codice],MAX([Versione]) AS Versione FROM [ManualeDocumenti] GROUP BY Codice

) AS T ON D.[Codice] = T.[Codice] AND D.[Versione] = T.[Versione]

8.4.6) visualizza Ultime righe di una tabellaSELECT TOP 10 * FROM NomeTabella ORDER BY campo DESC

DESC = ordinamento Decrescente

8.4.7) Assegnazione di un valore BULEANONella versione Free di Database4.exe non e’ possibile editare i valori buleani; per farlo occorre quindi usare l’SQL:

UPDATE ManualeDocumenti SET Annullato = 1 WHERE Id = 681

8.5) Tipi di Variabili DB

Rispetto ai tipi di campo usati in C#, ci sono alcune differenze.In particolare:

8.5.1) NVarChar()sostituisce il tipo String di C#.Rispetto a VarChar(), NVarChar() e’ preferibile, in quanto utilizza caratteri Unicode, che includono tutti i simboli strani e di altre lingue.

8.5.2) BitCorrisponde al tipo “Bool” (buleano) del C#.

48

9) Interfaccia con un DATABASEIl collegamento di un progetto ASP.Net.MVC ad un DataBase, presente nell’SQL Server, avviene associando una lista di oggetti ad una tabella (file) del DB, che abbia la stessa struttura.Per farlo esistono svariati metodi: illustriamo qui quello del “Entity Framework”.

9.1) Lista Librerie

da Visual Studio, verificare che nella lista, in .../ Riferimenti/

sia presente anche la libreria “EntityFramework”.

9.2) Connection Strings

Seguire le istruzioni dal sitowww.connectionstrings.com

cliccando (specificando) poi su:SQL server (nel riquadro di sinistra) \ sotto “.NET libraries”, scegliere:

.NET Framework Data Provider for SQL Server \ poi: SQL Server 2008

da qui, copiarsi la stringa di connessione,in base alla modalita’ prescelta:

- “Standard Security” = con user/password scritti direttamente nel link- “Trusted Connection” = con autenticazione automatica tramite user/password di

Windows

scegliamo quella indicata in modalita’ “Standard Security”,che e’:

Server=myServerAddress;Database=myDataBase;User Id=myUsername; Password=myPassword;

Questa stringa di connessione va indicata dentro al file.../ Web.config

nella sezione<ConnectionString>

utilizzando la sintassi preimpostata, con:- name = nome di riferimento della connessione (da inventare)- providerName = preimpostato da Windows: lasciare quello preimpostato- Server = nomeServer\nomeServizioDB ; vedi da dentro Database4.exe:

[Connetti] \ SQL server --> indica il nomeServizioDBil nomeServer e’ quello di rete

- Database = nome assegnato ad DB (vedi Database4.exe, riquadro di sx)

49

Es:<configuration> <connectionStrings>

<add name="IntranetConnection" providerName="System.Data.SqlClient" connectionString="Server=SVRPROD01\sqlexpress2008;Database=IntranetAAA;User Id=sa;Password=pippo4;" /> </connectionStrings>...

NB: funziona meglio se si usa l’indirizzo IP (172.20.1.119), cosi’ si evitano eventuali problemi di DNS.

9.3) creare l’oggetto DBContext

TastoDX su .../Models\ Add

\ Class--> NomeClasseDB.cs

che dovra’ contenere le seguenti istruzioni:9.3.1) usare la libreria “System Data Entity”

using System.Data.Entity;

9.3.2) definire la nuova classe di tipo DBcontext, cioe’ che eredita dalla classe standard “DbContext”:

public class NomeDB : DbContext

9.3.3) definire il Costruttore del DBcontext, con la sintassi:public NomeCostruttore() : base("NomeConnessione") {}

dove:- “base” e’ una parola-chiave che richiama qualcosa della classe da cui estendo; in questo caso, il costruttore di default

- "NomeConnessione" e’ quello definito in Web.config, nella Connection String; puo’ essere omesso se e’ identico a quello della classe che stiamo definendo.

9.3.4) mappare le tabelle DB alle liste Asp.Net.MVC,associandole ad oggetti di tipo “DbSet”:

public DbSet<ClasseOggettiInLista> NomeTabellaNelDB { get; set; }NB: la definizione Asp.Net.MVC della Classe dell’oggetto in Lista, e la definizione nel DB SQL dei records della tabella, devono coincidere.

9.3.5) Esempio di DBcontext, in file DBIntranetAAA.cs :using System;using System.Collections.Generic;using System.Data.Entity;using System.Linq;using System.Web;


public class DbIntranetAAA : DbContext{

public DbIntranetAAA() : base("IntranetConnection") {}

50

// mappa la tabella documentipublic DbSet<Documento> Documenti { get; set; }

}}

9.3.6) Impostazioni del Firewall- aggiungere Apertura porta 1434 in UDP, oltre che TCP;- aggiungere Apertura porta 1433, solo in TCP;

9.4) Richiamare il DbSet nel Controller

Elenco di operazioni effettuate dal file Controller:

9.4.1) Assegnazione:var nomeVarDB = new nomeClasseDB ();

oppure, meglio:using (var nomeVarDB = new nomeClasseDB ()) {}

in questo modo, alla fine del blocco {}, quando disalloco la memoria, chiamo anche il “Distruttore”, che butta giu’ anche la connessione al DB. Cosi’ alleggerisco il lavoro del server.L’istruzione di assegnazione viene spesso utilizzata piu’ volte di seguito, una per ogni “operazione atomica” (= indivisibile) sul DB. In questo modo si distinguono le eventuali segnalazioni di errore. La velocita’ del processo non ne risente, in quanto le connessioni rimangono comunque aperte per qualche secondo dopo l’utilizzo, per cui, se nuovamente chiamate, sono gia’ disponibili.

9.4.2) Lettura di una Lista (o di un singolo Record)nomeLista = nomeVarDB.NomeTabella.ToList() ;

Il metodo standard “ToList” prende tutto quello che c’e’ nella tabella (di Classe definita nel DbContext), e lo mette nella lista (di classe congruente).

Se, invece, si vuole leggere un solo record:nomeRecord = nomeVarDB.NomeTabella.FirstOrDefault() ;

Il metodo standard “FirstOrDefault” prende il primo record che trova nella tabella (di Classe definita nel DbContext), e lo copia nella variabileRecord (di classe congruente).Prima della lettura, la tabella puo’ essere filtrata, per esempio col metodo “Where”.

Per una panoramica dei metodi possibili, vedi cap. (9.5).

9.4.3) Esempio di Controllerusing System;using System.Collections.Generic;using System.Linq;using System.Web;using System.Web.Mvc;using Prova1.Models;

namespace Prova1.Controllers{ public class LCommercialeEsteroController : Controller { public ActionResult Index()

51

{ViewBag.Titolo = "Funzione COMMERCIALE Estero";

// dichiarazioneList<Documento> anagraficaDocumenti;

// mi collego al databaseusing (var db = new DbIntranetAAA()){

// estraggo tutti i documenti e li metto nella listaanagraficaDocumenti = db.Documenti.ToList();

}// restituisco la lista dei documentireturn View(anagraficaDocumenti);

} }}

9.4.4) Esempio di View@using Prova1.Models@model List<Documento>@{ ViewBag.Title = "Index";

Layout = "~/Views/Shared/_Layout.cshtml";}

@foreach (var doc in Model) { <p><a class="lkd" target="_blank" href="@doc.Percorso">@doc.Descrizione</a></p> }

<p><a target="_blank" class="lkd" href="file:///n:/Grulav/FATT.xls">Sconto Medio</a> </p>

dove il ciclo “for” puo’ essere scritto anche in un altro modo:@for (var i = 0; i < Model.Count; i++){<p><a class="lkd" target="_blank" href="@Model[i].Percorso">@Model[i].Descrizione</a></p>}

9.5) METODI standard: parametri per Query-String ed altri

Nel Controller posso usare Metodi della Classe “DbSet” e/o delle Liste generiche, che miconsentono di processare i dati in ingresso, costruendo ed eseguendo direttamente dellequery SQL.Seguono alcuni esempi:

9.5.1) metodo TOLIST: lettura di una Lista da tabella DBnomeLista = nomeVarDB.NomeTabella.ToList() ;

Il metodo standard “ToList” prende tutto quello che c’e’ nella tabella (di Classe definita nel DbContext), e lo mette nella lista (di classe congruente).

9.5.2) metodo FIRSTorDEFAULT: lettura di un singolo RecordnomeRecord = nomeVarDB.NomeTabella.FirstOrDefault() ;

Il metodo standard “FirstOrDefault” prende il primo record che trova nella tabella (di Classe definita nel DbContext), e lo copia nella variabileRecord (di classe congruente).Questo metodo ha due varianti:

52

.First : se non trovo nulla va in errore

.FirstOrDefault : se non trovo nulla prende il default (= Null)

9.5.3) Metodo WHEREPrima della lettura, la tabella puo’ essere filtrata, col metodo “Where”.Esempio 1:

using (var db = new DBIntranetAAA()){

tipo = db.TipiDoc.Where(x => x.Tipo == id).FirstOrDefault();

}

Esempio 2, inglobando il “.Where” nel “.First”:using (var db = new DBIntranetAAA()){

tipo = db.TipiDoc.FirstOrDefault(x => x.Tipo == id);}

Esempio3 (file .../ Controllers/ C03FiloniController.cs):using System;using System.Collections.Generic;using System.Linq;using System.Web;using System.Web.Mvc;using Manuale.Models;

namespace Manuale.Controllers{ public class C03FiloniController : Controller { public ActionResult Index() { ViewBag.Titolo = "Filoni ";

List<Documento> anagraficaDocumenti; dichiarazione

var tipi = new string[] {"D", "I", "P"}; definisco un array costante using (var db = new DBIntranetAAA()) mi collego al database {

anagraficaDocumenti = db.ManualeDocumenti lettura DB.Where(d => tipi.Contains(d.Tipo))

.ToList(); utilizzando l’array }

return View(anagraficaDocumenti); restituisco la lista letta } }}

Notare l’uso della variabile “d”: e’ una variabile locale, che identifica la generica riga della tabella; il nome puo’ essere scelto a piacere (spesso si usa “e”= “elemento”).Equivale alla variabile “x” in una definizione di funzione f(x).

L’argomento del metodo Where:.Where(d => tipi.Contains(d.Tipo))

per evitare di dover dichiarare la stringa costante:var tipi = new string[] {"D", "I", "P"};

53

poteva essere scritto anche per esteso:.Where(d => d.Tipo == "D" || d.Tipo == "I" || d.Tipo == "P")

Notare la sintassi (vedi 5.1):|| = OR&& = AND== = Equal=> = Tale per cui (Appartiene ad insieme di seguito definito)

9.5.4) Metodo SELECTConsente di prendere un solo CAMPO di una tabella, ottenendo un vettore o un valore singolo.Esempio1:a = db.GruppiUtenti

.Where(e => e.Utente == ut)

.Select(e => e.Gruppo)

.ToList();

“a” e’ un vettore, che legge il campo “Gruppo” della tabella “GruppiUtenti”; (in piu’ fa un filtro sul campo “Utente”).

Esempio2:a = db.GruppiUtenti

.Where(e => e.Utente == ut)


.FirstOrDefault();

“a” e’ una variabile, che legge il campo “Gruppo” della tabella “GruppiUtenti”; (prendeil primo record che soddisfa una condizione sul campo “Utente”).

9.5.5) metodo ORDER BYModifica l’ordinamento con cui caricare la lista.Esempio:

tipi = db.TipiDoc.OrderBy(t => t.Sequenza).ToList();

9.5.6) metodo CONTAINSConferma se un dato valore e’ presente.Esempio:

anagraficaDocumenti = db.ManualeDocumenti.Where(d => tipi.Contains(d.Tipo)).ToList();

9.5.7) Altri metodi di interrogazione LINQ (lettura DB)Altri metodi ereditari per la lettura di Tabelle DB sono:

.Max : prende il record a valore massimo (su un dato campo)

.Min : prende il record a valore minimo (su un dato campo)

.Take : prende un numero predefinito di record: serve per paginare, senza dover ricaricare la tabella

.Any : verifica se un dato valore e’ presente

Esempio:

54

DateTime DataUltimoAgg;using (var db = new DBIntranetAAA()){

DataUltimoAgg = db.Documenti.Max(e => e.DataAggiornam);}

La Lista di tutti i Metodi ereditari delle Tabelle si puo’ trovare, su internet:code.msdn.microsoft.com/101-LINQ-Samples-3fb9811b

9.6) Generazione Automatica del DB

Al momento del Debug, se il Progetto punta su un DB che non esiste, per default se lo crea (vuoto) automaticamente.In questo caso, MVC-C# si aspetta di trovare sempre un DB che coincida esattamente in ogni dettaglio con quello da lui definito, e va in errore se trova tabelle in piu’, che lui non usa.

Per evitare che questo avvenga, occorre inserire, nel Modello del DB, nel Costruttore della Classe DB, la seguente direttiva:

Database.SetInitializer<DBIntranetAAA>(null);

Si usa quando il database e’ stato creato precedentemente (a mano).In questo modo si evitano messaggi di errore se nel DB si trovano anche files (tabelle) usati solo da altri progetti; sono tollerati anche files con campi in piu’, rispetto a quelli dichiarati in MVC-C#.

Esempio: file .../ Models/ DBIntranetAAA.csusing System;using System.Collections.Generic;using System.Data.Entity;using System.Linq;using System.Web;

namespace Manuale.Models{ public class DBIntranetAAA : DbContext

{public DBIntranetAAA() : base("IntranetConnection")

{Database.SetInitializer<DBIntranetAAA>(null); } // Tabelle prese da DB public DbSet<Documento> ManualeDocumenti { get; set; }

public DbSet<TipoDoc> ManualeTipiDoc { get; set; }public DbSet<FamigliaDoc> ManualeFamiglieDoc { get; set; }

}}

55

10) INPUT – interfaccia UtenteFin’ora abbiamo visto solo processi unidirezionali server --> client, in cui l’utente puo’ solo indirizzare su un URL, specificando, al piu’, un parametro (id).Vedi cap.(1.11), es:

localhost:4280/Documento/Elenco/QVediamo ora come fare per acquisire piu’ di un parametro.

Esistono due metodi fondamentali:1) FORMs html (interfaccia gestita da una pagina, e resa su un’altra pagina)

a loro volta suddivise in: metodo GETmetodo POST

2) Chiamate AJAX (l’imput viene passato al controller, senza cambiare pagina)

10.1) FORMs

L’interfaccia utente e’ gestita, sulla view, con l’istruzione html <form>.Una volta che la form (view) ha acquisito i dati, per passarli al controller esistono due metodi:

- metodo GET = scrivo l’output nell’URL, tramite Query String- metodo POST = restituisco i parametri sulla stessa pagina

corrispondenti, nel controller, alle specifiche:-[HttpGet] (= default)-[HttpPost].

10.1.1) Sintassi delle Forms HTMLLe forms, nel linguaggio html, sono definite dai tag:

<form ...><input ...>

</form>

Come riferimento, vedi sito: www.w3schools.com/html/html_forms.asp(oltre al solito “pure-css”)

L’URL di destinazione (del Controller) viene passato tramite il parametro “action” dell’istruzione <form>. Esempio:

<form action="~/....." method="get"> First name: <input type="text" name="fname"><br> <input type="submit" value="Submit"></form>

Se si omette l’istruzione “Action”, si ridirige allo stesso indirizzo.

10.1.1.1) Parametri dell’istruzione “input”:type = tipo di variabile da leggere:

- “password” = come “string”, ma non si vede cosa si scrive- “submit” = definisce un “submit button” = tasto “invio”

56

- “text area” = area di testo, su piu’ righe- “input file” = permette di fare un upload- “hidden” = campo nascosto, che non viene visualizzato, ma viene comunque

postato sull’output

id = ... := identificazione della variabile, ai fini di JSvalue = ... := variabile corrispondente, da leggere/scriverename = ... := riferimento che verra’ passato di ritorno al controller [Post]class = ... := classe cssreadonly="readonly" := dichiara il campo in sola lettura

10.1.2) Input in modalita’ GET (e Query String)Il passaggio di parametri in QueryString consiste nello specificare nell’URL, dopo l’indirizzo, il segno “?”, seguito dalla lista di parametro=valore, separati dal simbolo “&”. Non vanno lasciati spazi bianchi (se serve, vanno sostituiti da “%20”).Tutti i parametri sono trattati come stringhe.Questo sistema permette di passare piu’ parametri, e di usare nomi diversi da “id”.Esempio:

localhost:4280/Documento/Elenco/Q?pippo=50&pluto=1&topolino=ciao%20ragazzi

La form tipo “Get” postera’ automaticamente in output /QueryString i parametri letti.

10.1.2.1) Pagine cshtml con metodo “Get”La modalita’ “Get” e’ identificata sulla view tramite il parametro “method” del tag “form”; es:

<form ... method="GET">

10.1.2.2) Metodo “Get” nel ControllerIl Metodo Get del Controller assegna i valori iniziali dei campi della form; e’ identificato dalla specifica [HttpGet]: [HttpGet] public ActionResult Modifica(int id, string cod, string desc)(specifica che puo’ essere omessa, in quanto default).Nella pagina di destinazione, le variabili tipo “int?” possono essere lette con il metodo “.value”;es:

x = nome.value;

Esempio: richiamo della pagina, da file Elenco.cshtml:<div class="BottoneNuovoDocumento">

<a href="~/Documento/NuovoDocumento/[email protected]" class="pure-button bottone-D">Nuovo Documento (Tipo @ViewBag.TipoDocumenti )</a></div>

Lettura, da Controller sulla pagina di destinazione: public ActionResult NuovoDocumento(string tipo) { var doc = new Documento(); doc.Tipo = tipo;

...

57

10.1.2.3) Esempio esteso (da ProgrammaCarico):OperazioneController.cs intero nullabileusing System;using System.Collections.Generic;using System.Linq;using System.Web;using System.Web.Mvc;using ProgrammaCarico.Models;using System.IO;

namespace ProgrammaCarico.Controllers{

public class OperazioneController : BaseController{

// [HttpGet]public ActionResult Selezione(int? idCaricoDaRicercare){

var modello = new Carico();if (idCaricoDaRicercare != null){

modello.IdCarico = idCaricoDaRicercare.Value;// cerca il Carico sul databaseusing (var db = new DbAS400()){

modello = db.Carichi.FirstOrDefault(e => e.IdCarico == idCaricoDaRicercare.Value);

}}string titoloVB;titoloVB = GeneraTitoloSelezioneCarico(modello, idCaricoDaRicercare);ViewBag.Titolo = titoloVB;return View(modello);

}}

}

Selezione.cshtml@using ProgrammaCarico.Models;@model Carico@{

Layout = "~/Views/Shared/_LayoutCar.cshtml";}<form class="pure-form pure-form-aligned" method="GET">

<fieldset><div class="pure-control-group">

<label for="IdCarico">Carico:</label><input id="IdCarico" name="IdCaricoDaRicercare" type="number"

value="@Model.IdCarico"/></div><div class="pure-control-group">

<label for="Nazionalita">Nazionalita': </label><input id="Nazionalita" name="Nazionalita" type="text"

value="@Model.Nazionalita" readonly="readonly"/></div><div class="pure-controls">

<input type="submit" class="pure-button" value="Aggiorna"/><a href="~/Operazione/Selezione/@Model.IdCarico"

class="pure-button">OK</a></div>

</fieldset></form>

58

costruisce automaticamente la Querystring

10.1.3) Input tramite Pagine in Modalita’ POSTLa Form html e’ di tipo:

<form action="~/....." method="post">Sul controller, ci sono due metodi che hanno lo stesso nome, ma parametri diversi: il primo di tipo[HttpGet], il secondo [HttpPost].

10.1.3.1) Pagine cshtml utilizzabili in “Post”La modalita’ “Post” e’ identificata sulla view tramite il parametro “method” del tag “form”; es:

<form class="pure-form pure-form-aligned" method="POST">

10.1.3.2) Intestazione del Metodo nel ControllerIl Metodo Post del Controller dichiara le variabili in input allo stesso modo in cui il Metodo Get dichiara quelle in output (campi pre-compilati): [HttpPost] public ActionResult Modifica(int id, string cod, string desc)

Notare che tutte le variabili dichiarate in [Post] devono essere valorizzate nel Form html; in caso contrario (cioe’, per esempio, se sono impostate “Readonly”) assumerannoil valore Null.E’ quindi opportuno, nel Controller, verificare che non siano Null (con degli “if”) prima di utilizzarle.

10.1.3.3) Gestione variabili nel “Post”Nella parte [Post] del controller, gestisco i campi del database come una normale variabile in i/o.

Per cancellare un record, uso il metodo “.Remove”; esempio:db.Documenti.Remove(model.Documento);

Alla fine salvo le modifiche sul DB, con il comandodb.SaveChanges();

(ovviamente all’interno dello “using db...”).Notare che, se ho creato un record nuovo, e’ in questo momento che vengono valorizzati(dal DB) i campi auto-incrementanti. Variabili lette prima di questa istruzione riporteranno valore null... a meno che non siano puntatori allo stesso DB, che rimangonoquindi aggiornati.

10.1.3.4) istruzione finale del Metodo [Post]Sul Controller, il blocco di codice relativo al metodo [Post] si chiude normalmente, con:

return View(model);oppure, reindirizzando su un’altra pagina:

return Redirect("~/Documento/Elenco/" + model.Documento.Tipo);Notare che, sul Metodo [Get], un reindirizzamento sarebbe incongruente.

10.1.4) EsempioPagina Views/ Documento/ Modifica.cshtml@using Manuale.Models;@model ModificaDocumentoModel

59

@{ Layout = "~/Views/Shared/_Layout.cshtml";}<form class="pure-form pure-form-aligned" method="POST">

<fieldset><div class="pure-control-group">

<label for="DataAggiornam">Data Agg.</label><input id="DataAggiornam" type="text" value

="@Model.Documento.DataAggiornam.ToString("dd/MM/yyyy")"readonly="readonly"/>

</div><div class="pure-control-group">

<label for="Descrizione">Descrizione</label><input id="Descrizione" name="Descrizione" class="pure-input-2-3"

type="text" value="@Model.Documento.Descrizione"/></div>

...Seguono gli altri campi della classe Documento (...).

<div class="pure-control-group"><label for="Famiglia">Famiglia</label>

<select name="Famiglia"> Menu a tendina@foreach (var f in Model.ElencoFamiglie){

if (Model.Documento.Famiglia == f.Famiglia){

<option value="@f.Famiglia" selected="selected">@f.Descrizione</option>

}else{

<option value="@f.Famiglia">@f.Descrizione</option>}

}</select>

</div><div class="pure-controls">

<input type="submit" class="pure-button pure-button-primary"value="Aggiorna"/>

<a href="~/Documento/NuovaVersione/@Model.Documento.Id" class="pure-button">Nuova Versione</a>

</div></fieldset>

</form>

Chiamata dal Controller: Controller/ DocumentoController.csusing (...)namespace Manuale.Controllers{

public class DocumentoController : BaseController{

public ActionResult Elenco(string id){

(...) ... controllo della vista “Elenco(id)”return View(anagraficaDocumenti);

}

[HttpGet]public ActionResult Modifica(int id){

CreaMenuSx();var model = new ModificaDocumentoModel();

60

// apre il databaseusing (var db = new DBIntranetAAA()){

// carica il documento con il codicemodel.Documento = db.Documenti.FirstOrDefault(e => e.Id == id);// carica l'elenco delle famigliemodel.ElencoFamiglie = db.FamiglieDoc.OrderBy(e =>

e.Famiglia).ToList();}

(...) scrive il ViewBag.Titolo, verificando che non sia vuoto (vedi 10.2.2)return View(model);

}

[HttpPost]public ActionResult Modifica(int id, string descrizione, string famiglia){

CreaMenuSx();var model = new ModificaDocumentoModel();using (var db = new DBIntranetAAA()){

// carica il documento con il codicemodel.Documento = db.Documenti.FirstOrDefault(e => e.Id == id);// aggiorno il documentoif (model.Documento != null){

// se avvessi voluto cancellarlo://db.Documenti.Remove(model.Documento);model.Documento.Descrizione = descrizione;model.Documento.Famiglia = famiglia;//model.Documento.DataAggiornam = DateTime.Today;db.SaveChanges();

}// carica l'elenco delle famigliemodel.ElencoFamiglie = db.FamiglieDoc.OrderBy(e =>

e.Famiglia).ToList();}

(...) scrive il ViewBag.Titolo, verificando che non sia vuoto (vedi 10.2.2)return View(model);

}

public ActionResult NuovaVersione(int id){

var model = new ModificaDocumentoModel();// apre il databaseusing (var db = new DBIntranetAAA()){

// carica il vecchio documento con il codicevar oldDoc = db.Documenti.FirstOrDefault(e => e.Id == id);// crea il nuovo documentovar doc = new Documento();doc.Versione = oldDoc.Versione + 1;doc.Codice = oldDoc.Codice;doc.DataAggiornam = DateTime.Now;doc.Descrizione = oldDoc.Descrizione;doc.Famiglia = oldDoc.Famiglia;doc.Tipo = oldDoc.Tipo;// aggiungo il nuovo documento alla tabelladb.Documenti.Add(doc);

model.Documento = doc; NB: model.Documento.Id si valorizzera’ solo con la riga successiva

// salvodb.SaveChanges();

61

}return Redirect("/Documento/Modifica/" + model.Documento.Id);

}}

}

Notare il Metodo “NuovaVersione”, che non ha Viste dedicate: esegue solo delle operazioni (inizializza un nuovo record sulla tabella “documenti”), per poi reindirizzare sulla Vista “Modifica” (controllata dal metodo “Modifica”), tramite il comando

return Redirect(...);

10.1.5) input TextAreaIn una View, all’interno di una Form, tra i vari input:<form class="pure-form pure-form-aligned" method="POST"> <fieldset>

<div class="pure-control-group"> <label for="Tipo">Tipo</label> <input id="Tipo" type="text" value="@Model.Doc.Tipo"

readonly="readonly"/></div>...

si puo’ aggiungere un input di testo su piu’ righe:<div class="pure-control-group"> <label for="Motivazione">Motivazione</label>

<textarea rows="4" cols="150" name="Motivi">"@Model.Doc.Mot"</textarea>

</div>

10.1.6) input CheckBoxAltro tipo di input e’ il CheckBox, usato per valori booleani.Questo tag si contraddistingue per il parametro “Checked” che, se “spuntato” restituisce al Controller il valore del “value”.E’ pensato per gestire una lista di opzioni diverse, corrispondenti a valori diversi che potrebbero essere contemporaneamente validi (es: nazioni che hai visitato=?).

Esempio, su html:<div class="pure-control-group">

<label for="Annullato">Doc. Annullato:</label>@if (Model.Documento.Annullato){

<input id="Annullato" name="Annullato" type="checkbox" value="si" checked="checked"/>

}else{

<input id="Annullato" name="Annullato" type="checkbox" value="si"/>}

</div>

Se lo trovo true, lo pre-imposto “baffato”, altrimenti no.Poi, l’utente della pagina, potra’ modificarlo con un click, ed il valore finale sara’ quelloimpostato da lui.Sul Controller [Post], avendo specificato il value=”si” scrivero’:

if (annullato == "si")model.Documento.Annullato = true;

elsemodel.Documento.Annullato = false;

62

o, piu’ elegantemente:model.Documento.Annullato = (annullato == "si");

(Rif. su internet: cercare: “MVC binding to checkbox”)

10.2) Chiamate AJAX

La tecnica AJAX (=Asynchronous JavaScript and XML) è un metodo per realizzare applicazioni web interattive. Per “Asincrono” si intende che i dati vengono scambiati in background fra web browser e server (view e controller), consentendo l'aggiornamento dinamico di una pagina web senza doverla ricaricare.Il Controller risponde con testi XML o JSON.Il sistema si basa su linguaggio JavaScript.

11) Soluzioni tipoDi seguito alcuni esempi su come realizzare alcune specifiche tipiche.

11.1) Estrazione Selettiva da DB, in base ad un parametro Calcolato

Esempio: estrarre dal DB, tabella “ManDocumenti” (che include i campi “Codice”, “Versione”), la tabella C# “Documenti”, visualizzando solo le ultime “Versioni” per ogni di ogni “Codice”.

11.1.1) Vista LogicaNel DB, creare una Vista Logica (“ManDocumentiUltimaVersione”) che effettui il filtro voluto.Con comando SQL:

CREATE VIEW ManDocumentiUltimaVersione (c)ASSELECT D.* FROM [ManualeDocumenti] AS D (b)INNER JOIN (

SELECT [Codice],MAX([Versione]) AS Versione FROM [ManualeDocumenti] (a)GROUP BY Codice

) AS T ON D.[Codice] = T.[Codice] AND D.[Versione] = T.[Versione]a) Riepilogo il file per Codice, leggendo la Versione Maxb) Combino (Join) il file riepilogato con quello originale, per estrarre il record

corrispondente all’ultima versionec) Genero una Vista sul file cosi’ costruito.

11.1.2) Lettura della VistaDa C#, invece di “ManDocumenti”, aggancio la sua Vista “ManDocumentiUltimaVersione”.Sara’ necessario generare anche un apposito Modello per i records della Vista, sia per poter indirizzare la tabella da leggere (con l’istruzione [Table(...)] nel Modello), sia perche’, a priori, la vista potrebbe avere una struttura diversa dal file origine: public DbSet<DocumentoUltimaVersione> DocumentiUltimeVersioni { get; set; }

63

11.2) Menu Dinamico

Costruzione di un Menu che abbia una voce per ogni elemento di una data tabella DB.

Esempio dal sito “Manuale Qualita”:

11.2.1) ~/ Models/ DBIntranetAAA.csSul Modello di Database, definisco anche la lettura della Vista Logica che contiene solo le ultime versioni dei documenti:using System;using System.Collections.Generic;using System.Data.Entity;using System.Linq;using System.Web;

namespace Manuale.Models{ public class DBIntranetAAA : DbContext {

public DBIntranetAAA() : base("IntranetConnection"){ Database.SetInitializer<DBIntranetAAA>(null); }

// Tabelle prese da DBpublic DbSet<Documento> Documenti { get; set; }public DbSet<TipoDoc> TipiDoc { get; set; }public DbSet<FamigliaDoc> FamiglieDoc { get; set; }

// Viste prese dal DBpublic DbSet<DocumentoUltimaVersione> DocumentiUltimeVersioni {get;set;}

}}

11.2.2) ~/ Controllers/ DocumentoController.cs Faccio un controller “Documento”, che gestira’ la manipolazione delle pagine, dove:

a) Uso il Modello di Vista “Elenco”, invece di “Index”, che ha il parametro “id” di tipo string (NB: il nome “id” e’ OBBLIGATORIO)

b) Leggo, sul DB, la Vista Logica “UltimaVersione” della tabella “Documenti”c) Definisco la variabile “tipi” come lista di TipoDoc, e ci copio dentro la tabella

db.TipiDoc, letta dal DB (Tabella “ManualeTipiDoc”)

using System;using System.Collections.Generic;using System.Linq;using System.Web;using System.Web.Mvc;using Manuale.Models;

namespace Manuale.Controllers{

public class DocumentoController : Controller{

public ActionResult Elenco(string id) (a){

// dichiarazione

List<DocumentoUltimaVersione> anagraficaDocumenti; (b)TipoDoc tipo;List<RigaMenu> menus = new List<RigaMenu>();

64

List<TipoDoc> tipi; (c)

// crea menu (da passare alla vista, tramite ViewBag)// mi collego al databaseusing (var db = new DBIntranetAAA()){

tipi = db.TipiDoc.OrderBy(t => t.Sequenza).ToList(); (c)foreach (var t in tipi) (d){

var rMenu = new RigaMenu();

rMenu.Link = "Documento/Elenco/" + t.Tipo; (d)rMenu.Descrizione = t.Descrizione;menus.Add(rMenu);

}}

ViewBag.ElencoMenu = menus; (e)

// crea titolo della pagina (da passare alla vista, tramite ViewBag)using (var db = new DBIntranetAAA()){

// vado a cercare il tipo documento nella tabella del database

tipo = db.TipiDoc (f).Where(x => x.Tipo == id).FirstOrDefault();

if (tipo != null) (g){

ViewBag.Titolo = tipo.Descrizione;}else{

ViewBag.Titolo = "Errore - '" + id + "' classe errata";}

// estraggo tutti i documenti e li metto nella lista

anagraficaDocumenti = db.DocumentiUltimeVersioni (h).Where(d => d.Tipo == id).ToList();

}// restituisco la lista dei documenti

return View(anagraficaDocumenti); (j) } }}

d) A partire dalla lista “tipi”, costruisco la lista “menus” (dichiarata in intestazione),costruendo opportunamente le singole righe (variabile rMenu)

e) Copio la lista “menus” appena creata nel ViewBagf) Leggo nella variabile “tipo”, il primo (.FirstOrDefault) record corrispondente,

che aggancio per “id” (= parametro passato nel Link) nella tabella “db.TipiDoc”.g) Se ho letto qualcosa, lo scrivo nel titolo (in ViewBag); altrimenti gestisco l’erroreh) leggo la lista “anagraficaDocumenti”, limitatamente a quelli corrispondenti per

“id”j) Apro la pagina web, passandogli il parametro

11.2.3) ~/ Models / RigaMenu.cs Definisco una nuova classe di variabili, per le righe di menu:

65

using System;using System.Collections.Generic;using System.Linq;using System.Web;

namespace Manuale.Models{

public class RigaMenu{

public string Link { get; set; }public string Descrizione { get; set; }

}}

11.2.4) ~/ Views/ Documento/ Elenco.cshtmlDefinisco la View “Elenco”, che riceve come parametro la lista di documenti da elencare(passata dal controller “DocumentoController”):@using Manuale.Models@model List<DocumentoUltimaVersione>@{ Layout = "~/Views/Shared/_Layout.cshtml";}<table class="pure-table">

<thead> <-- Intestazione della Tabella<tr>

<th>Documento</th><th>Versione</th><th>Data Agg.</th>

</tr></thead>

<tbody> <-- Corpo della Tabella@foreach (var doc in Model){

<tr><td><a class="lkd" target="_blank"

ref="@doc.Percorso">@doc.Descrizione</a></td><td>@doc.Versione</td><td>@doc.DataAggiornam</td>

</tr>}</tbody>

</table>

66

11.2.5) ~/ Views/ Shared/ _Layout.cshtmlIl Layout scrive il menu letto nel ViewBag.ElencoMenu (che e’ una Lista):<!DOCTYPE html><html>

<head><title>Intranet Azienda - @ViewBag.Titolo</title><meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1"><meta name="viewport" content="width=device-width, initial-scale=1"><link rel="stylesheet" href="~/Content/pure-min.css"><link rel="stylesheet" type="text/css" href="~/Content/FoglioStile-Man.css">

</head>

<body><div class="boxS">

<div>

<img class="logo" src="~/Content/immagini/logo_c.gif" alt="OTL"><img class="logo_Q" src="~/Content/immagini/SGS.gif" alt="SGS">

</div>

<p> <a class="pure-button bottone-A" href="~/Home/Index">Home</a></p><br />@if (ViewBag.ElencoMenu != null){

foreach (Manuale.Models.RigaMenu menu in ViewBag.ElencoMenu){

<p><a class="pure-button bottone-A" href="~/@menu.Link">@menu.Descrizione</a></p>

}}<p> <a class="pure-button bottone-A" href="~/Percorso">Norme </a> </p>

<br /><p> <a class="pure-button bottone-B"

href="mailto:[email protected]">e-mail</a> </p><p> <a class="pure-button bottone-B"

href="http://www.azienda.it" target="_blank">OTL</a> </p> <p>@DateTime.Now</p>

</div>

<div class="Titolo">

<h1>@ViewBag.Titolo</h1></div><div class="boxD">

@RenderBody()</div>

</body></html>

67

11.2.6) ~/ Controllers/ HomeController.csAdeguo anche il Controller “Home” alla costruzione e passaggio righe del menu al nuovo _Layout, analogamente a quanto appena fatto in DocumentoController:using System;using System.Collections.Generic;using System.Linq;using System.Web;using System.Web.Mvc;using Manuale.Models;

namespace Manuale.Controllers{ public class HomeController : Controller { public ActionResult Index() { ViewBag.Titolo = "Home Page - Manuale Qualita' ";

List<RigaMenu> menus = new List<RigaMenu>(); List<TipoDoc> tipi;


tipi = db.TipiDoc.OrderBy(t => t.Sequenza).ToList();foreach (var t in tipi){

var rMenu = new RigaMenu(); rMenu.Link = "Documento/Elenco/" + t.Tipo; rMenu.Descrizione = t.Descrizione; menus.Add(rMenu);

}}

ViewBag.ElencoMenu = menus; return View(); } }}

11.3) Utilizzo di METODI (=Procedure) e PROPRIETA’

Ogni volta che una stessa sequenza di codice viene ripetuta in controllers diversi, e’ opportuno sostituirla con un Metodo (sinonimi: subroutine, procedura). In questo modo evito complicazioni in caso di modifica del codice.

11.3.1) Dove scrivere il Metodo ?In linea di principio, un metodo puo’ essere definito in una qualunque classe di oggetti, definita in un qualunque file *.cs. Per richiamarlo bastera’ dichiarare una variabile “v” di quella classe

var v = new ClasseOgg();oppure

using(var v = new ClasseOgg()) { ... }; se ClasseOgg e’ di tipo “IDisposable” (per es. un Controller)

, e poi usare il suo metodo:v.metodo();

68

Il posto migliore dove metterlo, pero’, e’ la Classe Padre del mio Controller: in questo modo il metodo verra’ automaticamente Ereditato, e sara’ quindi richiamabile direttamente.Non posso, pero’, modificare la classe “Controller”, che e’ uno standard: creo allora un controller-tipo personale, che eredita da Controller, e da cui faro’ ereditare tutti i miei Controller operativi (o quelli in cui mi serve).

11.3.2) Esempio:inclusione delle istruzioni di costruzione del menu principale, ripetute in HomeController e DocumentoController, in un metodo CreaMenuSx(), del Controller-tipo BaseController:

Controllers/ BaseController.cs :using System.Collections.Generic;using System.Linq;using System.Web.Mvc;using Manuale.Models;

namespace Manuale.Controllers{

public class BaseController : Controller <-- Eredita da Controller{

// Questo metodo serve a generare il menu leggendo i tipiDoc dalla tab.public void CreaMenuSx() <-- definisco il metodo CreaMenu{

List<RigaMenu> menus = new List<RigaMenu>();List<TipoDoc> tipi;using (var db = new DBIntranetAAA()){

tipi = db.TipiDoc.OrderBy(t => t.Sequenza).ToList();foreach (var t in tipi){

var rMenu = new RigaMenu();rMenu.Link = "Documento/Elenco/" + t.Tipo;rMenu.Descrizione = t.Descrizione;menus.Add(rMenu);

}}ViewBag.ElencoMenu = menus; <-- che scrive direttamente nel ViewBag

} (infatti e’ di tipo void = senza output)

public string UtenteLoggato <-- definisco la Proprieta’ UtenteLoggato{

get{

return HttpContext.User.Identity.Name;}

69

}

public List<string> GruppiUtente() <-- definisco il metodo GruppiUtente{ (che ha in output una lista di stringhe)

var utente = UtenteLoggato;// controllo che l'utente ci siaif (utente == null) return new List<string>();


return db.GruppiUtenti

.Where(e => e.Utente == utente)


.ToList();}

} }

}

I controllers che lo useranno includeranno, per esempio, le seguenti istruzioni: public class HomeController : BaseController

CreaMenuSx();ViewBag.Gruppi = GruppiUtente();

11.4) Stampa pagina

La stampa di una pagina web e’ controllata dal browser, e si attiva, oltre che da menu, con il comando standard [CTRL]+P.La stampante, e quindi, in particolare, la stampa su PDF, non e’ controllabile dal sw sul server, e va selezionata manualmente.

Quello che si puo’ fare e’ mettere un bottone “Stampa”, che apre l’interfaccia sul browser:<p> <a class="pure-button bottone-B" onclick="window.print();">Stampa</a></p>

comando html comando JavaScript(esempio tratto da: _Layout.cshtml)

Nella pagina da stampare e’ spesso opportunno escludere alcuni elementi; a questo scopo si utilizzano degli stili variabili a seconda del “media” (video o stampante).Per esempio, se voglio evitare di stampare gli elementi in stile “BoxS”, aggiungero’, nel mio foglio di stile:

@media print {.boxD {left: 0; height: 100%;overflow: hidden;}

}(da: FoglioStile-Man.css)

70

11.5) Verifica Esistenza Files

Si utilizza il metodo “File.Exists()” dell’oggetto “System.IO”, definito nella DLL “System” (caricata per default).

Poiche’ esiste gia’ un metodo “File” anche per l’oggetto “Controller”, anche se ho scritto “using System.IO” in intestazione, devo comunque rispecificare il nome completo del metodo:

System.IO.File.Exists(percorsoFile)

L’argomento del metodo e’ la Path del file, espressa con le regole del sistema operativo in uso (quindi, per Windows, va usata la “\” invece di “/”, e l’indirizzo a partire dal nome del disco, es: C:\...).Per convertire la URL in Path si usa il metodo “Server.MapPath()”.

Quindi, per esempio (da /Controllers/DocumentoController.cs - Elenco): var percorsoFile = Server.MapPath("~/" + rv.PercorsoCompleto); rv.EsisteFile = System.IO.File.Exists(percorsoFile);

Notare che, in C#, il carattere “\” (“slash”) rappresenta un [esc]; quindi, per scrivere “slash”, devo scrivere “\\”.

11.6) UpLoad Files

11.6.1) Lato Client = htmlSi usa una Form con Input di tipo “File”.Questo comando mostra sulla pagina un bottone “Scegli File”, che consente di sfogliare le proprie cartelle, e selezionare il file; evidenzia poi il file selezionato.Quando clicco “Aggiorna”, mi invia al Controller anche il file selezionato (che e’ una stringa di caratteri).

Nell’intestazione della Form, dopo la specifica [Post], va aggiunta laenctype="multipart/form-data"

che avverte il server che il post sara’ molto corposo.

esempio (tratto da Views/Documento/Modifica.cshtml):<form class="pippo" method="POST" enctype="multipart/form-data"> <fieldset>

<div class="pure-control-group"> <label for="Descrizione">Descrizione</label> <input id="Descrizione" name="Descrizione" type="text"

value="@Model.Docu.Descrizione"/></div><div class="pure-control-group"> <label for="Percorso">Nome File</label> <input id="Percorso" class="pure-input-1-3" type="text"

value="@Model.Docu.Percorso" readonly="readonly"/> <input type="file" class="pure-input-1-3" name="FileDaCaricare" /></div><div class="pure-controls">

71

<input type="submit" class="pluto" value="Aggiorna"/> <a href="~/Documento/NuovaV/@Model.Docu.Id" class="paper">Nuova</a></div>

</fieldset></form>

11.6.2) Lato Server = ControllerIl File letto dalla pagina http va poi gestito (salvato su disco) nel Metodo “Post” del Controller, come di seguito indicato.

La variabile File in input va definita di tipo “HttpPostedFileBase”

Il File va salvato con il comando fileDaCaricare.SaveAs(percorsoFile);

dove “percorsoFile” e’ la Path completa, incluso il nome del file.Viene costruita utilizzando i seguenti comandi: - Path.GetFileName(file);

legge il nome del file (usato per il file in upload) - Path.Combine(folderName, fileName);

costruisce una Path, partendo da directory e nomeFile - Server.MapPath("~/cartella/sottocartella/")

estrae la Path completa di una cartella.

NB: i comandi “Path.” e “Server.” appartengono all’oggetto “System.IO”, che va quindi indicato in intestazione (using System.IO), o specificato davanti ad ogni comando.

Ricordarsi di verificare che l’utente IIS abbia l’autorizzazione in scrittura sulla directory di destinazione.

Esempio (tratto da /Controller/DocumentoController.cs):[HttpPost]public ActionResult Modifica(int id, string codice, string descrizione, string famiglia, string motivazione, string annullato, HttpPostedFileBase fileDaCaricare){ var model = new ModificaDocumentoModel(); using (var db = new DBIntranetAAA()) {

// carica il documento con il codicemodel.Documento = db.Documenti.FirstOrDefault(e => e.Id == id);// aggiorno il documentoif (model.Documento != null){

if (model.Documento.Codice == "-" && !string.IsNullOrEmpty(codice))model.Documento.Codice = codice;

model.Documento.Descrizione = descrizione;model.Documento.Famiglia = famiglia;model.Documento.Motivazione = motivazione;model.Documento.Annullato = (annullato == "si");// gestione file uploadif (fileDaCaricare != null && fileDaCaricare.ContentLength > 0){

var fileName = Path.GetFileName(fileDaCaricare.FileName);var percorsoFile = Path.Combine(Server.MapPath(

"~/Content/Documenti/" + model.Documento.Tipo

72

+ "/"), fileName);// salva il file nel percorso correttofileDaCaricare.SaveAs(percorsoFile);// cancella il file vecchio se diverso dal nuovoif (model.Documento.Percorso != fileName){

var percorsoFileVecchio = Server.MapPath( "~/Content/Documenti/" + model.Documento.Tipo + "/" + model.Documento.Percorso);

EliminaFile(percorsoFileVecchio);}model.Documento.Percorso = fileName;

}db.SaveChanges();

}// carica l'elenco delle famigliemodel.ElencoFamiglie = db.FamiglieDoc.OrderBy(e => e.Famiglia).ToList();

} return Redirect("~/Documento/Elenco/" + model.Documento.Tipo);}

Dove il Metodo “EliminaFile” e’ definito nel Controller/BaseController.cs:public void EliminaFile(string percorsoFile){ // controllo che il file esista

if (System.IO.File.Exists(percorsoFile)){ // elimino il file

System.IO.File.Delete(percorsoFile);}

}

11.7) Lettura Dati su siti terzi

Esistono fondamentalmente due metodi con cui il mio sito puo’ leggere dati da un altro sito in internet:

- Parse- Web Service

11.7.1) ParsingSi usa su siti non collaborativi.Consiste nel processare tutto il testo html, cercando delle parole chiave che precedono ivalori da leggere. Il codice di lettura va elaborato su ogni specifica pagina: ogni volta che questa viene modificata, va messo nuovamente a punto.

11.7.2) Web ServicesSi usa su siti collaborativi, che hanno appositi servizi “API” (Application Programming Interface), fatti per essere letti da programmi.Il passaggio dati avviene tramite files in formato standardizzato, tipicamente XML o, ultimamente, JSON (JavaScript Object Notation).

Un servizio consiste in una pagina web, con URL contenente i parametri di richiesta, che risponde (in JSON) con i parametri di output.

73

12) Manuali di Riferimento12.1) Riferimento ASP.Net/MVC: interfaccia con un DB

www.asp.net/mvc/tutorials/getting-started-with-ef-5-using-mvc-4/creating-an-entity-framework-data-model-for-an-asp-net-mvc-application

12.2) Forum di supporto generico, per linguaggi di programmazione:http:// stackoverflow.com

12.3) Lista di tutti i Metodi ereditari delle Tabelle (vedi 9.4.2 e 9.4.3):code.msdn.microsoft.com/101-LINQ-Samples-3fb9811b

12.4) Formattazione delle Stringhe (vedi 5.12):msdn.microsoft.com/it-it/library/system.string.format(v=vs.110).aspx

12.5) Tabelle di Dati, formattate con JS:www.datatables.net/examples/index

12.6) Esempi di Tabelle di Dati, formattate con JS (da verificare):codepen.io/jgx/pen/wiIGccodepen.io/zivpug/pen/yAxdG/

12.7) Tool “ReSharper” (a pagamento): help on-line per VisualStudio:www.jetbrains.com

12.8) CSS Zen Garden = Esempi di uso dei fogli di stile:www.csszengarden.com

12.9) W3school: manuale programmazione webwww.w3schools.com

NB1: molti tag sono stati introdotti con html5, e non funzionano con le versioni precedenti.

NB2: notare il tasto “Try it Yoursenf”, che divide lo schermo in due, mostrando contemporaneamente causa ed effetto del codice.

12.10) PURE-CSS: gestione Stili htmlhttp://purecss.io

12.11) Librerie di Fonts html (file da scaricare: vedi 7.7)fortawesome.github.io/Font-Awesome/

12.12) Guide JShttp://www.html.it/guide/guida-javascript-di-base/?autorefresh=yeshttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Guidewww.w3schools.com/js/js_syntax.aspapi.jquery.com (API= Application programming interface = lista delle funzioni)

12.13) comando MailTowww.webfract.it/GUIDA/mailTo.htm

74

12.14) statistiche utilizzo browserwww.w3schools.com/browsers/

12.15) specifiche html5 (NB: “Canvas”= sostituto di FlashPlayer)http://diveintohtml5.info/

APPUNTI di PROGRAMMAZIONE WEB con ASP.Net · - CLR = Common Language Runtime = librerie comuni...

Documents

Transcript of APPUNTI di PROGRAMMAZIONE WEB con ASP.Net · - CLR = Common Language Runtime = librerie comuni...