โดยทั่วไปมีสองวิธีในการอัปเดตแอปพลิเคชัน: วิธีหนึ่งคือแจ้งผู้ใช้ (เช่น การส่งอีเมล) และขอให้ผู้ใช้ดาวน์โหลดโปรแกรมที่อัปเดตจากที่อยู่เว็บไซต์ที่กำหนด อีกวิธีหนึ่งคือโอนความรับผิดชอบในการอัปเดตจากผู้ใช้ไปยัง แอปพลิเคชันไคลเอนต์จะรับผิดชอบในการดาวน์โหลดและติดตั้งการอัปเดตจากเซิร์ฟเวอร์ที่รู้จัก แทนที่จะให้ผู้ใช้รับและติดตั้งการอัปเดตซอฟต์แวร์ สิ่งเดียวที่ผู้ใช้ต้องทำคือตัดสินใจว่าต้องการติดตั้งการอัปเดตใหม่ทันทีหรือ ภายหลัง. แน่นอนว่าฝ่ายหลังเป็นมิตรมากกว่าสมัยก่อน ตอนนี้คุณสามารถเห็นผลิตภัณฑ์จริงที่คล้ายกับแนวทางหลัง เช่น Windows XP และ Microsoft Money คอมโพเนนต์การอัปเดตแอปพลิเคชัน .NET ที่นำมาใช้ในบทความนี้สามารถให้ฟังก์ชันการทำงานที่คล้ายกันได้
1. ความรู้เบื้องต้นเกี่ยวกับส่วนประกอบการอัปเดตแอปพลิเคชัน .
NET AppUpdater ส่วนประกอบการอัปเดตแอปพลิเคชัน .NET ได้รับการพัฒนาโดยใช้ .NET Framework แม้ว่า AppUpdater จะไม่ใช่ผลิตภัณฑ์ของ Microsoft ตราบใดที่คุณเพิ่มส่วนประกอบลงในแถบเครื่องมือ VS.NET คุณสามารถลากและวางส่วนประกอบจากแถบเครื่องมือลงในแอปพลิเคชันของคุณได้เหมือนกับการใช้ส่วนประกอบอื่นๆ หลังจากตั้งค่าคุณสมบัติบางอย่าง (เช่น ตำแหน่ง) และความถี่ในการรับการอัปเดต ฯลฯ) แอปพลิเคชันไคลเอ็นต์ของคุณสามารถมีฟังก์ชันการอัปเดตอัตโนมัติได้
2. หลักการทำงาน
เพื่อให้เข้าใจหลักการทำงานของส่วนประกอบการอัปเดตแอปพลิเคชันไคลเอนต์ .NET อย่างลึกซึ้ง คุณต้องศึกษาอย่างรอบคอบว่าจะต้องทำอะไรเพื่อใช้การอัปเดตแอปพลิเคชันไคลเอนต์ ขั้นตอนแรกคือการตรวจสอบว่ามีการอัพเดตหรือไม่ เมื่อพบการอัพเดต ให้เริ่มขั้นตอนที่สอง - ดาวน์โหลดการอัพเดต เสร็จสิ้น ให้ดำเนินการขั้นตอนสุดท้าย - ดำเนินการอัพเดต
(1) ตรวจสอบการอัปเดต
ในฐานะนักพัฒนา คุณต้องบอกแอปพลิเคชันว่าจะตรวจสอบการอัปเดตจากที่ใด ไม่เช่นนั้น จะไม่เหมือนกับการมองหาเข็มในกองหญ้าใช่หรือไม่? ประการที่สอง กำหนดเวลาที่จะตรวจสอบการอัปเดต เป็นไปไม่ได้ที่ผู้ใช้จะเรียกใช้โปรแกรมไคลเอนต์ทุกครั้งและจะตรวจสอบการอัปเดตในเบื้องหลังอยู่ตลอดเวลา ช่างเป็นการสิ้นเปลืองทรัพยากร! สิ่งสำคัญประการสุดท้ายที่ต้องแก้ไขคือวิธีตรวจสอบการอัปเดต คอมโพเนนต์การอัปเดตแอปพลิเคชัน .NET ใช้ HTTP สำหรับการสื่อสาร ซึ่งอนุญาตให้แอปพลิเคชันไคลเอ็นต์ดำเนินการอัปเดตผ่านไฟร์วอลล์ และที่อยู่ที่จำเป็นสำหรับการตรวจสอบการอัปเดตจะกลายเป็นที่อยู่ URL ของเว็บเซิร์ฟเวอร์ที่รู้จัก และปัญหาแรกก็แก้ไขได้สำเร็จ
ส่วนประกอบการอัปเดตแอปพลิเคชัน .NET จะสร้างเธรดตามการสร้างส่วนประกอบ ซึ่งมีหน้าที่ตรวจสอบการอัปเดต เธรดนี้จะเข้าสู่โหมดสลีปเกือบตลอดเวลา แต่จะกลับมาทำงานตามช่วงเวลาที่กำหนดและดำเนินการตรวจสอบการอัปเดต ความถี่ที่แอปพลิเคชันตรวจสอบการอัปเดตใหม่จะขึ้นอยู่กับแอปพลิเคชัน ค่าทั่วไปสำหรับช่วงเวลาระหว่างการตรวจสอบการอัปเดตโดยทั่วไปจะอยู่ในช่วงตั้งแต่หนึ่งชั่วโมงถึงหลายวัน วิธีการลงคะแนนเสียงขั้นพื้นฐานนี้ไม่เหมาะกับทุกสถานการณ์ ตัวอย่างเช่น Microsoft Money จะตรวจสอบการอัปเดตเมื่อผู้ใช้ร้องขอเท่านั้น ในกรณีนี้ คุณสามารถปิดใช้งานเธรดการโพลอัพเดตได้
การตรวจสอบการอัปเดตจะดำเนินการโดยการเรียกเมธอด CheckForUpdate() ของส่วนประกอบการอัปเดตด้วยคำสั่ง
มีหลายวิธีในการดำเนินการตรวจสอบการอัปเดต:
วิธีที่ 1: การตรวจสอบไฟล์โดยตรง - ใช้ HTTP เพื่อเปรียบเทียบการประทับวันที่/เวลาแก้ไขล่าสุดของเซิร์ฟเวอร์และแอปพลิเคชันไคลเอนต์เพื่อดูว่าสอดคล้องกันหรือไม่ หากมีไฟล์ที่อัปเดตบนเซิร์ฟเวอร์ ลูกค้าจะรู้ว่าสามารถอัปเดตตัวเองได้ เช่นเดียวกับเว็บเบราว์เซอร์ ซึ่งรู้ว่าจำเป็นต้องดาวน์โหลดหน้า html หรือรูปภาพอีกครั้ง หรือสามารถนำสิ่งที่ดาวน์โหลดมาก่อนหน้านี้กลับมาใช้ใหม่ได้หรือไม่ เมื่อแอปพลิเคชันเวอร์ชันใหม่พร้อมใช้งาน ผู้ดูแลระบบเพียงคัดลอกเวอร์ชันที่ใหม่กว่าไปยังเวอร์ชันเก่าบนเว็บเซิร์ฟเวอร์ ปัญหาของแนวทางนี้คือ การอัปเดตไม่อัตโนมัติ ดังนั้นจึงอาจเกิดความล้มเหลวได้ ตัวอย่างเช่น หากผู้ดูแลระบบกำลังอัปเดตเวอร์ชันของแอปพลิเคชันบนเว็บเซิร์ฟเวอร์ และลูกค้ากำลังดาวน์โหลดเวอร์ชันก่อนการอัปเดต คอมพิวเตอร์ของลูกค้าก็จะมีไฟล์บางไฟล์ก่อนการอัปเดต รวมถึงไฟล์บางไฟล์จากเวอร์ชันใหม่ เวอร์ชันหลังจากการอัพเดตเอกสาร ด้วยเหตุผลข้างต้น ไม่แนะนำให้ตรวจสอบไฟล์โดยตรงเพื่ออัพเดตสำหรับแอพพลิเคชั่นที่สำคัญ
วิธีที่ 2: การตรวจสอบที่ชัดเจน - ใช้ไฟล์การกำหนดค่าที่ชัดเจนบนเซิร์ฟเวอร์ ไฟล์ที่ชัดเจนของเซิร์ฟเวอร์ที่ถูกต้องสำหรับใช้กับส่วนประกอบการอัปเดตแอปพลิเคชัน .NET มีลักษณะดังนี้: ..
<VersionConfig>
＜เวอร์ชันที่มีจำหน่าย＞1.0.0.0＜/เวอร์ชันที่มีจำหน่าย＞
＜ApplicationUrl＞ http://localhost/demos/selfupdate/V1/ ＜/
URL แอปพลิเคชัน>
</VersionConfig>
AvailableVersion ระบุหมายเลขเวอร์ชันของแอสเซมบลีที่มีอยู่ล่าสุด แอตทริบิวต์ ApplicationURL ระบุที่อยู่ URL ซึ่งเป็นที่ตั้งของแอปพลิเคชันเวอร์ชันนี้ เมื่อผู้ดูแลระบบต้องการอัปเดตแอปพลิเคชันไคลเอนต์ พวกเขาจะคัดลอกแอปพลิเคชันเวอร์ชันใหม่ไปยังเว็บเซิร์ฟเวอร์และแก้ไขไฟล์ที่ชัดเจนของเซิร์ฟเวอร์อย่างเหมาะสม ตัวไคลเอนต์จะตรวจพบว่ามีการแก้ไขไฟล์ที่ชัดเจนของเซิร์ฟเวอร์ จากนั้นจึงดาวน์โหลดไฟล์ที่ชัดเจน จากนั้นไคลเอ็นต์จะเปรียบเทียบหมายเลขเวอร์ชันแอสเซมบลีที่ระบุในไฟล์ที่ชัดเจนกับหมายเลขเวอร์ชันของไฟล์ EXE ของแอปพลิเคชัน หากมีหมายเลขเวอร์ชันที่ใหม่กว่าในไฟล์ที่ชัดเจนของเซิร์ฟเวอร์ แอปพลิเคชันจะรู้ว่าจำเป็นต้องอัปเดต วิธีนี้เหมาะสำหรับการใช้งานส่วนใหญ่
วิธีที่สาม: การตรวจสอบ XML Web Service-XML WebServices มีวิธีตรวจสอบการอัปเดตขั้นสูงเพิ่มเติม ตัวอย่างเช่น สมมติว่าคุณต้องการอัพเดตชุดผู้ใช้ในยุคแรกก่อนที่จะอัพเดตผู้ใช้รายอื่นของคุณ หากแอปพลิเคชันไคลเอนต์เรียกใช้ XML Web Service เพื่อตรวจสอบว่ามีการอัพเดตหรือไม่ XML Web Service ก็สามารถสืบค้นฐานข้อมูลสำหรับการอัพเดตนั้นได้เช่นกัน และพิจารณาว่าผู้ใช้เป็นผู้ใช้ระยะแรกหรือไม่ หากเป็นผู้ใช้ในช่วงแรก XML Web Service จะส่งกลับค่าที่ระบุว่ามีการอัปเดตให้ใช้งานได้ ถ้าไม่เช่นนั้น Web Service จะส่งคืนค่าที่ระบุว่าไม่มีการอัปเดต อย่างไรก็ตาม คอมโพเนนต์การอัปเดตแอปพลิเคชัน .NET ที่นำมาใช้ในบทความนี้ไม่ได้ให้การสนับสนุน XML Web Service โดยตรง
หากต้องการใช้ XML Web Service เพื่อตรวจสอบการอัปเดต ขั้นแรกให้สร้าง XML Web Service และเชื่อมโยงเหตุการณ์ OnCheckForUpdate สิ่งนี้ทำให้คุณสามารถเขียนเช็คที่คุณกำหนดเองแทนการตรวจสอบการอัพเดตเธรดของโพลเลอร์ เหตุการณ์ OnCheckForUpdate มีค่าส่งคืนที่ระบุว่าตรวจพบการอัปเดตหรือไม่
(2) ดาวน์โหลดการอัปเดต
เมื่อส่วนประกอบการอัปเดตแอปพลิเคชัน .NET ตรวจพบว่ามีการอัปเดตใหม่พร้อมใช้งาน จะเริ่มเธรดอื่นโดยอัตโนมัติ และเริ่มดาวน์โหลดการอัปเดตเบื้องหลังแบบอะซิงโครนัส
การดาวน์โหลดเสร็จสิ้นโดยใช้ HTTP-DAV DAV เป็นเวอร์ชันขยายของ HTTP ซึ่งมีฟังก์ชันการทำงาน เช่น ไดเร็กทอรีและการแจงนับไฟล์ กระบวนการดาวน์โหลดที่สมบูรณ์เริ่มต้นด้วยการระบุ URL URL ที่ใช้ในการดาวน์โหลดจะขึ้นอยู่กับวิธีการที่ใช้ในการตรวจสอบการอัปเดตให้เสร็จสิ้น ตัวอย่างเช่น หากคุณใช้ไฟล์ที่ชัดเจนของเซิร์ฟเวอร์ URL ที่ใช้ในการดาวน์โหลดการอัปเดตจะถูกระบุผ่านแอตทริบิวต์ ApplicationURL ในไฟล์ที่ชัดเจนของเซิร์ฟเวอร์
การดาวน์โหลดอัปเดตต้องใช้ความคงทนอย่างเห็นได้ชัด เป็นที่ยอมรับไม่ได้ที่จะปล่อยให้แอปพลิเคชันไคลเอนต์อยู่ในสถานะที่ไม่เสถียรหลังจากดาวน์โหลดและอัปเดต อาจเกิดปัญหาหลายประการในระหว่างขั้นตอนการดาวน์โหลด: เว็บเซิร์ฟเวอร์ที่มีไฟล์อัพเดตอยู่อาจล่ม เครื่องไคลเอนต์อาจหยุดทำงาน หรือผู้ใช้อาจเพียงแค่ปิดแอปพลิเคชันด้วยเหตุผลบางประการ เนื่องจากกำลังดาวน์โหลดแอปพลิเคชัน หากปิดอยู่ การดาวน์โหลดจะหยุดลง โซลูชันการออกแบบทางเลือกอื่นคือการใช้บริการระบบแยกต่างหากสำหรับการดาวน์โหลดและอัปเดตแอปพลิเคชัน เมื่อใช้บริการของระบบ การดาวน์โหลดอัปเดตจะดำเนินต่อไปแม้ว่าตัวแอปพลิเคชันเองไม่ได้ทำงานอยู่ก็ตาม ในความเป็นจริง Windows XP มีบริการดาวน์โหลดในตัวที่เรียกว่า BITS ซึ่งให้บริการตามวัตถุประสงค์นี้ Windows XP ใช้ BITS เพื่อดาวน์โหลดและอัปเดต Windows เอง สำหรับข้อมูลเพิ่มเติมเกี่ยวกับ BITS โปรดดู http://msdn.microsoft.com/library/en-us/dnwxp/html/WinXP_BITS.asp บริการนี้ไม่ได้ใช้ในคอมโพเนนต์ .NET Application Update ดังนั้นจึงสามารถใช้ได้ใน Windows 9x ซึ่งไม่รองรับบริการของระบบ
(3) การใช้การอัปเดต
องค์ประกอบการอัปเดตแอปพลิเคชัน .NET ได้รับความเข้มแข็งโดยการแบ่งกระบวนการดาวน์โหลดและอัปเดตออกเป็นสองเฟสแยกกัน เมื่อแต่ละขั้นตอนเสร็จสิ้น ขั้นตอนจะถูกบันทึกไว้ในไฟล์ Manifest ที่อัปเดตซึ่งอยู่ในไดเร็กทอรีแอปพลิเคชันไคลเอนต์ หากกระบวนการดาวน์โหลดหรืออัปเดตถูกขัดจังหวะในขั้นตอนใด ๆ กระบวนการดังกล่าวจะดำเนินการต่อจากจุดพักที่เสร็จสมบูรณ์ครั้งล่าสุดในครั้งถัดไปที่แอปพลิเคชันเริ่มทำงาน แต่ละสเตจสามารถรันซ้ำได้ ดังนั้นหากเกิดความล้มเหลวระหว่างสเตจ การรันสเตจใหม่จะสำเร็จ หากเกิดข้อผิดพลาด เช่น การเชื่อมต่อกับเซิร์ฟเวอร์ขาดหายไประหว่างการดาวน์โหลด ส่วนประกอบการอัปเดต .NET จะพยายามอีกครั้งในภายหลัง หากมีการรายงานข้อผิดพลาดมากเกินไป (เช่น เว็บเซิร์ฟเวอร์ไม่กลับมาออนไลน์อีก) การดาวน์โหลดและการอัปเดตจะถูกยกเลิกและรายงานข้อผิดพลาด
แนวทางแรกของเราคือเพียงเริ่มกระบวนการแยกต่างหากเพื่อใช้การอัปเดต กระบวนการที่แยกจากกันนี้จะปิดกระบวนการแอปพลิเคชันก่อน ดำเนินการอัปเดต (เนื่องจากตอนนี้ปลดล็อคแล้ว) เริ่มกระบวนการแอปพลิเคชันใหม่ จากนั้นปิดตัวเองเมื่อเสร็จสิ้น ดังนั้นจึงมีปัญหาพื้นฐานสามประการเกี่ยวกับการออกแบบนี้:
ในบางกรณีอาจไม่ทำงาน เมื่ออัปเดตแอปพลิเคชัน กระบวนการอัปเดตจะปิดกระบวนการแอปพลิเคชันเดิม และกระบวนการอัปเดตเองก็จะปิดเช่นกัน ดังนั้นการอัปเดตจะไม่ถูกนำมาใช้
. เราต้องการให้สามารถอัปเดตโค้ดทั้งหมดที่ต้องอัปเดตได้โดยอัตโนมัติ เราต้องการความสามารถในการติดตั้งแพตช์โดยอัตโนมัติ ไม่เพียงแต่ในแอปพลิเคชันเท่านั้น แต่ยังรวมไปถึงส่วนประกอบ .NET Application Update ด้วย เมื่อใช้โหมดนี้ เราไม่สามารถอัปเดตกระบวนการที่ใช้การอัปเดตได้
เป็นการหยาบคายที่จะบังคับให้ผู้ใช้ปิดแอปพลิเคชันและรอขณะใช้งาน
วิธีสุดท้ายที่ใช้ในการนำการอัปเดตแอปพลิเคชันไปใช้คือการใช้รูปแบบแอสเซมบลีแบบขนานของ .NET Framework อีกทางเลือกหนึ่งในการพยายามอัปเดตแอปพลิเคชัน ให้สร้างแอปพลิเคชันเวอร์ชันที่ใหม่กว่าเวอร์ชันที่มีอยู่ในปัจจุบัน
สามารถสร้างเวอร์ชันใหม่ได้โดยการรวมแค็ตตาล็อกแอปพลิเคชันที่มีอยู่ในปัจจุบันเข้ากับเวอร์ชันอัปเดตที่ดาวน์โหลดไว้ เมื่อเวอร์ชันใหม่เสร็จสมบูรณ์ ผู้ใช้จะใช้เวอร์ชันใหม่โดยอัตโนมัติในครั้งถัดไปที่พวกเขาเปิดแอปอีกครั้ง สำเนาของแอปพลิเคชันต้นฉบับสามารถลบออกได้ สิ่งที่ยุ่งยากคือการพิจารณาว่าควรโหลดเวอร์ชันใดในขณะนั้น เราแนะนำแอปพลิเคชันชื่อ Appstart Appstart เป็นจุดเริ่มต้นเข้าสู่แอปพลิเคชันของคุณ เมื่อใช้โหมดนี้ ไดเรกทอรีแอปพลิเคชันของคุณจะมีลักษณะดังนี้: ..
--> ไฟล์โปรแกรม
--> MyApp
--> Appstart.exe
--> Appstart.config
- -> โฟลเดอร์ V1
-- > MyApp.exe
--> โฟลเดอร์ V1.1
--> MyApp.exe
ในการรันแอปพลิเคชันของคุณ โดยปกติแล้ว คุณจะเริ่ม Appstart.exe หากคุณต้องการมีคีย์ลัดบนเดสก์ท็อป คีย์ลัดนั้นจะต้องชี้ไปที่ Appstart ไม่ใช่ไปที่แอปพลิเคชันโดยตรง (โปรดทราบว่าคุณสามารถเปลี่ยนชื่อ AppStart.exe เป็นอะไรก็ได้ที่คุณต้องการ เช่น YourApp.exe) Appstart.exe มันคือ โปรแกรมง่ายๆ ที่อ่านไฟล์ Appstart.config และโหลดแอปพลิเคชันที่ระบุ ไฟล์ Appstart.config ที่ถูกต้องมีลักษณะดังนี้:
<Config>
＜AppFolderName>โฟลเดอร์ V1＜/AppFolderName>
＜AppExeName>MyApp.exe＜/AppExeName>
＜AppLaunchMode><โดเมนแอป<//AppLaunchMode>
＜/กำหนดค่า><
AppFolderName ระบุโฟลเดอร์ย่อยที่มีเวอร์ชันของแอปพลิเคชันที่กำลังทำงานอยู่ AppExeName มีชื่อของไฟล์ exe ที่จะโหลดในโฟลเดอร์นั้น เมื่อการอัปเดตแอปพลิเคชันเสร็จสมบูรณ์ ขั้นตอนสุดท้ายคือการแก้ไขค่าของ AppFolderName ให้ชี้ไปที่เวอร์ชันใหม่ของแอปพลิเคชัน ด้วยวิธีนี้ ในครั้งถัดไปที่ผู้ใช้เรียกใช้แอปพลิเคชัน แอปพลิเคชันเวอร์ชันอัปเดตใหม่จะทำงาน AppLaunchMode ระบุวิธีการโหลดแอปพลิเคชัน มีสองวิธีในการโหลดแอปพลิเคชัน: วิธีแรกคือการใช้ AppDomains AppDomains เป็นคุณลักษณะของรันไทม์ภาษาทั่วไปของ .NET Framework และยังเป็นหน่วยลอจิคัลอิสระและออบเจ็กต์การจัดการอีกด้วย รันไทม์ภาษาทั่วไปอนุญาตให้มีหลายโดเมนแอปพลิเคชันต่อกระบวนการ วิธีนี้ทำให้ Appstart.exe สามารถโหลดแอปพลิเคชันของคุณใน AppDomain แยกต่างหาก แต่อยู่ในกระบวนการ AppStart.exe เดียวกัน แม้ว่าจะมีโปรแกรม exe สองโปรแกรมที่ทำงานอยู่ (เช่น Appstart.exe และ MyApp.exe) แต่มีการใช้กระบวนการเดียวเท่านั้น AppDomains จะทำงานได้ดีกับแอปพลิเคชันส่วนใหญ่ แม้ว่าจะมีความแตกต่างเล็กน้อยระหว่างการทำงานใน AppDomain ที่แยกจากกันและการทำงานในกระบวนการที่แยกกันก็ตาม ในกรณีนี้ AppLaunchMode สามารถตั้งค่าเป็น "กระบวนการ" ซึ่งจะทำให้แอปพลิเคชันโหลดในกระบวนการแยกต่างหาก
เมื่อ Appstart เปิดแอปพลิเคชันขึ้นมา แอปจะเข้าสู่โหมดสลีปเพื่อรอให้แอปพลิเคชันยุติการทำงาน เมื่อแอปพลิเคชันสิ้นสุดลง Appstart ก็จะถูกปิดเช่นกัน
3. การแนะนำตัวอย่าง
ก่อนหน้านี้เราได้พูดคุยถึงวิธีการทำงานของการอัปเดตแอปพลิเคชัน .NET แล้ว ตอนนี้เรามาดูตัวอย่างกันดีกว่า
ขั้นตอนที่ 1: สร้างแอปพลิเคชันที่จะอัปเดต
1. ใช้ VS.NET เพื่อสร้างโครงการแอปพลิเคชัน Windows ใหม่ชื่อ "SampleApp"
2. กำหนดสีพื้นหลังที่น่าสนใจให้กับแบบฟอร์มที่คุณเลือก เราจะใช้สีพื้นหลังเพื่อแยกความแตกต่างจากเวอร์ชันที่อัปเดตในภายหลัง
3. ตอนนี้เรามาเพิ่มคุณลักษณะที่ละเอียดอ่อนให้กับแอปพลิเคชันนี้ ขั้นแรก ให้เพิ่มปุ่มลงในแบบฟอร์มของคุณ ไฟล์บีบอัดประกอบด้วยชุดประกอบที่มี Windows Form อย่างง่าย เพิ่มการอ้างอิงไปยังแอสเซมบลี SamplesSampleAppSimpleForm ในไฟล์บีบอัด จากนั้นเพิ่มโค้ดสองบรรทัดลงในตัวจัดการเหตุการณ์ปุ่มของคุณ:
-
SimpleForm.Form1 F = SimpleForm.Form1();
F.แสดง();
4. แปลงแฟล็ก build ของคุณจาก debug เป็น RELEASE ซึ่งจะช่วยให้เราหลีกเลี่ยงปัญหาการล็อกไฟล์ pdb ในภายหลังเมื่อเราสร้างแอปพลิเคชันเวอร์ชันใหม่ในขณะที่สำเนาต้นฉบับกำลังทำงานอยู่ สร้างและทดสอบแอปพลิเคชันของคุณ
ขั้นตอนที่ 2: เพิ่มส่วนประกอบการอัปเดตแอปพลิเคชัน .NET
1. บนแท็บส่วนประกอบของแถบเครื่องมือ VS.NET คลิกขวาและเลือก "กำหนดแถบเครื่องมือเอง" เลือกแท็บ ".NET Framework Components" คลิก "เรียกดู" และเลือก AppUpdater.dll ที่อยู่ใต้โครงการ AppUpdater ในไฟล์บีบอัด คลิกตกลง
2. ตอนนี้ไอคอน AppUpdater ควรปรากฏที่ด้านล่างของรายการส่วนประกอบของแถบเครื่องมือ ลากและวางส่วนประกอบ AppUpdater ลงในแบบฟอร์ม SampleApp อินสแตนซ์ของคอมโพเนนต์การอัปเดตแอปพลิเคชัน .NET ชื่อ appUpdater1 ปรากฏที่ด้านล่างของแบบฟอร์ม
ขั้นตอนที่ 3: ตั้งค่าส่วนประกอบการอัปเดตแอปพลิเคชัน .NET
ในขั้นตอนนี้ เราจะตั้งค่าส่วนประกอบการอัปเดตแอปพลิเคชัน .NET โปรดทราบว่าในตัวอย่างนี้ คุณจะต้องเปลี่ยนคุณสมบัติสี่รายการแรกเท่านั้น โดยปล่อยให้ส่วนที่เหลือเป็นค่าเริ่มต้น
คุณลักษณะ AppUpdater: นี่คือแกนหลักของการอัปเดตแอปพลิเคชัน .NET การตั้งค่าต่อไปนี้จำเป็นต้องทำสำหรับโปรแกรมนี้:
(1) AutoFileLoad: ซึ่งจะควบคุมลักษณะการดาวน์โหลดคำสั่งที่จะอธิบายในภายหลัง
(2) ChangeDetectionMode: การแจงนับนี้กำหนดวิธีการตรวจสอบการอัปเดต ในตัวอย่างนี้ เราจะใช้การตรวจสอบเซิร์ฟเวอร์อย่างชัดเจน ดังนั้น ให้ตั้งค่านี้เป็น "ServerManifestCheck"
(3) ShowDefaultUI: องค์ประกอบการอัปเดตแอปพลิเคชัน .NET มีชุดอินเทอร์เฟซผู้ใช้เพื่อแจ้งเตือนผู้ใช้เกี่ยวกับเหตุการณ์บางอย่าง เช่น มีการอัปเดตใหม่ให้ใช้งานได้ หรือมีข้อผิดพลาดเกิดขึ้นระหว่างการอัปเดต UI นี้สามารถปิดใช้งานได้โดยการตั้งค่า UI เริ่มต้นให้ไม่ถูกต้องและแทนที่ด้วย UI เฉพาะแอปพลิเคชันที่กำหนดเอง เพื่อเชื่อมโยงเข้ากับเหตุการณ์ที่เหมาะสม (เช่น
OnUpdateComplete) และป๊อปอัปอินเทอร์เฟซผู้ใช้แบบกำหนดเอง สำหรับตัวอย่างนี้ เราจะใช้อินเทอร์เฟซผู้ใช้เริ่มต้น ดังนั้นให้ตั้งค่านี้เป็นจริง
(4) UpdateUrl: UpdateUrl กำหนดตำแหน่งที่โปรแกรมอัพเดตจะค้นหาการอัพเดต ในตัวอย่างนี้ เราใช้ไฟล์ที่ชัดเจนของเซิร์ฟเวอร์เพื่อตรวจสอบการอัปเดต ดังนั้นคุณสมบัตินี้จึงควรตั้งค่าเป็น URL ของไฟล์ที่ชัดเจนของเซิร์ฟเวอร์
ในตัวอย่างนี้ ให้ตั้งค่าเป็น: http://yourWebserver/SampleApp_ServerSetup/UpdateVersion.xml โปรดแทนที่ "yourWebserver" ด้วยชื่อเว็บเซิร์ฟเวอร์ของคุณ
คุณสมบัติตัวดาวน์โหลด: ส่วนประกอบ AppUpdater มีสององค์ประกอบย่อย ส่วนประกอบแรกเรียกว่า Downloader ซึ่งควบคุมการดาวน์โหลดและคุณสมบัติ Poller ของส่วนประกอบ ส่วนประกอบย่อยที่สองของ AppUpdater คือ Poller ซึ่งควบคุมการตรวจสอบการอัปเดต
(1)เริ่มต้นอัตโนมัติ: ค่าบูลีนที่ควบคุมว่า Poller ควรเริ่มการสำรวจเมื่อแอปพลิเคชันเริ่มทำงาน หรือควรรอจนกว่าแบบสอบถามการอัปเดตที่วางแผนไว้จะเริ่มขึ้น
(2) DownloadOnDetection: ค่าบูลีน ควบคุมว่า Poller จะเริ่มดาวน์โหลดการอัพเดตทันทีเมื่อมีการค้นพบการอัพเดตใหม่ หรือไม่ หรือจะเริ่มการดาวน์โหลดอย่างชัดเจนโดยการเรียกใช้เมธอด DownloadUdpate()
(3)InitialPollInterval: จำนวนวินาทีที่ต้องรอก่อนดำเนินการตรวจสอบการอัปเดตครั้งแรกหลังจากแอปพลิเคชันเริ่มทำงาน
(4)PollInterval: หลังจากการตรวจสอบการอัปเดตครั้งแรก PollInterval จะควบคุมจำนวนวินาทีระหว่างการตรวจสอบการอัปเดตครั้งต่อไป .
หลังจากทั้งหมดนี้เสร็จสิ้น ตารางคุณสมบัติของคุณควรมีลักษณะดังนี้:
ไดเร็กทอรี SamplesSampleAppSampleApp_Complete มีเวอร์ชันของแอปพลิเคชันที่ติดตั้งอย่างถูกต้อง
การติดตั้ง:
(1)DownloadRetryAttempts: หากเกิดข้อผิดพลาดระหว่างการดาวน์โหลด (เช่น เว็บเซิร์ฟเวอร์ล่ม) ผู้ดาวน์โหลดจะลองอีกครั้งในภายหลัง คุณสมบัตินี้ควบคุมจำนวนครั้งที่ผู้ดาวน์โหลดลองส่งคำขอเครือข่ายอีกครั้งก่อนที่จะถือว่าเป็นข้อผิดพลาดในการอัปเดตแอปพลิเคชันโดยสมบูรณ์
(2)SecondsBeteweenDownloadRety: จำนวนวินาทีที่รอก่อนที่จะลองร้องขอเครือข่ายอีกครั้ง
(3)UpdateRetryAttempts: หากเกิดข้อผิดพลาดร้ายแรงในระหว่างการอัปเดต (เช่น ตัวดาวน์โหลดเกินจำนวนครั้งในการลองใหม่) ข้อผิดพลาดในการอัปเดตแอปพลิเคชันจะถูกสร้างขึ้น ตามค่าเริ่มต้น ความพยายามในการอัปเดตจะหยุดลง แต่จะพยายามกู้คืนในครั้งต่อไปที่แอปพลิเคชันเริ่มทำงาน (เช่น การอัปเดตเว็บเซิร์ฟเวอร์อาจล่มเป็นเวลาหลายวัน) คุณสมบัตินี้ควบคุมจำนวนครั้งที่พยายามอัพเดต หากเกินค่านี้ ตัวอัพเดตจะยกเลิกการอัพเดต รีเซ็ตสถานะ และกลับสู่การตรวจสอบการอัพเดต
(4)ValidateAssemblies: คุณลักษณะนี้ควบคุมระดับที่แอสเซมบลีที่ดาวน์โหลดมาเสร็จสมบูรณ์อย่างมีประสิทธิภาพ ดูส่วนความปลอดภัยของบทความนี้สำหรับข้อมูลเพิ่มเติม
ขั้นตอนที่ 4: สร้างและปรับใช้แอปพลิเคชันเวอร์ชัน V1 บนไคลเอนต์
ในโครงการ SampleApp ให้เปิดไฟล์ AssemblyInfo.cs แก้ไขค่าของ AssemblyVersion จาก "1.0" เป็น "1.0.0.0" สาเหตุนี้เกิดขึ้นเมื่อสร้างแอสเซมบลีเพื่อรับแท็กที่มีค่า "1.0.0.0".. แทนที่จะเป็นค่าที่ VS.NET ปกติระบุเป็นค่าเพิ่ม
1. สร้างแอปพลิเคชัน
2. คัดลอกไดเร็กทอรี SamplesSampleAppSampleApp_ClientSetup จากไฟล์บีบอัดไปยังเครื่องภายในของคุณ โปรดทราบว่าไดเร็กทอรีนี้มี AppStart.exe อยู่แล้ว AppStart.config ได้รับการตั้งค่าให้ชี้ไปที่ไดเร็กทอรี 1.0.0.0 และเริ่ม SampleApp.exe
คัดลอก SampleApp (Appupdater.dll, SimpleForm.dll และ SampleApp.exe) จากไดเร็กทอรี release ของ SampleApp
ไปยังไดเร็กทอรี SampleApp_ClientSetup1.0.0.0 ของไคลเอ็นต์ ณ จุดนี้ แอปพลิเคชันเวอร์ชันที่ทำงานได้อย่างสมบูรณ์ได้ถูก "ติดตั้ง" บนไคลเอนต์แล้ว และสามารถดำเนินการได้โดยการเรียกใช้ AppStart.exe
ขั้นตอนที่ 5: ติดตั้งเว็บเซิร์ฟเวอร์
ในขั้นตอนนี้ เราจะติดตั้งเว็บเซิร์ฟเวอร์เพื่อให้ฟังก์ชันการโพลอัพเดต คอมโพเนนต์การอัปเดตแอปพลิเคชัน .NET ใช้ HTTP-DAV เพื่อดาวน์โหลดการอัปเดตแอปพลิเคชัน ดังนั้นจึงต้องมีเว็บเซิร์ฟเวอร์ที่รองรับ HTTP-DAV IIS5.0 บน Windows 2000 และระบบปฏิบัติการใหม่กว่ารองรับ HTTP-DAV
1. คัดลอกไดเร็กทอรี Samples/SampleApp_ServerSetup ไปยังไดเร็กทอรี wwwroot บนเว็บเซิร์ฟเวอร์ของคุณ
2. คัดลอก SampleApp เวอร์ชัน V1 ไปยังโฟลเดอร์ 1.0.0.0 ของเว็บเซิร์ฟเวอร์
3. เปิดใช้งานสิทธิ์ "เรียกดูไดเรกทอรี" ของ IIS สำหรับไดเรกทอรี SampleApp_ServerSetup บนเว็บเซิร์ฟเวอร์
ขั้นตอนที่หก: อัปเดตแอปพลิเคชันโดยอัตโนมัติ
ตกลง... ตอนนี้ถึงเวลาที่จะเห็นผลลัพธ์ของการทำงานหนักทั้งหมดนี้ด้วยการติดตั้งเวอร์ชันใหม่โดยอัตโนมัติ
1. หากเวอร์ชันของ SampleApp ที่คุณปรับใช้บนไคลเอนต์ไม่ทำงาน ให้โหลดและปล่อยให้มันรัน อย่าลืมใช้ AppStart.exe
2. กลับไปที่ VS.NET และทำการเปลี่ยนแปลงที่เห็นได้ชัดเจนในแบบฟอร์ม SampleApp (เช่น การเปลี่ยนสีพื้นหลัง)
3. เปลี่ยนข้อมูลเวอร์ชันของ AssemblyInfo.cs เป็น 2.0.0.0
4. สร้างใหม่
5. กลับสู่เว็บเซิร์ฟเวอร์และสร้างไดเร็กทอรี 2.0.0.0 ที่เทียบเท่ากับไดเร็กทอรี 1.0.0.0 คัดลอกเวอร์ชันใหม่ของแอปพลิเคชันจากไดเร็กทอรีรุ่น release ไปยังไดเร็กทอรี 2.0.0.0 ที่สร้างขึ้นใหม่บนเว็บเซิร์ฟเวอร์
6. เปิด UpdateVersion.xml และแก้ไข AvailableVersion เป็น 2.0.0.0 แก้ไข ApplicationURL ให้ชี้ไปที่เส้นทาง 2.0.0.0 ใหม่
7. บันทึกการเปลี่ยนแปลงที่ทำกับ UpdateVersion.xml
เมื่อคุณบันทึก UpdateVersion.xml ใหม่ ภายใน 30 วินาที การรันสำเนาของ SampleApp จะตรวจพบเวอร์ชันใหม่ที่พร้อมใช้งาน
4. การติดตั้งตามความต้องการ ความปลอดภัย ความสามารถในการปรับขนาด และการดีบัก
(1) การติดตั้งตามความต้องการ
สิ่งที่เรียกว่าการติดตั้งตามความต้องการหมายความว่าเฉพาะโปรแกรมปฏิบัติการหลักเท่านั้นที่ได้รับการติดตั้งอย่างชัดเจนบนคอมพิวเตอร์ไคลเอนต์ แอปพลิเคชันที่เหลือสามารถดาวน์โหลดและติดตั้งได้โดยอัตโนมัติตามความต้องการขั้นพื้นฐาน
เริ่มต้นการติดตั้งตามความต้องการผ่านคุณสมบัติ AutoFileLoad ของคอมโพเนนต์การอัปเดตแอปพลิเคชัน .NET คุณต้องพิจารณาอย่างรอบคอบว่าขอบเขตของแอสเซมบลีอยู่ที่ใดภายในแอปพลิเคชันของคุณ และการดำเนินการใดที่จะทำให้แอสเซมบลีถูกดาวน์โหลด เนื่องจากการดาวน์โหลดแอสเซมบลีเกี่ยวข้องกับอินพุตและเอาต์พุตของเครือข่าย เวลาที่ใช้ในการดาวน์โหลดจึงแปรผัน ในระหว่างการดาวน์โหลดแอสเซมบลี แอปพลิเคชันจะหยุดนิ่งเพื่อรอให้การดาวน์โหลดแอสเซมบลีเสร็จสิ้น
(2) การปรับใช้
ความสามารถในการติดตั้งการอัปเดตแอปพลิเคชันโดยอัตโนมัติอย่างปลอดภัยมีประโยชน์มากมาย แต่ก็มีอันตรายที่อาจเกิดขึ้นเช่นกัน เมื่อคุณทำให้การติดตั้งการอัปเดตเป็นเรื่องง่าย คุณยังสามารถติดตั้งโค้ดที่เป็นอันตรายได้ง่ายหากคุณไม่ระวัง มีอันตรายอยู่สองประการ อันตรายประการแรกคือบางคนจะใช้เว็บเซิร์ฟเวอร์ของตนเองเพื่อหลอกเว็บเซิร์ฟเวอร์ที่ใช้ในการปรับใช้การอัปเดต พวกเขาอาจใช้เว็บเซิร์ฟเวอร์นั้นเพื่อติดตั้งไวรัสในเส้นทางแอปพลิเคชันของคุณ วิธีที่ง่ายที่สุดในการป้องกันการปลอมแปลงหรือการรบกวนที่ไม่เหมาะสมบนเครือข่ายคือการใช้ HTTPS หากต้องการใช้ HTTPS กับคอมโพเนนต์ .NET Application Update เพียงแทนที่ HTTP URL ด้วย HTTPS URL แน่นอนว่า HTTPS ไม่ใช่เป้าหมายหลัก มีปัญหาสองประการในการใช้ HTTPS ปัญหาแรกคือความสามารถในการขยายขนาด การใช้ HTTPS ต้องการให้เซิร์ฟเวอร์เข้ารหัสไฟล์ทั้งหมดที่ดาวน์โหลดจากเว็บเซิร์ฟเวอร์ หากไฟล์อัพเดตของแอปพลิเคชันมีขนาดใหญ่ ค่าใช้จ่ายในการเข้ารหัสไฟล์อัพเดตอาจทำให้เซิร์ฟเวอร์มีภาระมากเกินไป ปัญหาอีกประการหนึ่งของการใช้ HTTPS ก็คือ มันไม่มีประโยชน์ใดๆ เลยต่ออันตรายด้านความปลอดภัยประการที่ 2 อันตรายประการที่สองคือแฮกเกอร์สามารถโจมตีเซิร์ฟเวอร์ของคุณจากภายในและจากภายนอกได้ หากการโจมตีสำเร็จ อาจหมายความว่าไคลเอนต์นับร้อยหรือหลายพันรายได้รับผลกระทบจากการอัปเดตอัตโนมัติด้วย ซึ่งอาจเป็นหายนะ
เมื่อต้องการแก้ไขปัญหานี้ คอมโพเนนต์การอัปเดตแอปพลิเคชัน .NET จะใช้คุณลักษณะชื่อที่รัดกุมสำหรับแอสเซมบลี .NET เพื่อตรวจสอบแอสเซมบลีที่ดาวน์โหลด หากคอมโพเนนต์การอัปเดตแอปพลิเคชัน .NET ตรวจพบว่าแอสเซมบลีไม่ได้ลงนามด้วยคีย์ของคุณในระหว่างการดาวน์โหลด การดาวน์โหลดจะถูกยกเลิก ซึ่งหมายความว่ามีเพียงผู้ที่มีคีย์ส่วนตัวของแอปพลิเคชันของคุณเท่านั้นที่สามารถสร้างการอัปเดตที่สามารถใช้งานได้โดยอัตโนมัติ
เพื่อตรวจสอบว่าแอสเซมบลีนั้นถูกต้อง คอมโพเนนต์การอัปเดตแอปพลิเคชัน .NET จะตรวจสอบว่าคีย์สาธารณะของแอปพลิเคชันที่ติดตั้งอยู่ในปัจจุบันนั้นสามารถเรียกใช้งานได้และคีย์สาธารณะของการอัปเดตที่ดาวน์โหลดตรงกัน หากมีการลงนามสองแอสเซมบลีด้วยคีย์ส่วนตัวลับเดียวกัน ดังนั้นคีย์สาธารณะที่ฝังไว้จะเหมือนกัน เนื่องจากแอสเซมบลีที่ถูกโหลดโดย CLR จะตรวจสอบคีย์สาธารณะ CLR จึงคำนวณการตรวจสอบแฮชปกติเพื่อให้แน่ใจว่าแอสเซมบลีนั้นเป็นแอสเซมบลีของแท้ไม่ใช่แอสเซมบลีที่ถูกดัดแปลง หากต้องการเปิดใช้งานการตรวจสอบ ณ เวลาดาวน์โหลด ให้เพิ่มชื่อที่คาดเดายากให้กับแอสเซมบลีแอปพลิเคชันทั้งหมดของคุณ และตั้งค่าคุณสมบัติ ValidateAssemblies ของคอมโพเนนต์ .NET Application Update ให้เป็นจริง
การตรวจสอบแอสเซมบลีในเวลาดาวน์โหลดช่วยได้มาก แต่ในทางปฏิบัติ แอปพลิเคชันมักจะมีส่วนประกอบที่ลงนามด้วยคีย์ส่วนตัวที่แตกต่างกัน ตัวอย่างเช่น แอปพลิเคชันของคุณอาจมีสองไฟล์: แอสเซมบลีที่ปฏิบัติการได้ซึ่งลงนามด้วยคีย์ส่วนตัวของคุณ และแอสเซมบลี dll อื่นที่มีการควบคุมแผนภูมิของบริษัทอื่นที่คุณซื้อและใช้ในแอปพลิเคชันของคุณ แอสเซมบลีของบุคคลที่สามอาจลงนามโดยใช้คีย์ส่วนตัวของบุคคลที่สามแทนของคุณเอง เพื่อให้สถานการณ์ซับซ้อนยิ่งขึ้น การตั้งค่าคีย์ส่วนตัวที่ถูกต้องซึ่งใช้ในการลงนามแอสเซมบลีในแอปพลิเคชันของคุณอาจเปลี่ยนจากหมายเลขเวอร์ชันเป็นหมายเลขเวอร์ชัน คุณจะอัพเดตประเภทแอปพลิเคชันเหล่านั้นโดยอัตโนมัติได้อย่างไร? เพื่อแก้ไขปัญหานี้ คุณสามารถสร้างแอสเซมบลีในแอปพลิเคชันของคุณที่มีรายการคีย์สาธารณะที่ถูกต้องได้ ลงนามแอสเซมบลีด้วยคีย์ส่วนตัวหลักของแอปพลิเคชัน (คีย์ที่ใช้ในการลงนามไฟล์ exe ของแอปพลิเคชัน) และวางแอสเซมบลีในไดเร็กทอรีบนเว็บเซิร์ฟเวอร์ด้วยไฟล์อัปเดตแอปพลิเคชัน ก่อนที่กระบวนการดาวน์โหลดการอัปเดตจะเริ่มต้นขึ้น คอมโพเนนต์การอัปเดตแอปพลิเคชัน .NET จะตรวจสอบแอสเซมบลีที่ชื่อ "AppUpdaterKeys.dll" ในไดเรกทอรีการอัปเดตแอปพลิเคชันบนเว็บเซิร์ฟเวอร์ หากมีอยู่ แอสเซมบลีจะถูกดาวน์โหลด แอสเซมบลีได้รับการตรวจสอบกับคีย์สาธารณะของแอปพลิเคชันหลัก หากลายเซ็นถูกต้อง รายการคีย์จะถูกแยกออกมา จากนี้ไป คีย์ใดๆ ในรายการนี้ถือเป็นลายเซ็นที่ถูกต้องสำหรับไฟล์ที่อัปเดต
แนวทางรักษาความปลอดภัยที่แนะนำคือการใช้ HTTPS URL สำหรับการตรวจสอบการอัปเดต นี่เป็นการป้องกันการปลอมแปลงในระดับแรก สำหรับการดาวน์โหลดอัปเดต ทางที่ดีที่สุดคืออย่าใช้ HTTPS RL เพื่อหลีกเลี่ยงไม่ให้เว็บเซิร์ฟเวอร์ของคุณทำงานหนักเกินไป ให้เพิ่มชื่อที่รัดกุมให้กับแอสเซมบลีของแอปพลิเคชันของคุณแทน และใช้คุณสมบัติการตรวจสอบแอสเซมบลี
(3) ความสามารถในการปรับขนาด
ในตัวอย่างที่กล่าวถึงก่อนหน้าของบทความนี้ เราเพียงแค่ลากและวางส่วนประกอบลงในแอปพลิเคชันและตั้งค่าคุณสมบัติบางอย่างเพื่อให้เกิดการปรับใช้อัตโนมัติ
แม้ว่าวิธีนี้จะทำงานได้ดีในหลายแอปพลิเคชัน แต่บางแอปพลิเคชันจำเป็นต้องมีการควบคุมในระดับสูงซึ่งสามารถทำได้โดยการเขียนโค้ดเท่านั้น เราสามารถเขียนโค้ดของเราเองเพื่อแทนที่กระบวนการมาตรฐานของคอมโพเนนต์การอัปเดตแอปพลิเคชัน .NET โดยใช้เมธอด CheckForUpdate() และ ApplyUpdate() ที่ถูกแทนที่ เพื่อปรับแต่งพฤติกรรมการตรวจสอบและอัปเดต
(4) การดีบัก
ส่วนนี้จะชี้ให้เห็นตัวเลือกการดีบักที่ต้องการ รวมทั้งอธิบายปัญหาที่พบบ่อยที่สุดที่ผู้ใช้ส่วนประกอบนี้เผชิญ
.NET Application Updater สร้างไฟล์บันทึกที่ซ่อนอยู่ชื่อ AppUpdate.log ในไดเรกทอรีเดียวกันกับ AppStart.exe
ข้อมูลความสำเร็จและความล้มเหลวในการอัปเดตทั้งหมดจะถูกบันทึกไว้ในบันทึกนี้ ไฟล์บันทึกมีประโยชน์อย่างยิ่งเมื่อไคลเอ็นต์เฉพาะไม่สามารถอัปเดตได้สำเร็จ
คุณสามารถใช้บันทึกเพื่อกำหนดเวลาและวิธีที่การอัปเดตล้มเหลว นอกจากนี้ ส่วนประกอบ .NET Application Update ยังใช้คลาส Debug ของ .NET Framework เพื่อแสดงผลข้อมูลที่เป็นประโยชน์มากมาย หากคุณเรียกใช้แอปพลิเคชันของคุณในดีบักเกอร์ คุณจะเห็นข้อมูลนี้ในหน้าต่างเอาท์พุต คุณสามารถติดตามบันทึกของ .NET Application Updater เพื่อเน้นและค้นหาส่วนที่เป็นปัญหาได้
หากคุณไม่สามารถใช้งาน .NET Application Updater ได้ด้วยเหตุผลบางประการ โปรดตรวจสอบสิ่งต่อไปนี้ก่อนที่จะดำเนินการแก้ไขจุดบกพร่อง ปัญหาที่คุณพบมักเกิดจากปัญหาใดปัญหาหนึ่งต่อไปนี้: ..
คุณได้เรียกดู IIS หรือไม่ ไดเร็กทอรี? เปิดแล้ว? ถ้าไม่เช่นนั้น ตัวอัปเดตจะไม่ดาวน์โหลดและติดตั้งไฟล์ใดๆ
คุณปรับใช้ทุกอย่างถูกต้องและตั้งค่า URL อย่างถูกต้องหรือไม่?
หากแอปพลิเคชันของคุณได้รับการติดตั้งในไดเร็กทอรีไฟล์โปรแกรม คุณแน่ใจหรือไม่ว่าคุณเป็นผู้ดูแลระบบขั้นสูงหรือผู้ใช้ขั้นสูงของเครื่อง ถ้าไม่เช่นนั้น คุณจะไม่มีสิทธิ์เขียนเพื่ออัปเดตแอปพลิเคชัน
คุณกำลังสร้างวัตถุ AppUpdater ในเธรด UI หลักของแอปพลิเคชันหรือไม่ ถ้าไม่เช่นนั้น ตัวอัพเดตจะไม่สามารถแสดง UI ได้ และจะล้มเหลวเมื่อเริ่มเหตุการณ์กลับไปยัง UI
การอัปเดตสำเร็จแต่แอปพลิเคชันไม่สามารถรีสตาร์ทโดยอัตโนมัติพร้อมกับการอัปเดตใหม่ได้หรือไม่ คอมโพเนนต์การอัปเดตแอปพลิเคชัน .NET พยายามออกจากแอปพลิเคชันโดยการเรียกเมธอด Application.Exit อย่างไรก็ตาม วิธีการนี้ไม่รับประกันว่าจะปิดแอปพลิเคชันได้ หากคุณวางไข่และปล่อยให้เธรดแยกต่างหากทำงานอยู่ วิธีการนี้จะไม่สามารถปิดกระบวนการได้ วิธีแก้ปัญหาเพื่อรับประกันว่าเธรดทั้งหมดจะสิ้นสุดลงโดยการเรียกเหตุการณ์ Application.OnExit หรือเชื่อมต่อกับเหตุการณ์ OnUpdateComplete ของตัวอัปเดตแอปพลิเคชัน .NET และจัดการการปิดระบบด้วยตนเอง
5. สรุป
การใช้งานแอปพลิเคชันไคลเอนต์ที่สะดวกเป็นเป้าหมายสำคัญของเฟรมเวิร์ก .NET เวอร์ชันแรก การใช้เฟรมเวิร์ก .NET เป็นเทคนิคที่ยอดเยี่ยมสำหรับการสร้างแอปพลิเคชันไคลเอนต์ที่ช่วยแก้ปัญหาการปรับใช้ ความง่ายในการปรับใช้ยังคงเป็นเป้าหมายสำคัญสำหรับ .NET Framework เวอร์ชันใหม่ในอนาคต เพื่อเป็นแนวทางแก้ไข ส่วนประกอบการอัปเดตแอปพลิเคชัน .NET ที่อธิบายไว้ที่นี่แสดงถึงแนวคิดบางส่วนของเราที่เราจะสามารถนำไปใช้โดยตรงใน .NET Framework เวอร์ชันต่อๆ ไป อย่างไรก็ตาม ในช่วงก่อนหน้านั้นจะมาถึง องค์ประกอบการอัปเดตแอปพลิเคชัน .NET ถือได้ว่าเป็นวิธีสำคัญในการเริ่มสร้างแอปพลิเคชันการอัปเดตอัตโนมัติ
จาก: csdn ฉันเห็นมันใน Tianji ฉันยังไม่ได้ศึกษาอย่างละเอียดเลย จะทิ้งไว้ดูทีหลัง