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

Mein Lieblingstrick ist die Verwendung der Null-Koaleszenz-Operator und Klammern, um automatisch Sammlungen für mich zu instanziieren.

private IList<Foo> _foo;

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

Answer 2

Vermeiden Sie die Überprüfung auf Null-Ereignishandler

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

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

Lassen Sie sich das machen

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

Stattdessen

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

Bitte beachten Sie auch dies verwandte Diskussion und dies Blog-Eintrag von Eric Lippert zu diesem Thema (und möglichen Nachteilen).

Answer 3

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

---

Eine andere:

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

public int MyId { get; private set; }

---

Danke @pzycoman, dass du mich daran erinnert hast:

5) Namensraum-Aliase (nicht, dass Sie diese besondere Unterscheidung benötigen würden):

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

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

Answer 4

Ich kannte das Schlüsselwort "as" eine ganze Weile lang nicht.

MyClass myObject = (MyClass) obj;

gegen

MyClass myObject = obj as MyClass;

Die zweite gibt null zurück, wenn obj keine MyClass ist, anstatt eine Klassen-Cast-Ausnahme auszulösen.

Answer 5

Zwei Dinge, die ich mag, sind automatische Eigenschaften, damit Sie Ihren Code noch weiter reduzieren können:

private string _name;
public string Name
{
    get
    {
        return _name;
    }
    set
    {
        _name = value;
    }
}

wird

public string Name { get; set;}

Auch Objektinitialisierungen:

Employee emp = new Employee();
emp.Name = "John Smith";
emp.StartDate = DateTime.Now();

wird

Employee emp = new Employee {Name="John Smith", StartDate=DateTime.Now()}