[Certification] Cursus de Certification Microsoft sur le Framework 4.5

En tant que développeurs passionnés et investis, nous sommes toujours avides d'apprendre les petites ou grosses spécificités de l'environnement qui accueillera nos futures applications. Environnement qui a pas mal changé ces derniers temps, et qui permet à Microsoft de remanier ces différents cursus de certification. Nous allons faire un tour d'horizon de l'ensemble de ces nouveaux cursus.

Pour un topo plus généraliste sur pourquoi et comment la certification, je vous invite à lire mon post sur le précédent cursus de certification Microsoft ici

La première des choses qui changent au delà du nom des certifications, c'est la dénomination du titre. Je m'explique, plus de MCTS (Microsoft Certified Technology Specialist) mais du MCSD (Microsoft Certified Solutions Developer). Idem pour le MCPD (Microsoft Certified Professional Developer)qui devient MCSM(Microsoft Certified Solutions Master). Rentrons maintenant dans le détails.

MCSD

Windows Store App

Comme vous vous en êtes rendus compte lorsque vous avez ouvert la béta de Visual Studio 2012 (11 à l'époque), il est maintenant possible de créer des applications clientes, natives en HTML5, javascript et CSS3. Bien évidemment, les développeurs préférant ces technologies peuvent également démontrer leur expertise en se certifiant. Donc, il a une différence de cursus en fonction de la techno utilisée pour la création des applications clientes.

Cursus HTML5, javascript, CSS3

1. 70-480 : Programming in HTML5 with JavaScript and CSS3
2. 70-481 : Essentials of Developing Windows Store Apps Using HTML5 and JavaScript
3. 70-482 : Advanced Windows Store App Development Using HTML5 and JavaScript

Cursus C#

1. 70-483 : Programming in C#
2. 70-484 : Essentials of Developing Windows Store Apps Using C#
3. 70-485 : Advanced Windows Store App Development Using C#

Et là vous allez vous, il s'est trompé c'est pas <ol> qu'il faut utiliser mais <ul> !! Et bien non il y a maintenant un ordre spécifique pour avancer dans nos cursus de certifications. Il est vrai qu'avec le cursus précédent, nous pouvions choisir les certif au fil de nos envies, de nos humeurs. Plus maintenant !

Web Applications

Ici qu'un seul cursus !

1. 70-480 : Programming in HTML5 with JavaScript and CSS3
2. 70-486 : Developing ASP.NET 4.5 MVC Web Applications
3. 70-487 : Developing Windows Azure and Web Services

Bon qu'on doivent passer une certif HTML5, javascript, CSS3 pourquoi pas, ça me semblait déjà indispensable auparavant ! A noter que c'est exam est commun avec celui pour la certif cliente HTML5.

Application Lifecycle Management

1. 70-496 : Administering Microsoft Visual Studio Team Foundation Server 2012
2. 70-497 : Software Testing with Visual Studio 2012
3. 70-498 : Delivering Continuous Value with Visual Studio 2012 Application Lifecycle Management

MCSM

La partie MCSM n'étant pas totalement finalisé, je la compléterai ultérieurement

Data Platform

Sharepoint

Communication

Messaging

Certification du framework 3.5 et 4.0

Les certifications des précédents Framework vont être retirées des examens potentiels à partir du 31 Juillet 2013. Restent seulement celle du cursus relative à Windows Phone à savoir MCTS Silverlight 4, Data Access, Windows Phone. Personellement je pense qu'elles sont maintenu pour peu de temps jusqu'à être réintégrées dans le nouveau modèle.

Conclusion

Enfin une dernière information mais non des moindres à savoir que pour que nos certifications de ce nouveau cursus soient considérées comme valides, il faudra au minimum passer une certification de réactivation spécifique à chaque cursus tous les deux à trois ans.

Voilà et on se met boulot !

Vous pouvez retrouver les sources de l'article ici

EDIT : Ajout des liens vers site marchand.

[Surface] Premières impressions

Commandée le jour même de l'annonce de la sortie officielle de Windows 8, 3 jours ont suffit pour recevoir ma Surface. Petite précision, le modèle testé est la version WinRT 32 Go avec un Clavier "Touch Cover". La version sans le clavier portait le délai de livraison à 3 semaines.

Donc avec presque un semaine de pratique, je vous livre mes impressions.

Le Hardware

La Surface

Dès la saisie, on sent la surface présente de part son poids. Equilibrée, elle se laisse prendre en main sans déconvenue. A noter la présence d'une prise USB. Chez certains concurrents ce genre de détails n'est pas pris en compte.

D'autre part et personnellement, je n'ai jamais réussi à utiliser une couverture d'iPad pour faire tenir le devise. Avec la surface, pas de souci, même pour les mecs comme moi y arrivent. Le support se sort et se range facilement.

Côté finition, on est sur un objet épurée, comme le sont presque toute les tablettes. La jointure coque, écran laisse présager une certaine solidité dans le temps mais à voir.

Le Touch Cover

Le Touch Cover était vraiment l'élément technique de la surface qui m'intriguait le plus. Et ma première réaction a été vraiment de me dire qu'ils avaient bien bossé. Mais très vite je suis resté dubitatif qu'en au ressenti sur les touches.

Dès la première utilisation, le fait de ne pas avoir de retour sensitif sur les touches m'a vraiment perturbé. Après plusieurs heures d'utilisation avec l'ensemble de la tablette, on constate un véritable contraste entre la fluidité et la réactivité qui est à mon sens excellente (à noter aussi performante que sur Windows Phone) sur la tablette et l'utilisation de certaines touches du clavier qui nécessite d'appuyer un peu plus franchement.

En écrivant ces lignes, je me rends compte qu'au final, à part en protection d'écran, je n'ai plus utilisé le Touch Cover depuis quelques jours. En revanche, mon entourage lui a très vite adopté le clavier, notamment avec le côté rassurant du Touch Pad pour une utilisation souris.

l'OS

Donc, je ne vais pas faire un listing des nouvelles fonctionnalités de Windows 8, d'autres sites spécialisés ont déjà fait ça et certainement mieux que moi. Pour avoir découvert Windows 8 lors de sa première version béta, la plus grande surprise à résider dans l'efficacité du devise à mettre l'OS.

En revanche, un point qui a mon sens risque de coincer avec le grand public est le faible espace disque. Là vous vous dites, oui mais il a pris une version 32Go, je vous réponds oui mais l'OS annonce 17Go de libre alors qu'aucune application tierce n'est installée...

Enfin, le côté frustrant dès le déballage du produit est la mise à jour de pas moins de 17 applications. Du coup, il faut soit paramétrer avant de lancer les mises à jour ou bien patienter 2 heures.

Conclusion

Cette Surface est un beau produit qui sait bien mettre en avant les nouvelles fonctionnalités de Windows 8 et on en attendait pas moins de Microsoft. Maintenant, espérons que les fabricants de hardware emboitent leur pas pour l'innovation.

[XAML] Bubbling, Tunneling et Konami

Allez aujourd'hui on fait un tout petit topo technique sur une particularité XAML à savoir le bubbling et le tunneling et ensuite on va voir une mise en application ludique et amusante.

Alors on commence par le point théorique.
Lorsque que l'on gère les événements en XAML, on va utiliser 3 types différents d'événements routés

Les événements directs, les événements de type bulle (bubbling) et les événements de type tunnel (tunneling).

Donc pour illustrer rapidement ces trois concepts, on part du postulat que vous avec ceci :

<Grid x:Name="myGrid">
  <StackPanel x:Name="myStackPanel">
    <TextBox x:Name="myTextBox"/>          
  </StackPanel>
</Grid>

Evénements directs

Ici rien de nouveau neuf, on est sur ce qu'il a de plus classique comme cela était géré avec les Forms (Win ou Web). En exemple :

<Grid x:Name="myGrid">
  <StackPanel x:Name="myStackPanel">
    <TextBox x:Name="myTextBox" TextChanged="myTextBox_TextChanged"/>          
  </StackPanel>
</Grid>

Ici l'événement levé sera celui de la modification du texte de la TextBox.

Evénements de type bulle (bubbling)

Le Bubbling va nous permettre de lever un événement ou des événements dans un ordre précis. Ici chaque élément graphique s'abonne au même événement.

<Grid x:Name="myGrid" KeyDown="myGrid_KeyDown" >
  <StackPanel x:Name="myStackPanel" KeyDown="myStackPanel_KeyDown">
    <TextBox x:Name="myTextBox" KeyDown="myTextBox_KeyDown"/>          
  </StackPanel>
</Grid>

Ici le premier élément graphique a lever l'événement sera la TextBox puis le StackPanel et enfin la Grid.

Evénements de type tunnel (tunneling)

Le Tunneling va nous permettre la même granularité :

<Grid x:Name="myGrid" PreviewKeyDown="myGrid_PreviewKeyDown" >
  <StackPanel x:Name="myStackPanel" PreviewKeyDown="myStackPanel_PreviewKeyDown">
    <TextBox x:Name="myTextBox" PreviewKeyDown="myTextBox_PreviewKeyDown"/>          
  </StackPanel>
</Grid>

Ici le premier élément graphique a lever l'événement sera la Grid puis le StackPanel et enfin la TextBox.

Conclusion

D'une manière générale, les événements qui nous permettent de gérer le bubbling sont suffixé de "Down" et ceux pour le tunneling sont préfixé de "Preview". Voilà pour le petit topo. Maintenant on s'amuse...

Coding4Fun

Maintenant qu'on sait faire ça, on fait quoi ? Pour une fois je suis parti d'une idée et pas d'une particularité technique. Donc Aujourd'hui, je vous propose de mettre en place dans nos applications .NET, une fonctionnalité totalement old school, totalement geek, totalement inutile donc totalement indispensable, c'est à dire un Konami Code. C'est parti

On commence par créer notre classe qui va gérer le Code Konami.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Input;

namespace KonamiWPF
{
    public class KonamiCode
    {
        
        //La belle séquence Konami
        List Konami = new List
        {
            Key.Up, Key.Up,
            Key.Down, Key.Down,
            Key.Left, Key.Right,
            Key.Left, Key.Right,
            Key.B, Key.A
        };

        //notre index pour analyser la séquence
        public int myIndex { get; set; }

        public bool IsCompletedBy(Key myKey)
        {
            //on vérifie que la nouvelle touche pressé correspondent à la série
            if (Konami[myIndex + 1] == myKey)
            {
                myIndex++;
            }

            //mis en place si 3 Key.Up sont rentrés, il ne réinitialise pas analyse de la séquence
            else if (myIndex == 1 && myKey == Key.Up)
            {

            }
            
            // Démarrage de l'analyse de la séquence
            else if (Konami[0] == myKey)
            {
                myIndex = 0;
            }
            else
            {
                myIndex = -1;
            }
            // Si on arrive au bout on renvoie true et on réinitialise
            if (myIndex == Konami.Count -1)
            {
                myIndex = -1;
                return true;
            }
            return false;
        }
    }
}

Maintenant on reprends la même exemple de code XAML :

<Grid x:Name="myGrid" PreviewKeyUp="myGrid_PreviewKeyUp" >
  <StackPanel x:Name="myStackPanel">
    <TextBox x:Name="myTextBox"/>          
  </StackPanel>
</Grid>

Du coup, on fait un petit traitement juste pour vérifier si le Konami est correctement pris en charge.

public partial class MainWindow : Window
    {
        private KonamiCode seq;
        public MainWindow()
        {
            InitializeComponent();
            seq =  new KonamiCode();
        }

        private void myGrid_PreviewKeyUp(object sender, KeyEventArgs e)
        {
            if (seq.IsCompletedBy(e.Key))
            {
                myTextBox.Text = "Konami !!!";
            }
        }
    }

Maintenant je vous laisse faire preuve d'inventivité pour vos créations graphiques et bon code (Konami bien sûr ^^).

[XAML] Les Converters

Bon aujourd'hui un petit topo sur les converters en WPF, c'est simple, rapide et ça peut rapporter gros !!
Après une expérience de conversions tout à fait improbable (sur 4 couches applicatives!!!) sur un projet en Debug, il va être bon de rappeller les fondemmentaux :

a - Conversion monétaire

Allez on assume que les prix sont stockés dans notre base en Euros sous un format decimal !
Alors on va créer notre converter :

Using ...

namespace MyConverterApp
{
   [System.Windows.Data.ValueConversion(typeof(decimal), typeof(string))]
   class ConvertMoneyInEuros : System.Windows.Data.IValueConverter
   {
       public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo cultureInfo)
       {
           decimal myPrice = decimal.Parse(value.ToString());
           return myPrice.ToString("C");
       }

       public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo cultureInfo)
       {
           string aMyPrice = value.ToString();
           decimal result;
           if(decimal.TryParse(aMyPrice, System.GLobalization.NumberStyles.Any, null, out result)
           {
              return result;
           }
           else
              return 0;
       }
   }
}

Ensuite on instancie dans le XAML :

<Window x:Class="MyConverterApp"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

 xmlns:local="clr-namespace:MyConverterApp"

        Title="MainWindow" Height="350" Width="525">
<Window.Resources>
   <local:ConvertMoneyInEuros x:Key="DisplayInEuros"/>
</Window.Resources>
 ...
<Window>

Puis il ne nous reste plus qu'à l'utiliser dans notre Elément d'interface (en supposant un DataContext dans la Grid) :

<Grid Name="Grid1">
   <StackPanel>
      <label Content={Binding Path=UnitPrice, Converter={StaticResource DisplayInEuros}}
   </StackPanel>

Et cela nous affiche un joli 12,50 € !

Supposons maintenant que nous souhaitions l'afficher en dollars US mais pas comme font certains, qu'un produit à $6.00 ne devienne pas un produit vendu à 6,00 €... Mais bien que notre "12,50 €" devienne un "$9.52" Alors on créé simplement un nouveau converter :

Using ...

namespace MyConverterApp
{
   [System.Windows.Data.ValueConversion(typeof(decimal), typeof(string))]
   class ConvertMoneyInUSDollars : System.Windows.Data.IValueConverter
   {
      readonly decimal _rate = decimal.Parse("1,3131");
      readonly System.Globalization.CultureInfo _usCulture = new System.Globalization.CultureInfo("en-US");
      readonly System.Globalization.CultureInfo _currentcult = System.Globalization.CultureInfo.CurrentCulture;

      public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo cultureInfo)
      {
         decimal myPrice = decimal.Parse(value.ToString());
         myPrice = myPrice /_rate
         return myPrice.ToString("C", _usCulture);
         
      }

      public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo cultureInfo)
      {
         string aMyPrice = value.ToString();
         decimal result;
         if(decimal.TryParse(aMyPrice, System.GLobalization.NumberStyles.Any, null, out result)
         {
            result = result * _rate;
            return result;
         }
         else
            return 0;
      }
   }
}

Supposons maintenant souhaite basculer dynamiquement dans le code d'un affichage en Euros à un affichage en Dollars US avec un bouton radio par exemple :

        private void RadioButtonEURClick(object sender, RoutedEventArgs e)
        {
            var bd = new Binding();
            bd.Converter = new ConvertMoneyInEuros();
            bd.Path = new PropertyPath("UnitPrice");
            bd.UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged;
            bd.Mode = BindingMode.TwoWay;

            MyDynamicTextBox.SetBinding(TextBox.TextProperty, bd);
        }

        private void RadioButtonUSDClick(object sender, RoutedEventArgs e)
        {
            var bd = new Binding();
            bd.Converter = new ConvertMoneyInUsDollars();
            bd.Path = new PropertyPath("UnitPrice");
            bd.UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged;
            bd.Mode = BindingMode.TwoWay;

            MyDynamicTextBox.SetBinding(TextBox.TextProperty, bd);
        }

b - Conversion d'image

Les exemples présentés ici sont uniquement pour illustrer à nouveau les principes des converters à vous de les réadapter.
Voilà un converter pour remplacer le chemin d'accès à une image en image :

Using ...

namespace MyConverterApp
{
   [System.Windows.Data.ValueConversion(typeof(string), typeof(BitmapImage))]
   class ConvertStringToBitmap : System.Windows.Data.IValueConverter
   {

      public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo cultureInfo)
      {
         try
         {
            string myPath = (string)value;
            Uri myUri = new Uri(myPath);
            BitmapImage myImage = new BitmapImage(myUri);
            return myImage;
         }
         catch
         {
            return new BitmapImage(new Uri("C:\\ImageNotAvailable.jpg"));
         }
      }
      
      public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo cultureInfo)
      {
         throw new NotImplementedException();
      }
   }
}

Pour résumer, les converters sont un moyens efficaces d'effectuer diverses convertions au niveau de l'IHM.