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


    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:


    Poco fa ho quello che ritengo un problema riscontrato in Silverlight 2.0. Quello che avviene è che la classe base della pagine (UserControl) viene dichiarata anche nella parte autogenerata della partial class. Questo fa si che sia impossibile ereditare una pagina da una propria classe base e costringe a scrivere molto codice duplicato.

    Speriamo che la venga accolta...

    Technorati Tag: ,

    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.


    Pare che l'articolo che qualche giorno fa ho scritto in inglese a proposito di CollectionViewSource sia stato visto da un buon numero di persone, probabilmente grazie anche all'apparizione nel blog inglese. Perciò ho deciso di scrivere un secondo articolo, sempre in inglese, e nel contempo ho anche arricchito ulteriormente la Silverlight Library (giunta alla versione 1.0.3043.0) pubblicata su codeplex.

    Questa volta si parla di Custom Layout control cioè della possibilità di creare dei controlli di layout che implementino una logica di distribuzione che supera quella di Canvas, Grid e StackPanel. Non tutti sanno infatti che estendendo la classe Panel, e facendo l'override di un paio di metodi è possibile creare un controllo con una logica completamente personalizzata.

    Ecco perchè ho realizzato un RadialPanel. Immaginate di voler distribuite una serie di UIElement, figli del proprio Panel sulla base di un Angolo rispetto all'asse centrale e di una Distanza dal centro. Creare un Layout custom implica anche l'uso di Attached Properties. il RadialPanel infatti definisce Angle e Distance come Attached Property. Spiegare come funzionano esula dallo scopo dell'articolo. Magari ci sarà materia prima per un prossimo articolo.

    Per ora godetevi questo articolo che ho postato qui: http://blog.boschin.it/articles/silverlight-radialpanel.aspx

    Il progetto Silverlight Library si trova qui: http://www.codeplex.com/silverlight


    Silverlight 2.0 has introduced some new layout controls that match some controls from Windows Presentation Foundation. Grid, and StackPanel can handle the most of cases but there are many other cases where they are not useful and we have to return to the Canvas control and handle the resize event to get our custom layout to work.

    Many people do not know that in Silverlight 2.0 it is possible to create a custom layout control and use it in XAML markup exactly like a usual layout control. Implementing a custom layout control is easy and require only that we are able to write the layout logic in the 2-pass layout system of Silverlight.

    When the Silverlight runtime encounter a Layout control, it start a 2-pass algorithm to define measure and arrangement of the child controls. The first pass work to define the size of each element. During this passage the runtime calls the Measure method and collect the size requested by each control. When the first pass is completed and all the nodes of the XAML document has been visited and measured the runtime start to call the Arrange method where it request each control to do its own layout hierarchically. Every control has to perform layout of his children calling the Arrange method and define the position of every element.

    In this sample I will show how to create a custom layout arranging the children in Radial positions. This control will be called RadialPanel and we will have to implement at least one of the two layout passages of the runtime to have it to work.

    For a RadialPanel we have also to define two Attached Properties. This properties will contains the Angle and Distance from center for each children element. During the arrangement of control we will use this properties to define the position of the elements calculating it respect the center of the panel using a simple formula. So let's start our RadialPanel control creating the class

       1: public class RadialPanel : Panel
       2: {
       3: }

    To create a layout control we have to inherits from the Panel class that is the base class for Canvas, Grid and StackPanel. This class handle the biggest part of the layout system and define two methods that we may override to implements our custom layout rule. Now that we have created the layout control we have to define the dependency properties:

       1: public static readonly DependencyProperty DistanceProperty = 
       2:     DependencyProperty.RegisterAttached("Distance", typeof(double), typeof(RadialPanel), null);
       3: public static readonly DependencyProperty AngleProperty = 
       4:     DependencyProperty.RegisterAttached("Angle", typeof(double), typeof(RadialPanel), null);

    These declarations create two Dependency Properties that we register as Attached Properties using the RegisterAttached static method of the DependencyProperty class. This method require us to specify the property name (as we will write in XAML markup), the property type, the type of containing class and if needed a PropertyChangedCallback delegate that the runtime will call when the property changes its value. We have also to create four methods - two Set methods and two Get methods - that will Set and Get the value to and from the UIElement contained in the Panel. This is a simple operation:

       1: /// <summary>
       2: /// Sets the distance.
       3: /// </summary>
       4: /// <param name="element">The element.</param>
       5: /// <param name="distance">The distance.</param>
       6: public static void SetDistance(UIElement element, double distance)
       7: {
       8:     element.SetValue(DistanceProperty, distance);
       9: }
      10:  
      11: /// <summary>
      12: /// Gets the distance.
      13: /// </summary>
      14: /// <param name="element">The element.</param>
      15: /// <returns></returns>
      16: public static double GetDistance(UIElement element)
      17: {
      18:     return (double)element.GetValue(DistanceProperty);
      19: }
      20:  
      21:  
      22: /// <summary>
      23: /// Sets the angle.
      24: /// </summary>
      25: /// <param name="element">The element.</param>
      26: /// <param name="distance">The distance.</param>
      27: public static void SetAngle(UIElement element, double distance)
      28: {
      29:     element.SetValue(AngleProperty, distance);
      30: }
      31:  
      32: /// <summary>
      33: /// Gets the angle.
      34: /// </summary>
      35: /// <param name="element">The element.</param>
      36: /// <returns></returns>
      37: public static double GetAngle(UIElement element)
      38: {
      39:     return (double)element.GetValue(AngleProperty);
      40: }

    Now it is time to implement our custom layout logic. The Panel class expose two methods to override to customize the layout algorithm. These methods are MeasureOverride, called during the first pass and ArrangeOverride called during the second pass. For our RadialPanel to work whe need only to override the ArrangeOverride method because the default implementation of MeasureOverride is perfect for us. Here is the implementation of this method:

       1: /// <summary>
       2: /// When implemented in a derived class, provides the behavior for the "Arrange" pass of Silverlight layout.
       3: /// </summary>
       4: /// <param name="finalSize">The final area within the parent that this element should use to arrange itself and its children.</param>
       5: /// <returns>The actual size used.</returns>
       6: protected override Size ArrangeOverride(Size finalSize)
       7: {
       8:     foreach (UIElement element in this.Children)
       9:     {
      10:         double distance = (double)element.GetValue(DistanceProperty);
      11:         double angle = Math.PI / 180 * (double)element.GetValue(AngleProperty);
      12:  
      13:         double x = distance * Math.Cos(angle);
      14:         double y = distance * Math.Sin(angle);
      15:  
      16:         element.Arrange(new Rect(x, y, finalSize.Width, finalSize.Height));
      17:     }
      18:  
      19:     return base.ArrangeOverride(finalSize);
      20: }

    The code is very simple. We loop all the UIElement in the Children collection and for every element found we acquire its angle and distance property. The angle property need to be converted from degree to radians because we have to use this parameter in the trigonometric functions Math.Sin() and Math.Cos(). The next lines calculate the x and y position referred to the panel center. Finally we call the Arrange method on the UIElement passing the rectangle defining position and size granted to the element itself. As size we simply pass the entire area. It is not an our concern the size the element will have. It may fill the entire panel.

    Now that the RadialPanel has been completed we need to use it in a XAML markup. The first thing to do is to reference the assembly in the XAML file. It has to be done by inserting the namespace declaration in the UserControl root element of the XAML page:

       1: <UserControl
       2:     x:Class="Elite.Silverlight.Samples.RadialPanelSample"
       3:     xmlns="http://schemas.microsoft.com/client/2007" 
       4:     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
       5:     xmlns:ec="clr-namespace:Elite.Silverlight.Controls;assembly=Elite.Silverlight"
       6:     Width="Auto" Height="Auto">
       7:  
       8: </UserControl>

    In the namespace declaration we have to insert also the "assembly=Elite.Silverlight" part of the declaration otherwise the AttachedProperties will not work. It appears there is an issue in the Silverlight runtime affecting this kind of properties. Now we have to insert the RadialPanel in the markup. It is needed we use the declared namespace "ec" and Visual Studio 2008 will show us a powerful intellisense window.

       1: <UserControl 
       2:     x:Class="Elite.Silverlight.Samples.RadialPanelSample"
       3:     xmlns="http://schemas.microsoft.com/client/2007" 
       4:     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
       5:     xmlns:ec="clr-namespace:Elite.Silverlight.Controls;assembly=Elite.Silverlight"
       6:     Width="Auto" Height="Auto">
       7:  
       8:     <ec:RadialPanel>
       9:         
      10:     </ec:RadialPanel>
      11:     
      12: </UserControl>

    Finally we may insert some TextBloks specifing the Angle and distance properties. We have to specify the namespace too using the Attached Properties to have is working.

       1: <UserControl x:Class="Elite.Silverlight.Samples.RadialPanelSample"
       2:     xmlns="http://schemas.microsoft.com/client/2007" 
       3:     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
       4:     xmlns:ec="clr-namespace:Elite.Silverlight.Controls;assembly=Elite.Silverlight"
       5:     Width="Auto" Height="Auto">
       6:     <ec:RadialPanel>
       7:         <TextBlock Text="0" ec:RadialPanel.Distance="100" ec:RadialPanel.Angle="0" Width="50" Height="50" />
       8:         <TextBlock Text="45" ec:RadialPanel.Distance="100" ec:RadialPanel.Angle="45" Width="50" Height="50" />
       9:         <TextBlock Text="90" ec:RadialPanel.Distance="100" ec:RadialPanel.Angle="90" Width="50" Height="50" />
      10:         <TextBlock Text="135" ec:RadialPanel.Distance="100" ec:RadialPanel.Angle="135" Width="50" Height="50" />
      11:         <TextBlock Text="180" ec:RadialPanel.Distance="100" ec:RadialPanel.Angle="180" Width="50" Height="50" />
      12:         <TextBlock Text="225" ec:RadialPanel.Distance="100" ec:RadialPanel.Angle="225" Width="50" Height="50" />
      13:         <TextBlock Text="270" ec:RadialPanel.Distance="100" ec:RadialPanel.Angle="270" Width="50" Height="50" />
      14:         <TextBlock Text="315" ec:RadialPanel.Distance="100" ec:RadialPanel.Angle="315" Width="50" Height="50" />
      15:     </ec:RadialPanel>    
      16: </UserControl>

    The example is now complete and it will show eight Textblock arranged in a circle around the center of the layout panel. Each Textblock Text property contains the angle we have specified to show how the panel works.

    I think that custom layout will be very powerful. Thanks to this kind of extensibility we can easily fill the gap between Silverlight 2.0 and WPF layout system. Probably is not so hard to implement a DockPanel and a WrapPanel using this tecnique.

    Conclusion

    The code I shown in this article has been added to the Elite.Silverlight library I've uploaded to codeplex at this address. I think I will add all the working samples to this library because I think that it is useful to have a library exposing this useful controls and code snippets.

    Link: http://www.codeplex.com/silverlightlibrary (release 1.1.3043.0)


    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.