Questo mi è venuto in mente dopo aver appreso quanto segue da questa domanda :

where T : struct

Noi, sviluppatori di C #, conosciamo tutti le basi di C #. Intendo dichiarazioni, condizionali, loop, operatori, ecc.

Alcuni di noi hanno anche imparato cose come Generici , tipi anonimi , lambda , LINQ , ...

Ma quali sono le funzionalità o i trucchi più nascosti di C # che persino i fan di C #, i tossicodipendenti e gli esperti conoscono a malapena?

Ecco le caratteristiche rivelate finora:

parole

• yielddi Michael Stum
• vardi Michael Stum
• using()dichiarazione di Kokos
• readonlydi kokos
• asdi Mike Stone
• as/ isdi Ed Swangren
• as/ is(migliorato) di Rocketpants
• defaultdi deathofrats
• global::di pzycoman
• using()blocchi di AlexCuse
• volatiledi Jakub Šturc
• extern aliasdi Jakub Šturc

attributi

• DefaultValueAttributedi Michael Stum
• ObsoleteAttributedi DannySmurf
• DebuggerDisplayAttributedi Stu
• DebuggerBrowsablee DebuggerStepThroughdai bdukes
• ThreadStaticAttributedi marxidad
• FlagsAttributedi Martin Clarke
• ConditionalAttributedi AndrewBurns

Sintassi

• ??(coalesce nulls) operator di kokos
• Numero flaggings di Nick Berardi
• where T:newdi Lars Mæhlum
• Generici impliciti di Keith
• Lambdas a un parametro di Keith
• Proprietà automatiche di Keith
• Alias ​​dello spazio dei nomi di Keith
• Verbatim string letterali con @ di Patrick
• enumvalori di lfoust
• @variablenames di marxidad
• eventoperatori di marxidad
• Formatta le parentesi di stringa di Portman
• Modificatori di accessibilità dell'accessor di proprietà di xanadont
• Operatore condizionale (ternario) ( ?:) di JasonS
• checkede uncheckedoperatori di Binoj Antony
• implicit and explicitoperatori di Flory

Caratteristiche del linguaggio

• Tipi nullabili di Brad Barker
• Tipi anonimi di Keith
• __makeref __reftype __refvaluedi Judah Himango
• Inizializzatori di oggetti di lomaxx
• Formatta le stringhe di David in Dakota
• Metodi di estensione di marxidad
• partialmetodi di Jon Erickson
• Direttive del preprocessore di John Asbeck
• DEBUGdirettiva pre-processore di Robert Durgin
• Sovraccarico dell'operatore da parte di SefBkn
• Digitare inferrenza per chakrit
• Operatori booleani portati al livello successivo da Rob Gough
• Passa la variabile value-type come interfaccia senza boxe di Roman Boiko
• Determinare programmaticamente il tipo di variabile dichiarato da Roman Boiko
• Costruttori statici di Chris
• Mappatura ORM più semplice per gli occhi / condensata usando LINQ di roosteronacid
• __arglistdi Zac Bowling

Funzionalità di Visual Studio

• Seleziona il blocco di testo nell'editor di Himadri
• Snippet di DannySmurf

Struttura

• TransactionScopedi KiwiBastard
• DependantTransactiondi KiwiBastard
• Nullable<T>di IainMH
• Mutexdi Diago
• System.IO.Pathda ageektrapped
• WeakReferencedi Juan Manuel

Metodi e proprietà

• String.IsNullOrEmpty()metodo di KiwiBastard
• List.ForEach()metodo di KiwiBastard
• BeginInvoke(), EndInvoke()metodi di Will Dean
• Nullable<T>.HasValuee Nullable<T>.Valueproprietà di Rismo
• GetValueOrDefaultmetodo di John Sheehan

Suggerimenti e trucchi

• Bel metodo per i gestori di eventi di Andreas HR Nilsson
• Confronti maiuscoli di John
• Accedi a tipi anonimi senza riflessione di dp
• Un modo rapido per istanziare pigramente le proprietà della collezione di Will
• Funzioni in linea anonime simili a JavaScript di roosteronacid

Altro

• netmodules di kokos
• LINQBridge di Duncan Smart
• Estensioni parallele di Joel Coehoorn

Questo non è C # di per sé, ma non ho visto nessuno che lo usi davvero System.IO.Path.Combine()nella misura in cui dovrebbe. In effetti, l'intera classe Path è davvero utile, ma nessuno la usa!

Sono disposto a scommettere che ogni app di produzione ha il seguente codice, anche se non dovrebbe:

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

lambda e inferenza del tipo sono sottovalutati. Lambdas può avere più istruzioni e raddoppiano automaticamente come oggetto delegato compatibile (assicurati solo che la firma corrisponda) come in:

Console.CancelKeyPress +=
    (sender, e) => {
        Console.WriteLine("CTRL+C detected!\n");
        e.Cancel = true;
    };

Si noti che non ho new CancellationEventHandlerné devo specificare i tipi di sendere e, sono inferibili dall'evento. Questo è il motivo per cui è meno complicato scrivere tutto, il delegate (blah blah)che richiede anche di specificare i tipi di parametri.

Le lambda non hanno bisogno di restituire nulla e l'inferenza del tipo è estremamente potente in un contesto come questo.

E a proposito, puoi sempre restituire Lambdas che rendono Lambdas nel senso della programmazione funzionale. Ad esempio, ecco un lambda che crea un lambda che gestisce un evento Button.Click:

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

Nota il concatenamento: (dx, dy) => (sender, e) =>

Ora è per questo che sono felice di aver preso la classe di programmazione funzionale :-)

A parte i puntatori in C, penso che sia l'altra cosa fondamentale che dovresti imparare :-)

Da Rick Strahl :

Puoi incatenare il ?? operatore in modo da poter fare un sacco di confronti null.

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

Generici con alias:

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

Ti permette di usare ASimpleName, invece di Dictionary<string, Dictionary<string, List<string>>>.

Usalo quando useresti la stessa cosa generica lunga e complessa in molti posti.

Da CLR via C # :

Quando si normalizzano le stringhe, si consiglia vivamente di utilizzare ToUpperInvariant anziché ToLowerInvariant perché Microsoft ha ottimizzato il codice per eseguire confronti maiuscoli .

Ricordo che una volta il mio collega ha sempre cambiato le stringhe in maiuscolo prima del confronto. Mi sono sempre chiesto perché lo fa perché ritengo che sia più "naturale" convertire prima in minuscolo. Dopo aver letto il libro ora so perché.

Il mio trucco preferito è usare l' operatore di coalescenza null e le parentesi per istanziare automagicamente le raccolte per me.

private IList<Foo> _foo;

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

Evitare di controllare i gestori di eventi null

Aggiungere un delegato vuoto agli eventi durante la dichiarazione, sopprimendo la necessità di controllare sempre l'evento per null prima di chiamarlo, è fantastico. Esempio:

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

Lascialo fare

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

Invece di questo

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

Vedi anche questa discussione correlata e questo post sul blog di Eric Lippert su questo argomento (e possibili aspetti negativi).

Tutto il resto, oltre

1) generici impliciti (perché solo sui metodi e non sulle classi?)

void GenericMethod<T>( T input ) { ... }

//Infer type, so
GenericMethod<int>(23); //You don't need the <>.
GenericMethod(23);      //Is enough.

2) lambda semplici con un parametro:

x => x.ToString() //simplify so many calls

3) tipi anonimi e inizializzatori:

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

Un altro:

4) Le proprietà automatiche possono avere ambiti diversi:

public int MyId { get; private set; }

Grazie @pzycoman per avermelo ricordato:

5) Alias ​​dello spazio dei nomi (non che tu abbia probabilmente bisogno di questa particolare distinzione):

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

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

Non conoscevo la parola chiave "as" da un po '.

MyClass myObject = (MyClass) obj;

vs

MyClass myObject = obj as MyClass;

Il secondo restituirà null se obj non è una MyClass, anziché generare un'eccezione di cast di classe.

Due cose che mi piacciono sono le proprietà automatiche in modo da poter comprimere ulteriormente il codice:

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

diventa

public string Name { get; set;}

Anche inizializzatori di oggetti:

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

diventa

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

La parola chiave "predefinita" in tipi generici:

T t = default(T);

genera un "null" se T è un tipo di riferimento e 0 se è un int, falso se è un valore booleano, eccetera.

Attributi in generale, ma soprattutto DebuggerDisplay . Ti salva anni.

@ Indica al compilatore di ignorare tutti i caratteri di escape in una stringa.

Volevo solo chiarire questo ... non gli dice di ignorare i caratteri di escape, in realtà dice al compilatore di interpretare la stringa come un valore letterale.

Se hai

string s = @"cat
             dog
             fish"

verrà effettivamente stampato come (si noti che include anche lo spazio bianco utilizzato per il rientro):

cat
             dog
             fish

Penso che una delle funzionalità meno apprezzate e meno conosciute di C # (.NET 3.5) siano gli Expression Tree , specialmente se combinati con Generics e Lambdas. Questo è un approccio alla creazione dell'API utilizzato da librerie più recenti come NInject e Moq.

Ad esempio, diciamo che voglio registrare un metodo con un'API e che l'API deve ottenere il nome del metodo

Data questa classe:

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

Prima, era molto comune vedere gli sviluppatori fare questo con stringhe e tipi (o qualcos'altro in gran parte basato su stringhe):

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

Bene, questo fa schifo a causa della mancanza di una digitazione forte. E se rinominassi "SomeMethod"? Ora, in 3.5, tuttavia, posso farlo in modo fortemente tipizzato:

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

In cui la classe RegisterMethod utilizza in Expression<Action<T>>questo modo:

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

Questa è una grande ragione per cui sono innamorato di Lambdas e Expression Trees in questo momento.

la " resa " mi sarebbe venuta in mente. Alcuni degli attributi come [DefaultValue ()] sono anche tra i miei preferiti.

La parola chiave " var " è un po 'più nota, ma è possibile utilizzarla anche nelle applicazioni .NET 2.0 (purché si usi il compilatore .NET 3.5 e lo imposti sul codice di output 2.0) non sembra essere molto conosciuta bene.

Modifica: kokos, grazie per aver sottolineato il ?? operatore, è davvero molto utile. Dato che è un po 'difficile cercarlo su Google (dato che ?? è appena ignorato), ecco la pagina di documentazione MSDN per quell'operatore: ?? Operatore (riferimento C #)

Tendo a scoprire che la maggior parte degli sviluppatori C # non conosce tipi "nullable". Fondamentalmente, primitive che possono avere un valore nullo.

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

Impostare un doppio nullable, num1 , su null, quindi impostare un doppio normale, num2 , su num1 o -100 se num1 era null.

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

un'altra cosa sul tipo Nullable:

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

è return String.Empty. Controlla questo link per maggiori dettagli

Ecco alcune interessanti funzionalità C # nascoste, sotto forma di parole chiave C # non documentate:

__makeref

__reftype

__refvalue

__arglist

Queste sono parole chiave C # non documentate (anche Visual Studio le riconosce!) A cui sono state aggiunte per un boxing / unboxing più efficiente prima dei farmaci generici. Lavorano in coordinamento con la struttura System.TypedReference.

C'è anche __arglist, che viene utilizzato per elenchi di parametri di lunghezza variabile.

Una cosa di cui la gente non sa molto è System.WeakReference - una classe molto utile che tiene traccia di un oggetto ma consente comunque al garbage collector di raccoglierlo.

La funzione "nascosta" più utile sarebbe la parola chiave return return. Non è davvero nascosto, ma molte persone non lo sanno. LINQ è costruito sopra questo; consente di eseguire query ritardate generando una macchina a stati sotto il cofano. Raymond Chen ha recentemente pubblicato dei dettagli interni e grintosi .

Unions (il tipo di memoria condivisa C ++) in C # puro e sicuro

Senza ricorrere a modalità e puntatori non sicuri, è possibile fare in modo che i membri della classe condividano lo spazio di memoria in una classe / struttura. Data la seguente classe:

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

È possibile modificare i valori dei campi byte modificando il campo Int32 e viceversa. Ad esempio, questo programma:

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

Emette questo:

2147483647
FF FF FF 7F
65535

basta aggiungere usando System.Runtime.InteropServices;

Utilizzo di @ per nomi di variabili che sono parole chiave.

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

Se si desidera uscire dal programma senza richiamare finalmente blocchi o finalizzatori, utilizzare FailFast :

Environment.FailFast()

Restituzione di tipi anonimi da un metodo e accesso ai membri senza riflessione.

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

Eccone uno utile per espressioni regolari e percorsi di file:

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

@ Indica al compilatore di ignorare tutti i caratteri di escape in una stringa.

Mixins. Fondamentalmente, se si desidera aggiungere una funzione a più classi, ma non è possibile utilizzare una classe di base per tutte, fare in modo che ciascuna classe implementi un'interfaccia (senza membri). Quindi, scrivere un metodo di estensione per l'interfaccia , ad es

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

Certo, viene sacrificata una certa chiarezza. Ma funziona!

Non so perché qualcuno vorrebbe mai usare Nullable <bool> però. :-)

Vero, falso, FileNotFound ?

Questo non è "nascosto" tanto quanto è erroneamente chiamato.

Molta attenzione è riservata agli algoritmi "map", "ridurre" e "filtro". Ciò che la maggior parte delle persone non capisce è che .NET 3.5 ha aggiunto tutti e tre questi algoritmi, ma ha dato loro nomi molto SQL-ish, in base al fatto che fanno parte di LINQ.

"map" => Seleziona
Trasforma i dati da un modulo a un altro

"ridurre" =>
Aggrega i valori aggregati in un unico risultato

"filter" => Dove filtra i
dati in base a un criterio

La capacità di utilizzare LINQ per eseguire lavori in linea su raccolte utilizzate in passato per iterazioni e condizionali può essere incredibilmente preziosa. Vale la pena imparare come tutti i metodi di estensione LINQ possono aiutare a rendere il codice molto più compatto e gestibile.

Environment.NewLine

per newline indipendenti dal sistema.

Se stai cercando di usare parentesi graffe all'interno di un'espressione String.Format ...

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. ?? - operatore a coalescenza
2. using ( istruzione / direttiva ) - ottima parola chiave che può essere utilizzata per più di una semplice chiamata a Dispose
3. di sola lettura - dovrebbe essere usato di più
4. netmodules - peccato che non ci sia supporto in Visual Studio

@Ed, sono un po 'reticente nel pubblicare questo in quanto è poco più di un pignolo. Tuttavia, vorrei sottolineare che nel tuo esempio di codice:

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

Se hai intenzione di usare 'is', perché seguirlo con un cast sicuro usando 'as'? Se hai accertato che obj è davvero MyClass, un cast standard:

c = (MyClass)obj

... non fallirà mai.

Allo stesso modo, potresti semplicemente dire:

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

Non ne so abbastanza delle viscere di .NET per essere sicuro, ma il mio istinto mi dice che ciò ridurrebbe al massimo due operazioni di cast di tipo fino a un massimo di una. È improbabile che rompa la banca di elaborazione in entrambi i casi; personalmente, penso che anche quest'ultima forma sia più pulita.

Forse non è una tecnica avanzata, ma una che vedo tutto il tempo che mi fa impazzire:

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

può essere condensato in:

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