NETintroFULL [modalit compatibilit ]isi-personale.csr.unibo.it/vittorio.maniezzo/did... · Gestione...

1

Vittorio Maniezzo – Università di Bologna

.NET Introduzione

2Vittorio Maniezzo – Università di Bologna

Common Language Infrastructure

• .NET è un’implementazione di CLI, Common Language Infrastructure: uno standard ECMA (http://www.ecma-

international.org/)

— ECMA-334, ECMA-335

• Esistono già altre implementazioni di CLI:

— SSCLI (Microsoft, per Windows, FreeBSD e Macintosh)

—Mono (per Linux)

—DotGNU

— Intel OCL (Open CLI Library)

—…

2


.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, vista, 7, …) 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à utili, quali garbage collection automatica, accesso unificato alle API di sistema, accesso a Internet, connessione a database.

• .NET è rilasciato in integrazioni successive, chiamate framework. Oggi (2010) siamo al 4.


.NET frameworkVersione

VersionNumber

ReleaseDate

Visual StudioDefault in Windows

1.0 1.0.3705.0 13 – 2-2002 Visual Studio .NET

1.1 1.1.4322.573 24-4-2003Visual Studio .NET

2003

Windows Server

2003

2.0 2.0.50727.42 7-11-2005 Visual Studio 2005

3.0 3.0.4506.30 6-11-2006

Windows Vista,

Windows Server

2008

3.5 3.5.21022.8 19-11-2007 Visual Studio 2008

Windows 7,

Windows Server

2008 R2

4.0 4.0.30319.1 12-4-2010 Visual Studio 2010

3


Prima dei componenti

Prima dell’avvento dello sviluppo per componenti, le applicazioni erano entità completamente separate, senza integrazione

Applicazione

Codice e strutture dati


Architetture a componenti

I componenti forniscono un meccanismo per integrare parti dell’applicazione.Ogni componente deve però fornire dei “contatti” e gli oggetti non possono interagire direttamente

4


J2EE e .NET

Con J2EE o .NET, i componenti sono costruiti su uno strato comune. Gli oggetti interagiscono direttamente.

Caratteristiche principali


• Interoperabilità: per garantire l’interazone fra applicazioni nuove e

preesistenti. L’accesso a componenti COM è supportato in

System.Runtime.InteropServices e System.EnterpriseServices; 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 ecc.

5

Caratteristiche principali


• Deployment semplificato:.NET include tools che aiutano

l’installazione del sw e controllano che non ci siano interferenze con

SW preesistente.

• Sicurezza: vengono gestite esplicitamente condizioni (es. buffer

overflow) che potevano 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 cross-

platform. 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 cross-

platform.


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

6


Caratteristiche .NETIndipendenza 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, …


Indipendenza dal linguaggio

class Program

{

static void Main (string[] args)

{

System.Console.WriteLine( "Hello World" );

}

}

Class Program

Shared Sub Main (ByVal args As String())

System.Console.WriteLine( "Hello World" );

End Sub

End Class

C#

VB

7


Indipendenza dal linguaggio

class Hello

{

static void Main (string[] args)

{

System.Console.WriteLine(Greeting.Message());

}

}

Class Greeting

Shared Function Message() As String

Return "Hello World“;

End Function

End Class

C# richiama Vb.NET


Linguaggi e tool

Windows COM+ Services

Common Language Runtime

Base Class Library

ADO.NET and XML

ASP.NET WS Windows Forms

Common Language Specification

VB C++ C# JScript …

Visual S

tudio.NE

T

8


Architettura .NET (base)

Base Classes

Data & XML

UserInterface

Common Language Runtime

WebServices

Bas

e F

ram

e


Architettura .NET (2.0)

Common Language RuntimeMetadataType System Execution

System Base Framework

IO Net Security ServiceProcess

ADO.NET XML SQL Threading

System.Web

Web Services Web Forms

ASP.NET Application Services

System.WinForms

Controls Drawing

Windows Application Services

9


System

System.Data System.Xml

System.Web

Globalization

Diagnostics

Configuration

Collections

Resources

Reflection

IO

Threading

Text

Security

SqlClient

OleDb

SQLTypes

Common

RuntimeInteropServices

Remoting

Serialization

Configuration SessionState

Caching Security

UIHtmlControls

WebControls

System.Drawing

Imaging

Drawing2D

Text

Printing

System.Windows.Forms

Design ComponentModel

.NET Framework: i namespace

XPath

Xsl

Serialization

Schema

Hosting

Handlers

Compilation


Base Framework: i namespace

System

Threading

Text

Security

Resources

Reflection

IO

Globalization

Diagnostics

Configuration

Collections

Runtime

Serialization

Remoting

InteropServices

10


Data e XML: i namespace

System.Data

System.Xml

SqlTypes

OleDb

SqlClient

Common

Serialization

Schema

XPath

Xsl


Web Forms e Services: i namespace

System.Web

Caching

Configuration

UI

SessionState

HtmlControls

WebControls

Security

Handlers

Hosting

Compilation

11


Windows Forms: i namespace

System.Drawing

Drawing2D

Imaging

Printing

Text

System.Windows.Forms

Design ComponentModel


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

12


Piattaforma multi-linguaggio

• Libertà di scelta del linguaggio

— Tutte le funzionalità di .NET Framework sono disponibili a tutti i linguaggi .NET

— I componenti di un’applicazione possono essere scritti con diversi linguaggi

• Impatto sui tool

— Tool disponibili per tutti i linguaggi:Debugger, Profiler, Analisi, ecc.


Linguaggi

• La piattaforma .NET è neutrale rispetto al linguaggio(nessuno è favorito)

— Tutti i linguaggi .NET hanno le stesse possibilità

— Si possono sfruttare skill già esistenti

• Common Language Specification: due possibilità di utilizzo:

— Consumer: usa il .NET Framework

— Extender: estende il .NET Framework

13


Codice interpretato

Interprete OutputSorgenti


Codice compilato

Codicenativo(.EXE)

Output

CompilatoreSorgenti

14


Codice MSIL

Codicenativo

OutputCompilatoreJIT

Compilatore.NET

Sorgenti

CodiceMSIL

(Assembly).EXE/.DLL


Codice MSIL

Codicenativo

OutputCompilatoreJIT

Compilatore.NET

Sorgenti

CodiceMSIL

(Assembly).EXE/.DLL

.NET runtime

15


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


CTS: Common Type System

• Alla base di tutto ci sono i tipi (le classi)

• Fortemente tipizzato (compile-time)

• Object-oriented

— Campi, metodi, tipi nidificati, proprietà, ...

• Overload di funzioni (compile-time)

• Dispatch metodi virtuali risolto a runtime

• Ereditarietà singola di implementazione

• Ereditarietà multipla di interfacce

16


Common Type System

• Qualsiasi applicazione .NET è realizzata definendo un insieme di tipi + utilizzo (istanziazione) di questi ultimi 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).


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

17


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)

CLR

Windows OS

Richieste di funzionalità standard

Richieste di funzionalità CLR (es. garbage collection)

Managed code Codice Utente


Common Language RuntimeCaratteristiche

— 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

18


CLR: struttura

Class Loader

MSIL to NativeCompilers (JIT)

CodeManager

GarbageCollector (GC)

Security Engine Debug Engine

Type Checker Exception Manager

Thread Support COM Marshaler

Base Class Library Support


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.

19


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.


Servizi per lo sviluppo:

• 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 immagine

common language runtime caricabile contiene metadati.

• 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 run-time.

Funzioni del CLR

20


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.


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

VisualStudioMSIL JIT Codice

eseguibile

21


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


Doppia compilazione

22


Esecuzione codiceGenerazione file .NET PE(Portable Executable)

(Un file .NET PE è chiamato Assembly, memorizzato come .DLL o .EXE)

Class Loader

Verifica

JIT Compiler

JIT

Executer and Manager(GC, IL Management, Security Management,Exception Management)


(Chiamato solo una volta)

Esecuzione

JIT Compiler Codice nativo

MSILCodice

sorgente Compilazione

Compilazione

Intermediate Language

Metadata

Esecuzione codice

23


45

Esecuzione

OS Loader

JIT Compiler& Verification Class Loader Policy Manager Assembly Loader

MsCorEE.dll

Garbage Collection

Exception Manager

Thread Support

Security PermissionEnforcement

Debug Engine

CodeManager

Native code

GC Info

EH Info

PE/COFF Header

CLR Header

Metadata

IL Code

JMP _CorExeMain


NGEN

Per velocizzare il codice eseguibile.

•Si può compilare il codice IL in codice macchina

•Si utilizza ngen.exe

•Permette uno startup più rapido perché il codice è già

compilato

•Non è possibile fare alcuna ottimizzazione

•Il codice IL originale deve essere disponibile per informazioni

aggiuntive

•Per eseguire ngen.exe bisogna avere diritti amministrativi sulla

macchina

C:\Windows\Microsoft.NET\Framework\v2.0.50727\ngen.exe

24


Esempio

namespace HelloWorld

{ class Program

{ static void Main (string[] args)

{ System.Console.WriteLine( "Hello World" );

}

}

}

•Il compilatore per C# si trova in

C:\Windows\Microsoft.NET\Framework\v3.5\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


.method public static int32 Sum(int32 n) {.locals (int32 s, int32 i, int32 t)ldc.i4.0 // < 0 >stloc.0 // < > // s = 0ldc.i4.1 // < 1 >stloc.1 // < > // i = 1br.s chek // < > // => chek:

loop: ldloc.0 // < s >ldloc.1 // < i >add // < s+i >stloc.0 // < > // s = s + ildloc.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 = sbr.s done // < > // goto done:

done: ldloc.2 // < t >ret

}

public class X { public static int Sum(int n){ int s = 0; // running sumfor (int i = 1; i <= n; i++) { s += i; // add in current}return s;

}}

push ebpmov ebp,espsub esp,0Chpush esixor edx,edxxor esi,esixor edx,edxmov esi,1jmp 00000005add edx,esiinc esicmp esi,ecxjle FFFFFFFBmov eax,edxpop esimov esp,ebppop ebpret

C#

x86

IL

Esempio : Sommacsc /debug Sum.cs

JIT Compiler

Prolog

Epilog

25


public class X{ public static int Sum(int n)

{ int s = 0;for (int i = 1; i <= n; i++) s += i; return s;

}}

[0] 0000 0006 // s

[1] 0000 0004 // i

Var. locali

[0] 0000 0007 // n

Argomenti

0000 0004

Evaluation Stack

0000 0006

[2] 0000 0000 // t

Stack, stato corrente

16 0A 17 0B 2B.08 06 07 58 0A 07 17 58 0B 07 02 31.F4 06 0C 2A

.method static int32 Sum(int32 n) { .locals init ( [0] int32 s, [1] int32 i, [2] in t32 t)

ldc.i4.0; stloc.0; ldc.i4.1; stloc.1; br.s chek

loop: ldloc.0; ldloc.1; add; stloc.0ldloc.1; ldc.i4.1; add; stloc.1

chek : ldloc.1; ldarg.0; ble.s loopldloc.0; stloc.2; ldloc.2; ret }

C#

IL

Esempio : Somma


.method static int32 Sum(int32 n) {.locals init ( [0] int32 s, [1] int32 i, [2] int32 t)

ldc.i4.0 stloc.0 ldc.i4.1 stloc.1 br.s check

loop: ldloc.0 ldloc.1 add stloc.0ldloc.1 ldc.i4.1 add stloc.1

check: ldloc.1ldarg.0ble.s loopldloc.0stloc.2ldloc.2ret

}

[0] 0000 0000 // s

[1] 0000 0000 // i

Locals

[0] 0000 0007 // n

Arguments

Evaluation Stack

[2] 0000 0000 // t

Esempio : Somma

26



ldc.i4.0stloc.0 ldc.i4.1 stloc.1 br.s check



}

[0] 0000 0000 // s

[1] 0000 0000 // i

Locals

[0] 0000 0007 // n

Arguments

Evaluation Stack

[2] 0000 0000 // t

0000 0000

Esempio : Somma



ldc.i4.0 stloc.0ldc.i4.1 stloc.1 br.s check



}

[0] 0000 0000 // s

[1] 0000 0000 // i

Locals

[0] 0000 0007 // n

Arguments

Evaluation Stack

[2] 0000 0000 // t

Esempio : Somma

27



ldc.i4.0 stloc.0 ldc.i4.1stloc.1 br.s check



}

[0] 0000 0000 // s

[1] 0000 0000 // i

Locals

[0] 0000 0007 // n

Arguments

Evaluation Stack

[2] 0000 0000 // t

0000 0001

Esempio : Somma



ldc.i4.0 stloc.0 ldc.i4.1 stloc.1br.s check



}

[0] 0000 0000 // s

[1] 0000 0001 // i

Locals

[0] 0000 0007 // n

Arguments

Evaluation Stack

[2] 0000 0000 // t

Esempio : Somma

28






}

[0] 0000 0000 // s

[1] 0000 0001 // i

Locals

[0] 0000 0007 // n

Arguments

Evaluation Stack

[2] 0000 0000 // t

Esempio : Somma






}

[0] 0000 0000 // s

[1] 0000 0001 // i

Locals

[0] 0000 0007 // n

Arguments

Evaluation Stack

[2] 0000 0000 // t

0000 0001

Esempio : Somma

29






}

[0] 0000 0000 // s

[1] 0000 0001 // i

Locals

[0] 0000 0007 // n

Arguments

Evaluation Stack

[2] 0000 0000 // t

0000 0001

0000 0007

Esempio : Somma






}

[0] 0000 0000 // s

[1] 0000 0001 // i

Locals

[0] 0000 0007 // n

Arguments

Evaluation Stack

[2] 0000 0000 // t

0000 0001

0000 0007

Esempio : Somma

30




loop: ldloc.0ldloc.1 add stloc.0ldloc.1 ldc.i4.1 add stloc.1


}

[0] 0000 0000 // s

[1] 0000 0001 // i

Locals

[0] 0000 0007 // n

Arguments

Evaluation Stack

[2] 0000 0000 // t

0000 0000

Esempio : Somma




loop: ldloc.0 ldloc.1add stloc.0ldloc.1 ldc.i4.1 add stloc.1


}

[0] 0000 0000 // s

[1] 0000 0001 // i

Locals

[0] 0000 0007 // n

Arguments

Evaluation Stack

[2] 0000 0000 // t

0000 0000

0000 0001

Esempio : Somma

31






}

[0] 0000 0000 // s

[1] 0000 0001 // i

Locals

[0] 0000 0007 // n

Arguments

Evaluation Stack

[2] 0000 0000 // t

0000 0001

Esempio : Somma




loop: ldloc.0 ldloc.1 addstloc.0ldloc.1 ldc.i4.1 add stloc.1


}

[0] 0000 0001 // s

[1] 0000 0001 // i

Locals

[0] 0000 0007 // n

Arguments

Evaluation Stack

[2] 0000 0000 // t

Esempio : Somma

32




loop: ldloc.0 ldloc.1 addstloc.0ldloc.1ldc.i4.1 add stloc.1


}

[0] 0000 0001 // s

[1] 0000 0001 // i

Locals

[0] 0000 0007 // n

Arguments

Evaluation Stack

[2] 0000 0000 // t

0000 0001

Esempio : Somma




loop: ldloc.0 ldloc.1 addstloc.0ldloc.1 ldc.i4.1add stloc.1


}

[0] 0000 0001 // s

[1] 0000 0001 // i

Locals

[0] 0000 0007 // n

Arguments

Evaluation Stack

[2] 0000 0000 // t

0000 0001

0000 0001

Esempio : Somma

33




loop: ldloc.0 ldloc.1 addstloc.0ldloc.1 ldc.i4.1 addstloc.1


}

[0] 0000 0001 // s

[1] 0000 0001 // i

Locals

[0] 0000 0007 // n

Arguments

Evaluation Stack

[2] 0000 0000 // t

0000 0002

Esempio : Somma




loop: ldloc.0 ldloc.1 addstloc.0ldloc.1 ldc.i4.1 add stloc.1


}

[0] 0000 0001 // s

[1] 0000 0002 // i

Locals

[0] 0000 0007 // n

Arguments

Evaluation Stack

[2] 0000 0000 // t

Esempio : Somma

34


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.


Assembly

• Tutto il codice che gira nel CLR risiede in una 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.

35


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


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

36


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


Assembly

Assembly a modulo singolo

Codice IL

Metadati

Manifest

Modulo(file PE)

37


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.


Metadati

• Informazioni sui tipi di un assembly

• Generati automaticamente dai compilatori

• Estendibili da terze parti

• Formato binario rappresentabile con XML:

— XML Schema (XSD)

— Serializzazione e deserializzazione oggetti a runtime in XML

38


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


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

39


Compilatori e metadati

• Import dei tipi di dati cross-language

• Emettono i metadati insieme al codice

—Descrivono i tipi definiti e usati

—Registrano gli assembly esterni referenziati

—Registrano informazioni di versione

• Possono interpretare attributi custom

—Obsolete

— CLS Compliance (conformità CLS)

— Compilazione condizionale (es. debug)

—Attributi specifici del linguaggio


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

40


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


Garbage Collector - fase 1: Mark

NextObjPtr

Oggetti “vivi”

Oggetti non raggiungibili

Spazio libero

Root setRoot set

41


Garbage Collector - fase 2: Compact

NextObjPtr

Oggetti “vivi”

Spazio liberoRoot setRoot set

Spazio recuperato


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.) il C++ nativo è ancora il linguaggio di

elezione.

42


GC e distruzione deterministica

• In alcuni casi serve un comportamento di finalizzazione deterministica:

—Riferimenti a oggetti non gestiti

—Utilizzo di risorse che devono essere rilasciate appena termina il loro utilizzo

• Non si possono usare i finalizzatori, che non sono richiamabili direttamente

• Implementare l’interfaccia IDisposable


Gestione degli errori

• Uniforme per tutte le classi

• Gestione strutturata delle eccezioni

— Funzionalità implementata nel CTS

—Disponibile in tutti i linguaggi con sintassi diverse

— Elementi universali:

—Lanciare un’eccezione

—Catturare un’eccezione

—Codice di uscita da un blocco controllato (finally)

• Non ha costi elevati (codice/prestazioni)

43


Elaborazione sincrona e asincrona

a()a()a()a() b()b()b()b() c()c()c()c() d()d()d()d() e()e()e()e() f()f()f()f() g()g()g()g() h()h()h()h()

a()a()a()a()

b()b()b()b()

c()c()c()c()

d()d()d()d()

e()e()e()e()

f()f()f()f()

g()g()g()g() h()h()h()h()fork

join

Tempo

Elaborazionesincrona

Elaborazioneasincrona

Thread 1

Thread 2


Elaborazione sincrona e asincrona

• Programmazione asincrona possibile da tutti i linguaggi

— Chiamate asincrone

— Thread

— Thread pool

— Componenti remoti

—A volte è “involontaria”...

• Nuovo problema: componenti thread-safe

44


Processi e AppDomain

• Processo: codice eseguibile (almeno un thread) e dati all’interno della memoria che si è riservato col sistema operativo. Ogni risorsa cui si accede (file ecc.) viene assegnata al processo.

• Limite di sicurezza: bug o funzioni malevole interne non possono agire su aree esterne al loro processo. Necessarie tecniche specifiche per far comunicare processi.

• Il processo è l’unità minima di isolamento su Windows.

• Problema per servizi web: centinaia di applicazioni sullo stesso server. Devono essere isolate per sicurezza, ma il costo di istanziazione ed esecuzione di tanti processi è proibitivo.


AppDomain

• Application Domain (AppDomain): a metà fra processo e thread.

• Come un processo è un contenitore e un limite. Il runtime assegna

codice e risorse agli AppDomain e li isola entro confini di sicurezza.

• Un AppDomain appartiene a un unico processo, ma ogni processo

può contenere diversi AppDomain.

• Un AppDomain è molto meno costoso di un processo da gestire,

buono per gli ISP con centinaia di istanziazioni.

45


Type safety

• Isolamento della memoria

— Consente l’esecuzione sicura di più applicazioni nello stesso processo

• Type safety (sicurezza dei tipi)

—Assicura isolamento della memoria

—Assicura operazioni corrette rispettoal sistema di sicurezza

—Non è richiesta dal Runtime

• Verification

—Assicura type safety


Type safety

• Si eliminano:

— Cast non sicuri

—Variabili non inizializzate

— Indici di array fuori limite (out-of-bounds)

• PEVERIFY.EXE

— Tool linea di comando per verificare requisiti di type safety di un assembly

46

Framework 1.0


Questa e’ stata la prima release ufficiale del .NET Framework, rilasciata il 13 Febbraio 2002 per Windows 98, Me, NT 4.0, 2000 e XP.

Il supporto di Microsoft per questa versione e’ finito il 10 Luglio 2007, mentre il supporto esteso e’ finito il 14 Luglio 2009.

Framework 1.1


• Importante upgrade.

• Disponibile dal 3 aprile 2003, anche da sola come pacchettoridistribuibile o in un SDK, oltre ad essere inserita nella secondarelease del Visual Studio .NET.

• Prima versione di framework che e’ diventata parte di Windows, specificamente di Windows Server 2003.

• Il supporto per il framework 1.1 e’ finito il 14 ottobre 2008, ilsuppporto esteso terminera’ l’8 ottobre 2013.

• Dato pero’ che il.NET 1.1 e’ un componente di Windows Server 2003, il supporto esteso per .NET 1.1 su Server 2003 cessera’ assieme al supporto per quella versione di Windows, quindi il 14 Luglio 2015.

47


Framework 2.0

Non dipende dalle versioni 1.0 e 1.1

• Common Language Runtime (CLR) versione 2.0

• Compilatori per C# 2.0 e Visual Basic 8.0

Caratteristiche

• Supporto per i tipi generici

• Librerie di classi base

• ADO.NET

• ASP.NET

• Windows Form

• Web Service

Novità del 2.0 rispetto a 1.1


• Tipi generici• Supporto per architetture 64-bit.• MOLTI cambiamenti di API.• Integrazione con SQL Server: .Net 2.0, VS 2005 e SQL Server 2005

sono tutti collegati, si possono scrivere stored procedures e lanciarle da un qualunque linguaggio .NET.

• Nuove API per applicazioni native che vogliono ospitare (host) ina istanza del.NET runtime.

• Molti nuovi controlli web ASP.NET.• Classi parziali• Tipi nullable• Metodi anonimi• Iteratori• Data tables

48


Framework 3.0

• È un’estensione del .NET Framework 2.0

• Usa il CLR del .NET Framework 2.0

• Usa i compilatori della versione 2.0

Framework 3.0


• WPF: un nuovo sistema di sviluppo di interfacce utente basato su XML e grafica vettoriale, usa direttamente hardware grafico 3D e tecnologie Direct3D.

• WCF: un sistema di messaggistica service-oriented che permette ai programmi di interoperare in locale o in remoto, in modo analogo ai web services.

• WF: permette di sviluppare task automation e integrated transactions usando workflows.

• Windows CardSpace: un componente software che memorizza in modo sicuro le identita’ digitali e fornisce una interfaccia univoca per scegliere l’identita’ da usare per una particolare transazione (es. log in un sito web).

49


Framework 3.5

• È un’estensione del .NET Framework 2.0

• Si basa sul .NET Framework versione 2.0 e .NET Framework versione 3.0

• Usa il CLR del .NET Framework 2.0

• Nuovo compilatore per C# 3.0 e Visual Basic 9.0

• Aggiunta di classi rispetto al Framework 2.0 e 3.0


Framework 3.5

50

Variazioni da 3.0 a 3.5


• Nuove caratteristiche dei linguaggi C# 3.0 e VB.NET 9.0• Aggiunge supporto per expression trees e espressioni lambda• Extension methods• Tipi anonimi con inferenza statica del tipo• Language Integrated Query (LINQ), assieme a vari suoi providers

(LINQ to Objects, LINQ to XML, LINQ to SQL)• Supporto al paging per ADO.NET• API di sincronizzazione per ADO.NET , per sincronizzare cache locali

e datastore su server• API per I/O asincrono su rete.• Stack di rete per sviluppo peer-to-peer• Wrappers gestiti per API di Active Directory• Miglioramento dei runtime WCF e WF, i servizi WCF possono essere

resi stateful• ASP.NET AJAX.


Caratteristiche supportate

Non solo logica applicativa efficiente e accessibilità via browser, ma

anche:

• Interfacce web funzionalmente uguali ad applicazioni installate in

locale.

• Accesso consistente (stesse primitive) a diverse tipologie di dati:

relazionali, XML, testi, strutture dati, …

• Applicazioni distribuite, strutturate in accordo con una architettura

a servizi (SOA). Le funzionalità sono esposte come servizi

interoperabili, utilizzabili da altri applicativi.

• Interfaccia utente potenziata: include come controlli nelle form

diverse tipologie di documenti, grafica 2D e 3D, audio, video ecc.

51


AJAXAsynchronous JavaScript And XML, è una tecnica di sviluppo di applicazioni web interattive. Evitare che ogni richiesta utente risulti in una chiamata al server e a un reload della pagina

Le applicazioni HTML con AJAX si basano su uno scambio di dati in background fra browser e server, che consente l'aggiornamento dinamico delle parti interessate della pagina web senza esplicito ricaricamento da parte dell'utente.

AJAX è asincrono nel senso che i dati extra sono richiesti al server e caricati in background senza interferire con il comportamento della pagina esistente. Normalmente le funzioni richiamate sono scritte con il linguaggio JavaScript.

A dispetto del nome, l'uso di JavaScript e di XML non è obbligatorio, come non è necessario che le richieste di caricamento debbano essere necessariamente asincrone.


LINQ

I dati su cui lavorano le applicazioni sono disponibili in formati diversi: tabelle relazionali, XML, oggetti in memoria, …

L’accesso a dati diversi tradizionalmente viene fato con modalità diverse (SQL, Xparse, … ).

Language-INtegrated Query (LINQ) permette di usare lo stesso formalismo, simile a SQL, per interrogare sorgenti dati diverse.

LINQ definisce un insieme di operatori che possono essere usati per interrogare, proiettare e filtrare dati in matrici, classi enumerabili, XML, database relazionali e sorgenti dati di terze parti.

Consente l'interrogazione di ogni sorgente di dati che rappresenti i dati sotto forma di oggetti.

52


WCF

Windows Communication Foundation è il supporto .Net per lo sviluppo di applicazioni distribuite (cfr. Service-Oriented Applications, SOA).

WCF è un "sottosistema applicativo" che offre la struttura API per la creazione di applicazioni distribuite in ambienti Windows.

Ogni protocollo di rete (HTTP, FTP, SMTP, ecc.) ha un suo modello di programmazione, e necessita quindi di una conoscenza specifica da parte degli sviluppatori per poter essere utilizzata: WCF è stato realizzato con l'intento di ricondurre ad un unico modello diverse tecnologie, rendendo più semplice ed uniforme la programmazione in ambiente Windows.


WPF• Windows Presentation Foundation è una libreria per lo sviluppo

dell'interfaccia grafica delle applicazioni: approccio unificato a diverse tecnologie per la definizione di interfacce utente.

• Rimozione di ogni legame con il modello di sviluppo tradizionale di Windows. Tutti i controlli sono stati riscritti.

• WPF è basato su un sistema di grafica vettoriale che si appoggia alle DirectX per sfruttare l'accelerazione hardware delle moderne schede grafiche.

• WPF permette di sviluppare interfacce tradizionali a menu, ma anche includere video, animazioni, grafica 2D E 3D, visualizzare diversi tipi di documenti (word, pdf, ecc.) in una unica finestra.

• WPF permette di realizzare applicativi eseguibili anche all'interno di browser web. Il linguaggio usato per la creazione dell’interfaccia utente è XAML (eXtensible Application Markup Language), basato su XML.

53

Framework 4.0


• Parallel Extensions: supporto per parallel computing, target su multi-core o sistemi distribuiti. Verra’ incluso PLINQ (Parallel LINQ), e la Task Parallel Library che espone costrutti paralleli via invocazione di metodi.

• Nuovi elementi dei linguaggi Visual Basic .NET e C#, come statement lambdas, implicit line continuations, dynamic dispatch, named parameters, e parametri opzionali.

• Supporto completo IronPython, IronRuby e F#.

• Supporto per Code Contracts.

• Nuovi tipi per aritmetica a precisione arbitraria (System.Numerics.BigInteger) e numeri complessi (System.Numerics.Complex).


Benefici promessi da .NET

Facilità di utilizzo

— Modelli object-oriented (Tutto è un oggetto)

— Namespace e Framework structure

—Facile da capire e usare

—Lo schema di denominazione dei namespace riflette le funzionalità derivate

Possibilità di scegliere:

— Il linguaggio preferito

— I tool di sviluppo più adatti

— Le funzionalità predefinite a cui collegarsi

54


Benefici promessi da .NETStabilità

— Impossibile avere perdite di memoria (mem. allocata e non rilasciata)

— La memoria è gestita da un garbage collector

— Gli assembly eliminano i problemi di compatibilità delle DLL

— Gli elementi di deploy si limitano agli assembly

Sicurezza

— Si limitano e vincolano i riferimenti illegali alla memoria

— Modello di sicurezza globale

—Specifico di un assembly

—A livello di sistema

—Possibilità di ispezionare il codice MSIL

Critiche


• La applicazioni gestite richiedono piu’ risorse di quelle native che

accedono direttamente al SO.

• MSIL non obfuscated e’ piu’ semplice da disassemblare che codice

nativo. Problemi di perdita di proprieta’ industriale e di aggiramento di

metodi di controllo della licenza. Da Visual Studio .NET (2002),

Microsoft ha incluso un tool per offuscare il codice (Dotfuscator

Community Edition).

• Le nuove versioni del framework (da 3.5 in poi) non sono preinstallate

in versioni di Windows precedenti a Windows 7. Le applicazioni che lo

usano devono supportare gli utenti nella sua istallazione.

• Dimensioni eccessive degli installatori del .NET framework runtime per

end-users. Dimensioni: 54 MB per .NET 3.0, 197 MB per .NET 3.5 e 250

MB per .NET 3.5 SP1 (mentre usando web installer il download per

Windows XP e’ di 50 MB, per Windows Vista di 20 MB). Questo

problema e’ risolto con il .NET 4 installer (x86 + x64), che e’ di 54 MB

ma non comprende i runtime per le versioni precedenti.

55

Critiche


• I framework ancora non supportano chiamate a Streaming SIMD

Extensions (SSE). Mono le ha incluse dalla versione 2.2 nel

namespace Mono.Simd. Il capo sviluppo di Mono, Miguel de Icaza,

spera di fare includere il suo SIMD support nello standard CLR ECMA

standard. Streaming SIMD Extensions sono disponibili nelle CPU x86

fin dal Pentium III. Senza supporto, queste istruzioni sono eseguite

via software.

• Mentre gli standard alla base del .NET sono cross platform,

Microsoft implementa solo per Windows. Microsoft fornisce

implementazioni parziali per altre piattaforme quali XNA for

Windows, XBOX 360 e Windows Phone 7, oltre a Silverlight per

Windows, Mac OSX e Windows Phone 7. Implementazioni

alternative del CLR, base class libraries e compilatori sono sempre

incomplete.

NETintroFULL [modalit compatibilit ]isi-personale.csr.unibo.it/vittorio.maniezzo/did... · Gestione...

Documents

Transcript of NETintroFULL [modalit compatibilit ]isi-personale.csr.unibo.it/vittorio.maniezzo/did... · Gestione...