Archives pour la catégorie .NET

Release de Visual Studio 2022

Ca y est, la dernière version de Visual Studio est sortie. Mais que nous apporte cette nouvelle version ?

Tout d’abord Visual Studio est maintenant une application 64 bits ! Vous avez bien lu. Depuis des années nous attendions que cette superbe application de développement qui vous permet de compiler en 32 et 64 bits (ok, ce n’est pas elle qui compile, mais elle délègue cette compilation), qui s’adresse à tout type de plateforme (ordinateur, téléphone, Xbox, Hololens.. et puis tout le reste si l’on utilise avec Unity) passe elle même en 64 bits.

Visual Studio est donc rapide, très rapide (non, je ne dirais pas trop rapide car on le l’est jamais assez mais franchement j’ai failli le dire) et surtout il ne rencontre plus aucun problème pour adresser de grandes quantité de RAM (merci le 64 bits).

Microsoft s’est focalisé sur l’amélioration des performances à tous les niveaux. La fonctionnalités de recherche dans les fichiers est ainsi 3 fois plus rapide.

La construction d’application moderne est facilitée par un support total de .NET 6 et son framework unifié de développement web, client et mobile pour Windows et Mac. Les éditeurs Blazor, Razor et le rechargement à chaud dans ASP.NET Core est désormais inclus (c’est un véritable avantage lorsque vous sauvez un fichier ou modifié un simple CSS. C’est quand même un plaisir de ne pas devoir tout relancer).

L’intégration de Git au sein de Visual Studio est aussi améliorée avec le support de plusieurs repository en même temps. Quel plaisir de ne pas avoir besoin d’ouvrir plusieurs Visual Studio ou outils diverses et et variés parce que l’on travaille sur plusieurs projets en même temps !

IntelliCode n’est pas en reste. Il est désormais capable de compléter une ligne complète en un seul coup. Quel avantage pour les fainéants… et pour les autres d’ailleurs ! Moins de touches à taper, plus de temps pour se concentrer ! Ce n’est pas tout, le principe de recommandations d’actions rapides fait son apparition. IntelliCode peut désormais détecter lorsque vous faite une tâche classique et vous propose une action rapide à exécuter (plutôt que vous tapiez… quelle bande de veinard vous faites).

.NET Core 3.1, quoi de neuf ?

.NET Core 3.1 est sorti et il nous apporte quelques modifications substantielle, notamment pour les utilisateurs de Blazor et le Windows Desktop

Pour mémo, Blazor est une façon efficace, et orignale, d’envisager la création de site web. Il permet non seulement au programmeur de ne pas quitter son environnement de programmation préféré mais surtout de ne pas changer de langages.

Lire la suite →

HoloLens 2 et Azure Kinect : Microsoft ne lâche rien

​Du 25 au 28 février, donc pile cette semaine, se déroule le Mobile World Congress 2019. Un rendez-vous assez important dans le milieu des appareils mobiles, que ce soit évidemment les smartphones, tablettes, PC portable, ou casque de VR. Un salon parfait que Microsoft a choisi pour présenter ses deux nouveaux produits : HoloLens 2 et Azure Kinect Developer Kit

Lire la suite

C# 7.3 : les nouveautés

Petite évolution de C# 7.3 qui mérite notre attention, à nous fans de C#, du framework .NET et de ses apports. Microsoft a en effet apporté une attention particulière à la performance du code en mode sécurisé, à une amélioration substantielle de fonctionnalités existantes mais aussi deux nouvelles options de compilateur qui vont ravir ceux qui aiment l’opensource.

Que devons-nous retenir ?

Amélioration des performances du code sécurisé

L’indexation des champs fixed ne nécessite plus un second fixed

Vous le savez probablement, même si on en parle peu, même si on l’utilise peu, C# nous permet la création de code en mode non sécurisé. Cette écriture est très pratique pour ceux qui travaillent sur des fonctionnalités pointues où les performances sont essentielles. L’apport de C# 7.3 est de faciliter le contexte entre code sécurisé et code non-sécurisé afin que les développeurs aient justement moins accès au code non sécurisé. En effet, moins les développeurs passent de temps en code non sécurisé, plus leur code est stabilisé et sûr.

Observer par exemple dans le code ci-dessous la différence entre un code pré-C# 7.3 et un code C# 7.3. Dans cet exemple, vous devez accéder à un élément d’un tableau d’entier à l’intérieur d’une structure « unsafe »

unsafe struct S
{
   public fixed int myFixedField[10];
}

//Avant c# 7.3
class Avant
{
   static S s = new S();

   unsafe public void MaMethod()
   {
      fixed (int* ptr = s.myFixedField)
      {
         int p = ptr[5];
      }
   }
}

//Apres c# 7.3
class Apres
{
   static S s = new S();

   unsafe public void MaMethod()
   {
      int p = s.myFixedField[5];
   }
}

Avec C# 7.3, il n’y a plus besoin d’épingler avec fixed un pointeur complémentaire vers l’élément ; il y a a toutefois toujours besoin d’un contexte unsafe.

L’utilisation de fixed est étendue

L’instruction fixed, qui se limitait à un nombre limite de types est étendu à tout type contenant une méthode GetPinnableReference() qui retoure un ref T ou ref readonly T. L’instruction fixed est par exemple utilisable avec System.Span<T>.

Initialiseurs sur stackalloc

A l’image des initialiseurs sur les tableaux « classiques », il est possible d’utiliser la syntaxe suivante avec stackalloc (allocation d’un bloc mémoire sur la pile)

int* pArr = stackalloc int[3] {1, 2, 3};
int* pArr2 = stackalloc int[] {1, 2, 3};
Span arr = stackalloc [] {1, 2, 3};

Réaffectation des variables locales ref

Très pratique, les variables locales ref peuvent être réaffectées ; ce qui était auparavant impossible.

ref MaStructure  a = ref Structure1;
a = ref Structure2; //réassignation

Quelques nouveautés

Comparaisons et différences sur les tuples

Tous d’abord les tuples prennent désormais en charge les comparaisons et les différences. Je vous invite vivement à lire ce document Microsoft, mais voici en résumé le comportement : les tuples peuvent se comparer grâce à une comparaison dans l’ordre des membres de gauche à ceux de droites, les comparaisons s’arrêtant dès qu’une paire n’est pas égale.

var left = (a: 5, b: 10);
var right = (a: 5, b: 10);
Console.WriteLine(left == right); // affiche 'true'

De nombreuses choses se passent de façon transparente, notamment des conversions implicites comme dans l’exemple ci-dessous où la comparaison de int à long se fait implicitement

(long a, int b) longFirst = (5, 10);
(int a, long b) longSecond = (5, 10);
Console.WriteLine(longFirst == longSecond); // Affiche vrai

Des conversions « lifted », grosso modo des conversions qui gère le cas des comparaisons de type Nullable s’opèrent également

var left = (a: 5, b: 10);
(int? a, int? b) nullableMembers = (5, 10);
Console.WriteLine(left == nullableMembers); // Vrai

 Les contraintes « where » sur les génériques sont améliorées

Qu’il est pratique ce « where » sur les génériques ; il permet de spécifier l’héritage mais également s’il est possible de créer une instance comme dans l’exemple suivant où le type T doit implémenter IComparable mais également avoir un constructeur accessible sans paramètre.

public class MyGenericClass where T : IComparable, new()
{
// La ligne suivante est impossible sans la contrainte new():
T item = new T();
}

Vous connaissez et probablement utilisez déjà les contraintes de type struct ou class comme dans l’exemple suivant.

class MyClass<T, U>
where T : class
where U : struct
{ }

Ils sont en revanche nouveaux grâce à C# 7.3, ce sont les contraintes de type Enum, Delegate ou MulticastDelegate .

public class UsingEnum where T : System.Enum { }

public class UsingDelegate where T : System.Delegate { }

public class Multicaster where T : System.MulticastDelegate { }

Avec C# 7.3 est égaleemnt ajouté les types non managés, c’est à dire les type qu’on ne sont pas un type référence et ne contiennent aucun champ de type référencé à tous les niveaux d’imbrication

class UnManagedWrapper
where T : unmanaged
{ }

Cibles d’attribut

La cible d’un attribut est l’entité à laquelle il s’applique. Les cibles peuvent être assembly, module, field, event, method, param, propery, return ou type. Il est désormais possible d’écrire :

[field: InformationSurLeFieldAttribute]
public int Couleur { get; set; }
{ }

Nouvelles options du compilateur

Signature publique/opensource

Il est désormais possible de signer un assembly avec une clé publique grâce à

-publicsign. 

L’assembly est ainsi identifié comme « signée » (grâce à un bit dans l’assembly) mais provient d’une clé publique. Ceci permet la génération d’assembly à partir de clé publique opensource.

pathmap

L’option

pathmap

 contrôle le chemin des sources écrits dans les fichiers PDB ou CallerFilePathAttribute. Il est ainsi possible d’indiquer au compilateur de remplacer les chemins sources de l’environnement de build par ceux mappés.

Cet article s’est focalisé sur les améliorations les plus parlantes, la liste complète de toutes les fonctionnalités est disponible  dans la documentation Microsoft.

 

C# 7.1 – Les nouveautés

Les nouveautés de C# 7.1 sont subtiles mais intéressante. Tout d’abord la sélection de la version du langage se fait dans les paramètres avancés du build. En effet, par défaut la version C# 7.1 n’est pas sélectionnée par défaut.

Il est également possible de modifier directement le fichier csproj en ajoutant un propertygroup approprié.

Async Main

Evolution, il est désormais possible d’utiliser le mot clé await dans la méthode Main. Il était en effet autrefois nécessaire d’encapsuler le retour d’une tâche asynchrone pour attendre le retour. Plusieurs techniques existaient entre la preview de l’Async CTP avec « GeneralThreadAffineContext », l’ « AsyncContext » du packge NuGet Nito.AsyncEX, c’est bien celle proposé par Microsoft la plus usité :

class Program
{
    static void Main(string[] args)
    {
        MainAsync(args).GetAwaiter().GetResult();
    }

    static async Task MainAsync(string[] args)
    {
        Bootstrapper bs = new Bootstrapper();
        var list = await bs.GetList();
    }
}

Avec C# 7.1, l’appel est nettement plus simple

class Program
{
    static async Task Main(string[] args)
    {
        Bootstrapper bs = new Bootstrapper();
        var list = await bs.GetList();
    }
}

Literal «default » et inférence de type

Le mot clé « default » est déjà particulièrement utile pour affecter une valeur par défaut à un géneric de type T dont on ne sait d’avance si c’est un type référence ou valeur. Ce mot clé peut par ailleurs être utilisé avec n’importe quel type managé comme default(string), default(int) ou default(int ?)

Avec C# 7.1, « default » peut être utilisé comme littéral si le compilateur peut faire un inférence de type. Autrement dit, au lieu d’écrire « default(T) », on peut littéralement écrire « defaut » si le compilateur a suffisamment d’information. Le code devient ainsi plus concis et clair ; cela marchant pour de nombreux cas comme la déclaration de valeurs par défaut de paramètre optionnel, le retour de méthodes, l’initialisation ou assignation de variables, etc .

public class Point
{
    public double X { get; }
    public double Y { get; }

    public Point(double x, double y)
    {
        X = x;
        Y = y;
    }
}

public class LabeledPoint
{
    public double X { get; private set; }
    public double Y { get; private set; }
    public string Label { get; set; }

    // Providing the value for a default argument:
    public LabeledPoint(double x, double y, string label = default)
    {
        X = x;
        Y = y;
        this.Label = label;
    }

    public static LabeledPoint MovePoint(LabeledPoint source,
        double xDistance, double yDistance)
    {
        // return a default value:
        if (source == null)
            return default;

        return new LabeledPoint(source.X + xDistance, source.Y + yDistance,
        source.Label);
    }

    public static LabeledPoint FindClosestLocation(IEnumerable<LabeledPoint> sequence,
        Point location)
    {
        // initialize variable:
        LabeledPoint rVal = default;
        double distance = double.MaxValue;

        foreach (var pt in sequence)
        {
            var thisDistance = Math.Sqrt((pt.X - location.X) * (pt.X - location.X) +
                (pt.Y - location.Y) * (pt.Y - location.Y));
            if (thisDistance < distance)
            {
                distance = thisDistance;
                rVal = pt;
            }
        }

        return rVal;
    }

    public static LabeledPoint ClosestToOrigin(IEnumerable<LabeledPoint> sequence)
        // Pass default value of an argument.
        => FindClosestLocation(sequence, default);
}

Inférence du nom des éléments dans un type.

C# 7.0. a introduit les tuples. Lors de leur initialisation d’un tuple, les noms souhaités pour ses éléments sont généralement ceux des variables utilisés comme dans l’exemple suivant

string nom = "Fabrice JEAN-FRANCOIS";
int age = 26;
var personne = (nom: nom, age: age);

 

Avec C# 7.1, les noms d’éléments de tuple peuvent désormais être déduits à partir de variables utilisés :

string nom = "Fabrice JEAN-FRANCOIS";
int age = 26;
var personne = (nom, age); // le nom des elements du tuple seront « nom » et « age »

Génération d’assembly de référence

Le compilateur peut générer des assemblies de référénce uniquement via /refout et refonly.

S’interfacer avec une Sphèro en remote avec NancyModule

 

using SpheroNET;

using System;

using System.Collections.Generic;

using System.Drawing;

using System.Linq;

using System.Text;

namespace SpheroConsole

{

public class SpheroModule : Nancy.NancyModule

{

static SpheroConnector spheroConnector = new SpheroConnector();

static Sphero sphero = null;

public SpheroModule()

{

Get[« / »] = _ =>

{

string s = « Novencia TS – WebSphero Proxy<br><br> »;

s += « Command List :<br/> »;

s += « <b>find<b> – Get port id Bluetooth devices<br/> »;

s += « <b>connect/{port}<b> – Connect to the given port id (see find)<br/> »;

s += « <b>sleep<b> – Sleep the Sphero<br/> »;

s += « <b>close<b> – Close the Sphero communication<br/> »;

s += « <b>setrgb/{red}/{green}/{blue}<b> -Change Sphero color<br/> »;

return s;

};

Get[« /find »] = _ =>

{

spheroConnector.Scan();

var deviceNames = spheroConnector.DeviceNames;

string result = «  »;

for (int i = 0; i < deviceNames.Count; i++)

{

result += string.Format(« {0}: {1}<br/> », i, deviceNames[i]);

}

return result;

};

Get[« /connect/{port} »] = PortFinder;

Get[« /close »] = _ => { spheroConnector.Close(); return « OK »; };

Get[« /sleep »] = _ => { sphero.Sleep(); return « OK »; };

Get[« /setrgb/{red}/{green}/{blue} »] = SetRGBColor;

Get[« /setrgb/{colorName} »] = SetRGBColor;

Get[« /goroll/{h}/{s}/{g} »] = Goroll;

Get[« /goroll/{h}/{s}/{g}/{d} »] = GorollWithDelay;

Post[« / »] = _ => « Hello world! »;

}

public string Goroll(dynamic o)

{

int h, s, g;

if (!int.TryParse(o.h, out h)) throw new Exception(« Invalid parameter »);

if (!int.TryParse(o.s, out s)) throw new Exception(« Invalid parameter »);

if (!int.TryParse(o.g, out g)) throw new Exception(« Invalid parameter »);

var programLines = new List<string>();

programLines.Add(« 10 basflg 1\r »);

programLines.Add(string.Format(« 20 goroll {0},{1},{2}\r »,h,s,g));

var area = StorageArea.Temporary;

sphero.EraseOrbBasicStorage(area);

sphero.SendOrbBasicProgram(area, programLines);

sphero.ExecuteOrbBasicProgram(area, 10);

return « OK »;

}

public string GorollWithDelay(dynamic o)

{

int h, s, g, d;

if (!int.TryParse(o.h, out h)) throw new Exception(« Invalid parameter »);

if (!int.TryParse(o.s, out s)) throw new Exception(« Invalid parameter »);

if (!int.TryParse(o.g, out g)) throw new Exception(« Invalid parameter »);

if (!int.TryParse(o.d, out d)) throw new Exception(« Invalid parameter »);

var programLines = new List<string>();

programLines.Add(« 10 basflg 1\r »);

programLines.Add(string.Format(« 20 goroll {0},{1},{2}\r », h, s, g));

programLines.Add(string.Format(« 30 deelay {0}\r », d));

var area = StorageArea.Temporary;

sphero.EraseOrbBasicStorage(area);

sphero.SendOrbBasicProgram(area, programLines);

sphero.ExecuteOrbBasicProgram(area, 10);

return « OK »;

}

public string SetRGBColor(dynamic o)

{

byte r, g, b;

try

{

r = byte.Parse(o.red);

g = byte.Parse(o.green);

b = byte.Parse(o.blue);

}

catch

{

string name = o.colorName;

Color c = Color.FromName(name);

r = c.R;

g = c.G;

b = c.B;

}

sphero.SetRGBLEDOutput(r, g, b);

return « OK »;

}

public string PortFinder(dynamic o)

{

int index = –1;

if (int.TryParse(o.port, out index))

{

if (o.port < 0) return « invalid parameter »;

try

{

sphero = spheroConnector.Connect(index);

return « OK »;

}

catch (Exception ex)

{

return ex.Message;

}

}

else

{

return string.Format(« ‘{0}’ is not a valid device index. », o.port);

}

}

}

}

 

Visual Studio Code

Quel passionné de code Microsoft n’a pas dans des temps reculés rêvé de répondre à un aficionados Java que lui aussi, son code pouvait tourner ailleurs que sur environnement Microsoft ?

Qui se rappelle du début du millénaire où noyer dans du COM on espérait la venu de .NET. Que de chemin parcouru depuis cette époque. La CLI a permis à .NET ne tourner sur d’autres plateformes, comme Linux grâce à Mono.

Et désormais, c’est officiel, le nouveau venu « Visual Studio Code » permettra l’édition de code sous environnement Windows, Linux et également OS X.

Certes, toutes les fonctionnalités de Visual Studio ne seront pas présentes, mais c’est bien une démonstration d’ouverture totale de l’éditeur. L’effet « Azure », où l’on peut choisir son OS, utilisé des outils tiers, y est assurément pour quelque chose.

WinRT ou le retour en force du COM+

Laisser une réponse

J’ai voulu ajouter « Lol » à la fin du titre de ce lien, mais il paraît que ça ne se fait pas.

On retrouve plein d’articles sur le NET nous parlant de WinRT, des incidences lorsqu’on doit développer en C#.
Je vous propose donc ce petit post, non pas pour vous parler de WinRT mais plutôt pour vous parler de COM(+) et vous expliquer ce choix, qui semble hasardeux, de Microsoft.

Tout d’abord, un petit rappel.

Observez le schéma de l’article, il a fait le tour du monde. Avec Windows 8, il y a deux façon de considérer Windows. La première en mode WinRT (partie de gauche), l’autre en mode desktop (partie de droite).

En mode WinRT, on vise un nouveau type d’application dites « Metro style Apps », dénomination valable jusqu’en août 2012 date où l’on appris que le terme était déposé et sujet à copyright. On parle désormais d’application ModernUI (ou Windows 8 style)
En mode Desktop, on développe classiquement, C++, C#, VB.NET, Assembleur

Beaucoup de développeurs .NET ont espéré, comme Java en son époque, que Windows allait devenir « CLR ». En d’autres termes, l’OS serait une grande machine virtuelle, on gagnerait en simplicité tout en se débarrassant de ces bonnes vieilles API Win32.

Mais que faire alors des anciennes applications justement Win32 ? Il aurait suffit de les virtualiser ! On le fait déjà quelque part pour faire fonctionner les applications 32bits (et même 16 bits!) sur du Windows 64 bits (merci WoW64^^). Développer une application tournant dans l’OS/CLR, qui émulerait les API Win32 et ferait fonctionner toute application non .NET dans cette Sandbox ! Simple ,non ?

Oui mais voilà, ce n’est absolument pas ce que Microsoft a fait ! Mais allons donc ? Pourquoi ? C’était si simple !

Disons que ce n’est pas parce qu’une chose a l’air simple en apparence qu’elle l’est dans les fait. Tout d’abord, au risque de passer pour un dinosaure, il faut savoir que depuis fort longtemps tout Windows est COM… ou DCOM… Enfin COM+. De quoi je parle ? Du fait que peut après l’apparition de la base de registre (Windows 95), Microsoft a planché sur des vrais soucis de communication inter logiciel : faire en sorte qu’un copier/coller fonctionne entre un Word et un Excel et mieux, que les logiciels échangent des comportements en temps réel (exporter un tableau Excel dans Word par Exemple). Microsoft a commencé par une technologie type OLE (Object Linking and Embedding) qu’ils ont rapidement muté en composant ActiveX et composant COM : les composants ActiveX étant « visuel » (comme une applet Java), les composants COM étant eux des composants sans interface.

Il faut imaginer dès l’époque que tout était bien pensé. On parlait de composants comme au sens moderne. Car à la différence de l’objet qui tourne dans un processus, le composant a une sorte d’existence propre, des entrées et des sorties (je vous passe les histoires de surrogate chez Microsoft^^). Vous avez bien lu ! J’ai fait un raccourci, mais un objet est une représentation binaire qui n’a de sens que dans son process ! Le composant, lui, existe en dehors !
Pour ces raisons, lorsque vous faites du WCF, vos objets exposés peuvent et même doivent prendre la dénomination de composants. Idem pour COM+, ce bon vieux CORBA (certes, on parle d’IOR pour des références d’objets interopérable à distance, mais la vision externe est un « composant »), CCM (pour ceux qui connaissent) et surtout les EJB !

OLE/COM date des années 1995… Et fut transformé en DCOM vers 1998 (Le D signifiant Distributed), technologie permettant d’appeler les composants COM à partir d’un autre ordinateur puis renommé COM+ dès les années 2000. COM+ est le mix de DCOM et d’une technologie transactionnelle (MTS – Microsoft Transaction Server) développée par Microsoft dans l’optique de concurrencer CORBA et ses service OTS (Object Transaction Service). Il faut imaginer MTS comme le service JTS de JEE, où la partie transactionnelle des EJB stateless (avec un peu de stateful mais avec des limitations beaucoup plus forte), où bien encore du WCF avec des TransactionFlow et autres TransactionScopeRequired configurés.

Quand .NET est apparu, il fut vanté par rapport à COM+ pour sa simplicité. Il ressemblait à Java, finit les DLL Hells (ou l’enfer des DLL car COM+ exigeaient des inscriptions en base de registre, le versioning était très compliqué).

Sauf que COM+, tandis que .NET évoluait, a énormément évolué de son côté… notamment en se débarrassant de l’obligation d’aller en base de registre… mais également en améliorant le versionning, la possibilité de faire du side-by-side, etc.

Le choix de faire du WinRT en « COM-like » est beaucoup plus logique qu’il n’y parait. Contrairement aux apparences, C++ ne peut pas être concurrencé par des technologies à base de VM sur un ordinateur. Tout simplement parce que, même si pour bon nombre de projets de gestion c’est suffisant, la performance ultime ne peut être atteinte qu’en se calant le plus possible à la machine : RAM, disques, processeurs, CPU et registres.
Pour ces raisons, Microsoft a fait évoluer son OS dans le bon sens, le rendant multiplateforme (bienvenue aux processeurs ARM) tout en faisant évoluer C++ !

Mais il ne faut pas se tromper. Quand on cible WinRT en C++, on développe en C++/CX (Component Extensions) comme l’on développait en C++/CLI (Common Language Infrastructure) lorsqu’on ciblait la CLR. Ca c’est la façon qui arrange tout le monde. C++ dans le même sac que C#, VB.NET, Javascript, etc… car c’est juste un autre langage, on ne gagne rien.

Demeure pour le puriste, que l’on peut faire du WRL (Windows Runtime C++ Library) ! WRL c’est l’équivalent d’ATL (Active Template Library) en COM+ ! Débarrassé de pratiquement tout, on attaque les choses sérieuses et on a latitude pour réaliser des appels à l’OS… d’un autre monde 😉

Toutefois, même si je suis un aficionados d’ATL, et donc de WRL, je ne le recommande absolument pas en situation projet, à moins d’y être fortement contraint (pour des raisons de performances notamment, ou bien parce que vous développer un composant hyper technique). Car cela demande énormément de compétence et s’avère très difficile à la maintenance !

Debogage à distance avec VS 2010

Laisser une réponse

Les fonctionnalités de Débogage à distance sont véritablement pratiques pour savoir ce qui se passe sur un poste distant. Microsoft fournit l’installation d’un Remote Debuger (http://www.microsoft.com/downloads/fr-fr/details.aspx?familyid=60ec9d08-439b-4986-ae43-0487eb83c09e), une version « light » de ce que propose Visual Studio, pour permettre de déboguer des machines distantes, notamment des serveurs.

L’installation est on ne peut plus simple; on a le choix d’exécuter le Remote Debugger sous la forme d’un service (tournant sur un compte et pouvant aller jusqu’à accepter tout type d’utilisateur distant. Dans ce dernier mode, on ne peut toutefois que faire du debugage natif) ou sous la forme d’un programme.

Nous conseillons vivement cette dernière option pour du debugage sur des serveurs car cela ne devrait être que très occasionnel.

 

Configuration du Remote Debuger

 

Lors de l’installation/configuration, une seule option est disponible: configurer ou non le Remote Debugger en tant que service. Dans ce mode, le Remote Debugger est toujours actif et accessible à distance.

Le compte par défaut proposé est LocalSystem, ce qui est judicieux mais en même temps très ouvert.

Local System est un compte Built-In donnant des privilèges élevés sur l’ordinateur local et qui permet d’agir sur le réseau comme s’il s’agissait de l’ordinateur lui-même. Il n’y a pas besoin de mot de passe.

Lors de la configuration, il vous est possible de configurer un autre compte mais ses privilèges doivent avoir « Ouvrir une session en tant que service ». Microsoft propose par ailleurs que ce compte soit membre du groupe Administrateurs.

 

Options du Remote Debuger

Lancer le programme manuellement, puis allez dans Options. Le serveur porte un nom de la forme user@machine, plus précisément le user précise un domaine.

En mode Authentification Windows, on peut se permettre n’importe quel type de débugage ; le bouton « Autorisations » permet d’indiquer les comptes ayant le droit de deboguer.

Vous noterez l’option « Aucune authentification (natif uniquement) » et « Permettre à tous les utilisateurs de déboguer » qui permet à n’importe qui se connecter et deboguer, mais des applications natives seulement. Ce mode est à proscrire, d’autant plus que votre machine peut se trouver, pardonnez l’expression, en milieu « hostile » et soumise à attaque (en clair, faîtes cela chez vous, pas dans votre entreprise).

Par ailleurs, comme son nom l’indique, le debogage en mode natif

Classiquement, le compte qui debug sur une machine A en remote sur la machine B doit être le même… si possible. Malheureusement, ce n’est absolument pas le cas si A est dans un domaine et B dans un autre.

 

Debogage en interdomaine

Les choses se compliquent lorsque l’on veut déboguer à distance une machine hébergée dans un différent domaine. Rajoutons une contrainte qui a son importance, lorsque les deux domaines en question ne sont pas approuvés. Ce cas de figure qui peut vous sembler bizarre arrive bien plus fréquemment qu’on ne le croit.

Imaginons un environnement de test ou recette possédant son propre domaine, son propre AD, ses propres contraintes de sécurité ; ceci afin d’éviter tout télescopage possible. Il n’y a aucune raison de faire un domaine de production approuver un domaine de test/recette. Mais il est en revanche possible d’imaginer un développeur sur son réseau de développement (donc un environement réel, d’entreprise) nécessitant un débugage sur le domaine test/recette car un bug ne se produit que dans cet environement. Sans cette capacité de débogage, son bug ne peut être résolu et son application ne vas pas en prod.

Bref, lorsque les domaines ne sont pas approuvés, on peut choisir le débogage natif (non intéressant pour du débogage managé) mais celui-ci exige, pour des actions interdomaines de permettre à tout le monde de pouvoir se connecter à machine créant ainsi un trou de sécurité.

Il existe néanmoins une solution, ou plutôt 2 solutions.

Option 1

La première exige de jouer avec les Local Security Policy (Stratégie de sécurité locale). Dans le panneau de configuration, outils d’administration, si on lance l’application, il nous est possible (pour peu que l’on possède les droits suffisants) de changer la façon dont un compte local s’expose à l’extérieur en terme de sécurité.

Dans la section « Local Policies », « Security Options », changer la clé « Network access: sharing and security model for local accounts » de « Guest only – local users authentivcate as Guest » à « Classic – local users authenticate as themselves ».

En faisant ce réglage, on indique qu’un compte local à la machine sur un réseau se présente en tant que lui-même. Cette option est classique lorsque vous faite un Workgroup de machine et non pas un domaine. Pour permettre à un compte d’accéder à un partage par exemple, il suffit de dupliquer ce compte ; même user, même password; pour que l’accès soit autorisé

Le Remote Debuging exigeant une communication dans les deux sens, il vous faut faire ce réglage sur les 2 machines impliquées dans la communication.

Cette option fonctionne bien mais souffre d’une grosse limitation… On se retrouve à modifier des réglages de sécurité sur les 2 machines impliquées. Lorsque l’une d’en être elle est une serveur, c’est une sacré limitation car on augmente la surface d’attaque. Des problèmes peuvent surgir au niveau partage et DCOM et quelqu’un à distance peut s’authentifier avec votre compte plutôt qu’en Guest. Par ailleurs, il faut se soucier d’avoir un compte en double avec un mot de passe similaire pour que cela fonctionne (on peut faire correspondre un compte de domaine, même user/password, à un compte local).

Option 2

L’option 2 est beacoup plus belle… Et beaucoup plus simple aussi (sauf si l’on se met à déplacer le répertoire utilisateur AppData sur le réseau. Nous préciseronts ce point par la suite).

L’astuce consiste à utiliser une seule et unique commande : un runas ! Mais attention, ce runas est lancé dans un mode spécial.

Pour rappel, le runas permet l’exécution d’un programme sous le compte d’un autre utilisateur. Il suffirait a priori de faire un runas en précisant Visual Studio et banco, le remote debugger et VS 2010 se retrouve dans le même domaine et, comme dirait Dora, c’est gagné !!

Malheureusement, ce n’est pas aussi simple. Si on effectue un runas classique en précisant un user sur un autre domaine, malheureusement l’application que l’on lance va s’exécuter avec un compte… d’un autre domaine… et ceci en local .

Bref, vous l’aurez compris, ce n’est pas possible puisque votre machine locale respectera les contraintes de son propre domaine et n’autorisera pas un compte extérieur d’un autre domaine à lancer un programme sur votre machine.

Nous souhaiterions non seulement pourvoir utiliser notre poste local, dans son domaine et ses crédentials, tout en faisant en sorte que les communications réseaux s’effectuent sous l’identité d’un autre compte.

Si nous vous disions que la commande runas a été modifiée en ce sens par Microsoft en lui attribuant l’option netonly ?

Pour preuve, notez l’appel suivant (ligne de commande) qui permet de lancer Visual Studio sous le compte local de l’utilisateur et qui fait en sorte que les appels réseaux s’effectuent avec un autre compte sous un autre domaine.

 

runas /netonly /user:domain\user « C:\localapp\Apps\Microsoft Visual Studio 10.0\Common7\IDE\devenv.exe »

Le programme vous lancera une invite de commande vous permettant d’indiquer le mot de passe.

Votre Visual Studio va se lancer sous votre propre compte, mais tout appel réseau se déroulera sous le compte/domaine ayant été précisé via la balise netonly.

 

Attention, un bug peut se produire.

Ce bug peut se produire si votre ordinateur local, un ordinateur d’entreprise, a été configuré pour que votre profil soit sauvegardé sur le réseau. Dans ce cas de figure spécifique, Visual Studio se connectera au partage réseau avec le compte fourni par /netonly et pas votre compte de domaine.

Il en résultera l’erreur suivante :

 

Don’t panic… Là aussi il y a une astuce, modifier dans la registry le répertoire AppData

Dans « HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders », il suffit de renseigner un répertoire local temporaire de votre machine. Pensez bien à modifier cette clé de registre après coup….

Pourquoi choisir l’option 2 vis-à-vis de l’option 1 ? Ou l’inverse ?

Parce que vous ne créez pas un deuxième compte et parce que vous ne modifiez pas les stratégies de sécurité locale des machines que vous souhaitez déboguer, l’option 2 est nettement plus intéressante que l’option 1. Une simple ligne de commande…

Toutefois, dans le cas d’un répertoire AppData sauvegardé sur le réseau, c’est une histoire de préférence car les 2 solutions ont leurs inconvénients et avantages. L’option 2 reste locale mais exige des modifications de clé de registre (ce qui est sensible pour un non averti). L’option 1 demande des modifications de part et d’autre, augmente le risque de sécurité, mais aucune action sensible en base de registre n’est requise… A vous de juger.

 

Comment deboguer à distance

Toute les possibilités de debug à distance sont maintenant activées.

Lancez Visual Studio, puis vous pouvez par exemple cliquer sur Debug, puis Attach To Process

 

 

Noter le qualifier. Il correspond au compte et à l’adresse de la machine sur laquelle on souhaite se connecter.

Plus précisément, on notera qu’il s’agit de l’adresse proposée par le msvmon (le remote debugger).