Bạn có thể làm gì trong MSIL mà bạn không thể làm trong C # hoặc VB.NET? [đóng cửa]

Tất cả các mã được viết bằng ngôn ngữ .NET biên dịch thành MSIL, nhưng có các tác vụ / thao tác cụ thể mà bạn chỉ có thể thực hiện khi sử dụng MSIL trực tiếp không?

Chúng ta cũng có những thứ được thực hiện dễ dàng hơn trong MSIL so với C #, VB.NET, F #, j # hoặc bất kỳ ngôn ngữ .NET nào khác.

Cho đến nay chúng ta có điều này:

1. Đuôi đệ quy
2. Chung chung / Chống chỉ định
3. Quá tải chỉ khác nhau ở các loại trả về
4. Ghi đè sửa đổi truy cập
5. Có một lớp không thể kế thừa từ System.Object
6. Các ngoại lệ được lọc (có thể được thực hiện trong vb.net)
7. Gọi một phương thức ảo của loại lớp tĩnh hiện tại.
8. Nhận một điều khiển trên phiên bản đóng hộp của một loại giá trị.
9. Làm thử / lỗi.
10. Sử dụng tên cấm.
11. Xác định các hàm tạo không tham số của riêng bạn cho các loại giá trị .
12. Xác định các sự kiện với một raiseyếu tố.
13. Một số chuyển đổi được CLR cho phép nhưng không phải bởi C #.
14. Thực hiện một main()phương pháp không phải là .entrypoint.
15. làm việc với các loại bản địa intvà bản địa unsigned inttrực tiếp.
16. Chơi với con trỏ thoáng qua
17. chỉ thị phát ra trong Phương thứcBodyItem
18. Ném và bắt các loại System.Exception
19. Kế thừa Enums (Chưa được xác minh)
20. Bạn có thể coi một mảng byte là một mảng int (nhỏ hơn 4 lần).
21. Bạn có thể có một trường / phương thức / thuộc tính / sự kiện đều có cùng tên (Chưa được xác minh).
22. Bạn có thể phân nhánh trở lại thành một khối thử từ khối bắt riêng của nó.
23. Bạn có quyền truy cập vào công cụ xác định truy cập famandassem ( protected internallà fam hoặc lắp ráp)
24. Truy cập trực tiếp vào <Module>lớp để xác định các hàm toàn cục hoặc trình khởi tạo mô-đun.

MSIL cho phép quá tải chỉ khác nhau ở các loại trả về vì

call void [mscorlib]System.Console::Write(string)

hoặc là

callvirt int32 ...

Hầu hết các ngôn ngữ .Net bao gồm C # và VB không sử dụng tính năng đệ quy đuôi của mã MSIL.

Đệ quy đuôi là một tối ưu hóa phổ biến trong các ngôn ngữ chức năng. Nó xảy ra khi một phương thức A kết thúc bằng cách trả về giá trị của phương thức B sao cho ngăn xếp của phương thức A có thể được giải quyết sau khi lệnh gọi phương thức B được thực hiện.

Mã MSIL hỗ trợ đệ quy đuôi một cách rõ ràng và đối với một số thuật toán, đây có thể là một tối ưu hóa quan trọng để thực hiện. Nhưng vì C # và VB không tạo ra các hướng dẫn để làm điều này, nên nó phải được thực hiện thủ công (hoặc sử dụng F # hoặc một số ngôn ngữ khác).

Dưới đây là một ví dụ về cách đệ quy đuôi có thể được thực hiện thủ công trong C #:

private static int RecursiveMethod(int myParameter)
{
    // Body of recursive method
    if (BaseCase(details))
        return result;
    // ...

    return RecursiveMethod(modifiedParameter);
}

// Is transformed into:

private static int RecursiveMethod(int myParameter)
{
    while (true)
    {
        // Body of recursive method
        if (BaseCase(details))
            return result;
        // ...

        myParameter = modifiedParameter;
    }
}

Đó là thực tế phổ biến để loại bỏ đệ quy bằng cách di chuyển dữ liệu cục bộ từ ngăn xếp phần cứng lên cấu trúc dữ liệu ngăn xếp được phân bổ heap. Trong loại bỏ đệ quy cuộc gọi đuôi như hình trên, ngăn xếp được loại bỏ hoàn toàn, đó là một tối ưu hóa khá tốt. Ngoài ra, giá trị trả về không phải đi lên chuỗi cuộc gọi dài mà được trả lại trực tiếp.

Nhưng, dù sao, CIL cung cấp tính năng này như một phần của ngôn ngữ, nhưng với C # hoặc VB, nó phải được thực hiện thủ công. (Jitter cũng được tự do thực hiện tối ưu hóa này, nhưng đó là một vấn đề hoàn toàn khác.)

Trong MSIL, bạn có thể có một lớp không thể kế thừa từ System.Object.

Mã mẫu: biên dịch nó với ilasm.exe CẬP NHẬT: Bạn phải sử dụng "/ NOAUTOINHERIT" để ngăn trình biên dịch tự động kế thừa.

// Metadata version: v2.0.50215
.assembly extern mscorlib
{
  .publickeytoken = (B7 7A 5C 56 19 34 E0 89 )                         // .z\V.4..
  .ver 2:0:0:0
}
.assembly sample
{
  .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) 
  .hash algorithm 0x00008004
  .ver 0:0:0:0
}
.module sample.exe
// MVID: {A224F460-A049-4A03-9E71-80A36DBBBCD3}
.imagebase 0x00400000
.file alignment 0x00000200
.stackreserve 0x00100000
.subsystem 0x0003       // WINDOWS_CUI
.corflags 0x00000001    //  ILONLY
// Image base: 0x02F20000


// =============== CLASS MEMBERS DECLARATION ===================

.class public auto ansi beforefieldinit Hello
{
  .method public hidebysig static void  Main(string[] args) cil managed
  {
    .entrypoint
    // Code size       13 (0xd)
    .maxstack  8
    IL_0000:  nop
    IL_0001:  ldstr      "Hello World!"
    IL_0006:  call       void [mscorlib]System.Console::WriteLine(string)
    IL_000b:  nop
    IL_000c:  ret
  } // end of method Hello::Main
} // end of class Hello

Có thể kết hợp protectedvà internalsửa đổi truy cập. Trong C #, nếu bạn viết protected internalmột thành viên có thể truy cập được từ hội đồng và từ các lớp dẫn xuất. Qua MSIL bạn có thể có được một thành viên có thể truy cập từ các lớp học có nguồn gốc trong lắp ráp chỉ . (Tôi nghĩ rằng nó có thể khá hữu ích!)

Ồ, tôi đã không phát hiện ra điều này vào thời điểm đó. (Nếu bạn thêm thẻ jon-skeet thì nhiều khả năng, nhưng tôi không kiểm tra nó thường xuyên.)

Có vẻ như bạn đã có câu trả lời khá tốt rồi. Ngoài ra:

• Bạn không thể xử lý phiên bản được đóng hộp của loại giá trị trong C #. Bạn có thể trong C ++ / CLI
• Bạn không thể thực hiện thử / lỗi trong C # ("lỗi" giống như "bắt tất cả mọi thứ và suy nghĩ lại ở cuối khối" hoặc "cuối cùng nhưng chỉ khi thất bại")
• Có rất nhiều tên bị cấm bởi C # nhưng IL hợp pháp
• IL cho phép bạn xác định các hàm tạo không tham số của riêng bạn cho các loại giá trị .
• Bạn không thể xác định các sự kiện có yếu tố "nâng cao" trong C #. (Trong VB bạn phải cho các sự kiện tùy chỉnh, nhưng các sự kiện "mặc định" không bao gồm một sự kiện.)
• Một số chuyển đổi được CLR cho phép nhưng không phải bởi C #. Nếu bạn đi qua objecttrong C #, đôi khi chúng sẽ hoạt động. Xem một câu hỏi uint [] / int [] SO để biết ví dụ.

Tôi sẽ thêm vào điều này nếu tôi nghĩ về bất cứ điều gì khác ...

CLR đã hỗ trợ chung / chống chỉ định chung, nhưng C # không có tính năng này cho đến 4.0

• Tính năng C # 4.0
• Co / chống chỉ định

Trong IL bạn có thể ném và bắt bất kỳ loại nào, không chỉ các loại có nguồn gốc từ System.Exception.

IL có sự phân biệt giữa callvà callvirtcho các cuộc gọi phương thức ảo. Bằng cách sử dụng trước đây, bạn có thể buộc gọi một phương thức ảo của loại lớp tĩnh hiện tại thay vì hàm ảo trong loại lớp động.

C # không có cách nào để làm điều này:

abstract class Foo {
    public void F() {
        Console.WriteLine(ToString()); // Always a virtual call!
    }

    public override string ToString() { System.Diagnostics.Debug.Assert(false); }
};

sealed class Bar : Foo {
    public override string ToString() { return "I'm called!"; }
}

VB, giống như IL, có thể thực hiện các cuộc gọi không ảo bằng cách sử dụng MyClass.Method()cú pháp. Ở trên, điều này sẽ được MyClass.ToString().

Trong thử / bắt, bạn có thể nhập lại khối thử từ khối bắt của chính nó. Vì vậy, bạn có thể làm điều này:

.try {
    // ...

  MidTry:
    // ...

    leave.s RestOfMethod
}
catch [mscorlib]System.Exception {
    leave.s MidTry  // branching back into try block!
}

RestOfMethod:
    // ...

AFAIK bạn không thể làm điều này trong C # hoặc VB

Với IL và VB.NET, bạn có thể thêm các bộ lọc khi bắt ngoại lệ, nhưng C # v3 không hỗ trợ tính năng này.

Ví dụ VB.NET này được lấy từ http://bloss.msdn.com/clrteam/archive/2009/02/05/catch-rethrow-and-filters-why-you-should-care.aspx (lưu ý When ShouldCatch(ex) = Truetrong Điều khoản bắt):

Try
   Foo()
Catch ex As CustomBaseException When ShouldCatch(ex)
   Console.WriteLine("Caught exception!")
End Try

Theo tôi biết, không có cách nào để tạo bộ khởi tạo mô-đun (hàm tạo tĩnh cho toàn bộ mô-đun) trực tiếp trong C #:

http://bloss.msdn.com/junfeng/archive/2005/11/19/494914.aspx

Native types
Bạn có thể làm việc trực tiếp với các kiểu int int và unsign gốc (trong c #, bạn chỉ có thể làm việc trên một IntPtr không giống nhau.

Transient Pointers
Bạn có thể chơi với các con trỏ thoáng qua, là các con trỏ tới các loại được quản lý nhưng đảm bảo không di chuyển trong bộ nhớ vì chúng không nằm trong heap được quản lý. Không hoàn toàn chắc chắn làm thế nào bạn có thể sử dụng điều này một cách hữu ích mà không gây rối với mã không được quản lý nhưng nó không được tiếp xúc trực tiếp với các ngôn ngữ khác chỉ thông qua những thứ như stackalloc.

<Module>
bạn có thể gây rối với lớp nếu bạn mong muốn (bạn có thể thực hiện điều này bằng cách phản chiếu mà không cần IL)

.emitbyte

15.4.1.1 Phương thức chỉ thị .emitbyteBodyItem :: = trên | .emitbyte Int32 Lệnh này làm cho giá trị 8 bit không dấu được phát trực tiếp vào luồng CIL của phương thức, tại điểm xuất hiện lệnh này. [Lưu ý: Lệnh .emitbyte được sử dụng để tạo các bài kiểm tra. Nó không phải là bắt buộc trong việc tạo ra các chương trình thông thường. lưu ý cuối]

.entrypoint
Bạn có một chút linh hoạt hơn về điều này, bạn có thể áp dụng nó cho các phương thức không được gọi là Main chẳng hạn.

đọc thông số kỹ thuật tôi chắc chắn bạn sẽ tìm thấy một vài chi tiết.

Bạn có thể hack phương thức ghi đè co / contra-variance, điều mà C # không cho phép (điều này KHÔNG giống với phương sai chung!). Tôi đã có thêm thông tin về việc thực hiện điều này ở đây , và phần 1 và 2

Tôi nghĩ rằng điều tôi luôn mong muốn (với những lý do hoàn toàn sai lầm) là sự kế thừa trong Enums. Nó dường như không phải là một điều khó làm trong SMIL (vì Enums chỉ là các lớp) nhưng đó không phải là điều mà cú pháp C # muốn bạn làm.

Dưới đây là một số:

1. Bạn có thể có các phương thức ví dụ bổ sung trong các đại biểu.
2. Các đại biểu có thể thực hiện các giao diện.
3. Bạn có thể có các thành viên tĩnh trong các đại biểu và giao diện.

20) Bạn có thể coi một mảng byte là một mảng int (nhỏ hơn 4 lần).

Tôi đã sử dụng điều này gần đây để thực hiện XOR nhanh, vì hàm CLR xor hoạt động trên ints và tôi cần thực hiện XOR trên luồng byte.

Mã kết quả được đo là nhanh hơn ~ 10 lần so với mã tương đương được thực hiện trong C # (thực hiện XOR trên mỗi byte).

===

Tôi không có đủ uy tín đường phố stackoverflow để chỉnh sửa câu hỏi và thêm câu hỏi này vào danh sách là # 20, nếu người khác có thể bị sưng lên ;-)

Một cái gì đó obfuscators sử dụng - bạn có thể có một trường / phương thức / thuộc tính / sự kiện đều có cùng tên.

Kế thừa Enum là không thực sự có thể:

Bạn có thể kế thừa từ một lớp Enum. Nhưng kết quả không hoạt động như một Enum nói riêng. Nó hành xử thậm chí không giống như một loại giá trị, mà giống như một lớp bình thường. Điều thú vị là: IsEnum: True, IsValueType: True, IsClass: false

Nhưng đó không phải là đặc biệt hữu ích (trừ khi bạn muốn nhầm lẫn một người hoặc chính thời gian chạy.)

Bạn cũng có thể lấy được một lớp từ đại biểu System.Multicast ở IL, nhưng bạn không thể làm điều này trong C #:

// Định nghĩa lớp sau là bất hợp pháp:

lớp công khai YourCustomDelegate: MulticastDelegate {}

Ngược lại, bạn cũng có thể xác định các phương thức cấp mô-đun (còn gọi là toàn cầu) trong IL và C #, chỉ cho phép bạn xác định các phương thức miễn là chúng được gắn vào ít nhất một loại.