Frage Versteckte Funktionen von C #? [geschlossen]


Das kam mir in den Sinn, nachdem ich folgendes gelernt hatte diese Frage:

where T : struct

Wir, C # -Entwickler, kennen die Grundlagen von C #. Ich meine Deklarationen, Bedingungen, Schleifen, Operatoren usw.

Einige von uns haben das Zeug sogar gemeistert Generika, anonyme Typen, Lambda, LINQ, ...

Aber was sind die verborgensten Features oder Tricks von C #, die selbst C # -Fans, Süchtige, Experten kaum kennen?

Hier sind die bisher offenbarten Features:


Schlüsselwörter

Attribute

Syntax

  • ?? (Koaleszenz Null) Operator von Kokos
  • Anzahl Flaggings von Nick Berardi
  • where T:new durch Lars Mæhlum
  • Implizite Generika nach Keith
  • Ein-Parameter-Lambdas von Keith
  • Automatische Eigenschaften von Keith
  • Namespace-Aliase nach Keith
  • Verbatim String-Literale mit @ von Patrick
  • enum Werte nach Lfust
  • @ Variablennamen von marxidad
  • event Betreiber von marxidad
  • Formatieren Sie die String-Klammern nach Portman
  • Accessibility-Modifikatoren für die Eigenschaft Accessor von Xanadont
  • Bedingter (ternärer) Operator (?:) durch JasonS
  • checked und unchecked Betreiber von Binoj Antonius
  • implicit and explicit Betreiber von Flory

Sprachmerkmale

Visual Studio-Funktionen

Rahmen

Methoden und Eigenschaften

  • String.IsNullOrEmpty() Methode durch KiwiBastard
  • List.ForEach() Methode durch KiwiBastard
  • BeginInvoke(), EndInvoke() Methoden nach Will Dean
  • Nullable<T>.HasValue und Nullable<T>.Value Eigenschaften von Rismo
  • GetValueOrDefault Methode durch John Sheehan

Tipps

  • Nette Methode für Eventhandler von Andreas H. R. Nilsson
  • Großvergleiche nach John
  • Zugriff auf anonyme Typen ohne Reflektion von dp
  • Ein schneller Weg, um die Auflistungseigenschaften instanzweise zu instanziieren Wille
  • JavaScript-ähnliche anonyme Inline-Funktionen von Roosteron säure

Andere


1476


Ursprung


Antworten:


Das ist nicht C # per se, aber ich habe niemanden gesehen, der wirklich benutzt System.IO.Path.Combine() soweit sie es sollten. In der Tat ist die gesamte Path-Klasse wirklich nützlich, aber niemand benutzt es!

Ich wette, dass jede Produktions-App den folgenden Code hat, obwohl es nicht sollte:

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

752



lambdas und type inferrence sind unterbewertet. Lambdas kann mehrere Aussagen haben und sie doppelt als ein kompatibles Delegat-Objekt automatisch (nur sicherstellen, dass die Signatur übereinstimmt) wie in:

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

Beachten Sie, dass ich kein a new CancellationEventHandler noch muss ich Arten von angeben sender und e, sie sind von der Veranstaltung herstellbar. Deshalb ist das Schreiben des Ganzen weniger mühsam delegate (blah blah) Dazu müssen Sie auch Arten von Parametern angeben.

Lambdas müssen nichts zurückgeben und Inferenz ist im Kontext so extrem mächtig.

Und übrigens, du kannst immer zurückkehren Lambdas, die Lambdas machen im Sinne der funktionalen Programmierung. Zum Beispiel ist hier ein Lambda, das ein Lambda erstellt, das ein Button.Click-Ereignis behandelt:

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

Beachten Sie die Verkettung: (dx, dy) => (sender, e) =>

Jetzt bin ich froh, dass ich die funktionale Programmierklasse genommen habe :-)

Abgesehen von den Zeigern in C, denke ich, es ist die andere grundlegende Sache, die du lernen solltest :-)


585



Von Rick Strahl:

Sie können die Kette? Operator, so dass Sie eine Reihe von Null-Vergleichen durchführen können.

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

528



Aliase Generics:

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

Es ermöglicht Ihnen zu verwenden ASimpleName, Anstatt von Dictionary<string, Dictionary<string, List<string>>>.

Verwenden Sie es, wenn Sie an vielen Orten die gleiche generische große lange komplexe Sache verwenden würden.


455



Von CLR über C #:

Bei der Normalisierung von Strings ist es sehr hoch   empfohlen, dass Sie verwenden   ToUpperInvariant statt   ToLowerInvariant weil Microsoft hat   optimiert den Code für die Durchführung   Vergleiche in Großbuchstaben.

Ich erinnere mich, dass mein Kollege die Zeichenfolgen vor dem Vergleich immer in Großbuchstaben umwandelte. Ich habe mich immer gefragt, warum er das macht, weil ich es eher "natürlich" finde, zuerst in Kleinbuchstaben zu konvertieren. Nachdem ich jetzt das Buch gelesen habe, weiß ich warum.


438



Mein Lieblingstrick ist die Verwendung der Nullkoaleszenzoperator und Klammern, um automatisch Sammlungen für mich zu instantiieren.

private IList<Foo> _foo;

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

409



Vermeiden Sie die Suche nach Null-Event-Handlern

Hinzufügen eines leeren Delegaten zu Ereignissen bei der Deklaration, wodurch die Notwendigkeit unterdrückt wird, das Ereignis immer auf Null zu überprüfen, bevor es aufgerufen wird, ist großartig. Beispiel:

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

Lass es dich tun

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

An Stelle von

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

Bitte sehen Sie das auch verwandte Diskussion und das Blogeintrag von Eric Lippert zu diesem Thema (und mögliche Nachteile).


314



Alles andere, plus

1) implizite Generika (warum nur für Methoden und nicht für Klassen?)

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

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

2) einfache Lambdas mit einem Parameter:

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

3) anonyme Typen und Initialisierer:

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

Noch einer:

4) Auto-Eigenschaften können unterschiedliche Bereiche haben:

public int MyId { get; private set; }

Danke @pzycoman für die Erinnerung an mich:

5) Namespace-Aliase (nicht dass Sie diese besondere Unterscheidung benötigen):

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

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

305



Ich kannte das "as" Keyword schon lange nicht mehr.

MyClass myObject = (MyClass) obj;

vs

MyClass myObject = obj as MyClass;

Die zweite gibt null zurück, wenn obj keine MyClass ist, statt eine Cast-Ausnahme zu werfen.


286