Vraag Verborgen functies van C #? [Gesloten]


Dit kwam in me op nadat ik het volgende leerde deze vraag:

where T : struct

Wij, C # -ontwikkelaars, kennen allemaal de basisprincipes van C #. Ik bedoel verklaringen, conditionals, loops, operatoren, etc.

Sommigen van ons hebben het zelfs gemastered Generics, anonieme typen, lambda, LINQ, ...

Maar wat zijn de meest verborgen functies of trucs van C # die zelfs C # -ventilators, verslaafden, experts nauwelijks weten?

Hier zijn de geopenbaarde functies tot nu toe:


trefwoorden

attributen

Syntaxis

  • ?? (coalesce nulls) operator door kokos
  • Nummervlaggen door Nick Berardi
  • where T:new door Lars Mæhlum
  • Impliciete generieken door Keith
  • Lambda met één parameter door Keith
  • Auto eigenschappen door Keith
  • Namespace-aliassen door Keith
  • Verbatim-snaarliteratuur met @ by Patrick
  • enum waarden door lfoust
  • @variablenames door marxidad
  • event operatoren door marxidad
  • Formaat reeks haakjes door Portman
  • Eigendomstoegang of toegankelijkheidsaanpassingen door xanadont
  • Voorwaardelijke (ternaire) operator (?:) door Jasons
  • checked en unchecked operatoren door Binoj Antony
  • implicit and explicit operatoren door Flory

Taalfuncties

Visual Studio-functies

Kader

Methoden en eigenschappen

  • String.IsNullOrEmpty() methode door KiwiBastard
  • List.ForEach() methode door KiwiBastard
  • BeginInvoke(), EndInvoke() methoden door Will Dean
  • Nullable<T>.HasValue en Nullable<T>.Value eigenschappen door Rismo
  • GetValueOrDefault methode door John Sheehan

tips & trucs

  • Leuke methode voor event-handlers van Andreas H.R. Nilsson
  • Hoofdletters vergelijken met John
  • Toegang tot anonieme typen zonder reflectie door dp
  • Een snelle manier om lui collecties te identificeren met Zullen
  • JavaScript-achtige anonieme inline-functies van roosteronacid

anders


1476


oorsprong


antwoorden:


Dit is niet C # per se, maar ik heb niemand gezien die echt gebruikt System.IO.Path.Combine() voor zover ze zouden moeten. In feite is de hele Path-klasse echt nuttig, maar niemand gebruikt het!

Ik durf te wedden dat elke productie-app de volgende code heeft, ook al zou het niet:

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

752



lambdas en type afleiding zijn ondergewaardeerd. Lambda's kunnen meerdere verklaringen hebben en zij dubbel als een compatibel delegeer object automatisch (zorg ervoor dat de handtekening overeenkomt) als in:

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

Merk op dat ik geen a heb new CancellationEventHandler ik hoef ook geen typen op te geven sender en e, ze zijn af te nemen van het evenement. Daarom is dit minder omslachtig om het geheel te schrijven delegate (blah blah) waarvoor je ook soorten parameters moet opgeven.

Lambda's hoeven niets terug te brengen en type inferentie is extreem krachtig in context zoals deze.

En tussen haakjes, je kunt altijd terugkeren Lambda's die Lambdas maken in de functionele programmeerzin. Hier is bijvoorbeeld een lambda die een lambda maakt die een Button.Click-gebeurtenis afgehandelt:

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);

Let op de ketting: (dx, dy) => (sender, e) =>

Nu ben ik daarom blij dat ik de functionele programmeercursus heb gevolgd :-)

Anders dan de aanwijzers in C, denk ik dat dit het andere fundamentele is wat je zou moeten leren :-)


585



Van Rick Strahl:

Je kunt de ?? operator zodat u een hele reeks nulvergelijkingen kunt doen.

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

528



Aliased generics:

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

Hiermee kunt u gebruiken ASimpleName, in plaats van Dictionary<string, Dictionary<string, List<string>>>.

Gebruik het wanneer u op veel plaatsen hetzelfde generieke grote lange complexe ding zou gebruiken.


455



Van CLR via C #:

Bij het normaliseren van strings is dit hoogst   aanbevolen dat u gebruikt   ToUpperInvariant in plaats van   ToLowerInvariant omdat Microsoft heeft   optimaliseerde de code voor het uitvoeren   vergelijking in hoofdletters.

Ik herinner me een keer dat mijn collega altijd van strings veranderde in hoofdletters voordat hij het vergelijkt. Ik heb me altijd afgevraagd waarom hij dat doet omdat ik vind dat het "natuurlijker" is om eerst in kleine letters te veranderen. Na het lezen van het boek weet ik waarom.


438



Mijn favoriete truc is het gebruik van de null coalesce operator en haakjes om collecties automatisch voor mij te instantiëren.

private IList<Foo> _foo;

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

409



Controleer niet op null-gebeurtenishandlers

Het toevoegen van een lege gedelegeerde aan gebeurtenissen bij aangifte, het onderdrukken van de noodzaak om de gebeurtenis altijd te controleren op null voor het bellen is geweldig. Voorbeeld:

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

Laat je dit doen

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

In plaats van dit

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

Zie dit ook alstublieft gerelateerde discussie en dit blogpost door Eric Lippert over dit onderwerp (en mogelijke nadelen).


314



Al het andere, plus

1) impliciete generieken (waarom alleen op methoden en niet op klassen?)

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

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

2) eenvoudige lambda's met één parameter:

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

3) anonieme typen en initialisers:

//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 };

Nog een:

4) Automatische eigenschappen kunnen verschillende scopes hebben:

public int MyId { get; private set; }

Bedankt @pzycoman omdat ik me eraan heb herinnerd:

5) Namespace-aliassen (niet dat u dit specifieke onderscheid waarschijnlijk nodig heeft):

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

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

305



Ik kende het "als" zoekwoord al een tijdje niet.

MyClass myObject = (MyClass) obj;

vs

MyClass myObject = obj as MyClass;

De tweede zal null retourneren als obj geen MyClass is, in plaats van een class cast-uitzondering te werpen.


286



Twee dingen die ik leuk vind, zijn Automatische eigenschappen, zodat je je code nog verder kunt samenvouwen:

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

wordt

public string Name { get; set;}

Probeer ook initializers:

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

wordt

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

262



Het sleutelwoord 'standaard' in algemene typen:

T t = default(T);

resulteert in een 'null' als T een referentietype is en 0 als het een int is, false als het een boolean is, etcetera.


255