Visual Studio 2013 Community Edition

vs2013logoIl y a aujourd’hui (enfin hier) une news qui a retenu mon attention. Elle a tellement retenu mon attention qu’elle m’a poussé à publier un billet à son sujet, alors même que les brouillons d’articles en attente de publication s’entassent depuis le mois de mai dans mon WordPress.

Bref cette news qui, quand on connait le passif de Microsoft, a de quoi en surprendre plus d’un, c’est l’annonce d’une nouvelle version de Visual Studio,  dénommée Visual Studio Community, totalement gratuite (dans certaines conditions).

Il ne s’agit pas là d’une énième déclinaison de Visual Studio Express, autrement dit d’un Visual Studio amputé d’un certain nombre de fonctionnalités et orienté sur un type de développement bien particulier (Express pour le web, Express pour Windows…). Il s’agit là d’un « vrai » Visual Studio Professional (à en croire les annonces en tout cas, je n’ai pas encore testé). On peut donc utiliser toutes les fonctionnalités d’un Visual Studio Professional, notamment en terme de debugage, profiling, … et on a accès à la même galerie d’extensions (on peut donc y installer par exemple Web essentials, ce qui n’est pas possible sur Visual Studio Express).

Après le passage en open source de projets phares comme .Net MVC ou Entity Framework, en plus de la prochaine version d’ASP.Net (vNext) qui devrait pouvoir s’exécuter beaucoup plus simplement sur toutes les plateformes , Microsoft fait un pas de plus vers la communauté des développeurs.

De cette façon microsoft ne s’adresse plus uniquement aux professionnels, mais aussi aux développeurs passionnés, aux petites équipes, aux startups… toutes ces cibles jusqu’alors ignorées mais qui ont un rôle essentiel à jouer dans la vie d’une communautés de développeurs.

Bref, il ne reste plus qu’à tester tout ça maintenant, en espérant qu’il ne s’agisse pas que d’un effet d’annonce.

[Git] Annuler le dernier Commit

Une demande qui revient souvent lorsque les développeurs se mettent à Git est « Comment annuler le dernier commit ? ».

La réponse n’est pas unique, elle dépend de différents critères : il faut savoir si le commit a déjà été pushé et si l’on souhaite tout de même conserver les modifications.

Voici trois cas qui couvrent les besoins rencontrés par les développeurs de mon équipe.

Supprimer définitivement le dernier commit non pushé :


git reset --hard HEAD~1

Supprimer le dernier commit non pushé tout en conservant les modifications dans la staging area :


git reset --soft HEAD~1

Revenir dans l’étant du commit précédent en appliquant un nouveau commit qui est exactement l’opposé du précédent : très pratique pour annuler un commit qui a déjà été pushé, et qu’on ne peut donc pas supprimer du dépôt central sans gêner les collaborateurs :


git revert HEAD~1

IIS6 – Modifier le nom d’un répertoire virtuel

Voici encore un petit billet – mémo qui aura très peu de chances d’intéresser quelqu’un d’autre que moi.

Avec IIS6, modifier le chemin d’un répertoire virtuel se fait très simplement dans le Gestionnaire des services Internet. Par contre lorsque l’on souhaite en modifier le nom, c’est une autre paire de manches. Rien ne peut être fait via l’interface graphique. Il existe cependant une solution, il faudra en passer par l’édition du fichier C:\WINDOWS\system32\inetsrv\MetaBase.xml

Je ne sais pas si c’est toujours valable pour les versions à jour de IIS, je trouve assez fou que cette possibilité d’édition ne soit pas prise en charge par l’interface graphique directement.

A noter au passage que ce fichier présente des informations qui peuvent se révéler intéressantes (l’attribut « AppRoot » est très utile si l’on souhaite par exemple scripter le changement du chemin d’un répertoire virtuel, possible uniquement via VBScript sous IIS6)

Closure Compiler : Compilation de code Javascript

Google met à disposition des développeurs un service de compilation / minification de javascript. Il s’agit de Closure Compiler.

L’avantage de ce service est de proposer, en plus de l’interface Web, une API REST permettant par exemple d’intégrer la compilation de code JS dans un build de projet. On peut contrôler la compression du code suivant 3 niveaux, le plus élevé (Advanced) étant susceptible de casser votre JS si celui-ci n’est pas prévu pour passer dans la moulinette.

Voici la doc du projet.

Je n’ai pas encore eu l’occasion de tester le service, mais je le partage ici de façon à le retrouver facilement au moment opportun ;)

MSDeploy et Connection Strings

MSBuild est un outil complet. Il permet notamment de déployer automatiquement des applications, via l’utilisation de MSDeploy. Mais il y a beaucoup de paramètres liés à l’utilisation de MSDeploy et on ne trouve pas forcément directement les informations souhaitées dans la documentation officielle.

Il y a en particulier une petite subtilité liée aux paramètres « sensibles »du Web.config comme les chaines de connexion, qui se retrouvent remplacées par des tokens lors de la création des packages ou lors des déploiements automatiques. Pour empêcher la paramétrisation automatique des chaines de connexion lors de déploiements automatique avec MSDeploy, il y a un paramètre à connaître :

AutoParameterizationWebConfigConnectionStrings = False

En ce qui me concerne, voici à quoi ressemble mes appels à MSDeploy pour un déploiement automatique en environnement d’intégration :

MSBuild.exe /P:Configuration=%compilationTarget% /P:DeployOnBuild=True /P:DeployTarget=MSDeployPublish /P:MsDeployServiceUrl=**** /P:MSDeployPublishMethod=MsDepSvc /P:AllowUntrustedCertificate=True /P:CreatePackageOnPublish=True
/P:AutoParameterizationWebConfigConnectionStrings=False

Notez que le paramètre MSDeployPublishMethod a son importance. J’utilise ici MsDepSvc qui est l’ancien service de déploiement automatique (IIS6). A partir de IIS7, il vaut mieux utiliser WMSvc (même si MsDepSvc existe toujours).

Au passage, une série d’articles très complets sur le déploiement automatique : http://www.troyhunt.com/2010/11/you-deploying-it-wrong-teamcity.html

Entity Framework – Garder l’oeil sur le SQL généré

Avec les ORM, il est indispensable de garder un œil sur les requêtes générées. Avec Entity Framework, il n’est pas nécessaire de démarrer un profilage de la base de données pour voir les requêtes qui passent. Surtout si l’on cherche à repérer ce qu’il se passe au niveau d’un appel en particulier. Il est alors préférable d’utiliser les fonctionnalités natives d’EF. Voici comment obtenir la requête SQL générée (pour EF < 4.1)

Voici un exemple avec une requête linq :

var result = from x in appEntities
             where x.id = 32
             select x;

var sql = ((System.Data.Objects.ObjectQuery)result).ToTraceString();

à utiliser par exemple dans un espion ou dans la fenêtre d’exécution lors du debug.

En espérant que ça puisse vous servir également !

[GIT] Résoudre les problèmes de .gitignore

Dans la série des billets mémo, voici une des premières questions que j’ai pu me poser lorsque j’ai commencé à utiliser Git.

Au fur et à mesure des commits, il peut arriver que des fichiers qui devraient pourtant être ignorés d’après les règles édictées dans le fichier .gitignore soient proposés à l’indexation . Ceci semble se produire si les fichiers étaient préalablement non ignorés et déjà commités (ou simplement indexés ?). Pour pouvoir ignorer ces fichiers qui posent problème, il faut réinitialiser l’index. Pour ce faire voici les étapes à respecter :

  • Archiver tout le code modifié que vous souhaitez conserver
  • Supprimer tout de l’index
  • git rm -r --cached .
  • Réimporter tout dans l’index (.gitignore est maintenant pris en compte)
  • git add .
  • Archiver (pour supprimer tout ce qui est ignoré)
  • git commit -m ".gitignore est maintenant fonctionnel"

 

Et voilà ! :)

.Net Webforms et .Net MVC dans la même application

Edit 18/02/2014 : Avec Visual Studio 2013 (et sans doute 2012, mais je n’ai pas testé), on crée avant tout un projet web, on y ajoute ensuite à souhait du webform, du mvc, ou du web API. Le mieux est donc sans doute de commencer par migrer en 2013 lorsque c’est possible ;-)

Lors de la migration de projets, il pourrait être intéressant de voir cohabiter, au moins pendant un certain temps, des Webforms et du MVC au sein de la même application. Et bien c’est tout à fait possible ! Après tout, derrière, c’est le même Framework ;-)

La documentation sur le sujet n’est pas florissante dans la langue de Molière, mais par contre on trouve, comme d’habitude, notre bonheur si on lit l’anglais (ce serait un comble pour un développeur) . Je suis tombé en particulier sur des posts intéressants de Scott Hanselman :

Plug-In Hybrids: ASP.NET WebForms and ASP.MVC and ASP.NET Dynamic Data Side By Side
Integrating ASP.NET MVC 3 into existing upgraded ASP.NET 4 Web Forms applications

Voilà en tout cas un bon point de départ, en espérant que d’autres que moins trouveront la solution intéressante pour certaines situations inextricables :-)

jQuery – Clic out

Puisque la question revient souvent, et que je donne toujours la même réponse, la voilà plus accessible qu’au fond d’un projet.

Pour fermer automatiquement un conteneur (menu, popin, …) lorsque l’on clic en dehors, voici une solution simple (basée sur jQuery)

$(document).mouseup(function (e)
{
    var container = $("SÉLECTEUR DU BLOC A CACHER");
 
    if (container.has(e.target).length === 0)
    {
        container.hide();
    }
});

jQuery – squelette de plugin et instance liée à l’objet DOM

EDIT : Une petite coquille existe dans le squelette proposé par pixelgraphics. Il manque un « return » dans le getter. Ci-dessous le squelette corrigé.

Rapide billet en mode pense bête.

Aujourd’hui j’ai eu besoin de lier une instance d’objet jQuery à un objet DOM, pour éviter d’instancier plusieurs fois mon plugin sur le même objet du DOM. Pour ça j’avais déjà vu un squelette de plugin qui répond au besoin, mais je ne me souvenais plus sur quel site. Pour ne plus perdre de temps à le rechercher comme aujourd’hui, et pour que ça puisse servir à d’autres voici le site en question : http://starter.pixelgraphics.us/

Ce site propose un générateur de squelettes de plugins jQuery, avec quelques options sympas, comme justement l’option « Getter » (qu’il ne faut pas oublier de cocher dans notre cas)

Lors de l’instanciation de l’objet jQuery, celui-ci est lié à l’objet du DOM grâce à la ligne :

base.$el.data("myAmazingPlugin", base);

et on peut simplement récupérer l’instance grâce à la fonction jQuery créée à cet effet :

$.fn.getmyAmazingPlugin = function(){
        return this.data("myAmazingPlugin");
    };

Pour utiliser ce plugin on utilisera donc :

//Instanciation du plugin
$("#myElement").myAmazingPlugin();
//Récupération de l'instance
$myElementInstance = $("#myElement").getmyAmazingPlugin();

On pourrait même simplement imaginer une fonction unique qui retourne l’instance si elle existe ou instancie le plugin sinon.

Le squelette de plugin au complet (j’en étais arrivé au même squelette, sans la ligne permettant de lier l’instance à l’objet du DOM) :

(function($){
    $.myAmazingPlugin = function(el, options){
        // To avoid scope issues, use 'base' instead of 'this'
        // to reference this class from internal events and functions.
        var base = this;
 
        // Access to jQuery and DOM versions of element
        base.$el = $(el);
        base.el = el;
 
        // Add a reverse reference to the DOM object
        base.$el.data("myAmazingPlugin", base);
 
        base.init = function(){
            base.options = $.extend({},$.myAmazingPlugin.defaultOptions, options);
 
            // Put your initialization code here
        };
 
        // Sample Function, Uncomment to use
        // base.functionName = function(paramaters){
        // 
        // };
 
        // Run initializer
        base.init();
    };
 
    $.myAmazingPlugin.defaultOptions = {
    };
 
    $.fn.myAmazingPlugin = function(options){
        return this.each(function(){
            (new $.myAmazingPlugin(this, options));
        });
    };
 
    // This function breaks the chain, but returns
    // the myAmazingPlugin if it has been attached to the object.
    $.fn.getmyAmazingPlugin = function(){
        return this.data("myAmazingPlugin");
    };
 
})(jQuery);

Notez la gestion des options, à connaitre quand on développe ses propres plugins jQuery !

PS : Je n’ai pas oublié l’article sur TVHeadEnd ;)