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

Vielen Menschen ist nicht klar, dass sie Saiten vergleichen können: OrdinalIgnoreCase vergleichen können, anstatt someString.ToUpper() zu verwenden. Dadurch entfällt der zusätzliche Overhead bei der Stringzuweisung.

if( myString.ToUpper() == theirString.ToUpper() ){ ... }

wird

if( myString.Equals( theirString, StringComparison.OrdinalIgnoreCase ) ){ ... }

Answer 2

Gerade gelernt, anonyme Typen können Eigenschaftsnamen aus dem Variablennamen ableiten:

string hello = "world";
var o = new { hello };
Console.WriteLine(o.hello);

Answer 3

Ich mag es, Dinge in einer Liste nachzuschlagen, wie zum Beispiel:-

bool basketContainsFruit(string fruit) {
  return new[] { "apple", "orange", "banana", "pear" }.Contains(fruit);
}

Anstatt:-

bool basketContainsFruit(string fruit) {
  return fruit == "apple" || fruit == "orange" || fruit == "banana" ||
    fruit == "pear";
}

In der Praxis kommt das nicht so oft vor, aber die Idee, Elemente mit dem Thema der Suche abzugleichen, kann wirklich sehr nützlich und prägnant sein.

Answer 4

Ehrlich gesagt sollten die Experten per definitionem mit diesen Dingen vertraut sein. Aber um Ihre Frage zu beantworten: Tabelle der eingebauten Typen (C#-Referenz)

Die Compiler-Flags für Zahlen sind für diese weithin bekannt:

Decimal = M
Float = F
Double = D

// for example
double d = 30D;

Diese sind jedoch eher undurchsichtig:

Long = L
Unsigned Long = UL
Unsigned Int = U

Answer 5

InternalsVisibleTo ist ein Attribut, das nicht so bekannt ist, aber unter bestimmten Umständen sehr nützlich sein kann. Es ermöglicht im Grunde einer anderen Assembly den Zugriff auf "interne" Elemente der definierenden Assembly.