Điều này xuất hiện trong đầu tôi sau khi tôi học được những điều sau đây từ câu hỏi này :

where T : struct

Chúng tôi, các nhà phát triển C #, tất cả đều biết những điều cơ bản của C #. Ý tôi là khai báo, điều kiện, vòng lặp, toán tử, v.v.

Một số người trong chúng ta thậm chí còn thành thạo các công cụ như Generics , các loại ẩn danh , lambdas , LINQ , ...

Nhưng những tính năng hay thủ thuật ẩn giấu nhất của C # mà ngay cả người hâm mộ, người nghiện, chuyên gia C # cũng không biết?

Dưới đây là các tính năng được tiết lộ cho đến nay:

Từ khóa

• yieldbởi Michael Stum
• varbởi Michael Stum
• using()tuyên bố của kokos
• readonlybởi kokos
• asbởi Mike Stone
• as/ isbởi Ed Swangren
• as/ is(được cải thiện) bởi Rocketpants
• defaultbởi deathofrats
• global::bởi pzycoman
• using()khối của AlexCuse
• volatilebởi Jakub turc
• extern aliasbởi Jakub turc

Thuộc tính

• DefaultValueAttributebởi Michael Stum
• ObsoleteAttributebởi DanielSmurf
• DebuggerDisplayAttributebởi Stu
• DebuggerBrowsablevà DebuggerStepThroughbởi bdukes
• ThreadStaticAttributebởi marxidad
• FlagsAttributecủa Martin Clarke
• ConditionalAttributebởi AndrewBurns

Cú pháp

• ??Toán tử (hợp nhất null) bởi kokos
• Cờ hiệu số của Nick Berardi
• where T:newbởi Lars Mæhlum
• Khái quát tiềm ẩn của Keith
• Lambdas một tham số của Keith
• Thuộc tính tự động của Keith
• Bí danh không gian tên của Keith
• Nguyên văn chuỗi ký tự với @ by Patrick
• enumgiá trị của lfoust
• @variablenames bởi marxidad
• eventkhai thác bởi marxidad
• Định dạng chuỗi ngoặc theo Portman
• Công cụ sửa đổi khả năng truy cập thuộc tính của xanadont
• Toán tử có điều kiện (ternary) ( ?:) của JasonS
• checkedvà các uncheckednhà khai thác bởi Binoj Antony
• implicit and explicitkhai thác bởi Flory

Đặc điểm ngôn ngữ

• Các loại không thể xóa của Brad Barker
• Các loại ẩn danh của Keith
• __makeref __reftype __refvaluebởi Judah Himango
• Đối tượng khởi tạo bởi lomaxx
• Định dạng chuỗi của David ở Dakota
• Phương pháp mở rộng của marxidad
• partialphương pháp của Jon Erickson
• Chỉ thị tiền xử lý của John Asbeck
• DEBUGchỉ thị tiền xử lý của Robert Durgin
• Quá tải toán tử bởi SefBkn
• Gõ vô sinh bằng chakrit
• Toán tử Boolean được đưa lên cấp độ tiếp theo bởi Rob Gough
• Vượt qua biến loại giá trị như giao diện mà không có quyền anh của Roman Boiko
• Lập trình xác định loại biến được khai báo bởi Roman Boiko
• Xây dựng tĩnh bởi Chris
• Ánh xạ ORM dễ nhìn hơn / cô đặc hơn bằng cách sử dụng LINQ bởi roosteronacid
• __arglistbởi Zac Bowling

Tính năng Visual Studio

• Chọn khối văn bản trong trình soạn thảo của Himadri
• Đoạn trích của DanielSmurf

Khung

• TransactionScopebởi KiwiBastard
• DependantTransactionbởi KiwiBastard
• Nullable<T>bởi IainMH
• Mutexbởi Diago
• System.IO.Pathbởi ageektrapping
• WeakReferencebởi Juan Manuel

Phương thức và tính chất

• String.IsNullOrEmpty()phương pháp của KiwiBastard
• List.ForEach()phương pháp của KiwiBastard
• BeginInvoke(), EndInvoke()phương pháp của Will Dean
• Nullable<T>.HasValuevà Nullable<T>.Valuetài sản của Rismo
• GetValueOrDefaultphương pháp của John Sheehan

Mẹo và thủ thuật

• Phương pháp hay cho người xử lý sự kiện của Andreas HR Nilsson
• So sánh chữ hoa của John
• Truy cập các loại ẩn danh mà không có sự phản ánh của dp
• Một cách nhanh chóng để nhanh chóng khởi tạo các thuộc tính bộ sưu tập của Will
• Các hàm nội tuyến ẩn danh giống như JavaScript của roosteronacid

Khác

• netmodules bởi kokos
• LINQBridge của Duncan Smart
• Phần mở rộng song song của Joel Coehoorn

Đây không phải là C # per se, nhưng tôi chưa thấy ai thực sự sử dụng System.IO.Path.Combine()đến mức họ nên làm. Trong thực tế, toàn bộ lớp Path thực sự hữu ích, nhưng không ai sử dụng nó!

Tôi sẵn sàng đặt cược rằng mọi ứng dụng sản xuất đều có mã sau, mặc dù không nên:

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

lambdas và suy luận loại được đánh giá thấp. Lambdas có thể có nhiều câu lệnh và chúng tự động nhân đôi thành một đối tượng ủy nhiệm tương thích (chỉ cần đảm bảo khớp chữ ký) như trong:

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

Lưu ý rằng tôi không phải new CancellationEventHandlercũng không phải chỉ định các loại sendervà e, chúng không thể tham gia được từ sự kiện. Đó là lý do tại sao điều này ít rườm rà hơn khi viết toàn bộ delegate (blah blah)cũng đòi hỏi bạn phải chỉ định các loại tham số.

Lambdas không cần trả lại bất cứ điều gì và kiểu suy luận cực kỳ mạnh mẽ trong bối cảnh như thế này.

Và BTW, bạn luôn có thể trả về Lambdas tạo ra Lambdas theo nghĩa lập trình chức năng. Ví dụ: đây là lambda tạo ra lambda xử lý sự kiện 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);

Lưu ý chuỗi: (dx, dy) => (sender, e) =>

Bây giờ, đó là lý do tại sao tôi rất vui khi tham gia lớp lập trình chức năng :-)

Khác với các con trỏ trong C, tôi nghĩ đó là điều cơ bản khác bạn nên học :-)

Từ Rick Strahl :

Bạn có thể xâu chuỗi ?? toán tử để bạn có thể thực hiện một loạt các so sánh null.

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

Chung chung bí danh:

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

Nó cho phép bạn sử dụng ASimpleName, thay vì Dictionary<string, Dictionary<string, List<string>>>.

Sử dụng nó khi bạn sẽ sử dụng cùng một thứ phức tạp lớn dài chung ở nhiều nơi.

Từ CLR qua C # :

Khi chuẩn hóa các chuỗi, chúng tôi khuyên bạn nên sử dụng ToUpperInvariant thay vì ToLowerInvariant vì Microsoft đã tối ưu hóa mã để thực hiện so sánh chữ hoa .

Tôi nhớ một lần đồng nghiệp của tôi luôn thay đổi chuỗi thành chữ hoa trước khi so sánh. Tôi đã luôn tự hỏi tại sao anh ấy làm điều đó bởi vì tôi cảm thấy nó "tự nhiên" hơn để chuyển đổi thành chữ thường trước. Sau khi đọc cuốn sách bây giờ tôi biết tại sao.

Thủ thuật yêu thích của tôi là sử dụng toán tử hợp nhất null và dấu ngoặc đơn để tự động khởi tạo các bộ sưu tập cho tôi.

private IList<Foo> _foo;

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

Tránh kiểm tra xử lý sự kiện null

Thêm một đại biểu trống vào các sự kiện khi khai báo, không cần phải luôn luôn kiểm tra sự kiện đó trước khi gọi nó là tuyệt vời. Thí dụ:

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

Để bạn làm điều này

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

Thay vì cái này

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

Xin vui lòng xem cuộc thảo luận liên quan này và bài đăng trên blog này của Eric Lippert về chủ đề này (và những nhược điểm có thể xảy ra).

Mọi thứ khác, cộng với

1) khái quát chung (tại sao chỉ trên các phương thức mà không phải trên các lớp học?)

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

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

2) lambdas đơn giản với một tham số:

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

3) các loại ẩn danh và khởi tạo:

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

Một số khác:

4) Thuộc tính tự động có thể có phạm vi khác nhau:

public int MyId { get; private set; }

Cảm ơn @pzycoman đã nhắc nhở tôi:

5) Bí danh không gian tên (không phải là bạn có thể cần sự khác biệt đặc biệt này):

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

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

Tôi đã không biết từ khóa "như" trong một thời gian dài.

MyClass myObject = (MyClass) obj;

đấu với

MyClass myObject = obj as MyClass;

Cái thứ hai sẽ trả về null nếu obj không phải là MyClass, thay vì ném ngoại lệ cast class.

Hai điều tôi thích là thuộc tính Tự động để bạn có thể thu gọn mã của mình xuống hơn nữa:

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

trở thành

public string Name { get; set;}

Ngoài ra đối tượng khởi tạo:

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

trở thành

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

Từ khóa 'mặc định' trong các loại chung:

T t = default(T);

kết quả là 'null' nếu T là loại tham chiếu và 0 nếu đó là int, false nếu đó là boolean, vân vân.

Các thuộc tính nói chung, nhưng hầu hết tất cả các DebuggerDisplay . Tiết kiệm cho bạn nhiều năm.

@ Nói trình biên dịch bỏ qua mọi ký tự thoát trong chuỗi.

Chỉ muốn làm rõ cái này ... nó không bảo nó bỏ qua các ký tự thoát, nó thực sự bảo trình biên dịch diễn giải chuỗi dưới dạng một nghĩa đen.

Nếu bạn có

string s = @"cat
             dog
             fish"

nó thực sự sẽ in ra (lưu ý rằng nó thậm chí bao gồm khoảng trắng được sử dụng để thụt lề):

cat
             dog
             fish

Tôi nghĩ rằng một trong những tính năng được đánh giá thấp và ít được biết đến nhất của C # (.NET 3.5) là Cây biểu hiện , đặc biệt là khi kết hợp với Generics và Lambdas. Đây là một cách tiếp cận để tạo API mà các thư viện mới hơn như NInject và Moq đang sử dụng.

Ví dụ: giả sử tôi muốn đăng ký một phương thức với API và API đó cần có được tên phương thức

Cho lớp này:

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

Trước đây, rất phổ biến khi thấy các nhà phát triển làm điều này với các chuỗi và loại (hoặc một cái gì đó chủ yếu dựa trên chuỗi):

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

Vâng, đó là hút vì thiếu gõ mạnh. Nếu tôi đổi tên "someMethod" thì sao? Bây giờ, trong 3.5, tuy nhiên, tôi có thể thực hiện việc này theo kiểu được gõ mạnh:

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

Trong đó lớp RegisterMethod sử dụng Expression<Action<T>>như thế này:

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

Đây là một lý do lớn khiến tôi yêu Lambdas và Expression Tree ngay bây giờ.

" năng suất " sẽ đến với tâm trí của tôi. Một số thuộc tính như [DefaultValue ()] cũng nằm trong số các mục yêu thích của tôi.

Các " var " từ khóa là nổi tiếng hơn một chút, nhưng mà bạn có thể sử dụng nó trong các ứng dụng .NET 2.0 cũng như (miễn là bạn sử dụng trình biên dịch .NET 3.5 và đặt nó là mã đầu ra 2.0) dường như không được biết đến rất tốt.

Chỉnh sửa: kokos, cảm ơn vì đã chỉ ra ?? Toán tử, điều đó thực sự hữu ích. Vì hơi khó để google cho nó (vì ?? chỉ bị bỏ qua), đây là trang tài liệu MSDN cho nhà điều hành đó: ?? Toán tử (Tham khảo C #)

Tôi có xu hướng thấy rằng hầu hết các nhà phát triển C # không biết về các loại 'nullable'. Về cơ bản, nguyên thủy có thể có giá trị null.

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

Đặt một đôi không thể, num1 , thành null, sau đó đặt một đôi thông thường, num2 , thành num1 hoặc -100 nếu num1 là null.

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

một điều nữa về loại Nullable:

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

đó là trả về String.Empty. Kiểm tra liên kết này để biết thêm chi tiết

Dưới đây là một số tính năng C # ẩn thú vị, dưới dạng từ khóa C # không có giấy tờ:

__makeref

__reftype

__refvalue

__arglist

Đây là những từ khóa C # không có giấy tờ (ngay cả Visual Studio cũng nhận ra chúng!) Đã được thêm vào để đấm bốc / bỏ hộp hiệu quả hơn trước khi sử dụng thuốc generic. Chúng phối hợp với cấu trúc System.TypedReference.

Ngoài ra còn có __arglist, được sử dụng cho danh sách tham số độ dài thay đổi.

Một điều mọi người không biết nhiều là System.WeakReference - một lớp rất hữu ích để theo dõi một đối tượng nhưng vẫn cho phép người thu gom rác thu thập nó.

Tính năng "ẩn" hữu ích nhất sẽ là từ khóa lợi nhuận. Nó không thực sự bị ẩn, nhưng rất nhiều người không biết về nó. LINQ được xây dựng trên đỉnh này; nó cho phép các truy vấn được thực hiện trễ bằng cách tạo một máy trạng thái dưới mui xe. Raymond Chen gần đây đã đăng về các chi tiết nội bộ, nghiệt ngã .

Liên hiệp (loại bộ nhớ chia sẻ C ++) trong C # thuần túy, an toàn

Không cần dùng đến chế độ và con trỏ không an toàn, bạn có thể yêu cầu các thành viên lớp chia sẻ không gian bộ nhớ trong một lớp / struct. Cho lớp sau:

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

Bạn có thể sửa đổi các giá trị của các trường byte bằng cách thao tác trường Int32 và ngược lại. Ví dụ, chương trình này:

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

Đầu ra này:

2147483647
FF FF FF 7F
65535

chỉ cần thêm bằng System.R.78.InteropService;

Sử dụng @ cho tên biến là từ khóa.

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

Nếu bạn muốn thoát khỏi chương trình của mình mà không gọi bất kỳ khối cuối cùng hoặc bộ hoàn thiện nào, hãy sử dụng FailFast :

Environment.FailFast()

Trả về các loại ẩn danh từ một phương thức và truy cập các thành viên mà không cần phản ánh.

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

Đây là một cách hữu ích cho các biểu thức và đường dẫn tệp thông thường:

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

@ Nói trình biên dịch bỏ qua mọi ký tự thoát trong chuỗi.

Hỗn hợp. Về cơ bản, nếu bạn muốn thêm một tính năng cho một số lớp, nhưng không thể sử dụng một lớp cơ sở cho tất cả chúng, hãy yêu cầu mỗi lớp thực hiện một giao diện (không có thành viên). Sau đó, viết một phương thức mở rộng cho giao diện , tức là

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

Tất nhiên, một số sự rõ ràng là hy sinh. Nhưng nó đã có tác dụng!

Không chắc chắn tại sao mọi người sẽ muốn sử dụng Nullable <bool> mặc dù. :-)

Đúng, Sai, FileNotFound ?

Cái này không "ẩn" quá nhiều vì nó được đặt tên sai.

Rất nhiều sự chú ý được dành cho các thuật toán "bản đồ", "thu nhỏ" và "bộ lọc". Điều mà hầu hết mọi người không nhận ra là .NET 3.5 đã thêm cả ba thuật toán này, nhưng nó mang lại cho họ những cái tên rất SQL, dựa trên thực tế rằng chúng là một phần của LINQ.

"bản đồ" => Chọn
Chuyển đổi dữ liệu từ dạng này sang dạng khác

"giảm" => Tổng hợp
hợp các giá trị Tổng hợp thành một kết quả duy nhất

"bộ lọc" => Nơi
bộ lọc dữ liệu dựa trên một tiêu chí

Khả năng sử dụng LINQ để thực hiện công việc nội tuyến trên các bộ sưu tập được sử dụng để lặp lại và điều kiện có thể cực kỳ có giá trị. Thật đáng để tìm hiểu làm thế nào tất cả các phương thức mở rộng LINQ có thể giúp làm cho mã của bạn gọn hơn và dễ bảo trì hơn nhiều.

Environment.NewLine

cho các dòng mới độc lập hệ thống.

Nếu bạn đang cố gắng sử dụng dấu ngoặc nhọn bên trong biểu thức 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. ?? - toán tử liên kết
2. bằng cách sử dụng ( tuyên bố / chỉ thị ) - từ khóa tuyệt vời có thể được sử dụng nhiều hơn là chỉ gọi Vứt bỏ
3. chỉ đọc - nên được sử dụng nhiều hơn
4. netmodules - quá tệ không có hỗ trợ trong Visual Studio

@Ed, tôi hơi thận trọng về việc đăng bài này vì nó ít hơn nhiều so với nitpicking. Tuy nhiên, tôi sẽ chỉ ra rằng trong mẫu mã của bạn:

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

Nếu bạn sẽ sử dụng 'là', tại sao lại theo dõi nó với một dàn diễn viên an toàn bằng cách sử dụng 'as'? Nếu bạn đã xác định rằng obj thực sự là MyClass, một diễn viên tiêu chuẩn không có thật:

c = (MyClass)obj

... sẽ không bao giờ thất bại.

Tương tự, bạn chỉ có thể nói:

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

Tôi không biết đủ về các bộ phận của .NET để chắc chắn, nhưng bản năng của tôi nói với tôi rằng điều này sẽ cắt giảm tối đa hai loại hoạt động phôi xuống tối đa một. Dù sao thì nó cũng khó có thể phá vỡ ngân hàng xử lý; cá nhân, tôi nghĩ rằng hình thức sau có vẻ sạch sẽ hơn.

Có thể không phải là một kỹ thuật tiên tiến, nhưng một trong những điều tôi thấy suốt thời gian khiến tôi phát điên:

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

có thể được ngưng tụ để:

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