หลังจากอ่านบทความต่อไปนี้ ฉันพบว่าแบบทดสอบของผู้เขียนมีประโยชน์มากกับเพื่อนที่ใช้ ASP จริงๆ ซึ่งควรจะคล้ายกันไม่เฉพาะกับ ASP แต่สำหรับภาษาอื่นๆ ด้วย การสร้างเนื้อหาแบบไดนามิกบนเซิร์ฟเวอร์เป็นหนึ่งในเหตุผลหลักในการใช้ ASP ดังนั้นโครงการทดสอบแรกที่เราเลือกคือการกำหนดวิธีที่ดีที่สุดในการส่งเนื้อหาแบบไดนามิกไปยังสตรีมการตอบกลับ มีสองตัวเลือกพื้นฐาน (และบางรูปแบบ): การใช้แท็ก ASP แบบอินไลน์ และการใช้คำสั่ง Response.Write
เพื่อทดสอบแนวทางต่างๆ เหล่านี้ เราได้สร้างเพจ ASP แบบง่ายที่กำหนดตัวแปรบางตัวแล้วแทรกลงในตาราง แม้ว่าหน้านี้จะเรียบง่ายและไม่มีการใช้งานจริง แต่ก็เพียงพอที่จะช่วยให้เราแยกและทดสอบปัญหาแต่ละข้อได้
2.1 การใช้แท็กอินไลน์ ASP
การทดสอบแรกคือการใช้แท็กอินไลน์ของ ASP <%= x %> โดยที่ x คือตัวแปร นี่เป็นวิธีที่สะดวกที่สุดในการใช้ และทำให้ส่วน HTML ของหน้าอ่านและบำรุงรักษาได้ง่ายขึ้น
คัดลอกรหัสรหัสดังต่อไปนี้:
<% ตัวเลือกที่ชัดเจน
ชื่อจริงดิม
DimLastName
Dim Middleเริ่มต้น
ที่อยู่สลัว
เมืองดิม
รัฐสลัว
ดิมโฟนนัมเบอร์
Dim FaxNumber
อีเมลสลัว
DimBirthDate
ชื่อ = จอห์น
MiddleInitial = ถาม
นามสกุล = สาธารณะ
ที่อยู่ = 100 ถนนสายหลัก
เมือง=นิวยอร์ก
รัฐ=นิวยอร์ก
หมายเลขโทรศัพท์ = 1-212-555-1234
หมายเลขแฟกซ์ = 1-212-555-1234
อีเมล์ = [email protected]
วันเกิด = 1/1/1950
-
<HTML>
<หัว>
<TITLE>การทดสอบการตอบสนอง</TITLE>
</HEAD>
<ร่างกาย>
<H1>การทดสอบการตอบสนอง</H1>
<ตาราง>
<tr><td><b>ชื่อ:</b></td><td><%= ชื่อ %></td></tr>
<tr><td><b>ชื่อย่อกลาง:</b></td><td><%= ชื่อย่อกลาง %></td></tr>
<tr><td><b>นามสกุล:</b></td><td><%= นามสกุล %></td></tr>
<tr><td><b>ที่อยู่:</b></td><td><%= ที่อยู่ %></td></tr>
<tr><td><b>เมือง:</b></td><td><%= เมือง %></td></tr>
<tr><td><b>สถานะ:</b></td><td><%= รัฐ %></td></tr>
<tr><td><b>หมายเลขโทรศัพท์:</b></td><td><%= หมายเลขโทรศัพท์ %></td></tr>
<tr><td><b>หมายเลขแฟกซ์:</b></td><td><%= หมายเลขแฟกซ์ %></td></tr>
<tr><td><b>อีเมล:</b></td><td><%= อีเมล %></td></tr>
<tr><td><b>วันเกิด:</b></td><td><%= วันเกิด %></td></tr>
</ตาราง>
</ร่างกาย>
</HTML>
รหัสที่สมบูรณ์ของ /app1/response1.asp
สถิติที่ดีที่สุด = 8.28 ms/หน้า
2.2 ใช้ Response.Write เพื่อส่งออกโค้ด HTML แต่ละบรรทัด
มีวรรณกรรมดีๆ มากมายที่ระบุว่าควรหลีกเลี่ยงวิธีการมาร์กอัปแบบอินไลน์ก่อนหน้านี้ เนื่องจากจะส่งผลให้เกิดการดำเนินการที่เรียกว่าสวิตช์บริบท การดำเนินการนี้เกิดขึ้นเมื่อประเภทของโค้ดที่เว็บเซิร์ฟเวอร์ประมวลผลเปลี่ยนแปลง (จากการส่ง HTML ล้วนๆ ไปเป็นการประมวลผลสคริปต์ หรือในทางกลับกัน) และสวิตช์นี้ใช้เวลาช่วงระยะเวลาหนึ่ง หลังจากที่โปรแกรมเมอร์หลายคนเรียนรู้สิ่งนี้ ปฏิกิริยาแรกของพวกเขาคือการใช้ฟังก์ชัน Response.Write เพื่อส่งออกโค้ด HTML แต่ละบรรทัด:
คัดลอกรหัสรหัสดังต่อไปนี้:
-
การตอบกลับเขียน(<html>)
Response.เขียน(<head>)
Response.Write( <title>การทดสอบการตอบสนอง</title>)
ตอบกลับเขียน(</head>)
Response.เขียน(<body>)
Response.Write(<h1>การทดสอบการตอบสนอง</h1>)
Response.Write(<ตาราง>)
Response.Write(<tr><td><b>ชื่อ:</b></td><td> & ชื่อ & </td></tr>)
Response.Write(<tr><td><b>ชื่อกลาง:</b></td><td> & MiddleInitial & </td></tr>)
-
/app1/response2.asp ส่วน
สถิติที่ดีที่สุด = 8.28 ms/หน้า
เวลาตอบสนอง = 8.08 ms/หน้า
ความแตกต่าง = -0.20 ms (ลดลง 2.4%)
การปรับปรุงประสิทธิภาพที่เราเห็นเมื่อเทียบกับเวอร์ชันมาร์กอัปแบบอินไลน์นั้นน้อยมากจนน่าประหลาดใจ อาจเป็นเพราะมีการเรียกใช้ฟังก์ชันเพิ่มเติมมากมายในเพจ อย่างไรก็ตาม วิธีนี้มีข้อเสียมากกว่า เนื่องจากโค้ด HTML ถูกฝังอยู่ในฟังก์ชัน โค้ดสคริปต์จึงมีความยาวมากและไม่สะดวกในการอ่านและบำรุงรักษา
2.3 ใช้ฟังก์ชัน wrapper
Response.Write ไม่ได้เพิ่ม CRLF (Carriage Return - Line Feed, Carriage Return - Line Feed) ที่ท้ายบรรทัดข้อความ ซึ่งเป็นลักษณะที่น่าผิดหวังที่สุดของการใช้วิธีการข้างต้น แม้ว่าโค้ด HTML จะได้รับการจัดรูปแบบอย่างดีบนฝั่งเซิร์ฟเวอร์ แต่สิ่งที่คุณเห็นในเบราว์เซอร์ยังคงเป็นโค้ดยาวเพียงบรรทัดเดียว แต่ปัญหานี้ไม่ใช่สิ่งเดียวที่ทำให้ผิดหวัง ในไม่ช้า ผู้คนก็ค้นพบว่าไม่มีฟังก์ชัน Response.WriteLn ที่สามารถเพิ่ม CRLF ได้โดยอัตโนมัติ ปฏิกิริยาตามธรรมชาติคือการสร้างฟังก์ชัน wrapper สำหรับ Response.Write และเพิ่ม CRLF หลังจากแต่ละบรรทัด:
-
writeCR(<tr><td><b>ชื่อ:</b></td><td> & ชื่อ & </td></tr>)
-
ย่อยเขียน CR(str)
การตอบกลับเขียน (str & vbCRLF)
จบย่อย
/app1/response4.asp ส่วน
สถิติดีที่สุด = 8.08 ms/page
เวลาตอบสนอง = 10.11 ms/หน้า
ส่วนต่าง = +2.03 ms (เพิ่มขึ้น 25.1%)
ผลลัพธ์ที่ได้คือประสิทธิภาพลดลงอย่างมาก แน่นอนว่าสาเหตุหลักมาจากวิธีนี้เพิ่มจำนวนการเรียกใช้ฟังก์ชันเป็นสองเท่า และผลกระทบต่อประสิทธิภาพก็ชัดเจนมาก ควรหลีกเลี่ยงการใช้งานนี้ไม่ว่าจะด้วยวิธีใดก็ตาม CRLF จะส่งผลให้มีไบต์เพิ่มเติมสองไบต์ที่ท้ายแต่ละบรรทัด และทั้งสองไบต์นี้ไม่มีประโยชน์สำหรับเบราว์เซอร์ในการแสดงเพจ ในกรณีส่วนใหญ่ รูปแบบที่สวยงามของโค้ด HTML ฝั่งเบราว์เซอร์ช่วยให้คู่แข่งของคุณอ่านและทำความเข้าใจการออกแบบเพจได้ง่ายขึ้น
2.4 ผสานหลาย Response.Write
โดยไม่สนใจการทดสอบครั้งล่าสุดเกี่ยวกับฟังก์ชันการห่อหุ้ม ขั้นตอนตรรกะถัดไปคือการรวมสตริงทั้งหมดจากคำสั่ง Response.Write ที่แยกกันเป็นคำสั่งเดียว ซึ่งจะช่วยลดจำนวนการเรียกใช้ฟังก์ชันและปรับปรุงประสิทธิภาพของโค้ด
คัดลอกรหัสรหัสดังต่อไปนี้:
การตอบกลับเขียน(<html> & _
<หัว> & _
<title>การทดสอบการตอบสนอง</title> & _
</หัว> & _
<ร่างกาย> & _
<h1>การทดสอบการตอบสนอง</h1> & _
<ตาราง> & _
<tr><td><b>ชื่อ:</b></td><td> & ชื่อ & </td></tr> & _
-
<tr><td><b>วันเกิด:</b></td><td> & วันเกิด & </td></tr> & _
</ตาราง> & _
</ร่างกาย> & _
</html>)
/app1/response3.asp ส่วน
สถิติดีที่สุด = 8.08 ms/page
เวลาตอบสนอง = 7.05 ms/หน้า
ความแตกต่าง = -1.03 ms (ลดลง 12.7%)
นี่เป็นวิธีที่ดีที่สุด
2.5 รวมการตอบกลับหลายรายการเข้าด้วยกัน เขียนและเพิ่ม CRLF ที่ท้ายแต่ละบรรทัด
บางคนยังกังวลอย่างมากว่าโค้ด HTML ของพวกเขาดูสวยงามบนฝั่งเบราว์เซอร์หรือไม่ ดังนั้นเราจึงเพิ่มการขึ้นบรรทัดใหม่ที่ส่วนท้ายของโค้ด HTML แต่ละบรรทัด โดยใช้ค่าคงที่ vbCRLF โค้ดทดสอบอื่นๆ จะเหมือนกับตัวอย่างข้างต้น .
-
การตอบกลับเขียน(<html> & vbCRLF & _
<หัว> & vbCRLF & _
<title>การทดสอบการตอบสนอง</title> & vbCRLF & _
</หัว> & vbCRLF & _
-
/app1/response5.asp ส่วน
สถิติที่ดีที่สุด = 7.05 ms/หน้า
เวลาตอบสนอง = 7.63 ms/หน้า
ความแตกต่าง = +0.58 ms (เพิ่มขึ้น 8.5%)
ผลลัพธ์คือประสิทธิภาพลดลงเล็กน้อย อาจเนื่องมาจากการเพิ่มการดำเนินการต่อสตริงและข้อความเอาต์พุตที่เพิ่มขึ้น
2.6 ความคิดเห็น
จากผลการทดสอบเอาต์พุต ASP ข้างต้น เรามาถึงกฎการเข้ารหัสต่อไปนี้:
หลีกเลี่ยงการใช้ ASP แบบฝังมากเกินไป
รวมคำสั่ง Response.Write ให้ได้มากที่สุดเป็นคำสั่งเดียว
ไม่ต้องห่อหุ้มการตอบสนอง เขียนเพียงเพื่อเพิ่ม CRLF
หากคุณต้องการจัดรูปแบบเอาต์พุต HTML ให้เพิ่ม CRLF โดยตรงหลังคำสั่ง Response.Write
โครงร่าง: วิธีที่มีประสิทธิภาพที่สุดในการส่งออกเนื้อหาที่สร้างโดย ASP แบบไดนามิกคืออะไร? วิธีที่ดีที่สุดในการแยกชุดบันทึกฐานข้อมูลคืออะไร? บทความนี้ทดสอบปัญหาทั่วไปเกือบ 20 ปัญหาในการพัฒนา ASP ดังกล่าว เวลาที่แสดงโดยเครื่องมือทดสอบบอกเราว่าปัญหาเหล่านี้ที่มักมองข้ามไปไม่เพียงแต่คุ้มค่าแก่ความสนใจเท่านั้น แต่ยังมีความลับที่ไม่คาดคิดซ่อนอยู่ภายในอีกด้วย
1. วัตถุประสงค์ในการทดสอบ
ส่วนแรกของบทความนี้จะตรวจสอบปัญหาพื้นฐานบางประการในการพัฒนา ASP และให้ผลการทดสอบประสิทธิภาพบางอย่างเพื่อช่วยให้ผู้อ่านเข้าใจว่าโค้ดที่วางบนเพจมีผลกระทบต่อประสิทธิภาพอย่างไร ADO เป็นอินเทอร์เฟซฐานข้อมูลสากลที่ใช้งานง่ายซึ่งพัฒนาโดย Microsoft ปรากฎว่าการโต้ตอบกับฐานข้อมูลผ่าน ADO เป็นหนึ่งในแอปพลิเคชันที่สำคัญที่สุดของ ASP ในส่วนที่สอง เราจะศึกษาปัญหานี้
ฟังก์ชันการทำงานที่ ADO ให้มานั้นค่อนข้างกว้างขวาง ดังนั้นปัญหาที่ใหญ่ที่สุดในการเตรียมบทความนี้คือวิธีการกำหนดขอบเขตของปัญหา เมื่อพิจารณาว่าการแยกข้อมูลจำนวนมากสามารถเพิ่มภาระบนเว็บเซิร์ฟเวอร์ได้อย่างมาก เราจึงตัดสินใจว่าวัตถุประสงค์หลักของส่วนนี้คือการค้นหาว่าการกำหนดค่าที่เหมาะสมที่สุดสำหรับการใช้งานชุดระเบียน ADO คืออะไร อย่างไรก็ตาม แม้หลังจากจำกัดขอบเขตของปัญหาแล้ว เรายังคงเผชิญกับความยากลำบากอย่างมาก เนื่องจาก ADO สามารถมีหลายวิธีในการทำงานเดียวกันให้สำเร็จ ตัวอย่างเช่น ชุดระเบียนสามารถแยกออกมาได้ไม่เฉพาะผ่านคลาส Recordset เท่านั้น แต่ยังแยกผ่านคลาส Connection และ Command ได้ด้วย แม้ว่าจะได้รับอ็อบเจ็กต์ชุดระเบียนแล้ว ก็ยังมีวิธีดำเนินการมากมายที่อาจส่งผลกระทบอย่างมากต่อประสิทธิภาพการทำงาน อย่างไรก็ตาม เช่นเดียวกับในส่วนที่ 1 เราจะพยายามครอบคลุมประเด็นต่างๆ ที่กว้างที่สุดเท่าที่จะเป็นไปได้
โดยเฉพาะอย่างยิ่ง เป้าหมายของส่วนนี้คือการรวบรวมข้อมูลให้เพียงพอเพื่อตอบคำถามต่อไปนี้:
ADOVBS.inc ควรอ้างอิงผ่าน include หรือไม่
ฉันควรสร้างออบเจ็กต์การเชื่อมต่อแยกต่างหากเมื่อใช้ชุดระเบียนหรือไม่
วิธีที่ดีที่สุดในการแยกชุดระเบียนคืออะไร?
ประเภทเคอร์เซอร์และวิธีการล็อคบันทึกใดมีประสิทธิภาพมากที่สุด?
ฉันควรใช้ชุดระเบียนในเครื่องหรือไม่
วิธีที่ดีที่สุดในการตั้งค่าคุณสมบัติชุดระเบียนคืออะไร
l วิธีใดมีประสิทธิภาพมากที่สุดในการอ้างอิงค่าฟิลด์ในชุดบันทึก?
เป็นวิธีที่ดีในการรวบรวมเอาต์พุตด้วยสตริงชั่วคราวหรือไม่?
2. สภาพแวดล้อมการทดสอบ
การทดสอบนี้ใช้ไฟล์ ASP ทั้งหมด 21 ไฟล์ ซึ่งสามารถดาวน์โหลดได้จากด้านหลังของบทความนี้ แต่ละหน้าได้รับการตั้งค่าให้เรียกใช้แบบสอบถามที่แตกต่างกันสามรายการ โดยส่งคืนระเบียน 0, 25 และ 250 ตามลำดับ ซึ่งจะช่วยให้เราแยกการเริ่มต้นและการดำเนินการโอเวอร์เฮดของเพจออกจากโอเวอร์เฮดของการวนซ้ำผ่านชุดระเบียน
เพื่ออำนวยความสะดวกในการทดสอบ สตริงการเชื่อมต่อฐานข้อมูลและสตริงคำสั่ง SQL จะถูกบันทึกเป็นตัวแปรแอปพลิเคชันใน Global.asa เนื่องจากฐานข้อมูลทดสอบของเราคือ SQL Server 7.0 สตริงการเชื่อมต่อจึงระบุ OLEDB เป็นผู้ให้บริการการเชื่อมต่อ และข้อมูลการทดสอบมาจากฐานข้อมูล Northwind ของ SQL Server คำสั่ง SQL SELECT แยกฟิลด์ที่ระบุ 7 รายการออกจากตารางคำสั่งซื้อ NorthWind
คัดลอกรหัสรหัสดังต่อไปนี้:
<ภาษาสคริปต์=VBScript RUNAT=เซิร์ฟเวอร์>
Application_OnStart ย่อย
แอปพลิเคชัน (Conn) = ผู้ให้บริการ = SQLOLEDB;
เซิร์ฟเวอร์=เซิร์ฟเวอร์ของฉัน & _
uid=sa;
รหัสผ่าน=;
ฐานข้อมูล=ลมเหนือ
แอปพลิเคชัน (SQL) = SELECTTOP 0OrderID, & _
รหัสลูกค้า & _
รหัสพนักงาน & _
วันที่สั่งซื้อ & _
วันที่ต้องระบุ & _
วันที่จัดส่ง & _
ค่าขนส่ง & _
จาก[คำสั่งซื้อ]
จบหมวดย่อย
</สคริปต์>
'sql สำรอง - 25 บันทึก
แอปพลิเคชัน (SQL) = SELECTTOP 25OrderID, & _
รหัสลูกค้า & _
รหัสพนักงาน & _
วันที่สั่งซื้อ & _
วันที่ต้องระบุ & _
วันที่จัดส่ง & _
ค่าขนส่ง & _
จาก[คำสั่งซื้อ]
'บันทึกสำรอง sql-250
แอปพลิเคชัน (SQL) = SELECTTOP 250 รหัสคำสั่งซื้อ & _
รหัสลูกค้า & _
รหัสพนักงาน & _
วันที่สั่งซื้อ & _
วันที่ต้องระบุ & _
วันที่จัดส่ง & _
ค่าขนส่ง & _
จาก[คำสั่งซื้อ]
การกำหนดค่าเซิร์ฟเวอร์ทดสอบมีดังนี้: 450 Mhz Pentium, 512 MB RAM, NT Server 4.0 SP5, MDAC 2.1 (ส่วนประกอบการเข้าถึงข้อมูล) และ Microsoft Scripting Engine เวอร์ชัน 5.0 SQL Server กำลังทำงานบนเครื่องอื่นที่มีการกำหนดค่าคล้ายกัน เช่นเดียวกับในส่วนแรก เรายังคงใช้ Microsoft Web Application Stress Tool เพื่อบันทึกเวลาตั้งแต่คำขอหน้าแรกไปจนถึงไบต์สุดท้ายที่ได้รับจากเซิร์ฟเวอร์ (TTLB, Time To Last Byte) เวลาเป็นมิลลิวินาที สคริปต์ทดสอบเรียกแต่ละหน้ามากกว่า 1300 ครั้ง และใช้เวลาประมาณ 20 ชั่วโมงในการรัน เวลาที่แสดงด้านล่างคือเวลา TTLB เฉลี่ยสำหรับเซสชัน โปรดจำไว้ว่า ในส่วนแรก เรากังวลเฉพาะกับประสิทธิภาพของโค้ดเท่านั้น ไม่ใช่ความสามารถในการปรับขนาดหรือประสิทธิภาพของเซิร์ฟเวอร์
โปรดทราบว่าเราได้เปิดใช้งานการบัฟเฟอร์เซิร์ฟเวอร์แล้ว นอกจากนี้ เพื่อให้ชื่อไฟล์ทั้งหมดมีความยาวเท่ากัน ชื่อไฟล์บางชื่อจะมีขีดล่างอย่างน้อยหนึ่งอันฝังอยู่
3. การทดสอบครั้งแรก
ในการทดสอบครั้งแรก เราได้แยกชุดระเบียนที่จำลองสถานการณ์ทั่วไปที่พบในตัวอย่าง Microsoft ASP ADO ในตัวอย่างนี้ (ADO__01.asp) เราจะเปิดการเชื่อมต่อก่อน จากนั้นจึงสร้างวัตถุชุดระเบียน แน่นอนว่าสคริปต์ที่นี่ได้รับการปรับให้เหมาะสมตามกฎการเข้ารหัสที่สรุปไว้ในส่วนแรกของบทความนี้
คัดลอกรหัสรหัสดังต่อไปนี้:
<% ตัวเลือกที่ชัดเจน %>
<!-- #รวมไฟล์=ADOVBS.INC -->
-
ติ่ม objConn
ติ่ม objRS
ตอบกลับเขียน(_
<HTML><HEAD> & _
<TITLE>การทดสอบ ADO</TITLE> & _
</HEAD><BODY> _
-
ตั้งค่า objConn = Server.CreateObject (ADODB.Connection)
objConn เปิดแอปพลิเคชัน (Conn)
ตั้ง objRS = Server.CreateObject(ADODB.Recordset)
objRS.ActiveConnection = objConn
objRS.CursorType = adOpenForwardOnly
objRS.LockType = adLockReadOnly
objRS เปิดแอปพลิเคชัน (SQL)
ถ้า objRS.EOF แล้ว
ตอบกลับเขียน(ไม่พบบันทึก)
อื่น
'เขียนหัวเรื่อง
ตอบกลับเขียน(_
<เส้นขอบตาราง=1> & _
<TR> & _
<TH>รหัสคำสั่งซื้อ</TH> & _
<TH>รหัสลูกค้า</TH> & _
<TH>รหัสพนักงาน</TH> & _
<TH>วันที่สั่งซื้อ</TH> & _
<TH>วันที่ต้องระบุ</TH> & _
<TH>วันที่จัดส่ง</TH> & _
<TH>ค่าขนส่ง</TH> & _
</TR> _
-
'เขียนข้อมูล
ทำในขณะที่ไม่ objRS.EOF
ตอบกลับเขียน(_
<TR> & _
<TD> & objRS(รหัสคำสั่งซื้อ) & </TD> & _
<TD> & objRS(รหัสลูกค้า) & </TD> & _
<TD> & objRS(รหัสพนักงาน) & </TD> & _
<TD> & objRS(วันที่สั่งซื้อ) & </TD> & _
<TD> & objRS(วันที่ต้องระบุ) & </TD> & _
<TD> & objRS(วันที่จัดส่ง) & </TD> & _
<TD> & objRS (ค่าขนส่ง) & </TD> & _
</TR> _
-
objRS.MoveNext
วนซ้ำ
การตอบกลับเขียน(</TABLE>)
สิ้นสุดถ้า
objRS.ปิด
objConn ปิด
ตั้ง objRS = ไม่มีเลย
ตั้งค่า objConn = ไม่มีเลย
ตอบกลับเขียน(</BODY></HTML>)
-
นี่คือผลการทดสอบ:
มาดูความหมายของตัวเลขในแต่ละคอลัมน์กันดีกว่า:
0 ส่งคืน TTLB (เป็นมิลลิวินาที) ที่จำเป็นสำหรับเพจที่มี 0 เรคคอร์ด ในการทดสอบทั้งหมด ค่านี้ถือเป็นค่าใช้จ่ายในการสร้างเพจ (รวมถึงการสร้างออบเจ็กต์) โดยไม่รวมเวลาในการวนซ้ำข้อมูลชุดระเบียน
25 TTLB ในหน่วยมิลลิวินาทีเพื่อดึงข้อมูลและแสดง 25 รายการ
TTLB ในคอลัมน์เวลารวม/2525 หารด้วย 25 ซึ่งเป็นต้นทุนเวลาเฉลี่ยทั้งหมดต่อบันทึก
เวลาจ่าย/2525 คอลัมน์ TTLB ลบ 0 คอลัมน์ TTLB แล้วหารด้วย 25 ค่านี้สะท้อนถึงเวลาที่ต้องใช้ในการแสดงระเบียนเดียวในขณะที่วนซ้ำชุดระเบียน
250 แยกและแสดง TTLB จาก 250 บันทึก
TTLB ในคอลัมน์เวลารวม/250250 หารด้วย 25 ค่านี้แสดงถึงต้นทุนเวลาเฉลี่ยรวมของเรกคอร์ดเดียว
disp time/250 TTLB ในคอลัมน์ 250 จะถูกลบออกจาก TTLB ในคอลัมน์ 0 แล้วหารด้วย 250 ค่านี้สะท้อนถึงเวลาที่ต้องใช้ในการแสดงระเบียนเดียวในขณะที่วนซ้ำชุดระเบียน
ผลการทดสอบข้างต้นจะถูกใช้เพื่อเปรียบเทียบกับผลการทดสอบครั้งต่อไป
4. ADOVBS.inc ควรมีการอ้างอิงผ่านการรวมหรือไม่
ADOVBS.inc จัดทำโดย Microsoft ประกอบด้วยโค้ด 270 บรรทัดที่กำหนดค่าคงที่ของคุณสมบัติ ADO ส่วนใหญ่ ตัวอย่างของเราอ้างอิงเพียง 2 ค่าคงที่จาก ADOVBS.inc ดังนั้นในการทดสอบนี้ (ADO__02.asp) เราจึงลบการอ้างอิงไฟล์ที่รวมไว้ และใช้ค่าที่เกี่ยวข้องโดยตรงเมื่อตั้งค่าคุณสมบัติ
objRS.CursorType = 0? adOpenForwardOnly
objRS.LockType = 1' adLockReadOnly
คุณจะเห็นว่าค่าใช้จ่ายของหน้าลดลง 23% ค่านี้ไม่ส่งผลต่อเวลาในการดึงข้อมูลและการแสดงของแต่ละเรคคอร์ด เนื่องจากการเปลี่ยนแปลงที่นี่จะไม่ส่งผลต่อการทำงานของชุดเรคคอร์ดภายในลูป มีหลายวิธีในการแก้ไขปัญหาการอ้างอิง ADOVBS.inc เราขอแนะนำให้ใช้ไฟล์ ADOVBS.inc เป็นข้อมูลอ้างอิงและอธิบายการตั้งค่าผ่านความคิดเห็น โปรดจำไว้ว่า ตามที่ระบุไว้ในส่วนที่ 1 การใช้ความคิดเห็นในระดับปานกลางมีผลกระทบน้อยที่สุดต่อประสิทธิภาพของโค้ดของคุณ อีกวิธีหนึ่งคือการคัดลอกค่าคงที่ที่คุณต้องการจากไฟล์ ADOVBS.inc ลงในเพจ
ยังมีวิธีที่ดีในการแก้ไขปัญหานี้ ซึ่งก็คือ ทำให้ค่าคงที่ ADO ทั้งหมดพร้อมใช้งานโดยตรง โดยการลิงก์ไปยังไลบรารีชนิด ADO เพิ่มรหัสต่อไปนี้ลงในแฟ้ม Global.asa เพื่อเข้าถึงค่าคงที่ ADO ทั้งหมดโดยตรง:
<!--ประเภทข้อมูลเมตา=typelib
FILE=C:ไฟล์โปรแกรมไฟล์ทั่วไปSYSTEMADOmsado15.dll
NAME=ไลบรารีประเภท ADODB -->
หรือ:
<!--ประเภทข้อมูลเมตา=typelib
UUID=00000205-0000-0010-8000-00AA006D2EA4
NAME=ไลบรารีประเภท ADODB -->
ดังนั้นกฎข้อแรกของเราคือ:
หลีกเลี่ยงการรวมไฟล์ ADOVBS.inc และเข้าถึงและใช้ค่าคงที่ ADO ผ่านวิธีการอื่น
5. ฉันควรสร้างออบเจ็กต์การเชื่อมต่อแยกต่างหากเมื่อใช้ชุดระเบียนหรือไม่
เพื่อตอบคำถามนี้อย่างถูกต้อง เราต้องวิเคราะห์การทดสอบภายใต้เงื่อนไขที่แตกต่างกันสองประการ ประการแรก เพจมีธุรกรรมฐานข้อมูลเดียวเท่านั้น ประการที่สอง เพจมีธุรกรรมฐานข้อมูลหลายรายการ
ในตัวอย่างก่อนหน้านี้ เราได้สร้างออบเจ็กต์การเชื่อมต่อแยกต่างหาก และกำหนดให้กับคุณสมบัติ ActiveConnection ของ Recordset อย่างไรก็ตาม ดังที่แสดงใน ADO__03.asp เรายังสามารถกำหนดสตริงการเชื่อมต่อให้กับคุณสมบัติ ActiveConnection ได้โดยตรง โดยกำจัดขั้นตอนเพิ่มเติมในการเริ่มต้นและกำหนดค่าออบเจ็กต์การเชื่อมต่อในสคริปต์
objRS.ActiveConnection = แอปพลิเคชัน (Conn)
แม้ว่าวัตถุ Recordset ยังคงจำเป็นต้องสร้างการเชื่อมต่อ การสร้างในเวลานี้จะดำเนินการภายใต้เงื่อนไขที่ได้รับการปรับปรุงให้เหมาะสมที่สุด เป็นผลให้ค่าใช้จ่ายของหน้าลดลงอีก 23% เมื่อเทียบกับการทดสอบครั้งก่อน และตามที่คาดไว้ เวลาแสดงของบันทึกเดียวไม่เปลี่ยนแปลงอย่างมีนัยสำคัญ
ดังนั้นกฎข้อที่สองของเราจึงเป็นดังนี้:
หากคุณใช้ชุดระเบียนเดียว ให้กำหนดสตริงการเชื่อมต่อให้กับคุณสมบัติ ActiveConnection โดยตรง
ต่อไป เราจะตรวจสอบว่ากฎข้างต้นยังคงถูกต้องหรือไม่เมื่อเพจใช้ชุดระเบียนหลายชุด เพื่อทดสอบสถานการณ์นี้ เราแนะนำการวนซ้ำ FOR เพื่อทำซ้ำตัวอย่างก่อนหน้า 10 ครั้ง ในการทดสอบนี้ เราจะดูรูปแบบต่างๆ สามแบบ:
ขั้นแรก ดังที่แสดงใน ADO__04.asp วัตถุการเชื่อมต่อจะถูกสร้างและทำลายในแต่ละวง:
คัดลอกรหัสรหัสดังต่อไปนี้:
ดิม ไอ
สำหรับ i = 1 ถึง 10
ตั้งค่า objConn = Server.CreateObject (ADODB.Connection)
objConn เปิดแอปพลิเคชัน (Conn)
ตั้ง objRS = Server.CreateObject(ADODB.Recordset)
objRS.ActiveConnection = objConn
objRS.CursorType = 0 'adOpenForwardOnly
objRS.LockType = 1 'adLockReadOnly
objRS เปิดแอปพลิเคชัน (SQL)
ถ้า objRS.EOF แล้ว
ตอบกลับเขียน(ไม่พบบันทึก)
อื่น
'เขียนหัวเรื่อง
-
'เขียนข้อมูล
-
สิ้นสุดถ้า
objRS.ปิด
ตั้ง objRS = ไม่มีเลย
objConn ปิด
ตั้งค่า objConn = ไม่มีเลย
ต่อไป
ประการที่สอง ดังที่แสดงใน ADO__05.asp สร้างวัตถุการเชื่อมต่อภายนอกลูป และแบ่งปันวัตถุนี้กับชุดระเบียนทั้งหมด:
คัดลอกรหัสรหัสดังต่อไปนี้:
ตั้งค่า objConn = Server.CreateObject (ADODB.Connection)
objConn เปิดแอปพลิเคชัน (Conn)
ดิม ไอ
สำหรับ i = 1 ถึง 10
ตั้ง objRS = Server.CreateObject(ADODB.Recordset)
objRS.ActiveConnection = objConn
objRS.CursorType = 0 'adOpenForwardOnly
objRS.LockType = 1 'adLockReadOnly
objRS เปิดแอปพลิเคชัน (SQL)
ถ้า objRS.EOF แล้ว
ตอบกลับเขียน(ไม่พบบันทึก)
อื่น
'เขียนหัวเรื่อง
-
'เขียนข้อมูล
-
สิ้นสุดถ้า
objRS.ปิด
ตั้ง objRS = ไม่มีเลย
ต่อไป
objConn ปิด
ตั้งค่า objConn = ไม่มีเลย
ประการที่สาม ดังที่แสดงใน ADO__06.asp กำหนดสตริงการเชื่อมต่อให้กับคุณสมบัติ ActiveConnection ในแต่ละวง:
คัดลอกรหัสรหัสดังต่อไปนี้:
ดิม ไอ
สำหรับ i = 1 ถึง 10
ตั้ง objRS = Server.CreateObject(ADODB.Recordset)
objRS.ActiveConnection = แอปพลิเคชัน (Conn)
objRS.CursorType = 0 'adOpenForwardOnly
objRS.LockType = 1 'adLockReadOnly
objRS เปิดแอปพลิเคชัน (SQL)
ถ้า objRS.EOF แล้ว
ตอบกลับเขียน(ไม่พบบันทึก)
อื่น
'เขียนหัวเรื่อง
-
'เขียนข้อมูล
-
สิ้นสุดถ้า
objRS.ปิด
ตั้ง objRS = ไม่มีเลย
ต่อไป
ดังที่เราคาดเดาได้ การสร้างและการแยกวัตถุการเชื่อมต่อภายในลูปเป็นวิธีที่มีประสิทธิภาพน้อยที่สุด อย่างไรก็ตาม น่าประหลาดใจที่การกำหนดสตริงการเชื่อมต่อโดยตรงให้กับคุณสมบัติ ActiveConnection ภายในลูปนั้นช้ากว่าการแชร์ออบเจ็กต์การเชื่อมต่อเดียวเพียงเล็กน้อยเท่านั้น
อย่างไรก็ตาม กฎข้อที่สามควรเป็น:
เมื่อใช้ชุดระเบียนหลายชุดในหน้าเดียวกัน ให้สร้างออบเจ็กต์การเชื่อมต่อเดียวและแบ่งปันผ่านคุณสมบัติ ActiveConnection
6. ประเภทเคอร์เซอร์และวิธีการล็อคบันทึกใดมีประสิทธิภาพมากที่สุด?
ในการทดสอบทั้งหมดจนถึงตอนนี้ เราใช้เฉพาะเคอร์เซอร์แบบส่งต่อเท่านั้นในการเข้าถึงชุดระเบียน ADO มีเคอร์เซอร์อยู่สามประเภทสำหรับชุดบันทึก ได้แก่ เคอร์เซอร์แบบเลื่อนแบบคงที่ เคอร์เซอร์แบบเลื่อนแบบไดนามิก และเคอร์เซอร์ชุดคีย์ เคอร์เซอร์แต่ละตัวมีฟังก์ชันที่แตกต่างกัน เช่น การเข้าถึงบันทึกก่อนหน้าและบันทึกถัดไป ไม่ว่าคุณจะสามารถดูการแก้ไขข้อมูลโดยโปรแกรมอื่นหรือไม่ เป็นต้น อย่างไรก็ตาม การอภิปรายโดยละเอียดเกี่ยวกับฟังก์ชันของเคอร์เซอร์แต่ละประเภทนั้นอยู่นอกเหนือขอบเขตของบทความนี้
เคอร์เซอร์ประเภทอื่นๆ ทั้งหมดต้องการโอเวอร์เฮดเพิ่มเติมเมื่อเปรียบเทียบกับเคอร์เซอร์แบบส่งต่อเท่านั้น และโดยทั่วไปเคอร์เซอร์เหล่านี้จะช้ากว่าภายในลูป ดังนั้นเราจึงอยากแบ่งปันคำเตือนต่อไปนี้กับคุณ: อย่าคิดแบบนี้ - บางครั้งฉันจะใช้เคอร์เซอร์แบบไดนามิก ดังนั้นฉันจะใช้เคอร์เซอร์นี้เสมอ
ความคิดเห็นเดียวกันนี้ใช้กับการเลือกวิธีการล็อคบันทึก การทดสอบก่อนหน้านี้ใช้เฉพาะวิธีการล็อคแบบอ่านอย่างเดียว แต่มีอีกสามวิธี: การประมวลผลแบบอนุรักษ์นิยม เปิด และเปิด เช่นเดียวกับประเภทเคอร์เซอร์ วิธีการล็อคเหล่านี้มีฟังก์ชันการทำงานที่แตกต่างกันและการควบคุมการทำงานกับข้อมูลชุดระเบียน
เรามาถึงกฎต่อไปนี้:
ใช้ประเภทเคอร์เซอร์ที่ง่ายที่สุดและวิธีการล็อคบันทึกที่เหมาะสมกับงาน
7. วิธีใดดีที่สุดที่จะใช้ในการแยกชุดบันทึก?
จนถึงขณะนี้ เราได้แยกชุดระเบียนด้วยการสร้างวัตถุชุดระเบียน แต่ ADO ยังมีวิธีการแยกชุดระเบียนทางอ้อมอีกด้วย การทดสอบต่อไปนี้เปรียบเทียบ ADO__03.asp และการสร้างชุดระเบียนโดยตรงจากวัตถุการเชื่อมต่อ (CONN_01.asp):
คัดลอกรหัสรหัสดังต่อไปนี้:
ตั้งค่า objConn = Server.CreateObject (ADODB.Connection)
objConn เปิดแอปพลิเคชัน (Conn)
ตั้งค่า objRS = objConn.Execute (Application (SQL))
คุณจะเห็นว่าค่าใช้จ่ายของหน้าเพิ่มขึ้นเล็กน้อย และเวลาแสดงของเรกคอร์ดเดียวไม่เปลี่ยนแปลง
มาดูการสร้างวัตถุชุดระเบียน (CMD__02.asp) โดยตรงจากวัตถุ Command กัน:
คัดลอกรหัสรหัสดังต่อไปนี้:
ตั้งค่า objCmd = Server.CreateObject(ADODB.Command)
objCmd.ActiveConnection = แอปพลิเคชัน (Conn)
objCmd.CommandText = แอปพลิเคชัน (SQL)
ตั้งค่า objRS = objCmd.Execute
ในทำนองเดียวกัน โอเวอร์เฮดของหน้าจะเพิ่มขึ้นเล็กน้อยโดยไม่มีการเปลี่ยนแปลงเวลาแสดงของเรกคอร์ดเดียวมากนัก ความแตกต่างในประสิทธิภาพระหว่างสองวิธีหลังนั้นมีน้อย แต่เรามีปัญหาสำคัญที่ต้องพิจารณา
เมื่อสร้างชุดระเบียนผ่านคลาส Recordset เราสามารถควบคุมการประมวลผลของชุดระเบียนได้อย่างยืดหยุ่นที่สุด เนื่องจากสองวิธีหลังนี้ล้มเหลวในการบรรลุประสิทธิภาพอย่างท่วมท้น เราจึงพิจารณาประเภทเคอร์เซอร์และวิธีการล็อกบันทึกที่ส่งกลับเป็นค่าเริ่มต้นเป็นหลัก ในบางครั้ง ค่าเริ่มต้นไม่จำเป็นต้องเป็นค่าที่เหมาะสมที่สุด
ดังนั้น เว้นแต่จะมีเหตุผลพิเศษในการเลือกระหว่างสองวิธีหลัง เราขอแนะนำให้พิจารณากฎต่อไปนี้:
สร้างอินสแตนซ์ชุดระเบียนผ่านคลาส ADODB.Recordset เพื่อให้ได้ประสิทธิภาพและความยืดหยุ่นที่ดีที่สุด
8. ฉันควรใช้ชุดบันทึกในเครื่องหรือไม่
ADO อนุญาตให้ใช้ชุดระเบียนภายในเครื่อง (ไคลเอนต์) ในขณะนี้ แบบสอบถามจะแยกข้อมูลทั้งหมดในชุดระเบียน หลังจากแบบสอบถามเสร็จสิ้น การเชื่อมต่อสามารถปิดได้ทันที และเคอร์เซอร์ในเครื่องสามารถใช้เพื่อเข้าถึงข้อมูลได้ อนาคตที่นำความสะดวกสบายมาสู่การปล่อยการเชื่อมต่อ การใช้ชุดบันทึกในเครื่องเป็นสิ่งสำคัญสำหรับการเข้าถึงบริการข้อมูลระยะไกลที่ต้องใช้ข้อมูลแบบออฟไลน์ แต่จะมีประโยชน์สำหรับแอปพลิเคชันทั่วไปด้วยหรือไม่
ต่อไปเราจะเพิ่มแอตทริบิวต์ CursorLocation และปิดการเชื่อมต่อ (CLIENT1.asp) หลังจากเปิดชุดระเบียน:
คัดลอกรหัสรหัสดังต่อไปนี้:
ตั้ง objRS = Server.CreateObject(ADODB.Recordset)
objRS.CursorLocation = 2' adUseClient
objRS.ActiveConnection = แอปพลิเคชัน (Conn)
objRS.LockType = 1? adLockReadOnly
objRS เปิดแอปพลิเคชัน (SQL)
objRS.ActiveConnection = ไม่มีเลย
ตามทฤษฎี วิธีการนี้จะเป็นประโยชน์ต่อประสิทธิภาพด้วยเหตุผลสองประการ ประการแรก จะหลีกเลี่ยงการร้องขอข้อมูลซ้ำๆ ผ่านการเชื่อมต่อเมื่อย้ายระหว่างเรกคอร์ด ประการที่สอง จะช่วยลดความต้องการทรัพยากร อย่างไรก็ตาม จากตารางด้านบนดูเหมือนว่าการใช้ชุดระเบียนในเครื่องจะไม่ช่วยปรับปรุงประสิทธิภาพได้อย่างชัดเจน อาจเป็นเพราะเมื่อใช้ชุดระเบียนในเครื่อง เคอร์เซอร์จะกลายเป็นประเภทคงที่เสมอไม่ว่าการตั้งค่าโปรแกรมจะเป็นอย่างไร
กฎข้อที่ 6 มีดังนี้:
lควรหลีกเลี่ยงสิ่งนี้เว้นแต่จำเป็นต้องมีการแปลชุดระเบียนเป็นภาษาท้องถิ่นอย่างแท้จริง
10. วิธีใดมีประสิทธิภาพที่สุดในการอ้างอิงค่าฟิลด์ในชุดบันทึก?
10.1 การทดสอบ
จนถึงตอนนี้เราได้อ้างถึงค่าฟิลด์ในชุดระเบียนตามชื่อ เนื่องจากวิธีนี้จำเป็นต้องค้นหาฟิลด์ที่เกี่ยวข้องทุกครั้ง จึงไม่มีประสิทธิภาพมากนัก เพื่อสาธิตสิ่งนี้ ในการทดสอบต่อไปนี้ เราจะอ้างอิงค่าของฟิลด์ตามดัชนีในคอลเลกชัน (ADO__08.asp):
คัดลอกรหัสรหัสดังต่อไปนี้:
'เขียนข้อมูล
ทำในขณะที่ไม่ objRS.EOF
ตอบกลับเขียน(_
<TR> & _
<TD> & objRS(0) & </TD> & _
<TD> & objRS(1) & </TD> & _
<TD> & objRS(2) & </TD> & _
<TD> & objRS(3) & </TD> & _
<TD> & objRS(4) & </TD> & _
<TD> & objRS(5) & </TD> & _
<TD> & objRS(6) & </TD> & _
</TR> _
-
objRS.MoveNext
วนซ้ำ
ตามที่คาดไว้ มีการเปลี่ยนแปลงเล็กน้อยในค่าใช้จ่ายของหน้าด้วย (อาจเป็นเพราะโค้ดลดลงเล็กน้อย) อย่างไรก็ตาม การปรับปรุงเวลาในการแสดงผลด้วยวิธีนี้ค่อนข้างชัดเจน
ในการทดสอบครั้งต่อไป เราจะผูกฟิลด์ทั้งหมดเข้ากับตัวแปรทีละรายการ (ADO__09.asp):
คัดลอกรหัสรหัสดังต่อไปนี้:
ถ้า objRS.EOF แล้ว
ตอบกลับเขียน(ไม่พบบันทึก)
อื่น
'เขียนหัวเรื่อง
-
หรี่ fld0
ดิม fld1
ดิม ffl2
ดิม ffl3
ดิม fld4
ดิม ff5
ดิม fld6
ตั้งค่า fld0 = objRS(0)
ตั้งค่า fld1 = objRS(1)
ตั้งค่า fld2 = objRS(2)
ตั้งค่า fld3 = objRS(3)
ตั้งค่า fld4 = objRS(4)
ตั้งค่า fld5 = objRS(5)
ตั้งค่า fld6 = objRS(6)
'เขียนข้อมูล
ทำในขณะที่ไม่ objRS.EOF
ตอบกลับเขียน(_
<TR> & _
<TD> & fld0 & </TD> & _
<TD> & fld1 & </TD> & _
<TD> & fld2 & </TD> & _
<TD> & fld3 & </TD> & _
<TD> & fld4 & </TD> & _
<TD> & fld5 & </TD> & _
<TD> & fld6 & </TD> & _
</TR> _
-
objRS.MoveNext
วนซ้ำ
ตั้งค่า fld0 = ไม่มีเลย
ตั้งค่า fld1 = ไม่มีเลย
ตั้งค่า fld2 = ไม่มีเลย
ตั้งค่า fld3 = ไม่มีเลย
ตั้งค่า fld4 = ไม่มีเลย
ตั้งค่า fld5 = ไม่มีเลย
ตั้งค่า fld6 = ไม่มีเลย
การตอบกลับเขียน(</TABLE>)
สิ้นสุดถ้า
นี่คือบันทึกที่ดีที่สุดจนถึงตอนนี้ โปรดทราบว่าเวลาการแสดงผลของบันทึกเดียวลดลงเหลือน้อยกว่า 0.45 มิลลิวินาที
สคริปต์ข้างต้นทั้งหมดจำเป็นต้องมีความเข้าใจในการสร้างชุดบันทึกผลลัพธ์ ตัวอย่างเช่น เราใช้ชื่อฟิลด์ในส่วนหัวของคอลัมน์โดยตรงเพื่ออ้างอิงค่าของฟิลด์แต่ละค่าแยกกัน ในการทดสอบต่อไปนี้ ไม่เพียงแต่ได้รับข้อมูลฟิลด์จากการสำรวจคอลเลกชันฟิลด์เท่านั้น แต่ยังได้รับชื่อฟิลด์ในลักษณะเดียวกัน นี่เป็นโซลูชันแบบไดนามิกมากขึ้น (ADO__10.asp)
คัดลอกรหัสรหัสดังต่อไปนี้:
ถ้า objRS.EOF แล้ว
ตอบกลับเขียน(ไม่พบบันทึก)
อื่น
'เขียนส่วนหัว Response.Write(<TABLE BORDER=1><TR>)
สำหรับแต่ละ objFld ใน objRS.Fields
Response.Write(<TH> & objFld.name & </TH>)
ต่อไป
ตอบกลับเขียน(</TR>)
'เขียนข้อมูล
ทำในขณะที่ไม่ objRS.EOF
การตอบสนองเขียน(<TR>)
สำหรับแต่ละ objFld ใน objRS.Fields
? Response.Write(<TD> & objFld.value & </TD>)
ต่อไป
ตอบกลับเขียน(</TR>)
objRS.MoveNext
วนซ้ำ
การตอบกลับเขียน(</TABLE>)
สิ้นสุดถ้า
อย่างที่คุณเห็น ประสิทธิภาพของโค้ดลดลง แต่ก็ยังเร็วกว่า ADO__07.asp
ตัวอย่างการทดสอบถัดไปคือการประนีประนอมของสองวิธีก่อนหน้านี้ เราจะรักษาคุณสมบัติไดนามิกต่อไปในขณะที่ปรับปรุงประสิทธิภาพโดยบันทึกการอ้างอิงฟิลด์ในอาร์เรย์ที่จัดสรรแบบไดนามิก:
คัดลอกรหัสรหัสดังต่อไปนี้:
ถ้า objRS.EOF แล้ว
ตอบกลับเขียน(ไม่พบบันทึก)
อื่น
Dim fldCount
fldCount = objRS.Fields.Count
ติ่ม fld()
ReDim fld(fldCount)
ดิม ไอ
สำหรับ i = 0 ถึง fldCount-1
ตั้งค่า fld(i) = objRS(i)
ต่อไป
'เขียนหัวเรื่อง
Response.Write(<TABLE BORDER=1><TR>) สำหรับ i = 0 ถึง fldCount-1
Response.Write(<TH> & fld(i).name & </TH>)
ต่อไป
ตอบกลับเขียน(</TR>)
'เขียนข้อมูล
ทำในขณะที่ไม่ objRS.EOF
การตอบสนองเขียน(<TR>)
สำหรับ i = 0 ถึง fldCount-1
การตอบกลับเขียน(<TD> & fld(i) & </TD>)
ต่อไป
ตอบกลับเขียน(</TR>)
objRS.MoveNext
วนซ้ำ
สำหรับ i = 0 ถึง fldCount-1
ตั้งค่า fld(i) = ไม่มีเลย
ต่อไป
การตอบกลับเขียน(</TABLE>)
สิ้นสุดถ้า
แม้ว่าจะไม่เอาชนะสิ่งที่ดีที่สุดก่อนหน้านี้ แต่ก็เร็วกว่าสองสามตัวอย่างแรกๆ และมีข้อได้เปรียบในการประมวลผลชุดบันทึกใดๆ แบบไดนามิก
เมื่อเทียบกับรหัสทดสอบก่อนหน้า รหัสทดสอบต่อไปนี้ได้รับการเปลี่ยนแปลงโดยพื้นฐาน โดยจะใช้เมธอด GetRows ของอ็อบเจ็กต์ Recordset เพื่อเติมอาร์เรย์สำหรับการวนซ้ำข้อมูล แทนที่จะเข้าถึง Recordset โดยตรง โปรดทราบว่า Recordset จะถูกตั้งค่าเป็น Nothing ทันทีหลังจากเรียก GetRows ซึ่งหมายความว่าทรัพยากรระบบจะถูกเผยแพร่โดยเร็วที่สุด นอกจากนี้ โปรดทราบว่ามิติแรกของอาร์เรย์แสดงถึงฟิลด์ และมิติที่สองแสดงถึงแถว (ADO__12.asp)
คัดลอกรหัสรหัสดังต่อไปนี้:
ถ้า objRS.EOF แล้ว
ตอบกลับเขียน(ไม่พบบันทึก)
objRS.ปิด
ตั้ง objRS = ไม่มีเลย
อื่น
'เขียนหัวเรื่อง
-
'ตั้งค่าอาร์เรย์
อาร์อาร์สสลัว
arrRS = objRS.GetRows
'ปิดบันทึกก่อนเวลา'
objRS.ปิด
ตั้ง objRS = ไม่มีเลย
'เขียนข้อมูล
DimnumRows
DimnumFlds
แถวสลัว
ติ่มซำ
numFlds = Ubound(arrRS, 1)
numRows = Ubound(arrRS, 2)
สำหรับแถว= 0 ถึง numRows
การตอบสนองเขียน(<TR>)
สำหรับ fld = 0 ถึง numFlds
Response.Write(<TD> & arrRS(fld, แถว) & </TD>)
ต่อไป
ตอบกลับเขียน(</TR>)
ต่อไป
การตอบกลับเขียน(</TABLE>)
สิ้นสุดถ้า
เมื่อใช้เมธอด GetRows ชุดระเบียนทั้งหมดจะถูกแยกออกเป็นอาร์เรย์ แม้ว่าปัญหาทรัพยากรอาจเกิดขึ้นเมื่อชุดระเบียนมีขนาดใหญ่มาก การเข้าถึงข้อมูลในวงวนจะเร็วขึ้นอย่างแน่นอนเนื่องจากการเรียกใช้ฟังก์ชัน เช่น MoveNext และการตรวจสอบ EOF จะถูกยกเลิก
ความเร็วมาพร้อมกับค่าใช้จ่าย ตอนนี้ข้อมูลเมตาของชุดระเบียนสูญหาย เพื่อแก้ไขปัญหานี้ เราสามารถแยกข้อมูลส่วนหัวออกจากวัตถุชุดระเบียนก่อนที่จะเรียก GetRows นอกจากนี้ ชนิดข้อมูลและข้อมูลอื่น ๆ ยังสามารถแยกออกมาล่วงหน้าได้อีกด้วย โปรดทราบว่าข้อได้เปรียบด้านประสิทธิภาพในการทดสอบจะเกิดขึ้นก็ต่อเมื่อชุดบันทึกมีขนาดใหญ่กว่าเท่านั้น
ในการทดสอบครั้งสุดท้ายของชุดนี้ เราใช้วิธีGetStringของชุดระเบียน วิธีการGetStringแยกชุดระเบียนทั้งหมดออกเป็นสตริงขนาดใหญ่ และช่วยให้คุณสามารถระบุตัวคั่น (ADO__13.asp):
คัดลอกรหัสรหัสดังต่อไปนี้:
ถ้า objRS.EOF แล้ว
ตอบกลับเขียน(ไม่พบบันทึก)
objRS.ปิด
ตั้ง objRS = ไม่มีเลย
อื่น
'เขียนหัวเรื่อง
-
'ตั้งค่าอาร์เรย์
Dim strTable
strTable = objRS.GetString (2, , </TD><TD>, </TD></TR><TR><TD>)
'ปิดบันทึกก่อนเวลา'
objRS.ปิด
ตั้ง objRS = ไม่มีเลย
Response.Write (strTable & </TD></TR></TABLE>)
สิ้นสุดถ้า