Sự khác biệt giữa tạo đại biểu tiềm ẩn và rõ ràng (có và không có generics)

Question

Xem bốn dòng trong Go() phương pháp dưới đây:

delegate void Action<T>(T arg); 
delegate void Action(); 

void DoSomething<T>(Action<T> action) 
{ 
    //... 
} 

void DoSomething(Action action) 
{ 
    //... 
} 

void MyAction<T>(T arg) 
{ 
    //... 
} 

void MyAction() 
{ 
    //... 
} 

void Go<T>() 
{ 
    DoSomething<T>(MyAction<T>); // throws compiler error - why? 
    DoSomething(new Action<T>(MyAction<T>)); // no problems here 
    DoSomething(MyAction); // what's the difference between this... 
    DoSomething(new Action(MyAction)); // ... and this? 
} 

Lưu ý rằng lỗi biên dịch được tạo ra bởi các cuộc gọi đầu tiên là: Các đối số kiểu cho phương thức 'Hành động (T)' không thể suy ra từ việc sử dụng. Hãy thử xác định các đối số kiểu một cách rõ ràng.

Answer 1

Không có sự khác biệt giữa MyAction và new Action(MyAction) (khi cả hai đều hợp lệ) khác với tên cũ sẽ không hoạt động trong C# 1. Đây là implicit method group conversion. Có những lúc điều này không thể áp dụng, đáng chú ý nhất khi trình biên dịch không thể tìm ra loại đại biểu bạn muốn, ví dụ:

Delegate foo = new Action(MyAction); // Fine 
Delegate bar = MyAction; // Nope, can't tell target type 

Điều này xảy ra trong câu hỏi của bạn vì cả hai phương pháp liên quan đều bị quá tải. Điều này dẫn đến đau đầu, về cơ bản.

Đối với mặt generics - điều đó thật thú vị. Các nhóm phương pháp không nhận được nhiều tình cảm từ suy luận kiểu C# 3 - Tôi không chắc liệu điều đó có được cải thiện trong C# 4 hay không. Nếu bạn gọi một phương thức chung và chỉ định đối số kiểu, suy luận kiểu hoạt động khá tốt - nhưng nếu bạn cố gắng để làm điều đó theo chiều ngược lại, nó không thành công:

using System; 

class Test 
{ 
    static void Main() 
    { 
     // Valid - it infers Foo<int> 
     DoSomething<int>(Foo); 
     // Valid - both are specified 
     DoSomething<int>(Foo<int>); 
     // Invalid - type inference fails 
     DoSomething(Foo<int>); 
     // Invalid - mismatched types, basically 
     DoSomething<int>(Foo<string>); 
    } 

    static void Foo<T>(T input) 
    { 
    } 

    static void DoSomething<T>(Action<T> action) 
    { 
     Console.WriteLine(typeof(T)); 
    } 
} 

Loại suy luận trong C# 3 là rất phức tạp, và hoạt động tốt trong hầu hết các trường hợp (đặc biệt là rất tốt cho LINQ) nhưng không thành công trong một vài trường hợp khác. Trong một thế giới lý tưởng, sẽ dễ hiểu hơn để hiểu được và mạnh mẽ hơn trong các phiên bản sau ... chúng ta sẽ thấy!

Answer 2

phi-generic tạo đại biểu ngầm chỉ là cú pháp đường, vì vậy trình biên dịch tạo ra chính xác cùng mã cho

DoSomething(MyAction); 

và

DoSomething(new Action(MyAction)); 

vì nó có thể suy ra các loại của các đại biểu trực tiếp từ đối số phương thức & ngữ cảnh.

Với đại biểu chung, bạn phải chỉ định loại đại biểu do hiệp phương sai và đối nghịch (xem http://msdn.microsoft.com/en-us/library/ms173174(VS.80).aspx để biết chi tiết) - T trong hành động có thể là siêu kiểu cho T trong phương thức và vẫn sẽ được chấp nhận một phương thức đại biểu. Vì vậy, bạn cần phải xác định T trong delegate một cách rõ ràng vì trình biên dịch không thể tự tìm ra nó.

Answer 3

Chỉ cần một sidenote .. Vì một số lý do này hoạt động trong VB.

Dường như việc triển khai bộ tiền xử lý trong C# và VB khác nhau khi tôi chuyển sang nhóm Methodgroup/adderessof thành một đại biểu.