Cancellazione rivista settimanale

Vi avviso della cancellazione dell’indirizzo http://galaxydotnet.bell1.net/ con la mia “rivista settimanale” con le notizie dal mondo .NET …

Il nuovo indirizzo è The Galaxy of .NET .NET Programming.

Le novità di C#

I team di sviluppo di Microsoft continuano a sfornare novità nei linguaggi .NET e anche questa volta non si smentiscono.

In Visual Studio 2015 sono state introdotte alcune novità al linguaggio C#, nella versione 6.0, che sono veramente interessanti.

Per approfondire nella maniera più corretta, vi segnalo due articoli:

http://www.winfxitalia.com/articoli/netfx46/novita-csharp-6.aspx (in italiano, dal sito ASPitalia.com)

http://www.codeaddiction.net/articles/15/10-features-in-c-that-you-really-should-learn-and-use (in inglese, dal sito CodeAddiction.net)

Windows 10 su MSDN Magazine di ottobre 2015

Mi è appena arrivato il nuovo numero (ottobre 2015) di MSDN Magazine e come al solito gli ho dato una veloce occhiata per capire su cosa puntavano gli articoli.

image

 

Infatti, MSDN Magazine, essendo la rivista ufficiale degli sviluppatori Microsoft, come è ovvio ha sempre un occhio di riguardo per le ultime novità sul mondo della programmazione e quindi già dall’indice degli articoli si può capire quali sono le ultime novità e cosa sta bollendo in pentola.

Questo mese MSDN Magazine offre una serie di articoli, oserei dire uno “special”, su Windows 10, come si può vedere anche dall’indice degli articoli:

image

 

Quindi, Windows 10 e Universal Windows Apps: un’accoppiata vincente.

Se avete la disponibilità di MSDN Magazine (ovviamente se avete sottoscritto un abbonamento, che in edizione digitale costa solo 25 dollari senza sottoscrizione MSDN, oppure gratuito se avete una sottoscrizione MSDN) vi consiglio di dare un’occhiata e di leggere gli articoli. In caso contrario, potete leggere gli articoli alla pagina https://msdn.microsoft.com/it-it/magazine/win10issue (tra qualche settimana potrete anche scaricare il PDF dell’intero numero).

Giusto per completare, vi informo che alla pagina https://msdn.microsoft.com/it-it/magazine/ee310108.aspx trovate anche tutti i numeri precedenti, scaricabili anche in PDF (i numeri del 2008 e precedenti sono in formato .CHM).

Buona lettura! Sorriso

Lean startup

La puntata #44 di dotNetPodcast riguarda l’approccio Lean per la gestione di una startup.

image

Ma cos’è una startup? Nella letteratura ci sono parecchie definizioni di startup, a seconda di come la si considera, “forse si fa prima a dire cosa NON è una startup: una startup non è una piccola azienda. Questo è il primo errore che si possa fare.

Questa è una delle numerose chicche che ho ripreso dallo speech di Felice Pescatore.

Vi consiglio di ascoltare questo podcast, soprattutto se volete avviare una nuova startup.

Gestire le directory con C#

Credo che questo sia il mio primo post su C# e quindi voglio iniziare da qualcosa di semplice. Bisogna pur partire da qualcosa, no?

Impariamo come si crea, come si sposta e come si cancella una directory.

Per lavorare sulle directory bisogna ricordarsi di due cose:

  • caricare il namespace System.IO
  • utilizzare la classe Directory

Vediamo quindi una possibile classe, molto semplice, che contenga le tre istruzioni di creazione, spostamento e cancellazione di una directory.

using System.IO;
class GestisciDirectory {
public static void Main {
Directory.CreateDirectory(“C:\\prova1”);
Directory.CreateDirectory(“C:\\prova2”);
Directory.CreateDirectory(“C:\\prova2\spostami”);
Directory.Move(“C:\\prova2\spostami”, “C:\\prova1”);
Directory.Delete(“C:\\prova1”, true);
Directory.Delete(“C:\\prova2”, true);
}
}

L’argomento “true” passato al metodo Delete serve per cancellare la directory in modo ricorsivo, cioè per eliminare anche tutto il contenuto.

Visual Basic – tip "Sostituire Image.FromFile risparmiando risorse"

In questa pagina della community Visual Basic Tips & Tricks potete trovare un suggerimento di Diego Cattaruzza per sostituire Image.FromFile che ha qualche problema di rilascio di risorse.

Se utilizzate normalmente Image.FromFile, è consigliabile seguire le indicazioni di cui sopra.

Cartella "Preferiti" di Windows 10 (promemoria)

Con Windows 10 è arrivato anche il nuovo browser Microsoft Edge che cambia drasticamente la gestione dei Preferiti, in un modo che a mio avviso è assolutamente inadeguato e inefficace. Speriamo che in un prossimo aggiornamento di Windows 10 o di Edge ci sia qualche miglioramento, perché così proprio non va…

A futura (mia) memoria, il percorso dove sono nascosti i Preferiti è questo

C:\Users\Mario\AppData\Local\Packages\
Microsoft.MicrosoftEdge_8wekyb3d8bbwe\
AC\MicrosoftEdge\User\Default\Favorites\Links

dove ovviamente “Mario” è il nome del mio profilo (ma va?).

Un consiglio? Andate nella vostra cartella dei preferiti e trascinate tutto fuori in una vostra cartella. In questo modo potrete modificare i link nelle proprietà.

[VB] Leggere un file riga per riga con righe vuote

Con questo post riprendo una breve discussione di qualche anno fa, in cui il problema esposto riguardava lo scorrimento di un file di testo “riga per riga”, con la presenza di righe vuote.

Infatti, con il seguente codice, all’arrivo di una riga vuota, l’esecuzione esce dal ciclo:

do
   buf=str.readline
   …
loop while buf=nothing

 

L’altro difetto di questo frammento di codice, anche ammettendo che non esistano righe vuote all’interno delle “righe valide” è che deve esserci una riga vuota alla fine del file, altrimenti non viene rilevata la fine del file e il programma solleva un’eccezione.

La soluzione migliore è questa:

Using sr As New System.IO.StreamReader(nomeFile)
    Do Until sr.EndOfStream
        Try
            Dim sBuf As String = sr.ReadLine
            ‘ fai qualcosa (1)

        Catch ex As Exception
            ‘ gestisci l’eccezione
        End Try
    Loop
End Using

Infatti, l’uso di sr.EndOfStream permette di rilevare la fine effettiva del file, indipendentemente dal contenuto delle righe.

Attenzione che nella sezione Try (1) dovete inserire del codice per leggere il contenuto della riga e se questo contenuto consiste in una riga vuota, dovete scartare la riga (ovvero ignorarla).

Future Decoded – Roma, 12 novembre 2015

Lo volete un consiglio? Anche se non lo volete ve lo dò lo stesso…

Il 12 novembre 2015 …

… non prendete impegni!

 

Banner 1

 

Perché? Volete anche sapere perché?

Perché ve lo dico io, no?  Sorriso

 

http://www.microsoft.com/italy/futuredecoded/

Imparare F# giorno per giorno, anzi… day by day!

Un interessante progetto open source, su GitHub, permette di imparare il linguaggio F# giorno per giorno, nel senso che ogni giorno viene aggiunto del codice e la spiegazione del funzionamento di una specifica caratteristica del linguaggio.

Il progetto, che si chiama fsharpdaybyday, si trova al seguente indirizzo:

https://github.com/ccdschool/fsharpdaybyday

image

Il progetto contiene una cartella per ciascuna settimana e ogni cartella contiene 5 cartelle, una per ogni giorno feriale, con la spiegazione di una caratteristica del linguaggio F#.

Il progetto non è pensato per essere effettivamente un’applicazione eseguibile, anche se un po’ di codice applicativo c’è realmente, ma ha l’obiettivo di essere semplicemente un tutorial testuale da consultare direttamente nelle pagine del progetto GitHub.

La modalità di apprendimento “giorno per giorno” è probabilmente quella migliore per riuscire a padroneggiare un linguaggio di programmazione come F#, senza perdere il filo del discorso e senza disperdere energie.

Buona lettura!

Parlare in pubblico (podcast)

image_thumb[6]

Se nel vostro lavoro dovete parlare in pubblico, fare presentazioni, registrazioni audio e video e cose simili, come è capitato varie volte anche a me, vi consiglio di ascoltare questo podcast!

image

Lorenzo Barbieri, che conosco anche di persona e che apprezzo molto per la sua competenza e “umanità”, in questa presentazione è veramente strepitoso e tocca tutti i tasti dolenti.

image

Io ho ascoltato con vero piacere, anche perché alcune situazioni sono capitate anche a me, come quella volta che dovevo presentare un mio progetto al WPC ad Assago (mi pare nel 2010), avevo messo il portatile in “ibernazione” per non consumare la batteria. Al momento cruciale il portatile non ripartiva più… panico!

Vi assicuro che i suoi consigli sono assolutamente corretti e appropriati!

Buon ascolto.

Novità nel programma MVP Award

Sono appena stato rinominato Microsoft MVP per la categoria .NET (prima sono stato per vari anni in quella di Visual Basic, poi per un anno in F# e infine .NET che include tutti e tre i linguaggi) che da ottobre 2015 c’è un nuovo cambiamento:

https://mvp.microsoft.com/en-us/pages/mvp-award-update

image

Come si può vedere nella pagina sopra indicata e nell’immagine, ora la categoria .NET sarà inclusa in una più ampia categoria “Visual Studio and Development Technologies”. Nella stessa pagina potete vedere altri raggruppamenti di varie tecnologie in 10 categorie principali.

La strategia di Microsoft e in particolare del programma MVP Award è quella di non rinchiudere gli MVP a una categoria troppo ristretta. Chi si occupa di un linguaggio ha anche a che fare sempre con Visual Studio (compreso Visual Studio ALM) e potrebbe anche occuparsi di sviluppo web con ASP.NET (in VB e C#, oppure JavaScript), con la sicurezza (Developer Security), magari sviluppa applicazioni multipiattaforma per dispositivi mobili (Xamarin) e così via.

Ecco quindi che nella mia categoria potrò spaziare in argomenti più vasti e trasversali a molti aspetti inerenti lo sviluppo di applicazioni su diverse piattaforme.

Great job!

Introduzione a F# (podcast)

Se siete curiosi di sapere cos’è F# e a cosa serve, vi consiglio di ascoltare questo podcast con Alessandro Melchiori:

http://www.dotnetpodcast.com/show/card/31

image

 

Le oltre 50 puntate (ad oggi sono 56) di DotNetPodcast sono veramente interessantissime, con una formula azzeccata e ormai ampiamente collaudata, e coprono numerose tecnologie Microsoft in ambito DotNet.

image

Buon ascolto!

Small Basic 1.2

E’ stata rilasciata la nuova versione (1.2) di Small Basic:

http://blogs.msdn.com/b/smallbasic/archive/2015/10/01/small-basic-1-2-released-with-kinect-support-and-bug-fixes.aspx

Le novità riguardano il supporto a Kinect e alcune correzioni di bug.

Alcuni anni fa ho scritto un articolo pubblicato su ioProgrammo… prima o poi scriverò ancora qualcosa, perché credo che sia un ottimo linguaggio di programmazione adatto alla didattica.

Cos’è U-SQL? (suggerimento: Big Data)

Confesso che lavoro con grandi moli di dati e ho sempre avuto qualche problema nel trattarli: ovvero, come fare ad importarli in una tabella di SQL Server senza diventare matti? Access con grossi volumi di dati diminuisce rapidamente di prestazioni e il file non è nemmeno esaminabile con Notepad perché è troppo grande.

In questi casi ho lavorato sulla singola riga: caricamento della riga, scomposizione in diversi campi utilizzando le variabili, scrittura di un nuovo record. Funziona ma è molto lento.

Sono rimasto sbalordito, quindi, da questo post:

http://blogs.msdn.com/b/visualstudio/archive/2015/09/28/introducing-u-sql.aspxv

Con questo linguaggio si può fare un grande lavoro con istruzioni come questa:

image

Che dire? Al lavoro con U-SQLSorriso

Microsoft MVP per l’8^ volta!

Ancora una volta sono stato rinominato Microsoft MVP: quest’anno è l’ottava nomina di questo prestigiosissimo premio!

MVP_Horizontal_FullColor

Con questo post ringrazio Microsoft Corp. e personalmente Cristina Gonzales Herrero, MVP Lead per EMEA, e la sua più stretta collaboratrice nell’ambito del programma MVP, Marjorie Di Clemente.

Molti si congratulano con me per la nomina “anche se non so cosa vuol dire”… Visto che molti “non addetti ai lavori” non conoscono il programma Microsoft MVP mi riprometto in un prossimo post di spiegare meglio di cosa si tratta.

Per il momento lasciatemi gioire del mio 8° traguardo!  Sorriso

Nuove funzionalità di C# 6.0 (VS 2015)

In Visual Studio 2015 è inclusa la sesta versione di C#, una versione che ci offre sul piatto d’argento numerose nuove funzionalità molto interessanti.

In questo articolo trovate alcuni esempi delle 15 nuove caratteristiche più interessanti:

15 Cool New Features in C# 6.0
http://immortalcoder.blogspot.in/2015/09/15-cool-new-features-in-c-6.html

L’articolo è in inglese, ma gli esempi sono semplici e ben formulati, quindi non dovrebbero esserci problemi di comprensione anche da parte di chi non conosce benissimo la lingua.

Office 2016!

Finalmente è arrivata la nuova versione Office 2016!

In questa versione, oltre all’integrazione con Windows 10 (ovviamente), potete trovare una maggiore focalizzazione agli strumenti per la collaborazione nei gruppi di lavoro (team working). Per esempio, direttamente all’interno delle applicazioni è possibile utilizzare Skype for Business per chattare con i colleghi e condividere il video, in modo da poter collaborare a distanza.

Un altro strumento orientato ai gruppi di lavoro è Planner che permette ai team di organizzare il proprio lavoro, organizzare e assegnare i compiti, le scadenze previste e lo stato di aggiornamento dei progetti. Sarà possibile avere, separatamente per ciascun team di lavoro, una casella di posta, un calendario, uno spazio sul cloud e un “blocco note” di OneNote.

A questo si aggiunge una maggiore integrazione con OneDrive, in particolare su OneDrive for Business, ma anche una propensione all’utilizzo su qualsiasi dispositivo (PC, tablet, smartphone).

Ecco dunque qualche immagine, tratta dalla pagina ufficiale del blog di Office (https://blogs.office.com/2015/09/22/thenewoffice/):

The new office is here 1 v2

 

 

 

The new office is here 4 v2

 

Template10, un nuovo approccio per Universal Windows App

In questo post vi presento una serie di post (scusate il gioco di parole) scritti da Matteo Pagani e pubblicati nel blog ufficiale del team MSDN Italia:

Guest post- Template10, un nuovo approccio nello sviluppo di Universal Windows app – Le basi

Guest post- Template10, un nuovo approccio nello sviluppo di Universal Windows app – I controlli

Guest post- Template10, un nuovo approccio nello sviluppo di Universal Windows app – Il pattern

Si tratta di tre articoli introduttivi su questo template ancora in fase di sviluppo ma già utilizzabile dagli sviluppatori per semplificare il proprio percorso di sviluppo di nuove applicazioni basate su MVVM o su code behind, utilizzabili su qualsiasi dispositivo (Universal Windows App).

Il progetto è scaricabile da NuGet ma bisogna abilitare l’opzione Include prerelease, perché il pacchetto è ancora rilasciato in fase beta.

In ogni caso penso che lo sforzo di alcuni sviluppatori di creare nuovi template come questo, tesi a semplificare il lavoro, giustifichi un po’ di studio da parte nostra per sfruttare al meglio tutte le opportunità che ci vengono offerte.

L’obiettivo, infatti, è sempre quello di migliorare la produttività, ma mantenendo alta la qualità delle applicazioni rilasciate. Se questo vuol dire continuare a studiare e imparare cose nuove, ben venga, vuol dire che manterremo il nostro cervello sempre allenato e potremo ridurre i rischi di brutte malattie come l’Alzheimer! (scusate per la citazione dovuta a una specie di mia “deformazione professionale”)…

Good coding! Sorriso

“10 motivi per usare F#” (infografica)

Non è una cosa banale o un puro esercizio mentale: quali sono i motivi per cui un programmatore dovrebbe adottare F# come linguaggio di programmazione?

Scoprite ben 10 motivi nella seguente infografica:

10ReasonsforFS

L’originale si trova qui:
http://www.wintellect.com/devcenter/paulballard/10-reasons-to-use-f

Templates per applicazioni Web, con MVC 5 e Web API 2.2 per F#

Un’altra cosa interessante che ho trovato è un pacchetto con i modelli per creare applicazioni web, utilizzando MVC 5 e Web API 2.2.

Naturalmente tutto per F# e naturalmente reperibile nella Visual Studio Gallery:

https://visualstudiogallery.msdn.microsoft.com/39ae8dec-d11a-4ac9-974e-be0fdadec71b

Una calcolatrice in F#

Molto tempo fa (nel mio libro “Visual Basic 2005”) ho pubblicato una “calcolatrice a nastro” sviluppata appunto in Visual Basic 2005.

Recentemente ho iniziato a interessarmi al linguaggio F# e sono appena capitato in un progetto di calcolatrice scritta in F# (l’articolo è organizzato in 4 parti):

L’idea mi sembra abbastanza interessante, cosa ne pensate?

Recensione del libro “SQL Server 2012 Bible”

Autori: Adam Jorgensen, Jorge Segarra, Patrick LeBlanc, Jose Chinchilla, Aaron Nelson

ISBN: 978-1-118-10687-7

1416 pages – August 2012

Pagina web: http://eu.wiley.com/WileyCDA/WileyTitle/productCd-1118106873.html

9781118106877_cover.indd

Ho scritto molte recensioni sui libri della serie “Bible” e ancora una volta non posso evitare di sottolineare l’ottima qualità di questi libri, sia dal punto di vista “fisico” (qualità della carta e della rilegatura, impaginazione, uso dei font e delle immagini ecc.), sia dal punto di vista dei contenuti.

In questo caso il libro si focalizza su Microsoft SQL Server 2012, un DBMS di livello professionale e distribuito con vari tipi di licenze. L’edizione SQL Server 2012 Express è addirittura distribuita gratuitamente, con il solo limite di 10 Gb per database, per permetterne l’utilizzo anche per applicazioni più limitate (studio, produttività personale, piccole realtà commerciali e così via).

Il libro è molto ben strutturato: parte dalle nozioni fondamentali, per poi passare alla programmazione con T-SQL e le stored procedure, fino ad arrivare alle informazioni necessarie per l’uso in una azienda, tra le quali anche la sua piattaforma di Business Intelligence.

Nella parte relativa alla progettazione dello schema del database è presente una parte teorica che spiega un po’ di teoria delle basi di dati (chiavi, relazioni, forme normali), assolutamente essenziali per chi non ha pratica con i database, ma anche per chi ha bisogno solo di una semplice “rinfrescata” della memoria.

Infine, se andate nella pagina web (indicata all’inizio di questo articolo), potete trovare tutti gli esempi e i frammenti di codice TSQL.

In conclusione, un libro notevole e fondamentale per chiunque voglia cimentarsi con SQL Server 2012.

Ecco l’elenco dei 59 capitoli del libro:

Part I: Laying the Foundations 1

Chapter 1: The World of SQL Server

Chapter 2: Data Architecture

Chapter 3: Installing SQL Server

Chapter 4: Client Connectivity

Chapter 5: SQL Server Management and Development Tools

Part II: Building Databases and Working with Data

Chapter 6: Introducing Basic Query Flow

Chapter 7: Relational Database Design and Creating the Physical Database Schema

Chapter 8: Data Types, Expressions, and Scalar Functions

Chapter 9: Merging Data with Joins, Subqueries, and CTEs

Chapter 10: Aggregating, Windowing, and Ranking Data

Chapter 11: Projecting Data Through Views

Chapter 12: Modifying Data In SQL Server

Part III: Advanced T-SQL Data Types and Querying Techniques

Chapter 13: Working with Hierarchies

Chapter 14: Using XML Data

Chapter 15: Executing Distributed Queries

Part IV: Programming with T-SQL

Chapter 16: Programming with T-SQL

Chapter 17: Developing Stored Procedures

Chapter 18: Building User-Defi ned Functions

Part V: Enterprise Data Management

Chapter 19: Confi guring SQL Server

Chapter 20: Policy Based Management

Chapter 21: Backup and Recovery Planning

Chapter 22: Maintaining the Database

Chapter 23: Transferring Databases

Chapter 24: Database Snapshots

Chapter 25: Asynchronous Messaging with Service Broker

Chapter 26: Log Shipping

Chapter 27: Database Mirroring

Chapter 28: Replicating Data

Chapter 29: Clustering

Chapter 30: Confi guring and Managing SQL Server with PowerShell

Chapter 31: Managing Data in Windows Azure SQL Database

Part VI: Securing Your SQL Server

Chapter 32: Authentication Types in SQL Server

Chapter 33: Authorizing Securables

Chapter 34: Data Encryption

Chapter 35: Row-Level Security

Part VII: Monitoring and Auditing

Chapter 36: Creating Triggers

Chapter 37: Performance Monitor and PAL

Chapter 38: Using Profi ler and SQL Trace

Chapter 39: Wait States

Chapter 40: Extended Events

Chapter 41: Data Change Tracking and Capture

Chapter 42: SQL Audit

Chapter 43: Management Data Warehouse

Part VIII: Performance Tuning and Optimization

Chapter 44: Interpreting Query Execution Plans

Chapter 45: Indexing Strategies

Chapter 46: Maximizing Query Plan Reuse

Chapter 47: Managing Transactions, Locking, and Blocking

Chapter 48: Data Compression

Chapter 49: Partitioning

Chapter 50: Resource Governor

Part IX: Business Intelligence

Chapter 51: Business Intelligence Database Design

Chapter 52: Building, Deploying, and Managing ETL Workflows in Integration Services

Chapter 53: Building Multidimensional Cubes in Analysis Services with MDX

Chapter 54: Confi guring and Administering Analysis Services

Chapter 55: Authoring Reports in Reporting Services

Chapter 56: Configuring and Administering Reporting Services

Chapter 57: Data Mining with Analysis Services

Chapter 58: Creating and Deploying BI Semantic Models

Chapter 59: Creating and Deploying Power View Reports

Recensione del libro “Access 2013 Bible”, Wiley.com

http://eu.wiley.com/WileyCDA/WileyTitle/productCd-1118490355.html
Michael Alexander, Dick Kusleika
ISBN: 978-1-118-49035-8
1296 pages
May 2013

clip_image001

I libri della collana “Bible” sono il migliore acquisto che si possa fare nell’ambito del software, perché contengono tutte, ma proprio tutte, le informazioni utili al neofita come all’esperto.

Nel caso di “Access 2013 Bible”, nelle quasi 1300 pagine di cui è composto troviamo argomenti che approfondiscono la conoscenza dei vari oggetti e delle numerose funzionalità di Access 2013, per permetterci di utilizzare questo prodotto nel migliore dei modi.

Il neofita vi troverà molte informazioni utili per iniziare a utilizzarlo, mentre l’esperto vi troverà sicuramente molti trucchi e suggerimenti per strutturare meglio e per arricchire di funzionalità le proprie applicazioni di database Access.

Naturalmente molti capitoli sono dedicati alla programmazione, utilizzando le Macro di Access ma anche il linguaggio VBA. L’accesso ai dati di Access e di SQL Server è realizzato con le librerie ADO e DAO, in modo da soddisfare qualsiasi esigenza. Le informazioni fornite permettono di realizzare delle vere e proprie applicazioni eseguibili per mezzo di Access stesso o del runtime gratuito (scaricabile gratuitamente dal seguente indirizzo: http://www.microsoft.com/it-it/download/details.aspx?id=39358).

Non manca una parte dedicata all’interazione di Access con i servizi di SharePoint, per chi ha la necessità di creare applicazioni aziendali di alto livello.

Nella pagina web (http://www.wiley.com/go/access2013bible) sono presenti:

– la correzione al capitolo 14 pagine 411-414
– gli esempi del libro
– n. 3 database di esempio

In conclusione, questo è un libro che, senza dubbio, non può mancare nella “cassetta degli attrezzi” dell’utilizzatore e dello sviluppatore di database Access.

Ecco quindi l’elenco dei 36 capitoli del libro (più 4 appendici):

Part I: Access Building Blocks  1

Chapter 1: An Introduction to Database Development  3

Chapter 2: Getting Started with Access  19

Part II: Understanding Access Tables 31

Chapter 3: Creating Access Tables  33

Chapter 4: Understanding Table Relationships  89

Chapter 5: Working with Access Tables 129

Chapter 6: Importing and Exporting Data 167

Chapter 7: Linking to External Data 201

Part III: Working with Access Queries 227

Chapter 8: Selecting Data with Queries 229

Chapter 9: Using Operators and Expressions in Access 261

Chapter 10: Going Beyond Select Queries 301

Part IV: Analyzing Data in Access  337

Chapter 11: Transforming Data in Access 339

Chapter 12: Working with Calculations and Dates 363

Chapter 13: Performing Conditional Analyses 389

Chapter 14: Fundamentals of Using Access SQL 407

Chapter 15: Subqueries and Domain Aggregate Functions 427

Chapter 16: Running Descriptive Statistics in Access 451

Part V: Working with Access Forms and Reports 469

Chapter 17: Creating Basic Access Forms 471

Chapter 18: Working with Data on Access Forms 509

Chapter 19: Working with Form Controls 541

Chapter 20: Presenting Data with Access Reports 575

Chapter 21: Advanced Access Report Techniques 631

Part VI: Access Programming Fundamentals  675

Chapter 22: Using Access Macros 677

Chapter 23: Getting Started with Access VBA 715

Chapter 24: Mastering VBA Data Types and Procedures 757

Chapter 25: Understanding the Access Event Model 799

Chapter 26: Debugging Your Access Applications 821

Part VII: Advanced Access Programming Techniques 853

Chapter 27: Accessing Data with VBA Code 855

Chapter 28: Advanced Data Access with VBA 897

Chapter 29: Integrating Access and SQL Server 915

Chapter 30: Customizing the Ribbon 957

Chapter 31: Preparing Your Access Application for Distribution 993

Part VIII: Access and Windows SharePoint Services   1037

Chapter 32: Understanding Windows SharePoint Services 1039

Chapter 33: Integrating Access with SharePoint 1045

Chapter 34: Understanding Access Services 1059

Chapter 35: Deploying Access Applications to SharePoint 1067

Chapter 36: Using Access Data Macros 1089

Part IX: Appendixes 1109

Appendix A: Access 2013 Specifications 1111

Appendix B: Optimizing Access Applications 1117

Appendix C: Understanding Query Performance and Database Corruption 1139

Appendix D: Function Reference for Data Analysts 1147

Visual Basic 2015: commenti e istruzioni su più righe

Ecco un’altra novità molto interessante!

Fino alla versione 2013, in Visual Basic non si potevano inserire commenti in linea, all’interno di istruzioni suddivise in più righe con la “Implicit Line Continuation”. Facciamo un esempio, questo è il codice che elenca tutti i processi attivi, li ordina e li mostra in una finestra messaggio:

Dim elenco = From processo In Process.GetProcesses
Select processo.ProcessName
Order By ProcessName
Dim stringa As String = “”
For Each proc In elenco
stringa &= proc & vbCrLf
Next
MsgBox(stringa)

Ora possiamo aggiungere commenti in linea così:

Dim elenco = From processo In Process.GetProcesses
Select processo.ProcessName ‘ seleziona il nome del processo
             Order By ProcessName ‘ ordina i nomi
Dim stringa As String = “”
For Each proc In elenco
stringa &= proc & vbCrLf
Next
MsgBox(stringa)

Il risultato che otterremo sarà invariato, ma avremo maggiore chiarezza nel codice.

Introduzione a F#

Nel numero di febbraio 2011 della rivista ioProgrammo avevo pubblicato un articolo nel quale spiegavo come è possibile utilizzare una DLL, scritta e compilata in F#, all’interno di una soluzione Visual Basic. In quella occasione ho utilizzato una DLL open source (“Excel Financial functions for .NET”: http://bit.ly/hRBhCy), in alternativa all’utilizzo dei metodi disponibili nel namespace Microsoft.VisualBasic.Financial, per calcolare il tasso di interesse e l’importo totale da pagare per un prestito.

Purtroppo, l’attuale crisi economica ha reso quanto mai attuale l’idea di creare programmi di questo tipo, anche se ottenere un prestito è sempre più arduo.

Lasciamo comunque da parte questi pensieri tristi e dedichiamoci a qualcosa di più interessante e utile: magari potreste trovare il modo di “sbarcare il lunario” vendendo librerie di funzioni scritte in F#.

In questo articolo vedremo alcuni aspetti di F# in modo più approfondito, rispetto all’articolo che vi ho citato.

NOTA: potete scaricare i progetti presentati in questo articolo da questo indirizzo.

Un po’ di storia

La programmazione funzionale non è una novità di questi giorni: è un paradigma di programmazione che esiste almeno da 30 anni. Purtroppo non è stato adeguatamente supportato dai canali commerciali per vari motivi. Il mancato supporto deriva dalla convinzione che la programmazione funzionale sia adatta principalmente a problemi di carattere matematico, scientifico o finanziario. Questa concezione ha fatto sì che la programmazione funzionale fosse finora relegata ad àmbiti di tipo accademico, in laboratori di ricerca o in grandi istituti di statistica e di finanza (banche ecc.).

La situazione è cambiata da qualche anno, cioè da quando Microsoft ha deciso di investire sul linguaggio F# nei suoi laboratori di ricerca (Microsoft Research). Don Syme, l’inventore di F#, ha definito i costrutti del linguaggio partendo dalla sintassi dei precedenti linguaggi funzionali (OCaml, ML…) e aggiungendo le strutture che permettono di utilizzare istruzioni della programmazione imperativa e istruzioni della programmazione orientata agli oggetti, in perfetta integrazione con il .NET Framework.

Queste aggiunte hanno permesso a F# di uscire dai laboratori di ricerca per diventare un linguaggio multi-paradigma, utilizzabile anche in applicazioni commerciali.

Cosa fa F# che non fanno Visual Basic e C#?

F# non utilizza il non-valore Null e quindi il codice F# puro non può incorrere in eccezioni NullReferenceException.

In realtà è ancora possibile ottenere un NullReferenceException, ma solo in casi rari e particolari: utilizzando librerie VB/C#, tipi definiti in VB/C#, il valore null letterale e pochi altri casi.

Tuttavia il codice F# abbatte drasticamente i null utilizzati, rispetto ad analoghe applicazioni scritte in VB/C#, e di conseguenza la probabilità di ottenere un NullReferenceException è estremamente rara.

Un altro aspetto che rende F# uno dei linguaggi più robusti mai esistiti: è un linguaggio fortemente tipizzato ed è un linguaggio statico (non dinamico). Il compilatore, quindi, conosce in anticipo la maggior parte delle situazioni che possono portare a un’eccezione ed emette gli opportuni errori o avvertimenti.

L’ultimo aspetto su cui voglio soffermarmi è la straordinaria concisione di questo linguaggio, senza che però venga persa la chiarezza delle istruzioni e del flusso di esecuzione.

F# utilizza l’inferenza dei tipi per non dover dichiarare esplicitamente il tipo di dato di una “variabile” (o per meglio dire: di un “identificatore”, dato che le variabili utilizzate in F# sono immutabili, salvo che non venga indicato diversamente e in modo esplicito con la parola riservata mutable).

I blocchi di codice e i cicli non richiedono una apertura e una chiusura: è sufficiente aggiungere uno o più spazi di indentazione dove è opportuno. Niente parentesi graffe, niente punti e virgola, niente parole chiave di chiusura blocco (End …), niente di niente: solo ritorni a capo e spaziatura differente all’inizio di ogni riga di codice.

Tutto questo riduce enormemente il codice da scrivere, con la conseguenza di ridurne la complessità visiva, il tempo di digitazione e il tasso di errore (meno cose ci sono dentro, meno cose si rompono). Quello che aumenta è la semplicità, la produttività, la robustezza e la sicurezza.

F# linguaggio del futuro

Un’aspetto interessante di F# che sta diventando evidente è il fatto che questo linguaggio sia stato un precursore di alcune funzionalità che sono state poi implementate in Visual Basic e in C#.

LINQ, per esempio, nasce come un’estensione del .NET Framework con una natura prettamente funzionale.

In F# sono state sviluppate tecniche che sono state implementate successivamente anche in VB e in C#: per esempio la programmazione parallela, le funzioni asincrone, l’inferenza dei tipi.

Insomma, pare che il panorama della programmazione si stia gradualmente orientando verso il paradigma della programmazione funzionale, proprio per i vantaggi che questo può portare nella produttività e nella robustezza delle nostre applicazioni.

Conoscere F#, quindi, permette di precorrere i tempi ed essere sempre un passo avanti agli altri.

Cui prodest? A chi giova?

Dopo aver esposto “vita, morte e miracoli” di F#, sicuramente qualcuno si chiederà: “ma alla fine, dove posso utilizzare F#, per quali tipi di applicazioni?”.

Per quanto riguarda le piattaforme, F# è stato rilasciato anche con licenza open source e quindi può essere utilizzato in applicazioni Windows, ma anche in Linux (con Mono). Non disdegna il web, dato che può essere utilizzato in applicazioni ASP.NET e su applicazioni Windows Azure, né le applicazioni mobili, potendo essere utilizzato in applicazioni per Windows Phone.

Possiamo utilizzare all’interno di una finestra di Visual Studio (F# Interactive), direttamente da una “finestra DOS” (con gli eseguibili fsi e fsc), possiamo utilizzarlo come linguaggio di scripting, in applicazioni in puro F# o possiamo creare librerie F# da compilare in DLL e utilizzare in tutti gli altri ambiti (in applicazioni Visual Basic e C#, in ASP.NET, in Windows Azure, in Windows Phone ecc.). Insomma, la versatilità di questo linguaggio è enorme.

Ci sono alcuni ambiti in cui F# non è molto forte: se volete creare controlli visuali o interfacce utente, è meglio se vi orientate verso VB o C#. In ogni caso l’integrazione tra tutti i linguaggi .NET rende semplice creare applicazioni in linguaggio misto, dove F# fa la parte del leone nell’ottimizzare librerie di funzioni e VB/C# la fanno nella gestione di interfacce e controlli visuali.

La cassetta degli attrezzi

Purtroppo non è mai stata rilasciata una edizione Express di Visual F#, quindi dobbiamo scegliere tra una rosa di possibilità più limitata.

F# è naturalmente uno dei linguaggi che può essere installato durante l’installazione di Visual Studio 2012/2013 in versione completa (Professional o Ultimate).

Un’alternativa è quella di utilizzare un’IDE open source e gratuito come SharpDevelop: tra i modelli di progetti che possono essere creati ci sono anche le applicazioni Console in F#. Tuttavia, se proverete a creare un progetto di questo tipo otterrete un errore, perché dovete installare F#. Quest’ultimo potete trovarlo in licenza open source, quindi scaricarlo e installarlo, ma con un piccolo handicap: nel momento in cui sto scrivendo questo articolo la versione disponibile in open source è la 2.0, mentre con Visual Studio 2013 la versione disponibile è la 3.1 (in Visual Studio 2012 è presente la versione 3.0).

Ecco quindi una possibilità che possiamo sfruttare per poter lavorare in F# senza comprare Visual Studio:

1. installate “Visual Studio Express 2012 for Web” (http://bit.ly/1bgM3m7);

2. poi installate “F# Tools for Visual Studio Express 2012 for Web” (http://bit.ly/17Bf3Rx).

L’installazione di quest’ultimo software viene preceduta, in modo automatico e con un minimo intervento da parte dello sviluppatore, dall’installazione di “Microsoft Web Platform Installer”.

Microsoft Web Platform Installer è un software che ci permette di installare e aggiornare vari software e strumenti di sviluppo: per esempio fornisce i tool di supporto per Windows Azure, i tool di supporto per SQL Server (per esempio la Compact Edition), applicazioni CMS (come DotNetNuke, Orchard ecc.), blog, wiki e molto altro.

Dopo che avrete completato l’installazione di “F# Tools for Visual Studio Express 2012 for Web” potrete creare librerie F# e applicazioni web (ASP.NET e Windows Azure), sfruttando anche le grandi possibilità fornite dal linguaggio F#.

Bando alle ciance!

In questo articolo introduttivo su F# ho dovuto inquadrare un po’ qual è la sua storia, a cosa serve e come possiamo utilizzarlo. Dopo questa lunga trattazione su F#, sperando di non avervi annoiati, passo a qualche semplice esempio pratico.

In questo articolo affronteremo le seguenti tematiche, ciascuna con un suo esempio pratico:

  • F# Interactive in una finestra Prompt dei comandi;

  • F# Interactive in Visual Studio;

  • Applicazione interamente in F#;

  • Esecuzione di parti del programma;

  • Librerie in F#;

  • Windows Form con F#;

  • Applicazione VB/F# e C#/F# (con WPF);

  • Applicazione ASP.NET con F#

F# Interactive in una finestra Prompt dei comandi

Possiamo utilizzare F# in molti modi diversi. Uno di questi modi è quello di aprire una finestra del Prompt dei comandi (se avete Visual Studio potete aprire la versione specifica “per gli sviluppatori per Visual Studio 2012/2013”) e digitare fsi.

Una volta aperta la finestra del prompt dei comandi, possiamo digitare ed eseguire le istruzioni F# in modo interattivo (fsi = “FSharp Interactive”).

Per esempio possiamo scrivere l’istruzione

#help;;

per ottenere una breve guida su alcuni comandi che possono essere utilizzati, possiamo fare delle assegnazioni ed eseguire delle somme con la funzione let o “stampare” a video delle stringhe con le istruzioni printfn o printf.

L’istruzione printfn va a capo dopo aver visualizzato la stringa, mentre printf mantiene il cursore alla fine della stringa, così che un’eventuale altra stringa che viene stampata, viene posizionata concatenandola a quella precedente. Questo comportamento è perfettamente corrispondente all’utilizzo dei metodi Console.Write() e Console.WriteLine().

Nella Figura 1 potete vedere alcune istruzioni eseguite nella finestra del prompt dei comandi.

clip_image002

Noterete sicuramente che per eseguire le istruzioni è necessario aggiungere, alla fine della riga, un doppio carattere di punto e virgola (;;). Questo simbolo è necessario per far capire a FSharp che l’istruzione è terminata. Senza questo simbolo speciale possiamo continuare la scrittura dell’istruzione sulla riga successiva, almeno finché non abbiamo inserito il simbolo di fine istruzione. Notate però che l’utilizzo del simbolo “;;” di fine istruzione è necessario solamente nella modalità interattiva, mentre nei programmi compilati questa necessità non c’è, perché il compilatore è in grado di capire quando un’istruzione è terminata e quando inizia l’istruzione successiva. Come vi abbiamo già fatto notare, questa “intelligenza” del compilatore deriva dalla spaziatura delle istruzioni (indentazione) e dalla conoscenza di tutto il codice già inserito nel progetto.

L’istruzione let permette di assegnare un valore letterale o un risultato di una funzione o di un’espressione.

Notate anche che fsi definisce il tipo di dato restituito: in due casi abbiamo due int (Integer), mentre nell’ultimo caso abbiamo uno unit = (), perché la funzione printfn non restituisce alcun valore. Lo unit viene assegnato automaticamente a una variabile di nome it: questo è il nome predefinito che viene utilizzato quando non viene definita espressamente una variabile.

Degno di nota è anche il fatto che l’identificatore somma mantiene il valore assegnato nella prima istruzione, permettendo di utilizzarne il valore anche nella seconda istruzione. Questo significa che lo stato delle assegnazioni viene mantenuto durante tutta la sessione di F# Interactive, permettendo di scrivere ed eseguire un programma in modalità effettivamente interattiva.

Cosa succede se sbagliamo a digitare un’istruzione? Lo potete vedere nella Figura 2.

clip_image004

F# Interactive in Visual Studio

Una modalità di esecuzione di F# Interactive molto più comoda è quella che possiamo ottenere lavorando all’interno di Visual Studio.

Per lavorare con la finestra di F# Interactive non è necessario creare un progetto F# né altri tipi di progetto: è sufficiente selezionare la voce di menu Visualizza > Altre Finestre > F# Interactive, oppure basta premere molto più semplicemente la combinazione di tasti CTRL+ALT+F.

Come potete vedere nella Figura 3, possiamo eseguire le stesse istruzioni che abbiamo eseguito nel esempio precedente, esattamente con la stessa modalità (un’istruzione alla volta) e sostanzialmente con la stessa “esperienza utente”.

clip_image005

La finestra F# Interactive di Visual Studio e l’utilizzo di fsi.exe in Console sono indubbiamente utili per sperimentare singole istruzioni o semplici sequenze di istruzioni, specialmente quando avete appena iniziato a prendere confidenza con il linguaggio F#.

Ad un certo punto, però, sarà necessario andare un po’ oltre per poter sfruttare ulteriori vantaggi dall’ambiente di Visual Studio, come la possibilità di scrivere programmi più complessi e utilizzare le funzionalità di debug e di compilazione di programmi o di librerie di funzioni.

Il passo successivo, quindi, sarà costituito dalla creazione di programmi di tipo Applicazione F#.

Applicazione F#

Un’applicazione F# si crea semplicemente come tutti gli altri tipi di applicazione in Visual Studio: nel pannello sinistro della Start page selezionate Nuovo progetto oppure dal menu principiale selezionate File > Nuovo > Progetto. All’apparizione della finestra Nuovo progetto, selezionate il nodo Modelli > Visual F#, poi selezionate la voce Applicazione F# e compilate le informazioni nella parte inferiore della finestra: nome dell’applicazione, percorso, nome della soluzione, eventuale inclusione al controllo del codice sorgente (per esempio Team Foundation Server, Team Foundation Service sul web o anche all’analogo servizio CodePlex per progetti open source) e l’eventuale creazione di una sottodirectory per il progetto.

Nel file Program.fs troveremo il seguente codice di esempio:

#light

// Ulteriori informazioni su F# all'indirizzo http://fsharp.net
// Per ulteriori informazioni, vedere il progetto 'Esercitazione su F#'.

[<EntryPoint>]
let main argv =
printfn "%A" argv
0 // restituisci un intero come codice di uscita

Possiamo cancellare l’intero codice e scrivere quanto segue:

// esempio: mdgIntroFSharp01

open System

let mutable somma = 3 + 2

somma <- somma + 4

printfn("la somma di (3+2)+4 è uguale a 9")

let fine = Console.ReadLine()

Notate che abbiamo tolto la direttiva #light: lo possiamo fare perché l’impostazione di default è #light on. Tuttavia se volete maggiore chiarezza, potete lasciare tranquillamente tale direttiva nel codice (male non fa).

L’istruzione open System equivale all’istruzione import di Visual Basic: serve per utilizzare le classi e i metodi del relativo namespace senza dover necessariamente utilizzare utilizzare l’intera gerarchia di nomi: nel nostro esempio, cioè, possiamo utilizzare Console.ReadLine invece di System.Console.ReadLine.

La seconda istruzione (let mutable somma = 3 + 2) è simile all’esempio precedente, ma con l’aggiunta della parola riservata “mutable”. Questa parola permette di rendere l’identificatore somma una variabile modificabile. Per una questione intrinseca di F#, infatti, gli identificatori non sono variabili, nel senso che non permettono normalmente di modificare il loro contenuto, una volta che sono state definite e che gli è stato assegnato un valore. La mancanza della parola mutable nella seconda istruzione comporterebbe un errore nella terza istruzione, dato che il compilatore di F# segnalerebbe il duplicato della definizione dell’identificatore somma.

Nella terza istruzione, a questo punto non possiamo più utilizzare la funzione let, né possiamo utilizzare il simbolo di assegnazione (=). F# permette di assegnare a una variabile il valore di un’espressione, utilizzando un operatore di assegnazione inedito per gli sviluppatori Visual Basic e C#: il simbolo “freccia a sinistra” realizzato con due caratteri, cioè il simbolo “minore di” e il trattino (<-). Se ci ragioniamo un attimo, il significato è evidente: calcoliamo il valore dell’espressione “somma + 4” e lo assegniamo alla variabile posta alla sinistra dell’istruzione, cioè “somma”, utilizzando una freccia.

La quarta istruzione è identica a quella che abbiamo scritto nell’esempio F# Interactive.

Qui però troviamo una quinta istruzione che non avevamo utilizzato prima e che potrebbe risultare incomprensibile (let fine = Console.ReadLine()).

Il metodo Console.ReadLine() è utilizzato per evitare che la finestra della Console sparisca subito, dopo aver eseguito le istruzioni precedenti, rendendo difficile, se non impossibile, la lettura del contenuto della finestra. Con la quinta istruzione, quindi, il programma attende che l’utente prema il pulsante Invio prima di chiudere la finestra.

Questa è una tecnica che è utilizzata anche nei programmi Visual Basic e C#, quando sono progettati per essere eseguiti nella Console. La situazione, qui, è un po’ diversa perché il metodo ReadLine restituisce un valore che deve essere comunque assegnato a qualche variabile, anche se in questo caso non ci interessa leggere cosa ha inserito l’utente. Nelle applicazioni VB e C#, invece, possiamo invocare il metodo Console.ReadLine() senza assegnare il risultato a una variabile. Abbiamo quindi definito un identificatore “fine”, destinato a contenere la risposta dell’utente, sia essa una semplice pressione del tasto Invio oppure una stringa inserita prima della pressione di tale tasto.

Qui effettivamente l’assegnazione a un’identificatore non ha molto senso e rende l’istruzione un po’ strana. Possiamo quindi modificare l’istruzione per far sì che la risposta dell’utente venga ignorata, scrivendola in questo modo:

Console.ReadLine() |> ignore

In questo caso eseguiamo il metodo Console.ReadLine() ottenendo una risposta che viene “inviata”, con l’operatore di “pipe” (composto dalla barra verticale e da un simbolo “maggiore di”), verso la parola riservata ignore che indica che il valore restituito sarà ignorato.

Bisogna entrare nella mentalità di F# e dei linguaggi funzionali in generale: tutte le istruzioni devono essere delle funzioni che restituiscono un valore e tutti i valori restituiti devono essere in qualche modo utilizzati dal programma, oppure lo sviluppatore deve indicare espressamente al compilatore che un determinato valore non deve essere utilizzato, ovvero che deve essere ignorato.

Esecuzione di parti del programma

Un aspetto interessante dell’ambiente di sviluppo di Visual Studio è dato dalla possibilità di eseguire una unica istruzione oppure un blocco di istruzioni di un programma, senza dover necessariamente avviare l’esecuzione dell’intero programma.

È molto semplice: è sufficiente selezionare una o più istruzioni e premere la combinazione di tasti ALT+INVIO. Per esempio selezionate l’istruzione seguente:


let mutable somma = 3 + 2
somma <- somma + 4

e poi premete la combinazione di tasti che vi abbiamo indicato.

Vedrete che si aprirà automaticamente la finestra F# Interactive e sarà eseguito il blocco di istruzioni che avevate selezionato. Ecco il risultato per il nostro esempio:


val mutable somma : int = 9
val it : unit = ()

Questa modalità di esecuzione parziale è molto utile per testare piccole parti del programma, quando non vogliamo creare un progetto semplificato per fare degli esperimenti separati dallo sviluppo della nostra applicazione.

Libreria F#

Per sperimentare la creazione di una libreria F#, come primo esempio vediamo un’applicazione F# (soluzione mdgIntroFsharp02 e progetto con lo stesso nome) che utilizza un progetto di tipo Libreria F#. I passi da seguire sono i seguenti:

1. create una nuova soluzione con un progetto di tipo Applicazione F#, così come avevamo fatto nel primo esempio di applicazione di questo articolo;

2. cliccate con il tasto destro del mouse sul nome della soluzione (mdgIntroFsharp02) e selezionate la voce Aggiungi > Nuovo progetto;

3. nella scheda Visual F# selezionate il template Libreria F#, verificate che il percorso sia corretto (deve trovarsi preferibilmente nella sottocartella della soluzione, come il progetto principale) e indicate un nome di progetto (nel nostro caso abbiamo lasciato il nome predefinito Library1) e confermate premendo il tasto OK.

Vedrete che automaticamente verrà aggiunto il seguente codice:

namespace Library1

type Class1() =
   member this.X = "F#"

Il codice definisce un namespace di nome Library1, una classe di nome Class1 e una proprietà di nome X e contenente la stringa “F#”. Proviamo a modificare la libreria, sostituendo il codice con qualcosa di relativamente più utile:


// esempio: mdgIntroFsharp02
namespace Library1

type Stampa(x: string) =
static member testo(x) =
"Testo: " + x

Il codice è abbastanza banale: permette di restituire una stringa passata come parametro, concatenandola con il prefisso “Testo: ” (con uno spazio dopo i due punti, per una questione di esposizione visiva del testo). La sua banalità, però, ci permette di utilizzare questo semplice codice per vedere come può essere utilizzata la libreria in modo estremamente facile.

Alcune precisazioni: la prima riga contiene la dichiarazione del namespace Library1 a cui appartiene la libreria. Poi abbiamo dichiarato un tipo (cioè una classe) di nome Stampa. A seguire abbiamo dichiarato un metodo statico di nome testo che restituisce la stringa modificata.

Dopo aver scritto il codice, compilate il progetto Library1, cliccando con il tasto destro del mouse sul suo nome e selezionando Compila. Questo ci servirà per poter utilizzare la libreria compilata dal progetto principale.

Cliccate ora, sempre con il tasto destro del mouse, sul nodo Riferimenti del progetto mdgIntroFsharp02 e selezionate Aggiungi riferimento. Apparirà una finestra per la selezione dei riferimenti: cliccate sulla sezione Soluzione e selezionate la voce Library1, poi confermate premendo OK.

clip_image002[5]

Aprite il file Program.fs del progetto mdgIntroFsharp02 e modificate il codice presente nell’editor con il seguente codice:

// esempio: mdgIntroFsharp02
open System
open Library1

let testo = Stampa.testo("Ciao mondo!")
printfn "%s" testo |> ignore
Console.ReadLine() |> ignore
()

Anche qui è bene specificare alcune cose, per comprendere bene il codice.

Le prime due istruzioni aprono o, per meglio dire, “includono” le librerie dei namespace System (del .NET Framework) e Library1 (cioè quella creata da noi).

L’istruzione let invoca il metodo Stampa.testo, passando come parametro una stringa da modificare.

La successiva istruzione stampa la stringa nella Console, segnalando che non ci interessa restituire un valore (vi ricordiamo che la “pipe” |> ignore è necessaria nella programmazione funzionale, quando non vogliamo utilizzare un valore di ritorno).

Poi abbiamo inserito un’istruzione in grado di leggere una stringa di input, con il solo scopo di “fermare” la chiusura della finestra della Console. Anche qui non ci interessa restituire un valore, né ci interessa cosa viene inserito dall’utente, bastando anche un semplice invio.

L’ultima riga può suscitare qualche curiosità: una coppia di parentesi tonde (). Questo è uno unit, cioè il valore/non-valore di cui abbiamo già parlato e che serve a indicare che il programma non restituisce valori significativi al chiamante o all’utente. Possiamo considerarlo un simbolo di chiusura del programma, anche se in alcuni casi potrebbe essere utile indicare un vero valore, per esempio un codice numerico per indicare una condizione di errore che si è verificata oppure un valore che rappresenta un risultato.

Dopo aver compilato l’intera soluzione, provate ad eseguire il programma: dovrebbe apparire ancora una volta la finestra del prompt dei comandi con il testo “Ciao mondo!”. La finestra resterà in attesa della vostra pressione di un tasto qualsiasi, dopodiché il programma terminerà chiudendo anche tale finestra.

Windows Form con F#

Un aspetto che emerge nella programmazione F#, all’interno dell’ambiente di sviluppo Visual Studio, è la scarsa, per non dire nulla, propensione di F# alla progettazione visuale.

Sebbene spesso si legga “Visual F#” nella documentazione disponibile, di “Visual” c’è ben poco, perché F# non è progettato per fornire supporto al trascinamento di elementi nell’interfaccia utente.

Questo non significa, però, che non si possa sviluppare un’applicazione F# in grado di visualizzare delle finestre con alcuni componenti visuali: semplicemente dobbiamo farlo da codice.

Nel prossimo esempio vedremo come si può creare un’applicazione Windows Form con F#, scrivendo del codice che, tutto sommato, non è molto complesso.

L’obiettivo che ci proponiamo di ottenere è quello di definire una finestra Windows Form, di posizionarvi un pulsante e di definire un evento Click, associato al pulsante stesso, per far apparire un messaggio.

// esempio: mdgIntroFsharp03
open System
open System.Drawing
open System.Windows.Forms
open System.Runtime.InteropServices // necessario per le API di Windows
 
// definizione delle API di Windows:
[<DllImport("kernel32.dll")>] extern System.IntPtr GetConsoleWindow()
[<DllImport("user32.dll")>] extern bool ShowWindow(System.IntPtr, int)

// riferimento all'handle della finestra “Prompt dei comandi”:
let h = GetConsoleWindow()

// la finestra “Prompt dei comandi” viene nascosta (0=hide):
ShowWindow(h, 0) |> ignore

// definizione della finestra Windows Form:
let form = new Form(Text="FsharpForm", Visible=true, Width=300, Height=300)

// definizione di un pulsante:
let btn1 = new Button()
btn1.Text <- "ClickME"
btn1.Location <- new Point(20, 20)

// aggiunta del pulsante all'insieme dei controlli del form:
form.Controls.Add(btn1)

// definizione del metodo da eseguire con l'evento Click del pulsante:
let btnClick _ =
MessageBox.Show("Click!") |> ignore

// aggiunta dell'evento Click:
let _ = btn1.Click.Add(btnClick)

// punto di ingresso dell'applicazione, con definizione del
// modello di threading COM come apartment a thread singolo:
[<STAThread>]
Application.Run(form)

Il codice è sufficientemente commentato, per cui non dovrebbero esserci problemi di comprensione sul suo funzionamento.

Vogliamo solamente attirare la vostra attenzione sulle istruzioni iniziali che servono a nascondere la finestra “Prompt dei comandi”. Infatti, se vogliamo utilizzare Windows Form come interfaccia utente, la vecchia “finestra DOS” è inutile e antiestetica, quindi vale la pena di aggiungere qualche istruzione per nasconderla.

Dopo aver avviato l’applicazione e cliccato sul pulsante, otterrete un risultato simile a quello che potete vedere nella Figura 5.

clip_image009

Applicazione VB/F# e C#/F#

Se non volete perdere tempo a definire l’interfaccia utente con F#, potete optare per la combinazione VB/F# oppure per quella C#/F#.

In questo caso, il progetto principale fornisce la struttura base dell’applicazione, sia dal punto di vista visuale, sia da quello del “comportamento” (eventi, interazione con l’utente ecc.), mentre tutta la logica e gli algoritmi più importanti vengono delegati a una libreria F#.

Questo fatto permette di utilizzare tecnologie visuali più recenti per la progettazione dell’interfaccia utente, come WPF o Silverlight.

Dato che in questo articolo abbiamo già visto come si scrive una libreria F#, in questo contesto non ci resta che definire l’interazione tra il codice VB e il codice F#.

Per prima cosa creiamo un progetto Visual Basic, utilizzando un template WPF, e lo chiamiamo mdgIntroFsharp04. Poi aggiungiamo un altro progetto, questa volta di tipo Libreria F#, denominato Library1.

Nella libreria F# inseriamo ancora una volta il codice seguente:

namespace Library1

type Stampa(x: string) =
static member testo(x) =
"Testo: " + x

Dopo aver compilato singolarmente il progetto della libreria F#, aggiungiamo il riferimento a Library1 nel progetto Visual Basic, così come abbiamo già visto negli esempi precedenti.

Quello che ci interessa di più, in questo momento, è la parte relativa al progetto Visual Basic.

Nella finestra del progetto principale aggiungiamo due caselle di testo e un pulsante.

La prima casella servirà per permettere all’utente di inserire una stringa di testo, mentre la seconda casella di testo mostrerà il risultato della funzione Stampa della libreria F#. Il pulsante, naturalmente, permetterà di chiamare la funzione e di mostrare il risultato.

Prima di tutto definiamo l’interfaccia utente con il seguente codice XAML:

<Window x:Class="MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Title="MainWindow" Height="316" Width="525">
<Grid>
<TextBox x:Name="txtTestoInserito"
HorizontalAlignment="Left"
Height="56"
Margin="10,23,0,0"
TextWrapping="Wrap"
VerticalAlignment="Top"
Width="497"
FontSize="36"/>
<TextBox x:Name="txtRisultato"
HorizontalAlignment="Left"
Height="54"
Margin="10,211,0,0"
TextWrapping="Wrap"
VerticalAlignment="Top"
Width="497"
FontSize="36"/>
<Button
x:Name="btnCallStampa"
Content="Chiama funzione F#"
HorizontalAlignment="Left"
VerticalAlignment="Top"
Width="361"
Margin="89,111,0,0"
Height="62"
FontSize="36"/>
</Grid>
</Window>

Il codice Visual Basic relativo al gestore dell’evento Click del pulsante è invece il seguente:

// esempio: mdgIntroFsharp04
Class MainWindow
Private Sub btnCallStampa_Click(
sender As Object, e As RoutedEventArgs) _
Handles btnCallStampa.Click
txtRisultato.Text =
Library1.Stampa.testo(txtTestoInserito.Text)
End Sub
End Class

Potete vedere l’applicazione funzionante nella Figura 6.

clip_image011

L’applicazione C# è sostanzialmente identica: cambia solamente il codice del gestore dell’evento Click che troviamo nel seguente frammento:

// esempio: mdgIntroFsharp05
using System;
using System.Text;
using System.Windows;
using System.Windows.Controls;

namespace mdgIntroFsharp05
{
/// <summary>
/// Logica di interazione per MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
}

private void btnCallStampa_Click(
object sender, RoutedEventArgs e)
{
txtRisultato.Text =
Library1.Stampa.testo(txtTestoInserito.Text);
}
}
}

Applicazione ASP.NET/F#

Anche nell’ambito delle applicazioni web, l’interazione tra l’applicazione ASP.NET e la libreria F# non potrebbe essere più facile di così. Vediamo un breve esempio.

Prima di tutto creiamo un sito ASP.NET. Dopo aver selezionato la voce di menu File > Nuovo > Sito web, apparirà una finestra di selezione del tipo di applicazione (Figura 7).

clip_image013

Per semplificare, selezioniamo il template Sito web ASP.NET vuoto, scegliamo un percorso nel quale salvare i file dell’applicazione e confermiamo.

Una volta creata l’applicazione base, aggiungiamo un progetto di Libreria F#: su questo aspetto non ci soffermiamo oltre, perché la modalità di aggiunta della libreria, il codice contenuto nella libreria, la compilazione e l’aggiunta del riferimento nell’applicazione ASP.NET sono esattamente identici a quanto abbiamo già visto negli esempi precedenti.

Avendo scelto di creare un’applicazione ASP.NET vuota, tra i file del progetto non abbiamo nemmeno una pagina definita: aggiungiamo quindi una pagina di tipo WebForm (che nel nostro caso si chiama WebForm1.aspx) e modifichiamo il blocco <body> … </body> come segue:

<body>
<form id="form1" runat="server">
<div>
<asp:TextBox ID="txtTestoInserito" runat="server" Font-Size="24pt" Width="420
px"></asp:TextBox>
<br />
<br />
<asp:Button ID="btnCallStampa" runat="server" Font-Size="24pt" Text="Chiama funzione F#" Width="342px" />
<br />
<br />
<asp:TextBox ID="txtRisultato" runat="server" Font-Size="24pt" Width="420px"></asp:TextBox>
</div>
</form>
</body>

Come potete vedere, non abbiamo fatto altro che aggiungere due caselle di testo e un pulsante, esattamente come avevamo fatto negli esempi precedenti.

Ora dobbiamo solo modificare il codice che viene richiamato dalla pressione del pulsante: con un doppio click sul pulsante stesso, entriamo nell’editor del codice (Visual Basic o C#, a seconda del tipo di sito ASP.NET che avete scelto). Scriviamo quindi il seguente codice Visual Basic:

// esempio: mdgIntroFsharp06
txtRisultato.Text =
Library1.Stampa.testo(txtTestoInserito.Text)

oppure il seguente codice C#:

txtRisultato.Text =
Library1.Stampa.testo(txtTestoInserito.Text);

A questo punto potete compilare ed eseguire l’applicazione. Verrà avviato il web server incluso in Visual Studio e verrà aperto Internet Explorer per mostrare l’applicazione che abbiamo appena concluso. Se inserite un testo nella prima casella di testo e premete il pulsante, vedrete un risultato che ricalca quello che avete già visto nella Figura 6.

Alcune risorse per approfondire

In rete è possibile trovare parecchia documentazione su F#, anche se quasi esclusivamente in lingua inglese. In italiano, attualmente esiste quasi solo il blog dell’autore di questo articolo, reperibile all’indirizzo https://fsharpdazero.wordpress.com.

A seguire vi elenchiamo alcune risorse utili e interessanti che uno sviluppatore F# deve assolutamente conoscere.

MSDN Library

Si trova all’indirizzo http://bit.ly/15FalRk, ma è possibile scaricare tutta la documentazione anche in locale, utilizzando l’Help Viewer di Visual Studio 2012 (menu ? > Aggiungi e rimuovi contenuto della guida).

tryF#

All’indirizzo http://preview.tryfsharp.org/ è possibile trovare della documentazione e molti esempi pratici, ma il vantaggio principale è quello di poter eseguire il codice di esempio o il nostro codice F# direttamente online, senza utilizzare Visual Studio.

Visual F# Resources

All’indirizzo http://bit.ly/14llVa8 si trovano molte risorse per F#: riferimenti a documentazione, news, librerie, video, tutorial, esempi e così via.

Il blog di Don Syme

Nella vostra cassetta degli attrezzi non può mancare l’indirizzo al blog di Don Syme, cioè dello sviluppatore che ha creato Visual F#: http://blogs.msdn.com/b/dsyme/. Qui troverete articoli e annunci di novità che riguardano il linguaggio.

Rich Minerich’s Development Wonderland

Un altro blog che dovete assolutamente segnarvi è quello di Rich Minerich, sviluppatore F# e autore di vari libri su questo linguaggio: http://bit.ly/1akHpGO.

In questo blog trovate anche periodicamente un post con un immenso elenco di riferimenti a risorse su F#: news, articoli, librerie, video e molto altro.

Progetti su CodePlex

All’indirizzo http://bit.ly/150jzMo trovate un elenco di progetti open source (ben 69 progetti!) che potete scaricare, provare e utilizzare a vostro piacimento.

Channel 9

Per chi preferisce veder fare le cose in pratica e non ha particolare difficoltà a capire l’inglese parlato, non c’è niente di meglio che una serie di video. Li trovate su Channel 9 all’indirizzo http://bit.ly/18ubUVj.

FPish

Un altro riferimento importante è FPish, all’indirizzo http://cs.hubfs.net/. Si tratta di una community di sviluppatori F# e quindi vi potete trovare una grande varietà di contenuti, da vari blog a risposte su quesiti dei visitatori, fino a veri e propri corsi (questi però sono a pagamento).

Guida per la sopravvivenza

All’indirizzo http://bit.ly/15wxYMG potete trovare “The F# Survival Guide”, praticamente un libro-guida gratuito online. Dato il grande numero di esempi di codice è fortemente consigliato.

F# Snippet

Fortemente consigliato è anche il sito che si trova all’indirizzo http://fssnip.net/. A fronte di un’organizzazione del materiale forse un po’ caotica, potete trovare gli esempi per le varie categorie rappresentate da una “nuvola” di parole chiave presente all’inizio della pagina. Le parole chiave hanno una dimensione proporzionale al numero di esempi a cui si riferiscono.

La nuova versione 3.1 per Visual Studio 2013

Naturalmente un linguaggio del futuro deve continuamente aggiornarsi e aggiungere nuove caratteristiche. All’indirizzo http://bit.ly/14lnjcZ potete trovare l’annuncio delle novità della nuova versione 3.1 che sarà rilasciata contestualmente a Visual Studio 2013 (nel momento in cui scriviamo non è ancora stata resa pubblica la data di lancio).

Conclusioni

In questo articolo vi ho mostrato una panoramica su cosa è F#, su come è nato e su quale “filosofia” si basa, cioè la programmazione funzionale, unita alla programmazione imperativa e a quella orientata agli oggetti. Un linguaggio, quindi, multi-paradigma che ci consente una flessibilità mai vista prima, ma anche una robustezza senza precedenti.

Dopo aver esplorato alcuni aspetti che differenziano F# dagli altri linguaggi .NET (VB e C#) vi ho spiegato come installare F# anche sull’ambiente di sviluppo Visual Studio Express 2012 for Web. In seguito ho sperimentato l’esecuzione di istruzioni in F# Interactive e la costruzione di una libreria F#, utilizzata a sua volta da un programma F#, analizzandone anche le singole istruzioni.

Per motivi di spazio non ho potuto esplorare altre possibilità di F#: dall’utilizzo della libreria Library1 in VB e C# alla programmazione di interfacce Windows Forms con F#, dall’utilizzo di F# in siti ASP.NET e in applicazioni Windows Azure.

Visual Basic 2015: stringhe multilinea

Come ormai è noto, nella seconda metà di luglio è stato rilasciato Visual Studio 2015, nuova versione dell’ambiente di sviluppo di Microsoft. Questa versione porta molte novità e con questo post iniziamo ad esplorarne alcune.

Colgo l’occasione per avvertirvi che questo blog, inizialmente (e per vari anni) dedicato a Visual Basic e poi passato a F#, diventa “multi-linguaggio”, nel senso che qui mi occuperò di Visual Basic, di C# e di F#, ma anche di sviluppo web, di sviluppo di database, di Azure, di Windows Phone, di … tante altre cose legate allo sviluppo .NET.  Sorriso  … Ok, iniziamo.

Una delle funzionalità più richieste dagli sviluppatori era la possibilità di andare a capo senza dover inserire caratteri di punteggiatura o altri caratteri speciali. Nelle precedenti versioni di Visual Basic abbiamo avuto questa possibilità con il codice, ma ora è possibile farlo anche con le stringhe. Per esempio:

 

    MsgBox(“Prima non si poteva andare
a capo semplicemente premendo il tasto di Invio,
ma bisognava inserire un doppio apice, un ‘underscore’
e poi un doppio apice nella riga seguente.
Ora basta fare…
così!”)

 

Nel momento in cui eseguiamo questo codice, vediamo che il testo va a capo esattamente come nella stringa:

image

 

Ma cosa succede se scriviamo un codice come questo?

 

    Dim stringa As String = “

    MsgBox(stringa.Length.ToString)

 

Il risultato che otterremo nella finestra del messaggio è: 2, corrispondente ai codici di controllo CR+LF, ovvero la sequenza “normale” di Windows per andare a capo.

Questa sequenza significa: CR = carriage return, cioè ritorno carrello (in ricordo del “ritorno carrello” delle vecchie macchine da scrivere) + LF = line feed, ovvero lo scorrimento alla riga successiva (alcuni sistemi utilizzano solo il codice LF = line feed).

 

 

 

 

 

 

 

 

Un articolo su F# di Julie Lerman – MSDN Magazine di Febbraio 2013

Nel numero di Febbraio 2013 di MSDN Magazine c’è un interessante articolo di Julie Lerman intitolato “Data, Meet My New Friend, F#”, pagine 24-26.

Non appena il numero della rivista sarà pubblicato online, dovreste trovarlo a questo indirizzo: http://msdn.microsoft.com/it-it/magazine/dn519915.aspx.

L’articolo è molto interessante perché suggerisce alcuni cambiamenti nella architettura delle nostre applicazioni, dal fatto di spostare parte o tutta la logica dal database all’applicazione client, al fatto di creare librerie in F#, molto più veloci (sfruttando la programmazione parallela) ed efficaci. Tali librerie possono poi essere utilizzate da qualsiasi altro linguaggio (VB, C#, ma anche in ASP.NET), così da avere il massimo risultato possibile in termini di performance.

Assolutamente da leggere!

Nuovi modelli di applicazioni per F#

Qualche tempo fa è stato rilasciato il pacchetto “Visual F# Out of Band Release 3.1.1” che potete trovare a questo indirizzo:

http://www.microsoft.com/en-us/download/details.aspx?id=41654

Potete approfondire il contenuto di questo aggiornamento leggendo il blog del Team di sviluppo F# a questo indirizzo:

http://blogs.msdn.com/b/fsharpteam/archive/2014/01/22/announcing-visual-f-3-1-1-and-support-for-desktop-express.aspx

In sostanza, le novità principali di questo aggiornamento sono:

  • un limitato numero di correzioni di bug, in base alla versione rilasciata per Visual Studio 2013 RTM

  • il supporto dell’integrazione di F# nell’IDE delle versioni Express (Desktop, Web e ovviamente nelle versioni da Professional in su)

  • supporto per distribuzione del compilatore/runtime/”interactive” indipendenti su macchine che non hanno installato Visual Studio

  • un nuovo meccanismo di aggiornamento di Visual F#: gli aggiornamenti e le correzioni di bug possono essere ora distribuiti facilmente e con la stessa cadenza dei rilasci di Visual Studio (i famosi “Update N”).

Inutile dire che sono molto contento di queste novità, in particolare quella che più mi piace è la possibilità di utilizzare F# nelle edizioni Express. Infatti il problema che più impattava negativamente nella diffusione di F# tra gli studenti e gli appassionati di programmazione era il fatto di non poter utilizzare il compilatore e F# Interactive nelle edizioni Express di Visual Studio (si poteva in altri ambiti, come SharpDeveloper, ma con limitazioni). Ora che questo passo è stato fatto, tutti possono utilizzare gratuitamente F# per scrivere i propri programmi, anche didattici!

Buona programmazione con F#!

Nuovi modelli di applicazioni per F#

Il “mondo di F#” è sempre in movimento.

Come potete vedere da questo articolo di Kevin Ransom e di Don Syme, sono stati introdotti vari nuovi modelli di applicazione F# realizzati da vari autori delle community tecniche.

Inoltre è stato creato un “repository” centrale di modelli di applicazioni F# basato su Git per facilitare la condivisione dei template e il loro miglioramento, attraverso l’attività degli autori delle community tecniche.

I link alle pagine che illustrano alcuni template sono questi:

  • A New F# ASP.NET MVC 5 and Web API 2 Project Template

  • Nancy Templates for F#

  • MSTest Project Template for F#

  • FSharpTest Template for F#

  • New F# Web App Item Templates

  • Adding New Items to a Pure F# ASP.NET MVC/Web API Project

  • A Few Changes to the F#/C# MVC 4 Project Template

  • Iscriviti

    Ricevi al tuo indirizzo email tutti i nuovi post del sito.

    Segui assieme ad altri 970 follower