I Blogs di Visual Basic Tips & Tricks

Il mio libro Visual Studio LightSwitch Unleashed disponibile dal 29 febbraio

Alessandro Del Sole — Fri, 24 Feb 2012 10:34:57 GMT

Dopo lunga attesa, sono contento di poter annunciare che il mio nuovo libro Visual Studio LightSwitch Unleashed sarà finalmente disponibile a partire dal 29 febbraio 2012.

Mi porto avanti con questa comunicazione atteso che il 29 febbraio sarò a Redmond per l'MVP Global Summit e quindi avrò poco tempo per il blog

Il libro sarà disponibile solo in lingua inglese, poichè l'editore non fa anche traduzioni in altre lingue.

Facendo parte della collana Unleashed, non mi sono smentito e anche stavolta ho prodotto un bel tomo di circa 900 pagine. Ho trattato ogni possibile aspetto dello sviluppo LightSwitch, quanto meno dal punto di vista delle possibilità offerte e della strumentazione attualmente a disposizione.

Prima di annoiarvi con una descrizione, vi invito a scaricare gratuitamente il contenuto dimostrativo, costituito in formato PDF dal Capitolo 3, dall'elenco completo dei capitoli e degli argomenti trattati, dall'indice analitico, dai miei special thanks. Inoltre, andando nella pagina del libro su Amazon, cliccando sulla copertina è possibile spulciare ulteriori contenuti di esempio tratti dal volume.

E' anche inclusa la prefazione di Beth Massi, della quale sono ovviamente onorato. Beth fa parte del team di LightSwitch a Redmond ed ha rivestito la figura di editore tecnico per questo libro. La ringrazio in modo particolare sia per aver accettato la mia richiesta di rivestire quel ruolo, sia perchè attraverso le sue correzioni e i suoi suggerimenti ho potuto imparare davvero molte cose in più e ad ottimizzare determinate parti di codice.

Ci sono 19 capitoli + 2 appendici, organizzati in modo graduale di modo che anche il principiante possa cominciare senza problemi via via arrivando ad argomenti più 'tosti' e destinati a sviluppatori Silverlight e WPF già più esperti.

Si parla di come creare le applicazioni business, sia semplici che complesse, si parla di come implementare la propria business logic, si parla di query, di LINQ, di debug delle applicazioni. Si parla della distribuzione tramite pacchetti di installazione ma anche su server Web aziendali. Si parla di Cloud, descrivendo l'hosting su Windows Azure e l'uso di SQL Azure. Si parla di WCF RIA Services, di SharePoint, di sorgenti dati diverse da SQL Server. Si parla di Team Foundation Server e di source control in LightSwitch. Si parla di estendibilità dell'ambiente e delle applicazioni, in tutti i possibili extensibility points.

Chiaramente ho cercato di trasfondere l'esperienza reale, per cui si parla anche di cose non tipicamente trattate nel materiale didattico, come stored procedure, reportistica tramite extension, integrazione con Office, tips & tricks utili.

Il codice sorgente sarà disponibile, e scaricabile liberamente, entro pochi giorni sul book site e sarà sia per Visual Basic che per Visual C#, mentre gli esempi all'interno del libro sono solo in Visual Basic. Tengo a ringraziare in modo particolare coloro che hanno pre-ordinato il libro molto tempo fa e che hanno dovuto attendere così a lungo. Purtroppo i processi su libri di questo genere sono molto articolati e l'autore del libro è solo una parte di un'organizzazione complessa

Se avete feedback o altre curiosità inerenti il libro, sarò contento di rispondere all'interno dei forum di LightSwitch Tips & Tricks.

Alessandro

Visual Studio 11 Beta e .NET Framework 4.5 Beta in arrivo il 29 febbraio - Sneak Preview

Alessandro Del Sole — Fri, 24 Feb 2012 07:54:25 GMT

Chiaramente in concomitanza con il rilascio della Consumer Preview di Windows 8, il futuro degli sviluppatori su tecnologie Microsoft comincerà a delinearsi il giorno 29 febbraio, data in cui verrà rilasciata la Beta di Visual Studio 11 e .NET Framework 4.5.

Ieri i maggiori rappresentanti della Dev Div a Redmond hanno scritto dei blog post in cui mostrano una serie di screen shot e descrivono alcune delle più innovative caratteristiche di questo prodotto, sebbene in beta.

Vi segnalo quindi:

il Developer Center di MSDN aggiornato
Blog post di S. Somasegar
Blog post di Jason Zander
Blog post del team di Visual Studio

Come potete vedere, piaccia o non piaccia Metro is everywhere, ma questo è abbastanza naturale

Ci aggiorneremo d'ora in avanti con le novità inerenti il primo passo vero verso la nuova versione dell'ambiente di sviluppo.

Alessandro

WPF 4.5: novità nel VirtualizingStackPanel

Alessandro Del Sole — Tue, 21 Feb 2012 16:39:58 GMT

Come sapete, il VirtualizingStackPanel è uno speciale contenitore che alcuni controlli WPF utilizzano, per default, per presentare liste di dati (es. ListBox, ListView, DataGrid).

Come infatti il nome lascia intendere, questo contenitore è in grado di virtualizzare la collection associata al controllo, di modo che la combinazione tra scorrimento e caricamento in memoria sia il più possibile "responsive" e ottimizzata per collection molto grandi.

In WPF 4.5 il VirtualizingStackPanel subisce due ulteriori miglioramenti:

nell'architettura: by design il controllo è ora più performante di prima
nella gestione: viene introdotta la proprietà ScrollUnit, che accetta due valori: Item e Pixel. Item fa si che lo scrolling visualizzi solo gli elementi completamente virtualizzati, quindi fa sì che l'intero elemento sia visibile. Pixel, invece, scrolla normalmente mostrando un po' alla volta l'elemento in via di virtualizzazione

Ho fatto un po' di test e l'uso di ScrollUnit lo ritengo abbastanza estremo. Nel senso che le performance del VirtualizingStackPanel sono ottime anche con 500000 istanze di oggetti.

Ho questo codice XAML:

    <Grid DataContext="{Binding}">
        <Grid.RowDefinitions>
            <RowDefinition Height="*"/>
            <RowDefinition Height="40"/>
        </Grid.RowDefinitions>
        <ListBox 
                 VirtualizingPanel.ScrollUnit="Item" Grid.Row="0"
                 ScrollViewer.CanContentScroll="True"
                 ItemsSource="{Binding}" Name="VirtualizingBox" ScrollViewer.VerticalScrollBarVisibility="Auto">
            <ListBox.ItemTemplate>
                <DataTemplate>
                    <Border BorderBrush="Black" CornerRadius="5" BorderThickness="3" Margin="40">
                        <StackPanel Background="LightBlue">
                            <TextBlock  Text="{Binding FirstName}" Height="40" FontSize="30" Width="250"/>
                            <TextBlock  Text="{Binding LastName}" Height="40" FontSize="30" Width="250"/>
                        </StackPanel>
                    </Border>
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>
        <Button Content="Load" Name="LoadButton" Click="LoadButton_Click" Grid.Row="1"/>
    </Grid>

Ho una ListBox che riceverà dei dati a runtime, per la quale ho esplicitato la virtualizzazione (è by default, ma non guasta...) e la visualizzazione di scroll bar. Ho anche impostato la attached property ScrollUnit del panel virtualizzante (che parolona ). I due TextBlock sono collegati in binding a una ipotetica classe Contact o altro nome. Ho, inoltre, ipoteticamente creato una classe Contacts che è di tipo ObservableCollection(Of Contact). Se consideriamo ora il seguente codice:

    Dim c As Contact
    Dim cs As New Contacts

    Private Sub LoadButton_Click(sender As Object, e As RoutedEventArgs)
        Dispatcher.InvokeAsync(Sub()
                                   For i = 1 To 100000
                                       c = New Contact
                                       c.Age = 34
                                       c.FirstName = "Nome " + i.ToString
                                       c.LastName = "Cognome " + i.ToString
                                       cs.Add(c)
                                   Next
 
                                   For Each item In cs
                                       Me.VirtualizingBox.Items.Add(item)
                                   Next
                               End Sub)
 
    End Sub

sto generando 100000 istanze della classe Contact e potrò verificare da solo l'opera di virtualizzazione compiuta dal VirtualizingStackPanel a runtime.

Quello che però è interessante notare è anche un nuovo metodo della classe Dispatcher, chiamato InvokeAsync, che consente di eseguire in modo asincrono un attività di tipo Action, rappresentata in questo caso da una statement lambda la quale si occupa di generare le istanze della classe.

Questa modalità asincrona consente un'ulteriore ottimizzazione del caricamento, non ci sono problemi di cross-thread perchè l'attività viene eseguita nello stesso thread ed è, inoltre, una delle altre novità di WPF 4.5.

Alessandro

WPF 4.5: Nuove API per le Binding Expressions

Alessandro Del Sole — Tue, 21 Feb 2012 16:19:39 GMT

Già nelle precedenti versioni di WPF esisteva una classe chiamata BindingOperations, che consente l'interazione con le espressioni di binding poste in essere attraverso istanze di System.Windows.Data.Binding e System.Windows.Data.MultiBinding.

In WPF 4.5 questa classe viene arricchita con alcune API che permettono di conoscere ulteriormente, a runtime, le espressioni di binding. In particolare è possibile recuperare:

l'oggetto destinatario del binding
la proprietà del citato oggetto, destinataria del binding
il tipo che costituisce la sorgente dati
la proprietà della sorgente dati che è collegata in binding

Ad esempio consideriamo il seguente codice, in cui una TextBox è collegata in binding a un'istanza di una ipotetica classe Person (o Contact o come volete ) che esponga una proprietà chiamata FirstName:

        <StackPanel DataContext="{Binding}">
            <TextBlock Text="{Binding FirstName}" FontSize="18" Name="NameBox"/>
            <Button Name="GetBindingButton" Width="100" Height="30" Content="Go!"/>
        </StackPanel>

In questo esempio la binding expression è costituita dal contenuto della coppia di parentesi graffe all'interno della proprietà Text. Scrivendo codice come il seguente:

    Dim expression = BindingOperations.GetBindingExpression(NameBox, TextBlock.TextProperty)
 
    Dim target As DependencyObject = Expression.Target
    Dim targetProperty As DependencyProperty = Expression.TargetProperty
    Dim source As Object = Expression.ResolvedSource
    Dim sourceName As String = Expression.ResolvedSourcePropertyName
 
    'Mostra: TextBlock
        MessageBox.Show(target.DependencyObjectType.Name)
    'Mostra: Text
        MessageBox.Show(targetProperty.Name)
    'Mostra: Person (o Contact o il nome del tipo)
        MessageBox.Show(source.GetType.Name)
    'Mostra: FirstName
        MessageBox.Show(sourceName)

è possibile ottenere determinate informazioni sul binding, come da commenti nel codice. Fondamentale è l'invocazione al metodo GetBindingExpression della classe BindingOperations, i cui argomenti sono il nome del controllo su cui insiste il binding e il nome della dependency property di cui vogliamo ottenere informazioni. E' abbastanza ovvio che, nel caso degli oggetti target, si tratti rispettivamente di DependencyObject e DependencyProperty. Questo è chiaramente solo un esempio, sfruttando le varie proprietà di istanza esposte dai tipi ottenuti è possibile ottenere anche il risultato di espressioni più complesse.

Alessandro

WPF 4.5: INotifyDataErrorInfo

Alessandro Del Sole — Mon, 20 Feb 2012 15:23:01 GMT

WPF 4.5 introduce una significativa novità nella validazione dei dati, costituita dall'interfaccia INotifyDataErrorInfo. Questa proviene da Silverlight e la sua peculiarità è quella di poter validare i dati anche in modalità asincrona (es. nell'ambito di callback).

Tale interfaccia ha tre membri fondamentali da implementare:

la proprietà HasErrors, di tipo booleano, che restituisce vero o falso a seconda che per la proprietà specificata esistano o meno errori di validazione
il metodo GetErrors che restituisce una IEnumerable di errori di validazione che colpiscono la proprietà specificata
l'evento ErrorsChanged, che va scatenato quando la collezione di errori viene modificata

Il seguente esempio (tratto da MSDN per Silverlight) mostra come implementare l'interfaccia e come aggiungere o rimuovere, da una collection di tipo Dictionary, voci costituenti errori di validazione attraverso due metodi chiamati AddError e RemoveError:

Imports System.ComponentModel
 
Public Class Product
    Implements INotifyDataErrorInfo
 
    Private idValue As Integer
    Public Property Id As Integer
        Get
            Return idValue
        End Get
        Set(ByVal value As Integer)
            If IsIdValid(value) AndAlso
                idValue <> value Then idValue = value
        End Set
    End Property
 
    Private nameValue As String
    Public Property Name As String
        Get
            Return nameValue
        End Get
        Set(ByVal value As String)
            If IsNameValid(value) AndAlso
                nameValue <> value Then nameValue = value
        End Set
    End Property
 
    ' Validates the Id property, updating the errors collection as needed.
    Public Function IsIdValid(ByVal value As Integer) As Boolean
 
        Dim isValid = True
 
        If value < 5 Then
            AddError("Id", ID_ERROR, False)
            isValid = False
        Else
            RemoveError("Id", ID_ERROR)
        End If
 
        If value > 10 Then
            AddError("Id", ID_WARNING, True)
        Else
            RemoveError("Id", ID_WARNING)
        End If
 
        Return isValid
 
    End Function
 
    ' Validates the Name property, updating the errors collection as needed.
    Public Function IsNameValid(ByVal value As String) As Boolean
 
        Dim isValid = True
 
        If value.Contains(" ") Then
            AddError("Name", NAME_ERROR, False)
            isValid = False
        Else
            RemoveError("Name", NAME_ERROR)
        End If
 
        If (value.Length > 5) Then
            AddError("Name", NAME_WARNING, True)
        Else
            RemoveError("Name", NAME_WARNING)
        End If
 
        Return isValid
 
    End Function
 
    Private errors As New Dictionary(Of String, List(Of String))
    Private ReadOnly ID_ERROR As String = "Value cannot be less than 5."
    Private ReadOnly ID_WARNING As String = "Value should not be less than 10."
    Private ReadOnly NAME_ERROR As String = "Value must not contain any spaces."
    Private ReadOnly NAME_WARNING As String = "Value should be 5 characters or less."
 
    ' Adds the specified error to the errors collection if it is not 
    ' already present, inserting it in the first position if isWarning is 
    ' false. Raises the ErrorsChanged event if the collection changes. 
    Public Sub AddError(ByVal propertyName As String, ByVal [error] As String,
                        ByVal isWarning As Boolean)
 
        If Not errors.ContainsKey(propertyName) Then _
            errors(propertyName) = New List(Of String)()
 
        If Not errors(propertyName).Contains([error]) Then
            If isWarning Then
                errors(propertyName).Add([error])
            Else
                errors(propertyName).Insert(0, [error])
            End If
            RaiseErrorsChanged(propertyName)
        End If
 
    End Sub
 
    ' Removes the specified error from the errors collection if it is
    ' present. Raises the ErrorsChanged event if the collection changes.
    Public Sub RemoveError(ByVal propertyName As String, ByVal [error] As String)
 
        If errors.ContainsKey(propertyName) AndAlso
            errors(propertyName).Contains([error]) Then
 
            errors(propertyName).Remove([error])
            If errors(propertyName).Count = 0 Then errors.Remove(propertyName)
            RaiseErrorsChanged(propertyName)
 
        End If
 
    End Sub
 
    Public Sub RaiseErrorsChanged(ByVal propertyName As String)
        RaiseEvent ErrorsChanged(Me,
            New DataErrorsChangedEventArgs(propertyName))
    End Sub
 
    Public Event ErrorsChanged As EventHandler(Of DataErrorsChangedEventArgs) _
        Implements INotifyDataErrorInfo.ErrorsChanged
 
    Public Function GetErrors(ByVal propertyName As String) _
        As System.Collections.IEnumerable _
        Implements INotifyDataErrorInfo.GetErrors
        Return errors(propertyName)
    End Function
 
    Public ReadOnly Property HasErrors As Boolean _
        Implements INotifyDataErrorInfo.HasErrors
        Get
            Return errors.Any
        End Get
    End Property
 
End Class

Lato XAML l'accortezza che bisogna avere è quella di impostare a True l'espressione NotifyOnValidationError:

    <StackPanel>
        <TextBox Text="{Binding Path=Id, Mode=TwoWay, NotifyOnValidationError=True}" Margin="5"/>
        <TextBox Text="{Binding Path=Name,Mode=TwoWay,NotifyOnValidationError=True}" Margin="5"/>
    </StackPanel>

Chiaramente WPF utilizza un template di default per la visualizzazione degli errori, per cui un errore verrebbe evidenziato in questo modo:

Come però sapete è possibile ridefinire l'ErrorTemplate delle TextBox e presentare gli errori in modo anche diverso.

Alessandro

WPF 4.5: integrazione grafica Win32 migliorata

Alessandro Del Sole — Mon, 20 Feb 2012 15:11:38 GMT

Sebbene anche nelle versioni precedenti di WPF fosse possibile integrare elementi grafici Win32 all'interno di elementi WPF, in passato esisteva il problema del cosiddetto air space. Sostanzialmente, secondo la logica dell'air space, ogni elemento ha un suo spazio che non può prevaricare quello degli altri.

Tradotto in altri termini e semplificando al massimo la questione, elementi Win32 che venivano integrati con WPF fino alla v. 4.0 non potevano subire alcune azioni tipiche di WPF stessa, ad esempio gli oggetti Win32 integrati non potevano essere sottoposti all'utilizzo di oggetti Transform o di oggetti Brush.

Per capire come cambiano le cose in WPF 4.5, possiamo ricorrere al controllo WebBrowser che apparentemente è nativo di WPF ma in realtà è un wrapper della controparte Win32. Quindi possiamo scrivere qualcosa di questo tipo:

    <UniformGrid Columns="2" x:Name="grid">
        <WebBrowser x:Name="_webBrowser" Source="http://www.visual-basic.it" Margin="5" Opacity="0.6">
            <WebBrowser.RenderTransform>
                <ScaleTransform ScaleX="0.5" ScaleY="0.5" />
            </WebBrowser.RenderTransform>
        </WebBrowser>
        <Rectangle Margin="5">
            <Rectangle.Fill>
                <VisualBrush Visual="{Binding ElementName=_webBrowser}" />
            </Rectangle.Fill>
        </Rectangle>
    </UniformGrid>

Il rendering viene poi controllato dalle seguenti due nuove proprietà dell'oggetto HWndHost:

IsRedirected che, se True, stabilisce che l'HwndHost può condividere l'air space tra WPF e Win32
CompositionMode, che permette di stabilire la modalità con cui l'air space viene condiviso (None, OutputOnly dove la condivisione è ammessa ma l'utente non può agire sul contenuto hostato, Full dove la condivisione è ammessa e l'utente ha pieno accesso al contenuto hostato).

Così facendo, laddove aveste necessità di integrare dei contenuti grafici di tipo Win32, sappiate che ora potete sfruttarli ancora meglio anche dal punto di vista delle trasformazioni.

Alessandro

WPF 4.5: data-binding verso proprietà statiche

Alessandro Del Sole — Mon, 20 Feb 2012 14:58:28 GMT

In WPF 4.5 viene aggiunto il supporto per il data-binding anche nei confronti di proprietà statiche (shared in VB) delle nostre classi.

Questa peculiarità è stata richiesta a gran voce da molti e Microsoft ha deciso di accoglierla nella nuova versione di WPF. L'utilizzo è abbastanza semplice e si può scegliere tra due approcci che ora andiamo ad esaminare. Consideriamo la seguente classe, che espone due proprietà statiche di pura fantasia:

Imports System.ComponentModel
 
Public Class StaticModel
 
    Public Shared Event ValoreCondivisoChanged As EventHandler
 
    Private Shared _valoreCondiviso As String
    Public Shared Property ValoreCondiviso As String
        Get
            Return _valoreCondiviso
        End Get
        Set(value As String)
            If value <> _valoreCondiviso Then
                _valoreCondiviso = value
                RaiseEvent ValoreCondivisoChanged(Nothing, EventArgs.Empty)
            End If
        End Set
    End Property
 
    Public Shared Event StaticPropertyChanged As EventHandler(Of PropertyChangedEventArgs)
 
    Private Shared _velocità As Double
    Public Shared Property Velocità As Double
        Get
            Return _velocità
        End Get
        Set(value As Double)
            _velocità = value
            NotifyStaticPropertyChanged("Velocità")
        End Set
    End Property
 
    Private Shared Sub NotifyStaticPropertyChanged(propertyName As String)
        RaiseEvent StaticPropertyChanged(Nothing, New PropertyChangedEventArgs(propertyName))
    End Sub
End Class

Le implementazioni delle due proprietà sono accomunate dal fatto che entrambe devono scatenare un evento che farà sapere all'interfaccia grafica che i dati sono cambiati. Ciò premesso, nella prima proprietà si dichiara un evento non generico (in senso .NET ) e questo evento viene scatenato al variare dei dati. Poichè è un tipo EventHandler, questo approccio non è considerato 'astratto' o riutilizzabile, ma specifico per la singola proprietà.

Nel secondo caso c'è invece un evento generico chiamato StaticPropertyChanged, la cui implementazione richiama il comportamento della ben nota INotifyPropertyChanged e permetterà di notificare alla UI le modifiche attraverso un approccio generico e passando informazioni addizionali. Vedremo poi lato XAML la differenza sostanziale tra i due.

Il binding lato XAML funziona in modo identico a come già conosciamo, con una piccola differenza sintattica. Nel caso specifico dichiaro un namespace XML che mi permetta di accedere alle proprietà:

xmlns:local="clr-namespace:WpfApplication1"

Supponiamo poi di avere alcuni controlli utente che debbano essere collegati in binding con le proprietà di cui sopra:

    <StackPanel>
        <TextBox Text="{Binding Path=(local:StaticModel.ValoreCondiviso), Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" Width="100" Height="30"/>
        <TextBlock Text="{Binding Path=(local:StaticModel.Velocità)}" Width="100" Height="30"/>
        <Button Content="Button" HorizontalAlignment="Left" Height="29" Margin="43,192,0,0" VerticalAlignment="Top" Width="200" Click="Button_Click"/>
    </StackPanel>

NOTA BENE: Nella prima develope preview di VS 11, il codice di cui sopra fa comparire un errore nel designer, ma dovete ignorarlo. E' un problema già noto e si verifica anche se la sintassi è corretta.

Possiamo quindi notare che:

la sintassi vuole che dopo Path, ci sia una coppia di parentesi tonde all'interno della quale la proprietà statica è raggiungibile nella forma namespace:NomeClasse.NomeProprietà
nel caso dell'approccio con evento non generico, si esplicità l'UpdateSourceTrigger come PropertyChanged (atteso che l'evento non generico non si comporta come l'altro che richiama il meccanismo delle notifiche)

Vi basta modificare a runtime i valori delle due proprietà e rendervi conto come in effetti il data-binding funzioni nel modo atteso.

Alessandro

Archivio Sportelli Bancari - Elenco Abi Cab Aggiornato a Fine Gennaio 2012

Luciano Bastianello — Mon, 20 Feb 2012 07:55:58 GMT

L'archivio sportelli bancari elenco Abi Cab aggiornato a fine gennaio 2012 disponibile per lo scaricamento a questo indirizzo:
Alcune informazioni sui files:
- campi separati da tabulazione hex: 09
- righe separate dal terminatore di riga windows hex: 0d0a
- intestazione colonne sulla prima riga
Il file TabAbi contiene i dati relativi alle banche.
Il file TabAbiCab contiene le informazioni relative agli sportelli
Nel file TabAbi e TabAbiCab è presente il campo "Aggiornamento" che evidenzia la data di riferimento di validità dei dati.
Tutte le righe di TabAbiCab che NON contengono la data più recente sono da considerarsi relative a sportelli non più attivi o assorbiti da altre banche, tali sportelli sono presenti solo come log dei dati storici, ne è sconsigliato l'utilizzo per nuove emissioni di flussi di comunicazione con le banche.
Questo archivio è da considerarsi frutto di una rielaborazione "amatoriale" dei dati degli sportelli bancari reperibili in rete l'unico mio apporto è l'aggiunta della data di ultima importazione in modo tale da costituire un archivio comprendente anche i dati di banche e sportelli non più attivi.
Non si rivendica nessun diritto riguardo al contenuto del file, l'utilizzatore ne può fare ciò che vuole senza contattarmi nè informarmi della cosa, preferirei inoltre non essere neanche citato come fonte in eventuali successive redistribuzioni.
Se si vuole una garanzia circa la correttezza dei dati e/o una qualsiasi licenza il mio consiglio è di NON utilizzare il presente archivio e di rivolgersi direttamente alla propria banca chiedendo di avere in forma ufficiale il file degli sportelli bancari.
I ringraziamenti sono comunque graditi.
Se sentite il malsano bisogno di farmi pervenire una somma di denaro, in alternativa scegliete l'organizzazione umanitaria a voi più gradita e fate a questa il vostro pagamento.

Powered with Windows Live Writer

Community Days 2012: com'è andata

Alessandro Del Sole — Sun, 19 Feb 2012 11:10:46 GMT

Come sapete, giovedì e venerdì u.s. si sono tenuti i Community Days 2012 a Milano, presso la nuova sede di Microsoft Italia a Peschiera Borromeo (MI).

Si tratta dell'evento community più importante dell'anno, poichè le community italiane vengono coinvolte sia a livello di speaker e sessioni, sia a livello di sinergie nel sostenere l'evento stesso.

VB T&T ha partecipato con me e Renato Marzaro come speaker; la mia sessione su WPF 4.5 ha riempito la sala (di questo ne sono chiaramente onorato) ed è stata una delle poche volte in cui, parlando di WPF, ho trovato un pubblico molto preparato in materia.

L'evento ha consentito di presentare argomenti e tecnologie assolutamente di primo piano, come lo sviluppo Metro per Windows 8, le nuove Web API, Kinect, il Web sotto vari di punti di vista.

Ma al di là di questo, che è chiaramente importante, c'era un'atmosfera eccezionale. Un incontro tecnico, certo, ma un ritrovarsi tra amici e una partecipazione tipica dello spirito di community. Ho partecipato a tanti eventi, sia come attendee che come speaker, ma ai Community Days 2012 ho vissuto un'esperienza veramente speciale.

I miei più sinceri complimenti a Daniele Bochicchio e Andrea Saltarello per un'organizzazione impeccabile e degna di giornate come queste e un ringraziamento a tutti coloro che hanno contribuito alle giornate.

E speriamo di replicare in un'altra occasione ;) Non dimenticate di visitare il sito dell'evento anche per il download dei materiali.

Alessandro

Dopo dieci anni…

Diego Cattaruzza — Fri, 17 Feb 2012 10:54:00 GMT

Ogni tanto capita di sentirsi soddisfatti.

Oggi ho ricevuto il seguente messaggio:

Buongiorno Diego ti volevo ringraziare per il tuo fondamentale aiuto.

Da ieri sto usando SOLO il programma in VB2010 che soprattutto grazie a te sono riuscito a finire o meglio adesso lo posso perfezionare ai miei… usi e consumi.

Ho abbandonato sinceramente con un po' di ..timore il vecchio in VB6 dopo 10 anni di ..onorato servizio ma....doveva accadere.

ti ringrazio di nuovo e ti auguro una buona giornata.

Ora, che uno si decida a sviluppare in .Net non è poi quel gran evento, se accade dopo dieci anni, ma è un evento che 'il merito' di questo cambiamento sia attribuito a me in modo così 'importante' da far sentire il dovere (o l'entusiasmo) di scrivermi appositamente un messaggio di ringraziamento.

E' in momenti come questo che uno si sente degno della nomina a MVP :D:D:D

Stampare direttamente un reportViewer

Flavio Firmo — Fri, 17 Feb 2012 08:58:47 GMT

Uno dei post più caldi dell'anno viene riservato alla stampa diretta del reportviewer. Siamo tutti felici quando vediamo il nostro report a video e lo mandiamo alla stampante tramite la sua icona. Però cosa succede se ho molti report da stampare, per esempio un centinaio di fatture a fine mese? Cento click sull'icona sono fastidiosi e fanno perdere un sacco di tempo.
Allora procediamo con calma. Esiste una funzione che permette la stampa diretta, ma parte dal presupposto di creare un immagine grafica in memoria e stamparla. Funziona, certo ma cambia l'altezza di alcuni font con il risultato di avere le stampe imperfette.
La logica della mia funzione è simile, ma genero un file PDF che poi stampo. Per ampliare l'impatto emotivo della funzione immagino di avere tutti i dati in una griglia e selezionarne soltanto alcuni e mandarli in stampa.
Bando alle ciancie e si comincia.

          Dim NumeroFattura As String
        Dim row As DataGridViewRow
         For Each row In VwFattureListaDataGridView.Rows
            If row.Selected = True Then 'se la riga è selezionata
                'componi il nome del file che andrai a creare
                NumeroFattura = CInt(row.Cells(2).Value) & "_" & Year(row.Cells(3).Value)
                Dim nomeFileDestinazione As String = System.Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) & "\Ft " & NumeroFattura & ".pdf"
                'crea la fonte dati LinqToSql e associala alla fonte dati del report
                Dim stampa = From report In mydc.vwFattures _
                      Where report.idFattura = CInt(row.Cells(0).Value) _
                      Order By report.Posizione _
                      Select report
                VwFattureBindingSource.DataSource = stampa
                'compila i parametri
                Dim PrintRef As Boolean = chkPrintRef.Checked
                Dim params(0) As Microsoft.Reporting.WinForms.ReportParameter
                params(0) = New Microsoft.Reporting.WinForms.ReportParameter("StampaRiferimenti", PrintRef, False)
                Me.rptFattura.LocalReport.SetParameters(params)
                Me.rptFattura.RefreshReport()

                'quindi creo il file pdf.
                Dim warnings As Microsoft.Reporting.WinForms.Warning() = Nothing
                Dim streamids As String() = Nothing
                Dim mimeType As String = Nothing
                Dim encoding As String = Nothing
                Dim extension As String = Nothing
                Dim bytes As Byte()
                bytes = rptFattura.LocalReport.Render("PDF", Nothing, mimeType, encoding, extension, streamids, warnings)
                Dim fs As New IO.FileStream(nomeFileDestinazione, IO.FileMode.Create)
                fs.Write(bytes, 0, bytes.Length)
                fs.Close()
                'richiama il file pdf appena creato e mandalo in stampa
                Dim MyProcess As New Process
                MyProcess.StartInfo.CreateNoWindow = False
                MyProcess.StartInfo.Verb = "print"
                MyProcess.StartInfo.FileName = nomeFileDestinazione
                MyProcess.Start()
                MyProcess.WaitForExit(10000)
                MyProcess.CloseMainWindow()
                MyProcess.Close()

            End If
        Next

Se vi è piaciuto non dimenticate di comprare il mio romanzo.
http://www.ebookvanilla.it/il-cavaliere-bianco.html
troverete qualche personaggio famoso di VBT&T

WPF 4.5: Live Shaping

Alessandro Del Sole — Sun, 12 Feb 2012 14:31:50 GMT

Uno dei difetti che ha contraddistinto WPF fino alla sua versione 4.0 riguarda il fatto che l'interfaccia grafica non riflette automaticamente azioni di ordinamento, filtro e raggruppamento eseguite nei confronti di una ICollectionView o, più genericamente, di una collezione.

Il problema è definitivamente risolto in WPF 4.5 grazie a una nuova caratteristica nota come Live Shaping.

Ho sempre la stessa classe Contact, più una ObservableCollection chiamata Contacts:

Imports System.ComponentModel
 
Public Class Contact
    Implements System.ComponentModel.INotifyPropertyChanged
 
    Public Property LastName As String
    Public Property FirstName As String
 
    Private _age As Integer
    Public Property Age As Integer
        Get
            Return _age
        End Get
        Set(value As Integer)
            _age = value
            RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs("Age"))
        End Set
    End Property
 
    Public Event PropertyChanged(sender As Object, e As ComponentModel.PropertyChangedEventArgs) Implements ComponentModel.INotifyPropertyChanged.PropertyChanged
End Class
 
Public Class Contacts
    Inherits System.Collections.ObjectModel.ObservableCollection(Of Contact)
 
End Class

A differenza del passato, abbiamo ora a disposizione un tipo chiamato ICollectionViewLiveShaping, che si usa come una ICollectionView ma che supporta anche delle proprietà booleane chiamate IsLiveSorting, IsLiveFiltering, IsLiveGrouping che, se impostate a True, permettono alla UI di aggiornare automaticamente la presentazione dei dati. Ipotizzando di avere una Window qualunque, supponiamo di popolare una collezione di contatti in questo modo:

    Private Sub LiveShapingWindow_Loaded(sender As Object, e As RoutedEventArgs) Handles Me.Loaded
        Dim cnt As New Contacts
        cnt.Add(New Contact With {.Age = 34, .FirstName = "Alessandro", .LastName = "Del Sole"})
        cnt.Add(New Contact With {.Age = 44, .FirstName = "Renato", .LastName = "Marzaro"})
        cnt.Add(New Contact With {.Age = 18, .FirstName = "Contatto", .LastName = "AppenaMaggiorenne"})
 
 
        Dim view = CType(CollectionViewSource.GetDefaultView(cnt), ICollectionViewLiveShaping)
        view.IsLiveSorting = True
        Me.DG1.ItemsSource = cnt
 
        view.IsLiveFiltering = True
    End Sub

Dove DG1 è una semplice DataGrid definita, lato XAML, in questo modo (con colonne auto-generate per velocità):

Come potete vedere la ICollectionViewLiveShaping si usa in un modo che già conosciamo ma, impostandone la proprietà di interesse su True, otterremo finalmente l'effetto desiderato.

Alessandro

Windows 8 Developer Portal, Content e Store: Partecipa alla community per migliorare il glossario italiano per i dev

Alessandro Del Sole — Sat, 11 Feb 2012 10:01:22 GMT

Come da questo post di Lorenzo, MSDN Italia lancia un'iniziativa che permette alla comunità di sviluppatori di contribuire al miglioramento del glossario di Windows 8 in italiano, con particolare riferimento a quella che è la terminologia per sviluppatori.

Il forum è stato aperto il 9 febbraio e lo rimarrà fino al 22 c.m. Se avete avuto modo di dare un'occhiata alla prima developer preview di Windows 8 si tratta indubbiamente di una bella opportunità.

Alessandro

WPF 4.5: Delay Binding

Alessandro Del Sole — Thu, 09 Feb 2012 20:52:01 GMT

Con questo post vorrei iniziare una mini-serie dedicate alle novità di Windows Presentation Foundation 4.5, ossia quella che sarà la versione disponibile nella ventura release di .NET Framework. Per eseguire il codice chiaramente è necessario avere installato la Developer Preview di Visual Studio 11.

Vi ricordo che venerdì 17 p.v. terrò una sessione completa sulle novità della piattaforma ai Community Days 2012.

In questo post parliamo del Delay Binding, una feature che all'apparenza può avere scarsa utilità ma che in realtà in alcuni scenari può essere utile. Di cosa si tratta? Sostanzialmente, in un data-binding di tipo Two-Way, è possibile ritardare l'aggiornamento della sorgente dati collegata di un tempo specificato in millisecondi. Questo presuppone che l'UpdateSourceTrigger nel binding sia di tipo PropertyChanged.

La documentazione MSDN in preview fa un esempio calzante, ossia un controllo Slider al cui spostamento il valore collegato non viene aggiornato subito per evitare overhead. Qui invece facciamo un esempio diverso, secondo me più adatto per capire.

Non uso MVVM perchè anche i meno esperti vanno incoraggiati a capire meglio. Ho una banale classe Contact:

Imports System.ComponentModel
 
Public Class Contact
    Implements System.ComponentModel.INotifyPropertyChanged
 
    Private _lastName As String
    Public Property LastName As String
        Get
            Return _lastName
        End Get
        Set(value As String)
            _lastName = value
            RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs("LastName"))
        End Set
    End Property
 
    Private _firstName As String
    Public Property FirstName As String
        Get
            Return _firstName
        End Get
        Set(value As String)
            _firstName = value
            RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs("FirstName"))
        End Set
    End Property
 
    Public Event PropertyChanged(sender As Object, e As ComponentModel.PropertyChangedEventArgs) Implements ComponentModel.INotifyPropertyChanged.PropertyChanged
End Class

Viene implementata INotifyPropertyChanged per inviare una notifica quando i dati sono modificati. Poi ho una Window così definita:

<Window x:Class="DBWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="clr-namespace:WpfApplication1"
    Title="DBWindow" Height="300" Width="300">
    <Window.Resources>
        <local:Contact x:Key="DemoContact"/>
    </Window.Resources>
    <Grid DataContext="{Binding Source={StaticResource DemoContact}}">
        <StackPanel DataContext="{Binding}">
            <TextBox Text="{Binding Path=FirstName, Mode=TwoWay, Delay=3000, UpdateSourceTrigger=PropertyChanged}" Width="200" Height="40" FontSize="16"/>
            <TextBox Text="{Binding Path=LastName, Mode=TwoWay, Delay=3000, UpdateSourceTrigger=PropertyChanged}" Width="200" Height="40" FontSize="16"/>
 
            <Button Width="100" Name="Button1" Height="40" Click="Button1_Click" Content="Mostra valori" Margin="0,20,0,0"/>
        </StackPanel>
    </Grid>
</Window>

Nelle risorse dichiaro un'istanza della classe Contact da utilizzare come contesto dati della finestra stessa. Ho due TextBox collegate in binding alle rispettive proprietà della classe citata. Come vedete il binding ha ora una nuova proprietà chiamata Delay, che permette di specificare l'intervallo in millisecondi trascorso il quale la UI invierà le modifiche fatte alla sorgente collegata.

L'evento Click del pulsante è semplice e serve null'altro che a mostrare una stringa contenente il nome e cognome del contatto:

    Private Sub Button1_Click(sender As Object, e As RoutedEventArgs)
        Dim contactInstance = CType(FindResource("DemoContact"), Contact)
 
        MessageBox.Show(String.Concat(contactINstance.FirstName, " ", contactINstance.LastName))
    End Sub

Per capire come funziona il codice sopra esposto, lanciamo l'applicazione. Inseriamo dei valori e attendiamo tre secondi. Poi facciamo altre modifiche e clicchiamo sul pulsante prima che siano trascorsi i tre secondi specificati. Ci accorgeremo a questo punto che le modifiche fatte non sono state ancora invitate all'oggetto collegato, a causa del delay binding. Trascorso l'intervallo specificato, invece, le modifiche saranno inviate all'oggetto.

Un utilizzo di questo tipo di binding può riguardare oggetti che subiscono continue modifiche (es. testo) e che quindi non necessitano di un update finchè la modifica non si è conclusa.

Alessandro

Windows 8 Beta disponibile dal 29 febbraio

Alessandro Del Sole — Thu, 09 Feb 2012 18:26:51 GMT

Di solito non scrivo di queste cose se non quando le notizie provengono da uno dei canali MSDN che di solito seguo, ma siccome c'è una notizia da un blog Microsoft, per me vale come ufficiale (al di là dei tanti rumours).

Nel suo blog su TechNet Italia, Feliciano Intini comunica, in questo post, che Windows 8 Consumer Preview (la Beta, insomma) sarà disponibile a partire dal 29 febbraio in concomitanza con il Mobile World Congress 2012 di Barcellona. Come Feliciano sottolinea, probabilmente questo rilascio fatto a una delle più importanti conferenze per device mobili ha un suo significato importante.

Io a quella data sarò all'MVP Global Summit a Redmond e sono curioso di vedere che tipo di aria si respirerà!

Alessandro

Disponibile Kinect per Windows

Alessandro Del Sole — Thu, 02 Feb 2012 09:26:37 GMT

E' di ieri la notizia della disponibilità di Kinect SDK per Windows. Il noto dispositivo precedentemente disponibile solo per XBox ora è anche disponibile, con una licenza commerciale (al prezzo suggerito di $ 249), per sviluppare applicazioni che permettano di interagire col sistema operativo del pc attraverso gesti.

Esiste un blog del Team di Kinect per Windows, sul quale potete trovare tutte le ultime novità e le informazioni essenziali per iniziare ad avvicinarsi a questa nuova frontiera di sviluppo, che secondo me avrà delle ottime prospettive soprattutto in ottica futura.

Alessandro

Community Days 2012: informazioni di dettaglio

Alessandro Del Sole — Wed, 01 Feb 2012 22:54:30 GMT

Ci siamo quasi! Tra circa due settimane avrà luogo l'evento community più importante dell'anno, ossia quello dei Community Days 2012! L'hashtag ufficiale su Twitter è #cdays12.

La nostra community avrà quest'anno l'onore di partecipare con 2 sessioni, una mia su WPF 4.5 e una di Renato Marzaro su Kinect. Approfitto quindi per ringraziare tutti gli iscritti, circa 700 , che sono il vero cuore di queste due giornate!

Oltre a noi, chiaramente, c'è una nutrita agenda di sessioni sulle più recenti novità tecnologiche Microsoft, quindi parliamo di Windows 8, Windows Phone, Windows Azure, ASP.NET MVC, ecc. ecc.

Un sincero ringraziamento anche agli instancabili Daniele e Andrea, che hanno messo in piedi una macchina organizzativa perfetta.

Qualche info di dettaglio, soprattutto di tipo logistico.

Servizio navetta e come raggiungere la sede

Grazie a Microsoft Italia, è stato predisposto un servizio navetta gratuito. Ci sono due navette da 50 posti l'una la mattina e due la sera, dal terminal degli autobus sopra la stazione M3 di San Donato.

Orari:

Andata: 8.45 e 9:00
Ritorno: 18.45 e 19:00

Sulla pagina di Microsoft Italia a questo indirizzo sono riportate le altre modalità per raggiungere la sede.
Per chi è in auto, l'Innovation Center di Microsoft Italia è dotato di un parcheggio sotterraneo dedicato e di due parcheggi più piccoli, scoperti.

Cosa portare se partecipate ai lab

Se siete iscritti ad uno dei lab dev, dovete portare con voi il vostro computer portatile. Alla reception vi verrà dato un accesso ad internet usando la guest wifi di Microsoft.

Se partecipate al lab Web Camp, andate su questa pagina e scaricate il materiale specifico. Dovete avere installato VS 2010 SP1, ASP.NET MVC 3 e WebMatrix 2 (beta, va benissimo).

Per il lab Windows Phone, dovete avere i tool installati.

Per il lab Azure, dovete avere i tool Azure installati ed avere una sottoscrizione Azure già attiva al momento di partecipare al lab.

Vi aspettiamo all'evento! Ci vediamo il 16 e il 17 febbraio!

Alessandro

Lab su Windows Azure ai Community Days 2012

Alessandro Del Sole — Wed, 01 Feb 2012 18:07:06 GMT

Nel ricordarvi che il 16 e 17 febbraio vi aspettiamo ai Community Days 2012, approfitto per segnalarvi che ci sono ancora pochissimi posti disponibili per il lab su Windows Azure che verrà tenuto il venerdì.

Trattandosi di una ghiotta occasione per conoscere meglio la Cloud e la piattaforma di servizi che Microsoft ha creato per essa, direi che fareste bene ad iscrivervi

Tutte le info qui. Ricordatevi di installare l'SDK di Windows Azure sul vostro pc.

Alessandro

Com'è andato l'evento con DotNetLiguria del 27 gennaio

Alessandro Del Sole — Tue, 31 Jan 2012 16:54:51 GMT

Venerdì 27 gennaio ho avuto il piacere di tenere a Genova una sessione di introduzione a Visual Studio LightSwitch nel primo workshop del 2012 della community DotNetLiguria.

Sono molto soddisfatto della sessione, anche perchè è stata seguita da sviluppatori con skill già medio-alti su .NET e non provenienti (almeno attualmente ) dai mondi VB 6 e Access. Domande precise e circostanziate, mi è piaciuto molto.

Tendenzialmente, si sa, lo sviluppatore esperto non gradisce molto determinate limitazioni e imposizioni, ma in LightSwitch questo è ripagato dal tempo (molto) che si risparmia poichè non c'è da fare tutte le operazioni di generazione di roba c.d. "plumbing" (interfaccia, pulsanti, creazione DAL, ecc. ecc.).

Circa il resto dell'evento, mi ha particolarmente colpito la lucidità che i partecipanti hanno dimostrato nell'intendere Silverlight, come dimostrato nella prima roundtable. Molto interessante la sessione sui Code Contracts di Claudio Masieri, che ha saputo utilizzare un approccio molto friendly alla cosa.

Le slide della mia sessione sono disponibili a questo indirizzo. Infine, un ringraziamento speciale a Raf e ai ragazzi della community per la calorosa accoglienza e per l'ottimo pomeriggio/pizza!

Alessandro

Windows Phone: cambiare skin all'emulatore

Alessandro Del Sole — Thu, 26 Jan 2012 21:42:21 GMT

Stanchi della skin di default dell'emulatore di Windows Phone? Niente di più semplice: cambiatela!

C'è un bellissimo progetto su CodePlex chiamato Windows Phone 7 Emulator Skin Switcher che vi permette di scegliere tra ben 25 skin diverse che riproducono l'estetica dei dispositivi più diffusi.

Io, ovviamente, ho ora la skin del Nokia Lumia

Alessandro

Windows Phone: effetto turn-style nella navigazione tra pagine

Alessandro Del Sole — Thu, 26 Jan 2012 21:33:55 GMT

Vi segnalo questo bellissimo post dell'amico Cristian Civera il quale ci spiega come applicare l'effetto di transizione che vediamo normalmente nella navigazione tra pagine in Windows Phone anche all'interno delle nostre app.

Cristian, secondo me, ha sempre avuto la grande dote di spiegare in modo semplice anche gli argomenti più complessi e questo post non è da meno.

Alessandro

Address Book Sample per LightSwitch

Alessandro Del Sole — Thu, 26 Jan 2012 21:26:36 GMT

Beth Massi ha pubblicato l'esempio completo, chiamato Address Book, a corredo della serie di post intitolata "Beginning Visual Studio LightSwitch", che potete trovare in questo suo post.

Nel citato post è anche disponibile l'elenco completo della serie di articoli che vi permetteranno di comprendere ancora meglio questo speciale ambiente di sviluppo.

Alessandro

SQL: Backup automatici con Nant

Antonio "tdj" Catucci — Mon, 23 Jan 2012 21:44:31 GMT

Chi utilizza la versione Express di SQL Server sa bene che una delle differenze rispetto alle versioni “Full” è l’assenza del SQL Server Agent, un processo fondamentale per schedulare le diverse attività sul server. Una di queste è il backup di uno o più database che non dovrebbe mai mancare su un server!

Naturalmente esistono dei tools sia a pagamento che gratuiti per colmare questa lacuna ma si può ovviare al problema anche utilizzando strumenti non direttamente ricollegabili al mondo SQL.
Uno di questi è NAnt, un Build Tool ossia un framework per la creazione di script di build (in questo caso per .NET).
Senza entrare troppo nel dettaglio, si tratta di creare uno script che esegue una serie di task (chiamati Target) in maniera più o meno strutturata.
Nel nostro caso vogliamo creare uno script di backup di un database compattato in un archivio ZIP.

Installazione di Nant
Per prima cosa scarichiamo NAnt dal Download NAnt. Non esiste un setup automatico ma bisogna semplicemente scompattare il contenuto del file .ZIP in una cartella qualunque.

Creazione dello script
NAnt è basato su file script chiamati Build File che non sono altro che file xml con estensione .build. Ecco il nostro file db.backup.build:

<?xml version="1.0"?>
<project default="backup">
    <property name="backup.path" value="E:\Backup" />
    <property name="backup.name" value="" />
    <property name="backup-date" 
                    value="${datetime::get-year(current-date)}${string::pad-left(datetime::get-month(current-date),2,'0')}${string::pad-left(datetime::get-day(current-date),2,'0')}" />
    <property name="filename" value="${backup.name}_${backup-date}" />
	
    <target name="backup">
	<echo message="Running backup... ${datetime::now()}" failonerror="False" />
	<exec program="sqlcmd" 
                          commandline="-S .\sqlexpress -i &quot;E:\backup\sql\database.backup.sql&quot;  
                          -v dbname=${backup.name} filename=${filename} path=&quot;${backup.path}&quot;
                          -o &quot;${backup.path}\${filename}.log&quot;" />
	<call target="zip" />
    </target>
	
     <target name="zip">
	<property name="backup.file" value="${backup.path}\${filename}.bak" />
	<if test="${file::exists(backup.file)}">
		<echo message="Compressing..." failonerror="False" />
		<zip zipfile="${backup.path}\${filename}.zip">
			<fileset basedir="${backup.path}">
    			    <include name="${filename}.bak" />
			</fileset>
		</zip>
		<delete file="${backup.path}\${filename}.bak" />
	</if>
    </target>
</project>

Lo script definisce, all’inizio, delle varibili identificate dall’elemento <property> utilizzate nei vari task con la sintassi ${nome_variabile}. Da notare la variabile filename che identifica il nome del file finale composto dal nome del database e la data corrente calcolata dalla variabile backup-date nel formato yyyymmdd.

I task sono due. Il primo, “backup”, esegue il backup del database utilizzando l’utility sqlcmd per eseguire il file script database.backup.sql:

declare @filename nvarchar(500)
set @filename='$(path)\$(filename).bak' 

declare @dbname varchar(255)
set @dbname = '$(dbname)'

BACKUP DATABASE @dbname
	TO  DISK = @filename
WITH 
	NOFORMAT, 
	NOINIT,  
	NAME = @dbname,
	SKIP, 
	STATS = 10;
GO

Si tratta di un semplice comando BACKUP che sfrutta le variabili identificate da $(nome_variabile) che sono valorizzate sternamente utilizzando l’opzione –v variabile=valore del comando sqlcmd.

Il secondo task, “zip”, è lo zip del backup utilizzando un task predefinito di NAnt chiamato <zip> nel quale si specificano i file da includere nell’archivio mediante l’uso dell’elemtno <fileset>…</fileset>.
L’ultima operazione è eliminare il backup con la funzione <delete />.

Ora non ci resta che provare lo script eseguendo questo comando utilizzando la shell di Windows (cmd):

c:\> nant.exe -buildfile:E:\Backup\db.backup.build -D:backup.name=Northwind

I parametri specificati sono due:

1) buildfile: il path del nostro script (in questo esempio in E:\backup);

2) D: valorizza le <property> definite dello script. Nell’esempio specifichiamo il nome del database valorizzando la property backup.name.

Se tutto ha funzionato bene avremo il nostro backup zippato. A questo punto possiamo schedulare il tutto con il Task Scheduler di Windows

Interessanti opportunità al .Net Campus 2012

Diego Cattaruzza — Fri, 20 Jan 2012 10:04:50 GMT

Dall'organizzazione veniamo informati sulle novità relative all'evento, e io ve le comunico volentieri:

da oggi si è aperto il contest "progetti e idee": puoi pubblicare la tua idea di applicazione sul sito e farla valutare agli sponsor.
Le 5 migliori proposte potranno essere presentate al .NET Campus Roma e la migliore proposta value uno stage retribuito in Avanade !
abbiamo pubblicato i primi annunci di lavoro degli sponsor sul sito:
puoi segnalare la tua candidatura direttamente dal sito.
sul sito puoi inoltre pubblicare il tuo profilo tecnico per farti
conoscere ed essere contattato dagli sponsor dell'evento.

Quindi, iscrivetevi :D:D:D

Windows Phone: salvare una foto dal Web all'hub sul device (Visual Basic)

Alessandro Del Sole — Thu, 19 Jan 2012 18:24:55 GMT

La piattaforma di sviluppo per Windows Phone mette a disposizione una serie di API per l'interazione con il Pictures Hub, che è poi il posto in cui vengono memorizzate le foto.

Una richiesta molto frequente è quella di poter salvare nel device foto da Internet, dato il loro indirizzo Web. Posto che ci siamo accertati di avere il permesso di poterlo fare , ricorriamo a una serie di strumenti. Innanzitutto usiamo la classe WebClient per eseguire il download asincrono della foto. Quindi spostiamo il suo contenuto fatto di byte in un file all'interno dell'isolated storage, per poi eseguire il salvataggio vero e proprio.

Per interagire in modo rapido con l'hub delle foto è conveniente utilizzare la classe MediaLibrary (che non fa solo questo), messa a disposizione dall'assembly Microsoft.Xna.Framework. Tale assembly, al quale dobbiamo necessariamente aggiungere un riferimento nel nostro progetto, è specifico per i giochi sviluppati con XNA ma si integra perfettamente con le app.

Il codice che ci permette di eseguire questa operazione non è affatto complicato, richiede solo un po' di dimestichezza con gli stream. Eccolo, con i commenti che facilitano la lettura:

'The following Imports directives are required
'Imports System.Windows.Resources
'Imports System.IO
'Imports Microsoft.Xna.Framework.Media
'Imports System.IO.IsolatedStorage
 
Private Sub SavePictureToHub(webAddress As Uri, pictureName As String)
    Dim client As New WebClient()
    AddHandler client.OpenReadCompleted, Sub(sender As Object, e As OpenReadCompletedEventArgs)
                                             'Get the result of the download operation as a stream
                                             Dim resInfo As New StreamResourceInfo(e.Result, Nothing)
                                             Dim reader As New StreamReader(resInfo.Stream)
 
                                             'Get a reference to the isolated storage
                                             Dim store = IsolatedStorageFile.GetUserStoreForApplication
 
                                             'Read the downloaded stream
                                             Dim contents As Byte()
                                             Using bReader As New BinaryReader(reader.BaseStream)
                                                 contents = bReader.ReadBytes(CInt(reader.BaseStream.Length))
                                             End Using
 
                                             'Move the downloaded stream to a temp file into the isolated storage
                                             Using fStream As IsolatedStorage.IsolatedStorageFileStream = store.CreateFile(pictureName)
                                                 fStream.Write(contents, 0, contents.Length)
                                             End Using
 
                                             'Save the picture to the Pictures hub (Saved pictures)
                                             Using rStream As New IsolatedStorageFileStream(pictureName, FileMode.Open, store)
                                                 Dim ml As New MediaLibrary
                                                 ml.SavePicture(pictureName, rStream)
                                             End Using
 
                                             reader.Close()
 
                                             'Remove the temp file from the isolated storage
                                             store.DeleteFile(pictureName)
                                         End Sub
 
    client.OpenReadAsync(webAddress)
End Sub

Per una comodità personale uso le statement lambda dove posso, chiaramente si poteva incapsulare il codice della sub 'nidificata' in un delegate separato. L'unica cosa di cui tener conto (oltre, come detto, ad avere il permesso di scaricare la foto) è che le immagini verranno salvate nell'album chiamato Foto Salvate.

Alessandro