Question Caractéristiques cachées de C #? [fermé]


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

where T : struct

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

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

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

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


Mots clés

Les attributs

Syntaxe

  • ?? (coalesce nulls) opérateur par kokos
  • Indicateurs de nombre 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 auto par Keith
  • Alias ​​de l'espace de noms par Keith
  • Verbatim littéraux de chaîne avec @ par Patrick
  • enum valeurs par lfoust
  • @variablenames par marxidad
  • event opérateurs par marxidad
  • Mettre en forme les parenthèses de chaîne par Portman
  • Modificateurs d'accessibilité d'accesseur de propriété 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 linguistiques

Fonctionnalités Visual Studio

Cadre

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 & Astuces

  • Méthode agréable pour les gestionnaires d'événements par Andreas H.R. 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 de collection par Volonté
  • JavaScript inline-inline-fonctions par roosteronacid

Autre


1476


origine


Réponses:


Ce n'est pas du C # en soi, mais je n'ai vu personne qui utilise vraiment System.IO.Path.Combine() dans la mesure où ils devraient. En fait, toute 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 ce n'est pas le cas:

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

752



lambdas et inférence de type sont sous-estimés. Lambdas peut avoir plusieurs instructions et ils double en tant qu'objet de délégué compatible automatiquement (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'ai pas de new CancellationEventHandler Je ne dois pas non plus spécifier les types de sender et e, ils sont inferable de l'événement. C'est pourquoi c'est moins encombrant d'écrire l'ensemble delegate (blah blah) ce qui nécessite également de spécifier des 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 revenir Lambdas qui font 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 pris la classe de programmation fonctionnelle :-)

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


585



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;

528



Génériques avec alias:

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

Cela 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 dans de nombreux endroits.


455



De CLR via C #:

Lors de la normalisation des chaînes, il est très   recommandé que vous utilisez   ToUpperInvariant au lieu de   ToLowerInvariant parce que Microsoft a   optimisé le code pour effectuer   comparaisons en majuscules.

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


438



Mon truc préféré est d'utiliser le opérateur de coalesce null et des parenthèses pour instancier automagiquement des collections pour moi.

private IList<Foo> _foo;

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

409



Évitez de rechercher des gestionnaires d'événements null

Ajout d'un délégué vide aux événements lors de la déclaration, supprimant le besoin 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 ça

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

Au lieu de cela

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

S'il vous plaît voir aussi discussion connexe et ça article de blog par Eric Lippert sur ce sujet (et les inconvénients possibles).


314



Tout le reste, plus

1) génériques implicites (pourquoi seulement sur les méthodes et pas 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 et initiateurs anonymes:

//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 des étendues différentes:

public int MyId { get; private set; }

Merci @pzycoman pour me rappeler:

5) Alias ​​d'espace de noms (pas que vous ayez 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();

305



Je ne connaissais pas le mot clé "as" depuis pas mal de temps.

MyClass myObject = (MyClass) obj;

contre

MyClass myObject = obj as MyClass;

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


286



Deux choses que j'aime sont des 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'objet:

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

devient

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

262