C# – Bases, culture et pédagogie

Comme tous les langages, C# a son lot de particularités techniques et culturelles. Cette page en liste quelques-unes, sans avoir la moindre prétention d'exhaustivité.

Ressources et textes d'introduction

• Foire aux questions sur C# pour programmeurs C++ : http://andymcm.com/csharpfaq.htm
• Pièges en C# pour programmeurs C++, Par Punit Ganshani en 2009 : http://www.ganshani.com/2009/07/ten-traps-in-c-for-c-programmers/
• Petit défi interactif, qui vous invite à prédire ce qu'afficheront les programmes C# qui vous sont proposés : http://www.volatileread.com/wiki/Index?id=1073
• Le Wiki : http://en.wikipedia.org/wiki/C_Sharp_%28programming_language%29
• Un « Wikilivre » : http://en.wikibooks.org/wiki/C_Sharp_Programming
• Outil d'aide à l'écriture de programmes C# :
  • le Bing Code Search for C# :
    • http://blogs.msdn.com/b/visualstudio/archive/2014/02/17/introducing-bing-code-search-for-c.aspx
    • http://blogs.technet.com/b/inside_microsoft_research/archive/2014/02/17/bing-code-search-makes-developers-more-productive.aspx
  • le .NET Reference Source :
    • http://blogs.msdn.com/b/dotnet/archive/2014/02/24/a-new-look-for-net-reference-source.aspx
  • projet de recherche par lequel les questions placées en commentaires son remplacées par des propositions de solutions dans le code source : http://codesnippet.research.microsoft.com/
• Quelques sites pleins de trucs divers pour tirer profit de ce langage :
  • C# Corner : http://www.c-sharpcorner.com/
  • C# Help : http://www.csharphelp.com/
  • C# Station : http://www.csharp-station.com/
  • Master C# : http://www.mastercsharp.com/
  • Hitmill C# Programming : http://www.hitmill.com/programming/dotNET/csharp.html

Généralités

Liens vers diverses considérations d'ordre général :

• Spécification du langage : http://msdn.microsoft.com/en-us/library/ms228593
• Tour d'horizon du langage : http://msdn.microsoft.com/en-us/vcsharp/aa336809.aspx
• Brève histoire du langage, par Eric Lippert en 2014 : http://www.developer-tech.com/news/2014/jan/30/past-present-and-future-c/
• Ce qu'un programmeur C ou C++ doit savoir à propos de C# et de la plateforme .NET : http://www.charlespetzold.com/dotnet/
• Questions pièges :
  • http://www.yoda.arachsys.com/csharp/teasers.html?0
  • http://www.codeproject.com/KB/cs/Quiz_CShapDotNETSecrets.aspx
  • http://www.johndcook.com/blog/2010/06/08/c-math-gotchas/
  • http://www.microsoftvirtualacademy.com/training-courses/twenty-c-questions-explained?prid=20Q
  • Quelques questions pièges sur le langage, colligées par Sunny Ahuwanya :
  • http://www.ahuwanya.net/blog/post/C-Brainteasers-Part-I
  • http://ahuwanya.net/blog/post/C-Sharp-Brainteasers-Part-2
  • Pouvez-vous prédire ce que ces programmes produiront comme résultat? Par K. Bonneau :
    • http://volatileread.com/Wiki?id=1073
    • http://volatileread.com/Wiki?id=1074
    • http://volatileread.com/Wiki?id=2092
    • http://volatileread.com/Wiki?id=2102
    • http://volatileread.com/Wiki/index?id=2108
• Apprendre C#, une série d'articles par Jeremy Morgan :
  • texte d'introduction : http://www.jeremymorgan.com/tutorials/c-sharp/how-to-learn-c-sharp-part-1/
  • les espaces nommés : http://www.jeremymorgan.com/tutorials/c-sharp/how-to-learn-c-sharp-part-2-namespaces/
  • quelques bases pour ce qui est de la compilation : http://www.jeremymorgan.com/tutorials/c-sharp/how-to-learn-c-sharp-part-3-coding-basics/
• Psychologie des programmeuses et des programmeurs C#, par Eric Lippert en 2013 : http://fr.slideshare.net/Coverity/the-psychology-of-c-analysis-24025354
• Dix erreurs typiques que font les programmeurs C#, par Patrick Ryder en 2014 : http://www.toptal.com/c-sharp/top-10-mistakes-that-c-sharp-programmers-make
• Le langage C# est en partie de « haut » niveau et en partie de « moins haut » niveau. Réflexions d'Eric Lippert en 2014 :
  • http://ericlippert.com/2014/04/28/lowering-in-language-design-part-one/
  • dans ce texte de 2014, Eric Lippert explique que C# n'exige pas que toutes ses caractéristiques de haut niveau puissent être exprimées par ses caractéristiques de bas niveau (la « magie » y est admissible, sur le plan philosophique), mais qu'il demeure sympathique de pouvoir le faire. Il explique ensuite qu'avec C# v. 6.0, la possibilité d'introduire des déclarations de variables dans une expression permet désormais d'exprimer as dans le langage : http://ericlippert.com/2014/05/01/lowering-in-language-design-part-two/
• Plaidoyer de Nico Schuele en 2014 pour apprendre à programmer avec C# : http://www.nicoschuele.com/posts/teach-yourself-to-code-with-c-and-net
• Dix conseils pour programmeurs C#, par V. N. S. Arun en 2014 : http://www.developer.com/net/top-10-tips-for-c-programmers.html
• L'enfer est pavé de bonnes intentions, comme le montre cette courte série d'articles par Eric Lippert en 2014 sur les règles de nommage imbriquées en C# :
  • http://ericlippert.com/2014/09/25/confusing-errors-for-a-confusing-feature-part-one/
  • http://ericlippert.com/2014/09/29/confusing-errors-for-a-confusing-feature-part-two/
  • http://ericlippert.com/2014/10/03/confusing-errors-for-a-confusing-feature-part-three/
• Abuser de certains mécanismes du langage, texte pervers de Jon Skeet en 2014 : http://codeblog.jonskeet.uk/2014/10/23/violating-the-smart-enum-pattern-in-c/
• Les fichiers de configuration App.config et Web.config d'un programme C#, expliqués par Erik Schierboom en 2015 : http://www.erikschierboom.com/2015/02/01/config-files/

Technique

Liens vers diverses considérations d'ordre technique :

• Quelques idées et quelques trucs : http://h-deb.ca/Sujets/Divers--cdiese/index.html
• Programmation fonctionnelle avec C# : ../../Liens/Paradigmes-programmation--Liens.html#programmation_fonctionnelle_par_langage
  • les monades avec C# : Paradigmes-programmation--Liens.html#monades_Cdiese
• À propos des régions de C# :
  • http://blog.nebyoolae.com/i-dont-say-anything-to-c-regions-actually-because-theyre-inanimate-constructs/
• Utiliser sainement la mémoire : Gestion-memoire--Liens.html#collecte_ordures_pointnet
• Utiliser un pipeline d'opérations : http://www.lexparse.com/2009/11/10/c-pipelining-extend-object-with-pipe/
• Quelques trucs moins connus du langage : http://www.koushikdutta.com/2009/02/learn-something-new-every-day.html?FuckYeahNarwals
• Quelques factoïdes sur C#, relevés par Damien Guard en 2012 : http://damieng.com/blog/2012/10/29/8-things-you-probably-didnt-know-about-csharp
• Les continuations avec yield return : http://altdevblogaday.com/2011/07/07/unity3d-coroutines-in-detail/
• Définir une initialisation spécialisée pour une collection, par Marius Schulz en 2014 : http://blog.mariusschulz.com/2014/06/26/fun-with-custom-c-collection-initializers
• Blocks blocs checked et unchecked :
  • ce qu'ils font et – surtout – ce qu'ils ne font pas, par Raymond Chen en 2014 : http://blogs.msdn.com/b/oldnewthing/archive/2014/08/15/10550205.aspx
  • à quoi sert unchecked, textes d'Eric Lippert en 2015 :
    • http://ericlippert.com/2015/04/09/what-is-the-unchecked-keyword-good-for-part-one/
    • http://ericlippert.com/2015/04/13/what-is-the-unchecked-keyword-good-for-part-two/
• Implémenter un « with » inspiré des pratiques de F# mais pour les collections immuables de C#, un texte de 2014 : http://productiverage.com/implementing-f-sharp-inspired-with-updates-for-immutable-classes-in-c-sharp
• Quelle est la différence entre string et String? Euh... Texte de 2015 : http://manyrootsofallevilrants.blogspot.co.uk/2015/01/string-vs-string-in-c.html
• Compiler C# avec LLVM, par Mukul Sabharwal en 2015 : http://www.llvmsharp.org/
• Cas d'utilisation du mot clé static en C#, texte du Code Project par Priyank Modi en 2015 : http://www.codeproject.com/Articles/891433/Must-Remember-Key-concepts-to-Keyword-Static (voir aussi les constructeurs de classe)
• Quelques trucs et outils « cachés » de C#, texte du Code Project par Anton Angelov en 2015 : http://www.codeproject.com/Articles/1021335/Top-Hidden-Features-of-Csharp

Compilation

À propos de la mécanique de compilation en C# et des détails d'ordre plus syntaxique du langage :

• Utiliser le compilateur C# de Mono en tant que service pour cycle REPL (Read, Evaluate, Print, Loop) : http://amazedsaint.blogspot.com/2010/09/how-to-host-monos-csharp-compiler-in.html
• http://amazedsaint.blogspot.com/2010/09/dynamic-filtering-and-querying-in-your.html
• http://amazedsaint.blogspot.com/2010/09/c-as-scripting-language-in-your-net.html
• Traiter le compilateur comme un service, texte de Miguel de Icaza en 2011 : http://tirania.org/blog/archive/2011/Feb-24.html
• Dans quelles circonstances une instruction est elle considérée comme hors d'atteinte par un compilateur C#? Texte d'Eric Lippert en 2013 : http://blog.coverity.com/2013/11/06/c-reachability/
• Mots clés et mots clés contextuels de C#, listés par Eric Lippert en 2009 : http://ericlippert.com/2009/05/11/reserved-and-contextual-keywords/
• Développer en mode interactif avec C#, à l'aide de Roslyn et de RyuJIT :
  • http://blog.filipekberg.se/2011/11/14/using-the-c-interactive-window-that-comes-with-roslyn/
  • http://blog.csharp-tutor.com/2011/11/25/using-the-c-interactive-window-that-comes-with-roslyn-part-2/
  • http://joshvarty.wordpress.com/2014/03/09/why-roslyn-is-a-bigdeal/
  • http://blogs.msdn.com/b/dotnet/archive/2014/02/27/ryujit-ctp2-getting-ready-for-prime-time.aspx
• Les identifiants verbatim, précédés d'un @, texte d'Eric Lippert en 2013 : http://ericlippert.com/2013/09/09/verbatim-identifiers/

Concurrence

• Implémenter un regroupement d'objets concurrents : http://dzmitryhuba.blogspot.com/2011/05/concurrent-object-pool.html
• Appliquer des timeouts génériques sur l'exécution de méthodes : http://kossovsky.net/index.php/2009/07/csharp-how-to-limit-method-execution-time/?settiemeout
• Le sens à donner au mot clé fixed, texte d'Eric Lippert en 2012 : http://ericlippert.com/2012/12/11/taking-responsibility/
• Les moniteurs avec C#, série par Eric Lippert en 2015 :
  • http://ericlippert.com/2015/11/16/monitor-madness-part-one/
  • http://ericlippert.com/2015/11/19/monitor-madness-part-two/ (qui discute entre autres de la question des réveils intempestifs, ou Spurious Wakeups)
• Exemples de programmation concurrente avec async et await : async_await.html

Constantes

• Avec C#, certaines constantes sont moins constantes que d'autres. Texte de Jon Skeet en 2014 : http://codeblog.jonskeet.uk/2014/08/22/when-is-a-constant-not-a-constant-when-its-a-decimal/

Conteneurs et collections

• Conteneurs et collections :
  • quand utiliser IEnumerable, ICollection, IList et List, un texte de 2013 par Claudio Bernasconi : http://www.claudiobernasconi.ch/2013/07/22/when-to-use-ienumerable-icollection-ilist-and-list/
  • collections immuables :
    • programmer efficacement avec des collections immuables, par Craig Gidney en 2012 : http://twistedoakstudios.com/blog/Post1585_linq-to-collections-beyond-ienumerablet
    • le type ImmutableArray<T>, décrit par Immo Landwerth en 2013 : http://blogs.msdn.com/b/dotnet/archive/2013/06/24/please-welcome-immutablearray.aspx
• En 2013, Eric Lippert explique un irritant conceptuel avec foreach, dû au fait que cet outil a été implémenté avant que C# ne supporte la programmation générique : http://ericlippert.com/2013/07/22/why-does-a-foreach-loop-silently-insert-an-explicit-conversion/
• En 2014, MultiValueDictionary remplace MultiDictionary. Texte de Ian Hays : http://blogs.msdn.com/b/dotnet/archive/2014/08/05/multidictionary-becomes-multivaluedictionary.aspx
• Comparer ConcurrentHashMap et Collections.synchronizedMap, par Pi Ke en 2014 : http://www.pixelstech.net/article/index.php?id=1394026282
• Écrire un vecteur immuable et rapide avec C#, par Jules Jacobs en 2014 : http://julesjacobs.github.io/2014/11/11/immutable-vectors-csharp.html
• Selon Jacob Krall en 2016, en C#, tout ensemble peut être utilisé à titre de prédicat : http://jacob.jkrall.net/sets-are-predicates/

Encapsulation

• Constructeurs, destructeurs et C# :
  • comprendre l'ordre de construction et l'ordre d'initialisation dans ce langage :
    • http://blogs.msdn.com/b/ericlippert/archive/2008/02/15/why-do-initializers-run-in-the-opposite-order-as-constructors-part-one.aspx
    • http://blogs.msdn.com/b/ericlippert/archive/2008/02/18/why-do-initializers-run-in-the-opposite-order-as-constructors-part-two.aspx
  • discussion sur l'ordre d'initialisation des états en C#, par Jon Skeet : http://csharpindepth.com/Articles/General/Beforefieldinit.aspx
  • à propos des constructeurs de classe (constructeurs static) :
    • en 2013, Eric Lippert montre qu'une utilisation naïve des constructeurs de classe peut mener à un interblocage : http://ericlippert.com/2013/01/31/the-no-lock-deadlock/
    • texte de 2013 par Eric Lippert indiquant le moment où ces méthodes sont réellemment appelées : http://ericlippert.com/2013/02/06/static-constructors-part-one/
    • en 2013, Eric Lippert sur ce qui se produit quand un constructeur de classe lève une exception : http://ericlippert.com/2013/02/11/static-constructors-part-two/
    • texte de 2013 par Eric Lippert qui explique ce que fait le compilateur C# dans une classe qui n'a pas de constructeur de classe : http://ericlippert.com/2013/02/14/static-constructors-part-three/
    • texte de 2013 par Eric Lippert qui explique ce qui devrait être fait dans un constructeur de classe... et ce qui ne devrait pas y être fait : http://ericlippert.com/2013/02/18/static-constructors-part-four/
  • à propos des constructeurs d'instances :
    • textes de 2008 par Eric Lippert expliquant la nuance entre ordre de construction et ordre d'initialisation : http://blogs.msdn.com/b/ericlippert/archive/2008/02/15/why-do-initializers-run-in-the-opposite-order-as-constructors-part-one.aspx et http://blogs.msdn.com/b/ericlippert/archive/2008/02/18/why-do-initializers-run-in-the-opposite-order-as-constructors-part-two.aspx
    • comprendre l'interaction entre les constructeurs, les « finaliseurs » et les effets de bord en C#, texte d'Eric Lippert en 2013 : http://ericlippert.com/2013/06/10/construction-destruction/
  • à propos des finaliseurs de C# :
    • comment fonctionne la finalisation avec .NET, et pourquoi elle coûte cher sur cette plateforme, par Chris Brumme en 2004 : http://blogs.msdn.com/b/cbrumme/archive/2004/02/20/77460.aspx
    • textes d'Eric Lippert en 2015, qui suggère que « tout ce que vous savez à ce sujet est faux » :
      •  http://ericlippert.com/2015/05/18/when-everything-you-know-is-wrong-part-one/
      • http://ericlippert.com/2015/05/21/when-everything-you-know-is-wrong-part-two/
  • réflexivité, constructeurs et paramètres par défaut, par Eric Lippert en 2013 : https://communities.coverity.com/blogs/development-testing-blog/2013/09/11/c-bug
• Classes partielles :
  • applications des classes partielles avec C#, texte du Code Project par Shivprasad Koirala en 2012 : http://www.codeproject.com/Articles/313352/4-real-time-use-of-Partial-classes-and-partial-met
  • application spécifique des classes partielles, proposée par Elliot Balynn en 2015 : http://ireadable.com/2015/01/08/a-use-for-partial-classesstructs/
• Un membre d'instance d'une classe sealed et internal devrait-il préférablement être qualifié internal ou public? Position d'Eric Lippert en 2014 : http://ericlippert.com/2014/09/15/internal-or-public/

Fonctions et méthodes

• Texte d'Eric Lippert en 2009 expliquant pourquoi un paramètre par valeur en C# peut être du type exact demandé dans la signature de la méthode appelée, ou encore de tout type qui y serait implicitement convertible, alors qu'un paramètre out ou ref doit être du type exact demandé, point à la ligne : http://blogs.msdn.com/b/ericlippert/archive/2009/09/21/why-do-ref-and-out-parameters-not-allow-type-variation.aspx
• Méthodes d'extension :
  • Introduction aux méthodes d'extension avec C#, un texte de Kenneth Parker en 2013 : http://startingdotneprogramming.blogspot.ca/2013/04/extension-methods.html
  • Les méthodes d'extension, expliquées par Erik Schierboom en 2014 : http://www.erikschierboom.com/2014/06/23/extension-methods-an-introduction/
  • Les méthodes d'extension, thématiques avancées selon Erik Schierboom en 2014 : http://www.erikschierboom.com/2014/07/07/extension-methods-advanced/
  • Tirer profit des méthodes d'extension, un texte de Peter Vogel en 2014 : http://visualstudiomagazine.com/articles/2014/08/01/leveraging-interfaces.aspx
  • Selon Alan Zucconi en 2015, les méthodes d'extension sont ce que C# propose de mieux : http://www.alanzucconi.com/2015/08/05/extension-methods-in-c/
  Fonctions anonymes, texte de Filip Ekberg en 2010 : http://blog.filipekberg.se/2011/10/05/making-code-more-readable-with-anonymous-functions/
• Paramètres nommés et lisibilité, par Rod Howarth en 2012 : http://blog.rodhowarth.com/2012/06/using-c-named-parameters-for-code.html
• Surcharge de méthodes, texte de Jon Skeet en 2012 : http://csharpindepth.com/Articles/General/Overloading.aspx
• En 2013, Eric Lippert explique comment le compilateur C# choisit au point d'appel entre plusieurs méthodes du même nom : http://ericlippert.com/2013/12/23/closer-is-better/

Héritage

• Texte de Jon Skeet en 2016 expliquant ce qu'il estime être un problème terminologique dans la description de la mécanique par laquelle un constructeur d'une classe enfant appelle implicitement le constructeur par défaut de son parent : http://codeblog.jonskeet.uk/2016/01/08/to-base-or-not-to-base-that-is-the-question/

Interfaces

• Interfaces, implémentation et code généré à la compilation, un texte d'Eric Lippert en 2013 : http://ericlippert.com/2013/05/23/the-mystery-of-the-inserted-method/
• Interfaces publiques et méthodes privées, les règles en C#, par Eric Lippert en 2013 : http://blog.coverity.com/2013/10/09/oct-9-posting-interface-behaves-differently-in-visual-basic/
• Implémenter explicitement (plutôt qu'implicitement) une interface en C#, pratique recommandée par Reuven Bass dans ce texte du Code Project en 2012 : http://www.codeproject.com/Articles/392516/Why-I-use-explicit-interface-implementation-as-a-d

Internationalisation

• Comment gérer le marqueur de décimales dans un nombre avec C#, par Erik Schierboom en 2014 : http://www.erikschierboom.com/2014/09/01/numbers-and-culture/

LINQ

• En 2014, Eric Lippert explique pourquoi un jeton silencieux est inséré dans la traduction de requêtres LINQ :
  •  http://ericlippert.com/2014/07/31/transparent-identifiers-part-one/
  • http://ericlippert.com/2014/08/01/transparent-identifiers-part-two/
• Petit exemple documenté par Jean-Noël Guilbault : Linq.html

Mathématiques

• Programmation numérique en C#, une introduction (du Code Project) : http://www.codeproject.com/KB/cs/numprogrammingcs.aspx
• Énumérer les permutations d'un ensemble, série de textes d'Eric Lippert en 2013 :
  • http://ericlippert.com/2013/04/15/producing-permutations-part-one/
  • http://ericlippert.com/2013/04/18/producing-permutations-part-two/
  • http://ericlippert.com/2013/04/22/producing-permutations-part-three/
  • http://ericlippert.com/2013/04/25/producing-permutations-part-four/
  • http://ericlippert.com/2013/04/29/producing-permutations-part-five/
  • http://ericlippert.com/2013/05/02/producing-permutations-part-six/
  • http://ericlippert.com/2013/05/06/producing-permutations-part-seven/
• Énumérer les combinaisons d'un ensemble, série de textes d'Eric Lippert en 2014 :
  • http://ericlippert.com/2014/10/13/producing-combinations-part-one/
  • http://ericlippert.com/2014/10/16/producing-combinations-part-two/
  • http://ericlippert.com/2014/10/20/producing-combinations-part-three/
  • http://ericlippert.com/2014/10/23/producing-combinations-part-four/
  • http://ericlippert.com/2014/10/27/producing-combinations-part-five/
• Réaliser une traversée de graphe, série de textes d'Eric Lippert en 2014 :
  • http://ericlippert.com/2014/10/30/graph-traversal-part-one/
  • http://ericlippert.com/2014/11/03/graph-traversal-part-two/
  • http://ericlippert.com/2014/11/06/graph-traversal-part-three/
  • http://ericlippert.com/2014/11/10/graph-traversal-part-four/

Opérateurs

J'ai placé les liens à ce sujet sur Operateurs.html

Parallélisme

• Du traitement parallèle ordonnancé avec C#, texte de 2015 : http://manyrootsofallevilrants.blogspot.co.uk/2015/02/ordered-parallel-processing-in-c.html

Pattern Matching

En 2014 s'entament des discussions autour de l'ajout de Pattern Matching en C#.

• Pour participer aux échanges : https://roslyn.codeplex.com/discussions/560339
• La spécification au coeur des échanges : https://onedrive.live.com/redir?resid=4558A04E77D0CF5%215396

Qualifications d'accès

• La qualification protected de C# :
  • http://blogs.msdn.com/b/ericlippert/archive/2005/11/09/why-can-t-i-access-a-protected-member-from-a-derived-class.aspx
  • http://blogs.msdn.com/b/ericlippert/archive/2008/03/28/why-can-t-i-access-a-protected-member-from-a-derived-class-part-two-why-can-i.aspx
  • http://blogs.msdn.com/b/ericlippert/archive/2008/04/24/why-can-t-i-access-a-protected-member-from-a-derived-class-part-three.aspx
  • http://blogs.msdn.com/b/ericlippert/archive/2008/05/02/protected-member-access-part-four.aspx
  • http://blogs.msdn.com/b/ericlippert/archive/2008/05/05/protected-semantics-part-five-more-on-immutability.aspx
  • http://blogs.msdn.com/b/ericlippert/archive/2010/01/14/why-cant-i-access-a-protected-member-from-a-derived-class-part-six.aspx
  • http://blogs.msdn.com/b/ericlippert/archive/2010/03/25/knights-knaves-protected-and-internal.aspx

Système de types

J'ai localisé les informations en ce sens dans ../../Liens/Systemes-types--Liens.html#langage_Cdiese

Divers

• Jouer avec une imprimante : http://odetocode.com/humor/68.aspx
• Manipuler des noms de répertoires, par Craig Gidney en 2013 : http://twistedoakstudios.com/blog/Post4872_dont-treat-paths-like-strings
• Mêler du code F# et du code C# : http://www.voyce.com/index.php/2011/05/09/mixing-it-up-when-f-meets-c/
• Ce qui est bon pour C# peut ne pas l'être pour JavaScript :
  • http://enterprisejquery.com/2010/10/how-good-c-habits-can-encourage-bad-javascript-habits-part-1/
  • http://enterprisejquery.com/2010/10/how-good-c-habits-can-encourage-bad-javascript-habits-part-2/
• Manipuler des images en format SVG avec C#, par Lasitha Ishan Petthawadu en 2014 : http://lasithapetthawadu.wordpress.com/2014/02/24/using-vector-svg-graphics-in-c-net/
• Programmer un type Either<T,U> en C#, donc un type dont les instances peuvent contenir un T ou un U puis être testées dynamiquement pour savoir lequel des deux, texte de 2012 : http://siliconcoding.wordpress.com/2012/10/26/either_in_csharp/
• Itérateurs et énumérateurs en C#, texte du Code Project par Karthik Chintala en 2014 : http://www.codeproject.com/Tips/749456/Iterators-in-Csharp
• Pourquoi C# utilise-t-il l'encodage UTF-16? Explication d'Eric Lippert en 2014 : http://blog.coverity.com/2014/04/09/why-utf-16/
• Programmer en fonction d'un SIMD 64 bits avec C#, par Gastón Hillar : http://www.drdobbs.com/windows/64-bit-simd-code-from-c/240168851
• La rétrocompatibilié est une chose difficile, en C# comme avec d'autres langages, comme le souligne Jon Skeet en 2015 : http://codeblog.jonskeet.uk/2015/06/03/backwards-compatibility-is-still-hard/
• Les types « blittables » en C#, expliqués par Andrey Akinshin en 2015 : http://aakinshin.net/en/blog/dotnet/blittable/

Considérations de versions

Programmer dans un langage .NET tel que C# induit une dépendance forte envers la plateforme, les deux étant fortement couplés :

• Guides du « bluffeur » :
  • de C# version 2.0 : http://csharpindepth.com/Articles/General/BluffersGuide2.aspx
  • de C# version 3.0 : http://csharpindepth.com/Articles/General/BluffersGuide3.aspx
• À quoi sert l'option langversion d'un compilateur C#? Explications d'Eric Lippert en 2013 : http://ericlippert.com/2013/04/04/what-does-the-langversion-switch-do/
• Raffinements avec C# 4.0 :
  • tour d'horizon des nouveautés : http://jlambert.developpez.com/tutoriels/dotnet/nouveautescsharp4/
  • article du Code Project sur les raffinements pour l'interaction avec le modèle COM : http://www.codeproject.com/Articles/73886/Csharp-4-0-COM-Interop-Improvements.aspx
  • risques associés aux paramètres optionnels : http://www.lostechies.com/blogs/jimmy_bogard/archive/2010/05/18/caveats-of-c-4-0-optional-parameters.aspx
  • covariance et contravariance avec C# 4.0, par Tomas Petricek en 2012 : http://tomasp.net/blog/variance-explained.aspx
• Raffinements avec C# 5.0 :
  • de meilleures λ et la capacité de fournir un descriptif implicite de l'appelant à l'appelé : http://www.mindscapehq.com/blog/index.php/2012/03/18/what-else-is-new-in-c-5/
  • asynchronicité :
    • série de textes par Eric Lippert en 2010 :
      • http://blogs.msdn.com/b/ericlippert/archive/2010/10/28/asynchrony-in-c-5-part-one.aspx
      • http://blogs.msdn.com/b/ericlippert/archive/2010/10/29/asynchronous-programming-in-c-5-0-part-two-whence-await.aspx
      • http://blogs.msdn.com/b/ericlippert/archive/2010/11/01/asynchrony-in-c-5-part-three-composition.aspx
      • http://blogs.msdn.com/b/ericlippert/archive/2010/11/04/asynchrony-in-c-5-0-part-four-it-s-not-magic.aspx
      • http://blogs.msdn.com/b/ericlippert/archive/2010/11/08/asynchrony-in-c-5-part-five-too-many-tasks.aspx
      • http://blogs.msdn.com/b/ericlippert/archive/2010/11/11/whither-async.aspx
      • http://blogs.msdn.com/b/ericlippert/archive/2010/11/19/asynchrony-in-c-5-part-seven-exceptions.aspx
      • http://blogs.msdn.com/b/ericlippert/archive/2010/11/23/asynchrony-in-c-5-part-eight-more-exceptions.aspx
    • en 2012, Daniel Grunwald décompile le code d'instructions async/ await : http://community.sharpdevelop.net/blogs/danielgrunwald/archive/2012/04/16/decompiling-async-await.aspx
• Raffinements avec C# 6.0 :
  • nouveaux éléments prévus pour le langage, selon Adam Ralph en 2013 : http://adamralph.com/2013/12/06/ndc-diary-day-3/?1
  • comparaisons syntaxiques de ces éléments, par Damien Guard en 2013 : http://damieng.com/blog/2013/12/09/probable-c-6-0-features-illustrated
  • point de vue de Jon Skeet en 2014 : http://msmvps.com/blogs/jon_skeet/archive/2014/04/04/c-6-first-reactions.aspx
  • rapport proposé par Mads Torgensen, en 2014 : https://gist.github.com/anonymous/9997622
  • en 2014, Filip Ekberg liste ce qu'il estime être les principaux attraits de C# 6.0 : http://www.dotnetcurry.com/showarticle.aspx?ID=1042
  • les meilleurs aspects de C# 6.0, selon Marco Costello en 2014 : http://www.marccostello.com/csharp-6-whats-good/
  • liste de caractéristiques de C# 6.0 telles qu'implémentées avec Roslyn : https://roslyn.codeplex.com/wikipage?title=Language%20feature%20status
  • en 2014, Jon Skeet explique l'impact de C# 6.0 sur un vrai projet : http://codeblog.jonskeet.uk/2014/12/08/c-6-in-action/
  • textes de 2014 par Kunal Chowdhury, portant sur des particularités de C# 6.0 :
    • les propriétés avec valeurs par défaut : http://www.kunal-chowdhury.com/2014/11/csharp-6-auto-property.html
    • l'interpolation de chaînes de caractères : http://www.kunal-chowdhury.com/2014/11/csharp-6-string-interpolation.html
    • les expressions nameof : http://www.kunal-chowdhury.com/2014/12/csharp-6-nameof-expression.html
    • l'opérateur null-conditional : http://www.kunal-chowdhury.com/2014/12/csharp-6-null-conditional-operators.html
    • les filtres d'exceptions : http://www.kunal-chowdhury.com/2014/12/csharp-6-exception-filters.html
    • les expressions faites de leur seule définition : http://www.kunal-chowdhury.com/2014/12/csharp-6-expression-bodied-method.html
    • la possibilité d'utiliser await dans les blocs catch et finally : http://www.kunal-chowdhury.com/2015/01/csharp-6-await-statement.html
  • survol des nouvelles fonctionnalités de C# 6.0, un texte du Code Project en 2014 par Srinivasa Dinesh Parupalli : http://www.codeproject.com/Tips/856913/Csharp-New-Features-Explored
  • gestion des événements de manière élégante avec C# 6.0, par Jon Skeet en 2015 : http://codeblog.jonskeet.uk/2015/01/30/clean-event-handlers-invocation-with-c-6/
  • « analyse pratique » des nouvelles caractéristiques de C# 6.0, par Vladimir Milev en 2015 :
    • http://www.newventuresoftware.com/blog/practical-analysis-new-features-c-6-part-1/
    • http://www.newventuresoftware.com/blog/practical-analysis-new-features-c-6-part-2/
    • http://www.newventuresoftware.com/blog/practical-analysis-new-features-c-6-part-3/
  • survol des nouvelles caractéristiques, par Alex Mackey en 2015 : https://gooroo.io/GoorooTHINK/Article/16282/C6-New-Features/18087
  • survol des nouvelles caractéristiques : https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-6
• En vue de C# 7.0 :
  • proposition de Jon Skeet en 2015, qui pourrait impliquer des changements en profondeur dans le CLR : http://codeblog.jonskeet.uk/2015/01/12/c-7-feature-request-1-extension-attributes/
  • les minutes d'une rencontre des concepteurs (fort intéressant), en 2015 : https://github.com/dotnet/roslyn/issues/98
  • ce qui est sur la table de travail, en 2015 : https://github.com/dotnet/roslyn/issues/2136
  • en 2015, Jonathan Allen décrit ce qu'il envisage comme type Tuple pour C# 7.0 : http://www.infoq.com/news/2015/04/CSharp-7-Tuples
  • en 2015, Jonathan Allen discute des nullable references et des mandatory references envisagées pour C# 7.0 : http://www.infoq.com/news/2015/04/CSharp-7-Null
  • survol de ce que C# 7.0 contiendra probablement, et n'offrira probablement pas, par Rob Marvin en 2015 : http://sdtimes.com/c-7-the-features-you-will-and-wont-see/
  • entrevue avec Mads Torgensen par Pierre-Luc Maheux, en 2015, offrant un coup d'oeil sur ce que promet d'offrir C# 7.0 : http://www.infoq.com/news/2015/10/csharp-7-sneak-peek
  • un survol proposé par Alex Mackey en 2016 : https://gooroo.io/GoorooTHINK/Article/16674/C7-Features/21575
  • il semble que le Pattern Matching, du moins dans son acception initiale plus ambitieuse, ne fera pas partie de cette version, du moins si on se fie à Sergio Simone en 2016 : http://infoq.com/news/2016/05/csharp7-pattern-matching-removed

Critiques

Critiques du langage et de la plateforme :

• Série de critiques de C# en particulier et du CLR de .NET, par Sandro Magi, un programmeur qui aime malgré tout ce langage puisqu'il s'en sert :
  • http://higherlogics.blogspot.com/2007/05/whats-wrong-with-net.html
  • http://higherlogics.blogspot.com/2010/05/asymmetries-in-cil_17.html
  • http://higherlogics.blogspot.com/2010/05/cil-verification-and-safety.html
  • http://higherlogics.blogspot.com/2011/08/open-instance-delegate-for-generic.html
  • http://higherlogics.blogspot.com/2011/09/iobservable-and-delegate-equality.html
  • http://higherlogics.blogspot.com/2011/11/type-unification-forbidden-more-cclr.html
• Parfois, pour être productifs, faut se faire violence, comme l'indique Jon Skeet en 2015 : http://codeblog.jonskeet.uk/2015/07/27/sideways-overriding-with-partial-methods/
• Une optimisation qui a mal tourné, rapport de Nick Craver en 2015 : http://nickcraver.com/blog/2015/07/27/why-you-should-wait-on-dotnet-46/
• Texte de 2015 dans lequel Eric Lippert parle des dix caractéristiques de C# qu'il aime le moins : http://www.informit.com/articles/article.aspx?p=2425867