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

Das Schlüsselwort "default" in generischen Typen:

T t = default(T);

ergibt 'null', wenn T ein Referenztyp ist, und 0, wenn es ein int ist, false, wenn es ein boolean ist, und so weiter.

Answer 2

Attribute im Allgemeinen, aber vor allem DebuggerDisplay . Das spart Ihnen Jahre.

Answer 3

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

Wollte nur dieses eine zu klären... es nicht sagen, es zu ignorieren, die Escape-Zeichen, es tatsächlich sagt der Compiler, die Zeichenfolge als ein Literal zu interpretieren.

Wenn Sie eine

string s = @"cat
             dog
             fish"

ausgedruckt wird (beachten Sie, dass es sogar die Leerzeichen für die Einrückung enthält):

cat
             dog
             fish

Answer 4

Ich denke, eine der am meisten unterschätzten und weniger bekannten Funktionen von C# (.NET 3.5) sind Ausdrucksbäume , insbesondere in Kombination mit Generika und Lambdas. Dies ist ein Ansatz zur API-Erstellung, den neuere Bibliotheken wie NInject und Moq verwenden.

Nehmen wir zum Beispiel an, ich möchte eine Methode bei einer API registrieren und diese API muss den Namen der Methode erhalten

Angesichts dieser Klasse:

public class MyClass
{
     public void SomeMethod() { /* Do Something */ }
}

Früher war es sehr üblich, dass Entwickler dies mit Strings und Typen (oder etwas anderem, das weitgehend auf Strings basiert) taten:

RegisterMethod(typeof(MyClass), "SomeMethod");

Nun, das ist scheiße, weil es keine starke Schreibweise gibt. Was, wenn ich "SomeMethod" umbenenne? Jetzt, in 3.5, kann ich dies jedoch in einer stark typisierten Weise tun:

RegisterMethod<MyClass>(cl => cl.SomeMethod());

Die Klasse RegisterMethod verwendet Expression<Action<T>> wie diese:

void RegisterMethod<T>(Expression<Action<T>> action) where T : class
{
    var expression = (action.Body as MethodCallExpression);

    if (expression != null)
    {
        // TODO: Register method
        Console.WriteLine(expression.Method.Name);
    }
}

Das ist ein wichtiger Grund, warum ich Lambdas und Expression Trees gerade jetzt so liebe.

Answer 5

" Ertrag "würde mir in den Sinn kommen. Einige der Attribute wie [DefaultValue()] gehören ebenfalls zu meinen Favoriten.

Die " var "-Schlüsselwort etwas bekannter ist, aber dass Sie es auch in .NET 2.0-Anwendungen verwenden können (solange Sie den .NET 3.5 Compiler verwenden und ihn auf die Ausgabe von 2.0-Code einstellen), scheint nicht sehr bekannt zu sein.

Edit: kokos, danke für den Hinweis auf den ?? Operator, das ist in der Tat sehr nützlich. Da es ein bisschen schwierig ist, danach zu googeln (da ?? einfach ignoriert wird), hier ist die MSDN-Dokumentationsseite für diesen Operator: ?? Operator (C#-Referenz)