Presentazione di PowerPoint

Transcript

29/09/2014
.NET
introduzione
Vittorio Maniezzo – University of Bologna
1
Common Language Infrastructure
.NET è un’implementazione di CLI, Common Language
Infrastructure: uno standard ECMA (http://www.ecmainternational.org/)
• ECMA-334, ECMA-335
Esistono altre implementazioni di CLI:
•
•
•
•
•
SSCLI (Microsoft, per Windows, FreeBSD e Macintosh)
Mono (per Linux)
DotGNU
Intel OCL (Open CLI Library)
…
2
1
29/09/2014
.NET framework
• .NET framework è un’estensione del sistema operativo. È
l'ambiente per la creazione, la distribuzione e l'esecuzione di tutti
gli applicativi che supportano .NET siano essi servizi Web o altre
applicazioni.
• .NET contiene un ambiente run-time che si appoggia su Windows
(XP, 7, 8, …) di supporto allo sviluppo, gestione e deploy del
codice.
• I programmi e componenti scritti dall’utente vengono eseguiti
all’interno dell’ambiente.
• Fornisce al programmatore funzionalità specifiche, quali garbage
collection automatica, accesso unificato alle API di sistema,
accesso a Internet, connessione a database, ...
• .NET è rilasciato in integrazioni successive, chiamate framework.
Oggi (2014) siamo al 4.5.
3
.NET framework
Versione
Release
Date
Visual Studio
1.0
13 – 2-2002
1.1
24-4-2003
Visual Studio .NET 2003
2.0
7-11-2005
Visual Studio 2005
3.0
6-11-2006
3.5
19-11-2007
Visual Studio 2008
4.0
12-4-2010
Visual Studio 2010
4.5
15-8-2012
Visual Studio 2012
Default in
Windows
Visual Studio .NET
Windows Server 2003
Windows Vista,
Windows Server 2008
Windows 7, Windows
Server 2008 R2
Windows 8
4
2
29/09/2014
Caratteristiche principali
• Interoperabilità: per garantire l’interazone fra applicazioni nuove e
preesistenti, è supportato l’accesso a componenti COM; l’ accesso a
generiche funzionalità si ha con il P/Invoke.
• Common Language Runtime (CLR): è una virtual machine del .NET
framework. Tutti i programmi .NET girano sotto la sua supervisione
con garanzie sulla gestione della memoria, delle eccezioni e della
sicurezza.
• Indipendenza dal linguaggio: garantita dal Common Type System
(CTS). Il CTS definisce tutti i tipi dati e le operazioni compatibili col
CLR. Questo garantisce l’interoperabilità fra pezzi di codice scritti in
linguaggi diversi.
• Base Class Library: una libreria di funzioni utilizzabile in qualunque
linguaggio: incapsula funzioni comuni come lettura, scrittura,
rendering grafico, accesso a database, XML, remotizzazione, ecc.
5
Caratteristiche principali
• Sicurezza: vengono gestite esplicitamente condizioni (es. buffer
overflow) che potrebbero essere sfruttate da SW malevolo. Inoltre, il
.NET fornisce un modello di sicurezza comune a tutte le applicazioni.
• Portabilità:.NET è indipendente dal sistema operativo, quindi crossplatform. Un programma scritto per il framework dovrebbe girare
senza modifiche su qualunque SO. Microsoft non ha mai
implementato il framework su sistemi diversi da Windows, ma
sviluppatori indipendenti l’hanno fatto ed esistono applicazioni crossplatform.
• Deployment semplificato:.NET include tool che aiutano l’installazione
del sw e controllano che non ci siano interferenze con SW
preesistente.
6
3
29/09/2014
Sviluppo semplificato
Ambiente object-oriented
• Qualsiasi entità è un oggetto
• Classi ed ereditarietà pienamente supportati
• Anche tra linguaggi diversi
Riduzione errori comuni di programmazione
• Linguaggi fortemente tipizzati
• Errori gestiti
• Meno perdite di memoria: Garbage Collector
7
Caratteristiche .NET
Indipendenza dal linguaggio
• Il .NET Framework introduce un Common Type System (CTS)
• Le specifiche del CTS definiscono tutti i possibili tipi di dato e
costrutti di programmazione supportati dall’ambiente runtime
(chiamato Common Language Runtime, CLR): questo permette di
scambiarsi istanze di tipi tra programmi scritti nei vari linguaggi
.NET
Base Class Library (BCL)
• È una libreria disponibile a tutti i linguaggi .NET
• Contiene classi che incapsulano un numero di funzioni comuni,
come per esempio lettura e scrittura di file, interazione con le
stringhe, i numeri, …
8
4
29/09/2014
class Program
{
static void Main (string[] args)
{
System.Console.WriteLine( "Hello World" );
}
}
Class Program
Shared Sub Main (ByVal args As String())
End Sub
End Class
C#
VB
9
class Hello
{
static void Main (string[] args)
{
System.Console.WriteLine(Greeting.Message());
}
C# richiama Vb.NET
}
Class Greeting
Shared Function Message() As String
Return "Hello World“;
End Function
End Class
10
5
29/09/2014
Architettura, linguaggi e tool
VB
C++
C#
JScript
…
Common Language Specification
Windows Forms
ADO.NET and XML
Base Class Library
Common Language Runtime
Windows
Visual Studio.NET
WS
ASP.NET
COM+ Services
11
Architettura .NET (base)
Web
Services
User
Interface
Base Classes
Base Frame
Data & XML
12
6
29/09/2014
Namespace .NET (2.0, alcuni)
System.WinForms
System.Web
Web Services
Controls
Web Forms
Drawing
Windows Application Services
ASP.NET Application Services
System Base Framework
ADO.NET
XML
SQL
Threading
IO
Net
Security
ServiceProcess
Type System
Metadata
Execution
13
Namespace .NET (un po’ di più)
System.Web
System.Windows.Forms
UI
HtmlControls
Compilation
Design
ComponentModel
WebControls
Handlers
System.Drawing
Hosting
Caching
Security
Drawing2D
Printing
Configuration
SessionState
Imaging
Text
System.Data
System.Xml
OleDb
Common
Xsl
Schema
SqlClient
SQLTypes
XPath
Serialization
System
Collections
IO
Security
Configuration
Reflection
Text
Diagnostics
Resources
Threading
Globalization
Runtime
InteropServices
Remoting
Serialization
14
7
29/09/2014
Ambiente di esecuzione
Elementi fondamentali:
• MSIL: Microsoft Intermediate Language
• CLR: Common Language Runtime
• CTS: Common Type System
• CLS: Common Language Specification
• BCL: Base Class Library
15
Codice interpretato
Sorgenti
Interprete
Output
16
8
29/09/2014
Codice compilato
Sorgenti
Compilatore
Codice
nativo
(.EXE)
Output
17
Codice MSIL
Sorgenti
Compilatore
.NET
Codice
MSIL
(Assembly)
.EXE/.DLL
Compilatore
JIT
Codice
nativo
Output
18
9
29/09/2014
Codice MSIL
Sorgenti
Compilatore
.NET
Codice
MSIL
(Assembly)
.EXE/.DLL
.NET runtime
Compilatore
JIT
Codice
nativo
Output
19
CTS: Common Type System
Sistema di tipi comune alla base di tutti i linguaggi .NET
Progettato per linguaggi object-oriented, procedurali e
funzionali
• Esaminate caratteristiche di 20 linguaggi
• Tutte le funzionalità disponibili con MSIL
• Ogni linguaggio utilizza alcune caratteristiche
Common Language Specification (CLS)
• Sottoinsieme di CTS
• Regole di compatibilità tra linguaggi
20
10
29/09/2014
Common Type System
Qualsiasi applicazione .NET è realizzata definendo un
insieme di tipi, utilizzandoli insieme a quelli predefiniti
da MS (Base Class Library)
Due categorie di tipi:
• Tipi reference (riferimento)

Allocati su heap gestito
• Tipi value (valore)

Allocati su stack o in oggetti gestiti (reference)
Tutti i tipi value possono essere utilizzati come tipi
reference (Boxing).
21
Estendibilità delle classi
Il Framework non è una scatola nera, qualsiasi classe
.NET può essere estesa mediante ereditarietà
• si usa e si estende la classe stessa, non uno strato
intermedio (wrapper)
L’ereditarietà è cross-language
22
11
29/09/2014
Managed code e CLR
Il codice sviluppato all’interno del framework viene
eseguito come managed code (codice gestito)
Managed code gira in un ambiente chiamato Common
Language Runtime (CLR)
Managed code
Codice Utente
CLR
Richieste di
funzionalità standard
Richieste di
funzionalità CLR (es.
garbage collection)
Windows OS
23
Il CLR di .NET
Il CLR è un ambiente runtime che supporta qualunque
linguaggio .NET.
Il CLR può girare su qualunque OS che implementi la
Common Language Infrastructure, che è definita in modo
indipendente dalla macchina.
24
12
29/09/2014
Caratteristiche
• Tipi di dati comuni

Mapping dei tipi di dati fra linguaggi diversi
• Compilatori just-in-time (JIT)


•
•
•
•
•
JIT compila un linguaggio intermedio (MSIL) in codice nativo
Può essere ottimizzato per ogni piattaforma
Garbage collector
Permessi e politiche di sicurezza
Eccezioni
Threading
Diagnostica e profiling
25
CLR: struttura
Base Class Library Support
Thread Support
COM Marshaler
Type Checker
Exception Manager
Security Engine
Debug Engine
MSIL to Native
Compilers (JIT)
Code
Manager
Garbage
Collector (GC)
Class Loader
26
13
29/09/2014
Funzioni del CLR
Gestione dell’esecuzione del codice:
Il CLR gestisce le referenze agli oggetti, rilasciandoli quando
non sono più utilizzati. Gli oggetti gestiti in questo modo
sono detti “oggetti gestiti” (managed objects).
La gestione automatica della memoria elimina le perdite di
memoria, oltre ad alcuni comuni errori di programmazione.
27
CLR e metadati
I metadati, forniscono le informazioni che descrivono la dichiarazione
dei tipi, dei membri delle classi e le referenze nel codice.
I metadati sono memorizzati col codice; qualunque file common
language runtime caricabile contiene metadati (v. ILSDAM).
Il runtime usa i metadati per localizzare e caricare le classi, posizionare
le istanze in memoria, risolvere le chiamate ai metodi, generare
codice nativo, garantire la sicurezza e definire limiti ai contesti runtime.
28
14
29/09/2014
Class Loader
E’ un componente .NET, che cerca e carica classi .NET
utilizzando metadati.
Il Class Loader può caricare classi locali, remote o su
internet.
Carica le classi remote tramite un processo detto di
“marshaling” delle informazioni di chiamata.
29
JIT
Il CLR è in grado di lavorare solo con codice in Microsoft
Intermediate Language (MSIL o IL, il bytecode della MS)
Ogni linguaggio .NET compatibile deve compilarsi in
MSIL
Un compilatore Just In Time (JIT) traduce il MSIL in
istruzioni macchina
Tre possibilità di compilazione per deploy
Codice
sorgente
VisualStudio
MSIL
JIT
Codice
eseguibile
30
15
29/09/2014
Doppia compilazione
Avviene una doppia compilazione
• La prima a design time con csc.exe: viene creato un semilavorato
in IL
• La seconda quando il programma viene eseguito: il codice IL è
compilato durante l’esecuzione dal JIT Compiler (Just –in –time)
Vantaggi
• Il JIT produce codice ottimizzato per quella particolare
esecuzione
• Potenzialmente multipiattaforma
Svantaggi
• Maggior lentezza iniziale
• Possibilità di fare reverse engineering
31
Doppia compilazione
32
16
29/09/2014
Esecuzione codice
Generazione file .NET PE(Portable Executable)
(Un file .NET PE è chiamato Assembly, memorizzato come .DLL o .EXE)
Class Loader
JIT Compiler
Verifica
JIT
Executer and Manager(GC, IL Management, Security
Management,Exception Management)
33
Esecuzione codice
Compilazione
Codice
sorgente
Compilazione
Intermediate Language
MSIL
Metadata
Esecuzione
JIT Compiler
Codice nativo
(Chiamato solo una volta)
34
17
29/09/2014
Esecuzione
PE/COFF Header
JMPHeader
_CorExeMain
CLR
OS Loader
MsCorEE.dll
Metadata
IL Code
JIT Compiler
& Verification
Class Loader
Policy Manager
Assembly Loader
Garbage Collection
Native code
GC Info
EH Info
Exception Manager
Code
Manager
Thread Support
Security Permission
Enforcement
Debug Engine
35
35
Esempio
namespace HelloWorld
{ class Program
{ static void Main (string[] args)
{
}
}
}
• Il compilatore per C# si trova (ad es) in
c:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe
• Esempio direttiva di compilazione csc Program.cs (csc è il
compilatore di C#)
• Il risultato della compilazione è un file program.exe
• Program.exe è un file non in linguaggio macchina ma in MSIL
36
18
29/09/2014
Esempio : Somma
public class X
{ public static int Sum(int n)
{ int s = 0; // running sum
for (int i = 1; i <= n; i++)
{ s += i; // add in current
}
return s;
}
C#
}
Prolog
Epilog
push
mov
sub
push
xor
xor
xor
mov
jmp
add
inc
cmp
jle
mov
pop
mov
pop
ret
ebp
ebp,esp
esp,0Ch
esi
edx,edx
esi,esi
edx,edx
esi,1
00000005
edx,esi
esi
esi,ecx
FFFFFFFB
eax,edx
esi
esp,ebp
ebp
x86
csc /debug Sum.cs
.method public static int32 Sum(int32 n) {
.locals (int32 s, int32 i, int32 t)
ldc.i4.0
// < 0
>
stloc.0
// <
>
// s = 0
ldc.i4.1
// < 1
>
stloc.1
// <
>
// i = 1
br.s
chek // <
>
// => chek:
loop: ldloc.0
// < s
>
ldloc.1
// < i
>
add
// < s+i >
stloc.0
// <
>
// s = s + i
ldloc.1
// < i
>
ldc.i4.1
// < i 1 >
add
// < i+1 >
stloc.1
// <
>
// i = i + 1
chek: ldloc.1
// < i
>
ldarg.0
// < n
>
ble.s
loop // <
>
// i< n => loop:
ldloc.0
// < s
>
stloc.2
// <
>
// t = s
br.s
done // <
>
// goto done:
done: ldloc.2
// < t
>
ret
IL
}
JIT Compiler
37
Esecuzione di codice gestito
• Il codice, quando mandato in esecuzione, gira in
cooperazione con (è gestito da) il runtime environment.
• Il codice gestito deve fornire i metadati necessari al
runtime per fornire i servizi di gestione memoria,
integrazione multilinguaggio e sicurezza accesso al codice.
• Qualunque codice basato sul Microsoft Intermediate
Language (MSIL) viene eseguito come codice gestito.
38
19
29/09/2014
Assembly
Tutto il codice che gira nel CLR risiede in un qualche
assembly.
Un assembly è una collezione di uno o più file exe o
dll che contengono codice e risorse di una
applicazione.
Un assembly contiene anche un manifest, metadata
(in chiaro) di descrizione dei contenuti dell’assembly.
Molte funzionalità di base, es. gestione sicurezza,
namespace, versioning, sono basate su assembly di
sistema.
39
Assembly
Un assembly corrisponde a un componente, che può
essere privato dell’applicazione o reso pubblico.
Assembly private risiedono nel sottodirettorio BIN
del progetto
Assembly condivise NON usano il registro di
windows  ma risiedono nella Global Assembly
Cache (GAC), in \windows\assembly
40
20
29/09/2014
Assembly
Assembly
• Unità minima per la distribuzione, il versioning e la
security
• Simile alle DLL, ma aggiunge meta-dati sul contenuto
attraverso il “Manifest”
• Può essere composto da uno o più file
• Il manifest può risiedere in un file EXE/DLL separato,
oppure in un EXE/DLL che contiene codice
dell’assembly
41
Dove sono gli assembly
Assembly privati
• Directory applicazione (e sub-directory)
Assembly condivisi
• Global Assembly Cache (GAC)
• c:\windows\assembly
Assembly scaricati da URL
• Download cache
• c:\windows\assembly\download
GACUTIL.EXE
• Tool per esaminare GAC e download cache
42
21
29/09/2014
Assembly
Modulo
(file PE)
Codice IL
Metadati
Manifest
Assembly a modulo singolo
43
Metadati
I metadati descrivono ogni elemento gestito dal runtime:
un assembly, un file caricabile, tipi, metodi, ecc.
In particolare contengono le informazioni necessarie al
debugging e alla garbage collection, gli attributi di
sicurezza, il marshaling dei dati, le classi estese, il version
binding.
44
22
29/09/2014
Metadati
Descrizione di un assembly
•
•
•
•
Identità: nome, versione, cultura [, public key]
Tipi esportati
Assembly da cui dipende
Permessi necessari per l’esecuzione
Descrizione dei tipi
• Nome, visibilità, classe base, interfacce implementate
Attributi custom
• Definiti dall’utente
• Definiti dal compilatore
• Definiti dal Framework
45
Tool che usano i metadati
Compilatori
• Compilazione condizionale
Ambienti per sviluppo rapido di applicazioni
• Informazioni sulle proprietà dei componenti


Categoria
Descrizione
• Editor personalizzati di tipi di proprietà
Analisi dei tipi
• Intellisense
• ILDASM
46
23
29/09/2014
Altri servizi del CLR
Garbage collector
• Gestione del ciclo di vita degli oggetti
• Distruzione deterministica
Reflection
• Analisi dei metadati di un assembly
• Generazione di un assembly dinamico
Remoting
• Chiamata di componenti remoti (.NET)
Interoperabilità (COM, Platform Invoke)
AppDomains
47
Garbage Collector
Gli oggetti vengono distrutti automaticamente
quando non sono più referenziati
Non ci si basa sul Reference Counting
• Maggiore velocità di allocazione
• Consentiti i riferimenti circolari
• Perdita della distruzione deterministica
Algoritmo Mark-and-Compact
48
24
29/09/2014
Garbage Collector - fase 1: Mark
NextObjPtr
Root set
Oggetti “vivi”
Oggetti non raggiungibili
Spazio libero
49
Garbage Collector - fase 2:
Compact
Spazio recuperato
NextObjPtr
Oggetti “vivi”
Root set
Spazio libero
50
25
29/09/2014
Spazio per il C++ (e ANSI C)
• Il GC riloca gli oggetti in memoria: non è più possibile gestirli
esplicitamente tramite puntatore.
• La gestione della memoria è delegata al framework: più comodo, più
sicuro ma più lento (ca. da 1.2 a 1.5 volte più lento).
• Inefficienze computazionali non sono tanto dovute alla doppia
compilazione quanto alla difficoltà di una gestione diretta della
memoria.
• Per le applicazioni computazionalmente più impegnative
(ottimizzazione, grafica, ecc.) ANSI C (o C++ nativo) possono essere più
efficienti.
51
26

Presentazione di PowerPoint

Transcript

Documenti analoghi

Edizione 29 - Dicembre 2014 - Nobile Collegio Mondragone

Corso base di cucina tradizionale e pasticceria

Euristiche - www3 - Università di Bologna

Scarica - Liceo Fermi

VITTORIO GRIGOLO ITALIA, UN SOGNO Tour 10 settembre – 8

Vittorio Grigolo - So-net

Deep Learning

Reti di calcolatori: Introduzione Reti di computer e Internet

A due anni dalla morte. In ricordo di Vittorio Caloni