Pourquoi la construction with () n'est-elle pas incluse dans C #, alors que c'est vraiment cool dans VB.NET?

Question

Je suis développeur C #. J'aime vraiment l'accolade parce que je viens de C, C ++ et de Java. Cependant, j'aime aussi les autres langages de programmation de la famille .NET tels que VB.NET. Basculer entre C # et VB.NET n’est pas vraiment une grosse affaire si vous programmez depuis longtemps avec .NET. C'est une approche très courante dans l'entreprise où je travaille. En tant que gars C #, j'aime beaucoup les mots-clés XML littéral et avec fournis par le compilateur VB.NET. J'aurais aimé que Microsoft ait également inclus ces fonctionnalités en C #.

Je suis simplement curieux de savoir ce qu'un autre développeur a à dire à ce sujet!

Answer 1

Je ne serais pas surpris si vous utilisez "Avec". ou une fonctionnalité similaire est ajoutée à C #, éventuellement avec d'autres fonctionnalités exclusivement populaires jusqu'alors populaires. Il y a eu beaucoup de discussions récemment dans les présentations de présentation du C # 4.0 à PDC et ailleurs sur l'augmentation du "focus sur la parité linguistique". en commençant par C # 4.0 et VB 10.

Answer 2

Personnellement, je n'aime pas WITH lorsqu'il est utilisé après la construction. Si vous devez effectuer plusieurs opérations avec un objet après son initialisation, ce comportement doit généralement être encapsulé dans le type lui-même. Si vous voulez vraiment faire quelque chose comme WITH, il suffit de déclarer une variable courte et éventuellement d’introduire une nouvelle portée.

Cependant, il est utile de pouvoir initialiser de manière compacte un objet avec plusieurs propriétés - c’est précisément pourquoi C # 3 vous permet d’écrire:

MyObject x = new MyObject { Name="Fred", Age=20, Salary=15000 };

Il existe des limites à cela (que les paramètres facultatifs et nommés de C # 4 aideront à surmonter), mais elles sont meilleures qu’elles ne l’étaient sans que cela ne conduise à des gâchis / ambiguïtés potentiels.

(Sur le plan littéral XML, je suis de nouveau membre de l'équipe C # - XML ??est une technologie très spécifique à mettre dans un langage. S'ils pouvaient créer un formulaire généralisé , ce qui est arrivé créer XML mais pourrait également être utilisé pour créer d'autres arbres, ce qui serait bien - de même que les expressions de requête ne sont pas directement liées à IEnumerable ou IQueryable.)

Answer 3

Vous pouvez remplacer le de VB.Net par en créant un nom de variable rapide à une lettre. C'est en fait moins de code, car With nécessite également un End With plus tard.

Par exemple, une chose que j’avais l'habitude de faire assez souvent était de parcourir les lignes d'un datatable pour un rapport de style contrôle / pause.

Dans vb.net, cela pourrait ressembler à ceci:

Dim CurCustomerName As String 
Dim CustomerSalesTotal As Decimal

Dim ds As DataSet = GetReportData()
With ds.Tables(0).Rows
   Dim i As Integer = 0
   While i < .Count
       ''//{
       CurCustomerName = .Item(i)("CustName")
       CustomerSalesTotal = 0
       PrintHeaderLine(CurCustomerName)

       While i < .Count AndAlso CurCustomerName = .Item(i)("CustName")
            ''//{
            PrintItemLine(.Item(i)("OrderTotal"))
            CustomerSalesTotal += .Item(i)("OrderTotal")

            i+= 1
       End While ''//}
       PrintSubTotalLine(CustomerSalesTotal)
   End While ''//}
End With

Le C # ressemblerait à ceci:

string CurCustomerName;
Decimal CustomerSalesTotal;

DataSet ds = GetReportData();
DataRowCollection r = ds.Tables[0].Rows;
int i=0;
while (i<r.Count)
{
    CurCustomerName = r[i]["CustName"];
    CustomerSalesTotal = 0;
    PrintHeaderLine(CurCustomerName);

    while (i<r.Count && CurCustomerName == r[i]["CustName"])
    {
        PrintItemLine(r[i]["OrderTotal"]);
        CustomerSalesTotal += r[i]["OrderTotal"];

        i++;
    }
    PrintSubTotalLine(CustomerSalesTotal);
}

Ce qu'il faut remarquer ici, c'est que la version C # avait besoin de moins de dactylographie, car le VB ne pouvait pas combiner WITH avec l'index du tableau et devait passer par le .Item propriété pour certaines choses. Ce n’est pas une grosse affaire ici, mais imaginez si le rapport avait 20 champs au lieu de 2 et devait casser 3 articles au lieu de 1.

Bien sûr, vous pouvez également utiliser la technique présentée en C # pour VB. Mais l’essentiel à noter est que WITH ne vous rapporte pas grand chose.

Answer 4

Cela concerne les préférences des développeurs, mais je suis avec vous à propos de WITH. Ma préférence est de minimiser le nombre de variables en jeu et la portée de leur vie. La philosophie de C # semble être sensiblement la même. Mais dans ce cas, les réponses semblent suggérer que l’ajout (et la responsabilisation) d’une variable est une bonne chose par rapport à une construction qui, pour moi, est très similaire à lambdas.

Answer 5

Je pense qu'il est plutôt arbitraire de n'autoriser que le paramétrage de la propriété 'masse' lors de l'initialisation. Je ne comprends vraiment pas pourquoi ce serait «mauvais»:

MyObj myObj = ObjFactoryFunction();

...

if(someCondition)
  myObj { Prop1 = 1, Prop2 = 2 };

Je pense que cet exemple de code est propre et concis.

Answer 6

Habituellement, lorsque je vois une demande de fonctionnalité avec en C #, je vois du code susceptible de bénéficier d'un refactoring. Habituellement, lorsque le refactoring est terminé, le besoin supposé de avec a disparu.

J'aime la manière dont mon code fonctionne lorsque je construis une interface fluide dans un objet. il présente certaines similitudes avec avec . Si je concevais MessageBox.Show () , je pourrais écrire:

new MessageBox()
    .SetText("Hello World!")
    .SetButtons(MessageBox.Buttons.OK)
    .SetIcon(MessageBox.Icon.Information)
    .Show();

Vous pouvez également voir quelque chose de similaire avec Linq:

var q = Enumerable.Range(1, 100)
            .Where(x => x % 2 == 0)
            .Select(x => x * x);

Cela ressemble un peu à avec mais semble correspondre naturellement au langage que je connais déjà.