Dies kam mir in den Sinn, nachdem ich aus dieser Frage Folgendes gelernt hatte :

where T : struct

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

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

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

Hier sind die bisher offenbarten Funktionen:

Schlüsselwörter

• yieldvon Michael Stum
• varvon Michael Stum
• using()Aussage von Kokos
• readonlyvon kokos
• asvon Mike Stone
• as/ isvon Ed Swangren
• as/ is(verbessert) von Rocketpants
• defaultvon Deathofrats
• global::von pzycoman
• using()Blöcke von AlexCuse
• volatilevon Jakub Šturc
• extern aliasvon Jakub Šturc

Attribute

• DefaultValueAttributevon Michael Stum
• ObsoleteAttributevon DannySmurf
• DebuggerDisplayAttributevon Stu
• DebuggerBrowsableund DebuggerStepThroughvon bdukes
• ThreadStaticAttributevon Marxidad
• FlagsAttributevon Martin Clarke
• ConditionalAttributevon AndrewBurns

Syntax

• ??(Koalesce Nulls) Operator von Kokos
• Nummernschilder von Nick Berardi
• where T:newvon Lars Mæhlum
• Implizite Generika von Keith
• Ein-Parameter-Lambdas von Keith
• Auto-Eigenschaften von Keith
• Namespace-Aliase von Keith
• Wörtliche String-Literale mit @ von Patrick
• enumWerte von lfoust
• @variablenames von marxidad
• eventBetreiber von Marxidad
• Formatieren Sie Zeichenfolgen in Klammern von Portman
• Eingabehilfen für den Zugriff auf Eigenschaften von xanadont
• Bedingter (ternärer) Operator ( ?:) von JasonS
• checkedund uncheckedBetreiber von Binoj Antony
• implicit and explicitBetreiber von Flory

Sprachmerkmale

• Nullable Typen von Brad Barker
• Anonyme Typen von Keith
• __makeref __reftype __refvaluevon Judah Himango
• Objektinitialisierer von lomaxx
• Formatieren Sie Zeichenfolgen von David in Dakota
• Verlängerungsmethoden von Marxidad
• partialMethoden von Jon Erickson
• Präprozessor-Direktiven von John Asbeck
• DEBUGVorprozessor-Direktive von Robert Durgin
• Überlastung des Bedieners durch SefBkn
• Typinferenz durch Chakrit
• Boolesche Operatoren von Rob Gough auf die nächste Stufe gebracht
• Übergeben Sie eine Variable vom Typ Wert als Schnittstelle ohne Boxen von Roman Boiko
• Programmgesteuerten deklarierten Variablentyp von Roman Boiko programmieren
• Statische Konstruktoren von Chris
• Einfacher auf den Augen / kondensierte ORM-Kartierung mit LINQ von Roosteronacid
• __arglistvon Zac Bowling

Visual Studio-Funktionen

• Wählen Sie einen Textblock im Editor von Himadri
• Schnipsel von DannySmurf

Rahmen

• TransactionScopevon KiwiBastard
• DependantTransactionvon KiwiBastard
• Nullable<T>von IainMH
• Mutexvon Diago
• System.IO.Pathvon ageektrapped
• WeakReferencevon Juan Manuel

Methoden und Eigenschaften

• String.IsNullOrEmpty()Methode von KiwiBastard
• List.ForEach()Methode von KiwiBastard
• BeginInvoke(), EndInvoke()Methoden von Will Dean
• Nullable<T>.HasValueund Nullable<T>.ValueEigenschaften von Rismo
• GetValueOrDefaultMethode von John Sheehan

Tipps

• Schöne Methode für Event-Handler von Andreas HR Nilsson
• Vergleiche in Großbuchstaben von John
• Zugriff auf anonyme Typen ohne Reflexion durch dp
• Ein schneller Weg, um Sammlungseigenschaften von Will träge zu instanziieren
• JavaScript-ähnliche anonyme Inline-Funktionen von Roosteronacid

Andere

• Netzmodule von Kokos
• LINQBridge von Duncan Smart
• Parallele Erweiterungen von Joel Coehoorn

Dies ist nicht C # an sich, aber ich habe niemanden gesehen, der wirklich so viel verwendet System.IO.Path.Combine(), wie er sollte. Tatsächlich ist die gesamte Path-Klasse wirklich nützlich, aber niemand benutzt sie!

Ich bin bereit zu wetten, dass jede Produktions-App den folgenden Code hat, obwohl dies nicht der Fall sein sollte:

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

Lambdas und Typinferenz werden unterschätzt. Lambdas können mehrere Anweisungen haben und sie werden automatisch als kompatibles Delegatenobjekt (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 habe new CancellationEventHandlerund keine Typen von senderund angeben emuss, die aus dem Ereignis abgeleitet werden können. Aus diesem Grund ist das Schreiben des Ganzen weniger umständlich, delegate (blah blah)sodass Sie auch Parametertypen angeben müssen.

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

Übrigens können Sie immer Lambdas zurückgeben, die Lambdas im Sinne der funktionalen Programmierung machen. Hier ist zum Beispiel ein Lambda, das ein Lambda erstellt, das ein Button.Click-Ereignis behandelt:

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, die funktionale Programmierklasse besucht zu haben :-)

Abgesehen von den Zeigern in C denke ich, dass es die andere grundlegende Sache ist, die Sie lernen sollten :-)

Von Rick Strahl :

Sie können die ?? Operator, damit Sie eine Reihe von Nullvergleichen durchführen können.

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

Alias-Generika:

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

Es ermöglicht Ihnen ASimpleName, anstelle von zu verwenden Dictionary<string, Dictionary<string, List<string>>>.

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

Von CLR über C # :

Beim Normalisieren von Zeichenfolgen wird dringend empfohlen, ToUpperInvariant anstelle von ToLowerInvariant zu verwenden, da Microsoft den Code für die Durchführung von Vergleichen in Großbuchstaben optimiert hat .

Ich erinnere mich, dass mein Kollege vor dem Vergleich einmal die Zeichenfolgen in Großbuchstaben geändert hat. Ich habe mich immer gefragt, warum er das tut, weil ich finde, dass es "natürlicher" ist, zuerst in Kleinbuchstaben umzuwandeln. Nachdem ich das Buch jetzt gelesen habe, weiß ich warum.

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

private IList<Foo> _foo;

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

Vermeiden Sie es, nach Null-Ereignishandlern zu suchen

Das Hinzufügen eines leeren Delegaten zu Ereignissen bei der Deklaration und das Unterdrücken der Notwendigkeit, das Ereignis immer auf Null zu prüfen, bevor es aufgerufen wird, ist fantastisch. Beispiel:

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

Lass dich das machen

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

An Stelle von

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

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

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

Noch einer:

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

public int MyId { get; private set; }

Danke @pzycoman, dass du mich daran erinnert hast:

5) Namespace-Aliase (nicht, dass Sie diese besondere Unterscheidung wahrscheinlich benötigen):

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

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

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

MyClass myObject = (MyClass) obj;

vs.

MyClass myObject = obj as MyClass;

Die zweite Option gibt null zurück, wenn obj keine MyClass ist, anstatt eine Klassenumwandlungsausnahme auszulösen.

Zwei Dinge, die mir gefallen, sind automatische Eigenschaften, mit denen 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 Objektinitialisierer:

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

wird

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

Das 'Standard'-Schlüsselwort in generischen Typen:

T t = default(T);

führt zu 'null', wenn T ein Referenztyp ist, und 0, wenn es ein int ist, false, wenn es ein Boolescher Wert ist, usw.

Attribute im Allgemeinen, aber vor allem DebuggerDisplay . Spart dir Jahre.

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

Ich wollte dies nur klarstellen ... es sagt ihm nicht, dass er die Escape-Zeichen ignorieren soll, sondern dass der Compiler die Zeichenfolge als Literal interpretieren soll.

Wenn Sie haben

string s = @"cat
             dog
             fish"

Es wird tatsächlich als gedruckt (beachten Sie, dass es sogar das zum Einrücken verwendete Leerzeichen enthält):

cat
             dog
             fish

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

Angenommen, ich möchte eine Methode bei einer API registrieren und diese API muss den Methodennamen abrufen

Angesichts dieser Klasse:

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

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

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

Nun, das ist scheiße wegen des Mangels an starker Typisierung. Was ist, wenn ich "SomeMethod" umbenenne? Jetzt, in Version 3.5, kann ich dies jedoch auf eine stark typisierte Weise tun:

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

In dem die RegisterMethod-Klasse Folgendes verwendet Expression<Action<T>>:

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

Dies ist ein wichtiger Grund, warum ich gerade in Lambdas und Expression Trees verliebt bin.

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

Das Schlüsselwort " var " ist etwas bekannter, 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 Gut.

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

Ich finde, dass die meisten C # -Entwickler nichts über 'nullable'-Typen wissen. Grundsätzlich Grundelemente, die einen Nullwert haben können.

double? num1 = null; 
double num2 = num1 ?? -100;

Setzen Sie ein nullbares Double, num1 , auf null und setzen Sie dann ein reguläres Double, num2 , auf num1 oder -100, wenn num1 null war.

http://msdn.microsoft.com/en-us/library/1t3y8s4s(VS.80).aspx

eine weitere Sache über Nullable-Typ:

DateTime? tmp = new DateTime();
tmp = null;
return tmp.ToString();

es ist return String.Empty. Überprüfen Sie diesen Link für weitere Details

Hier sind einige interessante versteckte C # -Funktionen in Form von undokumentierten C # -Schlüsselwörtern:

__makeref

__reftype

__refvalue

__arglist

Dies sind undokumentierte C # -Schlüsselwörter (sogar Visual Studio erkennt sie!), Die für ein effizienteres Boxen / Unboxing vor Generika hinzugefügt wurden. Sie arbeiten in Abstimmung mit der System.TypedReference-Struktur.

Es gibt auch __arglist, die für Parameterlisten mit variabler Länge verwendet wird.

Eine Sache, über die die Leute nicht viel wissen, ist System.WeakReference - eine sehr nützliche Klasse, die ein Objekt verfolgt, es dem Garbage Collector jedoch ermöglicht, es zu sammeln.

Die nützlichste "versteckte" Funktion wäre das Schlüsselwort "return return". Es ist nicht wirklich versteckt, aber viele Leute wissen nichts darüber. Darauf baut LINQ auf; Es ermöglicht verzögert ausgeführte Abfragen, indem eine Zustandsmaschine unter der Haube erzeugt wird. Raymond Chen hat kürzlich über die internen Details berichtet .

Gewerkschaften (die C ++ Shared Memory-Art) in reinem, sicherem C #

Ohne auf unsicheren Modus und Zeiger zurückzugreifen, können Klassenmitglieder Speicherplatz in einer Klasse / Struktur gemeinsam nutzen. Gegeben die folgende Klasse:

[StructLayout(LayoutKind.Explicit)]
public class A
{
    [FieldOffset(0)]
    public byte One;

    [FieldOffset(1)]
    public byte Two;

    [FieldOffset(2)]
    public byte Three;

    [FieldOffset(3)]
    public byte Four;

    [FieldOffset(0)]
    public int Int32;
}

Sie können die Werte der Bytefelder ändern, indem Sie das Int32-Feld bearbeiten und umgekehrt. Zum Beispiel dieses Programm:

    static void Main(string[] args)
    {
        A a = new A { Int32 = int.MaxValue };

        Console.WriteLine(a.Int32);
        Console.WriteLine("{0:X} {1:X} {2:X} {3:X}", a.One, a.Two, a.Three, a.Four);

        a.Four = 0;
        a.Three = 0;
        Console.WriteLine(a.Int32);
    }

Gibt dies aus:

2147483647
FF FF FF 7F
65535

Fügen Sie einfach mit System.Runtime.InteropServices hinzu.

Verwenden von @ für Variablennamen, bei denen es sich um Schlüsselwörter handelt.

var @object = new object();
var @string = "";
var @if = IpsoFacto(); 

Wenn Sie Ihr Programm beenden möchten, ohne endgültige Blöcke oder Finalizer aufzurufen , verwenden Sie FailFast :

Environment.FailFast()

Rückgabe anonymer Typen von 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;
}

Hier ist eine nützliche 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 Zeichenfolge zu ignorieren.

Mixins. Wenn Sie mehreren Klassen ein Feature hinzufügen möchten, aber nicht für alle eine Basisklasse verwenden können, muss jede Klasse eine Schnittstelle implementieren (ohne Mitglieder). Schreiben Sie dann eine Erweiterungsmethode für die Schnittstelle , dh

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

Natürlich wird etwas Klarheit geopfert. Aber es funktioniert!

Ich bin mir nicht sicher, warum irgendjemand jemals Nullable <bool> verwenden möchte. :-)

Richtig , falsch, FileNotFound ?

Dieser ist nicht so sehr "versteckt", als dass er falsch benannt ist.

Viel Aufmerksamkeit wird den Algorithmen "Map", "Reduce" und "Filter" gewidmet. Was die meisten Leute nicht merken, ist, dass .NET 3.5 alle drei dieser Algorithmen hinzugefügt hat, aber es gab ihnen sehr SQL-ähnliche Namen, basierend auf der Tatsache, dass sie Teil von LINQ sind.

"map" => Select
Transformiert Daten von einem Formular in ein anderes

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

"filter" => Where
Filtert Daten basierend auf einem Kriterium

Die Möglichkeit, mit LINQ Inline-Arbeiten an Sammlungen durchzuführen, für die früher Iterationen und Bedingungen erforderlich waren, kann unglaublich wertvoll sein. Es lohnt sich zu lernen, wie alle LINQ-Erweiterungsmethoden dazu beitragen können, Ihren Code viel kompakter und wartbarer zu machen.

Environment.NewLine

für systemunabhängige Zeilenumbrüche.

Wenn Sie versuchen, geschweifte Klammern in einem String.Format-Ausdruck zu verwenden ...

int foo = 3;
string bar = "blind mice";
String.Format("{{I am in brackets!}} {0} {1}", foo, bar);
//Outputs "{I am in brackets!} 3 blind mice"

1. ??- Koaleszenzbetreiber
2. using ( Anweisung / Direktive ) - ein großartiges Schlüsselwort, das nicht nur zum Aufrufen von Dispose verwendet werden kann
3. schreibgeschützt - sollte mehr verwendet werden
4. Netzmodule - schade, dass Visual Studio keine Unterstützung bietet

@Ed, ich bin etwas zurückhaltend, wenn es darum geht, dies zu veröffentlichen, da es kaum mehr als ein Trottel ist. Ich möchte jedoch darauf hinweisen, dass in Ihrem Codebeispiel:

MyClass c;
  if (obj is MyClass)
    c = obj as MyClass

Wenn Sie 'is' verwenden möchten, warum sollten Sie dann eine sichere Besetzung mit 'as' durchführen? Wenn Sie festgestellt haben, dass es sich bei obj tatsächlich um MyClass handelt, eine Besetzung nach Moorstandard:

c = (MyClass)obj

... wird niemals scheitern.

Ebenso könnte man einfach sagen:

MyClass c = obj as MyClass;
if(c != null)
{
   ...
}

Ich weiß nicht genug über die Innereien von .NET, um sicher zu sein, aber mein Instinkt sagt mir, dass dies maximal zwei Typ-Casts-Operationen auf maximal eine reduzieren würde. Es ist kaum wahrscheinlich, dass die Verarbeitungsbank so oder so kaputt geht. Ich persönlich denke, die letztere Form sieht auch sauberer aus.

Vielleicht keine fortgeschrittene Technik, aber eine, die ich ständig sehe und die mich verrückt macht:

if (x == 1)
{
   x = 2;
}
else
{
   x = 3;
}

kann verdichtet werden zu:

x = (x==1) ? 2 : 3;