Blog de Matthieu MEZIL » MMCS31

Rappel sur C# 3.0 et limitation sur les collection initializers

Matthieu MEZIL — Wed, 24 Oct 2007 23:28:39 +0000

Partons du code suivant :

public class Point
{
private int _x;
private int _y;

public int X
{
get { return _x; }
set { _x = value; }
}
public int Y
{
get { return _y; }
set { _y = value; }
}
}
public class Rectangle
{
private Point _p1;
private point _p2;

public Point P1
{
get { return _p1; }
set { _p1 = value; }
}
public Point P2
{
get { return _p2; }
set { _p2 = value; }
}
}

En C# 3.0, ce code pourra être réduit à ça :

public class Point
{
public int X { get; set; }
public int Y { get; set; }
}
public class Rectangle
{
public Point P1 { get; set; }
public Point P2 { get; set; }
}

Le code C# 2.0 suivant

Point p1 = new Point();
p1.X = 10;
p1.Y = 10;
Point p2 = new Point();
p2.X = 20;
p2.Y = 20;
Rectangle r = new Rectangle();
r.P1 = p1;
r.P2 = p2;

peut s’écrire en C# 3.0 comme ceci :

Rectangle r = new Rectangle {
P1 = new Point { X = 10, Y = 10 },
P2 = new Point { X = 20, Y = 20 } };

mais également, et c’est encore mieux, comme ceci :

Rectangle r = new Rectangle {
P1 = { X = 10, Y = 10 },
P2 = { X = 20, Y = 20 } };

Ceci est possible grâce aux objects initializers.

Avec C# 3.0, une autre nouveauté est les collections initializers :

Le code suivant, écrit en C# 2.0,

List points = new List();
Point p = new Point();
p.X = 10;
p.Y = 10;
points.Add(p);
p = new Point();
p.X = 20;
p.Y = 20;
points.Add(p);

pourra s’écrire en C# 3.0 comme ceci :

List points = new List() { new Point { X = 10, Y = 10 }, new Point { X = 20, Y = 20 }};

Si on suit la logique des objects initializers, on pourrait envisager d’écrire ceci :

List points = new List() { { X = 10, Y = 10 }, { X = 20, Y = 20 }};

mais non, ça ne marche pas

En réalité, je pense que je sais pourquoi :
Les collections initializers s’appliquent à tous les IEnumerable avec une méthode Add. Quand la méthode Add prend plusieurs paramètres, ceux-ci sont regroupés entre accolades, d’où l’ambigüeté :

Dictionary dico = new Dictionary {{ "key1", "value1" }, { "key2", "value2" }};

Il n’en demeure pas moins que quand j’aurai un peu de temps, j’essaierai de creuser pour MMCS31.

POC de MMCS31 alpha 1

Matthieu MEZIL — Fri, 13 Jul 2007 22:48:29 +0000

Depuis que j’ai blogué sur mon compilateur MMCS31, je n’ai pas eu le temps d’avancer.
Comme le projet CodePlex que j’avais créé pour l’occasion allé mourrir (délai avant publication atteint), j’ai décidé de le publier en l’état.
Avant toute chose, sachez que le but n’est pas d’écrire un compilateur que du reste personne n’utilisera mais de faire une POC. Le code a clairement été écrit à « l’arrache », sans réelle réflexion ni conception et le temps de compilation est catastrophique.
Quand je trouverais un peu de temps, je tacherai d’améliorer tout ça.
Dans tous les cas, cela devrait permettre de donner une première idée aux personnes (promis, c’est au pluriel :D) qui m’ont demandé comment mon compilateur allait fonctionner.
Actuellement, je n’ai traité que partiellement le cas d’extension des Objects Initializers. Autant dire que je suis loin d’avoir terminé !

MMCS31

Matthieu MEZIL — Fri, 15 Jun 2007 22:46:07 +0000

MMCS31 : C’est le nom de mon projet de compilateur sencé simplifier l’écriture du code par rapport à du C# 3.0.
Je sais c’est un peu pourri comme nom mais bon…

J’ai eu quelques retours me demandant de dévoiler comment je m’y étais pris et ce que mon compilateur fera, si tout se passe bien, dans sa version finale.
Tout d’abord, ce compilateur n’est pas un vrai compliateur. Je n’ai pas défini de grammaire ni aucun autre élément essentiel lorsque l’on crée un vrai compilateur.
Pour ma part, mon compilateur fonctionne de la manière suivante :
Il compile le programme avec CodeDom. Il récupère les erreurs eventuelles, analyse le code relatif à l’erreur et essaye de reconnaître avec des Regex mes fonctionnalités. Il traduit ensuite le code puis recompile.

Ce que je veux que mon compilateur fasse :

Etendre les object initializers afin de pouvoir renseigner plusieurs propriétés en une seule instruction n’importe où

class TestObject
{
private TestObject()
{
}
public static TestObject Create()
{
return new TestObject();
}
public int I1 { get; set; }
public string I1S
{
get { return I1.ToString(); }
}
public string S1 { get; set; }
public string S2 { get; set; }
public string S3 { get; set; }
}

En C# 3.0, on ne peut utiliser les object initializers qu’après un new(). Avec mon compilateur vous pouvez faire des choses comme ça :

var test = TestObject.Create() : { S1 = "S1", S2 = "S2", S3 = "S3" };
test : { S1 = "S1Bis", S2 = "S2Bis" };
for (int i = 0 ; i < 10 ; i ++)
Console.WriteLine(TestObject.Create() : { I1 = i }.I1S);

Ce code sera traduit par :

var test = TestObject.Create();
test.S1 = "S1";
test.S2 = "S2";
test.S3 = "S3";
test.S1 = "S1Bis";
test.S2 = "S2Bis";
for (int i = 0 ; i < 10 ; i ++)
{
var mmCS311 = TestObject.Create();
mmCS311.I1 = i;
Console.WriteLine(mmCS311.I1S);
}

Etendre les collection initializers afin de pouvoir initialiser les éléments de la collection même si celle-ci est en lecture seule

Soit la classe Class1 :

class Class1
{
public List Test { get; set; }
}

En C# 3.0, on peut faire ça :

var test = new Class1();
test.Test = new List { "un", "deux" };

En revanche, soit la classe Class2 :

class Class2
{
public List Test { get; private set; }
}

En C# 3.0, impossible d’initialiser la liste.

Avec mon compilateur, vous pourrez faire ceci :

var test = new Class2();
test.Test : { "un", "deux" };

qui sera traduit par :

var test = new Class2();
test.Add("un");
test.Add("deux");

Permettre l’ajout d’éléments à un IEnumerable avec un Add via un simple +

Vous pourrez faire ça :

int[] ints = { 1, 2, 3 };
ints = ints + { 4, 5, 6 };
ints += { 7, 8, 9 };
ints += 10;

Quand le type est connu pouvoir, sans passer dans le new

var c = new Class1(); // C# 3.0
// [...]
c = new(); // MMCS31

Vous pourrez également faire sur tous les IEnumerable avec un Add comme pour les tableaux depuis C# 2.0 (voire même avant) :

List test = { "un", "deux" } // Plus court que var test = new List { « un », « deux » };

Quand le type peut être déduit des paramètres, pouvoir sans passer dans l’appel d’une méthode

Soient les classes C1, C2 et C3 :

public class C1
{
public string S1 { get; set; }
}
public class C2
{
public string S2 { get; set; }
}
public class C3
{
public int S1 { get; set; }
}

Soient les méthodes M :

public void M(C1 c1)
{
}
public void M(C2 c2)
{
}
public void M(C3 c3)
{
}

Mon compilateur permettra l’écriture suivante :

M( { S1 = "S1" } );

qui sera traduit par :

M( new C1 { S1 = "S1" } );

Gérer le Optional comme en VB

break * n
Quand on a des boucles imbriquées, on veut parfois en quitter deux d’un coup.
Pour cela, on fait des choses comme ça si on ne veut pas utiliser de goto :

for (...)
{
bool doBreak = false;
for (...)
{
[...]
doBreak = true;
break;
}
if (doBreak)
break;
}

Mon compilateut devra faire la même chose de la façon suivante :

for (...)
{
for (...)
{
[...]
break * 2;
}
}

Voici pour l’instant mon objectif. Comme vous pouvez le voir il y a pas mal de boulot mais si vous avez d’autres idées, n’hésitez surtout pas.

Quand j’aurais fini tout ça, le step suivant consistera a l’intégrer dans Orcas pour la compilation mais aussi et surtout dans l’intellisence.

Que manque-t-il à C# 3.0 ?

Matthieu MEZIL — Fri, 15 Jun 2007 00:55:50 +0000

Je suis en train de développer un compilo qui rajoute des facilités d’écriture à C# 3.0 en traduisant le code en C#3.0 puis en compilant avec CodeDom le code ainsi généré. Je vais bientôt ouvrir un nouveau projet CodePlex. La première fonctionnalité que j’ai rajouté est la possibilité d’utiliser les Object Initializer ailleurs qu’après un new. En effet, je trouve cela assez limité. Par exemple, impossible d’initialiser en une seule instruction les propriétés d’un objet créer via une Factory ni d’initialiser plusieurs propriétés d’un objet en une seule instruction. Mon compilateur C# 3.1, comme je m’amuse à appeler ce langage même si je trouve cela un peu (trop) prétentieux, fait ça.

J’ai plusieurs autres idées mais avant de continuer, je lance un petit sondage : que manque-t-il à C# 3.0 ?

Merci d’avance pour vos réponses.