คุณสามารถทำอะไรใน MSIL ที่คุณไม่สามารถทำได้ใน C # หรือ VB.NET [ปิด]

รหัสทั้งหมดที่เขียนใน. NET ภาษารวบรวม MSIL แต่มีงานเฉพาะ / การดำเนินงานที่คุณสามารถทำได้เพียงใช้ MSIL โดยตรงหรือไม่

ให้เราทำสิ่งต่าง ๆ ได้ง่ายขึ้นใน MSIL กว่า C #, VB.NET, F #, j # หรือภาษา NET อื่น ๆ

จนถึงตอนนี้เรามีสิ่งนี้:

1. หางเรียกซ้ำ
2. Generic Co / Contravariance
3. เกินพิกัดที่แตกต่างกันเฉพาะในประเภทผลตอบแทน
4. แทนที่ตัวดัดแปลงการเข้าถึง
5. มีคลาสที่ไม่สามารถสืบทอดจาก System.Object
6. ข้อยกเว้นที่กรอง (สามารถทำได้ใน vb.net)
7. การเรียกใช้วิธีเสมือนของชนิดคลาสคงที่ปัจจุบัน
8. รับการจัดการกับชนิดของค่าชนิดบรรจุกล่อง
9. ลอง / ผิด
10. การใช้ชื่อต้องห้าม
11. กำหนดก่อสร้าง parameterless ของคุณเองสำหรับประเภทค่า
12. กำหนดกิจกรรมด้วยraiseองค์ประกอบ
13. การแปลงบางอย่างได้รับอนุญาตจาก CLR แต่ไม่ใช่โดย C #
14. ทำให้ไม่ใช่วิธีการที่เป็นmain().entrypoint
15. ทำงานกับชนพื้นเมืองintและunsigned intประเภทพื้นเมืองโดยตรง
16. เล่นกับตัวชี้ชั่วคราว
17. คำสั่ง emitbyte ใน MethodBodyItem
18. โยนและจับระบบที่ไม่ใช่ประเภทข้อยกเว้น
19. รับช่วง Enums (ไม่ได้ยืนยัน)
20. คุณสามารถจัดการกับอาร์เรย์ของไบต์เป็นอาร์เรย์ (ขนาดเล็ก 4x) ของ ints
21. คุณสามารถมีฟิลด์ / วิธี / คุณสมบัติ / เหตุการณ์ทั้งหมดมีชื่อเดียวกัน (ไม่ได้รับการยืนยัน)
22. คุณสามารถแยกสาขากลับเป็นบล็อกลองได้จากบล็อก catch ของมันเอง
23. คุณสามารถเข้าถึงตัวระบุการเข้าถึง famandassem ( protected internalคือ fam หรือ assem)
24. เข้าถึง<Module>ชั้นเรียนโดยตรงเพื่อกำหนดฟังก์ชั่นทั่วโลกหรือโมดูลเริ่มต้น

MSIL อนุญาตให้โอเวอร์โหลดที่แตกต่างกันในประเภทส่งคืนเท่านั้นเนื่องจาก

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

หรือ

callvirt int32 ...

ภาษา. Net ส่วนใหญ่รวมถึง C # และ VB ไม่ได้ใช้คุณสมบัติเรียกซ้ำหางของรหัส MSIL

การเรียกซ้ำแบบหางเป็นการเพิ่มประสิทธิภาพที่พบได้ทั่วไปในภาษาที่ใช้งานได้ มันเกิดขึ้นเมื่อเมธอด A สิ้นสุดลงโดยส่งคืนค่าของเมธอด B เช่นนั้นสแต็กของเมธอด A สามารถถูกจัดสรรคืนได้เมื่อทำการเรียกเมธอด B

รหัส MSIL รองรับการเรียกซ้ำหางอย่างชัดเจนและสำหรับอัลกอริทึมบางอย่างนี่อาจเป็นการเพิ่มประสิทธิภาพที่สำคัญในการทำ แต่เนื่องจาก C # และ VB ไม่ได้สร้างคำแนะนำในการทำสิ่งนี้จึงต้องทำด้วยตนเอง (หรือใช้ F # หรือภาษาอื่น ๆ )

นี่คือตัวอย่างของวิธีเรียกใช้การเรียกซ้ำแบบหางด้วยตนเองใน 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;
    }
}

เป็นเรื่องปกติที่จะลบการสอบถามซ้ำโดยการย้ายข้อมูลโลคัลจากสแต็กฮาร์ดแวร์ไปยังโครงสร้างข้อมูลสแต็กที่จัดสรรฮีป ในการกำจัดการเรียกซ้ำแบบ tail-call ดังแสดงด้านบนสแต็กจะถูกกำจัดออกอย่างสมบูรณ์ซึ่งเป็นการปรับให้เหมาะสมที่ดี นอกจากนี้ค่าส่งคืนไม่จำเป็นต้องเดินขึ้นสายคอลยาว แต่จะถูกส่งกลับโดยตรง

แต่อย่างไรก็ตาม CIL ให้คุณสมบัตินี้เป็นส่วนหนึ่งของภาษา แต่ด้วย C # หรือ VB จะต้องดำเนินการด้วยตนเอง (กระวนกระวายใจยังมีอิสระที่จะทำให้การเพิ่มประสิทธิภาพนี้ด้วยตัวเอง แต่นั่นเป็นปัญหาอื่น ๆ ทั้งหมด)

ใน MSIL คุณสามารถมีคลาสที่ไม่สามารถสืบทอดจาก System.Object

โค้ดตัวอย่าง: คอมไพล์ด้วย ilasm.exe UPDATE:คุณต้องใช้ "/ NOAUTOINHERIT" เพื่อป้องกันแอสเซมเบลอร์ไม่ให้สืบทอดโดยอัตโนมัติ

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

เป็นไปได้ที่จะรวมprotectedและinternalตัวดัดแปลงการเข้าถึง ใน C # ถ้าคุณเขียนprotected internalสมาชิกสามารถเข้าถึงได้จากแอสเซมบลีและจากคลาสที่ได้รับ Via MSIL คุณจะได้รับเป็นสมาชิกที่สามารถเข้าถึงได้จากชั้นเรียนมาในการชุมนุมเท่านั้น (ฉันคิดว่ามันอาจมีประโยชน์ทีเดียว!)

Ooh ฉันไม่ได้เห็นสิ่งนี้ในเวลา (ถ้าคุณเพิ่มแท็ก jon-skeet มีโอกาสมากขึ้น แต่ฉันไม่ได้ตรวจสอบบ่อยครั้ง)

ดูเหมือนว่าคุณจะได้คำตอบที่ดีอยู่แล้ว นอกจากนี้:

• คุณไม่สามารถรับหมายเลขอ้างอิงในประเภทค่าชนิดบรรจุกล่องใน C # คุณสามารถใน C ++ / CLI
• คุณไม่สามารถลอง / ข้อผิดพลาดใน C # ("ความผิด" เป็นเหมือน "จับทุกอย่างและทำใหม่ในตอนท้ายของบล็อก" หรือ "ในที่สุด แต่ในความล้มเหลวเท่านั้น")
• มีชื่อมากมายที่ถูกห้ามใช้โดย C # แต่เป็นกฎหมาย IL
• IL ช่วยให้คุณสามารถกำหนดก่อสร้าง parameterless ของคุณเองสำหรับประเภทค่า
• คุณไม่สามารถกำหนดกิจกรรมด้วยองค์ประกอบ "เพิ่ม" ใน C # (ใน VB คุณต้องใช้สำหรับเหตุการณ์ที่กำหนดเอง แต่เหตุการณ์ "ค่าเริ่มต้น" จะไม่รวมหนึ่งเหตุการณ์)
• การแปลงบางอย่างได้รับอนุญาตจาก CLR แต่ไม่ใช่ C # หากคุณผ่านobjectใน C # บางครั้งสิ่งเหล่านี้จะใช้ได้ ดูuint [] / int [] คำถาม SOสำหรับตัวอย่าง

ฉันจะเพิ่มสิ่งนี้ถ้าฉันคิดอย่างอื่น ...

CLR รองรับ co / contravariance ทั่วไปอยู่แล้ว แต่ C # ไม่ได้รับคุณลักษณะนี้จนถึง 4.0

• คุณสมบัติ C # 4.0
• Co / contravariance

ใน IL คุณสามารถโยนและจับได้ทุกประเภทไม่เพียง แต่มาจากประเภทSystem.Exceptionใด

IL มีความแตกต่างระหว่างcallและcallvirtสำหรับวิธีการโทรเสมือน ด้วยการใช้แบบเดิมคุณสามารถบังคับให้เรียกวิธีเสมือนของชนิดคลาสคงที่ปัจจุบันแทนฟังก์ชันเสมือนในชนิดคลาสแบบไดนามิก

C # ไม่มีทางทำสิ่งนี้:

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, เช่น IL, สามารถออกการโทรที่ไม่เสมือนโดยใช้MyClass.Method()ไวยากรณ์ MyClass.ToString()ในข้างต้นนี้จะเป็น

ในการลอง / จับคุณสามารถป้อนบล็อกลองจากบล็อกการจับของตัวเองอีกครั้ง ดังนั้นคุณสามารถทำสิ่งนี้:

.try {
    // ...

  MidTry:
    // ...

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

RestOfMethod:
    // ...

AFAIK คุณไม่สามารถทำได้ใน C # หรือ VB

ด้วย IL และ VB.NET คุณสามารถเพิ่มตัวกรองเมื่อตรวจพบข้อยกเว้น แต่ C # v3 ไม่รองรับคุณสมบัตินี้

ตัวอย่าง VB.NET นี้นำมาจากhttp://blogs.msdn.com/clrteam/archive/2009/02/05/catch-rethrow-and-filters-why-you-should-care.aspx (หมายเหตุWhen ShouldCatch(ex) = Trueใน จับข้อ):

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

เท่าที่ฉันรู้ไม่มีวิธีสร้างโมดูล initializers (ตัวสร้างสแตติกสำหรับโมดูลทั้งหมด) โดยตรงใน C #:

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

Native types
คุณสามารถทำงานกับประเภท int ดั้งเดิมและพื้นเมืองที่ไม่ได้ลงนามโดยตรง (ใน c # คุณสามารถทำงานกับ IntPtr เท่านั้นซึ่งไม่เหมือนกัน

Transient Pointers
คุณสามารถเล่นกับพอยน์เตอร์ชั่วคราวซึ่งเป็นพอยน์เตอร์สำหรับประเภทที่มีการจัดการ แต่รับประกันว่าจะไม่ย้ายในหน่วยความจำเนื่องจากไม่ได้อยู่ในฮีปที่ได้รับการจัดการ ไม่แน่ใจทั้งหมดว่าคุณจะใช้ประโยชน์ได้อย่างไรโดยไม่ยุ่งกับโค้ดที่ไม่มีการจัดการ แต่มันไม่ได้สัมผัสกับภาษาอื่นโดยตรงผ่านสิ่งต่างๆเช่น stackalloc

<Module>
คุณสามารถยุ่งเกี่ยวกับชั้นเรียนถ้าคุณต้องการ (คุณสามารถทำสิ่งนี้ได้โดยไม่ต้องใช้ IL)

.emitbyte

15.4.1.1 .emitbyte directive MethodBodyItem :: = … | .emitbyte Int32 คำสั่งนี้ทำให้ค่า 8 บิตที่ไม่ได้ลงนามถูกปล่อยโดยตรงไปยังสตรีม CIL ของวิธี ณ จุดที่คำสั่งปรากฏขึ้น [หมายเหตุ:. emitbyte directive ใช้สำหรับการสร้างการทดสอบ ไม่จำเป็นในการสร้างโปรแกรมปกติ จบบันทึก]

.entrypoint
คุณมีความยืดหยุ่นมากกว่านี้เล็กน้อยคุณสามารถนำไปใช้กับวิธีที่ไม่ได้เรียกว่า Main เป็นต้น

ได้อ่านสเป็คฉันแน่ใจว่าคุณจะพบอีกไม่กี่

คุณสามารถแฮ็ควิธีการแทนที่ co / contra-variance ซึ่ง C # ไม่อนุญาต (นี่ไม่เหมือนกับความแปรปรวนทั่วไป!) ฉันได้รับข้อมูลเพิ่มเติมเกี่ยวกับการนำไปใช้ที่นี่และส่วนที่1และ2

ฉันคิดว่าสิ่งที่ฉันต้องการ (ด้วยเหตุผลที่ผิดทั้งหมด) คือการสืบทอดใน Enums ดูเหมือนไม่ยากที่จะทำใน SMIL (เนื่องจาก Enums เป็นเพียงคลาส) แต่ไม่ใช่สิ่งที่ไวยากรณ์ C # ต้องการให้คุณทำ

นี่คือบางส่วนเพิ่มเติม:

1. คุณสามารถมีวิธีการอินสแตนซ์พิเศษในผู้รับมอบสิทธิ์
2. ผู้รับมอบสิทธิ์สามารถใช้อินเทอร์เฟซ
3. คุณสามารถมีสมาชิกแบบสแตติกในผู้รับมอบสิทธิ์และอินเทอร์เฟซ

20) คุณสามารถปฏิบัติต่ออาร์เรย์ของไบต์เป็นอาร์เรย์ (เล็กกว่า 4x) ของ ints

ฉันใช้สิ่งนี้เมื่อเร็ว ๆ นี้เพื่อทำการติดตั้ง XOR ที่รวดเร็วเนื่องจากฟังก์ชัน CLR xor ทำงานกับ ints และฉันต้องการทำ XOR ในไบต์ของสตรีม

โค้ดผลลัพธ์ที่วัดได้จะเป็น 10 เท่าเร็วกว่าสิ่งที่เทียบเท่าใน C # (ทำ XOR ในแต่ละไบต์)

===

ฉันไม่มีถนนซ้อนทับ credz เพียงพอที่จะแก้ไขคำถามและเพิ่มสิ่งนี้ลงในรายการเป็น # 20 ถ้ามีคนอื่นที่อาจจะบวม ;-)

มีผู้ใช้ obfuscators บางคนคุณสามารถมีฟิลด์ / วิธี / คุณสมบัติ / เหตุการณ์ทั้งหมดมีชื่อเหมือนกัน

Enum ไม่สามารถสืบทอดได้จริง:

คุณสามารถสืบทอดจากคลาส Enum แต่ผลลัพธ์จะไม่ทำงานเหมือน Enum โดยเฉพาะ มันจะทำงานไม่เหมือนประเภทค่า แต่เหมือนคลาสปกติ สิ่งที่เรียงลำดับคือ: IsEnum: True, IsValueType: True, IsClass: False

แต่นั่นไม่ใช่ประโยชน์โดยเฉพาะ (เว้นแต่คุณต้องการสร้างความสับสนให้กับบุคคลหรือรันไทม์เอง)

นอกจากนี้คุณยังสามารถรับคลาสจากผู้แทน System.Multicast ใน IL แต่คุณไม่สามารถทำได้ใน C #:

// คำจำกัดความของคลาสต่อไปนี้ผิดกฎหมาย:

คลาสสาธารณะ YourCustomDelegate: MulticastDelegate {}

นอกจากนี้คุณยังสามารถกำหนดวิธีการระดับโมดูล (aka ทั่วโลก) ใน IL และ C # ในทางตรงกันข้ามช่วยให้คุณสามารถกำหนดวิธีการตราบเท่าที่พวกเขาจะแนบมากับอย่างน้อยหนึ่งประเภท