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

Rückgabe anonymer Typen aus einer Methode und Zugriff auf Mitglieder ohne Reflexion.

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

Answer 2

Hier ist ein nützliches Beispiel für reguläre Ausdrücke und Dateipfade:

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

Das @ weist den Compiler an, alle Escape-Zeichen in einer Zeichenkette zu ignorieren.

Answer 3

Mixins. Wenn Sie eine Funktion zu mehreren Klassen hinzufügen möchten, aber nicht eine Basisklasse für alle verwenden können, implementieren Sie eine Schnittstelle (ohne Mitglieder) in jeder Klasse. Schreiben Sie dann eine Erweiterungsmethode für die Schnittstelle d.h.

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

Natürlich geht dies zu Lasten der Klarheit. Aber es funktioniert!

Answer 4

Ich weiß allerdings nicht, warum jemand Nullable<bool> verwenden sollte :-)

Wahr, Falsch, FileNotFound ?

Answer 5

Dieser ist nicht so sehr "versteckt", sondern nur falsch benannt.

Viel Aufmerksamkeit wird den Algorithmen "map", "reduce" und "filter" gewidmet. Was die meisten Leute nicht wissen, ist, dass .NET 3.5 alle drei dieser Algorithmen hinzugefügt hat, ihnen aber sehr SQL-ähnliche Namen gegeben hat, die darauf beruhen, dass sie Teil von LINQ sind.

"map" => Auswählen
Daten umwandeln von einer Form in eine andere

"reduzieren" => Aggregat
Aggregate Werte zu einem einzigen Ergebnis

"Filter" => Wo
Daten filtern nach einem Kriterium

Die Möglichkeit, LINQ für die Inline-Bearbeitung von Sammlungen zu verwenden, die früher Iterationen und Konditionierungen erforderten, kann unglaublich wertvoll sein. Es lohnt sich zu lernen, wie alle LINQ-Erweiterungsmethoden dazu beitragen können, Ihren Code kompakter und wartbarer zu machen.