Elementi di C# 1.0
Delegati ed eventi. Eccezioni. Enumeratori.
Elementi di C# 2.0
Static Classes. Generics e collezioni generiche.Nullable Types. Partial Types e Partial Classes. Anonymous Methods.Iteratori,
Elementi di C# 3.0
Auto-implemented properties.Object Initializers e Collection Initializers. Implicit Typed Variables. Anonymous Types.Extension Methods. Lambda Expression.
Slide quarta lezione al linguaggio Java 8 in preparazione alla certificazione OCA 1Z0-808.
Argomenti:
Design Pattern: Singleton
Classe Astratta
Interfaccia e interfaccia funzionale
Ereditarietà e costruttori
Super e this
Incapsulamento
Polimorfismo
Varargs
Overload e Override
Invocazione virtuale dei metodi
Lezione del 28-11-2017 tenuta da Valerio Radice presso Nextre Engeneering
https://www.nextre.it/corso/corso-java-oca/
Il Corso Programmazione Java Base di K-Tech (http://www.k-tech.it) ha come obiettivo quello di far comprendere le tecniche di programmazione orientata agli oggetti, cioè di modellare e “pensare” a oggetti, di trasmettere i concetti base del linguaggio e le basi per sviluppare piccole applicazioni in modo autonomo.
Il corso Programmazione Java Base è composto da dodici moduli:
1. Introduzione
2. Ciclo di sviluppo
3. Sintassi Elementare
4. Principi OOP
5. Classi e Oggetti
6. Concetti Object Oriented
7. Collections
8. Eccezioni
9. Input Output
10. Serialization
11. Unit Testing
12. Threads
Leggi il programma completo: http://www.k-tech.it/formazione/catalogo/programmazione_java_base
Slide introduttive al linguaggio Java 8 in preparazione alla certificazione OCA 1Z0-808.
Lezione del 12-10-2017 tenuta da Valerio Radice presso Nextre Engeneering
https://www.nextre.it/corso/corso-java-oca/
With Visual Studio 2017, we have a new C # language update. After a brief review of Update 6.0, we'll see what's new. The themes of Update 7 are: Working with Data, Improved Perfomances, and Code Simplification.
Slide quarta lezione al linguaggio Java 8 in preparazione alla certificazione OCA 1Z0-808.
Argomenti:
Design Pattern: Singleton
Classe Astratta
Interfaccia e interfaccia funzionale
Ereditarietà e costruttori
Super e this
Incapsulamento
Polimorfismo
Varargs
Overload e Override
Invocazione virtuale dei metodi
Lezione del 28-11-2017 tenuta da Valerio Radice presso Nextre Engeneering
https://www.nextre.it/corso/corso-java-oca/
Il Corso Programmazione Java Base di K-Tech (http://www.k-tech.it) ha come obiettivo quello di far comprendere le tecniche di programmazione orientata agli oggetti, cioè di modellare e “pensare” a oggetti, di trasmettere i concetti base del linguaggio e le basi per sviluppare piccole applicazioni in modo autonomo.
Il corso Programmazione Java Base è composto da dodici moduli:
1. Introduzione
2. Ciclo di sviluppo
3. Sintassi Elementare
4. Principi OOP
5. Classi e Oggetti
6. Concetti Object Oriented
7. Collections
8. Eccezioni
9. Input Output
10. Serialization
11. Unit Testing
12. Threads
Leggi il programma completo: http://www.k-tech.it/formazione/catalogo/programmazione_java_base
Slide introduttive al linguaggio Java 8 in preparazione alla certificazione OCA 1Z0-808.
Lezione del 12-10-2017 tenuta da Valerio Radice presso Nextre Engeneering
https://www.nextre.it/corso/corso-java-oca/
With Visual Studio 2017, we have a new C # language update. After a brief review of Update 6.0, we'll see what's new. The themes of Update 7 are: Working with Data, Improved Perfomances, and Code Simplification.
Repository Pattern: Un buon design al servizio della testabilità.
Le slides si riferiscono al talk tenuto in Mikamai Milano durante i TDD Meetup di Milano, il 02/05/2017
co-authors: Scola Davide and Maia Nicoletta
Small workshop on Inferno, Limbo and the Dis virtual machine.
Inferno is a new operative system developped for creation and support of network systems and distribuited services.
There are three fundamental programming principles: all resources are files in a hierarchic file system, the network is a unic namespace like a file system hierarchic, it uses Styx that is a standard protocol of comunication for local and remote resources.
Limbo is the programming language for the Inferno OS.
The language is Object Based, you can compile it or interpret it with the Dis virtual machine (like Java virtual machine with a JIT compiler).
Limbo has a native support for: array, string, int, float, tuple (like record), channel (linda-like), and other...
The Limbo's channels are used to comunicate with other processes or with thread.
The Dis virtual machine is an environment for Limbo programs and it has important features: CISC architecture, memory-to-memory, many high level types, just in time compiler, ecc...
In the end of presentation there is a comparison between Dis, Java VM and C# .Net VM.
50 minuti per svelare la tigre, il cavallo e sapere che esiste il delfino.
La nuova versione di Java implementa caratteristiche che da tempo erano attese
nello standard del linguaggio: Metadata, Generic Types, AutoBoxing e
Unboxing dei tipi primitivi, Static import, gestione dinamica dei Loop e delle
Enumeration.
Per Java 6: gestione di SystemTray e motori di scripting.
Vediamo di cosa si tratta e di come poter utilizzare queste nuove feature all'interno dei nostri programmi
Normalmente parliamo e presentiamo Azure IoT (Central) con un taglio un po' da "maker". In questa sessione, invece, vediamo di parlare allo SCADA engineer. Come si configura Azure IoT Central per il mondo industriale? Dov'è OPC/UA? Cosa c'entra IoT Plug & Play in tutto questo? E Azure IoT Central...quali vantaggi ci da? Cerchiamo di rispondere a queste e ad altre domande in questa sessione...
Allo sviluppatore Azure piacciono i servizi PaaS perchè sono "pronti all'uso". Ma quando proponiamo le nostre soluzioni alle aziende, ci scontriamo con l'IT che apprezza gli elementi infrastrutturali, IaaS. Perchè non (ri)scoprirli aggiungendo anche un pizzico di Hybrid che con il recente Azure Kubernetes Services Edge Essentials si può anche usare in un hardware che si può tenere anche in casa? Quindi scopriremo in questa sessione, tra gli altri, le VNET, le VPN S2S, Azure Arc, i Private Endpoints, e AKS EE.
Static abstract members nelle interfacce di C# 11 e dintorni di .NET 7.pptxMarco Parenzan
Did interfaces in C# need evolution? Maybe yes. Are they violating some fundamental principles? We see. Are we asking for some hoops? Let's see all this by telling a story (of code, of course)
Azure Synapse Analytics for your IoT SolutionsMarco Parenzan
Let's find out in this session how Azure Synapse Analytics, with its SQL Serverless Pool, ADX, Data Factory, Notebooks, Spark can be useful for managing data analysis in an IoT solution.
Power BI Streaming Data Flow e Azure IoT Central Marco Parenzan
Dal 2015 gli utilizzatori di Power BI hanno potuto analizzare dati in real-time grazie all'integrazione con altri prodotti e servizi Microsoft. Con streaming dataflow, si porterà l'analisi in tempo reale completamente all'interno di Power BI, rimuovendo la maggior parte delle restrizioni che avevamo, integrando al contempo funzionalità di analisi chiave come la preparazione dei dati in streaming e nessuna creazione di codice. Per vederlo in funzione, studieremo un caso specifico di streaming come l'IoT con Azure IoT Central.
Power BI Streaming Data Flow e Azure IoT CentralMarco Parenzan
Dal 2015 gli utilizzatori di Power BI hanno potuto analizzare dati in real-time grazie all'integrazione con altri prodotti e servizi Microsoft. Con streaming dataflow, si porterà l'analisi in tempo reale completamente all'interno di Power BI, rimuovendo la maggior parte delle restrizioni che avevamo, integrando al contempo funzionalità di analisi chiave come la preparazione dei dati in streaming e nessuna creazione di codice. Per vederlo in funzione, studieremo un caso specifico di streaming come l'IoT con Azure IoT Central.
Power BI Streaming Data Flow e Azure IoT CentralMarco Parenzan
Since 2015, Power BI users have been able to analyze data in real-time thanks to the integration with other Microsoft products and services. With streaming dataflow, you'll bring real-time analytics completely within Power BI, removing most of the restrictions we had, while integrating key analytics features like streaming data preparation and no coding. To see it in action, we will study a specific case of streaming such as IoT with Azure IoT Central.
What are the actors? What are they used for? And how can we develop them? And how are they published and used on Azure? Let's see how it's done in this session
Generic Math, funzionalità ora schedulata per .NET 7, e Azure IoT PnP mi hanno risvegliato un argomento che nel mio passato mi hanno portato a fare due/tre viaggi, grazie all'Università di Trieste, a Cambridge (2006/2007 circa) e a Seattle (2010, quando ho parlato pubblicamente per la prima volta di Azure :) e che mi ha fatto conoscere il mito Don Box!), a parlare di codice in .NET che aveva a che fare con la matematica e con la fisica: le unità di misura e le matrici. L'avvento dei Notebook nel mondo .NET e un vecchio sogno legato alla libreria ANTLR (e tutti i miei esercizi di Code Generation) mi portano a mettere in ordine 'sto minestrone di idee...o almeno ci provo (non so se sta tutto in piedi).
322 / 5,000
Translation results
.NET is better every year for a developer who still dreams of developing a video game. Without pretensions and without talking about Unity or any other framework, just "barebones" .NET code, we will try to write a game (or parts of it) in the 80's style (because I was a kid in those years). In Christmas style.
Building IoT infrastructure on edge with .net, Raspberry PI and ESP32 to conn...Marco Parenzan
The document discusses building an IoT infrastructure on the edge with .NET that connects devices like Raspberry Pis and ESP32s to Azure. It describes setting up a network of Raspberry Pi devices running .NET Core and connecting sensors to collect data and send events to an Apache Kafka cluster. The events are then aggregated using Apache Spark on another Raspberry Pi and the results routed to the cloud. Issues encountered include Kafka's Java dependencies, Spark's complex processing model, and lack of documentation around integrating Pi, Kafka and Spark. While the technologies work individually, configuring and integrating them presented challenges at the edge.
How can you handle defects? If you are in a factory, production can produce objects with defects. Or values from sensors can tell you over time that some values are not "normal". What can you do as a developer (not a Data Scientist) with .NET o Azure to detect these anomalies? Let's see how in this session.
Quali vantaggi ci da Azure? Dal punto di vista dello sviluppo software, uno di questi è certamente la varietà dei servizi di gestione dei dati. Questo ci permette di cominciare a non essere SQL centrici ma utilizzare il servizio giusto per il problema giusto fino ad applicare una strategia di Polyglot Persistence (e vedremo cosa significa) nel rispetto di una corretta gestione delle risorse IT e delle pratiche di DevOps.
- Azure IoT Central provides a fully managed platform for building IoT solutions that is compliant with the Azure IoT platform.
- It offers predictable pricing per device, forces useful modeling practices like device twins and plug and play, and provides industry templates to accelerate solution building.
- While it handles much of the complexity, it also maintains compatibility with customizing solutions using the full Azure IoT platform and other Azure services.
Come puoi gestire i difetti? Se sei in una fabbrica, la produzione può produrre oggetti con difetti. Oppure i valori dei sensori possono dirti nel tempo che alcuni valori non sono "normali". Cosa puoi fare come sviluppatore (non come Data Scientist) con .NET o Azure per rilevare queste anomalie? Vediamo come in questa sessione.
It happens that we have to develop several services and deploy them in Azure. They are small, repetitive but different, often not very different. Why not use code generation techniques to simplify the development and implementation of these services? Let's see with .NET comes to meet us and helps us to deploy in Azure.
Running Kafka and Spark on Raspberry PI with Azure and some .net magicMarco Parenzan
IoT scenarios necessarily pass through the Edge component and the Raspberry PI is a great way to explore this world. If we need to receive IoT events from sensors, how do I implement an MQTT endpoint? Kafka is a clever way to do this. And how do I process the data in Kafka? Spark is another clever way of doing this. How do we write custom code for these environments? .NET, now in version 6 is another clever way to do it! And maybe, we also communicate with Azure. We'll see in this session if we can make it all work!
Time Series Anomaly Detection with Azure and .NETTMarco Parenzan
f you have any device or source that generates values over time (also a log from a service), you want to determine if in a time frame, the time serie is correct or you can detect some anomalies. What can you do as a developer (not a Data Scientist) with .NET o Azure? Let's see how in this session.
2. Agenda
Introduzione al .NET Framework – Marco Parenzan
C# Language Enhancements Evolution
What is new in C# 1.x
What is new in C# 2.0
What is new in C# 3.0
4. Novità in C# 1.0
Introduzione al .NET Framework – Marco Parenzan
Reference Types Enum
Value Types Delegates
Tipi primitivi Eventi
Struct Eccezioni
Class e Ereditarietà Enumeratori
Proprietà Attributi
Namespace
5. Reference Types
Introduzione al .NET Framework – Marco Parenzan
Una qualsiasi dichiarazione di tipo fatta con la parola class indica un
Reference Type
Il riferimento è a una istanza di quel tipo
L’istanza viene creata con l’operatore new
Allocazione nel managed heap
L’assegnazione tra variabili di tipo Reference implica la copia del
riferimento, non dell’oggetto riferito
Una variabile di un reference type accetta null
Invalida il riferimento
Valore di default per una variabile
Non distrugge l’oggetto (Garbage Collection)
Far riferimento ad una variabile null solleva una NullReferenceException
Gli array e le stringhe sono reference types
6. Value Types
Introduzione al .NET Framework – Marco Parenzan
Nel caso di local variables, parameters, loop counters, un
programma ne può fare un uso intensivo
Problemi
Allocazione
Accesso
Rilascio
Uso dello stack
Allocazione e rilascio automatico
Accesso alla memoria efficiente
I value types contengono i valori direttamente, non i riferimenti
Int, char, byte, TimeSpan sono value types primitivi
Se ne possono definire di custom tramite struct
7. Tipi primitivi
Introduzione al .NET Framework – Marco Parenzan
I tipi primitivi sono strutture definite nel namespace
System
È possibile usare il loro nome o il loroBoolean bool Boolean
char Char
alias C# character
sbyte SByte
byte Byte
short Int16
structure name Int32 i = 4; ushort UInt16
C# alias int j; integer
int Int32
same type so uint UInt32
j = i;
can interoperate
long Int64
ulong UInt64
float Single
floating point double Double
decimal Decimal
8. struct
Introduzione al .NET Framework – Marco Parenzan
Possono avere proprietà, metodi, costruttori, membri,
implementare interfacce
Non possono:
Ereditarietà per classe
Valori inizializzati alla definizione
Non possono avere un custom default constructor (senza
parametri)
Un costruttore deve esplicitamente inizializzare tutte le
variabili
9. class e ereditarietà
Introduzione al .NET Framework – Marco Parenzan
Class per definire reference type
Ereditarietà
Single rooted
Multiple Interface
“base” per referenziare la classe base
Le classi non sono polimorfiche di default
I membri non sono virtuali di default
Necessaria la parola chiave virtual
Per identificare un tipo si usa l’operatore is
<variable> is <type>
10. Proprietà
Introduzione al .NET Framework – Marco Parenzan
Le proprietà combinano la sintassi delle variabili
membro con il controllo delle funzioni membro
Permettono di associare ad un nome (con un tipo) le due
funzioni accessorie
Syntactic Sugar
Permettono di definire
Readonly properties
Guarded properties
Calculated properties
11. Namespace
Introduzione al .NET Framework – Marco Parenzan
Qualificano un insieme di classi sotto un unico nome contenitore
Nome COMPLETO della classe: nome del namespace + nome della classe
Livelli>1
Si definiscono in namespace {}
Permettono di disambiguare classi con lo stesso nome
È possibile usare sempre i nomi qualificati
È possibile importare un namespace con la parola chiave using
Permette di definire alias sul namespace: using <alias> = <namespace>
<alias>.<nome classe>
Permette di definire alias sulla classe: using <aliasclasse> = <namespace>.<classe>
<aliasclasse>
È possibile usare la parola using sia dentro che fuori del namespace
La differenza diventa “importante” nel caso nello stesso file ci siano più definizioni di
namespace
Spesso non succede
Esiste un “global” namespace
12. Enum
Introduzione al .NET Framework – Marco Parenzan
La parola chiave enum è usata per definire il nuovo
tipo
Contiene un insieme di costanti simboliche
È possibile definire variabili di un tipo enum, usando I
valori definiti in essa
Di default usa (implicitamente) il tipo int
È possibile fare il cast (esplicito) da/verso il tipo implicito
È possibile specificare un altro tipo primitivo (a parte char)
È possibile assegnare dei valori diretti
È possibile modificare la sequenza dei numeri
13. Delegate
Introduzione al .NET Framework – Marco Parenzan
La parola riservata delegate serve a definire un tipo in grado di puntare a un
metodo e gestire indirettamente la sua invocazione.
Possiamo vedere un delegate come un "puntatore a funzione“
Garantisce che il metodo abbia una specifica firma
Lista ordinata dei tipi dei parametri formali
Non include il tipo di ritorno (ma due funzioni non possono distinguersi per il solo tipo di ritorno)
Offrono la possibilità di chiamare un metodo (anche) in modo asincrono tramite
BeginInvoke e EndInvoke
Un delegato ha dei metodi (è una classe)
<delegate>() è la sintassi contratta di <delegate>.Invoke()
I delegati sono multicast
È possibile assegnare ad un delegate più puntamenti a metodi diversi
Un invocazione sul delegato implica la chiamata a tutti i metodi referenziati
Vengono utilizzati principalmente per:
la gestione degli eventi
L’uso come callback (passare un metodo come “valore” ad un altro metodo)
14. Eventi
Introduzione al .NET Framework – Marco Parenzan
Un evento caratterizza un componente
Qualcosa che succede all’interno del componente e che lo stesso notifica
Un oggetto esterno può sottoscrivere l’evento per essere notificato quando succede
Un evento è una specializzazione di un delegato
event è una parola chiave da associare ad una proprietà di un tipo delegato
event impedisce l’uso dell’assegnazione (“=“) ma solo la sottoscrizione (“+=“) o la
cancellazione (“-=“)
Il mancato uso dell’assegnazione impedisce ad un consumatore generico di rimuovere la
sottoscrizione a qualche altro componente
Qualsiasi delegato può essere usato per un evento
È convenzione usare un delegato del tipo
delegate void <event handler>(object sender, <event args> e)
dove <event args> è una classe che deriva da EventArgs
È possibile creare una variabile membro di tipo evento
È possibile creare una proprietà di tipo evento
Rispetto alle proprietà le funzioni accessorie sono add e remove
15. Eccezioni
Introduzione al .NET Framework – Marco Parenzan
Un’eccezione è un evento sincrono
È prevedibile il punto in cui può avvenire, non il momento
Un’eccezione è un pattern utilizzato per notificare errori
Un’eccezione può essere gestita con un blocco try…catch…finally
Try: blocco che può generare eccezione
Catch: blocco eseguito subito dopo all’istruzione nel blocco try che ha generato l’eccezione
Finally: blocco eseguito comunque dopo il blocco try e l’eventuale blocco catch
Un’eccezione, per essere gestita dal blocco try prende forma di un oggetto che deriva dalla classe
exception
La notifica di un’eccezione si basa sullo stack
Un blocco try…catch…finally viene registrato nello stack
Non è detto che un metodo che chiama un altro metodo che genera una eccezione debba “trappare” una
eccezione
Viene fatto uno “stack walk” per trovare il primo blocco disponibile
Eventualmente quello di default fornito dal framework
È possibile definire una eccezione derivando una nuova classe dal tipo Exception
Si usa l’istruzione throw per sollevare una nuova eccezione
Ci sono delle eccezioni di uso comune
16. Eccezioni comuni
Introduzione al .NET Framework – Marco Parenzan
System.ArgumentException
Thrown when a function is called with a bogus argument. This generally indicates a program bug.
System.ArgumentNullException
Thrown when a function argument is (unexpectedly) null. (It is a subclass of ArgumentException.
System.ArgumentOutOfRangeException
Thrown when a (usually numeric) argument is too big or too small. (It is also a subclass of ArgumentException.) For example, this is
thrown when passing a negative number into a function that accepts only positive values.
System.InvalidOperationException
Thrown when the state of an object is unsuitable for a method to successfully execute, regardless of any particular argument values.
Examples include reading an unopened file or getting the next element from an enumerator where the underlying list has been
modified partway through the iteration.
System.NotSupportedException
Thrown to indicate that a particular functionality is not supported. A good example is calling the Add method on a collection for
which IsReadOnly returns true.
System.NotImplementedException
Thrown to indicate that a function has not yet been implemented.
System.ObjectDisposedException
Thrown when the object upon which the function is called has been disposed.
17. Enumeratori
Introduzione al .NET Framework – Marco Parenzan
Un enumeratore è un cursore read-only forward only
Permette di visitare una collezione di elementi
Si basa su due interfacce
IEnumerator: l’enumeratore vero e proprio
IEnumerable: permette di richiedere ad una collezione un
enumeratore per visitare la stessa
Usato dal costrutto foreach
18. Attributi
Introduzione al .NET Framework – Marco Parenzan
Permettono di associare metadati agli elementi di definizione di una classe
(classe, metodo, variabile, proprietà, …)
Sono informazioni disponibili a runtime tramite reflection
<object>.GetType().GetMember()
Permettodo di implementare algoritmi basati sulla struttura stessa della
classe, decidendo in base agli attributi
Un esempio su tutti: serializzazione
Atttributi Standard (dalla BCL)
Attributi Custom
Classi derivate da System.Attribute
Accessibili tramite Attribute.GetCustomAttribute(<memberinfo>)
Sintassi:
[<attribute>Attribute(positional parameters, named parameters….)]
20. Novità in C# 2.0
Introduzione al .NET Framework – Marco Parenzan
Static Classes
Generics
Nullable Types
Partial Types
Anonymous Methods
Iterators
21. Static Classes
Introduzione al .NET Framework – Marco Parenzan
Contengono solo metodi statici
Non membri di istanza
Serviranno per gli Extension Methods
public static class Math
{
public static double Sin(double x) {…}
public static double Cos(double x) {…}
…
}
22. Generics
Introduzione al .NET Framework – Marco Parenzan
Cosa sono i generics?
Polimorfismo Parametrico
Funziona sia con reference and value types
Controllo dei tipi in fase di dichiarazione
No boxing (value types)
No downcasts (no object)
Supporto completo a runtime
Reduced code bloat
Non bisogna scrivere classi wrapper tipizzate
23. Come possono essere usati?
Introduzione al .NET Framework – Marco Parenzan
Con varie definizione di tipo
Class, struct, interface and delegate
Per specificare variabili membro, parametri, valori di
ritorno
25. Various other Generic Classes
Introduzione al .NET Framework – Marco Parenzan
System.Collections.ObjectModel classes
Collection<T>
KeyedCollection<T>
ReadOnlyCollection<T>
Various Other Classes
Nullable<T>
EventHandler<T>
Comparer<T>
26. Nullable types
Introduzione al .NET Framework – Marco Parenzan
Int è un value type e non può accettare il null (reference type)
Utile nel momento in cui mappiamo gli attributi di una tabella di database (tutti
gli attributi di una tabella di DB possono essere nullabili)
Applicazione dei generics
Nullable<T>
T è un tipo primitivo (value type/struct)
Rende possibile la sintassi
int? x = null;
Int? è equivalente a Nullable<int>
Il cast può essere:
Implicito: int? x = 5;
Esplicito: int y = (int) x; // perché bisogna verificare se non sia null
int y = 0;
if (x.HasValue) y = (int) x;
27. Tipi parziali (Partial Types)
Introduzione al .NET Framework – Marco Parenzan
È possibile spezzare una dichiarazione in più files
Utile quando c’è un designer/generatore di codice
Ottimo anche per organizzare il codice
Una partial class per ogni interfaccia implementata
Tipi supportati
Classes (Partial Classes)
Struct
Interface
Divisi a design time, “fusi insieme” a compile time
28. Anonymous Methods
Introduzione al .NET Framework – Marco Parenzan
Permettono di definire direttamente il codice dove è
necessario un delegato
Il tipo dei delegati viene automaticamente
inferenziato (non serve istanziare esplicitamente il
delegato, ma scrivere solo il corpo)
button.Click += delegate(object sender, EventArgs e) {
MessageBox.Show(((Button)sender).Text);
};
29. Anonymous Methods
Introduzione al .NET Framework – Marco Parenzan
I blocchi di codice possono accedere alle variabili locali
Non possono però accedere a parametri (di un metodo in
cui sono definiti) ref o out
Ovvio, in quanto la loro esecuzione non è legata
all’invocazione del metodo di definizione
La vita delle variabili locali è “estesa” fino a che il delegato
che le referenzia non è eligibile di garbage collection
Tutto è dovuto a generazione nascosta di classi
int n = 0;
Del d = delegate() { System.Console.WriteLine("Copy #:{0}", ++n);
};
30. Iteratori
Introduzione al .NET Framework – Marco Parenzan
È possibile usare la
parola chiave yield
yield return e yield
break
Bisogna restituire
IEnumerator o
IEnumerable
public class List
{
public IEnumerator GetEnumerator() {
for (int i = 0; i < count; i++) {
yield return elements[i];
}
}
}
32. What is new in C# 3.0
Introduzione al .NET Framework – Marco Parenzan
Auto-Implemented Properties
Object Initializers
Implicit Typed Variables
Anonymous Types
Extension Methods
Partial Methods
Lambdas
Expression Trees
The “real”Query Expressions
33. Autoimplemented Properties
Introduzione al .NET Framework – Marco Parenzan
Permettono di specificare una proprietà senza doverne specificare il field
privato
Velocizza il processo di creazione di proprietà all’interno delle classi
Il membro privato viene generato a compile-time
Per vedere il nome del field privato generato, è necessario utilizzare
ildasm.exe o Reflector.exe
Non è possibile utilizzarle per specificare proprietà in read-only o write-
only
E’ possibile limitare l’accesso al get o al set di una proprietà, specificandone la
visibilità
Non è possibile specificare un valore di default a causa del membro
privato che non è presente
Nel costruttore della classe si può intervenire impostando il valore di default
34. Object Initializers
Introduzione al .NET Framework – Marco Parenzan
È possibile inizializzare variabili membro e proprietà,
senza richiamare il costruttore in modo esplicito
new C(1, 2, name=“my class”);
Valgono le regole di visibilità
È possibile fare annidamento
Initializzare grafi
Collection initializers
List<int> digits = new List<int> { 0, 1};
Deve implementare System.Generic.ICollection<T>
Object initializers
var a = new Point { X = 0, Y = 1 };
35. Implicitly typed variables
Introduzione al .NET Framework – Marco Parenzan
E’ possibile dichiarare le variabili in modo implicito, utilizzando la parola chiave
“var”
var i = 5;
var s = "Hello";
var d = 1.0;
var orders = new Dictionary<int,Order>();
Il tipo delle variabili è indotto dalla espressione che lo inizializza
DEVE INCLUDERE L’INIZIALIZZAZIONE
“var” non è variant o object
È comunque statically typed
Non può essere null
Var può essere usata SOLO nei metodi
Non può essere usata a livello di classe
Attenzione all’abuso
Bisogna capire il contesto dell’esecuzione per capire cosa c’è dentro
E’ possibile utilizzare la keywork “var” anche all’interno di cicli for e foreach
36. Anonymous Types
Introduzione al .NET Framework – Marco Parenzan
È una “tupla” le cui proprietà specifiche sono inferenziate tramite Object Initializer
Viene fatto a compile time, quindi è sempre comunque statically/strongly typed
Internamente viene creata una classe nascosta
var x = new {p1 = 10, p2 = “name”};
Il tipo di x è anonimo
Non è possibile referenziarlo “per nome” da codice
structural type equivalence
Due tipi anonimi possono essere compatibili
Viene ricostruita la “compatibilità” a compile time
Viene definito un solo nuovo tipo (anonimo)
La classe verrà generata automaticamente in fase di compilazione, e deriverà da System.Object
implicitly typed arrays
var a = new[] { 1, 10, 100, 1000 };
Devono avere tipi compatibili
O conversioni implicite
37. Extension methods
Introduzione al .NET Framework – Marco Parenzan
È possibile aggiungere metodi a classi già definite
È possibile aggiungere metodi a classi già compilate, in assembly diversi
Non sono mixin (dai dynamic languages)
Sono “syntactic sugar”
Readability
Solo metodi
Non per properties, events, operators (almeno per adesso)
Metodi statici in classi statiche
La chiamata esplicita al metodo statico avviene sempre (e rimuove
ambiguità)
Nel caso di sovrapposizione con metodi locali
I metodi locali hanno la precedenza
L’inserimento degli extension method avviene al momento
dell’importazione del namespace
38. Extension methods
Introduzione al .NET Framework – Marco Parenzan
public static class Extensions
{
public static int ToInt32(this string s) {
return Int32.Parse(s);
}
public static T[] Slice<T>(this T[] source,
int index, int count) {
if (index < 0 || count < 0 ||
source.Length – index < count)
throw new ArgumentException();
T[] result = new T[count];
Array.Copy(source, index, result, 0, count);
return result;
}
}
39. Partial Methods
Introduzione al .NET Framework – Marco Parenzan
E’ stata aggiunta la possibilità di definire un metodo come “partial”
Permette di definire un metodo in una parte della classe, e poterlo
implementare in un’altra parte della classe
Utile in caso di uso dei generatori di codice
Non necessità di ereditarietà di metodi virtuali
I metodi dichiarati come “partial” hanno delle limitazioni:
Devono essere definiti all’interno di una partial class
Devono sempre ritornare void
Possono avere argomenti, ma non con clausula “out”
Sono sempre implicitamente privati
Se un metodo partial non viene implementato, questo non compare
nel codice compilato (nemmeno la chiamata del metodo)
40. Lambda expressions
Introduzione al .NET Framework – Marco Parenzan
Permettono di definire delle funzioni “inline”, associando
direttamente un blocco di codice
Permettono di creare un metodo “stand-alone” all’interno del codice
(utilizzando gli anonymous methods)
Sono un’ulteriore semplificazione rispetto l’uso dei delegate
Dal calcolo lambda
x.x+1
In C# 3.0
x => x + 1
Dalla sintassi delle anonymous functions
delegate(int x) { return x + 1;}
Possono usare variabili implicitamente tipizzate
Possono avere più di una variabile
Il corpo può contenere espressioni o istruzioni
41. Esempi di Lambda Expressions
Introduzione al .NET Framework – Marco Parenzan
x => x + 1
// Implicitly typed, expression body
x => { return x + 1; }
// Implicitly typed, statement body
(int x) => x + 1
// Explicitly typed, expression body
(int x) => { return x + 1; }
// Explicitly typed, statement body
(x, y) => x * y
// Multiple parameters
() => Console.WriteLine()
// No parameters
42. Lambda to Delegates
Introduzione al .NET Framework – Marco Parenzan
Una lambda expression è un valore,che non ha tipo, ma può essere convertito in un particolare delegato
delegate R Func<A,R>(A arg);
Func<int,int> f1 = x => x + 1;
// Ok
Func<int,double> f2 = x => x + 1;
// Ok
Func<double,int> f3 = x => x + 1;
// Error – double cannot be
// implicitly converted to int
Nel framework sono predefiniti dei delegates “standard”
public delegate TResult Func<TResult>();
public delegate TResult Func<T, TResult>(T a);
public delegate TResult Func<T1, T2, TResult>(T1 a, T2 b);
public delegate TResult Func<T1, T2, T3, TResult>(T1 a, T2 b, T3 c);
public delegate TResult Func<T1, T2, T3, T4, TResult>(T1 a, T2 b, T3 c, T4 d);
public delegate void Action();
public delegate void Action<T>(T a);
public delegate void Action<T1, T2>(T1 a, T2 b);
public delegate void Action<T1, T2, T3>(T1 a, T2 b, T3 c);
public delegate void Action<T1, T2, T3, T4>(T1 a, T2 b, T3 c, T4 d);
43. Expression trees
Introduzione al .NET Framework – Marco Parenzan
Forniscono una rappresentazione ad
oggetti di una lambda expression.
Sono assimilabili agli AST generati
da un compilatore per creare il
codice “a compiler time”
L’expression tree è accessibile a runtime
Le lambda expression possono
essere convertite in un expression
tree
Expression<Func<T>> e = x => x + 1;
Sono compilati, strong-typed,
provider independent e
serializzabili.
Sono Immutabili, e quindi per
modificarne una sua parte, si deve
creare un nuovo Expression Tree
44. Visita e costruzione
di un Expression Tree
Introduzione al .NET Framework – Marco Parenzan
// Create an expression tree. // Create the parameter "x" in x + 1
Expression<Func<int, bool>> exprTree = num => num < 5; ParameterExpression p0 = Expression.Parameter(typeof(int),
"x");
// Decompose the expression tree.
// Create the constant 1 in x + 1
ParameterExpression param =
(ParameterExpression)exprTree.Parameters[0]; ConstantExpression c0 = Expression.Constant(1);
BinaryExpression operation =
(BinaryExpression)exprTree.Body;
// Build the addition expression x + 1 using the above
ParameterExpression left =
(ParameterExpression)operation.Left; // Note it will really look like Add(x,1)
ConstantExpression right = BinaryExpression expression = Expression.Add(p0, c0);
(ConstantExpression)operation.Right;
// Create the Lamda Expression x => Add(x,1)
Console.WriteLine("Decomposed expression: {0} => {1} {2} var lambdaExpression = Expression.Lambda<Func<int,int>>
{3}", (expression, new ParameterExpression[] { p0 });
param.Name, left.Name,
operation.NodeType, right.Value);
// Let's compile it so we can use it
var theDelegate = lambdaExpression.Compile();
/* This code produces the following output:
// Execute... 6 + 1 = 7
Decomposed expression: num => num LessThan 5
var seven = theDelegate.Invoke(6);
*/
46. Query Expressions
Introduzione al .NET Framework – Marco Parenzan
Fornisce delle API che permetteno di eseguire delle query
expression (sia in lettura che scrittura) verso classi che
implementano IEnumerable<T>, database relazionali,
DataSets, o documenti XML. (etc etc ...)
Definiscono delle query verso una sorgente dati,
utilizzando dei query operators (es: from, in, where,
orderby, e select)
Le LINQ query expression sono strongly typed. Il
compilatore verificherà la corretta sintassi delle query.
Il tipo di dati ritornato è del tipo IEnumerable<T>
47. Query Expressions
Introduzione al .NET Framework – Marco Parenzan
Query expressions or LINQ (Language INtergrated Queries) are the
key feature of .NET 3.5
Query expressions are translated to method calls works on classes
like:
delegate R Func<A,R>(A arg);
class C<T>
{
public C<T> Where(Func<T,bool> predicate);
public C<S> Select<S>(Func<T,S> selector);
public C<S> SelectMany<S>(Func<T,C<S>> selector);
public O<T> OrderBy<K>(Func<T,K> keyExpr);
public O<T> OrderByDescending<K>(Func<T,K> keyExpr);
public C<G<K,T>> GroupBy<K>(Func<T,K> keyExpr);
public C<G<K,E>> GroupBy<K,E>(Func<T,K> keyExpr, Func<T,E> elemExpr);
}
48. Sintactic sugar
Introduzione al .NET Framework – Marco Parenzan
string[] londoners =
from c in customers
where c.City == “London”
select c.Name;
string[] londoners =
customers.
Where(expression).
Select(expression);
49. Lambda Expressions
Introduzione al .NET Framework – Marco Parenzan
What is this?
customers.Where(City == “London”)
Expression?
Data Structure? Code fragment?
Local Query
Anonymous method?
vertices.Where(X > Y)
vertices.Where(delegate(Point p)
{ return p.X > p.Y; })
50. Lambda Expressions
Introduzione al .NET Framework – Marco Parenzan
Remote Query
== Remotable
customers.Where(delegate(Customer c) {
return c.City == “London”})
c.City “London”
Inspectable
customers.Where(Expr.Delegate(
Expr.Param(“c”), AST
Expr.EQ( IL doesn’t travel
Good for API’s well
Expr.Property(
Expr.Param(“c”),
“City”),
Still no type Expr.Literal(“London”))
checking?
But please don’t
make me write this
51. Lambda Expressions
Introduzione al .NET Framework – Marco Parenzan
Better if something like
this …
customers.Where(City == “London”)
or this
Expr.Delegate(
delegate(Customer c) {
Expr.Param(“c”),
return c.City == “London”
Expr.EQ(
}
Expr.Property(
Expr.Param(“c”),
“City”),
could become this Expr.Literal(“London”)
))
52. Lambda Expressions
Introduzione al .NET Framework – Marco Parenzan
Parameterized
fragments of code
public delegate Func<T,bool>(T t)
Func<Customer,bool> f = c => c.City == “London”;
Coercible to delegates
Expression<Func<Customer,bool>> e = c=> c.City == “London”;
or Expression types
Syntax is the same
53. Definizione ed esecuzione
Introduzione al .NET Framework – Marco Parenzan
La definizione di una query è differente dalla sua
esecuzione
Questo è necessario perché il modello di
interrogazione deve essere componibile
Componibile è necessario per rendere “accettabile” la
definizione della query
Vale soprattutto se l’esecuzione deve essere eseguita
remotamente (da una definizione locale)
Si parla di esecuzione “differita” (DEFERRED)
54. Query Execution
Introduzione al .NET Framework – Marco Parenzan
Una query expression
viene eseguita quando
• Per avere una esecuzione
viene valutata immediata della query, si possono
int[] numbers = { 10, 20, 30, 40, 1, 2, 3, 8 }; utilizzare i metodi ToArray<T>(),
var subset = from i in numbers where i < 10 select i; ToDictionary<TSource,TKey
// LINQ statement evaluated here! int[] numbers = { 10, 20, 30, 40, 1, 2, 3,
8 };
foreach (var i in subset)
Console.WriteLine("{0} < 10", i);
// Get data RIGHT NOW as int[].
// Change some data in the array.
int[] subsetAsIntArray =
numbers[0] = 4; (from i in numbers
// Evaluate again. where i < 10 select i).ToArray<int>();
foreach (var j in subset)
Console.WriteLine("{0} < 10", j); // Get data RIGHT NOW as List<int>.
List<int> subsetAsListOfInts = (from
i in numbers where i < 10 select
i).ToList<int>();