A quanto pare il setup di Silverlight 2.0 Beta 2 è proprio riuscito male (vedi anche ). Quest'oggi mi sono imbattuto nell'ennesimo problema che mi ha costretto a penare parecchio per trovare una soluzione.

I sintomi sono molteplici:

  1. Tentando di aggiungere una Service Reference si ottiene l'errore "Object not set to a reference of an object" dopo aver selezionato il servizio da generare
  2. Premendo il pulsante "Advanced..." nella finestra di selezione del servizio appare un errore "Unable to find 'DynamicTypeService'"
  3. Nel pannello di controllo la dimensione dei "Microsoft Silverlight Tools Beta 2 for Visual Studio 2008" è di 1,14 MB anzichè 1,17 MB

Se i punti elencati sono veri per voi ecco come dovete procedere per riuscire ad installare correttamente i famigerati "tools":

  1. Andate nella cartella "%programfiles%\Microsoft Visual Studio 9.0\Common7\IDE" e cancellate la DLL Microsoft.VisualStudio.ServicesProxy.dll
  2. Disinstallate dal pannello di controllo la voce "Microsoft Silverlight Tools Beta 2 for Visual Studio 2008"
  3. Scaricare da i tools (se non li avete già) e con un Prompt di Visual Studio raggiungete il file silverlight_chainer.exe
  4. Digitate silverlight_chainer.exe /extract e selezionate una cartella in cui scompattare l'archivio
  5. Chiudete tutte le istanze di Visual Studio 2008
  6. Tra i vari file estratti trovate VS_SilverlightTools_Beta2_Setup.exe ed eseguite il setup
  7. Al termine del setup controllate nel pannello di controllo che la dimensione dei tools installati corrisponda a 1,17 MB. In tal caso il problema è risolto
  8. Aprite Visual Studio 2008 e verificate che il problema sia risolto

Come spiegato in , probabilmente il problema deriva dal fatto che il setup trovando Microsoft.VisualStudio.ServicesProxy.dll già presente nel filesystem interrompe l'installazione credendo che tutta una serie di componenti siano già presenti nel sistema. Ecco spiegata la diversità nelle dimensioni dell'installato, anche se al momento esiste una sola versione del setup (quindi non andate a cercare un setup aggiornato come ho fatto io...)

Il consiglio è di verificare la presenza di Microsoft.VisualStudio.ServicesProxy.dll prima di procedere al setup se ancora non avere installato Silverlight 2.0 Beta 2, così perlomeno vi risparmiate un po' di lavoro inutile...

E ora passo a sistemare il portatile... :(


Se come a me vi capita di avere problemi di installazione di Silverlight 2.0 Beta2 vi consiglio di guardarvi questo di Brad Bartz che fornisce molte utili indicazioni per risoverli. Il problema principale che ho riscontrato è che l'installer silverlight_chainer.exe - per intenderci quello che installa tutto il necessario, Tools e SDK compresi - non è stato in grado di rimuovere una patch di Visual Studio 2008 (KB949325). Perciò vi consiglio di verificare a mano nel pannello di controllo che questa patch sia presente e in tal caso di disintallarla prima di lanciare il setup di Silverlight 2.0.

Inoltre, prima di eseguire Visual Studio 2008, subito dopo il termine dell'installazione, ricordate di azzerare i packages eseguando il seguente comando:

devenv /resetskippkgs

Dopo queste operazioni che ho faticosamente estratto dal lungo post, finalmente tutto ha cominciato a funzionare a dovere... almeno spero.

Ecco il link:

UPDATE: Verificate anche quanto riportato in questo post


Developer Express si prepara a rilasciare una Grid gratuita per lo sviluppo con Sivlerlight 2.0. Ecco le feature:

  • Data Grouping against multiple Silverlight Grid columns
  • Data Sorting against multiple Silverlight Grid columns
  • Comprehensive Summary Computation support against multiple Silverlight Grid columns
  • Column Movement
  • Column Resizing
  • Column Auto-Width
  • Row Editing
  • Row Preview (with animation)
  • Template Support (for cell content, cell editing, row preview and headers)
  • Auto Height Support for cells, headers, and totals.
  • Virtual StackPanel Row Container (simply means we are able to handle an unlimited number of rows)
  • Focused Row and Focused Cell
  • Multi-Row Selection
  • Cell Text Wrapping
  • Vertical/Horizontal Lines
  • Multiple column types/editors

    Vista così pare un sogno... Stiamo a vedere

    Link: http://www.devexpress.com/Products/NET/Components/Silverlight/Grid/


  • Da un post che riassume la keynote del teched

    • UI Framework: Beta 2 includes improvements in animation support, error handling and reporting, automation and accessibility support, keyboard input support, and general performance. This release also provides more compatibility between Silverlight and WPF.
    • Rich Controls: Beta 2 includes a new templating model called Visual State Manager that allows for easier templating for controls. Other features include the introduction of a TabControl, text wrapping and scrollbars for TextBox.  DataGrid additions include Autosize, Reorder, Sort, performance increases and more. Most controls are now in the runtime instead of packaged with the application.
    • Networking Support: Beta 2 includes improved Cross Domain support and security enhancements, upload support for WebClient, and duplex communications (“push” from server to Silverlight client).
    • Rich Base Class Library: Beta 2 includes improved threading abilities, LINQ-to-JSON, ADO.NET Data Services support, better support for SOAP and other improvements to make networking and data handling easier.
    • Deep Zoom: Beta 2 introduces a new XML-based file format for Deep Zoom image tiles as well as a new MultiScaleTileSource that enables existing tile databases to utilize Deep Zoom. Better, event driven notification for zoom/pan state is another improvement in Silverlight 2 Beta 2.

    Fonte: New Features in Silverlight 2 Beta 2


    Tra le righe di questo post si trovano lumi sulla modalità di licenza di Silverlight 2.0 beta 2

    Microsoft is releasing Silverlight 2 Beta 2 with one of its "Go Live" licenses. That means, gulp, businesses can deploy Beta 2 in production. In the tradition of Microsoft eating its own dog food, MSN will serve up 3,000 hours of Olympics content using Silverlight 2 Beta 2.

    Fonte: Silverlight 2 Beta 2 Go Live


    Domani sarà un'altra giornata campale per la mia attività di community. Mi troverò infatti nuovamente di fronte ad una nutrita platea - sono attese circa 80 persone - per parlare di Silverlight 2.0.

    La sessione che terrò, a partire dalle 18:20 circa sarà una overview delle possibilità offerte dalla nuova piattaforma per le applicazioni RIA, attualmente in Beta 1, ma che si spera al più presto venga rilasciata al pubblico. Vedremo perciò i punti salienti di Silverlight 2.0, iniziando dall'onnipresente XAML, affrontando Brush, Trasformazioni, Animazioni, Layout, Stili e Risorse per poi passare alla parte della programmazione vera e propria, con esempi interattivi, Networking, Templates e quant'altro. Il tutto naturalmente con numerosi esempi pratici di codice come consueto per le mie sessioni.

    Sarà un'ora molto densa, nella quale spero di solleticare la vostra curiosità. Siete invitati tutti a farvi riconoscere come lettori del mio blog e a pormi le domande che volete sui temi della sessione o anche su altro. Come sempre farò il tutto possibile per rispondervi con dovizia di particolari.

    Vi ricordo inoltre anche le altre interessanti sessioni della serata, con Davide Bedin che parlerà di WCF e Andrea Dottor che ci mostrerà le meraviglie di ASP.NET 3.5 creando una applicazione in tempo reale...

    Per chi ancora non fosse iscritto: http://webcongress.xedotnet.org


    Stasera è arrivata la segnalazione che il mio bug qualche giorno fa è stato chiuso. Putroppo la soluzione non è quella che speravo ma un by-design. Non sarà quindi possibile avere una classe base comune per gli UserControl di Silverlight... Mi sa che mi dovrò inventare qualcosa...

    Link:


    Le due settimane che sono iniziare ieri sono dense di appuntamenti per il nostro gruppo e ci aspettano ben due eventi GRATUITI che si terranno il 16 e il 29 Maggio.

    Un appuntamento da non perdere per tenersi aggiornati sulla piattaforma Microsoft per lo sviluppo su web. Andrea Dottor infatti oltre a mostrare alcune delle feature di ASP.NET 3.5 mostrerà anche una preview di alcuni dei controlli rilasciti nella recente beta della Service Pack 1. Inizio ore 19:00 - leggi >>

    Organizzato in collaborazione con 1NN0va, si tratta di un evento ad ampio spettro dedicato agli sviluppatori web. Oltre ad ASP.NET 3.5 vedremo anche Silverlight 2.0 e Windows Communication Foundation 3.5. Gli argomenti saranno esposti da me (Silverlight 2.0). Andrea Dottor (ASP.NET 3.5) e Davide Bedin (WCF). Inizio ore 18:00 - leggi >>

    Vi consiglio di prenotare il vostro posto in prima fila al più presto perchè ormai siamo agli sgoccioli.


    Il video è un po' vecchio dato che è uscito su channel 10 a fine marzo ma a quanto vedo non ha avuto molta eco in Italia. E poi è davvero divertente perciò ho deciso di proporlo lo stesso...

    Non fosse altro che per la frase più bella di tutto il video con la quale ho dato il titolo al questo post.

    "I do develop and design... so I'm a diviner!" (diviner==mago indovino) :)

    Davvero folli...

    Link: http://on10.net/blogs/tina/Silverlight-Rehab/

    Technorati Tag: ,
    tags: - categories: XAML

    Ieri sera ho trovato il tempo di configurare l'hosting e di pubblicare gli esempi della library che ho messo su codeplex qualche giorno fa. Si tratta del codice che va anche a corredo dei recenti articoli in inglese che ho scritto nei giorni scorsi. Gli esempi per ora sono due.

    1. CollectionViewSource - /
    2. RadialPanel - /

    L'indice degli esempi si trova qui: http://silverlight.boschin.it/library

    L'esempio riguardante il RadialPanel è il più interessante dal punto di vista dell'impatto grafico mentre a mio parere il componente più utile è la CollectionViewSource.

    Gli esempi naturalmente richiedono l'installazione di .

    Come sempre i feedback sono graditissimi.


    Ho finalmente pubblicato la mia ultima fatica. Si tratta di un , accompagnato da un po' di codice rilasciato su codeplex, che spiega come fare a creare un controllo CollectionViewSource per Silverlight 2.0. Il controllo , presente all'interno di Windows Presentation foundation fin dalla prima versione ma assente in Silverlight 2.0, consente di operare facilmente delle trasformazioni a sorgenti dati senza dover intervenire sulla stessa. Esso funziona come un filtro che si interpone tra la datasource e il controllo che consuma i dati e trasforma il contenuto della datasource operando filtri o ordinamenti. Nel caso di WPF esso è anche in grado di supportare il grouping ma dato che in Silverlight non vi sono controlli che possono consumarlo non mi sono preoccupato di implementare anche questa feature.

    Il controllo CollectionViewSource che ho creato è stato inserito all'interno di una libreria open source su codeplex ed è liberamente scaricabile sotto licenza CCPL non commerciale al seguente indirizzo:

    L'articolo, che ho scritto completamente in inglese per cercare di raggiungere un pubblco più vasto oltre che per misurare la mia capacità di scrivere in questa lingua, si concentra innanzitutto sul funzionamento del Databinding in Silverlight 2.0 e poi introduce il controllo spiegando le scelte operate per renderlo funzionante. Chi fosse interessato può leggerlo qui:

    Spero di avere al più presto i vostri feedback oltre che sul contenuto dell'articolo anche sulla qualità del mio - probabilmente stentato - inglese.


    Una delle possibilità mancanti in silverlight 2.0 è quella di creare dei controlli con un rendering custom. L'unica soluzione per creare delle forme complesse è quella di comporre tra loro figure più semplici quali poligoni o path. In questo breve esempio voglio mostrarvi come fare a creare un controllo che disegni un poligono regolare di cui sia conosciuto il numero di vertici. Inoltre questo poligono sarà in grado di assumere una percentuale di "stellatura" che indichi la profondità dell'effetto stella ad esso applicato.

    star

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     


    Il primo passo per arrivare al risultato è quello di determinare come costruire la figura. Nel caso del poligono regolare possiamo indifferentemente usare un Polygon o un Path, ma è sicuramente più proficuo e immediato usare un Polygon. Il nostro algoritmo di disegno quindi dovrà determinare la posizione dei vertici rispetto ad un ipotetico centro e tracciare le rette che li congiungono. Considerato che un poligono potrà avere una Width e una Height il processo migliore per determinare i vertici è quello di percorrere un'ellisse inscritta nel rettangolo determinato dall'area e ad intervalli regolari tracciare un segmento che unisca il punto corrente al precedente. In questo modo avremo sempre un poligono che riempia del tutto l'area e che quindi potrà essere anche distorto. Il poligono regolare lo avremo quando Width e Height sono uguali. Ecco il codice necessario all'operazione:

       1: private void DrawPolygon(Size size)
       2: {
       3:     this.Polygon.Width = size.Width;
       4:     this.Polygon.Height = size.Height;
       5:  
       6:     double halfWidth = this.Width / 2;
       7:     double halfHeight = this.Height / 2;
       8:  
       9:     PointCollection points = new PointCollection();
      10:  
      11:     for (double angle = 0; angle < Math.PI * 2; angle += Math.PI * 2 / this.VertexCount)
      12:     {
      13:         double x = halfWidth * Math.Sin(angle) + halfWidth;
      14:         double y = halfHeight * Math.Cos(angle) + halfHeight;
      15:         points.Add(new Point(x, y));
      16:     }
      17:  
      18:     this.Polygon.Points = points;
      19: }

    Per ottenere l'effetto di stellatura invece dovremmo suddividere l'elisse in un numero doppio di vertici e tracciarne metà su di essa e metà su una elisse concentrica più interna la cui dimensione sia una frazione (espressa in percentuale) rispetto alla più esterna. Regolando la percentuale di stellatura avremo stelle con punte più o meno acuminate. Ad esempio per ottenere la classica stella a cinque punte dovremmo impostare VertexCount = 5 e StarPercentage = 60%.

       1: private void DrawStar(Size size)
       2: {
       3:     this.Polygon.Width = size.Width;
       4:     this.Polygon.Height = size.Height;
       5:  
       6:     double halfWidth = this.Width / 2;
       7:     double halfHeight = this.Height / 2;
       8:     double xStar = halfWidth / 100 * (100 - this.StarPercentage);
       9:     double yStar = halfHeight / 100 * (100 - this.StarPercentage);
      10:  
      11:     PointCollection points = new PointCollection();
      12:  
      13:     int count = 0;
      14:  
      15:     for (double angle = 0; angle < Math.PI * 2; angle += Math.PI * 2 / (this.VertexCount * 2))
      16:     {
      17:         if (count++ % 2 == 0)
      18:         {
      19:             double x = halfWidth * Math.Sin(angle) + halfWidth;
      20:             double y = halfHeight * Math.Cos(angle) + halfHeight;
      21:             points.Add(new Point(x, y));
      22:         }
      23:         else
      24:         {
      25:             double x = xStar * Math.Sin(angle) + halfWidth;
      26:             double y = yStar * Math.Cos(angle) + halfHeight;
      27:             points.Add(new Point(x, y));
      28:         }
      29:     }
      30:  
      31:     this.Polygon.Points = points;
      32: }

    I due metodi riportati sono in realtà alternativi. Nel caso in cui la percentuale di stellatura sia 0 useremo il primo mentre con valori diversi useremo il secondo. Essi operano su una Shape di tipo Polygon inserita in un Canvas da cui eredita il nostro controllo. All'interno del metodo ArrangeOverride provvederemo ad invocare il metodo di disegno.

       1: public class RegularPolygon : Canvas
       2: {
       3:     // .................
       4:  
       5:     protected override Size ArrangeOverride(Size finalSize)
       6:     {
       7:         DrawShape(finalSize);
       8:         return base.ArrangeOverride(finalSize);
       9:     }
      10:     
      11:     // .................
      12: }

    A questo punto il controllo potrebbe essere considerato finito se non fosse per il fatto che le proprietà esposte (VertexCount e StarPercentage) sono dei meri contenitori e non sortiscono alcun effetto se ad esse applichiamo uno Style o il DataBinding. Questo tipo di comportamenti infatti hanno la caratteristica di essere applicabili esclusivamente a delle DependencyProperty. La DependencyProperty è una proprietà, registrata all'interno del sistema delle DP che consente di ottenere notifica del cambiamento del suo valore. Essa supporta pienamente il DataBinding e può anche essere oggetto dell'applicazione di uno style oppure di una Animazione.

    Creare una DependencyProperty è tutto sommato semplice. Innanzitutto occorre creare un membro statico la cui funzione è di tenere una sorta di puntatore alla DependencyProperty. Al suo interno definiamo il nome della proprieta e il suo tipo nonchè il delegate che sarà incaricato di gestire la notifica del cambio di valore. Il secondo passo è di creare una proprietà che serva ad esporre il valore della DP verso l'esterno. Ecco un esempio:

       1: public static DependencyProperty VertexCountProperty =
       2:     DependencyProperty.Register("VertexCount", typeof(Int32), typeof(RegularPolygon), new PropertyChangedCallback(Property_Changed));
       3:  
       4: //..........
       5:  
       6: public Int32 VertexCount
       7: {
       8:     get { return (Int32)this.GetValue(RegularPolygon.VertexCountProperty); }
       9:     set { this.SetValue(RegularPolygon.VertexCountProperty, value); }
      10: }

    Una proprietà dichiarata in questo modo comincerà a funzionare come si addice ad una vera DependencyProperty. Nel metodo Property_Changed infatti riceveremmo le notifiche del cambio di numero vertici e provvederemo a ridisegnare il poligono. Inoltre visto che siamo raffinati dovremmo provvedere ad esporre una serie di proprietà aggiuntive che ci permettano di applicare delle caratteristiche dinamiche. Ad esempio Stroke, Fill, StrokeLineJoin ecosì via. Non potendo ereditare da Shape siamo costretti a usare il contenimento. Ecco il metodo:

       1: private static void Property_Changed(object sender, DependencyPropertyChangedEventArgs args)
       2: {
       3:     Polygon polygon = ((RegularPolygon)sender).Polygon;
       4:     
       5:     if (args.Property == RegularPolygon.StrokeProperty)
       6:              polygon.SetValue(Polygon.StrokeProperty, args.NewValue);
       7:     else if (args.Property == RegularPolygon.StrokeThicknessProperty)
       8:      polygon.SetValue(Polygon.StrokeThicknessProperty, args.NewValue);
       9:     else if (args.Property == RegularPolygon.StrokeLineJoinProperty)
      10:      polygon.SetValue(Polygon.StrokeLineJoinProperty, args.NewValue);
      11:     else if (args.Property == RegularPolygon.StrokeDashArrayProperty)
      12:      polygon.SetValue(Polygon.StrokeDashArrayProperty, args.NewValue);
      13:     else if (args.Property == RegularPolygon.FillProperty)
      14:      polygon.SetValue(Polygon.FillProperty, args.NewValue);
      15:     else if (args.Property == RegularPolygon.VertexCountProperty)
      16:      ((RegularPolygon)sender).ArrangeOverride(new Size(((RegularPolygon)sender).ActualWidth, ((RegularPolygon)sender).ActualHeight));
      17:     else if (args.Property == RegularPolygon.StarPercentageProperty)
      18:      ((RegularPolygon)sender).ArrangeOverride(new Size(((RegularPolygon)sender).ActualWidth, ((RegularPolygon)sender).ActualHeight));
      19: }

    A questo punto possiamo introdurre il nuovo controllo nei nostri lavori molto semplicemente ma per questo vi lascio allo studio del progetto allegato. Nella figura qui riportata si vede il controllo completo. Gli slider consentono di speficare rotadione, stellatura e il numero di vertici.

    Download: http://blog.boschin.it/download/Elite.Silverlight..RegularPolygon.zip

    Technorati Tag: ,