Ini muncul di benak saya setelah saya mempelajari yang berikut dari pertanyaan ini :

where T : struct

Kami, pengembang C #, semua tahu dasar-dasar C #. Maksud saya deklarasi, kondisional, loop, operator, dll.

Beberapa dari kita bahkan menguasai hal-hal seperti Generik , tipe anonim , lambdas , LINQ , ...

Tapi apa saja fitur atau trik paling tersembunyi dari C # yang bahkan tidak diketahui oleh penggemar, pecandu, dan pakar C #?

Berikut adalah fitur yang terungkap sejauh ini:

Kata kunci

• yieldoleh Michael Stum
• varoleh Michael Stum
• using()pernyataan oleh kokos
• readonlyoleh kokos
• asoleh Mike Stone
• as/ isdari Ed Swangren
• as/ is(ditingkatkan) oleh Rocketpants
• defaultoleh deathofrats
• global::oleh pzycoman
• using()blok oleh AlexCuse
• volatileoleh Jakub Šturc
• extern aliasoleh Jakub Šturc

Atribut

• DefaultValueAttributeoleh Michael Stum
• ObsoleteAttributeoleh DannySmurf
• DebuggerDisplayAttributeoleh Stu
• DebuggerBrowsable dan DebuggerStepThrough oleh bdukes
• ThreadStaticAttributeoleh marxidad
• FlagsAttribute oleh Martin Clarke
• ConditionalAttribute oleh AndrewBurns

Sintaksis

• ?? (coalesce nulls) operator oleh kokos
• Angka ditandai oleh Nick Berardi
• where T:new oleh Lars Mæhlum
• Obat generik implisit oleh Keith
• Satu-parameter lambdas oleh Keith
• Properti otomatis oleh Keith
• Namespace alias oleh Keith
• Verbatim string literals dengan @ by Patrick
• enum nilai oleh lfoust
• @variablenames oleh marxidad
• event operator oleh marxidad
• Format kurung string dengan Portman
• Pengubah aksesibilitas properti atau akses oleh xanadont
• Operator kondisional (ternary) ( ?:) oleh JasonS
• checkeddan uncheckedoperator oleh Binoj Antony
• implicit and explicitoperator oleh Flory

Fitur Bahasa

• Jenis tidak dapat dihapus oleh Brad Barker
• Jenis anonim menurut Keith
• __makeref __reftype __refvalue oleh Judah Himango
• Penginisialisasi objek oleh lomaxx
• Memformat string dengan David di Dakota
• Metode Penyuluhan oleh marxidad
• partial metode oleh Jon Erickson
• Arahan preprosesor oleh preprosesor John Asbeck
• DEBUG direktif pra-prosesor oleh Robert Durgin
• Operator kelebihan oleh SefBkn
• Ketik inferensi berdasarkan chakrit
• Operator Boolean dibawa ke tingkat berikutnya oleh Rob Gough
• Lulus variabel tipe nilai sebagai antarmuka tanpa tinju oleh Roman Boiko
• Secara terprogram menentukan jenis variabel yang dideklarasikan oleh Roman Boiko
• Konstruktor Statis oleh Chris
• Pemetaan ORM yang lebih mudah dilihat / dipadatkan menggunakan LINQ oleh roosteronacid
• __arglistoleh Zac Bowling

Fitur Visual Studio

• Pilih blok teks dalam editor oleh Himadri
• Cuplikan oleh DannySmurf

Kerangka

• TransactionScopeoleh KiwiBastard
• DependantTransactionoleh KiwiBastard
• Nullable<T>oleh IainMH
• Mutexoleh Diago
• System.IO.Path oleh ageektrapped
• WeakReferenceoleh Juan Manuel

Metode dan Properti

• String.IsNullOrEmpty()metode oleh KiwiBastard
• List.ForEach()metode oleh KiwiBastard
• BeginInvoke(), EndInvoke()metode oleh Will Dean
• Nullable<T>.HasValuedan Nullable<T>.Valueproperti oleh Rismo
• GetValueOrDefaultmetode oleh John Sheehan

Tips dan Trik

• Metode yang bagus untuk penangan acara oleh Andreas HR Nilsson
• Perbandingan huruf besar oleh John
• Akses tipe anonim tanpa refleksi oleh dp
• Cara cepat untuk instantiate properti koleksi dengan malas oleh Will
• JavaScript-seperti fungsi inline anonim oleh roosteronacid

Lain

• netmodules oleh kokos
• LINQBridge oleh Duncan Smart
• Ekstensi Paralel oleh Joel Coehoorn

Ini bukan C # per se, tapi saya belum melihat siapa pun yang benar-benar menggunakan System.IO.Path.Combine()sejauh yang seharusnya. Faktanya, seluruh kelas Path benar-benar bermanfaat, tetapi tidak ada yang menggunakannya!

Saya berani bertaruh bahwa setiap aplikasi produksi memiliki kode berikut, meskipun seharusnya tidak:

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

lambdas dan inferensi tipe diremehkan. Lambdas dapat memiliki banyak pernyataan dan merangkap sebagai objek delegasi yang kompatibel secara otomatis (pastikan pencocokan tanda tangan) seperti pada:

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

Perhatikan bahwa saya tidak memiliki new CancellationEventHandlerdan tidak harus menentukan jenis senderdan e, mereka dapat disimpulkan dari acara tersebut. Itulah sebabnya ini kurang merepotkan untuk menulis keseluruhan delegate (blah blah)yang juga mengharuskan Anda untuk menentukan jenis parameter.

Lambdas tidak perlu mengembalikan apa pun dan mengetik inferensi sangat kuat dalam konteks seperti ini.

Dan BTW, Anda selalu dapat mengembalikan Lambdas yang membuat Lambdas dalam pengertian pemrograman fungsional. Misalnya, inilah lambda yang membuat lambda yang menangani acara Button.Klik:

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

Perhatikan chaining: (dx, dy) => (sender, e) =>

Nah, itu sebabnya saya senang telah mengambil kelas pemrograman fungsional :-)

Selain petunjuk dalam C, saya pikir itu hal mendasar lain yang harus Anda pelajari :-)

Dari Rick Strahl :

Anda dapat rantai ?? operator sehingga Anda dapat melakukan banyak perbandingan nol.

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

Obat generik:

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

Hal ini memungkinkan Anda untuk menggunakan ASimpleName, bukanDictionary<string, Dictionary<string, List<string>>> .

Gunakan ketika Anda akan menggunakan hal kompleks panjang besar generik yang sama di banyak tempat.

Dari CLR via C # :

Ketika menormalkan string, sangat disarankan agar Anda menggunakan ToUpperInvariant daripada ToLowerInvariant karena Microsoft telah mengoptimalkan kode untuk melakukan perbandingan huruf besar .

Saya ingat suatu kali rekan kerja saya selalu mengubah string menjadi huruf besar sebelum membandingkan. Saya selalu bertanya-tanya mengapa dia melakukan itu karena saya merasa lebih "alami" untuk beralih ke huruf kecil terlebih dahulu. Setelah membaca buku itu sekarang saya tahu mengapa.

Trik favorit saya adalah menggunakan operator penggabungan nol dan tanda kurung untuk secara otomatis instantiate koleksi untuk saya.

private IList<Foo> _foo;

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

Hindari memeriksa penangan acara nol

Menambahkan delegasi kosong ke acara di deklarasi, menekan kebutuhan untuk selalu memeriksa acara untuk nol sebelum memanggilnya keren. Contoh:

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

Biarkan kamu melakukan ini

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

Alih-alih ini

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

Silakan juga lihat diskusi terkait ini dan posting blog ini oleh Eric Lippert tentang topik ini (dan kemungkinan kerugian).

Yang lainnya, plus

1) generik implisit (mengapa hanya pada metode dan bukan pada kelas?)

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

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

2) lambda sederhana dengan satu parameter:

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

3) jenis dan inisialisasi anonim:

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

Yang lainnya:

4) Properti otomatis dapat memiliki cakupan yang berbeda:

public int MyId { get; private set; }

Terima kasih @pcomcoman untuk mengingatkan saya:

5) Alias ​​Namespace (bukan berarti Anda membutuhkan perbedaan khusus ini):

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

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

Saya tidak tahu kata kunci "sebagai" selama beberapa waktu.

MyClass myObject = (MyClass) obj;

vs.

MyClass myObject = obj as MyClass;

Yang kedua akan mengembalikan nol jika obj bukan MyClass, daripada melemparkan pengecualian pemain kelas.

Dua hal yang saya sukai adalah properti Otomatis sehingga Anda dapat menciutkan kode Anda lebih jauh:

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

menjadi

public string Name { get; set;}

Juga inisialisasi objek:

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

menjadi

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

Kata kunci 'default' dalam tipe umum:

T t = default(T);

menghasilkan 'null' jika T adalah tipe referensi, dan 0 jika itu adalah int, false jika itu adalah boolean, dan sebagainya.

Atribut secara umum, tetapi sebagian besar dari semua DebuggerDisplay . Menghemat Anda bertahun-tahun.

@ Memberitahu kompiler untuk mengabaikan karakter escape dalam sebuah string.

Hanya ingin memperjelas yang ini ... itu tidak memberitahu untuk mengabaikan karakter pelarian, itu sebenarnya memberitahu kompiler untuk menafsirkan string sebagai literal.

Jika Anda memiliki

string s = @"cat
             dog
             fish"

itu benar-benar akan dicetak sebagai (perhatikan bahwa itu bahkan termasuk spasi putih yang digunakan untuk indentasi):

cat
             dog
             fish

Saya pikir salah satu fitur yang paling kurang dihargai dan kurang dikenal dari C # (.NET 3.5) adalah Pohon Ekspresi , terutama ketika dikombinasikan dengan Generics dan Lambdas. Ini adalah pendekatan untuk pembuatan API yang menggunakan perpustakaan baru seperti NInject dan Moq.

Misalnya, katakanlah saya ingin mendaftarkan metode dengan API dan API perlu mendapatkan nama metode

Diberikan kelas ini:

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

Sebelumnya, sangat umum untuk melihat pengembang melakukan ini dengan string dan tipe (atau sesuatu yang sebagian besar berbasis string):

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

Yah, itu menyebalkan karena kurangnya mengetik yang kuat. Bagaimana jika saya mengganti nama "SomeMethod"? Sekarang, dalam 3,5 namun, saya bisa melakukan ini dengan cara yang sangat diketik:

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

Di mana kelas RegisterMethod menggunakan Expression<Action<T>>seperti ini:

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

Ini adalah salah satu alasan utama mengapa saya jatuh cinta dengan Lambdas dan Pohon Ekspresi saat ini.

" Hasil " akan muncul di pikiranku. Beberapa atribut seperti [DefaultValue ()] juga di antara favorit saya.

Kata kunci " var " sedikit lebih dikenal, tetapi Anda juga dapat menggunakannya dalam aplikasi .NET 2.0 (selama Anda menggunakan kompiler .NET 3.5 dan mengaturnya untuk mengeluarkan kode 2.0) tampaknya tidak terlalu dikenal. baik.

Sunting: kokos, terima kasih telah menunjukkan ?? Operator, itu memang sangat berguna. Karena agak sulit untuk google untuk itu (seperti ?? diabaikan), berikut adalah halaman dokumentasi MSDN untuk operator itu: ?? Operator (Referensi C #)

Saya cenderung menemukan bahwa sebagian besar pengembang C # tidak tahu tentang tipe 'nullable'. Pada dasarnya, primitif yang dapat memiliki nilai nol.

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

Setel angka nol , num1 , menjadi nol, lalu setel angka ganda, num2 , menjadi num1 atau -100 jika num1 bernilai nol.

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

satu hal lagi tentang tipe Nullable:

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

itu mengembalikan String.Empty. Periksa tautan ini untuk detail lebih lanjut

Berikut adalah beberapa fitur C # tersembunyi yang menarik, dalam bentuk kata kunci C # tidak berdokumen:

__makeref

__reftype

__refvalue

__arglist

Ini adalah kata kunci C # tidak berdokumen (bahkan Visual Studio mengenalinya!) Yang ditambahkan untuk tinju / unboxing yang lebih efisien sebelum obat generik. Mereka bekerja dalam koordinasi dengan System.TypedReference struct.

Ada juga __arglist, yang digunakan untuk daftar parameter panjang variabel.

Satu hal yang tidak diketahui banyak orang adalah System.WeakReference - kelas yang sangat berguna yang melacak objek tetapi masih memungkinkan pengumpul sampah untuk mengumpulkannya.

Fitur "tersembunyi" yang paling berguna adalah kata kunci hasil pengembalian. Itu tidak benar-benar tersembunyi, tetapi banyak orang tidak tahu tentang itu. LINQ dibangun di atas ini; ini memungkinkan untuk permintaan yang dieksekusi dengan menghasilkan mesin negara di bawah kap. Raymond Chen baru-baru ini memposting tentang detail internal yang kasar .

Serikat pekerja (jenis memori yang dibagikan C ++) dalam C # murni dan aman

Tanpa beralih ke mode dan pointer yang tidak aman, Anda dapat meminta anggota kelas berbagi ruang memori di kelas / struct. Diberi kelas berikut:

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

Anda dapat mengubah nilai-nilai bidang byte dengan memanipulasi bidang Int32 dan sebaliknya. Misalnya, program ini:

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

Output ini:

2147483647
FF FF FF 7F
65535

cukup tambahkan menggunakan System.Runtime.InteropServices;

Menggunakan @ untuk nama variabel yang merupakan kata kunci.

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

Jika Anda ingin keluar dari program Anda tanpa memanggil blok atau penyelesai akhirnya gunakan FailFast :

Environment.FailFast()

Mengembalikan jenis anonim dari metode dan mengakses anggota tanpa refleksi.

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

Inilah yang bermanfaat untuk ekspresi reguler dan jalur file:

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

@ Memberitahu kompiler untuk mengabaikan karakter escape dalam sebuah string.

Mixin. Pada dasarnya, jika Anda ingin menambahkan fitur ke beberapa kelas, tetapi tidak dapat menggunakan satu kelas dasar untuk semua kelas tersebut, mintalah setiap kelas untuk mengimplementasikan antarmuka (tanpa anggota). Kemudian, tulis metode ekstensi untuk antarmuka , yaitu

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

Tentu saja, beberapa kejelasan dikorbankan. Tapi berhasil!

Tidak yakin mengapa ada orang yang ingin menggunakan Nullable <bool>. :-)

Benar, Salah, FileNotFound ?

Yang ini tidak "disembunyikan" sebanyak itu salah namanya.

Banyak perhatian diberikan pada algoritme "peta", "kurangi", dan "filter". Apa yang kebanyakan orang tidak sadari adalah. NET 3.5 menambahkan ketiga algoritma ini, tetapi memberi mereka nama yang sangat SQL-ish, berdasarkan pada fakta bahwa mereka adalah bagian dari LINQ.

"map" => Pilih
Mengubah data dari satu formulir ke bentuk lain

"kurangi" => Agregat
Agregat Nilai agregat menjadi satu hasil

"filter" => Di mana
Memfilter data berdasarkan kriteria

Kemampuan untuk menggunakan LINQ untuk melakukan pekerjaan inline pada koleksi yang digunakan untuk mengambil iterasi dan persyaratan bisa sangat berharga. Perlu dipelajari bagaimana semua metode ekstensi LINQ dapat membantu membuat kode Anda jauh lebih ringkas dan mudah dikelola.

Environment.NewLine

untuk baris baru independen sistem.

Jika Anda mencoba menggunakan kurung keriting di dalam ekspresi 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 penggabungan
2. using ( statement / directive ) - kata kunci hebat yang bisa digunakan lebih dari sekadar menelepon Buang
3. readonly - harus digunakan lebih banyak
4. netmodules - sayang sekali tidak ada dukungan di Visual Studio

@ Id, saya agak enggan untuk memposting ini karena ini sedikit lebih dari sekadar nitpicking. Namun, saya akan menunjukkan bahwa dalam sampel kode Anda:

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

Jika Anda akan menggunakan 'apa adanya', mengapa harus diikuti dengan pemain aman menggunakan 'sebagai'? Jika Anda sudah memastikan bahwa obj memang MyClass, pemain standar rawa:

c = (MyClass)obj

... tidak akan pernah gagal.

Demikian pula, Anda bisa mengatakan:

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

Saya tidak cukup tahu tentang. NET innards untuk memastikan, tetapi insting saya mengatakan kepada saya bahwa ini akan memotong maksimum dua jenis operasi pemain ke maksimum satu. Kemungkinan besar tidak akan merusak bank pemrosesan; secara pribadi, saya pikir bentuk terakhir terlihat lebih bersih juga.

Mungkin bukan teknik yang canggih, tapi yang saya lihat sepanjang waktu itu membuat saya gila:

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

dapat diringkas menjadi:

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