C#

Interview d’Antoine Cote, responsable du développement du designer de DLinq

Mitsu Furuta — Fri, 13 Oct 2006 22:48:00 GMT

J'ai eu la chance et l'honneur lors de mon dernier passage à Redmond de faire une rencontre très intéressante.
Antoine Cote est responsable du développemet du designer de DLinq. Cerise sur le gateau, l'interview est en français puisqu'Antoine est...Québéquois !
Le designer de DLinq offre une fonctionnalité décisive dans la productivité qu'apportera DLinq.

Bonne lecture à tous,

Mitsu

http://www.microsoft.com/france/vision/db/msdn/P00974/

Liste des bloggers de l'équipe C#

Mitsu Furuta — Thu, 12 Oct 2006 20:34:00 GMT

Charlie Calvert a intégré l'équipe C# à Redmond et gère désormais les relations avec les communautés.
Voici la liste des blogs des équipes C# qu'il maintient sur son blog: http://blogs.msdn.com/charlie/archive/2006/09/06/c-bloggers.aspx

A retenir pour tous les curieux des avancées de C# et de Linq

Mitsu

[Article] C# 2.0, un an après: un avant gout avant les webcasts

Mitsu Furuta — Sat, 30 Sep 2006 21:41:00 GMT

Bonjour à tous,

Le mercredi du développement sur C# 2.0 s'est bien déroulé mercredi dernier et les webcasts sont en cours de mise en ligne (ce qui devrait prendre une dizaine de jours car nous avons quelques problèmes techniques).
Pour nous faire pardonner et vous faire patienter, je vous propose deux petits extraits dans ce post.

Bonne lecture et donc à très bientôt pour les webcasts dont j'annoncerai la disponibilité sur ce même blog.

Mitsu

1- Factoriser des instructions de bloc.

L'idée est la suivante, imaginons que nous voulions factoriser une gestion d'erreur pour toute notre application avec un traitement d'erreur centralisé. Dans bon nombre de cas existants (comme les apis win32), un modèle classique consiste à implémenter des méthodes qui renvoient un entier. Il devient alors assez simple de créer une méthode ShowError(int errorCode) qui centralise la gestion d'erreur. Ce modèle impose la convention qui consiste à renvoyer un entier et ne factorise pas le try...catch que nous devons implémenter dans toutes les méthodes.

private int AddCustomer(string param)
{
try
{
int i = Convert.ToInt32(param);
}
catch
{
return 1;
}
return 0;
}

private void ShowError(int value)
{
if (value != 0)
    switch (value)
    {
      case 1:
      case 2:
      default:
        MessageBox.Show("Une erreur s'est produite: n°" + value.ToString());
        break;
    }
}

L'appel ressemble alors à:

ShowError(AddCustomer("blabla"));

L'idée en C# 2.0 est d'utiliser les méthodes anonymes pour retarder l'exécution du code critique afin de prendre le temps d'encadrer l'appel par un bloc try...catch. Nous aurons besoin d'un délégué le plus simple possible afin d'être générique. Le code des méthodes anonymes ayant accès aux membres accessibles depuis la méthode hôte, nous de déclarerons aucun paramètre.

public delegate void SimpleDelegate();

Nous pouvons alors implémenter une unique méthode de gestion des exceptions incluant le bloc try...catch.

private void SafeCall(SimpleDelegate d)
{
try
{
    if (d != null)
      d();
}
catch (Exception e)
{
    MessageBox.Show("Une erreur s'est produite:" + e.Message);
}
}

L'appel devient alors très simple:

string s = "blabla";
SafeCall(delegate
{
int i = Convert.ToInt32(s);
});

Nous pouvons également imaginer utiliser ce même pattern pour centraliser les transactions.

InTransaction(delegate
{
AddCustomer();
});

1- Enumerer des énumérations ..?!?!

Les types enum de .Net permettent de stocker un ensemble de valeurs en utilisant la vue binaire de l'entier sousjacent de l'énumération.
Ce pattern est très connu et est largement utilisé à la fois dans le framework .Net et dans l'api win32.

Exemple:

[Flags]
public enum Day { None = 0, Lundi = 1, Mardi = 2, Mercredi = 4, Jeudi = 8, Vendredi = 16, Samedi = 32, Dimanche = 64 };

Récupérer la liste des valeurs stockées dans l'énuméré demande donc un parcours binaire de l'ensemble des bits en utilisant un 'et' binaire (&) pour tester les différentes valeurs.
L'idée est alors d'accèder à cette liste de valeurs via une énumération (IEnumerable). Nous utiliserons les itérations de C# 2.0 pour faciliter cette implémentation (yield return).

private IEnumerable<T> GetEnumeration<T>(T values) where T : struct
{
if (!typeof(T).IsSubclassOf(typeof(Enum)))
    throw new Exception("n'est pas un Enum");
int[] allValues = (int[])Enum.GetValues(typeof(T));
int intValues = Convert.ToInt32(values);
foreach (int i in allValues)
{
    if ((i & intValues) != 0)
      yield return (T)Enum.ToObject(typeof(T), i);
}
}

L'appel devient alors:

Day d = Day.Samedi | Day.Jeudi;
foreach (Day d2 in GetEnumeration<Day>(d))...

Essayons d'implémenter cette fonctionnalité de façon plus intégré. Nous pouvons utiliser le pattern des nullables.

public struct MyEnum<T> : IEnumerable<T> where T : struct
{
public MyEnum(T value)
{
    _value = value;
}
private T _value;
public static implicit operator T(MyEnum<T> e)
{
    return e._value;
}
public static implicit operator MyEnum<T>(T e)
{
    return new MyEnum<T>(e);
}
public static MyEnum<T> FromEnumerable(IEnumerable<T> e)
{
    int value = 0;
    foreach (T t in e)
    {
      value |= Convert.ToInt32(t);
    }
    return (T)Enum.ToObject(typeof(T), value);
}

#region IEnumerable<T> Members
IEnumerator<T> IEnumerable<T>.GetEnumerator()
{
    if (!typeof(T).IsSubclassOf(typeof(Enum)))
      throw new Exception("n'est pas un enum");
    int[] allValues = (int[])Enum.GetValues(typeof(T));
    int intValues = Convert.ToInt32(_value);
    foreach (int i in allValues)
    {
      if ((i & intValues) != 0)
        yield return (T)Enum.ToObject(typeof(T), i);
    }
}
#endregion

#region IEnumerable Members
IEnumerator IEnumerable.GetEnumerator()
{
return (this as IEnumerable<T>).GetEnumerator() as IEnumerator;
}
#endregion

public override string ToString()
{
return _value.ToString();
}
}

L'utilisation est alors fortement simplifiée:

MyEnum<Day> d = Day.Samedi | Day.Jeudi;

foreach (Day d2 in d) ...

Day d3 = d;

L'énumération ainsi crée profitera des fonctions ensemblistes de C# 3.0:

d.Intersect(d2);

Mercredi du développement: C# 2.0, un an après...

Mitsu Furuta — Wed, 13 Sep 2006 17:05:00 GMT

Vous n'avez pas rêvé et je ne me suis pas non plus trompé dans le titre.
Bien qu'ayant hésité avec "C# 2.0, trucs et astuces" ou encore "Tout ce que vous avez toujours voulu savoir sur C# 2.0", nous parlerons bien de la version 2.0 de ce langage.
Je voulais répondre à plusieurs demandes de contenu sur les versions actuelles de nos produits et pas toujours sur les versions futures.
Je vous propose donc de venir partager à la fois un appronfondissement de C# 2.0 mais également des cas d'utilisation du quotidien que j'ai pu rencontrer après un an de développement.

Utilisateur de C# 2.0 de la première heure ou non, cette présentation est pour vous. Generics, Nullables ou autres méthodes anonymes seront au programme dans des présentations inédites qui je pense vous surprendront.

En guise de conclusion, je finirai par quelques démonstrations C# 3.0.

En espérant vous voir nombreux,

Mitsu

Inscription: http://www.microsoft.com/france/events/event.aspx?EventID=1032309328

Sondage: quels sujets pour les mercredis du développement de l'année prochaine ?

Mitsu Furuta — Wed, 05 Jul 2006 00:12:00 GMT

Bonjour à tous,

Aujourd’hui a lieu le dernier mercredi du développement avant l’été. Nous avons depuis le mois de septembre, balayé un nombre important de domaines qui je l’espère vous ont apporté une meilleur connaissance de la plateforme .Net.

Encore et toujours cette plate-forme évolue afin de vous permettre d’appréhender au mieux les défis de l’informatique de demain.

Nous sommes actuellement en phase de planification des mercredis du développement de l’année prochaine et j’aimerai tout simplement recueillir vos avis et vos souhaits quant aux thèmes que vous aimeriez voir traités.

Il y aura bien évidemment un axe Windows Vista/Office 2007 très important ainsi que bien sûr, l’ensemble des composants du .NET Framework 3.0 (anciennement WinFx).

Toutes vos idées, mêmes les plus farfelues sont les bienvenues. Je vous propose de répondre directement en commentaire de ce post.

A vous de jouer,

Cordialement,

Mitsu

DLinq, VB.NET rentre dans le rang

Mitsu Furuta — Wed, 14 Jun 2006 20:36:00 GMT

Petite modification m’ayant échappé dans les CTP de mai de DLinq : nous sommes revenu à une syntaxe avec le « from » avant le « select » tellement l’ancienne n’avait pas de sens par rapport à la philosophie de Linq.

Public Sub DLinq1()

Dim q = From c In db.Customers _

Where c.City = "London" _

Select c

ObjectDumper.Write(q)

End Sub

Encore une fois cette syntaxe est celle de l’appel des méthodes par le compilateur. En effet la projection se fait toujours en dernier.

Je suis en train d’écrire un exemple appliquant Linq à un serveur FTP et je réalise combien l’équipe VB.NET avait dû galérer pour inverser l’ordre.

Les choses sont donc rentrées dans l’ordre pour le bien de l’unification J.

A plus pour de nouvelles news,

Mitsu

News from Redmond

Mitsu Furuta — Fri, 09 Jun 2006 20:03:00 GMT

...and from me.

Bonjour à tous, juste un petit coucou pour vous tenir au courant de mon activité un peu particulière durant tout ce mois de juin. Je profite en effet d'un programme d'échange avec Microsoft Corp. Je suis aimablement reçu dans l'équipe C# dirigée par Scott Wiltamuth. Quant à mon travail de tous les jours, je suis rattaché à l'équipe Linq et plus précisément au projet DLinq. J'ai récemment organisé un mercredi du développement sur ce sujet dont le contenu est en ligne ici.

Durant ce mois, je vais développer quelques exemples pour le projet Linq (nottamment un exemple WPF, ainsi que quelques autres surprises) et je participe aux réunions de design du projet. Les enjeux de l'accès aux données sont multiples et complexes (génération de sql, entitées intégrables dans des architectures multi-tiers, databinding, designers, etc).

Après quelques discussions, je me suis également lancé dans deux études qui posent problème aujourd'hui: le binding sur des collections hétérogènes que supporte DLinq depuis peu et la gestion des listes virtuelles (comme la ListBox de WPF ou le ListView des Windows Forms) dont la connexion aux objets DLinq est loin d'être naturelle.

Cette phase est très intéressante car les choses ne sont pas encore figées. D'ici deux ou trois mois, la machine de production d'Orcas (prochain Visual Studio) va resserer les plannings et les modifications de fonds seront de plus en plus difficiles.

A bientôt pour de nouvelles news,

Mitsu

Les webcasts du mercredi du développement sur Linq sont en ligne !

Mitsu Furuta — Mon, 22 May 2006 19:42:00 GMT

Bonjour à tous,

Des vidéos que je conseille à tout ceux qui veulent connaître et comprendre le futur de l'accès aux données depuis la plate-forme .Net. Toutes les présentations ont été faites avec la nouvelle version du projet Linq (CTP de Mai 2006), y compris le nouveau designer de classe de mapping objet-relationnel dont vous trouverez une démo dans la partie DLinq.

C#3 et le projet Linq - partie 1 : Introduction

Les langages objet ont atteint une maturité reconnue dans les entreprises mais le probléme de l'accés aux données (relationnelles, xml ou autres) reste entier.
Découvrez comment le projet Linq offre une solution en se basant sur les toutes nouvelles évolutions du langage C#.

C#3 et le projet Linq - partie 2 : Rappels sur le framework .NET 2.0

Utiliser Linq est simple, c'est même là toute l'orientation de ce produit.
Comprendre le fonctionnement de Linq est plus complexe et vous demandera de bien comprendre les nouveautés de C#3 dont un grand nombre sont des évolutions des nouveautés de C#2.

Je vous propose donc un petit rappel sur les énumerations, le mot clé "return yield" ainsi que les classes génériques que Linq exploite à outrance.

C#3 et le projet Linq - partie 3 : Linq, le langage de manipulation des données

Découvrez la syntaxe et les possibilités de Linq dans de premiers exemples simples.

C#3 et le projet Linq - partie 4 : les nouveautés de C#3

Comprendre comment fonctionne Linq vous demandera une première compréhension des nouveautés de C#3.
Cette partie a pour but de démystifier ces nouveautés afin d'en apporter une explication claire.

C#3 et le projet Linq - partie 5 : la librairie XLinq

XLinq apporte, via de nouvelles librairies, des classes d'accès aux Xml révolutionnaires par rapport aux techniques actuelles.
Ce modèle a bien évidemment été conçu pour pleinement profiter des bénéfices de Linq.

C#3 et le projet Linq - partie 6 : la librairie DLinq

DLinq est une partie très attendue du projet Linq. L'accès aux données relationnelles est une problèmatique de tous les jours pour le développeur et DLinq apporte un nouveau moteur de requêtage en langage .Net et non plus en SQL, vérifiable à la compilation ainsi qu'un ensemble de librairies permettant le fameux mapping objet-relationnel.

Bonne lecture à tous,

Mitsu

La nouvelle technical preview de Linq (CTP may 2006) est disponible !!!

Mitsu Furuta — Wed, 10 May 2006 09:49:00 GMT

http://msdn.microsoft.com/data/ref/linq/

IQueryable, nouveaux designers DLinq, visualiseurs d'expressions en débogage et plein de nouveautés très intéressantes.

Pour rappel, le mercredi du développement sur Linq...c'est cet après-midi !

Mitsu

Mercredi du développement Linq et C#3, quand le langage rejoint les données...

Mitsu Furuta — Thu, 27 Apr 2006 11:06:00 GMT

Bonjour à tous,

J'ai le plaisir de vous convier mercredi 10 mai à une session des mercredis du développement spécialement dédiée à Linq. En quelques mots, comment unifier les méthodes de requête quelques que soient les sources de données.
L'enjeu est d'enrichir mais également de simplifier les domaines tels que le mapping objet-relationnel en profitant de l'évolutions des langages .Net plutôt que de frameworks complexes.

Pour rappel, un article que j'ai écrit il y a déjà quelques mois pour vous familiariser avec C#3: http://www.techheadbrothers.com/DesktopDefault.aspx?tabindex=1&tabid=7&AId=119

Bien évidemment, le lien d'inscription:
http://www.microsoft.com/france/events/event.aspx?EventID=1032296819

A bientôt en vous espérant nombreux,

Mitsu