DotMim

Bonjour à tous,

Les Techdays 2012 c’est fini pour cette année.

Ce fut un excellent cru, je n’ai pas encore les chiffres mais je pense qu’on va encore faire péter un score.

De ce que j’ai vu, les sessions étaient exceptionnellement bien pleines les 2 premiers jours, tout du moins toutes celles auxquelles j’ai participées / animées.

Bon le 3ème jour, la fatigue se fait sentir et les salles se remplissaient moins vite.

J’ai d’ailleurs eu la chance d’animer la dernière session du dernier jour au dernier créneau en Amphi bleu (soit le plus grand amphi après l’amphi plénière) et nous étions AU BAS MOT …. 20 (WOOOOOT !!) Et encore je compte pas la régie  

Bref bref, je parle je parle, mais sans plus attendre (et en attendant les web casts) voici les Powerpoints et les démos de mes 5 sessions :

De A à Z: Accès aux données avec Entity Framework 4.2 et publication en OData

J’ai eu la chance d’animer cette session avec Stéphanie Hertrich qui proposait une journée complète autour d’une application à concevoir de l’architecture à la livraison finale.

Vous trouverez d’ailleurs sur son blog l’ensemble des slides de tout son parcours (avec les miens donc)

Cette session aborde 2 aspects liés à la couche de données :

• Le stockage et l’accès aux données côté serveur avec l’utilisation d’EF 4.3 Code First
• La publication des données sous forme de service pour les rendre disponibles aux applications clientes grâce à ODATA et WCF Data Services

Et les démos associées : Techdays 2012 EF 4.3 Odata

Publication des données publiques (Open Data), WCF Data Services, OData

Session encore une fois axée sur le partage d’informations, que j’ai co-animée avec Sébastien Brasseur et Philippe Béraud.

Ici on parle plus d’Open Data et je suis intervenu sur la mise en place d’un serveur WCF Data Services.

Ici ce qui a été techniquement sympa c’est que je vous propose dans les démos d’aborder quelques nouveautés apportées par les spécifications OData V3 et déjà implémentées (bon pas toutes, c’est vrai) dans WCF Data Services.

Vous trouverez dans les démos l’utilisation du type géographique ou encore du système d’annotation :

Et les démos associées : Open Data et OData

SQL Azure Data Sync ou comment synchroniser vos données avec le Cloud

La session où vraiment je me suis lâché

Dernière session, dernier jour, les gens qui sont là sont “encore” motivés, alors on va envoyer du bon code bien lourd

Bon j’en ai vu un ou deux dormir au fond ! (mais on leur en voudra pas, ambiance feutrée, amphi bleu tout ça tout ça …)

Et donc sans plus attendre :

Et les démos qui vont avec bien sûr : SQL Azure Sync Data et Sync Framework

Utilisation avancée de la base de donnée locale SQL CE dans Windows Phone 7.5

Bon là faut bien être clair, j’ai sorti “accompagné” mon pote Ben Il a fait une super session sur le sujet où je suis juste intervenu pour répondre à quelques questions et passer une démo de synchronisation de données avec WP7. 

On parle ici de SQL Server CE pour WP7, de Linq to SQL for Mango ou encore de Code First !

Pour les démos, je laisse Benoit les relayer. Quant à moi je vous propose la démo de synchronisation de WP7 avec l’utilisation de la toolkit Sync Framework V4 : WP7 Synchronisation Sync FX 4

Pour la petite note “humour inside” : J’ai préparé cette démo… 30 minutes avant la session, car on pensait qu’on aurait pas assez de choses à dire !! L’erreur !!! j’ai même pas eu le temps de la jouer jusqu’au bout

Les Experts SQL Server

Voici le résumé (tiré du site des techdays) de la session

“Au cours de cette session, vous n’aurez qu’un seul but : coller les experts Microsoft sur SQL Server 2012 ! Nous avons réuni pour vous tous les experts du domaine pour répondre à vos questions, venez nombreux !”

Et oui nous étions tous sur scènes pour répondre à vos questions ! Donc pas de slides ni démos

Et bien on peut dire que vous avez des questions d’un sacré niveau !! Nous avons tous été surpris par la pertinence des questions et la connaissance de chacun d’entre vous. Comme quoi SQL Server devient une plateforme vraiment ancrée (enfin tout du moins chez les personnes ayant assistées à la session )

Sinon j’ai une photo de Philippe Geiger à vous proposer, juste pour vous montrer le beau monde qu’il y avait !

Vous aurez bien entendu reconnu la tête qui dépasse ?

Voilà voilà !

Un bon Techdays 2012 pour ma part, la tête dans le guidon durant 3 jours complets !

Et comme chaque année, on dit qu’on y reviendra pas et chaque année on remet ça ! Alors à l’année prochaine

Il y’a déjà pas mal de développeurs (moi le premier) qui se sont empressés de commencer à développer en WinRT des applications Metro destinés à Windows 8

Pour certains, don’t je fais parti, l’utilisation du pattern MVVM est un plus, une philosophie, une habitude, bref un “must have coding pattern”

Pour faire du MVVM, j’utilise suivant les projets soit PRISM soit MVVM light Toolkit

En WinRT, aucun portage n’a encore était réalisé de ces 2 frameworks.

Je vous propose donc en téléchargement une version de MVVM Light, migrée vers vers WIN RT, utilisable en C#

Vous pouvez le télécharger ici : http://www.dotmim.com/SiteFiles/GalaSoft.MvvmLight.zip

Biensur je vous recommande de surveiller le portage qui sera suremment développé par Laurent Bugnon, auteur et créateur de MVVM Light.

En attendant cette nouvelle version, celle ci pourra toujours vous servir

(Note : Code fournit “AS IS”, sans AUCUNE garantie !!! )

Dans la série des Posts “Comparons WPF, Silverlight et WinRT” :

Une différence de technique pour télécharger un élément (nous prendrons ici une image par exemple)

Dans le cas de WP7, nous utliserons la classe WebClient, et l’appellerons de manière asynchrone (on a pas le choix) et du coté WinRT, on utilisera le nouveau mot clé “async” et “wait”

WP7 :

public void GetImage(Uri url)
{
    var webClient = new WebClient();

    webClient.OpenReadCompleted += WebClientOpenReadCompleted;
    webClient.OpenReadAsync(url);
}

void WebClientOpenReadCompleted(object sender, OpenReadCompletedEventArgs e)
{
    if (e.Error != null)
        return;

    BitmapImage bi = new BitmapImage();
    bi.SetSource(e.Result);

    image1.Source = bi;
}

WinRT :

public async void GetImage(Uri url)
{
    HttpClient client = new HttpClient();
    HttpResponseMessage response = await client.GetAsync(url);
    byte[] img = response.Content.ReadAsByteArray();
    InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream();
 
    DataWriter writer = new DataWriter(stream.GetOutputStreamAt(0));
    writer.WriteBytes(img);
 
    await writer.StoreAsync();
 
    BitmapImage bi = new BitmapImage();
    bi.SetSource(randomAccessStream);

    image1.Source = bi;
}

Autant je trouve sexy l’utilisation des nouvelles directives d’asynchronisme, autant l’utilisation de IMemoryRandomAccessStream et d’un DataWriter, ben… bof hein

Bon Downloading !

Dans la série des Posts “Comparons WPF, Silverlight et WinRT” :

Si vous devez déclarer des namespaces en WinRT, sachez que la syntaxe change (heuresement que Visual Studio aide !)

WPF :

xmlns:conv= »clr-namespace:TimeTrack.Converters »
xmlns:mess= »clr-namespace:Bewise.Phone;assembly=Bewise.Phone »

WinRT :

xmlns:conv= »using:TimeTrack.Converters »
xmlns:mess= »using:Bewise.Phone »

Deux remarques:

1. Remplacement de clr-namespace par using
2. Plus d’obligation d’utiliser le nom de l’assembly si vous référencez un namespace provenant d’une autre assembly

To be continued !

Si vous faites du MVVM, et que vous tentez une migration vers WinRT, attention à l’implémentation de INotifyPropertyChanged

La subtilité vient de l’apparition de cette interface dans un autre namespace, lié à l’UI :

Windows.UI.Xaml.Data.INotifyPropertyChanged

D’ailleurs, on le remarque vite, lors de l’ajout du using :

Si vous migrez du code, et que votre INotifyPropertyChanged est encore celui de System.ComponentModel, et bien aucun de vos contrôles XAML ne s’abonnera à cet évènement de votre ViewModel !

Keep The Fight !

La déclaration en WinRT est différente de WPF / Silverlight.

Elle différe lors de la phase Register sur l’objet static DependencyProperty.

On note qu’en WPF / SL4, le Register prend un Type (typeof(TOTO)) comme argument, alors qu’en WinRT, il prend une chaine de caractères.

Note : Pour moi, ceci est un comportement imputable à la CTP de WinRT, je serai surpris que ce soit encore le cas lors de la RTM. My 2 Cents

WPF:

public int MatchesCount
{     get { return (int)GetValue(MatchesCountProperty); }     set { SetValue(MatchesCountProperty, value); }
}

public static readonly DependencyProperty MatchesCountProperty =     DependencyProperty.Register(

              "MatchesCount", 

               typeof(int), 

               typeof(WidthMatchConverter),                new PropertyMetadata(0));

WinRT:

public int MatchesCount
{
    get { return (int)GetValue(MatchesCountProperty); }
    set { SetValue(MatchesCountProperty, value); }
}

public static readonly DependencyProperty MatchesCountProperty =
    DependencyProperty.Register(
               « MatchesCount »,
               « Int32″,
                « WidthMatchConverter »,
                new PropertyMetadata(0));

Dans la série des Posts “Comparons WPF, Silverlight et WinRT” :

Si vous voulez savoir si vous êtes en mode design, par code :

WPF

var prop = DesignerProperties.IsInDesignModeProperty;
                    _isInDesignMode
                        = (bool)DependencyPropertyDescriptor
                                     .FromProperty(prop, typeof(FrameworkElement))
                                     .Metadata.DefaultValue;

                    // Just to be sure
                    if (!_isInDesignMode.Value
                        && Process.GetCurrentProcess().ProcessName.StartsWith("devenv", StringComparison.Ordinal))
                    {
                        _isInDesignMode = true;
                    }

Silverlight

DesignerProperties.IsInDesignTool;

WinRT

Windows.ApplicationModel.DesignMode.DesignModeEnabled;

Dans la série des Posts “Comparons WPF, Silverlight et WinRT” :

En WPF, comme en silverlight, accéder par réflection à des métadatas d’objets se fait relativement simplement.

Par exemple, vérifier l’existance d’une propriété dans un type, en WPF, comme en Silverlight :

var myType = this.GetType();

if (!string.IsNullOrEmpty(propertyName) && myType.GetProperty(propertyName) == null)
    throw new ArgumentException("Property not found", propertyName);

En WinRT, les choses changent quelque peu. Vous devez passer par la méthode GetTypeInfo() qui vous donnera accés à des méthodes GetDelcared*

Attention GetTypeInfo() est une méthode d’extension de System.Reflection, n’oubliez pas le Using/ Imports adéquat

Le même exemple que précédemment :

var myType = this.GetType();

if (!string.IsNullOrEmpty(propertyName) 
     && myType.GetTypeInfo().GetDeclaredProperty(propertyName) == null)
                 throw new ArgumentException("Property not found", propertyName);

Parfois même, la méthode a été remplacée par une propriété.

L’exemple de récupération d’interfaces.

En WPF / Silverlight:

Type[] interfaces = instanceType.GetInterfaces();

En WinRT:

IEnumerable<Type> interfaces = instanceType.GetTypeInfo().ImplementedInterfaces;

Dans la série des Posts “Comparons WPF, Silverlight et WinRT” :

Si vous voulez accéder au dispacther dans votre code (sans être obligatoirement dans une page xaml)

Définition

Première chose notable, le nom de la classe change:

Dans WPF et Silverlight, la classe est : Dispatcher et elle se situe dans System.Windows.Threading
En WinRT, la classe s’appelle : CoreDispatcher et elle se situe dans Windows.UI.Core

Dans les exemples suivants, vous trouverez la façon d’appeller le Dispatcher et sa méthode d’invocation qui est différente en WinRT

WPF

System.Windows.Threading.Dispatcher.CurrentDispatcher d;

d.BeginInvoke(action);

Silverlight

System.Windows.Threading.Deployment.Current.Dispatcher d;

d.BeginInvoke(action);

WinRT

En WinRT, impossible de passer directement une action, vous êtes contraint de passer par un Invokehandler qui prend en paramètre un objet Context (que je n’utilise pas dans l’exemple suivant):

InvokedHandler handler = (s, ia) => action();

Windows.Current.Dispatcher.InvokeAsync(CoreDispatcherPriority.Normal, handler, null, null);

 

Note : J’ai remarqué que souvent, le Windows.Current est égal à Null…. bug de la CTP ? comportement By Design ? who knows !

Bon je vais exceptionnellement m’écarter de SQL SERVER sur mon blog pour vous parler un peu de WinRT

Pour ceux qui ont loupé cet évènement et les annonces autour du sujet, je vous conseille d’aller faire un tour sur http://www.buildwindows.com

Une fois que vous voyez de quoi on va causer, je vous propose une série de posts qui illustrent mes aventures avec WinRT, et surtout les écueils et autre différences que j’ai trouvé en essayant de migrer une application WP7 vers WinRT

(Et le premier qui me dit que la CLR de WinRT pour C# et VB, c’est la même que la CLR.Net, je l’étripe !… Bon ok elle est fortement inspirée de la CLR.Net, mais CE N’EST PAS LA CLR.Net !!!)

1. WinRT : Dispatcher
2. WinRT : Reflection
3. WinRT : DesignMode
4. WinRT : Dependency Properties
5. WinRT : INotifyPropertyChanged
6. WinRT : Namespaces
7. WinRT : Downlading Images
8. WinRT : MVVM
9. …