ซอฟต์แวร์ที่มีประสิทธิภาพคืออะไร

ซอฟต์แวร์ที่มีประสิทธิภาพคืออะไร? ซอฟต์แวร์ที่มีประสิทธิภาพไม่เพียงแต่จะทำงานได้เร็วกว่าซอฟต์แวร์ที่ทำหน้าที่เดียวกันเท่านั้น แต่ยังควรใช้ทรัพยากรระบบน้อยลงด้วย บทความนี้รวบรวมประสบการณ์บางส่วนที่ผู้เขียนสั่งสมมาเมื่อใช้ VB เพื่อการพัฒนาซอฟต์แวร์ และใช้ตัวอย่างง่ายๆ เพื่อแสดงวิธีเขียนโค้ด VB ที่มีประสิทธิภาพ ประกอบด้วยเทคนิคบางอย่างที่อาจเป็นประโยชน์กับโปรแกรมเมอร์ VB ก่อนที่ฉันจะเริ่ม ให้ฉันอธิบายแนวคิดบางประการก่อน

ปล่อยให้โค้ดเป็นรูปเป็นร่างทันที: ในบรรดาโปรแกรมเมอร์ที่ฉันติดต่อด้วย หลายคนชอบเขียนโค้ดก่อนตามความต้องการด้านการทำงาน จากนั้นจึงปรับโค้ดให้เหมาะสมบนพื้นฐานนี้ ในท้ายที่สุด พวกเขาพบว่าเพื่อให้บรรลุการปรับให้เหมาะสม พวกเขาต้องเขียนโค้ดใหม่ ดังนั้นฉันขอแนะนำให้คุณพิจารณาปัญหาการปรับให้เหมาะสมก่อนที่จะเขียนโค้ด

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

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

เมื่อคุณเขียนโค้ด VB ฉันหวังว่าคุณจะสามารถใช้ประเด็นข้างต้นเป็นแนวทางในการเขียนโค้ดของคุณได้ ฉันแบ่งบทความออกเป็นสองส่วน: วิธีปรับปรุงความเร็วการทำงานของโค้ดและการเพิ่มประสิทธิภาพการคอมไพล์

วิธีทำให้โค้ดของคุณทำงานเร็วขึ้น

วิธีการต่อไปนี้สามารถช่วยคุณปรับปรุงความเร็วของโค้ดของคุณได้:

1. ใช้จำนวนเต็ม (Integer) และจำนวนเต็มยาว (Long)

วิธีที่ง่ายที่สุดในการทำให้โค้ดของคุณทำงานเร็วขึ้นคือการใช้ประเภทข้อมูลที่ถูกต้อง คุณอาจไม่เชื่อ แต่การเลือกประเภทข้อมูลที่ถูกต้องสามารถปรับปรุงประสิทธิภาพของโค้ดของคุณได้อย่างมาก ในกรณีส่วนใหญ่ โปรแกรมเมอร์สามารถแทนที่ตัวแปรประเภท Single, Double และสกุลเงินด้วยตัวแปรประเภท Integer หรือ Long เนื่องจากความสามารถของ VB ในการจัดการ Integer และ Long นั้นสูงกว่าประเภทข้อมูลอื่นมาก

ในกรณีส่วนใหญ่ เหตุผลที่โปรแกรมเมอร์เลือกใช้ Single หรือ Double ก็เนื่องมาจากความสามารถในการบันทึกทศนิยม แต่ทศนิยมสามารถเก็บไว้ในตัวแปรประเภท Integer ได้ ตัวอย่างเช่น หากมีทศนิยมสามตำแหน่งที่ตกลงกันในโปรแกรม คุณเพียงแค่ต้องหารค่าที่เก็บไว้ในตัวแปร Integer ด้วย 1,000 เพื่อให้ได้ผลลัพธ์ จากประสบการณ์ของผม โค้ดสามารถทำงานได้เร็วขึ้นเกือบ 10 เท่าโดยใช้ Integer และ Long แทน Single, Double และ Currency

2. หลีกเลี่ยงการใช้ตัวแปร

สำหรับโปรแกรมเมอร์ VB สิ่งนี้ชัดเจน ตัวแปรประเภทตัวแปรต้องใช้พื้นที่ 16 ไบต์ในการจัดเก็บข้อมูล ในขณะที่จำนวนเต็ม (จำนวนเต็ม) ต้องการเพียง 2 ไบต์เท่านั้น โดยปกติแล้วจุดประสงค์ของการใช้ประเภทตัวแปรคือเพื่อลดภาระงานการออกแบบและจำนวนโค้ดโปรแกรมเมอร์บางคนก็ใช้มันเพื่อประหยัดปัญหาเช่นกัน แต่หากซอฟต์แวร์ได้รับการออกแบบและเขียนโค้ดตามข้อกำหนดอย่างเคร่งครัด ก็สามารถหลีกเลี่ยงการใช้ประเภทที่แตกต่างกันได้โดยสิ้นเชิง

อย่างไรก็ตาม ปัญหาเดียวกันนี้ก็เกิดขึ้นกับวัตถุ Object เช่นกัน โปรดดูรหัสด้านล่าง:

มฟส

SetFSO=NewScripting.FileSystemObject

หรือ

DimFSOasobject

SetFSO=NewScripting.FileSystemObject

เนื่องจากโค้ดด้านบนไม่ได้ระบุประเภทข้อมูลเมื่อประกาศ หน่วยความจำและเวลา CPU จะสูญเปล่าระหว่างการกำหนด รหัสที่ถูกต้องควรมีลักษณะดังนี้:

DimFSOasNewFileSystemObject

3. พยายามหลีกเลี่ยงการใช้คุณลักษณะ

ในโค้ดรายวัน โค้ดที่ไม่มีประสิทธิภาพที่พบบ่อยที่สุดคือการใช้คุณสมบัติ (Property) ซ้ำๆ เมื่อสามารถใช้ตัวแปรได้ โดยเฉพาะในลูป คุณต้องรู้ว่าความเร็วในการเข้าถึงตัวแปรนั้นประมาณ 20 เท่าของการเข้าถึงแอตทริบิวต์ โปรแกรมเมอร์จำนวนมากใช้รหัสต่อไปนี้ในโปรแกรมของตน:

DimintConasInteger

ForintCon=0toUbound(SomVar())

Text1.Text=Text1.Text&vbcrlf&SomeVar(intCon)

เน็กซ์อินคอน

โค้ดด้านล่างดำเนินการเร็วกว่าโค้ดด้านบนถึง 20 เท่า

DimintConasInteger

DimsOutputasString

ForintCon=0toUbound(SomeVar())

sOutput=sOutput&vbCrlf&

SomeVar(intCon)

ต่อไป

Text1.Text=sเอาท์พุต

4. พยายามใช้อาร์เรย์และหลีกเลี่ยงการใช้ชุด

เว้นแต่คุณจะต้องใช้คอลเลกชัน คุณควรใช้อาร์เรย์เสมอ ตามการทดสอบ ความเร็วในการเข้าถึงของอาร์เรย์สามารถเข้าถึง 100 เท่าของคอลเลกชัน ตัวเลขนี้ฟังดูน่าตกใจเล็กน้อย แต่ถ้าคุณพิจารณาว่าคอลเลกชั่นคือวัตถุ คุณจะเข้าใจว่าทำไมความแตกต่างจึงใหญ่มาก

5. ขยายตัวห่วงเล็ก

เมื่อเขียนโค้ด คุณอาจพบสถานการณ์เช่นนี้: ตัวลูปจะวนซ้ำ 2 หรือ 3 ครั้งเท่านั้น และตัวลูปประกอบด้วยโค้ดหลายบรรทัด ในกรณีนี้ คุณสามารถคลายการวนซ้ำได้ เหตุผลก็คือการวนซ้ำใช้เวลา CPU มากขึ้น แต่หากการวนซ้ำซับซ้อนกว่านี้ คุณไม่จำเป็นต้องทำเช่นนี้

6. หลีกเลี่ยงการใช้ฟังก์ชันที่สั้นมาก

เช่นเดียวกับการใช้ลูปเล็กๆ การเรียกใช้ฟังก์ชันที่มีโค้ดเพียงไม่กี่บรรทัดจะไม่ประหยัด การเรียกใช้ฟังก์ชันอาจใช้เวลานานกว่าการเรียกใช้โค้ดในฟังก์ชัน ในกรณีนี้ คุณสามารถคัดลอกโค้ดในฟังก์ชันไปยังตำแหน่งที่ฟังก์ชันเดิมถูกเรียกใช้ได้

7. ลดการอ้างอิงถึงวัตถุย่อย

ใน VB การอ้างอิงวัตถุจะถูกนำไปใช้โดยใช้ . ตัวอย่างเช่น:

Form1.Text1.ข้อความ

ในตัวอย่างข้างต้น โปรแกรมอ้างอิงวัตถุสองตัว: Form1 และ Text1 การอ้างอิงโดยใช้วิธีนี้ไม่มีประสิทธิภาพ แต่น่าเสียดายที่ไม่มีทางหลีกเลี่ยงได้ สิ่งเดียวที่โปรแกรมเมอร์สามารถทำได้คือใช้ With หรือบันทึกวัตถุลูก (Text1) กับวัตถุอื่น

หมายเหตุ: ใช้กับ

WithfrmMain.Text1

.Text="LearnVB"

.การจัดตำแหน่ง=0

.Tag="อิทมายไลฟ์"

.BackColor=vbBlack

.ForeColor=vbสีขาว

จบด้วย

หรือ

หมายเหตุ: ใช้วัตถุอื่นเพื่อบันทึกวัตถุลูก

DimtxtTextBoxasTextBox

SettxtTextBox=frmMain.Text1

TxtTextBox.Text="LearnVB"

TxtTextBox.Alignment=0

TxtTextBox.Tag="Itsmylife"

TxtTextBox.BackColor=vbBlack

TxtTextBox.ForeColor=vbWhite

โปรดทราบว่าวิธีการที่กล่าวถึงข้างต้นใช้ได้เฉพาะเมื่อคุณต้องการดำเนินการกับวัตถุย่อยของวัตถุรหัสต่อไปนี้ไม่ถูกต้อง:

ด้วยข้อความ1

.Text="LearnVB"

.การจัดตำแหน่ง=0

.Tag="อิทมายไลฟ์"

.BackColor=vbBlack

.ForeColor=vbสีขาว

จบด้วย

น่าเสียดายที่เรามักจะพบโค้ดที่คล้ายกับโค้ดข้างต้นในโค้ดจริง การทำเช่นนี้จะทำให้โค้ดทำงานช้าลงเท่านั้น เหตุผลก็คือบล็อก With จะสร้างสาขาหลังจากการคอมไพล์ ซึ่งจะเพิ่มงานการประมวลผลเพิ่มเติม

8. ตรวจสอบว่าสตริงว่างเปล่าหรือไม่

โปรแกรมเมอร์ส่วนใหญ่ใช้วิธีการต่อไปนี้เมื่อตรวจสอบว่าสตริงว่างเปล่าหรือไม่:

IfText1.Text=""แล้ว

หมายเหตุ: ดำเนินการ

เอนดิฟ

น่าเสียดายที่การเปรียบเทียบสตริงต้องใช้การประมวลผลมากกว่าการอ่านคุณสมบัติ ดังนั้นฉันขอแนะนำให้คุณใช้วิธีการต่อไปนี้:

IfLen(Text1.Text)=0แล้ว

หมายเหตุ: ดำเนินการ

เอนดิฟ

9. ชื่อตัวแปรหลังจากลบคีย์เวิร์ด Next

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

ความคิดเห็น: รหัสผิด

ForiCount=1ถึง10

หมายเหตุ: ดำเนินการ

เน็กซ์ไอเคาท์

หมายเหตุ: รหัสที่ถูกต้อง

ForiCount=1ถึง10

หมายเหตุ: ดำเนินการ

ต่อไป

10. ใช้อาร์เรย์แทนหลายตัวแปร

เมื่อคุณมีตัวแปรหลายตัวที่เก็บข้อมูลคล้ายกัน ให้ลองแทนที่ตัวแปรเหล่านั้นด้วยอาร์เรย์ ใน VB อาร์เรย์เป็นหนึ่งในโครงสร้างข้อมูลที่มีประสิทธิภาพมากที่สุด

11. ใช้อาร์เรย์แบบไดนามิกแทนอาร์เรย์แบบคงที่

การใช้อาร์เรย์แบบไดนามิกจะไม่ส่งผลกระทบอย่างมากต่อความเร็วในการดำเนินการของโค้ด แต่ในบางกรณีอาจช่วยประหยัดทรัพยากรได้มาก

12. ทำลายวัตถุ

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

DimFSOasNewFileSystemObject

หมายเหตุ: ดำเนินการ

หมายเหตุ: ทำลายวัตถุ

SetFSO=ไม่มีอะไร

สำหรับแบบฟอร์ม คุณสามารถถอนการติดตั้ง:

ยกเลิกการโหลดจากMain

หรือ

SetfrmMain=ไม่มีอะไร

13. สตริงที่มีความยาวผันแปรได้และมีความยาวคงที่

ในทางเทคนิคแล้ว สตริงที่มีความยาวคงที่ต้องใช้เวลาและพื้นที่ในการประมวลผลน้อยกว่าสตริงที่มีความยาวผันแปรได้ อย่างไรก็ตาม ข้อเสียของสตริงที่มีความยาวคงที่คือ ในหลายกรณี คุณต้องเรียกใช้ฟังก์ชัน Trim เพื่อลบอักขระ null ที่ส่วนท้ายของสตริง ซึ่งจะลดประสิทธิภาพของโค้ด ดังนั้นเว้นแต่ความยาวของสตริงจะไม่เปลี่ยนแปลง ให้ใช้สตริงที่มีความยาวผันแปรได้

14. ใช้โมดูลคลาสแทนการควบคุม ActiveX

ยกเว้นว่าตัวควบคุม ActiveX เกี่ยวข้องกับอินเทอร์เฟซผู้ใช้ ให้ลองใช้วัตถุน้ำหนักเบาเช่นคลาส มีประสิทธิภาพแตกต่างกันมากระหว่างทั้งสอง

15. ใช้วัตถุภายใน

เมื่อพูดถึงการใช้ตัวควบคุม ActiveX และ DLL โปรแกรมเมอร์จำนวนมากต้องการคอมไพล์และเพิ่มลงในโปรเจ็กต์ ฉันขอแนะนำไม่ให้คุณทำเช่นนี้เนื่องจากการเชื่อมต่อกับวัตถุภายนอกจาก VB ต้องใช้พลังการประมวลผลของ CPU จำนวนมาก ทุกครั้งที่คุณเรียกใช้เมธอดหรือเข้าถึงคุณสมบัติ คุณจะสูญเสียทรัพยากรระบบจำนวนมาก หากคุณมีซอร์สโค้ดสำหรับตัวควบคุม ActiveX หรือ DLL ให้ทำให้เป็นวัตถุส่วนตัวในโครงการ

16. ลดจำนวนโมดูล

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

17. ใช้อาร์เรย์วัตถุ

เมื่อออกแบบอินเทอร์เฟซผู้ใช้ โปรแกรมเมอร์ควรพยายามใช้อาร์เรย์วัตถุสำหรับการควบคุมประเภทเดียวกัน คุณสามารถทำการทดลองได้ โดยเพิ่ม PictureBox 100 กล่องลงในหน้าต่าง โดยแต่ละกล่องมีชื่อต่างกัน แล้วรันโปรแกรม จากนั้นสร้างโปรเจ็กต์ใหม่ เพิ่ม 100 PictureBoxes ลงในหน้าต่าง แต่คราวนี้ใช้อาร์เรย์อ็อบเจ็กต์ รันโปรแกรม คุณจะสังเกตเห็นความแตกต่างในเวลาโหลดของทั้งสองโปรแกรม

18. ใช้วิธีย้าย

เมื่อเปลี่ยนตำแหน่งของวัตถุ โปรแกรมเมอร์บางคนต้องการใช้คุณสมบัติความกว้าง ความสูง บน และซ้าย ตัวอย่างเช่น:

รูปภาพ1.ความกว้าง=100

ภาพที่ 1 ความสูง = 100

ภาพที่ 1.ด้านบน=0

รูปภาพ1.ซ้าย=0

อันที่จริง สิ่งนี้ไม่มีประสิทธิภาพมากนัก เนื่องจากโปรแกรมแก้ไขคุณสมบัติสี่ประการ และหลังจากการปรับเปลี่ยนแต่ละครั้ง หน้าต่างจะถูกวาดใหม่ วิธีที่ถูกต้องคือใช้วิธี Move:

ภาพที่ 1. เคลื่อนที่ 0,0,100,100

19. ลดการใช้รูปภาพ

รูปภาพจะใช้หน่วยความจำจำนวนมาก และการประมวลผลรูปภาพก็จะใช้ทรัพยากร CPU จำนวนมากเช่นกัน ในซอฟต์แวร์ หากเป็นไปได้ ให้พิจารณาใช้สีพื้นหลังแทนรูปภาพ แน่นอนว่านี่เป็นเพียงมุมมองของบุคลากรด้านเทคนิคเกี่ยวกับปัญหานี้

20. ใช้ ActiveXDLL แทนตัวควบคุม ActiveX

ถ้าวัตถุ ActiveX ที่คุณกำลังออกแบบไม่เกี่ยวข้องกับอินเทอร์เฟซผู้ใช้ ให้ใช้ ActiveXDLL

การเพิ่มประสิทธิภาพการรวบรวม

โปรแกรมเมอร์ VB หลายคนที่ฉันเคยพบไม่เคยใช้ตัวเลือกการคอมไพล์หรือพยายามค้นหาความแตกต่างระหว่างตัวเลือกต่างๆ เรามาดูความหมายเฉพาะของแต่ละตัวเลือกกันดีกว่า

1.P-code (pseudocode) และโค้ดเนทีฟ

คุณสามารถเลือกคอมไพล์ซอฟต์แวร์เป็นรหัส P หรือรหัสเนทีฟได้ ตัวเลือกเริ่มต้นคือโค้ดเนทิฟ แล้ว P-code และ Native Code คืออะไร?

P-code: เมื่อรันโค้ดใน VB VB จะคอมไพล์โค้ดเป็น P-code ก่อน จากนั้นจึงตีความและรัน P-code ที่คอมไพล์แล้ว ในสภาพแวดล้อมที่คอมไพล์ การใช้โค้ดนี้จะเร็วกว่าโค้ดเนทีฟ หลังจากเลือก P-Code แล้ว VB จะใส่รหัสเทียมลงในไฟล์ EXE เมื่อทำการคอมไพล์

รหัสเนทีฟ: รหัสเนทิฟเป็นตัวเลือกที่แนะนำหลังจาก VB6 เท่านั้น เมื่อคอมไพล์เป็นไฟล์ EXE โค้ดเนทีฟจะดำเนินการเร็วกว่า P-code หลังจากเลือกโค้ดเนทิฟแล้ว VB จะใช้คำแนะนำของเครื่องเพื่อสร้างไฟล์ EXE เมื่อทำการคอมไพล์

เมื่อคอมไพล์ด้วยโค้ดเนทีฟ ฉันพบว่าบางครั้งมีข้อผิดพลาดที่อธิบายไม่ได้เกิดขึ้น รหัสของฉันดำเนินการอย่างถูกต้องสมบูรณ์ในสภาพแวดล้อมการคอมไพล์ แต่ไฟล์ EXE ที่สร้างด้วยตัวเลือกเนทีฟโค้ดไม่ทำงานอย่างถูกต้อง โดยปกติสิ่งนี้จะเกิดขึ้นเมื่อมีการยกเลิกการโหลดหน้าต่างหรือมีหน้าต่างการพิมพ์ปรากฏขึ้น ฉันแก้ไขปัญหานี้ด้วยการเพิ่มคำสั่ง DoEvent ลงในโค้ด แน่นอนว่าโอกาสที่สิ่งนี้จะเกิดขึ้นนั้นเกิดขึ้นได้ยากมาก บางทีโปรแกรมเมอร์ VB บางคนอาจไม่เคยเจอมัน แต่มันก็มีอยู่จริง

มีหลายตัวเลือกในโค้ดเนทิฟ:

ก) การเพิ่มประสิทธิภาพความเร็วโค้ด: ตัวเลือกนี้สามารถคอมไพล์ไฟล์ปฏิบัติการที่เร็วขึ้น แต่ไฟล์ปฏิบัติการจะมีขนาดใหญ่กว่า ที่แนะนำ

b) การเพิ่มประสิทธิภาพขนาดโค้ด: ตัวเลือกนี้สามารถรวบรวมไฟล์ปฏิบัติการที่มีขนาดเล็กลงได้ แต่ไม่แนะนำให้ใช้เนื่องจากความเร็ว

c) ไม่มีการเพิ่มประสิทธิภาพ: ตัวเลือกนี้จะแปลงเฉพาะ P-code เป็นโค้ดเนทีฟโดยไม่มีการปรับให้เหมาะสมใดๆ สามารถใช้เมื่อแก้ไขโค้ด

d) ปรับให้เหมาะสมสำหรับ Pentium Pro: แม้ว่าตัวเลือกนี้จะไม่ใช่ตัวเลือกเริ่มต้นในโค้ดเนทีฟ แต่ฉันมักจะใช้ตัวเลือกนี้ โปรแกรมปฏิบัติการที่คอมไพล์ด้วยตัวเลือกนี้สามารถทำงานได้เร็วขึ้นบนเครื่อง PentiumPro และ Pentium2 หรือสูงกว่า แต่จะช้ากว่าเล็กน้อยในเครื่องรุ่นเก่า เมื่อพิจารณาว่าการใช้ Pentium2 นั้นล้าสมัยแล้ว ขอแนะนำให้ทุกคนใช้ตัวเลือกนี้

จ) สร้างข้อมูลการดีบักเชิงสัญลักษณ์: รายการนี้สร้างข้อมูลการดีบักบางอย่างในระหว่างกระบวนการคอมไพล์ ซึ่งช่วยให้ผู้ใช้สามารถใช้เครื่องมือ เช่น Visual C++ เพื่อดีบักโค้ดที่คอมไพล์แล้ว การใช้ตัวเลือกนี้จะสร้างไฟล์ .pdf ที่บันทึกข้อมูลแฟล็กในไฟล์ปฏิบัติการ ตัวเลือกนี้จะมีประโยชน์เมื่อโปรแกรมมีฟังก์ชัน API หรือการเรียก DLL

2. การเพิ่มประสิทธิภาพขั้นสูง

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

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

b) ยกเลิกการตรวจสอบการเชื่อมโยงอาร์เรย์ ยกเลิกการตรวจสอบจำนวนเต็มล้น และยกเลิกการตรวจสอบข้อผิดพลาดจุดลอยตัว: เมื่อโปรแกรมกำลังทำงาน หากพบข้อผิดพลาดจากการตรวจสอบเหล่านี้ โค้ดการจัดการข้อผิดพลาดจะจัดการกับข้อผิดพลาดเหล่านี้ แต่หากการตรวจสอบเหล่านี้ถูกยกเลิก โปรแกรมจะไม่สามารถจัดการกับข้อผิดพลาดได้ คุณควรใช้ตัวเลือกเหล่านี้เฉพาะในกรณีที่คุณแน่ใจว่าข้อผิดพลาดข้างต้นจะไม่เกิดขึ้นในโค้ดของคุณ พวกเขาจะปรับปรุงประสิทธิภาพของซอฟต์แวร์อย่างมาก

c) อนุญาตการดำเนินการจุดลอยตัวโดยไม่ต้องปัดเศษ: การเลือกตัวเลือกนี้จะทำให้โปรแกรมที่คอมไพล์สามารถประมวลผลการดำเนินการจุดลอยตัวได้เร็วขึ้น ข้อเสียเพียงอย่างเดียวคืออาจนำไปสู่ผลลัพธ์ที่ไม่ถูกต้องเมื่อเปรียบเทียบตัวเลขทศนิยมสองตัว

d) ยกเลิกการตรวจสอบความปลอดภัยของ PentiumFDIV: ตัวเลือกนี้ถูกตั้งค่าไว้สำหรับชิป Pentium เก่าบางรุ่น และตอนนี้ดูเหมือนว่าจะล้าสมัยแล้ว