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

where T : struct

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

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

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

Voici les fonctionnalités révélées jusqu'à présent:

Mots clés

• yieldpar Michael Stum
• varpar Michael Stum
• using()déclaration de kokos
• readonlypar kokos
• aspar Mike Stone
• as/ ispar Ed Swangren
• as/ is(amélioré) par Rocketpants
• defaultpar deathofrats
• global::par pzycoman
• using()blocs par AlexCuse
• volatilepar Jakub Šturc
• extern aliaspar Jakub Šturc

Les attributs

• DefaultValueAttributepar Michael Stum
• ObsoleteAttributepar DannySmurf
• DebuggerDisplayAttributepar Stu
• DebuggerBrowsableet DebuggerStepThroughpar bdukes
• ThreadStaticAttributepar marxidad
• FlagsAttributepar Martin Clarke
• ConditionalAttributepar AndrewBurns

Syntaxe

• ??(coalesce nulls ) opérateur par kokos
• Signalisation numérique par Nick Berardi
• where T:newpar Lars Mæhlum
• Génériques implicites par Keith
• Lambdas à un paramètre par Keith
• Propriétés automatiques par Keith
• Alias ​​d'espace de noms par Keith
• Verbatim string literals with @ by Patrick
• enumvaleurs par lfoust
• @variablenames par marxidad
• eventopérateurs par marxidad
• Format des parenthèses de chaîne par Portman
• Modificateurs d'accessibilité des accesseurs de propriété par xanadont
• Opérateur conditionnel (ternaire) ( ?:) par JasonS
• checkedet uncheckedopérateurs par Binoj Antony
• implicit and explicitopérateurs par Flory

Caractéristiques linguistiques

• Types nullables par Brad Barker
• Types anonymes par Keith
• __makeref __reftype __refvaluepar Judah Himango
• Initialiseurs d'objets par lomaxx
• Format des chaînes de David dans le Dakota
• Méthodes d'extension par marxidad
• partialméthodes par Jon Erickson
• Directives de préprocesseur par John Asbeck
• DEBUGdirective pré-processeur par Robert Durgin
• Surcharge de l'opérateur par SefBkn
• Inférence de type par chakrit
• Les opérateurs booléens poussés au niveau supérieur par Rob Gough
• Passer la variable de type valeur comme interface sans boxe par Roman Boiko
• Déterminer par programme le type de variable déclaré par Roman Boiko
• Constructeurs statiques par Chris
• Cartographie ORM plus facile à regarder / condensée à l'aide de LINQ par roosteronacid
• __arglistpar Zac Bowling

Fonctionnalités de Visual Studio

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

Cadre

• TransactionScopepar KiwiBastard
• DependantTransactionpar KiwiBastard
• Nullable<T>par IainMH
• Mutexpar Diago
• System.IO.Pathpar ageektrapped
• WeakReferencepar Juan Manuel

Méthodes et propriétés

• String.IsNullOrEmpty()méthode par KiwiBastard
• List.ForEach()méthode par KiwiBastard
• BeginInvoke(), EndInvoke()méthodes de Will Dean
• Nullable<T>.HasValueet Nullable<T>.Valuepropriétés de Rismo
• GetValueOrDefaultméthode par John Sheehan

Conseils & Astuces

• Belle méthode pour les gestionnaires d'événements par Andreas HR Nilsson
• Comparaisons majuscules par John
• Accéder aux types anonymes sans réflexion par dp
• Un moyen rapide d'instancier paresseusement les propriétés d'une collection par Will
• Fonctions en ligne anonymes de type JavaScript par roosteronacid

Autre

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

Ce n'est pas C # en soi, mais je n'ai vu personne qui utilise vraiment System.IO.Path.Combine()autant qu'il le devrait. En fait, toute la classe Path est vraiment utile, mais personne ne l'utilise!

Je suis prêt à parier que chaque application de production possède le code suivant, même s'il ne devrait pas:

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

les lambdas et l'inférence de type sont sous-estimés. Lambdas peut avoir plusieurs instructions et elles se doublent automatiquement en tant qu'objet délégué compatible (assurez-vous simplement que la signature correspond) comme dans:

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

Notez que je n'en ai pas new CancellationEventHandleret je n'ai pas besoin de spécifier les types de senderet e, ils sont déductibles de l'événement. C'est pourquoi cela est moins fastidieux d'écrire le tout delegate (blah blah)ce qui nécessite également de spécifier des types de paramètres.

Lambdas n'a 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 au sens de la programmation fonctionnelle. Par exemple, voici un lambda qui crée 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 :-)

À part les pointeurs en C, je pense que c'est l'autre chose fondamentale que vous devriez apprendre :-)

De Rick Strahl :

Vous pouvez enchaîner le ?? opérateur afin que vous puissiez faire un tas de comparaisons nulles.

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

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 utiliserez la même chose générique longue et complexe dans de nombreux endroits.

De CLR via C # :

Lors de la normalisation des chaînes, il est fortement recommandé d'utiliser ToUpperInvariant au lieu de ToLowerInvariant car Microsoft a optimisé le code pour effectuer des comparaisons en majuscules .

Je me souviens qu'une fois, mon collègue changeait toujours les chaînes en majuscules avant de comparer. Je me suis toujours demandé pourquoi il faisait ça parce que je pense qu'il est plus "naturel" de se convertir en minuscules en premier. Après avoir lu le livre maintenant, je sais pourquoi.

Mon astuce préférée consiste à utiliser l' opérateur de coalescence nulle et les parenthèses pour instancier automatiquement des collections pour moi.

private IList<Foo> _foo;

public IList<Foo> ListOfFoo 
    { get { return _foo ?? (_foo = new List<Foo>()); } }

Évitez de rechercher les gestionnaires d'événements nuls

L'ajout d'un délégué vide aux événements lors de la déclaration, supprimant la nécessité de toujours vérifier l'événement pour null avant de l'appeler est génial. Exemple:

public delegate void MyClickHandler(object sender, string myValue);
public event MyClickHandler Click = delegate {}; // add empty delegate!

Laissez-vous faire

public void DoSomething()
{
    Click(this, "foo");
}

Au lieu de cela

public void DoSomething()
{
    // Unnecessary!
    MyClickHandler click = Click;
    if (click != null) // Unnecessary! 
    {
        click(this, "foo");
    }
}

Veuillez également consulter cette discussion connexe et cet article de blog d'Eric Lippert sur ce sujet (et les inconvénients possibles).

Tout le reste, plus

1) génériques implicites (pourquoi uniquement sur les méthodes et non sur les classes?)

void GenericMethod<T>( T input ) { ... }

//Infer type, so
GenericMethod<int>(23); //You don't need the <>.
GenericMethod(23);      //Is enough.

2) lambdas simples avec un paramètre:

x => x.ToString() //simplify so many calls

3) types anonymes et initialiseurs:

//Duck-typed: works with any .Add method.
var colours = new Dictionary<string, string> {
    { "red", "#ff0000" },
    { "green", "#00ff00" },
    { "blue", "#0000ff" }
};

int[] arrayOfInt = { 1, 2, 3, 4, 5 };

Un autre:

4) Les propriétés automatiques peuvent avoir différentes portées:

public int MyId { get; private set; }

Merci @pzycoman de m'avoir rappelé:

5) Alias ​​d'espace de noms (pas que vous ayez probablement besoin de cette distinction particulière):

using web = System.Web.UI.WebControls;
using win = System.Windows.Forms;

web::Control aWebControl = new web::Control();
win::Control aFormControl = new win::Control();

Je ne connaissais pas le mot-clé "as" depuis un bon moment.

MyClass myObject = (MyClass) obj;

contre

MyClass myObject = obj as MyClass;

La seconde retournera null si obj n'est pas une MyClass, plutôt que de lever une exception de transtypage de classe.

Deux choses que j'aime sont les propriétés automatiques afin que vous puissiez réduire encore plus votre code:

private string _name;
public string Name
{
    get
    {
        return _name;
    }
    set
    {
        _name = value;
    }
}

devient

public string Name { get; set;}

Aussi initialiseurs d'objets:

Employee emp = new Employee();
emp.Name = "John Smith";
emp.StartDate = DateTime.Now();

devient

Employee emp = new Employee {Name="John Smith", StartDate=DateTime.Now()}

Le mot clé 'default' dans les types génériques:

T t = default(T);

résulte en un 'null' si T est un type de référence, et 0 s'il s'agit d'un int, false s'il s'agit d'un booléen, etc.

Attributs en général, mais surtout DebuggerDisplay . Vous fait gagner des années.

Le @ indique au compilateur d'ignorer tous les caractères d'échappement dans une chaîne.

Je voulais juste clarifier celui-ci ... il ne lui dit pas d'ignorer les caractères d'échappement, il dit en fait au compilateur d'interpréter la chaîne comme un littéral.

Si tu as

string s = @"cat
             dog
             fish"

il sera en fait imprimé comme (notez qu'il inclut même l'espace blanc utilisé pour l'indentation):

cat
             dog
             fish

Je pense que l'une des fonctionnalités les plus sous-estimées et moins connues de C # (.NET 3.5) sont les arbres d'expression , en particulier lorsqu'ils sont combinés avec des génériques et des Lambdas. Il s'agit d'une approche de la création d'API que les bibliothèques plus récentes comme NInject et Moq utilisent.

Par exemple, disons que je veux enregistrer une méthode avec une API et que l'API doit obtenir le nom de la méthode

Compte tenu de cette classe:

public class MyClass
{
     public void SomeMethod() { /* Do Something */ }
}

Avant, il était très courant de voir les développeurs faire cela avec des chaînes et des types (ou autre chose largement basé sur des chaînes):

RegisterMethod(typeof(MyClass), "SomeMethod");

Eh bien, ça craint à cause du manque de frappe forte. Et si je renomme "SomeMethod"? Maintenant, en 3.5 cependant, je peux le faire de manière fortement typée:

RegisterMethod<MyClass>(cl => cl.SomeMethod());

Dans lequel la classe RegisterMethod utilise Expression<Action<T>>comme ceci:

void RegisterMethod<T>(Expression<Action<T>> action) where T : class
{
    var expression = (action.Body as MethodCallExpression);

    if (expression != null)
    {
        // TODO: Register method
        Console.WriteLine(expression.Method.Name);
    }
}

C'est une grande raison pour laquelle je suis amoureux des Lambdas et des arbres d'expression en ce moment.

« céder » me viendrait à l'esprit. Certains des attributs comme [DefaultValue ()] sont également parmi mes favoris.

Le mot-clé " var " est un peu plus connu, mais le fait que vous puissiez également l'utiliser dans les applications .NET 2.0 (tant que vous utilisez le compilateur .NET 3.5 et le définissez pour afficher le code 2.0) ne semble pas être très connu bien.

Edit: kokos, merci d'avoir souligné le ?? opérateur, c'est vraiment très utile. Comme il est un peu difficile de le rechercher sur Google (car ?? est simplement ignoré), voici la page de documentation MSDN pour cet opérateur: ?? Opérateur (référence C #)

J'ai tendance à constater que la plupart des développeurs C # ne connaissent pas les types «nullables». Fondamentalement, des primitives qui peuvent avoir une valeur nulle.

double? num1 = null; 
double num2 = num1 ?? -100;

Définissez un double nullable , num1 , sur null, puis définissez un double normal, num2 , sur num1 ou -100 si num1 était nul.

http://msdn.microsoft.com/en-us/library/1t3y8s4s(VS.80).aspx

encore une chose sur le type Nullable:

DateTime? tmp = new DateTime();
tmp = null;
return tmp.ToString();

c'est return String.Empty. Consultez ce lien pour plus de détails

Voici quelques fonctionnalités C # cachées intéressantes, sous la forme de mots clés C # non documentés:

__makeref

__reftype

__refvalue

__arglist

Ce sont des mots clés C # non documentés (même Visual Studio les reconnaît!) Qui ont été ajoutés pour une boxe / unboxing plus efficace avant les génériques. Ils travaillent en coordination avec la structure System.TypedReference.

Il y a aussi __arglist, qui est utilisé pour les listes de paramètres de longueur variable.

Les gens ne savent pas grand-chose sur System.WeakReference - une classe très utile qui garde la trace d'un objet mais permet toujours au garbage collector de le collecter.

La fonction "cachée" la plus utile serait le mot-clé return yield. Ce n'est pas vraiment caché, mais beaucoup de gens ne le savent pas. LINQ est construit au-dessus de cela; il permet des requêtes exécutées avec retard en générant une machine d'état sous le capot. Raymond Chen a récemment publié des détails sur les détails internes .

Unions (du type mémoire partagée C ++) en C # pur et sûr

Sans recourir au mode et aux pointeurs non sécurisés, vous pouvez faire en sorte que les membres de la classe partagent l'espace mémoire dans une classe / structure. Étant donné la classe suivante:

[StructLayout(LayoutKind.Explicit)]
public class A
{
    [FieldOffset(0)]
    public byte One;

    [FieldOffset(1)]
    public byte Two;

    [FieldOffset(2)]
    public byte Three;

    [FieldOffset(3)]
    public byte Four;

    [FieldOffset(0)]
    public int Int32;
}

Vous pouvez modifier les valeurs des champs d'octets en manipulant le champ Int32 et vice-versa. Par exemple, ce programme:

    static void Main(string[] args)
    {
        A a = new A { Int32 = int.MaxValue };

        Console.WriteLine(a.Int32);
        Console.WriteLine("{0:X} {1:X} {2:X} {3:X}", a.One, a.Two, a.Three, a.Four);

        a.Four = 0;
        a.Three = 0;
        Console.WriteLine(a.Int32);
    }

Produit ceci:

2147483647
FF FF FF 7F
65535

ajoutez simplement en utilisant System.Runtime.InteropServices;

Utilisation de @ pour les noms de variables qui sont des mots clés.

var @object = new object();
var @string = "";
var @if = IpsoFacto(); 

Si vous souhaitez quitter votre programme sans appeler de blocs ou de finaliseurs enfin, utilisez FailFast :

Environment.FailFast()

Renvoyer des types anonymes à partir d'une méthode et accéder aux membres sans réflexion.

// Useful? probably not.
private void foo()
{
    var user = AnonCast(GetUserTuple(), new { Name = default(string), Badges = default(int) });
    Console.WriteLine("Name: {0} Badges: {1}", user.Name, user.Badges);
}

object GetUserTuple()
{
    return new { Name = "dp", Badges = 5 };
}    

// Using the magic of Type Inference...
static T AnonCast<T>(object obj, T t)
{
   return (T) obj;
}

En voici une utile pour les expressions régulières et les chemins de fichiers:

"c:\\program files\\oldway"
@"c:\program file\newway"

Le @ indique au compilateur d'ignorer tous les caractères d'échappement dans une chaîne.

Mixins. Fondamentalement, si vous souhaitez ajouter une fonctionnalité à plusieurs classes, mais ne pouvez pas utiliser une classe de base pour toutes, demandez à chaque classe d'implémenter une interface (sans membres). Ensuite, écrivez une méthode d'extension pour l'interface , ie

public static DeepCopy(this IPrototype p) { ... }

Bien sûr, une certaine clarté est sacrifiée. Mais ça marche!

Je ne sais pas pourquoi quelqu'un voudrait utiliser Nullable <bool>. :-)

Vrai, faux, FileNotFound ?

Celui-ci n'est pas «caché» autant qu'il est mal nommé.

Une grande attention est accordée aux algorithmes "carte", "réduire" et "filtrer". Ce que la plupart des gens ne réalisent pas, c'est que .NET 3.5 a ajouté ces trois algorithmes, mais cela leur a donné des noms très SQL, basés sur le fait qu'ils font partie de LINQ.

"map" => Sélectionnez
Transforme les données d'un formulaire à un autre

"réduire" => Agréger
Agrège les valeurs en un seul résultat

"filter" => Où
Filtre les données en fonction d'un critère

La possibilité d'utiliser LINQ pour effectuer un travail en ligne sur des collections qui prenaient auparavant des itérations et des conditions peut être extrêmement utile. Il vaut la peine d'apprendre comment toutes les méthodes d'extension LINQ peuvent aider à rendre votre code beaucoup plus compact et maintenable.

Environment.NewLine

pour les sauts de ligne indépendants du système.

Si vous essayez d'utiliser des accolades à l'intérieur d'une expression String.Format ...

int foo = 3;
string bar = "blind mice";
String.Format("{{I am in brackets!}} {0} {1}", foo, bar);
//Outputs "{I am in brackets!} 3 blind mice"

1. ?? - opérateur coalescent
2. using ( statement / directive ) - excellent mot-clé qui peut être utilisé pour plus que simplement appeler Dispose
3. en lecture seule - devrait être utilisé davantage
4. netmodules - dommage qu'il n'y ait pas de support dans Visual Studio

@Ed, je suis un peu réticent à publier ceci, car c'est un peu plus que de taquiner. Cependant, je voudrais souligner que dans votre exemple de code:

MyClass c;
  if (obj is MyClass)
    c = obj as MyClass

Si vous allez utiliser «is», pourquoi le suivre avec un casting sûr en utilisant «as»? Si vous avez vérifié que obj est bien MyClass, un casting standard:

c = (MyClass)obj

... ne va jamais échouer.

De même, vous pourriez simplement dire:

MyClass c = obj as MyClass;
if(c != null)
{
   ...
}

Je n'en sais pas assez sur les entrailles de .NET pour être sûr, mais mon instinct me dit que cela réduirait un maximum de deux opérations de conversion de type à un maximum. Il est peu probable de casser la banque de traitement de toute façon; personnellement, je pense que cette dernière forme semble plus propre aussi.

Peut-être pas une technique avancée, mais celle que je vois tout le temps qui me rend fou:

if (x == 1)
{
   x = 2;
}
else
{
   x = 3;
}

peut être condensé en:

x = (x==1) ? 2 : 3;