Versteckte Eigenschaften von C#?

Question

Dies kam mir in den Sinn, nachdem ich folgendes erfahren hatte diese Frage :

where T : struct

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

Einige von uns beherrschten sogar die Dinge wie Generika , anonyme Typen , lambdas , LINQ , ...

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

Hier sind die bisher enthüllten Funktionen:

Schlüsselwörter

• yield par Michael Stum
• var par Michael Stum
• using() Aussage von kokos
• readonly par kokos
• as par Mike Stein
• as / is par Ed Swangren
• as / is (verbessert) durch Raketenhosen
• default par deathofrats
• global:: par pzycoman
• using() Blöcke von AlexCuse
• volatile par Jakub Šturc
• extern alias par Jakub Šturc

Attribute

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

Syntax

• ?? (Koaleszenz-Nullen) Operator durch kokos
• Nummerierung der Markierungen durch Nick Berardi
• where T:new par Lars Mæhlum
• Implizite Generika durch Keith
• Ein-Parameter-Lambdas durch Keith
• Auto-Eigenschaften von Keith
• Namespace-Aliase von Keith
• Verbatim-String-Literale mit @ durch Patrick
• enum Werte von lfoust
• @variablennamen von marxidad
• event Betreiber von marxidad
• Formatieren von String-Klammern durch Portman
• Modifikatoren für die Zugänglichkeit der Eigenschaft accessor durch xanadont
• Bedingter (ternärer) Operator ( ?: ) durch JasonS
• checked y unchecked Betreiber von Binoj Antony
• implicit and explicit Betreiber von Flory

Sprachliche Merkmale

• Nullbare Typen durch Brad Barker
• Anonyme Typen von Keith
• __makeref __reftype __refvalue par Judah Himango
• Objektinitialisierungen durch lomaxx
• Zeichenketten formatieren nach David in Dakota
• Erweiterungsmethoden durch marxidad
• partial Methoden von Jon Erickson
• Präprozessoranweisungen von John Asbeck
• DEBUG Präprozessor-Richtlinie durch Robert Durgin
• Überladen von Operatoren durch SefBkn
• Typenableitung durch chakrit
• Boolesche Operatoren auf die nächste Stufe gebracht par Rob Gough
• Übergabe der Variablen vom Typ Wert als Schnittstelle ohne Boxing durch Roman Boiko
• Programmatisch den deklarierten Variablentyp bestimmen durch Roman Boiko
• Statische Konstrukteure von Chris
• Vereinfachtes / komprimiertes ORM-Mapping mit LINQ von roosteronacid
• __arglist par Zac Bowling

Visual Studio-Funktionen

• Markieren Sie einen Textblock im Editor mit Himadri
• Schnipsel von DannySmurf

Rahmenwerk

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

Methoden und Eigenschaften

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

Tipps und Tricks

• Nette Methode für Ereignisbehandler von Andreas H.R. Nilsson
• Vergleiche in Großbuchstaben durch John
• Zugriff auf anonyme Typen ohne Reflexion durch dp
• Eine schnelle Möglichkeit, Sammlungseigenschaften zu instanziieren, indem man Will
• JavaScript-ähnliche anonyme Inline-Funktionen durch roosteronacid

Andere

• Netzbausteine von kokos
• LINQBridge par Duncan Smart
• Parallele Erweiterungen par Joel Coehoorn

Answer 1

Dies ist nicht C# per se, aber ich habe noch niemanden gesehen, der wirklich mit System.IO.Path.Combine() in dem Maße, wie sie es sollten. Tatsächlich ist die gesamte Path-Klasse wirklich nützlich, aber niemand benutzt sie!

Ich bin bereit zu wetten, dass jede Produktionsanwendung den folgenden Code enthält, auch wenn dies nicht der Fall sein sollte:

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

Answer 2

Lambdas und Typinferenz werden unterschätzt. Lambdas können mehrere Anweisungen haben und sie double als kompatibles Delegiertenobjekt automatisch (stellen Sie nur sicher, dass die Signatur übereinstimmt) wie in:

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

Beachten Sie, dass ich keine new CancellationEventHandler noch muss ich die Arten von sender y e sind sie aus dem Ereignis ableitbar. Deshalb ist dies weniger umständlich als das Schreiben der gesamten delegate (blah blah) die ebenfalls die Angabe von Parametertypen erfordert.

Lambdas müssen nichts zurückgeben und die Typinferenz ist in einem solchen Kontext extrem leistungsfähig.

Und übrigens: Sie können jederzeit zurückkehren Lambdas, die Lambdas machen im Sinne der funktionalen Programmierung. Hier ist zum Beispiel ein Lambda, das ein Lambda erzeugt, das ein Button.Click-Ereignis verarbeitet:

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

Deshalb bin ich froh, dass ich den Kurs über funktionale Programmierung belegt habe :-)

Neben den Zeigern in C ist das meiner Meinung nach die zweite grundlegende Sache, die man lernen sollte :-)

Answer 3

Desde Rick Strahl :

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

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

Answer 4

Aliierte Generika:

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

Es ermöglicht Ihnen die Verwendung ASimpleName anstelle von Dictionary<string, Dictionary<string, List<string>>> .

Verwenden Sie es, wenn Sie an vielen Stellen dasselbe große, lange, komplexe Ding verwenden würden.

Answer 5

Desde CLR über C# :

Bei der Normalisierung von Zeichenketten ist es sehr empfohlen, dass Sie ToUpperInvariant anstelle von ToLowerInvariant zu verwenden, da Microsoft hat den Code für die Durchführung von Vergleiche in Großbuchstaben .

Ich erinnere mich, dass mein Kollege einmal Zeichenketten vor dem Vergleich immer in Großbuchstaben änderte. Ich habe mich immer gefragt, warum er das tut, denn ich finde es "natürlicher", zuerst in Kleinbuchstaben zu konvertieren. Nach der Lektüre des Buches weiß ich jetzt, warum.