Fonctions cachées de C# ?

Question

Cela m'est venu à l'esprit après avoir appris ce qui suit de la part de cette question :

where T : struct

Nous, développeurs C#, connaissons tous les bases de C#. Je veux dire les déclarations, les conditionnels, les boucles, les opérateurs, etc.

Certains d'entre nous ont même maîtrisé des trucs comme Génériques , types anonymes , lambdas , LINQ , ...

Mais quelles sont les fonctionnalités ou les astuces les plus cachées de C# que même les fans, les accros et les experts de C# connaissent à peine ?

Voici les caractéristiques révélées jusqu'à présent :

Mots clés

• yield par Michael Stum
• var par Michael Stum
• using() déclaration de kokos
• readonly par kokos
• as par Mike Stone
• as / is par Ed Swangren
• as / is (amélioré) par Rocketpants
• default par deathofrats
• global:: par pzycoman
• using() blocs par AlexCuse
• volatile par Jakub Šturc
• extern alias par Jakub Šturc

Attributs

• DefaultValueAttribute par Michael Stum
• ObsoleteAttribute par DannySmurf
• DebuggerDisplayAttribute par Stu
• DebuggerBrowsable et DebuggerStepThrough par bdukes
• ThreadStaticAttribute par marxidad
• FlagsAttribute par Martin Clarke
• ConditionalAttribute par AndrewBurns

Syntaxe

• ?? (coalesce nulls) opérateur par kokos
• Nombre de drapeaux par Nick Berardi
• where T:new par Lars Mæhlum
• Génériques implicites par Keith
• Lambdas à un paramètre par Keith
• Propriétés automobiles par Keith
• Les alias de l'espace de nommage par Keith
• Les chaînes littérales verbatim avec @ par Patrick
• enum valeurs par lfoust
• @variablenames par marxidad
• event opérateurs par marxidad
• Format de la chaîne de caractères entre crochets par Portman
• Modificateurs d'accessibilité des accesseurs de propriétés par xanadont
• Opérateur conditionnel (ternaire) ( ?: ) par JasonS
• checked et unchecked opérateurs par Binoj Antony
• implicit and explicit opérateurs par Flory

Caractéristiques de la langue

• Types nuls par Brad Barker
• Types anonymes par Keith
• __makeref __reftype __refvalue par Judah Himango
• Initialisateurs d'objets par lomaxx
• Formatage des chaînes de caractères par David dans le Dakota
• Méthodes d'extension par marxidad
• partial méthodes par Jon Erickson
• Les directives du préprocesseur par John Asbeck
• DEBUG par la directive pré-processeur Robert Durgin
• Surcharge d'opérateurs par SefBkn
• Type d'inférence par chakrit
• Opérateurs booléens passer au niveau supérieur par Rob Gough
• Passer une variable de type valeur comme interface sans la mettre en boîte par Roman Boiko
• Déterminer de façon programmatique le type de variable déclarée par Roman Boiko
• Constructeurs statiques par Chris
• Cartographie ORM simplifiée / condensée à l'aide de LINQ by acide rostéronique
• __arglist par Zac Bowling

Fonctionnalités de Visual Studio

• Sélectionnez un bloc de texte dans l'éditeur en Himadri
• Snippets by DannySmurf

Cadre de travail

• TransactionScope par KiwiBastard
• DependantTransaction par KiwiBastard
• Nullable<T> par IainMH
• Mutex par Diago
• System.IO.Path par ageektrapped
• WeakReference par Juan Manuel

Méthodes et propriétés

• String.IsNullOrEmpty() méthode par KiwiBastard
• List.ForEach() méthode par KiwiBastard
• BeginInvoke() , EndInvoke() méthodes par Will Dean
• Nullable<T>.HasValue et Nullable<T>.Value propriétés par Rismo
• GetValueOrDefault méthode par John Sheehan

Conseils et astuces

• Méthode agréable pour les gestionnaires d'événements par Andreas H.R. Nilsson
• Comparaisons en majuscules par John
• Accéder aux types anonymes sans réflexion par dp
• Un moyen rapide d'instancier paresseusement les propriétés de la collection en Will
• Fonctions inline anonymes de type JavaScript par acide rostéronique

Autre

• netmodules par kokos
• LINQBridge par Duncan Smart
• Extensions parallèles par Joel Coehoorn

Answer 1

Ce n'est pas C# en soi, mais je n'ai vu personne qui utilise vraiment System.IO.Path.Combine() dans la mesure où ils le devraient. En fait, l'ensemble de la classe Path est vraiment utile, mais personne ne l'utilise !

Je suis prêt à parier que chaque application de production a le code suivant, même si elle ne devrait pas :

string path = dir + "\\" + fileName;

Answer 2

lambdas et inférence de type sont sous-estimés. Les lambdas peuvent avoir plusieurs déclarations et ils double en tant qu'objet délégué compatible automatiquement (il suffit de s'assurer que la signature correspond) comme dans :

Console.CancelKeyPress +=
    (sender, e) => {
        Console.WriteLine("CTRL+C detected!\n");
        e.Cancel = true;
    };

Notez que je n'ai pas de new CancellationEventHandler et je ne dois pas non plus spécifier les types de sender et e ils sont déductibles de l'événement. C'est pourquoi c'est moins lourd que d'écrire l'ensemble de l'événement. delegate (blah blah) qui vous oblige également à spécifier les types de paramètres.

Les lambdas n'ont pas besoin de retourner quoi que ce soit. et l'inférence de type est extrêmement puissante dans un contexte comme celui-ci.

Et BTW, vous pouvez toujours retourner Des lambdas qui font des lambdas dans le sens de la programmation fonctionnelle. Par exemple, voici un lambda qui fait un lambda qui gère un événement Button.Click :

Func<int, int, EventHandler> makeHandler =
    (dx, dy) => (sender, e) => {
        var btn = (Button) sender;
        btn.Top += dy;
        btn.Left += dx;
    };

btnUp.Click += makeHandler(0, -1);
btnDown.Click += makeHandler(0, 1);
btnLeft.Click += makeHandler(-1, 0);
btnRight.Click += makeHandler(1, 0);

Notez le chaînage : (dx, dy) => (sender, e) =>

Voilà pourquoi je suis heureux d'avoir suivi le cours de programmation fonctionnelle :-)

En dehors des pointeurs en C, je pense que c'est l'autre chose fondamentale que vous devriez apprendre :-)

Answer 3

De Rick Strahl :

Vous pouvez enchaîner l'opérateur ? ? afin de faire un tas de comparaisons nulles.

string result = value1 ?? value2 ?? value3 ?? String.Empty;

Answer 4

Génériques aliasés :

using ASimpleName = Dictionary<string, Dictionary<string, List<string>>>;

Il vous permet d'utiliser ASimpleName au lieu de Dictionary<string, Dictionary<string, List<string>>> .

Utilisez-le lorsque vous utilisez la même chose générique, longue et complexe, dans de nombreux endroits.

Answer 5

De CLR via C# :

Lorsque vous normalisez des chaînes de caractères, il est fortement recommandé d'utiliser ToUpperInvariant plutôt que ToLowerInvariant car Microsoft a optimisé le code pour effectuer comparaisons en majuscules .

Je me souviens d'une fois où mon collègue changeait toujours les chaînes de caractères en majuscules avant de les comparer. Je me suis toujours demandé pourquoi il faisait cela, car j'ai l'impression qu'il est plus "naturel" de passer d'abord en minuscules. Après avoir lu le livre, je sais maintenant pourquoi.