Inetsis Blog

Déployer sur azure

Mon, 28 May 2018 17:26:00 +0100

Voici quelques infos bien utiles pour déployer sur Azure.

L'idée est de compiler les sources, lancer une publication locale, zipper le résultat et l'uploader

1- Compilation

publishSiteName=monApp
buildConfiguration=maConfig
publishProfile=nomPublication
pathMSBuild="C:/Program Files (x86)/MSBuild/14.0/Bin/msbuild.exe"

#  Execution du script.
"$pathMSBuild" ./masolution.sln /property:configuration=$buildConfiguration 
               /property:PublishProfile=$publishProfile /property:DeployOnBuild=true

2- La publication locale

Le code ci-dessus, lance automatiquement la publication passée en paramètre, elle correspond au nom que vous avez indiqué dans visual studio

3- Pour zipper, rien de compliquer

deployArchiveFile="$publishSiteName.zip"
pathDeploy="C:\Publish\Monapp\wwwroot\publishSiteName"

"C:/Program Files/7-Zip/7zG.exe" a "./$deployArchiveFile" "$pathDeploy/*"

Ne pas oublier de supprimer le fichier une fois l'upload terminée

4- Il reste simplement à envoyer sur Azure

completeAzureLogin="$AZURE_LOGIN:$AZURE_PASSWORD"

echo "Upload de l'archive sur azure via l'API de KUDU"
curl -X PUT --data-binary @$publishSiteName.zip 
        https://monazure.scm.azurewebsites.net/api/zip/site/$publishSiteName/ 
        -u $completeAzureLogin

Attention, bien vérifier l'url vers l'api KUDU qui est la même que l'url du site avec un .scm. en plus !

Pour obtenir le login et le mode de passe de l'api zip, il faut se connecter à l'interface de gestion (https://portal.azure.com) et télécharger le profil de publication. Le login commence par un $ et le mot de passe est une longue suite de caractères, exemple :

AZURE_LOGIN=$monapi
AZURE_PASSWORD=ZpuSQ3o9WXnSQeBbzu5qsrBgJ1b79aApkg8MoQEjriCxh6JLc0i6W1NJ6amS

5- Vérification du déploiement

Aller dans les outils avancés et vérifier dans le dossier "site" si l'application a bien été déployée

6- Créer un sous-site

Pour déployer plusieurs site sur une même machine azure, il faut aller dans "Paramètres \ Paramètres de l'application" puis tout en bas dans "Applications et répertoires virtuels" et associer les répertoire au sous-site voulu

Voilà de quoi partir du bon pied !

En PJ : les fichiers complets

create-zip-package-api.sh (762,00 bytes)

publish-package-api.sh (1,21 kb)

publish-package-rec.sh (1,05 kb)

Boucle sans fin

Mon, 27 Jun 2016 17:14:00 +0100

J'ai eu le cas récemment de relire un code C# utilisant une BlockingCollection<T> qui est un peu particulière car elle permet de dépiler les items de la collection au fur et à mesure qu'on en ajoute (donc threadsafe) et en plus, la petite maline bloque le thread producteur si la collection est pleine ! Bon sur le papier ça peut être cool parce qu'en procédant ainsi, la pile ne grossit pas trop et on grossit pas en mémoire ... mais bon ... le thread est bloqué quoi !!! En fonction du sénario, ça peut justement être très BLOQUANT et engendrer un max de fragmentation ...

Donc, comme souvent, back to basic : j'ai mis en place un bonne vieille stack threadsafe : ConcurrentQueue<T> avec un thread et une boucle sans fin ! C'est l'occasion de revenir sur cette conception simple mais pourtant bigrement efficace qu'est le while(true). Cette boucle est souvent associée à problème, pourtant, bien maitrisée, elle fait des miracles. Il n'y d'ailleurs que 3 choses à bien vérifier :

1 - La gestion du thread

Qui dit thread, dit forcement clôture bien propre du thread, pour se faire, vous devez utiliser un objet tout simple, le "CancellationTokenSource" qu'il faut passer à la création du thread et qui, lorsque vous appelez sa méthode "Cancel()", va dire au thread de s'arreter gentiment parce qu'il est bien élevé codé.

Ensuite, quel objet thread utiliser ? Il y a le classique System.Threading.Thread connu depuis la nuit des temps, qui porte bien son nom parce qu'il crée simplement un thread au sens OS du terme, c'est l'objet de base, le truc avec lequel vous serez jamais déçu ! Ensuite on a le ThreadPool, qui est un peu plus haut niveau et qui va gérer un ensemble de thread applicatif pour pas polluer l'OS, si vous faite beaucoup de création / destruction de petits thread dans votre appli, c'est l'objet idéal. Et puis ya le petit nouveau, le System.Threading.Tasks.Task qui est la nouvelle manière de faire avec les mots clefs async / await, c'est le thread next-gen, celui qui résoud tous vos problèmes et qui fait le café ...

2 - La gestion des exception

Mais revenons à notre boucle sans fin, qui a aussi besoin de bien savoir gérer ses exceptions, alors biensur, vous mettez un try/catch dans la boucle pour éviter les bétises, mais en plus, parce qu'il arrive toujours des trucs auxquels on a pas pensé, on ajoute un "ContinueWith()" à notre task pour la faire repartir ni vu ni connu !

3 - Laissez-la respirer !!

Et c'est bien souvent là que le bât blesse, si votre boucle sans fin tourne tout le temps, votre processeur est à 100% et vous pas content ! Donc il faut absolument mettre un petit Thread.Sleep() dans votre boucle pour laisser les autres processus prendre la main et continuer leurs jobs. Votre boucle sans fin aura ainsi le droit de parler comme les autres et non pas tout le temps. La valeur que vous aller mettre dans ce sleep est assez déterminante, 500 millisecondes c'est énorme mais pour un thread background c'est correcte, il est possible de descendre à 10 voir à 2 pour un traitement UI ou real-time. Il faut faire des tests et doser ...

Finalement, c'était pas si compliqué hein ? Aller le code type :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    public class MonManager
    {
        private readonly CancellationTokenSource _cancel;
        private readonly Task _worker;

        public MonManager()
        {
            _cancel = new CancellationTokenSource();
            _worker = new Task(DoWork, _cancel.Token, TaskCreationOptions.LongRunning);
        }

        private void DoWork()
        {
            do
            {
                try
                {
                    // Le code de la boucle sans fin
                    // ...

                    // Avec le sleep pour laisser respirer
                    Thread.Sleep(500);
                }
                catch (ExceptionMetier ex)
                {
                    // Gestion des exceptions métiers
                    throw;
                }
            }
            while (!_cancel.IsCancellationRequested);
        }

        public void Start()
        {
            _worker.Start();
            _worker.ContinueWith(WorkerException, TaskContinuationOptions.OnlyOnFaulted);
        }

        public void Stop()
        {
            if (!_cancel.IsCancellationRequested)
                _cancel.Cancel();
        }

        private void WorkerException(Task task)
        {
            // Gestion des exceptions techniques
            if (!_cancel.IsCancellationRequested)
                this.Start();
        }
    }
}

Avec un code aussi simple, pourquoi se priver ?

L'OpacityMask en XAML

Wed, 20 Apr 2016 16:34:00 +0100

J'ai besoin de faire un truc tout simple : un bouton image qui est bleu lorsqu'il est actif et gris lorsqu'il est désactivé.

Pour être malin, on va utiliser le principe de la ICommand bindée sur un bouton, ainsi, lorsque le CanExecute() retournera false, le bouton sera désactivé. Ensuite on va supprimer entièrement le template du bouton et y placer notre image blanche en OpacityMask d'un rectangle sur lequel on pourra faire varier la couleur du Fill et ainsi coloriser l'image. Pour finir, il reste juste à binder Fill à IsEnabled du bouton.

1- Rappel de la syntaxe de la commande MVVM light :

public ICommand AddCommand { get; private set; }

public Ctor()
{
    this.AddCommand = new RelayCommand(this.AddVersion, this.AddVersionCanExecute);
}

private void AddVersion()
{
    // Truc à faire
}
private bool AddVersionCanExecute()
{
    // Peut-on faire le truc ?
    return this.SelectedVersion != null;
}

2- Code XAML :

<!--Image button : no template, hand cursor-->
<Style x:Key="btImg" TargetType="Button">
    <Setter Property="Template" Value="{x:Null}" />
    <Setter Property="Cursor" Value="Hand" />
    <Setter Property="VerticalAlignment" Value="Center" />
</Style>

<!--L'image blanche-->
<ImageBrush x:Key="AddVipIcon" ImageSource="/Mon.Assembly;component/Images/add.png" />

<!--La jolie couleur bleue-->     
<SolidColorBrush x:Name="c_blue" Color="#3572BA" />       
           
<!--Le Converter-->
<fwk:BooleanConverter x:Key="CanAddToColorConv" 
                      TrueValue="{StaticResource c_blue}" FalseValue="Gray" />
                
<!-- Et enfin le bouton -->    
<Button Style="{StaticResource btImg}" Command="{Binding AddCommand}">
    <!-- Le rectangle donne la couleur à l'image blanche en opacity mask -->
    <!-- Le bouton gère son IsEnabled avec le CanExecute de la commande -->
    <!-- Le converter sur Fill donne la couleur en fontion du IsEnabled : -->
    <!-- actif = bleu / désactivé = gris -->
    <Rectangle Width="16" Height="16" OpacityMask="{StaticResource AddVipIcon}"
               Fill="{Binding IsEnabled, 
                      RelativeSource={RelativeSource AncestorType=Button}, 
                      Converter={StaticResource CanAddToColorConv}}"/>
</Button>

J'aime bien ce code car il utilise au maximum la puissance du XAML et on trouve des rappels intéressants comme le findAncestor sur le type ou l'imageBrush

TFS : Fichiers modifiés hors contrôle de source

Thu, 18 Feb 2016 12:51:00 +0100

Voici une astuce avec TFS qui permet de reprendre en automatique, tous les "check out" sur les fichiers que vous avez modifiés en dehors de Visual Studio et ainsi pouvoir faire votre commit dans de bonnes conditions.

On commence par chercher les fichiers qui sont différents de la version serveur avec un "compare" sur un dossier à partir du Source Control Explorer :

Dans la liste des fichiers modifiés, on a alors l'information si le verrou TFS est bien atif ou non dans la colonne "Pending Change". Il suffit donc de sélectionner les fichiers qui ne sont pas "edit" et lancer l'outil de synchro avec TFS, le "Reconcile".

Il ne reste plus qu'à dire à TFS de garder le fichier et à faire le Checkout pour chaque fichier

Voilà, en quelques clics, vous avez rattrapé le coup !

TFS : Déplacer un Shelve vers une autre branche

Tue, 16 Feb 2016 13:31:00 +0100

Comment se faire avoir stupidement : vous avez commencez à développer, vous avez mis votre travail de coté en Shelve, mais depuis, vous avez banché et vote Shelve n'est plus sur les bonnes sources ... Aïe ... Pas de panique, comme toujours TFS a pensé à ce cas de figure ! Certe, il n'y a pas d'interface graphique, mais en mode ligne de command, on s'en sort.

1- Identifiez avec précision le NOM du changeset

Sur la capture ci-dessus, on voit que je suis dans la branche V1113. Avant d'aller plus loin, il faut absolument avoir la branche destinatrice en local sur votre poste. Donc, si ce n'est pas le cas, faite un "get lateste version". Ensuite, ouvrez la commande DOS développeur, qui se trouve dans le menu démarrer : Visual \ Tools \ VS Command Prompt, et naviguez vers l'emplacement de la branche (très important)

2- Utilisez la commande "unshelve /migrate" avec le nom du shelve :

Une fenètre va alors s'ouvrir pour vous présenter les différences entre les deux branches. La plupart des fichiers seront automatiquement mergés

3- Faites le merge à la main pour tous les autres en cliquant sur le bouton "Resolve"

Voilà, votre Shelve a changé de branche

Source : http://benjii.me/2014/04/move-shelveset-to-different-branch-in-tfs/

Démarrer avec Xamarin

Mon, 28 Sep 2015 16:07:00 +0100

Nouveau challenge pour moi, faire du dev mobile ! J'ai fait un peu le tour de la question et il n'y a pas photo, c'est Xamarin qui sort du lot. Maintenant qu'il est intégré nativement à Visual 2015, Microsoft pousse derrière, on code en C# et en XAML, ça produit du code natif, moi je dis chapeau, c'est exactement ce qu'il faut, je kiff !

Donc voici quelques liens qui m'ont permis de démarrer :

Le starting guide en français : Tuto Xamarin
Ajouter la plateforme surface : Adding a windows app
La bible : Xamarin.Forms Namespace
La hiérarchie objet : Classes derived from Element
La mise en forme : Forms layouts
La gestion des images : Working with Images

Déjà avec ça, on est bien pour commencer, let's go to code !

Un peu de lecture pour la rentrée !

Tue, 01 Sep 2015 15:54:00 +0100

Trouver des petites solutions à des petits problème sur stackoverflow c'est déjà très bien. Mais pour apprendre des concepts ou une nouvelle techno, rien de mieux qu'un bon bouquin qui vous emmène de A à Z en passant par toutes les étapes qui vont biens !

Je vous recommande donc la lecture des très bons ouvrages NAXOS ! C'est très bien écrit, le développeur est talentueux, c'est en français, et c'est gratuit !! Que demander de plus ? Tout est là :

http://www.e-naxos.com/AllDotBlog.html

Alors bonne lecture !

Les nouveautés de C# 6

Thu, 20 Aug 2015 10:20:00 +0100

Visual studio 2015 est disponible depuis quelques semaines, c'est l'occasion de découvrir les nouveautés du langage C#6. Voici déjà en préambule l'historique des version de C# :

C# est apparu en 2001 avec Visual Studio.Net
v2 en 2005 avec les classes partielles, les nullables, les méthodes anonymes et les générics
v3 en 2007 avec Linq, les var, les méthodes d'extension, les expressions lambda
v4 en 2010 avec les arguments nommés, les dynamics, la programmation parallèle
v5 en 2012 avec async / await, le [CallerMemberName]

Pour cette nouvelle mouture, nous avons de le droits à des tips vraiment sympa :

1 - Le mot clef nameof

On l'attendait depuis l'utilisation massive de NotifyPropertyChanged dont l'utilisation du nom de le propriété en string posait problème de puis longtemps (voir cet article). Nous avons maintenant un mot clef qui permet de récupérer le nom d'un symbole de manière générale. Ca fonctionne donc pour une propriété, un champ, une variable ou même une méthode.

nameof(objet.MaProp) -> "MaProp"
nameof(objet.MaFonc) -> "MaFonc"

2 - La vérification de nullité avec ?.

Voici maintenant un nouvel opérateur ! Le "?." évite les nullReferenceException en incluant un test de nullité à notre place. Si l'objet que l'on accède est null, alors la valeur renvoyé sera null aussi.

Person obj = null;
int? age = obj?.Age;

// Est la même chose que : 

if (obj != null)
   age = obj.Age;

Ce qui est intéressant c'est que l'on peut enchainer les "?." pour éviter les tests à rallonge !

int? cp = person?.Mere?.Ville?.CodePostal

Et si l'on veut donner une valeur par défaut, il suffit de l'associer avec un double point d'interrogation

int age = peson?.Age ? ? 18;

3 - Le nouveau système de string.format

Des formattage de chaine de caractère on en fait énormément, avec ce nouveau système, C# nous aide à obtenir un code plus lisible en utilisant les variables directement dans la chaine. Pour ce faire, on doit préfixer la chaine par "$" et l'on utilise les variable à place des numéros toujours entre "{}"

string c = $"Bonjour M.{person.Nom}, il est {DateTime.Now.Hour:T}";

4 - L'enrichissement des lambda

Ce n'est pas vraiment une lambda, mais ça se rapproche d'une méthode anonyme, voici une manière plus concise d'écrire une propriété ou un méthode qui ne possède qu'une seule instruction "return"

public int NbFreres
{
    get { return this.Freres.Count(); }
}

// Devient : 

public int NbFreres => this.Freres.Count();

// Ou

public int GetNbFreres() => this.Freres.Count();

5 - Une nouvelle méthode d'initialisateur de dictionary et des getters

Initialiser un dictionary n'est pas très intuitif, là encore C#6 nous aide à obtenir un code plus lisible :

var surnoms = new Dictionary<string, Person>
{
    { "Toto", new Person("Tom") },
    { "Papy", new Person("Jean") },
    ...
};

// Devient :

var surnoms = new Dictionary<string, Person>
{
    ["Toto"] = new Person("Tom"),
    ["Papy"] = new Person("Jean"),
    ...
};

Et un peu dans le même esprit, il est maintenant possible d'initialiser les getters court :

int Age {get; set; } = 18;

6 - Enrichissement du catch

La limitation qui empêchait d'écrire un await dans un bloc catch ou finally est maintenant levée !

private async Task DoSomethingAsync()
{
    try
    {
        // Some async code that can throw an exception
        ...
    }
    catch (Exception ex)
    {
        var dialog = new MessageDialog("Something went wrong!");
        await dialog.ShowAsync();
    }
}

De plus, il est possible de poser des conditions sur les blocs catch pour tester un code d'erreur par exemple :

try
{
   ...
}
catch(IOException ex) if (ex.HResult == 0x80070020)
{
    // File is in use by another process
}
catch(IOException ex) if (ex.HResult == 0x80070035)
{
    // Network path was not found
}
catch(Exception ex)
{
    // Something else happened
}

7 - Using de namespace dans une portée

Les using sont normalement définit en tête de fichier pour tout le fichier. Mais il peut arriver que l'on souhaite utiliser un using que dans une partie de son code, pour éviter les conflits de nommage par exemple. C'est maintenant possible avec une syntaxe un peu particulière. On peut aussi préciser un objet static que l'on utilise fréquement.

public void MaFonction()
{
   // Using dans la portée
   using static Inetsis.Helpers;

   ...
   // Utilisation directe d'un objet static
   using static System.Math;
   double distance = Sqrt(x * x + y * y);
}

A noter que toutes ces évolutions sont utilisables avec le framework 4;

Installer Windows depuis une clef USB

Wed, 12 Aug 2015 10:41:00 +0100

C'est le moment de passer à Windows 10 mais malheureusement je n'ai pas de lecteur optique sur ma tablette alors comment faire ?

Il suffit juste d'utiliser un outil qui va créer un clef USB bootable depuis un ISO : Windows USB/DVD Download Tool

http://wudt.codeplex.com/

Et voici la procédure complète si besoin : FAQ

Des boutons réactifs en Asp.net

Tue, 30 Jun 2015 10:31:00 +0100

Un tweak rapide pour désactiver un bouton dès que l'utilisateur a cliqué dessus pour éviter les appels multiples au serveur. Ajouter le onLoad pour prendre la main en code behind :

<asp:Button ID="btSave" runat="server" CommandName="Update" 
            Text="Enregistrer" OnLoad="AddDisableEvent" />

Et ajouter du code javascript en concervant le callBack du click :

protected void AddDisableEvent(object sender, EventArgs e)
{
    var btSave = sender as Button;
    if (btSave != null)
    {
        // Ajouter le disabled du bouton enregistrer
        btSave.Attributes.Add("onclick", "this.disabled=true; this.value='En cours ...'; " 
            + ClientScript.GetPostBackEventReference(btSave, null) + ";");
    }

}

Et un deuxième pour confirmer une action coté client :

<script type="text/javascript">
    function displayBox() {
        if (confirm("Voulez-vous ... blabla ... ?") == true)
        { return true; }
        else
        { return false; }
    }
</script>

et

<asp:LinkButton runat="server" Text="Envoyer" CommandArgument="<%# Item.Id %>"
                OnClick="Envoyer_Click"  OnClientClick="return displayBox();" />

Le "OnClick" n'est pas appelé si le OnClientClick renvoie false !

Bien pratique pour rendre son UI plus réactive.