di .NET e di altre amenità

Usability: Ridotta leggibilità per i menù giustificati a destra

2008-04-29T01:16:13+01:00

Da un recente studio per che i menù giustificati a destra riducano la leggibilità per gli utenti che leggono da sinistra verso destra. Questo avviene perchè l'utente cerca di scandire la lista muovendo l'occhio rapidamente sulla parte iniziale del testo sulla sinistra. Trovando gli elementi allineati a sinistra la scansione sarà più rapida e di conseguenza il sito apparità più leggibile.

Interessanti anche le regole che vengono proposte:

Left-justify the menu, so that the user's eyes can move in a straight line and don't have to re-acquire the beginning of each new line.
Start each menu item with the one or two most information-carrying words.
Avoid using the same few words to start list items, because doing so makes them harder to scan.

Chi fosse interessato potrà trovare una analisi del problema in questo articolo apparso nell'alertbox di oggi di Jakob-Nielsen.

Technorati Tag: Web,Usability

Articolo: Migliorare il databinding di Silverlight 2.0 con un controllo CollectionViewSource

2008-04-26T18:58:52+01:00

Ho finalmente pubblicato la mia ultima fatica. Si tratta di un articolo, accompagnato da un po' di codice rilasciato su codeplex, che spiega come fare a creare un controllo CollectionViewSource per Silverlight 2.0. Il controllo CollectionViewSource, 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: http://www.codeplex.com/silverlight

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:

http://blog.boschin.it/articles/Improving-Silverlight-2.0-databinding-with-a-CollectionViewSource-control.aspx

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

Technorati Tag: Silverlight,Controls,CollectionViewSource

Improving Silverlight 2.0 databinding with a CollectionViewSource control

2008-04-26T07:56:04+01:00

People that have worked with Windows Presentation Foundation probably know the usefulness of the CollectionViewSource control. This control is simple to be configured and enables to easily filter, sort and group data items before binding them to an ItemsControl, without any need to change the underlying datasource. Many times we have to operate filtering on a datasource before displaying it in a listbox, or we need to sort the same data answering to a user request. Both this behaviors may be handled using the CollectionViewSource; filtering will raise an event asking to choice the items to show or to hide and we have simply to select the elements with the correct criteria. On the other side, the control can sort elements on one or more properties ascending or descending. If the target control support grouping we can also specify a grouping criteria and the control will operate seamless for us. But probably the better thing is that we can change sorting, filtering or grouping and the target control will be updated according to the new criteria.

Unfortunately Silverlight 2.0 does not have a CollectionViewSource but while exploring the capabilities of databinding I found that it is possible to build a control similar to the CollectionViewSource that support both filtering and sorting. There aren't controls supporting grouping in Silverlight 2.0 so it is unuseful to implement it in this control. Before getting to know how the control works it is better to understand how databinding works in Silverlight 2.0 so let me begin with a brief introduction to this argument.

Databinding in Silverlight 2.0

Databinding is a feature introduced many years ago so there is no need to explain what it is. Windows Presentation Foundation has taken this ancient tecnique to an high level of simplicity and Silverlight 2.0 implements a databinding capability very close to WPF with some little limitations.

The two main components of databinding are DataContext and the Binding markup extension. DataContext is a property, exposed by all the classes inheriting from FrameworkElement so it is available on all the controls, shapes, panels and other user interface elements. Through DataContext property we may specify a class instance that will be the source of databinding for the target element and for all his children. The DataContext will propagate to children elements until the end of the hierarchy or until another DataContext will be encountered. All the elements of the hierarchy may be binded with a property of the object that is associated to the DataContext. To bind the properties each other we have to use the Binding markup extension. In the simplest form the markup extension require that we specify the property of the datasource to bind to.

Another way to bind to a user interface control is using an ItemsControl. Connecting a datasource to its ItemsSource property will cause the collection to be displayed in the control repeating a DataTemplate for every item in the collection. The DataTemplate will be binded to each element throught the Binding markup extension itself. Here is an example showing both the tecniques applied.

<UserControl x:Class="Elite.Silverlight.Samples.Databinding"
    xmlns="http://schemas.microsoft.com/client/2007" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:d="clr-namespace:Elite.Silverlight.Samples"
    Width="400" Height="300">
    <UserControl.Resources>
        <d:DataSource x:Key="data" />
    </UserControl.Resources>
    <Grid x:Name="LayoutRoot" DataContext="{StaticResource data}" Background="White">
        <ItemsControl ItemsSource="{Binding Strings}">
            <ItemsPanelTemplate>
                <DataTemplate>
                    <TextBlock Text="{Binding}" />
                </DataTemplate>
            </ItemsPanelTemplate>
        </ItemsControl>
    </Grid>
</UserControl>

In this sample an instance of a class named DataSource has been referenced in the user control resources. This class has a property named "Strings" returning an IEnumerable<string>. The yielded strings is the data to be displayed in the ItemsControl. The DataContext property of the Grid is assigned to a reference of the DataSource class and the ItemsSource property is binded to the Strings property throught the Binding markup extension. The data collected from the datasource become the DataContext for the each item with the template specified in ItemsTemplatePanel so the Binding markup extension assign each string to the Text property of the TextBlock.

For the purpose of this article we don't need to deepen our knowledge of this aspect. Instead, we need to concentrate on another aspect. Databinding enable developers to bind properties of a control to properties of a data item and have them updated when the data item change. In the same way it is possible to bind a collection to a specific property and have the control updated when we add or remove items to the collection. This two behaviors came from two interfaces: INotifyPropertyChanged and INotifyCollectionChanged. Objects implementing one of these interfaces have to notify internal changes through an event. PropertyChanged notify changes to single properties and is useful for objects binded directly to control properties, instead CollectionChanged notify about adding or removal of items from a collection and it has to be used for controls binded to collections like an ItemsControl.

Silverlight 2.0 and WPF come with a generic collection ObservableCollection<T> that implements INotifyCollectionChanged interface. This class helps us to bind collection of objects to an ItemsControl. We may create a class, expose a property of this type and bind it to an ItemsControl. Then we can add or remove elements to the collection and them will be added to or removed from the ItemsControl seamless.

Thinking about our CollectionViewSource

It is now the time to think about how to implement our CollectionViewSource. We need to create the control as a filter that will be interposed between the datasource and the consuming control and it will operate notifying changes responding to user choices. So probably our control has to appear as a collection for the control that will displays the data items. To notify changes we need to implement the INotifyCollectionChanged interface so we get the consuming control to update its appearance responding to changes to the filtering or sorting criteria. Watching to the control from the side of the datasource it has to expose a Source property that we'll connect to the underlying datasource we need to transform.

So let start creating the control. It will be called CollectionViewSource as expected and extends the Control class. We cannot create a simple class that does not implement any other base class because we need to get access to the DependencyProperty system. The Control class is tipically dedicated to elements that have a visual aspect, so probably it would be better we extend a class like DependencyObject for our control to work. Unfortunately we have to use the Control class because all the base classes from FrameworkElement to DependencyObject does not have a public constructor so we are unable to inherit from them. The Control class is not the best choice, but it is the only choice available.

public class CollectionViewSource : Control, IEnumerable, INotifyCollectionChanged
{
    // implement the control... 
}

The class has also to implement two interfaces: IEnumerable and INotifyCollectionChanged. The first interface is required to grant our control the capability to be consumed from an ItemsControl. Using the IEnumerable interface we get two goals. We can assign the CollectionViewSource directly to the ItemsSource property and we can use LINQ to Objects to yield resulting items to the consuming control. Taking advantage of LINQ to Objects will simplify our control structure and get our code to a better level of readability.

#region IEnumerable Members
  
/// <summary>
/// Returns an enumerator that iterates through a collection.
/// </summary>
/// <returns>
/// An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the collection.
/// </returns>
public IEnumerator GetEnumerator()
{
    var result = this.Source
        .Cast<object>();
  
    return result.GetEnumerator();
}
  
#endregion

For the filtering to work we have to expose an event that we'll call every time we have to filter the collection, one time for every item in the collection asking the user to choice the items to show. The simplest thing to do is to create a delegate, that we use as a Where clause lambda expression in the Linq query yielding items. So the delegate will be called by the query every time it needs to examine an element to decide if it has to be yielded or skipped.

/// <summary>
/// Occurs when [filter].
/// </summary>
public event EventHandler<FilterCollectionEventArgs> Filter;
  
/// <summary>
/// Returns an enumerator that iterates through a collection.
/// </summary>
/// <returns>
/// An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the collection.
/// </returns>
public IEnumerator GetEnumerator()
{
    var result = this.Source
        .Cast<object>()
        .Where(FilterItem);
  
    return result.GetEnumerator();
}
  
/// <summary>
/// Filters the item.
/// </summary>
/// <param name="o">The o.</param>
/// <returns></returns>
private bool FilterItem(object o)
{
    FilterCollectionEventArgs args = new FilterCollectionEventArgs(o);
    OnFilter(args);
    return args.Accept;
}
  
/// <summary>
/// Raises the <see cref="E:Filter"/> event.
/// </summary>
/// <param name="e">The <see cref="Elite.Silverlight.FilterCollectionEventArgs"/> instance containing the event data.</param>
protected virtual void OnFilter(FilterCollectionEventArgs e)
{
    EventHandler<FilterCollectionEventArgs> handler = Filter;
  
    if (handler != null)
        handler(this, e);
}

To configure the sorting behavior we have to expose a property that collect the sorting criteria in a way similar to the CollectionViewSource contained in the Windows Presentation Foundation. This require to create a SortDescriptionCollection class that will collect the SortDescription instances. Every SortDescription will require a PropertyName and a Direction property to tell the control wich property use for sorting and the direction of the sorting. All the names I've proposed come directly from the WPF control. Using this namig will grant our CollectionViewSource the maximum compatibility with the WPF control so we may use code snippet created for WPF in Silverlight 2.0.

We use the same LINQ to Objects expression adding OrderBy and ThenBy calls to the query if the sorting is enabled. The sorting will be called immediately after the Where clause.

/// <summary>
/// Returns an enumerator that iterates through a collection.
/// </summary>
/// <returns>
/// An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the collection.
/// </returns>
public IEnumerator GetEnumerator()
{
    var result = this.Source
        .Cast<object>()
        .Where(FilterItem);
  
    foreach (SortDescription sd in this.SortDescriptions)
    {
        if (sd.Direction == ListSortDirection.Ascending)
            result = AppendOrderBy(result, sd.PropertyName);
        else
            result = AppendOrderByDescending(result, sd.PropertyName);
    }
  
    return result.GetEnumerator();
}
  
/// <summary>
/// Appends the order by.
/// </summary>
/// <param name="result">The result.</param>
/// <param name="propertyName">Name of the property.</param>
/// <returns></returns>
private IEnumerable<object> AppendOrderBy(IEnumerable<object> result, string propertyName)
{
    if (result is IOrderedEnumerable<object>)
        return ((IOrderedEnumerable<object>)result).ThenBy(o => GetPropertyValue(o, propertyName));
  
    return result.OrderBy(o => GetPropertyValue(o, propertyName));
}
  
/// <summary>
/// Appends the order by descending.
/// </summary>
/// <param name="result">The result.</param>
/// <param name="propertyName">Name of the property.</param>
/// <returns></returns>
private IEnumerable<object> AppendOrderByDescending(IEnumerable<object> result, string propertyName)
{
    if (result is IOrderedEnumerable<object>)
        return ((IOrderedEnumerable<object>)result).ThenByDescending(o => GetPropertyValue(o, propertyName));
  
    return result.OrderByDescending(o => GetPropertyValue(o, propertyName));
}

With the INotifyCollectionChanged interface we'll notify the control to update his aspect when changes occur. The only thing we have to take care is the way to notify events. The NotifyCollectionChangedEventArgs class we have to use to raise the CollectionChanged event require us to specify the kind of event we are raising. The constructor of this class need to specify a NotifyCollectionChangedAction enumeration parameter that define if we are updating the datasource for Add, Remove, Replace, Move or Reset. To get the ItemsControl updating we need to specify the NotifyCollectionChangedAction.Reset value because every other value does not have an effect on the ItemsControl. This behavior become from the implementation of the ItemsSource property. Inspecting this property with Lutz Roeder Reflector it will show us that it is wrapped with an internal private EnumerableCollectionView that will mask every other type of event. The drawback of this choice is that the target control will be updated entirely instead of handling only the added or removed items. I hope that a future implementation of this control will change this thing, but now we have to accept this behavior to get the CollectionViewSource working.

We have to handle two type of events that raise the CollectionChanged event. The first one is when the underliyng collection raise the same event. This is because if the datasource change we have to reflect this change to the user interface itself forwarding this event. So when the Source property will be assigned we have to hook up its CollectionChanged event (if the source itself implements the INotifyCollectionChanged). For this purpose we create the source property as a DependencyProperty to take advantage of the PropertyChangedCallback that will notify when the Source property change its value. When the value change we have to remove event from a previous instance before to hook the new instance to avoid memory leaks and unexpected results.

public static readonly DependencyProperty SourceProperty =
    DependencyProperty.Register("Source", typeof(IEnumerable), typeof(CollectionViewSource), new PropertyChangedCallback(SourceProperty_Changed));
  
/// <summary>
/// Gets or sets the source.
/// </summary>
/// <value>The source.</value>
public IEnumerable Source
{
    get { return (IEnumerable)this.GetValue(SourceProperty); }
    set { this.SetValue(SourceProperty, value); }
}
  
/// <summary>
/// Sources the property_ changed.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="System.Windows.DependencyPropertyChangedEventArgs"/> instance containing the event data.</param>
private static void SourceProperty_Changed(DependencyObject sender, DependencyPropertyChangedEventArgs e)
{
    CollectionViewSource cvs = sender as CollectionViewSource;
  
    if (cvs != null)
    {
        if (e.OldValue != null && e.OldValue is INotifyCollectionChanged)
            ((INotifyCollectionChanged)e.OldValue).CollectionChanged -= new NotifyCollectionChangedEventHandler(cvs.CollectionViewSource_CollectionChanged);
  
        if (e.NewValue != null && e.NewValue is INotifyCollectionChanged)
            ((INotifyCollectionChanged)e.NewValue).CollectionChanged += new NotifyCollectionChangedEventHandler(cvs.CollectionViewSource_CollectionChanged);
    }
}
  
/// <summary>
/// Handles the CollectionChanged event of the CollectionViewSource control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.Collections.Specialized.NotifyCollectionChangedEventArgs"/> instance containing the event data.</param>
private void CollectionViewSource_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
    if (sender != null)
        this.OnCollectionChanged(e);
}
  
/// <summary>
/// Raises the <see cref="E:CollectionChanged"/> event.
/// </summary>
/// <param name="e">The <see cref="System.Collections.Specialized.NotifyCollectionChangedEventArgs"/> instance containing the event data.</param>
protected virtual void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
{
    NotifyCollectionChangedEventHandler handler = CollectionChanged;
  
    if (handler != null)
        handler(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
}

Last but not least we have to expose a method to enable users to force the CollectionViewSource to refresh the criteria and notifying the changes if needed. This is the second type of event we have to handle to notify the collection change. If the user call this method we will assume that something has been changed in the criteria and we raise the CollectionChanged event.

/// <summary>
/// Refreshes this instance.
/// </summary>
public void Refresh()
{
    this.OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
}

Using the CollectionViewSource control

Now that the control has been completed we have to build a sample project that use the CollectionViewSource. For this purpose I have created an application that read the rss feed of my weblog (http://blog.boschin.it) and display it in an ItemsControl. The interface have a TextBox that we use to filter the post by title and two radio buttons that decide if sort the items ascending or descending by the publish date. The application is very simple but its purpose is only to dimostrate how to use the CollectionViewSource control and how simple is to use and customize its behavior. Here is a brief markup defining the application interface:

<UserControl x:Class="Silverlight.Page"
    xmlns="http://schemas.microsoft.com/client/2007" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:s="clr-namespace:Silverlight" Loaded="UserControl_Loaded"
    xmlns:e="clr-namespace:Elite.Silverlight;assembly=Elite.Silverlight"
    xmlns:ed="clr-namespace:Elite.Silverlight.Data;assembly=Elite.Silverlight"
    Width="400" Height="400">
    <UserControl.Resources>
        <s:DataSource x:Name="dataSource" />
        <ed:CollectionViewSource x:Name="rssView" Source="{Binding Items, Source={StaticResource dataSource}}" Filter="rssView_Filter">
            <CollectionViewSource.SortDescriptions>
                <ed:SortDescription PropertyName="PublishDate" Direction="Ascending" />
            </CollectionViewSource.SortDescriptions>
        </ed:CollectionViewSource>
        <e:StringToUriConverter x:Name="stringToUri" />
        <e:FormatDateTimeConverter x:Name="dateToString" />
    </UserControl.Resources>
    <Grid x:Name="LayoutRoot" Background="#ffffffff">
        <Grid.RowDefinitions>
            <RowDefinition Height="*" />
            <RowDefinition Height="80" />
        </Grid.RowDefinitions>
        <Grid.Resources>
            <DataTemplate x:Name="rssTemplate">
                <Border Background="#ffeeeeee" Margin="2,2,2,0" Padding="5" BorderBrush="#00000000" BorderThickness="1" CornerRadius="3,3">
                    <Grid>
                        <Grid.ColumnDefinitions>
                            <ColumnDefinition Width="50*"/>
                            <ColumnDefinition Width="50*"/>
                        </Grid.ColumnDefinitions>
                        <Grid.RowDefinitions>
                            <RowDefinition Height="60*" />
                            <RowDefinition Height="40*" />
                        </Grid.RowDefinitions>
                        <HyperlinkButton x:Name="itemLabel" Grid.Column="0" Grid.Row="0" Grid.ColumnSpan="2" Margin="3,3,3,3" 
                                         Content="{Binding Title.Text}" NavigateUri="{Binding Id, Converter={StaticResource stringToUri}}" 
                                         TargetName="_blank" FontSize="14" FontFamily="Verdana" Foreground="#ffff9900" />
                        <TextBlock Grid.Column="0" Grid.Row="1" Margin="3,3,3,3" FontSize="14" FontFamily="Verdana" 
                                   Foreground="#ff666666" Text="{Binding PublishDate, Converter={StaticResource dateToString}, ConverterParameter=dd.MM.yyyy - hh:mm}" />
                        <TextBlock Grid.Column="1" Grid.Row="1" Margin="3,3,3,3" FontSize="14" FontFamily="Verdana"
                                   Foreground="#ff666666" Text="{Binding Copyright}" />
                    </Grid>
                </Border>
            </DataTemplate>
        </Grid.Resources>
        <Border Grid.Column="0" Grid.Row="0" Margin="2" BorderBrush="#ffff9900" BorderThickness="1" CornerRadius="3,3">
            <ScrollViewer DataContext="{StaticResource dataSource}" VerticalScrollBarVisibility="Auto" HorizontalScrollBarVisibility="Disabled">
                <ItemsControl ItemsSource="{Binding Source={StaticResource rssView}}" ItemTemplate="{StaticResource rssTemplate}">
                </ItemsControl>
            </ScrollViewer>
        </Border>
        <Grid Grid.Column="0" Grid.Row="1" Background="#55ff9900" Margin="2">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="*"/>
                <ColumnDefinition Width="*"/>
            </Grid.ColumnDefinitions>
            <Grid.RowDefinitions>
                <RowDefinition Height="50*" />
                <RowDefinition Height="50*" />
            </Grid.RowDefinitions>
            <RadioButton x:Name="sortDescending" TextAlignment="Right" HorizontalAlignment="Left" Margin="10" Grid.Column="1" Grid.Row="1" Grid.ColumnSpan="1" Content="Descending" GroupName="sort" Checked="sort_Checked" IsChecked="true" />
            <RadioButton x:Name="sortAscending" TextAlignment="Left" HorizontalAlignment="Right" Margin="10" Grid.Column="0" Grid.Row="1" Grid.ColumnSpan="1" Content="Ascending" GroupName="sort" Checked="sort_Checked" />
            <WatermarkedTextBox x:Name="txtKey" Padding="3" Grid.Column="0" Grid.Row="0" Margin="5" FontSize="14" Grid.ColumnSpan="2" TextChanged="txtKey_TextChanged" Watermark="Insert Keywork..." />
        </Grid>
    </Grid>
</UserControl>

In this code snippet it is visible how to bind correctly the datasource to the CollectionViewSource and the CollectionViewSource itselft to the consuming ItemsControl. When we have established this connection we hook up the filtering event where we use a Contains() to check that the element contains the text written in the textbox. Every time we press a key the TextChanged event simply call the Refresh() method of the CollectionViewSource causing the filtering to happen again with the new text entered. This is a very intensive use of the CollectionViewSource but with a few collection items (up to one or two hundred) there will be no side effects. In a production application this scenario probably will be handled in a different way, but I'm sure there is many other times you may take advantage of my control. The sorting happen in a similar way. When a radio button has been hit we swap the direction of the configured sorting and then recall the Refresh() method to rebind the interface. Try changing the SortDescription properties to sort by another property.

public partial class Page : UserControl
{
    public Page()
    {
        InitializeComponent();
    }
  
    private void UserControl_Loaded(object sender, RoutedEventArgs e)
    {
        this.dataSource = this.Resources["dataSource"] as DataSource;
        this.dataSource.Load();
    }
  
    private void sort_Checked(object sender, RoutedEventArgs e)
    {
        CollectionViewSource rssView = this.Resources["rssView"] as CollectionViewSource;
  
        if (rssView != null)
        {
            SortDescription sort = rssView.SortDescriptions[0];
            sort.Direction = (sender == sortAscending ? ListSortDirection.Ascending : ListSortDirection.Descending);
            rssView.Refresh();
        }
    }
  
    private void txtKey_TextChanged(object sender, TextChangedEventArgs e)
    {
        rssView.Refresh();
    }
  
    private void rssView_Filter(object sender, Elite.Silverlight.FilterCollectionEventArgs e)
    {
        SyndicationItem item = e.Item as SyndicationItem;
  
        if (item != null)
        {
            e.Accept = item.Title.Text.ToLower().Contains(txtKey.Text.ToLower()) || txtKey.Text == txtKey.Watermark || txtKey.Text == string.Empty;
        }
    }
}

Now we may run the application and try to enter some text in the TextBox. We will see that the displayed item will change according to the text entered. Also checking and unchecking the sort direction radio button will change the order of the the items.

Conclusion

The CollectionViewSource control is part of my Elite.Silverlight Library 1.0.3037.0 where I'm collecting all my reusable controls and classes. Please download it from codeplex (http://www.codeplex.com/silverlightlibrary) and use for free in your projects. The project come under the CCPL license and is free for non-commercial purposes. For use in commercial project please contact me on my weblog contact form at (http://blog.boschin.it/contact.aspx).

Rilasciato il Training Kit di .NET 3.5 enhancements

2008-04-23T17:07:48+01:00

E' stato rilasciato un training kit relativo i futuri "enhancements" del Framework 3.5. Si tratta di un pacchetto di hands-on-lab che comprende le seguenti tecnologie:

ADO.NET Data Services

ADO.NET Entity Framework

ASP.NET AJAX History

ASP.NET Dynamic Data

ASP.NET MVC

ASP.NET Silverlight controls

Per maggiori dettagli leggete questo post:

http://lostintangent.com/2008/04/16/net-35-enhancements-training-kit/

Il download pubblico lo trovate qui:

http://www.microsoft.com/downloads/details.aspx?FamilyID=355c80e9-fde0-4812-98b5-8a03f5874e96&displaylang=en

Technorati Tag: ASP.NET,.NET Framework 3.5,Training Kit

Summit 2008: Ancora foto...

2008-04-21T02:38:57+01:00

Ho appena terminato di caricare le ultime 150 foto su Picasa. Le potete vedere allo stesso indirizzo dell'altra volta:

http://picasaweb.google.it/codeblock/Seattle?authkey=23xipySjxqE

Inoltre trovate anche un album pubblico su facebook completamente taggato:

http://www.facebook.com/album.php?aid=20906&id=621769502

Aggiungete pure i vostri commenti.

Technorati Tag: MVP Summit 2008,Foto

Summit 2008: Ecco dove lavorano i dipendenti Microsoft...

2008-04-18T17:34:23+01:00

il servizio navetta	nel parcheggio del Building 9
Uno scorcio del Building 8	Sempre il Building 8
La dentro qualcuno lavora...	Un campo di Soccer
La gente passeggia tra i Building	Il conference center

Tutto ciò è davvero sconfortante se paragonato alle nostre condizioni di lavoro... o almeno alle mie

Summit 2008: Le foto ricordo

2008-04-18T17:20:31+01:00

Ed ecco le foto ricordo di questo summit...

Summit 2008: Aggiornato l'album web

2008-04-17T18:20:13+01:00

Ho aggiunto più di 60 nuove immagini.

http://picasaweb.google.it/codeblock/Seattle?authkey=23xipySjxqE

Technorati Tag: MVP Summit 2008,Microsoft

Summit 2008: We apologize... no WI-FI on the bus

2008-04-17T18:09:07+01:00

non ho letteralmente parole... ecco cosa appariva su un autobus nel campus:

This is a spare bus and not your regular bus.

We apologize for not having Wi-Fi available

Summit 2008: Effetti collaterali

2008-04-17T18:05:13+01:00

Ecco cosa può causare una giornata al campus Microsoft durante il Summit. Qui Nino sta animatamente spiegando le sue impressioni nell'incontro con Oslo...

Technorati Tag: Nino Crudele,Impressions

ASP.NET: Disponibile update MVC Framework su codeplex

2008-04-17T08:12:19+01:00

We've just released the latest source code for ASP.NET MVC...this latest release includes Visual Studio templates and unit tests. You can find this release here

http://www.codeplex.com/aspnet/Release/ProjectReleases.aspx?ReleaseId=12640

Summit 2008: Ragionamenti a colazione

2008-04-17T02:01:51+01:00

Stamattina è iniziata bene. Scendo a colazione e una inserviente al piano mi saluta e mi sorride. Arrivo a colazione e un cameriere mi saluta. Vabbè dico io, è il loro lavoro sarà perfettamente normale... ma la cosa continua. un tizio al tavolo si avvicina e mi stringe la mano per salutarmi, poi si siede e parte una piacevole chiacchierata. Chi lo ha mai visto...

Esco e mi reco allo Starbucks e mentre do uno sguardo interessato alle brioches un tizio dall'altra parte mi fa : "hello, how are you!". Sorriso stampato sulle labbra. Sono le 6:30 di mattina. Dalle nostre parti mi avrebbero sbattuto un cappuccino sul tavolo guardandomi storto.

Poi la cosa continua. Un tizio che si assicura di non avermi sopravanzato alla cassa. L'autista dell'autobus che mi accoglie sorridendo come fosse la più bella giornata dell'anno. Scendo dall'autobus e una cortese signora mi augura buona giornata. Sono estasiato. Dove devo firmare per avere giornate come questa tutti i giorni?

Ora sono seduto in attesa che Pablo Castro inizi una sessione su ........... ... (sorry ma non posso dire cosa). Tutti contenti, ci si sorride a vicenda. Sarà pure una stupidaggine ma vivere in questo modo è sicuramente più leggere e semplice.

Mi sa che da noi c'è molto da imparare.