Olivier Dahan

MVP Windows Platform Development 2015
MVP Client Development 2014
MVP Silverlight 2013, 2012, 2011,
MVP CAD 2010, MVP C# 2009


Membre du Developer Guidance Advisory Council Microsoft

Audit, Conseil, Formation, Développement
[WPF, WinRT, Xamarin Android]

Historique

Se préparer pour WIndows 10

Une conférence en ligne gratuite proposée par les MVPs pour tout savoir sur le développement sous Windows 10 le 10 juin en français, inscription gratuite, dépêchez-vous !More...

C# Quick Tip

Vite fait, un peu de C# et un rappel sur la façon d’écrire du code de type “inline” ou de recréer les sous-fonctions du Pascal qui n’existent pas.More...

Windows 10, le dernier Windows selon Microsoft

Jerry Nixon, évangéliste bien connu outre atlantique a confirmé la rumeur “Windows 10 sera le dernier Windows”… Que faut-il entendre par là ?More...

Unity Game: la solution de dev de jeux cross-plateforme de MS

Create-a-Windows-8-1-Game-in-Unity-and-Win-50-000-36-500-Euros-443408-2Décidemment Microsoft fait très fort ces derniers temps, comme quoi l’échec à du bon : n’arrivant pas à être seuls les maitres du jeu, ils proposent un ensemble cross-plateforme pour concevoir des jeux pour 21 cibles différentes !More...

“Microsoft Awakens !” Enfin, le téléphone devient un PC

Enfin, ou presque enfin, le téléphone devient un PC ! Depuis des années que cette idée couve sur le feu il était temps qu’elle prenne corps. Et encore une fois c’est Microsoft qui propose la solution la plus cohérente…More...

Windows Phone, Android et iOS & Injection de dépendances et conteneurs IoC

L’injection de dépendances et les conteneurs IoC (inversion de contrôle) qu’est-ce que cela a à voir avec les trois OS cités ? Xamarin. Et au-delà les Xamarin.Forms. Mais encore plus les Xamarin.Forms.Labs ! Comment tout cela est-il lié ? Lisez la suite ! More...

Soignez votre service !

butler-159811_640Les services sous Windows sont d’une grande utilité et sont bien plus élégants que tous ces exécutables qu’on place dans le démarrage de l’OS pour jouer en fait le même rôle. Mais le debug d’un service est si pénible… une vraie plaie ! Ou pas… Regardons comment en faire un vrai bonheur !More...

Entity Framework : Load et AsNoTracking

entity_image

Entity Framework est d’une grande richesse et depuis un moment déjà elle est une technologie mature et efficace. Ce qui ne l’empêche pas d’évoluer, mais souvent quand on connait bien une techno on loupe les nouveautés qui deviennent des vieilleries entre temps... C’est le cas de deux ajouts à EF 4.1 qui valent pourtant le détour…More...

C# 6.0 – les “Expression-bodied function members”

Encore une nouveauté qui va faciliter l’écriture du code… Sous ce nom un peu complexe d’Expression-bodied function members se cache quelque chose d’assez simple mais de très puissant…More...

C# 6.0 – Tester le null plus facilement

La série des mini-tips sur les nouveautés de C# 6.0 continue. Aujourd’hui testons plus facilement les nulls pour l’écriture d’un code plus clair… More...

smallest" title="Tag: wp8">wp8</a> </li><li><a href="/Blog/?tag=/wpf" class="medium" title="Tag: wpf">wpf</a> </li><li><a href="/Blog/?tag=/Xamarin" class="smallest" title="Tag: Xamarin">Xamarin</a> </li><li><a href="/Blog/?tag=/XamarinForms" class="smallest" title="Tag: Xamarin.Forms">Xamarin.Forms</a> </li><li><a href="/Blog/?tag=/xaml" class="small" title="Tag: xaml">xaml</a> </li></ul></div></div><div class="widget monthlist" id="widgetab2b8c27-02c4-46ab-a78f-28939c2a1a09"><h4>Historique</h4><div class="content"><ul id="monthList">
  <li class="year" onclick="BlogEngine.toggleMonth(&#39;year2015&#39;)">2015<ul id="year2015" class="open">
    <li><a href="/Blog/2015/05/default.aspx">mai</a> (4)</li><li><a href="/Blog/2015/04/default.aspx">avril</a> (2)</li><li><a href="/Blog/2015/03/default.aspx">mars</a> (6)</li><li><a href="/Blog/2015/02/default.aspx">février</a> (3)</li><li><a href="/Blog/2015/01/default.aspx">janvier</a> (7)</li>
  </ul></li><li class="year" onclick="BlogEngine.toggleMonth(&#39;year2014&#39;)">2014<ul id="year2014">
    <li><a href="/Blog/2014/12/default.aspx">décembre</a> (1)</li><li><a href="/Blog/2014/11/default.aspx">novembre</a> (1)</li><li><a href="/Blog/2014/10/default.aspx">octobre</a> (2)</li><li><a href="/Blog/2014/09/default.aspx">septembre</a> (11)</li><li><a href="/Blog/2014/08/default.aspx">août</a> (5)</li><li><a href="/Blog/2014/07/default.aspx">juillet</a> (20)</li><li><a href="/Blog/2014/06/default.aspx">juin</a> (7)</li><li><a href="/Blog/2014/05/default.aspx">mai</a> (5)</li><li><a href="/Blog/2014/04/default.aspx">avril</a> (7)</li><li><a href="/Blog/2014/03/default.aspx">mars</a> (4)</li><li><a href="/Blog/2014/02/default.aspx">février</a> (6)</li><li><a href="/Blog/2014/01/default.aspx">janvier</a> (6)</li>
  </ul></li><li class="year" onclick="BlogEngine.toggleMonth(&#39;year2013&#39;)">2013<ul id="year2013">
    <li><a href="/Blog/2013/12/default.aspx">décembre</a> (3)</li><li><a href="/Blog/2013/11/default.aspx">novembre</a> (3)</li><li><a href="/Blog/2013/10/default.aspx">octobre</a> (9)</li><li><a href="/Blog/2013/09/default.aspx">septembre</a> (16)</li><li><a href="/Blog/2013/08/default.aspx">août</a> (9)</li><li><a href="/Blog/2013/07/default.aspx">juillet</a> (10)</li><li><a href="/Blog/2013/06/default.aspx">juin</a> (8)</li><li><a href="/Blog/2013/05/default.aspx">mai</a> (8)</li><li><a href="/Blog/2013/04/default.aspx">avril</a> (10)</li><li><a href="/Blog/2013/03/default.aspx">mars</a> (3)</li><li><a href="/Blog/2013/02/default.aspx">février</a> (6)</li><li><a href="/Blog/2013/01/default.aspx">janvier</a> (8)</li>
  </ul></li><li class="year" onclick="BlogEngine.toggleMonth(&#39;year2012&#39;)">2012<ul id="year2012">
    <li><a href="/Blog/2012/12/default.aspx">décembre</a> (14)</li><li><a href="/Blog/2012/11/default.aspx">novembre</a> (12)</li><li><a href="/Blog/2012/10/default.aspx">octobre</a> (20)</li><li><a href="/Blog/2012/09/default.aspx">septembre</a> (10)</li><li><a href="/Blog/2012/08/default.aspx">août</a> (22)</li><li><a href="/Blog/2012/07/default.aspx">juillet</a> (9)</li><li><a href="/Blog/2012/06/default.aspx">juin</a> (9)</li><li><a href="/Blog/2012/05/default.aspx">mai</a> (7)</li><li><a href="/Blog/2012/04/default.aspx">avril</a> (3)</li><li><a href="/Blog/2012/03/default.aspx">mars</a> (5)</li><li><a href="/Blog/2012/02/default.aspx">février</a> (2)</li><li><a href="/Blog/2012/01/default.aspx">janvier</a> (4)</li>
  </ul></li><li class="year" onclick="BlogEngine.toggleMonth(&#39;year2011&#39;)">2011<ul id="year2011">
    <li><a href="/Blog/2011/12/default.aspx">décembre</a> (3)</li><li><a href="/Blog/2011/11/default.aspx">novembre</a> (6)</li><li><a href="/Blog/2011/10/default.aspx">octobre</a> (2)</li><li><a href="/Blog/2011/09/default.aspx">septembre</a> (9)</li><li><a href="/Blog/2011/08/default.aspx">août</a> (5)</li><li><a href="/Blog/2011/07/default.aspx">juillet</a> (4)</li><li><a href="/Blog/2011/06/default.aspx">juin</a> (15)</li><li><a href="/Blog/2011/05/default.aspx">mai</a> (5)</li><li><a href="/Blog/2011/04/default.aspx">avril</a> (9)</li><li><a href="/Blog/2011/03/default.aspx">mars</a> (6)</li><li><a href="/Blog/2011/02/default.aspx">février</a> (11)</li><li><a href="/Blog/2011/01/default.aspx">janvier</a> (12)</li>
  </ul></li><li class="year" onclick="BlogEngine.toggleMonth(&#39;year2010&#39;)">2010<ul id="year2010">
    <li><a href="/Blog/2010/12/default.aspx">décembre</a> (5)</li><li><a href="/Blog/2010/11/default.aspx">novembre</a> (2)</li><li><a href="/Blog/2010/10/default.aspx">octobre</a> (1)</li><li><a href="/Blog/2010/09/default.aspx">septembre</a> (13)</li><li><a href="/Blog/2010/08/default.aspx">août</a> (2)</li><li><a href="/Blog/2010/07/default.aspx">juillet</a> (21)</li><li><a href="/Blog/2010/06/default.aspx">juin</a> (21)</li><li><a href="/Blog/2010/05/default.aspx">mai</a> (22)</li><li><a href="/Blog/2010/04/default.aspx">avril</a> (11)</li><li><a href="/Blog/2010/03/default.aspx">mars</a> (4)</li><li><a href="/Blog/2010/02/default.aspx">février</a> (5)</li><li><a href="/Blog/2010/01/default.aspx">janvier</a> (7)</li>
  </ul></li><li class="year" onclick="BlogEngine.toggleMonth(&#39;year2009&#39;)">2009<ul id="year2009">
    <li><a href="/Blog/2009/12/default.aspx">décembre</a> (5)</li><li><a href="/Blog/2009/11/default.aspx">novembre</a> (5)</li><li><a href="/Blog/2009/10/default.aspx">octobre</a> (6)</li><li><a href="/Blog/2009/09/default.aspx">septembre</a> (9)</li><li><a href="/Blog/2009/08/default.aspx">août</a> (16)</li><li><a href="/Blog/2009/07/default.aspx">juillet</a> (14)</li><li><a href="/Blog/2009/06/default.aspx">juin</a> (8)</li><li><a href="/Blog/2009/05/default.aspx">mai</a> (6)</li><li><a href="/Blog/2009/03/default.aspx">mars</a> (11)</li><li><a href="/Blog/2009/02/default.aspx">février</a> (15)</li><li><a href="/Blog/2009/01/default.aspx">janvier</a> (5)</li>
  </ul></li><li class="year" onclick="BlogEngine.toggleMonth(&#39;year2008&#39;)">2008<ul id="year2008">
    <li><a href="/Blog/2008/12/default.aspx">décembre</a> (7)</li><li><a href="/Blog/2008/11/default.aspx">novembre</a> (12)</li><li><a href="/Blog/2008/10/default.aspx">octobre</a> (16)</li><li><a href="/Blog/2008/09/default.aspx">septembre</a> (20)</li><li><a href="/Blog/2008/08/default.aspx">août</a> (18)</li><li><a href="/Blog/2008/07/default.aspx">juillet</a> (20)</li><li><a href="/Blog/2008/06/default.aspx">juin</a> (10)</li><li><a href="/Blog/2008/05/default.aspx">mai</a> (1)</li><li><a href="/Blog/2008/04/default.aspx">avril</a> (4)</li><li><a href="/Blog/2008/03/default.aspx">mars</a> (3)</li><li><a href="/Blog/2008/02/default.aspx">février</a> (5)</li><li><a href="/Blog/2008/01/default.aspx">janvier</a> (4)</li>
  </ul></li><li class="year" onclick="BlogEngine.toggleMonth(&#39;year2007&#39;)">2007<ul id="year2007">
    <li><a href="/Blog/2007/12/default.aspx">décembre</a> (4)</li><li><a href="/Blog/2007/11/default.aspx">novembre</a> (16)</li><li><a href="/Blog/2007/10/default.aspx">octobre</a> (7)</li><li><a href="/Blog/2007/09/default.aspx">septembre</a> (6)</li>
  </ul></li>
</ul></div></div><div class="widget textbox" id="widgetbd40eca1-446b-4441-9892-e17b050e1cc8"><h4>Archives</h4><div class="content"><p><strong><a title="Dot.Blog Archives" href="http://www.e-naxos.com/Blog/archive.aspx" target="_self">Les archives compl&egrave;tes de Dot.Blog</a></strong></p></div></div><div class="widget pagelist" id="widgetdc246169-0320-459f-a181-0f7f423dfbb5"><h4>Pages spéciales</h4><div class="content"><ul id="pagelist" class="pagelist"><li><a href="/Blog/page/ALLDOTBLOG-168;PDF-Gratuits-!.aspx">ALL.DOT.BLOG PDF Gratuits !</a></li><li><a href="/Blog/page/Apprendre-Silverlight.aspx" title="Principaux billets portant sur Silverlight. La grande majorité de ces billets sont pertinents dans toutes les &quot;saveurs&quot; du couple C#/Xaml comme WPF, Silverlight pour Windows Phone 7.x, et même C#/Xaml sous WinRT">Apprendre C#/Xaml</a></li><li><a href="/Blog/page/Comprendre-et-Appliquer-MVVM.aspx" title="Apprendre et comprendre le pattern Model-View-ViewModel (MVVM) en C# / Xaml avec ou sans frameworks (MVVM Light, Jounce, Simple MVVM, ...)">Comprendre et Appliquer MVVM</a></li><li><a href="/Blog/page/Cross-Plateforme.aspx">Cross-Plateforme</a></li><li><a href="/Blog/page/Exemples-Silverlight.aspx" title="Exemples d&#39;applications silverlight">Exemples Silverlight</a></li></ul></div></div><div class="widget newsletter" id="widget7b243290-f8a8-4996-a98d-9849658b0f35"><h4>Newsletter</h4><div class="content">

<div id="newsletterform">
  <p>Recevoir une notification lorsqu'un nouvel article est publié</p>

  <label for="ctl00_widgetContainer7b243290f8a84996a98d9849658b0f35_7b243290f8a84996a98d9849658b0f35_txtEmail" style="font-weight:bold">Entrez votre e-mail</label><br />
  <input name="ctl00$widgetContainer7b243290f8a84996a98d9849658b0f35$7b243290f8a84996a98d9849658b0f35$txtEmail" type="text" id="ctl00_widgetContainer7b243290f8a84996a98d9849658b0f35_7b243290f8a84996a98d9849658b0f35_txtEmail" style="width:98%;" />
  <span id="ctl00_widgetContainer7b243290f8a84996a98d9849658b0f35_7b243290f8a84996a98d9849658b0f35_ctl00" style="color:Red;display:none;">Veuillez entrer une adresse e-mail</span>
    
  <span id="ctl00_widgetContainer7b243290f8a84996a98d9849658b0f35_7b243290f8a84996a98d9849658b0f35_ctl01" style="color:Red;display:none;">Veuillez entrer une adresse e-mail valide</span>
    
  <div style="text-align:center">
    <input type="submit" name="ctl00$widgetContainer7b243290f8a84996a98d9849658b0f35$7b243290f8a84996a98d9849658b0f35$btnSave" value="Me notifier" onclick="return beginAddEmail();WebForm_DoPostBackWithOptions(new WebForm_PostBackOptions(&quot;ctl00$widgetContainer7b243290f8a84996a98d9849658b0f35$7b243290f8a84996a98d9849658b0f35$btnSave&quot;, &quot;&quot;, true, &quot;newsletter&quot;, &quot;&quot;, false, false))" id="ctl00_widgetContainer7b243290f8a84996a98d9849658b0f35_7b243290f8a84996a98d9849658b0f35_btnSave" />
  </div>
</div>

<div id="newsletterthanks" style="display:none;text-align:center">
  <br /><br />
  <h2 id="newsletteraction">Merci</h2>
  <br /><br />
</div>

<script type="text/javascript">
  function beginAddEmail()
  {
    if(!Page_ClientValidate('newsletter'))
      return false;
      
    var arg = BlogEngine.$('ctl00_widgetContainer7b243290f8a84996a98d9849658b0f35_7b243290f8a84996a98d9849658b0f35_txtEmail').value;
    var context = 'newsletter';
    WebForm_DoCallback('ctl00$widgetContainer7b243290f8a84996a98d9849658b0f35$7b243290f8a84996a98d9849658b0f35',arg,endAddEmail,context,null,false);
    
    return false;
  }
  
  function endAddEmail(arg, context)
  {
    BlogEngine.$('newsletterform').style.display = 'none';
    BlogEngine.$('newsletterthanks').style.display = 'block';
    if (arg == "false")
    {
      BlogEngine.$('newsletteraction').innerHTML = "Vous êtes maintenant désinscris";
    }
  }
</script></div></div></div>
          </div>
      </div>
            <div id="colRight">
                
                
  
  

  
    <div id="postnavigation">
      <a id="ctl00_cphBody_hlNext" class="nav-next"></a> | <a id="ctl00_cphBody_hlPrev" title="Précédent" class="nav-prev" href="/Blog/post/Windows-10-le-dernier-Windows-selon-Microsoft.aspx">Windows 10, le dernier Windows selon Microsoft &gt;&gt;</a>
    </div>
  
  
  

<div class="postItem">
    <h1><a href="/Blog/post/C-Quick-Tip.aspx">C# Quick Tip</a></h1>
    <!--
    <div class="meta">
    
    <span>11</span><a rel="nofollow" href="/Blog/post/C-Quick-Tip.aspx#comment">Commentaires</a>  
    
    </div>
    -->
    <h5>Read this article in your language <a href='http://translate.google.com/translate?u=http://www.e-naxos.com/Blog/post/C-Quick-Tip.aspx%2F&sl=Auto&tl=it&hl=en&ie=UTF-8'>IT</a> | <a href='http://translate.google.com/translate?u=http://www.e-naxos.com/Blog/post/C-Quick-Tip.aspx%2F&sl=Auto&tl=en&hl=en&ie=UTF-8'>EN</a> | <a href='http://translate.google.com/translate?u=http://www.e-naxos.com/Blog/post/C-Quick-Tip.aspx%2F&sl=Auto&tl=de&hl=en&ie=UTF-8'>DE</a> | <a href='http://translate.google.com/translate?u=http://www.e-naxos.com/Blog/post/C-Quick-Tip.aspx%2F&sl=Auto&tl=es&hl=en&ie=UTF-8'>ES</a></h5><p><img runat="server" class="hotnew" src="/Blog/pics/new.png" alt="New" />Vite fait, un peu de C# et un rappel sur la façon d’écrire du code de type “inline” ou de recréer les sous-fonctions du Pascal qui n’existent pas.<span id="continue"></span></p>  <h2>Quick c’est quick, c’est même fast</h2>  <p>Pas de blabla, il suffit de regarder le code ci-dessous avec un exemple de la sortie produite pour comprendre tout l’intérêt de ce style d’écriture. Définir une fonction (ou méthode) dans une autre est certainement la chose la plus intéressante de mon point vue. Ancien Pascalien, j’ai toujours trouvé dommage qu’il faille déclarer une méthode private de plus juste pour découper un algorithme là où des sous-fonctions sont milles fois plus efficaces.</p>  <p>Au fil de ses évolutions C# s’est tellement sophistiqué qu’on peut presque tout faire, même des sous-fonction à la Pascal.</p>  <p>Bref voici le code copier tout droit de LinqPad dont on ne dit jamais assez de bien :</p>  <pre class="brush: csharp; auto-links: true; collapse: false; first-line: 1; gutter: true; html-script: false; light: true; ruler: false; smart-tabs: true; tab-size: 4; toolbar: true;">        //calcul
  var add = new Func&lt;int,int,int&gt;((i,ii)=&gt;{return i+ii;});
  var a1 = add(add(add(1,2),3),4);
  Console.WriteLine(add(5,8)+&quot; &quot;+a1);
  
  //chaînes
  var normalize = new Func&lt;string,string&gt;((s)=&gt;{return s.Trim().ToUpper();});
  var c=&quot;    test   &quot;;
  Console.WriteLine(&quot;&gt;&quot;+normalize(c)+&quot;&lt;&quot;);
  
  // dicos
  var dico = new Func&lt;Dictionary&lt;int,string&gt;&gt;(()=&gt;
  {
    return new Dictionary&lt;int,string&gt;
    {
      {0,&quot;zéro&quot;},
      {1,&quot;un&quot;},
      {2,&quot;deux&quot;},
      {3,&quot;trois&quot;}
    };
  })();
  
  Console.WriteLine(dico[2]);
  
  // multiplier + tostring
  Func&lt;int,int,string&gt; AddToStr = (i,ii) =&gt; (i+ii).ToString();
  
  var x = &quot;5+3= &quot;+AddToStr(5,3);
  Console.WriteLine(x);
  
  // sans param et chaînage
  Func&lt;string&gt; TenBlankChars = ()=&gt; new string(' ',10);
  var k = &quot;1&quot;+TenBlankChars()+&quot;2&quot;;
  Console.WriteLine(&quot;k: '{0}' Longueur: {1}&quot;,k,k.Length);
  Func&lt;string&gt; OneCol = () =&gt; TenBlankChars()+&quot;|&quot;;
  Func&lt;string&gt; TenCol = () =&gt; string.Concat(Enumerable.Repeat(OneCol(),10));
  
  Console.WriteLine(TenCol());</pre>

<p>&#160;</p>

<p>Et voici la sortie :</p>

<pre class="brush: text; auto-links: true; collapse: false; first-line: 1; gutter: true; html-script: false; light: true; ruler: false; smart-tabs: true; tab-size: 4; toolbar: true;">13 10
&gt;TEST&lt;
deux
5+3= 8
k: '1          2' Longueur: 12
          |          |          |          |          |          |          |          |          |          |</pre>

<p>&#160;</p>

<h2>Conclusion</h2>

<p>Quick, c’est quick.</p>

<p>Pas de révélation choc ici, mais juste un petit rappel de la puissance de C# car je ne vois que très rarement du code utiliser ce type d’écriture pourtant très efficace et évitant souvent la création de méthodes privées utilisées une seule fois et qui polluent les classes.</p>

<p>Si vous le saviez, et bien servez-vous en ! Et si vous aviez zappé cet aspect de la syntaxe de C#, adoptez-le sans tarder !</p>

<p>Et Stay Tuned :</p>

<!-- Go to www.addthis.com/dashboard to customize your tools -->
<script type="text/javascript" src="//s7.addthis.com/js/300/addthis_widget.js#pubid=ra-53e895774ff4c1c8"></script>


<!-- Go to www.addthis.com/dashboard to customize your tools -->
<div class="addthis_sharing_toolbox"></div>
<!--

<br />
<span class='st_googleplus_hcount' displayText='Google +'></span>
<span class='st_twitter_hcount' displayText='Tweet'></span>
<span class='st_facebook_hcount' displayText='Facebook'></span>
<span class='st_linkedin_hcount' displayText='LinkedIn'></span>
<span class='st_evernote_hcount' displayText='Evernote'></span>
<span class='st_email_hcount' displayText='Email'></span>
<br />

-->


    <div class="post-footer">
        Posté le 18 mai 2015  | <a href="http://www.e-naxos.com/Blog/post.aspx?id=fc5b70b3-e95c-4786-bcc9-5d42f1ed3676" rel="bookmark">Permalink</a> | <a href="http://www.e-naxos.com/Blog/trackback.axd?id=fc5b70b3-e95c-4786-bcc9-5d42f1ed3676">Trackback</a>
        <br />Tags: <a href="http://www.e-naxos.com/Blog/?tag=/c%23" rel="tag">c#</a>
    </div>
    <div class="adminLinks">
        
    </div>
    <script type="text/javascript">
        function foo() {
            var p = $("[id$='_hlPrev']");
            var n = $("[id$='_hlNext']");

            if (p != null && p.html() != undefined && p.html().length > 0) {
                var newhtml = p.html().replace('&lt;&lt;', '');
                p.html(newhtml);
                p.addClass('nav-pre');
            }

            if (n != null && n.html() != undefined && n.html().length > 0) {
                var newhtml = n.html().replace('&gt;&gt;', '');
                n.html(newhtml);
                n.addClass('nav-nxt');
            }
        }
        foo();
    </script>
</div>

  
  
    <!--
    <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:trackback="http://madskills.com/public/xml/rss/module/trackback/">
      <rdfLaughingescription rdf:about="http://www.e-naxos.com/Blog/post/C-Quick-Tip.aspx" dc:identifier="http://www.e-naxos.com/Blog/post/C-Quick-Tip.aspx" dc:title="C# Quick Tip" trackback:ping="http://www.e-naxos.com/Blog/trackback.axd?id=fc5b70b3-e95c-4786-bcc9-5d42f1ed3676" />
    </rdf:RDF>
    -->
  
  
  
  
  
<h3 id="comment">
    Commentaires (11)
    <a id="commenttoggle" style="float:right;width:20px;height:20px;border:1px solid #ccc;text-decoration:none;text-align:center" href="javascript:toggle_visibility('commentlist', 'commenttoggle');">-</a>
</h3>


<div id="commentlist" style="display:block">
  

<div id="id_d041b841-7069-4253-b6da-d3edb03c7f02" class="vcard comment">
    <div class="commentHdrContainer">
      <div class="commentHdr">
        <div class="commentHdrContent">
          <div class="innertube">
                    <a href="javascript:void(0);" class="reply-to-comment" onclick="BlogEngine.replyToComment('d041b841-7069-4253-b6da-d3edb03c7f02');">Répondre</a>
                    
                </div>
        </div>
      </div>
      <div class="commentHdrLeftCol">
        <span class="gvt-img"><img class="photo" src="http://www.gravatar.com/avatar/875f37a5c0f88dfd0abe30e8ee039f42.jpg?s=40&amp;d=identicon" alt="dfiad77pro" width="40" height="40" /></span>
      </div>
      <div class="commentHdrRightCol">
            <span class="commentAuthor"><span class="fn">dfiad77pro</span></span>
            <br/>19/05/2015 09:06:30 <!-- <a href="#id_d041b841-7069-4253-b6da-d3edb03c7f02">#</a> -->
      </div>
    </div>
    <p class="commenttext">Le soucis de ce genre de code dans beaucoup d&#39; entreprises c&#39;est qu&#39;il beaucoup de personnes qui ne connaissent presque rien &#224; C# qui vont potentiellement relire le code...
<br />
<br />Bref faut niveler son code pour le rendre compr&#233;hensible par des gens qui en ont rien &#224; faire !
<br />
<br />
<br />Bref quand on voit que il y&#39;en a qui font m&#234;me pas l&#39;effort d’apprendre Linq et les expression Lambda, ce truc &#224; au moins l&#39;avantage de les forcer &#224; explorer le potentiel de C#...</p>
    
    <div class="comment-replies" id="replies_d041b841-7069-4253-b6da-d3edb03c7f02" >
      

<div id="id_88448560-e851-4a23-88d2-39aa6f94c12b" class="vcard comment">
    <div class="commentHdrContainer">
      <div class="commentHdr">
        <div class="commentHdrContent">
          <div class="innertube">
                    <a href="javascript:void(0);" class="reply-to-comment" onclick="BlogEngine.replyToComment('88448560-e851-4a23-88d2-39aa6f94c12b');">Répondre</a>
                    
                </div>
        </div>
      </div>
      <div class="commentHdrLeftCol">
        <span class="gvt-img"><img class="photo" src="http://www.gravatar.com/avatar/b27ad565e88029789453710df9ec458a.jpg?s=40&amp;d=identicon" alt="C&amp;#233;dric" width="40" height="40" /></span>
      </div>
      <div class="commentHdrRightCol">
            <span class="commentAuthor"><span class="fn">C&#233;dric</span></span>
            <br/>19/05/2015 23:13:49 <!-- <a href="#id_88448560-e851-4a23-88d2-39aa6f94c12b">#</a> -->
      </div>
    </div>
    <p class="commenttext">Je suis d&#39;accord avec toi. Il est n&#233;cessaire de nivel&#233; le code par le bas pour qui soit compr&#233;hensible par le plus grand nombre.
<br />
<br />Par contre, bien que ce genre d&#39;&#233;criture ne proviendra pas d&#39;un d&#233;butant, elle reste accessible en lecture pour ces derniers.</p>
    
    <div class="comment-replies" id="replies_88448560-e851-4a23-88d2-39aa6f94c12b" >
      

<div id="id_dc42af89-faf5-4a27-ac49-7e47445d0d83" class="vcard comment">
    <div class="commentHdrContainer">
      <div class="commentHdr">
        <div class="commentHdrContent">
          <div class="innertube">
                    <a href="javascript:void(0);" class="reply-to-comment" onclick="BlogEngine.replyToComment('dc42af89-faf5-4a27-ac49-7e47445d0d83');">Répondre</a>
                    
                </div>
        </div>
      </div>
      <div class="commentHdrLeftCol">
        <span class="gvt-img"><img class="photo" src="http://www.gravatar.com/avatar/957aabfd2f460cdbeb9bb046f9aa2f2f.jpg?s=40&amp;d=identicon" alt="prout" width="40" height="40" /></span>
      </div>
      <div class="commentHdrRightCol">
            <span class="commentAuthor"><a href="http://www.aaaa.com/" rel="nofollow" class="url fn">prout</a></span>
            <br/>28/05/2015 07:40:59 <!-- <a href="#id_dc42af89-faf5-4a27-ac49-7e47445d0d83">#</a> -->
      </div>
    </div>
    <p class="commenttext">Dot.Blog<br /><br />C# XAML WINDOWS &amp; ANDROID<br />28&nbsp;&nbsp;mai&nbsp;&nbsp;&nbsp;&nbsp;<br /> &nbsp;&nbsp; Souscrire &nbsp;&nbsp; &nbsp;&nbsp; Contact <br />Archive &nbsp;&nbsp;&nbsp;&nbsp; e-naxos <br /> <br />Olivier Dahan<br />MVP Windows Platform Development 2015<br />MVP Client Development 2014<br />MVP Silverlight 2013, 2012, 2011, <br />MVP CAD 2010, MVP C# 2009<br /><br /><br />Membre du Developer Guidance Advisory Council Microsoft<br /><br />Audit, Conseil, Formation, D&#233;veloppement<br />[WPF, WinRT, Xamarin Android]<br /><br /><br /><br />Olivier sur Google+<br /><br />Nuage th&#233;matique<br />Android article asp.net asynchronisme blend c# cloud data debug design edm expression F# framework humeur internet iOS liens linq linux livres m&#233;thodologie metro microsoft mobile modernUI monodroid musique mvp mvvm mvvmcross prism riaservices securit&#233; silverlight Surface tablet techdays teched threading ux vs2008 vs2010 vs2012 wcf windows windows7 windows8 WindowsStore WinRT wp7 wp8 wpf Xamarin Xamarin.Forms xaml<br />Historique<br />2015<br />mai (4)<br />avril (2)<br />mars (6)<br />f&#233;vrier (3)<br />janvier (7)<br />2014<br />2013<br />2012<br />2011<br />2010<br />2009<br />2008<br />2007<br />Archives<br />Les archives compl&#232;tes de Dot.Blog<br /><br />Pages sp&#233;ciales<br />ALL.DOT.BLOG PDF Gratuits !<br />Apprendre C#/Xaml<br />Comprendre et Appliquer MVVM<br />Cross-Plateforme<br />Exemples Silverlight<br />Newsletter<br />Recevoir une notification lorsqu&#39;un nouvel article est publi&#233;<br /><br />Entrez votre e-mail<br /><br /><br /> | Windows 10, le dernier Windows selon Microsoft &gt;&gt;<br />C# Quick Tip<br />Read this article in your language IT | EN | DE | ES<br />NewVite fait, un peu de C# et un rappel sur la fa&#231;on d’&#233;crire du code de type “inline” ou de recr&#233;er les sous-fonctions du Pascal qui n’existent pas.<br /><br />Quick c’est quick, c’est m&#234;me fast<br />Pas de blabla, il suffit de regarder le code ci-dessous avec un exemple de la sortie produite pour comprendre tout l’int&#233;r&#234;t de ce style d’&#233;criture. D&#233;finir une fonction (ou m&#233;thode) dans une autre est certainement la chose la plus int&#233;ressante de mon point vue. Ancien Pascalien, j’ai toujours trouv&#233; dommage qu’il faille d&#233;clarer une m&#233;thode private de plus juste pour d&#233;couper un algorithme l&#224; o&#249; des sous-fonctions sont milles fois plus efficaces.<br /><br />Au fil de ses &#233;volutions C# s’est tellement sophistiqu&#233; qu’on peut presque tout faire, m&#234;me des sous-fonction &#224; la Pascal.<br /><br />Bref voici le code copier tout droit de LinqPad dont on ne dit jamais assez de bien :<br /><br />&nbsp;&nbsp;&nbsp;&nbsp;//calcul<br />var add = new Func&lt;int,int,int&gt;((i,ii)=&gt;{return i+ii;});<br />var a1 = add(add(add(1,2),3),4);<br />Console.WriteLine(add(5,8)+&quot; &quot;+a1);<br /> <br />//cha&#238;nes<br />var normalize = new Func&lt;string,string&gt;((s)=&gt;{return s.Trim().ToUpper();});<br />var c=&quot;&nbsp;&nbsp;&nbsp;&nbsp;test&nbsp;&nbsp; &quot;;<br />Console.WriteLine(&quot;&gt;&quot;+normalize(c)+&quot;&lt;&quot;);<br /> <br />// dicos<br />var dico = new Func&lt;Dictionary&lt;int,string&gt;&gt;(()=&gt;<br />{<br />&nbsp;&nbsp;&nbsp;&nbsp;return new Dictionary&lt;int,string&gt; <br />&nbsp;&nbsp;&nbsp;&nbsp;{<br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{0,&quot;z&#233;ro&quot;},<br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{1,&quot;un&quot;},<br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{2,&quot;deux&quot;},<br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{3,&quot;trois&quot;}<br />&nbsp;&nbsp;&nbsp;&nbsp;};<br />})();<br /> <br />Console.WriteLine(dico[2]);<br /> <br />// multiplier + tostring<br />Func&lt;int,int,string&gt; AddToStr = (i,ii) =&gt; (i+ii).ToString();<br /> <br />var x = &quot;5+3= &quot;+AddToStr(5,3);<br />Console.WriteLine(x);<br /> <br />// sans param et cha&#238;nage<br />Func&lt;string&gt; TenBlankChars = ()=&gt; new string(&#39; &#39;,10);<br />var k = &quot;1&quot;+TenBlankChars()+&quot;2&quot;;<br />Console.WriteLine(&quot;k: &#39;{0}&#39; Longueur: {1}&quot;,k,k.Length);<br />Func&lt;string&gt; OneCol = () =&gt; TenBlankChars()+&quot;|&quot;;<br />Func&lt;string&gt; TenCol = () =&gt; string.Concat(Enumerable.Repeat(OneCol(),10));<br /> <br />Console.WriteLine(TenCol());<br /> <br /><br />Et voici la sortie :<br /><br />13 10<br />&gt;TEST&lt;<br />deux<br />5+3= 8<br />k: &#39;1&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;2&#39; Longueur: 12<br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|<br /> <br /><br />Conclusion<br />Quick, c’est quick.<br /><br />Pas de r&#233;v&#233;lation choc ici, mais juste un petit rappel de la puissance de C# car je ne vois que tr&#232;s rarement du code utiliser ce type d’&#233;criture pourtant tr&#232;s efficace et &#233;vitant souvent la cr&#233;ation de m&#233;thodes priv&#233;es utilis&#233;es une seule fois et qui polluent les classes.<br /><br />Si vous le saviez, et bien servez-vous en ! Et si vous aviez zapp&#233; cet aspect de la syntaxe de C#, adoptez-le sans tarder !<br /><br />Et Stay Tuned :<br /><br />Post&#233; le 18 mai 2015 | Permalink | Trackback <br />Tags: c#<br />Commentaires (8) -<br />R&#233;pondre<br />dfiad77pro dfiad77pro <br />19/05/2015 09:06:30<br />Le soucis de ce genre de code dans beaucoup d&#39; entreprises c&#39;est qu&#39;il beaucoup de personnes qui ne connaissent presque rien &#224; C# qui vont potentiellement relire le code... <br /><br />Bref faut niveler son code pour le rendre compr&#233;hensible par des gens qui en ont rien &#224; faire ! <br /><br /><br />Bref quand on voit que il y&#39;en a qui font m&#234;me pas l&#39;effort d’apprendre Linq et les expression Lambda, ce truc &#224; au moins l&#39;avantage de les forcer &#224; explorer le potentiel de C#...<br /><br />R&#233;pondre<br />C&amp;#233;dric C&#233;dric <br />19/05/2015 23:13:49<br />Je suis d&#39;accord avec toi. Il est n&#233;cessaire de nivel&#233; le code par le bas pour qui soit compr&#233;hensible par le plus grand nombre. <br /><br />Par contre, bien que ce genre d&#39;&#233;criture ne proviendra pas d&#39;un d&#233;butant, elle reste accessible en lecture pour ces derniers.<br /><br />R&#233;pondre<br />C&amp;#233;dric C&#233;dric <br />19/05/2015 23:11:07<br />Quelles sont les avantages de ce type de programmation? <br /><br />Il n&#39;y pas de question idiotes, juste des questions pos&#233;es par des idiots.<br /><br />R&#233;pondre<br />Olivier Olivier <br />21/05/2015 23:24:44<br />Un langage est un langage... il a sa syntaxe, sa grammaire. Quel est l&#39;avantage de bien savoir parler fran&#231;ais alors qu&#39;avec 200 ou 300 mots on peut se faire comprendre pour l&#39;essentiel... <br /><br />je crois que les deux choses sont &#233;quivalentes. un langage informatique n&#39;est pas un accessoire dont la connaissance est superflue. On doit connaitre le langage qu&#39;on utilise et donc savoir en utiliser toutes les facettes. <br /><br />Je suis d&#39;accord sur le &quot;nivellement par le bas&quot; mais je ne l&#39;exprimerais pas comme &#231;a. Un code doit &#234;tre lisible et maintenable. C&#39;est &#231;a qui compte. <br />Le pr&#233;alable est que la personne qui lise ou maintienne soit comp&#233;tente. On ne peut pas &#233;crire un code idiot pour des idiots, mais on doit se forcer &#224; &#233;crire un code intelligent et lisible. <br /><br />Par exemple je connais des d&#233;veloppeurs qui roulent des m&#233;caniques en &#233;crivant des formules sans utiliser les parenth&#232;ses, juste parce que connaitre la pr&#233;c&#233;dence des op&#233;rateurs est pour eux le B.A.BA que tout le monde doit connaitre. Sauf que c&#39;est illisible, que &#231;a peut varier d&#39;un langage &#224; l&#39;autre, et que c&#39;est g&#233;n&#233;rateur d&#39;erreurs. Il faut syst&#233;matiquement mettre des parenth&#232;ses dans les calculs pour s&#39;assurer que tout le monde les comprend correctement et m&#234;me qu&#39;un portage dans un autre langage soit possible sans avoir des connaissances expertes du langage de d&#233;part. <br /><br />Donc ce genre de chose n&#39;est pas lisible et tr&#232;s peu maintenable on doit se l&#39;interdire. <br /><br />En revanche utiliser des expressions lambda ou LINQ en C# c&#39;est naturel, c&#39;est le langage ! <br />Il faut l&#39;&#233;crire de fa&#231;on lisible et maintenable mais se l&#39;interdire pour un &quot;nivellement par le bas&quot; c&#39;est une b&#234;tise. Si C# est trop compliqu&#233; alors il faut faire de l&#39;assembleur ou du Basic. <br /><br />Bref : oui &#224; la lisibilit&#233; et &#224; la maintenabilit&#233; car c&#39;est essentiel, non au concept de &quot;nivellement par le bas&quot; qui ferait que certaines structures du langages seraient jug&#233;es trop &quot;intelligentes&quot;. Car o&#249; on s&#39;arr&#234;te si la limite c&#39;est la connerie des gens ?&nbsp;&nbsp;On sait qu&#39;elle n&#39;a pas de limite et on peut limiter C# autant qu&#39;on veut on trouvera toujours un con qui avec si peu arrivera &#224; faire des conneries... <br /><br />Lisible mais pas nivel&#233; par le bas donc. <br /><br />Pour ce qui est de l&#39;int&#233;r&#234;t des structures montr&#233;es dans l&#39;article il y en a plein ! En fran&#231;ais il est possible d&#39;exprimer la m&#234;me chose de plusieurs fa&#231;ons, ce qui permet de le faire avec nuance, avec joie ou tristesse, avec chaleur ou froideur etc.. Sans ces nuances on peut limiter comme je le disais le fran&#231;ais &#224; quelques mots, mais quelle monde fade ! <br />C# c&#39;est pareil, on peut arriver au m&#234;me r&#233;sultat de plusieurs fa&#231;ons et cela permet de s&#39;adapter non pas l&#39;humeur de celui qui &#233;crit mais &#224; la stylistique g&#233;n&#233;rale de l&#39;application, cela peut aider &#224; la lisbilit&#233; justement en rempla&#231;ant des appels imbriqu&#233;s &#224; des tas de m&#233;thodes par un seul corps de quelques lignes, etc. <br /><br />Donc la richesse du langage C#,tout comme celle du fran&#231;ais, est un avantage pour exprimer un code de la meilleure fa&#231;on possible selon le contexte. <br /><br />Plus prosa&#239;quement on peut parler ensuite d&#39;avantages techniques : <br />1) l&#39;ex&#233;cution &quot;lazy&quot;, le fait que sous la forme d&#39;une expression certaines initialisations seront faites au dernier moment ce qui peut &#234;tre un avantage sur une initialisation &quot;en dur&quot;. Pareil pour l&#39;ex&#233;cution d&#39;un code. <br />2) Pascal permet les sous-fonctions par exemple. Delphi, cr&#233;&#233; par le p&#232;re de C# le permettait donc. Mais pas C#. Et c&#39;est une erreur &#224; mon avis. <br />car souvent on a besoin de factoriser des petits bouts de traitement (par exemple faire un Trim() et passer en majuscule). Si on a 10 affectations qui doivent r&#233;p&#233;ter ce bout de code c&#39;est laid, ouvert aux erreurs de copie, etc. <br />En C# la seule solution c&#39;est de cr&#233;er une m&#233;thode priv&#233;e et de l&#39;appeler. Cela imbrique des appels (lenteur impos&#233;e par la pile et la gestion des param&#232;tres par ex), cela &#233;clate le code en plusieurs m&#233;thodes qui n&#39;ont pas de raison d&#39;&#234;tre fonctionnelle (code spaghetti te voil&#224; !) etc. <br />F&#233;d&#233;rer ces petits traitement utiliser quelques fois dans une m&#233;thode sous la forme d&#39;une expression, donc une forme de sous-fonction, c&#39;est &#233;viter tous ces probl&#232;mes. <br /><br />Et cela rend aussi le code plus lisible et plus maintenable ... sans le niveler par le bas Smile !<br /><br />R&#233;pondre<br />Madame Madame <br />22/05/2015 16:13:26<br />&gt;&gt;... sans le niveler par le bas <br />D’o&#249; l&#39;expression, &#224; bas le g&#233;n&#233;ral Nivell !<br /><br />R&#233;pondre<br />sundown sundown <br />23/05/2015 23:52:27<br />A noter que la notion de sous-fonction est justement discut&#233;e pour &#234;tre &#233;ventuellement int&#233;gr&#233;e dans C#7 / VB15. <br /><br />Voir : https://github.com/dotnet/roslyn/issues/2930<br /><br />R&#233;pondre<br />Olivier Olivier <br />24/05/2015 00:58:10<br />merci de l&#39;info je ne l&#39;avais pas vue. <br /><br />Mais sinon c&#39;est amusant qu&#39;il faille attendre C#7 pour r&#233;inventer progressivement Pascal... <br /><br />la premi&#232;re raison qui est donn&#233;e est d&#39;ailleurs explicite et c&#39;est l&#39;un des points que je pr&#233;sente ici comme avantage des sous-fonctions : <br /><br />&quot;It is very common to write a helper method that is only used from one place, but it makes the code less clear to the reader because the association between the helper function and the thing it is helping is not explicit. Local functions makes the association part of the syntax.&quot; <br /><br />On a envie de dire &quot;ben oui mon gars, c&#39;est dans Pascal depuis les ann&#233;es 60 !&quot; <br /><br />J&#39;ai not&#233; qu&#39;h&#233;las la d&#233;claration de type local ne sera pas (encore?) autoris&#233;e alors que Pascal le permet. Il faudra sans doute attendre C# 8 ou 9. <br /><br />J&#39;adore la modernit&#233; de C# mais le p&#232;re de Delphi et de Turbo Pascal a trop voulu rompre avec le pass&#233; en abandonnant nombre de bonnes id&#233;es qui finalement sont r&#233;int&#233;gr&#233;es avec 10 ans de retard. <br />C&#39;est un peu b&#234;te ce parti pris de la rupture pour revenir sur ce qui &#233;tait bon. <br /><br />Pascal comme Delphi ont montr&#233; leurs limites et C# les explose comme il explose C, C++ et java. <br />Mais Pascal reste malgr&#233; tout une base solide, il y avait beaucoup &#224; ajouter certes mais il n&#39;y avait rien &#224; enlever ! Anders aurait gagn&#233; du temps en reprenant tout Delphi et en ajoutant juste Linq et les Lambda, il aurait fait un C#10 &#224; la premi&#232;re version Smile <br /><br />Avec C#7 on se rapprochera encore un peu plus de cette r&#233;int&#233;gration du travail de Wirth...<br /><br />R&#233;pondre<br />aaaa aaaa <br />27/05/2015 13:52:58<br />AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA<br /><br />Ajouter un commentaire<br />Nom*<br /> <br />E-mail*<br /> <br />Site Internet<br /> <br />Pays<br />&nbsp;&nbsp; Country flag <br />trois fois (5*2)<br /><br /><br />Notifier quand de nouveaux commentaires sont ajout&#233;s <br />Accueil&nbsp;&nbsp; Archive&nbsp;&nbsp; Souscrire&nbsp;&nbsp; Se connecter <br />&#169; 2015 Dot.Blog<br />ShareThis Copy and Paste - See more at: http://www.e-naxos.com/Blog/post/C-Quick-Tip.aspx#sthash.n9MZyudr.dpuf<br />-----------------------------------------------------------------------------------------------------------------------------------------------<br />Dot.Blog<br /><br />C# XAML WINDOWS &amp; ANDROID<br />28&nbsp;&nbsp;mai&nbsp;&nbsp;&nbsp;&nbsp;<br /> &nbsp;&nbsp; Souscrire &nbsp;&nbsp; &nbsp;&nbsp; Contact <br />Archive &nbsp;&nbsp;&nbsp;&nbsp; e-naxos <br /> <br />Olivier Dahan<br />MVP Windows Platform Development 2015<br />MVP Client Development 2014<br />MVP Silverlight 2013, 2012, 2011, <br />MVP CAD 2010, MVP C# 2009<br /><br /><br />Membre du Developer Guidance Advisory Council Microsoft<br /><br />Audit, Conseil, Formation, D&#233;veloppement<br />[WPF, WinRT, Xamarin Android]<br /><br /><br /><br />Olivier sur Google+<br /><br />Nuage th&#233;matique<br />Android article asp.net asynchronisme blend c# cloud data debug design edm expression F# framework humeur internet iOS liens linq linux livres m&#233;thodologie metro microsoft mobile modernUI monodroid musique mvp mvvm mvvmcross prism riaservices securit&#233; silverlight Surface tablet techdays teched threading ux vs2008 vs2010 vs2012 wcf windows windows7 windows8 WindowsStore WinRT wp7 wp8 wpf Xamarin Xamarin.Forms xaml<br />Historique<br />2015<br />mai (4)<br />avril (2)<br />mars (6)<br />f&#233;vrier (3)<br />janvier (7)<br />2014<br />2013<br />2012<br />2011<br />2010<br />2009<br />2008<br />2007<br />Archives<br />Les archives compl&#232;tes de Dot.Blog<br /><br />Pages sp&#233;ciales<br />ALL.DOT.BLOG PDF Gratuits !<br />Apprendre C#/Xaml<br />Comprendre et Appliquer MVVM<br />Cross-Plateforme<br />Exemples Silverlight<br />Newsletter<br />Recevoir une notification lorsqu&#39;un nouvel article est publi&#233;<br /><br />Entrez votre e-mail<br /><br /><br /> | Windows 10, le dernier Windows selon Microsoft &gt;&gt;<br />C# Quick Tip<br />Read this article in your language IT | EN | DE | ES<br />NewVite fait, un peu de C# et un rappel sur la fa&#231;on d’&#233;crire du code de type “inline” ou de recr&#233;er les sous-fonctions du Pascal qui n’existent pas.<br /><br />Quick c’est quick, c’est m&#234;me fast<br />Pas de blabla, il suffit de regarder le code ci-dessous avec un exemple de la sortie produite pour comprendre tout l’int&#233;r&#234;t de ce style d’&#233;criture. D&#233;finir une fonction (ou m&#233;thode) dans une autre est certainement la chose la plus int&#233;ressante de mon point vue. Ancien Pascalien, j’ai toujours trouv&#233; dommage qu’il faille d&#233;clarer une m&#233;thode private de plus juste pour d&#233;couper un algorithme l&#224; o&#249; des sous-fonctions sont milles fois plus efficaces.<br /><br />Au fil de ses &#233;volutions C# s’est tellement sophistiqu&#233; qu’on peut presque tout faire, m&#234;me des sous-fonction &#224; la Pascal.<br /><br />Bref voici le code copier tout droit de LinqPad dont on ne dit jamais assez de bien :<br /><br />&nbsp;&nbsp;&nbsp;&nbsp;//calcul<br />var add = new Func&lt;int,int,int&gt;((i,ii)=&gt;{return i+ii;});<br />var a1 = add(add(add(1,2),3),4);<br />Console.WriteLine(add(5,8)+&quot; &quot;+a1);<br /> <br />//cha&#238;nes<br />var normalize = new Func&lt;string,string&gt;((s)=&gt;{return s.Trim().ToUpper();});<br />var c=&quot;&nbsp;&nbsp;&nbsp;&nbsp;test&nbsp;&nbsp; &quot;;<br />Console.WriteLine(&quot;&gt;&quot;+normalize(c)+&quot;&lt;&quot;);<br /> <br />// dicos<br />var dico = new Func&lt;Dictionary&lt;int,string&gt;&gt;(()=&gt;<br />{<br />&nbsp;&nbsp;&nbsp;&nbsp;return new Dictionary&lt;int,string&gt; <br />&nbsp;&nbsp;&nbsp;&nbsp;{<br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{0,&quot;z&#233;ro&quot;},<br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{1,&quot;un&quot;},<br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{2,&quot;deux&quot;},<br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{3,&quot;trois&quot;}<br />&nbsp;&nbsp;&nbsp;&nbsp;};<br />})();<br /> <br />Console.WriteLine(dico[2]);<br /> <br />// multiplier + tostring<br />Func&lt;int,int,string&gt; AddToStr = (i,ii) =&gt; (i+ii).ToString();<br /> <br />var x = &quot;5+3= &quot;+AddToStr(5,3);<br />Console.WriteLine(x);<br /> <br />// sans param et cha&#238;nage<br />Func&lt;string&gt; TenBlankChars = ()=&gt; new string(&#39; &#39;,10);<br />var k = &quot;1&quot;+TenBlankChars()+&quot;2&quot;;<br />Console.WriteLine(&quot;k: &#39;{0}&#39; Longueur: {1}&quot;,k,k.Length);<br />Func&lt;string&gt; OneCol = () =&gt; TenBlankChars()+&quot;|&quot;;<br />Func&lt;string&gt; TenCol = () =&gt; string.Concat(Enumerable.Repeat(OneCol(),10));<br /> <br />Console.WriteLine(TenCol());<br /> <br /><br />Et voici la sortie :<br /><br />13 10<br />&gt;TEST&lt;<br />deux<br />5+3= 8<br />k: &#39;1&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;2&#39; Longueur: 12<br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|<br /> <br /><br />Conclusion<br />Quick, c’est quick.<br /><br />Pas de r&#233;v&#233;lation choc ici, mais juste un petit rappel de la puissance de C# car je ne vois que tr&#232;s rarement du code utiliser ce type d’&#233;criture pourtant tr&#232;s efficace et &#233;vitant souvent la cr&#233;ation de m&#233;thodes priv&#233;es utilis&#233;es une seule fois et qui polluent les classes.<br /><br />Si vous le saviez, et bien servez-vous en ! Et si vous aviez zapp&#233; cet aspect de la syntaxe de C#, adoptez-le sans tarder !<br /><br />Et Stay Tuned :<br /><br />Post&#233; le 18 mai 2015 | Permalink | Trackback <br />Tags: c#<br />Commentaires (8) -<br />R&#233;pondre<br />dfiad77pro dfiad77pro <br />19/05/2015 09:06:30<br />Le soucis de ce genre de code dans beaucoup d&#39; entreprises c&#39;est qu&#39;il beaucoup de personnes qui ne connaissent presque rien &#224; C# qui vont potentiellement relire le code... <br /><br />Bref faut niveler son code pour le rendre compr&#233;hensible par des gens qui en ont rien &#224; faire ! <br /><br /><br />Bref quand on voit que il y&#39;en a qui font m&#234;me pas l&#39;effort d’apprendre Linq et les expression Lambda, ce truc &#224; au moins l&#39;avantage de les forcer &#224; explorer le potentiel de C#...<br /><br />R&#233;pondre<br />C&amp;#233;dric C&#233;dric <br />19/05/2015 23:13:49<br />Je suis d&#39;accord avec toi. Il est n&#233;cessaire de nivel&#233; le code par le bas pour qui soit compr&#233;hensible par le plus grand nombre. <br /><br />Par contre, bien que ce genre d&#39;&#233;criture ne proviendra pas d&#39;un d&#233;butant, elle reste accessible en lecture pour ces derniers.<br /><br />Merci pour votre commentaire. Il est maintenant en attente de mod&#233;ration<br />Ajouter un commentaire<br />Annuler la r&#233;ponse du commentaire&nbsp;&nbsp;<br />Nom*<br /> <br />E-mail*<br /> <br />Site Internet<br /> <br />Pays<br />&nbsp;&nbsp; Country flag <br />trois fois (5*2)<br /><br /><br />Notifier quand de nouveaux commentaires sont ajout&#233;s <br />R&#233;pondre<br />C&amp;#233;dric C&#233;dric <br />19/05/2015 23:11:07<br />Quelles sont les avantages de ce type de programmation? <br /><br />Il n&#39;y pas de question idiotes, juste des questions pos&#233;es par des idiots.<br /><br />R&#233;pondre<br />Olivier Olivier <br />21/05/2015 23:24:44<br />Un langage est un langage... il a sa syntaxe, sa grammaire. Quel est l&#39;avantage de bien savoir parler fran&#231;ais alors qu&#39;avec 200 ou 300 mots on peut se faire comprendre pour l&#39;essentiel... <br /><br />je crois que les deux choses sont &#233;quivalentes. un langage informatique n&#39;est pas un accessoire dont la connaissance est superflue. On doit connaitre le langage qu&#39;on utilise et donc savoir en utiliser toutes les facettes. <br /><br />Je suis d&#39;accord sur le &quot;nivellement par le bas&quot; mais je ne l&#39;exprimerais pas comme &#231;a. Un code doit &#234;tre lisible et maintenable. C&#39;est &#231;a qui compte. <br />Le pr&#233;alable est que la personne qui lise ou maintienne soit comp&#233;tente. On ne peut pas &#233;crire un code idiot pour des idiots, mais on doit se forcer &#224; &#233;crire un code intelligent et lisible. <br /><br />Par exemple je connais des d&#233;veloppeurs qui roulent des m&#233;caniques en &#233;crivant des formules sans utiliser les parenth&#232;ses, juste parce que connaitre la pr&#233;c&#233;dence des op&#233;rateurs est pour eux le B.A.BA que tout le monde doit connaitre. Sauf que c&#39;est illisible, que &#231;a peut varier d&#39;un langage &#224; l&#39;autre, et que c&#39;est g&#233;n&#233;rateur d&#39;erreurs. Il faut syst&#233;matiquement mettre des parenth&#232;ses dans les calculs pour s&#39;assurer que tout le monde les comprend correctement et m&#234;me qu&#39;un portage dans un autre langage soit possible sans avoir des connaissances expertes du langage de d&#233;part. <br /><br />Donc ce genre de chose n&#39;est pas lisible et tr&#232;s peu maintenable on doit se l&#39;interdire. <br /><br />En revanche utiliser des expressions lambda ou LINQ en C# c&#39;est naturel, c&#39;est le langage ! <br />Il faut l&#39;&#233;crire de fa&#231;on lisible et maintenable mais se l&#39;interdire pour un &quot;nivellement par le bas&quot; c&#39;est une b&#234;tise. Si C# est trop compliqu&#233; alors il faut faire de l&#39;assembleur ou du Basic. <br /><br />Bref : oui &#224; la lisibilit&#233; et &#224; la maintenabilit&#233; car c&#39;est essentiel, non au concept de &quot;nivellement par le bas&quot; qui ferait que certaines structures du langages seraient jug&#233;es trop &quot;intelligentes&quot;. Car o&#249; on s&#39;arr&#234;te si la limite c&#39;est la connerie des gens ?&nbsp;&nbsp;On sait qu&#39;elle n&#39;a pas de limite et on peut limiter C# autant qu&#39;on veut on trouvera toujours un con qui avec si peu arrivera &#224; faire des conneries... <br /><br />Lisible mais pas nivel&#233; par le bas donc. <br /><br />Pour ce qui est de l&#39;int&#233;r&#234;t des structures montr&#233;es dans l&#39;article il y en a plein ! En fran&#231;ais il est possible d&#39;exprimer la m&#234;me chose de plusieurs fa&#231;ons, ce qui permet de le faire avec nuance, avec joie ou tristesse, avec chaleur ou froideur etc.. Sans ces nuances on peut limiter comme je le disais le fran&#231;ais &#224; quelques mots, mais quelle monde fade ! <br />C# c&#39;est pareil, on peut arriver au m&#234;me r&#233;sultat de plusieurs fa&#231;ons et cela permet de s&#39;adapter non pas l&#39;humeur de celui qui &#233;crit mais &#224; la stylistique g&#233;n&#233;rale de l&#39;application, cela peut aider &#224; la lisbilit&#233; justement en rempla&#231;ant des appels imbriqu&#233;s &#224; des tas de m&#233;thodes par un seul corps de quelques lignes, etc. <br /><br />Donc la richesse du langage C#,tout comme celle du fran&#231;ais, est un avantage pour exprimer un code de la meilleure fa&#231;on possible selon le contexte. <br /><br />Plus prosa&#239;quement on peut parler ensuite d&#39;avantages techniques : <br />1) l&#39;ex&#233;cution &quot;lazy&quot;, le fait que sous la forme d&#39;une expression certaines initialisations seront faites au dernier moment ce qui peut &#234;tre un avantage sur une initialisation &quot;en dur&quot;. Pareil pour l&#39;ex&#233;cution d&#39;un code. <br />2) Pascal permet les sous-fonctions par exemple. Delphi, cr&#233;&#233; par le p&#232;re de C# le permettait donc. Mais pas C#. Et c&#39;est une erreur &#224; mon avis. <br />car souvent on a besoin de factoriser des petits bouts de traitement (par exemple faire un Trim() et passer en majuscule). Si on a 10 affectations qui doivent r&#233;p&#233;ter ce bout de code c&#39;est laid, ouvert aux erreurs de copie, etc. <br />En C# la seule solution c&#39;est de cr&#233;er une m&#233;thode priv&#233;e et de l&#39;appeler. Cela imbrique des appels (lenteur impos&#233;e par la pile et la gestion des param&#232;tres par ex), cela &#233;clate le code en plusieurs m&#233;thodes qui n&#39;ont pas de raison d&#39;&#234;tre fonctionnelle (code spaghetti te voil&#224; !) etc. <br />F&#233;d&#233;rer ces petits traitement utiliser quelques fois dans une m&#233;thode sous la forme d&#39;une expression, donc une forme de sous-fonction, c&#39;est &#233;viter tous ces probl&#232;mes. <br /><br />Et cela rend aussi le code plus lisible et plus maintenable ... sans le niveler par le bas Smile !<br /><br />R&#233;pondre<br />Madame Madame <br />22/05/2015 16:13:26<br />&gt;&gt;... sans le niveler par le bas <br />D’o&#249; l&#39;expression, &#224; bas le g&#233;n&#233;ral Nivell !<br /><br />R&#233;pondre<br />sundown sundown <br />23/05/2015 23:52:27<br />A noter que la notion de sous-fonction est justement discut&#233;e pour &#234;tre &#233;ventuellement int&#233;gr&#233;e dans C#7 / VB15. <br /><br />Voir : https://github.com/dotnet/roslyn/issues/2930<br /><br />R&#233;pondre<br />Olivier Olivier <br />24/05/2015 00:58:10<br />merci de l&#39;info je ne l&#39;avais pas vue. <br /><br />Mais sinon c&#39;est amusant qu&#39;il faille attendre C#7 pour r&#233;inventer progressivement Pascal... <br /><br />la premi&#232;re raison qui est donn&#233;e est d&#39;ailleurs explicite et c&#39;est l&#39;un des points que je pr&#233;sente ici comme avantage des sous-fonctions : <br /><br />&quot;It is very common to write a helper method that is only used from one place, but it makes the code less clear to the reader because the association between the helper function and the thing it is helping is not explicit. Local functions makes the association part of the syntax.&quot; <br /><br />On a envie de dire &quot;ben oui mon gars, c&#39;est dans Pascal depuis les ann&#233;es 60 !&quot; <br /><br />J&#39;ai not&#233; qu&#39;h&#233;las la d&#233;claration de type local ne sera pas (encore?) autoris&#233;e alors que Pascal le permet. Il faudra sans doute attendre C# 8 ou 9. <br /><br />J&#39;adore la modernit&#233; de C# mais le p&#232;re de Delphi et de Turbo Pascal a trop voulu rompre avec le pass&#233; en abandonnant nombre de bonnes id&#233;es qui finalement sont r&#233;int&#233;gr&#233;es avec 10 ans de retard. <br />C&#39;est un peu b&#234;te ce parti pris de la rupture pour revenir sur ce qui &#233;tait bon. <br /><br />Pascal comme Delphi ont montr&#233; leurs limites et C# les explose comme il explose C, C++ et java. <br />Mais Pascal reste malgr&#233; tout une base solide, il y avait beaucoup &#224; ajouter certes mais il n&#39;y avait rien &#224; enlever ! Anders aurait gagn&#233; du temps en reprenant tout Delphi et en ajoutant juste Linq et les Lambda, il aurait fait un C#10 &#224; la premi&#232;re version Smile <br /><br />Avec C#7 on se rapprochera encore un peu plus de cette r&#233;int&#233;gration du travail de Wirth...<br /><br />R&#233;pondre<br />aaaa aaaa <br />27/05/2015 13:52:58<br />AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA<br /><br />R&#233;pondre<br />aaaa aaaa <br />28/05/2015 07:39:45<br />Dot.Blog<br /><br />C# XAML WINDOWS &amp; ANDROID<br />28&nbsp;&nbsp;mai&nbsp;&nbsp;&nbsp;&nbsp;<br />&nbsp;&nbsp; Souscrire&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Contact <br />Archive&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;e-naxos <br /><br />Olivier Dahan<br />MVP Windows Platform Development 2015<br />MVP Client Development 2014<br />MVP Silverlight 2013, 2012, 2011, <br />MVP CAD 2010, MVP C# 2009<br /><br /><br />Membre du Developer Guidance Advisory Council Microsoft<br /><br />Audit, Conseil, Formation, D&#233;veloppement<br />[WPF, WinRT, Xamarin Android]<br /><br /><br /><br />Olivier sur Google+<br /><br />Nuage th&#233;matique<br />Android article asp.net asynchronisme blend c# cloud data debug design edm expression F# framework humeur internet iOS liens linq linux livres m&#233;thodologie metro microsoft mobile modernUI monodroid musique mvp mvvm mvvmcross prism riaservices securit&#233; silverlight Surface tablet techdays teched threading ux vs2008 vs2010 vs2012 wcf windows windows7 windows8 WindowsStore WinRT wp7 wp8 wpf Xamarin Xamarin.Forms xaml<br />Historique<br />2015<br />mai (4)<br />avril (2)<br />mars (6)<br />f&#233;vrier (3)<br />janvier (7)<br />2014<br />2013<br />2012<br />2011<br />2010<br />2009<br />2008<br />2007<br />Archives<br />Les archives compl&#232;tes de Dot.Blog<br /><br />Pages sp&#233;ciales<br />ALL.DOT.BLOG PDF Gratuits !<br />Apprendre C#/Xaml<br />Comprendre et Appliquer MVVM<br />Cross-Plateforme<br />Exemples Silverlight<br />Newsletter<br />Recevoir une notification lorsqu&#39;un nouvel article est publi&#233;<br /><br />Entrez votre e-mail<br /><br /><br />| Windows 10, le dernier Windows selon Microsoft &gt;&gt;<br />C# Quick Tip<br />Read this article in your language IT | EN | DE | ES<br />NewVite fait, un peu de C# et un rappel sur la fa&#231;on d’&#233;crire du code de type “inline” ou de recr&#233;er les sous-fonctions du Pascal qui n’existent pas.<br /><br />Quick c’est quick, c’est m&#234;me fast<br />Pas de blabla, il suffit de regarder le code ci-dessous avec un exemple de la sortie produite pour comprendre tout l’int&#233;r&#234;t de ce style d’&#233;criture. D&#233;finir une fonction (ou m&#233;thode) dans une autre est certainement la chose la plus int&#233;ressante de mon point vue. Ancien Pascalien, j’ai toujours trouv&#233; dommage qu’il faille d&#233;clarer une m&#233;thode private de plus juste pour d&#233;couper un algorithme l&#224; o&#249; des sous-fonctions sont milles fois plus efficaces.<br /><br />Au fil de ses &#233;volutions C# s’est tellement sophistiqu&#233; qu’on peut presque tout faire, m&#234;me des sous-fonction &#224; la Pascal.<br /><br />Bref voici le code copier tout droit de LinqPad dont on ne dit jamais assez de bien :<br /><br />&nbsp;&nbsp;&nbsp;&nbsp;//calcul<br />var add = new Func&lt;int,int,int&gt;((i,ii)=&gt;{return i+ii;});<br />var a1 = add(add(add(1,2),3),4);<br />Console.WriteLine(add(5,8)+&quot; &quot;+a1);<br /><br />//cha&#238;nes<br />var normalize = new Func&lt;string,string&gt;((s)=&gt;{return s.Trim().ToUpper();});<br />var c=&quot;&nbsp;&nbsp;&nbsp;&nbsp;test&nbsp;&nbsp; &quot;;<br />Console.WriteLine(&quot;&gt;&quot;+normalize(c)+&quot;&lt;&quot;);<br /><br />// dicos<br />var dico = new Func&lt;Dictionary&lt;int,string&gt;&gt;(()=&gt;<br />{<br />&nbsp;&nbsp;&nbsp;&nbsp;return new Dictionary&lt;int,string&gt; <br />&nbsp;&nbsp;&nbsp;&nbsp;{<br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{0,&quot;z&#233;ro&quot;},<br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{1,&quot;un&quot;},<br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{2,&quot;deux&quot;},<br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{3,&quot;trois&quot;}<br />&nbsp;&nbsp;&nbsp;&nbsp;};<br />})();<br /><br />Console.WriteLine(dico[2]);<br /><br />// multiplier + tostring<br />Func&lt;int,int,string&gt; AddToStr = (i,ii) =&gt; (i+ii).ToString();<br /><br />var x = &quot;5+3= &quot;+AddToStr(5,3);<br />Console.WriteLine(x);<br /><br />// sans param et cha&#238;nage<br />Func&lt;string&gt; TenBlankChars = ()=&gt; new string(&#39; &#39;,10);<br />var k = &quot;1&quot;+TenBlankChars()+&quot;2&quot;;<br />Console.WriteLine(&quot;k: &#39;{0}&#39; Longueur: {1}&quot;,k,k.Length);<br />Func&lt;string&gt; OneCol = () =&gt; TenBlankChars()+&quot;|&quot;;<br />Func&lt;string&gt; TenCol = () =&gt; string.Concat(Enumerable.Repeat(OneCol(),10));<br /><br />Console.WriteLine(TenCol());<br /><br /><br />Et voici la sortie :<br /><br />13 10<br />&gt;TEST&lt;<br />deux<br />5+3= 8<br />k: &#39;1&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;2&#39; Longueur: 12<br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|<br /><br /><br />Conclusion<br />Quick, c’est quick.<br /><br />Pas de r&#233;v&#233;lation choc ici, mais juste un petit rappel de la puissance de C# car je ne vois que tr&#232;s rarement du code utiliser ce type d’&#233;criture pourtant tr&#232;s efficace et &#233;vitant souvent la cr&#233;ation de m&#233;thodes priv&#233;es utilis&#233;es une seule fois et qui polluent les classes.<br /><br />Si vous le saviez, et bien servez-vous en ! Et si vous aviez zapp&#233; cet aspect de la syntaxe de C#, adoptez-le sans tarder !<br /><br />Et Stay Tuned :<br /><br />Post&#233; le 18 mai 2015 | Permalink | Trackback <br />Tags: c#<br />Commentaires (8) -<br />R&#233;pondre<br />dfiad77pro dfiad77pro <br />19/05/2015 09:06:30<br />Le soucis de ce genre de code dans beaucoup d&#39; entreprises c&#39;est qu&#39;il beaucoup de personnes qui ne connaissent presque rien &#224; C# qui vont potentiellement relire le code... <br /><br />Bref faut niveler son code pour le rendre compr&#233;hensible par des gens qui en ont rien &#224; faire ! <br /><br /><br />Bref quand on voit que il y&#39;en a qui font m&#234;me pas l&#39;effort d’apprendre Linq et les expression Lambda, ce truc &#224; au moins l&#39;avantage de les forcer &#224; explorer le potentiel de C#...<br /><br />R&#233;pondre<br />C&amp;#233;dric C&#233;dric <br />19/05/2015 23:13:49<br />Je suis d&#39;accord avec toi. Il est n&#233;cessaire de nivel&#233; le code par le bas pour qui soit compr&#233;hensible par le plus grand nombre. <br /><br />Par contre, bien que ce genre d&#39;&#233;criture ne proviendra pas d&#39;un d&#233;butant, elle reste accessible en lecture pour ces derniers.<br /><br />R&#233;pondre<br />C&amp;#233;dric C&#233;dric <br />19/05/2015 23:11:07<br />Quelles sont les avantages de ce type de programmation? <br /><br />Il n&#39;y pas de question idiotes, juste des questions pos&#233;es par des idiots.<br /><br />R&#233;pondre<br />Olivier Olivier <br />21/05/2015 23:24:44<br />Un langage est un langage... il a sa syntaxe, sa grammaire. Quel est l&#39;avantage de bien savoir parler fran&#231;ais alors qu&#39;avec 200 ou 300 mots on peut se faire comprendre pour l&#39;essentiel... <br /><br />je crois que les deux choses sont &#233;quivalentes. un langage informatique n&#39;est pas un accessoire dont la connaissance est superflue. On doit connaitre le langage qu&#39;on utilise et donc savoir en utiliser toutes les facettes. <br /><br />Je suis d&#39;accord sur le &quot;nivellement par le bas&quot; mais je ne l&#39;exprimerais pas comme &#231;a. Un code doit &#234;tre lisible et maintenable. C&#39;est &#231;a qui compte. <br />Le pr&#233;alable est que la personne qui lise ou maintienne soit comp&#233;tente. On ne peut pas &#233;crire un code idiot pour des idiots, mais on doit se forcer &#224; &#233;crire un code intelligent et lisible. <br /><br />Par exemple je connais des d&#233;veloppeurs qui roulent des m&#233;caniques en &#233;crivant des formules sans utiliser les parenth&#232;ses, juste parce que connaitre la pr&#233;c&#233;dence des op&#233;rateurs est pour eux le B.A.BA que tout le monde doit connaitre. Sauf que c&#39;est illisible, que &#231;a peut varier d&#39;un langage &#224; l&#39;autre, et que c&#39;est g&#233;n&#233;rateur d&#39;erreurs. Il faut syst&#233;matiquement mettre des parenth&#232;ses dans les calculs pour s&#39;assurer que tout le monde les comprend correctement et m&#234;me qu&#39;un portage dans un autre langage soit possible sans avoir des connaissances expertes du langage de d&#233;part. <br /><br />Donc ce genre de chose n&#39;est pas lisible et tr&#232;s peu maintenable on doit se l&#39;interdire. <br /><br />En revanche utiliser des expressions lambda ou LINQ en C# c&#39;est naturel, c&#39;est le langage ! <br />Il faut l&#39;&#233;crire de fa&#231;on lisible et maintenable mais se l&#39;interdire pour un &quot;nivellement par le bas&quot; c&#39;est une b&#234;tise. Si C# est trop compliqu&#233; alors il faut faire de l&#39;assembleur ou du Basic. <br /><br />Bref : oui &#224; la lisibilit&#233; et &#224; la maintenabilit&#233; car c&#39;est essentiel, non au concept de &quot;nivellement par le bas&quot; qui ferait que certaines structures du langages seraient jug&#233;es trop &quot;intelligentes&quot;. Car o&#249; on s&#39;arr&#234;te si la limite c&#39;est la connerie des gens ?&nbsp;&nbsp;On sait qu&#39;elle n&#39;a pas de limite et on peut limiter C# autant qu&#39;on veut on trouvera toujours un con qui avec si peu arrivera &#224; faire des conneries... <br /><br />Lisible mais pas nivel&#233; par le bas donc. <br /><br />Pour ce qui est de l&#39;int&#233;r&#234;t des structures montr&#233;es dans l&#39;article il y en a plein ! En fran&#231;ais il est possible d&#39;exprimer la m&#234;me chose de plusieurs fa&#231;ons, ce qui permet de le faire avec nuance, avec joie ou tristesse, avec chaleur ou froideur etc.. Sans ces nuances on peut limiter comme je le disais le fran&#231;ais &#224; quelques mots, mais quelle monde fade ! <br />C# c&#39;est pareil, on peut arriver au m&#234;me r&#233;sultat de plusieurs fa&#231;ons et cela permet de s&#39;adapter non pas l&#39;humeur de celui qui &#233;crit mais &#224; la stylistique g&#233;n&#233;rale de l&#39;application, cela peut aider &#224; la lisbilit&#233; justement en rempla&#231;ant des appels imbriqu&#233;s &#224; des tas de m&#233;thodes par un seul corps de quelques lignes, etc. <br /><br />Donc la richesse du langage C#,tout comme celle du fran&#231;ais, est un avantage pour exprimer un code de la meilleure fa&#231;on possible selon le contexte. <br /><br />Plus prosa&#239;quement on peut parler ensuite d&#39;avantages techniques : <br />1) l&#39;ex&#233;cution &quot;lazy&quot;, le fait que sous la forme d&#39;une expression certaines initialisations seront faites au dernier moment ce qui peut &#234;tre un avantage sur une initialisation &quot;en dur&quot;. Pareil pour l&#39;ex&#233;cution d&#39;un code. <br />2) Pascal permet les sous-fonctions par exemple. Delphi, cr&#233;&#233; par le p&#232;re de C# le permettait donc. Mais pas C#. Et c&#39;est une erreur &#224; mon avis. <br />car souvent on a besoin de factoriser des petits bouts de traitement (par exemple faire un Trim() et passer en majuscule). Si on a 10 affectations qui doivent r&#233;p&#233;ter ce bout de code c&#39;est laid, ouvert aux erreurs de copie, etc. <br />En C# la seule solution c&#39;est de cr&#233;er une m&#233;thode priv&#233;e et de l&#39;appeler. Cela imbrique des appels (lenteur impos&#233;e par la pile et la gestion des param&#232;tres par ex), cela &#233;clate le code en plusieurs m&#233;thodes qui n&#39;ont pas de raison d&#39;&#234;tre fonctionnelle (code spaghetti te voil&#224; !) etc. <br />F&#233;d&#233;rer ces petits traitement utiliser quelques fois dans une m&#233;thode sous la forme d&#39;une expression, donc une forme de sous-fonction, c&#39;est &#233;viter tous ces probl&#232;mes. <br /><br />Et cela rend aussi le code plus lisible et plus maintenable ... sans le niveler par le bas Smile !<br /><br />R&#233;pondre<br />Madame Madame <br />22/05/2015 16:13:26<br />&gt;&gt;... sans le niveler par le bas <br />D’o&#249; l&#39;expression, &#224; bas le g&#233;n&#233;ral Nivell !<br /><br />R&#233;pondre<br />sundown sundown <br />23/05/2015 23:52:27<br />A noter que la notion de sous-fonction est justement discut&#233;e pour &#234;tre &#233;ventuellement int&#233;gr&#233;e dans C#7 / VB15. <br /><br />Voir : https://github.com/dotnet/roslyn/issues/2930<br /><br />R&#233;pondre<br />Olivier Olivier <br />24/05/2015 00:58:10<br />merci de l&#39;info je ne l&#39;avais pas vue. <br /><br />Mais sinon c&#39;est amusant qu&#39;il faille attendre C#7 pour r&#233;inventer progressivement Pascal... <br /><br />la premi&#232;re raison qui est donn&#233;e est d&#39;ailleurs explicite et c&#39;est l&#39;un des points que je pr&#233;sente ici comme avantage des sous-fonctions : <br /><br />&quot;It is very common to write a helper method that is only used from one place, but it makes the code less clear to the reader because the association between the helper function and the thing it is helping is not explicit. Local functions makes the association part of the syntax.&quot; <br /><br />On a envie de dire &quot;ben oui mon gars, c&#39;est dans Pascal depuis les ann&#233;es 60 !&quot; <br /><br />J&#39;ai not&#233; qu&#39;h&#233;las la d&#233;claration de type local ne sera pas (encore?) autoris&#233;e alors que Pascal le permet. Il faudra sans doute attendre C# 8 ou 9. <br /><br />J&#39;adore la modernit&#233; de C# mais le p&#232;re de Delphi et de Turbo Pascal a trop voulu rompre avec le pass&#233; en abandonnant nombre de bonnes id&#233;es qui finalement sont r&#233;int&#233;gr&#233;es avec 10 ans de retard. <br />C&#39;est un peu b&#234;te ce parti pris de la rupture pour revenir sur ce qui &#233;tait bon. <br /><br />Pascal comme Delphi ont montr&#233; leurs limites et C# les explose comme il explose C, C++ et java. <br />Mais Pascal reste malgr&#233; tout une base solide, il y avait beaucoup &#224; ajouter certes mais il n&#39;y avait rien &#224; enlever ! Anders aurait gagn&#233; du temps en reprenant tout Delphi et en ajoutant juste Linq et les Lambda, il aurait fait un C#10 &#224; la premi&#232;re version Smile <br /><br />Avec C#7 on se rapprochera encore un peu plus de cette r&#233;int&#233;gration du travail de Wirth...<br /><br />R&#233;pondre<br />aaaa aaaa <br />27/05/2015 13:52:58<br />AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA<br /><br />Ajouter un commentaire<br />Nom*<br /><br />E-mail*<br /><br />Site Internet<br /><br />Pays<br />&nbsp;&nbsp; Country flag <br />trois fois (5*2)<br /><br /><br />Notifier quand de nouveaux commentaires sont ajout&#233;s <br />Accueil&nbsp;&nbsp; Archive&nbsp;&nbsp; Souscrire&nbsp;&nbsp; Se connecter <br />&#169; 2015 Dot.Blog<br />ShareThis Copy and Paste - See more at: http://www.e-naxos.com/Blog/post/C-Quick-Tip.aspx#sthash.n9MZyudr.dpuf<br /><br />Accueil&nbsp;&nbsp; Archive&nbsp;&nbsp; Souscrire&nbsp;&nbsp; Se connecter <br />&#169; 2015 Dot.Blog<br />Dot.Blog<br /><br />C# XAML WINDOWS &amp; ANDROID<br />28&nbsp;&nbsp;mai&nbsp;&nbsp;&nbsp;&nbsp;<br /> &nbsp;&nbsp; Souscrire &nbsp;&nbsp; &nbsp;&nbsp; Contact <br />Archive &nbsp;&nbsp;&nbsp;&nbsp; e-naxos <br /> <br />Olivier Dahan<br />MVP Windows Platform Development 2015<br />MVP Client Development 2014<br />MVP Silverlight 2013, 2012, 2011, <br />MVP CAD 2010, MVP C# 2009<br /><br /><br />Membre du Developer Guidance Advisory Council Microsoft<br /><br />Audit, Conseil, Formation, D&#233;veloppement<br />[WPF, WinRT, Xamarin Android]<br /><br /><br /><br />Olivier sur Google+<br /><br />Nuage th&#233;matique<br />Android article asp.net asynchronisme blend c# cloud data debug design edm expression F# framework humeur internet iOS liens linq linux livres m&#233;thodologie metro microsoft mobile modernUI monodroid musique mvp mvvm mvvmcross prism riaservices securit&#233; silverlight Surface tablet techdays teched threading ux vs2008 vs2010 vs2012 wcf windows windows7 windows8 WindowsStore WinRT wp7 wp8 wpf Xamarin Xamarin.Forms xaml<br />Historique<br />2015<br />mai (4)<br />avril (2)<br />mars (6)<br />f&#233;vrier (3)<br />janvier (7)<br />2014<br />2013<br />2012<br />2011<br />2010<br />2009<br />2008<br />2007<br />Archives<br />Les archives compl&#232;tes de Dot.Blog<br /><br />Pages sp&#233;ciales<br />ALL.DOT.BLOG PDF Gratuits !<br />Apprendre C#/Xaml<br />Comprendre et Appliquer MVVM<br />Cross-Plateforme<br />Exemples Silverlight<br />Newsletter<br />Recevoir une notification lorsqu&#39;un nouvel article est publi&#233;<br /><br />Entrez votre e-mail<br /><br /><br /> | Windows 10, le dernier Windows selon Microsoft &gt;&gt;<br />C# Quick Tip<br />Read this article in your language IT | EN | DE | ES<br />NewVite fait, un peu de C# et un rappel sur la fa&#231;on d’&#233;crire du code de type “inline” ou de recr&#233;er les sous-fonctions du Pascal qui n’existent pas.<br /><br />Quick c’est quick, c’est m&#234;me fast<br />Pas de blabla, il suffit de regarder le code ci-dessous avec un exemple de la sortie produite pour comprendre tout l’int&#233;r&#234;t de ce style d’&#233;criture. D&#233;finir une fonction (ou m&#233;thode) dans une autre est certainement la chose la plus int&#233;ressante de mon point vue. Ancien Pascalien, j’ai toujours trouv&#233; dommage qu’il faille d&#233;clarer une m&#233;thode private de plus juste pour d&#233;couper un algorithme l&#224; o&#249; des sous-fonctions sont milles fois plus efficaces.<br /><br />Au fil de ses &#233;volutions C# s’est tellement sophistiqu&#233; qu’on peut presque tout faire, m&#234;me des sous-fonction &#224; la Pascal.<br /><br />Bref voici le code copier tout droit de LinqPad dont on ne dit jamais assez de bien :<br /><br />&nbsp;&nbsp;&nbsp;&nbsp;//calcul<br />var add = new Func&lt;int,int,int&gt;((i,ii)=&gt;{return i+ii;});<br />var a1 = add(add(add(1,2),3),4);<br />Console.WriteLine(add(5,8)+&quot; &quot;+a1);<br /> <br />//cha&#238;nes<br />var normalize = new Func&lt;string,string&gt;((s)=&gt;{return s.Trim().ToUpper();});<br />var c=&quot;&nbsp;&nbsp;&nbsp;&nbsp;test&nbsp;&nbsp; &quot;;<br />Console.WriteLine(&quot;&gt;&quot;+normalize(c)+&quot;&lt;&quot;);<br /> <br />// dicos<br />var dico = new Func&lt;Dictionary&lt;int,string&gt;&gt;(()=&gt;<br />{<br />&nbsp;&nbsp;&nbsp;&nbsp;return new Dictionary&lt;int,string&gt; <br />&nbsp;&nbsp;&nbsp;&nbsp;{<br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{0,&quot;z&#233;ro&quot;},<br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{1,&quot;un&quot;},<br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{2,&quot;deux&quot;},<br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{3,&quot;trois&quot;}<br />&nbsp;&nbsp;&nbsp;&nbsp;};<br />})();<br /> <br />Console.WriteLine(dico[2]);<br /> <br />// multiplier + tostring<br />Func&lt;int,int,string&gt; AddToStr = (i,ii) =&gt; (i+ii).ToString();<br /> <br />var x = &quot;5+3= &quot;+AddToStr(5,3);<br />Console.WriteLine(x);<br /> <br />// sans param et cha&#238;nage<br />Func&lt;string&gt; TenBlankChars = ()=&gt; new string(&#39; &#39;,10);<br />var k = &quot;1&quot;+TenBlankChars()+&quot;2&quot;;<br />Console.WriteLine(&quot;k: &#39;{0}&#39; Longueur: {1}&quot;,k,k.Length);<br />Func&lt;string&gt; OneCol = () =&gt; TenBlankChars()+&quot;|&quot;;<br />Func&lt;string&gt; TenCol = () =&gt; string.Concat(Enumerable.Repeat(OneCol(),10));<br /> <br />Console.WriteLine(TenCol());<br /> <br /><br />Et voici la sortie :<br /><br />13 10<br />&gt;TEST&lt;<br />deux<br />5+3= 8<br />k: &#39;1&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;2&#39; Longueur: 12<br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;|<br /> <br /><br />Conclusion<br />Quick, c’est quick.<br /><br />Pas de r&#233;v&#233;lation choc ici, mais juste un petit rappel de la puissance de C# car je ne vois que tr&#232;s rarement du code utiliser ce type d’&#233;criture pourtant tr&#232;s efficace et &#233;vitant souvent la cr&#233;ation de m&#233;thodes priv&#233;es utilis&#233;es une seule fois et qui polluent les classes.<br /><br />Si vous le saviez, et bien servez-vous en ! Et si vous aviez zapp&#233; cet aspect de la syntaxe de C#, adoptez-le sans tarder !<br /><br />Et Stay Tuned :<br /><br />Post&#233; le 18 mai 2015 | Permalink | Trackback <br />Tags: c#<br />Commentaires (8) -<br />R&#233;pondre<br />dfiad77pro dfiad77pro <br />19/05/2015 09:06:30<br />Le soucis de ce genre de code dans beaucoup d&#39; entreprises c&#39;est qu&#39;il beaucoup de personnes qui ne connaissent presque rien &#224; C# qui vont potentiellement relire le code... <br /><br />Bref faut niveler son code pour le rendre compr&#233;hensible par des gens qui en ont rien &#224; faire ! <br /><br /><br />Bref quand on voit que il y&#39;en a qui font m&#234;me pas l&#39;effort d’apprendre Linq et les expression Lambda, ce truc &#224; au moins l&#39;avantage de les forcer &#224; explorer le potentiel de C#...<br /><br />R&#233;pondre<br />C&amp;#233;dric C&#233;dric <br />19/05/2015 23:13:49<br />Je suis d&#39;accord avec toi. Il est n&#233;cessaire de nivel&#233; le code par le bas pour qui soit compr&#233;hensible par le plus grand nombre. <br /><br />Par contre, bien que ce genre d&#39;&#233;criture ne proviendra pas d&#39;un d&#233;butant, elle reste accessible en lecture pour ces derniers.<br /><br />R&#233;pondre<br />C&amp;#233;dric C&#233;dric <br />19/05/2015 23:11:07<br />Quelles sont les avantages de ce type de programmation? <br /><br />Il n&#39;y pas de question idiotes, juste des questions pos&#233;es par des idiots.<br /><br />R&#233;pondre<br />Olivier Olivier <br />21/05/2015 23:24:44<br />Un langage est un langage... il a sa syntaxe, sa grammaire. Quel est l&#39;avantage de bien savoir parler fran&#231;ais alors qu&#39;avec 200 ou 300 mots on peut se faire comprendre pour l&#39;essentiel... <br /><br />je crois que les deux choses sont &#233;quivalentes. un langage informatique n&#39;est pas un accessoire dont la connaissance est superflue. On doit connaitre le langage qu&#39;on utilise et donc savoir en utiliser toutes les facettes. <br /><br />Je suis d&#39;accord sur le &quot;nivellement par le bas&quot; mais je ne l&#39;exprimerais pas comme &#231;a. Un code doit &#234;tre lisible et maintenable. C&#39;est &#231;a qui compte. <br />Le pr&#233;alable est que la personne qui lise ou maintienne soit comp&#233;tente. On ne peut pas &#233;crire un code idiot pour des idiots, mais on doit se forcer &#224; &#233;crire un code intelligent et lisible. <br /><br />Par exemple je connais des d&#233;veloppeurs qui roulent des m&#233;caniques en &#233;crivant des formules sans utiliser les parenth&#232;ses, juste parce que connaitre la pr&#233;c&#233;dence des op&#233;rateurs est pour eux le B.A.BA que tout le monde doit connaitre. Sauf que c&#39;est illisible, que &#231;a peut varier d&#39;un langage &#224; l&#39;autre, et que c&#39;est g&#233;n&#233;rateur d&#39;erreurs. Il faut syst&#233;matiquement mettre des parenth&#232;ses dans les calculs pour s&#39;assurer que tout le monde les comprend correctement et m&#234;me qu&#39;un portage dans un autre langage soit possible sans avoir des connaissances expertes du langage de d&#233;part. <br /><br />Donc ce genre de chose n&#39;est pas lisible et tr&#232;s peu maintenable on doit se l&#39;interdire. <br /><br />En revanche utiliser des expressions lambda ou LINQ en C# c&#39;est naturel, c&#39;est le langage ! <br />Il faut l&#39;&#233;crire de fa&#231;on lisible et maintenable mais se l&#39;interdire pour un &quot;nivellement par le bas&quot; c&#39;est une b&#234;tise. Si C# est trop compliqu&#233; alors il faut faire de l&#39;assembleur ou du Basic. <br /><br />Bref : oui &#224; la lisibilit&#233; et &#224; la maintenabilit&#233; car c&#39;est essentiel, non au concept de &quot;nivellement par le bas&quot; qui ferait que certaines structures du langages seraient jug&#233;es trop &quot;intelligentes&quot;. Car o&#249; on s&#39;arr&#234;te si la limite c&#39;est la connerie des gens ?&nbsp;&nbsp;On sait qu&#39;elle n&#39;a pas de limite et on peut limiter C# autant qu&#39;on veut on trouvera toujours un con qui avec si peu arrivera &#224; faire des conneries... <br /><br />Lisible mais pas nivel&#233; par le bas donc. <br /><br />Pour ce qui est de l&#39;int&#233;r&#234;t des structures montr&#233;es dans l&#39;article il y en a plein ! En fran&#231;ais il est possible d&#39;exprimer la m&#234;me chose de plusieurs fa&#231;ons, ce qui permet de le faire avec nuance, avec joie ou tristesse, avec chaleur ou froideur etc.. Sans ces nuances on peut limiter comme je le disais le fran&#231;ais &#224; quelques mots, mais quelle monde fade ! <br />C# c&#39;est pareil, on peut arriver au m&#234;me r&#233;sultat de plusieurs fa&#231;ons et cela permet de s&#39;adapter non pas l&#39;humeur de celui qui &#233;crit mais &#224; la stylistique g&#233;n&#233;rale de l&#39;application, cela peut aider &#224; la lisbilit&#233; justement en rempla&#231;ant des appels imbriqu&#233;s &#224; des tas de m&#233;thodes par un seul corps de quelques lignes, etc. <br /><br />Donc la richesse du langage C#,tout comme celle du fran&#231;ais, est un avantage pour exprimer un code de la meilleure fa&#231;on possible selon le contexte. <br /><br />Plus prosa&#239;quement on peut parler ensuite d&#39;avantages techniques : <br />1) l&#39;ex&#233;cution &quot;lazy&quot;, le fait que sous la forme d&#39;une expression certaines initialisations seront faites au dernier moment ce qui peut &#234;tre un avantage sur une initialisation &quot;en dur&quot;. Pareil pour l&#39;ex&#233;cution d&#39;un code. <br />2) Pascal permet les sous-fonctions par exemple. Delphi, cr&#233;&#233; par le p&#232;re de C# le permettait donc. Mais pas C#. Et c&#39;est une erreur &#224; mon avis. <br />car souvent on a besoin de factoriser des petits bouts de traitement (par exemple faire un Trim() et passer en majuscule). Si on a 10 affectations qui doivent r&#233;p&#233;ter ce bout de code c&#39;est laid, ouvert aux erreurs de copie, etc. <br />En C# la seule solution c&#39;est de cr&#233;er une m&#233;thode priv&#233;e et de l&#39;appeler. Cela imbrique des appels (lenteur impos&#233;e par la pile et la gestion des param&#232;tres par ex), cela &#233;clate le code en plusieurs m&#233;thodes qui n&#39;ont pas de raison d&#39;&#234;tre fonctionnelle (code spaghetti te voil&#224; !) etc. <br />F&#233;d&#233;rer ces petits traitement utiliser quelques fois dans une m&#233;thode sous la forme d&#39;une expression, donc une forme de sous-fonction, c&#39;est &#233;viter tous ces probl&#232;mes. <br /><br />Et cela rend aussi le code plus lisible et plus maintenable ... sans le niveler par le bas Smile !<br /><br />R&#233;pondre<br />Madame Madame <br />22/05/2015 16:13:26<br />&gt;&gt;... sans le niveler par le bas <br />D’o&#249; l&#39;expression, &#224; bas le g&#233;n&#233;ral Nivell !<br /><br />R&#233;pondre<br />sundown sundown <br />23/05/2015 23:52:27<br />A noter que la notion de sous-fonction est justement discut&#233;e pour &#234;tre &#23#233;ventuellement int&#233;gr&#233;e dans C#7 / VB15. <br /><br />Voir : https://github.com/dotnet/roslyn/issues/2930<br /><br />R&#233;pondre<br />Olivier Olivier <br />24/05/2015 00:58:10<br />merci de l&#39;info je ne l&#39;avais pas vue. <br /><br />Mais sinon c&#39;est amusant qu&#39;il faille attendre C#7 pour r&#233;inventer progressivement Pascal... <br /><br />la premi&#232;re raison qui est donn&#233;e est d&#39;ailleurs explicite et c&#39;est l&#39;un des points que je pr&#233;sente ici comme avantage des sous-fonctions : <br /><br />&quot;It is very common to write a helper method that is only used from one place, but it makes the code less clear to the reader because the association between the helper function and the thing it is helping is not explicit. Local functions makes the association part of the syntax.&quot; <br /><br />On a envie de dire &quot;ben oui mon gars, c&#39;est dans Pascal depuis les ann&#233;es 60 !&quot; <br /><br />J&#39;ai not&#233; qu&#39;h&#233;las la d&#233;claration de type local ne sera pas (encore?) autoris&#233;e alors que Pascal le permet. Il faudra sans doute attendre C# 8 ou 9. <br /><br />J&#39;adore la modernit&#233; de C# mais le p&#232;re de Delphi et de Turbo Pascal a trop voulu rompre avec le pass&#233; en abandonnant nombre de bonnes id&#233;es qui finalement sont r&#233;int&#233;gr&#233;es avec 10 ans de retard. <br />C&#39;est un peu b&#234;te ce parti pris de la rupture pour revenir sur ce qui &#233;tait bon. <br /><br />Pascal comme Delphi ont montr&#233; leurs limites et C# les explose comme il explose C, C++ et java. <br />Mais Pascal reste malgr&#233; tout une base solide, il y avait beaucoup &#224; ajouter certes mais il n&#39;y avait rien &#224; enlever ! Anders aurait gagn&#233; du temps en reprenant tout Delphi et en ajoutant juste Linq et les Lambda, il aurait fait un C#10 &#224; la premi&#232;re version Smile <br /><br />Avec C#7 on se rapprochera encore un peu plus de cette r&#233;int&#233;gration du travail de Wirth...<br /><br />R&#233;pondre<br />aaaa aaaa <br />27/05/2015 13:52:58<br />AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA<br /><br />Ajouter un commentaire<br />Nom*<br /> <br />E-mail*<br /> <br />Site Internet<br /> <br />Pays<br />&nbsp;&nbsp; Country flag <br />trois fois (5*2)<br /><br /><br />Notifier quand de nouveaux commentaires sont ajout&#233;s <br />Accueil&nbsp;&nbsp; Archive&nbsp;&nbsp; Souscrire&nbsp;&nbsp; Se connecter <br />&#169; 2015 Dot.Blog<br />ShareThis Copy and Paste - See more at: http://www.e-naxos.com/Blog/post/C-Quick-Tip.aspx#sthash.n9MZyudr.dpuf - See more at: http://www.e-naxos.com/Blog/post/C-Quick-Tip.aspx#sthash.n9MZyudr.dpuf</p>
    
    <div class="comment-replies" id="replies_dc42af89-faf5-4a27-ac49-7e47445d0d83"  style="display:none;">
      
    </div>
</div>
    </div>
</div>

<div id="id_a827bceb-fd0d-4739-b0fa-8ef8943f9d40" class="vcard comment">
    <div class="commentHdrContainer">
      <div class="commentHdr">
        <div class="commentHdrContent">
          <div class="innertube">
                    <a href="javascript:void(0);" class="reply-to-comment" onclick="BlogEngine.replyToComment('a827bceb-fd0d-4739-b0fa-8ef8943f9d40');">Répondre</a>
                    
                </div>
        </div>
      </div>
      <div class="commentHdrLeftCol">
        <span class="gvt-img"><img class="photo" src="http://www.gravatar.com/avatar/957aabfd2f460cdbeb9bb046f9aa2f2f.jpg?s=40&amp;d=identicon" alt="sarkozyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyDot.Blog  C# XAML WINDOWS &amp;amp; ANDROID 28  mai         Souscrire       Contact  Archive      e-naxos    Olivier Dahan MVP Windows Platform Development 2015 MVP Client Development 2014 MVP Silverlight 2013, 2012, 2011,  MVP CAD 2010, MVP C# 2009   Membre du Developer Guidance Advisory Council Microsoft  Audit, Conseil, Formation, D&amp;#233;veloppement [WPF, WinRT, Xamarin Android]    Olivier sur Google+  Nuage th&amp;#233;matique Android article asp.net asynchronisme blend c# cloud data debug design edm expression F# framework humeur internet iOS liens linq linux livres m&amp;#233;thodologie metro microsoft mobile modernUI monodroid musique mvp mvvm mvvmcross prism riaservices securit&amp;#233; silverlight Surface tablet techdays teched threading ux vs2008 vs2010 vs2012 wcf windows windows7 windows8 WindowsStore WinRT wp7 wp8 wpf Xamarin Xamarin.Forms xaml Historique 2015 mai (4) avril (2) mars (6) f&amp;#233;vrier (3) janvier (7) 2014 2013 2012 2011 2010 2009 2008 2007 Archives Les archives compl&amp;#232;tes de Dot.Blog  Pages sp&amp;#233;ciales ALL.DOT.BLOG PDF Gratuits ! Apprendre C#/Xaml Comprendre et Appliquer MVVM Cross-Plateforme Exemples Silverlight Newsletter Recevoir une notification lorsqu&amp;#39;un nouvel article est publi&amp;#233;  Entrez votre e-mail    | Windows 10, le dernier Windows selon Microsoft &amp;gt;&amp;gt; C# Quick Tip Read this article in your language IT | EN | DE | ES NewVite fait, un peu de C# et un rappel sur la fa&amp;#231;on d’&amp;#233;crire du code de type “inline” ou de recr&amp;#233;er les sous-fonctions du Pascal qui n’existent pas.  Quick c’est quick, c’est m&amp;#234;me fast Pas de blabla, il suffit de regarder le code ci-dessous avec un exemple de la sortie produite pour comprendre tout l’int&amp;#233;r&amp;#234;t de ce style d’&amp;#233;criture. D&amp;#233;finir une fonction (ou m&amp;#233;thode) dans une autre est certainement la chose la plus int&amp;#233;ressante de mon point vue. Ancien Pascalien, j’ai toujours trouv&amp;#233; dommage qu’il faille d&amp;#233;clarer une m&amp;#233;thode private de plus juste pour d&amp;#233;couper un algorithme l&amp;#224; o&amp;#249; des sous-fonctions sont milles fois plus efficaces.  Au fil de ses &amp;#233;volutions C# s’est tellement sophistiqu&amp;#233; qu’on peut presque tout faire, m&amp;#234;me des sous-fonction &amp;#224; la Pascal.  Bref voici le code copier tout droit de LinqPad dont on ne dit jamais assez de bien :          //calcul   var add = new Func&amp;lt;int,int,int&amp;gt;((i,ii)=&amp;gt;{return i+ii;});   var a1 = add(add(add(1,2),3),4);   Console.WriteLine(add(5,8)+&amp;quot; &amp;quot;+a1);      //cha&amp;#238;nes   var normalize = new Func&amp;lt;string,string&amp;gt;((s)=&amp;gt;{return s.Trim().ToUpper();});   var c=&amp;quot;    test   &amp;quot;;   Console.WriteLine(&amp;quot;&amp;gt;&amp;quot;+normalize(c)+&amp;quot;&amp;lt;&amp;quot;);      // dicos   var dico = new Func&amp;lt;Dictionary&amp;lt;int,string&amp;gt;&amp;gt;(()=&amp;gt;   {     return new Dictionary&amp;lt;int,string&amp;gt;      {       {0,&amp;quot;z&amp;#233;ro&amp;quot;},       {1,&amp;quot;un&amp;quot;},       {2,&amp;quot;deux&amp;quot;},       {3,&amp;quot;trois&amp;quot;}     };   })();      Console.WriteLine(dico[2]);      // multiplier + tostring   Func&amp;lt;int,int,string&amp;gt; AddToStr = (i,ii) =&amp;gt; (i+ii).ToString();      var x = &amp;quot;5+3= &amp;quot;+AddToStr(5,3);   Console.WriteLine(x);      // sans param et cha&amp;#238;nage   Func&amp;lt;string&amp;gt; TenBlankChars = ()=&amp;gt; new string(&amp;#39; &amp;#39;,10);   var k = &amp;quot;1&amp;quot;+TenBlankChars()+&amp;quot;2&amp;quot;;   Console.WriteLine(&amp;quot;k: &amp;#39;{0}&amp;#39; Longueur: {1}&amp;quot;,k,k.Length);   Func&amp;lt;string&amp;gt; OneCol = () =&amp;gt; TenBlankChars()+&amp;quot;|&amp;quot;;   Func&amp;lt;string&amp;gt; TenCol = () =&amp;gt; string.Concat(Enumerable.Repeat(OneCol(),10));      Console.WriteLine(TenCol());    Et voici la sortie :  13 10 &amp;gt;TEST&amp;lt; deux 5+3= 8 k: &amp;#39;1          2&amp;#39; Longueur: 12           |          |          |          |          |          |          |          |          |          |    Conclusion Quick, c’est quick.  Pas de r&amp;#233;v&amp;#233;lation choc ici, mais juste un petit rappel de la puissance de C# car je ne vois que tr&amp;#232;s rarement du code utiliser ce type d’&amp;#233;criture pourtant tr&amp;#232;s efficace et &amp;#233;vitant souvent la cr&amp;#233;ation de m&amp;#233;thodes priv&amp;#233;es utilis&amp;#233;es une seule fois et qui polluent les classes.  Si vous le saviez, et bien servez-vous en ! Et si vous aviez zapp&amp;#233; cet aspect de la syntaxe de C#, adoptez-le sans tarder !  Et Stay Tuned :  Post&amp;#233; le 18 mai 2015 | Permalink | Trackback  Tags: c# Commentaires (10) - R&amp;#233;pondre dfiad77pro dfiad77pro  19/05/2015 09:06:30 Le soucis de ce genre de code dans beaucoup d&amp;#39; entreprises c&amp;#39;est qu&amp;#39;il beaucoup de personnes qui ne connaissent presque rien &amp;#224; C# qui vont potentiellement relire le code...   Bref faut niveler son code pour le rendre compr&amp;#233;hensible par des gens qui en ont rien &amp;#224; faire !    Bref quand on voit que il y&amp;#39;en a qui font m&amp;#234;me pas l&amp;#39;effort d’apprendre Linq et les expression Lambda, ce truc &amp;#224; au moins l&amp;#39;avantage de les forcer &amp;#224; explorer le potentiel de C#...  R&amp;#233;pondre C&amp;amp;#233;dric C&amp;#233;dric  19/05/2015 23:13:49 Je suis d&amp;#39;accord avec toi. Il est n&amp;#233;cessaire de nivel&amp;#233; le code par le bas pour qui soit compr&amp;#233;hensible par le plus grand nombre.   Par contre, bien que ce genre d&amp;#39;&amp;#233;criture ne proviendra pas d&amp;#39;un d&amp;#233;butant, elle reste accessible en lecture pour ces derniers.  R&amp;#233;pondre prout prout  28/05/2015 07:40:59 Dot.Blog  C# XAML WINDOWS &amp;amp; ANDROID 28  mai        Souscrire       Contact  Archive      e-naxos   Olivier Dahan MVP Windows Platform Development 2015 MVP Client Development 2014 MVP Silverlight 2013, 2012, 2011,  MVP CAD 2010, MVP C# 2009   Membre du Developer Guidance Advisory Council Microsoft  Audit, Conseil, Formation, D&amp;#233;veloppement [WPF, WinRT, Xamarin Android]    Olivier sur Google+  Nuage th&amp;#233;matique Android article asp.net asynchronisme blend c# cloud data debug design edm expression F# framework humeur internet iOS liens linq linux livres m&amp;#233;thodologie metro microsoft mobile modernUI monodroid musique mvp mvvm mvvmcross prism riaservices securit&amp;#233; silverlight Surface tablet techdays teched threading ux vs2008 vs2010 vs2012 wcf windows windows7 windows8 WindowsStore WinRT wp7 wp8 wpf Xamarin Xamarin.Forms xaml Historique 2015 mai (4) avril (2) mars (6) f&amp;#233;vrier (3) janvier (7) 2014 2013 2012 2011 2010 2009 2008 2007 Archives Les archives compl&amp;#232;tes de Dot.Blog  Pages sp&amp;#233;ciales ALL.DOT.BLOG PDF Gratuits ! Apprendre C#/Xaml Comprendre et Appliquer MVVM Cross-Plateforme Exemples Silverlight Newsletter Recevoir une notification lorsqu&amp;#39;un nouvel article est publi&amp;#233;  Entrez votre e-mail   | Windows 10, le dernier Windows selon Microsoft &amp;gt;&amp;gt; C# Quick Tip Read this article in your language IT | EN | DE | ES NewVite fait, un peu de C# et un rappel sur la fa&amp;#231;on d’&amp;#233;crire du code de type “inline” ou de recr&amp;#233;er les sous-fonctions du Pascal qui n’existent pas.  Quick c’est quick, c’est m&amp;#234;me fast Pas de blabla, il suffit de regarder le code ci-dessous avec un exemple de la sortie produite pour comprendre tout l’int&amp;#233;r&amp;#234;t de ce style d’&amp;#233;criture. D&amp;#233;finir une fonction (ou m&amp;#233;thode) dans une autre est certainement la chose la plus int&amp;#233;ressante de mon point vue. Ancien Pascalien, j’ai toujours trouv&amp;#233; dommage qu’il faille d&amp;#233;clarer une m&amp;#233;thode private de plus juste pour d&amp;#233;couper un algorithme l&amp;#224; o&amp;#249; des sous-fonctions sont milles fois plus efficaces.  Au fil de ses &amp;#233;volutions C# s’est tellement sophistiqu&amp;#233; qu’on peut presque tout faire, m&amp;#234;me des sous-fonction &amp;#224; la Pascal.  Bref voici le code copier tout droit de LinqPad dont on ne dit jamais assez de bien :      //calcul var add = new Func&amp;lt;int,int,int&amp;gt;((i,ii)=&amp;gt;{return i+ii;}); var a1 = add(add(add(1,2),3),4); Console.WriteLine(add(5,8)+&amp;quot; &amp;quot;+a1);  //cha&amp;#238;nes var normalize = new Func&amp;lt;string,string&amp;gt;((s)=&amp;gt;{return s.Trim().ToUpper();}); var c=&amp;quot;    test   &amp;quot;; Console.WriteLine(&amp;quot;&amp;gt;&amp;quot;+normalize(c)+&amp;quot;&amp;lt;&amp;quot;);  // dicos var dico = new Func&amp;lt;Dictionary&amp;lt;int,string&amp;gt;&amp;gt;(()=&amp;gt; {     return new Dictionary&amp;lt;int,string&amp;gt;      {         {0,&amp;quot;z&amp;#233;ro&amp;quot;},         {1,&amp;quot;un&amp;quot;},         {2,&amp;quot;deux&amp;quot;},         {3,&amp;quot;trois&amp;quot;}     }; })();  Console.WriteLine(dico[2]);  // multiplier + tostring Func&amp;lt;int,int,string&amp;gt; AddToStr = (i,ii) =&amp;gt; (i+ii).ToString();  var x = &amp;quot;5+3= &amp;quot;+AddToStr(5,3); Console.WriteLine(x);  // sans param et cha&amp;#238;nage Func&amp;lt;string&amp;gt; TenBlankChars = ()=&amp;gt; new string(&amp;#39; &amp;#39;,10); var k = &amp;quot;1&amp;quot;+TenBlankChars()+&amp;quot;2&amp;quot;; Console.WriteLine(&amp;quot;k: &amp;#39;{0}&amp;#39; Longueur: {1}&amp;quot;,k,k.Length); Func&amp;lt;string&amp;gt; OneCol = () =&amp;gt; TenBlankChars()+&amp;quot;|&amp;quot;; Func&amp;lt;string&amp;gt; TenCol = () =&amp;gt; string.Concat(Enumerable.Repeat(OneCol(),10));  Console.WriteLine(TenCol());   Et voici la sortie :  13 10 &amp;gt;TEST&amp;lt; deux 5+3= 8 k: &amp;#39;1          2&amp;#39; Longueur: 12           |          |          |          |          |          |          |          |          |          |   Conclusion Quick, c’est quick.  Pas de r&amp;#233;v&amp;#233;lation choc ici, mais juste un petit rappel de la puissance de C# car je ne vois que tr&amp;#232;s rarement du code utiliser ce type d’&amp;#233;criture pourtant tr&amp;#232;s efficace et &amp;#233;vitant souvent la cr&amp;#233;ation de m&amp;#233;thodes priv&amp;#233;es utilis&amp;#233;es une seule fois et qui polluent les classes.  Si vous le saviez, et bien servez-vous en ! Et si vous aviez zapp&amp;#233; cet aspect de la syntaxe de C#, adoptez-le sans tarder !  Et Stay Tuned :  Post&amp;#233; le 18 mai 2015 | Permalink | Trackback  Tags: c# Commentaires (8) - R&amp;#233;pondre dfiad77pro dfiad77pro  19/05/2015 09:06:30 Le soucis de ce genre de code dans beaucoup d&amp;#39; entreprises c&amp;#39;est qu&amp;#39;il beaucoup de personnes qui ne connaissent presque rien &amp;#224; C# qui vont potentiellement relire le code...   Bref faut niveler son code pour le rendre compr&amp;#233;hensible par des gens qui en ont rien &amp;#224; faire !    Bref quand on voit que il y&amp;#39;en a qui font m&amp;#234;me pas l&amp;#39;effort d’apprendre Linq et les expression Lambda, ce truc &amp;#224; au moins l&amp;#39;avantage de les forcer &amp;#224; explorer le potentiel de C#...  R&amp;#233;pondre C&amp;amp;#233;dric C&amp;#233;dric  19/05/2015 23:13:49 Je suis d&amp;#39;accord avec toi. Il est n&amp;#233;cessaire de nivel&amp;#233; le code par le bas pour qui soit compr&amp;#233;hensible par le plus grand nombre.   Par contre, bien que ce genre d&amp;#39;&amp;#233;criture ne proviendra pas d&amp;#39;un d&amp;#233;butant, elle reste accessible en lecture pour ces derniers.  R&amp;#233;pondre C&amp;amp;#233;dric C&amp;#233;dric  19/05/2015 23:11:07 Quelles sont les avantages de ce type de programmation?   Il n&amp;#39;y pas de question idiotes, juste des questions pos&amp;#233;es par des idiots.  R&amp;#233;pondre Olivier Olivier  21/05/2015 23:24:44 Un langage est un langage... il a sa syntaxe, sa grammaire. Quel est l&amp;#39;avantage de bien savoir parler fran&amp;#231;ais alors qu&amp;#39;avec 200 ou 300 mots on peut se faire comprendre pour l&amp;#39;essentiel...   je crois que les deux choses sont &amp;#233;quivalentes. un langage informatique n&amp;#39;est pas un accessoire dont la connaissance est superflue. On doit connaitre le langage qu&amp;#39;on utilise et donc savoir en utiliser toutes les facettes.   Je suis d&amp;#39;accord sur le &amp;quot;nivellement par le bas&amp;quot; mais je ne l&amp;#39;exprimerais pas comme &amp;#231;a. Un code doit &amp;#234;tre lisible et maintenable. C&amp;#39;est &amp;#231;a qui compte.  Le pr&amp;#233;alable est que la personne qui lise ou maintienne soit comp&amp;#233;tente. On ne peut pas &amp;#233;crire un code idiot pour des idiots, mais on doit se forcer &amp;#224; &amp;#233;crire un code intelligent et lisible.   Par exemple je connais des d&amp;#233;veloppeurs qui roulent des m&amp;#233;caniques en &amp;#233;crivant des formules sans utiliser les parenth&amp;#232;ses, juste parce que connaitre la pr&amp;#233;c&amp;#233;dence des op&amp;#233;rateurs est pour eux le B.A.BA que tout le monde doit connaitre. Sauf que c&amp;#39;est illisible, que &amp;#231;a peut varier d&amp;#39;un langage &amp;#224; l&amp;#39;autre, et que c&amp;#39;est g&amp;#233;n&amp;#233;rateur d&amp;#39;erreurs. Il faut syst&amp;#233;matiquement mettre des parenth&amp;#232;ses dans les calculs pour s&amp;#39;assurer que tout le monde les comprend correctement et m&amp;#234;me qu&amp;#39;un portage dans un autre langage soit possible sans avoir des connaissances expertes du langage de d&amp;#233;part.   Donc ce genre de chose n&amp;#39;est pas lisible et tr&amp;#232;s peu maintenable on doit se l&amp;#39;interdire.   En revanche utiliser des expressions lambda ou LINQ en C# c&amp;#39;est naturel, c&amp;#39;est le langage !  Il faut l&amp;#39;&amp;#233;crire de fa&amp;#231;on lisible et maintenable mais se l&amp;#39;interdire pour un &amp;quot;nivellement par le bas&amp;quot; c&amp;#39;est une b&amp;#234;tise. Si C# est trop compliqu&amp;#233; alors il faut faire de l&amp;#39;assembleur ou du Basic.   Bref : oui &amp;#224; la lisibilit&amp;#233; et &amp;#224; la maintenabilit&amp;#233; car c&amp;#39;est essentiel, non au concept de &amp;quot;nivellement par le bas&amp;quot; qui ferait que certaines structures du langages seraient jug&amp;#233;es trop &amp;quot;intelligentes&amp;quot;. Car o&amp;#249; on s&amp;#39;arr&amp;#234;te si la limite c&amp;#39;est la connerie des gens ?  On sait qu&amp;#39;elle n&amp;#39;a pas de limite et on peut limiter C# autant qu&amp;#39;on veut on trouvera toujours un con qui avec si peu arrivera &amp;#224; faire des conneries...   Lisible mais pas nivel&amp;#233; par le bas donc.   Pour ce qui est de l&amp;#39;int&amp;#233;r&amp;#234;t des structures montr&amp;#233;es dans l&amp;#39;article il y en a plein ! En fran&amp;#231;ais il est possible d&amp;#39;exprimer la m&amp;#234;me chose de plusieurs fa&amp;#231;ons, ce qui permet de le faire avec nuance, avec joie ou tristesse, avec chaleur ou froideur etc.. Sans ces nuances on peut limiter comme je le disais le fran&amp;#231;ais &amp;#224; quelques mots, mais quelle monde fade !  C# c&amp;#39;est pareil, on peut arriver au m&amp;#234;me r&amp;#233;sultat de plusieurs fa&amp;#231;ons et cela permet de s&amp;#39;adapter non pas l&amp;#39;humeur de celui qui &amp;#233;crit mais &amp;#224; la stylistique g&amp;#233;n&amp;#233;rale de l&amp;#39;application, cela peut aider &amp;#224; la lisbilit&amp;#233; justement en rempla&amp;#231;ant des appels imbriqu&amp;#233;s &amp;#224; des tas de m&amp;#233;thodes par un seul corps de quelques lignes, etc.   Donc la richesse du langage C#,tout comme celle du fran&amp;#231;ais, est un avantage pour exprimer un code de la meilleure fa&amp;#231;on possible selon le contexte.   Plus prosa&amp;#239;quement on peut parler ensuite d&amp;#39;avantages techniques :  1) l&amp;#39;ex&amp;#233;cution &amp;quot;lazy&amp;quot;, le fait que sous la forme d&amp;#39;une expression certaines initialisations seront faites au dernier moment ce qui peut &amp;#234;tre un avantage sur une initialisation &amp;quot;en dur&amp;quot;. Pareil pour l&amp;#39;ex&amp;#233;cution d&amp;#39;un code.  2) Pascal permet les sous-fonctions par exemple. Delphi, cr&amp;#233;&amp;#233; par le p&amp;#232;re de C# le permettait donc. Mais pas C#. Et c&amp;#39;est une erreur &amp;#224; mon avis.  car souvent on a besoin de factoriser des petits bouts de traitement (par exemple faire un Trim() et passer en majuscule). Si on a 10 affectations qui doivent r&amp;#233;p&amp;#233;ter ce bout de code c&amp;#39;est laid, ouvert aux erreurs de copie, etc.  En C# la seule solution c&amp;#39;est de cr&amp;#233;er une m&amp;#233;thode priv&amp;#233;e et de l&amp;#39;appeler. Cela imbrique des appels (lenteur impos&amp;#233;e par la pile et la gestion des param&amp;#232;tres par ex), cela &amp;#233;clate le code en plusieurs m&amp;#233;thodes qui n&amp;#39;ont pas de raison d&amp;#39;&amp;#234;tre fonctionnelle (code spaghetti te voil&amp;#224; !) etc.  F&amp;#233;d&amp;#233;rer ces petits traitement utiliser quelques fois dans une m&amp;#233;thode sous la forme d&amp;#39;une expression, donc une forme de sous-fonction, c&amp;#39;est &amp;#233;viter tous ces probl&amp;#232;mes.   Et cela rend aussi le code plus lisible et plus maintenable ... sans le niveler par le bas Smile !  R&amp;#233;pondre Madame Madame  22/05/2015 16:13:26 &amp;gt;&amp;gt;... sans le niveler par le bas  D’o&amp;#249; l&amp;#39;expression, &amp;#224; bas le g&amp;#233;n&amp;#233;ral Nivell !  R&amp;#233;pondre sundown sundown  23/05/2015 23:52:27 A noter que la notion de sous-fonction est justement discut&amp;#233;e pour &amp;#234;tre &amp;#233;ventuellement int&amp;#233;gr&amp;#233;e dans C#7 / VB15.   Voir : https://github.com/dotnet/roslyn/issues/2930  R&amp;#233;pondre Olivier Olivier  24/05/2015 00:58:10 merci de l&amp;#39;info je ne l&amp;#39;avais pas vue.   Mais sinon c&amp;#39;est amusant qu&amp;#39;il faille attendre C#7 pour r&amp;#233;inventer progressivement Pascal...   la premi&amp;#232;re raison qui est donn&amp;#233;e est d&amp;#39;ailleurs explicite et c&amp;#39;est l&amp;#39;un des points que je pr&amp;#233;sente ici comme avantage des sous-fonctions :   &amp;quot;It is very common to write a helper method that is only used from one place, but it makes the code less clear to the reader because the association between the helper function and the thing it is helping is not explicit. Local functions makes the association part of the syntax.&amp;quot;   On a envie de dire &amp;quot;ben oui mon gars, c&amp;#39;est dans Pascal depuis les ann&amp;#233;es 60 !&amp;quot;   J&amp;#39;ai not&amp;#233; qu&amp;#39;h&amp;#233;las la d&amp;#233;claration de type local ne sera pas (encore?) autoris&amp;#233;e alors que Pascal le permet. Il faudra sans doute attendre C# 8 ou 9.   J&amp;#39;adore la modernit&amp;#233; de C# mais le p&amp;#232;re de Delphi et de Turbo Pascal a trop voulu rompre avec le pass&amp;#233; en abandonnant nombre de bonnes id&amp;#233;es qui finalement sont r&amp;#233;int&amp;#233;gr&amp;#233;es avec 10 ans de retard.  C&amp;#39;est un peu b&amp;#234;te ce parti pris de la rupture pour revenir sur ce qui &amp;#233;tait bon.   Pascal comme Delphi ont montr&amp;#233; leurs limites et C# les explose comme il explose C, C++ et java.  Mais Pascal reste malgr&amp;#233; tout une base solide, il y avait beaucoup &amp;#224; ajouter certes mais il n&amp;#39;y avait rien &amp;#224; enlever ! Anders aurait gagn&amp;#233; du temps en reprenant tout Delphi et en ajoutant juste Linq et les Lambda, il aurait fait un C#10 &amp;#224; la premi&amp;#232;re version Smile   Avec C#7 on se rapprochera encore un peu plus de cette r&amp;#233;int&amp;#233;gration du travail de Wirth...  R&amp;#233;pondre aaaa aaaa  27/05/2015 13:52:58 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA  Ajouter un commentaire Nom*  E-mail*  Site Internet  Pays    Country flag  trois fois (5*2)   Notifier quand de nouveaux commentaires sont ajout&amp;#233;s  Accueil   Archive   Souscrire   Se connecter  &amp;#169; 2015 Dot.Blog ShareThis Copy and Paste - See more at: http://www.e-naxos.com/Blog/post/C-Quick-Tip.aspx#sthash.n9MZyudr.dpuf ----------------------------------------------------------------------------------------------------------------------------------------------- Dot.Blog  C# XAML WINDOWS &amp;amp; ANDROID 28  mai        Souscrire       Contact  Archive      e-naxos   Olivier Dahan MVP Windows Platform Development 2015 MVP Client Development 2014 MVP Silverlight 2013, 2012, 2011,  MVP CAD 2010, MVP C# 2009   Membre du Developer Guidance Advisory Council Microsoft  Audit, Conseil, Formation, D&amp;#233;veloppement [WPF, WinRT, Xamarin Android]    Olivier sur Google+  Nuage th&amp;#233;matique Android article asp.net asynchronisme blend c# cloud data debug design edm expression F# framework humeur internet iOS liens linq linux livres m&amp;#233;thodologie metro microsoft mobile modernUI monodroid musique mvp mvvm mvvmcross prism riaservices securit&amp;#233; silverlight Surface tablet techdays teched threading ux vs2008 vs2010 vs2012 wcf windows windows7 windows8 WindowsStore WinRT wp7 wp8 wpf Xamarin Xamarin.Forms xaml Historique 2015 mai (4) avril (2) mars (6) f&amp;#233;vrier (3) janvier (7) 2014 2013 2012 2011 2010 2009 2008 2007 Archives Les archives compl&amp;#232;tes de Dot.Blog  Pages sp&amp;#233;ciales ALL.DOT.BLOG PDF Gratuits ! Apprendre C#/Xaml Comprendre et Appliquer MVVM Cross-Plateforme Exemples Silverlight Newsletter Recevoir une notification lorsqu&amp;#39;un nouvel article est publi&amp;#233;  Entrez votre e-mail   | Windows 10, le dernier Windows selon Microsoft &amp;gt;&amp;gt; C# Quick Tip Read this article in your language IT | EN | DE | ES NewVite fait, un peu de C# et un rappel sur la fa&amp;#231;on d’&amp;#233;crire du code de type “inline” ou de recr&amp;#233;er les sous-fonctions du Pascal qui n’existent pas.  Quick c’est quick, c’est m&amp;#234;me fast Pas de blabla, il suffit de regarder le code ci-dessous avec un exemple de la sortie produite pour comprendre tout l’int&amp;#233;r&amp;#234;t de ce style d’&amp;#233;criture. D&amp;#233;finir une fonction (ou m&amp;#233;thode) dans une autre est certainement la chose la plus int&amp;#233;ressante de mon point vue. Ancien Pascalien, j’ai toujours trouv&amp;#233; dommage qu’il faille d&amp;#233;clarer une m&amp;#233;thode private de plus juste pour d&amp;#233;couper un algorithme l&amp;#224; o&amp;#249; des sous-fonctions sont milles fois plus efficaces.  Au fil de ses &amp;#233;volutions C# s’est tellement sophistiqu&amp;#233; qu’on peut presque tout faire, m&amp;#234;me des sous-fonction &amp;#224; la Pascal.  Bref voici le code copier tout droit de LinqPad dont on ne dit jamais assez de bien :      //calcul var add = new Func&amp;lt;int,int,int&amp;gt;((i,ii)=&amp;gt;{return i+ii;}); var a1 = add(add(add(1,2),3),4); Console.WriteLine(add(5,8)+&amp;quot; &amp;quot;+a1);  //cha&amp;#238;nes var normalize = new Func&amp;lt;string,string&amp;gt;((s)=&amp;gt;{return s.Trim().ToUpper();}); var c=&amp;quot;    test   &amp;quot;; Console.WriteLine(&amp;quot;&amp;gt;&amp;quot;+normalize(c)+&amp;quot;&amp;lt;&amp;quot;);  // dicos var dico = new Func&amp;lt;Dictionary&amp;lt;int,string&amp;gt;&amp;gt;(()=&amp;gt; {     return new Dictionary&amp;lt;int,string&amp;gt;      {         {0,&amp;quot;z&amp;#233;ro&amp;quot;},         {1,&amp;quot;un&amp;quot;},         {2,&amp;quot;deux&amp;quot;},         {3,&amp;quot;trois&amp;quot;}     }; })();  Console.WriteLine(dico[2]);  // multiplier + tostring Func&amp;lt;int,int,string&amp;gt; AddToStr = (i,ii) =&amp;gt; (i+ii).ToString();  var x = &amp;quot;5+3= &amp;quot;+AddToStr(5,3); Console.WriteLine(x);  // sans param et cha&amp;#238;nage Func&amp;lt;string&amp;gt; TenBlankChars = ()=&amp;gt; new string(&amp;#39; &amp;#39;,10); var k = &amp;quot;1&amp;quot;+TenBlankChars()+&amp;quot;2&amp;quot;; Console.WriteLine(&amp;quot;k: &amp;#39;{0}&amp;#39; Longueur: {1}&amp;quot;,k,k.Length); Func&amp;lt;string&amp;gt; OneCol = () =&amp;gt; TenBlankChars()+&amp;quot;|&amp;quot;; Func&amp;lt;string&amp;gt; TenCol = () =&amp;gt; string.Concat(Enumerable.Repeat(OneCol(),10));  Console.WriteLine(TenCol());   Et voici la sortie :  13 10 &amp;gt;TEST&amp;lt; deux 5+3= 8 k: &amp;#39;1          2&amp;#39; Longueur: 12           |          |          |          |          |          |          |          |          |          |   Conclusion Quick, c’est quick.  Pas de r&amp;#233;v&amp;#233;lation choc ici, mais juste un petit rappel de la puissance de C# car je ne vois que tr&amp;#232;s rarement du code utiliser ce type d’&amp;#233;criture pourtant tr&amp;#232;s efficace et &amp;#233;vitant souvent la cr&amp;#233;ation de m&amp;#233;thodes priv&amp;#233;es utilis&amp;#233;es une seule fois et qui polluent les classes.  Si vous le saviez, et bien servez-vous en ! Et si vous aviez zapp&amp;#233; cet aspect de la syntaxe de C#, adoptez-le sans tarder !  Et Stay Tuned :  Post&amp;#233; le 18 mai 2015 | Permalink | Trackback  Tags: c# Commentaires (8) - R&amp;#233;pondre dfiad77pro dfiad77pro  19/05/2015 09:06:30 Le soucis de ce genre de code dans beaucoup d&amp;#39; entreprises c&amp;#39;est qu&amp;#39;il beaucoup de personnes qui ne connaissent presque rien &amp;#224; C# qui vont potentiellement relire le code...   Bref faut niveler son code pour le rendre compr&amp;#233;hensible par des gens qui en ont rien &amp;#224; faire !    Bref quand on voit que il y&amp;#39;en a qui font m&amp;#234;me pas l&amp;#39;effort d’apprendre Linq et les expression Lambda, ce truc &amp;#224; au moins l&amp;#39;avantage de les forcer &amp;#224; explorer le potentiel de C#...  R&amp;#233;pondre C&amp;amp;#233;dric C&amp;#233;dric  19/05/2015 23:13:49 Je suis d&amp;#39;accord avec toi. Il est n&amp;#233;cessaire de nivel&amp;#233; le code par le bas pour qui soit compr&amp;#233;hensible par le plus grand nombre.   Par contre, bien que ce genre d&amp;#39;&amp;#233;criture ne proviendra pas d&amp;#39;un d&amp;#233;butant, elle reste accessible en lecture pour ces derniers.  Merci pour votre commentaire. Il est maintenant en attente de mod&amp;#233;ration Ajouter un commentaire Annuler la r&amp;#233;ponse du commentaire   Nom*  E-mail*  Site Internet  Pays    Country flag  trois fois (5*2)   Notifier quand de nouveaux commentaires sont ajout&amp;#233;s  R&amp;#233;pondre C&amp;amp;#233;dric C&amp;#233;dric  19/05/2015 23:11:07 Quelles sont les avantages de ce type de programmation?   Il n&amp;#39;y pas de question idiotes, juste des questions pos&amp;#233;es par des idiots.  R&amp;#233;pondre Olivier Olivier  21/05/2015 23:24:44 Un langage est un langage... il a sa syntaxe, sa grammaire. Quel est l&amp;#39;avantage de bien savoir parler fran&amp;#231;ais alors qu&amp;#39;avec 200 ou 300 mots on peut se faire comprendre pour l&amp;#39;essentiel...   je crois que les deux choses sont &amp;#233;quivalentes. un langage informatique n&amp;#39;est pas un accessoire dont la connaissance est superflue. On doit connaitre le langage qu&amp;#39;on utilise et donc savoir en utiliser toutes les facettes.   Je suis d&amp;#39;accord sur le &amp;quot;nivellement par le bas&amp;quot; mais je ne l&amp;#39;exprimerais pas comme &amp;#231;a. Un code doit &amp;#234;tre lisible et maintenable. C&amp;#39;est &amp;#231;a qui compte.  Le pr&amp;#233;alable est que la personne qui lise ou maintienne soit comp&amp;#233;tente. On ne peut pas &amp;#233;crire un code idiot pour des idiots, mais on doit se forcer &amp;#224; &amp;#233;crire un code intelligent et lisible.   Par exemple je connais des d&amp;#233;veloppeurs qui roulent des m&amp;#233;caniques en &amp;#233;crivant des formules sans utiliser les parenth&amp;#232;ses, juste parce que connaitre la pr&amp;#233;c&amp;#233;dence des op&amp;#233;rateurs est pour eux le B.A.BA que tout le monde doit connaitre. Sauf que c&amp;#39;est illisible, que &amp;#231;a peut varier d&amp;#39;un langage &amp;#224; l&amp;#39;autre, et que c&amp;#39;est g&amp;#233;n&amp;#233;rateur d&amp;#39;erreurs. Il faut syst&amp;#233;matiquement mettre des parenth&amp;#232;ses dans les calculs pour s&amp;#39;assurer que tout le monde les comprend correctement et m&amp;#234;me qu&amp;#39;un portage dans un autre langage soit possible sans avoir des connaissances expertes du langage de d&amp;#233;part.   Donc ce genre de chose n&amp;#39;est pas lisible et tr&amp;#232;s peu maintenable on doit se l&amp;#39;interdire.   En revanche utiliser des expressions lambda ou LINQ en C# c&amp;#39;est naturel, c&amp;#39;est le langage !  Il faut l&amp;#39;&amp;#233;crire de fa&amp;#231;on lisible et maintenable mais se l&amp;#39;interdire pour un &amp;quot;nivellement par le bas&amp;quot; c&amp;#39;est une b&amp;#234;tise. Si C# est trop compliqu&amp;#233; alors il faut faire de l&amp;#39;assembleur ou du Basic.   Bref : oui &amp;#224; la lisibilit&amp;#233; et &amp;#224; la maintenabilit&amp;#233; car c&amp;#39;est essentiel, non au concept de &amp;quot;nivellement par le bas&amp;quot; qui ferait que certaines structures du langages seraient jug&amp;#233;es trop &amp;quot;intelligentes&amp;quot;. Car o&amp;#249; on s&amp;#39;arr&amp;#234;te si la limite c&amp;#39;est la connerie des gens ?  On sait qu&amp;#39;elle n&amp;#39;a pas de limite et on peut limiter C# autant qu&amp;#39;on veut on trouvera toujours un con qui avec si peu arrivera &amp;#224; faire des conneries...   Lisible mais pas nivel&amp;#233; par le bas donc.   Pour ce qui est de l&amp;#39;int&amp;#233;r&amp;#234;t des structures montr&amp;#233;es dans l&amp;#39;article il y en a plein ! En fran&amp;#231;ais il est possible d&amp;#39;exprimer la m&amp;#234;me chose de plusieurs fa&amp;#231;ons, ce qui permet de le faire avec nuance, avec joie ou tristesse, avec chaleur ou froideur etc.. Sans ces nuances on peut limiter comme je le disais le fran&amp;#231;ais &amp;#224; quelques mots, mais quelle monde fade !  C# c&amp;#39;est pareil, on peut arriver au m&amp;#234;me r&amp;#233;sultat de plusieurs fa&amp;#231;ons et cela permet de s&amp;#39;adapter non pas l&amp;#39;humeur de celui qui &amp;#233;crit mais &amp;#224; la stylistique g&amp;#233;n&amp;#233;rale de l&amp;#39;application, cela peut aider &amp;#224; la lisbilit&amp;#233; justement en rempla&amp;#231;ant des appels imbriqu&amp;#233;s &amp;#224; des tas de m&amp;#233;thodes par un seul corps de quelques lignes, etc.   Donc la richesse du langage C#,tout comme celle du fran&amp;#231;ais, est un avantage pour exprimer un code de la meilleure fa&amp;#231;on possible selon le contexte.   Plus prosa&amp;#239;quement on peut parler ensuite d&amp;#39;avantages techniques :  1) l&amp;#39;ex&amp;#233;cution &amp;quot;lazy&amp;quot;, le fait que sous la forme d&amp;#39;une expression certaines initialisations seront faites au dernier moment ce qui peut &amp;#234;tre un avantage sur une initialisation &amp;quot;en dur&amp;quot;. Pareil pour l&amp;#39;ex&amp;#233;cution d&amp;#39;un code.  2) Pascal permet les sous-fonctions par exemple. Delphi, cr&amp;#233;&amp;#233; par le p&amp;#232;re de C# le permettait donc. Mais pas C#. Et c&amp;#39;est une erreur &amp;#224; mon avis.  car souvent on a besoin de factoriser des petits bouts de traitement (par exemple faire un Trim() et passer en majuscule). Si on a 10 affectations qui doivent r&amp;#233;p&amp;#233;ter ce bout de code c&amp;#39;est laid, ouvert aux erreurs de copie, etc.  En C# la seule solution c&amp;#39;est de cr&amp;#233;er une m&amp;#233;thode priv&amp;#233;e et de l&amp;#39;appeler. Cela imbrique des appels (lenteur impos&amp;#233;e par la pile et la gestion des param&amp;#232;tres par ex), cela &amp;#233;clate le code en plusieurs m&amp;#233;thodes qui n&amp;#39;ont pas de raison d&amp;#39;&amp;#234;tre fonctionnelle (code spaghetti te voil&amp;#224; !) etc.  F&amp;#233;d&amp;#233;rer ces petits traitement utiliser quelques fois dans une m&amp;#233;thode sous la forme d&amp;#39;une expression, donc une forme de sous-fonction, c&amp;#39;est &amp;#233;viter tous ces probl&amp;#232;mes.   Et cela rend aussi le code plus lisible et plus maintenable ... sans le niveler par le bas Smile !  R&amp;#233;pondre Madame Madame  22/05/2015 16:13:26 &amp;gt;&amp;gt;... sans le niveler par le bas  D’o&amp;#249; l&amp;#39;expression, &amp;#224; bas le g&amp;#233;n&amp;#233;ral Nivell !  R&amp;#233;pondre sundown sundown  23/05/2015 23:52:27 A noter que la notion de sous-fonction est justement discut&amp;#233;e pour &amp;#234;tre &amp;#233;ventuellement int&amp;#233;gr&amp;#233;e dans C#7 / VB15.   Voir : https://github.com/dotnet/roslyn/issues/2930  R&amp;#233;pondre Olivier Olivier  24/05/2015 00:58:10 merci de l&amp;#39;info je ne l&amp;#39;avais pas vue.   Mais sinon c&amp;#39;est amusant qu&amp;#39;il faille attendre C#7 pour r&amp;#233;inventer progressivement Pascal...   la premi&amp;#232;re raison qui est donn&amp;#233;e est d&amp;#39;ailleurs explicite et c&amp;#39;est l&amp;#39;un des points que je pr&amp;#233;sente ici comme avantage des sous-fonctions :   &amp;quot;It is very common to write a helper method that is only used from one place, but it makes the code less clear to the reader because the association between the helper function and the thing it is helping is not explicit. Local functions makes the association part of the syntax.&amp;quot;   On a envie de dire &amp;quot;ben oui mon gars, c&amp;#39;est dans Pascal depuis les ann&amp;#233;es 60 !&amp;quot;   J&amp;#39;ai not&amp;#233; qu&amp;#39;h&amp;#233;las la d&amp;#233;claration de type local ne sera pas (encore?) autoris&amp;#233;e alors que Pascal le permet. Il faudra sans doute attendre C# 8 ou 9.   J&amp;#39;adore la modernit&amp;#233; de C# mais le p&amp;#232;re de Delphi et de Turbo Pascal a trop voulu rompre avec le pass&amp;#233; en abandonnant nombre de bonnes id&amp;#233;es qui finalement sont r&amp;#233;int&amp;#233;gr&amp;#233;es avec 10 ans de retard.  C&amp;#39;est un peu b&amp;#234;te ce parti pris de la rupture pour revenir sur ce qui &amp;#233;tait bon.   Pascal comme Delphi ont montr&amp;#233; leurs limites et C# les explose comme il explose C, C++ et java.  Mais Pascal reste malgr&amp;#233; tout une base solide, il y avait beaucoup &amp;#224; ajouter certes mais il n&amp;#39;y avait rien &amp;#224; enlever ! Anders aurait gagn&amp;#233; du temps en reprenant tout Delphi et en ajoutant juste Linq et les Lambda, il aurait fait un C#10 &amp;#224; la premi&amp;#232;re version Smile   Avec C#7 on se rapprochera encore un peu plus de cette r&amp;#233;int&amp;#233;gration du travail de Wirth...  R&amp;#233;pondre aaaa aaaa  27/05/2015 13:52:58 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA  R&amp;#233;pondre aaaa aaaa  28/05/2015 07:39:45 Dot.Blog  C# XAML WINDOWS &amp;amp; ANDROID 28  mai        Souscrire       Contact  Archive      e-naxos   Olivier Dahan MVP Windows Platform Development 2015 MVP Client Development 2014 MVP Silverlight 2013, 2012, 2011,  MVP CAD 2010, MVP C# 2009   Membre du Developer Guidance Advisory Council Microsoft  Audit, Conseil, Formation, D&amp;#233;veloppement [WPF, WinRT, Xamarin Android]    Olivier sur Google+  Nuage th&amp;#233;matique Android article asp.net asynchronisme blend c# cloud data debug design edm expression F# framework humeur internet iOS liens linq linux livres m&amp;#233;thodologie metro microsoft mobile modernUI monodroid musique mvp mvvm mvvmcross prism riaservices securit&amp;#233; silverlight Surface tablet techdays teched threading ux vs2008 vs2010 vs2012 wcf windows windows7 windows8 WindowsStore WinRT wp7 wp8 wpf Xamarin Xamarin.Forms xaml Historique 2015 mai (4) avril (2) mars (6) f&amp;#233;vrier (3) janvier (7) 2014 2013 2012 2011 2010 2009 2008 2007 Archives Les archives compl&amp;#232;tes de Dot.Blog  Pages sp&amp;#233;ciales ALL.DOT.BLOG PDF Gratuits ! Apprendre C#/Xaml Comprendre et Appliquer MVVM Cross-Plateforme Exemples Silverlight Newsletter Recevoir une notification lorsqu&amp;#39;un nouvel article est publi&amp;#233;  Entrez votre e-mail   | Windows 10, le dernier Windows selon Microsoft &amp;gt;&amp;gt; C# Quick Tip Read this article in your language IT | EN | DE | ES NewVite fait, un peu de C# et un rappel sur la fa&amp;#231;on d’&amp;#233;crire du code de type “inline” ou de recr&amp;#233;er les sous-fonctions du Pascal qui n’existent pas.  Quick c’est quick, c’est m&amp;#234;me fast Pas de blabla, il suffit de regarder le code ci-dessous avec un exemple de la sortie produite pour comprendre tout l’int&amp;#233;r&amp;#234;t de ce style d’&amp;#233;criture. D&amp;#233;finir une fonction (ou m&amp;#233;thode) dans une autre est certainement la chose la plus int&amp;#233;ressante de mon point vue. Ancien Pascalien, j’ai toujours trouv&amp;#233; dommage qu’il faille d&amp;#233;clarer une m&amp;#233;thode private de plus juste pour d&amp;#233;couper un algorithme l&amp;#224; o&amp;#249; des sous-fonctions sont milles fois plus efficaces.  Au fil de ses &amp;#233;volutions C# s’est tellement sophistiqu&amp;#233; qu’on peut presque tout faire, m&amp;#234;me des sous-fonction &amp;#224; la Pascal.  Bref voici le code copier tout droit de LinqPad dont on ne dit jamais assez de bien :      //calcul var add = new Func&amp;lt;int,int,int&amp;gt;((i,ii)=&amp;gt;{return i+ii;}); var a1 = add(add(add(1,2),3),4); Console.WriteLine(add(5,8)+&amp;quot; &amp;quot;+a1);  //cha&amp;#238;nes var normalize = new Func&amp;lt;string,string&amp;gt;((s)=&amp;gt;{return s.Trim().ToUpper();}); var c=&amp;quot;    test   &amp;quot;; Console.WriteLine(&amp;quot;&amp;gt;&amp;quot;+normalize(c)+&amp;quot;&amp;lt;&amp;quot;);  // dicos var dico = new Func&amp;lt;Dictionary&amp;lt;int,string&amp;gt;&amp;gt;(()=&amp;gt; {     return new Dictionary&amp;lt;int,string&amp;gt;      {         {0,&amp;quot;z&amp;#233;ro&amp;quot;},         {1,&amp;quot;un&amp;quot;},         {2,&amp;quot;deux&amp;quot;},         {3,&amp;quot;trois&amp;quot;}     }; })();  Console.WriteLine(dico[2]);  // multiplier + tostring Func&amp;lt;int,int,string&amp;gt; AddToStr = (i,ii) =&amp;gt; (i+ii).ToString();  var x = &amp;quot;5+3= &amp;quot;+AddToStr(5,3); Console.WriteLine(x);  // sans param et cha&amp;#238;nage Func&amp;lt;string&amp;gt; TenBlankChars = ()=&amp;gt; new string(&amp;#39; &amp;#39;,10); var k = &amp;quot;1&amp;quot;+TenBlankChars()+&amp;quot;2&amp;quot;; Console.WriteLine(&amp;quot;k: &amp;#39;{0}&amp;#39; Longueur: {1}&amp;quot;,k,k.Length); Func&amp;lt;string&amp;gt; OneCol = () =&amp;gt; TenBlankChars()+&amp;quot;|&amp;quot;; Func&amp;lt;string&amp;gt; TenCol = () =&amp;gt; string.Concat(Enumerable.Repeat(OneCol(),10));  Console.WriteLine(TenCol());   Et voici la sortie :  13 10 &amp;gt;TEST&amp;lt; deux 5+3= 8 k: &amp;#39;1          2&amp;#39; Longueur: 12           |          |          |          |          |          |          |          |          |          |   Conclusion Quick, c’est quick.  Pas de r&amp;#233;v&amp;#233;lation choc ici, mais juste un petit rappel de la puissance de C# car je ne vois que tr&amp;#232;s rarement du code utiliser ce type d’&amp;#233;criture pourtant tr&amp;#232;s efficace et &amp;#233;vitant souvent la cr&amp;#233;ation de m&amp;#233;thodes priv&amp;#233;es utilis&amp;#233;es une seule fois et qui polluent les classes.  Si vous le saviez, et bien servez-vous en ! Et si vous aviez zapp&amp;#233; cet aspect de la syntaxe de C#, adoptez-le sans tarder !  Et Stay Tuned :  Post&amp;#233; le 18 mai 2015 | Permalink | Trackback  Tags: c# Commentaires (8) - R&amp;#233;pondre dfiad77pro dfiad77pro  19/05/2015 09:06:30 Le soucis de ce genre de code dans beaucoup d&amp;#39; entreprises c&amp;#39;est qu&amp;#39;il beaucoup de personnes qui ne connaissent presque rien &amp;#224; C# qui vont potentiellement relire le code...   Bref faut niveler son code pour le rendre compr&amp;#233;hensible par des gens qui en ont rien &amp;#224; faire !    Bref quand on voit que il y&amp;#39;en a qui font m&amp;#234;me pas l&amp;#39;effort d’apprendre Linq et les expression Lambda, ce truc &amp;#224; au moins l&amp;#39;avantage de les forcer &amp;#224; explorer le potentiel de C#...  R&amp;#233;pondre C&amp;amp;#233;dric C&amp;#233;dric  19/05/2015 23:13:49 Je suis d&amp;#39;accord avec toi. Il est n&amp;#233;cessaire de nivel&amp;#233; le code par le bas pour qui soit compr&amp;#233;hensible par le plus grand nombre.   Par contre, bien que ce genre d&amp;#39;&amp;#233;criture ne proviendra pas d&amp;#39;un d&amp;#233;butant, elle reste accessible en lecture pour ces derniers.  R&amp;#233;pondre C&amp;amp;#233;dric C&amp;#233;dric  19/05/2015 23:11:07 Quelles sont les avantages de ce type de programmation?   Il n&amp;#39;y pas de question idiotes, juste des questions pos&amp;#233;es par des idiots.  R&amp;#233;pondre Olivier Olivier  21/05/2015 23:24:44 Un langage est un langage... il a sa syntaxe, sa grammaire. Quel est l&amp;#39;avantage de bien savoir parler fran&amp;#231;ais alors qu&amp;#39;avec 200 ou 300 mots on peut se faire comprendre pour l&amp;#39;essentiel...   je crois que les deux choses sont &amp;#233;quivalentes. un langage informatique n&amp;#39;est pas un accessoire dont la connaissance est superflue. On doit connaitre le langage qu&amp;#39;on utilise et donc savoir en utiliser toutes les facettes.   Je suis d&amp;#39;accord sur le &amp;quot;nivellement par le bas&amp;quot; mais je ne l&amp;#39;exprimerais pas comme &amp;#231;a. Un code doit &amp;#234;tre lisible et maintenable. C&amp;#39;est &amp;#231;a qui compte.  Le pr&amp;#233;alable est que la personne qui lise ou maintienne soit comp&amp;#233;tente. On ne peut pas &amp;#233;crire un code idiot pour des idiots, mais on doit se forcer &amp;#224; &amp;#233;crire un code intelligent et lisible.   Par exemple je connais des d&amp;#233;veloppeurs qui roulent des m&amp;#233;caniques en &amp;#233;crivant des formules sans utiliser les parenth&amp;#232;ses, juste parce que connaitre la pr&amp;#233;c&amp;#233;dence des op&amp;#233;rateurs est pour eux le B.A.BA que tout le monde doit connaitre. Sauf que c&amp;#39;est illisible, que &amp;#231;a peut varier d&amp;#39;un langage &amp;#224; l&amp;#39;autre, et que c&amp;#39;est g&amp;#233;n&amp;#233;rateur d&amp;#39;erreurs. Il faut syst&amp;#233;matiquement mettre des parenth&amp;#232;ses dans les calculs pour s&amp;#39;assurer que tout le monde les comprend correctement et m&amp;#234;me qu&amp;#39;un portage dans un autre langage soit possible sans avoir des connaissances expertes du langage de d&amp;#233;part.   Donc ce genre de chose n&amp;#39;est pas lisible et tr&amp;#232;s peu maintenable on doit se l&amp;#39;interdire.   En revanche utiliser des expressions lambda ou LINQ en C# c&amp;#39;est naturel, c&amp;#39;est le langage !  Il faut l&amp;#39;&amp;#233;crire de fa&amp;#231;on lisible et maintenable mais se l&amp;#39;interdire pour un &amp;quot;nivellement par le bas&amp;quot; c&amp;#39;est une b&amp;#234;tise. Si C# est trop compliqu&amp;#233; alors il faut faire de l&amp;#39;assembleur ou du Basic.   Bref