Blog Stats

  • Blogs - 41
  • Posts - 4201
  • Articles - 185
  • Comments - 23656
  • Trackbacks - 950

Bloggers (posts, last update)

Powered By:
Powered by Subtext

Latest Posts

Visual Studio "15" Preview 4 disponibile

E' stata rilasciata proprio qualche giorno fa la quarta preview di Visual Studio "15", prossima versione dell'ambiente di sviluppo di casa Microsoft e che ci consente di vedere in anteprima una serie di innovazioni sulle quali stanno lavorando a Redmond.

In questa pagin
a ci sono le note di rilascio con tutto ciò che è stato introdotto in questa nuova release intermedia unitamente al link per il download. Ovviamente, non dimenticate che si tratta di una release non supportata e da non usare su macchine di produzione.

Alessandro

posted @ 24/08/2016 16:52 by Alessandro Del Sole

Xamarin, il simulatore iOS per Windows

Forse non tutti sanno che Xamarin offre anche un simulatore iOS per lo sviluppo su Windows con Xamarin Studio e Visual Studio 2015.

Questo strumento è in grado di simulare sia iPhone che iPad. Ovviamente, il simulatore da solo non basta dal momento che per compilare per iOS è necessario avere un Mac, ma di questo vi parlerò nel prossimo post, unitamente a un esempio di come utilizzarlo.

Per ora vi lascio il link al simulatore, con relativa documentazione, nella pagina apposita nel sito Xamarin.

Alessandro

posted @ 19/08/2016 15:57 by Alessandro Del Sole

Xamarin: usare MacInCloud per compilare app per iOS in Visual Studio 2015

Come sapete, Xamarin permette di sviluppare app per diverse piattaforme: Android, Windows e iOS, sia attraverso Xamarin Studio che con Visual Studio 2015. Mentre per le prime due non ci sono problemi di sorta, in quanto sviluppo, compilazione, debug, test e tutto il resto possono essere eseguiti su Windows, per la parte iOS non è così in quanto le policy di Apple impongono che per compilare un'app ci voglia un Mac con XCode installato sopra. Sottolineo il "per compilare".
Ovviamente, non tutti hanno un Mac (incluso il sottoscritto), ma potreste avere la necessità di sviluppare anche per iOS. Quindi, come fai se il Mac non ce l'hai? (semi-cit.)

La Cloud ci viene ancora una volta incontro. Esiste un servizio, a pagamento, chiamato MacInCloud. Si tratta, in buona sostanza, di un'azienda che affitta Mac raggiungibili tramite desktop remoto e che fa proprio al caso nostro. Basterà sottoscrivere un piano, associare il Mac remoto a Xamarin e.. compilare! Visto che l'ho usato personalmente, in questo post voglio spiegare non solo come funziona ma anche darvi alcune dritte che nessuno vi dirà. Vi spiegherò l'uso in Visual Studio 2015, non con Xamarin Studio, ma credo che i passaggi siano simili.

Per prima cosa, potete visitare il sito:



Da qui, potrete visionare e selezionare uno dei piani a pagamento di vostro interesse:



Sceglierete un piano a seconda di cosa dovete fare, il Pay-as-you-go è abbastanza onesto perché con 1 $ all'ora offre quanto serve. Se scegliete questo, sappiate che il minimo è di 30 ore e vi verrà richiesto un anticipo di 30 $ con relativo credito a scalare. In sostanza, avrete 30 ore a disposizione già pagate.

In fase di registrazione e pagamento, fate attenzione a due particolari aspetti:

  • Scegliete OS X "El Capitan". Non scegliete Yosemite, perché ci sono problemi di compatibilità con le ultime versioni di Xamarin.
  • Ricordatevi di selezionare anche l'attivazione del Build Agent remoto. Sul piano Pay-as-you-go questo richiederà ulteriori 5 $, ma se non lo fate.. scordatevi di usare Xamarin dalla vostra macchina di sviluppo!
Una volta pagato e quindi registrati, vi verrà inviata una mail con una serie di informazioni tra cui: nome e indirizzo IP del Mac remoto, uno zip contenente dei file per connessioni tramite remote desktop e, ovviamente, user name e password. Ci sono diversi file .rdp, ognuno con una risoluzione specifica. Avviate quello che preferite (vi consiglio quello con più ampia risoluzione rispetto al vostro monitor), quindi inserite le credenziali che vi sono state inviate:



Se non ci sono intoppi, dopo alcuni secondi accederete al vostro Mac remoto:




Fate attenzione ad avere la porta 6000 sbloccata oppure visitate la pagina delle FAQ in caso di problemi. Il bello di MacInCloud è che il Mac remoto ha già installato tutto ciò che serve per sviluppare, sia Xamarin Studio e relativi tool, ma soprattutto XCode. Quest'ultimo tool a noi in realtà non serve direttamente, ma contiene l'SDK che viene usato dietro le scene da Xamarin. Importante: prima di tentare di collegare Xamarin al Mac, avviate XCode almeno una volta. Serve per attivare il tutto.

Altro punto importante: avere ottenuto un Mac remoto serve a poco se non lo lasciate attivo, quindi lasciate aperta la connessione in desktop remoto. Quando poi avrete terminato il lavoro, fate Logout altrimenti vi verranno addebitate le ore di connessione.

A questo punto passiamo a Visual Studio 2015. Se avete già esperienza di sviluppo con Xamarin e iOS utilizzando un Mac fisico, i passaggi successivi probabilmente li conoscete già. Diversamente, seguite i seguenti passaggi:

  1. Andate in Tools, Options, Xamarin, iOS Settings
  2. Cliccate su Find Xamarin Mac Agent
  3. Nella dialog che compare, cliccate su Add Mac

Per prima cosa inserite l'IP del Mac remoto, che vi è stato dato nell'email di registrazione a MacInCloud. Mettete l'IP e non il nome:


Click su Add. La finestra sottostante conterrà il Mac appena aggiunto, ma per ora non fate click su Connect bensì su Close:


Tornerete così alle opzioni di Visual Studio. Potete lasciare in bianco il percorso relativo all'Apple SDK, perché sul vostro Mac remoto è installato nella cartella di default. Potete scegliere se, una volta compilato, la vostra app venga eseguita nel simulatore locale (descritto in quest'altro post) oppure direttamente sul vostro Mac remoto. Togliendo la spunta, il tutto avverrà in remoto. Mettendola, verrà usato il simulatore locale. Ricordatevelo

Aprite ora il vostro progetto Xamarin, uno qualsiasi. Molto probabilmente Visual Studio vi chiederà di inserire le credenziali di accesso al vostro Mac remoto, quindi inserirete nome utente e password usati anche per la connessione tramite desktop remoto, e attenderete la connessione al Mac. Diversamente, vi verranno chieste nel momento in cui avviate l'app. Ad ogni buon conto, per prima cosa compilate il progetto iOS. Lascio alle vostre prove (o alla vostra esperienza) la specifica delle proprietà del progetto.

Nella barra degli strumenti di Visual Studio, nella parte di configurazione scegliete iPhone Simulator e poi scegliete uno dei device emulati disponibili con la freccetta che appare a fianco al pulsante di start, tra cui troverete varie versioni di iPhone e iPad.

Nota bene: il Mac Agent remoto dev'essere completamente avviato prima di eseguire la compilazione. Lo potrete verificare dalla barra di stato di Visual Studio, in basso a sinistra compare un messaggio di successo nel momento in cui l'agent è avviato. Quando pronti, potete premere F5 o comunque avviare. La seguente figura mostra l'app in esecuzione sul simulatore remoto, mentre la seconda su quello locale.



Chiaramente questo è ciò che serve per poter compilare, debuggare e testare un'app per iOS, poi c'è tutto il discorso relativo alla distribuzione ma la documentazione di Xamarin e di Apple sono esaustive al riguardo.

Io con MacInCloud mi sono trovato bene, ho avuto necessità del supporto tecnico e sono stati anche molto veloci e cordiali nel rispondere. Spero vi sia utile!

Alessandro

posted @ 19/08/2016 02:00 by Alessandro Del Sole

Visual Studio Code, importante aggiornamento alla versione 1.3.1

Recentemente, Microsoft ha rilasciato un importantissimo aggiornamento per Visual Studio Code, lo strumento di sviluppo cross-platform ed open source per Linux, Mac e Windows. Se volete conoscere meglio Code, potete leggere il mio ebook gratuito Visual Studio Code Succinctly, ma in questo post vi voglio dare qualche flash sugli importanti aggiornamenti dell'ultima versione.

Linguaggi
Linguaggi di markup come JSON, Markdown, LESS e CSS diventano ora estensioni e non più forniti out of the box. La cosa però interessante è che VS Code si accorge del linguaggio che vi serve e lo installa in modo asincrono, intanto che lavorate. Questo per esempio accade la prima volta che aprite un file C# e Code scaricherà tutto il pacchetto OmniSharp necessario.

Area di editing
L'area di editing subisce parecchie modifiche interessanti. I file vengono ora suddivisi in schede, le famose tab che Visual Studio ha da anni. Le tab possono anche essere oggetto di drag and drop fino ad avere i soliti tre file in editing contemporaneo. Il pannello noto come Working files diventa Open Editors. E' ora possibile sostituire testo in tutti i file, mentre prima era disponibile solo la ricerca. La Command Palette può mostrare l'elenco degl editor recenti e soprattutto viene introdotto il cosiddetto Problems Panel, un'area in cui vengono mostrati errori e warning raggruppati per file. Il pannello è filtrabile e sostituisce la visualizzazione degli errori disponibile nelle precedenti versioni. Una visione d'insieme:



Gestione di estensioni
L'estendibilità di Visual Studio Code è sempre stato uno dei suoi punti forti, tanto da spingere Microsoft a introdurre un apposito pannello nel navigation pane, all'interno del quale potrete visualizzare sia le estensioni installate, sia fare rapidamente aggiornamenti, sia cercarne di nuove:



In questo modo non dovrete più ricorrere alla Command Palette.

Debugger
La barra di debug ora è spostabile e viene introdotto un minimo supporto al cambio di valori delle variabili durante il debug. Inoltre, nel caso di Node.js, il debugger è in grado di fare attach a un processo esistente.

Molto altro
Quelle elencate sono le novità più succose e secondo me più importanti, ma ovviamente c'è dell'altro e l'elenco completo è disponibile nelle note di rilascio.

Alessandro

posted @ 27/07/2016 00:22 by Alessandro Del Sole

VS 2015 Update 3: installare un pacchetto NuGet come quick action dell'editor

Tra le varie novità introdotte da Visual Studio 2015 Update 3, la mia preferita è sicuramente la possibilità di installare un pacchetto NuGet tramite i suggerimenti del Light Bulb, quando si digita il nome di un oggetto che ancora non è definito. In buona sostanza, guardate qua:



Sto cercando di usare un oggetto, JsonConvert, che non è definito né nella BCL né in altra libreria referenziata. Quindi se uso il Light Bulb, troverò una nuova quick action che mi suggerisce di installare da NuGet la libreria Newtonsoft.Json, che in effetti è quella che definisce l'oggetto in questione. Mi basta un click per installare l'ultima versione, oppure posso scegliere di attivare la UI di NuGet. Nel primo caso, è questione di pochi secondi:



Come vedete, la libreria viene scaricata da NuGet, installata e referenziata. Inoltre viene automaticamente aggiunta la direttiva Imports (o using per C#) appropriata e l'oggetto viene riconosciuto.

Questa opzione non è abilitata per default, per farlo bisogna andare in Tools, Options, Text Editor, Basic (o C#) nel nodo Advanced selezionare la spunta per il suggerimento da NuGet:



Una grandissima comodità, sia se siete pigri come me , sia se conoscete in anticipo il nome degli oggetti da usare e volete lasciar fare il resto all'IDE.

Alessandro

posted @ 24/07/2016 22:59 by Alessandro Del Sole

Xamarin.Forms e i servizi WCF

Windows Communication Foundation è una delle tecnologie su cui molti sviluppatori hanno investito, nel tempo, per offrire informazioni, dati e operazioni all'interno di reti e di architetture SOA.

Sebbene oggi si preferiscano maggiormente servizi che supportano lo standard REST, tipo Web API, WCF riveste ancora una grande importanza per due motivi: fare tutto ciò per cui Web API è meno indicato e perché, appunto, ci sono investimenti esistenti.

Chiaramente, da quest'ultimo punto di vista, può emergere la necessità di far dialogare anche un'app per dispositivo Android, iOS e Windows con un servizio WCF e, per quello che interessa noi, Xamarin e la sua parte Xamarin.Forms. Pertanto in questo post vedremo come consumare servizi WCF da Xamarin.Forms superando alcune limitazioni di progetti che difficilmente ci riguarderanno ancora.

Il problema è infatti il seguente: in Xamarin.Forms, nel progetto PCL (quello in cui condivido il codice tra le piattaforme) non esiste più la voce Add Service Reference. Devo quindi crearmi la classe proxy a manina? No, una soluzione c'è.

Creare un servizio WCF

Per questo post creeremo un semplicissimo servizio WCF che esporrà un'operazione di servizio il cui compito è quello di calcolare l'area di un cerchio. Non ci serve affatto un servizio complicato, ci serve capire i passaggi soprattutto lato client. Utilizzerò C# (...) solamente per consistency con Xamarin, ma il servizio si può scrivere senza dubbio anche in VB. Visual Studio 2015 dev'essere avviato con privilegi di amministratore, perché poi pubblicheremo il servizio su IIS locale. Non utilizzeremo IIS Express che richiede configurazioni particolari per l'emulatore Android. Creato un progetto di tipo WCF Service Application, la prima cosa è definire il contract, ossia l'interfaccia-contratto che definiremo in questo modo (rinominando quella di default):

[ServiceContract] 
public
 interface ICircleService
{    
[OperationContract]    
double CalculateCircleArea(double radius);
}

Quindi, la classe di servizio che implementa il contract, anch'essa definita rinominando la parte .svc di default:

public class CircleService : ICircleService 
{    
public
 double CalculateCircleArea(double radius)    
{        
return
 radius*radius*Math.PI;    
}
}

Posto che il progetto compila, lo pubblichiamo facendo clic destro sul progetto, Publish. Nella finestra di pubblicazione dapprima selezioniamo il profilo Custom, a cui daremo un nome, quindi inseriamo le informazioni per la pubblicazione su IIS locale:



Al termine della pubblicazione, ci accerteremo che il servizio funzioni digitando l'URL http://localhost/WcfCircleService/CircleService.svc nel browser. Nel frattempo, munitevi dell'IP della vostra macchina di sviluppo (o comunque quella su cui pubblicate il servizio). Mentre usare Localhost va bene per la pubblicazione, per la connessione al servizio ci vuole l'IP per i motivi che poi vi spiego.

Consumare servizi WCF da un'app Xamarin.Forms
Un'app per Android, iOS e Windows scritta con Xamarin.Forms può facilmente consumare un servizio WCF. C'è un però: se vogliamo sfruttare il famoso comando Add Service Reference, dobbiamo rimuovere i progetti Windows 8.1 e Windows Phone 8.1. In teoria questo non sarà un grosso danno, se stiamo creando un nuovo progetto è molto probabile che ci interessi più che altro la parte di Universal Windows Platform. Creato quindi un nuovo progetto Xamarin.Forms basato su Portable Class Library, prima di connetterci al servizio dobbiamo eseguire questa sequenza di passaggi:

  1. Rimuovere i progetti Windows 8.1 e Phone 8.1. Già solo questo farà magicamente riapparire il comando Add Service Reference (c'è una nota limitazione legata ai progetti Windows Phone)
  2. Dal progetto PCL, rimuovere il pacchetto NuGet Xamarin.Forms. Questo è necessario perché dobbiamo cambiare il target della PCL
  3. Nelle proprietà del progetto PCL, clicchiamo su Change vicino ai target supportati e cambiamoli con quelli visibili nella prossima figura (di fatto togliamo Windows Phone 8.1)
  4. Reinstalliamo il pacchetto Xamarin.Forms da NuGet.



Fatto questo, possiamo finalmente connetterci al servizio WCF mediante Add Service Reference nel progetto PCL:




Importante: nell'indirizzo del servizio, mettete l'indirizzo IP. Non localhost, né il nome della macchina perché l'emulatore Android considera se stesso come il localhost. A questo punto il più è fatto. Nella pagina principale di questa app, possiamo scrivere dello XAML molto semplice che richieda l'inserimento del raggio e attenda il risultato del calcolo a seguito della pressione di un pulsante:

  <StackLayout Orientation="Vertical">     
<
Label Text="Insert radius:"             
VerticalOptions="Center"             
HorizontalOptions
="Center" />    
<
Entry x:Name="RadiusEntry" />    
<
Button x:Name="CircleButton" Text="Go!" Clicked="CircleButton_Clicked"/>    
<
Label x:Name="ResultLabel"/>  
</
StackLayout>
Il code-behind è altrettanto semplice, si crea l'istanza della classe client e si invoca il metodo di servizio:

public partial class MainPage : ContentPage 
{    
CircleServiceClient
 client;    
public MainPage()    
{        
InitializeComponent();        
this.client = new CircleServiceClient();        
this
.client.CalculateCircleAreaCompleted += Client_CalculateCircleAreaCompleted;    
}    

private
 void Client_CalculateCircleAreaCompleted(object sender, CalculateCircleAreaCompletedEventArgs e)    
{            
this
.ResultLabel.Text = e.Result.ToString();    
}    
private
 void CircleButton_Clicked(object sender, EventArgs e)    
{            
double
 radius = double.Parse(this.RadiusEntry.Text);            
this
.client.CalculateCircleAreaAsync(radius);    
}
}

Una considerazione fondamentale: non c'è modo di cambiare la generazione del codice basato su APM (Asynchronous Programming Model), quindi anche se la nostra operazione di servizio restituisce double, la classe proxy la costringe a ritornare void per poi scatenare un evento al completamento dell'operazione, all'interno del cui gestore troveremo il risultato dell'operazione stessa. Altre operazioni di generazione del codice sono disabilitate e pertanto, almeno da quel che ho visto, ce lo dobbiamo tenere così.

I permessi

Ricordiamoci che le nostre app devono poter accedere alla rete e pertanto devono avere i relativi permessi. Un'app Android vuole la permission Internet, una UWP vuole la Internet (client) e la Private Networks se siete all'interno di una rete locale. I permessi vanno impostati nei relativi manifest.

Risultato finale
Al termine di questo lavoro, la nostra app riesce a consumare il servizio WCF in modo molto semplice:



Come detto, il servizio utilizzato è molto molto semplice. La logica di connessione e generazione della classe proxy, però, è quella anche in servizi più complessi.

Alessandro

posted @ 13/07/2016 02:00 by Alessandro Del Sole

Nuovo articolo su MSDN Magazine: Xamarin Forms e l'accesso ai dati con SQLite

Con il numero di luglio 2016 di MSDN Magazine è stato pubblicato un mio nuovo articolo dal titolo "Working with local databases in Xamarin.Forms using SQLite".

L'articolo descrive come utilizzare SQLite per memorizzare dati locali nelle app cross-platform che possiamo creare per Android, iOS e Universal Windows Platform con Xamarin Forms e come SQLite sia un'ottima scelta nel caso in cui non ci servano database server o comunque dati remoti.

Con l'occasione ricordo che anche su VB T&T stiamo dedicando spazio a Xamarin, in particolare a Xamarin Forms: nell'area Video potete trovare tre video introduttivi. Ci stiamo poi attrezzando per altri contenuti.

Alessandro

posted @ 07/07/2016 16:00 by Alessandro Del Sole

Visual Studio 2015 Update 3: un consiglio per il setup

Come sapete da qualche giorno è disponibile l'Update 3 per Visual Studio 2015.
Parlando in giro con un po' di persone, sembra che molti abbiano avuto problemi installandolo dall'ISO disponibile per gli abbonati MSDN e, credo, anche sul sito di VS.

Anche se non è mia abitudine, stavolta ho utilizzato il Web Installer e problemi non ne ho avuti. Idem altre persone che hanno fatto la stessa cosa. Consiglio, quindi, di installarlo con questo piccolo tool. Non sono andato ad approfondire le ragioni, non c'è tempo, ma tant'è.

Alessandro

posted @ 02/07/2016 12:27 by Alessandro Del Sole

Microsoft MVP 2016

Da qualche anno il 1° luglio per me è sempre una giornata speciale, in quanto si attende la rinomina a Microsoft MVP che, fortunatamente, anche quest'anno è arrivata nella categoria Visual Studio and Development Technologies.

So di essere ripetitivo, ma per me è sempre un grande onore e una grande emozione far parte di questo gruppo di professionisti che nel globo si contraddistinguono non solo per le loro capacità, ma anche per la loro umanità, amicizia e spirito di community.

La community è fatta dalle persone e queste sono il vero benefit del programma MVP. Il primo award arrivò l'1 luglio 2008 per Visual Basic (e per alcuni anni a seguire), nel frattempo il mondo dello sviluppo su tecnologie Microsoft è cambiato molto e di riflesso sono cambiati tanti contenuti di cui mi sono occupato, spesso scrivendo nella lingua d'oltre oceano, ma spero che la passione che ci metto continui ad essere trasparente e che anche gli argomenti nuovi risultino utili.

Un ringraziamento a Microsoft, per la rinnovata fiducia, a tutti gli MVP per l'amicizia ma soprattutto un abbraccio ad Alessandro Teglia e Marjorie per tutto quello che hanno fatto in questi anni per noi.

Alessandro

posted @ 01/07/2016 22:45 by Alessandro Del Sole

Xamarin Forms, MVVM e il refresh dei command

Per questo post prendo spunto da una domanda ricevuta durante un corso che ho appena tenuto su Xamarin Forms, fornendo una soluzione che abbiamo recuperato tramite Internet ma che merita qualche approfondimento.

Se anche voi provenite da WPF e siete abituati ad utilizzare il pattern Model-View-ViewModel, sapete che la classe RelayCommand implementa l'interfaccia ICommand, che obbliga la classe ad avere, tra gli altri, un metodo CanExecute. Questo serve a dire agli oggetti in binding se un comando può essere eseguito oppure no.

Se ad esempio un pulsante è in binding con un comando e CanExecute è False, il pulsante risulta disabilitato. In WPF esiste la classe CommandManager e il suo metodo RequerySuggested, che consentono a RelayCommand di aggiornare manualmente lo stato di CanExecute. Essi però fanno parte dell'assembly PresentationCore che, ovviamente, in Xamarin non è disponibile.

In Xamarin Forms, però, esiste una classe Command che, oltre ad implementare ICommand, ha una struttura leggermente diversa e che può fare al caso. Per ottenere il risultato, in buona sostanza, si può riscrivere RelayCommand ereditando da Command invece che implementare ICommand e mettersi in ascolto di eventi PropertyChanged, al verificarsi dei quali verrà chiamato manualmente un delegate che si chiama ChangeCanExecute e che si occuperà di aggiornare, per l'appunto, lo stato di CanExecute.

Tradotto in codice:

    public class RelayCommand : Command
    {
        
public RelayCommand(Action<object> execute)
            : 
base(execute)
        {
        }

        
public RelayCommand(Action execute)
            : 
this(o => execute())
        {
        }

        
public RelayCommand(Action<object> execute, Func<objectbool> canExecute, INotifyPropertyChanged npc = null)
            : 
base(execute, canExecute)
        {
            
if (npc != null)
                npc.PropertyChanged += 
delegate { ChangeCanExecute(); };
        }

        
public RelayCommand(Action execute, Func<bool> canExecute, INotifyPropertyChanged npc = null)
            : 
this(o => execute(), o => canExecute(), npc)
        {
        }
    }

Fonte qui.

Alessandro

posted @ 30/06/2016 21:29 by Alessandro Del Sole