To przyszło mi do głowy po tym, jak nauczyłem się z tego pytania :

where T : struct

My, programiści C #, wszyscy znamy podstawy C #. Mam na myśli deklaracje, warunki, pętle, operatory itp.

Niektórzy z nas opanowali nawet takie rzeczy, jak Generics , anonimowe typy , lambda , LINQ , ...

Ale jakie są najbardziej ukryte funkcje lub sztuczki C #, o których nawet fani C #, uzależnieni, eksperci ledwo wiedzą?

Oto dotychczas ujawnione funkcje:

Słowa kluczowe

• yieldautor: Michael Stum
• varautor: Michael Stum
• using()wypowiedź kokos
• readonlyautor: kokos
• asautor: Mike Stone
• as/ isprzez Ed Swangren
• as/ is(ulepszone) przez Rocketpants
• defaultprzez deathofrats
• global::przez pzycoman
• using()bloki przez AlexCuse
• volatileautor: Jakub Šturc
• extern aliasautor: Jakub Šturc

Atrybuty

• DefaultValueAttributeautor: Michael Stum
• ObsoleteAttributeautor: DannySmurf
• DebuggerDisplayAttributeautor: Stu
• DebuggerBrowsablei DebuggerStepThroughprzez bdukes
• ThreadStaticAttributeprzez marxidad
• FlagsAttributeautor: Martin Clarke
• ConditionalAttributeautor: AndrewBurns

Składnia

• ??(koalesce nulls ) operator kokos
• Oznaczenia liczbowe przez Nicka Berardi
• where T:newautor: Lars Mæhlum
• Domniemane leki generyczne autorstwa Keitha
• Lambda jednoparametrowe Keitha
• Auto właściwości według Keitha
• Aliasy przestrzeni nazw autorstwa Keitha
• Dosłowne ciągi literałów z @ przez Patrick
• enumwartości według lfoust
• @variablenames by marxidad
• eventoperatorzy przez marxidad
• Sformatuj nawiasy ciągowe według Portmana
• Modyfikatory ułatwień dostępu przez Xanadont
• Operator warunkowy (trójskładnikowy) ( ?:) JasonS
• checkedoraz uncheckedoperatorzy Binoj Antony
• implicit and explicitoperatorzy Flory

Funkcje językowe

• Rodzaje zerowalne autorstwa Brada Barkera
• Anonimowe typy według Keitha
• __makeref __reftype __refvalueprzez Judah Himango
• Inicjalizatory obiektów przez lomaxx
• Formatuj ciągi znaków Davida w Dakocie
• Metody rozszerzenia autorstwa marxidad
• partialmetody Jona Ericksona
• Wytyczne preprocesora autorstwa Johna Asbecka
• DEBUGdyrektywa przedprocesorowa autorstwa Roberta Durgina
• Przeciążenie operatora przez SefBkn
• Wpisz wnioskowanie według czakrytu
• Operatory logiczne przeniesione na wyższy poziom przez Roba Gougha
• Przekaż zmienną typu wartości jako interfejs bez boksu przez Romana Boiko
• Programowo określ deklarowany typ zmiennej przez Romana Boiko
• Static Constructors by Chris
• Łatwiejsze w użyciu / skondensowane mapowanie ORM za pomocą LINQ przez roosteronacid
• __arglistprzez Zac Bowling

Funkcje programu Visual Studio

• Wybierz blok tekstu w edytorze autorstwa Himadri
• Fragmenty autorstwa DannySmurf

Struktura

• TransactionScopeautor: KiwiBastard
• DependantTransactionautor: KiwiBastard
• Nullable<T>przez IainMH
• Mutexprzez Diago
• System.IO.Pathprzez ageektrapped
• WeakReferenceautor: Juan Manuel

Metody i właściwości

• String.IsNullOrEmpty()metoda KiwiBastard
• List.ForEach()metoda KiwiBastard
• BeginInvoke(), EndInvoke()metody Will Dean
• Nullable<T>.HasValuei Nullable<T>.Valuewłaściwości Rismo
• GetValueOrDefaultmetoda Johna Sheehana

Porady & Triki

• Fajna metoda dla organizatorów wydarzeń autorstwa Andreasa HR Nilssona
• Porównania wielkich liter Johna
• Dostęp do typów anonimowych bez refleksji przez dp
• Szybki sposób na leniwe tworzenie instancji właściwości kolekcji przez Willa
• JavaScript-anonimowe funkcje wstawiane przez roosteronacid

Inny

• netmodules od kokos
• LINQBridge firmy Duncan Smart
• Rozszerzenia równoległe autorstwa Joela Coehoorna

To nie jest C # jako taki, ale nie widziałem nikogo, kto naprawdę używałby System.IO.Path.Combine()w takim stopniu, w jakim powinien. W rzeczywistości cała klasa Path jest naprawdę przydatna, ale nikt jej nie używa!

Jestem gotów się założyć, że każda aplikacja produkcyjna ma następujący kod, nawet jeśli nie powinna:

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

lambdas i wnioskowanie o typie są niedoceniane. Lambdas może mieć wiele instrukcji i automatycznie podwajają się jako kompatybilny obiekt delegowany (po prostu upewnij się, że podpis jest zgodny), jak w:

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

Pamiętaj, że nie mam new CancellationEventHandlerani nie muszę określać typów senderi e, są one wywnioskowane na podstawie zdarzenia. Dlatego jest to mniej kłopotliwe w pisaniu całości, delegate (blah blah)która wymaga również określenia typów parametrów.

Lambda nie musi niczego zwracać, a wnioskowanie typu jest niezwykle potężne w takim kontekście.

A BTW, zawsze możesz zwrócić Lambdas, które sprawiają, że Lambdas w sensie programowania funkcjonalnego. Na przykład, oto lambda, która tworzy lambda, która obsługuje zdarzenie 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);

Zwróć uwagę na łączenie: (dx, dy) => (sender, e) =>

Właśnie dlatego cieszę się, że wziąłem klasę programowania funkcjonalnego :-)

Poza wskazówkami w C myślę, że to kolejna podstawowa rzecz, której powinieneś się nauczyć :-)

Od Ricka Strahla :

Możesz połączyć? operator, dzięki czemu można wykonać kilka porównań zerowych.

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

Alias ​​generics:

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

Pozwala na użycie ASimpleNamezamiast Dictionary<string, Dictionary<string, List<string>>>.

Użyj go, gdy w wielu miejscach użyjesz tej samej ogólnej, długiej, skomplikowanej rzeczy.

Z CLR przez C # :

Podczas normalizacji ciągów zdecydowanie zaleca się stosowanie ToUpperInvariant zamiast ToLowerInvariant, ponieważ Microsoft zoptymalizował kod do wykonywania porównań wielkimi literami .

Pamiętam, jak kiedyś mój współpracownik zawsze zmieniał ciągi znaków na wielkie przed porównaniem. Zawsze zastanawiałem się, dlaczego to robi, ponieważ uważam, że bardziej „naturalne” jest przejście na małe litery. Po przeczytaniu książki wiem już dlaczego.

Moją ulubioną sztuczką jest użycie operatora koalescencji zerowej i nawiasów do automatycznego tworzenia instancji kolekcji.

private IList<Foo> _foo;

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

Unikaj sprawdzania procedur obsługi zdarzeń o wartości NULL

Dodanie pustego delegata do zdarzeń w momencie deklaracji, eliminując potrzebę sprawdzania zdarzenia pod kątem wartości zerowej przed wywołaniem, jest niesamowite. Przykład:

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

Pozwól to zrobić

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

Zamiast tego

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

Zobacz także pokrewną dyskusję i ten post na blogu Erica Lipperta na ten temat (i możliwe wady).

Wszystko inne plus

1) niejawne leki generyczne (dlaczego tylko na metodach, a nie na klasach?)

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

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

2) proste lambdy z jednym parametrem:

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

3) anonimowe typy i inicjatory:

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

Inny:

4) Właściwości automatyczne mogą mieć różne zakresy:

public int MyId { get; private set; }

Dzięki @pzycoman za przypomnienie:

5) Aliasy przestrzeni nazw (nie dlatego, że prawdopodobnie będziesz potrzebować tego konkretnego rozróżnienia):

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

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

Od dłuższego czasu nie znałem słowa kluczowego „jako”.

MyClass myObject = (MyClass) obj;

vs

MyClass myObject = obj as MyClass;

Drugi zwróci null, jeśli obj nie jest MyClass, zamiast zgłosić wyjątek rzutowania na klasę.

Dwie rzeczy, które lubię, to właściwości automatyczne, dzięki czemu możesz jeszcze bardziej zwinąć kod:

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

staje się

public string Name { get; set;}

Również obiekty inicjujące:

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

staje się

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

„Domyślne” słowo kluczowe w typach ogólnych:

T t = default(T);

skutkuje wartością „null”, jeśli T jest typem odniesienia, a 0, jeśli jest liczbą całkowitą, false, jeśli jest wartością logiczną itp.

Atrybuty ogólnie, ale przede wszystkim DebuggerDisplay . Oszczędza ci lat.

@ Mówi kompilatorowi, aby zignorował wszelkie znaki specjalne w ciągu.

Chciałem tylko wyjaśnić ten ... nie mówi, aby ignorował znaki specjalne, w rzeczywistości mówi kompilatorowi, aby interpretował ciąg jako literał.

Jeśli masz

string s = @"cat
             dog
             fish"

faktycznie wydrukuje jako (zwróć uwagę, że zawiera nawet spację używaną do wcięcia):

cat
             dog
             fish

Myślę, że jedną z najbardziej niedocenianych i mniej znanych funkcji C # (.NET 3.5) są drzewa wyrażeń , szczególnie w połączeniu z Generics i Lambdas. Jest to podejście do tworzenia API, z którego korzystają nowsze biblioteki, takie jak NInject i Moq.

Powiedzmy na przykład, że chcę zarejestrować metodę za pomocą interfejsu API i że interfejs API musi uzyskać nazwę metody

Biorąc pod uwagę tę klasę:

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

Wcześniej bardzo często obserwowano, jak programiści robią to z łańcuchami i typami (lub czymś innym, w dużej mierze opartym na łańcuchach):

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

Cóż, to do bani z powodu braku silnego pisania. Co się stanie, jeśli zmienię nazwę „SomeMethod”? Teraz, w wersji 3.5, mogę to zrobić w mocno typowy sposób:

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

W którym klasa RegisterMethod używa w Expression<Action<T>>ten sposób:

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

Jest to jeden z głównych powodów, dla których jestem teraz zakochany w Lambdas i drzewkach ekspresyjnych.

przychodzi mi na myśl „ dochód ”. Niektóre atrybuty, takie jak [DefaultValue ()], również należą do moich ulubionych.

Słowo kluczowe „ var ” jest nieco bardziej znane, ale można go również używać w aplikacjach .NET 2.0 (o ile używasz kompilatora .NET 3.5 i ustawiasz go na kod wyjściowy 2.0), wydaje się, że nie jest bardzo znany dobrze.

Edycja: kokos, dzięki za wskazanie ?? operator, to naprawdę bardzo przydatne. Ponieważ wyszukiwanie google jest trochę trudne (ponieważ ?? jest po prostu ignorowane), oto strona dokumentacji MSDN tego operatora: ?? Operator (C # Reference)

Zwykle stwierdzam, że większość programistów C # nie wie o typach „zerowalnych”. Zasadniczo prymitywy, które mogą mieć wartość zerową.

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

Ustaw nullable double, num1 , na null, a następnie ustaw zwykłe double, num2 , na num1 lub -100, jeśli num1 było null.

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

jeszcze jedna rzecz o typie Nullable:

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

zwracany jest String.Empty. Sprawdź ten link, aby uzyskać więcej informacji

Oto kilka interesujących ukrytych funkcji C #, w postaci nieudokumentowanych słów kluczowych C #:

__makeref

__reftype

__refvalue

__arglist

Są to nieudokumentowane słowa kluczowe C # (nawet Visual Studio je rozpoznaje!), Które zostały dodane do bardziej efektywnego boksowania / rozpakowywania przed generycznymi. Działają w koordynacji z strukturą System.TypedReference.

Istnieje również __arglist, który jest używany do list parametrów o zmiennej długości.

Jedną z rzeczy, o których ludzie nie wiedzą zbyt wiele, jest System.WeakReference - bardzo przydatna klasa, która śledzi obiekt, ale nadal pozwala zbieraczowi śmieci go gromadzić.

Najbardziej użyteczną funkcją „ukrytą” byłoby słowo kluczowe zwrotu z zysku. Nie jest tak naprawdę ukryty, ale wielu ludzi nie wie o tym. LINQ jest zbudowany na szczycie; pozwala na zapytania wykonywane z opóźnieniem, generując maszynę stanu pod maską. Raymond Chen niedawno napisał o wewnętrznych, szorstkich szczegółach .

Związki (rodzaj pamięci współużytkowanej w C ++) w czystym, bezpiecznym języku C #

Bez uciekania się do niebezpiecznego trybu i wskaźników, członkowie klasy mogą dzielić przestrzeń pamięci w klasie / strukturze. Biorąc pod uwagę następującą klasę:

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

Możesz modyfikować wartości pól bajtów, manipulując polem Int32 i odwrotnie. Na przykład ten program:

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

Wyprowadza to:

2147483647
FF FF FF 7F
65535

wystarczy dodać za pomocą System.Runtime.InteropServices;

Użycie @ dla nazw zmiennych, które są słowami kluczowymi.

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

Jeśli chcesz wyjść z programu bez wywoływania bloków lub finalizatorów, użyj funkcji FailFast :

Environment.FailFast()

Zwracanie anonimowych typów z metody i uzyskiwanie dostępu do członków bez refleksji.

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

Oto przydatne dla wyrażeń regularnych i ścieżek plików:

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

@ Mówi kompilatorowi, aby zignorował wszelkie znaki specjalne w ciągu.

Mixiny Zasadniczo, jeśli chcesz dodać funkcję do kilku klas, ale nie możesz użyć jednej klasy bazowej dla wszystkich z nich, poproś każdą klasę o wdrożenie interfejsu (bez członków). Następnie napisz metodę rozszerzenia interfejsu , tj

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

Oczywiście poświęcono trochę jasności. Ale to działa!

Nie jestem jednak pewien, dlaczego ktokolwiek miałby chcieć używać Nullable <bool>. :-)

Prawda, fałsz, FileNotFound ?

Ten nie jest „ukryty”, ale jest źle nazwany.

Wiele uwagi poświęca się algorytmom „mapuj”, „zmniejszaj” i „filtruj”. Większość ludzi nie zdaje sobie sprawy, że .NET 3.5 dodał wszystkie trzy z tych algorytmów, ale nadał im bardzo SQL-owe nazwy, w oparciu o fakt, że są częścią LINQ.

„map” => Wybierz
Przekształca dane z jednej formy w drugą

"zmniejsz" => Agreguj
Agreguje wartości w jeden wynik

„filter” => Where
Filtruje dane na podstawie kryteriów

Możliwość korzystania z LINQ do wykonywania prac inline na kolekcjach, które były używane do iteracji i operacji warunkowych, może być niezwykle cenna. Warto dowiedzieć się, w jaki sposób wszystkie metody rozszerzenia LINQ mogą pomóc w zwiększeniu kompaktowości i łatwości obsługi kodu.

Environment.NewLine

dla niezależnych od systemu nowych linii.

Jeśli próbujesz użyć nawiasów klamrowych w wyrażeniu 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. ?? - operator koalescencyjny
2. using ( instrukcja / dyrektywa ) - świetne słowo kluczowe, które może być użyte nie tylko do wywołania Dispose
3. tylko do odczytu - powinien być używany częściej
4. netmodules - szkoda, że ​​nie ma wsparcia w Visual Studio

@Ed, jestem trochę niechętny publikowaniu tego, ponieważ jest to coś więcej niż nitpicking. Chciałbym jednak zauważyć, że w twoim kodzie przykładowym:

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

Jeśli masz zamiar użyć „jest”, po co po bezpiecznej obsadzie, używając „jako”? Jeśli upewniłeś się, że obj to rzeczywiście MyClass, obsada standardowa:

c = (MyClass)obj

... nigdy nie zawiedzie.

Podobnie możesz po prostu powiedzieć:

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

Nie mam wystarczającej wiedzy o wewnętrznych dodatkach .NET, aby się upewnić, ale instynkt podpowiada mi, że ograniczyłoby to maksymalnie dwie operacje rzutowania typu do maksymalnie jednej. Jest mało prawdopodobne, że tak czy inaczej złamie bank przetwarzania; osobiście uważam, że ta druga forma też wygląda na czystszą.

Może nie jest to zaawansowana technika, ale taka, którą cały czas widzę, doprowadza mnie do szału:

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

może być skondensowany do:

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